content
stringlengths 5
1.05M
|
|---|
#!/usr/bin/env python
# -*- coding: utf-8 -*- #
#
# Copyright 2013 Google LLC. 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.
"""gcloud command line tool."""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
import time
START_TIME = time.time()
# pylint:disable=g-bad-import-order
# pylint:disable=g-import-not-at-top, We want to get the start time first.
import errno
import os
import sys
from googlecloudsdk.api_lib.iamcredentials import util as iamcred_util
from googlecloudsdk.calliope import base
from googlecloudsdk.calliope import cli
from googlecloudsdk.command_lib import crash_handling
from googlecloudsdk.command_lib.util.apis import yaml_command_translator
from googlecloudsdk.core import config
from googlecloudsdk.core import log
from googlecloudsdk.core import metrics
from googlecloudsdk.core import properties
from googlecloudsdk.core.credentials import store as creds_store
from googlecloudsdk.core.credentials import devshell as c_devshell
from googlecloudsdk.core.survey import survey_check
from googlecloudsdk.core.updater import local_state
from googlecloudsdk.core.updater import update_manager
from googlecloudsdk.core.util import keyboard_interrupt
from googlecloudsdk.core.util import platforms
import surface
# Disable stack traces when the command is interrupted.
keyboard_interrupt.InstallHandler()
if not config.Paths().sdk_root:
# Don't do update checks if there is no install root.
properties.VALUES.component_manager.disable_update_check.Set(True)
def UpdateCheck(command_path, **unused_kwargs):
try:
update_manager.UpdateManager.PerformUpdateCheck(command_path=command_path)
# pylint:disable=broad-except, We never want this to escape, ever. Only
# messages printed should reach the user.
except Exception:
log.debug('Failed to perform update check.', exc_info=True)
def _ShouldCheckSurveyPrompt(command_path):
"""Decides if survey prompt should be checked."""
if properties.VALUES.survey.disable_prompts.GetBool():
return False
# dev shell environment uses temporary folder for user config. That means
# survey prompt cache gets cleaned each time user starts a new session,
# which results in too frequent prompting.
if c_devshell.IsDevshellEnvironment():
return False
exempt_commands = ['gcloud.components.post-process',]
for exempt_command in exempt_commands:
if command_path.startswith(exempt_command):
return False
return True
def SurveyPromptCheck(command_path, **unused_kwargs):
"""Checks for in-tool survey prompt."""
if not _ShouldCheckSurveyPrompt(command_path):
return
try:
survey_check.SurveyPrompter().PromptForSurvey()
# pylint:disable=broad-except, We never want this to escape, ever. Only
# messages printed should reach the user.
except Exception:
log.debug('Failed to check survey prompt.', exc_info=True)
# pylint:enable=broad-except
def CreateCLI(surfaces, translator=None):
"""Generates the gcloud CLI from 'surface' folder with extra surfaces.
Args:
surfaces: list(tuple(dot_path, dir_path)), extra commands or subsurfaces
to add, where dot_path is calliope command path and dir_path
path to command group or command.
translator: yaml_command_translator.Translator, an alternative translator.
Returns:
calliope cli object.
"""
def VersionFunc():
generated_cli.Execute(['version'])
def HandleKnownErrorFunc():
crash_handling.ReportError(is_crash=False)
pkg_root = os.path.dirname(os.path.dirname(surface.__file__))
loader = cli.CLILoader(
name='gcloud',
command_root_directory=os.path.join(pkg_root, 'surface'),
allow_non_existing_modules=True,
version_func=VersionFunc,
known_error_handler=HandleKnownErrorFunc,
yaml_command_translator=(translator or
yaml_command_translator.Translator()),
)
loader.AddReleaseTrack(base.ReleaseTrack.ALPHA,
os.path.join(pkg_root, 'surface', 'alpha'),
component='alpha')
loader.AddReleaseTrack(base.ReleaseTrack.BETA,
os.path.join(pkg_root, 'surface', 'beta'),
component='beta')
for dot_path, dir_path in surfaces:
loader.AddModule(dot_path, dir_path, component=None)
# TODO(b/128465608): Remove cloned ml-engine commands and PreRunHook after a
# suitable deprecation period.
# Clone 'ai-platform' surface into 'ml-engine' for backward compatibility.
loader.AddModule('ml_engine', os.path.join(pkg_root, 'surface',
'ai_platform'))
loader.RegisterPreRunHook(
_IssueAIPlatformAliasWarning, include_commands=r'gcloud\..*ml-engine\..*')
# Check for updates on shutdown but not for any of the updater commands.
# Skip update checks for 'gcloud version' command as it does that manually.
exclude_commands = r'gcloud\.components\..*|gcloud\.version'
loader.RegisterPostRunHook(UpdateCheck, exclude_commands=exclude_commands)
loader.RegisterPostRunHook(SurveyPromptCheck)
generated_cli = loader.Generate()
return generated_cli
def _IssueAIPlatformAliasWarning(command_path=None):
del command_path # Unused in _IssueTestWarning
log.warning(
'The `gcloud ml-engine` commands have been renamed and will soon be '
'removed. Please use `gcloud ai-platform` instead.')
def main(gcloud_cli=None, credential_providers=None):
if not platforms.PythonVersion().IsCompatible(
allow_py3=properties.VALUES.core.allow_py3.GetBool()):
sys.exit(1)
metrics.Started(START_TIME)
# TODO(b/36049857): Put a real version number here
metrics.Executions(
'gcloud',
local_state.InstallationState.VersionForInstalledComponent('core'))
if gcloud_cli is None:
gcloud_cli = CreateCLI([])
# Register some other sources for credentials and project.
credential_providers = credential_providers or [
creds_store.DevShellCredentialProvider(),
creds_store.GceCredentialProvider(),
]
for provider in credential_providers:
provider.Register()
# Register support for service account impersonation.
creds_store.IMPERSONATION_TOKEN_PROVIDER = (
iamcred_util.ImpersonationAccessTokenProvider())
try:
try:
gcloud_cli.Execute()
# Flush stdout so that if we've received a SIGPIPE we handle the broken
# pipe within this try block, instead of potentially during interpreter
# shutdown.
sys.stdout.flush()
except IOError as err:
# We want to ignore EPIPE IOErrors (as of Python 3.3 these can be caught
# specifically with BrokenPipeError, but we do it this way for Python 2
# compatibility).
#
# By default, Python ignores SIGPIPE (see
# http://utcc.utoronto.ca/~cks/space/blog/python/SignalExceptionSurprise).
# This means that attempting to write any output to a closed pipe (e.g. in
# the case of output piped to `head` or `grep -q`) will result in an
# IOError, which gets reported as a gcloud crash. We don't want this
# behavior, so we ignore EPIPE (it's not a real error; it's a normal thing
# to occur).
#
# Before, we restored the SIGPIPE signal handler, but that caused issues
# with scripts/programs that wrapped gcloud.
if err.errno == errno.EPIPE:
# At this point we've caught the broken pipe, but since Python flushes
# standard streams on exit, it's still possible for a broken pipe error
# to happen during interpreter shutdown. The interpreter will catch this
# but in Python 3 it still prints a warning to stderr saying that the
# exception was ignored (see https://bugs.python.org/issue11380):
#
# Exception ignored in: <_io.TextIOWrapper name='<stdout>' mode='w'
# encoding='UTF-8'>
# BrokenPipeError: [Errno 32] Broken pipe
#
# To prevent this from happening, we redirect any remaining output to
# devnull as recommended here:
# https://docs.python.org/3/library/signal.html#note-on-sigpipe.
devnull = os.open(os.devnull, os.O_WRONLY)
os.dup2(devnull, sys.stdout.fileno())
else:
raise
except Exception as err: # pylint:disable=broad-except
crash_handling.HandleGcloudCrash(err)
if properties.VALUES.core.print_unhandled_tracebacks.GetBool():
# We want to see the traceback as normally handled by Python
raise
else:
# This is the case for most non-Cloud SDK developers. They shouldn't see
# the full stack trace, but just the nice "gcloud crashed" message.
sys.exit(1)
finally:
for provider in credential_providers:
provider.UnRegister()
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt:
keyboard_interrupt.HandleInterrupt()
|
##########################################################################
# If not stated otherwise in this file or this component's Licenses.txt
# file the following copyright and licenses apply:
#
# Copyright 2021 RDK Management
#
# 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.
##########################################################################
'''
<?xml version='1.0' encoding='utf-8'?>
<xml>
<id></id>
<!-- Do not edit id. This will be auto filled while exporting. If you are adding a new script keep the id empty -->
<version>5</version>
<!-- Do not edit version. This will be auto incremented while updating. If you are adding a new script you can keep the vresion as 1 -->
<name>TS_WANMANAGER_FixedModeOnBootup_CheckInternetConnectivity</name>
<!-- If you are adding a new script you can specify the script name. Script Name should be unique same as this file name with out .py extension -->
<primitive_test_id></primitive_test_id>
<!-- Do not change primitive_test_id if you are editing an existing script. -->
<primitive_test_name>wanmanager_DoNothing</primitive_test_name>
<!-- -->
<primitive_test_version>1</primitive_test_version>
<!-- -->
<status>FREE</status>
<!-- -->
<synopsis>Set the WAN Manager Policy to Fixed Mode On Bootup and check the internet connectivity.</synopsis>
<!-- -->
<groups_id />
<!-- -->
<execution_time>30</execution_time>
<!-- -->
<long_duration>false</long_duration>
<!-- -->
<advanced_script>false</advanced_script>
<!-- execution_time is the time out time for test execution -->
<remarks></remarks>
<!-- Reason for skipping the tests if marked to skip -->
<skip>false</skip>
<!-- -->
<box_types>
<box_type>Broadband</box_type>
<!-- -->
</box_types>
<rdk_versions>
<rdk_version>RDKB</rdk_version>
<!-- -->
</rdk_versions>
<test_cases>
<test_case_id>TC_WANMANAGER_22</test_case_id>
<test_objective>To set the WAN Manager Policy to Fixed Mode On Bootup and check the internet connectivity.</test_objective>
<test_type>Positive</test_type>
<test_setup>Broadband</test_setup>
<pre_requisite>1.Ccsp Components should be in a running state else invoke cosa_start.sh manually that includes all the ccsp components and TDK Component
2.TDK Agent should be in running state or invoke it through StartTdk.sh script
3.Wan Manager should be enabled</pre_requisite>
<api_or_interface_used>none</api_or_interface_used>
<input_parameters>none</input_parameters>
<automation_approch>1. Load the module
2. Get the value of Device.X_RDK_WanManager.Policy
3. Set Device.X_RDK_WanManager.Policy to FIXED_MODE_ON_BOOTUP. The device is expected to go for a reboot after the set operation
4. Once the device comes up, query Device.X_RDK_WanManager.Policy and verify the set value is same as get value
5.Test with ping command whether device is reachable outside
6.Unload the module</automation_approch>
<expected_output>Setting Device.X_RDK_WanManager.Policy to FIXED_MODE_ON_BOOTUP should be success and internet should be available</expected_output>
<priority>High</priority>
<test_stub_interface>WAN MANAGER</test_stub_interface>
<test_script>TS_WANMANAGER_FixedModeOnBootup_CheckInternetConnectivity</test_script>
<skipped>No</skipped>
<release_version>M89</release_version>
<remarks>None</remarks>
</test_cases>
<script_tags />
</xml>
'''
# use tdklib library,which provides a wrapper for tdk testcase script
import tdklib;
from WanManager_Utility import *
from tdkbVariables import *;
obj = tdklib.TDKScriptingLibrary("tdkbtr181","RDKB");
obj1 = tdklib.TDKScriptingLibrary("sysutil","1");
#IP and Port of box, No need to change,
#This will be replaced with correspoing Box Ip and port while executing script
ip = <ipaddress>
port = <port>
obj.configureTestCase(ip,port,'TS_WANMANAGER_FixedModeOnBootup_CheckInternetConnectivity');
obj1.configureTestCase(ip,port,'TS_WANMANAGER_FixedModeOnBootup_CheckInternetConnectivity');
#Get the result of connection with test component and DUT
loadmodulestatus =obj.getLoadModuleResult();
loadmodulestatus1 =obj1.getLoadModuleResult();
print "[LIB LOAD STATUS] : %s" %loadmodulestatus ;
print "[LIB LOAD STATUS] : %s" %loadmodulestatus1 ;
if "SUCCESS" in (loadmodulestatus.upper() and loadmodulestatus1.upper()):
#Set the result status of execution
obj.setLoadModuleStatus("SUCCESS");
obj1.setLoadModuleStatus("SUCCESS");
tdkTestObj = obj.createTestStep('TDKB_TR181Stub_Get');
step = 1;
status, policy_initial = get_policy(tdkTestObj, step);
if status == 0:
step = step + 1;
status = is_policy_expected(tdkTestObj, policy_initial, step);
if status == 0:
#Set the Wan Manager Policy to FIXED_MODE_ON_BOOTUP
new_policy = "FIXED_MODE_ON_BOOTUP"
expectedresult="SUCCESS";
print "Setting the wanmanager policy to :%s"%new_policy
revert = 0
set_policy(new_policy, policy_initial, obj1, revert);
#Get the WANMANAGER POLICY and cross check with the Set value
step = step + 1;
status, policy = get_policy(tdkTestObj, step);
if status == 0:
if policy == new_policy:
tdkTestObj.setResultStatus("SUCCESS");
print "The wanmanager policy is set successfully"
#Checking for internet connectivity after policy change
tdkTestObj = obj1.createTestStep('ExecuteCmd');
query ="ping -c 2 google.com | grep -i \"100% packet loss\"";
print "query:%s" %query;
tdkTestObj.addParameter("command",query);
expectedresult="SUCCESS";
#Execute the test case in DUT
tdkTestObj.executeTestCase(expectedresult);
actualresult = tdkTestObj.getResult();
details = tdkTestObj.getResultDetails().strip();
if expectedresult in actualresult and details == "":
#Set the result status of execution
tdkTestObj.setResultStatus("SUCCESS");
print "TEST STEP : Do a ping operation and check for internet connectivity";
print "EXPECTED RESULT: ping operation should be success with no 100% packet loss";
print "ACTUAL RESULT : ping operation is success and internet is available";
#Get the result of execution
print "[TEST EXECUTION RESULT] : SUCCESS";
else:
#Set the result status of execution
tdkTestObj.setResultStatus("FAILURE");
print "TEST STEP : Do a ping operation and check for internet connectivity";
print "EXPECTED RESULT: ping operation should be success with no 100% packet loss";
print "ACTUAL RESULT : %s"%details;
#Get the result of execution
print "[TEST EXECUTION RESULT] : FAILURE";
set_policy(new_policy, policy_initial, obj1, revert);
else:
tdkTestObj.setResultStatus("FAILURE");
print "The wanmanager policy is not set successfully"
else:
tdkTestObj.setResultStatus("FAILURE");
print "Failed to get wanmanager policy after set ";
else:
tdkTestObj.setResultStatus("FAILURE");
print "The current policy is not the expected policy";
else:
tdkTestObj.setResultStatus("FAILURE");
print "Failed to get initial wanmanager policy";
obj.unloadModule("tdkbtr181");
obj1.unloadModule("sysutil");
else:
print "Failed to load module";
obj.setLoadModuleStatus("FAILURE");
obj1.setLoadModuleStatus("FAILURE");
|
# Copyright 2018 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 f
"""Pipeline input for UpdateFlakeAnalysisDataPointPipeline."""
from dto.flake_swarming_task_output import FlakeSwarmingTaskOutput
from libs.structured_object import StructuredObject
class UpdateFlakeAnalysisDataPointsInput(StructuredObject):
# The urlsafe-key to the analysis to update.
analysis_urlsafe_key = basestring
# The url to the build whose artifacts were used to create the data point.
# Can be None if existing build artifacts were not used (compile was needed).
build_url = basestring
# The data point with matching commit position to update.
commit_position = int
# The revision corresponding to the data point.
revision = basestring
# The url to the try job that generated the build artifacts to generate the
# data point. Can be None if existing build artifacts were used (commit
# position mapped to a nearby valid build).
try_job_url = basestring
# The results of the flake swarming task to update data points with.
swarming_task_output = FlakeSwarmingTaskOutput
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
'''
Author : Nasir Khan (r0ot h3x49)
Github : https://github.com/r0oth3x49
License : MIT
Copyright (c) 2018 Nasir Khan (r0ot h3x49)
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.
'''
import os
import re
import sys
import json
from pprint import pprint
from ._auth import UdemyAuth
from ._utils import (
parse_json,
js_to_json,
search_regex,
unescapeHTML
)
from ._compat import (
re,
time,
encoding,
conn_error,
COURSE_URL,
ParseCookie,
MY_COURSES_URL,
COURSE_SEARCH,
COLLECTION_URL
)
from ._sanitize import (
slugify,
sanitize,
SLUG_OK
)
from ._colorized import *
from ._progress import ProgressBar
class Udemy(ProgressBar):
def __init__(self):
self._session = ''
self._cookies = ''
def _clean(self, text):
ok = re.compile(r'[^\\/:*?"<>|]')
text = "".join(x if ok.match(x) else "_" for x in text)
text = re.sub(r'\.+$', '', text.strip())
return text
def _course_name(self, url):
# mobj = re.search(r'(?i)(?:(.+)\.com/(?P<course_name>[a-zA-Z0-9_-]+))', url, re.I)
mobj = re.search(r'(?i)(?://(?P<portal_name>.+?).udemy.com/(?P<course_name>[a-zA-Z0-9_-]+))', url)
if mobj:
return mobj.group('portal_name'), mobj.group('course_name')
def _extract_cookie_string(self, raw_cookies):
cookies = {}
try:
client_id = re.search(r'(?i)(?:client_id=(?P<client_id>\w+))', raw_cookies)
access_token = re.search(r'(?i)(?:access_token=(?P<access_token>\w+))', raw_cookies)
except:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Cookies error, Request Headers is required.\n")
sys.stdout.write(fc + sd + "[" + fm + sb + "i" + fc + sd + "] : " + fg + sb + "Copy Request Headers for single request to a file, while you are logged in.\n")
sys.exit(0)
cookies.update({'client_id': client_id.group('client_id'),
'access_token': access_token.group('access_token')})
return cookies
def _sanitize(self, unsafetext):
text = sanitize(slugify(unsafetext, lower=False, spaces=True, ok=SLUG_OK + '().[]'))
return text
def _login(self, username='', password='', cookies=''):
if not cookies:
auth = UdemyAuth(username=username, password=password)
self._session = auth.authenticate()
if cookies:
self._cookies = self._extract_cookie_string(raw_cookies=cookies)
access_token = self._cookies.get('access_token')
client_id = self._cookies.get('client_id')
time.sleep(0.3)
auth = UdemyAuth()
self._session = auth.authenticate(access_token=access_token, client_id=client_id)
self._session._session.cookies.update(self._cookies)
if self._session is not None:
return {'login' : 'successful'}
else:
return {'login' : 'failed'}
def _logout(self):
return self._session.terminate()
def _subscribed_courses(self, portal_name, course_name):
results = []
self._session._headers.update({
'Host' : '{portal_name}.udemy.com'.format(portal_name=portal_name),
'Referer' : 'https://{portal_name}.udemy.com/home/my-courses/search/?q={course_name}'.format(portal_name=portal_name, course_name=course_name)
})
url = COURSE_SEARCH.format(portal_name=portal_name, course_name=course_name)
try:
webpage = self._session._get(url).json()
except conn_error as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Connection error : make sure your internet connection is working.\n")
time.sleep(0.8)
sys.exit(0)
except (ValueError, Exception) as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "%s.\n" % (e))
time.sleep(0.8)
sys.exit(0)
else:
results = webpage.get('results', [])
return results
def _my_courses(self, portal_name):
results = []
try:
url = MY_COURSES_URL.format(portal_name=portal_name)
webpage = self._session._get(url).json()
except conn_error as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Connection error : make sure your internet connection is working.\n")
time.sleep(0.8)
sys.exit(0)
except (ValueError, Exception) as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "%s.\n" % (e))
time.sleep(0.8)
sys.exit(0)
else:
results = webpage.get('results', [])
return results
def _subscribed_collection_courses(self, portal_name):
url = COLLECTION_URL.format(portal_name=portal_name)
courses_lists = []
try:
webpage = self._session._get(url).json()
except conn_error as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Connection error : make sure your internet connection is working.\n")
time.sleep(0.8)
sys.exit(0)
except (ValueError, Exception) as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "%s.\n" % (e))
time.sleep(0.8)
sys.exit(0)
else:
results = webpage.get('results', [])
if results:
[courses_lists.extend(courses.get('courses', [])) for courses in results if courses.get('courses', [])]
return courses_lists
def __extract_course(self, response, course_name):
_temp = {}
if response:
for entry in response:
if entry.get('published_title') == course_name:
_temp = entry
return _temp
def _extract_course_info(self, url):
portal_name, course_name = self._course_name(url)
course = {}
results = self._subscribed_courses(portal_name=portal_name, course_name=course_name)
if not results:
results = self._my_courses(portal_name=portal_name)
if results:
course = self.__extract_course(response=results, course_name=course_name)
if not course:
results = self._subscribed_collection_courses(portal_name=portal_name)
course = self.__extract_course(response=results, course_name=course_name)
if course:
course.update({'portal_name' : portal_name})
return course.get('id'), course
if not course:
sys.stdout.write('\033[2K\033[1G\r\r' + fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fg + sb + "Downloading course information, course id not found .. (%s%sfailed%s%s)\n" % (fr, sb, fg, sb))
sys.stdout.write(fc + sd + "[" + fw + sb + "i" + fc + sd + "] : " + fw + sb + "It seems either you are not enrolled or you have to visit the course atleast once while you are logged in.\n")
sys.stdout.write(fc + sd + "[" + fm + sb + "*" + fc + sd + "] : " + fg + sb + "Trying to logout now...\n")
if not self._cookies:
self._logout()
sys.stdout.write(fc + sd + "[" + fm + sb + "+" + fc + sd + "] : " + fg + sb + "Logged out successfully.\n")
sys.exit(0)
def _extract_large_course_content(self, url):
url = url.replace('10000', '300') if url.endswith('10000') else url
try:
data = self._session._get(url).json()
except conn_error as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Connection error : make sure your internet connection is working.\n")
time.sleep(0.8)
sys.exit(0)
else:
_next = data.get('next')
while _next:
try:
resp = self._session._get(_next).json()
except conn_error as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Connection error : make sure your internet connection is working.\n")
time.sleep(0.8)
sys.exit(0)
else:
_next = resp.get('next')
results = resp.get('results')
if results and isinstance(results, list):
for d in resp['results']:
data['results'].append(d)
return data
def _extract_course_json(self, url, course_id, portal_name):
self._session._headers.update({'Referer' : url})
url = COURSE_URL.format(portal_name=portal_name, course_id=course_id)
try:
resp = self._session._get(url)
if resp.status_code == 502:
resp = self._extract_large_course_content(url=url)
else:
resp = resp.json()
except conn_error as e:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Connection error : make sure your internet connection is working.\n")
time.sleep(0.8)
sys.exit(0)
except (ValueError, Exception) as e:
resp = self._extract_large_course_content(url=url)
return resp
else:
return resp
def _html_to_json(self, view_html, lecture_id):
data = parse_json(
search_regex(
r'videojs-setup-data=(["\'])(?P<data>{.+?})\1',
view_html,
'setup data',
default='{}',
group='data'),
lecture_id,
transform_source=unescapeHTML,
fatal=False
)
text_tracks = parse_json(
search_regex(
r'text-tracks=(["\'])(?P<data>\[.+?\])\1',
view_html,
'text tracks',
default='{}',
group='data'),
lecture_id,
transform_source=lambda s: js_to_json(unescapeHTML(s)),
fatal=False
)
return data, text_tracks
def _extract_ppt(self, assets):
_temp = []
download_urls = assets.get('download_urls')
slides_urls = assets.get('slide_urls')
filename = self._sanitize(assets.get('filename'))
if download_urls and isinstance(download_urls, dict):
extension = filename.rsplit('.', 1)[-1] if '.' in filename else ''
download_url = download_urls.get('Presentation', [])[0].get('file')
_temp.append({
'type' : 'presentation',
'filename' : filename,
'extension' : extension,
'download_url' : download_url
})
return _temp
def _extract_file(self, assets):
_temp = []
download_urls = assets.get('download_urls')
filename = self._sanitize(assets.get('filename'))
if download_urls and isinstance(download_urls, dict):
extension = filename.rsplit('.', 1)[-1] if '.' in filename else ''
download_url = download_urls.get('File', [])[0].get('file')
_temp.append({
'type' : 'file',
'filename' : filename,
'extension' : extension,
'download_url' : download_url
})
return _temp
def _extract_ebook(self, assets):
_temp = []
download_urls = assets.get('download_urls')
filename = self._sanitize(assets.get('filename'))
if download_urls and isinstance(download_urls, dict):
extension = filename.rsplit('.', 1)[-1] if '.' in filename else ''
download_url = download_urls.get('E-Book', [])[0].get('file')
_temp.append({
'type' : 'ebook',
'filename' : filename,
'extension' : extension,
'download_url' : download_url
})
return _temp
def _extract_audio(self, assets):
_temp = []
download_urls = assets.get('download_urls')
filename = self._sanitize(assets.get('filename'))
if download_urls and isinstance(download_urls, dict):
extension = filename.rsplit('.', 1)[-1] if '.' in filename else ''
download_url = download_urls.get('Audio', [])[0].get('file')
_temp.append({
'type' : 'audio',
'filename' : filename,
'extension' : extension,
'download_url' : download_url
})
return _temp
def _extract_sources(self, sources):
_temp = []
if sources and isinstance(sources, list):
for source in sources:
label = source.get('label')
download_url = source.get('file')
if not download_url:
continue
if label.lower() == 'audio':
continue
height = label if label else None
if height == "2160":
width = "3840"
elif height == "1440":
width = "2560"
elif height == "1080":
width = "1920"
elif height == "720":
width = "1280"
elif height == "480":
width = "854"
elif height == "360":
width = "640"
elif height == "240":
width = "426"
else:
width = "256"
if source.get('type') == 'application/x-mpegURL' or 'm3u8' in download_url:
continue
else:
_type = source.get('type')
_temp.append({
'type' : 'video',
'height' : height,
'width' : width,
'extension' : _type.replace('video/', ''),
'download_url' : download_url,
})
return _temp
def _extract_subtitles(self, tracks):
_temp = []
if tracks and isinstance(tracks, list):
for track in tracks:
if not isinstance(track, dict):
continue
if track.get('_class') != 'caption':
continue
download_url = track.get('url')
if not download_url or not isinstance(download_url, encoding):
continue
lang = track.get('language') or track.get('srclang') or track.get('label') or track['locale_id'].split('_')[0]
ext = 'vtt' if 'vtt' in download_url.rsplit('.', 1)[-1] else 'srt'
_temp.append({
'type' : 'subtitle',
'language' : lang,
'extension' : ext,
'download_url' : download_url,
})
return _temp
def _extract_supplementary_assets(self, supp_assets):
_temp = []
for entry in supp_assets:
file_id = entry.get('id')
filename = self._sanitize(entry.get('filename'))
download_urls = entry.get('download_urls')
external_url = entry.get('external_url')
slide_url = entry.get('slide_urls')
asset_type = entry.get('asset_type').lower()
if asset_type == 'file':
if download_urls and isinstance(download_urls, dict):
extension = filename.rsplit('.', 1)[-1] if '.' in filename else ''
download_url = download_urls.get('File', [])[0].get('file')
_temp.append({
'type' : 'file',
'filename' : filename,
'extension' : extension,
'download_url' : download_url,
})
elif asset_type == 'sourcecode':
if download_urls and isinstance(download_urls, dict):
extension = filename.rsplit('.', 1)[-1] if '.' in filename else ''
download_url = download_urls.get('SourceCode', [])[0].get('file')
_temp.append({
'type' : 'source_code',
'filename' : filename,
'extension' : extension,
'download_url' : download_url,
})
elif asset_type == 'externallink':
_temp.append({
'type' : 'external_link',
'filename' : filename,
'extension' : 'txt',
'download_url' : external_url,
})
return _temp
def _real_extract(self, url=''):
_udemy = {}
course_id, course_info = self._extract_course_info(url)
if course_info and isinstance(course_info, dict):
course_title = course_info.get('published_title')
portal_name = course_info.get('portal_name')
course_json = self._extract_course_json(url, course_id, portal_name)
course = course_json.get('results')
resource = course_json.get('detail')
if resource:
if not self._cookies:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Udemy Says : {}{}{} Run udemy-dl against course within few seconds.\n".format(resource, fw, sb))
if self._cookies:
sys.stdout.write(fc + sd + "[" + fr + sb + "-" + fc + sd + "] : " + fr + sb + "Udemy Says : {}{}{} cookies seems to be expired.\n".format(resource, fw, sb))
sys.stdout.write(fc + sd + "[" + fm + sb + "*" + fc + sd + "] : " + fg + sb + "Trying to logout now...\n")
if not self._cookies:
self._logout()
sys.stdout.write(fc + sd + "[" + fm + sb + "+" + fc + sd + "] : " + fg + sb + "Logged out successfully.\n")
sys.exit(0)
_udemy['course_id'] = course_id
_udemy['course_title'] = course_title
_udemy['chapters'] = []
counter = -1
if course:
for entry in course:
clazz = entry.get('_class')
asset = entry.get('asset')
supp_assets = entry.get('supplementary_assets')
if clazz == 'chapter':
lectures = []
chapter_index = entry.get('object_index')
chapter_title = self._clean(self._sanitize(entry.get('title')))
chapter = "{0:02d} {1!s}".format(chapter_index, chapter_title)
unsafe_chapter = u'{0:02d} '.format(chapter_index) + self._clean(entry.get('title'))
if chapter not in _udemy['chapters']:
_udemy['chapters'].append({
'chapter_title' : chapter,
'chapter_id' : entry.get("id"),
'chapter_index' : chapter_index,
'unsafe_chapter' : unsafe_chapter,
'lectures' : [],
})
counter += 1
elif clazz == 'lecture':
lecture_id = entry.get("id")
if len(_udemy['chapters']) == 0:
lectures = []
chapter_index = entry.get('object_index')
chapter_title = self._clean(self._sanitize(entry.get('title')))
chapter = "{0:03d} {1!s}".format(chapter_index, chapter_title)
unsafe_chapter = u'{0:02d} '.format(chapter_index) + self._clean(entry.get('title'))
if chapter not in _udemy['chapters']:
_udemy['chapters'].append({
'chapter_title' : chapter,
'chapter_id' : lecture_id,
'chapter_index' : chapter_index,
'unsafe_chapter' : unsafe_chapter,
'lectures' : [],
})
counter += 1
if lecture_id:
view_html = entry.get('view_html')
retVal = []
if isinstance(asset, dict):
asset_type = asset.get('asset_type').lower() or asset.get('assetType').lower()
if asset_type == 'article':
if isinstance(supp_assets, list) and len(supp_assets) > 0:
retVal = self._extract_supplementary_assets(supp_assets)
elif asset_type == 'video':
if isinstance(supp_assets, list) and len(supp_assets) > 0:
retVal = self._extract_supplementary_assets(supp_assets)
elif asset_type == 'e-book':
retVal = self._extract_ebook(asset)
elif asset_type == 'file':
retVal = self._extract_file(asset)
elif asset_type == 'presentation':
retVal = self._extract_ppt(asset)
elif asset_type == 'audio':
retVal = self._extract_audio(asset)
if view_html:
text = '\r' + fc + sd + "[" + fm + sb + "*" + fc + sd + "] : " + fg + sb + "Downloading course information .. "
self._spinner(text)
lecture_index = entry.get('object_index')
lecture_title = self._clean(self._sanitize(entry.get('title')))
lecture = "{0:03d} {1!s}".format(lecture_index, lecture_title)
unsafe_lecture = u'{0:03d} '.format(lecture_index) + entry.get('title')
data, subs = self._html_to_json(view_html, lecture_id)
if data and isinstance(data, dict):
sources = data.get('sources')
tracks = data.get('tracks') if isinstance(data.get('tracks'), list) else subs
duration = data.get('duration')
lectures.append({
'lecture_index' : lecture_index,
'lectures_id' : lecture_id,
'lecture_title' : lecture,
'unsafe_lecture' : unsafe_lecture,
'duration' : duration,
'assets' : retVal,
'assets_count' : len(retVal),
'sources' : self._extract_sources(sources),
'subtitles' : self._extract_subtitles(tracks),
'subtitle_count' : len(self._extract_subtitles(tracks)),
'sources_count' : len(self._extract_sources(sources)),
})
else:
lectures.append({
'lecture_index' : lecture_index,
'lectures_id' : lecture_id,
'lecture_title' : lecture,
'unsafe_lecture' : unsafe_lecture,
'html_content' : view_html,
'extension' : 'html',
'assets' : retVal,
'assets_count' : len(retVal),
'subtitle_count' : 0,
'sources_count' : 0,
})
if not view_html:
text = '\r' + fc + sd + "[" + fm + sb + "*" + fc + sd + "] : " + fg + sb + "Downloading course information .. "
self._spinner(text)
lecture_index = entry.get('object_index')
lecture_title = self._clean(self._sanitize(entry.get('title')))
lecture = "{0:03d} {1!s}".format(lecture_index, lecture_title)
unsafe_lecture = u'{0:03d} '.format(lecture_index) + self._clean(entry.get('title'))
data = asset.get('stream_urls')
if data and isinstance(data, dict):
sources = data.get('Video')
tracks = asset.get('captions')
duration = asset.get('time_estimation')
lectures.append({
'lecture_index' : lecture_index,
'lectures_id' : lecture_id,
'lecture_title' : lecture,
'unsafe_lecture' : unsafe_lecture,
'duration' : duration,
'assets' : retVal,
'assets_count' : len(retVal),
'sources' : self._extract_sources(sources),
'subtitles' : self._extract_subtitles(tracks),
'subtitle_count' : len(self._extract_subtitles(tracks)),
'sources_count' : len(self._extract_sources(sources)),
})
else:
lectures.append({
'lecture_index' : lecture_index,
'lectures_id' : lecture_id,
'lecture_title' : lecture,
'unsafe_lecture' : unsafe_lecture,
'html_content' : asset.get('body'),
'extension' : 'html',
'assets' : retVal,
'assets_count' : len(retVal),
'subtitle_count' : 0,
'sources_count' : 0,
})
_udemy['chapters'][counter]['lectures'] = lectures
_udemy['chapters'][counter]['lectures_count'] = len(lectures)
elif clazz == 'quiz':
lecture_id = entry.get("id")
if len(_udemy['chapters']) == 0:
lectures = []
chapter_index = entry.get('object_index')
chapter_title = self._clean(self._sanitize(entry.get('title')))
chapter = "{0:03d} {1!s}".format(chapter_index, chapter_title)
unsafe_chapter = u'{0:02d} '.format(chapter_index) + self._clean(entry.get('title'))
if chapter not in _udemy['chapters']:
_udemy['chapters'].append({
'chapter_title' : chapter,
'unsafe_chapter' : unsafe_chapter,
'chapter_id' : lecture_id,
'chapter_index' : chapter_index,
'lectures' : [],
})
counter += 1
_udemy['chapters'][counter]['lectures'] = lectures
_udemy['chapters'][counter]['lectures_count'] = len(lectures)
_udemy['total_chapters'] = len(_udemy['chapters'])
_udemy['total_lectures'] = sum([entry.get('lectures_count', 0) for entry in _udemy['chapters'] if entry])
return _udemy
|
import requests
# API: https://rapidapi.com/jkosgei/api/free-ip-geolocation
querystring = {"api-key":"test"} # take your free api key from ipdata.co if you pass your testing limit
headers = {
'x-rapidapi-host': "jkosgei-free-ip-geolocation-v1.p.rapidapi.com",
'x-rapidapi-key': "ENTER YOUR RAPIDAPI KEY"
}
def ip_details(ip):
url = f"https://jkosgei-free-ip-geolocation-v1.p.rapidapi.com/{ip}"
response = requests.request("GET", url, headers=headers, params=querystring)
details=response.json()
if response.status_code==200:
try:
print('IP: ', details['ip'])
print('Country: ', details['country_name'])
print('Region: ', details['region'])
print('City: ', details['city'])
print('Coordinates: lat=', details['latitude'],'long=',details['longitude'])
print('ASN info:')
print('ASN: ', details['asn']['asn'])
print('Name: ', details['asn']['name'])
print('domain: ', details['asn']['domain'])
except KeyError:
print('Try again, with "public" ip address')
else:
print(response.status_code)
ip=input('Enter public ip address: ')
ip_details(ip)
|
#!/usr/bin/env python
from __future__ import with_statement
import sys
import subprocess
try:
from setuptools import setup, Command
except ImportError:
from distutils.core import setup, Command
from distutils.errors import CCompilerError, DistutilsExecError, \
DistutilsPlatformError
VERSION = '1.0.7'
DESCRIPTION = "JSON decoder for Python that can extract data from the muck"
with open('README.rst', 'r') as f:
LONG_DESCRIPTION = f.read()
setup(
name="dirtyjson",
version=VERSION,
packages=['dirtyjson', 'dirtyjson.tests'],
author="Scott Maxwell",
author_email="scott@codecobblers.com",
url="https://github.com/codecobblers/dirtyjson",
description=DESCRIPTION,
long_description=LONG_DESCRIPTION,
license="MIT License",
classifiers=["Development Status :: 5 - Production/Stable",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"License :: OSI Approved :: Academic Free License (AFL)",
"Programming Language :: Python",
"Programming Language :: Python :: 2",
"Programming Language :: Python :: 2.5",
"Programming Language :: Python :: 2.6",
"Programming Language :: Python :: 2.7",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.3",
"Programming Language :: Python :: 3.4",
"Programming Language :: Python :: Implementation :: CPython",
"Programming Language :: Python :: Implementation :: PyPy",
"Topic :: Software Development :: Libraries :: Python Modules"],
platforms=['any'],
test_suite="dirtyjson.tests",
zip_safe=True)
|
from matplotlib.colors import LogNorm
import matplotlib.pyplot as plt
import numpy as np
np.set_printoptions(threshold=np.inf)
font = {'family' : 'normal',
'weight' : 'normal',
'size' : 30}
plt.rc('font', **font)
plt.figure(num=None, figsize=(13, 10), dpi=100, facecolor='w', edgecolor='k')
bonds = np.loadtxt('bonds.dat', comments={'#','@','&'}, unpack=True)
#print len(bonds)
N=10
ind= np.arange(N)
plt.hist(bonds, bins=ind, rwidth=1, normed=True)
plt.xticks(ind+0.5,('0','1','2','3','4','5','6','7','8'))
plt.xlabel('Number of bonds per frame')
plt.ylabel('Probability of occuring')
plt.savefig('histogram.pdf',format='pdf')
plt.show()
|
# -*- coding: utf-8 -*-
# This file is part of Moksha.
# Copyright (C) 2008-2010 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.
"""Sample controller with all its actions protected."""
from tg import expose, flash, redirect, validate, tmpl_context
from pylons.i18n import ugettext as _, lazy_ugettext as l_
from repoze.what.predicates import has_permission
import moksha
from moksha.lib.base import BaseController
#from moksha.model import DBSession, metadata
__all__ = ['SecureController']
class SecureController(BaseController):
"""Sample controller-wide authorization"""
# The predicate that must be met for all the actions in this controller:
allow_only = has_permission('manage',
msg=l_('Only for people with the "manage" permission'))
@expose('moksha.templates.index')
def index(self):
"""Let the user know that's visiting a protected controller."""
flash(_("Secure Controller here"))
if 'default_menu' in moksha.menus:
tmpl_context.menu_widget = moksha.menus['default_menu']
else:
tmpl_context.menu_widget = lambda: ''
return dict(title='Moksha Administrator Controller')
@expose('moksha.templates.index')
def some_where(self):
"""Let the user know that this action is protected too."""
return dict(page='some_where')
|
from cicada2.runners.sql_runner import runner
def test_contains_rows():
expected_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
actual_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
passed, description = runner.contains_rows(expected_rows, actual_rows)
assert passed
assert description == "passed"
def test_contains_rows_subset_1():
expected_rows = [{"foo": "bar"}, {"foo": "alpha"}]
actual_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
passed, description = runner.contains_rows(expected_rows, actual_rows)
assert passed
assert description == "passed"
def test_contains_rows_subset_2():
expected_rows = [{"foo": "bar"}, {"foo": "alpha"}]
actual_rows = [
{"foo": "bar", "fizz": "buzz"},
{"foo": "alpha", "fizz": "bravo"},
{"foo": 1, "fizz": 2},
]
passed, description = runner.contains_rows(expected_rows, actual_rows)
assert passed
assert description == "passed"
def test_contains_rows_fail_1():
expected_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
actual_rows = [{"foo": "bar"}, {"foo": "alpha"}]
passed, _ = runner.contains_rows(expected_rows, actual_rows)
assert not passed
def test_contains_rows_fail_2():
expected_rows = [{"foo": "bar"}, {"foo": "alpha"}, {"foo": 1}]
actual_rows = [{"foo": "bar"}, {"foo": "alpha"}]
passed, description = runner.contains_rows(expected_rows, actual_rows)
assert not passed
assert description == "The following rows did not match any returned: [{'foo': 1}]"
def test_equals_rows():
expected_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
actual_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
passed, description = runner.equals_rows(expected_rows, actual_rows)
assert passed
assert description == "passed"
def test_equals_rows_different_length_1():
expected_rows = [{"foo": "bar", "fizz": "buzz"}]
actual_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
passed, description = runner.equals_rows(expected_rows, actual_rows)
assert not passed
assert description == "Expected 1 rows, got 2"
def test_equals_rows_different_length_2():
expected_rows = [{"foo": "bar", "fizz": "buzz"}, {"foo": "alpha", "fizz": "bravo"}]
actual_rows = [{"foo": "bar", "fizz": "buzz"}]
passed, description = runner.equals_rows(expected_rows, actual_rows)
assert not passed
assert description == "Expected 2 rows, got 1"
def test_equals_rows_failed():
expected_rows = [{"foo": "alpha", "fizz": "bravo"}]
actual_rows = [{"foo": "bar", "fizz": "buzz"}]
passed, description = runner.equals_rows(expected_rows, actual_rows)
assert not passed
assert (
description
== "Expected {'foo': 'alpha', 'fizz': 'bravo'}, got {'foo': 'bar', 'fizz': 'buzz'}"
)
|
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
import scrapy
class WanfangPeriodicalItem(scrapy.Item):
perio_id = scrapy.Field() # 期刊id参数
perio_title = scrapy.Field() # 期刊名称
hostunit_name = scrapy.Field() # 主办单位 列表，以&隔开
language = scrapy.Field() # 语种
issn = scrapy.Field() # 国际刊号
cn = scrapy.Field() # 国内刊号
cn_short = scrapy.Field() # 国内刊号/后面的字符
release_cycle = scrapy.Field() # 出版周期
affectoi = scrapy.Field() # 影响因子
article_num = scrapy.Field() # 载文量
funded_num = scrapy.Field() # 基金论文量
cite_num = scrapy.Field() # 被引量
download_num = scrapy.Field() # 下载量
core_perio = scrapy.Field() # 期刊 标签 列表，以&隔开
trans_title = scrapy.Field() # 期刊外文名称
crawl_time = scrapy.Field() # 采集时间
|
def insert(root, Key):
node=Node(Key)
if root==None:
return node
while(root):
if root.data==Key:
break
if root.data>Key:
if root.left:
root=root.left
else:
root.left=node
break
else:
if root.right:
root=root.right
else:
root.right=node
break
|
from DataShip.db_management.db_models import User
from DataShip.db_management.db_manager import DB_manager
import streamlit as st
from datetime import date
from sqlite3 import Connection
def signup(DB_MAN: DB_manager, DB_CONN: Connection) -> None:
"""This function represents a view to the signup page.
Args:
DB_MAN (DB_manager): database manager.
DB_CONN (Connection): database connection.
"""
# signup form to retrieve the information from the user.
st.subheader("Signup")
with st.form("signup"):
name = st.text_input("Full name *")
email = st.text_input("Email")
username = st.text_input("Username *")
password = st.text_input("Password *", type="password")
submit = st.form_submit_button("signup")
# if user clicks on the submit button, the information is saved in the database.
if submit:
user = User(
id=1,
name=name,
username=username,
password=password,
created_at=date.today(),
email=email if email else None,
)
user_created = DB_MAN.create_user(DB_CONN, user)
if user_created:
st.success(f"Welcome {user.name}")
st.session_state["user"] = user
st.experimental_rerun()
else:
st.error("Username/password is incorrect")
|
# -*- coding: utf-8 -*-
"""
ghostly.errors
~~~~~~~~~~~~~~
All local errors that ghostly raises.
"""
from __future__ import absolute_import, print_function, unicode_literals
__all__ = ['GhostlyError', 'DriverDoesNotExistError', 'GhostlyTestFailed']
class GhostlyError(Exception):
"""
Ghostly error, which all Ghostly errors inherit.
"""
pass
class DriverDoesNotExistError(GhostlyError):
"""
Raised when :py:meth:`Ghostly.__init__` can't load a specific driver.
"""
pass
class GhostlyTestFailed(GhostlyError):
pass
class GhostlyTimeoutError(GhostlyError):
"""
Raised when a timeout occurs within Ghostly.
"""
pass
|
"""
Runtime: 76 ms, faster than 69.96% of Python3 online submissions for Populating Next Right Pointers in Each Node.
Memory Usage: 15.7 MB, less than 49.50% of Python3 online submissions for Populating Next Right Pointers in Each Node.
"""
from typing import List
from typing import Optional
class Node:
def __init__(self, val: int = 0, left: 'Node' = None, right: 'Node' = None, next: 'Node' = None):
self.val = val
self.left = left
self.right = right
self.next = next
class Solution:
def connect(self, root: 'Optional[Node]') -> 'Optional[Node]':
if root is None:
return None
level_list = [root]
while len(level_list) > 0:
next_level_list = []
for n in level_list:
if n.left is not None:
next_level_list.append(n.left)
if n.right is not None:
next_level_list.append(n.right)
for idx, n in enumerate(next_level_list[0:len(next_level_list)-1]):
n.next = next_level_list[idx+1]
level_list = next_level_list
return root
ans_list = []
def tree_print(root):
if root is not None:
ptr = root
temp = []
while ptr is not None:
temp.append(ptr.val)
ptr = ptr.next
ans_list.append(temp)
tree_print(root.left)
def main():
sol = Solution()
inp = Node(1, Node(2, Node(4), Node(5)), Node(3, Node(6), Node(7)))
ans = sol.connect(inp)
tree_print(ans)
print('Output:', ans_list)
print('Expected:', [[1], [2,3], [4,5,6,7]])
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
import os
import operator
import copy
import re
import datetime
from functools import singledispatchmethod
from webencodings import ascii_lower
import tinycss2, cssselect2
import inflect
import dmark
# TODO: handle better than just global state?
content = matcher = None
SORT_KEY = operator.itemgetter(0, 1)
ORDERLY = operator.attrgetter("style_order", "content_order")
p = inflect.engine()
class StyleMatcher(cssselect2.Matcher):
"""
Override to implement our own ~css
TODO:
- sure, but say more :)
- I'm having a general problem with finding/remembering to set up closures that
properly hold durable references to these other lists/objects. Would be nice
to either ensure this is done with rigor, or design around the need...
"""
@classmethod
def build_value_evaluator(cls, tokens, join=True):
values = [value for value in cls.token_to_values(tokens)]
evaluator = None
if join:
def evaluator(element, values=values):
return "".join([str(val(element)) for val in values])
else:
def evaluator(element, values=values):
return [val(element) for val in values]
return evaluator
def match(self, element):
"""Match selectors against the given element.
:param element:
An :class:`ElementWrapper`.
:returns:
A list of the payload objects associated to selectors that match
element, in order of lowest to highest
:attr:`compiler.CompiledSelector` specificity and in order of
addition with :meth:`add_selector` among selectors of equal
specificity.
"""
relevant_selectors = []
if element.id is not None:
relevant_selectors.append(self.id_selectors.get(element.id, []))
for class_name in element.classes:
relevant_selectors.append(self.class_selectors.get(class_name, []))
relevant_selectors.append(
self.lower_local_name_selectors.get(ascii_lower(element.local_name), [])
)
relevant_selectors.append(
self.namespace_selectors.get(element.namespace_url, [])
)
if "lang" in element.etree_element.attrib:
relevant_selectors.append(self.lang_attr_selectors)
relevant_selectors.append(self.other_selectors)
results = [
(specificity, order, pseudo, payload)
for selector_list in relevant_selectors
for test, specificity, order, pseudo, payload in selector_list
if not isinstance(element, str) and test(element)
]
results.sort(key=SORT_KEY)
return results
@classmethod
def token_to_values(cls, tokens):
"""
TODO: sniff for a refactor that makes these all easier to add and less noisy
"""
for token in tokens:
if isinstance(token, tinycss2.ast.NumberToken):
out = token.int_value if token.int_value is not None else token.value
def numeric(el, sigh=str(out)):
return sigh
yield numeric
elif isinstance(
token, (tinycss2.ast.WhitespaceToken, tinycss2.ast.LiteralToken)
):
pass
elif isinstance(token, tinycss2.ast.FunctionBlock):
tok = token
evaluators = cls.build_value_evaluator(tok.arguments, join=False)
if token.name == "attr":
def fetch_attr(el, tok=token):
lookfor = " ".join([x.serialize() for x in tok.arguments])
out = getattr(el, lookfor, el.attributes.get(lookfor, "")) or ""
return out
yield fetch_attr
elif token.name == "uppercase":
tok = token # TODO: not yet, but AFAIK all but the first of these are droppable
def case_the_joint(el, callables=evaluators):
return str.upper("".join(callables(el)))
yield case_the_joint
elif token.name == "lowercase":
tok = token
def case_the_joint(el, callables=evaluators):
return str.lower("".join(callables(el)))
yield case_the_joint
elif token.name == "titlecase":
tok = token
def case_the_joint(el, callables=evaluators):
return str.title("".join(callables(el)))
yield case_the_joint
elif token.name == "sentencecase":
tok = token
def case_the_joint(el, callables=evaluators):
return str.capitalize("".join(callables(el)))
yield case_the_joint
# TODO: any other case ops?
elif token.name == "slice":
tok = token
def snip_snip(el, callables=evaluators):
start = 0
stop = None
try:
text, _start, _stop = callables(el)
start = int(_start)
stop = int(_stop)
except Exception as e:
# TODO this obviously won't bite me :P
pass
return text[start:stop]
yield snip_snip
elif token.name == "nl":
# TODO: I think maybe I backed off of this idea; kill if so
tok = token
def newline(el):
return "\n"
yield newline
elif token.name == "children":
tok = token
def number_of_children(el):
return len(el.children) if el.children else 0
yield number_of_children
elif token.name == "content":
tok = token
def content_string(el):
# TODO: I don't really know what the correct format
# for this will be. space-sep is JUST a wild guess
return "".join(
space_cadet(
WordsWurst.handle_children(el, dict({}, depth=11))
)
)
return " ".join(el.children) if el.children else ""
yield content_string
elif token.name == "inflect":
"""
TODO: ponder/doc: we may have to escape some parts
of these format strings in dmark. They're fine in the CSS...
not loving it:
%inflect{Hair plural('is', {0%}) {0%} directive plural('form', {0%})}:
"""
def processor(el, callables=evaluators):
args = callables(el)
return p.inflect(args[0].format(*args[1:]))
yield processor
elif token.name == "today":
"""
TODO: at some point there's a line where these get too idiomatic
I think now() and today() are on the right side of it, but idk...
"""
def today(el, callables=evaluators):
return datetime.date.today().strftime("".join(callables(el)))
yield today
elif token.name == "shortform":
# TODO: verify this is in use and can't be written out? it's obviously
# hardcoding format; else, look at pulling it out into an extension
# layer on top of wordswurst
tok = token
def content_string(el):
# TODO: I don't really know what the correct format
# for this will be. space-sep is JUST a wild guess
out = " ".join(el.children) if el.children else ""
return ".Ar {:} Ns {:}".format(out[0], out[1:])
yield content_string
else:
raise Exception(
"unhandled css function '{:}' at line {:}:{:}".format(
token.name,
token.source_line,
token.source_column,
),
token,
)
elif isinstance(token, tinycss2.ast.ParseError):
raise Exception(
"{:} at {:}:{:}: {:}".format(
token.kind,
token.source_line,
token.source_column,
token.message,
)
)
else:
def mystery_meat(element, tok=token):
return tok.value
yield mystery_meat
def __init__(self, css):
cssselect2.Matcher.__init__(self)
rules = tinycss2.parse_stylesheet_bytes(
css,
skip_whitespace=True,
skip_comments=True,
)[0]
for rule in rules:
for selector in cssselect2.compile_selector_list(rule.prelude):
self.add_selector(
selector,
{
obj.name: self.build_value_evaluator(obj.value)
for obj in tinycss2.parse_declaration_list(
rule.content, skip_whitespace=True
)
if obj.type == "declaration"
},
)
def space_camp(nodes):
for i, node in enumerate(nodes):
if node:
node.content_order = i
yield node
def space_cadet(nodes):
"""
Lay out a sequence of nodes as a sequence of strings.
Yield trimmed node text and appropriate boundary
whitespace strings.
"""
nodes = sorted(space_camp(nodes), key=ORDERLY)
if len(nodes):
prev = cur = None
cur = nodes.pop(0)
yield cur.left(None)
while len(nodes):
prev = cur
cur = nodes.pop(0)
bound = prev.right(cur)
yield prev.text
yield bound
bound = cur.right(None)
yield cur.text
yield bound
class OutputForm(object):
text = style = depth = None
space = strippable = lstrippable = rstrippable = None
content_order = None
style_order = 0
def __init__(self, style, text, depth):
self.text = text
self.style = style
if "strippable" in style:
self.strippable = style["strippable"]
if "lstrippable" in style:
self.lstrippable = style["lstrippable"]
if "rstrippable" in style:
self.rstrippable = style["rstrippable"]
if "space" in style:
self.space = style["space"] * style.get("spacen", 1)
if "order" in style:
self.style_order = int(style["order"])
self.depth = depth
def __repr__(self):
return "<{:} == {:}>".format(self.__class__.__name__, repr(self.text))
def rstrip(self):
self.text = self.text.rstrip(self.rstrippable or self.strippable)
def rstrip_other(self, other):
if other and hasattr(other, "rstrip"):
return other.rstrip()
def lstrip(self):
self.text = self.text.lstrip(self.lstrippable or self.strippable)
def lstrip_other(self, other):
if other and hasattr(other, "lstrip"):
return other.lstrip()
# singledispatched per class later
def left(self, other):
raise NotImplementedError("I don't know this", type(other))
def _left(self, other):
self.lstrip()
self.rstrip_other(other)
return self.space
def right(self, other):
raise NotImplementedError("I don't know this", type(other))
def _right_dominated(self, other):
# defer to the higher-order unit
return other.left(self)
def _right_dominating(self, other):
self.lstrip_other(other)
self.rstrip()
return self.space
class Char(OutputForm):
space = ""
def _right_dominating(self, other):
# override; I think only strip char when dominated
return self.space
def __bool__(self):
# filterable if all-space
try:
return len(self.text.strip(" ")) > 0
except:
raise ValueError(self, self.text)
class Word(OutputForm):
space = " "
class Line(OutputForm):
space = "\n"
class Block(OutputForm):
space = "\n\n"
OUTPUT_FORMS = {
"char": Char,
"word": Word,
"line": Line,
"block": Block,
}
def form_from_style(style, content, depth):
try:
form = OUTPUT_FORMS[style.get("display", "block")]
return form(style, content, depth)
except KeyError as e:
raise Exception(
"I only recognize the following display values: %s"
% ", ".join(OUTPUT_FORMS.keys())
) from e
"""
Set up single-dispatch methods on all of these OutputForm classes for
all of the other OutputForm classes.
"""
for form in OUTPUT_FORMS.values():
dominating = True
form.left = singledispatchmethod(form.left)
form.right = singledispatchmethod(form.right)
for typ in (type(None), str, Char, Word, Line, Block):
if dominating:
form.left.register(typ, form._left)
form.right.register(typ, form._right_dominating)
else:
form.right.register(typ, form._right_dominated)
if typ == form:
dominating = False
class WordsWurst(dmark.Translator):
@classmethod
def handle_string(cls, string, context):
depth = context.get("depth", 1)
return Char({}, string, depth)
@classmethod
def handle_styled(cls, element, context, depth):
output = []
style = {}
content = ""
matches = matcher.match(element)
if matches:
for match in matches:
"""
specificity is a 3-tuple of unknown values
0 = number of ID selectors
1 = number of class selectors, attributes selectors, and pseudo-classes
2 = number of type selectors and pseudo-elements
order probably reflects add_selector order
sort should be 0 > 1 > 2 > order
"""
specificity, order, pseudo, declarations = match
declarations = {k: v(element) for k, v in declarations.items()}
if pseudo:
if pseudo not in style:
style[pseudo] = declarations.copy()
else:
style[pseudo].update(declarations)
else:
style.update(declarations)
if "display" in style and style["display"] == "none":
return Char({}, "", depth)
if "before" in element.attributes or (
"before" in style and "content" in style["before"]
):
output.append(
form_from_style(
style["before"],
element.attributes["before"]
if "before" in element.attributes
else style["before"]["content"],
depth,
)
)
content = (
style["content"]
if "content" in style
else "".join(
space_cadet(
cls.handle_children(element, dict(context, depth=depth + 1))
)
)
)
output.append(Char({}, content, depth))
if "after" in element.attributes or (
"after" in style and "content" in style["after"]
):
output.append(
form_from_style(
style["after"],
element.attributes["after"]
if "after" in element.attributes
else style["after"]["content"],
depth,
)
)
return form_from_style(style, "".join(space_cadet(output)), depth)
@classmethod
def handle_compose(cls, element, context, depth):
global content, matcher
content_path, style_path = element.children.pop(0).split()
with open(content_path, "r") as cd, open(style_path, "rb") as sd:
content_file = cd.read()
style_file = sd.read()
content = Parser(content_file).parse()
for item in content:
item.associate()
matcher = StyleMatcher(style_file)
return "".join(
space_cadet(cls.handle_children(element, dict(context, depth=depth + 1)))
)
@classmethod
def handle_insert(cls, element, context, depth):
content_path = element.children.pop(0)
with open(content_path, "r") as cd:
element.children = cd.readlines()
return cls.handle_styled(element, context, depth=depth + 1)
@classmethod
def handle_select(cls, element, context, depth):
global content, matcher
selected = []
query = element.children.pop(0)
for part in content:
results = part.query_all(query)
for result in results:
result = copy.deepcopy(result)
# TODO: do id, too? or only if it doesn't clash?
result.classes.update(element.classes)
selected.append(
cls.handle_element(result, dict(context, depth=depth + 1))
)
if selected:
# strip to keep selected nodes in the ~envelope
# of the original select directive.
return Char({}, "".join(space_cadet(selected)).strip(), depth)
else:
raise Exception("[[bad select: {:}]]".format(query), element)
@classmethod
def handle_element(cls, element, context):
depth = context.get("depth", 1)
if element.name == "compose":
return cls.handle_compose(element, context, depth)
elif element.name == "select":
return cls.handle_select(element, context, depth)
elif element.name == "insert":
return cls.handle_insert(element, context, depth)
else:
return cls.handle_styled(element, context, depth)
class Element(dmark.Element, cssselect2.ElementWrapper):
# TODO: better document where these all come from
# and who they are for
id = classes = None
tag = local_name = parent = index = in_html_document = None
etree_element = etree_siblings = transport_content_language = None
_id_regex = re.compile(r"(?=[.#])")
@classmethod
def parse_name(cls, text):
identifiers = cls._id_regex.split(text)
element = identifiers.pop(0)
if not len(identifiers):
return element, None, set()
else:
identifier = None
classes = set()
for each in identifiers:
if each.startswith("."):
classes.add(each[1:])
elif identifier is None and each.startswith("#"):
identifier = each[1:]
return element, identifier, classes
def __init__(self, name, attributes, children):
el_name, self.id, self.classes = self.parse_name(name)
self.tag = self.local_name = self.name = el_name
self.local_name = el_name
self.attrib = self.attributes = attributes
self.children = children
self.etree_element = self
self.in_html_document = False
self.etree_siblings = []
def __repr__(self):
return "Element([{index}]{name}{id}{classes}, {attributes}{children})".format(
index=self.index,
id="#" + self.id if self.id else "",
classes="." + ".".join(self.classes) if len(self.classes) else "",
name=self.name,
attributes=self._repr_attributes(),
children=repr(self.children),
)
def get(self, key):
return self.attributes.get(key, None)
def associate(self):
"""
TODO: Would prefer to do this without our own full tree visit,
whether that's at __init__, or via an add_child hook, or
via a children-added callback (but d-mark's parsing
process means this info isn't available at init, and the
latter mechanisms don't exist yet)
"""
elements_only_dot_com = [x for x in self.children if isinstance(x, Element)]
for i, child in enumerate(self.children):
if not isinstance(child, Element):
continue
if i > 0:
child.previous = self.children[i - 1]
child.parent = self
child.etree_siblings = elements_only_dot_com
child.index = i
child.associate()
def iter_children(self):
"""
override ElementWrapper.iter_children
to use d-mark Element.children
"""
for child in self.children:
yield child
def iter_subtree(self):
"""
override ElementWrapper.iter_subtree
to handle non-Elements such as str
"""
stack = [iter([self])]
while stack:
element = next(stack[-1], None)
if element is None:
stack.pop()
elif not isinstance(element, Element):
continue
else:
yield element
stack.append(element.iter_children())
def etree_children(self):
"""
override ElementWrapper.etree_children
to use d-mark Element.children
"""
return self.children
class Str(str):
index = tag = None
def __new__(cls, text):
self = str.__new__(cls, text)
return self
def __init__(self, text):
pass
class Parser(dmark.Parser):
IDENTIFIER_CHARS = dmark.Parser.IDENTIFIER_CHARS + ".#"
def read_string(self):
res = super(Parser, self).read_string()
# return res
return Str(res)
dmark.Element = Element # monkeypatch
def main():
for arg in sys.argv[1:]:
with open(arg, "r") as fd:
# treat paths as source-relative
os.chdir(os.path.dirname(os.path.abspath(fd.name)))
idkmybffjill = fd.read()
tree = Parser(idkmybffjill).parse()
for item in tree:
item.associate()
# print(tree)
# TODO: not certain about lstrip here
print(WordsWurst.translate(tree).lstrip())
|
# Copyright (c) <2020> <fboucher@redhat.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.
import sys
import pickle
import yaml
import base64
import logging
import argparse
from pathlib import Path
from typing import Union, Any, Dict, List, Literal, TypedDict
from googleapiclient.discovery import build, Resource
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from google.oauth2.credentials import Credentials
from email.mime.text import MIMEText
SCOPES = ["https://www.googleapis.com/auth/gmail.send"]
WORKDIR = Path("~/.sgms/").expanduser()
TOKEN = WORKDIR / Path("token.pickle")
CREDS = WORKDIR / Path("credentials.json")
SendStatus = Literal["SENT", "SKIPPED", "FAILURE"]
def create_workspace(workdir: Path) -> Union[Path, None]:
logging.info("Ensure %s exists" % workdir)
if not workdir.exists():
workdir.mkdir(mode=0o700)
return workdir
else:
return None
def auth(token: Path, credentials: Path) -> Credentials:
creds = None
if token.exists():
logging.info("Reading token file %s" % token)
creds = pickle.loads(token.read_bytes())
if not creds or not creds.valid:
if creds and creds.expired and creds.refresh_token:
logging.info("Refresh token ...")
creds.refresh(Request())
else:
logging.info("Running auth flow using %s" % credentials)
flow = InstalledAppFlow.from_client_secrets_file(str(credentials), SCOPES)
creds = flow.run_local_server(port=0)
logging.info("Writting token file %s" % token)
token.touch(mode=0o600, exist_ok=True)
token.write_bytes(pickle.dumps(creds))
return creds
class Message(TypedDict):
sender: str
to: str
subject: str
body: str
class RawMessage(TypedDict):
raw: str
def load_yaml_message(yaml_data: Dict[str, str], sender: str) -> Message:
return Message(
sender=sender,
to=yaml_data["to"],
subject=yaml_data["subject"],
body=yaml_data["body"],
)
def load_message_from_file(path: Path, sender: str) -> Union[None, Message]:
try:
logging.info("Reading yaml message %s" % path)
return load_yaml_message(
yaml_data=yaml.safe_load(path.read_bytes()), sender=sender
)
except Exception:
logging.exception("Unable to load message from file %s" % path)
return None
def create_message(message: Message) -> RawMessage:
d = MIMEText(message["body"])
d["to"] = message["to"]
d["from"] = message["sender"]
d["subject"] = message["subject"]
return RawMessage(raw=base64.urlsafe_b64encode(d.as_bytes()).decode())
def send_message(service: Resource, message: Message) -> Union[Any, None]:
raw_message = create_message(message)
try:
ret = (
service.users()
.messages()
.send(userId=message["sender"], body=raw_message)
.execute()
)
logging.info("Sent message to %s (Id: %s)" % (message["to"], ret["id"]))
return ret
except Exception:
logging.exception("Unable to send message to %s" + message["to"])
return None
def load_and_send(service: Resource, yaml_message: Path, from_email: str) -> SendStatus:
if yaml_message.suffix in [".yml", ".yaml"]:
if yaml_message.name.startswith("_sent_"):
# Short circuit as already sent
return "SKIPPED"
m = load_message_from_file(Path(yaml_message), from_email)
if m:
status = send_message(service, m)
return "SENT"
else:
logging.info("Skipping %s due to invalid file extension" % yaml_message)
return "FAILURE"
def process_directory(
service: Resource, directory: Path, from_email: str
) -> List[SendStatus]:
ret = []
if directory.exists():
logging.info("Reading %s ..." % directory)
paths = directory.iterdir()
for path in paths:
status = load_and_send(service, path, from_email)
if status == "SENT":
path.rename(path.parent / Path("_sent_" + str(path.name)))
ret.append(status)
else:
logging.info("Unable to find %s" % path)
return ret
def main() -> None:
parser = argparse.ArgumentParser(prog="sgms")
parser.add_argument("--loglevel", help="logging level", default="INFO")
parser.add_argument(
"--from-email", help="The from recipient address", required=False
)
parser.add_argument("--yaml-message", help="The message in YAML", required=False)
parser.add_argument(
"--from-directory",
help="The directory to read YAML message from",
required=False,
)
parser.add_argument(
"--auth-only",
help="Only perform the auth flow to get the token",
action="store_true",
)
args = parser.parse_args()
logging.basicConfig(
level=getattr(logging, args.loglevel.upper()),
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
logging.getLogger("googleapiclient.discovery_cache").setLevel(logging.ERROR)
create_workspace(workdir=WORKDIR)
try:
creds = auth(token=TOKEN, credentials=CREDS)
except Exception:
logging.info("Unable to authenticate")
sys.exit(-1)
if args.auth_only:
sys.exit(0)
if not args.from_email:
logging.info("Please provide --from-email")
service: Resource = build("gmail", "v1", credentials=creds)
if args.yaml_message:
yaml_message = Path(args.yaml_message)
if not yaml_message.is_file():
logging.info("%s is not a file" % yaml_message)
sys.exit(-1)
if not load_and_send(service, yaml_message, args.from_email):
sys.exit(-1)
elif args.from_directory:
directory = Path(args.from_directory).expanduser()
if not directory.is_dir():
logging.info("%s is not a directory" % directory)
sys.exit(-1)
status = process_directory(service, directory, args.from_email)
sent = len(list(filter(lambda s: s == "SENT", status)))
skipped = len(list(filter(lambda s: s == "SKIPPED", status)))
failed = len(list(filter(lambda s: s == "FAILURE", status)))
logging.info("Sent: %s, Skipped: %s, failed: %s" % (sent, skipped, failed))
if failed:
sys.exit(-1)
else:
logging.info(
"No action performed. Did you forget to pass --from-email or --from-directory"
)
|
# RUN: %PYTHON %s 2>&1 | FileCheck %s
# pytype: skip-file
import sys, time
import os
from typing import List
from collections import namedtuple
from collections.abc import Callable
from itertools import chain
from typing import Sequence, Optional
import numpy as np
from mlir.ir import *
from mlir.dialects import arith, builtin, linalg, memref, scf, std
from mlir.dialects.linalg.opdsl.lang import OperandKind
from mlir.execution_engine import *
from mlir.runtime import *
from .transforms import *
f16 = "f16"
f32 = "f32"
f64 = "f64"
numpy_types = {f16: np.float16, f32: np.float32, f64: np.float64}
scalar_types = list(numpy_types.keys())
_MLIR_RUNNER_UTILS_LIB_ENV = "MLIR_RUNNER_UTILS_LIB"
_MLIR_RUNNER_UTILS_LIB_DEFAULT = "libmlir_runner_utils.so"
_MLIR_C_RUNNER_UTILS_LIB_ENV = "MLIR_C_RUNNER_UTILS_LIB"
_MLIR_C_RUNNER_UTILS_LIB_DEFAULT = "libmlir_c_runner_utils.so"
_MLIR_RUNNER_EXTRA_LIBS_ENV = "MLIR_RUNNER_EXTRA_LIBS"
def numpy_type(scalar_type):
numpy_types[scalar_type]
def mlir_type(scalar_type):
if scalar_type == f16:
return F16Type.get()
elif scalar_type == f32:
return F32Type.get()
elif scalar_type == f64:
return F64Type.get()
else:
raise Exception(f"unknown scalar type: {scalar_type}")
def scalar_type(odef, **assignments):
return mlir_type(assignments[odef.type_var.name])
def operand_type(odef, **assignments):
if odef.kind == OperandKind.Scalar:
return scalar_type(odef, **assignments)
if (odef.kind == OperandKind.InputTensor or
odef.kind == OperandKind.OutputTensor):
shape = tuple(assignments[sym.symname] for sym in odef.size_exprs)
return RankedTensorType.get(shape, scalar_type(odef, **assignments))
raise Exception(f"unsupported operand type: {repr(odef)}")
def attach_inplaceable_attributes(func: builtin.FuncOp,
inplaceable: Sequence[Optional[bool]]):
attrs = []
for t, flag in zip(func.type.inputs, inplaceable):
if flag is None:
attrs.append(DictAttr.get({}))
continue
assert RankedTensorType.isinstance(t), "Not a RankedTensorType: {t}"
identity_map = AffineMapAttr.get(
AffineMap.get_identity(RankedTensorType(t).rank))
attrs.append(
DictAttr.get({
"linalg.inplaceable": BoolAttr.get(flag),
"linalg.buffer_layout": identity_map
}))
func.arg_attrs = attrs
def attach_passthrough(func: builtin.FuncOp,
extras: Sequence[Attribute] = [],
avx512: bool = False):
attributes = extras[:]
if avx512:
attributes.append(
ArrayAttr.get(
[StringAttr.get("target-cpu"),
StringAttr.get("skylake-avx512")]))
attributes.append(
ArrayAttr.get(
[StringAttr.get("prefer-vector-width"),
StringAttr.get("512")]))
else:
attributes.append(
ArrayAttr.get(
[StringAttr.get("target-cpu"),
StringAttr.get("broadwell")]))
attributes.append(
ArrayAttr.get(
[StringAttr.get("prefer-vector-width"),
StringAttr.get("256")]))
func.attributes["passthrough"] = ArrayAttr.get(attributes)
def emit_benchmarking_function(name: str,
func: builtin.FuncOp) -> builtin.FuncOp:
"""Produces the benchmarking function.
This function calls the given function `func` as many times as requested by
its last argument.
"""
i64_type = IntegerType.get_signless(64)
nano_time = builtin.FuncOp("nano_time", ([], [i64_type]),
visibility="private")
nano_time.attributes["llvm.emit_c_interface"] = UnitAttr.get()
memref_of_i64_type = MemRefType.get([-1], i64_type)
wrapper = builtin.FuncOp(
# Same signature and an extra buffer of indices to save timings.
name,
(func.arguments.types + [memref_of_i64_type], func.type.results),
visibility="public")
wrapper.attributes["llvm.emit_c_interface"] = UnitAttr.get()
wrapper.arg_attrs = func.arg_attrs + [DictAttr.get()]
num_results = len(func.type.results)
with InsertionPoint(wrapper.add_entry_block()):
timer_buffer = wrapper.arguments[-1]
zero = arith.ConstantOp.create_index(0)
n_iterations = memref.DimOp(IndexType.get(), timer_buffer, zero)
one = arith.ConstantOp.create_index(1)
iter_args = list(wrapper.arguments[-num_results - 1:-1])
loop = scf.ForOp(zero, n_iterations, one, iter_args)
with InsertionPoint(loop.body):
start = std.CallOp(nano_time, [])
call = std.CallOp(
func, wrapper.arguments[:-num_results - 1] + loop.inner_iter_args)
end = std.CallOp(nano_time, [])
time = arith.SubIOp(end, start)
memref.StoreOp(time, timer_buffer, [loop.induction_variable])
scf.YieldOp(list(call.results))
std.ReturnOp(loop)
return wrapper
# JIT compile and return an execution engine that can be invoked.
# Needs to be run under Context.
def compile_to_execution_engine(module,
transform: Callable,
opt_level: int = 3):
transformed_module = transform(module)
shared_libs = [
os.getenv(_MLIR_RUNNER_UTILS_LIB_ENV, _MLIR_RUNNER_UTILS_LIB_DEFAULT),
os.getenv(_MLIR_C_RUNNER_UTILS_LIB_ENV, _MLIR_C_RUNNER_UTILS_LIB_DEFAULT)
]
extra_libs = os.getenv(_MLIR_RUNNER_EXTRA_LIBS_ENV)
if extra_libs is not None:
shared_libs.append(*(str(extra_libs).split(',')))
execution_engine = ExecutionEngine(transformed_module,
opt_level,
shared_libs=shared_libs)
return transformed_module, execution_engine
|
from lib.libs import pykodi
TVSHOW = 'tvshow'
MOVIE = 'movie'
EPISODE = 'episode'
SEASON = 'season'
MOVIESET = 'set'
MUSICVIDEO = 'musicvideo'
ARTIST = 'artist'
ALBUM = 'album'
SONG = 'song'
audiotypes = (ARTIST, ALBUM, SONG)
require_manualid = (MOVIESET, MUSICVIDEO)
PREFERRED_SOURCE_SHARED = {'0': None, '1': 'fanart.tv'}
PREFERRED_SOURCE_MEDIA = {'tvshows': ('thetvdb.com', (TVSHOW, SEASON, EPISODE)),
'movies': ('themoviedb.org', (MOVIE, MOVIESET)),
'music': ('theaudiodb.com', audiotypes),
'musicvideos': ('theaudiodb.com', (MUSICVIDEO,))}
addon = pykodi.get_main_addon()
def get_artinfo(mediatype, arttype):
mediatype, arttype = hack_mediaarttype(mediatype, arttype)
return artinfo[mediatype].get(arttype, default_artinfo)
def hack_mediaarttype(mediatype, arttype):
# Seasons were implemented oddly and need special help
if arttype.startswith('season.'):
return SEASON, arttype.rsplit('.', 1)[1]
else:
return mediatype, arttype
default_artinfo = {'autolimit': 0, 'multiselect': False, 'download': False}
artinfo = {
TVSHOW: {
'poster': {
'autolimit': 1,
'multiselect': False,
'limit_setting': True,
'download': False
},
'keyart': {
'autolimit': 0,
'multiselect': False,
'limit_setting': True,
'download': False
},
'fanart': {
'autolimit': 5,
'multiselect': True,
'limit_setting': True,
'download': False
},
'banner': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearlogo': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'landscape': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'characterart': {
'autolimit': 1,
'multiselect': False,
'limit_setting': True,
'download': False
}
},
MOVIE: {
'poster': {
'autolimit': 1,
'multiselect': False,
'limit_setting': True,
'download': False
},
'keyart': {
'autolimit': 0,
'multiselect': False,
'limit_setting': True,
'download': False
},
'fanart': {
'autolimit': 5,
'multiselect': True,
'limit_setting': True,
'download': False
},
'banner': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearlogo': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'landscape': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'discart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'characterart': {
'autolimit': 1,
'multiselect': False,
'limit_setting': True,
'download': False
},
'animatedposter': {
'autolimit': 0,
'multiselect': False,
'download': True
},
'animatedkeyart': {
'autolimit': 0,
'multiselect': False,
'download': True
},
'animatedfanart': {
'autolimit': 0,
'multiselect': True,
'limit_setting': True,
'download': True
}
},
MOVIESET: {
'poster': {
'autolimit': 1,
'multiselect': False,
'limit_setting': True,
'download': False
},
'keyart': {
'autolimit': 0,
'multiselect': False,
'limit_setting': True,
'download': False
},
'fanart': {
'autolimit': 5,
'multiselect': True,
'limit_setting': True,
'download': False
},
'banner': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearlogo': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'landscape': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'discart': {
'autolimit': 1,
'multiselect': False,
'download': False
}
},
SEASON: {
'poster': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'fanart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'banner': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'landscape': {
'autolimit': 1,
'multiselect': False,
'download': False
}
},
EPISODE: {
'fanart': {
'autolimit': 1,
'multiselect': False,
'download': False
}
},
MUSICVIDEO: {
# album
'poster': { # poster is what Kodi scrapers set and matches other areas of the video library,
# but it should really be 'cover'
'autolimit': 1,
'multiselect': False,
'download': False
},
'discart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'fanart': { # artist or maybe album
'autolimit': 3,
'multiselect': True,
'limit_setting': True,
'download': False
},
# artist
'artistthumb': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'banner': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearlogo': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'landscape': {
'autolimit': 1,
'multiselect': False,
'download': False
}
},
ARTIST: {
'thumb': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'fanart': {
'autolimit': 3,
'multiselect': True,
'limit_setting': True,
'download': False
},
'banner': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearlogo': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'clearart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'landscape': {
'autolimit': 1,
'multiselect': False,
'download': False
}
},
ALBUM: {
'thumb': { # I'd much prefer 'cover', but for now it's thumb just like music video 'poster'
'autolimit': 1,
'multiselect': False,
'download': False
},
# I can imagine 'fanart' images that can be accurately attributed to an album rather than the artist,
# perhaps made from liner notes or press images, but nothing currently available from web services
'discart': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'back': {
'autolimit': 1,
'multiselect': False,
'download': False
},
'spine': {
'autolimit': 1,
'multiselect': False,
'download': False
}
},
SONG: {
'thumb': { # single cover
'autolimit': 1,
'multiselect': False,
'download': False
}
}
}
central_directories = {MOVIESET: False}
togenerate = dict((mediatype, False) for mediatype in artinfo)
preferred = dict((mediatype, None) for mediatype in artinfo)
onlyfs = dict((mediatype, False) for mediatype in artinfo)
othertypes = dict((mediatype, []) for mediatype in artinfo)
download_arttypes = dict((mediatype, []) for mediatype in artinfo)
arttype_settingskeys = [m[0] + '.' + art[0] + ('_limit' if art[1].get('limit_setting') else '')
for m in artinfo.items() for art in m[1].items()]
def disabled(mediatype):
return not any(iter_every_arttype(mediatype)) and not generatethumb(mediatype) and \
not downloadanyartwork(mediatype)
def iter_every_arttype(mediatype):
for arttype, info in artinfo[mediatype].items():
if not info['autolimit']:
continue
yield arttype
if info['autolimit'] > 1:
for num in range(1, info['autolimit']):
yield arttype + str(num)
for arttype in othertypes[mediatype]:
yield arttype
def downloadartwork(mediatype, arttype):
mediatype, arttype = hack_mediaarttype(mediatype, arttype)
arttype, _ = _split_arttype(arttype)
if arttype in download_arttypes.get(mediatype, ()):
return True
info = get_artinfo(mediatype, arttype)
return info['download']
def downloadanyartwork(mediatype):
if download_arttypes.get(mediatype):
return True
info = artinfo.get(mediatype)
if not info:
return False
return any(x for x in info.values() if x['download'])
def _split_arttype(arttype):
basetype = arttype.rstrip('0123456789')
idx = 0 if basetype == arttype else int(arttype.replace(basetype, ''))
return basetype, idx
def generatethumb(mediatype):
return togenerate.get(mediatype, False)
def haspreferred_source(mediatype):
return bool(preferred.get(mediatype))
def ispreferred_source(mediatype, provider):
return provider == preferred.get(mediatype, '')
def only_filesystem(mediatype):
return onlyfs.get(mediatype, False)
def update_settings():
always_multiple_selection = addon.get_setting('always_multiple_selection')
if not always_multiple_selection:
_set_allmulti(False)
for settingid in arttype_settingskeys:
splitsetting = settingid.split('.')
thistype = artinfo[splitsetting[0]][splitsetting[1].split('_')[0]]
try:
thistype['autolimit'], thistype['multiselect'] = _get_autolimit_from_setting(settingid)
except ValueError:
addon.set_setting(settingid, thistype['autolimit'])
addon.set_setting(settingid, thistype['multiselect'])
if always_multiple_selection:
_set_allmulti(True)
for mediatype in artinfo:
olddownload = addon.get_setting(mediatype + '.downloadartwork')
if olddownload != '':
# DEPRECATED: 2018-05-19
if olddownload:
addon.set_setting(mediatype + '.download_arttypes', ', '.join(artinfo[mediatype]))
if mediatype == TVSHOW:
addon.set_setting('season.download_arttypes', ', '.join(artinfo['season']))
addon.set_setting(mediatype + '.downloadartwork', '')
othertypes[mediatype] = [t.strip() for
t in addon.get_setting(mediatype + '.othertypes').split(',')]
if len(othertypes[mediatype]) == 1 and not othertypes[mediatype][0]:
othertypes[mediatype] = []
download_arttypes[mediatype] = [t.strip() for
t in addon.get_setting(mediatype + '.download_arttypes').split(',')]
if len(download_arttypes[mediatype]) == 1 and not download_arttypes[mediatype][0]:
download_arttypes[mediatype] = []
for atype in artinfo[mediatype]:
dl = atype in download_arttypes[mediatype]
artinfo[mediatype][atype]['download'] = dl
if dl:
del download_arttypes[mediatype][download_arttypes[mediatype].index(atype)]
for mediatype in (MOVIESET,):
central_directories[mediatype] = addon.get_setting('centraldir.{0}_enabled'.format(mediatype))
if central_directories[mediatype]:
central_directories[mediatype] = addon.get_setting('centraldir.{0}_dir'.format(mediatype))
for mediatype in (EPISODE, MOVIE, MUSICVIDEO):
togenerate[mediatype] = addon.get_setting('{0}.thumb_generate'.format(mediatype))
old_prefer_tmdb = addon.get_setting('prefer_tmdbartwork')
if old_prefer_tmdb != '':
# DEPRECATED: 2018-05-25
if old_prefer_tmdb:
addon.set_setting('preferredsource_movies', '2')
addon.set_setting('prefer_tmdbartwork', '')
old_only_filesystem = addon.get_setting('only_filesystem')
if old_only_filesystem != '':
# DEPRECATED: 2018-05-26
if old_only_filesystem:
for media in PREFERRED_SOURCE_MEDIA:
addon.set_setting('onlyfilesystem_' + media, True)
addon.set_setting('only_filesystem', '')
for media, config in PREFERRED_SOURCE_MEDIA.items():
result = addon.get_setting('preferredsource_' + media)
downloadconfig = addon.get_setting('download_config_' + media)
if downloadconfig not in ('0', '1', '2'):
# DEPRECATED: default to '2' for now for upgraders, can go back to '0' later
downloadconfig = '2'
addon.set_setting('download_config_' + mediatype, downloadconfig)
for mediatype in config[1]:
if result in ('0', '1', '2'):
preferred[mediatype] = PREFERRED_SOURCE_SHARED[result] if \
result in PREFERRED_SOURCE_SHARED else PREFERRED_SOURCE_MEDIA.get(media, (None,))[0]
else:
preferred[mediatype] = None
addon.set_setting('preferredsource_' + media, '0')
onlyfs[mediatype] = addon.get_setting('onlyfs_' + media)
if downloadconfig == '0': # None
download_arttypes[mediatype] = []
for atype in artinfo[mediatype].values():
atype['download'] = False
elif downloadconfig == '1': # all configured from web and local
download_arttypes[mediatype] = list(othertypes[mediatype])
for atype in artinfo[mediatype].values():
atype['download'] = atype['autolimit'] > 0
# Kodi doesn't cache gifs, so always download animated artwork
for arttype, artconfig in artinfo[mediatype].items():
if arttype.startswith('animated'):
artconfig['download'] = True
def _get_autolimit_from_setting(settingid):
result = addon.get_setting(settingid)
if settingid.endswith('_limit'):
result = int(result)
return result, result > 1
return (1 if result else 0), False
def _set_allmulti(always_multi):
for typeinfo in artinfo.values():
for arttypeinfo in typeinfo.values():
arttypeinfo['multiselect'] = always_multi
update_settings()
|
import requests
import pickle
import os
import scipy.io.netcdf as netcdf
import numpy as np
import torch
import argparse
import sys
def from_url(url, name, username = None, password = None):
path = url.split("/")[-1]
if not os.path.exists(path):
r = requests.get(url, auth=(username, password), stream=True)
size = int(r.headers["Content-Length"])
r.raise_for_status()
dl = 0
with open(path, 'wb') as handle:
for block in r.iter_content(4096):
dl += len(block)
handle.write(block)
done = int(50 * dl / size)
sys.stdout.write("\r[%s%s]" % ('=' * done, ' ' * (50-done)) )
sys.stdout.flush()
return path
def decompress(path):
if path.endswith(".nc"):
return path
elif path.endswith(".bz2"):
import bz2, shutil
newpath = ".".join(path.split(".")[:-1])
if not os.path.exists(newpath):
with bz2.BZ2File(path, "r") as source:
with open(newpath, "wb") as target:
shutil.copyfileobj(source, target)
return newpath
else:
raise ValueError("Compression scheme not supported for downloaded file {}")
def process(path, variable, name, flip=False):
with netcdf.netcdf_file(os.path.join(path), "r") as file:
var = file.variables[variable]
offset = var.add_offset
scale = var.scale_factor
missing = var._get_missing_value()
data = torch.Tensor(var.data.byteswap().view("<i2")).to(torch.int16).squeeze()
if flip:
data = data.flip(0)
raw = data.float() * scale + offset
if not os.path.exists("data"):
os.mkdir("data")
picklepath = os.path.join("data", name + ".pickle")
with open(picklepath, "wb") as f:
pickle.dump(raw, f)
print("Pickled file {} with offset {} and scale {}. Range is {} to {}. Shape is {}".format(picklepath, offset, scale, raw.min(), raw.max(), raw.shape))
return picklepath
def download(url, name, variable, username = None, password = None, flip=False):
print("downloading from url {}".format(url))
path = from_url(url, name, username, password)
print("done downloading. decompressing file.")
decompressed = decompress(path)
os.remove(path)
print("done decompressing. processing")
filepath = process(decompressed, variable, name, flip=flip)
print("done processing. file saved to {}".format(filepath))
os.remove(decompressed)
return filepath
parser = argparse.ArgumentParser(description="download and process netcdf files from NASA data repositories like PO.DAAC")
parser.add_argument('url', type=str, help='url for raw data file (supported formats: netCDF')
parser.add_argument('name', type=str, help='name of product')
parser.add_argument('variable', type=str, help='variable in netcdf file to use')
parser.add_argument('-u', type=str, dest="credentials", default="", help='username and password for website')
parser.add_argument('--filename', type=str, dest="credentials", default="", help='username and password for website')
parser.add_argument('--flip', action='store_true', default=False, help='flip image vertically')
args = parser.parse_args()
if args.credentials == "":
filepath = download(args.url, args.name, args.variable, flip = args.flip)
else:
filepath = download(args.url, args.name, args.variable, username = args.credentials.split(":")[0], password = args.credentials.split(":")[1], flip = args.flip)
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
tkRAD - tkinter Rapid Application Development library
(c) 2013+ Raphaël SEBAN <motus@laposte.net>
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/
"""
|
# unicorn-analytics is a python module.
|
import glob
import os
import zipfile
import nibabel as nib
import numpy as np
import traceback
def convert_mri_unlabeled():
source_path = "/mnt/projects/ukbiobank/original/imaging/brain_mri/"
destination_path = "/mnt/projects/ukbiobank/derived/imaging/brain_mri/"
t1_zip_files = sorted(glob.glob(source_path + "T1_structural_brain_mri/archive/**/" + "*.zip", recursive=True))
t2_flair_zip_files = sorted(
glob.glob(source_path + "T2_FLAIR_structural_brain_mri/archive/**/" + "*.zip", recursive=True))
t2_flair_patient_ids = dict()
for filename in t2_flair_zip_files:
id = os.path.basename(filename).split("_")[0]
t2_flair_patient_ids[id] = filename
del t2_flair_zip_files
count = 0
for t1_zip_file in t1_zip_files:
subject_id = os.path.basename(t1_zip_file).split("_")[0]
if subject_id in t2_flair_patient_ids: # ensure we have a scan in t2 too
count += 1
try:
t1_archive = zipfile.ZipFile(t1_zip_file, 'r')
t1_extracted_path = t1_archive.extract('T1/T1.nii.gz')
nif_file = nib.load(t1_extracted_path)
t1_scan = nif_file.get_fdata()
t1_extracted_path = t1_archive.extract('T1/T1_brain_mask.nii.gz')
nif_file = nib.load(t1_extracted_path)
t1_mask = np.asarray(nif_file.get_fdata(), dtype=np.bool)
t1_scan[~t1_mask] = t1_scan.min()
np.save(os.path.join(destination_path, "T1", str(subject_id) + ".npy"), t1_scan)
t2_archive = zipfile.ZipFile(t2_flair_patient_ids[subject_id], 'r')
t2_extracted_path = t2_archive.extract('T2_FLAIR/T2_FLAIR.nii.gz')
nif_file = nib.load(t2_extracted_path)
t2_scan = nif_file.get_fdata()
t2_scan[~t1_mask] = t2_scan.min()
np.save(os.path.join(destination_path, "T2_FLAIR", str(subject_id) + ".npy"), t2_scan)
del t1_scan, t2_scan
except Exception:
print(t1_zip_file)
print(traceback.format_exc())
if count % 100 == 0:
print("Processed " + str(count) + " scans so far.")
def convert_mri_masks(type='fast'):
"""
:param type: can be "fast" or "first"
"""
source_path = "/mnt/projects/ukbiobank/original/imaging/brain_mri/T1_structural_brain_mri/unzipped/"
destination_path = "/mnt/projects/ukbiobank/derived/imaging/brain_mri/"
filename_list = sorted(glob.glob(destination_path + "T1/**/" + "*.npy", recursive=True))
count = 0
for filename in filename_list:
id = os.path.basename(filename).split(".")[0]
count += 1
if type == 'fast':
mask = nib.load(source_path + str(id) + '_20252_2_0/T1/T1_fast/T1_brain_seg.nii.gz').get_data()
np.save(os.path.join(destination_path, "fast_masks", str(id) + ".npy"), mask)
else:
mask = nib.load(
source_path + str(id) + '_20252_2_0/T1/T1_first/T1_first_all_fast_firstseg.nii.gz').get_data()
np.save(os.path.join(destination_path, "first_masks", str(id) + ".npy"), mask)
if count % 100 == 0:
print("Processed " + str(count) + " masks so far.")
if __name__ == "__main__":
# convert_mri_unlabeled()
convert_mri_masks()
|
from django.urls import path
from .views import index, store, update
urlpatterns = [
path('tallas/', index, name='sizes.index'),
path('crear-nueva-talla/', store, name='sizes.store'),
path('actualizar-talla/<id>/', update, name='sizes.update'),
]
|
import random
nouns = ["дождь",'снег','солнце','туча','облоко','земля','небо','дерево','дорога','звук','свет','ветер',]
pril = ['красивый', 'вечерний', 'лазурный', 'морской', 'тёплый', 'нежный', 'суровый', 'сильный' ]
timed = "Сегодня Завтра Тогда Всегда Иногда".split()
nar = "медленно быстро спокойно яростно небрежно аккуратно".split()
verbs = "идёт ползёт летит бежит стучит поёт сидит грузит течёт".split()
def genstr0(end='.'):
s = ''
s += random.choice(timed) + ' '
s += random.choice(pril) + ' '
s += random.choice(nouns) + ' '
if random.randint(0,1) == 1:
s += random.choice(nar) + ' '
s += random.choice(verbs) + end
return s
random.seed()
def genpoem(n=4):
s = ''
for i in range(n):
s += genstr0(',\n')
s += genstr0('.')
return s
print(genpoem())
|
#!/usr/bin/python
import xml.dom.minidom
import getopt
import sys
##########################
# Important: This script is to be run from trunk/moon/test
# This file converts a Moonlight DRTList.xml to the MS DRTList.txt
##########################
class drtTest:
def __init__(self,id):
self.id = id
self.feature = 'unknown'
self.owner = 'moonlight'
def _tif_or_png(self):
filename = self.master10.split('/')[-1] # mytest.xaml
filename = filename.split('.')[0] # mytest
if self.feature == "Animation":
filename += ".tif"
else:
filename += ".png"
self.master10 = "../harness/masters/%s" % filename
def toBadXML(self):
self._tif_or_png()
x = '\t<Test id="%s">\n' % (self.id)
x += '\t\t<inputFile="%s"/>\n' % self.input
x += '\t\t<masterFile10="%s"/>\n' % self.master10
if self.master11 != None and self.master11 != '':
x += '\t\t<masterFile11="%s"/>\n' % self.master11
x += '\t\t<owner="%s"/>\n' % self.owner
x += '\t\t<featureName="%s"/>\n' % self.feature
x += '\t</Test>'
return x
def usage():
print "\nUsage: convert-drt.py [--missing]\n"
print " --missing Creates a drtlist.txt of only test with missing master files"
def main():
# saveMasters.py --missing, --regen
regen = False
missing = False
try:
shortopts = 'hm'
longopts = ['help','missing',]
opts, args = getopt.getopt(sys.argv[1:],shortopts, longopts)
except getopt.GetoptError, err:
print str(err)
sys.exit(1)
for o, a in opts:
if o in ('-h','--help'):
usage()
return
if o in ('-m','--missing'):
missing = True
doc = xml.dom.minidom.parse("xaml/drtlist.xml")
drtnode = doc.childNodes[0]
print "<DRTList>"
for testnode in drtnode.childNodes:
if ((testnode.localName is not None) and (testnode.localName != "")):
#print'\t<Test id="%s">' % (testnode.getAttribute("id"))
#if os.path.exists():
test = drtTest(testnode.getAttribute("id"))
test.input = testnode.getAttribute("inputFile")
test.master10 = testnode.getAttribute('masterFile10')
test.master11 = testnode.getAttribute('masterFile11')
if testnode.getAttribute('inputFile').find('animation') != -1:
test.feature = "Animation"
elif testnode.getAttribute('featureName') != '':
test.feature = testnode.getAttribute('featureName')
#print '\t\t<featureName="%s"/>' % feature
# Added these attributes if non-existent
if testnode.getAttribute('owner') != '':
test.owner = testnode.getAttribute('owner')
print test.toBadXML()
#print "\t</Test>"
print "</DRTList>"
if __name__ == '__main__':
main()
|
#!/usr/bin/python3
import os
import json
import sys
import subprocess
from modules.lib.colors import colors
def pyrecon_masscan(masscan_directory, output_directory, masscan_rate):
target_subnet_file = os.path.join(output_directory, 'subnets.txt')
masscan_json = os.path.join(masscan_directory, 'masscan.json')
if not os.path.isfile(target_subnet_file) or os.stat(target_subnet_file).st_size == 0:
raise FileNotFoundError
if os.path.isfile(masscan_json) and os.stat(masscan_json).st_size > 0:
raise FileExistsError
with open(target_subnet_file, 'r') as target_subnet_file_readlines:
cidrs = target_subnet_file_readlines.readlines()
number_cidr_nets = len(cidrs)
if number_cidr_nets > 1:
print('{1}[*] Running masscan on {2} hosts/CIDR nets{0}:'.format(colors.RESET, colors.YELLOW, number_cidr_nets))
for cidr in cidrs:
print('\t{0}'.format(cidr.rstrip('\n')))
print('{1}[*] Rate set to{0}:'.format(colors.RESET, colors.YELLOW))
print('\t{0}'.format(masscan_rate))
subprocess.call(["masscan", "-oJ" , masscan_json, "--rate", str(masscan_rate), "-iL", target_subnet_file, "-p1-65535", "--interactive"])
elif number_cidr_nets == 1:
with open(target_subnet_file) as target_subnet_file_read:
cidr = target_subnet_file_read.read()
print('{1}[*] Running masscan on {2} hosts/CIDR nets{0}:'.format(colors.RESET, colors.YELLOW, number_cidr_nets))
print('\t{0}'.format(cidr))
print(colors.YELLOW + '[*] Rate set to:' + colors.RESET)
print('\t{0}'.format(masscan_rate))
subprocess.call(["masscan", "-oJ" , masscan_json, "--rate", str(masscan_rate), "-iL", target_subnet_file, "-p1-65535", "--interactive"])
print('\n{1}[+] Done. Masscan JSON output saved to {2}{0}'.format(colors.RESET, colors.GREEN, masscan_json) + colors.RESET)
if os.stat(masscan_json).st_size != 0:
with open(masscan_json, 'r') as broken_json:
"""
masscan json output contains a comma in the last value
this causes Python's json to break when attempting to load json from the file
this can be fixed by finding the last value and removing the comma with string manipulation
"""
# Convert masscan JSON output to a list
broken_json_lines = list(broken_json)
# Broken line is the second to last value
last_value = broken_json_lines[-2]
# Get index value of last occurence of a comma in broken line
last_comma_index = last_value.rfind(',')
# Create string to hold value of broken line without comma
new_last_value = last_value[:last_comma_index] + last_value[last_comma_index + 1:]
# Write everything except the last 2 lines from old json to new json file
with open(masscan_json, 'w') as old_json:
old_json.writelines(broken_json_lines[:-2])
# Append new json file with the fixed last value and closing bracket
with open(masscan_json, 'a') as new_json:
new_json.write('{0}]\n'.format(new_last_value))
with open(masscan_json, 'r') as masscan_json:
masscan_json = json.load(masscan_json)
open_port_list = []
for item in range(len(masscan_json)):
port = masscan_json[item]["ports"][0]["port"]
if port not in open_port_list:
open_port_list.append(port)
# create a list of open ports with new line characters after each port
# this is used to create a text file of line seperated ports
open_port_list = [str(port) + "\n" for port in sorted(open_port_list)]
with open(os.path.join(output_directory, 'external_recon/portscan/open_ports.txt'), 'a') as open_ports_file:
# create file with a new line seperated list of ports
open_ports_file.writelines(open_port_list)
print('{1}[+] Line seperated list of open ports saved to {2}{0}\n'.format(colors.RESET, colors.GREEN, open_ports_file.name) + colors.RESET)
else:
print('{1}[!] Masscan found no open ports. Skipping Nmap...{0}\n'.format(colors.RESET, colors.RED))
"""
masscan -oJ <OUTFILE> -p1-65535 --rate <rate> -iL <ALL_LIVE_IPS_FILE>
-oJ <OUTFILE>
Sets output format to JSON
-iL <ALL_LIVE_IPS_FILE>
Takes new line seperated file as input
"""
|
# -*- encoding: utf-8 -*-
#############################
import sys, os
from shutil import *
# import qdarkstyle
from funciones import *
###############
import hashlib
################
from PyQt5.QtWidgets import *
##############################
from PyQt5.QtGui import *
############################
from PyQt5.QtCore import *
############################
class Registrar(QMainWindow):
def __init__(self):
super(Registrar, self).__init__()
self.setWindowTitle(' Registar Clientes !!!!')
self.setWindowIcon(QIcon('img/gato.jpg'))
self.resize(800, 620)
self.setFixedSize(800, 620)
flags = Qt.MSWindowsFixedSizeDialogHint
flags2 = Qt.X11BypassWindowManagerHint
flags3 = Qt.FramelessWindowHint
flags4 = Qt.WindowTitleHint
flags5 = Qt.WindowSystemMenuHint
flags6 = Qt.WindowMinimizeButtonHint
flags7 = Qt.WindowMaximizeButtonHint
flags8 = Qt.WindowCloseButtonHint
flags9 = Qt.WindowContextHelpButtonHint
flags10 = Qt.WindowShadeButtonHint
flags11 = Qt.WindowStaysOnTopHint
flags12 = Qt.WindowStaysOnBottomHint
flags13 = Qt.CustomizeWindowHint
f = Qt.X11BypassWindowManagerHint
a = Qt.SplashScreen
# self.setContentsMargins(QMargins())
self.setWindowFlags(Qt.FramelessWindowHint)
# self.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
# self.setContentsMargins(QMargins())
########################################
self.grilla = QWidget()
self.grilla.setObjectName('gr')
self.setCentralWidget(self.grilla)
#########################################
# self.centrar()
#########################################
self.msg = QLabel(self.grilla)
self.msg.setObjectName('c')
self.msg.setText('')
self.msg.setFrameShape(QFrame.Box)
self.msg.setFrameShadow(QFrame.Sunken)
self.msg.setAlignment(Qt.AlignCenter)
self.msg.setGeometry(140, 30, 611, 31)
self.gr = QWidget(self.grilla)
self.gr.setGeometry(QRect(40, 65, 711, 271))
self.grid = QGridLayout(self.gr)
self.grid.setContentsMargins(0, 0, 0, 0)
####################################
self.a = QLabel(self.gr)
self.a.setText('Nombre:')
self.a.setObjectName("a")
self.grid.addWidget(self.a, 0, 0, 1, 1)
self.g = QLabel(self.gr)
self.g.setText('Apellido:')
self.g.setObjectName("a")
self.grid.addWidget(self.g, 1, 0, 1, 1)
self.d = QLabel(self.gr)
self.d.setText('Correo :')
self.d.setObjectName("a")
self.grid.addWidget(self.d, 2, 0, 1, 1)
self.e = QLabel(self.gr)
self.e.setText('Funcion:')
self.e.setObjectName("a")
self.grid.addWidget(self.e, 3, 0, 1, 1)
self.h = QLabel(self.gr)
self.h.setText('Fecha reg:')
self.h.setObjectName("a")
self.grid.addWidget(self.h, 4, 0, 1, 1)
self.f = QLabel(self.gr)
self.f.setText('Tel Celular:')
self.f.setObjectName("a")
self.grid.addWidget(self.f, 0, 3, 1, 1)
self.c = QLabel(self.gr)
self.c.setText('Tel Trabajo:')
self.c.setObjectName("a")
self.grid.addWidget(self.c, 1, 3, 1, 1)
self.b = QLabel(self.gr)
self.b.setText('Tel Casa:')
self.b.setObjectName("a")
self.grid.addWidget(self.b, 2, 3, 1, 1)
self.j = QLabel(self.gr)
self.j.setText('Facebook:')
self.j.setObjectName("a")
self.grid.addWidget(self.j, 3, 3, 1, 1)
self.k = QLabel(self.gr)
self.k.setText('Twitter:')
self.k.setObjectName("a")
self.grid.addWidget(self.k, 4, 3, 1, 1)
self.i = QLabel(self.gr)
self.i.setText('WhatsApp:')
self.i.setObjectName("a")
self.grid.addWidget(self.i, 5, 3, 1, 1)
#################################################
self.nom = QLineEdit(self.gr)
self.nom.setPlaceholderText('Nom')
self.nom.setObjectName('f')
self.grid.addWidget(self.nom, 0, 2, 1, 1)
self.ap = QLineEdit(self.gr)
self.ap.setPlaceholderText('Ape')
self.ap.setObjectName('f')
self.grid.addWidget(self.ap, 1, 2, 1, 1)
self.cor= QLineEdit(self.gr)
self.cor.setPlaceholderText('Corr')
self.cor.setObjectName('f')
self.grid.addWidget(self.cor, 2, 2, 1, 1)
self.fun = QLineEdit(self.gr)
self.fun.setPlaceholderText('Fun')
self.fun.setObjectName('f')
self.grid.addWidget(self.fun, 3, 2, 1, 1)
self.ch = QDateEdit(self.gr)
self.ch.setDate(QDate.currentDate())
# self.ch.setFrame(True)
self.ch.setAlignment(Qt.AlignCenter)
self.ch.setCalendarPopup(True)
self.ch.setObjectName("dateEdit")
self.grid.addWidget(self.ch, 4, 2, 1, 1)
self.telm = QLineEdit(self.gr)
self.telm.setPlaceholderText('Cel')
self.telm.setObjectName('f')
self.grid.addWidget(self.telm, 0, 4, 1, 1)
self.telt = QLineEdit(self.gr)
self.telt.setPlaceholderText('Trabj')
self.telt.setObjectName('f')
self.grid.addWidget(self.telt, 1, 4, 1, 1)
self.telc = QLineEdit(self.gr)
self.telc.setPlaceholderText('Casa')
self.telc.setObjectName('f')
self.grid.addWidget(self.telc, 2, 4, 1, 1)
self.fac = QLineEdit(self.gr)
self.fac.setPlaceholderText('Fac')
self.fac.setObjectName('f')
self.grid.addWidget(self.fac, 3, 4, 1, 1)
self.tw = QLineEdit(self.gr)
self.tw.setPlaceholderText('Twitter')
self.tw.setObjectName('f')
self.grid.addWidget(self.tw, 4, 4, 1, 1)
self.cd = QCheckBox(self.gr)
self.cd.setObjectName('f')
self.grid.addWidget(self.cd, 5, 4, 1, 1)
###################################################
self.gri = QWidget(self.grilla)
self.gri.setGeometry(QRect(40, 345, 711, 194))
self.gridd = QGridLayout(self.gri)
self.gridd.setContentsMargins(0, 0, 0, 0)
self.lbl = QLabel(self.gri)
self.lbl.setText('Observ:')
self.lbl.setObjectName("a")
self.gridd.addWidget(self.lbl, 0, 0, 1, 1)
self.lbla = QLabel(self.gri)
self.lbla.setText('Foto:')
self.lbla.setObjectName("a")
self.gridd.addWidget(self.lbla, 0, 2, 1, 1)
self.ed = QTextEdit(self.gri)
self.ed.setObjectName("textEdit")
self.gridd.addWidget(self.ed, 0, 1, 2, 1)
self.mg = QGraphicsView(self.gri)
self.mg.setObjectName("graphicsView")
self.gridd.addWidget(self.mg, 0, 3, 2, 1)
##################################################
self.btn = QPushButton(self.grilla)
self.btn.setObjectName('c')
self.btn.setCursor(Qt.OpenHandCursor)
self.btn.setGeometry(QRect(204, 555, 181, 41))
self.btn.setAutoDefault(True)
self.btn.setText('Registrar')
self.btn2 = QPushButton(self.grilla)
self.btn2.setObjectName('d')
self.btn2.setCursor(Qt.OpenHandCursor)
self.btn2.setGeometry(QRect(400, 555, 181, 41))
self.btn2.setAutoDefault(True)
self.btn2.setText('Salir')
self.btn3 = QPushButton(self.gr)
self.btn3.setObjectName('d')
self.btn3.setCursor(Qt.OpenHandCursor)
self.grid.addWidget(self.btn3, 5, 0, 1, 3)
self.btn3.setAutoDefault(True)
self.btn3.setText('Subir foto')
self.btn4 = QPushButton(self.grilla)
self.btn4.setObjectName('d')
self.btn4.setCursor(Qt.OpenHandCursor)
self.btn4.setGeometry(QRect(750, 5, 18, 30))
self.btn4.setText('-')
self.btn3.clicked.connect(self.abrir)
self.btn2.clicked.connect(self.salir)
self.btn4.clicked.connect(self.min)
# self.btn3.clicked['bool'].connect(lambda state)
########################################################
def abrir(self):
ruta = 'fotos'
fichero = QFileDialog.getOpenFileName(self, "Subir archivo",
QDir.currentPath())
destino = os.path.split(fichero[0])[-1]
# print(destino)
img = QImage(fichero[0])
folder = os.path.join(os.getcwd(), ruta)
if not os.path.exists(folder):
os.makedirs(folder)
directorio = os.path.join(folder, destino)
# print(directorio)
response = img.save(directorio)
if response:
self.msg.setText("Imagen subida exitosamente")
else:
self.msg.setText("Solo imagenes")
################################################
def salir(self):
sys.exit()
######################################################
def mouseMoveEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.move(self.pos() + event.globalPos() - self.dragPos)
self.dragPos = event.globalPos()
event.accept()
####################################################
def mousePressEvent(self, event):
if event.buttons() == Qt.LeftButton:
self.dragPos = event.globalPos()
event.accept()
#####################################################
def min(self):
self.setWindowState(Qt.WindowMinimized)
# sender = self.sender()
# self.statusBar().showMessage(msg)
########################################################
###################################################
if __name__ == "__main__":
app = QApplication(sys.argv)
# with open('temas/tm.qss', 'r') as e:
# estilo = e.read()
# app.setStyleSheet(estilo)
ap = Registrar()
ap.show()
sys.exit(app.exec_())
######################################################
|
from __future__ import division
import collections
import mxnet as mx
import numpy as np
from numpy.linalg import norm
import mxnet.ndarray as nd
from ..model_zoo import model_zoo
from ..utils import face_align
__all__ = ['FaceAnalysis', 'Face']
Face = collections.namedtuple('Face', [
'bbox', 'landmark', 'det_score', 'embedding', 'gender', 'age',
'embedding_norm', 'normed_embedding'
])
Face.__new__.__defaults__ = (None, ) * len(Face._fields)
class FaceAnalysis:
def __init__(self,
det_name='retinaface_mnet025_v2',
rec_name='arcface_r100_v1',
ga_name='genderage_v1'):
assert det_name is not None
self.det_model = model_zoo.get_model(det_name)
if rec_name is not None:
self.rec_model = model_zoo.get_model(rec_name)
else:
self.rec_model = None
if ga_name is not None:
self.ga_model = model_zoo.get_model(ga_name)
else:
self.ga_model = None
def prepare(self, ctx_id, nms=0.4):
self.det_model.prepare(ctx_id, nms)
if self.rec_model is not None:
self.rec_model.prepare(ctx_id)
if self.ga_model is not None:
self.ga_model.prepare(ctx_id)
def get(self, img, det_thresh=0.8, det_scale=1.0, max_num=0):
bboxes, landmarks = self.det_model.detect(img,
threshold=det_thresh,
scale=det_scale)
if bboxes.shape[0] == 0:
return []
if max_num > 0 and bboxes.shape[0] > max_num:
area = (bboxes[:, 2] - bboxes[:, 0]) * (bboxes[:, 3] -
bboxes[:, 1])
img_center = img.shape[0] // 2, img.shape[1] // 2
offsets = np.vstack([
(bboxes[:, 0] + bboxes[:, 2]) / 2 - img_center[1],
(bboxes[:, 1] + bboxes[:, 3]) / 2 - img_center[0]
])
offset_dist_squared = np.sum(np.power(offsets, 2.0), 0)
values = area - offset_dist_squared * 2.0 # some extra weight on the centering
bindex = np.argsort(
values)[::-1] # some extra weight on the centering
bindex = bindex[0:max_num]
bboxes = bboxes[bindex, :]
landmarks = landmarks[bindex, :]
ret = []
for i in range(bboxes.shape[0]):
bbox = bboxes[i, 0:4]
det_score = bboxes[i, 4]
landmark = landmarks[i]
_img = face_align.norm_crop(img, landmark=landmark)
embedding = None
embedding_norm = None
normed_embedding = None
gender = None
age = None
if self.rec_model is not None:
embedding = self.rec_model.get_embedding(_img).flatten()
embedding_norm = norm(embedding)
normed_embedding = embedding / embedding_norm
if self.ga_model is not None:
gender, age = self.ga_model.get(_img)
face = Face(bbox=bbox,
landmark=landmark,
det_score=det_score,
embedding=embedding,
gender=gender,
age=age,
normed_embedding=normed_embedding,
embedding_norm=embedding_norm)
ret.append(face)
return ret
|
from . import card_combos
from . import card_info_lut_builder
from . import game_utility
from . import preflop
from . import runner
|
#!/usr/bin/env
# -*- coding: utf-8 -*-
"""
Copyright 2017-2018 Jagoba Pérez-Gómez
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 src.domain.exception import ProjectDoesNotExist
from src.infrastructure.query_bus import QueryHandler
class GetKeywordSummaryQuery(object):
def __init__(self, project_id):
self.project_id = project_id
class GetKeywordSummary(QueryHandler):
SERVICE_KEYWORDS = [
'79fd76ae-67c4-4d43-bbfe-19a710af1adf',
'ab637ef8-419d-46c4-b479-1f682df18b05'
]
PRICE_KEYWORDS = [
'61248ae5-e624-4cfb-a304-2b8678d5922c'
]
LOCATION_KEYWORDS = [
'b7c99e94-3dca-43de-b08a-b465b9c31112',
'9ab33c8b-98b0-4c91-b2f5-040c69771743'
]
FOOD_KEYWORDS = [
'8880f641-d560-41d8-a8bd-64951b249b04',
'25699329-e8a9-4c43-9ce3-4df36224858e',
'eb2db5f4-8847-45ec-919f-d900a3e26d33',
'f4c866cf-e092-427d-8604-dfb5d844c2f5',
'721fb226-9169-46db-9cdb-97467111fa65',
'ca1b2639-c543-4d1a-a406-807992c2592e',
'69353b54-a237-4a27-bb07-aed371d325d3',
'6414509f-6cad-4804-a246-d2aafa8e59d7',
'b4f388ce-2439-41e9-937e-d1ed505872fc'
]
def __init__(self):
self.project_repository = None
self.synonym_repository = None
self._service_score = 0
self._price_score = 0
self._location_score = 0
self._food_score = 0
self._total_score = 0
def invoke(self, query):
project = self.__check_project_exists(query.project_id)
self.__gather_keyword_scores(project)
return self.__transform_summary_data()
def __check_project_exists(self, project_id):
project = self.project_repository.get_of_id(project_id)
if project is None:
raise ProjectDoesNotExist()
return project
def __gather_keyword_scores(self, project):
keypoints = project.get_analysis().get_key_points()
self._service_score = self.__gather_scores(
GetKeywordSummary.SERVICE_KEYWORDS, keypoints
)
self._food_score = self.__gather_scores(
GetKeywordSummary.FOOD_KEYWORDS, keypoints
)
self._price_score = self.__gather_scores(
GetKeywordSummary.PRICE_KEYWORDS, keypoints
)
self._location_score = self.__gather_scores(
GetKeywordSummary.LOCATION_KEYWORDS, keypoints
)
self.__calculate_total()
def __calculate_total(self):
score = 0
items = 0
if self._service_score:
score = self._service_score
items += 1
if self._food_score:
score = score + self._food_score
items += 1
if self._location_score:
score = score + self._location_score
items += 1
if self._price_score:
score = score + self._price_score
items += 1
if items == 0:
self._total_score = None
else:
self._total_score = round(score / items, 3)
def __gather_scores(self, synonym_ids, project_keywords):
score = None
for synonym_id in synonym_ids:
keywords = self.synonym_repository.get_synonym_group(
synonym_id, 'es'
)
for project_keyword in project_keywords:
is_keyword = self.__is_keyword_in_synonym_group(
project_keyword, keywords
)
if not is_keyword:
continue
if score is None:
score = project_keyword.karma
else:
score = (score + project_keyword.karma) / 2
return score
@staticmethod
def __is_keyword_in_synonym_group(project_keyword, keywords):
for keyword in keywords:
# Not all words are translated
if keyword is None:
continue
if keyword.word == project_keyword.identifier:
return True
return False
def __transform_summary_data(self):
return {
'service': self._service_score,
'price': self._price_score,
'location': self._location_score,
'food': self._food_score,
'total': self._total_score
}
|
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt
import random
# GPU if available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
class ServerQueue:
"""
The server queuing task as described in Example 10.2.
"""
def __init__(self, num_servers, customer_rewards, free_prob):
""" Initializes the environment.
@type num_servers: int
The number of servers.
@type customer_rewards: list[float]
A list of the rewards of each customer
if they are given access to a server.
The reward paid by each customer is also
equal to their priority.
@type free_prob: float
The probability of a busy server freeing up at each
time step.
"""
self.num_servers = num_servers
self.customer_rewards = customer_rewards
self.free_prob = free_prob
def getInitialState(self):
"""
Returns the initial state.
@rtype: tuple[int]
A tuple (free_servers, customer) representing the initial state.
"""
return self.num_servers, random.randint(0, len(self.customer_rewards) - 1)
def getNextState(self, state, action):
""" The state transition function
The action is represented as 0 or 1, representing
whether to reject or accept the current customer.
@type state: tuple[int]
A tuple (num_free_servers, customer) representing the current state.
@type action: int
An integer 0, 1 representing the action.
@rtype: tuple(tuple(float))
A tuple (new_free_servers, next_customer) representing the new state
and the reward received.
"""
free_servers, customer = state
busy_servers = self.num_servers - free_servers
servers_freed = 0
for server in range(busy_servers):
if random.uniform(0, 1) < self.free_prob:
servers_freed += 1
free_servers += servers_freed
next_customer = random.randint(0, len(self.customer_rewards) - 1)
if free_servers == 0:
return (0, next_customer), 0
if action:
return (free_servers - 1, next_customer), self.customer_rewards[customer]
else:
return (free_servers, next_customer), 0
class Agent:
""" Agent object that uses differential semi-gradient SARSA to find optimal
policy.
"""
def __init__(self, server, NN, optimizer, criterion):
""" Initializes the agent.
@type server: ServerQueue
Server queue environment.
@type NN: NeuralNet
Neural network for computing the state-action values
@type optimizer: optimizer
Optimizer from the torch.optim module.
@type scheduler: lr_scheduler
Learning rate scheduler from the torch.optim module.
@type criterion: criterion
Criterion from the torch.nn module.
"""
self.server = server
self.NN = NN
self.op = optimizer
self.criterion = criterion
# Constructs a one-hot vector for each state.
num_servers = server.num_servers
num_customers = len(server.customer_rewards)
self.state_to_basis = {}
for free_servers in range(num_servers + 1):
for customer in range(num_customers):
basis = torch.zeros((num_servers + 1) * num_customers).to(device)
basis[free_servers * num_customers + customer] = 1.0
self.state_to_basis[(free_servers, customer)] = basis
def chooseAction(self, state, epsilon):
""" Chooses action according to an epsilon greedy policy.
@type state: tuple[int]
A tuple (free_servers, customer) representing the current state.
@type epsilon: float
Exploration probability.
@rtype: int
An integer 0, 1 representing the action.
"""
if random.uniform(0, 1) < epsilon:
return random.randint(0, 1)
else:
with torch.no_grad():
_, action = torch.max(self.NN(self.state_to_basis[state]), 0)
return int(action.item())
def oneStep(self, state, action, target):
""" Performs one training step on observed transition.
@type state: tuple[int]
A tuple (free_servers, customer) denoting the state.
@type action: int
An integer 0, 1 representing the action.
@type target: float
The target action value.
"""
pred = self.NN(self.state_to_basis[state])
with torch.no_grad():
pred_target = torch.clone(pred)
pred_target[action] = target
loss = self.criterion(pred, pred_target)
loss.backward()
self.op.step()
self.op.zero_grad()
def train(self, steps, epsilon, beta):
""" Trains the agent using on-policy differential semi-gradient SARSA.
@type steps: int
The number of steps to train.
@type epsilon: float
Exploration action probability.
@type beta: float
The step size in updating average reward.
@type gamma: float
A number between 0 and 1 that is multiplied to
beta at each step.
"""
state = self.server.getInitialState()
action = self.chooseAction(state, epsilon)
average_reward = 0.0
for step in range(steps):
if (step + 1) % 10000 == 0:
torch.save(self.NN.state_dict(), 'server_queue_NN_model')
print(f'Step {step + 1}/{steps} completed!')
self.plotPolicy(step + 1)
print(f'Average estimated reward: {average_reward:.3f}')
next_state, reward = self.server.getNextState(state, action)
next_action = self.chooseAction(next_state, epsilon)
with torch.no_grad():
target = reward - average_reward + self.NN(self.state_to_basis[next_state])[next_action]
average_reward += beta * (target - self.NN(self.state_to_basis[state])[action])
# Update network after reaching steady state
if step > 5000:
self.oneStep(state, action, target)
state, action = next_state, next_action
def plotPolicy(self, step):
"""
Plots the current policy.
"""
num_servers, num_customers = self.server.num_servers, len(self.server.customer_rewards)
pi = np.zeros(shape=(num_servers, num_customers))
with torch.no_grad():
for free_servers in range(1, num_servers+1):
for customer in range(num_customers):
vals = self.NN(self.state_to_basis[(free_servers, customer)])
if vals[0] == vals[1]:
action = 1
else:
_, action = torch.max(self.NN(self.state_to_basis[(free_servers, customer)]), 0)
action = action.item()
pi[free_servers-1, customer] = action
plt.figure()
plt.imshow(pi.T)
plt.xlabel('Number of free servers')
plt.ylabel('Customer priority')
plt.xticks(ticks=range(0, 10), labels=range(1, 11))
plt.yticks(ticks=range(num_customers), labels=self.server.customer_rewards)
plt.colorbar(ticks=[0, 1])
plt.title(f'Step {step}')
plt.savefig('policy.png')
plt.close()
if __name__ == "__main__":
# Server Queue parameters
num_servers = 10
customer_rewards = [1, 2, 4, 8]
free_prob = 0.06
# Training parameters
steps = 2000000
epsilon = 0.1
learning_rate = 0.02
beta = 0.01
server = ServerQueue(num_servers, customer_rewards, free_prob)
model = nn.Linear((num_servers + 1) * len(customer_rewards), 2, bias=False).to(device)
model.weight.data.fill_(0.0)
model.load_state_dict(torch.load('server_queue_NN_model'))
criterion = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
server_agent = Agent(server, model, optimizer, criterion)
server_agent.train(steps, epsilon, beta)
|
"""Maintainance Mode Middleware."""
import os
from ..response import Response
from config import application
class MaintenanceModeMiddleware:
def __init__(self, response: Response):
self.response = response
def before(self):
down = os.path.exists(
os.path.join(application.BASE_DIRECTORY, "bootstrap/down")
)
if down is True:
self.response.status(503)
|
# Copyright (C) 2017 Google Inc.
# Licensed under http://www.apache.org/licenses/LICENSE-2.0 <see LICENSE file>
"""Module for factories that create business entities."""
# pylint: disable=too-many-arguments
# pylint: disable=invalid-name
# pylint: disable=redefined-builtin
import random
import uuid
from lib.constants import element, objects, roles, url
from lib.constants.element import AdminWidgetCustomAttrs
from lib.entities import entity
from lib.utils import string_utils
from lib.utils.string_utils import random_list_of_strings, random_string
class EntitiesFactory(object):
"""Common factory class for entities."""
# pylint: disable=too-few-public-methods
_obj_person = objects.get_singular(objects.PEOPLE)
_obj_program = objects.get_singular(objects.PROGRAMS)
_obj_control = objects.get_singular(objects.CONTROLS)
_obj_audit = objects.get_singular(objects.AUDITS)
_obj_asmt_tmpl = objects.get_singular(objects.ASSESSMENT_TEMPLATES)
_obj_asmt = objects.get_singular(objects.ASSESSMENTS)
all_objs_attrs_names = tuple(entity.Entity().attrs_names_of_all_entities())
@classmethod
def update_obj_attrs_values(cls, obj, attrs_names=all_objs_attrs_names,
**arguments):
"""Update the object's (obj) attributes values according to the list of
unique possible objects' names and dictionary of arguments (key = value).
"""
# pylint: disable=expression-not-assigned
[setattr(obj, attr_name, arguments[attr_name]) for
attr_name in attrs_names if arguments.get(attr_name)]
return obj
@classmethod
def _generate_title(cls, obj_type):
"""Generate title according object type."""
special_chars = string_utils.SPECIAL
return "{obj_type}_{rand_str}_{uuid}".format(
obj_type=obj_type, uuid=uuid.uuid4(),
rand_str=random_string(size=len(special_chars), chars=special_chars))
@classmethod
def _generate_email(cls, domain=url.DEFAULT_EMAIL_DOMAIN):
"""Generate email according domain."""
return "{uuid}@{domain}".format(uuid=uuid.uuid4(), domain=domain)
class PersonFactory(EntitiesFactory):
"""Factory class for Person entity."""
@classmethod
def default(cls):
"""Create default system Person object."""
return cls.create(title=roles.DEFAULT_USER, id=1,
href=url.DEFAULT_URL_USER_API, email=url.DEFAULT_EMAIL,
authorizations=roles.SUPERUSER)
@classmethod
def create(cls, title=None, id=None, href=None, type=None, email=None,
authorizations=None):
"""Create Person object.
Random values will be used for title aka name.
Predictable values will be used for mail and system_wide_role.
"""
person_entity = cls._create_random_person()
person_entity = cls.update_obj_attrs_values(
obj=person_entity, title=title, id=id, href=href, type=type,
email=email, authorizations=authorizations)
return person_entity
@classmethod
def _create_random_person(cls):
"""Create Person entity with randomly filled fields."""
random_person = entity.Person()
random_person.title = cls._generate_title(cls._obj_person)
random_person.type = cls._obj_person
random_person.email = cls._generate_email()
random_person.authorizations = roles.NO_ROLE
return random_person
class CAFactory(EntitiesFactory):
"""Factory class for Custom Attribute entity."""
@classmethod
def create(cls, title=None, ca_type=None, definition_type=None, helptext="",
placeholder=None, multi_choice_options=None, is_mandatory=False,
ca_global=True):
"""Create CustomAttribute object.
Random values will be used for title, ca_type, definition_type and
multi_choice_options if they are None.
"""
ca_entity = cls._create_random_ca()
ca_entity = cls._fill_ca_entity_fields(
ca_entity, title=title,
ca_type=ca_type, definition_type=definition_type, helptext=helptext,
placeholder=placeholder, multi_choice_options=multi_choice_options,
is_mandatory=is_mandatory, ca_global=ca_global)
ca_entity = cls._normalize_ca_definition_type(ca_entity)
return ca_entity
@classmethod
def _create_random_ca(cls):
"""Create CustomAttribute entity with randomly filled fields."""
random_ca = entity.CustomAttribute()
random_ca.ca_type = random.choice(AdminWidgetCustomAttrs.ALL_ATTRS_TYPES)
random_ca.title = cls._generate_title(random_ca.ca_type)
random_ca.definition_type = random.choice(objects.ALL_CA_OBJECTS)
return random_ca
@classmethod
def _fill_ca_entity_fields(cls, ca_object, **ca_object_fields):
"""Set the CustomAttributes object's attributes."""
if ca_object_fields.get("ca_type"):
ca_object.ca_type = ca_object_fields["ca_type"]
ca_object.title = cls._generate_title(ca_object.ca_type)
if ca_object_fields.get("definition_type"):
ca_object.definition_type = ca_object_fields["definition_type"]
if ca_object_fields.get("title"):
ca_object.title = ca_object_fields["definition_type"]
# "Placeholder" field exists only for Text and Rich Text.
if (ca_object_fields.get("placeholder") and
ca_object.ca_type in (AdminWidgetCustomAttrs.TEXT,
AdminWidgetCustomAttrs.RICH_TEXT)):
ca_object.placeholder = ca_object_fields["placeholder"]
if ca_object_fields.get("helptext"):
ca_object.helptext = ca_object_fields["helptext"]
if ca_object_fields.get("is_mandatory"):
ca_object.is_mandatory = ca_object_fields["is_mandatory"]
if ca_object_fields.get("ca_global"):
ca_object.ca_global = ca_object_fields["ca_global"]
# "Possible Values" - is a mandatory field for dropdown CustomAttribute.
if ca_object.ca_type == AdminWidgetCustomAttrs.DROPDOWN:
if (ca_object_fields.get("multi_choice_options") and
ca_object_fields["multi_choice_options"] is not None):
ca_object.multi_choice_options =\
ca_object_fields["multi_choice_options"]
else:
ca_object.multi_choice_options = random_list_of_strings(list_len=3)
return ca_object
@classmethod
def _normalize_ca_definition_type(cls, ca_object):
"""Transform definition type to title form.
Title from used for UI operations.
For REST operations definition type should be interpreted as
objects.get_singular().get_object_name_form().
"""
ca_object.definition_type = objects.get_normal_form(
ca_object.definition_type
)
return ca_object
class ProgramFactory(EntitiesFactory):
"""Factory class for Program entity."""
@classmethod
def create(cls, title=None, id=None, href=None, type=None, manager=None,
pr_contact=None, code=None, state=None, last_update=None):
"""Create Program object.
Random values will be used for title.
Predictable values will be used for type, manager, pr_contact, state.
"""
program_entity = cls._create_random_program()
program_entity = cls.update_obj_attrs_values(
obj=program_entity, title=title, id=id, href=href, type=type,
manager=manager, pr_contact=pr_contact, code=code, state=state,
last_update=last_update)
return program_entity
@classmethod
def _create_random_program(cls):
"""Create Program entity with randomly and predictably filled fields."""
# pylint: disable=protected-access
random_program = entity.Program()
random_program.title = cls._generate_title(cls._obj_program)
random_program.type = cls._obj_program
random_program.manager = roles.DEFAULT_USER
random_program.pr_contact = roles.DEFAULT_USER
random_program.state = element.ObjectStates.DRAFT
return random_program
class ControlFactory(EntitiesFactory):
"""Factory class for Control entity."""
@classmethod
def create(cls, title=None, id=None, href=None, type=None, owner=None,
pr_contact=None, code=None, state=None, last_update=None):
"""Create Control object.
Random values will be used for title.
Predictable values will be used for type, owner, pr_contact, state.
"""
control_entity = cls._create_random_control()
control_entity = cls.update_obj_attrs_values(
obj=control_entity, title=title, id=id, href=href, type=type,
owner=owner, pr_contact=pr_contact, code=code, state=state,
last_update=last_update)
return control_entity
@classmethod
def _create_random_control(cls):
"""Create Control entity with randomly and predictably filled fields."""
# pylint: disable=protected-access
random_control = entity.Control()
random_control.title = cls._generate_title(cls._obj_control)
random_control.type = cls._obj_control
random_control.owner = roles.DEFAULT_USER
random_control.pr_contact = roles.DEFAULT_USER
random_control.state = element.ObjectStates.DRAFT
return random_control
class AuditFactory(EntitiesFactory):
"""Factory class for Audit entity."""
@classmethod
def create(cls, title=None, id=None, href=None, type=None, program=None,
audit_lead=None, code=None, status=None, last_update=None):
"""Create Audit object.
Random values will be used for title.
Predictable values will be used for type, audit_lead, status.
"""
audit_entity = cls._create_random_audit()
audit_entity = cls.update_obj_attrs_values(
obj=audit_entity, title=title, id=id, href=href, type=type,
program=program, audit_lead=audit_lead, code=code, status=status,
last_update=last_update)
return audit_entity
@classmethod
def _create_random_audit(cls):
"""Create Audit entity with randomly and predictably filled fields."""
# pylint: disable=protected-access
random_audit = entity.Audit()
random_audit.title = cls._generate_title(cls._obj_audit)
random_audit.type = cls._obj_audit
random_audit.audit_lead = roles.DEFAULT_USER
random_audit.status = element.AuditStates.PLANNED
return random_audit
class AsmtTmplFactory(EntitiesFactory):
"""Factory class for Assessment Template entity."""
@classmethod
def create(cls, title=None, id=None, href=None, type=None, audit=None,
asmt_objects=None, def_assessors=None, def_verifiers=None,
code=None, last_update=None):
"""Create Assessment Template object.
Random values will be used for title.
Predictable values will be used for type, asmt_objects, def_assessors,
def_verifiers.
"""
asmt_tmpl_entity = cls._create_random_asmt_tmpl()
asmt_tmpl_entity = cls.update_obj_attrs_values(
obj=asmt_tmpl_entity, title=title, id=id, href=href, type=type,
audit=audit, asmt_objects=asmt_objects, def_assessors=def_assessors,
def_verifiers=def_verifiers, code=code, last_update=last_update)
return asmt_tmpl_entity
@classmethod
def _create_random_asmt_tmpl(cls):
"""Create Assessment Template entity with randomly and predictably
filled fields.
"""
random_asmt_tmpl = entity.AsmtTmpl()
random_asmt_tmpl.title = cls._generate_title(cls._obj_asmt_tmpl)
random_asmt_tmpl.type = cls._obj_asmt_tmpl
random_asmt_tmpl.asmt_objects = objects.CONTROLS
random_asmt_tmpl.def_assessors = roles.OBJECT_OWNERS
random_asmt_tmpl.def_verifiers = roles.OBJECT_OWNERS
return random_asmt_tmpl
class AsmtFactory(EntitiesFactory):
"""Factory class for Assessment entity."""
@classmethod
def create(cls, title=None, id=None, href=None, type=None, object=None,
audit=None, creators=None, assignees=None, pr_contact=None,
is_verified=None, code=None, state=None, last_update=None):
"""Create Assessment object.
Random values will be used for title.
Predictable values will be used for type, object, creators, assignees,
state, is_verified.
"""
asmt_entity = cls._create_random_asmt()
asmt_entity = cls.update_obj_attrs_values(
obj=asmt_entity, title=title, id=id, href=href, type=type,
object=object, audit=audit, creators=creators, assignees=assignees,
pr_contact=pr_contact, is_verified=is_verified, code=code, state=state,
last_update=last_update)
return asmt_entity
@classmethod
def _create_random_asmt(cls):
"""Create Assessment entity with randomly and predictably filled fields."""
random_asmt = entity.Asmt()
random_asmt.title = cls._generate_title(cls._obj_asmt)
random_asmt.type = cls._obj_asmt
random_asmt.object = roles.DEFAULT_USER
random_asmt.creators = roles.DEFAULT_USER
random_asmt.assignees = roles.DEFAULT_USER
random_asmt.state = element.AsmtStates.NOT_STARTED
random_asmt.is_verified = element.Common.FALSE
return random_asmt
|
#! /usr/bin/env python3
#
# In this script we solve the lid driven cavity problem for stationary Stokes
# and Navier-Stokes flow. That is, a unit square domain, with no-slip left,
# bottom and right boundaries and a top boundary that is moving at unit
# velocity in positive x-direction.
import nutils, numpy, matplotlib.collections
# The main function defines the parameter space for the script. Configurable
# parameters are the mesh density (in number of elements along an edge),
# element type (square, triangle, or mixed), polynomial degree, and Reynolds
# number.
def main(nelems: 'number of elements' = 12,
etype: 'type of elements (square/triangle/mixed)' = 'square',
degree: 'polynomial degree for velocity' = 3,
reynolds: 'reynolds number' = 1000.):
domain, geom = nutils.mesh.unitsquare(nelems, etype)
ns = nutils.function.Namespace()
ns.Re = reynolds
ns.x = geom
ns.ubasis, ns.pbasis = nutils.function.chain([
domain.basis('std', degree=degree).vector(2),
domain.basis('std', degree=degree-1),
])
ns.u_i = 'ubasis_ni ?lhs_n'
ns.p = 'pbasis_n ?lhs_n'
ns.stress_ij = '(u_i,j + u_j,i) / Re - p δ_ij'
sqr = domain.boundary.integral('u_k u_k d:x' @ ns, degree=degree*2)
wallcons = nutils.solver.optimize('lhs', sqr, droptol=1e-15)
sqr = domain.boundary['top'].integral('(u_0 - 1)^2 d:x' @ ns, degree=degree*2)
lidcons = nutils.solver.optimize('lhs', sqr, droptol=1e-15)
cons = numpy.choose(numpy.isnan(lidcons), [lidcons, wallcons])
cons[-1] = 0 # pressure point constraint
res = domain.integral('(ubasis_ni,j stress_ij + pbasis_n u_k,k) d:x' @ ns, degree=degree*2)
with nutils.log.context('stokes'):
lhs0 = nutils.solver.solve_linear('lhs', res, constrain=cons)
postprocess(domain, ns, lhs=lhs0)
res += domain.integral('ubasis_ni u_i,j u_j d:x' @ ns, degree=degree*3)
with nutils.log.context('navierstokes'):
lhs1 = nutils.solver.newton('lhs', res, lhs0=lhs0, constrain=cons).solve(tol=1e-10)
postprocess(domain, ns, lhs=lhs1)
return lhs0, lhs1
# Postprocessing in this script is separated so that it can be reused for the
# results of Stokes and Navier-Stokes, and because of the extra steps required
# for establishing streamlines.
def postprocess(domain, ns, every=.05, spacing=.01, **arguments):
ns = ns.copy_() # copy namespace so that we don't modify the calling argument
ns.streambasis = domain.basis('std', degree=2)[1:] # remove first dof to obtain non-singular system
ns.stream = 'streambasis_n ?streamdofs_n' # stream function
sqr = domain.integral('((u_0 - stream_,1)^2 + (u_1 + stream_,0)^2) d:x' @ ns, degree=4)
arguments['streamdofs'] = nutils.solver.optimize('streamdofs', sqr, arguments=arguments) # compute streamlines
bezier = domain.sample('bezier', 9)
x, u, p, stream = bezier.eval(['x_i', 'sqrt(u_k u_k)', 'p', 'stream'] @ ns, **arguments)
with nutils.export.mplfigure('flow.jpg') as fig: # plot velocity as field, pressure as contours, streamlines as dashed
ax = fig.add_axes([.1,.1,.8,.8], yticks=[], aspect='equal')
ax.add_collection(matplotlib.collections.LineCollection(x[bezier.hull], colors='w', linewidths=.5, alpha=.2))
ax.tricontour(x[:,0], x[:,1], bezier.tri, stream, 16, colors='k', linestyles='dotted', linewidths=.5, zorder=9)
caxu = fig.add_axes([.1,.1,.03,.8], title='velocity')
imu = ax.tripcolor(x[:,0], x[:,1], bezier.tri, u, shading='gouraud', cmap='jet')
fig.colorbar(imu, cax=caxu)
caxu.yaxis.set_ticks_position('left')
caxp = fig.add_axes([.87,.1,.03,.8], title='pressure')
imp = ax.tricontour(x[:,0], x[:,1], bezier.tri, p, 16, cmap='gray', linestyles='solid')
fig.colorbar(imp, cax=caxp)
# If the script is executed (as opposed to imported), :func:`nutils.cli.run`
# calls the main function with arguments provided from the command line. To
# keep with the default arguments simply run :sh:`python3 drivencavity.py`.
if __name__ == '__main__':
nutils.cli.run(main)
# Once a simulation is developed and tested, it is good practice to save a few
# strategicly chosen return values for routine regression testing. Here we use
# the standard :mod:`unittest` framework, with
# :func:`nutils.numeric.assert_allclose64` facilitating the embedding of
# desired results as compressed base64 data.
import unittest
class test(unittest.TestCase):
def test_square(self):
lhs0, lhs1 = main(nelems=3, etype='square', reynolds=100, degree=3)
nutils.numeric.assert_allclose64(lhs0, 'eNp1zj1IQlEUB/BrCJKEQxLRFNFQxvN1vTcpo'
'qWhzZaGElr7WKOGirApiIaipcEKoiXCpaKEiCKnhjznXX1PejaEJGGFRCCiCH153YrXOXCG3+F'
'w/oT8rZFeQpaVqDGVmjHNxEKSJmxM2rOIal1aDlsxKyK+gF/asZbHEA5gDmL6FduuWRnHsAQXc'
'ABEXeGP/5rVrdUPqyxWma1q2ih3u1g7/+JnPf3+BiYtr5ToBGvm33yNd/C3pLTrTi9d9Y2yCku'
'xU2Z6pa17CqpKMzTo+6AbdLJmc3eupC7axKFmF7NiR5c2aBpiUYugAxUcRk/Nmgyn2MVXsME83'
'INblRZW6hMFfIA6CMRvbotonTgL7/ACWQjBfjwcT8MT6HAJSxCEI8hAvroxIQZ7cA7FX+3ET3C'
'gG1Ucxz5sRDu2IMctTONQNVkFbNW5iScGIT8HbdXq')
nutils.numeric.assert_allclose64(lhs1, 'eNptzktoU0EUBuC7KeLGguKioS4MBdPekNyZS'
'WIwEihowVVBxJW0pYuiFgpiXSh0F0ltELvoC2zAVuorRuiTJlRLC6Hof2cml0wwCxVqCl1XFOq'
'i4p27LPlXP985HI5hHM/1i4aRMzvVL7VqOs4j5VMhS9un8k2ZkEnZLL+271v3mLYb8oG4KuKiR'
'0yGtkk6om1MODzLH/Ma/xZK0b+eXROveJzX7Vs8ZcXYUFTbkYiJp7yFb9i3VTO765m/fFL+5IM'
'8ZBfFHJvybCD4WvVWi86BZPIsj3j3Gv3cKKXKUDhJovQ7TbBhdsrSdjl4xcqSbtrEZukM7VDa3'
'ge2wnHSRAt0lmboSFjbCfNMuGItkH7aSxdpi9Q2c+Gf80JFgpdIHxkgdaJtt3aufFq2iRXxUPq'
'chLfnV63yLT/Pd2CKLXqfadsL9DmGmLeruPPl42diN/44jyV8wBuMogvteIe827MYxwTWkMOiK'
'1k8QxrTbl9xZQpPMIzn2EDR3cgjg5dYxzYKKIHjDzbx252sY9mdHuKHaRj/AYh1yFc=')
def test_mixed(self):
lhs0, lhs1 = main(nelems=3, etype='mixed', reynolds=100, degree=2)
nutils.numeric.assert_allclose64(lhs0, 'eNpjYICAiRePnWdg0D736SyIF3P2nK6VYSWQH'
'WS+1SjI3MAkyLz6rMbZI2BZhXMJZxyMNp/xMbwMFA8yLzNhYNh6YdUFiElzzykYgGg94yBzkH6'
'oBQwvLm80YmA4r6dkCOYZq5h4GZUYgdg8QHKbJpA2OHhp8zmQiM8Vp6tpV03PMp1TPQ/ipwPJc'
'IOtZyAmvT69Bcy6BOXHnM0+m3w28ezmM+ZnY88EnW0/O+vs2bO7zq48W352FdA8ABC3SoM=')
nutils.numeric.assert_allclose64(lhs1, 'eNpjYICA1RezLjIwPD639hyIl31umX6vgQGQH'
'WTuaRhkLmYcZB54bvvZq2dBsofPqZ4tMoo4o22oaxJkHmReasLAsOrihAsQkxzOJl0B0TJAOZB'
'+qAUMtZefGzIwxOjtNgDxfho9MbI1UjcCsV/pMTA802VgqDNYqrsEbL+I7nGD0/o655ouMIFN3'
'QLUqWSUcQZiEvMZbrA7npyG8IXPyJ2RPiN65ubpn6dPn+Y9I3XG4AwfUMzlDPuZ60A9AH73RT0'
'=')
|
import pytest
from spytest import st, tgapi, SpyTestDict
import apis.routing.ip as ipfeature
import apis.switching.vlan as vapi
import apis.system.port as papi
import apis.system.interface as intapi
import apis.routing.ip as ip_obj
import apis.switching.portchannel as portchannel_obj
import apis.switching.vlan as vlan_obj
import apis.system.basic as basic_obj
data = SpyTestDict()
data.my_dut_list = None
data.local = None
data.remote = None
data.mask = "24"
data.counters_threshold = 10
data.tgen_stats_threshold = 20
data.tgen_rate_pps = '1000'
data.tgen_l3_len = '500'
data.traffic_run_time = 20
data.clear_parallel = True
data.d1t1_ip_addr = "192.168.11.1"
data.d1d2_ip_addr = "192.168.12.1"
data.d2d1_ip_addr = "192.168.12.2"
data.d2t1_ip_addr = "192.168.13.1"
data.t1d1_ip_addr = "192.168.11.2"
data.t1d2_ip_addr = "192.168.13.2"
data.static_ip_list = ["192.168.11.0/24","192.168.13.0/24"]
data.d1t1_ip_addr_v6 = "2011::1"
data.d1d2_ip_addr_v6 = "2012::1"
data.d2d1_ip_addr_v6 = "2012::2"
data.d2t1_ip_addr_v6 = "2013::1"
data.static_ipv6_list = ["2011::0/64","2013::0/64"]
data.mask_v6 = "64"
def get_handles():
tg1, tg_ph_1 = tgapi.get_handle_byname("T1D1P1")
tg2, tg_ph_2 = tgapi.get_handle_byname("T1D2P1")
return (tg1, tg2, tg_ph_1, tg_ph_2)
@pytest.fixture(scope="module", autouse=True)
def sanity_l3_module_hooks(request):
yield
def verifyPortStatus():
data.my_dut_list = st.get_dut_names()
intapi.interface_noshutdown(vars.D1, [vars.D1T1P1,vars.D1D2P1])
intapi.interface_noshutdown(vars.D2, [vars.D2T1P1,vars.D2D1P1])
st.wait(5)
for dut,portList in zip(data.my_dut_list,[[vars.D1T1P1,vars.D1D2P1] ,[vars.D2T1P1,vars.D2D1P1]]):
for port in portList:
if not intapi.verify_interface_status(dut,port,'oper', 'up'):
return False
return True
def pre_test_l3_fwding():
# override from testbed
data.my_dut_list = st.get_dut_names()
if len(data.my_dut_list) < 2:
st.report_fail("operation_failed")
return
dut1 = data.my_dut_list[0]
dut2 = data.my_dut_list[1]
if not verifyPortStatus():
st.report_fail("operation_failed")
ipfeature.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr,data.mask)
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,data.mask)
ipfeature.config_ip_addr_interface(dut2, vars.D2D1P1, data.d2d1_ip_addr,data.mask)
ipfeature.config_ip_addr_interface(dut2, vars.D2T1P1, data.d2t1_ip_addr,data.mask)
ipfeature.create_static_route(dut1, data.d2d1_ip_addr, data.static_ip_list[1])
ipfeature.create_static_route(dut2, data.d1d2_ip_addr, data.static_ip_list[0])
# ipv6
ipfeature.config_ip_addr_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.config_ip_addr_interface(dut2, vars.D2D1P1, data.d2d1_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.config_ip_addr_interface(dut2, vars.D2T1P1, data.d2t1_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.create_static_route(dut1, data.d2d1_ip_addr_v6, data.static_ipv6_list[1], family = 'ipv6')
ipfeature.create_static_route(dut2, data.d1d2_ip_addr_v6, data.static_ipv6_list[0], family = 'ipv6')
def post_test_l3_fwding():
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
dut2 = data.my_dut_list[1]
ipfeature.delete_static_route(dut1, data.d2d1_ip_addr, data.static_ip_list[1])
ipfeature.delete_static_route(dut2, data.d1d2_ip_addr, data.static_ip_list[0])
ipfeature.delete_ip_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr,data.mask)
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,data.mask)
ipfeature.delete_ip_interface(dut2, vars.D2D1P1, data.d2d1_ip_addr,data.mask)
ipfeature.delete_ip_interface(dut2, vars.D2T1P1, data.d2t1_ip_addr,data.mask)
ipfeature.delete_ip_interface(dut1, vars.D1T1P1, data.d1t1_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.delete_ip_interface(dut2, vars.D2D1P1, data.d2d1_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.delete_ip_interface(dut2, vars.D2T1P1, data.d2t1_ip_addr_v6,data.mask_v6,family='ipv6')
st.show(dut1, "show vlan config")
@pytest.fixture(scope="module", autouse=True)
def sanity_l3_func_hooks(request):
# add things at the start every test case
# use 'request.function.func_name' to compare
# if any thing specific a particular test case
global vars
vars = st.ensure_min_topology("D1D2:1", "D1T1:1", "D2T1:1")
st.log("POST TEST : Cleanup call are started..")
ip_obj.clear_ip_configuration(st.get_dut_names(),thread= data.clear_parallel)
ip_obj.clear_ip_configuration(st.get_dut_names(),'ipv6',thread= data.clear_parallel)
vlan_obj.clear_vlan_configuration(st.get_dut_names(),thread= data.clear_parallel)
portchannel_obj.clear_portchannel_configuration(st.get_dut_names(),thread= data.clear_parallel)
pre_test_l3_fwding()
yield
post_test_l3_fwding()
# add things at the end every test case
# use 'request.function.func_name' to compare
# if any thing specific a particular test case
@pytest.mark.base_test_sanity
def test_l3_fwding():
#pre_test_l3_fwding()
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
dut2 = data.my_dut_list[1]
dut1 = vars.D1
dut2 = vars.D2
st.show(dut1, "show ip interfaces")
st.show(dut1, "show ipv6 interfaces")
st.show(dut1, "show ip route")
# L3 traffic streams
(tg1, tg2, tg_ph_1, tg_ph_2) = get_handles()
tg1.tg_traffic_control(action='reset', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='reset', port_handle=tg_ph_2)
res=tg1.tg_interface_config(port_handle=tg_ph_1, mode='config', intf_ip_addr=data.t1d1_ip_addr,
gateway=data.d1t1_ip_addr, src_mac_addr='00:0a:01:00:11:01', arp_send_req='1')
st.log("INTFCONF: "+str(res))
handle1 = res['handle']
res=tg2.tg_interface_config(port_handle=tg_ph_2, mode='config', intf_ip_addr=data.t1d2_ip_addr,
gateway=data.d2t1_ip_addr, src_mac_addr='00:0a:01:00:12:01', arp_send_req='1')
st.log("INTFCONF: "+str(res))
handle2 = res['handle']
tg1.tg_traffic_config(port_handle=tg_ph_1, mode='create', transmit_mode='continuous', length_mode='fixed',
l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle1, emulation_dst_handle=handle2)
tg2.tg_traffic_config(port_handle=tg_ph_2, mode='create', transmit_mode='continuous', length_mode='fixed',
l3_length=data.tgen_l3_len, rate_pps=data.tgen_rate_pps, emulation_src_handle=handle2, emulation_dst_handle=handle1)
tg1.tg_packet_control(port_handle=tg_ph_1, action='start')
tg2.tg_packet_control(port_handle=tg_ph_2, action='start')
tg1.tg_traffic_control(action='clear_stats', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='clear_stats', port_handle=tg_ph_2)
papi.clear_interface_counters(dut1)
tg1.tg_traffic_control(action='run', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='run', port_handle=tg_ph_2)
st.wait(data.traffic_run_time)
tg1.tg_traffic_control(action='stop', port_handle=tg_ph_1)
tg2.tg_traffic_control(action='stop', port_handle=tg_ph_2)
st.wait(5)
tg1.tg_packet_control(port_handle=tg_ph_1, action='stop')
tg2.tg_packet_control(port_handle=tg_ph_2, action='stop')
stats_tg1 = tg1.tg_traffic_stats(port_handle=tg_ph_1,mode='aggregate')
total_tg1_tx = stats_tg1[tg_ph_1]['aggregate']['tx']['total_pkts']
total_tg1_rx = stats_tg1[tg_ph_1]['aggregate']['rx']['total_pkts']
stats_tg2 = tg2.tg_traffic_stats(port_handle=tg_ph_2,mode='aggregate')
total_tg2_tx = stats_tg2[tg_ph_2]['aggregate']['tx']['total_pkts']
total_tg2_rx = stats_tg2[tg_ph_2]['aggregate']['rx']['total_pkts']
st.log("Tgen Sent Packets on D1T1P1: {} and Received Packets on D2T1P1: {}".format(total_tg1_tx, total_tg2_rx))
st.log("Tgen Sent Packets on D2T1P1: {} and Received Packets on D1T1P1: {}".format(total_tg2_tx, total_tg1_rx))
if (int(total_tg1_tx) == 0) | (int(total_tg2_tx) == 0):
st.log("Traffic Validation Failed")
st.report_fail("operation_failed")
elif (abs(int(total_tg1_tx)-int(total_tg2_rx)) > data.tgen_stats_threshold):
st.log("Traffic Validation Failed")
st.report_fail("operation_failed")
elif (abs(int(total_tg2_tx)-int(total_tg1_rx)) > data.tgen_stats_threshold):
st.log("Traffic Validation Failed")
st.report_fail("operation_failed")
#Getting interfaces counter values on DUT
DUT_rx_value = papi.get_interface_counters(dut1, vars.D1T1P1, "rx_ok")
DUT_tx_value = papi.get_interface_counters(dut1, vars.D1D2P1, "tx_ok")
for i in DUT_rx_value:
p1_rcvd = i['rx_ok']
p1_rcvd = p1_rcvd.replace(",","")
for i in DUT_tx_value:
p2_txmt = i['tx_ok']
p2_txmt = p2_txmt.replace(",","")
st.log("rx_ok counter value on DUT Ingress port: {} and tx_ok xounter value on DUT Egress port : {}".format(p1_rcvd, p2_txmt))
if basic_obj.is_vsonic_device(vars.D1):
result1 = ipfeature.ping(dut1, data.d2t1_ip_addr, timeout=7)
result2 = ipfeature.ping(dut1, data.d2t1_ip_addr_v6,'ipv6', timeout=7)
else:
result1 = ipfeature.ping(dut1, data.d2t1_ip_addr)
result2 = ipfeature.ping(dut1, data.d2t1_ip_addr_v6,'ipv6')
if (abs(int(p1_rcvd)-int(p2_txmt)) > data.counters_threshold) | (p1_rcvd == '0') | (p2_txmt == '0') | (not result1) | (not result2):
st.report_fail("operation_failed")
else:
st.report_pass("operation_successful")
@pytest.mark.base_test_sanity
def test_l2_to_l3_port():
data.my_dut_list = st.get_dut_names()
dut1 = data.my_dut_list[0]
data.vlan='10'
data.vlan_int='Vlan'+'10'
result_flag = 1
# configure from L3 to L2 port
vapi.create_vlan(dut1, data.vlan)
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,data.mask)
ipfeature.delete_ip_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr_v6,data.mask_v6,family='ipv6')
ipfeature.config_ip_addr_interface(dut1, data.vlan_int, data.d1d2_ip_addr,data.mask)
ipfeature.config_ip_addr_interface(dut1, data.vlan_int, data.d1d2_ip_addr_v6,data.mask_v6,family='ipv6')
vapi.add_vlan_member(dut1, data.vlan, vars.D1D2P1, False)
if not vapi.verify_vlan_config(dut1, str(data.vlan), None, vars.D1D2P1):
result_flag = 0
# for now using local ping function till qa branch is merged
if basic_obj.is_vsonic_device(vars.D1):
result1 = ipfeature.ping(dut1, data.d2t1_ip_addr, timeout=7)
result2 = ipfeature.ping(dut1, data.d2t1_ip_addr_v6,'ipv6', timeout=7)
else:
result1 = ipfeature.ping(dut1, data.d2t1_ip_addr)
result2 = ipfeature.ping(dut1, data.d2t1_ip_addr_v6,'ipv6')
if not result1 or not result2:
result_flag = 0
# Revert back from L2 to L3 port
vapi.delete_vlan_member(dut1,data.vlan,[vars.D1D2P1])
ipfeature.delete_ip_interface(dut1, data.vlan_int, data.d1d2_ip_addr,data.mask)
ipfeature.delete_ip_interface(dut1, data.vlan_int, data.d1d2_ip_addr_v6,data.mask_v6,family='ipv6')
vapi.delete_vlan(dut1, [data.vlan])
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr,data.mask)
ipfeature.config_ip_addr_interface(dut1, vars.D1D2P1, data.d1d2_ip_addr_v6,data.mask_v6,family='ipv6')
if basic_obj.is_vsonic_device(vars.D1):
st.wait(15)
ping_result = ipfeature.ping(dut1, data.d2t1_ip_addr, timeout=7)
else:
ping_result = ipfeature.ping(dut1, data.d2t1_ip_addr)
if ping_result and result_flag:
st.report_pass("operation_successful")
else:
st.report_fail("operation_failed")
|
from bs4 import BeautifulSoup
from mitmproxy import ctx
# This class is WIP, but the intention is that we can inject a script into browser-requests for html
# that lets us get DOM timings, first paint time, and other metrics. There is less need for customers to have
# this ability now that selenium is going to offer many of these things, though. Since we dont'
# know when they are running selenium or cypress, or something else, we can still use our own capability to get
# these timings which is useful for monitoring and baseline performance monitoring. Devs and managers would like
# a graph of time to first paint over time (by release) ideally
class InjectPerformanceTimingScriptAddOn:
def __init__(self):
file_name = "../"
with open(file_name) as f:
self.script = f.read().replace('{{URL}}', self.get_url())
def get_url(self):
url = "http://{0}:{1}".format(
ctx.options.listen_host or "127.0.0.1",
ctx.options.listen_port
)
return url
def response(self, ctx, flow):
if flow.request.host in ctx.script:
return # Make sure JS isn't injected to itself
html = BeautifulSoup(flow.response.content.decode('utf-8'))
if html.body and ("text/html" in flow.response.headers["content-type"]):
script = html.new_tag("script", type="application/javascript")
script.insert(0, self.script)
html.body.insert(1, script)
flow.response.content = str(html)
print("Injected Perf Timings Script")
|
import enum
from enum import Enum
from typing import Union
import numba
import numpy as np
import skimage.restoration
from numpy.core.multiarray import ndarray
from scipy.signal import convolve2d
from skimage import img_as_float64, img_as_ubyte
from skimage.color import rgb2gray, rgb2lab
from skimage.filters import scharr, gaussian
from skimage.filters.rank import entropy
from skimage.morphology import disk, dilation
from triangler.sampling import (
SampleMethod,
poisson_disk_sample,
threshold_sample,
)
class EdgeMethod(Enum):
CANNY = enum.auto()
ENTROPY = enum.auto()
SOBEL = enum.auto()
class EdgePoints(object):
__slots__ = ["width", "height", "edge_detector", "num_of_points", "edge_method"]
def __init__(self, img: ndarray, n: int, edge: EdgeMethod):
self.width = img.shape[0]
self.height = img.shape[1]
self.edge_detector: EdgeDetectors = EdgeDetectors(img)
self.num_of_points = n
self.edge_method: EdgeMethod = edge
def get_edge_points(self, sampling: SampleMethod, blur: int = None) -> ndarray:
"""
Retrieves the triangle points using Sobel | Canny | Threshold Edge Detection
"""
if self.edge_method is EdgeMethod.CANNY:
if blur is None:
raise ValueError(
"To use Canny Edge Detector, you must call this method with (SampleMethod, int)"
)
edges = self.edge_detector.canny(blur)
elif self.edge_method is EdgeMethod.ENTROPY:
edges = self.edge_detector.entropy()
elif self.edge_method is EdgeMethod.SOBEL:
edges = self.edge_detector.sobel()
else:
raise ValueError(
"Unexpected edge processing method: {}\n"
"use {} instead: {}".format(
self.edge_method, SampleMethod.__name__, SampleMethod.__members__
)
)
if sampling is SampleMethod.POISSON_DISK:
sample_points = poisson_disk_sample(self.num_of_points, edges)
elif sampling is SampleMethod.THRESHOLD:
sample_points = threshold_sample(self.num_of_points, edges, 0.2)
else:
raise ValueError(
"Unexpected sampling method: {}\n"
"use {} instead: {}".format(
sampling, SampleMethod.__name__, SampleMethod.__members__
)
)
corners = np.array(
[
[0, 0],
[0, self.height - 1],
[self.width - 1, 0],
[self.width - 1, self.height - 1],
]
)
return np.append(sample_points, corners, axis=0)
class EdgeDetectors(object):
__slots__ = ["img"]
def __init__(self, img: ndarray):
self.img: ndarray = img
@numba.jit(parallel=True, fastmath=True)
def sobel(self) -> ndarray:
_img_as_float = self.img.astype(np.float)
c: Union[int, float]
_, _, c = _img_as_float.shape
_img = (
0.2126 * _img_as_float[:, :, 0]
+ 0.7152 * _img_as_float[:, :, 1]
+ 0.0722 * _img_as_float[:, :, 2]
if c > 1
else _img_as_float
)
kh = np.array(
[
[-1, -2, 0, 2, 1],
[-4, -8, 0, 8, 4],
[-6, -12, 0, 12, 6],
[-4, -8, 0, 8, 4],
[-1, -2, 0, 2, 1],
],
dtype=np.float,
)
kv = np.array(
[
[1, 4, 6, 4, 1],
[2, 8, 12, 8, 2],
[0, 0, 0, 0, 0],
[-2, -8, -12, -8, -2],
[-1, -4, -6, -4, -1],
],
dtype=np.float,
)
gx = convolve2d(_img, kh, mode="same", boundary="symm")
gy = convolve2d(_img, kv, mode="same", boundary="symm")
g = np.sqrt(gx * gx + gy * gy)
g *= 255.0 / np.max(g)
return g
@numba.jit(fastmath=True)
def entropy(self, bal=0.1) -> ndarray:
dn_img = skimage.restoration.denoise_tv_bregman(self.img, 0.1)
img_gray = rgb2gray(dn_img)
img_lab = rgb2lab(dn_img)
entropy_img = gaussian(
img_as_float64(dilation(entropy(img_as_ubyte(img_gray), disk(5)), disk(5)))
)
edges_img = dilation(
np.mean(
np.array([scharr(img_lab[:, :, channel]) for channel in range(3)]),
axis=0,
),
disk(3),
)
weight = (bal * entropy_img) + ((1 - bal) * edges_img)
weight /= np.mean(weight)
weight /= np.amax(weight)
return weight
@numba.jit(parallel=True, fastmath=True)
def canny(self, blur: int) -> ndarray:
# gray_img = rgb2gray(self.img)
# return cv2.Canny(gray_img, self.threshold, self.threshold*3)
threshold = 3 / 256
gray_img = rgb2gray(self.img)
blur_filt = np.ones(shape=(2 * blur + 1, 2 * blur + 1)) / ((2 * blur + 1) ** 2)
blurred = convolve2d(gray_img, blur_filt, mode="same", boundary="symm")
edge_filt = np.array([[1, 1, 1], [1, -8, 1], [1, 1, 1]])
edge = convolve2d(blurred, edge_filt, mode="same", boundary="symm")
for idx, val in np.ndenumerate(edge):
if val < threshold:
edge[idx] = 0
dense_filt = np.ones((3, 3))
dense = convolve2d(edge, dense_filt, mode="same", boundary="symm")
dense /= np.amax(dense)
return dense
|
from discord.ext.commands import (
Bot,
CheckFailure,
Command,
CommandError,
CommandNotFound,
Context,
Group,
HelpCommand,
MemberNotFound,
MissingRequiredArgument,
)
import re
from sentry_sdk import Hub, capture_exception
import sys
import traceback
from typing import get_type_hints, Dict, List, Tuple
from common import SETTINGS
from . import logger, embeds
async def on_error(ctx: Context, exception: Exception):
"""
Handle errors generated from commands
:param ctx: the command context
:param exception: the thrown exception
"""
exception_type = type(exception)
# Ignore failures from checks and command not found errors
if exception_type == CheckFailure or exception_type == CommandNotFound:
return
# Notify of non-existent user
elif exception_type == MemberNotFound:
await ctx.reply(
embed=embeds.error(
"Unknown member", f"Could not find member `{exception.argument}`"
),
mention_author=False,
)
# Notify of missing parameter
elif exception_type == MissingRequiredArgument:
formatted = str(exception)
arg_separator = formatted.index(" ")
await ctx.reply(
embed=embeds.error(
f"`{formatted[:arg_separator]}`{formatted[arg_separator:]}",
f"Use `{ctx.bot.command_prefix}help {ctx.command.qualified_name}` for usage information",
),
mention_author=False,
)
else:
# Log the error
name = "extensions." + ctx.command.name if ctx.command else ""
logger.get(name).error(f"{type(exception).__name__}: {exception}")
# Capture the exception if it hasn't already been captured
if Hub.current.scope.transaction is None:
capture_exception(exception)
# Log the full traceback if enabled
if SETTINGS.full_errors:
traceback.print_exception(
type(exception), exception, exception.__traceback__, file=sys.stdout
)
# Notify the user
await ctx.reply(
embed=embeds.error(
"Unknown exception",
"An internal error occurred, please try again later",
),
mention_author=False,
)
class Help(HelpCommand):
__OPTIONAL_REGEX = re.compile(r"typing\.Union\[[a-zA-Z0-9.]+, NoneType]")
def get_destination(self):
return self.context.message
async def send_bot_help(self, mapping):
ctx = self.context
bot = ctx.bot # type: Bot
# Create the base embed
embed = embeds.default()
embed.title = "WaffleBot Help"
embed.description = "All available commands:"
# Split the commands into left and right columns
filtered = await self.filter_all_commands(bot.all_commands)
partition = (len(filtered) // 2) + (len(filtered) % 2)
left = filtered[:partition]
right = filtered[partition:]
# Add the commands to the help menu
for side in [left, right]:
text = ""
for name, command in side:
text += f"`{bot.command_prefix}{name}`\n"
if text != "":
embed.add_field(name="\u200b", value=text.strip("\n"), inline=True)
# Add the footer
embed.add_field(
name="\u200b",
value=f"Type `{bot.command_prefix}help <command>` for information on a command.",
inline=False,
)
await self.get_destination().reply(embed=embed, mention_author=False)
async def send_command_help(self, command: Command):
ctx = self.context
bot = ctx.bot # type: Bot
# Check if using a command alias
requested_command = " ".join(ctx.message.content.split(" ")[1:])
name = command.name
if requested_command != command.name:
name = requested_command
# Create the base embed
embed = embeds.default()
embed.title = f"`{bot.command_prefix}{name}` Help"
embed.description = "`<>` - required argument\n`[]` - optional argument"
# Reformat the docstring
if command.help is None:
embed.add_field(
name="Description",
value="No description or usage information was provided",
)
else:
# Create the new description
description = ""
for line in command.help.split("\n"):
if line.startswith(":") or line == "":
break
description += line
embed.add_field(name="Description", value=description, inline=False)
# Create the usage information
usage = f"`{bot.command_prefix}{name}"
hints = get_type_hints(command.callback)
# Parse the parameters
for parameter, hint in hints.items():
# Ignore the context parameter
if parameter == "ctx":
continue
# Add optional and required arguments
if self.__OPTIONAL_REGEX.fullmatch(str(hint)) is None:
usage += f" <{parameter}>"
else:
usage += f" [{parameter}]"
embed.add_field(name="Usage", value=usage + "`", inline=False)
await self.get_destination().reply(embed=embed, mention_author=False)
async def send_group_help(self, group: Group):
await group.invoke(self.context)
async def filter_all_commands(
self, commands: Dict[str, Command]
) -> List[Tuple[str, Command]]:
"""
Returns the largest name length of the specified command list, including aliases.
:param commands: all the commands to check
:return: The maximum width of the commands
"""
# Remove hidden commands
iterator = (
commands.items()
if self.show_hidden
else filter(lambda item: not item[1].hidden, commands.items())
)
# Check every command if it can run
async def predicate(c: Command):
try:
return await c.can_run(self.context)
except CommandError:
return False
# Check each command
ret = []
for name, cmd in iterator:
valid = await predicate(cmd)
if valid:
ret.append((name, cmd))
# Sort the commands by name
ret.sort(key=lambda item: item[0])
return ret
|
import unittest
import os
import subprocess
import shlex
class TestFlake8(unittest.TestCase):
def testFlake8(self):
pth = os.path.dirname(__file__)
pth = os.path.join(pth, "..")
pth = os.path.abspath(pth)
pth = os.path.join(pth, "lib")
print
print
print
print
print "---------------------------------------------------"
print "RUNNING: flake8 on directory %s" % pth
print "---------------------------------------------------"
print
print
print
print
P = subprocess.Popen(shlex.split("flake8 --show-source --statistics --ignore=F999,F405,E121,E123,E126,E226,E24,E704 --max-line-length=120 %s" % pth),
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
P.wait()
out = P.stdout.read()
if out != "":
print out
self.assertEqual(out, "")
|
import traci
import numpy as np
import random
import timeit
import requests
# phase codes based on environment.net.xml
PHASE_NS_GREEN = 0 # action 0 code 00
PHASE_NS_YELLOW = 1
PHASE_NSL_GREEN = 2 # action 1 code 01
PHASE_NSL_YELLOW = 3
PHASE_EW_GREEN = 4 # action 2 code 10
PHASE_EW_YELLOW = 5
PHASE_EWL_GREEN = 6 # action 3 code 11
PHASE_EWL_YELLOW = 7
class Simulation():
def __init__(self, TrafficGen, sumo_cmd, gamma, max_steps, green_duration, yellow_duration, num_cells, num_states, num_actions, training_epochs):
self._TrafficGen = TrafficGen
self._gamma = gamma
self._step = 0
self._sumo_cmd = sumo_cmd
self._max_steps = max_steps
self._green_duration = green_duration
self._yellow_duration = yellow_duration
self._num_cells = num_cells
self._num_states = num_states
self._num_actions = num_actions
self._training_epochs = training_epochs
self._reward_store = []
self._reward_store_a1 = []
self._reward_store_a2 = []
self._cumulative_wait_store = []
self._cumulative_wait_store_a1 = []
self._cumulative_wait_store_a2 = []
self._avg_queue_length_store = []
self._avg_queue_length_store_a1 = []
self._avg_queue_length_store_a2 = []
self._avg_wait_time_per_vehicle = []
self._avg_wait_time_per_vehicle_a1 = []
self._avg_wait_time_per_vehicle_a2 = []
self._avg_loss = []
self._min_loss = []
self._list_density = []
self._list_flow = []
self._avg_density = []
self._avg_flow = []
self._list_occupancy = []
def run(self, episode, epsilon):
"""
Runs an episode of simulation, then starts a training session
"""
start_time = timeit.default_timer()
# first, generate the route file for this simulation and set up sumo
self._TrafficGen.generate_routefile(seed=episode)
traci.start(self._sumo_cmd)
print("Simulating...")
# inits
self._step = 0
self._waiting_times = {}
self._sum_neg_reward_one = 0
self._sum_neg_reward_two = 0
self._sum_queue_length = 0
self._sum_queue_length_a1 = 0
self._sum_queue_length_a2 = 0
self._sum_waiting_time = 0
self._model_training_loss = []
self._already_in = []
self._density = []
self._flow = []
self._occupancy = []
self._cumulative_waiting_time_agent_one = 0
self._cumulative_waiting_time_agent_two = 0
old_total_wait_one = 0
old_total_wait_two = 0
old_state_one = -1
old_action_one = -1
old_state_two = -1
old_action_two = -1
while self._step < self._max_steps:
# get current state of each of the intersections
current_state_one, current_state_two = self._get_states_with_advanced_perception()
if (self._num_states == 321):
#Adding the knowledge of the other agent previous action
current_state_one = np.append(current_state_one, old_action_two)
current_state_two = np.append(current_state_two, old_action_one)
# calculate reward of previous action: (change in cumulative waiting time between actions)
# waiting time = seconds waited by a car since the spawn in the environment, cumulated for every car in incoming lanes
## Reward per agents
# current_total_wait_one = self._collect_waiting_times_first_intersection()
# reward_one = old_total_wait_one - current_total_wait_one
# current_total_wait_two = self._collect_waiting_times_second_intersection()
# reward_two = old_total_wait_two - current_total_wait_two
## New reward per agents
current_total_wait_one = 0.2 * self._collect_waiting_times_first_intersection() + self._get_queue_length_intersection_one()
reward_one = old_total_wait_one - current_total_wait_one
current_total_wait_two = 0.2 * self._collect_waiting_times_second_intersection() + self._get_queue_length_intersection_two()
reward_two = old_total_wait_two - current_total_wait_two
## Mutual reward
reward_one += 0.5 * reward_two
reward_two += 0.5 * reward_one
## Metrics
self._cumulative_waiting_time_agent_one += current_total_wait_one
self._cumulative_waiting_time_agent_two += current_total_wait_two
# self._flow.append(self._get_flow())
# self._density.append(self._get_density())
# self._occupancy.append(self._get_occupancy())
# saving the data into the memories
if self._step != 0:
requests.post('http://127.0.0.1:5000/add_samples', json={'old_state_one': old_state_one.tolist(),
'old_state_two': old_state_two.tolist(),
'old_action_one': int(old_action_one),
'old_action_two': int(old_action_two),
'reward_one': reward_one,
'reward_two': reward_two,
'current_state_one': current_state_one.tolist(),
'current_state_two': current_state_two.tolist()})
# choose the light phase to activate, based on the current state of the first intersection
action_one = self._choose_action(current_state_one, epsilon, 1)
# choose the light phase to activate, based on the current state of the second intersection
action_two = self._choose_action(current_state_two, epsilon, 2)
# if the chosen phase is different from the last phase, activate the yellow phase
#Simultaneity of the 2 traffic lights : manages different cases
#Two in yellow phases
if self._step != 0 and old_action_one != action_one and old_action_two != action_two:
self._set_yellow_phase(old_action_one)
self._set_yellow_phase_two(old_action_two)
self._simulate(self._yellow_duration)
elif self._step != 0 and old_action_one != action_one:
self._set_yellow_phase(old_action_one)
self._simulate(self._yellow_duration)
elif self._step != 0 and old_action_two != action_two:
self._set_yellow_phase_two(old_action_two)
self._simulate(self._yellow_duration)
# execute the phase selected before
self._set_green_phase(action_one)
self._set_green_phase_two(action_two)
self._simulate(self._green_duration)
# saving variables for later & accumulate reward
old_state_one = current_state_one
old_state_two = current_state_two
old_action_one = action_one
old_action_two = action_two
old_total_wait_one = current_total_wait_one
old_total_wait_two = current_total_wait_two
# saving only the meaningful rewards to better see if the agents are behaving correctly
if reward_one < 0:
self._sum_neg_reward_one += reward_one
if reward_two < 0:
self._sum_neg_reward_two += reward_two
print("Saving episodes stats...")
self._save_episode_stats()
print("Total reward:", self._sum_neg_reward_one + self._sum_neg_reward_two, "- Epsilon:", round(epsilon, 2))
traci.close()
simulation_time = round(timeit.default_timer() - start_time, 1)
# print("Training...")
# start_time = timeit.default_timer()
# for _ in range(self._training_epochs):
# #self._replay()
# tr_loss = requests.post('http://127.0.0.1:5000/replay', json={'num_states': self._num_states,
# 'num_actions': self._num_actions,
# 'gamma': self._gamma}).json()['loss']
# #print(tr_loss)
# self._model_training_loss.append(tr_loss)
# training_time = round(timeit.default_timer() - start_time, 1)
# if(len(self._model_training_loss) > 0):
# print("Saving loss results...")
# #print(self._model_training_loss)
# self._avg_loss.append(sum(self._model_training_loss)/self._training_epochs)
# self._min_loss.append(min(self._model_training_loss))
return simulation_time#, training_time
def _simulate(self, steps_todo):
"""
Execute steps in sumo while gathering statistics
"""
if (self._step + steps_todo) >= self._max_steps: # do not do more steps than the maximum allowed number of steps
steps_todo = self._max_steps - self._step
while steps_todo > 0:
traci.simulationStep() # simulate 1 step in sumo
self._step += 1 # update the step counter
steps_todo -= 1
queue_length = self._get_queue_length_intersection_one() + self._get_queue_length_intersection_two()
self._sum_queue_length += queue_length
self._sum_waiting_time += queue_length # 1 step while waiting in queue means 1 second waited, for each car, therefore queue_lenght == waited_seconds
self._sum_queue_length_a1 += self._get_queue_length_intersection_one()
self._sum_queue_length_a2 += self._get_queue_length_intersection_two()
self._flow.append(self._get_flow())
self._density.append(self._get_density())
self._occupancy.append(self._get_occupancy())
def _collect_waiting_times_first_intersection(self):
"""
Retrieve the waiting time of every car in the incoming roads of the first intersection (left one)
"""
incoming_roads = ["N2TL", "W2TL", "S2TL", "2_TL2W"]
car_list = traci.vehicle.getIDList()
for car_id in car_list:
wait_time = traci.vehicle.getAccumulatedWaitingTime(car_id)
road_id = traci.vehicle.getRoadID(car_id) # get the road id where the car is located
if road_id in incoming_roads: # consider only the waiting times of cars in incoming roads
self._waiting_times[car_id] = wait_time
else:
if car_id in self._waiting_times: # a car that was tracked has cleared the intersection
del self._waiting_times[car_id]
total_waiting_time = sum(self._waiting_times.values())
return total_waiting_time
def _collect_waiting_times_second_intersection(self):
"""
Retrieve the waiting time of every car in the incoming roads
"""
incoming_roads = ["2_N2TL", "2_W2TL", "2_S2TL", "TL2E"]
car_list = traci.vehicle.getIDList()
for car_id in car_list:
wait_time = traci.vehicle.getAccumulatedWaitingTime(car_id)
road_id = traci.vehicle.getRoadID(car_id) # get the road id where the car is located
if road_id in incoming_roads: # consider only the waiting times of cars in incoming roads
self._waiting_times[car_id] = wait_time
else:
if car_id in self._waiting_times: # a car that was tracked has cleared the intersection
del self._waiting_times[car_id]
total_waiting_time = sum(self._waiting_times.values())
return total_waiting_time
def _choose_action(self, state, epsilon, num):
"""
Decide wheter to perform an explorative or exploitative action, according to an epsilon-greedy policy
"""
if random.random() < epsilon:
return random.randint(0, self._num_actions - 1) # random action
else:
pred = np.array(requests.post('http://127.0.0.1:5000/predict', json={'state': state.tolist(), 'num': int(num)}).json()['prediction'])
return np.argmax(pred)# the best action given the current state
def _set_yellow_phase(self, old_action):
"""
Activate the correct yellow light combination in sumo for the first intersection 'TL'
"""
yellow_phase_code = old_action * 2 + 1 # obtain the yellow phase code, based on the old action (ref on environment.net.xml)
traci.trafficlight.setPhase("TL", yellow_phase_code)
def _set_yellow_phase_two(self, old_action):
"""
Activate the correct yellow light combination in sumo for the second intersection 'TL_2'
"""
yellow_phase_code = old_action * 2 + 1 # obtain the yellow phase code, based on the old action (ref on environment.net.xml)
traci.trafficlight.setPhase("2_TL", yellow_phase_code)
def _set_green_phase(self, action_number):
"""
Activate the correct green light combination in sumo for the first intersection 'TL'
"""
if action_number == 0:
traci.trafficlight.setPhase("TL", PHASE_NS_GREEN)
elif action_number == 1:
traci.trafficlight.setPhase("TL", PHASE_NSL_GREEN)
elif action_number == 2:
traci.trafficlight.setPhase("TL", PHASE_EW_GREEN)
elif action_number == 3:
traci.trafficlight.setPhase("TL", PHASE_EWL_GREEN)
def _set_green_phase_two(self, action_number):
"""
Activate the correct green light combination in sumo for the second intersection 'TL'
"""
if action_number == 0:
traci.trafficlight.setPhase("2_TL", PHASE_NS_GREEN)
elif action_number == 1:
traci.trafficlight.setPhase("2_TL", PHASE_NSL_GREEN)
elif action_number == 2:
traci.trafficlight.setPhase("2_TL", PHASE_EW_GREEN)
elif action_number == 3:
traci.trafficlight.setPhase("2_TL", PHASE_EWL_GREEN)
def _get_queue_length_intersection_one(self):
"""
Retrieve the number of cars with speed = 0 in every incoming lane of the first intersection
"""
halt_N = traci.edge.getLastStepHaltingNumber("N2TL")
halt_S = traci.edge.getLastStepHaltingNumber("S2TL")
halt_E = traci.edge.getLastStepHaltingNumber("2_TL2W")
halt_W = traci.edge.getLastStepHaltingNumber("W2TL")
return halt_N + halt_S + halt_E + halt_W
def _get_queue_length_intersection_two(self):
"""
Retrieve the number of cars with speed = 0 in every incoming lane of the second intersection
"""
halt_N = traci.edge.getLastStepHaltingNumber("2_N2TL")
halt_S = traci.edge.getLastStepHaltingNumber("2_S2TL")
halt_E = traci.edge.getLastStepHaltingNumber("2_E2TL")
halt_W = traci.edge.getLastStepHaltingNumber("TL2E")
return halt_N + halt_S + halt_E + halt_W
def _get_density(self):
"""
Retrieve the density (vehicles per km) of every edges/lanes
"""
divider = traci.lane.getLength("N2TL_0") / 1000 # derives the id of the first lane from the edge id (all lanes of an edge have the same length) and 1000 m -> km
den_N = traci.edge.getLastStepVehicleNumber("N2TL") / divider
den_S = traci.edge.getLastStepVehicleNumber("S2TL") / divider
den_E = traci.edge.getLastStepVehicleNumber("2_TL2W") / divider
den_W = traci.edge.getLastStepVehicleNumber("W2TL") / divider
return den_N + den_S + den_E + den_W
def _get_flow(self):
"""
Retrieve the flow (vehicles per hour) of every edges/lanes
"""
counter_entered = 0
#Returns the list of ids of vehicles that were on the named edge in the last simulation step.
ids_N = traci.edge.getLastStepVehicleIDs("N2TL")
ids_S = traci.edge.getLastStepVehicleIDs("S2TL")
ids_W = traci.edge.getLastStepVehicleIDs("W2TL")
ids_E = traci.edge.getLastStepVehicleIDs("2_TL2W")
car_list = ids_N + ids_S + ids_W + ids_E
for car_id in car_list:
if car_id not in self._already_in:
counter_entered+=1
self._already_in.append(car_id)
return (counter_entered/5400)*3600
def _get_occupancy(self):
"""
Retrieve the occupancy of every edges
It is the ratio of the sum of the lengths of the vehicles to the length of the road section in which those vehicles are present in %.
"""
occ_N = traci.edge.getLastStepOccupancy("N2TL")
occ_S = traci.edge.getLastStepOccupancy("S2TL")
occ_W = traci.edge.getLastStepOccupancy("W2TL")
occ_E = traci.edge.getLastStepOccupancy("2_TL2W")
return (occ_N + occ_S + occ_W + occ_E)/4
def _get_states_with_advanced_perception(self):
"""
Retrieve the state of the intersection from sumo, in the form of four arrays concatenated representing respectively :
- the number of cars per each cell
- the average speed of cars in each cell
- the cumulated waiting time of vehicles per each cell
- the number of queued cars per each cell
"""
#Initialize the four arrays that will form our state representation
nb_cars = np.zeros(self._num_cells*2)
avg_speed = np.zeros(self._num_cells*2)
cumulated_waiting_time = np.zeros(self._num_cells*2)
nb_queued_cars = np.zeros(self._num_cells*2)
car_list = traci.vehicle.getIDList()
for car_id in car_list:
car_speed = traci.vehicle.getSpeed(car_id)
wait_time = traci.vehicle.getAccumulatedWaitingTime(car_id)
lane_pos = traci.vehicle.getLanePosition(car_id)
lane_id = traci.vehicle.getLaneID(car_id)
lane_pos = 750 - lane_pos # inversion of lane pos, so if the car is close to the traffic light -> lane_pos = 0 --- 750 = max len of a road
# distance in meters from the traffic light -> mapping into cells
if lane_pos < 7:
lane_cell = 0
elif lane_pos < 14:
lane_cell = 1
elif lane_pos < 21:
lane_cell = 2
elif lane_pos < 28:
lane_cell = 3
elif lane_pos < 40:
lane_cell = 4
elif lane_pos < 60:
lane_cell = 5
elif lane_pos < 100:
lane_cell = 6
elif lane_pos < 160:
lane_cell = 7
elif lane_pos < 400:
lane_cell = 8
elif lane_pos <= 750:
lane_cell = 9
# finding the lane where the car is located
# x2TL_3 are the "turn left only" lanes
if lane_id == "W2TL_0" or lane_id == "W2TL_1" or lane_id == "W2TL_2":
lane_group = 0
elif lane_id == "W2TL_3":
lane_group = 1
elif lane_id == "N2TL_0" or lane_id == "N2TL_1" or lane_id == "N2TL_2":
lane_group = 2
elif lane_id == "N2TL_3":
lane_group = 3
elif lane_id == "2_TL2W_0" or lane_id == "2_TL2W_1" or lane_id == "2_TL2W_2":
lane_group = 4
elif lane_id == "2_TL2W_3":
lane_group = 5
elif lane_id == "S2TL_0" or lane_id == "S2TL_1" or lane_id == "S2TL_2":
lane_group = 6
elif lane_id == "S2TL_3":
lane_group = 7
#2_xTL_x are the lanes of the second intersection
elif lane_id == "TL2E_0" or lane_id == "TL2E_1" or lane_id == "TL2E_2":
lane_group = 8
elif lane_id == "TL2E_3":
lane_group = 9
elif lane_id == "2_N2TL_0" or lane_id == "2_N2TL_1" or lane_id == "2_N2TL_2":
lane_group = 10
elif lane_id == "2_N2TL_3":
lane_group = 11
elif lane_id == "2_E2TL_0" or lane_id == "2_E2TL_1" or lane_id == "2_E2TL_2":
lane_group = 12
elif lane_id == "2_E2TL_3":
lane_group = 13
elif lane_id == "2_S2TL_0" or lane_id == "2_S2TL_1" or lane_id == "2_S2TL_2":
lane_group = 14
elif lane_id == "2_S2TL_3":
lane_group = 15
else:
lane_group = -1
if lane_group >= 1 and lane_group <= 15:
car_position = int(str(lane_group) + str(lane_cell)) # composition of the two postion ID to create a number in interval 0-79
valid_car = True
elif lane_group == 0:
car_position = lane_cell
valid_car = True
else:
valid_car = False # flag for not detecting cars crossing the intersection or driving away from it
if valid_car:
nb_cars[car_position] += 1
avg_speed[car_position] += car_speed
# A speed of less than 0.1 m/s is considered a halt.
if (car_speed < 0.1):
nb_queued_cars[car_position] += 1
cumulated_waiting_time[car_position] += wait_time
#avg_speed is an accumulative speed for the moment, we need to divide by the number of cars to obtain the average speed
for i in range(len(avg_speed)):
if (nb_cars[i] > 1):
avg_speed[i] /= nb_cars[i] # avg_speed[i] = avg_speed[i] / nb_cars[i]
#State is now a vector of 80 * 4
#First half for first intersection and second half for second intersection
state_one = np.concatenate((nb_cars[:self._num_cells], avg_speed[:self._num_cells], cumulated_waiting_time[:self._num_cells], nb_queued_cars[:self._num_cells]))
state_two = np.concatenate((nb_cars[self._num_cells:], avg_speed[self._num_cells:], cumulated_waiting_time[self._num_cells:], nb_queued_cars[self._num_cells:]))
#f = open("log.txt", "a")
#f.write(str(state_two) + "\n\n\n")
#f.close()
#print(state.shape)
return state_one, state_two
def _replay(self):
"""
Retrieve a group of samples from the memory and for each of them update the learning equation, then train
"""
batch = self._Memory.get_samples(self._Model.batch_size)
if len(batch) > 0: # if the memory is full enough
states = np.array([val[0] for val in batch]) # extract states from the batch
next_states = np.array([val[3] for val in batch]) # extract next states from the batch
# prediction
q_s_a = self._Model.predict_batch(states) # predict Q(state), for every sample
q_s_a_d = self._Model.predict_batch(next_states) # predict Q(next_state), for every sample
# setup training arrays
x = np.zeros((len(batch), self._num_states))
y = np.zeros((len(batch), self._num_actions))
for i, b in enumerate(batch):
state, action, reward, _ = b[0], b[1], b[2], b[3] # extract data from one sample
current_q = q_s_a[i] # get the Q(state) predicted before
current_q[action] = reward + self._gamma * np.amax(q_s_a_d[i]) # update Q(state, action)
x[i] = state
y[i] = current_q # Q(state) that includes the updated action value
self._Model.train_batch(x, y) # train the NN
self._model_training_loss.append(self._Model.training_loss) #get the MAE loss
def _calculate_avg_loss(self):
"""
Calculate the average loss of the model depending on scenario
"""
self._avg_loss = [sum(elts)/self._training_epochs for elts in zip(*self._total_loss)]
def _save_episode_stats(self):
"""
Save the stats of the episode to plot the graphs at the end of the session
"""
cum= self._cumulative_waiting_time_agent_one + self._cumulative_waiting_time_agent_two
self._reward_store.append(self._sum_neg_reward_one + self._sum_neg_reward_two) # how much negative reward in this episode for both agents
self._reward_store_a1.append(self._sum_neg_reward_one)
self._reward_store_a2.append(self._sum_neg_reward_two)
#self._cumulative_wait_store.append(self._sum_waiting_time) # total number of seconds waited by cars in this episode
self._cumulative_wait_store.append(cum) #cumulative wait time in this episode for both agents
self._cumulative_wait_store_a1.append(self._cumulative_waiting_time_agent_one)
self._cumulative_wait_store_a2.append(self._cumulative_waiting_time_agent_two)
self._avg_queue_length_store.append(self._sum_queue_length / self._max_steps) # average number of queued cars per step, in this episode
self._avg_queue_length_store_a1.append(self._sum_queue_length_a1 / self._max_steps)
self._avg_queue_length_store_a2.append(self._sum_queue_length_a2 / self._max_steps)
self._avg_wait_time_per_vehicle.append(cum/self._sum_queue_length) #how much time a vehicle wait in an episode
self._avg_wait_time_per_vehicle_a1.append(self._cumulative_waiting_time_agent_one/self._sum_queue_length)
self._avg_wait_time_per_vehicle_a2.append(self._cumulative_waiting_time_agent_two/self._sum_queue_length)
### TO BE MODIFIED
self._list_density.append(self._density)
self._list_flow.append(self._flow)
self._list_occupancy.append(self._occupancy)
@property
def avg_density_and_flow(self):
avg_den = [sum(i)/len(self._list_density) for i in zip(*self._list_density)]
d_max = max(avg_den) #maximum density
self._max_index = avg_den.index(d_max)
self._avg_density = avg_den[:self._max_index+1]
self._avg_flow = [sum(i)/len(self._list_flow) for i in zip(*self._list_flow)][:self._max_index+1]
return self._avg_density, self._avg_flow
@property
def get_avg_density_and_flow(self):
return self._avg_density, self._avg_flow
@property
def get_avg_occupancy_and_flow(self):
avg_occ = [sum(i)/len(self._list_occupancy) for i in zip(*self._list_occupancy)]
o_max = max(avg_occ) #maximum occupancy
max_index = avg_occ.index(o_max)
avg_occ = avg_occ[:max_index+1]
avg_flow = [sum(i)/len(self._list_flow) for i in zip(*self._list_flow)][:max_index+1]
return avg_occ, avg_flow
@property
def avg_wait_time_per_vehicle(self):
return self._avg_wait_time_per_vehicle
@property
def avg_loss(self):
return self._avg_loss
@property
def min_loss(self):
return self._min_loss
@property
def reward_store(self):
return self._reward_store
@property
def cumulative_wait_store(self):
return self._cumulative_wait_store
@property
def avg_queue_length_store(self):
return self._avg_queue_length_store
@property
def density(self):
return self._density
@property
def flow(self):
return self._flow
@property
def occupancy(self):
return self._occupancy
#End simulation
def stop(self):
return self.reward_store[0], self._reward_store_a1[0], self._reward_store_a2[0], self.cumulative_wait_store[0], self._cumulative_wait_store_a1[0], self._cumulative_wait_store_a2[0], self.avg_queue_length_store[0], self._avg_queue_length_store_a1[0], self._avg_queue_length_store_a2[0], self.avg_wait_time_per_vehicle[0], self._avg_wait_time_per_vehicle_a1[0], self._avg_wait_time_per_vehicle_a2[0], self.density, self.flow, self.occupancy
|
#!/usr/bin/env python2
from __future__ import with_statement
import os
import subprocess
import shutil
import sys
# LLVM commands.
# TODO: Factor out to be configurable from ./build.
CC = '/home/max/emscripten-workspace/llvm-gcc-install/bin/llvm-gcc'
LINK = '/home/max/emscripten-workspace/llvm-build/Release/bin/llvm-link'
LLC = '/home/max/emscripten-workspace/llvm-build/Release/bin/llc'
# Argument filters.
SKIPPED_CC_ARGS = [
# Don't run optimizations prematurely.
'-O1',
'-O2',
'-O3',
]
ADDITIONAL_CC_ARGS = [
# Compile for the most basic posible x86 machine.
'-m32',
# Compile with debugging info, so emscripten can easily access struct members.
'-g',
# Avoid architecture-specific optimizations.
'-U__i386__',
'-U__x86_64__',
'-U__SSE__',
# Our doubles are funky. Don't rely on accuracy.
'-UX87_DOUBLE_ROUNDING',
# We can't run inline assembly.
'-UHAVE_GCC_ASM_FOR_X87',
# Use plain old utime() instead of utimes().
'-UHAVE_UTIMES',
# Tell expat we actually have MEMMOVE, despite its belief in the opposite.
'-DHAVE_MEMMOVE',
# Tell elementtree that we have expat available for compilation.
'-DUSE_PYEXPAT_CAPI',
'-DHAVE_EXPAT_CONFIG_H',
]
ALLOWED_LINK_ARGS = [
# Don't allow linking to external libraries.
'-f',
'-help',
'-o',
'-print-after',
'-print-after-all',
'-print-before',
'-print-before-all',
'-time-passes',
'-v',
'-verify-dom-info',
'-version',
]
# Determine whether we want to call the linker or the compiler.
call = LINK
for arg in sys.argv[1:]:
if arg == '--version' or (not arg.startswith('-') and arg.endswith('.c')):
call = CC
break
# Filter the args.
if call == CC:
newargs = [arg for arg in sys.argv[1:] if arg not in SKIPPED_CC_ARGS]
newargs += ADDITIONAL_CC_ARGS
if 'conftest.c' not in newargs:
# For real files (rather than tests), we want to compile to LLVM bytecode.
newargs.append('-emit-llvm')
newargs.append('-c')
else:
def isArgAllowed(arg):
return not arg.startswith('-') or arg.split('=')[0] in ALLOWED_LINK_ARGS
newargs = [arg for arg in sys.argv[1:] if isArgAllowed(arg)]
# Run the linker or compiler.
with open('ccproxy.log', 'a') as log:
log.write('## Called with %s\n' % ' '.join(sys.argv))
if any(i.startswith('-print-prog-name') for i in sys.argv):
# Redirect any program name queries to us.
print sys.argv[0]
ret = 0
elif call == LINK and 'libpython2.7.a' in sys.argv:
# We don't care about the final Python binary. Create a fake.
fake_python_file = open('python', 'w')
fake_python_file.write('#!/bin/bash\n')
fake_python_file.close()
ret = subprocess.call(['chmod', '+x', 'python'])
else:
log.write('** Calling %s %s\n\n' % (call, ' '.join(newargs)))
ret = subprocess.call([call] + newargs)
if call == LINK and 'Parser/pgen' in sys.argv:
# We want to compile the parser generator to native code.
target = 'Parser/pgen'
subprocess.call([LLC, '--filetype=obj', target, '-o', target + '.tmp.o'])
subprocess.call([CC, '-m32', target + '.tmp.o', '-o', target])
os.unlink(target + '.tmp.o')
# Pass the subprocess result to the caller.
sys.exit(ret)
|
from enum import IntEnum
import os
import pygame
import random
import time
from cmg import color
from cmg import math
from cmg.input import *
from cmg.graphics import *
from cmg.application import *
from study_tool.card import *
from study_tool.card_set import *
from study_tool.entities.menu import Menu
from study_tool.states.state import *
from study_tool.states.sub_menu_state import SubMenuState
from study_tool.example_database import split_words
class ReadTextState(State):
def __init__(self):
super().__init__()
self.text_font = pygame.font.Font(None, 28)
def begin(self):
self.buttons[0] = Button("Scroll Up")
self.buttons[1] = Button("Menu", self.pause)
self.buttons[2] = Button("Scroll Down")
self.cursor = 0
self.text = AccentedText("У тебя вступление просто огромное, я тоже люблю такие форматы, но блин вступление на пол-ролика бесит, говоришь одно и то же Мне лично Maud не понравилась, совершенно банальный персонаж, которого даже не попытались развить, который к тому же еще и перечит серии Cutie Mark Chronicles... Кстати девушки-брони вроде бы Pegasisters))")
self.text = AccentedText("")
for para in self.app.example_database.stories[2].chapters[0].paragraphs:
self.text += para
self.words = list(split_words(self.text.text))
self.paragraphs = [(AccentedText(p), list(split_words(AccentedText(p).text)))
for p in self.app.example_database.stories[2].chapters[0].paragraphs]
def pause(self):
self.app.push_state(SubMenuState(
"Pause",
[("Resume", None),
("Menu", self.app.pop_state),
("Exit", self.app.quit)]))
def update(self, dt):
move = self.app.inputs[2].get_amount(
) - self.app.inputs[0].get_amount()
speed = 1000.0
self.cursor += move * dt * speed
def draw(self, g):
screen_width, screen_height = self.app.screen.get_size()
screen_center_x = screen_width / 2
screen_center_y = screen_height / 2
bottom = screen_height - self.margin_bottom
cursor_x = 40
cursor_y = self.margin_top + 40
cursor_y -= self.cursor
for paragraph_text, paragraph_words in self.paragraphs:
last_index = 0
if cursor_y > bottom:
break
for name, start_index in paragraph_words:
if cursor_y > bottom:
break
start_index -= 1
end_index = start_index + len(name)
text = paragraph_text.text[last_index:end_index]
pretext = paragraph_text.text[last_index:start_index]
last_index = end_index
cards = list(self.app.card_database.find_cards_by_word(name))
w, h = g.measure_text(text, font=self.text_font)
if cursor_x + w > screen_width - 80:
cursor_x = 40
cursor_y += 24
visible = cursor_y > self.margin_top - 30
if len(pretext) > 0:
if visible:
g.draw_text(cursor_x, cursor_y, text=pretext,
font=self.text_font,
color=color.BLACK)
cursor_x += g.measure_text(pretext, font=self.text_font)[0]
word_color = color.BLACK
w, h = g.measure_text(name, font=self.text_font)
if visible:
if len(cards) > 0:
back_color = math.lerp(
color.RED, color.GREEN, t=cards[0].get_history_score())
g.fill_rect(cursor_x, cursor_y, w, h, color=back_color)
else:
back_color = color.GRAY
words = list(self.app.word_database.lookup_word(name))
if len(words) > 0:
back_color = color.BLUE
g.draw_rect(cursor_x, cursor_y, w, h, color=back_color)
if cards:
word_color = color.BLACK
g.draw_text(cursor_x, cursor_y, text=name,
font=self.text_font,
color=word_color)
cursor_x += g.measure_text(name, font=self.text_font)[0]
cursor_x = 40
cursor_y += 24 * 2
# Draw state
State.draw(self, g)
|
"""Platform for Bestin TCP light integration."""
# async component so that calls can better be done by room instead of by light entity.
#
# Per the Bestin API, lights all hang off of one room API call, so you gather
# status for all of them on every status request (or on/off result).
#
# Updating a room at a time (see async_update_data) vs by each light entity
# should reduce network calls by 2-5x depending on the number of lights per
# room.
#
import voluptuous as vol
# Import the device class from the component that you want to support
from homeassistant.components.light import LightEntity
from homeassistant import const
from datetime import timedelta
import logging
import sys
import async_timeout
_LOGGER = logging.getLogger(__name__)
from homeassistant.helpers import entity
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from . import DOMAIN
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
rooms = discovery_info
async def async_update_data():
"""Fetch lighting data"""
async with async_timeout.timeout(10):
def fetch_light_status():
for room in rooms:
room.fetchLightsStatus()
await hass.async_add_executor_job(fetch_light_status)
# XXX should maybe attempt error catching here?
return True
coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
# Name of the data. For logging purposes.
name="bestintcp_light",
update_method=async_update_data,
# Polling interval. Will only be polled if there are subscribers.
update_interval=timedelta(seconds=60),
)
lights = []
for room in discovery_info:
_LOGGER.info(f"{room}")
for name in room.lights:
light = BestinTCPLight(room, name, coordinator)
lights.append(light)
# Fetch initial data so we have data when entities subscribe
await coordinator.async_refresh()
async_add_entities(lights)
class BestinTCPLight(LightEntity):
def __init__(self, room, name, coordinator):
self._room = room
self._name = name
self.coordinator = coordinator
@property
def name(self):
"""Return the display name of this light."""
return f'bestin_r{self._room.name}_{self._name}'
@property
def is_on(self):
"""Return true if light is on."""
return self._room.isLightOn(self._name)
@property
def available(self):
return self.coordinator.last_update_success
def should_poll(self):
return False
async def async_added_to_hass(self):
"""When entity is added to hass."""
self.async_on_remove(
self.coordinator.async_add_listener(
self.async_write_ha_state
)
)
def turn_on(self, **kwargs):
"""Turn the light on."""
self._room.setLightStatus(self._name, 'on')
def turn_off(self, **kwargs):
"""Turn the light off."""
self._room.setLightStatus(self._name, 'off')
async def async_update(self):
"""Update the light."""
return await self.coordinator.async_request_refresh()
|
import unittest
import os
import time
import subprocess
import docker
from mininet.net import Containernet
from mininet.node import Host, Controller, OVSSwitch, Docker
from mininet.link import TCLink
from mininet.topo import SingleSwitchTopo, LinearTopo
from mininet.log import setLogLevel
from mininet.util import quietRun
from mininet.clean import cleanup
class simpleTestTopology( unittest.TestCase ):
"""
Helper class to do basic test setups.
s1 -- s2 -- s3 -- ... -- sN
"""
def __init__(self, *args, **kwargs):
self.net = None
self.s = [] # list of switches
self.h = [] # list of hosts
self.d = [] # list of docker containers
self.docker_cli = None
super(simpleTestTopology, self).__init__(*args, **kwargs)
def createNet(
self,
nswitches=1, nhosts=0, ndockers=0,
autolinkswitches=False):
"""
Creates a Mininet instance and automatically adds some
nodes to it.
"""
self.net = Containernet( controller=Controller )
self.net.addController( 'c0' )
# add some switches
for i in range(0, nswitches):
self.s.append(self.net.addSwitch('s%d' % i))
# if specified, chain all switches
if autolinkswitches:
for i in range(0, len(self.s) - 1):
self.net.addLink(self.s[i], self.s[i + 1])
# add some hosts
for i in range(0, nhosts):
self.h.append(self.net.addHost('h%d' % i))
# add some dockers
for i in range(0, ndockers):
self.d.append(self.net.addDocker('d%d' % i, dimage="ubuntu:trusty"))
def startNet(self):
self.net.start()
def stopNet(self):
self.net.stop()
def getDockerCli(self):
"""
Helper to interact with local docker instance.
"""
if self.docker_cli is None:
self.docker_cli = docker.Client(
base_url='unix://var/run/docker.sock')
return self.docker_cli
@staticmethod
def setUp():
pass
@staticmethod
def tearDown():
cleanup()
# make sure that all pending docker containers are killed
with open(os.devnull, 'w') as devnull:
subprocess.call(
"docker rm -f $(docker ps --filter 'label=com.containernet' -a -q)",
stdout=devnull,
stderr=devnull,
shell=True)
def getContainernetContainers(self):
"""
List the containers managed by containernet
"""
return self.getDockerCli().containers(filters={"label": "com.containernet"})
#@unittest.skip("disabled connectivity tests for development")
class testContainernetConnectivity( simpleTestTopology ):
"""
Tests to check connectivity of Docker containers within
the emulated network.
"""
def testHostDocker( self ):
"""
d1 -- h1
"""
# create network
self.createNet(nswitches=0, nhosts=1, ndockers=1)
# setup links
self.net.addLink(self.h[0], self.d[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 1)
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping
self.assertTrue(self.net.pingAll() <= 0.0)
# stop Mininet network
self.stopNet()
def testDockerDocker( self ):
"""
d1 -- d2
"""
# create network
self.createNet(nswitches=0, nhosts=0, ndockers=2)
# setup links
self.net.addLink(self.d[0], self.d[1])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 2)
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping
self.assertTrue(self.net.pingAll() <= 0.0)
# stop Mininet network
self.stopNet()
def testHostSwtichDocker( self ):
"""
d1 -- s1 -- h1
"""
# create network
self.createNet(nswitches=1, nhosts=1, ndockers=1)
# setup links
self.net.addLink(self.h[0], self.s[0])
self.net.addLink(self.d[0], self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 1)
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping
self.assertTrue(self.net.pingAll() <= 0.0)
# stop Mininet network
self.stopNet()
def testDockerSwtichDocker( self ):
"""
d1 -- s1 -- d2
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=2)
# setup links
self.net.addLink(self.d[0], self.s[0])
self.net.addLink(self.d[1], self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 2)
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping
self.assertTrue(self.net.pingAll() <= 0.0)
# stop Mininet network
self.stopNet()
def testDockerMultipleInterfaces( self ):
"""
d1 -- s1 -- d2 -- s2 -- d3
d2 has two interfaces, each with its own subnet
"""
# create network
self.createNet(nswitches=2, nhosts=0, ndockers=2)
# add additional Docker with special IP
self.d.append(self.net.addDocker(
'd%d' % len(self.d), ip="11.0.0.2", dimage="ubuntu:trusty"))
# setup links
self.net.addLink(self.s[0], self.s[1])
self.net.addLink(self.d[0], self.s[0])
self.net.addLink(self.d[1], self.s[0])
self.net.addLink(self.d[2], self.s[1])
# special link that add second interface to d2
self.net.addLink(
self.d[1], self.s[1], params1={"ip": "11.0.0.1/8"})
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 3)
self.assertTrue(len(self.net.hosts) == 3)
# check connectivity by using ping
self.assertTrue(self.net.ping([self.d[0], self.d[1]]) <= 0.0)
self.assertTrue(self.net.ping([self.d[2]], manualdestip="11.0.0.1") <= 0.0)
self.assertTrue(self.net.ping([self.d[1]], manualdestip="11.0.0.2") <= 0.0)
# stop Mininet network
self.stopNet()
#@unittest.skip("disabled command execution tests for development")
class testContainernetContainerCommandExecution( simpleTestTopology ):
"""
Test to check the command execution inside Docker containers by
using the Mininet API.
"""
def testCommandSimple( self ):
"""
d1 ls
d1 ifconfig -a
d1 ping 127.0.0.1 -c 3
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=1)
# setup links (we always need one connection to suppress warnings)
self.net.addLink(self.d[0], self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 1)
self.assertTrue("etc" in self.d[0].cmd("ls"))
self.assertTrue("d0-eth0" in self.d[0].cmd("ifconfig -a"))
self.assertTrue("0%" in self.d[0].cmd("ping 127.0.0.1 -c 3"))
# stop Mininet network
self.stopNet()
#@unittest.skip("disabled dynamic topology tests for development")
class testContainernetDynamicTopologies( simpleTestTopology ):
"""
Tests to check dynamic topology support which allows to add
and remove containers to/from a running Mininet network instance.
"""
def testSimpleAdd( self ):
"""
start: d0 -- s0
add d1
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=1)
# setup links
self.net.addLink(self.s[0], self.d[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 1)
self.assertTrue(len(self.net.hosts) == 1)
# add d2 and connect it on-the-fly
d2 = self.net.addDocker('d2', dimage="ubuntu:trusty")
self.net.addLink(d2, self.s[0], params1={"ip": "10.0.0.254/8"})
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 2)
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping
self.assertTrue(self.net.ping([self.d[0]], manualdestip="10.0.0.254") <= 0.0)
# stop Mininet network
self.stopNet()
def testSimpleRemove( self ):
"""
start: d0 -- s0 -- d1
remove d1
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=2)
# setup links
self.net.addLink(self.s[0], self.d[0])
self.net.addLink(self.s[0], self.d[1])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 2)
self.assertTrue(len(self.net.hosts) == 2)
self.assertTrue(len(self.net.links) == 2)
# check connectivity by using ping
self.assertTrue(self.net.ping([self.d[0]], manualdestip="10.0.0.2") <= 0.0)
# remove d2 on-the-fly
self.net.removeLink(node1=self.d[1], node2=self.s[0])
self.net.removeDocker(self.d[1])
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 1)
self.assertTrue(len(self.net.hosts) == 1)
self.assertTrue(len(self.net.links) == 1)
# check connectivity by using ping (now it should be broken)
self.assertTrue(self.net.ping(
[self.d[0]], manualdestip="10.0.0.2", timeout=1) >= 100.0)
# stop Mininet network
self.stopNet()
def testFullyDynamic( self ):
"""
start: s1 -- h1 (for ping tests)
add d0, d1, d2, d3
remove d0, d1
add d4
remove d2, d3, d4
"""
# create network
self.createNet(nswitches=1, nhosts=1, ndockers=0)
# setup links
self.net.addLink(self.s[0], self.h[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 0)
self.assertTrue(len(self.net.hosts) == 1)
self.assertTrue(len(self.net.links) == 1)
### add some containers: d0, d1, d2, d3
d0 = self.net.addDocker('d0', dimage="ubuntu:trusty")
self.net.addLink(d0, self.s[0], params1={"ip": "10.0.0.200/8"})
d1 = self.net.addDocker('d1', dimage="ubuntu:trusty")
self.net.addLink(d1, self.s[0], params1={"ip": "10.0.0.201/8"})
d2 = self.net.addDocker('d2', dimage="ubuntu:trusty")
self.net.addLink(d2, self.s[0], params1={"ip": "10.0.0.202/8"})
d3 = self.net.addDocker('d3', dimage="ubuntu:trusty")
self.net.addLink(d3, self.s[0], params1={"ip": "10.0.0.203/8"})
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 4)
self.assertTrue(len(self.net.hosts) == 5)
self.assertTrue(len(self.net.links) == 5)
# check connectivity by using ping
self.assertTrue(self.net.ping([self.h[0]], manualdestip="10.0.0.200") <= 0.0)
self.assertTrue(self.net.ping([self.h[0]], manualdestip="10.0.0.201") <= 0.0)
self.assertTrue(self.net.ping([self.h[0]], manualdestip="10.0.0.202") <= 0.0)
self.assertTrue(self.net.ping([self.h[0]], manualdestip="10.0.0.203") <= 0.0)
### remove d0, d1
self.net.removeLink(node1=d0, node2=self.s[0])
self.net.removeDocker(d0)
self.net.removeLink(node1=d1, node2=self.s[0])
self.net.removeDocker(d1)
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 2)
self.assertTrue(len(self.net.hosts) == 3)
self.assertTrue(len(self.net.links) == 3)
# check connectivity by using ping
self.assertTrue(self.net.ping(
[self.h[0]], manualdestip="10.0.0.200", timeout=1) >= 100.0)
self.assertTrue(self.net.ping(
[self.h[0]], manualdestip="10.0.0.201", timeout=1) >= 100.0)
### add container: d4
d4 = self.net.addDocker('d4', dimage="ubuntu:trusty")
self.net.addLink(d4, self.s[0], params1={"ip": "10.0.0.204/8"})
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 3)
self.assertTrue(len(self.net.hosts) == 4)
self.assertTrue(len(self.net.links) == 4)
# check connectivity by using ping
self.assertTrue(self.net.ping([self.h[0]], manualdestip="10.0.0.204") <= 0.0)
### remove all containers
self.net.removeLink(node1=d2, node2=self.s[0])
self.net.removeDocker(d2)
self.net.removeLink(node1=d3, node2=self.s[0])
self.net.removeDocker(d3)
self.net.removeLink(node1=d4, node2=self.s[0])
self.net.removeDocker(d4)
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 0)
self.assertTrue(len(self.net.hosts) == 1)
self.assertTrue(len(self.net.links) == 1)
# check connectivity by using ping
self.assertTrue(self.net.ping(
[self.h[0]], manualdestip="10.0.0.202", timeout=1) >= 100.0)
self.assertTrue(self.net.ping(
[self.h[0]], manualdestip="10.0.0.203", timeout=1) >= 100.0)
self.assertTrue(self.net.ping(
[self.h[0]], manualdestip="10.0.0.204", timeout=1) >= 100.0)
# stop Mininet network
self.stopNet()
#@unittest.skip("disabled TCLink tests for development")
class testContainernetTCLinks( simpleTestTopology ):
"""
Tests to check TCLinks together with Docker containers.
"""
def testCustomDelay( self ):
"""
d0,d1 -- s0 --delay-- d2
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=3)
# setup links
self.net.addLink(self.s[0], self.d[0])
self.net.addLink(self.s[0], self.d[1])
self.net.addLink(self.s[0], self.d[2], cls=TCLink, delay="100ms")
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 3)
self.assertTrue(len(self.net.hosts) == 3)
# check connectivity by using ping: default link
_, _, res = self.net.pingFull([self.d[0]], manualdestip="10.0.0.2")[0]
self.assertTrue(res[3] <= 20)
# check connectivity by using ping: delayed TCLink
_, _, res = self.net.pingFull([self.d[0]], manualdestip="10.0.0.3")[0]
self.assertTrue(res[3] > 200 and res[3] < 500)
# stop Mininet network
self.stopNet()
def testCustomLoss( self ):
"""
d0,d1 -- s0 --loss-- d2
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=3)
# setup links
self.net.addLink(self.s[0], self.d[0])
self.net.addLink(self.s[0], self.d[1])
self.net.addLink(
self.s[0], self.d[2], cls=TCLink, loss=100) # 100% loss
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.getContainernetContainers()) == 3)
self.assertTrue(len(self.net.hosts) == 3)
# check connectivity by using ping: default link
self.assertTrue(self.net.ping(
[self.d[0]], manualdestip="10.0.0.2", timeout=1) <= 0.0)
# check connectivity by using ping: lossy TCLink (100%)
self.assertTrue(self.net.ping(
[self.d[0]], manualdestip="10.0.0.3", timeout=1) >= 100.0)
# stop Mininet network
self.stopNet()
#@unittest.skip("disabled container resource limit tests for development")
class testContainernetContainerResourceLimitAPI( simpleTestTopology ):
"""
Test to check the resource limitation API of the Docker integration.
TODO: Also check if values are set correctly in to running containers,
e.g., with: docker inspect mn.d1 CLI calls?
"""
def testCPUShare( self ):
"""
d1, d2 with CPU share limits
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=0)
# add dockers
d0 = self.net.addDocker('d0', ip='10.0.0.1', dimage="ubuntu:trusty", cpu_shares=10)
d1 = self.net.addDocker('d1', ip='10.0.0.2', dimage="ubuntu:trusty", cpu_shares=90)
# setup links (we always need one connection to suppress warnings)
self.net.addLink(d0, self.s[0])
self.net.addLink(d1, self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping: default link
self.assertTrue(self.net.ping([d0, d1]) <= 0.0)
# stop Mininet network
self.stopNet()
def testCPULimitCFSBased( self ):
"""
d1, d2 with CPU share limits
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=0)
# add dockers
d0 = self.net.addDocker(
'd0', ip='10.0.0.1', dimage="ubuntu:trusty",
cpu_period=50000, cpu_quota=10000)
d1 = self.net.addDocker(
'd1', ip='10.0.0.2', dimage="ubuntu:trusty",
cpu_period=50000, cpu_quota=10000)
# setup links (we always need one connection to suppress warnings)
self.net.addLink(d0, self.s[0])
self.net.addLink(d1, self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping: default link
self.assertTrue(self.net.ping([d0, d1]) <= 0.0)
# stop Mininet network
self.stopNet()
def testMemLimits( self ):
"""
d1, d2 with CPU share limits
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=0)
# add dockers
d0 = self.net.addDocker(
'd0', ip='10.0.0.1', dimage="ubuntu:trusty",
mem_limit=132182016)
d1 = self.net.addDocker(
'd1', ip='10.0.0.2', dimage="ubuntu:trusty",
mem_limit=132182016, memswap_limit=-1)
# setup links (we always need one connection to suppress warnings)
self.net.addLink(d0, self.s[0])
self.net.addLink(d1, self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping: default link
self.assertTrue(self.net.ping([d0, d1]) <= 0.0)
# stop Mininet network
self.stopNet()
def testRuntimeCPULimitUpdate(self):
"""
Test CPU limit update at runtime
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=0)
# add dockers
d0 = self.net.addDocker(
'd0', ip='10.0.0.1', dimage="ubuntu:trusty",
cpu_share=0.3)
d1 = self.net.addDocker(
'd1', ip='10.0.0.2', dimage="ubuntu:trusty",
cpu_period=50000, cpu_quota=10000)
# setup links (we always need one connection to suppress warnings)
self.net.addLink(d0, self.s[0])
self.net.addLink(d1, self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping: default link
self.assertTrue(self.net.ping([d0, d1]) <= 0.0)
# update limits
d0.updateCpuLimit(cpu_shares=512)
self.assertEqual(d0.cpu_shares, 512)
d1.updateCpuLimit(cpu_period=50001, cpu_quota=20000)
self.assertEqual(d1.cpu_period, 50001)
self.assertEqual(d1.cpu_quota, 20000)
# stop Mininet network
self.stopNet()
def testRuntimeMemoryLimitUpdate(self):
"""
Test mem limit update at runtime
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=0)
# add dockers
d0 = self.net.addDocker(
'd0', ip='10.0.0.1', dimage="ubuntu:trusty",
mem_limit=132182016)
d1 = self.net.addDocker(
'd1', ip='10.0.0.2', dimage="ubuntu:trusty",
memswap_limit=-1)
# setup links (we always need one connection to suppress warnings)
self.net.addLink(d0, self.s[0])
self.net.addLink(d1, self.s[0])
# start Mininet network
self.startNet()
# check number of running docker containers
self.assertTrue(len(self.net.hosts) == 2)
# check connectivity by using ping: default link
self.assertTrue(self.net.ping([d0, d1]) <= 0.0)
# update limits
d0.updateMemoryLimit(mem_limit=66093056)
self.assertEqual(d0.mem_limit, 66093056)
d1.updateMemoryLimit(memswap_limit=-1)
self.assertEqual(d1.memswap_limit, -1)
# stop Mininet network
self.stopNet()
#@unittest.skip("disabled container resource limit tests for development")
class testContainernetVolumeAPI( simpleTestTopology ):
"""
Test the volume API.
"""
def testContainerVolumes( self ):
"""
d1, d2 with volumes
"""
# create network
self.createNet(nswitches=1, nhosts=0, ndockers=0)
# add dockers
d0 = self.net.addDocker('d0', ip='10.0.0.1', dimage="ubuntu:trusty", volumes=["/:/mnt/vol1:rw"])
d1 = self.net.addDocker('d1', ip='10.0.0.2', dimage="ubuntu:trusty", volumes=["/:/mnt/vol1:rw", "/:/mnt/vol2:rw"])
# start Mininet network
self.startNet()
# check if we can see the root file system
self.assertTrue("etc" in d0.cmd("ls /mnt/vol1"))
self.assertTrue("etc" in d1.cmd("ls /mnt/vol1"))
self.assertTrue("etc" in d1.cmd("ls /mnt/vol2"))
# stop Mininet network
self.stopNet()
if __name__ == '__main__':
unittest.main()
|
# Generated by Django 3.2.6 on 2021-08-28 12:30
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('preguntas', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='pregunta',
name='texto',
field=models.CharField(max_length=300),
),
migrations.AlterField(
model_name='respuesta',
name='texto',
field=models.CharField(max_length=300),
),
]
|
# The maximum sum subarray problem consists in finding the maximum sum of a
# contiguous subsequence in an array or list of integers:
#
# maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4])
# # should be 6: [4, -1, 2, 1]
# Easy case is when the list is made up of only positive numbers and the
# maximum sum is the sum of the whole array. If the list is made up of only
# negative numbers, return 0 instead.
#
# Empty list is considered to have zero greatest sum. Note that the empty
# list or array is also a valid sublist/subarray.
def maxSequence(arr):
max, curr = 0, 0
for i in arr:
curr += i # add number from array
if curr < 0: # check if curr value is less than zero
curr = 0 # if so, set curr back to zero
if curr > max: # check if curr value is higher than max value
max = curr # if so, set max to curr value
return max
print(maxSequence([])) # 0
print(maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4])) # 6
|
from ._EncoderLinear import *
from ._Homography import *
from ._Obstacle import *
from ._ObstacleArray import *
from ._RoadLane import *
from ._RoadLine import *
from ._TimeCompare import *
from ._VehicleEncoder import *
from ._mav_RAW_DATA import *
from ._mav_cc16_COMMAND import *
from ._mav_cc16_CONFIG import *
from ._mav_cc16_CONFIG_COUNT import *
from ._mav_cc16_CONFIG_PARAM_BOOL import *
from ._mav_cc16_CONFIG_PARAM_FLOAT import *
from ._mav_cc16_CONFIG_PARAM_INT import *
from ._mav_cc16_CONFIG_PARAM_SET_BOOL import *
from ._mav_cc16_CONFIG_PARAM_SET_FLOAT import *
from ._mav_cc16_CONFIG_PARAM_SET_INT import *
from ._mav_cc16_CONFIG_REQUEST import *
from ._mav_cc16_CONFIG_REQUEST_COUNT import *
from ._mav_cc16_CONFIG_REQUEST_PARAMS import *
from ._mav_cc16_CONTROL_COMMAND import *
from ._mav_cc16_CONTROL_LIGHTS import *
from ._mav_cc16_DEBUG import *
from ._mav_cc16_HEARTBEAT import *
from ._mav_cc16_IMU import *
from ._mav_cc16_NOTIFICATION import *
from ._mav_cc16_ODOMETER import *
from ._mav_cc16_ODOMETER_ABS import *
from ._mav_cc16_ODOMETER_DELTA import *
from ._mav_cc16_ODOMETER_DELTA_RAW import *
from ._mav_cc16_ODOMETER_RAW import *
from ._mav_cc16_PARKING_LOT import *
from ._mav_cc16_PROXIMITY import *
from ._mav_cc16_TELEMETRY import *
|
from django.contrib import admin
from .models import *
class CompanyAdmin(admin.ModelAdmin):
list_display = ("name", "description")
class CompanyOrderAdmin(admin.ModelAdmin):
list_display = ("name", "id")
class OrderAdmin(admin.ModelAdmin):
list_display = ("recipe", "id")
class RecipeAdmin(admin.ModelAdmin):
list_display = ("name", "description")
class IngredientAdmin(admin.ModelAdmin):
list_display = ("name", "description")
class IngredientAmountAdmin(admin.ModelAdmin):
list_display = ("recipe", "amount", 'ingredient')
admin.site.register(Company, CompanyAdmin)
admin.site.register(CompanyOrder, CompanyOrderAdmin)
admin.site.register(Order, OrderAdmin)
admin.site.register(Recipe, RecipeAdmin)
admin.site.register(Ingredient, IngredientAdmin)
admin.site.register(IngredientAmount, IngredientAmountAdmin)
|
import json
import requests
from datetime import datetime
s = requests.Session()
squizz_sessions = []
base_url = "http://127.0.0.1:5000/"
null = None
def test_login():
url = 'api/login'
headers = {"Content-Type": "application/json"}
data = {"username": "user1", "password": "123456789"}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "failure"
data = {"username": "user1", "password": "squizz"}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
content = json_response['data']
squizz_sessions.append(content['session_id'])
# print(json_response['session_id'])
def test_barcode_search():
if len(squizz_sessions) == 0:
test_login()
url = 'api/barcode'
para = '?sessionKey=' + squizz_sessions[0] + '&barcode=933044000895'
response = s.get(base_url + url + para)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
para1 = '?sessionKey=' + squizz_sessions[0] + '&barcode=123'
response = s.get(base_url + url + para1)
json_response = json.loads(response.text)
assert json_response['status'] == "error"
# CANT USE THIS AS IT STORES DATA IN DATABASE
def test_product():
if len(squizz_sessions) == 0:
test_login()
base_url = "http://127.0.0.1:5000/"
url = 'api/product'
para = '?sessionKey=' + squizz_sessions[0] + '&productCode=00089'
response = s.get(base_url + url + para)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
para = '?sessionKey=' + squizz_sessions[0] + '&productCode=-1'
response = s.get(base_url + url + para)
json_response = json.loads(response.text)
assert json_response['status'] == "error"
def test_history_order():
if len(squizz_sessions) == 0:
test_login()
url = 'api/history'
response = s.post(base_url + url)
json_response = json.loads(response.text)
assert json_response['status'] == "error"
para = '?session_id=' + squizz_sessions[0]
response = s.get(base_url + url + para)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
# def test_submit_order():
# if len(squizz_sessions) == 0:
# test_login()
# url = 'api/purchase'
# headers = {"Content-Type": "application/json"}
# order_details = [
# {
# "keyProductId": "21479231996639",
# "productName": "test",
# "quantity": "2",
# "unitPrice": "1.38",
# "totalPrice": "2.76",
# "priceTotalIncTax": "0.00",
# "priceTotalExTax": "0.00",
# "productCode": "21479231996639",
# "productId": "20",
# }
# ]
# data = {'lines': order_details, 'sessionKey': squizz_sessions[0]}
#
# response = s.post(base_url + url, data=json.dumps(data), headers=headers)
# json_response = json.loads(response.text)
# assert json_response['status'] == "error"
# data = {'lines': order_details}
# response = s.post(base_url + url, data=json.dumps(data), headers=headers)
# json_response = json.loads(response.text)
# assert json_response['status'] == "failure"
#
# data = {}
# response = s.post(base_url + url, data=json.dumps(data), headers=headers)
# json_response = json.loads(response.text)
# assert json_response['status'] == "failure"
#
# data = {'sessionKey': squizz_sessions[0]}
# response = s.post(base_url + url, data=json.dumps(data), headers=headers)
# json_response = json.loads(response.text)
# assert json_response['status'] == "failure"
#
# order_details = [{
# "barcode": "9326243001224",
# "depth": 0,
# "height": 0,
# "id": 5,
# "keyProductID": "21479231981826",
# "lineType": "PRODUCT",
# "price": 8.23,
# "priceTotalExTax": 8.23,
# "productCode": "01224",
# "productName": "Tarpaulin 240cm x 300cm (8' x 10')",
# "quantity": 1,
# "stockLowQuantity": 0,
# "stockQuantity": 0,
# "totalPrice": 8.23,
# "unitPrice": 8.23,
# "volume": 0,
# "weight": 0,
# "width": 0}]
# data = {'lines': order_details, 'sessionKey': squizz_sessions[0]}
# response = s.post(base_url + url, data=json.dumps(data), headers=headers)
# json_response = json.loads(response.text)
# assert json_response['status'] == "success"
def test_logout():
url = 'api/logout'
response = s.get(base_url + url)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
squizz_sessions.pop()
def test_import_metadata():
url = '/metadata/import'
headers = {"Content-Type": "application/json"}
data = {
"Username": "user1",
"Password": "squizz",
"Products": [
{
"Code": "CFP-600-12",
"ProductParameters": [{
"Key": "Name",
"Value": "CFP - 600/12 Swirl Diffusers with Low Profile Plenum 250 Spigot"
}, {
"Key": "URL",
"Value": "http://www.holyoake.com"
}, {
"Key": "Type Comments",
"Value": "Holyoake Swirl Diffuser CFP-600/12 c/w Low Profile Plenum."
}, {
"Key": "Static Pressure Min",
"Value": "2 Pa"
}, {
"Key": "Static Pressure Max",
"Value": "28 Pa"
}, {
"Key": "Noise Level NC Min",
"Value": "5 NC"
}, {
"Key": "Noise Level NC Max",
"Value": "32NC"
}, {
"Key": "Model",
"Value": "CFP-600/12 Low Profile complete with low profile plenum."
}, {
"Key": "Min Flow (Hvac Air Flow Liters Per Second)",
"Value": "25.000000000000"
}, {
"Key": "Max Flow (Hvac Air Flow Liters Per Second)",
"Value": "200.000000000000"
}, {
"Key": "Material Body",
"Value": "Holyoake-Aluminium"
}, {
"Key": "Material - Face",
"Value": "Holyoake White"
}, {
"Key": "Manufacturer",
"Value": "Holyoake"
}, {
"Key": "d_r (Length Millimeters)",
"Value": "125.000000000000"
}, {
"Key": "Inlet Spigot Diameter (Length Millimeters)",
"Value": "250.000000000000"
}, {
"Key": "Plenum Box Height (Length Millimeters)",
"Value": "250.000000000000"
}, {
"Key": "Holyoake Product Range",
"Value": "Holyoake Swirl Diffusers."
}, {
"Key": "Flow Nom (Hvac Air Flow Liters Per Second)",
"Value": "112.500000000000"
}, {
"Key": "Diffuser Width (Length Millimeters)",
"Value": "595.000000000000"
}, {
"Key": "Plenum Box Width (Length Millimeters)",
"Value": "570.000000000000"
}, {
"Key": "Description",
"Value": "Radial Swirl Diffusers, Ceiling Fixed Pattern shall be Holyoake Model CFP-600/12. Ceiling Radial Swirl Diffusers shall be designed for use in Variable Air Volume (VAV) systems with Highly Turbulent Radial Air Flow Pattern and shall be suitable for ceiling heights of 2.4 to 4m. Ceiling Radial Swirl Diffusers shall maintain a COANDA effect at reduced air volumes and provide uniform temperature gradients throughout the occupied space. Diffusers shall be finished in powder coat and fitted with accessories and dampers where indicated as manufactured by Holyoake"
}]
}
]
}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
data = {
"Username": "user1",
"Password": "12345678",
"Products": [
{
"Code": "CFP-600-12",
"ProductParameters": [{
"Key": "Name",
"Value": "CFP - 600/12 Swirl Diffusers with Low Profile Plenum 250 Spigot"
}]
}
]
}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "failure"
data = {
"Username": "user1",
"Password": "squizz",
"Products": [
{
"Code": "CFP-600-12777777",
"ProductParameters": [{
"Key": "Name",
"Value": "CFP - 600/12 Swirl Diffusers with Low Profile Plenum 250 Spigot"
}]
}
]
}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "partial success"
def test_import_model():
url = '/threedmodel/import'
headers = {"Content-Type": "application/json"}
data = {"Username": "user1",
"Password": "squizz",
"Products": [{
"Code": "CFP-600-20-LPP",
"ProductParameters": null,
"ModelURL": "https://s3-ap-southeast-2.amazonaws.com/awstest.project/3dModels/600_20_low Profile.glb"
}]
}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "success"
data = {"Username": "user1",
"Password": "123456789",
"Products": [{
"Code": "CFP-600-20-LPP",
"ProductParameters": null,
"ModelURL": "https://s3-ap-southeast-2.amazonaws.com/awstest.project/3dModels/600_20_low Profile.glb"
}]
}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "failure"
data = {"Username": "user1",
"Password": "squizz",
"Products": [{
"Code": "CFP-600-20-77777",
"ProductParameters": null,
"ModelURL": "https://s3-ap-southeast-2.amazonaws.com/awstest.project/3dModels/600_20_low Profile.glb"
}]
}
response = s.post(base_url + url, data=json.dumps(data), headers=headers)
json_response = json.loads(response.text)
assert json_response['status'] == "partial success"
def test_get_metadata():
if len(squizz_sessions) == 0:
test_login()
base_url = "http://127.0.0.1:5000"
url = '/api/metadata/get'
para = '?productCode=CFP-600-12-LPP-200'
response = s.get(base_url + url + para)
json_response = json.loads(response.text)
assert json_response['found'] == True
para = '?productCode=CFP-600-12-LPP'
response = s.get(base_url + url + para)
json_response = json.loads(response.text)
assert json_response['found'] == False
|
# coding=utf-8
import unittest
import os
from ddt import ddt, data, unpack
import copy
import elifetools.parseJATS as parser
import elifetools.json_rewrite as json_rewrite
@ddt
class TestJsonRewrite(unittest.TestCase):
def setUp(self):
pass
@unpack
@data(
("", None, None, None),
(
"",
'<root><journal-meta><journal-id journal-id-type="publisher-id">eLife</journal-id></journal-meta></root>',
None,
None,
),
(
"not_a_rewrite_function",
'<root><journal-meta><journal-id journal-id-type="publisher-id">eLife</journal-id></journal-meta><article-meta><article-id pub-id-type="doi">10.7554/eLife.00051</article-id></article-meta></root>',
None,
None,
),
)
def test_rewrite_json(self, rewrite_type, xml_content, json_content, expected):
soup = None
if xml_content:
soup = parser.parse_xml(xml_content)
self.assertEqual(
json_rewrite.rewrite_json(rewrite_type, soup, json_content), expected
)
@unpack
@data(
(None, None, None),
("elife", "func", "rewrite_elife_func"),
("eLife", "func", "rewrite_elife_func"),
("other_journal", "func", "rewrite_other_journal_func"),
)
def test_rewrite_function_name(self, journal_id, rewrite_type, expected):
self.assertEqual(
json_rewrite.rewrite_function_name(journal_id, rewrite_type), expected
)
@unpack
@data(
({"used": [{"id": "dataro17"}]}, "10.7554/eLife.00348"),
({"used": [{"id": "dataro3"}]}, "10.7554/eLife.01311"),
({"used": [{"id": "dataro6"}]}, "10.7554/eLife.01311"),
({"used": [{"id": "dataro7"}]}, "10.7554/eLife.01311"),
({"used": [{"id": "dataro8"}]}, "10.7554/eLife.01311"),
({"used": [{"id": "dataro1"}]}, "10.7554/eLife.01440"),
({"used": [{"id": "dataro1", "date": "2000, 2005"}]}, "10.7554/eLife.01535"),
({"used": [{"id": "dataro11"}]}, "10.7554/eLife.02304"),
({"used": [{"id": "dataro2"}]}, "10.7554/eLife.03574"),
({"used": [{"id": "dataro4"}]}, "10.7554/eLife.03676"),
({"used": [{"id": "dataro2"}]}, "10.7554/eLife.03971"),
(
{"generated": [{"id": "dataro1", "date": "2014-2015"}]},
"10.7554/eLife.04660",
),
({"used": [{"id": "dataro2", "date": "NA"}]}, "10.7554/eLife.06421"),
({"used": [{"id": "data-ro1"}]}, "10.7554/eLife.08445"),
(
{"used": [{"id": "dataro2", "date": "2008, updated 2014"}]},
"10.7554/eLife.08916",
),
(
{"used": [{"id": "dataro3", "date": "2013, updated 2014"}]},
"10.7554/eLife.08916",
),
({"generated": [{"id": "dataro2"}]}, "10.7554/eLife.08955"),
({"used": [{"id": "dataro1"}]}, "10.7554/eLife.09207"),
({"generated": [{"id": "data-ro4"}]}, "10.7554/eLife.10607"),
({"used": [{"id": "data-ro1"}]}, "10.7554/eLife.10670"),
({"generated": [{"id": "dataro7"}]}, "10.7554/eLife.10856"),
({"generated": [{"id": "dataro8"}]}, "10.7554/eLife.10856"),
({"generated": [{"id": "dataro9"}]}, "10.7554/eLife.10856"),
({"generated": [{"id": "dataro1"}]}, "10.7554/eLife.10877"),
({"generated": [{"id": "dataro1"}]}, "10.7554/eLife.10921"),
({"used": [{"id": "dataro2"}]}, "10.7554/eLife.10921"),
({"used": [{"id": "dataro14"}]}, "10.7554/eLife.11117"),
({"used": [{"id": "dataro1"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro2"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro3"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro4"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro5"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro6"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro7"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro8"}]}, "10.7554/eLife.12204"),
({"used": [{"id": "dataro1"}]}, "10.7554/eLife.12876"),
({"generated": [{"id": "dataro1"}]}, "10.7554/eLife.13195"),
({"generated": [{"id": "data-ro1"}]}, "10.7554/eLife.14158"),
({"generated": [{"id": "data-ro2"}]}, "10.7554/eLife.14158"),
({"used": [{"id": "dataro3"}]}, "10.7554/eLife.14158"),
({"generated": [{"id": "dataro2"}]}, "10.7554/eLife.14243"),
(
{"generated": [{"id": "dataro1", "date": "current manuscript"}]},
"10.7554/eLife.16078",
),
({"used": [{"id": "data-ro4"}]}, "10.7554/eLife.17082"),
({"used": [{"id": "data-ro5"}]}, "10.7554/eLife.17082"),
({"used": [{"id": "data-ro6"}]}, "10.7554/eLife.17082"),
(
{"generated": [{"id": "dataro1", "date": "Release date: "}]},
"10.7554/eLife.17473",
),
)
def test_rewrite_elife_datasets_json(self, json_content, doi):
"""simple tests for coverage assert the result is different"""
original_json_content = copy.deepcopy(json_content)
self.assertNotEqual(
json_rewrite.rewrite_elife_datasets_json(json_content, doi),
original_json_content,
)
@unpack
@data(
([{}], "10.7554/eLife.00001", [{}]),
(
[{}],
"10.7554/eLife.00230",
[
{
"competingInterests": "The authors have declared that no competing interests exist"
}
],
),
(
[
{"name": {"index": "Chen, Zhijian J"}},
{"name": {"index": "Li, Xiao-Dong"}},
],
"10.7554/eLife.00102",
[
{
"name": {"index": "Chen, Zhijian J"},
"competingInterests": "ZJC: Reviewing Editor, <i>eLife</i>",
},
{
"name": {"index": "Li, Xiao-Dong"},
"competingInterests": "No competing interests declared.",
},
],
),
(
[{"name": {"index": "Patterson, Mark"}}],
"10.7554/eLife.00270",
[
{
"name": {"index": "Patterson, Mark"},
"competingInterests": "MP: Managing Executive Editor, <i>eLife</i>",
}
],
),
(
[{}],
"10.7554/eLife.507424566981410635",
[
{
"competingInterests": "The authors declare that no competing interests exist."
}
],
),
)
def test_rewrite_elife_authors_json(self, json_content, doi, expected):
original_json_content = copy.deepcopy(json_content)
self.assertEqual(
json_rewrite.rewrite_elife_authors_json(json_content, doi), expected
)
@unpack
@data(
([{}], "10.7554/eLife.23804", [{"role": "Reviewing Editor"}]),
(
[{"role": "Reviewing editor"}],
"10.7554/eLife.00001",
[{"role": "Reviewing Editor"}],
),
(
[{"role": "Specialised Role"}],
"10.7554/eLife.00001",
[{"role": "Specialised Role"}],
),
)
def test_rewrite_elife_editors_json(self, json_content, doi, expected):
"""simple tests for coverage assert the result is different"""
original_json_content = copy.deepcopy(json_content)
self.assertEqual(
json_rewrite.rewrite_elife_editors_json(json_content, doi), expected
)
if __name__ == "__main__":
unittest.main()
|
import hashlib
import os
import sys
from collections import namedtuple
from json import dumps, loads
from scopus.utils import download, get_content
AUTHOR_SEARCH_DIR = os.path.expanduser('~/.scopus/author_search')
if not os.path.exists(AUTHOR_SEARCH_DIR):
os.makedirs(AUTHOR_SEARCH_DIR)
class AuthorSearch(object):
@property
def authors(self):
"""A list of namedtuples storing author information,
where each namedtuple corresponds to one author.
The information in each namedtuple is (eid surname initials givenname
documents affiliation affiliation_id city country areas).
All entries are strings or None. Areas combines abbreviated subject
areas followed by the number of documents in this subject.
"""
out = []
order = 'eid surname initials givenname affiliation documents '\
'affiliation_id city country areas'
auth = namedtuple('Author', order)
for item in self._json:
name = item.get('preferred-name', {})
aff = item.get('affiliation-current', {})
fields = item.get('subject-area',
[{'@abbrev': '', '@frequency': ''}])
if isinstance(fields, dict):
fields = [fields]
areas = ["{} ({})".format(d.get('@abbrev', ''), d.get('@frequency', ''))
for d in fields]
new = auth(eid=item['eid'],
surname=name.get('surname'),
initials=name.get('initials'),
givenname=name.get('given-name'),
documents=item.get('document-count', '0'),
affiliation=aff.get('affiliation-name'),
affiliation_id=aff.get('affiliation-id'),
city=aff.get('affiliation-city'),
country=aff.get('affiliation-country'),
areas="; ".join(areas))
out.append(new)
return out
def __init__(self, query, count=200, start=0,
max_entries=5000, refresh=False):
"""Class to search a query, and retrieve a list of author IDs as results.
Parameters
----------
query : str
A string of the query, e.g. "authlast(Einstein) and
authfirst(Albert)".
count : int (optional, default=200)
The number of entries to be displayed at once. A smaller number
means more queries with each query having less results.
start : int (optional, default=0)
The entry number of the first search item to start with.
refresh : bool (optional, default=False)
Whether to refresh the cached file if it exists or not.
max_entries : int (optional, default=5000)
Raise error when the number of results is beyond this number.
The Scopus Search Engine does not allow more than 5000 entries.
Raises
------
Exception
If the number of search results exceeds max_entries.
Notes
-----
Json results are cached in ~/.scopus/author_search/{fname}, where
fname is the hashed version of query.
The results are stored as a property named authors.
"""
self.query = query
qfile = os.path.join(AUTHOR_SEARCH_DIR,
hashlib.md5(query.encode('utf8')).hexdigest())
if os.path.exists(qfile) and not refresh:
self._json = []
with open(qfile) as f:
for r in f.readlines():
self._json.append(loads(r))
else:
# No cached file exists, or we are refreshing.
# First, we get a count of how many things to retrieve
url = 'https://api.elsevier.com/content/search/author'
params = {'query': query, 'count': 0, 'start': 0}
res = get_content(qfile, url=url, refresh=refresh, params=params,
accept='json')
data = loads(res.decode('utf-8'))['search-results']
N = int(data.get('opensearch:totalResults', 0))
if N > max_entries:
raise Exception(('N = {}. '
'Set max_entries to a higher number or '
'change your query ({})').format(N, query))
self._json = []
while N > 0:
params = {'query': query, 'count': count, 'start': start}
resp = download(url=url, params=params, accept="json")
results = resp.json()
if 'entry' in results.get('search-results', []):
for r in results['search-results']['entry']:
self._json.append({f: r[f] for f in r.keys()})
start += count
N -= count
with open(qfile, 'wb') as f:
for author in self._json:
f.write('{}\n'.format(dumps(author)).encode('utf-8'))
def __str__(self):
s = """{query}
Resulted in {N} hits.
{entries}"""
return s.format(query=self.query, N=len(self._json),
entries='\n '.join([str(a) for a in self._json]))
|
# -*- coding: utf-8 -*-
import pytest
import sys
from .test_base_class import TestBaseClass
from aerospike import exception as e
aerospike = pytest.importorskip("aerospike")
try:
import aerospike
except:
print("Please install aerospike python client.")
sys.exit(1)
class TestUdfList(TestBaseClass):
def setup_class(cls):
"""
Setup class
"""
hostlist, user, password = TestBaseClass.get_hosts()
config = {'hosts': hostlist}
if user is None and password is None:
TestUdfList.client = aerospike.client(config).connect()
else:
TestUdfList.client = aerospike.client(config).connect(user,
password)
TestUdfList.client.udf_put('example.lua', 0, {})
def teardown_class(cls):
"""
Teardown class
"""
TestUdfList.client.udf_remove("example.lua")
TestUdfList.client.close()
def test_udf_list_without_any_paramter(self):
ulist = TestUdfList.client.udf_list()
assert type(ulist) is list
def test_udf_list_with_proper_parameters(self):
policy = {'timeout': 0}
udf_list = TestUdfList.client.udf_list(policy)
present = False
for udf in udf_list:
if 'example.lua' == udf['name']:
present = True
assert True if present else False
def test_udf_list_with_timeout_policy(self):
policy = {'timeout': 1000}
udf_list = TestUdfList.client.udf_list(policy)
present = False
for udf in udf_list:
if 'example.lua' == udf['name']:
present = True
assert True if present else False
def test_udf_list_with_invalid_timeout_policy_value(self):
policy = {'timeout': 0.1}
try:
TestUdfList.client.udf_list(policy)
except e.ParamError as exception:
assert exception.code == -2
assert exception.msg == 'timeout is invalid'
def test_udf_list_with_proper_parameters_without_connection(self):
config = {'hosts': [('127.0.0.1', 3000)]}
client1 = aerospike.client(config)
policy = {'timeout': 0}
try:
client1.udf_list(policy)
except e.ClusterError as exception:
assert exception.code == 11
assert exception.msg == 'No connection to aerospike cluster'
|
""" Tests of the command-line interface
:Author: Jonathan Karr <karr@mssm.edu>
:Date: 2021-05-28
:Copyright: 2021, Center for Reproducible Biomedical Modeling
:License: MIT
"""
from biosimulators_pyneuroml import core
from biosimulators_pyneuroml.data_model import Simulator, SIMULATOR_ENABLED, KISAO_ALGORITHM_MAP
from biosimulators_utils.combine import data_model as combine_data_model
from biosimulators_utils.combine.io import CombineArchiveWriter
from biosimulators_utils.config import get_config
from biosimulators_utils.log.data_model import TaskLog
from biosimulators_utils.report import data_model as report_data_model
from biosimulators_utils.report.io import ReportReader
from biosimulators_utils.simulator.exec import exec_sedml_docs_in_archive_with_containerized_simulator
from biosimulators_utils.simulator.specs import gen_algorithms_from_specs
from biosimulators_utils.sedml import data_model as sedml_data_model
from biosimulators_utils.sedml.io import SedmlSimulationWriter
from unittest import mock
import datetime
import dateutil.tz
import importlib
import numpy
import numpy.testing
import os
import parameterized
import shutil
import tempfile
import unittest
class CoreCliTestCase(unittest.TestCase):
DOCKER_IMAGES = {
Simulator.brian2: 'ghcr.io/biosimulators/biosimulators_pyneuroml/brian2:latest',
Simulator.netpyne: 'ghcr.io/biosimulators/biosimulators_pyneuroml/netpyne:latest',
Simulator.neuron: 'ghcr.io/biosimulators/biosimulators_pyneuroml/neuron:latest',
Simulator.pyneuroml: 'ghcr.io/biosimulators/biosimulators_pyneuroml/pyneuroml:latest',
}
FIXTURES_DIRNAME = os.path.join(os.path.dirname(__file__), 'fixtures')
def setUp(self):
self.dirname = tempfile.mkdtemp()
def tearDown(self):
shutil.rmtree(self.dirname)
def test_exec_sed_task(self):
task, variables = self._get_simulation()
log = TaskLog()
results, log = core.exec_sed_task(task, variables, log=log)
self._assert_variable_results(task, variables, results)
def test_exec_sed_task_with_changes(self):
# TODO: add test for continuation of time course
# - Simulation 1: 0-10 ms
# - Simulation 2: 0-5 ms
# - Simulation 3: 5-10 ms starting from simulation #2
task, variables = self._get_simulation()
preprocessed_task = core.preprocess_sed_task(task, variables)
core.exec_sed_task(task, variables, preprocessed_task=preprocessed_task)
task.model.changes.append(sedml_data_model.ModelAttributeChange(
target="/Lems/Include[@file='Cells.xml']/@file",
new_value='Undefined.xml',
))
with self.assertRaises(RuntimeError):
core.exec_sed_task(task, variables, preprocessed_task=preprocessed_task)
@parameterized.parameterized.expand([
(name,)
for name, simulator in Simulator.__members__.items()
if SIMULATOR_ENABLED[simulator]
])
def test_exec_sed_task_with_simulator(self, simulator_name):
task, variables = self._get_simulation()
log = TaskLog()
results, log = core.exec_sed_task(task, variables, log=log, simulator=Simulator[simulator_name])
self._assert_variable_results(task, variables, results)
def test_exec_sed_task_non_zero_output_start_time(self):
task, variables = self._get_simulation()
task.simulation.output_start_time = 100e-3
task.simulation.number_of_steps = int(200 / 0.01)
log = TaskLog()
results, log = core.exec_sed_task(task, variables, log=log)
self._assert_variable_results(task, variables, results)
def test_exec_sedml_docs_in_combine_archive(self):
doc, archive_filename = self._build_combine_archive()
out_dir = os.path.join(self.dirname, 'out')
config = get_config()
config.REPORT_FORMATS = [report_data_model.ReportFormat.h5]
config.BUNDLE_OUTPUTS = True
config.KEEP_INDIVIDUAL_OUTPUTS = True
_, log = core.exec_sedml_docs_in_combine_archive(archive_filename, out_dir, config=config)
if log.exception:
raise log.exception
self._assert_combine_archive_outputs(doc, out_dir)
def test_exec_sedml_docs_in_combine_archive_with_all_algorithms(self):
for simulator in [Simulator.pyneuroml]:
specs_filename = os.path.join(os.path.dirname(__file__), '..', 'biosimulators-{}.json'.format(simulator.name))
for alg in gen_algorithms_from_specs(specs_filename).values():
alg_props = KISAO_ALGORITHM_MAP[alg.kisao_id]
doc, archive_filename = self._build_combine_archive(algorithm=alg)
out_dir = os.path.join(self.dirname, 'out')
config = get_config()
config.REPORT_FORMATS = [report_data_model.ReportFormat.h5]
config.BUNDLE_OUTPUTS = True
config.KEEP_INDIVIDUAL_OUTPUTS = True
_, log = core.exec_sedml_docs_in_combine_archive(archive_filename, out_dir, config=config, simulator=simulator)
if log.exception:
raise log.exception
self._assert_combine_archive_outputs(doc, out_dir)
def _get_simulation(self, algorithm=None):
if os.path.isdir(os.path.join(self.dirname, 'fixtures')):
shutil.rmtree(os.path.join(self.dirname, 'fixtures'))
shutil.copytree(self.FIXTURES_DIRNAME, os.path.join(self.dirname, 'fixtures'))
model_source = os.path.join(self.dirname, 'fixtures', 'LEMS_NML2_Ex5_DetCell.xml')
if algorithm is None:
algorithm = sedml_data_model.Algorithm(
kisao_id='KISAO_0000030',
changes=[],
)
task = sedml_data_model.Task(
model=sedml_data_model.Model(id='net1', source=model_source, language=sedml_data_model.ModelLanguage.LEMS.value),
simulation=sedml_data_model.UniformTimeCourseSimulation(
initial_time=0.,
output_start_time=0.,
output_end_time=300e-3,
number_of_steps=int(300 / 0.01),
algorithm=algorithm,
),
)
variables = [
sedml_data_model.Variable(
id='time',
symbol=sedml_data_model.Symbol.time.value,
task=task,
),
sedml_data_model.Variable(
id='v',
target="hhpop[0]/v",
task=task,
),
sedml_data_model.Variable(
id='m',
target="hhpop[0]/bioPhys1/membraneProperties/NaConductances/NaConductance/m/q",
task=task,
),
sedml_data_model.Variable(
id='h',
target="hhpop[0]/bioPhys1/membraneProperties/NaConductances/NaConductance/h/q",
task=task,
),
sedml_data_model.Variable(
id='n',
target="hhpop[0]/bioPhys1/membraneProperties/KConductances/KConductance/n/q",
task=task,
),
]
return task, variables
def _build_sed_doc(self, algorithm=None):
task, variables = self._get_simulation(algorithm=algorithm)
doc = sedml_data_model.SedDocument()
model = task.model
model.id = 'net1'
doc.models.append(model)
sim = task.simulation
sim.id = 'simulation'
doc.simulations.append(sim)
task.id = 'task'
doc.tasks.append(task)
report = sedml_data_model.Report(id='report1')
doc.outputs.append(report)
for variable in variables:
data_gen = sedml_data_model.DataGenerator(
id='data_generator_' + variable.id,
variables=[
variable,
],
math=variable.id,
)
doc.data_generators.append(data_gen)
report.data_sets.append(sedml_data_model.DataSet(id='data_set_' + variable.id, label=variable.id, data_generator=data_gen))
return doc
def _build_combine_archive(self, algorithm=None):
doc = self._build_sed_doc(algorithm=algorithm)
archive_dirname = os.path.join(self.dirname, 'archive')
if not os.path.isdir(archive_dirname):
os.mkdir(archive_dirname)
model_filename = os.path.join(archive_dirname, 'model1.xml')
shutil.copyfile(doc.models[0].source, model_filename)
doc.models[0].source = 'model1.xml'
archive = combine_data_model.CombineArchive(
contents=[
combine_data_model.CombineArchiveContent(
'model1.xml', combine_data_model.CombineArchiveContentFormat.LEMS.value),
combine_data_model.CombineArchiveContent(
'simulation.sedml', combine_data_model.CombineArchiveContentFormat.SED_ML.value),
],
)
included_rel_model_files = [
'NaConductance.channel.nml',
'KConductance.channel.nml',
'LeakConductance.channel.nml',
'NML2_SingleCompHHCell.nml',
]
for included_rel_model_file in included_rel_model_files:
shutil.copyfile(
os.path.join(self.FIXTURES_DIRNAME, included_rel_model_file),
os.path.join(archive_dirname, included_rel_model_file))
archive.contents.append(
combine_data_model.CombineArchiveContent(
location=included_rel_model_file,
format=combine_data_model.CombineArchiveContentFormat.NeuroML.value,
),
)
sim_filename = os.path.join(archive_dirname, 'simulation.sedml')
SedmlSimulationWriter().run(doc, sim_filename)
archive_filename = os.path.join(self.dirname, 'archive.omex')
CombineArchiveWriter().run(archive, archive_dirname, archive_filename)
return (doc, archive_filename)
def _assert_variable_results(self, task, variables, results):
sim = task.simulation
self.assertTrue(set(results.keys()), set([var.id for var in variables]))
numpy.testing.assert_allclose(results['time'], numpy.linspace(sim.output_start_time, sim.output_end_time, sim.number_of_points + 1))
for result in results.values():
self.assertEqual(result.shape, (sim.number_of_points + 1,))
self.assertFalse(numpy.any(numpy.isnan(result)))
def _assert_combine_archive_outputs(self, doc, out_dir):
sim = doc.simulations[0]
report = doc.outputs[0]
# check HDF report
report_results = ReportReader().run(report, out_dir, 'simulation.sedml/report1', format=report_data_model.ReportFormat.h5)
self.assertEqual(sorted(report_results.keys()), sorted([d.id for d in report.data_sets]))
numpy.testing.assert_allclose(report_results['data_set_time'], numpy.linspace(
sim.output_start_time, sim.output_end_time, sim.number_of_points + 1))
for result in report_results.values():
self.assertEqual(result.shape, (sim.number_of_points + 1,))
self.assertFalse(numpy.any(numpy.isnan(result)))
def test_raw_cli(self):
for simulator in Simulator.__members__.values():
cli = importlib.import_module('biosimulators_pyneuroml.cli.{}'.format(simulator.name))
with mock.patch('sys.argv', ['', '--help']):
with self.assertRaises(SystemExit) as context:
cli.main()
self.assertRegex(context.Exception, 'usage: ')
def test_exec_sedml_docs_in_combine_archive_with_cli(self):
doc, archive_filename = self._build_combine_archive()
env = self._get_combine_archive_exec_env()
for simulator in [Simulator.pyneuroml]:
out_dir = os.path.join(self.dirname, 'out-' + simulator.name)
cli = importlib.import_module('biosimulators_pyneuroml.cli.{}'.format(simulator.name))
with mock.patch.dict(os.environ, env):
cli.main(argv=['-i', archive_filename, '-o', out_dir])
self._assert_combine_archive_outputs(doc, out_dir)
@parameterized.parameterized.expand([
(name,)
for name, simulator in Simulator.__members__.items()
if SIMULATOR_ENABLED[simulator]
])
def test_exec_sedml_docs_in_combine_archive_with_docker_image(self, simulator_name):
doc, archive_filename = self._build_combine_archive()
env = self._get_combine_archive_exec_env()
simulator = Simulator[simulator_name]
out_dir = os.path.join(self.dirname, 'out-' + simulator.name)
exec_sedml_docs_in_archive_with_containerized_simulator(
archive_filename, out_dir,
self.DOCKER_IMAGES[simulator])
self._assert_combine_archive_outputs(doc, out_dir)
def _get_combine_archive_exec_env(self):
return {
'REPORT_FORMATS': 'h5'
}
|
from torchvision.datasets import CIFAR10 # for test
from .img_dirs import ImgDirsDataset
|
#!/usr/bin/env python
import csv
import os
import sys
def get_description(line, parent):
cols = line.split('\t')
labels = {}
for pair in cols[8].split(";"):
k, v = pair.split('=')
labels[k] = v
if (cols[2]) == "CDS" and labels["Parent"] == parent:
return labels.get("Note", '-')
return '-'
def convert_to_prot_table(fname, output_name):
gff_file = open(fname)
output_file = open(output_name, 'w')
writer = csv.writer(output_file, delimiter='\t')
lines = gff_file.readlines()
gff_file.close()
for i, line in enumerate(lines):
line = line.strip()
if line.startswith('#'):
continue
cols = line.split('\t')
if (len(cols) < 9):
print("Ignoring invalid row with entries: {0}".format(cols))
elif (cols[2]) == "region":
continue
elif (cols[2]) == "CDS":
continue
elif (cols[2]) == "gene":
start = int(cols[3])
end = int(cols[4])
strand = cols[6].strip()
labels = {}
diff = int(abs(end - start) / 3) # What is this called?
for pair in cols[8].split(";"):
k, v = pair.split('=')
labels[k.strip()] = v.strip()
Rv = labels["locus_tag"].strip() # error out if not found
gene = labels.get('Name', '')
desc = get_description(lines[i + 1], labels.get("ID", "")) if (i + 1) < len(lines) else '-'
vals = [desc, start, end, strand, diff, '-', '-', gene, Rv, '-']
writer.writerow(vals)
output_file.close()
if __name__ == "__main__":
usage_string = "Usage: python gff-prot-converter.py <gff filename> <output filename>"
if len(sys.argv) < 3:
print(usage_string)
sys.exit(0)
file_name = sys.argv[1]
if not os.path.exists(file_name):
print("File not found. Exiting...")
print(usage_string)
sys.exit(0)
convert_to_prot_table(file_name, sys.argv[2])
|
import sys
from pyramid.compat import reraise
from pyramid.exceptions import PredicateMismatch
from pyramid.interfaces import (
IExceptionViewClassifier,
IRequest,
)
from zope.interface import providedBy
from pyramid.view import _call_view
def excview_tween_factory(handler, registry):
""" A :term:`tween` factory which produces a tween that catches an
exception raised by downstream tweens (or the main Pyramid request
handler) and, if possible, converts it into a Response using an
:term:`exception view`."""
def excview_tween(request):
attrs = request.__dict__
try:
response = handler(request)
except Exception as exc:
# WARNING: do not assign the result of sys.exc_info() to a local
# var here, doing so will cause a leak. We used to actually
# explicitly delete both "exception" and "exc_info" from ``attrs``
# in a ``finally:`` clause below, but now we do not because these
# attributes are useful to upstream tweens. This actually still
# apparently causes a reference cycle, but it is broken
# successfully by the garbage collector (see
# https://github.com/Pylons/pyramid/issues/1223).
attrs['exc_info'] = sys.exc_info()
attrs['exception'] = exc
# clear old generated request.response, if any; it may
# have been mutated by the view, and its state is not
# sane (e.g. caching headers)
if 'response' in attrs:
del attrs['response']
# we use .get instead of .__getitem__ below due to
# https://github.com/Pylons/pyramid/issues/700
request_iface = attrs.get('request_iface', IRequest)
provides = providedBy(exc)
try:
response = _call_view(
registry,
request,
exc,
provides,
'',
view_classifier=IExceptionViewClassifier,
request_iface=request_iface.combined
)
# if views matched but did not pass predicates, squash the error
# and re-raise the original exception
except PredicateMismatch:
response = None
# re-raise the original exception as no exception views were
# able to handle the error
if response is None:
reraise(*attrs['exc_info'])
return response
return excview_tween
MAIN = 'MAIN'
INGRESS = 'INGRESS'
EXCVIEW = 'pyramid.tweens.excview_tween_factory'
|
from common import *
##############################################################3
# https://github.com/Cadene/pretrained-models.pytorch
# https://github.com/Cadene/pretrained-models.pytorch/blob/master/pretrainedmodels/models/dpn.py
# 'dpn68b': {
# 'imagenet+5k': {
# 'url': 'http://data.lip6.fr/cadene/pretrainedmodels/dpn68b_extra-84854c156.pth',
# 'input_space': 'RGB',
# 'input_size': [3, 224, 224],
# 'input_range': [0, 1],
# 'mean': [124 / 255, 117 / 255, 104 / 255],
# 'std': [1 / (.0167 * 255)] * 3,
# 'num_classes': 1000
# }
# },
# 'dpn92': {
#
# 'imagenet+5k': {
# 'url': 'http://data.lip6.fr/cadene/pretrainedmodels/dpn92_extra-b040e4a9b.pth',
# 'input_space': 'RGB',
# 'input_size': [3, 224, 224],
# 'input_range': [0, 1],
# 'mean': [124 / 255, 117 / 255, 104 / 255],
# 'std': [1 / (.0167 * 255)] * 3,
# 'num_classes': 1000
# }
# },
BatchNorm2d = SynchronizedBatchNorm2d
#BatchNorm2d = nn.BatchNorm2d
class CatBnAct(nn.Module):
def __init__(self, in_chs, activation_fn=nn.ReLU(inplace=True)):
super(CatBnAct, self).__init__()
self.bn = BatchNorm2d(in_chs, eps=0.001)
self.act = activation_fn
def forward(self, x):
x = torch.cat(x, dim=1) if isinstance(x, tuple) else x
return self.act(self.bn(x))
class BnActConv2d(nn.Module):
def __init__(self, in_chs, out_chs, kernel_size, stride,
padding=0, groups=1, activation_fn=nn.ReLU(inplace=True)):
super(BnActConv2d, self).__init__()
self.bn = BatchNorm2d(in_chs, eps=0.001)
self.act = activation_fn
self.conv = nn.Conv2d(in_chs, out_chs, kernel_size, stride, padding, groups=groups, bias=False)
def forward(self, x):
return self.conv(self.act(self.bn(x)))
class InputBlock(nn.Module):
def __init__(self, num_init_features, kernel_size=7,
padding=3, activation_fn=nn.ReLU(inplace=True)):
super(InputBlock, self).__init__()
self.conv = nn.Conv2d(3, num_init_features, kernel_size=kernel_size, stride=2, padding=padding, bias=False)
self.bn = BatchNorm2d(num_init_features, eps=0.001)
self.act = activation_fn
self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
def forward(self, x):
x = self.conv(x)
x = self.bn(x)
x = self.act(x)
x = self.pool(x)
return x
class DualPathBlock(nn.Module):
def __init__(
self, in_chs, num_1x1_a, num_3x3_b, num_1x1_c, inc, groups, block_type='normal', b=False):
super(DualPathBlock, self).__init__()
self.num_1x1_c = num_1x1_c
self.inc = inc
self.b = b
if block_type is 'proj':
self.key_stride = 1
self.has_proj = True
elif block_type is 'down':
self.key_stride = 2
self.has_proj = True
else:
assert block_type is 'normal'
self.key_stride = 1
self.has_proj = False
if self.has_proj:
# Using different member names here to allow easier parameter key matching for conversion
if self.key_stride == 2:
self.c1x1_w_s2 = BnActConv2d(
in_chs=in_chs, out_chs=num_1x1_c + 2 * inc, kernel_size=1, stride=2)
else:
self.c1x1_w_s1 = BnActConv2d(
in_chs=in_chs, out_chs=num_1x1_c + 2 * inc, kernel_size=1, stride=1)
self.c1x1_a = BnActConv2d(in_chs=in_chs, out_chs=num_1x1_a, kernel_size=1, stride=1)
self.c3x3_b = BnActConv2d(
in_chs=num_1x1_a, out_chs=num_3x3_b, kernel_size=3,
stride=self.key_stride, padding=1, groups=groups)
if b:
self.c1x1_c = CatBnAct(in_chs=num_3x3_b)
self.c1x1_c1 = nn.Conv2d(num_3x3_b, num_1x1_c, kernel_size=1, bias=False)
self.c1x1_c2 = nn.Conv2d(num_3x3_b, inc, kernel_size=1, bias=False)
else:
self.c1x1_c = BnActConv2d(in_chs=num_3x3_b, out_chs=num_1x1_c + inc, kernel_size=1, stride=1)
def forward(self, x):
x_in = torch.cat(x, dim=1) if isinstance(x, tuple) else x
if self.has_proj:
if self.key_stride == 2:
x_s = self.c1x1_w_s2(x_in)
else:
x_s = self.c1x1_w_s1(x_in)
x_s1 = x_s[:, :self.num_1x1_c, :, :]
x_s2 = x_s[:, self.num_1x1_c:, :, :]
else:
x_s1 = x[0]
x_s2 = x[1]
x_in = self.c1x1_a(x_in)
x_in = self.c3x3_b(x_in)
if self.b:
x_in = self.c1x1_c(x_in)
out1 = self.c1x1_c1(x_in)
out2 = self.c1x1_c2(x_in)
else:
x_in = self.c1x1_c(x_in)
out1 = x_in[:, :self.num_1x1_c, :, :]
out2 = x_in[:, self.num_1x1_c:, :, :]
resid = x_s1 + out1
dense = torch.cat([x_s2, out2], dim=1)
return resid, dense
class DPN(nn.Module):
def __init__(self, small=False, num_init_features=64, k_r=96, groups=32,
b=False, k_sec=(3, 4, 20, 3), inc_sec=(16, 32, 24, 128),
num_classes=1000, test_time_pool=False):
super(DPN, self).__init__()
self.test_time_pool = test_time_pool
self.b = b
bw_factor = 1 if small else 4
# conv1
blocks1 = collections.OrderedDict()
if small:
blocks1['conv1_1'] = InputBlock(num_init_features, kernel_size=3, padding=1)
else:
blocks1['conv1_1'] = InputBlock(num_init_features, kernel_size=7, padding=3)
# conv2
blocks2 = collections.OrderedDict()
bw = 64 * bw_factor
inc = inc_sec[0]
r = (k_r * bw) // (64 * bw_factor)
blocks2['conv2_1'] = DualPathBlock(num_init_features, r, r, bw, inc, groups, 'proj', b)
in_chs = bw + 3 * inc
for i in range(2, k_sec[0] + 1):
blocks2['conv2_' + str(i)] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'normal', b)
in_chs += inc
# conv3
blocks3 = collections.OrderedDict()
bw = 128 * bw_factor
inc = inc_sec[1]
r = (k_r * bw) // (64 * bw_factor)
blocks3['conv3_1'] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'down', b)
in_chs = bw + 3 * inc
for i in range(2, k_sec[1] + 1):
blocks3['conv3_' + str(i)] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'normal', b)
in_chs += inc
# conv4
blocks4 = collections.OrderedDict()
bw = 256 * bw_factor
inc = inc_sec[2]
r = (k_r * bw) // (64 * bw_factor)
blocks4['conv4_1'] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'down', b)
in_chs = bw + 3 * inc
for i in range(2, k_sec[2] + 1):
blocks4['conv4_' + str(i)] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'normal', b)
in_chs += inc
# conv5
blocks5 = collections.OrderedDict()
bw = 512 * bw_factor
inc = inc_sec[3]
r = (k_r * bw) // (64 * bw_factor)
blocks5['conv5_1'] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'down', b)
in_chs = bw + 3 * inc
for i in range(2, k_sec[3] + 1):
blocks5['conv5_' + str(i)] = DualPathBlock(in_chs, r, r, bw, inc, groups, 'normal', b)
in_chs += inc
#blocks5['conv5_bn_ac'] = CatBnAct(in_chs)
self.layer1 = nn.Sequential(blocks1)
self.layer2 = nn.Sequential(blocks2)
self.layer3 = nn.Sequential(blocks3)
self.layer4 = nn.Sequential(blocks4)
self.layer5 = nn.Sequential(blocks5)
# Using 1x1 conv for the FC layer to allow the extra pooling scheme
#self.classifier = nn.Conv2d(in_chs, num_classes, kernel_size=1, bias=True)
def forward(self, x):
x = self.layer1(x) ; print(x.shape)
r, d = self.layer2(x) ; print(r.shape,d.shape)
r, d = self.layer3((r, d )) ; print(r.shape,d.shape)
r, d = self.layer4((r, d )) ; print(r.shape,d.shape)
r, d = self.layer5((r, d )) ; print(r.shape,d.shape)
'''
torch.Size([2, 10, 56, 56])
torch.Size([2, 64, 56, 56]) torch.Size([2, 80, 56, 56])
torch.Size([2, 128, 28, 28]) torch.Size([2, 192, 28, 28])
torch.Size([2, 256, 14, 14]) torch.Size([2, 448, 14, 14])
torch.Size([2, 512, 7, 7]) torch.Size([2, 320, 7, 7])
'''
#exit(0)
# if not self.training and self.test_time_pool:
# x = F.avg_pool2d(x, kernel_size=7, stride=1)
# out = self.classifier(x)
# # The extra test time pool should be pooling an img_size//32 - 6 size patch
# out = adaptive_avgmax_pool2d(out, pool_type='avgmax')
# else:
# x = adaptive_avgmax_pool2d(x, pool_type='avg')
# out = self.classifier(x)
# return out.view(out.size(0), -1)
return r, d
#
# def dpn68b(num_classes=1000, pretrained=False, test_time_pool=True):
# model = DPN(
# small=True, num_init_features=10, k_r=128, groups=32,
# b=True, k_sec=(3, 4, 12, 3), inc_sec=(16, 32, 32, 64),
# num_classes=num_classes, test_time_pool=test_time_pool)
#
# if pretrained:
# if model_urls['dpn68b-extra']:
# model.load_state_dict(model_zoo.load_url(model_urls['dpn68b-extra']))
# elif has_mxnet and os.path.exists('./pretrained/'):
# convert_from_mxnet(model, checkpoint_prefix='./pretrained/dpn68-extra')
# else:
# assert False, "Unable to load a pretrained model"
# return model
#
# def dpn92(num_classes=1000, pretrained='imagenet+5k'):
# model = DPN(
# num_init_features=64, k_r=96, groups=32,
# k_sec=(3, 4, 20, 3), inc_sec=(16, 32, 24, 128),
# num_classes=num_classes, test_time_pool=True)
#
# if pretrained:
# settings = pretrained_settings['dpn92'][pretrained]
# assert num_classes == settings['num_classes'], \
# "num_classes should be {}, but is {}".format(settings['num_classes'], num_classes)
#
# model.load_state_dict(model_zoo.load_url(settings['url']))
# model.input_space = settings['input_space']
# model.input_size = settings['input_size']
# model.input_range = settings['input_range']
# model.mean = settings['mean']
# model.std = settings['std']
# return model
########################################################################################
if __name__ == '__main__':
print( '%s: calling main function ... ' % os.path.basename(__file__))
print( 'sucessful!')
|
import numpy as np
from scipy.optimize import fsolve, minimize
from psoap import constants as C
class SB1:
'''
Describing a single-line Spectroscopic binary.
'''
def __init__(self, K, e, omega, P, T0, gamma, obs_dates=None, **kwargs):
self.K = K # [km/s]
self.e = e
self.omega = omega # [deg]
self.P = P # [days]
self.T0 = T0 # [JD]
self.gamma = gamma # [km/s]
# If we are going to be repeatedly predicting the orbit at a sequence of dates,
# just store them to the object.
self.obs_dates = obs_dates
self.param_dict = {"K":self.K, "e":self.e, "omega":self.omega, "P":self.P, "T0":self.T0, "gamma":self.gamma}
def update_parameters(self, param_values, param_list):
'''
param_values is numpy array of values
param_list is list of strings of the names of the parameters
'''
for (value, key) in zip(param_values, param_list):
self.param_dict[key] = value
def theta(self, t):
'''Calculate the true anomoly for the A-B orbit.
Input is in days.'''
# t is input in seconds
# Take a modulus of the period
t = (t - self.T0) % self.P
f = lambda E: E - self.e * np.sin(E) - 2 * np.pi * t/self.P
E0 = 2 * np.pi * t / self.P
E = fsolve(f, E0)[0]
th = 2 * np.arctan(np.sqrt((1 + self.e)/(1 - self.e)) * np.tan(E/2.))
if E < np.pi:
return th
else:
return th + 2 * np.pi
def v1_f(self, f):
'''Calculate the component of A's velocity based on only the inner orbit.
f is the true anomoly of this inner orbit.'''
return self.K * (np.cos(self.omega * np.pi/180 + f) + self.e * np.cos(self.omega * np.pi/180))
def vA_t(self, t):
'''
'''
# Get the true anomoly "f" from time
f = self.theta(t)
# Feed this into the orbit equation and add the systemic velocity
return self.v1_f(f) + self._gamma
def get_component_velocities(self, dates=None):
'''
Return both vA and vB for all dates provided.
'''
if dates is None and self.obs_dates is None:
raise RuntimeError("Must provide input dates or specify observation dates upon creation of orbit object.")
if dates is None and self.obs_dates is not None:
dates = self.obs_dates
dates = np.atleast_1d(dates)
vAs = np.array([self.vA_t(date) for date in dates])
return vAs
class SB2:
'''
Describing a single-line Spectroscopic binary.
'''
def __init__(self, q, K, e, omega, P, T0, gamma, obs_dates=None, **kwargs):
self.q = q # mass ratio
self.K = K # [km/s]
self.e = e
self.omega = omega # [deg]
self.P = P # [days]
self.T0 = T0 # [JD]
self.gamma = gamma # [km/s]
# If we are going to be repeatedly predicting the orbit at a sequence of dates,
# just store them to the object.
self.obs_dates = obs_dates
self.param_dict = {"q":self.q, "K":self.K, "e":self.e, "omega":self.omega, "P":self.P, "T0":self.T0, "gamma":self.gamma}
def update_parameters(self, param_values, param_list):
'''
param_values is numpy array of values
param_list is list of strings of the names of the parameters
'''
for (value, key) in zip(param_values, param_list):
self.param_dict[key] = value
def theta(self, t):
'''Calculate the true anomoly for the A-B orbit.
Input is in days.'''
# t is input in seconds
# Take a modulus of the period
t = (t - self.T0) % self.P
f = lambda E: E - self.e * np.sin(E) - 2 * np.pi * t/self.P
E0 = 2 * np.pi * t / self.P
E = fsolve(f, E0)[0]
th = 2 * np.arctan(np.sqrt((1 + self.e)/(1 - self.e)) * np.tan(E/2.))
if E < np.pi:
return th
else:
return th + 2 * np.pi
def v1_f(self, f):
'''Calculate the component of A's velocity based on only the inner orbit.
f is the true anomoly of this inner orbit.'''
return self.K * (np.cos(self.omega * np.pi/180 + f) + self.e * np.cos(self.omega * np.pi/180))
def v2_f(self, f):
'''Calculate the component of A's velocity based on only the inner orbit.
f is the true anomoly of this inner orbit.'''
return -self.K/self.q * (np.cos(self.omega * np.pi/180 + f) + self.e * np.cos(self.omega * np.pi/180))
def vA_t(self, t):
'''
'''
# Get the true anomoly "f" from time
f = self.theta(t)
# Feed this into the orbit equation and add the systemic velocity
return self.v1_f(f) + self.gamma
def vB_t(self, t):
f = self.theta(t)
return self.v2_f(f) + self.gamma
def get_component_velocities(self, dates=None):
'''
Return both vA and vB for all dates provided.
'''
if dates is None and self.obs_dates is None:
raise RuntimeError("Must provide input dates or specify observation dates upon creation of orbit object.")
if dates is None and self.obs_dates is not None:
dates = self.obs_dates
dates = np.atleast_1d(dates)
vAs = np.array([self.vA_t(date) for date in dates])
vBs = np.array([self.vB_t(date) for date in dates])
return (vAs, vBs)
class ST1:
'''
Techniques describing solving for a triple star orbit.
'''
def __init__(self, K_in, e_in, omega_in, P_in, T0_in, K_out, e_out, omega_out, P_out, T0_out, gamma, obs_dates=None, **kwargs):
self.K_in = K_in # [km/s]
self.e_in = e_in
self.omega_in = omega_in # [deg]
self.P_in = P_in # [days]
self.T0_in = T0_in # [JD]
self.K_out = K_out # [km/s]
self.e_out = e_out
self.omega_out = omega_out # [deg]
self.P_out = P_out # [days]
self.T0_out = T0_out # [JD]
self.gamma = gamma # [km/s]
# If we are going to be repeatedly predicting the orbit at a sequence of dates,
# just store them to the object.
self.obs_dates = obs_dates
self.param_dict = {"K_in":self.K_in, "e_in":self.e_in, "omega_in":self.omega_in, "P_in":self.P_in, "T0_in":self.T0_in, "K_out":self.K_out, "e_out":self.e_out, "omega_out":self.omega_out, "P_out":self.P_out, "T0_out":self.T0_out, "gamma":self.gamma}
def update_parameters(self, param_values, param_list):
'''
param_values is numpy array of values
param_list is list of strings of the names of the parameters
'''
for (value, key) in zip(param_values, param_list):
self.param_dict[key] = value
def theta_in(self, t):
'''Calculate the true anomoly for the A-B orbit.'''
# t is input in seconds
# Take a modulus of the period
t = (t - self.T0_in) % self.P_in
f = lambda E: E - self.e_in * np.sin(E) - 2 * np.pi * t/self.P_in
E0 = 2 * np.pi * t / self.P_in
E = fsolve(f, E0)[0]
th = 2 * np.arctan(np.sqrt((1 + self.e_in)/(1 - self.e_in)) * np.tan(E/2.))
if E < np.pi:
return th
else:
return th + 2 * np.pi
def theta_out(self, t):
'''Calculate the true anomoly for the (A-B) - C orbit.'''
# t is input in seconds
# Take a modulus of the period
t = (t - self.T0_out) % self.P_out
f = lambda E: E - self.e_out * np.sin(E) - 2 * np.pi * t/self.P_out
E0 = 2 * np.pi * t / self.P_out
E = fsolve(f, E0)[0]
th = 2 * np.arctan(np.sqrt((1 + self.e_out)/(1 - self.e_out)) * np.tan(E/2.))
if E < np.pi:
return th
else:
return th + 2 * np.pi
def v1_f(self, f):
'''Calculate the component of A's velocity based on only the inner orbit.
f is the true anomoly of this inner orbit.'''
return self.K_in * (np.cos(self.omega_in * np.pi/180 + f) + self.e_in * np.cos(self.omega_in * np.pi/180))
def v3_f(self, f):
'''Calculate the velocity of (A-B) based only on the outer orbit.
f is the true anomoly of the outer orbit'''
return self.K_out * (np.cos(self.omega_out * np.pi/180 + f) + self.e_out * np.cos(self.omega_out * np.pi/180))
def vA_t(self, t):
# Get the true anomoly "f" from time
f_in = self.theta_in(t)
f_out = self.theta_out(t)
v1 = self.v1_f(f_in)
v3 = self.v3_f(f_out)
return v1 + v3 + self.gamma
def get_component_velocities(self, dates=None):
'''
Return vA, vB, and vC for all dates provided.
'''
if dates is None and self.obs_dates is None:
raise RuntimeError("Must provide input dates or specify observation dates upon creation of orbit object.")
if dates is None and self.obs_dates is not None:
dates = self.obs_dates
dates = np.atleast_1d(dates)
vAs = np.array([self.vA_t(date) for date in dates])
return vAs
models = {"SB1":SB1, "ST1":ST1}
|
# -*- coding: utf-8 -*- #
# Copyright 2019 Google LLC. 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.
"""Describe command for the Org Policy CLI."""
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from googlecloudsdk.api_lib.orgpolicy import service as org_policy_service
from googlecloudsdk.calliope import base
from googlecloudsdk.command_lib.org_policies import arguments
from googlecloudsdk.command_lib.org_policies import utils
@base.Hidden
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class Describe(base.DescribeCommand):
r"""Describe an organization policy.
Describes an organization policy.
## EXAMPLES
To describe the policy associated with the constraint 'gcp.resourceLocations'
and the Project 'foo-project', run:
$ {command} gcp.resourceLocations --project=foo-project
"""
@staticmethod
def Args(parser):
arguments.AddConstraintArgToParser(parser)
arguments.AddResourceFlagsToParser(parser)
parser.add_argument(
'--effective',
action='store_true',
help='Describe the effective policy.')
parser.add_argument(
'--show-label-name',
action='store_true',
help=('Return label based conditions with the display name instead of '
'ID.')
)
def Run(self, args):
"""Gets the (effective) organization policy.
If --effective is not specified, then the policy is retrieved using
GetPolicy.
If --effective is specified, then the effective policy is retrieved using
GetEffectivePolicy.
Args:
args: argparse.Namespace, An object that contains the values for the
arguments specified in the Args method.
Returns:
The retrieved policy.
"""
policy_service = org_policy_service.PolicyService()
org_policy_messages = org_policy_service.OrgPolicyMessages()
policy_name = utils.GetPolicyNameFromArgs(args)
if args.effective:
get_request = org_policy_messages.OrgpolicyPoliciesGetEffectivePolicyRequest(
name=policy_name)
return policy_service.GetEffectivePolicy(get_request)
get_request = org_policy_messages.OrgpolicyPoliciesGetRequest(
name=policy_name)
policy = policy_service.Get(get_request)
if args.show_label_name:
utils.UpdateLabelNamesInCondition(policy)
return policy
|
from ecdsa import SigningKey, SECP256k1, VerifyingKey
from sha3 import keccak_256
import json
import rlp
from eth_keys import keys
public = '0x2377BB12320F46F0B9E30EBFB941121352716f2C'
private = '0x886d5b4ce9465473701bf394b1b0b217548c57576436864fcbc1f554033a0680'
trx = '0xF86B80850BA43B7400825208947917bc33eea648809c285607579c9919fb864f8f8703BAF82D03A0008025A0067940651530790861714b2e8fd8b080361d1ada048189000c07a66848afde46A069b041db7c29dbcc6becf42017ca7ac086b12bd53ec8ee494596f790fb6a0a69'
'''
0xf8 73
80 - nonce
85 3374a06200 - gasPrice
82 5208 - gasLimit
94 2377bb12320f46f0b9e30ebfb941121352716f2c - toAddress
89 055de6a779bbac0000 - value
80 - callData
86 02e92be91e86 - v
a0 602af7bd4ac154a568c2d1478b23d697390e035cd72250e77a0d56ce2c4a63db - r
a0 5d09ca05a62935d6c2a04bfa5bfa1cb46bfcb59e3a115e0c8cceca807efb778b - s
'''
class Trx(rlp.Serializable):
fields = (
('nonce', rlp.codec.big_endian_int),
('gasPrice', rlp.codec.big_endian_int),
('gasLimit', rlp.codec.big_endian_int),
('toAddress', rlp.codec.binary),
('value', rlp.codec.big_endian_int),
('callData', rlp.codec.binary),
('v', rlp.codec.big_endian_int),
('r', rlp.codec.big_endian_int),
('s', rlp.codec.big_endian_int)
)
def __init__(self, *args, **kwargs):
rlp.Serializable.__init__(self, *args, **kwargs)
self._msg = None
@classmethod
def fromString(cls, s):
return rlp.decode(s, Trx)
def chainId(self):
# chainid*2 + 35 xxxxx0 + 100011 xxxx0 + 100010 +1
# chainid*2 + 36 xxxxx0 + 100100 xxxx0 + 100011 +1
return (self.v-1)//2 - 17
def unsigned_msg(self):
if self._msg is None:
self._msg = rlp.encode((self.nonce, self.gasPrice, self.gasLimit, self.toAddress, self.value, self.callData, self.chainId(), b"", b""))
return self._msg
def signature(self):
return keys.Signature(vrs=[1 if self.v % 2 == 0 else 0, self.r, self.s]).to_bytes()
def sender(self):
hash = keccak_256(self.unsigned_msg()).digest()
sig = keys.Signature(vrs=[1 if self.v%2==0 else 0, self.r, self.s])
pub = sig.recover_public_key_from_msg_hash(hash)
return pub.to_canonical_address().hex()
#class JsonEncoder(json.JSONEncoder):
# def default(self, obj):
# if isinstance(obj, bytes):
# return obj.hex()
# return json.JSONEncoder.default(self.obj)
#
#trx = '0xf8af098539f98e7a0082bfd194b80102fd2d3d1be86823dd36f9c783ad0ee7d89880b844a9059cbb000000000000000000000000c1566af4699928fdf9be097ca3dc47ece39f8f8e00000000000000000000000000000000000000000000000000000000000000328602e92be91e86a0e2c683a38606033cf416cca55575b4080465f1a275aff080b2af1a264b24d56ca02e48a4cb63d8549610d070b02e272ab6a3a680e677c7d7f51045a9cbcf218f0d'
#trx = '0xf8af098539f98e7a0082bfd194b80102fd2d3d1be86823dd36f9c783ad0ee7d89880b844a9059cbb000000000000000000000000c1566af4699928fdf9be097ca3dc47ece39f8f8e00000000000000000000000000000000000000000000000000000000000000328602e92be91e86a0e2c683a38606033cf416cca55575b4080465f1a275aff080b2af1a264b24d56ca02e48a4cb63d8549610d070b02e272ab6a3a680e677c7d7f51045a9cbcf218f0d'
#trx = '0xf87202853946be1c0082520894c1566af4699928fdf9be097ca3dc47ece39f8f8e880de0b6b3a7640000808602e92be91e85a06f350382938df92b987681de78d81f0490ee1d26b18ea968ae42ee4a800711a6a0641672e91b735bd6badd2c51b6a6ecdcd740b78c8bf581aa3f1431cd0f8c02f3'
#
#_trx = Trx.fromString(bytearray.fromhex(trx[2:]))
#print(json.dumps(_trx.__dict__, cls=JsonEncoder, indent=3))
#print(str(_trx))
#print(trx[2:])
#
#msgHash = _trx.hash()
#sig = keys.Signature(vrs=[1 if _trx.v%2==0 else 0, _trx.r, _trx.s])
#pub = sig.recover_public_key_from_msg_hash(msgHash)
#print('SENDER', pub.to_canonical_address().hex())
#print("VERIFY", sig.verify_msg_hash(msgHash, pub))
|
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 31 17:04:47 2018
@author: Riza
This file provides the classes for 2D contour plotting.
"""
#%% Modules:
import numpy as np
shape = np.shape
reshape = np.reshape
size = np.size
import matplotlib.pyplot as plt
from UtilityFunc import UF
uf = UF()
#%% Contour plot class:
class ContourPlot():
"""Class to plot the contours of a given function."""
def __init__(self,
domain,
tInterval=None,
discNum=51
):
"""
Initializer for the contour plot.
Inputs:
domain: an insatnce of Domain class containing domain information.
tInterval [1x2]: time interval (default: time-independent)
discNum: number of spatial discretization points
Attributes:
status: status of the problem whose plots are requested:
'1D-time': 1D time-dependent problem
'2D': 2D time-independent problem
'2D-time': 2D time-dependent problem
isOutside: True for points that do not lie inside domain
x_coord: 1D discretization of the x-ccordinate
y_coord: 1D discretization of the y-ccordinate
X_coord: x-ccordinate of the meshgrid stacked in a column
Y_coord: y-ccordinate of the meshgrid stacked in a column
(y-coordinate may refer to time or 2nd coordinate in 2D problems)
xx: x-coordinate in meshgrid format
yy: y-coordinate in meshgrid format
"""
dim = domain.dim
lim = domain.lim
hx = (lim[1,0] - lim[0,0])/(discNum-1) # element size
x_coord = np.linspace(lim[0,0], lim[1,0], discNum) # x-discretization
if dim==1 and uf.isnone(tInterval):
raise ValueError('contour plot unavailable for 1D, time-independent problems!')
elif dim==1:
status = '1D-time'
hy = (tInterval[1] - tInterval[0])/(discNum-1) # element size
y_coord = np.linspace(tInterval[0], tInterval[1], discNum) # t-discretization
if dim==2:
hy = (lim[1,1] - lim[0,1])/(discNum-1) # element size
y_coord = np.linspace(lim[0,1], lim[1,1], discNum) # y-discretization
if uf.isnone(tInterval):
status = '2D'
else:
status = '2D-time'
# Mesh grid:
xx, yy = np.meshgrid(x_coord, y_coord, sparse=False)
# Function input:
X_coord = np.tile(x_coord, discNum) # copy for y
X_coord = reshape(X_coord, [len(X_coord), 1])
Y_coord = np.repeat(y_coord, discNum) # copy for x
Y_coord = reshape(Y_coord, [len(Y_coord), 1])
# Determine the points that lie outside the domain:
if status=='1D-time':
isOutside = np.zeros(discNum**2, dtype=bool)
else:
Input = np.concatenate([X_coord, Y_coord], axis=1)
isOutside = np.logical_not(domain.isInside(Input))
# Store data:
self.status = status
self.discNum = discNum
self.tInterval = tInterval
self.he = np.array([hx, hy])
self.isOutside = isOutside
self.x_coord = reshape(x_coord, [discNum,1])
self.y_coord = reshape(y_coord, [discNum,1])
self.X_coord = X_coord
self.Y_coord = Y_coord
self.xx = xx
self.yy = yy
self.domain = domain
def conPlot(self, func, t=None, figNum=None, title=None, fill_val=0.):
"""
Function to plot the contour field.
Inputs:
func: callable function of (x,t)
t: time instance for 2D time-dependent problems
title [string]: contour plot title
figNum: figure number to draw on
fill_val: value to be used for obstacles
Note that the function 'func' must handle the obstcles by assigning
neutral values to the grid over the obstacles.
"""
if not callable(func):
raise ValueError('field function must be callable!')
if self.status=='2D-time' and uf.isnone(t):
raise ValueError('time must be provided for 2D time-dependent problems!')
status = self.status
discNum = self.discNum
isOutside = self.isOutside
X_coord = self.X_coord
Y_coord = self.Y_coord
domain = self.domain
# Construct the field:
if status=='1D-time':
field = func(X_coord, Y_coord)
elif status=='2D':
Input = np.concatenate([X_coord, Y_coord], axis=1)
field = func(Input)
elif status=='2D-time':
Input = np.concatenate([X_coord, Y_coord], axis=1)
field = func(Input,t)
# Process the field:
if not shape(field)[0]==discNum**2:
raise ValueError('output of the function should be a column vector with size {}!'.format(discNum**2))
elif size(shape(field))==1:
field = reshape(field, [discNum**2,1])
field[isOutside,:] = fill_val
field = np.reshape(field, [discNum, discNum])
# Create the figure and plot the domain frame:
if uf.isnone(figNum):
figNum=0
plt.figure(figNum)
if domain.dim>1:
domain.domPlot(addDescription=False, figNum=figNum, frameColor='w')
# Plot the contour field:
cP = plt.contourf(self.xx, self.yy, field)
plt.colorbar(cP)
if status=='1D-time':
plt.xlabel('$x$')
plt.ylabel('time')
else:
plt.xlabel('$x_1$')
plt.ylabel('$x_2$')
if not uf.isnone(title):
plt.title(title)
plt.axis('scaled')
return field
def animPlot(self, func, t=[], figNum=None, title=None, fill_val=0.):
"""
Function to plot the animation of 2D time-dependent field.
Inputs:
func: callable function of (x,t)
t: time instance vector for 2D time-dependent problems
"""
# Error handling:
if not callable(func):
raise ValueError('field function must be callable!')
if self.status=='1D-time' or self.status=='2D':
raise ValueError('animation contour plot is only available for 2D time-dependent problems!')
if uf.isnone(figNum):
figNum=0
# Data:
discNum = self.discNum
X_coord = self.X_coord
Y_coord = self.Y_coord
isOutside = self.isOutside
domain = self.domain
Input = np.concatenate([X_coord, Y_coord], axis=1)
# If time sequence is not provided:
if np.size(t)==0:
tInterval = self.tInterval
t = np.linspace(tInterval[0], tInterval[1], num=5)
# Loop over time:
for ti in t:
plt.figure(figNum)
domain.domPlot(addDescription=False, figNum=figNum, frameColor='w')
field = func(Input, ti)
# Process the field:
if not shape(field)[0]==discNum**2:
raise ValueError('output of the function should be a column vector with size {}!'.format(discNum**2))
elif size(shape(field))==1:
field = reshape(field, [discNum**2,1])
field[isOutside,:] = fill_val
field = np.reshape(field, [discNum, discNum])
# Contour plot:
cP = plt.contourf(self.xx, self.yy, field)
plt.colorbar(cP)
titleT = 't = {0:.2f}s'.format(ti)
if not uf.isnone(title):
title2 = title + '-' + titleT
else:
title2 = titleT
plt.title(title2)
plt.xlabel('$x_1$')
plt.ylabel('$x_2$')
plt.axis('scaled')
plt.show()
plt.pause(1) # pause 1sec before plotting the next contour
def snap1Dt(self, func, t, lineOpt=None, figNum=None, title=None):
"""
Function to plot snapshots for 1D time-dependent function.
Inputs:
func: callable function of (x,t)
t: vector of time instances corresponding to the snapshot
lineOpt: line options to allow comparison between different functions
figNum: figure number to draw on
"""
# Error handling:
if not callable(func):
raise ValueError('field function must be callable!')
if not self.status=='1D-time':
raise ValueError('Function is specific to 1D time-dependent problems!')
x_coord = self.x_coord
field = func(x_coord, t)
if uf.isnone(figNum):
plt.figure()
else:
plt.figure(figNum)
if uf.isnone(lineOpt):
plt.plot(x_coord, field)
else:
plt.plot(x_coord, field, lineOpt)
plt.xlabel('$x$')
if not uf.isnone(title):
plt.title(title)
plt.grid(True)
|
# -*- coding: utf-8 -*-
__name = 'smsapi-contacts-python'
__version__ = '1.0.5'
lib_info = '%s/%s' % (__name, __version__)
|
def surface_area(l, w, h):
return 2*l*w + 2*w*h + 2*h*l + min([l*w, w*h, h*l])
def ribbon_length(l, w, h):
return sum([*map(lambda x: x*2, sorted([l,w,h])[:-1])]) + l*w*h
if __name__ == "__main__":
with open('2015/input/day02.txt') as f:
data = f.read().splitlines()
print( sum( [*map( lambda x: surface_area(*[*map(int, x.split('x'))]), data )] )) # 1588178
print( sum( [*map( lambda x: ribbon_length(*[*map(int, x.split('x'))]), data )] )) # 3783758
|
from setuptools import find_packages
from setuptools import setup
setup(
name="data_engineer_playground",
version="0.1.0",
description="A monorepo used to try things.",
author="Cristian Webber",
author_email="cbwebbers@gmail.com",
url="https://github.com/cristianwebber/data_engineer_playground",
packages=find_packages(exclude=("tests*", "testing*")),
)
|
# https://www.codechef.com/problems/AREAPERI
l,b=int(input()),int(input())
if(2*(l+b)>l*b): print("Peri\n{}".format(2*(l+b)))
elif(2*(l+b)<l*b): print("Area\n{}".format(l*b))
else: print("Eq\n{}".format(l*b))
|
from .packages.display import *
from .packages.exceptions import *
from .interface.banner import *
|
import os
import shutil
from aitoolbox.experiment.local_save.folder_create import ExperimentFolder as FolderCreator
from aitoolbox.utils.file_system import zip_folder
from aitoolbox.cloud.AWS.model_save import BaseModelSaver
from aitoolbox.cloud.AWS.results_save import BaseResultsSaver
from aitoolbox.cloud.GoogleCloud.model_save import BaseModelGoogleStorageSaver
from aitoolbox.cloud.GoogleCloud.results_save import BaseResultsGoogleStorageSaver
class HyperParamSourceReporter:
def __init__(self, project_name, experiment_name, experiment_timestamp, local_model_result_folder_path):
"""Writer of selected hyperparameters to human-readable text file on disk
Args:
project_name (str): root name of the project
experiment_name (str): name of the particular experiment
experiment_timestamp (str): time stamp of the training start
local_model_result_folder_path (str): root local path where project folder will be created
"""
self.project_name = project_name
self.experiment_name = experiment_name
self.experiment_timestamp = experiment_timestamp
self.local_model_result_folder_path = os.path.expanduser(local_model_result_folder_path)
self.experiment_dir_path = FolderCreator.create_base_folder(project_name, experiment_name, experiment_timestamp,
local_model_result_folder_path)
self.file_name = 'hyperparams_list.txt'
self.local_hyperparams_file_path = os.path.join(self.experiment_dir_path, self.file_name)
def save_hyperparams_to_text_file(self, hyperparams, sort_names=False):
"""Save hyperparameters dict into text file on disk
Args:
hyperparams (dict): hyper-parameters listed in the dict
sort_names (bool): should presented hyper-param names be listed alphabetically
Returns:
str: path to the saved hyper-param text file
"""
param_names = sorted(hyperparams.keys()) if sort_names else hyperparams.keys()
with open(self.local_hyperparams_file_path, 'w') as f:
for k in param_names:
f.write(f'{k}:\t{hyperparams[k]}\n')
return self.local_hyperparams_file_path
def copy_to_cloud_storage(self, local_hyperparams_file_path, cloud_saver, file_name=None):
"""Copy saved text local file into cloud storage
Args:
local_hyperparams_file_path (str): path to hyperparams file stored on local disk. File to be uploaded to cloud
cloud_saver (BaseModelSaver or BaseResultsSaver or BaseModelGoogleStorageSaver or BaseResultsGoogleStorageSaver):
file_name (str or None): manually specify the file name to be saved to the cloud instead of taking
the default from self.file_name
Returns:
str: path where the file was saved in the cloud storage
"""
cloud_folder_path = cloud_saver \
.create_experiment_cloud_storage_folder_structure(self.project_name, self.experiment_name,
self.experiment_timestamp).rsplit('/', 1)[0]
cloud_file_path = os.path.join(cloud_folder_path, self.file_name if file_name is None else file_name)
cloud_saver.save_file(local_hyperparams_file_path, cloud_file_path)
return cloud_file_path
def save_experiment_python_file(self, hyperparams):
"""Saves the python experiment file to the project folder
Python experiment file is file in which the main training procedure is defined. File from which the TrainLoop
is executed
Args:
hyperparams (dict): hyper-parameters listed in the dict. In order for this function to work, the dict needs
to include `experiment_file_path` key.
Returns:
str: path to the saved main python experiment file
"""
if 'experiment_file_path' in hyperparams:
try:
destination_file_path = os.path.join(self.experiment_dir_path,
os.path.basename(hyperparams['experiment_file_path']))
shutil.copyfile(hyperparams['experiment_file_path'], destination_file_path)
return destination_file_path
except FileNotFoundError:
print('experiment_file_path leading to the non-existent file. Possibly this error is related to'
'problematic automatic experiment python file path deduction when running the TrainLoop from'
'jupyter notebook. When using jupyter notebook you should manually specify the experiment'
'python file path as the value for experiment_file_path in hyperparams dict.')
else:
print('experiment_file_path experiment execution file path missing in the hyperparams dict. '
'Consequently not copying the file to the experiment dir.')
def save_experiment_source_files(self, hyperparams):
"""Saves all the experiment source files into single source code zip
Args:
hyperparams (dict): hyper-parameters listed in the dict. In order for this function to work, the dict needs
to include `source_dirs_paths` key.
Returns:
str: path to the saved experiment source code zip
"""
if 'source_dirs_paths' in hyperparams and \
type(hyperparams['source_dirs_paths']) in [list, tuple] and len(hyperparams['source_dirs_paths']) > 0:
src_dir_in_project_dir = os.path.join(self.experiment_dir_path, 'source_code')
os.mkdir(src_dir_in_project_dir)
for src_dir_path in hyperparams['source_dirs_paths']:
src_dir_path = os.path.expanduser(src_dir_path)
destination_file_path = os.path.join(src_dir_in_project_dir, os.path.basename(src_dir_path))
shutil.copytree(src_dir_path, destination_file_path)
zip_path = zip_folder(src_dir_in_project_dir, src_dir_in_project_dir)
shutil.rmtree(src_dir_in_project_dir)
return zip_path
|
from tkinter import *
from EMExp import *
import time
import pygame
class EMPage(Frame):
MUTE = False
INFO = False
CHECK = False
def __init__(self, parent, controller):
Frame.__init__(self, parent)
pygame.mixer.init()
BackS = pygame.mixer.Sound("EUBack.wav")
ClearS = pygame.mixer.Sound("EUClear.wav")
CalcS = pygame.mixer.Sound("EUCalc.wav")
InfoS = pygame.mixer.Sound("EUInfo.wav")
RandomS = pygame.mixer.Sound("EURandom.wav")
GraphS = pygame.mixer.Sound("EUGraph.wav")
EuBG = PhotoImage(file="EuBackground.png")
EuLabel = Label(self, image=EuBG)
EuLabel.image = EuBG
EuLabel.place(x=-2, y=-2)
info = PhotoImage(file='EuInfoPop.png')
InfoPop = Label(self, image=info)
InfoPop.image = info
InfoPop.place(x=-2, y=-2)
InfoPop.lower()
Back = PhotoImage(file="EuBack.png")
BackBtn = Button(self, image=Back, bd=0, bg='#c7e8d5', command=lambda: BackAct())
BackBtn.image = Back
BackBtn.place(x=-2, y=-2)
Info = PhotoImage(file="EuInfo.png")
InfoBtn = Button(self, image=Info, bd=0, bg='#c7e8d5', command=lambda: InfoAct())
InfoBtn.image = Info
InfoBtn.place(x=48, y=-2)
Sound = PhotoImage(file="EuSoundOn.png")
SoundBtn = Button(self, image=Sound, bd=0, bg='#c7e8d5', command=lambda: MuteAct())
SoundBtn.image = Sound
SoundBtn.place(x=98, y=-2)
SoundOff = PhotoImage(file="EuSoundOff.png")
MuteBtn = Button(self, image=SoundOff, bd=0, bg='#c7e8d5', command=lambda: MuteAct())
MuteBtn.image = SoundOff
MuteBtn.place(x=98, y=-2)
MuteBtn.lower()
Clear = PhotoImage(file="EuClear.png")
ClrBtn = Button(self, image=Clear, bd=0, bg="#c7e8d5", command=lambda: ClrAct())
ClrBtn.image = Clear
ClrBtn.place(x=198, y=-2)
Random = PhotoImage(file="EuRandom.png")
RandBtn = Button(self, image=Random, bd=0, bg="#c7e8d5", command=lambda: RandAct())
RandBtn.image = Random
RandBtn.place(x=148, y=-2)
Calc = PhotoImage(file="EuCalc.png")
CalcBtn = Button(self, image=Calc, bd=0, bg="#141809", command=lambda: CalcAct())
CalcBtn.image = Calc
CalcBtn.place(x=108, y=598)
Graph = PhotoImage(file="EuGraph.png")
GraphBtn = Button(self, image=Graph, bd=0, bg="#141809", command=lambda: GraphAct())
GraphBtn.image = Graph
GraphBtn.place(x=380, y=598)
Check = PhotoImage(file="EuCheck.png")
CheckBtn = Button(self, image=Check, bd=0, bg='black', command=lambda: CheckAct())
CheckBtn.image = Check
CheckBtn.place(x=371, y=276)
EuYesMsg = PhotoImage(file="EuYes.png")
YesMsg = Label(self, image=EuYesMsg, bg='black')
YesMsg.image = EuYesMsg
YesMsg.place(x=491, y=209)
EuNoMsg = PhotoImage(file="EuNo.png")
NoMsg = Label(self, image=EuNoMsg, bg='black')
NoMsg.image = EuNoMsg
NoMsg.place(x=491, y=209)
xlabel = Label(self, bg='#f7e5b7', anchor='e', justify="right")
xlabel.place(x=938, y=59, width=93, height=640)
fxlabel = Label(self, bg='#f7e5b7', anchor='e', justify="right")
fxlabel.place(x=1035, y=59, width=162, height=640)
def validate(string):
regex = re.compile(r"(\+|\-)?[0-9.]*$")
result = regex.match(string)
return (string == ""
or (string.count('+') <= 1
and string.count('-') <= 1
and string.count('.') <= 1
and result is not None
and result.group(0) != ""))
def on_validate(P):
return validate(P)
def validateFunc(string):
regex = re.compile(r"[\+\-\(\)\^\/\*abcegilnoqrstxy0-9.]*$")
result = regex.match(string)
return (string == ""
or (result is not None
and result.group(0) != ""))
def on_validateFunc(P):
return validateFunc(P)
FuncEnt = Entry(self, background="#fdc689", font="-family {Arial} -size 20", justify="center", validate="key")
FuncEnt.config(validatecommand=(FuncEnt.register(on_validateFunc), '%P'))
FuncEnt.place(x=232, y=211, width=250, height=50)
HEnt = Entry(self, background="#fdc689", font="-family {Arial} -size 20", justify="center", validate="key")
HEnt.config(validatecommand=(HEnt.register(on_validate), '%P'))
HEnt.place(x=232, y=303, width=100, height=50)
x0Ent = Entry(self, background="#fdc689", font="-family {Arial} -size 20", justify="center", validate="key")
x0Ent.config(validatecommand=(x0Ent.register(on_validate), '%P'))
x0Ent.place(x=93, y=395, width=75, height=50)
y0Ent = Entry(self, background="#fdc689", font="-family {Arial} -size 20", justify="center", validate="key")
y0Ent.config(validatecommand=(y0Ent.register(on_validate), '%P'))
y0Ent.place(x=232, y=395, width=75, height=50)
xfEnt = Entry(self, background="#fdc689", font="-family {Arial} -size 20", justify="center", validate="key")
xfEnt.config(validatecommand=(xfEnt.register(on_validate), '%P'))
xfEnt.place(x=232, y=487, width=75, height=50)
def InfoLower():
I = (CheckBtn, YesMsg, NoMsg)
for i in range(len(I)):
I[i].lower()
InfoLower()
def FTest(x):
return x.lstrip('-').lstrip('+').replace('.', '', 1).isdigit()
def em():
if FuncEnt.get()=="" or not FTest(HEnt.get()) or not FTest(x0Ent.get()) or not FTest(y0Ent.get()) or not FTest(xfEnt.get()):
Func = FuncEnt.get()
if not EMPage.CHECK:
Func = "error"
H = 0
x0 = 0
y0 = 0
xf = 0
else:
Func = FuncEnt.get()
H = float(HEnt.get())
x0 = float(x0Ent.get()) # nt necessary float
y0 = float(y0Ent.get()) # nt necessary float
xf = float(xfEnt.get())
em = EM(Func, H, x0, y0, xf)
return em
def CalcAct():
if em().Error():
xlabel.config(font=("PragmataPro", 13), anchor='ne', text="")
fxlabel.config(font=("PragmataPro", 14), anchor='c', justify='c', text="Invalid Input\n\nPlz refer to \n\nINSTRUCTION\n\nMath ERROR")
xlabel.update()
fxlabel.update()
else:
if EMPage.MUTE == False:
CalcS.play()
xlabel.config(font=("PragmataPro", 13), anchor='ne', text=em().xValue())
fxlabel.config(font=("PragmataPro", 13), anchor='ne', text=em().yValue())
xlabel.update()
fxlabel.update()
def GraphAct():
if not em().Error():
if EMPage.MUTE == False:
GraphS.play()
time.sleep(1.5)
em().Graph()
def BackAct():
BackS.play()
pygame.mixer.music.load("MenuBG.ogg")
pygame.mixer.music.play(-1)
em().CloseGraph()
controller.show_frame("MenuPage")
def RandAct():
if EMPage.MUTE == False:
RandomS.play()
time.sleep(1)
FuncEnt.delete(0, END)
FuncEnt.insert(1, "sin(x)-y")
HEnt.delete(0, END)
HEnt.insert(1, "0.1")
x0Ent.delete(0, END)
x0Ent.insert(1, "0")
y0Ent.delete(0, END)
y0Ent.insert(1, "2")
xfEnt.delete(0, END)
xfEnt.insert(1, "10")
def MuteAct():
if EMPage.MUTE == True:
EMPage.MUTE = False
pygame.mixer.music.load("EUBg.ogg")
pygame.mixer.music.play(-1)
MuteBtn.lower()
else:
EMPage.MUTE = True
pygame.mixer.music.stop()
MuteBtn.lift()
def ClrAct():
if EMPage.MUTE == False:
ClearS.play()
time.sleep(1)
Ent = (FuncEnt, HEnt, x0Ent, y0Ent, xfEnt)
for i in range(len(Ent)):
Ent[i].delete(0, END)
def InfoAct():
if EMPage.INFO == False:
EMPage.INFO = True
if EMPage.MUTE == False:
InfoS.play()
InfoPop.lift()
InfoBtn.lift()
FuncEnt.lift()
CheckBtn.lift()
else:
EMPage.INFO = False
InfoPop.lower()
InfoLower()
def CheckAct():
EMPage.CHECK = True
if em().FuncError():
YesMsg.lower()
NoMsg.lift()
else:
NoMsg.lower()
YesMsg.lift()
EMPage.CHECK = False
|
# Copyright (c) 2019 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#
import keyring
import mock
from sysinv.puppet import puppet
from sysinv.tests import keyring_fixture
class PuppetTestCaseMixin(object):
def setUp(self):
super(PuppetTestCaseMixin, self).setUp()
self.operator = puppet.PuppetOperator(self.dbapi)
self.useFixture(keyring_fixture.KeyringBackend())
keyring.set_password('sysinv', 'services', 'FakePassword1*')
self.mock_write_config = mock.patch.object(puppet.PuppetOperator, '_write_config').start()
mock.patch('sysinv.common.utils.is_virtual', return_value=False).start()
mock.patch('sysinv.puppet.kubernetes.KubernetesPuppet._get_host_join_command',
return_value={}).start()
mock.patch('sysinv.common.kubernetes.KubeOperator.kube_get_secret').start()
def assertConfigParameters(self, mock_write_config, parameters):
"""Validate the configuration contains the supplied parameters"""
config = mock_write_config.call_args[0][1] # single call, second param
for key, value in parameters.items():
self.assertIn(key, config)
self.assertEqual(config.get(key), value)
|
import math
angulo = float(input('Digite um angulo:'))
seno = math.sin(math.radians(angulo))
print('O angulo de {} tem o Seno de {:.2f}'.format(angulo, seno))
cosseno = math.cos(math.radians(angulo))
print('O angulo de {} tem o Cosseno de {:.2f}'.format(angulo, cosseno))
tangente = math.tan(math.radians(angulo))
print('O angulo de {} tem a Tangente de {:.2f}'.format(angulo, tangente))
|
from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.forms import ModelForm
from foodfficient.models import Profile
from django.forms import modelformset_factory, formset_factory
from django_summernote.fields import SummernoteTextFormField, SummernoteTextField
from django.db import models
from . import models
from .models import Comment, Recipe, Blog
from .recipe_utils import CUISINE_CHOICES, DIET_CHOICES
def must_be_unique(value):
user = User.objects.filter(email=value)
if len(user) > 0:
raise forms.ValidationError("Email Already Exists")
return value
class RegistrationForm(UserCreationForm):
email = forms.EmailField(
label="Email",
required=True,
validators=[must_be_unique]
)
class Meta:
model = User
fields = ("username", "first_name", "email",
"password1", "password2")
def save(self, commit=True):
user = super(RegistrationForm, self).save(commit=False)
user.email = self.cleaned_data["email"]
if commit:
user.save()
return user
class UserForm(forms.ModelForm):
class Meta:
model = User
fields = ('first_name', 'last_name', 'email')
class ProfileForm(forms.ModelForm):
class Meta:
model = Profile
fields = ('bio', 'location', 'avatar', 'facebook', 'instagram', 'pinterest')
class RecipeForm(forms.Form):
name = forms.CharField(label='Name: ', max_length=50)
prep_time = forms.IntegerField(label='Prep Time (minutes): ', min_value=0)
cook_time = forms.IntegerField(label='Cook Time (minutes): ', min_value=0)
servings = forms.IntegerField(label='Servings: ', min_value=0)
cuisine = forms.ChoiceField(choices=CUISINE_CHOICES)
diet = forms.MultipleChoiceField(choices=DIET_CHOICES, required=False, widget=forms.CheckboxSelectMultiple)
image = forms.ImageField(label='Submit picture: ', max_length=500)
description = forms.CharField(label='Description: ', max_length=500, widget=forms.Textarea)
ingredients = forms.CharField(label='Ingredients: ', widget=forms.Textarea)
instructions = forms.CharField(label='Instructions: ', widget=forms.Textarea)
notes = forms.CharField(label='Notes: ', widget=forms.Textarea, required=False)
def save(self, request):
recipe_instance = models.Recipe()
recipe_instance.name = self.cleaned_data["name"]
recipe_instance.prep_time = self.cleaned_data["prep_time"]
recipe_instance.cook_time = self.cleaned_data["cook_time"]
recipe_instance.servings = self.cleaned_data["servings"]
recipe_instance.cuisine = self.cleaned_data["cuisine"]
recipe_instance.diet = self.cleaned_data["diet"]
recipe_instance.image = self.cleaned_data["image"]
recipe_instance.description = self.cleaned_data["description"]
recipe_instance.ingredients = self.cleaned_data["ingredients"]
recipe_instance.instructions = self.cleaned_data["instructions"]
recipe_instance.notes = self.cleaned_data["notes"]
recipe_instance.author = request.user
recipe_instance.total_time = self.cleaned_data["prep_time"] + self.cleaned_data["cook_time"]
recipe_instance.save()
return recipe_instance
class BlogForm(forms.ModelForm):
class Meta:
model = Blog
fields = ('title', 'content')
content = SummernoteTextFormField()
class CommentForm(forms.ModelForm):
class Meta:
model = Comment
labels = {'body': 'Comment: '}
fields = ('body', )
|
from django.conf.urls import *
from directoalartista.apps.transaction import views as TransactionViews
urlpatterns = patterns('',
# payment
url(r'^paypal/pdt/', 'directoalartista.apps.transaction.views.paypal_pdt'),
url(r'^paypal/ipn-xxx/', include('paypal.standard.ipn.urls'))
)
|
"""
A setup script to create two executables and demonstrate the use a valid and
an invalid icon.
"""
from cx_Freeze import setup, Executable
executables = [
Executable("test_icon.py", icon="icon.ico", target_name="test_1.exe"),
Executable("test_icon.py", icon="favicon.png", target_name="test_2.exe"),
]
setup(
name="Icon sample",
version="0.1",
description="Test Icon",
executables=executables,
)
|
__version__ = "0.0.3" # only source of version ID
__title__ = "dfm"
__download_url__ = (
"https://github.com/centre-for-humanities-computing/danish-foundation-models"
)
|
from rllab.core.serializable import Serializable
from rllab.spaces.box import Box
from rllab.exploration_strategies.base import ExplorationStrategy
import numpy as np
class SimpleGaussianStrategy(ExplorationStrategy, Serializable):
"""
This strategy adds a constant Gaussian noise to the action taken by the
deterministic policy.
This is different from rllab's GaussianStrategy class in that the sigma
does not decay over time.
"""
def __init__(self, env_spec, sigma=1.0):
assert isinstance(env_spec.action_space, Box)
assert len(env_spec.action_space.shape) == 1
Serializable.quick_init(self, locals())
super().__init__()
self._sigma = sigma
self._action_space = env_spec.action_space
def __getstate__(self):
d = Serializable.__getstate__(self)
return d
def __setstate__(self, d):
Serializable.__setstate__(self, d)
def get_action(self, t, observation, policy, **kwargs):
action, agent_info = policy.get_action(observation)
return np.clip(action + np.random.normal(size=len(action))*self._sigma,
self._action_space.low,
self._action_space.high)
|
# Mathias Punkenhofer
# code.mpunkenhofer@gmail.com
#
from abc import ABC, abstractmethod
class Variant(ABC):
@abstractmethod
def __init__(self, board=None):
self.board = board
@abstractmethod
def is_draw(self):
"""
Returns true if the game is drawn
:return boolean
"""
@abstractmethod
def is_checkmated(self, color):
"""
Returns true if the player represented by color is checkmated
:param color: color representing player
:return boolean
"""
|
from nomad.core.edge import checks
from nomad.core.edge.sensors.implementations.camera_rpi import CameraRPi
class Camera(object):
def __init__(self, resolution):
if checks.is_raspberry_pi():
return CameraRPi(resolution)
def get_image(self):
pass
|
def bold(s):
return '**' + s + '**'
def italics(s):
return '*' + s + '*'
def curry_message(s):
return ":curry: " + s
def curry_format(s, *args):
return curry_message(s.format(*args))
def get_author(message):
return str(message.author)[:str(message.author).find('#')]
|
from django.contrib import admin
from .models import BookingAgent
# Register your models here.
admin.site.register(BookingAgent)
|
# coding=utf-8
#
# catkin_lint
# Copyright (c) 2013-2021 Fraunhofer FKIE
#
# 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 Fraunhofer organization 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
# HOLDER 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.
import unittest
from catkin_lint.linter import Message, ERROR, WARNING, NOTICE
import catkin_lint.output as o
from catkin_lint import __version__ as catkin_lint_version
try:
import StringIO as io
except ImportError:
import io
class OutputTest(unittest.TestCase):
_demo_msgs = [
Message(package="mock", file_name="mock.cmake", line=1, level=ERROR, msg_id="MOCK_MSG", text="short text", description="long text"),
Message(package="mock", file_name="mock.cmake", line=2, level=WARNING, msg_id="MOCK_MSG", text="short text", description="long text"),
Message(package="mock", file_name="mock.cmake", line=3, level=NOTICE, msg_id="MOCK_MSG", text="short text", description="long text"),
Message(package="mock", file_name="", line=0, level=ERROR, msg_id="MOCK_MSG", text="short text", description="long text"),
Message(package="mock", file_name="mock.cmake", line=0, level=ERROR, msg_id="MOCK_MSG", text="short text", description="long text"),
]
def _do_output(self, formatter, msgs):
output = io.StringIO()
formatter.prolog(fd=output)
for msg in msgs:
formatter.message(msg, fd=output)
formatter.epilog(fd=output)
return output.getvalue()
def test_text(self):
"""Test output format for catkin_lint text output"""
result = self._do_output(o.TextOutput(o.Color.Never), self._demo_msgs)
self.assertEqual(result,
"mock: mock.cmake(1): error: short text\n"
"mock: mock.cmake(2): warning: short text\n"
"mock: mock.cmake(3): notice: short text\n"
"mock: error: short text\n"
"mock: mock.cmake: error: short text\n"
)
def test_explained_text(self):
"""Test output format for catkin_lint text output with explanations"""
result = self._do_output(o.ExplainedTextOutput(o.Color.Never), self._demo_msgs)
self.assertEqual(result,
"mock: mock.cmake(1): error: short text\n"
" * long text\n"
" * You can ignore this problem with --ignore mock_msg\n"
"mock: mock.cmake(2): warning: short text\n"
"mock: mock.cmake(3): notice: short text\n"
"mock: error: short text\n"
"mock: mock.cmake: error: short text\n"
)
def test_json(self):
"""Test output format for catkin_lint JSON output"""
result = self._do_output(o.JsonOutput(), self._demo_msgs)
self.assertEqual(result,
'{"errors": ['
'{"id": "MOCK_MSG", "location": {"file": "mock.cmake", "line": 1, "package": "mock"}, "text": "short text"}, '
'{"id": "MOCK_MSG", "location": {"package": "mock"}, "text": "short text"}, '
'{"id": "MOCK_MSG", "location": {"file": "mock.cmake", "package": "mock"}, "text": "short text"}'
'], "notices": ['
'{"id": "MOCK_MSG", "location": {"file": "mock.cmake", "line": 3, "package": "mock"}, "text": "short text"}'
'], "version": "%(version)s", "warnings": ['
'{"id": "MOCK_MSG", "location": {"file": "mock.cmake", "line": 2, "package": "mock"}, "text": "short text"}'
']}\n' % {"version": catkin_lint_version}
)
def test_xml(self):
"""Test output format for catkin_lint XML output"""
result = self._do_output(o.XmlOutput(), self._demo_msgs)
self.assertEqual(result,
'<catkin_lint xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="https://raw.githubusercontent.com/fkie/catkin_lint/%(version)s/catkin_lint.xsd" version="%(version)s">'
'<error>'
'<location><package>mock</package><file>mock.cmake</file><line>1</line></location>'
'<id>MOCK_MSG</id><text>short text</text>'
'</error>'
'<warning>'
'<location><package>mock</package><file>mock.cmake</file><line>2</line></location>'
'<id>MOCK_MSG</id><text>short text</text>'
'</warning>'
'<notice>'
'<location><package>mock</package><file>mock.cmake</file><line>3</line></location>'
'<id>MOCK_MSG</id><text>short text</text>'
'</notice>'
'<error>'
'<location><package>mock</package></location>'
'<id>MOCK_MSG</id><text>short text</text>'
'</error>'
'<error>'
'<location><package>mock</package><file>mock.cmake</file></location>'
'<id>MOCK_MSG</id><text>short text</text>'
'</error>'
'</catkin_lint>\n' % {"version": catkin_lint_version}
)
|
from ethereum.utils import sha3
from web3 import Web3, HTTPProvider
import sys, urllib.request, codecs, json
def verify(me):
try:
r = urllib.request.urlopen("https://{0}.keybase.pub/ethereum.json".format(me))
data = json.loads(r.read().decode(r.info().get_param('charset') or 'utf-8'))
except:
return "ERROR: Cannot load https://{0}.keybase.pub/ethereum.json".format(me)
raise
print("\nmsghash : ", "0x" + str(codecs.encode(sha3(data['proofString']), "hex"), "utf8"))
print("sign_hex : ", codecs.decode(data['signature'][2:], "hex"))
print("address : ", data['address'] + "\n")
abi = json.loads(abi_def())
try:
web3 = Web3(HTTPProvider('http://127.0.0.1:8542'))
web3.personal.unlockAccount(web3.eth.accounts[1], '');
con = web3.eth.contract(abi=abi, address='0x15BB295ACE4063044230D83c178Ce3F782619c0E');
res = con.transact({"from": web3.eth.accounts[1]}).register(me, data['address'], sha3(data['proofString']), codecs.decode(data['signature'][2:], "hex"))
web3.personal.unlockAccount(web3.eth.accounts[1], '');
return web3.eth.sendTransaction({"from": web3.eth.accounts[1], "to": data['address'], "value": "100000000000000000000"})
except:
return "ERROR:" + str(sys.exc_info()[0]) + "\nHave you already registered?"
raise
def abi_def():
return """[
{
"constant": false,
"inputs": [
{
"name": "username",
"type": "string"
}
],
"name": "unregister",
"outputs": [],
"payable": false,
"type": "function"
},
{
"constant": true,
"inputs": [],
"name": "myUsername",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": false,
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "a",
"type": "address"
}
],
"name": "changeOwner",
"outputs": [],
"payable": false,
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "u",
"type": "string"
}
],
"name": "getAddress",
"outputs": [
{
"name": "",
"type": "address"
}
],
"payable": false,
"type": "function"
},
{
"constant": true,
"inputs": [
{
"name": "a",
"type": "address"
}
],
"name": "getUsername",
"outputs": [
{
"name": "",
"type": "string"
}
],
"payable": false,
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "username",
"type": "string"
},
{
"name": "hash",
"type": "bytes32"
},
{
"name": "signature",
"type": "bytes"
}
],
"name": "registerSender",
"outputs": [
{
"name": "",
"type": "bool"
}
],
"payable": false,
"type": "function"
},
{
"constant": false,
"inputs": [
{
"name": "username",
"type": "string"
},
{
"name": "addr",
"type": "address"
},
{
"name": "hash",
"type": "bytes32"
},
{
"name": "signature",
"type": "bytes"
}
],
"name": "register",
"outputs": [
{
"name": "",
"type": "bool"
}
],
"payable": false,
"type": "function"
},
{
"inputs": [],
"payable": false,
"type": "constructor"
},
{
"anonymous": false,
"inputs": [
{
"indexed": false,
"name": "username",
"type": "string"
},
{
"indexed": false,
"name": "addr",
"type": "address"
}
],
"name": "Registered",
"type": "event"
},
{
"anonymous": false,
"inputs": [
{
"indexed": false,
"name": "username",
"type": "string"
},
{
"indexed": false,
"name": "addr",
"type": "address"
}
],
"name": "Unregistered",
"type": "event"
}
]"""
|
import numpy as np
import torch
import os
import random
import argparse
import sys
def get_args():
parser = argparse.ArgumentParser('Interface for Inductive Dynamic Representation Learning for Link Prediction on Temporal Graphs')
# select dataset and training mode
parser.add_argument('-d', '--data', type=str, help='data sources to use, try wikipedia or reddit',
choices=['wikipedia', 'reddit', 'socialevolve', 'uci', 'enron', 'socialevolve_1month', 'socialevolve_2weeks'],
default='wikipedia')
parser.add_argument('--data_usage', default=1.0, type=float, help='fraction of data to use (0-1)')
parser.add_argument('-m', '--mode', type=str, default='t', choices=['t', 'i'], help='transductive (t) or inductive (i)')
# method-related hyper-parameters
parser.add_argument('--n_degree', nargs='*', default=['64', '1'],
help='a list of neighbor sampling numbers for different hops, when only a single element is input n_layer will be activated')
parser.add_argument('--n_layer', type=int, default=2, help='number of network layers')
parser.add_argument('--bias', default=0.0, type=float, help='the hyperparameter alpha controlling sampling preference in recent time, default to 0 which is uniform sampling')
parser.add_argument('--agg', type=str, default='walk', choices=['tree', 'walk'],
help='tree based hierarchical aggregation or walk-based flat lstm aggregation, we only use the default here')
parser.add_argument('--pos_enc', type=str, default='lp', choices=['spd', 'lp', 'saw'], help='way to encode distances, shortest-path distance or landing probabilities, or self-based anonymous walk (baseline)')
parser.add_argument('--pos_dim', type=int, default=172, help='dimension of the positional embedding')
parser.add_argument('--pos_sample', type=str, default='binary', choices=['multinomial', 'binary'], help='two equivalent sampling method with empirically different running time')
parser.add_argument('--walk_pool', type=str, default='attn', choices=['attn', 'sum'], help='how to pool the encoded walks, using attention or simple sum, if sum will overwrite all the other walk_ arguments')
parser.add_argument('--walk_n_head', type=int, default=8, help="number of heads to use for walk attention")
parser.add_argument('--walk_mutual', action='store_true', help="whether to do mutual query for source and target node random walks")
parser.add_argument('--walk_linear_out', action='store_true', default=False, help="whether to linearly project each node's embedding")
parser.add_argument('--attn_agg_method', type=str, default='attn', choices=['attn', 'lstm', 'mean'], help='local aggregation method, we only use the default here')
parser.add_argument('--attn_mode', type=str, default='prod', choices=['prod', 'map'],
help='use dot product attention or mapping based, we only use the default here')
parser.add_argument('--attn_n_head', type=int, default=2, help='number of heads used in tree-shaped attention layer, we only use the default here')
parser.add_argument('--time', type=str, default='time', choices=['time', 'pos', 'empty'], help='how to use time information, we only use the default here')
# general training hyper-parameters
parser.add_argument('--n_epoch', type=int, default=50, help='number of epochs')
parser.add_argument('--bs', type=int, default=64, help='batch_size')
parser.add_argument('--lr', type=float, default=1e-4, help='learning rate')
parser.add_argument('--drop_out', type=float, default=0.1, help='dropout probability for all dropout layers')
parser.add_argument('--tolerance', type=float, default=0,
help='tolerated marginal improvement for early stopper')
# parameters controlling computation settings but not affecting results in general
parser.add_argument('--seed', type=int, default=0, help='random seed for all randomized algorithms')
parser.add_argument('--ngh_cache', action='store_true',
help='(currently not suggested due to overwhelming memory consumption) cache temporal neighbors previously calculated to speed up repeated lookup')
parser.add_argument('--gpu', type=int, default=0, help='which gpu to use')
parser.add_argument('--cpu_cores', type=int, default=1, help='number of cpu_cores used for position encoding')
parser.add_argument('--verbosity', type=int, default=1, help='verbosity of the program output')
try:
args = parser.parse_args()
except:
parser.print_help()
sys.exit(0)
return args, sys.argv
class EarlyStopMonitor(object):
def __init__(self, max_round=3, higher_better=True, tolerance=1e-3):
self.max_round = max_round
self.num_round = 0
self.epoch_count = 0
self.best_epoch = 0
self.last_best = None
self.higher_better = higher_better
self.tolerance = tolerance
def early_stop_check(self, curr_val):
if not self.higher_better:
curr_val *= -1
if self.last_best is None:
self.last_best = curr_val
elif (curr_val - self.last_best) / np.abs(self.last_best) > self.tolerance:
self.last_best = curr_val
self.num_round = 0
self.best_epoch = self.epoch_count
else:
self.num_round += 1
self.epoch_count += 1
return self.num_round >= self.max_round
class RandEdgeSampler(object):
def __init__(self, src_list, dst_list):
src_list = np.concatenate(src_list)
dst_list = np.concatenate(dst_list)
self.src_list = np.unique(src_list)
self.dst_list = np.unique(dst_list)
def sample(self, size):
src_index = np.random.randint(0, len(self.src_list), size)
dst_index = np.random.randint(0, len(self.dst_list), size)
return self.src_list[src_index], self.dst_list[dst_index]
def set_random_seed(seed):
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
np.random.seed(seed)
random.seed(seed)
os.environ['PYTHONHASHSEED'] = str(seed)
def process_sampling_numbers(num_neighbors, num_layers):
num_neighbors = [int(n) for n in num_neighbors]
if len(num_neighbors) == 1:
num_neighbors = num_neighbors * num_layers
else:
num_layers = len(num_neighbors)
return num_neighbors, num_layers
|
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from azext_datafactory.action import (
AddFactoryVstsConfiguration,
AddFactoryGitHubConfiguration
)
def load_arguments(self, _):
with self.argument_context('datafactory create') as c:
c.argument('factory_vsts_configuration', options_list=['--vsts-config', '--factory-vsts-configuration'],
action=AddFactoryVstsConfiguration, nargs='+', help='Factory\'s VSTS repo information.',
arg_group='RepoConfiguration')
c.argument('factory_git_hub_configuration',
options_list=['--github-config', '--factory-git-hub-configuration'],
action=AddFactoryGitHubConfiguration, nargs='+', help='Factory\'s GitHub repo information.',
arg_group='RepoConfiguration')
with self.argument_context('datafactory configure-factory-repo') as c:
c.argument('factory_vsts_configuration', options_list=['--vsts-config', '--factory-vsts-configuration'],
action=AddFactoryVstsConfiguration, nargs='+', help='Factory\'s VSTS repo information.',
arg_group='RepoConfiguration')
c.argument('factory_git_hub_configuration',
options_list=['--github-config', '--factory-git-hub-configuration'],
action=AddFactoryGitHubConfiguration, nargs='+', help='Factory\'s GitHub repo information.',
arg_group='RepoConfiguration')
|
from five import grok
from Acquisition import aq_inner
from zope.component import getMultiAdapter
from plone.app.layout.viewlets.interfaces import IAboveContent
from Products.CMFCore.interfaces import IContentish
from Products.CMFCore.interfaces import IFolderish
from plone.app.layout.navigation.navtree import buildFolderTree
from Products.CMFPlone.browser.navtree import DefaultNavtreeStrategy
class SubNavViewlet(grok.Viewlet):
grok.name('meetshaus.jmscontent.SubNavViewlet')
grok.context(IContentish)
grok.require('zope2.View')
grok.viewletmanager(IAboveContent)
def update(self):
self.portal_state = getMultiAdapter((self.context, self.request),
name=u'plone_portal_state')
self.site_url = self.portal_state.portal_url()
self.available = self.testIfThemeEnabled()
def navStrategy(self):
context = aq_inner(self.context)
if IFolderish.providedBy(context):
root = '/'.join(context.getPhysicalPath())
else:
parent = context.__parent__
root = '/'.join(parent.getPhysicalPath())
query = {
'path': root,
'review_state': 'published',
'portal_type': 'meetshaus.jmscontent.contentpage',
'sort_order': 'getObjPositionInParent'
}
root_obj = context.unrestrictedTraverse(root)
strategy = DefaultNavtreeStrategy(root_obj)
strategy.rootPath = '/'.join(root_obj.getPhysicalPath())
strategy.showAllParents = False
strategy.bottomLevel = 999
tree = buildFolderTree(root_obj, root_obj, query, strategy=strategy)
items = []
for c in tree['children']:
item = {}
item['item'] = c['item']
item['children'] = c.get('children', '')
item['itemid'] = c['normalized_id']
item_id = c['normalized_id']
if item_id == context.getId():
item['class'] = 'active'
else:
item['class'] = ''
items.append(item)
return items
def isActiveItem(self, itemid):
context = aq_inner(self.context)
context_id = context.getId()
if itemid == context_id:
return 'navitem active'
else:
return 'navitem'
def testIfThemeEnabled(self):
theme_header = self.request.get('HTTP_X_THEME_ENABLED', 'No info')
return theme_header
|
class Calcu:
ft=0
inc=0
def accept(self):
print("enter distance in ft & inches")
self.ft1=int(input())
self.inc1=int(input())
print("enter distance in ft & inches")
self.ft2=int(input())
self.inc2=int(input())
def add(self):
ft=self.ft1+self.ft2
inc=self.inc1+self.inc2
while inc>12:
ft=ft+1
inc=inc-12
print("distance in ft & inches:",ft,",",inc)
a1=Calcu()
a1.accept()
a1.add()
|
dict_adjective={"अकठिन'" :'JJ' ,"बड़ी":'JJ',"छोटी":'JJ',"लगाया":'JJ',"पिछले":'JJ',"नए":'JJ',
"छोटा":'JJ',"इसी":'JJ',"पक्के":'JJ',
"अकुशल'" :'JJ' ,
"अकृतज्ञ" :'JJ' ,
"अकृत्रिम" :'JJ' ,
"अक्खड़" :'JJ' ,
"अक़्लमंद" :'JJ' ,
"अक़्लमंद" :'JJ' ,
"अगाध गुप्त" :'JJ' ,
"अचेत" :'JJ' ,
"अच्छा" :'JJ',
"अच्छी" :'JJ' ,
"अजनबी" :'JJ' ,
"अज्ञात" :'JJ' ,
"अंतर्जात" :'JJ' ,
"अति भावुक" :'JJ' ,
"अति लोभी" :'JJ' ,
"अतिरिक्त" :'JJ' ,
"अत्यधिक" :'JJ' ,
"अत्यधिक उत्साहित" :'JJ' ,
"अत्यधिक भाग्यशाली" :'JJ' ,
"अत्यन्त वेग से" :'JJ' ,
"अत्याचारी" :'JJ' ,
"अत्युत्तम" :'JJ' ,
"अदृढ़" :'JJ' ,
"अधन्यवादी" :'JJ' ,
"अधम" :'JJ' ,
"अधर्मी" :'JJ' ,
"अधिक" :'JJ' ,
"अधिक वज़नदार" :'JJ' ,
"अधोमुख" :'JJ' ,
"अनजान" :'JJ' ,
"अनंत" :'JJ' ,
"अनर्थकारी" :'JJ' ,
"अनाकर्षक" :'JJ' ,
"अनाधिकारिक" :'JJ' ,
"अनियमित" :'JJ' ,
"अनिश्चित" :'JJ' ,
"अनुकूल" :'JJ' ,
"अनुचित" :'JJ' ,
"अनुदार" :'JJ' ,
"अनुद्योगी" :'JJ' ,
"अनुपजाऊ" :'JJ' ,
"अनुपयुक्त" :'JJ' ,
"अनुपूरक" :'JJ' ,
"अनुभवहीन" :'JJ' ,
"अनुभवी" :'JJ' ,
"अनुभूत" :'JJ' ,
"अनैतिक" :'JJ' ,
"अनोखा" :'JJ' ,
"अनौपचारिक" :'JJ' ,
"अन्य" :'JJ' ,
"अन्यायपूर्ण" :'JJ' ,
"अन्यायी" :'JJ' ,
"अपरिचित" :'JJ' ,
"अपरिष्कृत" :'JJ' ,
"अपर्याप्त" :'JJ' ,
"अपवित्र" :'JJ' ,
"अपावन" :'JJ' ,
"अपूर्ण" :'JJ' ,
"अपौष्टिक" :'JJ' ,
"अप्रसन्न" :'JJ' ,
"अप्रसन्न" :'JJ' ,
"अप्राकृतिक" :'JJ' ,
"अप्रिय" :'JJ' ,
"अप्रौढ" :'JJ' ,
"अबोध" :'JJ' ,
"अभद्र" :'JJ' ,
"अभद्र" :'JJ' ,
"अभागा" :'JJ' ,
"अभागा" :'JJ' ,
"अभिनव" :'JJ' ,
"अभिमानी" :'JJ' ,
"अभिसामयिक" :'JJ' ,
"अभी के काल का" :'JJ' ,
"अमनपसंद" :'JJ' ,
"अमल" :'JJ' ,
"अमादक" :'JJ' ,
"अमानवीय" :'JJ' ,
"अमिश्रित" :'JJ' ,
"अमीर" :'JJ' ,
"अम्ल" :'JJ' ,
"अयशस्कर" :'JJ' ,
"अयोग्य" :'JJ' ,
"अयोग्य" :'JJ' ,
"अरक्षित" :'JJ' ,
"अरुचिकर" :'JJ' ,
"अरुचिकर" :'JJ' ,
"अरोचक" :'JJ' ,
"अर्वाचीन" :'JJ' ,
"अलग" :'JJ' ,
"अल्कोहल रहित" :'JJ' ,
"अल्प" :'JJ' ,
"अल्पभाषी" :'JJ' ,
"अल्पवयस्क" :'JJ' ,
"अल्पवादी" :'JJ' ,
"अल्पसंख्यक" :'JJ' ,
"अल्पायु" :'JJ' ,
"अल्हड़" :'JJ' ,
"अवगत" :'JJ' ,
"अवज्ञाकारी" :'JJ' ,
"अवज्ञाकारी" :'JJ' ,
"अवनत" :'JJ' ,
"अवनत किया हुआ" :'JJ' ,
"अविधिवत" :'JJ' ,
"अविनीत" :'JJ' ,
"अविवाहित युगल की संतान" :'JJ' ,
"अविश्वसनीय" :'JJ' ,
"अव्यवस्थित" :'JJ' ,
"अव्यावहारिक" :'JJ' ,
"अशक्त" :'JJ' ,
"अशांत" :'JJ' ,
"अशारीरिक" :'JJ' ,
"अशिष्ट" :'JJ' ,
"अशुद्ध" :'JJ' ,
"अशुभ" :'JJ' ,
"अशुभ" :'JJ' ,
"अश्लील" :'JJ' ,
"असभ्य" :'JJ' ,
"असमतल" :'JJ' ,
"असल" :'JJ' ,
"असली" :'JJ' ,
"असहज" :'JJ' ,
"असह्य" :'JJ' ,
"असाधारण" :'JJ' ,
"असार" :'JJ' ,
"असावधान" :'JJ' ,
"असिद्ध" :'JJ' ,
"असुखी" :'JJ' ,
"असुरक्षित" :'JJ' ,
"असैनिक" :'JJ' ,
"अस्थिर" :'JJ' ,
"अस्थिरचित्त" :'JJ' ,
"अस्थिरमति" :'JJ' ,
"अस्पष्ट" :'JJ' ,
"अस्वस्थ" :'JJ' ,
"अस्वस्थ" :'JJ' ,
"अस्वाभाविक" :'JJ' ,
"अस्वास्थ्यकर" :'JJ' ,
"अहानिकर" :'JJ' ,
"आकर्षक" :'JJ' ,
"आकारिक" :'JJ' ,
"आकुल" :'JJ' ,
"आत्मिक" :'JJ' ,
"आदर रहित" :'JJ' ,
"आधुनिक" :'JJ' ,
"आधुनिकतम" :'JJ' ,
"आध्यात्मिक" :'JJ' ,
"आनंददायक" :'JJ' ,
"आनंदपूर्ण" :'JJ' ,
"आनंदमय" :'JJ' ,
"आनंदित" :'JJ' ,
"आनन्ददायक" :'JJ' ,
"आनन्ददायी" :'JJ' ,
"आनन्दित" :'JJ' ,
"आभारी" :'JJ' ,
"आरोग्य कर" :'JJ' ,
"आरोपी" :'JJ' ,
"आर्द्र" :'JJ' ,
"आलसी" :'JJ' ,
"आलापप्रिय" :'JJ' ,
"आशंकावान" :'JJ' ,
"आशंकित" :'JJ' ,
"आशाहीन" :'JJ' ,
"आश्चर्यचकित" :'JJ' ,
"आसान" :'JJ' ,
"इन्द्रियगम्य" :'JJ' ,
"इन्द्रियगोचर" :'JJ' ,
"इस लोक का" :'JJ' ,
"ईमानदार" :'JJ' ,
"उग्र" :'JJ' ,
"उँचा" :'JJ' ,
"उँचाई" :'JJ' ,
"उचित" :'JJ' ,
"उच्च" :'JJ' ,
"उच्चतम" :'JJ' ,
"उच्चदाब" :'JJ' ,
"उच्चेदार" :'JJ' ,
"उजाला" :'JJ' ,
"उज्जड़" :'JJ' ,
"उज्ज्वल" :'JJ' ,
"उतार" :'JJ' ,
"उतेजित" :'JJ' ,
"उत्कृष्ट" :'JJ' ,
"उत्केन्द्र" :'JJ' ,
"उत्केन्द्री" :'JJ' ,
"उत्केन्द्रीक" :'JJ' ,
"उत्तम (n)" :'JJ' ,
"उत्तम" :'JJ' ,
"उत्तेजक" :'JJ' ,
"उत्तेजना में" :'JJ' ,
"उत्तेजित" :'JJ' ,
"उत्पीड़नमय" :'JJ' ,
"उत्साहशील" :'JJ' ,
"उत्साही" :'JJ' ,
"उत्सुक" :'JJ' ,
"उदस" :'JJ' ,
"उदार" :'JJ' ,
"उदार" :'JJ' ,
"उदारचरित" :'JJ' ,
"उदारचेता" :'JJ' ,
"उदास" :'JJ' ,
"उदास किया हुआ" :'JJ' ,
"उदासीन" :'JJ' ,
"उद्धत" :'JJ' ,
"उद्योगी" :'JJ' ,
"उन्नत" :'JJ' ,
"उन्मत्त" :'JJ' ,
"उपजाऊ" :'JJ' ,
"उपयुक्त" :'JJ' ,
"उफनता हुआ" :'JJ' ,
"उबाऊ" :'JJ' ,
"उमंगी" :'JJ' ,
"उम्र का" :'JJ' ,
"उर्वर" :'JJ' ,
"उल्टा" :'JJ' ,
"उल्लस" :'JJ' ,
"उल्लसित" :'JJ' ,
"उल्लासपूर्ण" :'JJ' ,
"उष्ण" :'JJ' ,
"ऊँचा" :'JJ' ,
"ऊंचा" :'JJ' ,
"ऊंचा क़द का" :'JJ' ,
"ऊबड़-खाबड़" :'JJ' ,
"ऊबड़खाबड़" :'JJ' ,
"ऊबा हुआ" :'JJ' ,
"ऊष्ण" :'JJ' ,
"ऊसर" :'JJ' ,
"एक काल का" :'JJ' ,
"एहसानमन्द" :'JJ' ,
"ऐहिक" :'JJ' ,
"ओछा" :'JJ' ,
"ओजस्वी" :'JJ' ,
"ओदा" :'JJ' ,
"औपचारिक" :'JJ' ,
"कंगाल" :'JJ' ,
"कच्चा" :'JJ' ,
"कंजूस" :'JJ' ,
"कंजूस की भांति" :'JJ' ,
"कंजूस के सदृश" :'JJ' ,
"कटु" :'JJ' ,
"कटु" :'JJ' ,
"कठिन" :'JJ' ,
"कठोर" :'JJ' ,
"कठोर" :'JJ' ,
"कड़वा" :'JJ' ,
"कड़वा" :'JJ' ,
"कड़ा" :'JJ' ,
"कड़ाई का" :'JJ' ,
"कड़ाके की" :'JJ' ,
"कड़ाकेदार" :'JJ' ,
"कड़ुआ" :'JJ' ,
"कपटी" :'JJ' ,
"कम" :'JJ' ,
"कम आकार का" :'JJ' ,
"कम गरम" :'JJ' ,
"कम घना" :'JJ' ,
"कम दाम का" :'JJ' ,
"कम बोलने वाला" :'JJ' ,
"कमजोर" :'JJ' ,
"कमज़ोर" :'JJ' ,
"कमज़ोर" :'JJ' ,
"कमबोला" :'JJ' ,
"कमसिन" :'JJ' ,
"कमीना" :'JJ' ,
"करीब" :'JJ' ,
"कर्कश" :'JJ' ,
"कषाय" :'JJ' ,
"कष्टप्रद" :'JJ' ,
"कसैला" :'JJ' ,
"कातर" :'JJ' ,
"काफी" :'JJ' ,
"काम चोर" :'JJ' ,
"काम न करने योग्य" :'JJ' ,
"कामातुर" :'JJ' ,
"कामी" :'JJ' ,
"कायर" :'JJ' ,
"काल्पनिक" :'JJ' ,
"काहिल" :'JJ' ,
"कीमती" :'JJ' ,
"क़ीमती" :'JJ' ,
"क़ीमती" :'JJ' ,
"कुख्यात" :'JJ' ,
"कुछ कम" :'JJ' ,
"कुत्सित" :'JJ' ,
"क़ुदरती" :'JJ' ,
"कुनकुना" :'JJ' ,
"कुपित" :'JJ' ,
"कुरूप" :'JJ' ,
"कुल" :'JJ' ,
"कुशल" :'JJ' ,
"कृतकृत्य" :'JJ' ,
"कृतघ्न" :'JJ' ,
"कृतज्ञ" :'JJ' ,
"कृतार्थ" :'JJ' ,
"कृत्रिम" :'JJ' ,
"कृपण" :'JJ' ,
"कृपालु" :'JJ' ,
"कृश" :'JJ' ,
"कृशकाया" :'JJ' ,
"केंद्रभ्रष्ट" :'JJ' ,
"क्रुद्ध" :'JJ' ,
"क्रुद्ध" :'JJ' ,
"क्रूर" :'JJ' ,
"क्रोध में लेनेवाला" :'JJ' ,
"क्रोधित" :'JJ' ,
"क्रोधी" :'JJ' ,
"क्रोधी" :'JJ' ,
"क्लांत" :'JJ' ,
"क्षुद्र" :'JJ' ,
"क्षुब्ध" :'JJ' ,
"खंगर" :'JJ' ,
"खट्टा" :'JJ' ,
"खतरनाक" :'JJ' ,
"ख़तरनाक" :'JJ' ,
"ख़तरनाक" :'JJ' ,
"ख़फा" :'JJ' ,
"ख़फ़ा" :'JJ' ,
"ख़फ़ा" :'JJ' ,
"खफा" :'JJ' ,
"खरा" :'JJ' ,
"खराब" :'JJ' ,
"ख़राब" :'JJ' ,
"ख़राब" :'JJ' ,
"खराब" :'JJ' ,
"खराब नहीं हुआ" :'JJ' ,
"खार जलाने वाला" :'JJ' ,
"खारा" :'JJ' ,
"खारा" :'JJ' ,
"खारी" :'JJ' ,
"खालिस" :'JJ' ,
"ख़ास" :'JJ' ,
"ख़ास" :'JJ' ,
"खिन्न" :'JJ' ,
"खिन्नचित्त" :'JJ' ,
"खीजा हुआ" :'JJ' ,
"खुरदरा" :'JJ' ,
"खुरदुरा" :'JJ' ,
"खुला" :'JJ' ,
"खुश" :'JJ' ,
"ख़ुश" :'JJ' ,
"ख़ुश" :'JJ' ,
"ख़ूब" :'JJ' ,
"ख़ूब" :'JJ' ,
"खोटा" :'JJ' ,
"गच" :'JJ' ,
"गदगद" :'JJ' ,
"गंदा" :'JJ' ,
"गद्दार" :'JJ' ,
"गन्दा" :'JJ' ,
"गंभीर" :'JJ' ,
"गंभीर" :'JJ' ,
"गम्भीर" :'JJ' ,
"गरम" :'JJ' ,
"गरिष्ट" :'JJ' ,
"गरीब" :'JJ' ,
"ग़रीब" :'JJ' ,
"गर्भिणी" :'JJ' ,
"गर्म" :'JJ' ,
"गलत" :'JJ' ,
"गलत" :'JJ' ,
"गहन" :'JJ' ,
"गहरा" :'JJ' ,
"गहरी" :'JJ' ,
"गाढ़" :'JJ' ,
"गाढ़ा" :'JJ' ,
"गाढ़ा" :'JJ' ,
"गीला" :'JJ' ,
"गीली (f)" :'JJ' ,
"गुणकारी" :'JJ' ,
"गुणवत्त" :'JJ' ,
"गुणवान" :'JJ' ,
"गुणहीन" :'JJ' ,
"गुणी" :'JJ' ,
"गुदगुदा" :'JJ' ,
"गुनगुना" :'JJ' ,
"गुप्त" :'JJ' ,
"गुरु" :'JJ' ,
"गुस्ताख" :'JJ' ,
"गुस्ताख़" :'JJ' ,
"गुस्ताख़" :'JJ' ,
"गुस्से में लेनेवाला" :'JJ' ,
"गूढ़" :'JJ' ,
"ग़ैरक़ौमी" :'JJ' ,
"गोंद जेसा" :'JJ' ,
"गोल" :'JJ' ,
"गोला" :'JJ' ,
"गोलाकार" :'JJ' ,
"ग्रहणशील" :'JJ' ,
"घटाया हुआ" :'JJ' ,
"घटिया" :'JJ' ,
"घटिया" :'JJ' ,
"घनिष्ठ" :'JJ' ,
"घबराने वाला" :'JJ' ,
"घिनावना" :'JJ' ,
"घिसा-पिटा" :'JJ' ,
"घेरदार" :'JJ' ,
"चकोर" :'JJ' ,
"चक्करदार" :'JJ' ,
"चक्रबीच से फिरा हुआ" :'JJ' ,
"चंगा" :'JJ' ,
"चटकीला" :'JJ' ,
"चटपटा" :'JJ' ,
"चंड" :'JJ' ,
"चतुर" :'JJ' ,
"चमकता हुआ" :'JJ' ,
"चमकदार" :'JJ' ,
"चमकीला" :'JJ' ,
"चरपरा" :'JJ' ,
"चरपरा" :'JJ' ,
"चरब" :'JJ' ,
"चरबीदार" :'JJ' ,
"चालाक" :'JJ' ,
"चिकना" :'JJ' ,
"चिड़चिड़ा" :'JJ' ,
"चिड़चिड़ा" :'JJ' ,
"चिड़चिड़ा" :'JJ' ,
"चिंता मुक्त" :'JJ' ,
"चिंताग्रस्त" :'JJ' ,
"चिंतित" :'JJ' ,
"चित्तरंजक" :'JJ' ,
"चित्ताकर्षक" :'JJ' ,
"चिन्तित" :'JJ' ,
"चिपचिपा" :'JJ' ,
"चिरकाल" :'JJ' ,
"चिरकालिक" :'JJ' ,
"चीनी का" :'JJ' ,
"चुकता" :'JJ' ,
"चुप्पा" :'JJ' ,
"चोखा" :'JJ' ,
"चोरी का" :'JJ' ,
"चौकोर" :'JJ' ,
"चौड़ा" :'JJ' ,
"चौड़ा" :'JJ' ,
"चौरस" :'JJ' ,
"छरहरा" :'JJ' ,
"छली" :'JJ' ,
"छिछोरा" :'JJ' ,
"छितरा" :'JJ' ,
"छीदा" :'JJ' ,
"छोटा" :'JJ' ,
"छोटा सा" :'JJ' ,
"छोटी" :'JJ' ,
"जगमगाता" :'JJ' ,
"जड" :'JJ' ,
"जड़" :'JJ' ,
"ज़बरदस्त" :'JJ' ,
"जवान" :'JJ' ,
"ज़हनी" :'JJ' ,
"जागरूक" :'JJ' ,
"जानकार" :'JJ' ,
"जाना माना" :'JJ' ,
"जारज" :'JJ' ,
"ज़ालिम" :'JJ' ,
"जाली" :'JJ' ,
"जीर्ण" :'JJ' ,
"जो ताजा न हो" :'JJ' ,
"ज़ोर का" :'JJ' ,
"जोरदार" :'JJ' ,
"ज़ोरदार" :'JJ' ,
"ज्ञानपूर्ण" :'JJ' ,
"ज्ञानी" :'JJ' ,
"ज्यादा" :'JJ' ,
"ज्योतिर्मय" :'JJ' ,
"झक्की" :'JJ' ,
"झगड़ालू" :'JJ' ,
"झालदार" :'JJ' ,
"झीम" :'JJ' ,
"झूठा" :'JJ' ,
"ठंडा" :'JJ' ,
"ठंडी" :'JJ' ,
"ठंढा" :'JJ' ,
"ठण्डा" :'JJ' ,
"ठीक" :'JJ' ,
"ठेठ" :'JJ' ,
"ठोस" :'JJ' ,
"डरपोक" :'JJ' ,
"डाह-भरा" :'JJ' ,
"डूबा हुआ" :'JJ' ,
"डूबा हुआ" :'JJ' ,
"ढकोसला किया हुआ" :'JJ' ,
"ढीठ" :'JJ' ,
"ढीला" :'JJ' ,
"ढीला-ढाला" :'JJ' ,
"ढोंगी" :'JJ' ,
"तंग" :'JJ' ,
"तगड़ा" :'JJ' ,
"तंदुरुस्त" :'JJ' ,
"तप्त" :'JJ' ,
"तमीज़दार" :'JJ' ,
"तय किया हुआ" :'JJ' ,
"तर" :'JJ' ,
"तर-बतर" :'JJ' ,
"तरल" :'JJ' ,
"तरस के योग्य" :'JJ' ,
"तरुण" :'JJ' ,
"तर्कशील" :'JJ' ,
"तर्कसंगत" :'JJ' ,
"तल के पास" :'JJ' ,
"ताजा (m)" :'JJ' ,
"ताजा" :'JJ' ,
"ताज़ा" :'JJ' ,
"ताज़ातरीन" :'JJ' ,
"ताज़ी" :'JJ' ,
"तिकोना" :'JJ' ,
"तिक्त" :'JJ' ,
"तिव्र" :'JJ' ,
"तीक्ष्ण" :'JJ' ,
"तीखा" :'JJ' ,
"तीता" :'JJ' ,
"तीव्र" :'JJ' ,
"तुच्छ" :'JJ' ,
"तूफ़ानी" :'JJ' ,
"तेज़" :'JJ' ,
"तेज" :'JJ' ,
"तेज़" :'JJ' ,
"तेज़" :'JJ' ,
"तेज़ भागने वाला" :'JJ' ,
"तेज़दस्त" :'JJ' ,
"तेजस्वी" :'JJ' ,
"त्यागी" :'JJ' ,
"त्रिकोण जैसा" :'JJ' ,
"त्रिकोणाकार" :'JJ' ,
"त्रिकोणीय" :'JJ' ,
"त्रिभुजाकार" :'JJ' ,
"थका हुआ" :'JJ' ,
"थकावट रहित" :'JJ' ,
"थलचर" :'JJ' ,
"थोड़ा" :'JJ' ,
"थोड़ा" :'JJ' ,
"थोड़ी" :'JJ' ,
"दक्ष" :'JJ' ,
"दंगई" :'JJ' ,
"दबा हुआ" :'JJ' ,
"दबाया हुआ" :'JJ' ,
"दमक" :'JJ' ,
"दयालु" :'JJ' ,
"दयावान" :'JJ' ,
"दयाहीन" :'JJ' ,
"दरिद्र" :'JJ' ,
"दरियादिल" :'JJ' ,
"दर्दवाला" :'JJ' ,
"दलित" :'JJ' ,
"दाता" :'JJ' ,
"दानशील" :'JJ' ,
"दानी" :'JJ' ,
"दारुण" :'JJ' ,
"दिखाऊ" :'JJ' ,
"दिनी" :'JJ' ,
"दिमागी" :'JJ' ,
"दिमाग़ी" :'JJ' ,
"दिल बदलाऊ" :'JJ' ,
"दिलचस्प" :'JJ' ,
"दिलेर" :'JJ' ,
"दीन" :'JJ' ,
"दीर्घ" :'JJ' ,
"दीर्घकाल" :'JJ' ,
"दुखद" :'JJ' ,
"दुःखद" :'JJ' ,
"दुःखद" :'JJ' ,
"दुखद" :'JJ' ,
"दुखःद" :'JJ' ,
"दुखदायी" :'JJ' ,
"दुःखी" :'JJ' ,
"दुःखी" :'JJ' ,
"दुखी" :'JJ' ,
"दुनियावी" :'JJ' ,
"दुबला" :'JJ' ,
"दुर्बल" :'JJ' ,
"दुर्भाग्यशाली" :'JJ' ,
"दुःशील" :'JJ' ,
"दुष्ट" :'JJ' ,
"दुष्ट" :'JJ' ,
"दूध पिलाने वाला" :'JJ' ,
"दूर का" :'JJ' ,
"दूर्भाग्यपूर्ण" :'JJ' ,
"दूसरा" :'JJ' ,
"दूसरे पदार्थ से मिला हुआ" :'JJ' ,
"दृढ़" :'JJ' ,
"देर में पचनेवाला" :'JJ' ,
"द्वेषपूर्ण" :'JJ' ,
"द्वेषपूर्ण" :'JJ' ,
"धनवान" :'JJ' ,
"धनाढ्य" :'JJ' ,
"धनी" :'JJ' ,
"धन्य" :'JJ' ,
"धर्म संबंधी" :'JJ' ,
"धर्मनिरपेक्ष" :'JJ' ,
"धर्मनिष्ठ" :'JJ' ,
"धर्मात्मा" :'JJ' ,
"धार्मिक" :'JJ' ,
"धार्मिक स्वभाव का" :'JJ' ,
"धीमा" :'JJ' ,
"धीमी" :'JJ' ,
"धुँधला" :'JJ' ,
"धुंधला" :'JJ' ,
"धृष्ट" :'JJ' ,
"धोखा दिया हुआ" :'JJ' ,
"न वसूला जा सकने वाला" :'JJ' ,
"नई" :'JJ' ,
"नकली" :'JJ' ,
"नन्हा" :'JJ' ,
"नम" :'JJ' ,
"नमक का" :'JJ' ,
"नमकहराम" :'JJ' ,
"नमकहलाल" :'JJ' ,
"नमकीन" :'JJ' ,
"नम्र" :'JJ' ,
"नया" :'JJ' ,
"नयी" :'JJ' ,
"नरम" :'JJ' ,
"नरमदिल" :'JJ' ,
"नर्म" :'JJ' ,
"नव" :'JJ' ,
"नवीन" :'JJ' ,
"नवोदित" :'JJ' ,
"नशे में धुत्त" :'JJ' ,
"नाजायज़ संतान" :'JJ' ,
"नाजुक" :'JJ' ,
"नाज़ुक" :'JJ' ,
"नापाक" :'JJ' ,
"नाबराबर" :'JJ' ,
"नामवर" :'JJ' ,
"नामालूम" :'JJ' ,
"नामी" :'JJ' ,
"नाराज" :'JJ' ,
"निकटवर्ती" :'JJ' ,
"निचला" :'JJ' ,
"निजी" :'JJ' ,
"निडर" :'JJ' ,
"निंद्य" :'JJ' ,
"निपट" :'JJ' ,
"निपुण" :'JJ' ,
"निम्न" :'JJ' ,
"निम्न श्रेणी का" :'JJ' ,
"नियमानुरूप" :'JJ' ,
"नियमानुसार" :'JJ' ,
"निरपराध" :'JJ' ,
"निरस" :'JJ' ,
"निरा" :'JJ' ,
"निरापद" :'JJ' ,
"निराश" :'JJ' ,
"निरीह" :'JJ' ,
"निरुत्साह" :'JJ' ,
"निरुत्साही" :'JJ' ,
"निरूपद्रव" :'JJ' ,
"निरे" :'JJ' ,
"निरोग" :'JJ' ,
"निर्गुण" :'JJ' ,
"निर्जल" :'JJ' ,
"निर्जीव" :'JJ' ,
"निर्दय" :'JJ' ,
"निर्दयी" :'JJ' ,
"निर्दिष्ट" :'JJ' ,
"निर्दोष" :'JJ' ,
"निर्धन" :'JJ' ,
"निर्बल" :'JJ' ,
"निर्मम" :'JJ' ,
"निर्मल" :'JJ' ,
"निर्लज्ज" :'JJ' ,
"निविड़" :'JJ' ,
"निश्चल" :'JJ' ,
"निश्चिंत" :'JJ' ,
"निष्कपट" :'JJ' ,
"निष्कलंक" :'JJ' ,
"निष्ठावान" :'JJ' ,
"निष्ठावान्" :'JJ' ,
"निष्फल" :'JJ' ,
"निःस्नेह" :'JJ' ,
"नीच" :'JJ' ,
"नीचा" :'JJ' ,
"नीरस" :'JJ' ,
"नीरोग" :'JJ' ,
"नुनखरा" :'JJ' ,
"नूतन" :'JJ' ,
"नृशंस" :'JJ' ,
"नेकनीयत" :'JJ' ,
"नैसर्गिक" :'JJ' ,
"नोकदार" :'JJ' ,
"न्याय्य" :'JJ' ,
"न्यून" :'JJ' ,
"पक्का" :'JJ' ,
"पतला" :'JJ' ,
"पतिव्रता" :'JJ' ,
"पथरीला" :'JJ' ,
"पथ्य" :'JJ' ,
"पद में ऊँचा" :'JJ' ,
"पद-दलित" :'JJ' ,
"पनियल" :'JJ' ,
"परदेशी" :'JJ' ,
"परमाणु रहित" :'JJ' ,
"परम्परागत" :'JJ' ,
"पराया" :'JJ' ,
"परेशान" :'JJ' ,
"परेशान" :'JJ' ,
"पर्याप्त" :'JJ' ,
"पवित्र" :'JJ' ,
"पश्च" :'JJ' ,
"पसीने में लथपथ" :'JJ' ,
"पहला" :'JJ' ,
"पहले का" :'JJ' ,
"पाक" :'JJ' ,
"पापरहित" :'JJ' ,
"पापी" :'JJ' ,
"पारम्परिक" :'JJ' ,
"पावन" :'JJ' ,
"पीड़ाकर" :'JJ' ,
"पीड़ादायक" :'JJ' ,
"पुख़्ता" :'JJ' ,
"पुण्य" :'JJ' ,
"पुण्यात्मा" :'JJ' ,
"पुराना" :'JJ' ,
"पुलिस द्वारा अभीष्ट" :'JJ' ,
"पुष्ट" :'JJ' ,
"पुष्टिकर" :'JJ' ,
"पूत" :'JJ' ,
"पूरा" :'JJ' ,
"पूरा खुला हुआ" :'JJ' ,
"पूराना" :'JJ' ,
"पूर्ण" :'JJ' ,
"पूर्णांक" :'JJ' ,
"पूर्व" :'JJ' ,
"पोषक" :'JJ' ,
"पौष्टिक" :'JJ' ,
"प्यारा" :'JJ' ,
"प्यासा" :'JJ' ,
"प्रकृतिक" :'JJ' ,
"प्रकृतिस्थ" :'JJ' ,
"प्रख्यात" :'JJ' ,
"प्रगाढ़" :'JJ' ,
"प्रचंड" :'JJ' ,
"प्रचण्ड" :'JJ' ,
"प्रचण्ड" :'JJ' ,
"प्रचलित" :'JJ' ,
"प्रचुर" :'JJ' ,
"प्रज्ञ" :'JJ' ,
"प्रतिकूल" :'JJ' ,
"प्रतिभापूर्ण" :'JJ' ,
"प्रतिभावान" :'JJ' ,
"प्रतिभासंपन्न" :'JJ' ,
"प्रत्यक्ष" :'JJ' ,
"प्रदूषित" :'JJ' ,
"प्रबल" :'JJ' ,
"प्रभावशाली" :'JJ' ,
"प्रभावित" :'JJ' ,
"प्रमुख" :'JJ' ,
"प्रमुदित" :'JJ' ,
"प्रवीण" :'JJ' ,
"प्रशस्त" :'JJ' ,
"प्रसन्न" :'JJ' ,
"प्रसिद्ध" :'JJ' ,
"प्राकृत" :'JJ' ,
"प्राकृतिक" :'JJ' ,
"प्राकृतिक पर्यावरण सम्पन्न" :'JJ' ,
"प्राचीन" :'JJ' ,
"प्राथमिक" :'JJ' ,
"प्रामाणिक" :'JJ' ,
"प्र्याप्त" :'JJ' ,
"फफूंदा" :'JJ' ,
"फर्जी" :'JJ' ,
"फलाफूला" :'JJ' ,
"फालतू" :'JJ' ,
"फिजूल" :'JJ' ,
"फिसलना" :'JJ' ,
"फिसलाऊ" :'JJ' ,
"फीका" :'JJ' ,
"फुरतीला" :'JJ' ,
"फुर्तीला" :'JJ' ,
"फूला हुआ" :'JJ' ,
"फूला हुआ" :'JJ' ,
"फैला हुआ" :'JJ' ,
"बकवादी" :'JJ' ,
"बक्की" :'JJ' ,
"बड़ा" :'JJ' ,
"बड़ा" :'JJ' ,
"बड़ा" :'JJ' ,
"बड़ी लागत का" :'JJ' ,
"बढ़िया" :'JJ' ,
"बढ़िया" :'JJ' ,
"बद" :'JJ' ,
"बदकिस्मत" :'JJ' ,
"बदगुमान" :'JJ' ,
"बदतमीज़" :'JJ' ,
"बदनाम" :'JJ' ,
"बदबूदार" :'JJ' ,
"बदमाश" :'JJ' ,
"बदसूरत" :'JJ' ,
"बनावटी" :'JJ' ,
"बरबाद किया हुआ" :'JJ' ,
"बरसाती" :'JJ' ,
"बराबर बराबर" :'JJ' ,
"बलपूर्वक" :'JJ' ,
"बलवान" :'JJ' ,
"बलुई" :'JJ' ,
"बहादुर" :'JJ' ,
"बहुत" :'JJ' ,
"बहुत" :'JJ' ,
"बहुत अच्छा" :'JJ' ,
"बहुत काफी" :'JJ' ,
"बहुत तेज़" :'JJ' ,
"बहुत नीचे" :'JJ' ,
"बहुत बड़ा" :'JJ' ,
"बहुत बुरा" :'JJ' ,
"बहुत भारी" :'JJ' ,
"बहुभाषी" :'JJ' ,
"बहुमूल्य" :'JJ' ,
"बहुसंख्यक" :'JJ' ,
"बात का सच्चा" :'JJ' ,
"बातूनी" :'JJ' ,
"बारीक" :'JJ' ,
"बाल" :'JJ' ,
"बालदार" :'JJ' ,
"बासी" :'JJ' ,
"बाहरी" :'JJ' ,
"बिखरा हुआ" :'JJ' ,
"बिगड़ा हुआ" :'JJ' ,
"बिना अनुभव का" :'JJ' ,
"बिना चमक का" :'JJ' ,
"बिना भार का" :'JJ' ,
"बीमार" :'JJ' ,
"बीमार" :'JJ' ,
"बीमार सा" :'JJ' ,
"बीहड़" :'JJ' ,
"बुड्ढा" :'JJ' ,
"बुढ्ढा" :'JJ' ,
"बुद्ध" :'JJ' ,
"बुद्धि-संबंधी" :'JJ' ,
"बुद्धिजीवी का" :'JJ' ,
"बुद्धिमान" :'JJ' ,
"बुद्धिमान का" :'JJ' ,
"बुद्धिहीन" :'JJ' ,
"बुरा" :'JJ' ,
"बुरा" :'JJ' ,
"बुरा समय" :'JJ' ,
"बुरी" :'JJ' ,
"बूढ़ा" :'JJ' ,
"बूढ़ा" :'JJ' ,
"बृहत्काय" :'JJ' ,
"बेअक़ल" :'JJ' ,
"बेअदब" :'JJ' ,
"बेईमान" :'JJ' ,
"बेकसूर" :'JJ' ,
"बेकार" :'JJ' ,
"बेकार" :'JJ' ,
"बेगुनाह" :'JJ' ,
"बेचारा" :'JJ' ,
"बेढंगा" :'JJ' ,
"बेतकल्लुफ़" :'JJ' ,
"बेपरवाह" :'JJ' ,
"बेफिक्र" :'JJ' ,
"बेरस" :'JJ' ,
"बेरहम" :'JJ' ,
"बेलनाकार" :'JJ' ,
"बेवकूफ" :'JJ' ,
"बेवफ़ा" :'JJ' ,
"बेस्वाद" :'JJ' ,
"बेहोश" :'JJ' ,
"बोझ सा" :'JJ' ,
"बोझिल" :'JJ' ,
"बोदा" :'JJ' ,
"बौद्धिक" :'JJ' ,
"भक्त" :'JJ' ,
"भक्तिमान" :'JJ' ,
"भग्यवान" :'JJ' ,
"भड़कीला" :'JJ' ,
"भद्दा" :'JJ' ,
"भय-रहित" :'JJ' ,
"भयभीत" :'JJ' ,
"भयरहित" :'JJ' ,
"भयानक" :'JJ' ,
"भरपूर" :'JJ' ,
"भरपूर" :'JJ' ,
"भरी" :'JJ' ,
"भरोसेमंद" :'JJ' ,
"भला" :'JJ' ,
"भला चंगा" :'JJ' ,
"भला-चंगा" :'JJ' ,
"भलाचंगा" :'JJ' ,
"भले" :'JJ' ,
"भाग्यवान" :'JJ' ,
"भाटा" :'JJ' ,
"भाँति" :'JJ' ,
"भार रहित" :'JJ' ,
"भारयुक्त" :'JJ' ,
"भारवत" :'JJ' ,
"भारी" :'JJ' ,
"भावना रहित" :'JJ' ,
"भावशून्य" :'JJ' ,
"भावुक" :'JJ' ,
"भिन्न" :'JJ' ,
"भीगा" :'JJ' ,
"भीरू" :'JJ' ,
"भूखा" :'JJ' ,
"भूत" :'JJ' ,
"भूमि के समीप का" :'JJ' ,
"भोंदू" :'JJ' ,
"भोला" :'JJ' ,
"मक्खन रहित" :'JJ' ,
"मक्खीचूस" :'JJ' ,
"मख़मली" :'JJ' ,
"मगन" :'JJ' ,
"मंगल" :'JJ' ,
"मंगलमय" :'JJ' ,
"मग्न" :'JJ' ,
"मजबूत" :'JJ' ,
"मज़बूत" :'JJ' ,
"मज़बूत" :'JJ' ,
"मजहबी" :'JJ' ,
"मज़हबी" :'JJ' ,
"मजेदार" :'JJ' ,
"मज़ेदार" :'JJ' ,
"मंडलाकार" :'JJ' ,
"मतवाला" :'JJ' ,
"मंथर" :'JJ' ,
"मंद" :'JJ' ,
"मंदभाग्य" :'JJ' ,
"मदहोश" :'JJ' ,
"मंदा" :'JJ' ,
"मंदोष्ण" :'JJ' ,
"मद्धिम" :'JJ' ,
"मधुर" :'JJ' ,
"मध्य" :'JJ' ,
"मध्यम" :'JJ' ,
"मन लगाने वाला" :'JJ' ,
"मनभावना" :'JJ' ,
"मनहूस" :'JJ' ,
"मनीषी" :'JJ' ,
"मनोगत" :'JJ' ,
"मनोरंजक" :'JJ' ,
"मनोरम" :'JJ' ,
"मनोहर" :'JJ' ,
"मन्द" :'JJ' ,
"मरा हुआ" :'JJ' ,
"मलिन" :'JJ' ,
"मशहूर" :'JJ' ,
"मसल" :'JJ' ,
"मसालेदा" :'JJ' ,
"मसालेदार" :'JJ' ,
"मसालों से भरा" :'JJ' ,
"मस्त" :'JJ' ,
"महँगा" :'JJ' ,
"महंगा" :'JJ' ,
"महत" :'JJ' ,
"महत" :'JJ' ,
"महत्त्वपूर्ण" :'JJ' ,
"महत्वपूर्ण" :'JJ' ,
"महत्वपूर्ण" :'JJ' ,
"महत्वहीन" :'JJ' ,
"महत्वाकांक्षी" :'JJ' ,
"महफ़ूज़" :'JJ' ,
"महसूस" :'JJ' ,
"महात्मा" :'JJ' ,
"महान" :'JJ' ,
"महान" :'JJ' ,
"महावीर" :'JJ' ,
"महीन" :'JJ' ,
"मानस" :'JJ' ,
"मानसिक" :'JJ' ,
"मान्य" :'JJ' ,
"मामूली" :'JJ' ,
"मायामय" :'JJ' ,
"मायुस" :'JJ' ,
"मालदार" :'JJ' ,
"मालामाल" :'JJ' ,
"मांसल" :'JJ' ,
"मासूम (n)" :'JJ' ,
"मिचलीग्रस्त" :'JJ' ,
"मितभाषी" :'JJ' ,
"मितव्ययी" :'JJ' ,
"मिथ्या" :'JJ' ,
"मिलावटी" :'JJ' ,
"मीठा" :'JJ' ,
"मीठी" :'JJ' ,
"मुक्तहस्त" :'JJ' ,
"मुखर" :'JJ' ,
"मुदित" :'JJ' ,
"मुफ़लिस" :'JJ' ,
"मुलायम" :'JJ' ,
"मुंहज़ोर" :'JJ' ,
"मुहताज" :'JJ' ,
"मूढ़" :'JJ' ,
"मूर्ख" :'JJ' ,
"मूर्खतापूर्ण" :'JJ' ,
"मूल्यवान" :'JJ' ,
"मृदु" :'JJ' ,
"मेघाच्छन्न" :'JJ' ,
"मेधावी" :'JJ' ,
"मेहरबान" :'JJ' ,
"मैला" :'JJ' ,
"मोटा" :'JJ' ,
"मोटा" :'JJ' ,
"मोटा ताजा" :'JJ' ,
"मोटा-ताज़ा" :'JJ' ,
"मौन रहने वाला" :'JJ' ,
"म्लान" :'JJ' ,
"यथार्थ" :'JJ' ,
"यशस्वी" :'JJ' ,
"युवा" :'JJ' ,
"योग्य" :'JJ' ,
"रक्तमय" :'JJ' ,
"रपटीला" :'JJ' ,
"रफ" :'JJ' ,
"रमणीय" :'JJ' ,
"रमणीय" :'JJ' ,
"रसहीन" :'JJ' ,
"रस्म का" :'JJ' ,
"रहस्यपूर्ण" :'JJ' ,
"रहस्यमय" :'JJ' ,
"राज-भक्त" :'JJ' ,
"रीति अनुसार" :'JJ' ,
"रीतिविरुद्ध" :'JJ' ,
"रुखा" :'JJ' ,
"रुग्ण" :'JJ' ,
"रुचिकर" :'JJ' ,
"रुचिर" :'JJ' ,
"रुष्ट" :'JJ' ,
"रूख" :'JJ' ,
"रूखा" :'JJ' ,
"रूखी" :'JJ' ,
"रूढ़िगत" :'JJ' ,
"रूपात्मक" :'JJ' ,
"रूहानी" :'JJ' ,
"रोगग्रस्त" :'JJ' ,
"रोगी" :'JJ' ,
"रोचक" :'JJ' ,
"रोना" :'JJ' ,
"रोनेवाला" :'JJ' ,
"रोमांचक" :'JJ' ,
"लग-भग" :'JJ' ,
"लग-भग सही" :'JJ' ,
"लघु" :'JJ' ,
"लघुभार" :'JJ' ,
"लचीला" :'JJ' ,
"लजीज़ (n)" :'JJ' ,
"लदा हुआ" :'JJ' ,
"लद्धड़" :'JJ' ,
"लंबा" :'JJ' ,
"लंबे क़द का" :'JJ' ,
"लब्धप्रतिष्ठ" :'JJ' ,
"लम्पट" :'JJ' ,
"लम्बा" :'JJ' ,
"लम्बी" :'JJ' ,
"लवणयुक्त" :'JJ' ,
"लसलसा" :'JJ' ,
"लापरवाह" :'JJ' ,
"लापरवाह" :'JJ' ,
"लाभदायक" :'JJ' ,
"लालची" :'JJ' ,
"लोक संगत" :'JJ' ,
"लोकप्रिय" :'JJ' ,
"लोकप्रिय" :'JJ' ,
"लोकाचारी" :'JJ' ,
"लौकिक" :'JJ' ,
"वफ़ादार" :'JJ' ,
"वयस्क" :'JJ' ,
"वर्गाकार" :'JJ' ,
"वर्तमान" :'JJ' ,
"वाक्संयमी" :'JJ' ,
"वाचाल" :'JJ' ,
"वायु-संबंधी" :'JJ' ,
"वायुमय" :'JJ' ,
"वास्तविक" :'JJ' ,
"विकेन्द्र" :'JJ' ,
"विख्यात" :'JJ' ,
"विचक्षण" :'JJ' ,
"विचित्र" :'JJ' ,
"विदेशी" :'JJ' ,
"विद्युत् से आवेशित" :'JJ' ,
"विद्वान" :'JJ' ,
"विधिवत" :'JJ' ,
"विनम्र" :'JJ' ,
"विनीत" :'JJ' ,
"विनीत किया हुआ" :'JJ' ,
"विनोदी" :'JJ' ,
"विपथगामी" :'JJ' ,
"विपदग्रस्त" :'JJ' ,
"विरक्त" :'JJ' ,
"विरल" :'JJ' ,
"विलक्षण" :'JJ' ,
"विलासी" :'JJ' ,
"विवेकपूर्ण" :'JJ' ,
"विवेकी" :'JJ' ,
"विशाल" :'JJ' ,
"विशिष्ट संख्या" :'JJ' ,
"विशुद्ध" :'JJ' ,
"विश्वसनीय" :'JJ' ,
"विश्वास योग्य" :'JJ' ,
"विश्वासघाती" :'JJ' ,
"विश्वासी" :'JJ' ,
"विषण्ण" :'JJ' ,
"विषम" :'JJ' ,
"विषाद-ग्रस्त" :'JJ' ,
"विषादपूर्ण" :'JJ' ,
"विषादी" :'JJ' ,
"विषैला" :'JJ' ,
"विष्" :'JJ' ,
"विस्तीर्ण" :'JJ' ,
"विस्तृत" :'JJ' ,
"विस्मित" :'JJ' ,
"वीर" :'JJ' ,
"वृत्ताकार" :'JJ' ,
"वृत्ताकार नृत्य" :'JJ' ,
"वृद्ध" :'JJ' ,
"वृष्टि-बहुल" :'JJ' ,
"वृहत्" :'JJ' ,
"व्यंग्यपूर्ण" :'JJ' ,
"व्यथित" :'JJ' ,
"व्यवसायिक" :'JJ' ,
"व्यस्त" :'JJ' ,
"व्याकुल" :'JJ' ,
"व्यापक" :'JJ' ,
"व्यावहारिक" :'JJ' ,
"शक्तिमान" :'JJ' ,
"शक्तिशाली" :'JJ' ,
"शक्तिशाली" :'JJ' ,
"शक्तिहीन" :'JJ' ,
"शराब की छूट देने वाला" :'JJ' ,
"शराब की छूट वाला" :'JJ' ,
"शराबी" :'JJ' ,
"शरारती" :'JJ' ,
"शरीफ़" :'JJ' ,
"शर्त किया हुआ" :'JJ' ,
"शांत" :'JJ' ,
"शांतिपूर्ण" :'JJ' ,
"शांतिप्रिय" :'JJ' ,
"शांतिमय" :'JJ' ,
"शानदार" :'JJ' ,
"शान्त" :'JJ' ,
"शिक्षित" :'JJ' ,
"शिथिल" :'JJ' ,
"शिष्टाचार के अनुकूल" :'JJ' ,
"शीघ्रग्राही" :'JJ' ,
"शीत" :'JJ' ,
"शीतल" :'JJ' ,
"शीतलप्रधान" :'JJ' ,
"शीर्ण" :'JJ' ,
"शुद्ध" :'JJ' ,
"शुभ" :'JJ' ,
"शुष्क" :'JJ' ,
"शूर" :'JJ' ,
"शूरवीर" :'JJ' ,
"शोकमय" :'JJ' ,
"शोकार्त्त" :'JJ' ,
"शोरबा" :'JJ' ,
"शोलाकुल" :'JJ' ,
"श्रद्धालु" :'JJ' ,
"श्रुत" :'JJ' ,
"श्रेष्ठ" :'JJ' ,
"संकटपूर्ण" :'JJ' ,
"सकुशल" :'JJ' ,
"संकोचशील" :'JJ' ,
"सख़्त" :'JJ' ,
"सख़्त" :'JJ' ,
"सघन" :'JJ' ,
"सचेत" :'JJ' ,
"सचेतन" :'JJ' ,
"सच्चरित्र" :'JJ' ,
"सच्चा" :'JJ' ,
"सच्ची" :'JJ' ,
"संजीदा" :'JJ' ,
"संजीदा" :'JJ' ,
"सज्जनतापूर्ण" :'JJ' ,
"सड़ा" :'JJ' ,
"सड़ा हुआ" :'JJ' ,
"सड़ा हुआ" :'JJ' ,
"सड़ा हुआ" :'JJ' ,
"संतप्त" :'JJ' ,
"सतर्क" :'JJ' ,
"संतोषजनक" :'JJ' ,
"संतोषप्रद" :'JJ' ,
"संतोषमय" :'JJ' ,
"सत्यवादी" :'JJ' ,
"संद" :'JJ' ,
"सदय" :'JJ' ,
"सदा" :'JJ' ,
"सदाशय" :'JJ' ,
"संदीप्त" :'JJ' ,
"सदोष" :'JJ' ,
"सनकी" :'JJ' ,
"सन्तापी" :'JJ' ,
"सन्तुष्ट" :'JJ' ,
"संपन्न" :'JJ' ,
"सफल" :'JJ' ,
"सब से छोटा" :'JJ' ,
"सबल" :'JJ' ,
"समझदार" :'JJ' ,
"समतल" :'JJ' ,
"समवेदनापूर्ण" :'JJ' ,
"समीचीन" :'JJ' ,
"समुचित रूप से व्यवस्थित" :'JJ' ,
"समुद्री" :'JJ' ,
"समृद्ध" :'JJ' ,
"सम्पदा से सम्पन्न" :'JJ' ,
"संयत" :'JJ' ,
"सयाना" :'JJ' ,
"सरल" :'JJ' ,
"सराबोर" :'JJ' ,
"सर्द" :'JJ' ,
"सर्वाधुनिक" :'JJ' ,
"सलाम" :'JJ' ,
"सलामत" :'JJ' ,
"संवेदनशील" :'JJ' ,
"संवेदी" :'JJ' ,
"सशक्त" :'JJ' ,
"संसारी" :'JJ' ,
"सस्ता" :'JJ' ,
"सहज" :'JJ' ,
"सहज में पचन योग्य" :'JJ' ,
"सहनीय" :'JJ' ,
"सही" :'JJ' ,
"साधन-संपन्न" :'JJ' ,
"साधारण" :'JJ' ,
"साधु" :'JJ' ,
"सानंद" :'JJ' ,
"साफ़" :'JJ' ,
"साफ" :'JJ' ,
"सामथर्यवान" :'JJ' ,
"सामान्य" :'JJ' ,
"सावधान" :'JJ' ,
"सांसारिक" :'JJ' ,
"साहसी" :'JJ' ,
"सिक्त" :'JJ' ,
"सीधा" :'JJ' ,
"सीधा सादा" :'JJ' ,
"सुकर" :'JJ' ,
"सुकुमार" :'JJ' ,
"सुखकर" :'JJ' ,
"सुखद" :'JJ' ,
"सुखी" :'JJ' ,
"सुगंधित" :'JJ' ,
"सुगम" :'JJ' ,
"सुग्राही" :'JJ' ,
"सुजान" :'JJ' ,
"सुदृढ़" :'JJ' ,
"सुदृढ़" :'JJ' ,
"सुन्दर" :'JJ' ,
"सुन्न" :'JJ' ,
"सुपरिचित ज्ञानी" :'JJ' ,
"सुपाच्य" :'JJ' ,
"सुप्रसिद्ध" :'JJ' ,
"सुबोध" :'JJ' ,
"सुरक्षित" :'JJ' ,
"सुरीला" :'JJ' ,
"सुरीली" :'JJ' ,
"सुलभ" :'JJ' ,
"सुव्यवस्थित" :'JJ' ,
"सुस्त" :'JJ' ,
"सुस्पष्ट" :'JJ' ,
"सुस्वर" :'JJ' ,
"सुस्वाद" :'JJ' ,
"सुस्वादु" :'JJ' ,
"सुहावना" :'JJ' ,
"सूक्ष्म" :'JJ' ,
"सूखा" :'JJ' ,
"सूखा हुआ" :'JJ' ,
"सूखी" :'JJ' ,
"से हटा हुआ" :'JJ' ,
"सैद्धाँतिक" :'JJ' ,
"सौभाग्यशाली" :'JJ' ,
"सौभाग्यशील" :'JJ' ,
"सौम्य" :'JJ' ,
"स्थिर" :'JJ' ,
"स्थूल" :'JJ' ,
"स्थूल" :'JJ' ,
"स्नेहहीन" :'JJ' ,
"स्पष्ट" :'JJ' ,
"स्मॉल" :'JJ' ,
"स्याना" :'JJ' ,
"स्वच्छ" :'JJ' ,
"स्वभाव विरुद्ध" :'JJ' ,
"स्वभाविक" :'JJ' ,
"स्वस्थ" :'JJ' ,
"स्वादिष्ट" :'JJ' ,
"स्वाभाविक" :'JJ' ,
"स्वास्थ्य के लिये हितकर" :'JJ' ,
"स्वीकार के योग्य" :'JJ' ,
"हतभाग्य" :'JJ' ,
"हताश" :'JJ' ,
"हतोत्साह" :'JJ' ,
"हद से अधिक" :'JJ' ,
"हद से ज़्यादा" :'JJ' ,
"हद से ज़्यादा" :'JJ' ,
"हरजाई" :'JJ' ,
"हरा भरा" :'JJ' ,
"हर्षित " :'JJ' ,
"हलका" :'JJ' ,
"हलका फुलका" :'JJ' ,
"हलकी" :'JJ' ,
"हल्का" :'JJ' ,
"हल्की" :'JJ' ,
"हवा सा" :'JJ' ,
"हवाई" :'JJ' ,
"हवादार" :'JJ' ,
"हानिकारक" :'JJ' ,
"हाल का" :'JJ' ,
"हाल में हुआ" :'JJ' ,
"हिचकिचानेवाला" :'JJ' ,
"हितकर" :'JJ' ,
"हिंसक" :'JJ' ,
"हिंसात्मक" :'JJ' ,
"हिंसापूर्ण" :'JJ' ,
"हींसक" :'JJ' ,
"हूबहू" :'JJ' ,
"हृष्ट-पुष्ट" :'JJ' ,
"हैरान" :'JJ' ,
"होशियार" :'JJ',
" अखंड": 'JJ',
" अत्यधिक शीतल": 'JJ',
" अनैश्वर्यदायी": 'JJ',
" अव्यवस्थित": 'JJ',
" इंटरनेट सेवा दाता": 'JJ',
" इन्टरनेट सेवा दाता": 'JJ',
" खुदा हुआ": 'JJ',
" जनहितकारी": 'JJ',
" थोड़ा कड़वा": 'JJ',
" लालिमायुक्त": 'JJ',
" सोपानवत्": 'JJ',
"अउन्नत": 'JJ',
"अऊत": 'JJ',
"अकंटक": 'JJ',
"अकड़बाज": 'JJ',
"अकड़बाज़": 'JJ',
"अकड़ू": 'JJ',
"अकड़ैत": 'JJ',
"अकत": 'JJ',
"अकथ": 'JJ',
"अकथनीय": 'JJ',
"अकथित": 'JJ',
"अकथ्य": 'JJ',
"अंकनीय": 'JJ',
"अकंप": 'JJ',
"अकपट": 'JJ',
"अकंपायमान": 'JJ',
"अकंपित": 'JJ',
"अकबरी": 'JJ',
"अकम्प": 'JJ',
"अकम्पायमान": 'JJ',
"अकम्पित": 'JJ',
"अकर": 'JJ',
"अकरण": 'JJ',
"अकरणीय": 'JJ',
"अकरा": 'JJ',
"अकर्ता": 'JJ',
"अकर्तार": 'JJ',
"अकर्तृ": 'JJ',
"अकर्मक": 'JJ',
"अकर्मठ": 'JJ',
"अकर्मण्य": 'JJ',
"अकर्मा": 'JJ',
"अकर्मी": 'JJ',
"अकलंक": 'JJ',
"अकलंकित": 'JJ',
"अकलंकी": 'JJ',
"अकलमंद": 'JJ',
"अकलमन्द": 'JJ',
"अकलात्मक": 'JJ',
"अकल्पनीय": 'JJ',
"अकल्पित": 'JJ',
"अकल्मष": 'JJ',
"अकल्याण कामी": 'JJ',
"अकल्याणकारक": 'JJ',
"अकल्याणकारी": 'JJ',
"अंकशायी": 'JJ',
"अकसीर": 'JJ',
"अकाज": 'JJ',
"अकाजी": 'JJ',
"अकाट": 'JJ',
"अकाट्य": 'JJ',
"अकादमिक": 'JJ',
"अकाम": 'JJ',
"अकामी": 'JJ',
"अकाय": 'JJ',
"अकारज": 'JJ',
"अकारण": 'JJ',
"अकारत": 'JJ',
"अकारथ": 'JJ',
"अकारांत": 'JJ',
"अकारान्त": 'JJ',
"अकार्बनिक": 'JJ',
"अकार्यसाधक": 'JJ',
"अकाल": 'JJ',
"अकाल प्रसूत": 'JJ',
"अकाल-ग्रस्त": 'JJ',
"अकाल-पीड़ित": 'JJ',
"अकालग्रस्त": 'JJ',
"अकालजात": 'JJ',
"अकालपीड़ित": 'JJ',
"अकालातीत": 'JJ',
"अकालिक": 'JJ',
"अकाली": 'JJ',
"अकाल्पनिक": 'JJ',
"अकिंचन": 'JJ',
"अंकित": 'JJ',
"अकीदतमंद": 'JJ',
"अक़ीदतमंद": 'JJ',
"अकीदतमन्द": 'JJ',
"अक़ीदतमन्द": 'JJ',
"अंकीय": 'JJ',
"अकीर्तिकर": 'JJ',
"अकीर्तिमान्": 'JJ',
"अकुटिल": 'JJ',
"अकुंठ": 'JJ',
"अकुंठित": 'JJ',
"अकुण्ठ": 'JJ',
"अकुण्ठित": 'JJ',
"अँकुराया": 'JJ',
"अंकुराया": 'JJ',
"अंकुरित": 'JJ',
"अकुल": 'JJ',
"अकुली": 'JJ',
"अकुलीन": 'JJ',
"अकुशल": 'JJ',
"अकूट": 'JJ',
"अकूत": 'JJ',
"अकृत": 'JJ',
"अकृतकार्य": 'JJ',
"अकृतज्ञ": 'JJ',
"अकृतार्थ": 'JJ',
"अकृति": 'JJ',
"अकृती": 'JJ',
"अकृत्यकारी": 'JJ',
"अकृत्रिम": 'JJ',
"अकृपण": 'JJ',
"अकृषित": 'JJ',
"अकृष्ट": 'JJ',
"अकेला": 'JJ',
"अंकों वाला": 'JJ',
"अकौटुंबिक": 'JJ',
"अकौटुम्बिक": 'JJ',
"अक्खड़": 'JJ',
"अक्रम": 'JJ',
"अक्रमिक": 'JJ',
"अक्रिय": 'JJ',
"अक्रूर": 'JJ',
"अक्रोधी": 'JJ',
"अक्लमंद": 'JJ',
"अक़्लमंद": 'JJ',
"अक्लमन्द": 'JJ',
"अक्लांत": 'JJ',
"अक्लान्त": 'JJ',
"अक्लिष्ट": 'JJ',
"अक्ली": 'JJ',
"अक़्ली": 'JJ',
"अक्षत": 'JJ',
"अक्षत योनि": 'JJ',
"अक्षतयोनि": 'JJ',
"अक्षता": 'JJ',
"अक्षम": 'JJ',
"अक्षमावान": 'JJ',
"अक्षमाशील": 'JJ',
"अक्षम्य": 'JJ',
"अक्षय": 'JJ',
"अक्षय्य": 'JJ',
"अक्षर": 'JJ',
"अक्षरवाला": 'JJ',
"अक्षरी": 'JJ',
"अक्षरीय": 'JJ',
"अक्षहीन": 'JJ',
"अक्षित": 'JJ',
"अक्षितिज": 'JJ',
"अक्षीय": 'JJ',
"अक्षुण": 'JJ',
"अक्षुण्ण": 'JJ',
"अक्षुण्य": 'JJ',
"अक्षेम": 'JJ',
"अक्सीर": 'JJ',
"अखज": 'JJ',
"अखंड": 'JJ',
"अखंडनीय": 'JJ',
"अखंडित": 'JJ',
"अखंड्य": 'JJ',
"अखण्ड": 'JJ',
"अखण्डनीय": 'JJ',
"अखण्डित": 'JJ',
"अखण्ड्य": 'JJ',
"अखबारी": 'JJ',
"अख़बारी": 'JJ',
"अखय": 'JJ',
"अखरा": 'JJ',
"अखाद्य": 'JJ',
"अखिल": 'JJ',
"अखीन": 'JJ',
"अँखुआया": 'JJ',
"अंखुआया": 'JJ',
"अखूट": 'JJ',
"अखेद": 'JJ',
"अखै": 'JJ',
"अख्यात": 'JJ',
"अग": 'JJ',
"अंग संबंधी": 'JJ',
"अंग-संबंधी": 'JJ',
"अंगच्छेदक": 'JJ',
"अंगछेदक": 'JJ',
"अंगज": 'JJ',
"अंगड़-खंगड़": 'JJ',
"अगड़-बगड़": 'JJ',
"अगड़धत्त": 'JJ',
"अगड़बगड़": 'JJ',
"अगड़म-बगड़म": 'JJ',
"अगड़मबगड़म": 'JJ',
"अगड़ा": 'JJ',
"अगणतंत्रात्मक": 'JJ',
"अगणतंत्री": 'JJ',
"अगणतंत्रीय": 'JJ',
"अगणतन्त्रात्मक": 'JJ',
"अगणतन्त्री": 'JJ',
"अगणतन्त्रीय": 'JJ',
"अगणतांत्रिक": 'JJ',
"अगणतान्त्रिक": 'JJ',
"अगणनीय": 'JJ',
"अगणित": 'JJ',
"अगण्य": 'JJ',
"अगत": 'JJ',
"अगति": 'JJ',
"अगतिक": 'JJ',
"अगत्तर": 'JJ',
"अगद": 'JJ',
"अंगधारी": 'JJ',
"अगनत": 'JJ',
"अगनित": 'JJ',
"अगम": 'JJ',
"अगमनीया": 'JJ',
"अगम्य": 'JJ',
"अगम्या": 'JJ',
"अंगरक्षक": 'JJ',
"अंगरंगी": 'JJ',
"अँगरेजी": 'JJ',
"अंगरेजी": 'JJ',
"अगला": 'JJ',
"अगवा": 'JJ',
"अग़वा": 'JJ',
"अंगसंबंधी": 'JJ',
"अंगसंरक्षी": 'JJ',
"अगहनिया": 'JJ',
"अगहनी": 'JJ',
"अंगहीन": 'JJ',
"अगाऊ": 'JJ',
"अगात्र": 'JJ',
"अगाध": 'JJ',
"अगाध्य": 'JJ',
"अगाह": 'JJ',
"अगिनत": 'JJ',
"अगिनित": 'JJ',
"अंगी": 'JJ',
"अंगीकार्य": 'JJ',
"अंगीकृत": 'JJ',
"अगुआ": 'JJ',
"अगुण": 'JJ',
"अगुणी": 'JJ',
"अगुप्त": 'JJ',
"अगुरु": 'JJ',
"अंगुश्तनुमा": 'JJ',
"अँगूठा छाप": 'JJ',
"अंगूठा छाप": 'JJ',
"अँगूठाछाप": 'JJ',
"अंगूठाछाप": 'JJ',
"अगूढ": 'JJ',
"अगूढ़": 'JJ',
"अंगूरी": 'JJ',
"अगेह": 'JJ',
"अगोचर": 'JJ',
"अगोतिया": 'JJ',
"अगोती": 'JJ',
"अगोत्रज": 'JJ',
"अगोत्री": 'JJ',
"अगोत्रीय": 'JJ',
"अगोपनीय": 'JJ',
"अगोप्य": 'JJ',
"अंगोलन": 'JJ',
"अंगोलाई": 'JJ',
"अग्निवर्धक": 'JJ',
"अग्निशामक": 'JJ',
"अग्यात": 'JJ',
"अग्र": 'JJ',
"अग्रगण्य": 'JJ',
"अग्रगत": 'JJ',
"अग्रगंत": 'JJ',
"अग्रगामी": 'JJ',
"अग्रज": 'JJ',
"अग्रजन्मा": 'JJ',
"अग्रजात": 'JJ',
"अग्रणी": 'JJ',
"अग्रदर्शी": 'JJ',
"अग्रप्रेषित": 'JJ',
"अग्रवर्ती": 'JJ',
"अग्रसर": 'JJ',
"अग्रसारित": 'JJ',
"अग्रसोची": 'JJ',
"अग्रहणीय": 'JJ',
"अग्रहीत": 'JJ',
"अग्रह्य": 'JJ',
"अग्राम्य": 'JJ',
"अग्राह्य": 'JJ',
"अग्रिम": 'JJ',
"अंग्रेजी": 'JJ',
"अंग्रेज़ी": 'JJ',
"अघट": 'JJ',
"अघटनीय": 'JJ',
"अघटित": 'JJ',
"अघट्य": 'JJ',
"अघन": 'JJ',
"अघनाशक": 'JJ',
"अघमय": 'JJ',
"अघाया हुआ": 'JJ',
"अघायु": 'JJ',
"अघारि": 'JJ',
"अघी": 'JJ',
"अघुलनशील": 'JJ',
"अघुलित": 'JJ',
"अघृण": 'JJ',
"अघोष": 'JJ',
"अघोषित": 'JJ',
"अङ्ग सम्बन्धी": 'JJ',
"अङ्ग-सम्बन्धी": 'JJ',
"अङ्गसम्बन्धी": 'JJ',
"अङ्गूरी": 'JJ',
"अचक्षु": 'JJ',
"अचंचल": 'JJ',
"अचंड": 'JJ',
"अचण्ड": 'JJ',
"अचतुर": 'JJ',
"अचपल": 'JJ',
"अचंभित": 'JJ',
"अचम्भित": 'JJ',
"अचयनित": 'JJ',
"अचयित": 'JJ',
"अचर": 'JJ',
"अचल": 'JJ',
"अंचलिक": 'JJ',
"अंचलीय": 'JJ',
"अचाहा": 'JJ',
"अचिकित्सित": 'JJ',
"अचिकित्स्य": 'JJ',
"अचिंत": 'JJ',
"अचिंतनीय": 'JJ',
"अचिंतित": 'JJ',
"अचिंत्य": 'JJ',
"अचित्रित": 'JJ',
"अचिन्त": 'JJ',
"अचिन्तित": 'JJ',
"अचिन्त्य": 'JJ',
"अचिन्हित": 'JJ',
"अचिर": 'JJ',
"अचिह्नित": 'JJ',
"अचीता": 'JJ',
"अचुंबकीय": 'JJ',
"अचुम्बकीय": 'JJ',
"अचुरा": 'JJ',
"अचूक": 'JJ',
"अचेत": 'JJ',
"अचेतन": 'JJ',
"अचेल": 'JJ',
"अचेष्ट": 'JJ',
"अचैतन्य": 'JJ',
"अचैन": 'JJ',
"अचैल": 'JJ',
"अचोट": 'JJ',
"अच्छत": 'JJ',
"अच्छा": 'JJ',
"अच्छा खासा": 'JJ',
"अच्छा पात्र": 'JJ',
"अच्छा-खासा": 'JJ',
"अच्छाखासा": 'JJ',
"अच्युत": 'JJ',
"अछत": 'JJ',
"अछद्म": 'JJ',
"अछिद्र": 'JJ',
"अछिद्रान्वेषक": 'JJ',
"अछिद्रान्वेषी": 'JJ',
"अछिद्रित": 'JJ',
"अछूत": 'JJ',
"अछूता": 'JJ',
"अछेद": 'JJ',
"अछेद्य": 'JJ',
"अछोह": 'JJ',
"अछोही": 'JJ',
"अज": 'JJ',
"अजगर": 'JJ',
"अजगरी": 'JJ',
"अजगैबी": 'JJ',
"अजन": 'JJ',
"अजनतांत्रिक": 'JJ',
"अजनतान्त्रिक": 'JJ',
"अजनबी": 'JJ',
"अंजनरहित": 'JJ',
"अजन्म": 'JJ',
"अजन्मगत": 'JJ',
"अजन्मजात": 'JJ',
"अजन्मा": 'JJ',
"अजपा": 'JJ',
"अजब": 'JJ',
"अजमानतीय": 'JJ',
"अजय": 'JJ',
"अजर": 'JJ',
"अजरबैजानी": 'JJ',
"अज़रबैजानी": 'JJ',
"अजरायल": 'JJ',
"अजराल": 'JJ',
"अजर्जर": 'JJ',
"अजल": 'JJ',
"अंजलिबद्ध": 'JJ',
"अजसी": 'JJ',
"अजस्र": 'JJ',
"अजहद": 'JJ',
"अंजहा": 'JJ',
"अजाचक": 'JJ',
"अजात": 'JJ',
"अजातशत्रु": 'JJ',
"अजाति": 'JJ',
"अजाती": 'JJ',
"अजाद": 'JJ',
"अजान": 'JJ',
"अजाना": 'JJ',
"अजानी": 'JJ',
"अजिज्ञासु": 'JJ',
"अजित": 'JJ',
"अंजित": 'JJ',
"अजितेंद्रिय": 'JJ',
"अजितेन्द्रिय": 'JJ',
"अजीज": 'JJ',
"अज़ीज़": 'JJ',
"अजीत": 'JJ',
"अजीब": 'JJ',
"अजीब ओ गरीब": 'JJ',
"अजीब ओ ग़रीब": 'JJ',
"अजीब-ओ-गरीब": 'JJ',
"अजीब-ओ-ग़रीब": 'JJ',
"अजीब-सा": 'JJ',
"अज़ीब-सा": 'JJ',
"अजीबो गरीब": 'JJ',
"अजीबो ग़रीब": 'JJ',
"अजीबो-गरीब": 'JJ',
"अजीबो-ग़रीब": 'JJ',
"अजीबोगरीब": 'JJ',
"अजीबोग़रीब": 'JJ',
"अजीम": 'JJ',
"अज़ीम": 'JJ',
"अजीर्ण": 'JJ',
"अजीर्णग्रस्त": 'JJ',
"अजीव": 'JJ',
"अजीवित": 'JJ',
"अजुड़ा": 'JJ',
"अजूठा": 'JJ',
"अजूबा": 'JJ',
"अजेय": 'JJ',
"अजैव": 'JJ',
"अजोड़": 'JJ',
"अजोत": 'JJ',
"अँजोरा": 'JJ',
"अंजोरा": 'JJ',
"अज्ञ": 'JJ',
"अज्ञात": 'JJ',
"अज्ञान": 'JJ',
"अज्ञानपूर्ण": 'JJ',
"अज्ञानी": 'JJ',
"अज्ञापित": 'JJ',
"अज्ञेय": 'JJ',
"अज्ञेयवादी": 'JJ',
"अझर": 'JJ',
"अञ्जलिबद्ध": 'JJ',
"अंट शंट": 'JJ',
"अंट संट": 'JJ',
"अंट-शंट": 'JJ',
"अंट-संट": 'JJ',
"अटकलपच्चू": 'JJ',
"अटका": 'JJ',
"अटपट": 'JJ',
"अटपटा": 'JJ',
"अटल": 'JJ',
"अटलनीय": 'JJ',
"अंटशंट": 'JJ',
"अंटसंट": 'JJ',
"अटाटूट": 'JJ',
"अंटार्कटिक": 'JJ',
"अटित": 'JJ',
"अंटीबाज": 'JJ',
"अंटीबाज़": 'JJ',
"अटूट": 'JJ',
"अटेक": 'JJ',
"अटोक": 'JJ',
"अट्ट-सट्ट": 'JJ',
"अट्टसट्ट": 'JJ',
"अट्ठयासी": 'JJ',
"अट्ठयासीवाँ": 'JJ',
"अट्ठाइस": 'JJ',
"अट्ठाइसवाँ": 'JJ',
"अट्ठाईस": 'JJ',
"अट्ठाईसवाँ": 'JJ',
"अट्ठानबे": 'JJ',
"अट्ठानबेवाँ": 'JJ',
"अट्ठानवे": 'JJ',
"अट्ठानवेवाँ": 'JJ',
"अट्ठारह": 'JJ',
"अट्ठारहवाँ": 'JJ',
"अट्ठावन": 'JJ',
"अट्ठावनवाँ": 'JJ',
"अट्ठावनवां": 'JJ',
"अट्ठाविस": 'JJ',
"अट्ठासी": 'JJ',
"अट्ठासीवाँ": 'JJ',
"अठकोना": 'JJ',
"अठगुना": 'JJ',
"अठपहला": 'JJ',
"अठपहलू": 'JJ',
"अठमासा": 'JJ',
"अठवारा": 'JJ',
"अठवाँसा": 'JJ',
"अठहत्तर": 'JJ',
"अठहत्तरवाँ": 'JJ',
"अठाइसवाँ": 'JJ',
"अठाईस": 'JJ',
"अठाईसवाँ": 'JJ',
"अठानबे": 'JJ',
"अंठानबे": 'JJ',
"अठानबेवाँ": 'JJ',
"अंठानबेवाँ": 'JJ',
"अठानवे": 'JJ',
"अंठानवे": 'JJ',
"अठानवेवाँ": 'JJ',
"अंठानवेवाँ": 'JJ',
"अठारह": 'JJ',
"अठारहवाँ": 'JJ',
"अठावन": 'JJ',
"अंठावन": 'JJ',
"अठावनवाँ": 'JJ',
"अठावीस": 'JJ',
"अठासी": 'JJ',
"अठासीवाँ": 'JJ',
"अंड बंड": 'JJ',
"अंड-बंड": 'JJ',
"अंडकोशयुक्त": 'JJ',
"अडग": 'JJ',
"अड़ंगेबाज": 'JJ',
"अड़ंगेबाज़": 'JJ',
"अंडज": 'JJ',
"अड़तालिस": 'JJ',
"अड़तालिसवाँ": 'JJ',
"अड़तालीस": 'JJ',
"अड़तालीसवाँ": 'JJ',
"अड़तीस": 'JJ',
"अड़तीसवाँ": 'JJ',
"अंडबंड": 'JJ',
"अड़बल": 'JJ',
"अंडमानी": 'JJ',
"अड़सठ": 'JJ',
"अड़सठवाँ": 'JJ',
"अंडा जैसा": 'JJ',
"अंडाकार": 'JJ',
"अडिग": 'JJ',
"अड़ियल": 'JJ',
"अडिशनल": 'JJ',
"अडिश्नल": 'JJ',
"अडीठ": 'JJ',
"अड़ुआ": 'JJ',
"अँडुआ": 'JJ',
"अँडैल": 'JJ',
"अंडैल": 'JJ',
"अडोल": 'JJ',
"अढ़ाई": 'JJ',
"अढ़ाई सौ": 'JJ',
"अणु संबंधी": 'JJ',
"अण्ड बण्ड": 'JJ',
"अण्ड-बण्ड": 'JJ',
"अण्डकोशयुक्त": 'JJ',
"अण्डज": 'JJ',
"अण्डबण्ड": 'JJ',
"अण्डमानी": 'JJ',
"अण्डा जैसा": 'JJ',
"अण्डाकार": 'JJ',
"अंतः": 'JJ',
"अतकनीकी": 'JJ',
"अंतकारी": 'JJ',
"अंतःज्ञानी": 'JJ',
"अतत्पर": 'JJ',
"अतनु": 'JJ',
"अंतःपवित्रा": 'JJ',
"अतप्त": 'JJ',
"अंतरंग": 'JJ',
"अतरंगित": 'JJ',
"अंतरंगी": 'JJ',
"अंतरजामी": 'JJ',
"अंतरज्ञ": 'JJ',
"अंतरमहाद्वीपीय": 'JJ',
"अंतरराष्ट्रीय": 'JJ',
"अँतरा": 'JJ',
"अंतरा": 'JJ',
"अंतराभिमुखी": 'JJ',
"अंतरावासी": 'JJ',
"अंतरिक्षसत्": 'JJ',
"अंतरित": 'JJ',
"अंतरिम": 'JJ',
"अंतरीय": 'JJ',
"अतर्क": 'JJ',
"अतर्क्य": 'JJ',
"अँतर्गडु": 'JJ',
"अंतर्गत": 'JJ',
"अंतर्जातीय": 'JJ',
"अंतर्ज्ञानी": 'JJ',
"अंतर्दर्शी": 'JJ',
"अंतर्दृष्टा": 'JJ',
"अंतर्देशीय": 'JJ',
"अंतर्निविष्ट": 'JJ',
"अंतर्निष्ठ": 'JJ',
"अंतर्निहित": 'JJ',
"अतर्पी": 'JJ',
"अंतर्प्रदेश स्तरीय": 'JJ',
"अंतर्प्रदेशीय": 'JJ',
"अंतर्प्रांतीय": 'JJ',
"अंतर्प्रादेशिक": 'JJ',
"अंतर्भावित": 'JJ',
"अंतर्भूत": 'JJ',
"अंतर्भौम": 'JJ',
"अंतर्मनस्क": 'JJ',
"अंतर्मना": 'JJ',
"अंतर्मुख": 'JJ',
"अंतर्मुखी": 'JJ',
"अंतर्यामी": 'JJ',
"अंतर्राज्यिक": 'JJ',
"अंतर्राज्यीय": 'JJ',
"अंतर्राष्ट्रीय": 'JJ',
"अंतर्लीन": 'JJ',
"अंतर्वती": 'JJ',
"अंतर्वत्नी": 'JJ',
"अंतर्वर्ती": 'JJ',
"अंतर्वेदी": 'JJ',
"अंतर्हित": 'JJ',
"अतल": 'JJ',
"अतलसी": 'JJ',
"अतला": 'JJ',
"अतल्लीन": 'JJ',
"अंतःशल्य": 'JJ',
"अंतःसत्वा": 'JJ',
"अंतःसार": 'JJ',
"अंतःसारवान": 'JJ',
"अंतःस्त्रावी": 'JJ',
"अंतस्थ": 'JJ',
"अंतःस्थ": 'JJ',
"अंतस्थिति": 'JJ',
"अंतःस्रावी": 'JJ',
"अंतस्सलिल": 'JJ',
"अंतहीन": 'JJ',
"अंताराष्ट्रीय": 'JJ',
"अतार्किक": 'JJ',
"अंतावसायी": 'JJ',
"अति": 'JJ',
"अति आवश्यक": 'JJ',
"अति आविष्ट": 'JJ',
"अति उत्साहयुक्त": 'JJ',
"अति उत्साहित": 'JJ',
"अति उत्साही": 'JJ',
"अति कटु": 'JJ',
"अति क्रुद्ध": 'JJ',
"अति क्षीणकाय": 'JJ',
"अति गूढ़": 'JJ',
"अति दानी": 'JJ',
"अति निकृष्ट": 'JJ',
"अति बलिष्ठ": 'JJ',
"अति विशद्": 'JJ',
"अति विशाल": 'JJ',
"अति विस्तृत": 'JJ',
"अति श्याम": 'JJ',
"अति सूक्ष्म": 'JJ',
"अति-आधुनिक": 'JJ',
"अति-उत्साहयुक्त": 'JJ',
"अति-उत्साहित": 'JJ',
"अति-उत्साही": 'JJ',
"अति-धोखा-दायक": 'JJ',
"अति-व्ययी": 'JJ',
"अंतिक": 'JJ',
"अतिकाय": 'JJ',
"अतिक्रमक": 'JJ',
"अतिक्रमणकारी": 'JJ',
"अतिक्रमणीय": 'JJ',
"अतिक्रमित": 'JJ',
"अतिक्रांत": 'JJ',
"अतिक्रामक": 'JJ',
"अतिग्रही": 'JJ',
"अतिचारी": 'JJ',
"अतिजीवित": 'JJ',
"अतिजीवी": 'JJ',
"अतिधोखादायक": 'JJ',
"अतिपक्व": 'JJ',
"अतिप्रदुषित": 'JJ',
"अतिभाषी": 'JJ',
"अतिभोजी": 'JJ',
"अंतिम": 'JJ',
"अतिरंजित": 'JJ',
"अतिरिक्त": 'JJ',
"अतिवक्ता": 'JJ',
"अतिव्ययी": 'JJ',
"अतिशय": 'JJ',
"अतिशयोक्त": 'JJ',
"अतिसंवेदनशील": 'JJ',
"अतिसूक्ष्म": 'JJ',
"अतीक्ष्ण": 'JJ',
"अतीत": 'JJ',
"अतीत कालीन": 'JJ',
"अतींद्रिय": 'JJ',
"अतीन्द्रिय": 'JJ',
"अतीव": 'JJ',
"अतीव्र": 'JJ',
"अतुकांत": 'JJ',
"अतुंग": 'JJ',
"अतुंद": 'JJ',
"अतुन्द": 'JJ',
"अतुल": 'JJ',
"अतुलनीय": 'JJ',
"अतुलित": 'JJ',
"अतुल्य": 'JJ',
"अतुष्ट": 'JJ',
"अतृप्त": 'JJ',
"अतृष्ण": 'JJ',
"अंतेवासी": 'JJ',
"अतोल": 'JJ',
"अतौल": 'JJ',
"अंत्य": 'JJ',
"अत्यंत": 'JJ',
"अत्यंत आसक्त": 'JJ',
"अत्यंत मजबूत": 'JJ',
"अत्यधिक": 'JJ',
"अत्यधिक ठंडा": 'JJ',
"अत्यधिक मुलायम": 'JJ',
"अत्यन्त": 'JJ',
"अत्यम्ल": 'JJ',
"अत्यल्प": 'JJ',
"अत्याचारी": 'JJ',
"अत्याधुनिक": 'JJ',
"अत्यावश्यक": 'JJ',
"अत्याहारी": 'JJ',
"अत्युग्र": 'JJ',
"अत्युत्तम": 'JJ',
"अथक": 'JJ',
"अथाह": 'JJ',
"अथिर": 'JJ',
"अदक्ष": 'JJ',
"अदंड": 'JJ',
"अदंडनीय": 'JJ',
"अदंडित": 'JJ',
"अदंड्य": 'JJ',
"अदण्ड": 'JJ',
"अदण्डनीय": 'JJ',
"अदण्डित": 'JJ',
"अदण्ड्य": 'JJ',
"अदंत": 'JJ',
"अदंतुरित": 'JJ',
"अदत्त": 'JJ',
"अदत्ता": 'JJ',
"अदना": 'JJ',
"अदंभी": 'JJ',
"अदम्य": 'JJ',
"अदय": 'JJ',
"अदयालु": 'JJ',
"अंदरूनी": 'JJ',
"अदर्पी": 'JJ',
"अदर्श": 'JJ',
"अदर्शनीय": 'JJ',
"अदल": 'JJ',
"अदली": 'JJ',
"अदशन": 'JJ',
"अदह": 'JJ',
"अदा": 'JJ',
"अदाग": 'JJ',
"अदाग़": 'JJ',
"अदागी": 'JJ',
"अदाग़ी": 'JJ',
"अदाँत": 'JJ',
"अदाता": 'JJ',
"अदानी": 'JJ',
"अदाय": 'JJ',
"अदालती": 'JJ',
"अदावती": 'JJ',
"अदास": 'JJ',
"अदाहक": 'JJ',
"अदाह्य": 'JJ',
"अदिव्य": 'JJ',
"अदिष्ट": 'JJ',
"अदीक्षित": 'JJ',
"अदीठ": 'JJ',
"अदूरदर्शी": 'JJ',
"अदृढ़": 'JJ',
"अदृप्त": 'JJ',
"अदृश्य": 'JJ',
"अदृश्यमान": 'JJ',
"अदृष्ट": 'JJ',
"अदृष्टिगोचर": 'JJ',
"अदेय": 'JJ',
"अदेह": 'JJ',
"अदोष": 'JJ',
"अद्ध": 'JJ',
"अद्भुत": 'JJ',
"अद्यतन": 'JJ',
"अद्रोही": 'JJ',
"अद्वितीय": 'JJ',
"अद्वेषी": 'JJ',
"अद्वैत": 'JJ',
"अद्वैतवादी": 'JJ',
"अद्वैती": 'JJ',
"अध": 'JJ',
"अंध": 'JJ',
"अध-उबला": 'JJ',
"अंध-विश्वासी": 'JJ',
"अधकचरा": 'JJ',
"अधकच्चा": 'JJ',
"अंधकारपूर्ण": 'JJ',
"अंधकारमय": 'JJ',
"अधकुटा": 'JJ',
"अधखुला": 'JJ',
"अधगला": 'JJ',
"अधजला": 'JJ',
"अंधड़": 'JJ',
"अधनंगा": 'JJ',
"अधनाढ्य": 'JJ',
"अधन्य": 'JJ',
"अधपका": 'JJ',
"अधपगला": 'JJ',
"अधपिसा": 'JJ',
"अधबना": 'JJ',
"अधबयसू": 'JJ',
"अधबुध": 'JJ',
"अधबैसू": 'JJ',
"अधम": 'JJ',
"अधमरा": 'JJ',
"अधमाधम": 'JJ',
"अधमुआ": 'JJ',
"अधमुँदा": 'JJ',
"अधर": 'JJ',
"अधरोत्तर": 'JJ',
"अधर्मात्मा": 'JJ',
"अधर्मिष्ट": 'JJ',
"अधर्मिष्ठ": 'JJ',
"अधर्मी": 'JJ',
"अँधला": 'JJ',
"अधलेटा": 'JJ',
"अधवा": 'JJ',
"अंधविश्वासी": 'JJ',
"अधसूखा": 'JJ',
"अधस्तन": 'JJ',
"अंधा": 'JJ',
"अधार्मिक": 'JJ',
"अधावट": 'JJ',
"अधिक": 'JJ',
"अधिक से अधिक": 'JJ',
"अधिकतम": 'JJ',
"अधिकतर": 'JJ',
"अधिकाधिक": 'JJ',
"अधिकार प्राप्त": 'JJ',
"अधिकार रहित": 'JJ',
"अधिकार विषयक": 'JJ',
"अधिकार-रहित": 'JJ',
"अधिकारक": 'JJ',
"अधिकारच्युत": 'JJ',
"अधिकारपूर्ण": 'JJ',
"अधिकारयुक्त": 'JJ',
"अधिकाररहित": 'JJ',
"अधिकारशून्य": 'JJ',
"अधिकारस्थ": 'JJ',
"अधिकारहीन": 'JJ',
"अधिकारिक": 'JJ',
"अधिकारी": 'JJ',
"अधिकार्थी": 'JJ',
"अधिकांश": 'JJ',
"अधिकांशीय": 'JJ',
"अधिकृत": 'JJ',
"अधिक्रांत": 'JJ',
"अधिक्रान्त": 'JJ',
"अधिक्षिप्त": 'JJ',
"अधिगत": 'JJ',
"अधिगुप्त": 'JJ',
"अधिग्रहीत": 'JJ',
"अधिज": 'JJ',
"अधिज्य": 'JJ',
"अधिदैविक": 'JJ',
"अधिप्रमाणित": 'JJ',
"अधिभोगी": 'JJ',
"अधिभौतिक": 'JJ',
"अधिमानित": 'JJ',
"अधिमान्य": 'JJ',
"अँधियार": 'JJ',
"अंधियार": 'JJ',
"अँधियारा": 'JJ',
"अंधियारा": 'JJ',
"अधियुक्त": 'JJ',
"अधिरूढ़": 'JJ',
"अधिरोपित": 'JJ',
"अधिवासित": 'JJ',
"अधिशायित": 'JJ',
"अधिशासी": 'JJ',
"अधिश्रित": 'JJ',
"अधिश्री": 'JJ',
"अधिष्ठापित": 'JJ',
"अधिष्ठित": 'JJ',
"अधिसंख्य": 'JJ',
"अधीत": 'JJ',
"अधीन": 'JJ',
"अधीनस्थ": 'JJ',
"अधीर": 'JJ',
"अधीरज": 'JJ',
"अधीष्ट": 'JJ',
"अधुत": 'JJ',
"अधुनातन": 'JJ',
"अधुर": 'JJ',
"अधुला": 'JJ',
"अधूत": 'JJ',
"अधूरा": 'JJ',
"अधृत": 'JJ',
"अधेड़": 'JJ',
"अँधेरा": 'JJ',
"अंधेरा": 'JJ',
"अँधेरिया": 'JJ',
"अंधेरिया": 'JJ',
"अधैर्य": 'JJ',
"अधैर्यवान": 'JJ',
"अधैर्यवान्": 'JJ',
"अधोगत": 'JJ',
"अधोगामी": 'JJ',
"अधोपतनकारी": 'JJ',
"अधोपतित": 'JJ',
"अधोमुख": 'JJ',
"अधोरक्त": 'JJ',
"अधोलिखित": 'JJ',
"अध्यक्षरहित": 'JJ',
"अध्यक्षीय": 'JJ',
"अध्यधीन": 'JJ',
"अध्ययनपूर्ण": 'JJ',
"अध्ययनशील": 'JJ',
"अध्ययनीय": 'JJ',
"अध्यर्ध": 'JJ',
"अध्यवसायित": 'JJ',
"अध्यवसायी": 'JJ',
"अध्यवसित": 'JJ',
"अध्यस्त": 'JJ',
"अध्यात्मक": 'JJ',
"अध्यात्मज्ञ": 'JJ',
"अध्यात्मज्ञाता": 'JJ',
"अध्यात्मज्ञानी": 'JJ',
"अध्यात्मिक": 'JJ',
"अध्यापनीय": 'JJ',
"अध्यापित": 'JJ',
"अध्यायी": 'JJ',
"अध्यारूढ़": 'JJ',
"अध्यारोपित": 'JJ',
"अध्यावसायी": 'JJ',
"अध्यासित": 'JJ',
"अध्यासीन": 'JJ',
"अध्याहार्य": 'JJ',
"अध्याहृत": 'JJ',
"अध्युष्ट": 'JJ',
"अध्येतव्य": 'JJ',
"अध्येय": 'JJ',
"अध्रियामाण": 'JJ',
"अध्रुव": 'JJ',
"अध्वगामी": 'JJ',
"अन": 'JJ',
"अनउपजाऊ": 'JJ',
"अनकटा": 'JJ',
"अनकना": 'JJ',
"अनकंप": 'JJ',
"अनकम्प": 'JJ',
"अनकहा": 'JJ',
"अनकिया": 'JJ',
"अनक्षर": 'JJ',
"अनख": 'JJ',
"अनखिला": 'JJ',
"अनखी": 'JJ',
"अनखौहा": 'JJ',
"अनंग": 'JJ',
"अनगढ़": 'JJ',
"अनगढ़ा": 'JJ',
"अनगणित": 'JJ',
"अनगन": 'JJ',
"अनगनित": 'JJ',
"अनंगवती": 'JJ',
"अनगा": 'JJ',
"अनगिन": 'JJ',
"अनगिनत": 'JJ',
"अनगिनती": 'JJ',
"अनगिना": 'JJ',
"अनंगी": 'JJ',
"अनगौरी": 'JJ',
"अनग्न": 'JJ',
"अनघ": 'JJ',
"अनघटा": 'JJ',
"अनघढ़": 'JJ',
"अनघैरी": 'JJ',
"अनचाहत": 'JJ',
"अनचाहा": 'JJ',
"अनचित": 'JJ',
"अनचित्ता": 'JJ',
"अनचिन्हा": 'JJ',
"अनचीत": 'JJ',
"अनचीता": 'JJ',
"अनचीन्हा": 'JJ',
"अनच्छ": 'JJ',
"अनछीला": 'JJ',
"अनछुआ": 'JJ',
"अनछेड़ा": 'JJ',
"अनजाँचा": 'JJ',
"अनजान": 'JJ',
"अनजाना": 'JJ',
"अनजुता": 'JJ',
"अनजूठा": 'JJ',
"अनजोखा": 'JJ',
"अनझुका": 'JJ',
"अनठानबे": 'JJ',
"अनठानबेवाँ": 'JJ',
"अनठानवे": 'JJ',
"अनठानवेवाँ": 'JJ',
"अनठावन": 'JJ',
"अनठावनवाँ": 'JJ',
"अनठावनवां": 'JJ',
"अनडीठ": 'JJ',
"अनढँका": 'JJ',
"अनत": 'JJ',
"अनंत": 'JJ',
"अनंत विश्वीय": 'JJ',
"अनंतकालीन": 'JJ',
"अनतपा": 'JJ',
"अनंतपार": 'JJ',
"अनंतर": 'JJ',
"अनंतरित": 'JJ',
"अनंतरूप": 'JJ',
"अनंतर्हित": 'JJ',
"अनंतवीर्य": 'JJ',
"अनंता": 'JJ',
"अनंताभिधेय": 'JJ',
"अनति": 'JJ',
"अनतिक्रमणीय": 'JJ',
"अनतिक्रमित": 'JJ',
"अनंतिम": 'JJ',
"अनतुला": 'JJ',
"अनतोला": 'JJ',
"अनतौला": 'JJ',
"अनंत्य": 'JJ',
"अनथका": 'JJ',
"अनंद": 'JJ',
"अनंदी": 'JJ',
"अनदेखा": 'JJ',
"अनद्यतन": 'JJ',
"अनधिक": 'JJ',
"अनधिकार": 'JJ',
"अनधिकारी": 'JJ',
"अनधिकृत": 'JJ',
"अनधिगत": 'JJ',
"अनधिगम्य": 'JJ',
"अनधीन": 'JJ',
"अनधुला": 'JJ',
"अनध्यक्ष": 'JJ',
"अननुकृत": 'JJ',
"अननुसंधेय": 'JJ',
"अननुसन्धेय": 'JJ',
"अनन्त": 'JJ',
"अनन्तकालिक": 'JJ',
"अनन्तपार": 'JJ',
"अनन्तर": 'JJ',
"अनन्तरित": 'JJ',
"अनन्तरूप": 'JJ',
"अनन्तर्हित": 'JJ',
"अनन्तलोकीय": 'JJ',
"अनन्तवीर्य": 'JJ',
"अनन्ता": 'JJ',
"अनन्ताभिधेय": 'JJ',
"अनन्तिम": 'JJ',
"अनन्त्य": 'JJ',
"अनन्द": 'JJ',
"अनन्दी": 'JJ',
"अनन्नासी": 'JJ',
"अनन्य": 'JJ',
"अनन्य-वृत्ति": 'JJ',
"अनन्यगति": 'JJ',
"अनन्यगतिक": 'JJ',
"अनन्यचित्त": 'JJ',
"अनन्यदृष्टि": 'JJ',
"अनन्यभव": 'JJ',
"अनन्यभाव": 'JJ',
"अनन्यमनस्क": 'JJ',
"अनन्ययोग्य": 'JJ',
"अनन्यवृत्ति": 'JJ',
"अनन्यसाधारण": 'JJ',
"अनन्यहृत": 'JJ',
"अनन्यार्थ": 'JJ',
"अनन्याश्रित": 'JJ',
"अनन्वित": 'JJ',
"अनप": 'JJ',
"अनपका": 'JJ',
"अनपकारी": 'JJ',
"अनपकृत": 'JJ',
"अनपंग": 'JJ',
"अनपढ़": 'JJ',
"अनपढ़ा": 'JJ',
"अनपत्य": 'JJ',
"अनपरखा": 'JJ',
"अनपराध": 'JJ',
"अनपराधी": 'JJ',
"अनपहृत": 'JJ',
"अनपाय": 'JJ',
"अनपायी": 'JJ',
"अनपाश्रय": 'JJ',
"अनपेक्ष": 'JJ',
"अनपेक्षित": 'JJ',
"अनपेक्ष्य": 'JJ',
"अनबदला": 'JJ',
"अनबना": 'JJ',
"अनबिद्ध": 'JJ',
"अनबिधा": 'JJ',
"अनबिंधा": 'JJ',
"अनबीता": 'JJ',
"अनबूझ": 'JJ',
"अनबेधा": 'JJ',
"अनबोध्य": 'JJ',
"अनबोया": 'JJ',
"अनबोल": 'JJ',
"अनबोला": 'JJ',
"अनब्याहा": 'JJ',
"अनब्याही": 'JJ',
"अनंभ": 'JJ',
"अनभला": 'JJ',
"अनभाया": 'JJ',
"अनभिज्ञ": 'JJ',
"अनभिधेय": 'JJ',
"अनभिप्रेत": 'JJ',
"अनभिभूत": 'JJ',
"अनभिमत": 'JJ',
"अनभिमानी": 'JJ',
"अनभिरूप": 'JJ',
"अनभिलषित": 'JJ',
"अनभिलाषी": 'JJ',
"अनभिलासी": 'JJ',
"अनभिविझप्त": 'JJ',
"अनभिव्यक्त": 'JJ',
"अनभिसंधान": 'JJ',
"अनभिसन्धान": 'JJ',
"अनभिसंबंध": 'JJ',
"अनभिसम्बन्ध": 'JJ',
"अनभिहित": 'JJ',
"अनभीष्ट": 'JJ',
"अनभीष्ठ": 'JJ',
"अनभो": 'JJ',
"अनभ्यसित": 'JJ',
"अनभ्यस्त": 'JJ',
"अनभ्यासी": 'JJ',
"अनभ्र": 'JJ',
"अनम": 'JJ',
"अनमद": 'JJ',
"अनमन": 'JJ',
"अनमना": 'JJ',
"अनमनीय": 'JJ',
"अनमापा": 'JJ',
"अनमिख": 'JJ',
"अनमित": 'JJ',
"अनमिल": 'JJ',
"अनमिलत": 'JJ',
"अनमिलता": 'JJ',
"अनमेल": 'JJ',
"अनमोल": 'JJ',
"अनम्भ": 'JJ',
"अनम्य": 'JJ',
"अनम्र": 'JJ',
"अनयन": 'JJ',
"अनयस": 'JJ',
"अनरखा": 'JJ',
"अनरगल": 'JJ',
"अनरसा": 'JJ',
"अनराता": 'JJ',
"अनरिकार्डिड": 'JJ',
"अनरिकार्डेड": 'JJ',
"अनरिकॉर्डिड": 'JJ',
"अनरिकॉर्डेड": 'JJ',
"अनरूप": 'JJ',
"अनर्गल": 'JJ',
"अनर्घ": 'JJ',
"अनर्घ्य": 'JJ',
"अनर्जित": 'JJ',
"अनर्थक": 'JJ',
"अनर्थकारी": 'JJ',
"अनर्थदर्शी": 'JJ',
"अनर्थनाशी": 'JJ',
"अनर्थबुद्धि": 'JJ',
"अनर्ह": 'JJ',
"अनलंकृत": 'JJ',
"अनलमुख": 'JJ',
"अनलस": 'JJ',
"अनलसित": 'JJ',
"अनलायक": 'JJ',
"अनलेखा": 'JJ',
"अनल्प": 'JJ',
"अनवगत": 'JJ',
"अनवगाह": 'JJ',
"अनवगाही": 'JJ',
"अनवगाह्य": 'JJ',
"अनवगीत": 'JJ',
"अनवग्रह": 'JJ',
"अनवच्छिन्न": 'JJ',
"अनवद्य": 'JJ',
"अनवद्यांग": 'JJ',
"अनवधान": 'JJ',
"अनवधि": 'JJ',
"अनवय": 'JJ',
"अनवर": 'JJ',
"अनवरत": 'JJ',
"अनवरुद्ध": 'JJ',
"अनवलंब": 'JJ',
"अनवलंबित": 'JJ',
"अनवलम्ब": 'JJ',
"अनवलम्बित": 'JJ',
"अनवलोकित": 'JJ',
"अनवसान": 'JJ',
"अनवसित": 'JJ',
"अनवस्थ": 'JJ',
"अनवस्थित": 'JJ',
"अनवहित": 'JJ',
"अनवहेलित": 'JJ',
"अनवाप्त": 'JJ',
"अनवाय": 'JJ',
"अनवाँसा": 'JJ',
"अनविद्ध": 'JJ',
"अनंश": 'JJ',
"अनश्रु": 'JJ',
"अनश्व": 'JJ',
"अनश्वर": 'JJ',
"अनष्ट": 'JJ',
"अनसजा": 'JJ',
"अनसठ": 'JJ',
"अनसत्त": 'JJ',
"अनसमझ": 'JJ',
"अनसमझा": 'JJ',
"अनसहत": 'JJ',
"अनसहन": 'JJ',
"अनसिखा": 'JJ',
"अनसीझा": 'JJ',
"अनसुन": 'JJ',
"अनसुना": 'JJ',
"अनसुय": 'JJ',
"अनसुलझा": 'JJ',
"अनसूखा": 'JJ',
"अनसूय": 'JJ',
"अनस्त": 'JJ',
"अनस्तमित": 'JJ',
"अनस्तित्व": 'JJ',
"अनहद": 'JJ',
"अनहित": 'JJ',
"अनहुआ": 'JJ',
"अनहोता": 'JJ',
"अनहोनी": 'JJ',
"अनाकर्षक": 'JJ',
"अनाकार": 'JJ',
"अनाकाश": 'JJ',
"अनाकुल": 'JJ',
"अनाक्रांत": 'JJ',
"अनाक्रान्त": 'JJ',
"अनाखर": 'JJ',
"अनागत": 'JJ',
"अनागम्य": 'JJ',
"अनागाह": 'JJ',
"अनाचारी": 'JJ',
"अनाचित": 'JJ',
"अनाच्छादित": 'JJ',
"अनाजी": 'JJ',
"अनाज्ञा": 'JJ',
"अनाज्ञाकारी": 'JJ',
"अनाड़ी": 'JJ',
"अनाढ्य": 'JJ',
"अनात्म": 'JJ',
"अनात्मक": 'JJ',
"अनात्मज्ञ": 'JJ',
"अनात्मीय": 'JJ',
"अनात्म्य": 'JJ',
"अनाथ": 'JJ',
"अनाथानुसारी": 'JJ',
"अनादरणीय": 'JJ',
"अनादरित": 'JJ',
"अनादि": 'JJ',
"अनादिकालिक": 'JJ',
"अनादिकालीन": 'JJ',
"अनादिष्ट": 'JJ',
"अनादृत": 'JJ',
"अनाधार": 'JJ',
"अनानुवंशिक": 'JJ',
"अनाप शनाप": 'JJ',
"अनापन्न": 'JJ',
"अनापा": 'JJ',
"अनाप्त": 'JJ',
"अनाप्य": 'JJ',
"अनाप्लुत": 'JJ',
"अनाबंटित": 'JJ',
"अनाबिद्ध": 'JJ',
"अनाम": 'JJ',
"अनामक": 'JJ',
"अनामंत्रित": 'JJ',
"अनामन्त्रित": 'JJ',
"अनामय": 'JJ',
"अनामिष": 'JJ',
"अनामी": 'JJ',
"अनामीज़": 'JJ',
"अनामीस": 'JJ',
"अनायक": 'JJ',
"अनायत": 'JJ',
"अनायत्त": 'JJ',
"अनायुध": 'JJ',
"अनारक्षित": 'JJ',
"अनारी": 'JJ',
"अनारोग्य": 'JJ',
"अनार्जव": 'JJ',
"अनार्तव": 'JJ',
"अनार्तवा": 'JJ',
"अनार्द्र": 'JJ',
"अनार्य जातीय": 'JJ',
"अनार्ष": 'JJ',
"अनालाप": 'JJ',
"अनालोचित": 'JJ',
"अनावर्ती": 'JJ',
"अनावश्यक": 'JJ',
"अनावासिक": 'JJ',
"अनाविद्ध": 'JJ',
"अनाविल": 'JJ',
"अनावृत": 'JJ',
"अनावृत्त": 'JJ',
"अनावेदक": 'JJ',
"अनावेष्टित": 'JJ',
"अनाश": 'JJ',
"अनाशंकित": 'JJ',
"अनाशवान": 'JJ',
"अनाशी": 'JJ',
"अनाशु": 'JJ',
"अनाश्य": 'JJ',
"अनाश्रमी": 'JJ',
"अनाश्रित": 'JJ',
"अनासक्त": 'JJ',
"अनासिक": 'JJ',
"अनास्वाद": 'JJ',
"अनास्वादित": 'JJ',
"अनाह": 'JJ',
"अनाहत": 'JJ',
"अनाहार": 'JJ',
"अनाहारी": 'JJ',
"अनाहार्य": 'JJ',
"अनाहिताग्नि": 'JJ',
"अनाहूत": 'JJ',
"अनाह्लादित": 'JJ',
"अनिकेत": 'JJ',
"अनिगीर्ण": 'JJ',
"अनिच्छ": 'JJ',
"अनिच्छित": 'JJ',
"अनिच्छु": 'JJ',
"अनिच्छुक": 'JJ',
"अनित": 'JJ',
"अनित्य": 'JJ',
"अनिंद": 'JJ',
"अनिंदनीय": 'JJ',
"अनिंदित": 'JJ',
"अनिंद्य": 'JJ',
"अनिद्र": 'JJ',
"अनिद्रित": 'JJ',
"अनिधिक": 'JJ',
"अनिन्द": 'JJ',
"अनिन्दनीय": 'JJ',
"अनिन्दित": 'JJ',
"अनिन्द्य": 'JJ',
"अनिपुण": 'JJ',
"अनिबद्ध": 'JJ',
"अनिभृत": 'JJ',
"अनिभ्य": 'JJ',
"अनिमग्न": 'JJ',
"अनिमंत्रित": 'JJ',
"अनिमन्त्रित": 'JJ',
"अनिमिख": 'JJ',
"अनिमित्त": 'JJ',
"अनिमित्तक": 'JJ',
"अनिमिष": 'JJ',
"अनिमेष": 'JJ',
"अनियत": 'JJ',
"अनियतात्मा": 'JJ',
"अनियंत्रित": 'JJ',
"अनियन्त्रित": 'JJ',
"अनियमबद्ध": 'JJ',
"अनियमित": 'JJ',
"अनियारा": 'JJ',
"अनियारी": 'JJ',
"अनियुक्त": 'JJ',
"अनियोगी": 'JJ',
"अनियोजित": 'JJ',
"अनिरुद्ध": 'JJ',
"अनिरूपित": 'JJ',
"अनिर्जित": 'JJ',
"अनिर्णित": 'JJ',
"अनिर्णीत": 'JJ',
"अनिर्दशा": 'JJ',
"अनिर्दिष्ट": 'JJ',
"अनिर्धारित": 'JJ',
"अनिर्धार्य": 'JJ',
"अनिर्बंध": 'JJ',
"अनिर्बन्ध": 'JJ',
"अनिर्मल": 'JJ',
"अनिर्मित": 'JJ',
"अनिर्वचनीय": 'JJ',
"अनिर्वाच्य": 'JJ',
"अनिर्वाह्य": 'JJ',
"अनिर्वृत्त": 'JJ',
"अनिलाशी": 'JJ',
"अनिवर्ती": 'JJ',
"अनिवारित": 'JJ',
"अनिवार्य": 'JJ',
"अनिवासित": 'JJ',
"अनिवेदित": 'JJ',
"अनिश्चयात्मक": 'JJ',
"अनिश्चित": 'JJ',
"अनिश्चितकालीन": 'JJ',
"अनिषिद्ध": 'JJ',
"अनिष्ट": 'JJ',
"अनिष्टकर": 'JJ',
"अनिष्टकरी": 'JJ',
"अनिष्टकारक": 'JJ',
"अनिष्टकारी": 'JJ',
"अनिष्टसूचक": 'JJ',
"अनिष्ठ": 'JJ',
"अनिष्पन्न": 'JJ',
"अनिष्पादित": 'JJ',
"अनीक": 'JJ',
"अनीच": 'JJ',
"अनीठ": 'JJ',
"अनीतिज्ञ": 'JJ',
"अनीतिपूर्ण": 'JJ',
"अनीतिमान्": 'JJ',
"अनीप्सित": 'JJ',
"अनीमिक": 'JJ',
"अनीमियाजन्य": 'JJ',
"अनीश": 'JJ',
"अनीश्वर": 'JJ',
"अनीश्वरवादी": 'JJ',
"अनीस": 'JJ',
"अनीह": 'JJ',
"अनुक": 'JJ',
"अनुकंपक": 'JJ',
"अनुकंपित": 'JJ',
"अनुकम्पक": 'JJ',
"अनुकम्पित": 'JJ',
"अनुकरणकर्ता": 'JJ',
"अनुकरणकर्त्ता": 'JJ',
"अनुकरणीय": 'JJ',
"अनुकर्ता": 'JJ',
"अनुकर्त्ता": 'JJ',
"अनुकल्पित": 'JJ',
"अनुकांक्षित": 'JJ',
"अनुकांक्षी": 'JJ',
"अनुकारी": 'JJ',
"अनुकूल": 'JJ',
"अनुकूलित": 'JJ',
"अनुकृत": 'JJ',
"अनुक्त": 'JJ',
"अनुक्रमिक": 'JJ',
"अनुग": 'JJ',
"अनुगणित": 'JJ',
"अनुगत": 'JJ',
"अनुगतार्थ": 'JJ',
"अनुगांग": 'JJ',
"अनुगामी": 'JJ',
"अनुगुण": 'JJ',
"अनुगुप्त": 'JJ',
"अनुगृहीत": 'JJ',
"अनुग्रहपात्र": 'JJ',
"अनुग्राहक": 'JJ',
"अनुग्राही": 'JJ',
"अनुचित": 'JJ',
"अनुचिंतित": 'JJ',
"अनुचिन्तित": 'JJ',
"अनुच्च": 'JJ',
"अनुच्छिन्न": 'JJ',
"अनुच्छिष्ट": 'JJ',
"अनुज": 'JJ',
"अनुजन्मा": 'JJ',
"अनुजात": 'JJ',
"अनुजीवी": 'JJ',
"अनुज्ञप्त": 'JJ',
"अनुज्ञात": 'JJ',
"अनुज्ञात्मक": 'JJ',
"अनुज्ञापित": 'JJ',
"अनुतपत": 'JJ',
"अनुतप्त": 'JJ',
"अनुतापी": 'JJ',
"अनुत्क्रमित": 'JJ',
"अनुत्तम": 'JJ',
"अनुत्तर": 'JJ',
"अनुत्तरदायी": 'JJ',
"अनुत्तरित": 'JJ',
"अनुत्तान": 'JJ',
"अनुत्तीर्ण": 'JJ',
"अनुत्पन्न": 'JJ',
"अनुत्पादक": 'JJ',
"अनुत्पादित": 'JJ',
"अनुत्मक": 'JJ',
"अनुत्साहित": 'JJ',
"अनुत्साही": 'JJ',
"अनुत्सुक": 'JJ',
"अनुदक": 'JJ',
"अनुदनीय": 'JJ',
"अनुदर": 'JJ',
"अनुदात्त": 'JJ',
"अनुदार": 'JJ',
"अनुदित": 'JJ',
"अनुदैर्ध्य": 'JJ',
"अनुद्धत": 'JJ',
"अनुद्धृत": 'JJ',
"अनुद्भूत": 'JJ',
"अनुद्यत": 'JJ',
"अनुद्यमशील": 'JJ',
"अनुद्यमी": 'JJ',
"अनुद्योगी": 'JJ',
"अनुद्विग्न": 'JJ',
"अनुनादित": 'JJ',
"अनुनादी": 'JJ',
"अनुनासिक": 'JJ',
"अनुनीत": 'JJ',
"अनुन्नत": 'JJ',
"अनुन्नत्त": 'JJ',
"अनुपकारी": 'JJ',
"अनुपचारित": 'JJ',
"अनुपतित": 'JJ',
"अनुपथ": 'JJ',
"अनुपदिष्ट": 'JJ',
"अनुपपन्न": 'JJ',
"अनुपभुक्त": 'JJ',
"अनुपम": 'JJ',
"अनुपमा": 'JJ',
"अनुपमित": 'JJ',
"अनुपमेय": 'JJ',
"अनुपयुक्त": 'JJ',
"अनुपयोगी": 'JJ',
"अनुपलक्षित": 'JJ',
"अनुपलब्ध": 'JJ',
"अनुपशांत": 'JJ',
"अनुपस्थित": 'JJ',
"अनुपहत": 'JJ',
"अनुपातकी": 'JJ',
"अनुपाती": 'JJ',
"अनुपाय": 'JJ',
"अनुपूरक": 'JJ',
"अनुपूर्व": 'JJ',
"अनुपेक्षित": 'JJ',
"अनुप्रपन्न": 'JJ',
"अनुप्रस्थ": 'JJ',
"अनुप्राप्त": 'JJ',
"अनुबद्ध": 'JJ',
"अनुबंधक": 'JJ',
"अनुबंधकर्ता": 'JJ',
"अनुबंधकर्त्ता": 'JJ',
"अनुबंधित": 'JJ',
"अनुबन्धक": 'JJ',
"अनुबन्धकर्ता": 'JJ',
"अनुबन्धकर्त्ता": 'JJ',
"अनुभक्त": 'JJ',
"अनुभवजन्य": 'JJ',
"अनुभवरहित": 'JJ',
"अनुभवसिद्ध": 'JJ',
"अनुभवहीन": 'JJ',
"अनुभवी": 'JJ',
"अनुभावक": 'JJ',
"अनुभावी": 'JJ',
"अनुभूत": 'JJ',
"अनुभूति प्रवण": 'JJ',
"अनुमत": 'JJ',
"अनुमति अदत्त": 'JJ',
"अनुमति अप्राप्त": 'JJ',
"अनुमति प्राप्त": 'JJ',
"अनुमतिप्राप्त": 'JJ',
"अनुमानपत्रीय": 'JJ',
"अनुमानसिद्ध": 'JJ',
"अनुमानातीत": 'JJ',
"अनुमानित": 'JJ',
"अनुमित": 'JJ',
"अनुमेय": 'JJ',
"अनुमोदक": 'JJ',
"अनुमोदित": 'JJ',
"अनुयायी": 'JJ',
"अनुयुक्त": 'JJ',
"अनुयोगी": 'JJ',
"अनुयोजित": 'JJ',
"अनुयोज्य": 'JJ',
"अनुरक्त": 'JJ',
"अनुरंजक": 'JJ',
"अनुरंजित": 'JJ',
"अनुरञ्जित": 'JJ',
"अनुरत": 'JJ',
"अनुरागयुक्त": 'JJ',
"अनुरागी": 'JJ',
"अनुरुद्ध": 'JJ',
"अनुरूप": 'JJ',
"अनुरूपी": 'JJ',
"अनुरोधक": 'JJ',
"अनुरोधी": 'JJ',
"अनुर्वर": 'JJ',
"अनुलग्न": 'JJ',
"अनुलंबित": 'JJ',
"अनुलम्बित": 'JJ',
"अनुलिप्त": 'JJ',
"अनुलोमज": 'JJ',
"अनुवक्र": 'JJ',
"अनुवर्ती": 'JJ',
"अनुवसित": 'JJ',
"अनुवाचित": 'JJ',
"अनुवादक": 'JJ',
"अनुवादनीय": 'JJ',
"अनुवादित": 'JJ',
"अनुवादी": 'JJ',
"अनुवाद्य": 'JJ',
"अनुवांशिक": 'JJ',
"अनुवासित": 'JJ',
"अनुविद्ध": 'JJ',
"अनुविष्ट": 'JJ',
"अनुवृत्त": 'JJ',
"अनुवृत्तिक": 'JJ',
"अनुवृत्तिका": 'JJ',
"अनुशयी": 'JJ',
"अनुशंसित": 'JJ',
"अनुशायी": 'JJ',
"अनुशासनहीन": 'JJ',
"अनुशासनात्मक": 'JJ',
"अनुशासनिक": 'JJ',
"अनुशासनीय": 'JJ',
"अनुशासित": 'JJ',
"अनुशासी": 'JJ',
"अनुशीलनीय": 'JJ',
"अनुशीलित": 'JJ',
"अनुशोचत": 'JJ',
"अनुषक्त": 'JJ',
"अनुषंगिक": 'JJ',
"अनुषंगी": 'JJ',
"अनुष्ठान कर्ता": 'JJ',
"अनुष्ठान कर्त्ता": 'JJ',
"अनुष्ण": 'JJ',
"अनुसंधान कर्ता": 'JJ',
"अनुसंधान कर्त्ता": 'JJ',
"अनुसंधानकर्ता": 'JJ',
"अनुसंधानकर्त्ता": 'JJ',
"अनुसंधानिक": 'JJ',
"अनुसंधानित": 'JJ',
"अनुसंधानी": 'JJ',
"अनुसंधेय": 'JJ',
"अनुसन्धान कर्ता": 'JJ',
"अनुसन्धान कर्त्ता": 'JJ',
"अनुसन्धानकर्ता": 'JJ',
"अनुसन्धानकर्त्ता": 'JJ',
"अनुसन्धानिक": 'JJ',
"अनुसन्धानित": 'JJ',
"अनुसन्धानी": 'JJ',
"अनुसन्धेय": 'JJ',
"अनुसंबद्ध": 'JJ',
"अनुसम्बद्ध": 'JJ',
"अनुसर": 'JJ',
"अनुसंरक्त": 'JJ',
"अनुसरित": 'JJ',
"अनुसार": 'JJ',
"अनुसूचित": 'JJ',
"अनुसूचीबद्ध": 'JJ',
"अनुसृत": 'JJ',
"अनुसेवी": 'JJ',
"अनुस्यूत": 'JJ',
"अनुहरत": 'JJ',
"अनुहरिया": 'JJ',
"अनुहार": 'JJ',
"अनुहारक": 'JJ',
"अनुहारि": 'JJ',
"अनुहारी": 'JJ',
"अनूक्त": 'JJ',
"अनूचान": 'JJ',
"अनूजरा": 'JJ',
"अनूठा": 'JJ',
"अनूढ़": 'JJ',
"अनूतर": 'JJ',
"अनूदित": 'JJ',
"अनून": 'JJ',
"अनूना": 'JJ',
"अनूप": 'JJ',
"अनूरु": 'JJ',
"अनूर्ध्व": 'JJ',
"अनूह": 'JJ',
"अनृण": 'JJ',
"अनृणी": 'JJ',
"अनृत": 'JJ',
"अनृतभाषी": 'JJ',
"अनृशंस": 'JJ',
"अनेक": 'JJ',
"अनेक तरह के": 'JJ',
"अनेक प्रकार का": 'JJ',
"अनेक प्रकार के": 'JJ',
"अनेकज": 'JJ',
"अनेकविध": 'JJ',
"अनेकाक्षर": 'JJ',
"अनेकाच": 'JJ',
"अनेकांत": 'JJ',
"अनेकानेक": 'JJ',
"अनेकान्त": 'JJ',
"अनेकार्थ": 'JJ',
"अनेकार्थक": 'JJ',
"अनेकार्थी": 'JJ',
"अनेकाल": 'JJ',
"अनेग": 'JJ',
"अनेरा": 'JJ',
"अनैच्छिक": 'JJ',
"अनैतिक": 'JJ',
"अनैतिहासिक": 'JJ',
"अनैपुण": 'JJ',
"अनैयायिक": 'JJ',
"अनैश्वर्यदायक": 'JJ',
"अनैश्वर्यप्रद": 'JJ',
"अनैश्वर्यप्रदायक": 'JJ',
"अनैश्वर्यप्रदायी": 'JJ',
"अनैसर्गिक": 'JJ',
"अनैसा": 'JJ',
"अनैसो": 'JJ',
"अनोखा": 'JJ',
"अनौपचारिक": 'JJ',
"अन्टार्कटिक": 'JJ',
"अन्ठानबे": 'JJ',
"अन्ठानबेवाँ": 'JJ',
"अन्ठानवे": 'JJ',
"अन्ठानवेवाँ": 'JJ',
"अन्ठावन": 'JJ',
"अन्तः": 'JJ',
"अन्तःपवित्रा": 'JJ',
"अन्तःप्रविष्ट": 'JJ',
"अन्तरंग": 'JJ',
"अन्तरजामी": 'JJ',
"अन्तरज्ञ": 'JJ',
"अन्तरराष्ट्रीय": 'JJ',
"अन्तरा": 'JJ',
"अन्तराभिमुखी": 'JJ',
"अन्तरावासी": 'JJ',
"अन्तरिक्षसत्": 'JJ',
"अन्तरित": 'JJ',
"अन्तरिम": 'JJ',
"अन्तरीय": 'JJ',
"अन्तर्गत": 'JJ',
"अन्तर्जातीय": 'JJ',
"अन्तर्देशीय": 'JJ',
"अन्तर्निविष्ट": 'JJ',
"अन्तर्निष्ठ": 'JJ',
"अन्तर्निहित": 'JJ',
"अन्तर्प्रदेश स्तरीय": 'JJ',
"अन्तर्प्रदेशीय": 'JJ',
"अन्तर्प्रांतीय": 'JJ',
"अन्तर्प्रादेशिक": 'JJ',
"अन्तर्भावित": 'JJ',
"अन्तर्भूत": 'JJ',
"अन्तर्भौम": 'JJ',
"अन्तर्मनस्क": 'JJ',
"अन्तर्मना": 'JJ',
"अन्तर्मुख": 'JJ',
"अन्तर्मुखी": 'JJ',
"अन्तर्यामी": 'JJ',
"अन्तर्राज्यिक": 'JJ',
"अन्तर्राज्यीय": 'JJ',
"अन्तर्राष्ट्रीय": 'JJ',
"अन्तर्लीन": 'JJ',
"अन्तर्वती": 'JJ',
"अन्तर्वत्नी": 'JJ',
"अन्तर्वर्ती": 'JJ',
"अन्तर्वेदी": 'JJ',
"अन्तर्हित": 'JJ',
"अन्तःशल्य": 'JJ',
"अन्तःसत्वा": 'JJ',
"अन्तःसार": 'JJ',
"अन्तःसारवान": 'JJ',
"अन्तस्थ": 'JJ',
"अन्तःस्थ": 'JJ',
"अन्तस्थिति": 'JJ',
"अन्तस्सलिल": 'JJ',
"अन्तहीन": 'JJ',
"अन्ताराष्ट्रीय": 'JJ',
"अन्तावसायी": 'JJ',
"अन्तिक": 'JJ',
"अन्तिम": 'JJ',
"अन्तेवासी": 'JJ',
"अन्त्य": 'JJ',
"अन्दरूनी": 'JJ',
"अन्ध": 'JJ',
"अन्ध-विश्वासी": 'JJ',
"अन्धकारपूर्ण": 'JJ',
"अन्धकारमय": 'JJ',
"अन्धड़": 'JJ',
"अन्धविश्वासी": 'JJ',
"अन्धा": 'JJ',
"अन्धियारा": 'JJ',
"अन्धेरा": 'JJ',
"अन्न": 'JJ',
"अन्नज": 'JJ',
"अन्नजात": 'JJ',
"अन्नमय": 'JJ',
"अन्नाद": 'JJ',
"अन्नार्थी": 'JJ',
"अन्नाहरी": 'JJ',
"अन्नाहारी": 'JJ',
"अन्नीय": 'JJ',
"अन्य": 'JJ',
"अन्य का": 'JJ',
"अन्य-गोत्र": 'JJ',
"अन्यग": 'JJ',
"अन्यगामी": 'JJ',
"अन्यगोत्र": 'JJ',
"अन्यचित": 'JJ',
"अन्यजात": 'JJ',
"अन्यतम": 'JJ',
"अन्यथा": 'JJ',
"अन्यदीय": 'JJ',
"अन्यदेशीय": 'JJ',
"अन्यपर": 'JJ',
"अन्यपुष्ट": 'JJ',
"अन्यभृत": 'JJ',
"अन्यमन": 'JJ',
"अन्यमनस्क": 'JJ',
"अन्यराष्ट्रीय": 'JJ',
"अन्यवर्ण": 'JJ',
"अन्यवादी": 'JJ',
"अन्यव्रत": 'JJ',
"अन्याधीन": 'JJ',
"अन्याय कर्ता": 'JJ',
"अन्याय विषयक": 'JJ',
"अन्यायपूर्ण": 'JJ',
"अन्यायी": 'JJ',
"अन्यासक्त": 'JJ',
"अन्यून": 'JJ',
"अन्येद्युक": 'JJ',
"अन्योत्सुक": 'JJ',
"अन्वक्ष": 'JJ',
"अन्वयी": 'JJ',
"अन्वर्थ": 'JJ',
"अन्वारूढ़": 'JJ',
"अन्वासीन": 'JJ',
"अन्वाहित": 'JJ',
"अन्वित": 'JJ',
"अन्वेषक": 'JJ',
"अन्वेषित": 'JJ',
"अपकरुण": 'JJ',
"अपकर्मी": 'JJ',
"अपकर्षक": 'JJ',
"अपकाजी": 'JJ',
"अपकारक": 'JJ',
"अपकाररहित": 'JJ',
"अपकारविहीन": 'JJ',
"अपकारी": 'JJ',
"अपकारीचार": 'JJ',
"अपंकिल": 'JJ',
"अपकीर्तिकर": 'JJ',
"अपकृत्": 'JJ',
"अपकृष्ट": 'JJ',
"अपक्रमी": 'JJ',
"अपक्व": 'JJ',
"अपक्ष": 'JJ',
"अपक्षपाती": 'JJ',
"अपक्षिप्त": 'JJ',
"अपंग": 'JJ',
"अपगत": 'JJ',
"अपगुणी": 'JJ',
"अपघन": 'JJ',
"अपघातक": 'JJ',
"अपघाती": 'JJ',
"अपचायित": 'JJ',
"अपचारी": 'JJ',
"अपचित": 'JJ',
"अपचेष्टित": 'JJ',
"अपच्छी": 'JJ',
"अपटु": 'JJ',
"अपट्ठमान": 'JJ',
"अपठ": 'JJ',
"अपठनीय": 'JJ',
"अपठ्य": 'JJ',
"अपंडित": 'JJ',
"अपढ़": 'JJ',
"अपण्य": 'JJ',
"अपत": 'JJ',
"अपतट": 'JJ',
"अपतटीय": 'JJ',
"अपति": 'JJ',
"अपतित": 'JJ',
"अपत्र": 'JJ',
"अपत्रय": 'JJ',
"अपत्रस्त": 'JJ',
"अपथ्य": 'JJ',
"अपद": 'JJ',
"अपदस्थ": 'JJ',
"अपदांतर": 'JJ',
"अपदान्तर": 'JJ',
"अपदार्थ": 'JJ',
"अपदिष्ट": 'JJ',
"अपदेखा": 'JJ',
"अपदोष": 'JJ',
"अपध्वंसी": 'JJ',
"अपध्वस्त": 'JJ',
"अपनत्वपूर्ण": 'JJ',
"अपना": 'JJ',
"अपनाया": 'JJ',
"अपनाया हुआ": 'JJ',
"अपनिद्र": 'JJ',
"अपनीत": 'JJ',
"अपप्रवृत्ति": 'JJ',
"अपभय": 'JJ',
"अपभीति": 'JJ',
"अपभ्रंश": 'JJ',
"अपभ्रंशित": 'JJ',
"अपभ्रष्ट": 'JJ',
"अपमान कर्ता": 'JJ',
"अपमान कर्त्ता": 'JJ',
"अपमानकर्ता": 'JJ',
"अपमानकर्त्ता": 'JJ',
"अपमानजनक": 'JJ',
"अपमानित": 'JJ',
"अपमानी": 'JJ',
"अपमान्य": 'JJ',
"अपमारगी": 'JJ',
"अपमार्गी": 'JJ',
"अपमिश्रित": 'JJ',
"अपमुख": 'JJ',
"अपयशस्क": 'JJ',
"अपयोगी": 'JJ',
"अपर": 'JJ',
"अपरछन": 'JJ',
"अपरतंत्र": 'JJ',
"अपरता": 'JJ',
"अपरंपरागत": 'JJ',
"अपरंपार": 'JJ',
"अपरबल": 'JJ',
"अपरम्परागत": 'JJ',
"अपरम्पार": 'JJ',
"अपरवश": 'JJ',
"अपरस": 'JJ',
"अपराजित": 'JJ',
"अपराजेय": 'JJ',
"अपराध कर्ता": 'JJ',
"अपराध-कर्ता": 'JJ',
"अपराधक": 'JJ',
"अपराधकर्ता": 'JJ',
"अपराधशील": 'JJ',
"अपराधहीन": 'JJ',
"अपराधी": 'JJ',
"अपरामृष्ट": 'JJ',
"अपरावर्ती": 'JJ',
"अपरास्त": 'JJ',
"अपरिकल्पित": 'JJ',
"अपरिक्लिन्न": 'JJ',
"अपरिगण्य": 'JJ',
"अपरिगत": 'JJ',
"अपरिगृहीत": 'JJ',
"अपरिचित": 'JJ',
"अपरिच्छन्न": 'JJ',
"अपरिच्छिन्न": 'JJ',
"अपरिणत": 'JJ',
"अपरिणामी": 'JJ',
"अपरिणीत": 'JJ',
"अपरिणीता": 'JJ',
"अपरिधान": 'JJ',
"अपरिपक्व": 'JJ',
"अपरिपूर्ण": 'JJ',
"अपरिमापित": 'JJ',
"अपरिमित": 'JJ',
"अपरिमित भोजी": 'JJ',
"अपरिवर्तनशील": 'JJ',
"अपरिवर्तनीय": 'JJ',
"अपरिवर्तित": 'JJ',
"अपरिवारीय": 'JJ',
"अपरिशोधित": 'JJ',
"अपरिश्रमी": 'JJ',
"अपरिष्कृत": 'JJ',
"अपरिहार्य": 'JJ',
"अपरीक्षित": 'JJ',
"अपरुष": 'JJ',
"अपरूप": 'JJ',
"अपरोक्ष": 'JJ',
"अपर्णी": 'JJ',
"अपर्याप्त": 'JJ',
"अपलायनशील": 'JJ',
"अपवचनी": 'JJ',
"अपवर्जित": 'JJ',
"अपवर्तित": 'JJ',
"अपवश": 'JJ',
"अपवादक": 'JJ',
"अपवादजनक": 'JJ',
"अपवादिक": 'JJ',
"अपवादित": 'JJ',
"अपवादी": 'JJ',
"अपवारित": 'JJ',
"अपवाहक": 'JJ',
"अपवाहित": 'JJ',
"अपविघ्न": 'JJ',
"अपवित्र": 'JJ',
"अपविद्ध": 'JJ',
"अपविष": 'JJ',
"अपव्ययी": 'JJ',
"अपशंक": 'JJ',
"अपशिष्ट": 'JJ',
"अपसरक": 'JJ',
"अपसर्पित": 'JJ',
"अपसव्य": 'JJ',
"अपसादी": 'JJ',
"अपसामान्य": 'JJ',
"अपसृत": 'JJ',
"अपस्मारी": 'JJ',
"अपस्वार्थी": 'JJ',
"अपह": 'JJ',
"अपहत": 'JJ',
"अपहतपाप्मा": 'JJ',
"अपहरणीय": 'JJ',
"अपहार": 'JJ',
"अपहारित": 'JJ',
"अपहार्य": 'JJ',
"अपहास्य": 'JJ',
"अपहृत": 'JJ',
"अपह्नुवान": 'JJ',
"अपाकृत": 'JJ',
"अपांग": 'JJ',
"अपाटव": 'JJ',
"अपाठ्य": 'JJ',
"अपाढ़": 'JJ',
"अपात्र": 'JJ',
"अपात्रदायी": 'JJ',
"अपाद": 'JJ',
"अपान": 'JJ',
"अपाप": 'JJ',
"अपाय": 'JJ',
"अपायी": 'JJ',
"अपार": 'JJ',
"अपारग": 'JJ',
"अपारगम्य": 'JJ',
"अपारदर्शक": 'JJ',
"अपारदर्शी": 'JJ',
"अपारंपरिक": 'JJ',
"अपारम्परिक": 'JJ',
"अपारित": 'JJ',
"अपारिवारिक": 'JJ',
"अपार्जित": 'JJ',
"अपार्थ": 'JJ',
"अपार्थिव": 'JJ',
"अपाल": 'JJ',
"अपालतू": 'JJ',
"अपावन": 'JJ',
"अपाश्रय": 'JJ',
"अपाश्रित": 'JJ',
"अपासित": 'JJ',
"अपास्त": 'JJ',
"अपाहज": 'JJ',
"अपाहिज": 'JJ',
"अपिंडी": 'JJ',
"अपितृ": 'JJ',
"अपितृक": 'JJ',
"अपिनद्ध": 'JJ',
"अपिबद्ध": 'JJ',
"अपिरच्छन्न": 'JJ',
"अपिहित": 'JJ',
"अपीच": 'JJ',
"अपीच्य": 'JJ',
"अपीली": 'JJ',
"अपुच्छ": 'JJ',
"अपुण्य": 'JJ',
"अपुनीत": 'JJ',
"अपुराण": 'JJ',
"अपुरातन": 'JJ',
"अपुरुष": 'JJ',
"अपुरोदंत": 'JJ',
"अपुरोदन्त": 'JJ',
"अपुष्ट": 'JJ',
"अपुष्प": 'JJ',
"अपुष्पित": 'JJ',
"अपूजक": 'JJ',
"अपूजनीय": 'JJ',
"अपूजित": 'JJ',
"अपूज्य": 'JJ',
"अपूत": 'JJ',
"अपूती": 'JJ',
"अपूर": 'JJ',
"अपूर्ण": 'JJ',
"अपूर्व": 'JJ',
"अपूर्वकालीन": 'JJ',
"अपृक्त": 'JJ',
"अपृथक": 'JJ',
"अपृथक्": 'JJ',
"अपृथ्वीज": 'JJ',
"अपेक्षक": 'JJ',
"अपेक्षणीय": 'JJ',
"अपेक्षारहित": 'JJ',
"अपेक्षित": 'JJ',
"अपेक्षी": 'JJ',
"अपेक्ष्य": 'JJ',
"अपेख": 'JJ',
"अपेत": 'JJ',
"अपेय": 'JJ',
"अपेल": 'JJ',
"अपैठ" :'JJ',
"अपैतृक" :'JJ',
"अपैशुन" :'JJ',
"अपोगंड" :'JJ',
"अपोमय" :'JJ',
"अपोहित" :'JJ',
"अपौरुष" :'JJ',
"अपौरुषेय" :'JJ',
"अप्रकट" :'JJ',
"अप्रकटित" :'JJ',
"अप्रकट्य" :'JJ',
"अप्रकांड" :'JJ',
"अप्रकाण्ड" :'JJ',
"अप्रकाश" :'JJ',
"अप्रकाशनीय" :'JJ',
"अप्रकाशमान" :'JJ',
"अप्रकाशित" :'JJ',
"अप्रकाश्य" :'JJ',
"अप्रकृत" :'JJ',
"अप्रखर" :'JJ',
"अप्रगट" :'JJ',
"अप्रगटित" :'JJ',
"अप्रगल्भ" :'JJ',
"अप्रगाध" :'JJ',
"अप्रचरित" :'JJ',
"अप्रचलित" :'JJ',
"अप्रचुर" :'JJ',
"अप्रच्छन्न" :'JJ',
"अप्रजा" :'JJ',
"अप्रजातंत्रात्मक" :'JJ',
"अप्रजातंत्री" :'JJ',
"अप्रजातंत्रीय" :'JJ',
"अप्रजातन्त्रात्मक" :'JJ',
"अप्रजातन्त्री" :'JJ',
"अप्रजातन्त्रीय" :'JJ',
"अप्रजातांत्रिक" :'JJ',
"अप्रजातान्त्रिक" :'JJ',
"अप्रतर्क्य" :'JJ',
"अप्रतिकार" :'JJ',
"अप्रतिकारी" :'JJ',
"अप्रतिगृहीत" :'JJ',
"अप्रतिघात" :'JJ',
"अप्रतिदेय" :'JJ',
"अप्रतिपन्न" :'JJ',
"अप्रतिबद्ध" :'JJ',
"अप्रतिबंधित" :'JJ',
"अप्रतिबन्धित" :'JJ',
"अप्रतिभ" :'JJ',
"अप्रतिभट" :'JJ',
"अप्रतिम" :'JJ',
"अप्रतिमान" :'JJ',
"अप्रतियोगी" :'JJ',
"अप्रतिरूप" :'JJ',
"अप्रतिवीर्य" :'JJ',
"अप्रतिवेदित" :'JJ',
"अप्रतिष्ठ" :'JJ',
"अप्रतिष्ठित" :'JJ',
"अप्रतिसिद्ध" :'JJ',
"अप्रतिहत" :'JJ',
"अप्रतीक" :'JJ',
"अप्रतीत" :'JJ',
"अप्रतीयमान" :'JJ',
"अप्रतुल" :'JJ',
"अप्रत्यक्ष" :'JJ',
"अप्रत्यय" :'JJ',
"अप्रत्ययी" :'JJ',
"अप्रत्याशित" :'JJ',
"अप्रथित" :'JJ',
"अप्रदूषित" :'JJ',
"अप्रधान" :'JJ',
"अप्रपन्न" :'JJ',
"अप्रबल" :'JJ',
"अप्रभ" :'JJ',
"अप्रभान्वित" :'JJ',
"अप्रभावित" :'JJ',
"अप्रभु" :'JJ',
"अप्रमत्त" :'JJ',
"अप्रमाण" :'JJ',
"अप्रमाणिक" :'JJ',
"अप्रमाणित" :'JJ',
"अप्रमाद" :'JJ',
"अप्रमादी" :'JJ',
"अप्रमित" :'JJ',
"अप्रमुख" :'JJ',
"अप्रमेय" :'JJ',
"अप्रयत्न" :'JJ',
"अप्रयत्नवान" :'JJ',
"अप्रयत्नशील" :'JJ',
"अप्रयत्नी" :'JJ',
"अप्रयास" :'JJ',
"अप्रयासशील" :'JJ',
"अप्रयासी" :'JJ',
"अप्रयुक्त" :'JJ',
"अप्रयोजक" :'JJ',
"अप्रवर्तक" :'JJ',
"अप्रवासी" :'JJ',
"अप्रवाहित" :'JJ',
"अप्रविष्ट" :'JJ',
"अप्रवीण" :'JJ',
"अप्रवृत्त" :'JJ',
"अप्रवृद्ध" :'JJ',
"अप्रवेश्य" :'JJ',
"अप्रशंसनीय" :'JJ',
"अप्रशस्त" :'JJ',
"अप्रशिक्षित" :'JJ',
"अप्रसंग" :'JJ',
"अप्रसंगिक" :'JJ',
"अप्रसङ्गिक" :'JJ',
"अप्रसन्न" :'JJ',
"अप्रसह्य" :'JJ',
"अप्रसिद्ध" :'JJ',
"अप्रसूत" :'JJ',
"अप्रसूता" :'JJ',
"अप्रस्तुत" :'JJ',
"अप्रहत" :'JJ',
"अप्राकृत" :'JJ',
"अप्राकृतिक" :'JJ',
"अप्राचीन" :'JJ',
"अप्राज्ञ" :'JJ',
"अप्राण" :'JJ',
"अप्राणी" :'JJ',
"अप्रादुर्भूत" :'JJ',
"अप्राप्त" :'JJ',
"अप्राप्तयौवन" :'JJ',
"अप्राप्तव्यवहार" :'JJ',
"अप्राप्य" :'JJ',
"अप्रामाणिक" :'JJ',
"अप्रामाण्य" :'JJ',
"अप्रासंगिक" :'JJ',
"अप्रासंङ्गिक" :'JJ',
"अप्रासांगिक" :'JJ',
"अप्रासाङ्गिक" :'JJ',
"अप्रासांङ्गिक" :'JJ',
"अप्रिय" :'JJ',
"अप्रियभाषी" :'JJ',
"अप्रियंवद" :'JJ',
"अप्रियवादी" :'JJ',
"अप्रीतिकर" :'JJ',
"अप्रौढ़" :'JJ',
"अप्सुचर" :'JJ',
"अफगान" :'JJ',
"अफ़गान" :'JJ',
"अफ़ग़ान" :'JJ',
"अफगानी" :'JJ',
"अफ़गानी" :'JJ',
"अफ़ग़ानी" :'JJ',
"अफजूँ" :'JJ',
"अफ़जूँ" :'JJ',
"अफरीकन" :'JJ',
"अफरीका-संबंधी" :'JJ',
"अफरीकी" :'JJ',
"अफल" :'JJ',
"अफलित" :'JJ',
"अफवाही" :'JJ',
"अफ़वाही" :'JJ',
"अफशाँ" :'JJ',
"अफ़शाँ" :'JJ',
"अफशान" :'JJ',
"अफ़शान" :'JJ',
"अफसराना" :'JJ',
"अफ़सराना" :'JJ',
"अफसरी" :'JJ',
"अफ़सरी" :'JJ',
"अफसोसजनक" :'JJ',
"अफ़सोसजनक" :'JJ',
"अफीमची" :'JJ',
"अफ़ीमची" :'JJ',
"अफीमी" :'JJ',
"अफ़ीमी" :'JJ',
"अफुल्ल" :'JJ',
"अफेन" :'JJ',
"अफ्यूनी" :'JJ',
"अफ्रीकन" :'JJ',
"अफ्रीका-संबंधी" :'JJ',
"अफ्रीकी" :'JJ',
"अफ़्रीक़ी" :'JJ',
"अबतर" :'JJ',
"अबद्ध" :'JJ',
"अबध" :'JJ',
"अबंधक" :'JJ',
"अबधार्ह" :'JJ',
"अबंधु" :'JJ',
"अबंधुर" :'JJ',
"अबधू" :'JJ',
"अबध्य" :'JJ',
"अबन्धक" :'JJ',
"अबन्धु" :'JJ',
"अबन्धुर" :'JJ',
"अबर" :'JJ',
"अबरन" :'JJ',
"अबरनीय" :'JJ',
"अबरस" :'JJ',
"अबरा" :'JJ',
"अबरी" :'JJ',
"अबल" :'JJ',
"अबलक" :'JJ',
"अबलख" :'JJ',
"अबला" :'JJ',
"अबस" :'JJ',
"अबहु" :'JJ',
"अबाइस्सिनियाई" :'JJ',
"अबाद" :'JJ',
"अबादान" :'JJ',
"अबाध" :'JJ',
"अबाधा" :'JJ',
"अबाधित" :'JJ',
"अबाध्य" :'JJ',
"अबान" :'JJ',
"अबाल" :'JJ',
"अबाह्य" :'JJ',
"अबिद्ध" :'JJ',
"अंबिरथा" :'JJ',
"अबिरल" :'JJ',
"अबीज" :'JJ',
"अबीरी" :'JJ',
"अंबुचर" :'JJ',
"अबुझ" :'JJ',
"अबुध" :'JJ',
"अबूझ" :'JJ',
"अबूझा" :'JJ',
"अबेध" :'JJ',
"अबेश" :'JJ',
"अबैन" :'JJ',
"अबोध" :'JJ',
"अबोधगम्य" :'JJ',
"अबोधनीय" :'JJ',
"अबोध्य" :'JJ',
"अबोल" :'JJ',
"अबोला" :'JJ',
"अब्ज" :'JJ',
"अब्धिज" :'JJ',
"अब्बर" :'JJ',
"अब्रह्मण्य" :'JJ',
"अभक्त" :'JJ',
"अभक्ष" :'JJ',
"अभक्ष्य" :'JJ',
"अभंग" :'JJ',
"अभगत" :'JJ',
"अभंगी" :'JJ',
"अभंगुर" :'JJ',
"अभग्न" :'JJ',
"अभङ्ग" :'JJ',
"अभङ्गी" :'JJ',
"अभङ्गुर" :'JJ',
"अभंजन" :'JJ',
"अभंजनशील" :'JJ',
"अभंजनीय" :'JJ',
"अभंजित" :'JJ',
"अभञ्जन" :'JJ',
"अभद्र" :'JJ',
"अभय" :'JJ',
"अभयकर" :'JJ',
"अभर" :'JJ',
"अभरम" :'JJ',
"अभल" :'JJ',
"अभव्य" :'JJ',
"अभाऊ" :'JJ',
"अभागा" :'JJ',
"अभागी" :'JJ',
"अभाजन" :'JJ',
"अभाज्य" :'JJ',
"अभाव-ग्रस्त" :'JJ',
"अभावग्रस्त" :'JJ',
"अभावनात्मक" :'JJ',
"अभावनीय" :'JJ',
"अभावात्मक" :'JJ',
"अभावित" :'JJ',
"अभावी" :'JJ',
"अभाषित" :'JJ',
"अभिक" :'JJ',
"अभिकांक्षित" :'JJ',
"अभिकांक्षी" :'JJ',
"अभिक्रांत" :'JJ',
"अभिक्रांती" :'JJ',
"अभिक्रान्त" :'JJ',
"अभिक्रान्ती" :'JJ',
"अभिख्यात" :'JJ',
"अभिगामी" :'JJ',
"अभिगुप्त" :'JJ',
"अभिगृहीत" :'JJ',
"अभिगोप्ता" :'JJ',
"अभिचारक" :'JJ',
"अभिचारी" :'JJ',
"अभिजात" :'JJ',
"अभिजात्य" :'JJ',
"अभिजित" :'JJ',
"अभिजीत" :'JJ',
"अभिज्ञ" :'JJ',
"अभिज्ञात" :'JJ',
"अभिज्ञापक" :'JJ',
"अभिज्ञेय" :'JJ',
"अभितप्त" :'JJ',
"अभितृप्त" :'JJ',
"अभितोमुख" :'JJ',
"अभिदत्त" :'JJ',
"अभिदिष्ट" :'JJ',
"अभिद्रुत" :'JJ',
"अभिधावक" :'JJ',
"अभिधेय" :'JJ',
"अभिनत" :'JJ',
"अभिनंदनीय" :'JJ',
"अभिनंदित" :'JJ',
"अभिनंदी" :'JJ',
"अभिनंद्य" :'JJ',
"अभिनन्दनीय" :'JJ',
"अभिनन्दित" :'JJ',
"अभिनम्र" :'JJ',
"अभिनव" :'JJ',
"अभिनिधन" :'JJ',
"अभिनियुक्त" :'JJ',
"अभिनिर्दिष्ट" :'JJ',
"अभिनिविष्ट" :'JJ',
"अभिनिवेशित" :'JJ',
"अभिनिवेशी" :'JJ',
"अभिनीत" :'JJ',
"अभिनेय" :'JJ',
"अभिन्न" :'JJ',
"अभिन्यस्त" :'JJ',
"अभिपन्न" :'JJ',
"अभिपीड़ित" :'JJ',
"अभिपूजित" :'JJ',
"अभिपूर्ण" :'JJ',
"अभिप्रहत" :'JJ',
"अभिप्रायविरुद्ध" :'JJ',
"अभिप्रेत" :'JJ',
"अभिप्लुत" :'JJ',
"अभिभंग" :'JJ',
"अभिभङ्ग" :'JJ',
"अभिभवनीय" :'JJ',
"अभिभाषित" :'JJ',
"अभिभाष्य" :'JJ',
"अभिभूत" :'JJ',
"अभिमंचित" :'JJ',
"अभिमंडित" :'JJ',
"अभिमत" :'JJ',
"अभिमंतव्य" :'JJ',
"अभिमंत्रित" :'JJ',
"अभिमद्यत" :'JJ',
"अभिमन्तव्य" :'JJ',
"अभिमन्त्रित" :'JJ',
"अभिमर्शक" :'JJ',
"अभिमर्षक" :'JJ',
"अभिमानरहित" :'JJ',
"अभिमानवत्" :'JJ',
"अभिमानशून्य" :'JJ',
"अभिमानित" :'JJ',
"अभिमानी" :'JJ',
"अभिमुख" :'JJ',
"अभिमूर्छित" :'JJ',
"अभिमृष्ट" :'JJ',
"अभियाचित" :'JJ',
"अभियुक्त" :'JJ',
"अभियोजक" :'JJ',
"अभियोज्य" :'JJ',
"अभिरक्षक" :'JJ',
"अभिरक्षित" :'JJ',
"अभिरंजित" :'JJ',
"अभिरञ्जित" :'JJ',
"अभिरत" :'JJ',
"अभिरमणीय" :'JJ',
"अभिरम्य" :'JJ',
"अभिराम" :'JJ',
"अभिरामी" :'JJ',
"अभिरूप" :'JJ',
"अभिरूपक" :'JJ',
"अभिलक्षित" :'JJ',
"अभिलक्ष्य" :'JJ',
"अभिलमंडित" :'JJ',
"अभिलमण्डित" :'JJ',
"अभिलषित" :'JJ',
"अभिलाखी" :'JJ',
"अभिलाषक" :'JJ',
"अभिलाषापूर्ण" :'JJ',
"अभिलाषारहित" :'JJ',
"अभिलाषित" :'JJ',
"अभिलाषी" :'JJ',
"अभिलाषुक" :'JJ',
"अभिलिखित" :'JJ',
"अभिलीन" :'JJ',
"अभिलुप्त" :'JJ',
"अभिवंदनीय" :'JJ',
"अभिवंदित" :'JJ',
"अभिवंद्य" :'JJ',
"अभिवन्दनीय" :'JJ',
"अभिवन्दित" :'JJ',
"अभिवन्द्य" :'JJ',
"अभिवांछित" :'JJ',
"अभिवाञ्छित" :'JJ',
"अभिवादक" :'JJ',
"अभिवादित" :'JJ',
"अभिवाद्य" :'JJ',
"अभिविख्यात" :'JJ',
"अभिविझप्त" :'JJ',
"अभिविनीत" :'JJ',
"अभिविश्रुत" :'JJ',
"अभिवृद्ध" :'JJ',
"अभिवृष्ट" :'JJ',
"अभिव्यक्त" :'JJ',
"अभिव्यक्तिशील" :'JJ',
"अभिव्यंजक" :'JJ',
"अभिव्यंजित" :'JJ',
"अभिव्यञ्जक" :'JJ',
"अभिव्यञ्जित" :'JJ',
"अभिव्यापक" :'JJ',
"अभिव्याप्त" :'JJ',
"अभिव्याहृत" :'JJ',
"अभिशंक" :'JJ',
"अभिशंकित" :'JJ',
"अभिशक्त" :'JJ',
"अभिशङ्क" :'JJ',
"अभिशङ्कित" :'JJ',
"अभिशप्त" :'JJ',
"अभिशब्दित" :'JJ',
"अभिशंसित" :'JJ',
"अभिशस्त" :'JJ',
"अभिशापित" :'JJ',
"अभिशासित" :'JJ',
"अभिषिक्त" :'JJ',
"अभिषेचित" :'JJ',
"अभिष्तुत" :'JJ',
"अभिष्यंदी" :'JJ',
"अभिष्यन्दी" :'JJ',
"अभिसंधक" :'JJ',
"अभिसन्धक" :'JJ',
"अभिसारिणी" :'JJ',
"अभिसारी" :'JJ',
"अभिस्फुरित" :'JJ',
"अभिस्यंदी" :'JJ',
"अभिस्यन्दी" :'JJ',
"अभिहत" :'JJ',
"अभिहरणीय" :'JJ',
"अभिहित" :'JJ',
"अभीक" :'JJ',
"अभीत" :'JJ',
"अभीप्सित" :'JJ',
"अभीप्सी" :'JJ',
"अभीप्सु" :'JJ',
"अभीरु" :'JJ',
"अभीष्ट" :'JJ',
"अभुक्त" :'JJ',
"अभुक्तभोगी" :'JJ',
"अभुग्न" :'JJ',
"अभुज" :'JJ',
"अभूत" :'JJ',
"अभूतपूर्व" :'JJ',
"अभूतशत्रु" :'JJ',
"अभूमिज" :'JJ',
"अभूयिष्ट" :'JJ',
"अभूरि" :'JJ',
"अभृत" :'JJ',
"अभेद" :'JJ',
"अभेदनीय" :'JJ',
"अभेद्य" :'JJ',
"अभेय" :'JJ',
"अभेव" :'JJ',
"अभै" :'JJ',
"अभोक्ता" :'JJ',
"अभोग" :'JJ',
"अभोगा" :'JJ',
"अभोगी" :'JJ',
"अभोग्य" :'JJ',
"अभोज" :'JJ',
"अभोजित" :'JJ',
"अभोज्य" :'JJ',
"अभौतिक" :'JJ',
"अभौम" :'JJ',
"अभ्यंजनीय" :'JJ',
"अभ्यञ्जनीय" :'JJ',
"अभ्यंञ्जनीय" :'JJ',
"अभ्यतीत" :'JJ',
"अभ्यनुक्त" :'JJ',
"अभ्यर्चनीय" :'JJ',
"अभ्यर्च्य" :'JJ',
"अभ्यर्थनीय" :'JJ',
"अभ्यर्थित" :'JJ',
"अभ्यर्थी" :'JJ',
"अभ्यसनीय" :'JJ',
"अभ्यसित" :'JJ',
"अभ्यस्त" :'JJ',
"अभ्याकांक्षित" :'JJ',
"अभ्याख्यात" :'JJ',
"अभ्यागत" :'JJ',
"अभ्यासरहित" :'JJ',
"अभ्यासहीन" :'JJ',
"अभ्यासी" :'JJ',
"अभ्याहत" :'JJ',
"अभ्युक्त" :'JJ',
"अभ्युक्षित" :'JJ',
"अभ्युचित" :'JJ',
"अभ्युत्थायी" :'JJ',
"अभ्युत्थित" :'JJ',
"अभ्युत्थेय" :'JJ',
"अभ्युदित" :'JJ',
"अभ्युन्नत" :'JJ',
"अभ्युपगत" :'JJ',
"अभ्युपित" :'JJ',
"अभ्युपेत" :'JJ',
"अभ्युपेय" :'JJ',
"अभ्रमित" :'JJ',
"अभ्रांत" :'JJ',
"अभ्रान्त" :'JJ',
"अमका" :'JJ',
"अमका-धमका" :'JJ',
"अमंगल" :'JJ',
"अमंगलकर" :'JJ',
"अमंगलकारक" :'JJ',
"अमंगलकारी" :'JJ',
"अमग्न" :'JJ',
"अमङ्गल" :'JJ',
"अमंचनीय" :'JJ',
"अमंच्य" :'JJ',
"अमंडित" :'JJ',
"अमत" :'JJ',
"अमति" :'JJ',
"अमत्त" :'JJ',
"अमद" :'JJ',
"अमंद" :'JJ',
"अमधुपर्क्य" :'JJ',
"अमधुर" :'JJ',
"अमनपसंद" :'JJ',
"अमनस्क" :'JJ',
"अमनिया" :'JJ',
"अमनुष्य" :'JJ',
"अमनैक" :'JJ',
"अमनोगत" :'JJ',
"अमनोज्ञ" :'JJ',
"अमनोनीत" :'JJ',
"अमनोयोगी" :'JJ',
"अमनोरथ" :'JJ',
"अमनोहर" :'JJ',
"अमन्तव्य" :'JJ',
"अमन्द" :'JJ',
"अमम" :'JJ',
"अमर" :'JJ',
"अमरखी" :'JJ',
"अमरण" :'JJ',
"अमरणीय" :'JJ',
"अमरप्रख्य" :'JJ',
"अमरप्रभ" :'JJ',
"अमरवत" :'JJ',
"अमरसी" :'JJ',
"अमराठी" :'JJ',
"अमरीकन" :'JJ',
"अमरीकी" :'JJ',
"अमरुत" :'JJ',
"अमरोपम" :'JJ',
"अमर्त" :'JJ',
"अमर्त्य" :'JJ',
"अमर्दित" :'JJ',
"अमर्द्दित" :'JJ',
"अमर्धत्" :'JJ',
"अमर्याद" :'JJ',
"अमर्यादित" :'JJ',
"अमर्षज" :'JJ',
"अमर्षित" :'JJ',
"अमर्षी" :'JJ',
"अमल" :'JJ',
"अमलतासिया" :'JJ',
"अमलिन" :'JJ',
"अमली" :'JJ',
"अमल्लक" :'JJ',
"अमसृण" :'JJ',
"अमहत" :'JJ',
"अमहत्वपूर्ण" :'JJ',
"अमहत्वाकांक्षी" :'JJ',
"अमहल" :'JJ',
"अमहैरिक" :'JJ',
"अमांगलिक" :'JJ',
"अमाङ्गलिक" :'JJ',
"अमातृक" :'JJ',
"अमात्र" :'JJ',
"अमान" :'JJ',
"अमानती" :'JJ',
"अमाननीय" :'JJ',
"अमानव" :'JJ',
"अमानवी" :'JJ',
"अमानवीय" :'JJ',
"अमानी" :'JJ',
"अमानुष" :'JJ',
"अमानुषिक" :'JJ',
"अमानुषी" :'JJ',
"अमानुषीय" :'JJ',
"अमानुष्य" :'JJ',
"अमान्य" :'JJ',
"अमाप" :'JJ',
"अमापनीय" :'JJ',
"अमापा" :'JJ',
"अमापित" :'JJ',
"अमाय" :'JJ',
"अमाया" :'JJ',
"अमार्जित" :'JJ',
"अमार्मिक" :'JJ',
"अमावड़" :'JJ',
"अमांस" :'JJ',
"अमाही" :'JJ',
"अमिट" :'JJ',
"अमित" :'JJ',
"अमिताभ" :'JJ',
"अमिताशन" :'JJ',
"अमित्र" :'JJ',
"अमिल" :'JJ',
"अमिलनसार" :'JJ',
"अमिलित" :'JJ',
"अमिश्र" :'JJ',
"अमिश्रणीय" :'JJ',
"अमिश्रित" :'JJ',
"अमिष" :'JJ',
"अमीत" :'JJ',
"अमीर" :'JJ',
"अमीराना" :'JJ',
"अमीरी" :'JJ',
"अमुक" :'JJ',
"अमुक्त" :'JJ',
"अमुख्य" :'JJ',
"अमुग्ध" :'JJ',
"अमुष्य" :'JJ',
"अमूक" :'JJ',
"अमूढ़" :'JJ',
"अमूर" :'JJ',
"अमूर्त" :'JJ',
"अमूर्तमान" :'JJ',
"अमूर्ति" :'JJ',
"अमूर्तिमान" :'JJ',
"अमूर्त्त" :'JJ',
"अमूर्त्ति" :'JJ',
"अमूर्त्तिमान" :'JJ',
"अमूल" :'JJ',
"अमूलक" :'JJ',
"अमूल्य" :'JJ',
"अमृत" :'JJ',
"अमृतद्रव" :'JJ',
"अमृतप" :'JJ',
"अमृताक्षर" :'JJ',
"अमृतासु" :'JJ',
"अमृत्युकारी" :'JJ',
"अमृष्ट" :'JJ',
"अमृष्य" :'JJ',
"अमेघ" :'JJ',
"अमेंड़" :'JJ',
"अमेदस्क" :'JJ',
"अमेध्य" :'JJ',
"अमेध्ययुक्त" :'JJ',
"अमेय" :'JJ',
"अमेरिकन" :'JJ',
"अमेरिकी" :'JJ',
"अमेल" :'JJ',
"अमेली" :'JJ',
"अमेव" :'JJ',
"अमैंड़" :'JJ',
"अमोघ" :'JJ',
"अमोचन" :'JJ',
"अमोल" :'JJ',
"अमोलक" :'JJ',
"अमोही" :'JJ',
"अमौआ" :'JJ',
"अमौलिक" :'JJ',
"अम्बुचर" :'JJ',
"अम्लान" :'JJ',
"अम्लीय" :'JJ',
"अम्हारिक" :'JJ',
"अम्हैरिक" :'JJ',
"अयक्ष्म" :'JJ',
"अयजनीय" :'JJ',
"अयज्ञिप" :'JJ',
"अयत" :'JJ',
"अयतेंद्रिय" :'JJ',
"अयतेन्द्रिय" :'JJ',
"अयत्न" :'JJ',
"अयत्नकारी" :'JJ',
"अयथा" :'JJ',
"अयथातथ" :'JJ',
"अयथापूर्व" :'JJ',
"अयथार्थ" :'JJ',
"अयथेष्ट" :'JJ',
"अयथोचित" :'JJ',
"अयमित" :'JJ',
"अयशकर" :'JJ',
"अयशत्य" :'JJ',
"अयशस्कर" :'JJ',
"अयशस्वी" :'JJ',
"अयशी" :'JJ',
"अयस्काम" :'JJ',
"अयां" :'JJ',
"अयाचक" :'JJ',
"अयाचित" :'JJ',
"अयाची" :'JJ',
"अयाच्य" :'JJ',
"अयाज्य" :'JJ',
"अयातपूर्व" :'JJ',
"अयातयाम" :'JJ',
"अयातु" :'JJ',
"अयाथार्थिक" :'JJ',
"अयान" :'JJ',
"अयाना" :'JJ',
"अयुक्त" :'JJ',
"अयुक्तरूप" :'JJ',
"अयुग" :'JJ',
"अयुग्म" :'JJ',
"अयुत" :'JJ',
"अयुध्य" :'JJ',
"अयोग" :'JJ',
"अयोगी" :'JJ',
"अयोग्य" :'JJ',
"अयोध्य" :'JJ',
"अयोध्या" :'JJ',
"अयोनि" :'JJ',
"अयोनिज" :'JJ',
"अय्याश" :'JJ',
"अरइल" :'JJ',
"अरक्त" :'JJ',
"अरक्तक" :'JJ',
"अरक्तताजन्य" :'JJ',
"अरक्षित" :'JJ',
"अरगजी" :'JJ',
"अरगट" :'JJ',
"अरगलीय" :'JJ',
"अरगवानी" :'JJ',
"अरचित" :'JJ',
"अरजल" :'JJ',
"अरडींग" :'JJ',
"अरणीय" :'JJ',
"अरण्यगत" :'JJ',
"अरण्यभव" :'JJ',
"अरत" :'JJ',
"अरतिस" :'JJ',
"अरतीस" :'JJ',
"अरथ" :'JJ',
"अरथी" :'JJ',
"अरद" :'JJ',
"अरदन" :'JJ',
"अरद्धाङ्गी" :'JJ',
"अरध" :'JJ',
"अरधंगी" :'JJ',
"अरधङ्गी" :'JJ',
"अरपनगंडा" :'JJ',
"अरपा" :'JJ',
"अरपित" :'JJ',
"अरब" :'JJ',
"अरबपति" :'JJ',
"अरबर" :'JJ',
"अरबी" :'JJ',
"अरबीला" :'JJ',
"अरबों" :'JJ',
"अरभक" :'JJ',
"अरम" :'JJ',
"अरमेनियन" :'JJ',
"अरमेनियाई" :'JJ',
"अरवाही" :'JJ',
"अरस" :'JJ',
"अरसज्ञ" :'JJ',
"अरसठ" :'JJ',
"अरसठवाँ" :'JJ',
"अरसिक" :'JJ',
"अरसीला" :'JJ',
"अरसौहाँ" :'JJ',
"अरसौहां" :'JJ',
"अरसौंहाँ" :'JJ',
"अरसौंहां" :'JJ',
"अरहित" :'JJ',
"अराग" :'JJ',
"अराज" :'JJ',
"अराजक" :'JJ',
"अराजपत्रित" :'JJ',
"अराधी" :'JJ',
"अराल" :'JJ',
"अरिक्थभाग" :'JJ',
"अरिघ्न" :'JJ',
"अरिजित" :'JJ',
"अरिंदम" :'JJ',
"अरिदमन" :'JJ',
"अरिनुत" :'JJ',
"अरिन्दम" :'JJ',
"अरिमर्द" :'JJ',
"अरिमर्दन" :'JJ',
"अरिष्ट" :'JJ',
"अरिहन" :'JJ',
"अरिहा" :'JJ',
"अरिहीन" :'JJ',
"अरुगण" :'JJ',
"अरुग्ण" :'JJ',
"अरुचिकर" :'JJ',
"अरुचिकारक" :'JJ',
"अरुचिर" :'JJ',
"अरुज" :'JJ',
"अरुणाचली" :'JJ',
"अरुणाचलीय" :'JJ',
"अरुणाभ" :'JJ',
"अरुणार" :'JJ',
"अरुणित" :'JJ',
"अरुंतुद" :'JJ',
"अरुद्ध" :'JJ',
"अरुनार" :'JJ',
"अरुनारा" :'JJ',
"अरुन्तुद" :'JJ',
"अरुष" :'JJ',
"अरूक्ष" :'JJ',
"अरूढ़" :'JJ',
"अरूप" :'JJ',
"अरूपक" :'JJ',
"अरूपित" :'JJ',
"अरेस्टिड" :'JJ',
"अरोक" :'JJ',
"अरोग" :'JJ',
"अरोगी" :'JJ',
"अरोग्य" :'JJ',
"अरोचक" :'JJ',
"अरोड़" :'JJ',
"अरोधन" :'JJ',
"अरोधित" :'JJ',
"अरोही" :'JJ',
"अरौद्र" :'JJ',
"अर्क" :'JJ',
"अर्कज" :'JJ',
"अर्कभ" :'JJ',
"अर्कीय" :'JJ',
"अर्चनीय" :'JJ',
"अर्चित" :'JJ',
"अर्जनीय" :'JJ',
"अर्जित" :'JJ',
"अर्जुनक" :'JJ',
"अर्जेन्टाइन" :'JJ',
"अर्जेन्टिना-संबंधी" :'JJ',
"अर्जेन्टिनाई" :'JJ',
"अर्जेन्टिनियन" :'JJ',
"अर्णव" :'JJ',
"अर्थ-संबंधी" :'JJ',
"अर्थकर" :'JJ',
"अर्थकिल्विषी" :'JJ',
"अर्थगत" :'JJ',
"अर्थद" :'JJ',
"अर्थनीय" :'JJ',
"अर्थपिशाच" :'JJ',
"अर्थपूर्ण" :'JJ',
"अर्थबुद्धि" :'JJ',
"अर्थमूलक" :'JJ',
"अर्थयुक्त" :'JJ',
"अर्थलोलुप" :'JJ',
"अर्थशास्त्रीय" :'JJ',
"अर्थशून्य" :'JJ',
"अर्थसंबंधी" :'JJ',
"अर्थहीन" :'JJ',
"अर्थिक" :'JJ',
"अर्थित" :'JJ',
"अर्थी" :'JJ',
"अर्थीय" :'JJ',
"अर्दित" :'JJ',
"अर्द्ध" :'JJ',
"अर्द्ध उन्मत्त" :'JJ',
"अर्द्ध कोटि" :'JJ',
"अर्द्ध पारदर्शी" :'JJ',
"अर्द्ध विक्षिप्त" :'JJ',
"अर्द्ध शहरी" :'JJ',
"अर्द्ध सम्मत" :'JJ',
"अर्द्ध सहमत" :'JJ',
"अर्द्ध-पारदर्शी" :'JJ',
"अर्द्ध-शब्द" :'JJ',
"अर्द्ध-शासकीय" :'JJ',
"अर्द्ध-सरकारी" :'JJ',
"अर्द्धकुशल" :'JJ',
"अर्द्धचेतन" :'JJ',
"अर्द्धजल" :'JJ',
"अर्द्धदग्ध" :'JJ',
"अर्द्धनिपुण" :'JJ',
"अर्द्धपारदर्शी" :'JJ',
"अर्द्धवार्षिक" :'JJ',
"अर्द्धविक्षिप्त" :'JJ',
"अर्द्धशत" :'JJ',
"अर्द्धशब्द" :'JJ',
"अर्द्धशहरी" :'JJ',
"अर्द्धशासकीय" :'JJ',
"अर्द्धसम" :'JJ',
"अर्द्धसम्मत" :'JJ',
"अर्द्धसरकारी" :'JJ',
"अर्द्धसहमत" :'JJ',
"अर्द्धसैनिक" :'JJ',
"अर्द्धस्वर" :'JJ',
"अर्द्धांगी" :'JJ',
"अर्द्धाङ्गी" :'JJ',
"अर्द्धुक" :'JJ',
"अर्द्धोन्मत्त" :'JJ',
"अर्ध" :'JJ',
"अर्ध उन्मत्त" :'JJ',
"अर्ध कोटि" :'JJ',
"अर्ध गोलाकार" :'JJ',
"अर्ध चंद्राकार" :'JJ',
"अर्ध चन्द्राकार" :'JJ',
"अर्ध पक्व" :'JJ',
"अर्ध पारदर्शी" :'JJ',
"अर्ध मंडलाकार" :'JJ',
"अर्ध मुकुलित" :'JJ',
"अर्ध मृत" :'JJ',
"अर्ध वर्तुल" :'JJ',
"अर्ध वर्तुलाकार" :'JJ',
"अर्ध वार्षिक" :'JJ',
"अर्ध विक्षिप्त" :'JJ',
"अर्ध सम्मत" :'JJ',
"अर्ध सहमत" :'JJ',
"अर्ध-गोलाकार" :'JJ',
"अर्ध-नग्न" :'JJ',
"अर्ध-पारदर्शी" :'JJ',
"अर्ध-मृत" :'JJ',
"अर्ध-वृत्ताकार" :'JJ',
"अर्ध-शब्द" :'JJ',
"अर्ध-शासकीय" :'JJ',
"अर्ध-सरकारी" :'JJ',
"अर्धकुशल" :'JJ',
"अर्धगोलाकार" :'JJ',
"अर्धचेतन" :'JJ',
"अर्धजल" :'JJ',
"अर्धदग्ध" :'JJ',
"अर्धनग्न" :'JJ',
"अर्धनिपुण" :'JJ',
"अर्धपारदर्शी" :'JJ',
"अर्धमृत" :'JJ',
"अर्धवार्षिक" :'JJ',
"अर्धविक्षिप्त" :'JJ',
"अर्धवृत्ताकार" :'JJ',
"अर्धशत" :'JJ',
"अर्धशब्द" :'JJ',
"अर्धशासकीय" :'JJ',
"अर्धशिक्षित" :'JJ',
"अर्धसम" :'JJ',
"अर्धसम्मत" :'JJ',
"अर्धसरकारी" :'JJ',
"अर्धसहमत" :'JJ',
"अर्धसैनिक" :'JJ',
"अर्धस्वर" :'JJ',
"अर्धांगी" :'JJ',
"अर्धुक" :'JJ',
"अर्धोन्मत्त" :'JJ',
"अर्धोंमत्त" :'JJ',
"अर्पणीय" :'JJ',
"अर्पित" :'JJ',
"अर्पित किया" :'JJ',
"अर्प्य" :'JJ',
"अर्बुद" :'JJ',
"अर्भ" :'JJ',
"अर्भक" :'JJ',
"अर्मक" :'JJ',
"अर्मेनियन" :'JJ',
"अर्मेनियाई" :'JJ',
"अर्य" :'JJ',
"अर्य्य" :'JJ',
"अर्वाचीन" :'JJ',
"अर्विंदनयन" :'JJ',
"अर्ह" :'JJ',
"अर्हित" :'JJ',
"अर्ह्य" :'JJ',
"अलं" :'JJ',
"अलंकरणीय" :'JJ',
"अलकलड़ैता" :'JJ',
"अलंकारपूर्ण" :'JJ',
"अलंकारहीन" :'JJ',
"अलंकारिक" :'JJ',
"अलंकारित" :'JJ',
"अलंकित" :'JJ',
"अलंकृत" :'JJ',
"अलक्षण" :'JJ',
"अलक्षणी" :'JJ',
"अलक्षित" :'JJ',
"अलक्ष्य" :'JJ',
"अलख" :'JJ',
"अलखित" :'JJ',
"अलग" :'JJ',
"अलग अलग" :'JJ',
"अलग किया" :'JJ',
"अलग-अलग" :'JJ',
"अलगरज" :'JJ',
"अलगरजी" :'JJ',
"अलगाया" :'JJ',
"अलगाववादी" :'JJ',
"अलंघनीय" :'JJ',
"अलंघ्य" :'JJ',
"अलङ्कित" :'JJ',
"अलङ्कृत" :'JJ',
"अलङ्घनीय" :'JJ',
"अलङ्घ्य" :'JJ',
"अलच्छ" :'JJ',
"अलज" :'JJ',
"अलजीरियाई" :'JJ',
"अलज्ज" :'JJ',
"अलप" :'JJ',
"अलपत" :'JJ',
"अलबानियन" :'JJ',
"अलबानियाई" :'JJ',
"अलबेनियन" :'JJ',
"अलबेनियाई" :'JJ',
"अलबेला" :'JJ',
"अलब्ध" :'JJ',
"अलब्धाभीप्सित" :'JJ',
"अलभ्य" :'JJ',
"अलमस्त" :'JJ',
"अलम्" :'JJ',
"अलरबलर" :'JJ',
"अलर्ट" :'JJ',
"अललटप्पू" :'JJ',
"अलवाई" :'JJ',
"अलवाँत" :'JJ',
"अलवाँती" :'JJ',
"अलवांती" :'JJ',
"अलवायी" :'JJ',
"अलस" :'JJ',
"अलसेटिया" :'JJ',
"अलसौहां" :'JJ',
"अलह" :'JJ',
"अलहदा" :'JJ',
"अलहदी" :'JJ',
"अँला" :'JJ',
"अलाई" :'JJ',
"अलापी" :'JJ',
"अलाभप्रद" :'JJ',
"अलाम" :'JJ',
"अलाय-बलाय" :'JJ',
"अलायक" :'JJ',
"अलायी" :'JJ',
"अलाल" :'JJ',
"अलास्य" :'JJ',
"अलिखित" :'JJ',
"अलिंग" :'JJ',
"अलिङ्ग" :'JJ',
"अलिपिबद्ध" :'JJ',
"अलिप्त" :'JJ',
"अलिया-बलिया" :'JJ',
"अलीक" :'JJ',
"अलीजा" :'JJ',
"अलीन" :'JJ',
"अलील" :'JJ',
"अलीह" :'JJ',
"अलुप्त" :'JJ',
"अलुब्ध" :'JJ',
"अलून" :'JJ',
"अलूना" :'JJ',
"अलूप" :'JJ',
"अलेख" :'JJ',
"अलेखा" :'JJ',
"अलेखी" :'JJ',
"अलोक" :'JJ',
"अलोकतंत्रात्मक" :'JJ',
"अलोकतंत्री" :'JJ',
"अलोकतंत्रीय" :'JJ',
"अलोकतन्त्रात्मक" :'JJ',
"अलोकतन्त्री" :'JJ',
"अलोकतन्त्रीय" :'JJ',
"अलोकतांत्रिक" :'JJ',
"अलोकतान्त्रिक" :'JJ',
"अलोना" :'JJ',
"अलोभ" :'JJ',
"अलोभी" :'JJ',
"अलोल" :'JJ',
"अलोलुप" :'JJ',
"अलोहित" :'JJ',
"अलौकिक" :'JJ',
"अल्जीरियन" :'JJ',
"अल्जीरियाई" :'JJ',
"अल्जेरिआई" :'JJ',
"अल्जेरियन" :'JJ',
"अल्जेरियाई" :'JJ',
"अल्प" :'JJ',
"अल्प कालीन" :'JJ',
"अल्प जीवी" :'JJ',
"अल्प पक्व" :'JJ',
"अल्प शिक्षित" :'JJ',
"अल्प-व्ययी" :'JJ',
"अल्पक" :'JJ',
"अल्पकालिक" :'JJ',
"अल्पकालीन" :'JJ',
"अल्पक्रीत" :'JJ',
"अल्पच्छद" :'JJ',
"अल्पजीवी" :'JJ',
"अल्पज्ञ" :'JJ',
"अल्पज्ञानी" :'JJ',
"अल्पदर्शी" :'JJ',
"अल्पदृष्टि" :'JJ',
"अल्पध्वनियुक्त" :'JJ',
"अल्पबल" :'JJ',
"अल्पबुद्धि" :'JJ',
"अल्पभाग्य" :'JJ',
"अल्पभाषी" :'JJ',
"अल्पभोजी" :'JJ',
"अल्पमध्यम" :'JJ',
"अल्पमूर्ति" :'JJ',
"अल्पमूल्य" :'JJ',
"अल्परक्तक" :'JJ',
"अल्परक्तताजन्य" :'JJ',
"अल्पवयस्क" :'JJ',
"अल्पवादी" :'JJ',
"अल्पविकसित" :'JJ',
"अल्पव्ययी" :'JJ',
"अल्पसंख्य" :'JJ',
"अल्पसंख्यक" :'JJ',
"अल्पहारी" :'JJ',
"अल्पायु" :'JJ',
"अल्पावधि" :'JJ',
"अल्पावधिक" :'JJ',
"अल्पाहारी" :'JJ',
"अल्पिष्ठ" :'JJ',
"अल्बानियन" :'JJ',
"अल्बानियाई" :'JJ',
"अल्बेनियन" :'JJ',
"अल्बेनियाई" :'JJ',
"अल्लम-गल्लम" :'JJ',
"अल्हड़" :'JJ',
"अवकंपित" :'JJ',
"अवकम्पित" :'JJ',
"अवकलित" :'JJ',
"अवकाश प्राप्त" :'JJ',
"अवकीर्ण" :'JJ',
"अवकीर्णा" :'JJ',
"अवकृष्ट" :'JJ',
"अवकेशी" :'JJ',
"अवकोकिल" :'JJ',
"अवक्तव्य" :'JJ',
"अवक्र" :'JJ',
"अवक्रम" :'JJ',
"अवक्लिन्न" :'JJ',
"अवक्षिप्त" :'JJ',
"अवक्षीण" :'JJ',
"अवक्षुत" :'JJ',
"अवगणित" :'JJ',
"अवगत" :'JJ',
"अवगर्हित" :'JJ',
"अवगाढ़" :'JJ',
"अवगाह" :'JJ',
"अवगाहित" :'JJ',
"अवगीत" :'JJ',
"अवगुंठित" :'JJ',
"अवगुंठ्य" :'JJ',
"अवगुणी" :'JJ',
"अवगुण्ठित" :'JJ',
"अवगुण्ठ्य" :'JJ',
"अवगुंफित" :'JJ',
"अवगुम्फित" :'JJ',
"अवघट" :'JJ',
"अवघटित" :'JJ',
"अवघाती" :'JJ',
"अवचन" :'JJ',
"अवचनीय" :'JJ',
"अवचित" :'JJ',
"अवचेतन" :'JJ',
"अवच्छिन्न" :'JJ',
"अवच्छेदक" :'JJ',
"अवच्छेद्य" :'JJ',
"अवजनित" :'JJ',
"अवजित" :'JJ',
"अवज्ञनीय" :'JJ',
"अवज्ञाकारी" :'JJ',
"अवज्ञात" :'JJ',
"अवज्ञेय" :'JJ',
"अवडेरा" :'JJ',
"अवढर" :'JJ',
"अवतमस" :'JJ',
"अवतरित" :'JJ',
"अवतल" :'JJ',
"अवतंसित" :'JJ',
"अवतारित" :'JJ',
"अवतारी" :'JJ',
"अवतारीय" :'JJ',
"अवतीर्ण" :'JJ',
"अवदलित" :'JJ',
"अवदात" :'JJ',
"अवदान्य" :'JJ',
"अवदारक" :'JJ',
"अवदारित" :'JJ',
"अवदीर्ण" :'JJ',
"अवद्य" :'JJ',
"अवधारणीय" :'JJ',
"अवधारित" :'JJ',
"अवधार्य" :'JJ',
"अवधार्य्य" :'JJ',
"अवधि समाप्त" :'JJ',
"अवधियुक्त" :'JJ',
"अवधिहीन" :'JJ',
"अवधी" :'JJ',
"अवधीरित" :'JJ',
"अवधूत" :'JJ',
"अवधृत" :'JJ',
"अवधेय" :'JJ',
"अवध्य" :'JJ',
"अवध्वंस्त" :'JJ',
"अवनत" :'JJ',
"अवनतिकारी" :'JJ',
"अवनतिशील" :'JJ',
"अवनमित" :'JJ',
"अवनम्र" :'JJ',
"अवपूर्ण" :'JJ',
"अवप्लुत" :'JJ',
"अवबुद्ध" :'JJ',
"अवबोधक" :'JJ',
"अवभासक" :'JJ',
"अवभासित" :'JJ',
"अवम" :'JJ',
"अवमत" :'JJ',
"अवमर्दित" :'JJ',
"अवमाननी" :'JJ',
"अवमानित" :'JJ',
"अवयवी" :'JJ',
"अवयस्क" :'JJ',
"अवर" :'JJ',
"अवरक्त" :'JJ',
"अवरक्षक" :'JJ',
"अवरज" :'JJ',
"अवरण" :'JJ',
"अवरत" :'JJ',
"अवरव्रत" :'JJ',
"अवराधक" :'JJ',
"अवरावर" :'JJ',
"अवरीट" :'JJ',
"अवरुद्ध" :'JJ',
"अवरूढ़" :'JJ',
"अवरूप" :'JJ',
"अवरेबदार" :'JJ',
"अवरेबी" :'JJ',
"अवरोक्त" :'JJ',
"अवरोधक" :'JJ',
"अवरोधपूर्ण" :'JJ',
"अवरोधहीन" :'JJ',
"अवरोधात्मक" :'JJ',
"अवरोधित" :'JJ',
"अवरोधी" :'JJ',
"अवरोपणीय" :'JJ',
"अवरोपित" :'JJ',
"अवरोहक" :'JJ',
"अवरोहित" :'JJ',
"अवरोही" :'JJ',
"अवर्ग" :'JJ',
"अवर्जित" :'JJ',
"अवर्ण" :'JJ',
"अवर्णनीय" :'JJ',
"अवर्णित" :'JJ',
"अवर्ण्य" :'JJ',
"अवर्तमान" :'JJ',
"अवर्त्तमान" :'JJ',
"अवर्द्धमान" :'JJ',
"अवर्धमान" :'JJ',
"अवलग्न" :'JJ',
"अवलंबनहीन" :'JJ',
"अवलंबनीय" :'JJ',
"अवलंबहीन" :'JJ',
"अवलंबित" :'JJ',
"अवलंबी" :'JJ',
"अवलम्बनहीन" :'JJ',
"अवलम्बनीय" :'JJ',
"अवलम्बहीन" :'JJ',
"अवलम्बित" :'JJ',
"अवलम्बी" :'JJ',
"अवलिप्त" :'JJ',
"अवलीक" :'JJ',
"अवलीढ" :'JJ',
"अवलुंचित" :'JJ',
"अवलुञ्चित" :'JJ',
"अवलुंठित" :'JJ',
"अवलुण्ठित" :'JJ',
"अवलून" :'JJ',
"अवलेह्य" :'JJ',
"अवलोकक" :'JJ',
"अवलोकनीय" :'JJ',
"अवलोकित" :'JJ',
"अवश" :'JJ',
"अवंश" :'JJ',
"अवशिष्ट" :'JJ',
"अवशेष" :'JJ',
"अवशेषित" :'JJ',
"अवशोषित" :'JJ',
"अवश्य" :'JJ',
"अवश्यंभावी" :'JJ',
"अवश्यम्भावी" :'JJ',
"अवष्टबध" :'JJ',
"अवसक्त" :'JJ',
"अवसन्न" :'JJ',
"अवसभ" :'JJ',
"अवसर प्राप्त" :'JJ',
"अवसर साधक" :'JJ',
"अवसर-प्राप्त" :'JJ',
"अवसरवादी" :'JJ',
"अवसरानुकूल" :'JJ',
"अवसरीय" :'JJ',
"अवसरोचित" :'JJ',
"अवसव्य" :'JJ',
"अवसाद-ग्रस्त" :'JJ',
"अवसादक" :'JJ',
"अवसादग्रस्त" :'JJ',
"अवसादहीन" :'JJ',
"अवसादित" :'JJ',
"अवसादी" :'JJ',
"अवसायक" :'JJ',
"अवसित" :'JJ',
"अवसी" :'JJ',
"अवसुप्त" :'JJ',
"अवसृष्ट" :'JJ',
"अवसेख" :'JJ',
"अवस्कंदित" :'JJ',
"अवस्कन्दित" :'JJ',
"अवस्तु" :'JJ',
"अवस्त्र" :'JJ',
"अवस्थित" :'JJ',
"अवह" :'JJ',
"अवहार्य" :'JJ',
"अवहास्य" :'JJ',
"अवहित" :'JJ',
"अवहितांजलि" :'JJ',
"अवहिताञ्जलि" :'JJ',
"अवहेलित" :'JJ',
"अवाक" :'JJ',
"अवाकी" :'JJ',
"अवाक्" :'JJ',
"अवाक्क" :'JJ',
"अवागी" :'JJ',
"अवाग्र" :'JJ',
"अवाङ्गमुख" :'JJ',
"अवाचीन" :'JJ',
"अवाच्य" :'JJ',
"अवांछनीय" :'JJ',
"अवांछित" :'JJ',
"अवाजी" :'JJ',
"अवात" :'JJ',
"अवांतर" :'JJ',
"अवादी" :'JJ',
"अवाध" :'JJ',
"अवाध्य" :'JJ',
"अवान्तर" :'JJ',
"अवापित" :'JJ',
"अवाप्त" :'JJ',
"अवाप्य" :'JJ',
"अवाय" :'JJ',
"अवारण" :'JJ',
"अवारणीय" :'JJ',
"अवारित" :'JJ',
"अवार्य" :'JJ',
"अवासित" :'JJ',
"अवास्तविक" :'JJ',
"अवाह्य" :'JJ',
"अविकच" :'JJ',
"अविकट" :'JJ',
"अविकल" :'JJ',
"अविकल्प" :'JJ',
"अविकसित" :'JJ',
"अविकार" :'JJ',
"अविकारी" :'JJ',
"अविकार्य" :'JJ',
"अविकृत" :'JJ',
"अविक्रांत" :'JJ',
"अविक्रान्त" :'JJ',
"अविक्रिय" :'JJ',
"अविक्रीत" :'JJ',
"अविख्यात" :'JJ',
"अविगत" :'JJ',
"अविगर्हित" :'JJ',
"अविग्रह" :'JJ',
"अविघ्न" :'JJ',
"अविचक्षण" :'JJ',
"अविचल" :'JJ',
"अविचलित" :'JJ',
"अविचार" :'JJ',
"अविचारणीय" :'JJ',
"अविचारित" :'JJ',
"अविचारी" :'JJ',
"अविचार्य" :'JJ',
"अविचेतन" :'JJ',
"अविच्छिन्न" :'JJ',
"अविच्छेद" :'JJ',
"अविच्छेद्य" :'JJ',
"अविजित" :'JJ',
"अविजेय" :'JJ',
"अविज्ञ" :'JJ',
"अविज्ञप्त" :'JJ',
"अविज्ञात" :'JJ',
"अविज्ञानीय" :'JJ',
"अविज्ञापित" :'JJ',
"अविज्ञेय" :'JJ',
"अवितत्" :'JJ',
"अवितथ" :'JJ',
"अवितर्किक" :'JJ',
"अवित्त" :'JJ',
"अवित्ति" :'JJ',
"अविद" :'JJ',
"अविदग्ध" :'JJ',
"अविदित" :'JJ',
"अविद्ध" :'JJ',
"अविद्य" :'JJ',
"अविद्यमान" :'JJ',
"अविद्यमानना" :'JJ',
"अविद्वान" :'JJ',
"अविधान" :'JJ',
"अविधानीय" :'JJ',
"अविधि" :'JJ',
"अविधिक" :'JJ',
"अविधिमान्य" :'JJ',
"अविनम्र" :'JJ',
"अविनयशील" :'JJ',
"अविनयी" :'JJ',
"अविनश्वर" :'JJ',
"अविनाशी" :'JJ',
"अविनासी" :'JJ',
"अविनीत" :'JJ',
"अविपन्न" :'JJ',
"अविपाक" :'JJ',
"अविबुध" :'JJ',
"अविभक्त" :'JJ',
"अविभाजनीय" :'JJ',
"अविभाजित" :'JJ',
"अविभाज्य" :'JJ',
"अविभावित" :'JJ',
"अविभूषित" :'JJ',
"अविमल" :'JJ',
"अविमुक्त" :'JJ',
"अवियोग" :'JJ',
"अविरत" :'JJ',
"अविरल" :'JJ',
"अविराम" :'JJ',
"अविरुद्ध" :'JJ',
"अविरोध" :'JJ',
"अविरोधी" :'JJ',
"अविलंब" :'JJ',
"अविलम्ब" :'JJ',
"अविवर" :'JJ',
"अविवाद" :'JJ',
"अविवादास्पद" :'JJ',
"अविवादित" :'JJ',
"अविवाद्य" :'JJ',
"अविवाहित" :'JJ',
"अविवाहिता" :'JJ',
"अविवेकपूर्ण" :'JJ',
"अविवेकी" :'JJ',
"अविशिष्ट" :'JJ',
"अविशुद्ध" :'JJ',
"अविशेष" :'JJ',
"अविश्रांत" :'JJ',
"अविश्रान्त" :'JJ',
"अविश्वसनीय" :'JJ',
"अविश्वस्त" :'JJ',
"अविश्वासपात्र" :'JJ',
"अविश्वासी" :'JJ',
"अविष" :'JJ',
"अविषम" :'JJ',
"अविषय" :'JJ',
"अविषाद" :'JJ',
"अविसन" :'JJ',
"अविस्तीर्ण" :'JJ',
"अविस्तृत" :'JJ',
"अविस्मरणीय" :'JJ',
"अविहड़" :'JJ',
"अविहर" :'JJ',
"अविहित" :'JJ',
"अवीक्षित" :'JJ',
"अवीज" :'JJ',
"अवीर" :'JJ',
"अवीर्य" :'JJ',
"अवीह" :'JJ',
"अवृद्धिक" :'JJ',
"अवेक्षणीय" :'JJ',
"अवेक्षित" :'JJ',
"अवेद्य" :'JJ',
"अवेद्या" :'JJ',
"अवेधित" :'JJ',
"अवेध्य" :'JJ',
"अवेल" :'JJ',
"अवेष्ट" :'JJ',
"अवैज्ञानिक" :'JJ',
"अवैतनिक" :'JJ',
"अवैदिक" :'JJ',
"अवैद्य" :'JJ',
"अवैध" :'JJ',
"अवैधानिक" :'JJ',
"अवैमत्य" :'JJ',
"अव्यक्त" :'JJ',
"अव्यक्तगति" :'JJ',
"अव्यक्तमूर्ति" :'JJ',
"अव्यंग" :'JJ',
"अव्यंगांग" :'JJ',
"अव्यग्र" :'JJ',
"अव्यङ्ग" :'JJ',
"अव्यङ्गाङ्ग" :'JJ',
"अव्यंजन" :'JJ',
"अव्यञ्जन" :'JJ',
"अव्यतीत" :'JJ',
"अव्यय" :'JJ',
"अव्यर्थ" :'JJ',
"अव्यलीक" :'JJ',
"अव्यवसायी" :'JJ',
"अव्यवस्थित" :'JJ',
"अव्यवहारी" :'JJ',
"अव्यवहारीय" :'JJ',
"अव्यवहार्य" :'JJ',
"अव्यवहार्य्य" :'JJ',
"अव्यवहित" :'JJ',
"अव्यवहृत" :'JJ',
"अव्यसनी" :'JJ',
"अव्यस्त" :'JJ',
"अव्याकुल" :'JJ',
"अव्याकृत" :'JJ',
"अव्याख्येय" :'JJ',
"अव्याघात" :'JJ',
"अव्यापक" :'JJ',
"अव्यापार" :'JJ',
"अव्यापारी" :'JJ',
"अव्याप्त" :'JJ',
"अव्याप्य" :'JJ',
"अव्यावहारिक" :'JJ',
"अव्यावृत" :'JJ',
"अव्याहत" :'JJ',
"अव्युच्छिन्न" :'JJ',
"अव्युत्पन्न" :'JJ',
"अव्रण" :'JJ',
"अव्रत" :'JJ',
"अव्रती" :'JJ',
"अव्वल" :'JJ',
"अव्वल दरजे का" :'JJ',
"अव्वल दर्जे का" :'JJ',
"अशंक" :'JJ',
"अंशकालिक" :'JJ',
"अशंकित" :'JJ',
"अशक्त" :'JJ',
"अशक्य" :'JJ',
"अशङ्क" :'JJ',
"अशङ्कित" :'JJ',
"अशठ" :'JJ',
"अशत्रु" :'JJ',
"अशन" :'JJ',
"अशनीय" :'JJ',
"अशब्द" :'JJ',
"अशरण" :'JJ',
"अशरफ" :'JJ',
"अशरफ़" :'JJ',
"अशराफ" :'JJ',
"अशराफ़" :'JJ',
"अशरीर" :'JJ',
"अशरीरी" :'JJ',
"अशर्म" :'JJ',
"अशाखित" :'JJ',
"अशांत" :'JJ',
"अशांतिपूर्ण" :'JJ',
"अशान्त" :'JJ',
"अशारीरिक" :'JJ',
"अशालीन" :'JJ',
"अशाश्वत" :'JJ',
"अशासकीय" :'JJ',
"अशिक्षित" :'JJ',
"अशित" :'JJ',
"अशिथिल" :'JJ',
"अशिशु" :'JJ',
"अशिष्ट" :'JJ',
"अशीतल" :'JJ',
"अशील" :'JJ',
"अशुचि" :'JJ',
"अशुद्ध" :'JJ',
"अशुभ" :'JJ',
"अशुभकर" :'JJ',
"अशुभकारक" :'JJ',
"अशुभकारी" :'JJ',
"अशुभचिंतक" :'JJ',
"अशुभेच्छुक" :'JJ',
"अशुभ्र" :'JJ',
"अशुष्क" :'JJ',
"अशून्य" :'JJ',
"अशृत" :'JJ',
"अशेष" :'JJ',
"अशोक" :'JJ',
"अशोधित" :'JJ',
"अशोभनीय" :'JJ',
"अशोभित" :'JJ',
"अशौर्य" :'JJ',
"अश्मर" :'JJ',
"अश्रद्ध" :'JJ',
"अश्रद्धेय" :'JJ',
"अश्रप" :'JJ',
"अश्रवणीय" :'JJ',
"अश्रव्य" :'JJ',
"अश्रांत" :'JJ',
"अश्रान्त" :'JJ',
"अश्रुत" :'JJ',
"अश्रुपूरित" :'JJ',
"अश्रुपूर्ण" :'JJ',
"अश्रुमुख" :'JJ',
"अश्रुयस" :'JJ',
"अश्रुयुक्त" :'JJ',
"अश्रुरहित" :'JJ',
"अश्रेष्ठ" :'JJ',
"अश्रौत" :'JJ',
"अश्लाघनीय" :'JJ',
"अश्लाघ्य" :'JJ',
"अश्लिष्ट" :'JJ',
"अश्लील" :'JJ',
"अश्वरहित" :'JJ',
"अश्वविहीन" :'JJ',
"अश्वस्तन" :'JJ',
"अश्वस्तनिक" :'JJ',
"अश्वारोही" :'JJ',
"अश्वेत" :'JJ',
"अषाढ़ी" :'JJ',
"अषाढ़ीय" :'JJ',
"अष्ट" :'JJ',
"अष्टकुली" :'JJ',
"अष्टकोण" :'JJ',
"अष्टकोना" :'JJ',
"अष्टंगी" :'JJ',
"अष्टङ्गी" :'JJ',
"अष्टदल" :'JJ',
"अष्टधाती" :'JJ',
"अष्टभुज" :'JJ',
"अष्टभुजी" :'JJ',
"अष्टम" :'JJ',
"अष्टाक्षरी" :'JJ',
"अष्टांग" :'JJ',
"अष्टांगी" :'JJ',
"अष्टाङ्ग" :'JJ',
"अष्टाङ्गी" :'JJ',
"अष्टादश" :'JJ',
"अष्टाश्रि" :'JJ',
"अष्टाह" :'JJ',
"असंक" :'JJ',
"असकती" :'JJ',
"असकल" :'JJ',
"असंकोची" :'JJ',
"असक्त" :'JJ',
"असंक्रमित" :'JJ',
"असंक्रामक" :'JJ',
"असक्रिय" :'JJ',
"असंख" :'JJ',
"असंख्य" :'JJ',
"असंख्यक" :'JJ',
"असंख्यात" :'JJ',
"असंख्येय" :'JJ',
"असंग" :'JJ',
"असंगठित" :'JJ',
"असंगत" :'JJ',
"असगर" :'JJ',
"असग़र" :'JJ',
"असगोत्र" :'JJ',
"असघन" :'JJ',
"असंघनित" :'JJ',
"असङ्ख्य" :'JJ',
"असङ्ख्यक" :'JJ',
"असङ्ख्यात" :'JJ',
"असङ्ख्येय" :'JJ',
"असङ्ग" :'JJ',
"असङ्गत" :'JJ',
"असंचारी" :'JJ',
"असजग" :'JJ',
"असजातीय" :'JJ',
"असज्जन" :'JJ',
"असंत" :'JJ',
"असती" :'JJ',
"असंतुलित" :'JJ',
"असंतुष्ट" :'JJ',
"असंतृप्त" :'JJ',
"असंतोषजनक" :'JJ',
"असंतोषप्रद" :'JJ',
"असंतोषी" :'JJ',
"असत्" :'JJ',
"असत्कार कृत" :'JJ',
"असत्कृत" :'JJ',
"असत्प्रतिग्राही" :'JJ',
"असत्य" :'JJ',
"असत्यतापूर्ण" :'JJ',
"असत्यभाषी" :'JJ',
"असत्यवादी" :'JJ',
"असत्यापित" :'JJ',
"असत्व" :'JJ',
"असंदिग्ध" :'JJ',
"असदृश" :'JJ',
"असन्तुष्ट" :'JJ',
"असन्तोषी" :'JJ',
"असन्दिग्ध" :'JJ',
"असन्नद्ध" :'JJ',
"असन्नाध" :'JJ',
"असन्निहित" :'JJ',
"असंपन्न" :'JJ',
"असंपादित" :'JJ',
"असंपूर्ण" :'JJ',
"असंप्राप्य" :'JJ',
"असफल" :'JJ',
"असंबद्ध" :'JJ',
"असंबंधित" :'JJ',
"असंभव" :'JJ',
"असंभार" :'JJ',
"असंभावनीय" :'JJ',
"असंभावित" :'JJ',
"असंभावी" :'JJ',
"असंभाव्य" :'JJ',
"असंभाष्य" :'JJ',
"असभ्य" :'JJ',
"असम" :'JJ',
"असमक्ष" :'JJ',
"असमग्र" :'JJ',
"असमतल" :'JJ',
"असमनेत्र" :'JJ',
"असमय" :'JJ',
"असमयोचित" :'JJ',
"असमरूप" :'JJ',
"असमरूपी" :'JJ',
"असमर्थ" :'JJ',
"असमाधानित" :'JJ',
"असमान" :'JJ',
"असमाप्त" :'JJ',
"असमाप्य" :'JJ',
"असमावर्तक" :'JJ',
"असमावृत्त" :'JJ',
"असमाहित" :'JJ',
"असमिया" :'JJ',
"असमीचीन" :'JJ',
"असमूचा" :'JJ',
"असमृद्ध" :'JJ',
"असमृद्धिदायक" :'JJ',
"असमृद्धिदायी" :'JJ',
"असमृद्धिप्रद" :'JJ',
"असमृद्धिप्रदायक" :'JJ',
"असमृद्धिप्रदायी" :'JJ',
"असम्पन्न" :'JJ',
"असम्पूर्ण" :'JJ',
"असम्प्राप्य" :'JJ',
"असम्बद्ध" :'JJ',
"असम्बन्धित" :'JJ',
"असम्भव" :'JJ',
"असम्भार" :'JJ',
"असम्भावनीय" :'JJ',
"असम्भावित" :'JJ',
"असम्भावी" :'JJ',
"असम्भाव्य" :'JJ',
"असम्भाष्य" :'JJ',
"असम्मत" :'JJ',
"असम्माननीय" :'JJ',
"असम्मानित" :'JJ',
"असम्मुख" :'JJ',
"असंयत" :'JJ',
"असंयमी" :'JJ',
"असयाना" :'JJ',
"असंयुक्त" :'JJ',
"असंयोजित" :'JJ',
"असरकारक" :'JJ',
"असंरक्षित" :'JJ',
"असरदार" :'JJ',
"असरन" :'JJ',
"असरशून्य" :'JJ',
"असरहीन" :'JJ',
"असंरुद्ध" :'JJ',
"असल" :'JJ',
"असंलग्न" :'JJ',
"असली" :'JJ',
"असलील" :'JJ',
"असवर्ण" :'JJ',
"असंवित" :'JJ',
"असंविधानिक" :'JJ',
"असंविधानीय" :'JJ',
"असंवेदनशील" :'JJ',
"असंवेदी" :'JJ',
"असंवेद्य" :'JJ',
"असंवैधानिक" :'JJ',
"असंशयात्मक" :'JJ',
"असंशोधित" :'JJ',
"असंश्लिष्ट" :'JJ',
"असंसक्त" :'JJ',
"असंसर्गजन्य" :'JJ',
"असंसारी" :'JJ',
"असंसिद्ध" :'JJ',
"असंसूचित" :'JJ',
"असंसृष्ट" :'JJ',
"असंस्कारित" :'JJ',
"असंस्कृत" :'JJ',
"असंस्तुत" :'JJ',
"असंस्थित" :'JJ',
"असह" :'JJ',
"असहज" :'JJ',
"असंहत" :'JJ',
"असहन" :'JJ',
"असहनशील" :'JJ',
"असहनीय" :'JJ',
"असहमत" :'JJ',
"असहाय" :'JJ',
"असहायता प्राप्त" :'JJ',
"असहाय्य" :'JJ',
"असहिष्णु" :'JJ',
"असही" :'JJ',
"असह्य" :'JJ',
"असाई" :'JJ',
"असाच" :'JJ',
"असाढ़ी" :'JJ',
"असाढ़ीय" :'JJ',
"असात्म्य" :'JJ',
"असाधारण" :'JJ',
"असाधु" :'JJ',
"असाध्य" :'JJ',
"असांप्रदायिक" :'JJ',
"असामंजस्य" :'JJ',
"असामंजस्यपूर्ण" :'JJ',
"असामयिक" :'JJ',
"असामाजिक" :'JJ',
"असामान्य" :'JJ',
"असार" :'JJ',
"असावधान" :'JJ',
"असांविधानिक" :'JJ',
"असांसद" :'JJ',
"असाहसिक" :'JJ',
"असित" :'JJ',
"असितांग" :'JJ',
"असिताङ्ग" :'JJ',
"असित्वहीन" :'JJ',
"असिद्ध" :'JJ',
"असिधारी" :'JJ',
"असिपाणि" :'JJ',
"असिस्टेंट" :'JJ',
"असीम" :'JJ',
"असीमांकित" :'JJ',
"असीमित" :'JJ',
"असुकर" :'JJ',
"असुखी" :'JJ',
"असुगम" :'JJ',
"असुचि" :'JJ',
"असुंदर" :'JJ',
"असुप्त" :'JJ',
"असुरक्षित" :'JJ',
"असुरक्ष्य" :'JJ',
"असुरीय" :'JJ',
"असुलभ" :'JJ',
"असुविधाजनक" :'JJ',
"असुविधापूर्ण" :'JJ',
"असूचित" :'JJ',
"असूझ" :'JJ',
"असूत" :'JJ',
"असूयक" :'JJ',
"असूर्यपश्य" :'JJ',
"असूर्यपश्या" :'JJ',
"असूल" :'JJ',
"असेव्य" :'JJ',
"असैनिक" :'JJ',
"असैन्य" :'JJ',
"असोक" :'JJ',
"असोकी" :'JJ',
"असोच" :'JJ',
"असोस" :'JJ',
"असौम्य" :'JJ',
"अस्खलित" :'JJ',
"अस्त" :'JJ',
"अस्त-व्यस्त" :'JJ',
"अस्तगत" :'JJ',
"अस्तंगत" :'JJ',
"अस्तमित" :'JJ',
"अस्तव्यस्त" :'JJ',
"अस्तित्ववादी" :'JJ',
"अस्तित्वहीन" :'JJ',
"अस्त्रघला" :'JJ',
"अस्त्रधारी" :'JJ',
"अस्त्राहत" :'JJ',
"अस्त्रीय" :'JJ',
"अस्थाई" :'JJ',
"अस्थायी" :'JJ',
"अस्थावर" :'JJ',
"अस्थि निर्मित" :'JJ',
"अस्थिनिर्मित" :'JJ',
"अस्थिमय" :'JJ',
"अस्थिर" :'JJ',
"अस्थिरचित्त" :'JJ',
"अस्थिशेष" :'JJ',
"अस्थिहीन" :'JJ',
"अस्थूल" :'JJ',
"अस्निग्ध" :'JJ',
"अस्पर्शित" :'JJ',
"अस्पष्ट" :'JJ',
"अस्पृश्य" :'JJ',
"अस्पृष्ट" :'JJ',
"अस्पृह" :'JJ',
"अस्फुट" :'JJ',
"अस्फूर्त" :'JJ',
"अस्मरणीय" :'JJ',
"अस्मित" :'JJ',
"अस्वच्छ" :'JJ',
"अस्वतंत्र" :'JJ',
"अस्वतन्त्र" :'JJ',
"अस्वस्थ" :'JJ',
"अस्वादिष्ट" :'JJ',
"अस्वादु" :'JJ',
"अस्वाभाविक" :'JJ',
"अस्वाभिमानी" :'JJ',
"अस्वार्थ" :'JJ',
"अस्वास्थ्यकर" :'JJ',
"अस्वास्थ्यवर्द्धक" :'JJ',
"अस्वास्थ्यवर्धक" :'JJ',
"अस्वीकरणीय" :'JJ',
"अस्वीकार कर्ता" :'JJ',
"अस्वीकार कर्त्ता" :'JJ',
"अस्वीकारात्मक" :'JJ',
"अस्वीकार्य" :'JJ',
"अस्वीकृत" :'JJ',
"अस्सी" :'JJ',
"अस्सीवाँ" :'JJ',
"अहंकाररहित" :'JJ',
"अहंकारशून्य" :'JJ',
"अहंकारहीन" :'JJ',
"अहंकारी" :'JJ',
"अहङ्कारी" :'JJ',
"अहदी" :'JJ',
"अहम" :'JJ',
"अहमक" :'JJ',
"अहमक़" :'JJ',
"अहरणीय" :'JJ',
"अहर्ष" :'JJ',
"अहर्षित" :'JJ',
"अहल्य" :'JJ',
"अहल्या" :'JJ',
"अहवनीय" :'JJ',
"अहसानफरामोश" :'JJ',
"अहसानफ़रामोश" :'JJ',
"अहसानमंद" :'JJ',
"अहस्ताक्षरित" :'JJ',
"अहार्य" :'JJ',
"अहितकर" :'JJ',
"अहितकारक" :'JJ',
"अहितकारी" :'JJ',
"अहिवाती" :'JJ',
"अहिंसक" :'JJ',
"अहिंसावादी" :'JJ',
"अहिंस्त" :'JJ',
"अहिंस्र" :'JJ',
"अहीन" :'JJ',
"अहीनवादी" :'JJ',
"अहुठ" :'JJ',
"अहुत" :'JJ',
"अहृदय" :'JJ',
"अहेड़" :'JJ',
"अहेतु" :'JJ',
"अहेतुक" :'JJ',
"आइंदा" :'JJ',
"आइन्दा" :'JJ',
"आइरिश" :'JJ',
"आइसलैंडी" :'JJ',
"आइसलैण्डी" :'JJ',
"आईनी" :'JJ',
"आउट" :'JJ',
"आउट आफ डेट" :'JJ',
"आउटडेटेड" :'JJ',
"आऊट" :'JJ',
"आकंपित" :'JJ',
"आकबत-अंदेश" :'JJ',
"आक़बत-अंदेश" :'JJ',
"आकबतअंदेश" :'JJ',
"आक़बतअंदेश" :'JJ',
"आकम्पित" :'JJ',
"आकर" :'JJ',
"आँकर" :'JJ',
"आकर्ण" :'JJ',
"आकर्णित" :'JJ',
"आकर्षक" :'JJ',
"आकर्षित" :'JJ',
"आकलनीय" :'JJ',
"आकलित" :'JJ',
"आकस्मिक" :'JJ',
"आकांक्षक" :'JJ',
"आकांक्षाहीन" :'JJ',
"आकांक्षित" :'JJ',
"आकांक्षी" :'JJ',
"आकार प्रदत्त" :'JJ',
"आकारयुक्त" :'JJ',
"आकारवान" :'JJ',
"आकारविहीन" :'JJ',
"आकारहीन" :'JJ',
"आकारांत" :'JJ',
"आकारान्त" :'JJ',
"आकारित" :'JJ',
"आकारी" :'JJ',
"आकालिक" :'JJ',
"आकाश-वृत्ति" :'JJ',
"आकाश-वृत्तिक" :'JJ',
"आकाशगामी" :'JJ',
"आकाशचर" :'JJ',
"आकाशचारी" :'JJ',
"आकाशभेदी" :'JJ',
"आकाशवृत्ति" :'JJ',
"आकाशवृत्तिक" :'JJ',
"आकाशी" :'JJ',
"आकाशीय" :'JJ',
"आकिल" :'JJ',
"आकीर्ण" :'JJ',
"आकुंचनीय" :'JJ',
"आकुंचित" :'JJ',
"आकुञ्चनीय" :'JJ',
"आकुञ्चित" :'JJ',
"आकुंठित" :'JJ',
"आकुण्ठित" :'JJ',
"आकुल" :'JJ',
"आकुलित" :'JJ',
"आकुलीभत" :'JJ',
"आकृतिहीन" :'JJ',
"आकृष्ट" :'JJ',
"आकृष्यमाण" :'JJ',
"आकोशित" :'JJ',
"आक्रंदित" :'JJ',
"आक्रन्दित" :'JJ',
"आक्रमण कर्ता" :'JJ',
"आक्रमण कर्त्ता" :'JJ',
"आक्रमणकारी" :'JJ',
"आक्रमणीय" :'JJ',
"आक्रमित" :'JJ',
"आक्रांत" :'JJ',
"आक्रांतरहित" :'JJ',
"आक्रांता" :'JJ',
"आक्रान्त" :'JJ',
"आक्रान्ता" :'JJ',
"आक्रामक" :'JJ',
"आक्रामकतापूर्ण" :'JJ',
"आक्रुष्ट" :'JJ',
"आक्लांत" :'JJ',
"आक्लान्त" :'JJ',
"आक्लिन्न" :'JJ',
"आक्ष" :'JJ',
"आक्षिक" :'JJ',
"आक्षिप्त" :'JJ',
"आक्षेपक" :'JJ',
"आक्षेपी" :'JJ',
"आख़ता" :'JJ',
"आँखफोड़टिड्डा" :'JJ',
"आंखफोड़टिड्डा" :'JJ',
"आखरी" :'JJ',
"आख़री" :'JJ',
"आखा" :'JJ',
"आखिर" :'JJ',
"आख़िर" :'JJ',
"आखिरी" :'JJ',
"आख़िरी" :'JJ',
"आखेट्य" :'JJ',
"आखोर" :'JJ',
"आख्यात" :'JJ',
"आख्यातव्य" :'JJ',
"आख्यापक" :'JJ',
"आख्यायक" :'JJ',
"आख्येय" :'JJ',
"आग बबूला" :'JJ',
"आगत" :'JJ',
"आगंतुक" :'JJ',
"आगनिक" :'JJ',
"आगन्तुक" :'JJ',
"आगम" :'JJ',
"आगमजानी" :'JJ',
"आगमज्ञानी" :'JJ',
"आगमनशील" :'JJ',
"आगमसोची" :'JJ',
"आगमापायी" :'JJ',
"आगमित" :'JJ',
"आगर" :'JJ',
"आगल" :'JJ',
"आगला" :'JJ',
"आगामी" :'JJ',
"आगाह" :'JJ',
"आँगिक" :'JJ',
"आंगिक" :'JJ',
"आँगिरस" :'JJ',
"आंगिरस" :'JJ',
"आगिल" :'JJ',
"आगे का" :'JJ',
"आग्नेय" :'JJ',
"आग्रस्त" :'JJ',
"आग्रहकर्ता" :'JJ',
"आग्रहकर्त्ता" :'JJ',
"आग्रही" :'JJ',
"आग्राहक" :'JJ',
"आघर्षित" :'JJ',
"आघात वर्धनीय" :'JJ',
"आघूर्ण" :'JJ',
"आघूर्णित" :'JJ',
"आघ्रात" :'JJ',
"आचमनीय" :'JJ',
"आचमनीयक" :'JJ',
"आचमित" :'JJ',
"आचरजित" :'JJ',
"आचरणीय" :'JJ',
"आचरित" :'JJ',
"आँचलिक" :'JJ',
"आंचलिक" :'JJ',
"आंचलीय" :'JJ',
"आचारभ्रष्ट" :'JJ',
"आचारवान" :'JJ',
"आचारवान्" :'JJ',
"आचारहीन" :'JJ',
"आचारित" :'JJ',
"आचारी" :'JJ',
"आचार्यी" :'JJ',
"आचार्य्यी" :'JJ',
"आचित" :'JJ',
"आचिंत्य" :'JJ',
"आचिन्त्य" :'JJ',
"आच्छन्न" :'JJ',
"आच्छादक" :'JJ',
"आच्छादित" :'JJ',
"आच्छाद्य" :'JJ',
"आच्छिन्न" :'JJ',
"आज का" :'JJ',
"आजम" :'JJ',
"आज़म" :'JJ',
"आजमाया" :'JJ',
"आजमीढ़" :'JJ',
"आजमूद" :'JJ',
"आज़मूद" :'JJ',
"आजमूदा" :'JJ',
"आज़मूदा" :'JJ',
"आजमूदाकार" :'JJ',
"आज़मूदाकार" :'JJ',
"आजवह" :'JJ',
"आजाद" :'JJ',
"आज़ाद" :'JJ',
"आजादाना" :'JJ',
"आजानु" :'JJ',
"आजानुबाहु" :'JJ',
"आजिज" :'JJ',
"आजिज़" :'JJ',
"आजीविकाहीन" :'JJ',
"आजुर्दा" :'JJ',
"आज़ुर्दा" :'JJ',
"आज्ञप्त" :'JJ',
"आज्ञा पालक" :'JJ',
"आज्ञाकारी" :'JJ',
"आज्ञात्मक" :'JJ',
"आज्ञानुगामी" :'JJ',
"आज्ञानुसार" :'JJ',
"आज्ञापक" :'JJ',
"आज्ञापालक" :'JJ',
"आज्ञापित" :'JJ',
"आज्ञापूर्ण" :'JJ',
"आज्ञावह" :'JJ',
"आटविक" :'JJ',
"आठ" :'JJ',
"आठगुना" :'JJ',
"आठवाँ" :'JJ',
"आठवां" :'JJ',
"आठेक" :'JJ',
"आडंबरपूर्ण" :'JJ',
"आडंबरी" :'JJ',
"आडम्बरी" :'JJ',
"आड़ा" :'JJ',
"आड़ा तिरछा" :'JJ',
"आड़ा-तिरछा" :'JJ',
"आड़ा-बेड़ा" :'JJ',
"आँडू" :'JJ',
"आंडू" :'JJ',
"आढ़" :'JJ',
"आढ़ती" :'JJ',
"आढ्य" :'JJ',
"आढ्यंकर" :'JJ',
"आढ्यङ्कर" :'JJ',
"आणक" :'JJ',
"आणविक" :'JJ',
"आतंकपूर्ण" :'JJ',
"आतंकवादी" :'JJ',
"आतंकित" :'JJ',
"आतंकी" :'JJ',
"आतताई" :'JJ',
"आततायी" :'JJ',
"आतपशुष्क" :'JJ',
"आतपी" :'JJ',
"आतप्त" :'JJ',
"आंतरिक" :'JJ',
"आतशी" :'JJ',
"आतिथ्यपूर्ण" :'JJ',
"आतिथ्यशील" :'JJ',
"आतिवाहिक" :'JJ',
"आतिशी" :'JJ',
"आतुर" :'JJ',
"आत्त" :'JJ',
"आत्तलक्ष्मी" :'JJ',
"आत्म" :'JJ',
"आत्म वंचक" :'JJ',
"आत्म विषयक" :'JJ',
"आत्म-केंद्रित" :'JJ',
"आत्म-केन्द्रित" :'JJ',
"आत्म-योनि" :'JJ',
"आत्म-वंचक" :'JJ',
"आत्म-संबंधी" :'JJ',
"आत्म-संभव" :'JJ',
"आत्म-सम्भव" :'JJ',
"आत्मक" :'JJ',
"आत्मकथात्मक" :'JJ',
"आत्मकाम" :'JJ',
"आत्मकृत" :'JJ',
"आत्मकेंद्रित" :'JJ',
"आत्मकेन्द्रित" :'JJ',
"आत्मगत" :'JJ',
"आत्मगुप्त" :'JJ',
"आत्मग्राही" :'JJ',
"आत्मघातक" :'JJ',
"आत्मघाती" :'JJ',
"आत्मज" :'JJ',
"आत्मजनीय" :'JJ',
"आत्मजात" :'JJ',
"आत्मज्ञानी" :'JJ',
"आत्मतुष्ट" :'JJ',
"आत्मतुष्टि" :'JJ',
"आत्मतृप्त" :'JJ',
"आत्मत्यागी" :'JJ',
"आत्मदर्शी" :'JJ',
"आत्मदानी" :'JJ',
"आत्मद्रष्टा" :'JJ',
"आत्मद्रोही" :'JJ',
"आत्मनिग्रही" :'JJ',
"आत्मनिरीक्षक" :'JJ',
"आत्मनिर्भर" :'JJ',
"आत्मनिष्ठ" :'JJ',
"आत्मपरक" :'JJ',
"आत्मप्रशंसक" :'JJ',
"आत्मभव" :'JJ',
"आत्मभू" :'JJ',
"आत्मरत" :'JJ',
"आत्मरहित" :'JJ',
"आत्मलीन" :'JJ',
"आत्मवंचक" :'JJ',
"आत्मवश" :'JJ',
"आत्मविश्वासी" :'JJ',
"आत्मश्लाघी" :'JJ',
"आत्मसंतुष्ट" :'JJ',
"आत्मसंभव" :'JJ',
"आत्मसमुद्भव" :'JJ',
"आत्मसम्भव" :'JJ',
"आत्मसात" :'JJ',
"आत्मसात्" :'JJ',
"आत्महन" :'JJ',
"आत्मा विषयक" :'JJ',
"आत्मानुशासी" :'JJ',
"आत्माभिमानी" :'JJ',
"आत्माभिमुखी" :'JJ',
"आत्मारहित" :'JJ',
"आत्मावलंबिनी" :'JJ',
"आत्मावलंबी" :'JJ',
"आत्मावलम्बी" :'JJ',
"आत्मिक" :'JJ',
"आत्मीकृत" :'JJ',
"आत्मीय" :'JJ',
"आत्म्य" :'JJ',
"आत्यंतिक" :'JJ',
"आत्यन्तिक" :'JJ',
"आंत्रिक" :'JJ',
"आंत्रीय" :'JJ',
"आत्रेय" :'JJ',
"आथराइज्ड" :'JJ',
"आदत्त" :'JJ',
"आदमकद" :'JJ',
"आदमक़द" :'JJ',
"आदमखोर" :'JJ',
"आदमख़ोर" :'JJ',
"आदरणीय" :'JJ',
"आदरणीया" :'JJ',
"आदर्य" :'JJ',
"आदर्श" :'JJ',
"आदर्शवादी" :'JJ',
"आदर्शित" :'JJ',
"आदाता" :'JJ',
"आदाय" :'JJ',
"आदायाद" :'JJ',
"आदि" :'JJ',
"आदिकालीन" :'JJ',
"आदिप्त" :'JJ',
"आदिम" :'JJ',
"आदिल" :'JJ',
"आदिवासी" :'JJ',
"आदिवासीय" :'JJ',
"आदिष्ट" :'JJ',
"आदी" :'JJ',
"आदीपक" :'JJ',
"आदीपित" :'JJ',
"आदृत" :'JJ',
"आदेय" :'JJ',
"आदेशक" :'JJ',
"आदेशपूर्ण" :'JJ',
"आदेशरहित" :'JJ',
"आदेशात्मक" :'JJ',
"आदेशित" :'JJ',
"आंदोलनकारी" :'JJ',
"आंदोलित" :'JJ',
"आद्य" :'JJ',
"आद्याक्षरित" :'JJ',
"आद्यांत" :'JJ',
"आद्यान्त" :'JJ',
"आद्योपांत" :'JJ',
"आद्र" :'JJ',
"आध" :'JJ',
"आँधर" :'JJ',
"आँधरा" :'JJ',
"आधर्षित" :'JJ',
"आधा" :'JJ',
"आधा अधूरा" :'JJ',
"आधा पागल" :'JJ',
"आधा सम्मत" :'JJ',
"आधा सहमत" :'JJ',
"आधा-अधूरा" :'JJ',
"आधानवती" :'JJ',
"आधार" :'JJ',
"आधारभूत" :'JJ',
"आधाररहित" :'JJ',
"आधारहीन" :'JJ',
"आधारिक" :'JJ',
"आधारित" :'JJ',
"आधारी" :'JJ',
"आधिक" :'JJ',
"आधिकरणिक" :'JJ',
"आधिकारिक" :'JJ',
"आधिदैविक" :'JJ',
"आधिभौतिक" :'JJ',
"आँधी" :'JJ',
"आंधी" :'JJ',
"आधीन" :'JJ',
"आधुनिक" :'JJ',
"आधुनिकतम" :'JJ',
"आधूत" :'JJ',
"आधूत़" :'JJ',
"आधृत" :'JJ',
"आधेक" :'JJ',
"आधेय" :'JJ',
"आन" :'JJ',
"आनत" :'JJ',
"आनंद-दायक" :'JJ',
"आनंदक" :'JJ',
"आनंदकर" :'JJ',
"आनंदकारी" :'JJ',
"आनंददायक" :'JJ',
"आनंददायी" :'JJ',
"आनंदपूर्ण" :'JJ',
"आनंदप्रद" :'JJ',
"आनंदमय" :'JJ',
"आनंदित" :'JJ',
"आनंदी" :'JJ',
"आनद्ध" :'JJ',
"आनन्दक" :'JJ',
"आनन्दकर" :'JJ',
"आनन्दकारी" :'JJ',
"आनन्ददायक" :'JJ',
"आनन्ददायी" :'JJ',
"आनन्दप्रद" :'JJ',
"आनन्दित" :'JJ',
"आनन्दी" :'JJ',
"आनर्त्तक" :'JJ',
"आनलाइन" :'JJ',
"आनीजानी" :'JJ',
"आनुपातिक" :'JJ',
"आनुपूर्वी" :'JJ',
"आनुभविक" :'JJ',
"आनुमानिक" :'JJ',
"आनुवंशिक" :'JJ',
"आनुवांशिक" :'JJ',
"आनुवृत्तिक" :'JJ',
"आनुषंगिक" :'JJ',
"आनुषङ्गिक" :'JJ',
"आनुष्ठानिक" :'JJ',
"आनेवाला" :'JJ',
"आन्तरिक" :'JJ',
"आन्दोलनकारी" :'JJ',
"आन्दोलित" :'JJ',
"आपक" :'JJ',
"आपत्कालिक" :'JJ',
"आपत्कालीन" :'JJ',
"आपत्तिजनक" :'JJ',
"आपत्य" :'JJ',
"आपदग्रस्त" :'JJ',
"आपदाग्रस्त" :'JJ',
"आपद्ग्रस्त" :'JJ',
"आपन्न" :'JJ',
"आपराधिक" :'JJ',
"आपराह्निक" :'JJ',
"आपवर्ग्य" :'JJ',
"आपवादिक" :'JJ',
"आपसी" :'JJ',
"आपात" :'JJ',
"आपातकालीन" :'JJ',
"आपातिक" :'JJ',
"आपाती" :'JJ',
"आपापंथी" :'JJ',
"आपापन्थी" :'JJ',
"आपायत" :'JJ',
"आपूर" :'JJ',
"आपूर्ण" :'JJ',
"आपेक्षिक" :'JJ',
"आप्त" :'JJ',
"आप्तकाम" :'JJ',
"आप्य" :'JJ',
"आप्यायित" :'JJ',
"आप्रच्छन्न" :'JJ',
"आप्रवासी" :'JJ',
"आप्लावित" :'JJ',
"आप्लुत" :'JJ',
"आफताबी" :'JJ',
"आफ़ताबी" :'JJ',
"आबंटित" :'JJ',
"आबदार" :'JJ',
"आबद्ध" :'JJ',
"आबनूसी" :'JJ',
"आबाद" :'JJ',
"आबी" :'JJ',
"आब्दिक" :'JJ',
"आभरित" :'JJ',
"आभारक" :'JJ',
"आभारी" :'JJ',
"आभास्वर" :'JJ',
"आभाहीन" :'JJ',
"आभूषित" :'JJ',
"आभ्यंतर" :'JJ',
"आभ्यंतरिक" :'JJ',
"आभ्यन्तर" :'JJ',
"आभ्यन्तरिक" :'JJ',
"आभ्युदयिक" :'JJ',
"आम" :'JJ',
"आमंत्रित" :'JJ',
"आमन्त्रित" :'JJ',
"आमादा" :'JJ',
"आमिन" :'JJ',
"आमिषाशी" :'JJ',
"आमिषाहारी" :'JJ',
"आमुदित" :'JJ',
"आमुष्मिक" :'JJ',
"आमूल" :'JJ',
"आमेज़" :'JJ',
"आमोख़्ता" :'JJ',
"आमोद-प्रमोदपूर्ण" :'JJ',
"आमोदित" :'JJ',
"आमोदी" :'JJ',
"आयं-बायं" :'JJ',
"आयत" :'JJ',
"आयताकार" :'JJ',
"आयत्त" :'JJ',
"आयद" :'JJ',
"आयंदा" :'JJ',
"आयन्दा" :'JJ',
"आयंबायं" :'JJ',
"आयरलैंडी" :'JJ',
"आयरलैण्डी" :'JJ',
"आयरिश" :'JJ',
"आयव्ययकीय" :'JJ',
"आयसी" :'JJ',
"आया" :'JJ',
"आया हुआ" :'JJ',
"आयाचित" :'JJ',
"आयात" :'JJ',
"आयातक" :'JJ',
"आयातित" :'JJ',
"आयामयुक्त" :'JJ',
"आयामी" :'JJ',
"आयीता" :'JJ',
"आयुक्त" :'JJ',
"आयुत" :'JJ',
"आयुर्वेदिक" :'JJ',
"आयुर्वेदीय" :'JJ',
"आयुष्कर" :'JJ',
"आयुष्कार" :'JJ',
"आयुष्मान" :'JJ',
"आयुष्मान्" :'JJ',
"आयोजित" :'JJ',
"आरक्त" :'JJ',
"आरक्षिक" :'JJ',
"आरक्षित" :'JJ',
"आरज" :'JJ',
"आरजूमंद" :'JJ',
"आरण्य" :'JJ',
"आरण्यक" :'JJ',
"आरण्यवासी" :'JJ',
"आरब्ध" :'JJ',
"आरंभ कर्ता" :'JJ',
"आरंभ कर्त्ता" :'JJ',
"आरंभक" :'JJ',
"आरंभहीन" :'JJ',
"आरंभिक" :'JJ',
"आरंभी" :'JJ',
"आरम्भ कर्ता" :'JJ',
"आरम्भ कर्त्ता" :'JJ',
"आरम्भक" :'JJ',
"आरम्भिक" :'JJ',
"आरम्भी" :'JJ',
"आरष" :'JJ',
"आरषी" :'JJ',
"आराइशी" :'JJ',
"आराधक" :'JJ',
"आराधनीय" :'JJ',
"आराधित" :'JJ',
"आराधिता" :'JJ',
"आराधी" :'JJ',
"आराध्य" :'JJ',
"आराध्यमान" :'JJ',
"आरामतलब" :'JJ',
"आरामदायक" :'JJ',
"आरामदेय" :'JJ',
"आरामदेह" :'JJ',
"आरास्ता" :'JJ',
"आरूढ़" :'JJ',
"आरूपित" :'JJ',
"आरोग" :'JJ',
"आरोग्य" :'JJ',
"आरोग्यप्रद" :'JJ',
"आरोधक" :'JJ',
"आरोधनीय" :'JJ',
"आरोप मुक्त" :'JJ',
"आरोपक" :'JJ',
"आरोपित" :'JJ',
"आरोपी" :'JJ',
"आरोप्य" :'JJ',
"आरोहक" :'JJ',
"आरोहित" :'JJ',
"आरोही" :'JJ',
"आर्ग्रस्त" :'JJ',
"आर्टिफिशल" :'JJ',
"आर्टिफेशल" :'JJ',
"आर्टीफिशल" :'JJ',
"आर्टीफेशल" :'JJ',
"आर्त" :'JJ',
"आर्त्त" :'JJ',
"आर्त्तव" :'JJ',
"आर्त्त्विज" :'JJ',
"आर्थ" :'JJ',
"आर्थिक" :'JJ',
"आर्थी" :'JJ',
"आर्थोपीडिक" :'JJ',
"आर्थोपीडीक" :'JJ',
"आर्द्र" :'JJ',
"आर्य" :'JJ',
"आर्य जातीय" :'JJ',
"आर्यसमाजी" :'JJ',
"आर्ष" :'JJ',
"आल" :'JJ',
"आल-जाल" :'JJ',
"आलंकारिक" :'JJ',
"आलङ्कारिक" :'JJ',
"आलजाल" :'JJ',
"आलतू-फालतू" :'JJ',
"आलतू-फ़ालतू" :'JJ',
"आलंबनहीन" :'JJ',
"आलंबित" :'JJ',
"आलंभी" :'JJ',
"आलमी" :'JJ',
"आलम्बनहीन" :'JJ',
"आलम्बित" :'JJ',
"आलम्भी" :'JJ',
"आलराउंडर" :'JJ',
"आलराउन्डर" :'JJ',
"आलसहीन" :'JJ',
"आलसी" :'JJ',
"आलस्य भरा" :'JJ',
"आलस्यपूर्ण" :'JJ',
"आलस्ययुक्त" :'JJ',
"आलस्यहीन" :'JJ',
"आला" :'JJ',
"आलापक" :'JJ',
"आलापनीय" :'JJ',
"आलापित" :'JJ',
"आलापी" :'JJ',
"आलारासी" :'JJ',
"आलिंगित" :'JJ',
"आलिङ्गित" :'JJ',
"आलिम" :'JJ',
"आली" :'JJ',
"आलीजाह" :'JJ',
"आलीशान" :'JJ',
"आलूदा" :'JJ',
"आलेख्य" :'JJ',
"आलोकनीय" :'JJ',
"आलोकहीन" :'JJ',
"आलोकित" :'JJ',
"आलोचनात्मक" :'JJ',
"आलोचित" :'JJ',
"आलोच्य" :'JJ',
"आलोड़ित" :'JJ',
"आलोल" :'JJ',
"आलोलित" :'JJ',
"आवंटित" :'JJ',
"आवंत्य" :'JJ',
"आवधिक" :'JJ',
"आवनेय" :'JJ',
"आवन्त्य" :'JJ',
"आवरणरहित" :'JJ',
"आवरणहीन" :'JJ',
"आवर्जित" :'JJ',
"आवर्तक" :'JJ',
"आवर्तनीय" :'JJ',
"आवर्तित" :'JJ',
"आवर्ती" :'JJ',
"आवर्त्तक" :'JJ',
"आवर्त्तनीय" :'JJ',
"आवर्त्तित" :'JJ',
"आवर्त्ती" :'JJ',
"आवर्दा" :'JJ',
"आवलित" :'JJ',
"आवश्यक" :'JJ',
"आवश्यकीय" :'JJ',
"आवसथ्य" :'JJ',
"आवह" :'JJ',
"आवारा" :'JJ',
"आवारागर्द" :'JJ',
"आवारिस" :'JJ',
"आवासहीन" :'JJ',
"आवासिक" :'JJ',
"आवासित" :'JJ',
"आवासीय" :'JJ',
"आविक" :'JJ',
"आविद्ध" :'JJ',
"आविर्भूत" :'JJ',
"आविल" :'JJ',
"आविष्कारशील" :'JJ',
"आविष्कारित" :'JJ',
"आविष्कृत" :'JJ',
"आविष्ट" :'JJ',
"आवीती" :'JJ',
"आवृत" :'JJ',
"आवृत्त" :'JJ',
"आवेदक" :'JJ',
"आवेदन कर्ता" :'JJ',
"आवेदन कर्त्ता" :'JJ',
"आवेदनीय" :'JJ',
"आवेदित" :'JJ',
"आवेदी" :'JJ',
"आवेद्य" :'JJ',
"आवेशग्रस्त" :'JJ',
"आवेशपूर्ण" :'JJ',
"आवेशित" :'JJ',
"आवेष्टित" :'JJ',
"आशंकापूर्ण" :'JJ',
"आशंकाहीन" :'JJ',
"आशंकित" :'JJ',
"आशङ्कापूर्ण" :'JJ',
"आशङ्कित" :'JJ',
"आशना" :'JJ',
"आशंसित" :'JJ',
"आशाजनक" :'JJ',
"आशाढ़ी" :'JJ',
"आशाढ़ीय" :'JJ',
"आशातीत" :'JJ',
"आशानुकूल" :'JJ',
"आशान्वित" :'JJ',
"आशापूर्ण" :'JJ',
"आशामुखी" :'JJ',
"आशावादी" :'JJ',
"आशावान" :'JJ',
"आशांवित" :'JJ',
"आशाहीन" :'JJ',
"आशिक" :'JJ',
"आशिक़" :'JJ',
"आंशिक" :'JJ',
"आशिकाना" :'JJ',
"आशिक़ाना" :'JJ',
"आशी" :'JJ',
"आशीर्वादी" :'JJ',
"आशुकारी" :'JJ',
"आशुकोपी" :'JJ',
"आशुग" :'JJ',
"आशुतोष" :'JJ',
"आश्चर्यचकित" :'JJ',
"आश्चर्यजनक" :'JJ',
"आश्चर्यपूर्ण" :'JJ',
"आश्चर्यभूत" :'JJ',
"आश्चर्यमय" :'JJ',
"आश्चर्यान्वित" :'JJ',
"आश्चर्यित" :'JJ',
"आश्रम-संबंधी" :'JJ',
"आश्रमवासी" :'JJ',
"आश्रमहीन" :'JJ',
"आश्रमी" :'JJ',
"आश्रय-दाता" :'JJ',
"आश्रयणीय" :'JJ',
"आश्रयदाता" :'JJ',
"आश्रयहीन" :'JJ',
"आश्रयी" :'JJ',
"आश्रित" :'JJ',
"आश्रिता" :'JJ',
"आश्रुत" :'JJ',
"आश्रेय" :'JJ',
"आश्लिष्ट" :'JJ',
"आश्व" :'JJ',
"आश्वमेधिक" :'JJ',
"आश्वसनीय" :'JJ',
"आश्वसित" :'JJ',
"आश्वस्त" :'JJ',
"आश्वस्य" :'JJ',
"आश्वासक" :'JJ',
"आश्वासनीय" :'JJ',
"आश्वासित" :'JJ',
"आश्वासी" :'JJ',
"आश्विनी" :'JJ',
"आषाढ़क" :'JJ',
"आषाढ़ी" :'JJ',
"आषाढ़ीय" :'JJ',
"आसकती" :'JJ',
"आसक्त" :'JJ',
"आसंजित" :'JJ',
"आसञ्जित" :'JJ',
"आसतोष" :'JJ',
"आसन्न" :'JJ',
"आसन्न प्रसवा" :'JJ',
"आसन्नप्रसवा" :'JJ',
"आसमान खोंचा" :'JJ',
"आसमान-खोंचा" :'JJ',
"आसमानी" :'JJ',
"आसरा" :'JJ',
"आसरैत" :'JJ',
"आसवित" :'JJ',
"आसाढ़ी" :'JJ',
"आसाढ़ीय" :'JJ',
"आसान" :'JJ',
"आसामी" :'JJ',
"आसिद्ध" :'JJ',
"आसीन" :'JJ',
"आसुग" :'JJ',
"आसुत" :'JJ',
"आसुर" :'JJ',
"आसुरी" :'JJ',
"आसूदा" :'JJ',
"आँसूरहित" :'JJ',
"आस्कंदी" :'JJ',
"आस्कन्दी" :'JJ',
"आस्ट्रियन" :'JJ',
"आस्ट्रियाई" :'JJ',
"आस्ट्रेलियन" :'JJ',
"आस्ट्रेलियाई" :'JJ',
"आस्तिक" :'JJ',
"आस्त्र" :'JJ',
"आस्थित" :'JJ',
"आस्मानी" :'JJ',
"आस्य" :'JJ',
"आस्रप" :'JJ',
"आस्राव" :'JJ',
"आस्वांत" :'JJ',
"आस्वादनीय" :'JJ',
"आस्वादित" :'JJ',
"आहत" :'JJ',
"आहतेदार" :'JJ',
"आहनी" :'JJ',
"आहरणीय" :'JJ',
"आहर्ता" :'JJ',
"आहवनी" :'JJ',
"आहारिक" :'JJ',
"आहारी" :'JJ',
"आहारीय" :'JJ',
"आहार्य" :'JJ',
"आहार्य्य" :'JJ',
"आहित" :'JJ',
"आहूत" :'JJ',
"आहृत" :'JJ',
"आह्न" :'JJ',
"आह्निक" :'JJ',
"आह्लादक" :'JJ',
"आह्लादित" :'JJ',
"आह्लादी" :'JJ',
"आह्वर" :'JJ',
"इक" :'JJ',
"इकइस" :'JJ',
"इकंग" :'JJ',
"इकचालीस" :'JJ',
"इकचालीसवाँ" :'JJ',
"इकटा" :'JJ',
"इकट्ठा" :'JJ',
"इकडाल" :'JJ',
"इकंत" :'JJ',
"इकतर" :'JJ',
"इकतरफा" :'JJ',
"इकतरफ़ा" :'JJ',
"इकतान" :'JJ',
"इकतार" :'JJ',
"इकतालीस" :'JJ',
"इकतालीसवाँ" :'JJ',
"इकतीस" :'JJ',
"इकतीसवाँ" :'JJ',
"इकत्तीस" :'JJ',
"इकत्र" :'JJ',
"इकबाली" :'JJ',
"इक़बाली" :'JJ',
"इकरारी" :'JJ',
"इक़रारी" :'JJ',
"इकलड़ा" :'JJ',
"इकलंत" :'JJ',
"इकला" :'JJ',
"इंकलाबी" :'JJ',
"इकलोई" :'JJ',
"इकलौता" :'JJ',
"इकल्ला" :'JJ',
"इकसठ" :'JJ',
"इकसठवाँ" :'JJ',
"इकसर" :'JJ',
"इकसरि" :'JJ',
"इकसार" :'JJ',
"इकसूत" :'JJ',
"इकहत्तर" :'JJ',
"इकहत्तरवाँ" :'JJ',
"इकहरा" :'JJ',
"इकांत" :'JJ',
"इकानवे" :'JJ',
"इकान्त" :'JJ',
"इकारांत" :'JJ',
"इकारान्त" :'JJ',
"इंकारी" :'JJ',
"इकावन" :'JJ',
"इकासी" :'JJ',
"इकासीवाँ" :'JJ',
"इकीस" :'JJ',
"इकीसवाँ" :'JJ',
"इकेला" :'JJ',
"इकैठ" :'JJ',
"इकोत्तर" :'JJ',
"इकौना" :'JJ',
"इकौसा" :'JJ',
"इकौंसा" :'JJ',
"इक्का" :'JJ',
"इक्का दुक्का" :'JJ',
"इक्का-दुक्का" :'JJ',
"इक्कानबे" :'JJ',
"इक्कानबेवाँ" :'JJ',
"इक्कानवे" :'JJ',
"इक्कानवेवाँ" :'JJ',
"इक्कावन" :'JJ',
"इक्कावनवाँ" :'JJ',
"इक्कावनवां" :'JJ',
"इक्कासी" :'JJ',
"इक्कासीवाँ" :'JJ',
"इक्कीस" :'JJ',
"इक्कीसवाँ" :'JJ',
"इक्बाली" :'JJ',
"इक़्बाली" :'JJ',
"इक्यानबे" :'JJ',
"इक्यानबेवाँ" :'JJ',
"इक्यानवे" :'JJ',
"इक्यानवेवाँ" :'JJ',
"इक्यावन" :'JJ',
"इक्यावनवाँ" :'JJ',
"इक्यावनवां" :'JJ',
"इक्यासी" :'JJ',
"इक्यासीवाँ" :'JJ',
"इक्षुज" :'JJ',
"इखद" :'JJ',
"इंगलिस्तानी" :'JJ',
"इगारह" :'JJ',
"इंगित" :'JJ',
"इग्यारह" :'JJ',
"इंग्लिश" :'JJ',
"इंग्लिस्तानी" :'JJ',
"इङ्गलिस्तानी" :'JJ',
"इङ्गित" :'JJ',
"इङ्ग्लिस्तानी" :'JJ',
"इच्छक" :'JJ',
"इच्छाचारी" :'JJ',
"इच्छापत्रहीन" :'JJ',
"इच्छापूर्ण" :'JJ',
"इच्छाभेदी" :'JJ',
"इच्छारहित" :'JJ',
"इच्छालु" :'JJ',
"इच्छाहीन" :'JJ',
"इच्छित" :'JJ',
"इच्छु" :'JJ',
"इच्छुक" :'JJ',
"इछु" :'JJ',
"इजमाली" :'JJ',
"इजराइली" :'JJ',
"इज़राइली" :'JJ',
"इजरायली" :'JJ',
"इजारदार" :'JJ',
"इजारेदार" :'JJ',
"इजिप्शियन" :'JJ',
"इज्जतदार" :'JJ',
"इज़्ज़तदार" :'JJ',
"इज़्राइली" :'JJ',
"इंटरनेट सर्विस प्रोवाइडर" :'JJ',
"इंटरनेट सेवा प्रदाता" :'JJ',
"इंटरनेट सेवा प्रदानकर्ता" :'JJ',
"इंटरनेशनल" :'JJ',
"इंटरनैशनल" :'JJ',
"इटालियन" :'JJ',
"इंडोनेशियन" :'JJ',
"इंडोनेशियाई" :'JJ',
"इतना" :'JJ',
"इतना सारा" :'JJ',
"इतमीनानी" :'JJ',
"इतर" :'JJ',
"इतरलिंगी" :'JJ',
"इतरलिंगीय" :'JJ',
"इतरेतर" :'JJ',
"इतरौहाँ" :'JJ',
"इतवरी" :'JJ',
"इतवारी" :'JJ',
"इंतहापसंद" :'JJ',
"इता" :'JJ',
"इतालवी" :'JJ',
"इतेक" :'JJ',
"इतो" :'JJ',
"इतौ" :'JJ',
"इत्तफाकिया" :'JJ',
"इत्तफ़ाक़िया" :'JJ',
"इत्ता" :'JJ',
"इत्तिफाकिया" :'JJ',
"इत्तिफ़ाक़िया" :'JJ',
"इत्तो" :'JJ',
"इत्थंभूत" :'JJ',
"इत्थंमेव" :'JJ',
"इत्मीनानी" :'JJ',
"इत्वर" :'JJ',
"इत्वरी" :'JJ',
"इथियोपियन" :'JJ',
"इथियोपियाई" :'JJ',
"इदानीतन" :'JJ',
"इंदु वदना" :'JJ',
"इंदु-वदना" :'JJ',
"इंदुवदना" :'JJ',
"इद्ध" :'JJ',
"इंद्र" :'JJ',
"इंद्र-कृष्ट" :'JJ',
"इंद्रक" :'JJ',
"इंद्रकृष्ट" :'JJ',
"इंद्रजालिक" :'JJ',
"इंद्रजाली" :'JJ',
"इंद्रजित" :'JJ',
"इंद्रजित्" :'JJ',
"इंद्रजीत" :'JJ',
"इंद्रधनुषी" :'JJ',
"इंद्रधनुषीय" :'JJ',
"इंद्रिय गोचर" :'JJ',
"इंद्रियगम्य" :'JJ',
"इंद्रियगोचर" :'JJ',
"इंद्रियग्राह्य" :'JJ',
"इंद्रियज" :'JJ',
"इंद्रियजित" :'JJ',
"इंद्रियजीत" :'JJ',
"इंद्रियनिग्रही" :'JJ',
"इंद्रियलोलुप" :'JJ',
"इंद्रियागोचर" :'JJ',
"इंद्रियातीत" :'JJ',
"इंद्रियाराम" :'JJ',
"इंद्रियारामी" :'JJ',
"इनकारी" :'JJ',
"इनसानी" :'JJ',
"इनसाफी" :'JJ',
"इनसाफ़ी" :'JJ',
"इना-गिना" :'JJ',
"इनागिना" :'JJ',
"इनामी" :'JJ',
"इनायती" :'JJ',
"इन्कलाबी" :'JJ',
"इन्कारी" :'JJ',
"इन्टरनेट सेवा प्रदाता" :'JJ',
"इन्टरनेट सेवा प्रदाता" :'JJ',
"इन्टरनेट सेवा प्रदानकर्ता" :'JJ',
"इन्टरनेशनल" :'JJ',
"इन्टरनैशनल" :'JJ',
"इन्तहापसन्द" :'JJ',
"इन्दु वदना" :'JJ',
"इन्दु-वदना" :'JJ',
"इन्दुवदना" :'JJ',
"इन्द्र" :'JJ',
"इन्द्र-कृष्ट" :'JJ',
"इन्द्रक" :'JJ',
"इन्द्रकृष्ट" :'JJ',
"इन्द्रजालिक" :'JJ',
"इन्द्रजाली" :'JJ',
"इन्द्रजित" :'JJ',
"इन्द्रजित्" :'JJ',
"इन्द्रजीत" :'JJ',
"इन्द्रधनुषी" :'JJ',
"इन्द्रधनुषीय" :'JJ',
"इन्द्रियगोचर" :'JJ',
"इन्द्रियज" :'JJ',
"इन्द्रियलोलुप" :'JJ',
"इन्द्रियागोचर" :'JJ',
"इन्द्रियाराम" :'JJ',
"इन्द्रियारामी" :'JJ',
"इन्फ्रारेड" :'JJ',
"इन्सानी" :'JJ',
"इन्साफी" :'JJ',
"इन्साफ़ी" :'JJ',
"इंपोर्टेड" :'JJ',
"इप्सु" :'JJ',
"इफरात" :'JJ',
"इफ़रात" :'JJ',
"इंफ्रारेड" :'JJ',
"इबरानी" :'JJ',
"इबारती" :'JJ',
"इब्तिदाई" :'JJ',
"इब्रानी" :'JJ',
"इमकान" :'JJ',
"इमदादी" :'JJ',
"इमरजेंसी" :'JJ',
"इमरतीदार" :'JJ',
"इमामी" :'JJ',
"इमामीय" :'JJ',
"इमारती" :'JJ',
"इम्पोर्टेड" :'JJ',
"इयारा" :'JJ',
"इरकली" :'JJ',
"इरषित" :'JJ',
"इराकी" :'JJ',
"इराक़ी" :'JJ',
"इलाही" :'JJ',
"इलाहीमुहर" :'JJ',
"इलेक्ट्रनिक" :'JJ',
"इलेक्ट्रानिक" :'JJ',
"इलेक्ट्रिक" :'JJ',
"इलेक्ट्रिकल" :'JJ',
"इलेक्ट्रॉनिक" :'JJ',
"इलेक्ट्रोनिक" :'JJ',
"इलेक्ट्रोमैगनेटिक" :'JJ',
"इलैक्ट्रानिक" :'JJ',
"इल्मी" :'JJ',
"इशतराकी" :'JJ',
"इशतिराकी" :'JJ',
"इश्किया" :'JJ',
"इश्क़िया" :'JJ',
"इश्की" :'JJ',
"इश्क़ी" :'JJ',
"इश्तराकी" :'JJ',
"इश्तहारी" :'JJ',
"इश्तिराकी" :'JJ',
"इश्तिहारी" :'JJ',
"इषित" :'JJ',
"इष्ट" :'JJ',
"इष्टकर" :'JJ',
"इस प्रकार का" :'JJ',
"इसके जैसा" :'JJ',
"इसके जैसा ही" :'JJ',
"इसपाती" :'JJ',
"इसराइली" :'JJ',
"इसराईली" :'JJ',
"इसरी" :'JJ',
"इसलामी" :'JJ',
"इसाई" :'JJ',
"इंसानी" :'JJ',
"इंसाफी" :'JJ',
"इंसाफ़ी" :'JJ',
"इसी तरह का" :'JJ',
"इसी प्रकार का" :'JJ',
"इसौ" :'JJ',
"इस्तमरारी" :'JJ',
"इस्तमालशुदा" :'JJ',
"इस्तेमाली" :'JJ',
"इस्पाती" :'JJ',
"इस्राइली" :'JJ',
"इस्लामिक" :'JJ',
"इस्लामी" :'JJ',
"इहलोकवादी" :'JJ',
"इहलौकिक" :'JJ',
"इहवादी" :'JJ',
"ईकारांत" :'JJ',
"ईकारादि" :'JJ',
"ईकारान्त" :'JJ',
"ईक्षित" :'JJ',
"ईजादी" :'JJ',
"ईठ" :'JJ',
"ईडित" :'JJ',
"ईड्य" :'JJ',
"ईंढ" :'JJ',
"ईढी" :'JJ',
"ईढ़ी" :'JJ',
"ईदृक्" :'JJ',
"ईदृश" :'JJ',
"ईदृश्" :'JJ',
"ईप्सित" :'JJ',
"ईमानदार" :'JJ',
"ईमानफ़रोश" :'JJ',
"ईमानी" :'JJ',
"ईरानियन" :'JJ',
"ईरानी" :'JJ',
"ईरित" :'JJ',
"ईर्षालु" :'JJ',
"ईर्षित" :'JJ',
"ईर्षी" :'JJ',
"ईर्षु" :'JJ',
"ईर्ष्य" :'JJ',
"ईर्ष्यक" :'JJ',
"ईर्ष्यमण" :'JJ',
"ईर्ष्यापूर्ण" :'JJ',
"ईर्ष्यालु" :'JJ',
"ईर्ष्याहीन" :'JJ',
"ईश निंदक" :'JJ',
"ईश निन्दक" :'JJ',
"ईश-निंदक" :'JJ',
"ईश-निन्दक" :'JJ',
"ईशान" :'JJ',
"ईश्वर परायण" :'JJ',
"ईश्वर-परायण" :'JJ',
"ईश्वरनिष्ठ" :'JJ',
"ईश्वरपरायण" :'JJ',
"ईश्वरप्रदत्त" :'JJ',
"ईश्वरवादी" :'JJ',
"ईश्वरहीन" :'JJ',
"ईश्वरी" :'JJ',
"ईश्वरीय" :'JJ',
"ईषत" :'JJ',
"ईषत्" :'JJ',
"ईषद" :'JJ',
"ईषदुष्ण" :'JJ',
"ईषद्" :'JJ',
"ईस" :'JJ',
"ईसरी" :'JJ',
"ईसवी" :'JJ',
"ईसा विषयक" :'JJ',
"ईसाई" :'JJ',
"ईहग" :'JJ',
"ईहित" :'JJ',
"उऋण" :'JJ',
"उकटा" :'JJ',
"उकठा" :'JJ',
"उकताऊ" :'JJ',
"उकताया" :'JJ',
"उकसाऊ" :'JJ',
"उकसौहाँ" :'JJ',
"उकसौंहाँ" :'JJ',
"उकारांत" :'JJ',
"उकारान्त" :'JJ',
"उँकारी" :'JJ',
"उक्त" :'JJ',
"उक्ष" :'JJ',
"उक्षित" :'JJ',
"उखड़ा" :'JJ',
"उखरैया" :'JJ',
"उखाड़नेवाला" :'JJ',
"उखाड़ा" :'JJ',
"उखाड़ू" :'JJ',
"उख्य" :'JJ',
"उगा" :'JJ',
"उगाहा" :'JJ',
"उगाहा हुआ" :'JJ',
"उग्र" :'JJ',
"उग्रपंथी" :'JJ',
"उग्रवादी" :'JJ',
"उग्रा" :'JJ',
"उघटा" :'JJ',
"उघड़ा" :'JJ',
"उघरा" :'JJ',
"उघरारा" :'JJ',
"उघाड़ा" :'JJ',
"उघाड़ी" :'JJ',
"उघारा" :'JJ',
"उचक्का" :'JJ',
"उचाट" :'JJ',
"उचाटू" :'JJ',
"उँचास" :'JJ',
"उंचास" :'JJ',
"उचित" :'JJ',
"उचिस्ट" :'JJ',
"उचौहाँ" :'JJ',
"उच्च" :'JJ',
"उच्च अधिकार" :'JJ',
"उच्च अधिकार प्राप्त" :'JJ',
"उच्च कुलीन" :'JJ',
"उच्च पदस्थ" :'JJ',
"उच्च पदासीन" :'JJ',
"उच्च मध्यम वर्गीय" :'JJ',
"उच्च वर्गीय" :'JJ',
"उच्च वंशीय" :'JJ',
"उच्च-स्तरीय" :'JJ',
"उच्चंड" :'JJ',
"उच्चण्ड" :'JJ',
"उच्चतम" :'JJ',
"उच्चपदस्थ" :'JJ',
"उच्चपदासीन" :'JJ',
"उच्चरित" :'JJ',
"उच्चस्तरीय" :'JJ',
"उच्चाकांक्षी" :'JJ',
"उच्चाटनीय" :'JJ',
"उच्चाटित" :'JJ',
"उच्चाधिकार" :'JJ',
"उच्चाधिकार प्राप्त" :'JJ',
"उच्चारणीय" :'JJ',
"उच्चारित" :'JJ',
"उच्चार्य" :'JJ',
"उच्चार्यमाण" :'JJ',
"उच्चित्र" :'JJ',
"उच्चैःश्रवा" :'JJ',
"उच्छन्न" :'JJ',
"उच्छल" :'JJ',
"उच्छवासी" :'JJ',
"उच्छिन्न" :'JJ',
"उच्छिष्ट" :'JJ',
"उच्छिष्ट भोजी" :'JJ',
"उच्छिष्ट-भोजी" :'JJ',
"उच्छिष्टभोजी" :'JJ',
"उच्छून" :'JJ',
"उच्छृंखल" :'JJ',
"उच्छृङ्खल" :'JJ',
"उच्छेतव्य" :'JJ',
"उच्छेदनीय" :'JJ',
"उच्छेदवादी" :'JJ',
"उच्छेदित" :'JJ',
"उच्छ्वसित" :'JJ',
"उच्छ्वासित" :'JJ',
"उछालछक्का" :'JJ',
"उछाही" :'JJ',
"उछिन्न" :'JJ',
"उछिष्ट" :'JJ',
"उछृंखल" :'JJ',
"उजड़ा" :'JJ',
"उजड्ड" :'JJ',
"उजबक" :'JJ',
"उज़बक" :'JJ',
"उजबेक" :'JJ',
"उज़बेक" :'JJ',
"उजबेकिस्तानी" :'JJ',
"उज़बेकिस्तानी" :'JJ',
"उजबेकी" :'JJ',
"उज़बेकी" :'JJ',
"उजबेग" :'JJ',
"उज़बेग" :'JJ',
"उजबैक" :'JJ',
"उज़बैक" :'JJ',
"उजयाली" :'JJ',
"उजर" :'JJ',
"उजरा" :'JJ',
"उजला" :'JJ',
"उजहदार" :'JJ',
"उजागर" :'JJ',
"उजाड़" :'JJ',
"उजाड़ू" :'JJ',
"उजार" :'JJ',
"उजाला" :'JJ',
"उजियार" :'JJ',
"उँजियार" :'JJ',
"उजियारा" :'JJ',
"उँजियारा" :'JJ',
"उजियाला" :'JJ',
"उजीता" :'JJ',
"उजूबा" :'JJ',
"उजेरा" :'JJ',
"उजेला" :'JJ',
"उज्जट" :'JJ',
"उज्जर" :'JJ',
"उज्जल" :'JJ',
"उज्जीवित" :'JJ',
"उज्जीवी" :'JJ',
"उज्ज्वल" :'JJ',
"उज्ज्वलित" :'JJ',
"उज्झटित" :'JJ',
"उज्झड़" :'JJ',
"उज्बेक" :'JJ',
"उज़्बेक" :'JJ',
"उज्बेकी" :'JJ',
"उज़्बेकी" :'JJ',
"उज्बेग" :'JJ',
"उज़्बेग" :'JJ',
"उज्बैक" :'JJ',
"उज़्बैक" :'JJ',
"उज्वल" :'JJ',
"उज्वलित" :'JJ',
"उटकनाटक" :'JJ',
"उटक्कर-लैस" :'JJ',
"उटक्करलैस" :'JJ',
"उटंग" :'JJ',
"उटंगा" :'JJ',
"उटङ्ग" :'JJ',
"उटङ्गा" :'JJ',
"उठंगल" :'JJ',
"उठल्लू" :'JJ',
"उठवैया" :'JJ',
"उठा" :'JJ',
"उठा हुआ" :'JJ',
"उठाईगीरा" :'JJ',
"उठाऊ" :'JJ',
"उठाने योग्य" :'JJ',
"उठैया" :'JJ',
"उठौआ" :'JJ',
"उठौवा" :'JJ',
"उड़ंकू" :'JJ',
"उड़खरा" :'JJ',
"उड़चक" :'JJ',
"उड़ता" :'JJ',
"उड़ता हुआ" :'JJ',
"उड़न" :'JJ',
"उड़न छू" :'JJ',
"उड़न-छू" :'JJ',
"उड़नछू" :'JJ',
"उड़नफाखता" :'JJ',
"उड़नफाख्ता" :'JJ',
"उड़नशील" :'JJ',
"उड़नहीन" :'JJ',
"उड़ना" :'JJ',
"उड़नेवाला" :'JJ',
"उड़ाइक" :'JJ',
"उड़ाऊ" :'JJ',
"उड़ाक" :'JJ',
"उड़ाँक" :'JJ',
"उड़ांक" :'JJ',
"उड़ाका" :'JJ',
"उड़ाकू" :'JJ',
"उड़ाँत" :'JJ',
"उड़ांत" :'JJ',
"उड़ानहीन" :'JJ',
"उड़ायक" :'JJ',
"उड़िया" :'JJ',
"उड़ैना" :'JJ',
"उड़ौहाँ" :'JJ',
"उड्डीयमान" :'JJ',
"उतंक" :'JJ',
"उतङ्क" :'JJ',
"उतंत" :'JJ',
"उतना" :'JJ',
"उतपन्न" :'JJ',
"उतरहा" :'JJ',
"उतरा हुआ" :'JJ',
"उतान" :'JJ',
"उतारा हुआ" :'JJ',
"उतारू" :'JJ',
"उतावला" :'JJ',
"उत्कट" :'JJ',
"उत्कंठित" :'JJ',
"उत्कण्ठित" :'JJ',
"उत्कर्षकारी" :'JJ',
"उत्कीर्ण" :'JJ',
"उत्कृष्ट" :'JJ',
"उत्खनित" :'JJ',
"उत्खात" :'JJ',
"उत्खाता" :'JJ',
"उत्तंग" :'JJ',
"उत्तङ्ग" :'JJ',
"उत्तम" :'JJ',
"उत्तमतर" :'JJ',
"उत्तमोत्तम" :'JJ',
"उत्तर" :'JJ',
"उत्तर कालीन" :'JJ',
"उत्तर कोरियाई" :'JJ',
"उत्तर दाता" :'JJ',
"उत्तर पच्छिमी" :'JJ',
"उत्तर पश्चिमी" :'JJ',
"उत्तर पूर्वी" :'JJ',
"उत्तर प्रदेशी" :'JJ',
"उत्तर प्रदेशीय" :'JJ',
"उत्तर-पच्छिमी" :'JJ',
"उत्तर-पश्चिमी" :'JJ',
"उत्तर-पूर्वी" :'JJ',
"उत्तर-प्रदेशी" :'JJ',
"उत्तर-प्रदेशीय" :'JJ',
"उत्तर-मध्य" :'JJ',
"उत्तर-मध्यवर्ती" :'JJ',
"उत्तरंग" :'JJ',
"उत्तरजात" :'JJ',
"उत्तरजीवी" :'JJ',
"उत्तरदायक" :'JJ',
"उत्तरदायित्वहीन" :'JJ',
"उत्तरदायी" :'JJ',
"उत्तरपूर्वी" :'JJ',
"उत्तरप्रदेशी" :'JJ',
"उत्तरप्रदेशीय" :'JJ',
"उत्तरवर्ती" :'JJ',
"उत्तरित" :'JJ',
"उत्तरी" :'JJ',
"उत्तरी अमरीकी" :'JJ',
"उत्तरी अमेरिकी" :'JJ',
"उत्तरी कोरियाई" :'JJ',
"उत्तरी पच्छिमी" :'JJ',
"उत्तरी पश्चिमी" :'JJ',
"उत्तरी पूर्वी" :'JJ',
"उत्तरी-अमरीकी" :'JJ',
"उत्तरी-अमेरिकी" :'JJ',
"उत्तरी-पच्छिमी" :'JJ',
"उत्तरी-पश्चिमी" :'JJ',
"उत्तरी-पूर्वी" :'JJ',
"उत्तरी-मध्यवर्ती" :'JJ',
"उत्तरीअमरीकी" :'JJ',
"उत्तरीअमेरिकी" :'JJ',
"उत्तरीपूर्वी" :'JJ',
"उत्तल" :'JJ',
"उत्तान" :'JJ',
"उत्तापित" :'JJ',
"उत्तीर्ण" :'JJ',
"उत्तुंग" :'JJ',
"उत्तेजक" :'JJ',
"उत्तेजनाप्रद" :'JJ',
"उत्तेजित" :'JJ',
"उत्तोलक" :'JJ',
"उत्तोलित" :'JJ',
"उत्थानशील" :'JJ',
"उत्पन्न" :'JJ',
"उत्पन्न हुआ" :'JJ',
"उत्पाटनीय" :'JJ',
"उत्पाटित" :'JJ',
"उत्पाती" :'JJ',
"उत्पादक" :'JJ',
"उत्पादित" :'JJ',
"उत्पीड़क" :'JJ',
"उत्पीड़ित" :'JJ',
"उत्प्रेरित" :'JJ',
"उत्सर्जित" :'JJ',
"उत्साह-जनक" :'JJ',
"उत्साहजनक" :'JJ',
"उत्साहपूर्ण" :'JJ',
"उत्साहयुक्त" :'JJ',
"उत्साहवर्द्धक" :'JJ',
"उत्साहवर्धक" :'JJ',
"उत्साहहीन" :'JJ',
"उत्साहित" :'JJ',
"उत्साही" :'JJ',
"उत्सुक" :'JJ',
"उत्सुकतारहित" :'JJ',
"उत्सुकताहीन" :'JJ',
"उत्स्फोटक" :'JJ',
"उथला" :'JJ',
"उदंड" :'JJ',
"उदण्ड" :'JJ',
"उदर पिशाच" :'JJ',
"उदर-परायण" :'JJ',
"उदरांत्रीय" :'JJ',
"उदरान्त्रीय" :'JJ',
"उदरीय" :'JJ',
"उदात्त" :'JJ',
"उदार" :'JJ',
"उदारचरित" :'JJ',
"उदारचित्त" :'JJ',
"उदारचेता" :'JJ',
"उदारतावादी" :'JJ',
"उदारमनस्क" :'JJ',
"उदारमना" :'JJ',
"उदारवादी" :'JJ',
"उदास" :'JJ',
"उदासीन" :'JJ',
"उदित" :'JJ',
"उद्घाटित" :'JJ',
"उद्घोषक" :'JJ',
"उद्दंड" :'JJ',
"उद्दण्ड" :'JJ',
"उद्दिष्ट" :'JJ',
"उद्दीप" :'JJ',
"उद्दीपक" :'JJ',
"उद्दीपन" :'JJ',
"उद्दीपित" :'JJ',
"उद्दीप्त" :'JJ',
"उद्देश्यरहित" :'JJ',
"उद्देश्यहीन" :'JJ',
"उद्धत" :'JJ',
"उद्धरित" :'JJ',
"उद्धृत" :'JJ',
"उद्बोधक" :'JJ',
"उद्यत" :'JJ',
"उद्यमरहित" :'JJ',
"उद्यमशील" :'JJ',
"उद्यमहीन" :'JJ',
"उद्यमी" :'JJ',
"उद्योग विषयक" :'JJ',
"उद्योगरत" :'JJ',
"उद्योगहीन" :'JJ',
"उद्योगी" :'JJ',
"उद्वासित" :'JJ',
"उद्विग्न" :'JJ',
"उद्वेलित" :'JJ',
"उधर का" :'JJ',
"उधार" :'JJ',
"उधार का" :'JJ',
"उधार-दाता" :'JJ',
"उधारदाता" :'JJ',
"उधारी का" :'JJ',
"उध्वत" :'JJ',
"उनचालीस" :'JJ',
"उनचालीसवाँ" :'JJ',
"उनचास" :'JJ',
"उनचासवाँ" :'JJ',
"उनञ्चास" :'JJ',
"उनतालीस" :'JJ',
"उनतालीसवाँ" :'JJ',
"उनतीस" :'JJ',
"उनतीसवाँ" :'JJ',
"उनसठ" :'JJ',
"उनसठवाँ" :'JJ',
"उनहत्तर" :'JJ',
"उनहत्तरवाँ" :'JJ',
"उनासी" :'JJ',
"उनासीवाँ" :'JJ',
"उनींदा" :'JJ',
"उनीस" :'JJ',
"उनीसवाँ" :'JJ',
"उन्नत" :'JJ',
"उन्नतकारी" :'JJ',
"उन्नतशील" :'JJ',
"उन्नतिकर्ता" :'JJ',
"उन्नतिकारक" :'JJ',
"उन्नतिकारी" :'JJ',
"उन्नतिशील" :'JJ',
"उन्नतोदर" :'JJ',
"उन्नायक" :'JJ',
"उन्नासी" :'JJ',
"उन्निद्र" :'JJ',
"उन्नीस" :'JJ',
"उन्नीसवाँ" :'JJ',
"उन्मत" :'JJ',
"उन्मत्त" :'JJ',
"उन्मद" :'JJ',
"उन्मनस्क" :'JJ',
"उन्मुक्त" :'JJ',
"उन्मुख" :'JJ',
"उन्मूलनीय" :'JJ',
"उन्मूलित" :'JJ',
"उन्मेल" :'JJ',
"उन्यासी" :'JJ',
"उन्यासीवाँ" :'JJ',
"उपकर्ता" :'JJ',
"उपकर्त्ता" :'JJ',
"उपकार कर्ता" :'JJ',
"उपकार कर्त्ता" :'JJ',
"उपकारक" :'JJ',
"उपकारी" :'JJ',
"उपकृत" :'JJ',
"उपघातक" :'JJ',
"उपचारित" :'JJ',
"उपचार्य" :'JJ',
"उपचित" :'JJ',
"उपजा" :'JJ',
"उपजा हुआ" :'JJ',
"उपजाऊ" :'JJ',
"उपदेशक" :'JJ',
"उपदेष्टा" :'JJ',
"उपद्रव कर्ता" :'JJ',
"उपद्रवकारी" :'JJ',
"उपद्रवग्रस्त" :'JJ',
"उपद्रवी" :'JJ',
"उपनिवेशित" :'JJ',
"उपनिवेशी" :'JJ',
"उपन्यास-संबंधी" :'JJ',
"उपपाद्य" :'JJ',
"उपभुक्त" :'JJ',
"उपभोक्ता" :'JJ',
"उपभोग्य" :'JJ',
"उपभोज्य" :'JJ',
"उपमारहित" :'JJ',
"उपमित" :'JJ',
"उपमेय" :'JJ',
"उपयुक्त" :'JJ',
"उपयोक्ता" :'JJ',
"उपयोगकर्ता" :'JJ',
"उपयोगकर्त्ता" :'JJ',
"उपयोगहीन" :'JJ',
"उपयोगी" :'JJ',
"उपरिलिखित" :'JJ',
"उपरोक्त" :'JJ',
"उपर्युक्त" :'JJ',
"उपलक्षित" :'JJ',
"उपलब्ध" :'JJ',
"उपवासी" :'JJ',
"उपविष्ट" :'JJ',
"उपस्थित" :'JJ',
"उपहासास्पद" :'JJ',
"उपहासी" :'JJ',
"उपहास्य" :'JJ',
"उपागत" :'JJ',
"उपादेय" :'JJ',
"उपाधिक" :'JJ',
"उपाधित" :'JJ',
"उपायहीन" :'JJ',
"उपार्जित" :'JJ',
"उपासक" :'JJ',
"उपासनीय" :'JJ',
"उपासा" :'JJ',
"उपासित" :'JJ',
"उपासी" :'JJ',
"उपास्य" :'JJ',
"उपेक्षक" :'JJ',
"उपेक्षणीय" :'JJ',
"उपेक्षापूर्ण" :'JJ',
"उपेक्षित" :'JJ',
"उपेक्ष्य" :'JJ',
"उपोष्णकटिबंधीय" :'JJ',
"उपोष्णकटिबन्धीय" :'JJ',
"उबला" :'JJ',
"उबाऊ" :'JJ',
"उभड़-खभड़" :'JJ',
"उभड़ा" :'JJ',
"उभय" :'JJ',
"उभयचर" :'JJ',
"उभरता" :'JJ',
"उभरा" :'JJ',
"उभाड़दार" :'JJ',
"उभारदार" :'JJ',
"उमंगपूर्ण" :'JJ',
"उमड़ता-घुमड़ता" :'JJ',
"उमड़ा" :'JJ',
"उमदा" :'JJ',
"उमर-रसीद" :'JJ',
"उमररसीद" :'JJ',
"उम्दा" :'JJ',
"उम्मीदवार" :'JJ',
"उम्मेदवार" :'JJ',
"उम्र-दराज" :'JJ',
"उम्र-दराज़" :'JJ',
"उम्र-रसीद" :'JJ',
"उम्रदराज" :'JJ',
"उम्रदराज़" :'JJ',
"उम्ररसीद" :'JJ',
"उरुग्वे-संबंधी" :'JJ',
"उरुग्वेयन" :'JJ',
"उरूग्वे-संबंधी" :'JJ',
"उरूग्वेयन" :'JJ',
"उर्दू" :'JJ',
"उर्मिल" :'JJ',
"उर्वर" :'JJ',
"उलंघित" :'JJ',
"उलझनहीन" :'JJ',
"उलझा" :'JJ',
"उलट" :'JJ',
"उलटा" :'JJ',
"उलटा पुलटा" :'JJ',
"उलटा पैदा" :'JJ',
"उलटा पैदा हुआ" :'JJ',
"उलटा-पलटा" :'JJ',
"उलटा-पुलटा" :'JJ',
"उलटा-सीधा" :'JJ',
"उल्टा" :'JJ',
"उल्टा पुल्टा" :'JJ',
"उल्टा पैदा" :'JJ',
"उल्टा पैदा हुआ" :'JJ',
"उल्टा-पल्टा" :'JJ',
"उल्टा-पुल्टा" :'JJ',
"उल्टा-सीधा" :'JJ',
"उल्टी करने वाला" :'JJ',
"उल्थाकार" :'JJ',
"उल्लंघक" :'JJ',
"उल्लंघनीय" :'JJ',
"उल्लंघित" :'JJ',
"उल्लङ्घक" :'JJ',
"उल्लङ्घनीय" :'JJ',
"उल्लसित" :'JJ',
"उल्लासपूर्ण" :'JJ',
"उल्लासित" :'JJ',
"उल्लासी" :'JJ',
"उल्लिखित" :'JJ',
"उल्लू का पट्ठा" :'JJ',
"उल्लेखनीय" :'JJ',
"उल्लेख्य" :'JJ',
"उष्ण" :'JJ',
"उष्ण कटिबंधी" :'JJ',
"उष्ण कटिबंधीय" :'JJ',
"उष्ण कटिबन्धी" :'JJ',
"उष्ण कटिबन्धीय" :'JJ',
"उष्णकटिबंधी" :'JJ',
"उष्णकटिबंधीय" :'JJ',
"उष्णकटिबन्धी" :'JJ',
"उष्णकटिबन्धीय" :'JJ',
"उस ओर का" :'JJ',
"उसके जैसा" :'JJ',
"उसना" :'JJ',
"उसी तरह का" :'JJ',
"उस्बेक" :'JJ',
"उस्बेग" :'JJ',
"ऊकारांत" :'JJ',
"ऊकारादि" :'JJ',
"ऊकारान्त" :'JJ',
"ऊँचा" :'JJ',
"ऊंचा" :'JJ',
"ऊँचा पूरा" :'JJ',
"ऊंचा पूरा" :'JJ',
"ऊँचा-नीचा" :'JJ',
"ऊंचा-नीचा" :'JJ',
"ऊँचा-पूरा" :'JJ',
"ऊंचा-पूरा" :'JJ',
"ऊटपटाँग" :'JJ',
"ऊटपटांग" :'JJ',
"ऊधमी" :'JJ',
"ऊन" :'JJ',
"ऊनवाचक" :'JJ',
"ऊनी" :'JJ',
"ऊपर लिखा" :'JJ',
"ऊपरी" :'JJ',
"ऊबड़ खाबड़" :'JJ',
"ऊबड़-खाबड़" :'JJ',
"ऊबा" :'JJ',
"ऊबाऊ" :'JJ',
"ऊरुहीन" :'JJ',
"ऊर्द्ध्व" :'JJ',
"ऊर्द्ध्वगामी" :'JJ',
"ऊर्ध्व" :'JJ',
"ऊर्ध्व मुख" :'JJ',
"ऊर्ध्व-पातित" :'JJ',
"ऊर्ध्वगामी" :'JJ',
"ऊर्ध्वपातित" :'JJ',
"ऊर्ध्वमुख" :'JJ',
"ऊर्ध्वोन्मुख" :'JJ',
"ऊल-जलूल" :'JJ',
"ऊलजलूल" :'JJ',
"ऊष्मागतिक" :'JJ',
"ऋजु" :'JJ',
"ऋण" :'JJ',
"ऋण-दाता" :'JJ',
"ऋण-प्रदाता" :'JJ',
"ऋणकर्ता" :'JJ',
"ऋणदाता" :'JJ',
"ऋणप्रदाता" :'JJ',
"ऋणमुक्त" :'JJ',
"ऋणरहित" :'JJ',
"ऋणात्मक" :'JJ',
"ऋणी" :'JJ',
"ऋत" :'JJ',
"ऋतुमति" :'JJ',
"ऋतुमती" :'JJ',
"ऋद्ध" :'JJ',
"ऋषिकृत" :'JJ',
"एअरोडाइनेमिक" :'JJ',
"एक" :'JJ',
"एक अकेला" :'JJ',
"एक एक" :'JJ',
"एक कोशिक" :'JJ',
"एक कोशिकीय" :'JJ',
"एक जैसा" :'JJ',
"एक भी नहीं" :'JJ',
"एक समान" :'JJ',
"एक सा" :'JJ',
"एक सितारा" :'JJ',
"एक सींग वाला" :'JJ',
"एक सौ एक" :'JJ',
"एक सौ नब्बे" :'JJ',
"एक सौ पचहत्तर" :'JJ',
"एक सौ पचास" :'JJ',
"एक सौ साठ" :'JJ',
"एक सौ सात" :'JJ',
"एक ही" :'JJ',
"एक-आध" :'JJ',
"एक-एक" :'JJ',
"एक-दो" :'JJ',
"एकक" :'JJ',
"एककोशिक" :'JJ',
"एककोशिकीय" :'JJ',
"एकंग" :'JJ',
"एकचारिणी" :'JJ',
"एकचालीस" :'JJ',
"एकचालीसवाँ" :'JJ',
"एकचित्त" :'JJ',
"एकचोबा" :'JJ',
"एकछत्र" :'JJ',
"एकजुट" :'JJ',
"एकटंगा" :'JJ',
"एकडाल" :'JJ',
"एकतंत्र" :'JJ',
"एकतरफा" :'JJ',
"एकतरफ़ा" :'JJ',
"एकतान" :'JJ',
"एकतापूर्ण" :'JJ',
"एकतारंकित" :'JJ',
"एकतारा" :'JJ',
"एकतालिस" :'JJ',
"एकतालिसवाँ" :'JJ',
"एकताहीन" :'JJ',
"एकतीस" :'JJ',
"एकतीसवाँ" :'JJ',
"एकत्र" :'JJ',
"एकत्रित" :'JJ',
"एकदम सही" :'JJ',
"एकदरा" :'JJ',
"एकदिवसीय" :'JJ',
"एकदेशी" :'JJ',
"एकदेशीय" :'JJ',
"एकनयन" :'JJ',
"एकनिष्ठ" :'JJ',
"एकपक्षीय" :'JJ',
"एकपहिया" :'JJ',
"एकफसला" :'JJ',
"एकमत" :'JJ',
"एकमात्र" :'JJ',
"एकमात्रिक" :'JJ',
"एकमुखी" :'JJ',
"एकमुँहा" :'JJ',
"एकमेव" :'JJ',
"एकरस" :'JJ',
"एकराय" :'JJ',
"एकल" :'JJ',
"एकलखा" :'JJ',
"एकलौता" :'JJ',
"एकवर्षी" :'JJ',
"एकवर्षीय" :'JJ',
"एकसठ" :'JJ',
"एकसठवाँ" :'JJ',
"एकसमान" :'JJ',
"एकसा" :'JJ',
"एकसींगी" :'JJ',
"एकहत्तर" :'JJ',
"एकहत्तरवाँ" :'JJ',
"एकहरा" :'JJ',
"एकाकी" :'JJ',
"एकाक्ष" :'JJ',
"एकाक्षरी" :'JJ',
"एकाग्र" :'JJ',
"एकाग्र-चित्त" :'JJ',
"एकाग्रचित्त" :'JJ',
"एकांडज" :'JJ',
"एकाण्डज" :'JJ',
"एकांत" :'JJ',
"एकांत वासी" :'JJ',
"एकांत सेवी" :'JJ',
"एकांत-वासी" :'JJ',
"एकांत-सेवी" :'JJ',
"एकांतर" :'JJ',
"एकांतरहित" :'JJ',
"एकांतरिक" :'JJ',
"एकांतवासी" :'JJ',
"एकांतसेवी" :'JJ',
"एकांतहीन" :'JJ',
"एकात्मवादी" :'JJ',
"एकादश" :'JJ',
"एकाध" :'JJ',
"एकाधिक" :'JJ',
"एकाधिपति" :'JJ',
"एकानवे" :'JJ',
"एकान्त" :'JJ',
"एकान्त वासी" :'JJ',
"एकान्त सेवी" :'JJ',
"एकान्त-वासी" :'JJ',
"एकान्त-सेवी" :'JJ',
"एकान्तर" :'JJ',
"एकान्तरहित" :'JJ',
"एकान्तरिक" :'JJ',
"एकान्तवासी" :'JJ',
"एकान्तसेवी" :'JJ',
"एकान्तहीन" :'JJ',
"एकारांत" :'JJ',
"एकारादि" :'JJ',
"एकारान्त" :'JJ',
"एकार्थी" :'JJ',
"एकावन" :'JJ',
"एकावली" :'JJ',
"एकासी" :'JJ',
"एकासीवाँ" :'JJ',
"एकाह" :'JJ',
"एकाहारी" :'JJ',
"एकाहिक" :'JJ',
"एकीकृत" :'JJ',
"एकीभूत" :'JJ',
"एकीस" :'JJ',
"एकीसवाँ" :'JJ',
"एकेडमिक" :'JJ',
"एकेश्वरवादी" :'JJ',
"एकोतरसौ" :'JJ',
"एकोत्तर" :'JJ',
"एकोदर" :'JJ',
"एक्का" :'JJ',
"एक्का दुक्का" :'JJ',
"एक्का-दुक्का" :'JJ',
"एक्कानबे" :'JJ',
"एक्कानबेवाँ" :'JJ',
"एक्कानवे" :'JJ',
"एक्कानवेवाँ" :'JJ',
"एक्कावन" :'JJ',
"एक्कावनवाँ" :'JJ',
"एक्कावनवां" :'JJ',
"एक्कासी" :'JJ',
"एक्कासीवाँ" :'JJ',
"एक्कीस" :'JJ',
"एक्कीसवाँ" :'JJ',
"एक्यानबे" :'JJ',
"एक्यानबेवाँ" :'JJ',
"एक्यानवे" :'JJ',
"एक्यानवेवाँ" :'JJ',
"एक्यावन" :'JJ',
"एक्यावनवाँ" :'JJ',
"एक्यावनवां" :'JJ',
"एक्यासी" :'JJ',
"एक्यासीवाँ" :'JJ',
"एक्वाडोरियन" :'JJ',
"एक्वाडोरी" :'JJ',
"एक्स्ट्रा" :'JJ',
"एटमी" :'JJ',
"एटीगुआई" :'JJ',
"एंटीगुआई" :'JJ',
"एंटीबायोटिक" :'JJ',
"एंटीवाइरल" :'JJ',
"एंटीवायरल" :'JJ',
"एंठू" :'JJ',
"एंडोरन" :'JJ',
"एंडोरी" :'JJ',
"एण्टीबायोटिक" :'JJ',
"एतबारी" :'JJ',
"एतवारी" :'JJ',
"एनीमिक" :'JJ',
"एन्टीगुआई" :'JJ',
"एन्टीवाइरल" :'JJ',
"एन्टीवायरल" :'JJ',
"एपडेमिक" :'JJ',
"एपिडेमिक" :'JJ',
"एमहैरिक" :'JJ',
"एम्हैरिक" :'JJ',
"एरिट्रिआई" :'JJ',
"एरिट्रियन" :'JJ',
"एरिट्रियाई" :'JJ',
"एल सल्वाडोरी" :'JJ',
"एवजी" :'JJ',
"एवज़ी" :'JJ',
"एशियन" :'JJ',
"एशियाई" :'JJ',
"एस्टोनियन" :'JJ',
"एस्टोनियाई" :'JJ',
"एहतियाती" :'JJ',
"एहसानफरामोश" :'JJ',
"एहसानफ़रामोश" :'JJ',
"एहसानमंद" :'JJ',
"ऐकडेमिक" :'JJ',
"ऐकारांत" :'JJ',
"ऐकारादि" :'JJ',
"ऐकारान्त" :'JJ',
"ऐंचताना" :'JJ',
"ऐच्छिक" :'JJ',
"ऐटमी" :'JJ',
"ऐंठदार" :'JJ',
"ऐंठा" :'JJ',
"ऐंठा हुआ" :'JJ',
"ऐंडोरन" :'JJ',
"ऐंडोरी" :'JJ',
"ऐतिहासिक" :'JJ',
"ऐंद्रजालिक" :'JJ',
"ऐंद्रिय" :'JJ',
"ऐन" :'JJ',
"ऐन्द्रिय" :'JJ',
"ऐबी" :'JJ',
"ऐयाश" :'JJ',
"ऐरा गैरा" :'JJ',
"ऐरा ग़ैरा" :'JJ',
"ऐरा-गैरा" :'JJ',
"ऐरा-ग़ैरा" :'JJ',
"ऐरागैरा" :'JJ',
"ऐराग़ैरा" :'JJ',
"ऐश्वर्यदायक" :'JJ',
"ऐश्वर्यदायी" :'JJ',
"ऐश्वर्यप्रद" :'JJ',
"ऐश्वर्यप्रदायक" :'JJ',
"ऐश्वर्यप्रदायी" :'JJ',
"ऐश्वर्यवान" :'JJ',
"ऐश्वर्यवान्" :'JJ',
"ऐश्वर्यशाली" :'JJ',
"ऐसा" :'JJ',
"ऐसा ही" :'JJ',
"ऐसा-वैसा" :'JJ',
"ऑथराइज्ड" :'JJ',
"ऑनलाइन" :'JJ',
"ऑर्थोपीडिक" :'JJ',
"ऑर्थोपीडीक" :'JJ',
"ऑलराउंडर" :'JJ',
"ऑलराउन्डर" :'JJ',
"ऑस्ट्रियन" :'JJ',
"ऑस्ट्रियाई" :'JJ',
"ऑस्ट्रेलियन" :'JJ',
"ऑस्ट्रेलियाई" :'JJ',
"ओकरा" :'JJ',
"ओकारांत" :'JJ',
"ओकारान्त" :'JJ',
"ओंगन" :'JJ',
"ओछा" :'JJ',
"ओजस्वी" :'JJ',
"ओजहीन" :'JJ',
"ओझल" :'JJ',
"ओड़िया" :'JJ',
"ओत प्रोत" :'JJ',
"ओत-प्रोत" :'JJ',
"ओतप्रोत" :'JJ',
"ओदा" :'JJ',
"ओपनिंग" :'JJ',
"ओबरा" :'JJ',
"ओमानी" :'JJ',
"ओलंपियन" :'JJ',
"ओलंपीयन" :'JJ',
"ओलम्पियन" :'JJ',
"ओलम्पीयन" :'JJ',
"ओला" :'JJ',
"ओलिंपियन" :'JJ',
"ओलिंपीयन" :'JJ',
"ओलिम्पियन" :'JJ',
"ओलिम्पीयन" :'JJ',
"ओष्ठ्य" :'JJ',
"औकारांत" :'JJ',
"औकारादि" :'JJ',
"औकारान्त" :'JJ',
"औंगन" :'JJ',
"औंगा" :'JJ',
"औंडा" :'JJ',
"औंड़ा" :'JJ',
"औढर" :'JJ',
"औढरदानी" :'JJ',
"औतारी" :'JJ',
"औदार्यवादी" :'JJ',
"औद्योगिक" :'JJ',
"औद्योगीकृत" :'JJ',
"औंधा" :'JJ',
"औपचारिक" :'JJ',
"औपनिवेशिक" :'JJ',
"औपन्यासिक" :'JJ',
"औरताना" :'JJ',
"औरस" :'JJ',
"औरेबदार" :'JJ',
"औरेबी" :'JJ',
"औवल" :'JJ',
"औवल दरजे का" :'JJ',
"औवल दर्जे का" :'JJ',
"औव्वल" :'JJ',
"औव्वल दरजे का" :'JJ',
"औव्वल दर्जे का" :'JJ',
"औषधीय" :'JJ',
"औसत" :'JJ',
"कई" :'JJ',
"कई तरह का" :'JJ',
"कई तरह के" :'JJ',
"कई प्रकार का" :'JJ',
"कई प्रकार के" :'JJ',
"कँकड़ीला" :'JJ',
"कंकड़ीला" :'JJ',
"कंकरीला" :'JJ',
"कंगाल" :'JJ',
"कच्चा" :'JJ',
"कच्छी" :'JJ',
"कज" :'JJ',
"कंजई" :'JJ',
"कजरारा" :'JJ',
"कंजा" :'JJ',
"कजाक" :'JJ',
"कज़ाक" :'JJ',
"कजाकी" :'JJ',
"कज़ाकी" :'JJ',
"कंजूस" :'JJ',
"कंटकयुक्त" :'JJ',
"कटकहा" :'JJ',
"कंटकहीन" :'JJ',
"कंटकित" :'JJ',
"कँटकी" :'JJ',
"कटखनहा" :'JJ',
"कटखना" :'JJ',
"कटखन्ना" :'JJ',
"कटखाहा" :'JJ',
"कटखैना" :'JJ',
"कटखौवा" :'JJ',
"कटवाँ" :'JJ',
"कटहली" :'JJ',
"कटहा" :'JJ',
"कटा" :'JJ',
"कटा हुआ" :'JJ',
"कटावदार" :'JJ',
"कटिबद्ध" :'JJ',
"कटिहीना" :'JJ',
"कटीला" :'JJ',
"कँटीला" :'JJ',
"कंटीला" :'JJ',
"कटु" :'JJ',
"कटुआ" :'JJ',
"कटुआँ" :'JJ',
"कटुक" :'JJ',
"कटुतिक्त" :'JJ',
"कटुभाषी" :'JJ',
"कट्टर" :'JJ',
"कट्टर-पंथी" :'JJ',
"कट्टरपंथी" :'JJ',
"कट्टरवादी" :'JJ',
"कंठ-तालव्य" :'JJ',
"कंठतालव्य" :'JJ',
"कंठस्थ" :'JJ',
"कंठाग्र" :'JJ',
"कठिन" :'JJ',
"कठिया" :'JJ',
"कठोर" :'JJ',
"कठोर व्यवहारी" :'JJ',
"कठोर हृदय" :'JJ',
"कठोरहृदय" :'JJ',
"कंठौष्ठ्य" :'JJ',
"कंठ्य" :'JJ',
"कड़क" :'JJ',
"कड़कड़" :'JJ',
"कड़कड़ाता" :'JJ',
"कड़कता" :'JJ',
"कड़वा" :'JJ',
"कडा" :'JJ',
"कड़ा" :'JJ',
"कड़ाके का" :'JJ',
"कड़ुआ" :'JJ',
"कड़ुवा" :'JJ',
"कड़ू" :'JJ',
"कढ़ाईदार" :'JJ',
"कढ़ी खाऊ" :'JJ',
"कढ़ी प्रेमी" :'JJ',
"कढ़ीचट" :'JJ',
"कण्ठौष्ठ्य" :'JJ',
"कण्ठ्य" :'JJ',
"कतरीला" :'JJ',
"कतिपय" :'JJ',
"कत्थई" :'JJ',
"कथनीय" :'JJ',
"कथित" :'JJ',
"कथ्य" :'JJ',
"कदरदाँ" :'JJ',
"क़दरदाँ" :'JJ',
"कदरदान" :'JJ',
"क़दरदान" :'JJ',
"कंदरावासी" :'JJ',
"कदर्य" :'JJ',
"कदलीजंघा" :'JJ',
"कदाचारी" :'JJ',
"कदीम" :'JJ',
"कद्दी" :'JJ',
"कद्रदान" :'JJ',
"क़द्रदान" :'JJ',
"कनकटा" :'JJ',
"कनकट्टा" :'JJ',
"कनकना" :'JJ',
"कनफुंकवा" :'JJ',
"कनफुसका" :'JJ',
"कनरसिया" :'JJ',
"कनाडाई" :'JJ',
"कनिष्ठ" :'JJ',
"कनिष्ठक" :'JJ',
"कनेठा" :'JJ',
"कनेडियन" :'JJ',
"कनोतर" :'JJ',
"कन्दरावासी" :'JJ',
"कन्नड़" :'JJ',
"कन्सूमर" :'JJ',
"कन्स्यूमर" :'JJ',
"कपटपूर्ण" :'JJ',
"कपटमय" :'JJ',
"कपटरहित" :'JJ',
"कपटहीन" :'JJ',
"कपटी" :'JJ',
"कंपमान" :'JJ',
"कंपमान्" :'JJ',
"कंपरहित" :'JJ',
"कंपायमान" :'JJ',
"कपासी" :'JJ',
"कपिंजल" :'JJ',
"कपिञ्जल" :'JJ',
"कंपित" :'JJ',
"कपिल" :'JJ',
"कंपूचियन" :'JJ',
"कंपूचियाई" :'JJ',
"कपूरी" :'JJ',
"कपोल कल्पित" :'JJ',
"कपोलकल्पित" :'JJ',
"कंप्यूटरी" :'JJ',
"कंप्यूटरीकृत" :'JJ',
"कफनखसोट" :'JJ',
"कफ़नखसोट" :'JJ',
"कबरा" :'JJ',
"कबाइली" :'JJ',
"कबाबी" :'JJ',
"कबायली" :'JJ',
"क़बायली" :'JJ',
"कबीर" :'JJ',
"कबीर-पंथी" :'JJ',
"कबीरपंथी" :'JJ',
"कबीलियाई" :'JJ',
"क़बीलियाई" :'JJ',
"कबीली" :'JJ',
"क़बीली" :'JJ',
"कंबोडियन" :'JJ',
"कंबोडियाई" :'JJ',
"कब्जकारक" :'JJ',
"कब्जावर" :'JJ',
"कब्ज़ावर" :'JJ',
"क़ब्जावर" :'JJ',
"क़ब्ज़ावर" :'JJ',
"कम" :'JJ',
"कम से कम" :'JJ',
"कम होता हुआ" :'JJ',
"कम-खर्ची" :'JJ',
"कम-समझ" :'JJ',
"कम-से-कम" :'JJ',
"कमखर्ची" :'JJ',
"कमजोर" :'JJ',
"कमज़ोर" :'JJ',
"कमतर" :'JJ',
"कमनीय" :'JJ',
"कमनैत" :'JJ',
"कमप्यूटरीकृत" :'JJ',
"कमबख्त" :'JJ',
"कमबख़्त" :'JJ',
"कमरतोड़" :'JJ',
"कमर्शल" :'JJ',
"कमर्शियल" :'JJ',
"कमलनयन" :'JJ',
"कमलनेत्र" :'JJ',
"कमसिन" :'JJ',
"कमाऊ" :'JJ',
"कमानीदार" :'JJ',
"कमानेवाला" :'JJ',
"कमाया" :'JJ',
"कमासुत" :'JJ',
"कमिटेड" :'JJ',
"कमीना" :'JJ',
"कम्पमान" :'JJ',
"कम्पमान्" :'JJ',
"कम्परहित" :'JJ',
"कम्पायमान" :'JJ',
"कम्पित" :'JJ',
"कम्पूचियन" :'JJ',
"कम्पूचियाई" :'JJ',
"कम्प्यूटरी" :'JJ',
"कम्प्यूटरीकृत" :'JJ',
"कम्बोडियन" :'JJ',
"कम्बोडियाई" :'JJ',
"कम्युनिस्ट" :'JJ',
"कम्यूनिस्ट" :'JJ',
"कर मुक्त" :'JJ',
"करंजा" :'JJ',
"करंजुआ" :'JJ',
"करंजुवा" :'JJ',
"करणहार" :'JJ',
"करणीय" :'JJ',
"करतबिया" :'JJ',
"करतबी" :'JJ',
"करनहार" :'JJ',
"करनाटकी" :'JJ',
"करप्ट" :'JJ',
"करबद्ध" :'JJ',
"करमट्ठा" :'JJ',
"करमुक्त" :'JJ',
"करयुक्त" :'JJ',
"करवाली" :'JJ',
"करहीन" :'JJ',
"कराधीन" :'JJ',
"करामाती" :'JJ',
"करारा" :'JJ',
"कराल" :'JJ',
"करिश्माई" :'JJ',
"करीबी" :'JJ',
"क़रीबी" :'JJ',
"करीम" :'JJ',
"करुण" :'JJ',
"करुणामय" :'JJ',
"करुणायुक्त" :'JJ',
"करुणावान" :'JJ',
"करुणाविहीन" :'JJ',
"करुणाहीन" :'JJ',
"करोड़" :'JJ',
"करोड़खूख" :'JJ',
"करोड़पति" :'JJ',
"करोड़वाँ" :'JJ',
"करोड़ों" :'JJ',
"करौंदिया" :'JJ',
"कर्कश" :'JJ',
"कर्कशा" :'JJ',
"कर्जदाता" :'JJ',
"क़र्ज़दाता" :'JJ',
"कर्जदार" :'JJ',
"क़र्ज़दार" :'JJ',
"कर्जबाजारी" :'JJ',
"क़र्ज़बाज़ारी" :'JJ',
"कर्जाऊ" :'JJ',
"कर्जेच्छु" :'JJ',
"क़र्ज़ेच्छु" :'JJ',
"कर्जेच्छुक" :'JJ',
"क़र्ज़ेच्छुक" :'JJ',
"कर्जेछु" :'JJ',
"क़र्ज़ेछु" :'JJ',
"कर्णकटु" :'JJ',
"कर्णभेदी" :'JJ',
"कर्णवेधी" :'JJ',
"कर्णीजप" :'JJ',
"कर्तव्यपरायण" :'JJ',
"कर्तव्यवादी" :'JJ',
"कर्ता" :'JJ',
"कर्तार" :'JJ',
"कर्तृत्ववादी" :'JJ',
"कर्तृत्वाधीन" :'JJ',
"कर्त्तव्यवादी" :'JJ',
"कर्त्ता" :'JJ',
"कर्नाटकी" :'JJ',
"कर्मठ" :'JJ',
"कर्मण्य" :'JJ',
"कर्मदक्ष" :'JJ',
"कर्मनिष्ठ" :'JJ',
"कर्मवादी" :'JJ',
"कर्मशील" :'JJ',
"कर्महीन" :'JJ',
"कर्माधीन" :'JJ',
"कर्मी" :'JJ',
"कर्षित" :'JJ',
"कलईदार" :'JJ',
"कलकतिया" :'JJ',
"कलंकरहित" :'JJ',
"कलंकित" :'JJ',
"कलगीदार" :'JJ',
"कलगीधर" :'JJ',
"कलजिब्भा" :'JJ',
"कलजुगी" :'JJ',
"कलफदार" :'JJ',
"कलफ़दार" :'JJ',
"कलमास" :'JJ',
"कलमी" :'JJ',
"क़लमी" :'JJ',
"कलमुँहा" :'JJ',
"कलयुगीन" :'JJ',
"कलसिरी" :'JJ',
"कलहकारी" :'JJ',
"कलहंतरिता" :'JJ',
"कलहंतारिता" :'JJ',
"कलहन्तरिता" :'JJ',
"कलहन्तारिता" :'JJ',
"कलहप्रिय" :'JJ',
"कलहार" :'JJ',
"कलहारी" :'JJ',
"कलहिनी" :'JJ',
"कलही" :'JJ',
"कला प्रेमी" :'JJ',
"कला रसिक" :'JJ',
"कला-प्रेमी" :'JJ',
"कलात्मक" :'JJ',
"कलापूर्ण" :'JJ',
"कलाप्रेमी" :'JJ',
"कलामय" :'JJ',
"कलावती" :'JJ',
"कलाहीन" :'JJ',
"कलिजुगी" :'JJ',
"कलित" :'JJ',
"कलियुगी" :'JJ',
"कलिवर्ज्य" :'JJ',
"कलुष" :'JJ',
"कलुषित" :'JJ',
"कल्पनातीत" :'JJ',
"कल्पनाशील" :'JJ',
"कल्पित" :'JJ',
"कल्याण कामी" :'JJ',
"कल्याणकारी" :'JJ',
"कल्याणप्रद" :'JJ',
"कल्याणमय" :'JJ',
"कल्याणी" :'JJ',
"कल्लातोड़" :'JJ',
"कवचधारी" :'JJ',
"कवचयुक्त" :'JJ',
"कवचहीन" :'JJ',
"कवचित" :'JJ',
"कवची" :'JJ',
"कवर्गीय" :'JJ',
"कँवारा" :'JJ',
"कँवारी" :'JJ',
"कवित्वपूर्ण" :'JJ',
"कवोष्ण" :'JJ',
"कशेरुकी" :'JJ',
"कश्मीरी" :'JJ',
"कषाय" :'JJ',
"कष्ट-साध्य" :'JJ',
"कष्टकर" :'JJ',
"कष्टग्रस्त" :'JJ',
"कष्टदायक" :'JJ',
"कष्टदायी" :'JJ',
"कष्टपूर्ण" :'JJ',
"कष्टप्रद" :'JJ',
"कष्टभरा" :'JJ',
"कष्टमय" :'JJ',
"कष्टसाध्य" :'JJ',
"कसरती" :'JJ',
"कसा" :'JJ',
"कसाई" :'JJ',
"कंसूमर" :'JJ',
"कसूरवार" :'JJ',
"क़सूरवार" :'JJ',
"कसैला" :'JJ',
"कस्तूरिया" :'JJ',
"कंस्यूमर" :'JJ',
"कहने भर का" :'JJ',
"कहर" :'JJ',
"कहा" :'JJ',
"कागजी" :'JJ',
"काग़ज़ी" :'JJ',
"काँग्रेसी" :'JJ',
"कांग्रेसी" :'JJ',
"कांचन" :'JJ',
"काचा" :'JJ',
"काँचा" :'JJ',
"काटारी" :'JJ',
"क़ाटारी" :'JJ',
"काटू" :'JJ',
"काँटेदार" :'JJ',
"कांटेदार" :'JJ',
"काट्य" :'JJ',
"काठा" :'JJ',
"काठियावाड़ी" :'JJ',
"काठी" :'JJ',
"कांड" :'JJ',
"काण्ड" :'JJ',
"कातर" :'JJ',
"कातारी" :'JJ',
"क़ातारी" :'JJ',
"कांतिमय" :'JJ',
"कांतिमान" :'JJ',
"कांतिमान्" :'JJ',
"कांतियुक्त" :'JJ',
"कातिल" :'JJ',
"क़ातिल" :'JJ',
"कातिलाना" :'JJ',
"क़ातिलाना" :'JJ',
"कांतिवान" :'JJ',
"कांतिवान्" :'JJ',
"कांतिहीन" :'JJ',
"कादर" :'JJ',
"कानफाड़ू" :'JJ',
"कानफोड़ू" :'JJ',
"काना" :'JJ',
"कानी" :'JJ',
"कानूनी" :'JJ',
"क़ानूनी" :'JJ',
"कान्तिमय" :'JJ',
"कान्तिमान" :'JJ',
"कान्तिमान्" :'JJ',
"कान्तियुक्त" :'JJ',
"कापेय" :'JJ',
"काफिर" :'JJ',
"काफ़िर" :'JJ',
"काफी" :'JJ',
"काफ़ी" :'JJ',
"काफी-कुछ" :'JJ',
"क़ाफी-कुछ" :'JJ',
"काफूरी" :'JJ',
"काफ़ूरी" :'JJ',
"काबिज" :'JJ',
"क़ाबिज़" :'JJ',
"काबिल" :'JJ',
"क़ाबिल" :'JJ',
"काबिले तारीफ" :'JJ',
"क़ाबिले तारीफ़" :'JJ',
"काबिले दाद" :'JJ',
"क़ाबिले दाद" :'JJ',
"काबिले दीद" :'JJ',
"क़ाबिले दीद" :'JJ',
"काबिले-तारीफ" :'JJ',
"क़ाबिले-तारीफ़" :'JJ',
"काबिले-दाद" :'JJ',
"क़ाबिले-दाद" :'JJ',
"काबिलेतारीफ" :'JJ',
"क़ाबिलेतारीफ़" :'JJ',
"काबिलेदाद" :'JJ',
"क़ाबिलेदाद" :'JJ',
"काबुली" :'JJ',
"काम चलाऊ" :'JJ',
"काम-काजी" :'JJ',
"काम-चलाऊ" :'JJ',
"कामकाजी" :'JJ',
"कामकूट" :'JJ',
"कामचलाऊ" :'JJ',
"कामचारी" :'JJ',
"कामचोर" :'JJ',
"कामदार" :'JJ',
"कामन" :'JJ',
"कामनापूर्ण" :'JJ',
"कामनारहित" :'JJ',
"कामयाब" :'JJ',
"कामवती" :'JJ',
"कामहीन" :'JJ',
"कामा" :'JJ',
"कामांध" :'JJ',
"कामान्ध" :'JJ',
"कामिल" :'JJ',
"कामी" :'JJ',
"कामुक" :'JJ',
"कामुकतापूर्ण" :'JJ',
"कायम" :'JJ',
"कायर" :'JJ',
"कायल" :'JJ',
"क़ायल" :'JJ',
"कायिक" :'JJ',
"कारक" :'JJ',
"कारगर" :'JJ',
"कारगुजार" :'JJ',
"कारगुज़ार" :'JJ',
"कारपोरेट" :'JJ',
"कारबारी" :'JJ',
"कारसाज" :'JJ',
"कारसाज़" :'JJ',
"कारुणिक" :'JJ',
"कारूणिक" :'JJ',
"कारोबारी" :'JJ',
"कार्तिकी" :'JJ',
"कार्दम" :'JJ',
"कार्पोरेट" :'JJ',
"कार्बनिक" :'JJ',
"कार्यकारी" :'JJ',
"कार्यकुशल" :'JJ',
"कार्यरत" :'JJ',
"कार्यवाहक" :'JJ',
"कार्यशील" :'JJ',
"कार्यान्वित" :'JJ',
"कार्यालयी" :'JJ',
"कार्यालयीन" :'JJ',
"कालजयी" :'JJ',
"कालजीत" :'JJ',
"कालबाह्य" :'JJ',
"कालवाचक" :'JJ',
"कालवाची" :'JJ',
"काला" :'JJ',
"काला सा" :'JJ',
"काला-कलूटा" :'JJ',
"कालाकलूटा" :'JJ',
"कालातीत" :'JJ',
"कालिक" :'JJ',
"काली जीभवाला" :'JJ',
"कालीन" :'JJ',
"काले जैसा" :'JJ',
"कालेय" :'JJ',
"कालोचित" :'JJ',
"काल्पनिक" :'JJ',
"काव्य प्रेमी" :'JJ',
"काव्य रसिक" :'JJ',
"काव्यमय" :'JJ',
"काव्यात्मक" :'JJ',
"काशेय" :'JJ',
"काश्मीरी" :'JJ',
"काष्ठीय" :'JJ',
"कासनी" :'JJ',
"कासिम" :'JJ',
"क़ासिम" :'JJ',
"कांस्य" :'JJ',
"काहिराई" :'JJ',
"क़ाहिराई" :'JJ',
"काहिल" :'JJ',
"किंकर्तव्य-विमूढ़" :'JJ',
"किंकर्तव्यविमूढ़" :'JJ',
"किंकर्त्तव्य-विमूढ़" :'JJ',
"किंकर्त्तव्यविमूढ़" :'JJ',
"किचकिचिया" :'JJ',
"किचपिचिया" :'JJ',
"किंचित् स्थूल" :'JJ',
"किण्वित" :'JJ',
"कितना" :'JJ',
"कितव" :'JJ',
"किताबी" :'JJ',
"क़िताबी" :'JJ',
"कित्ता" :'JJ',
"किनहा" :'JJ',
"किनारीदार" :'JJ',
"किनारेदार" :'JJ',
"किनाह" :'JJ',
"किफायतशार" :'JJ',
"किफ़ायतशार" :'JJ',
"किफायती" :'JJ',
"किफ़ायती" :'JJ',
"किरकिरा" :'JJ',
"किरगिज़स्तानी" :'JJ',
"किरघिज़स्तानी" :'JJ',
"किशमिशी" :'JJ',
"किस प्रकार का" :'JJ',
"किसकिसा" :'JJ',
"किस्म-किस्म का" :'JJ',
"क़िस्म-क़िस्म का" :'JJ',
"किस्सागो" :'JJ',
"कीचड़दार" :'JJ',
"कीचड़हा" :'JJ',
"कीचदार" :'JJ',
"कीट भक्षक" :'JJ',
"कीट भक्षी" :'JJ',
"कीट भोजी" :'JJ',
"कीट-नाशक" :'JJ',
"कीट-भक्षक" :'JJ',
"कीट-भक्षी" :'JJ',
"कीट-भोजी" :'JJ',
"कीटनाशक" :'JJ',
"कीटनाशी" :'JJ',
"कीटभक्षक" :'JJ',
"कीटभक्षी" :'JJ',
"कीटभोजी" :'JJ',
"कीटाणुनाशक" :'JJ',
"कीटाणुरहित" :'JJ',
"कीनियाई" :'JJ',
"कीमती" :'JJ',
"क़ीमती" :'JJ',
"कीर्तिमान" :'JJ',
"कीर्तिवंत" :'JJ',
"कीर्तिवन्त" :'JJ',
"कीर्तिशाली" :'JJ',
"कीर्त्तिमान" :'JJ',
"कीर्त्तिवंत" :'JJ',
"कीर्त्तिवन्त" :'JJ',
"कीर्त्तिशाली" :'JJ',
"कीसा" :'JJ',
"कीसा हुआ" :'JJ',
"कुँआरा" :'JJ',
"कुँआरी" :'JJ',
"कुकर्मी" :'JJ',
"कुख्यात" :'JJ',
"कुगठित" :'JJ',
"कुघट" :'JJ',
"कुचला" :'JJ',
"कुचला हुआ" :'JJ',
"कुचालक" :'JJ',
"कुंचित" :'JJ',
"कुचीला" :'JJ',
"कुचेल" :'JJ',
"कुचैला" :'JJ',
"कुछ" :'JJ',
"कुछ कड़वा" :'JJ',
"कुछ कड़ुआ" :'JJ',
"कुछ कड़ुवा" :'JJ',
"कुछ मोटा-सा" :'JJ',
"कुंजित" :'JJ',
"कुटा" :'JJ',
"कुटा हुआ" :'JJ',
"कुटिल" :'JJ',
"कुटुंबयुक्त" :'JJ',
"कुटुंबहीन" :'JJ',
"कुटुंबीय" :'JJ',
"कुटुम्बीय" :'JJ',
"कुटेबी" :'JJ',
"कुंठित" :'JJ',
"कुड़क" :'JJ',
"कुंडलधारी" :'JJ',
"कुंडलाकार" :'JJ',
"कुंडलित" :'JJ',
"कुंडली" :'JJ',
"कुंडलीकृत" :'JJ',
"कुंडीय" :'JJ',
"कुडौल" :'JJ',
"कुण्ठित" :'JJ',
"कुण्डलधारी" :'JJ',
"कुण्डलाकार" :'JJ',
"कुण्डलित" :'JJ',
"कुण्डली" :'JJ',
"कुण्डलीकृत" :'JJ',
"कुण्डीय" :'JJ',
"कुतर्की" :'JJ',
"कुतूहलजनक" :'JJ',
"कुत्सित" :'JJ',
"कुंद" :'JJ',
"कुदरती" :'JJ',
"क़ुदरती" :'JJ',
"कुनकुना" :'JJ',
"कुन्द" :'JJ',
"कुपथ्य" :'JJ',
"कुपाच्य" :'JJ',
"कुपात्र" :'JJ',
"कुपित" :'JJ',
"कुपोषित" :'JJ',
"कुप्रवृत्ति" :'JJ',
"कुप्रसिद्ध" :'JJ',
"कुबड़ा" :'JJ',
"कुबुद्धि" :'JJ',
"कुब्ज" :'JJ',
"कुंभकरणी" :'JJ',
"कुंभकर्णी" :'JJ',
"कुभाषी" :'JJ',
"कुमारिका" :'JJ',
"कुमार्गी" :'JJ',
"कुमुद" :'JJ',
"कुमैड़िया" :'JJ',
"कुम्भकरणी" :'JJ',
"कुम्भकर्णी" :'JJ',
"कुम्हलाया" :'JJ',
"कुरकुरा" :'JJ',
"कुरबान" :'JJ',
"क़ुरबान" :'JJ',
"कुरूप" :'JJ',
"कुर्क" :'JJ',
"क़ुर्क़" :'JJ',
"कुर्बान" :'JJ',
"क़ुर्बान" :'JJ',
"कुल" :'JJ',
"कुल-तारण" :'JJ',
"कुलक्ष" :'JJ',
"कुलक्षण" :'JJ',
"कुलक्षणी" :'JJ',
"कुलक्षन" :'JJ',
"कुलच्छन" :'JJ',
"कुलटा" :'JJ',
"कुलतारण" :'JJ',
"कुलतारन" :'JJ',
"कुलबोरन" :'JJ',
"कुलहीन" :'JJ',
"कुलिखित" :'JJ',
"कुलीन" :'JJ',
"कुलीय" :'JJ',
"कुलेखी" :'JJ',
"कुलोत्पन्न" :'JJ',
"कुवचनी" :'JJ',
"कुंवार" :'JJ',
"कुँवारा" :'JJ',
"कुवारी" :'JJ',
"कुँवारी" :'JJ',
"कुंवारी" :'JJ',
"कुविचारी" :'JJ',
"कुवैती" :'JJ',
"कुव्यसनी" :'JJ',
"कुशल" :'JJ',
"कुशाग्र" :'JJ',
"कुशाग्रबुद्धि" :'JJ',
"कुसुंभी" :'JJ',
"कुसुमरहित" :'JJ',
"कुसुमित" :'JJ',
"कुसुम्भी" :'JJ',
"कुसूरवार" :'JJ',
"क़ुसूरवार" :'JJ',
"कुस्वभावी" :'JJ',
"कूट" :'JJ',
"कूटकार" :'JJ',
"कूटतापूर्ण" :'JJ',
"कूटनीतिक" :'JJ',
"कूटनैतिक" :'JJ',
"कूटसाक्षी" :'JJ',
"कूबड़ा" :'JJ',
"कूल" :'JJ',
"कृत" :'JJ',
"कृतकृत्य" :'JJ',
"कृतघ्न" :'JJ',
"कृतज्ञ" :'JJ',
"कृतार्थ" :'JJ',
"कृत्रिम" :'JJ',
"कृपण" :'JJ',
"कृपानिधि" :'JJ',
"कृपापात्र" :'JJ',
"कृपालु" :'JJ',
"कृपासिंधु" :'JJ',
"कृमि नाशक" :'JJ',
"कृमि नाशी" :'JJ',
"कृमिनाशक" :'JJ',
"कृमिनाशी" :'JJ',
"कृश" :'JJ',
"कृशकाय" :'JJ',
"कृशोदर" :'JJ',
"कृशोदरी" :'JJ',
"कृषि प्रधान" :'JJ',
"कृषि-प्रधान" :'JJ',
"कृष्ण" :'JJ',
"कृष्य" :'JJ',
"केंद्र शासित" :'JJ',
"केंद्र-शासित" :'JJ',
"केंद्रशासित" :'JJ',
"केंद्रित" :'JJ',
"केंद्रीभूत" :'JJ',
"केंद्रीय" :'JJ',
"केन्द्र शासित" :'JJ',
"केन्द्र-शासित" :'JJ',
"केन्द्रशासित" :'JJ',
"केन्द्रित" :'JJ',
"केन्द्रीय" :'JJ',
"केन्यन" :'JJ',
"केन्या-संबंधी" :'JJ',
"केन्याई" :'JJ',
"केयूरी" :'JJ',
"केवड़ई" :'JJ',
"केवल" :'JJ',
"केशरी" :'JJ',
"केशहीन" :'JJ',
"केसरिया" :'JJ',
"केसरी" :'JJ',
"कै करने वाला" :'JJ',
"कैंचा" :'JJ',
"कैटलन" :'JJ',
"कैटेलन" :'JJ',
"कैटेलनी" :'JJ',
"कैतव" :'JJ',
"कैथोलिक" :'JJ',
"कैफी" :'JJ',
"क़ैफ़ी" :'JJ',
"कैरव" :'JJ',
"कैरा" :'JJ',
"कैल्विनवादी" :'JJ',
"कैसा" :'JJ',
"कॉमन" :'JJ',
"कॉरपोरेट" :'JJ',
"कॉर्पोरेट" :'JJ',
"कोई" :'JJ',
"कोई और" :'JJ',
"कोई भी" :'JJ',
"कोई-कोई" :'JJ',
"कोकई" :'JJ',
"कोकणी" :'JJ',
"कोंकणी" :'JJ',
"कोकनी" :'JJ',
"कोंकनी" :'JJ',
"कोखजली" :'JJ',
"कोटि" :'JJ',
"कोटी" :'JJ',
"कोठ" :'JJ',
"कोणयुक्त" :'JJ',
"कोणीय" :'JJ',
"कोफ्ता" :'JJ',
"कोफ़्ता" :'JJ',
"कोमल" :'JJ',
"कोमल स्वभावी" :'JJ',
"कोमलचित" :'JJ',
"कोमलमनस्क" :'JJ',
"कोमलहृदय" :'JJ',
"कोमलांग" :'JJ',
"कोमलांगना" :'JJ',
"कोमलांगिनी" :'JJ',
"कोमलांगी" :'JJ',
"कोमोरियन" :'JJ',
"कोमोरोज़ी" :'JJ',
"कोमोरोसी" :'JJ',
"कोरदार" :'JJ',
"कोरा" :'JJ',
"कोरियन" :'JJ',
"कोरियाई" :'JJ',
"कोलकतिया" :'JJ',
"कोलंबियन" :'JJ',
"कोलंबियाई" :'JJ',
"कोलम्बियन" :'JJ',
"कोलम्बियाई" :'JJ',
"कोलाहलपूर्ण" :'JJ',
"कोल्हापुरी" :'JJ',
"कोविद" :'JJ',
"कोशिकीय" :'JJ',
"कोषेय" :'JJ',
"कोष्ठ ग्राहक" :'JJ',
"कोष्ठ-ग्राहक" :'JJ',
"कौटुंबिक" :'JJ',
"कौटुम्बिक" :'JJ',
"कौड़ियाला" :'JJ',
"कौतुकभरा" :'JJ',
"कौत्स" :'JJ',
"कौमार्यभंजित" :'JJ',
"कौमार्ययुक्त" :'JJ',
"कौमी" :'JJ',
"क़ौमी" :'JJ',
"कौरव" :'JJ',
"क्यूबन" :'JJ',
"क्यूबाई" :'JJ',
"क्यूबिक" :'JJ',
"क्यूबिकल" :'JJ',
"क्रम सूचक" :'JJ',
"क्रम-सूचक" :'JJ',
"क्रमप्राप्त" :'JJ',
"क्रमबद्ध" :'JJ',
"क्रमरहित" :'JJ',
"क्रमसूचक" :'JJ',
"क्रमहीन" :'JJ',
"क्रमागत" :'JJ',
"क्रमानुकूल" :'JJ',
"क्रमानुसार" :'JJ',
"क्रमिक" :'JJ',
"क्रांतिकारी" :'JJ',
"क्रान्तिकारी" :'JJ',
"क्रिओल" :'JJ',
"क्रियान्वित" :'JJ',
"क्रियारहित" :'JJ',
"क्रियाशील" :'JJ',
"क्रियाहीन" :'JJ',
"क्रियोल" :'JJ',
"क्रिस्टलाभ" :'JJ',
"क्रीत" :'JJ',
"क्रुद्ध" :'JJ',
"क्रूर" :'JJ',
"क्रोएशिआई" :'JJ',
"क्रोएशियन" :'JJ',
"क्रोएशियाई" :'JJ',
"क्रोधहीन" :'JJ',
"क्रोधित" :'JJ',
"क्रोधी" :'JJ',
"क्लांत" :'JJ',
"क्लान्त" :'JJ',
"क्लासिकीय" :'JJ',
"क्लिनकल" :'JJ',
"क्लिनिकल" :'JJ',
"क्लिष्ट" :'JJ',
"क्लेशकर" :'JJ',
"क्वारा" :'JJ',
"क्वाँरा" :'JJ',
"क्वारी" :'JJ',
"क्वाँरी" :'JJ',
"क्वॉर्टर" :'JJ',
"क्षणजीवी" :'JJ',
"क्षणभंगुर" :'JJ',
"क्षणिक" :'JJ',
"क्षत" :'JJ',
"क्षत-विक्षत" :'JJ',
"क्षतरहित" :'JJ',
"क्षतविक्षत" :'JJ',
"क्षतिकर" :'JJ',
"क्षतिकारी" :'JJ',
"क्षतिग्रस्त" :'JJ',
"क्षतिहीन" :'JJ',
"क्षत्रिय" :'JJ',
"क्षमतावान" :'JJ',
"क्षमताशाली" :'JJ',
"क्षमताहीन" :'JJ',
"क्षमा कर्ता" :'JJ',
"क्षमा दाता" :'JJ',
"क्षमा प्रार्थी" :'JJ',
"क्षमा याचक" :'JJ',
"क्षमा योग्य" :'JJ',
"क्षमाप्रार्थी" :'JJ',
"क्षमायाची" :'JJ',
"क्षमावान" :'JJ',
"क्षमाशील" :'JJ',
"क्षमित" :'JJ',
"क्षम्य" :'JJ',
"क्षयशील" :'JJ',
"क्षयी" :'JJ',
"क्षात्र" :'JJ',
"क्षारीय" :'JJ',
"क्षितिज" :'JJ',
"क्षीण" :'JJ',
"क्षुद्र" :'JJ',
"क्षुधातुर" :'JJ',
"क्षुधावर्धक" :'JJ',
"क्षुधित" :'JJ',
"क्षुब्ध" :'JJ',
"क्षेत्रीय" :'JJ',
"क्षेपक" :'JJ',
"क्षैतिज" :'JJ',
"क्षोभकारी" :'JJ',
"खँगहा" :'JJ',
"खगीय" :'JJ',
"खगोलीय" :'JJ',
"खजूरी" :'JJ',
"खटपटिया" :'JJ',
"खटमली" :'JJ',
"खटमिट्ठा" :'JJ',
"खटमीठा" :'JJ',
"खटारा" :'JJ',
"खटेटी" :'JJ',
"खट्टन" :'JJ',
"खट्टा" :'JJ',
"खट्टा मीठा" :'JJ',
"खट्टा-चूक" :'JJ',
"खट्टा-मीठा" :'JJ',
"खट्टाचूक" :'JJ',
"खंड-खंड" :'JJ',
"खंडक" :'JJ',
"खंडनशील" :'JJ',
"खंडनीय" :'JJ',
"खंडहीन" :'JJ',
"खड़ा" :'JJ',
"खड़ा हुआ" :'JJ',
"खंडित" :'JJ',
"खण्ड-खण्ड" :'JJ',
"खण्डक" :'JJ',
"खण्डनीय" :'JJ',
"खण्डहीन" :'JJ',
"खण्डित" :'JJ',
"खतम" :'JJ',
"ख़तम" :'JJ',
"खतरनाक" :'JJ',
"ख़तरनाक" :'JJ',
"खत्म" :'JJ',
"ख़त्म" :'JJ',
"खनिज" :'JJ',
"खनित" :'JJ',
"खपड़ैल का" :'JJ',
"खपड़ैला" :'JJ',
"खपरैला" :'JJ',
"खपुआ" :'JJ',
"खफा" :'JJ',
"ख़फ़ा" :'JJ',
"खबरदार" :'JJ',
"ख़बरदार" :'JJ',
"खब्बा" :'JJ',
"खब्बू" :'JJ',
"खमीरी" :'JJ',
"ख़मीरी" :'JJ',
"ख़याली" :'JJ',
"खर" :'JJ',
"खरखर" :'JJ',
"खरजूरी" :'JJ',
"खरतल" :'JJ',
"खरदिमाग" :'JJ',
"खरदिमाग़" :'JJ',
"खरब" :'JJ',
"खरबपति" :'JJ',
"खरा" :'JJ',
"खराब" :'JJ',
"ख़राब" :'JJ',
"खराब होता" :'JJ',
"खरीदा" :'JJ',
"खरीदा हुआ" :'JJ',
"खर्चीला" :'JJ',
"ख़र्चीला" :'JJ',
"खर्जूरी" :'JJ',
"खल" :'JJ',
"खलबली मचाने वाला" :'JJ',
"खलबलीजनक" :'JJ',
"खल्वाट" :'JJ',
"खवैया" :'JJ',
"खसिया" :'JJ',
"खसी" :'JJ',
"खस्ता" :'JJ',
"खस्ताहाल" :'JJ',
"खस्सी" :'JJ',
"ख़स्सी" :'JJ',
"खाऊ" :'JJ',
"खाकसार" :'JJ',
"ख़ाकसार" :'JJ',
"खाकी" :'JJ',
"ख़ाकी" :'JJ',
"खाँखर" :'JJ',
"खातेदार" :'JJ',
"खादक" :'JJ',
"खाद्य" :'JJ',
"खाधूक" :'JJ',
"खानगी" :'JJ',
"खानदानी" :'JJ',
"ख़ानदानी" :'JJ',
"खानाबदोश" :'JJ',
"ख़ानाबदोश" :'JJ',
"खानेवाला" :'JJ',
"खामोश" :'JJ',
"ख़ामोश" :'JJ',
"खाया" :'JJ',
"खाया हुआ" :'JJ',
"खारा" :'JJ',
"खारिज" :'JJ',
"ख़ारिज" :'JJ',
"खालसाई" :'JJ',
"खालिस" :'JJ',
"ख़ालिस" :'JJ',
"खाली" :'JJ',
"ख़ाली" :'JJ',
"खास" :'JJ',
"ख़ास" :'JJ',
"खासगी" :'JJ',
"खासा" :'JJ',
"ख़ासा" :'JJ',
"खिचड़ी" :'JJ',
"खिताबी" :'JJ',
"ख़िताबी" :'JJ',
"खिन्न" :'JJ',
"खिला" :'JJ',
"खिला हुआ" :'JJ',
"खिलाफ" :'JJ',
"खिलाफ़" :'JJ',
"ख़िलाफ़" :'JJ',
"खिल्लीबाज" :'JJ',
"खिल्लीबाज़" :'JJ',
"खिसका" :'JJ',
"खिसिआना" :'JJ',
"खिसियाना" :'JJ',
"खुदगरज" :'JJ',
"ख़ुदग़रज़" :'JJ',
"खुदगर्ज" :'JJ',
"ख़ुदग़र्ज़" :'JJ',
"खुदपरस्त" :'JJ',
"खुदरा" :'JJ',
"खुदा" :'JJ',
"खुदा हुआ" :'JJ',
"खुदाई" :'JJ',
"ख़ुदाई" :'JJ',
"खुद्दार" :'JJ',
"ख़ुद्दार" :'JJ',
"खुफिया" :'JJ',
"ख़ुफ़िया" :'JJ',
"खुरखुरा" :'JJ',
"खुरदरा" :'JJ',
"खुरदुरा" :'JJ',
"खुराफाती" :'JJ',
"खुराफ़ाती" :'JJ',
"ख़ुराफ़ाती" :'JJ',
"खुर्राट" :'JJ',
"खुला" :'JJ',
"खुलासा" :'JJ',
"खुश" :'JJ',
"ख़ुश" :'JJ',
"खुशकिस्मत" :'JJ',
"ख़ुशक़िस्मत" :'JJ',
"खुशखत" :'JJ',
"ख़ुशख़त" :'JJ',
"खुशखतिया" :'JJ',
"ख़ुशख़तिया" :'JJ',
"खुशगवार" :'JJ',
"ख़ुशगवार" :'JJ',
"खुशदिल" :'JJ',
"ख़ुशदिल" :'JJ',
"खुशनसीब" :'JJ',
"ख़ुशनसीब" :'JJ',
"खुशनुमा" :'JJ',
"खुशबूदार" :'JJ',
"ख़ुशबूदार" :'JJ',
"खुशमिज़ाज" :'JJ',
"खुशमिज़ाज़" :'JJ',
"ख़ुशमिज़ाज" :'JJ',
"खुशहाल" :'JJ',
"ख़ुशहाल" :'JJ',
"खुशामदी" :'JJ',
"खुशाल" :'JJ',
"खुश्क" :'JJ',
"ख़ुश्क" :'JJ',
"खूँखार" :'JJ',
"खूँख़ार" :'JJ',
"खूंखार" :'JJ',
"खूंख़ार" :'JJ',
"खूंख्वार" :'JJ',
"खूंख़्वार" :'JJ',
"खूनखोर" :'JJ',
"ख़ूनखोर" :'JJ',
"खूनख्वार" :'JJ',
"ख़ूनख़्वार" :'JJ',
"खूनी" :'JJ',
"ख़ूनी" :'JJ',
"खूब" :'JJ',
"ख़ूब" :'JJ',
"खूब सारा" :'JJ',
"ख़ूब सारा" :'JJ',
"खूबसूरत" :'JJ',
"ख़ूबसूरत" :'JJ',
"खूसट" :'JJ',
"खेचर" :'JJ',
"खेदजनक" :'JJ',
"खेदरहित" :'JJ',
"खेल विषयक" :'JJ',
"खेल संबंधी" :'JJ',
"खेल सम्बन्धी" :'JJ',
"खेल-कूद विषयक" :'JJ',
"खेल-कूद संबंधी" :'JJ',
"खेल-कूद सम्बन्धी" :'JJ',
"खेला हुआ" :'JJ',
"खैरखाह" :'JJ',
"ख़ैरख़ाह" :'JJ',
"खोखला" :'JJ',
"खोजी" :'JJ',
"खोटरहित" :'JJ',
"खोटहीन" :'JJ',
"खोटा" :'JJ',
"खोया" :'JJ',
"खोया हुआ" :'JJ',
"खोल" :'JJ',
"खौफजद" :'JJ',
"ख़ौफ़ज़द" :'JJ',
"खौफजदा" :'JJ',
"ख़ौफ़ज़दा" :'JJ',
"खौफनाक" :'JJ',
"ख़ौफ़नाक" :'JJ',
"ख्यात" :'JJ',
"ख्याति प्राप्त" :'JJ',
"ख्यातिप्राप्त" :'JJ',
"ख्वाहिशमंद" :'JJ',
"ग" :'JJ',
"गगनचुंबी" :'JJ',
"गगनभेदी" :'JJ',
"गगनस्पर्शी" :'JJ',
"गगनीय" :'JJ',
"गज गौना" :'JJ',
"गज-गति" :'JJ',
"गजगति" :'JJ',
"गजगामिनी" :'JJ',
"गजगौनी" :'JJ',
"गजदंती" :'JJ',
"गजदन्ती" :'JJ',
"गजब" :'JJ',
"गज़ब" :'JJ',
"ग़ज़ब" :'JJ',
"गजब का" :'JJ',
"गज़ब का" :'JJ',
"ग़ज़ब का" :'JJ',
"गंजा" :'JJ',
"गजाधर" :'JJ',
"गंजू" :'JJ',
"गँजेड़ी" :'JJ',
"गझिन" :'JJ',
"गठित" :'JJ',
"गठीला" :'JJ',
"गँठीला" :'JJ',
"गंठीला" :'JJ',
"गडंगिया" :'JJ',
"गंडमूर्ख" :'JJ',
"गड़ा" :'JJ',
"गड़ा हुआ" :'JJ',
"गड्डबड्ड" :'JJ',
"गड्डमड्ड" :'JJ',
"गड्डाम" :'JJ',
"गड्डामी" :'JJ',
"गढ़ा" :'JJ',
"गणतंत्रात्मक" :'JJ',
"गणतंत्रिक" :'JJ',
"गणतंत्री" :'JJ',
"गणतंत्रीय" :'JJ',
"गणतन्त्रात्मक" :'JJ',
"गणतन्त्रिक" :'JJ',
"गणतन्त्री" :'JJ',
"गणतन्त्रीय" :'JJ',
"गणतांत्रिक" :'JJ',
"गणतान्त्रिक" :'JJ',
"गणनीय" :'JJ',
"गणमान्य" :'JJ',
"गणितीय" :'JJ',
"गण्डमूर्ख" :'JJ',
"गण्य" :'JJ',
"गत" :'JJ',
"गंतव्य" :'JJ',
"गतानुगतिक" :'JJ',
"गतावधिक" :'JJ',
"गतिपूर्ण" :'JJ',
"गतिमान" :'JJ',
"गतिशील" :'JJ',
"गतिहीन" :'JJ',
"गथिक" :'JJ',
"गदगद" :'JJ',
"गदरा" :'JJ',
"गँदला" :'JJ',
"गंदला" :'JJ',
"गंदा" :'JJ',
"गदाधर" :'JJ',
"गदाधारी" :'JJ',
"गदीला" :'JJ',
"गंदुमी" :'JJ',
"गद्गद" :'JJ',
"गद्दर" :'JJ',
"गद्दार" :'JJ',
"ग़द्दार" :'JJ',
"गद्देदार" :'JJ',
"गद्यात्मक" :'JJ',
"गंधकी" :'JJ',
"गंधयुक्त" :'JJ',
"गंधर्वी" :'JJ',
"गंधर्वीय" :'JJ',
"गंधहीन" :'JJ',
"गंधित" :'JJ',
"गनी" :'JJ',
"ग़नी" :'JJ',
"गन्तव्य" :'JJ',
"गन्दा" :'JJ',
"गन्दुमी" :'JJ',
"गन्धर्वी" :'JJ',
"गन्धर्वीय" :'JJ',
"गपिया" :'JJ',
"गपिहा" :'JJ',
"गपोड़" :'JJ',
"गपोड़बाज़" :'JJ',
"गपोड़ा" :'JJ',
"गपोड़िया" :'JJ',
"गपोड़ी" :'JJ',
"गपोड़ेबाज़" :'JJ',
"गप्पी" :'JJ',
"गप्पोड़ी" :'JJ',
"गफलती" :'JJ',
"ग़फ़लती" :'JJ',
"गबरगंड" :'JJ',
"गबरहा" :'JJ',
"गबाँई" :'JJ',
"गबुनी" :'JJ',
"गबुनीज़" :'JJ',
"गबुनीस" :'JJ',
"गबोनी" :'JJ',
"गबोनीज़" :'JJ',
"गबोनीस" :'JJ',
"गब्बर" :'JJ',
"गंभीर" :'JJ',
"गमकीला" :'JJ',
"गमखोर" :'JJ',
"गमख़ोर" :'JJ',
"ग़मखोर" :'JJ',
"ग़मख़ोर" :'JJ',
"गमगीन" :'JJ',
"ग़मगीन" :'JJ',
"गमनीय" :'JJ',
"गम्भीर" :'JJ',
"गम्य" :'JJ',
"गया-बीता" :'JJ',
"गरजमंद" :'JJ',
"ग़रज़मंद" :'JJ',
"गरजू" :'JJ',
"गरदाखोर" :'JJ',
"गरबीला" :'JJ',
"गरम" :'JJ',
"गरम गरम" :'JJ',
"गरम मिज़ाज" :'JJ',
"गरम-गरम" :'JJ',
"गरमगरम" :'JJ',
"गरमा गरम" :'JJ',
"गरमा-गरम" :'JJ',
"गरमागरम" :'JJ',
"गरारा" :'JJ',
"गरिमापूर्ण" :'JJ',
"गरिमायुक्त" :'JJ',
"गरिमाहीन" :'JJ',
"गरियालू" :'JJ',
"गरिष्ठ" :'JJ',
"गरीदार" :'JJ',
"गरीब" :'JJ',
"ग़रीब" :'JJ',
"ग़रीब नवाज़" :'JJ',
"ग़रीब परवर" :'JJ',
"गरीयुक्त" :'JJ',
"ग़र्ज़ी" :'JJ',
"गर्दखोर" :'JJ',
"गर्दख़ोर" :'JJ',
"गर्दाखोर" :'JJ',
"गर्भ निरोधक" :'JJ',
"गर्भ-निरोधक" :'JJ',
"गर्भज" :'JJ',
"गर्भनिरोधक" :'JJ',
"गर्भवती" :'JJ',
"गर्भस्थ" :'JJ',
"गर्भिणी" :'JJ',
"गर्भित" :'JJ',
"गर्म" :'JJ',
"गर्म गर्म" :'JJ',
"गर्म-गर्म" :'JJ',
"गर्मगर्म" :'JJ',
"गर्मा गर्म" :'JJ',
"गर्मा-गर्म" :'JJ',
"गर्मागर्म" :'JJ',
"गर्वरहित" :'JJ',
"गर्वहीन" :'JJ',
"गर्वित" :'JJ',
"गर्वी" :'JJ',
"गर्वीला" :'JJ',
"गर्हित" :'JJ',
"गलगुथना" :'JJ',
"गलघोंटू" :'JJ',
"गलत" :'JJ',
"ग़लत" :'JJ',
"गलतीरहित" :'JJ',
"गलतीहीन" :'JJ',
"गलतुंडिकीय" :'JJ',
"गलनशील" :'JJ',
"गलाऊ" :'JJ',
"गलाकाट" :'JJ',
"गलीज" :'JJ',
"ग़लीज़" :'JJ',
"गँवई" :'JJ',
"गँवार" :'JJ',
"गंवार" :'JJ',
"गँवारन" :'JJ',
"गँवारिन" :'JJ',
"गवेषित" :'JJ',
"गवैया" :'JJ',
"गवैहाँ" :'JJ',
"गव्य" :'JJ',
"गश्ती" :'JJ',
"गहन" :'JJ',
"गहबर" :'JJ',
"गहरा" :'JJ',
"गहरा काला" :'JJ',
"गांग" :'JJ',
"गाजदार" :'JJ',
"गाँठदार" :'JJ',
"गाँठवाला" :'JJ',
"गाड़ा" :'JJ',
"गाड़ी भर" :'JJ',
"गाढ़ा" :'JJ',
"गाध" :'JJ',
"गांधर्व" :'JJ',
"गाँधीवादी" :'JJ',
"गांधीवादी" :'JJ',
"गान्धर्व" :'JJ',
"गाफिल" :'JJ',
"ग़ाफ़िल" :'JJ',
"गाबाई" :'JJ',
"गाबाँई" :'JJ',
"गाभिन" :'JJ',
"गाभिनी" :'JJ',
"गाम्बिआ-संबंधी" :'JJ',
"गाम्बिआई" :'JJ',
"गाम्बियन" :'JJ',
"गाम्बिया-संबंधी" :'JJ',
"गाम्बियाई" :'JJ',
"गायक" :'JJ',
"गायताल" :'JJ',
"गायब" :'JJ',
"ग़ायब" :'JJ',
"गाया हुआ" :'JJ',
"गारत" :'JJ',
"ग़ारत" :'JJ',
"गारुड़" :'JJ',
"गालिब" :'JJ',
"ग़ालिब" :'JJ',
"गाली देने वाला" :'JJ',
"गाली-गलौज करने वाला" :'JJ',
"गालू" :'JJ',
"गावदी" :'JJ',
"गावदुम" :'JJ',
"गावदुमा" :'JJ',
"गाँसदार" :'JJ',
"गिचपिच" :'JJ',
"गिना हुआ" :'JJ',
"गिना-चुना" :'JJ',
"गिनाचुना" :'JJ',
"गिरफ्तार" :'JJ',
"गिरफ़्तार" :'JJ',
"गिरहकट" :'JJ',
"गिरहदार" :'JJ',
"गिरा" :'JJ',
"गिरा हुआ" :'JJ',
"गिरा-पड़ा" :'JJ',
"गिरीदार" :'JJ',
"गिरीयुक्त" :'JJ',
"गीदड़" :'JJ',
"गीला" :'JJ',
"गीली" :'JJ',
"गुजरा" :'JJ',
"गुज़रा" :'JJ',
"गुजराती" :'JJ',
"गुंजरित" :'JJ',
"गुंजान" :'JJ',
"गुंजायमान" :'JJ',
"गुंजित" :'JJ',
"गुञ्जित" :'JJ',
"गुट्टा" :'JJ',
"गुठला" :'JJ',
"गुड़ीला" :'JJ',
"गुणकारी" :'JJ',
"गुणग्राहक" :'JJ',
"गुणग्राही" :'JJ',
"गुणनिधान" :'JJ',
"गुणयुक्त" :'JJ',
"गुणरहित" :'JJ',
"गुणवंत" :'JJ',
"गुणवत्तायुक्त" :'JJ',
"गुणवत्तारहित" :'JJ',
"गुणवत्ताहीन" :'JJ',
"गुणवान" :'JJ',
"गुणशाली" :'JJ',
"गुणहीन" :'JJ',
"गुणाकर" :'JJ',
"गुणान्वित" :'JJ',
"गुणित" :'JJ',
"गुणी" :'JJ',
"गुनगुना" :'JJ',
"गुनहगार" :'JJ',
"गुनहीन" :'JJ',
"गुनाहगार" :'JJ',
"गुनाही" :'JJ',
"गुप्त" :'JJ',
"गुप्तकालीन" :'JJ',
"गुफावासी" :'JJ',
"गुंबजदार" :'JJ',
"गुम" :'JJ',
"गुमनाम" :'JJ',
"गुमराह" :'JJ',
"गुमशुदा" :'JJ',
"गुमसुम" :'JJ',
"गुम्बजदार" :'JJ',
"गुयनाई" :'JJ',
"गुयनीज़" :'JJ',
"गुयनीस" :'JJ',
"गुयानाई" :'JJ',
"गुरुकुलवासी" :'JJ',
"गुरुवारी" :'JJ',
"गुर्विणी" :'JJ',
"गुल" :'JJ',
"गुल अब्बासी" :'JJ',
"गुल बदन" :'JJ',
"गुल-अब्बासी" :'JJ',
"गुल-बदन" :'JJ',
"गुलअब्बासी" :'JJ',
"गुलगुल" :'JJ',
"गुलगुला" :'JJ',
"गुलगोथना" :'JJ',
"गुलजार" :'JJ',
"गुलज़ार" :'JJ',
"गुलबदन" :'JJ',
"गुलाबी" :'JJ',
"गुलाम" :'JJ',
"ग़ुलाम" :'JJ',
"गुस्ताख" :'JJ',
"गुस्ताख़" :'JJ',
"गुस्सावर" :'JJ',
"गुस्सैल" :'JJ',
"गुहारी" :'JJ',
"गुहावासी" :'JJ',
"गूँगा" :'JJ',
"गूंगा" :'JJ',
"गूढ़" :'JJ',
"गूथा हुआ" :'JJ',
"गूँथा हुआ" :'JJ',
"गूदारहित" :'JJ',
"गूदेदार" :'JJ',
"गृह निर्मित" :'JJ',
"गृह-संबंधी" :'JJ',
"गृहनिर्मित" :'JJ',
"गृहविहीन" :'JJ',
"गृहस्थ" :'JJ',
"गृहस्थ आश्रमी" :'JJ',
"गृहस्थाश्रमी" :'JJ',
"गृहहीन" :'JJ',
"गृहीत" :'JJ',
"गृहीय" :'JJ',
"गृहोपयोगी" :'JJ',
"गृह्य" :'JJ',
"गेंदई" :'JJ',
"गेय" :'JJ',
"गेरुआ" :'JJ',
"गेहुआँ" :'JJ',
"गेहुँआ" :'JJ',
"गैम्बिआई" :'JJ',
"गैम्बियन" :'JJ',
"गैम्बियाई" :'JJ',
"गैर" :'JJ',
"ग़ैर" :'JJ',
"गैर आबाद" :'JJ',
"ग़ैर आबाद" :'JJ',
"गैर का" :'JJ',
"ग़ैर का" :'JJ',
"गैर कानूनी" :'JJ',
"ग़ैर क़ानूनी" :'JJ',
"गैर कृषि" :'JJ',
"ग़ैर कृषि" :'JJ',
"गैर जरूरी" :'JJ',
"ग़ैर ज़रूरी" :'JJ',
"गैर बराबर" :'JJ',
"गैर महत्वपूर्ण" :'JJ',
"ग़ैर महत्वपूर्ण" :'JJ',
"गैर लाइसेन्सी" :'JJ',
"ग़ैर लाइसेन्सी" :'JJ',
"गैर लाइसेंसी" :'JJ',
"ग़ैर लाइसेंसी" :'JJ',
"गैर शादीशुदा" :'JJ',
"ग़ैर शादीशुदा" :'JJ',
"गैर समाजी" :'JJ',
"ग़ैर समाजी" :'JJ',
"गैर सरकारी" :'JJ',
"ग़ैर सरकारी" :'JJ',
"गैर सामाजिक" :'JJ',
"ग़ैर सामाजिक" :'JJ',
"गैर-कानूनी" :'JJ',
"ग़ैर-क़ानूनी" :'JJ',
"गैर-कृषि" :'JJ',
"ग़ैर-कृषि" :'JJ',
"गैर-जिम्मेदार" :'JJ',
"ग़ैर-ज़िम्मेदार" :'JJ',
"गैर-पेशवराना" :'JJ',
"ग़ैर-पेशवराना" :'JJ',
"गैर-रिवायती" :'JJ',
"ग़ैर-रिवायती" :'JJ',
"गैर-समाजी" :'JJ',
"ग़ैर-समाजी" :'JJ',
"गैर-सामाजिक" :'JJ',
"ग़ैर-सामाजिक" :'JJ',
"गैरआबाद" :'JJ',
"ग़ैरआबाद" :'JJ',
"गैरकानूनी" :'JJ',
"ग़ैरक़ानूनी" :'JJ',
"गैरजरूरी" :'JJ',
"ग़ैरज़रूरी" :'JJ',
"गैरजिम्मेदार" :'JJ',
"ग़ैरज़िम्मेदार" :'JJ',
"गैरतकनीकी" :'JJ',
"ग़ैरतकनीकी" :'JJ',
"गैरतमंद" :'JJ',
"ग़ैरतमंद" :'JJ',
"गैरतमन्द" :'JJ',
"ग़ैरतमन्द" :'JJ',
"गैरबराबर" :'JJ',
"गैरमनकूला" :'JJ',
"गैरमामूली" :'JJ',
"ग़ैरमामूली" :'JJ',
"ग़ैरमियादी" :'JJ',
"गैरमिलनसार" :'JJ',
"ग़ैरमिलनसार" :'JJ',
"गैरमुल्की" :'JJ',
"ग़ैरमुल्की" :'JJ',
"गैरमुस्तकिल" :'JJ',
"ग़ैरमुस्तक़िल" :'JJ',
"गैरमौजूद" :'JJ',
"ग़ैरमौज़ूद" :'JJ',
"गैररिवायती" :'JJ',
"ग़ैररिवायती" :'JJ',
"ग़ैरवाजिब" :'JJ',
"गैरवैधानिक" :'JJ',
"गैरसमाजी" :'JJ',
"ग़ैरसमाजी" :'JJ',
"गैरसरकारी" :'JJ',
"ग़ैरसरकारी" :'JJ',
"गैरसामाजिक" :'JJ',
"ग़ैरसामाजिक" :'JJ',
"गैरहाजिर" :'JJ',
"ग़ैरहाज़िर" :'JJ',
"गैरिक" :'JJ',
"गैलिक" :'JJ',
"गैसीय" :'JJ',
"गॉथिक" :'JJ',
"गोचर" :'JJ',
"गोंड़ी" :'JJ',
"गोताखोर" :'JJ',
"ग़ोताख़ोर" :'JJ',
"गोतिया" :'JJ',
"गोती" :'JJ',
"गोतीत" :'JJ',
"गोत्र प्रवर्तक" :'JJ',
"गोत्र-प्रवर्तक" :'JJ',
"गोत्रकार" :'JJ',
"गोत्रज" :'JJ',
"गोत्री" :'JJ',
"गोत्रीय" :'JJ',
"गोथिक" :'JJ',
"गोद लिया" :'JJ',
"गोंदीला" :'JJ',
"गोपनीय" :'JJ',
"गोप्य" :'JJ',
"गोबरहा" :'JJ',
"गोरख पंथी" :'JJ',
"गोरख-पंथी" :'JJ',
"गोरखपंथी" :'JJ',
"गोरा" :'JJ',
"गोरा चिट्टा" :'JJ',
"गोरा भभूका" :'JJ',
"गोरा-चिट्टा" :'JJ',
"गोरा-भभूका" :'JJ',
"गोराचिट्टा" :'JJ',
"गोल" :'JJ',
"गोल-गोल" :'JJ',
"गोल-मटोल" :'JJ',
"गोल-मोल" :'JJ',
"गोलगोल" :'JJ',
"गोलमटोल" :'JJ',
"गोलमोल" :'JJ',
"गोलाकार" :'JJ',
"गोली-सह" :'JJ',
"गौटमालन" :'JJ',
"गौटमालाई" :'JJ',
"गौटेमालन" :'JJ',
"गौटेमालाई" :'JJ',
"गौण" :'JJ',
"गौनहाई" :'JJ',
"गौरतलब" :'JJ',
"ग़ौरतलब" :'JJ',
"गौरवपूर्ण" :'JJ',
"गौरवमय" :'JJ',
"गौरवयुक्त" :'JJ',
"गौरवशाली" :'JJ',
"गौरवहीन" :'JJ',
"गौरवान्वित" :'JJ',
"ग्यारह" :'JJ',
"ग्यारहवाँ" :'JJ',
"ग्रंथित" :'JJ',
"ग्रन्थित" :'JJ',
"ग्रसित" :'JJ',
"ग्रस्त" :'JJ',
"ग्रहक" :'JJ',
"ग्रहणीय" :'JJ',
"ग्रहीत" :'JJ',
"ग्रहीता" :'JJ',
"ग्रांथिक" :'JJ',
"ग्रामज" :'JJ',
"ग्रामवासिनी" :'JJ',
"ग्रामवासी" :'JJ',
"ग्रामिक" :'JJ',
"ग्रामिणी" :'JJ',
"ग्रामीण" :'JJ',
"ग्रामीय" :'JJ',
"ग्राम्य" :'JJ',
"ग्राहक" :'JJ',
"ग्राह्य" :'JJ',
"ग्रीक" :'JJ',
"ग्रीनलैंडर" :'JJ',
"ग्रीनलैंडी" :'JJ',
"ग्रीनलैण्डर" :'JJ',
"ग्रीनलैण्डी" :'JJ',
"ग्रीष्म कालीन" :'JJ',
"ग्रीष्मकालीन" :'JJ',
"ग्रीष्मीय" :'JJ',
"ग्रे" :'JJ',
"ग्रेनाडाई" :'JJ',
"ग्रेनाडियन" :'JJ',
"ग्रेनैडाई" :'JJ',
"ग्रेनैडियन" :'JJ',
"ग्रोनलैंडर" :'JJ',
"ग्रोनलैंडी" :'JJ',
"ग्रोनलैण्डर" :'JJ',
"ग्रोनलैण्डी" :'JJ',
"ग्लोबल" :'JJ',
"घटता" :'JJ',
"घटता हुआ" :'JJ',
"घटनात्मक" :'JJ',
"घटनीय" :'JJ',
"घटा" :'JJ',
"घटा हुआ" :'JJ',
"घटित" :'JJ',
"घटिया" :'JJ',
"घट्य" :'JJ',
"घड़ियाली" :'JJ',
"घनघोर" :'JJ',
"घनचक्कर" :'JJ',
"घना" :'JJ',
"घनाकार" :'JJ',
"घनिष्ठ" :'JJ',
"घनेरा" :'JJ',
"घबराया" :'JJ',
"घबराया हुआ" :'JJ',
"घमंडरहित" :'JJ',
"घमंडी" :'JJ',
"घमण्डी" :'JJ',
"घमसान" :'JJ',
"घमासान" :'JJ',
"घर-फोड़ना" :'JJ',
"घरफोड़ना" :'JJ',
"घरू" :'JJ',
"घरेलू" :'JJ',
"घाटी" :'JJ',
"घातक" :'JJ',
"घातकी" :'JJ',
"घानाई" :'JJ',
"घामड़" :'JJ',
"घायल" :'JJ',
"घालक" :'JJ',
"घिचपिच" :'JJ',
"घिनौना" :'JJ',
"घिरा" :'JJ',
"घिसा पिटा" :'JJ',
"घिसा-पिटा" :'JJ',
"घुँघराला" :'JJ',
"घुँघरूदार" :'JJ',
"घुन्ना" :'JJ',
"घुमक्कड़" :'JJ',
"घुमंतू" :'JJ',
"घुमना" :'JJ',
"घुमन्तू" :'JJ',
"घुमा" :'JJ',
"घुमा हुआ" :'JJ',
"घुमाया हुआ" :'JJ',
"घुमावदार" :'JJ',
"घुलनशील" :'JJ',
"घुसा हुआ" :'JJ',
"घूँघरदार" :'JJ',
"घूना" :'JJ',
"घूमता हुआ" :'JJ',
"घूमनेवाला" :'JJ',
"घूसखोर" :'JJ',
"घूसख़ोर" :'JJ',
"घृणास्पद" :'JJ',
"घृणित" :'JJ',
"घेराबंध" :'JJ',
"घैहल" :'JJ',
"घैहा" :'JJ',
"घोखू" :'JJ',
"घोंखू" :'JJ',
"घोंघा" :'JJ',
"घोंटने वाला" :'JJ',
"घोटू" :'JJ',
"घोंटू" :'JJ',
"घोर" :'JJ',
"घोष" :'JJ',
"घोषित" :'JJ',
"घौहा" :'JJ',
"चउवन" :'JJ',
"चउवनवाँ" :'JJ',
"चकनाचूर" :'JJ',
"चकमाकी" :'JJ',
"चकमेबाज" :'JJ',
"चकमेबाज़" :'JJ',
"चकाचक" :'JJ',
"चकाचौंधपूर्ण" :'JJ',
"चकित" :'JJ',
"चक्करदार" :'JJ',
"चक्र-चर" :'JJ',
"चक्रचर" :'JJ',
"चक्रवर्ती" :'JJ',
"चक्राकार" :'JJ',
"चक्रीय" :'JJ',
"चक्षुहीन" :'JJ',
"चखा" :'JJ',
"चखा हुआ" :'JJ',
"चंगा" :'JJ',
"चंचल" :'JJ',
"चंचलतारहित" :'JJ',
"चचाजाद" :'JJ',
"चचिया" :'JJ',
"चचियाउत" :'JJ',
"चचेरा" :'JJ',
"चंट" :'JJ',
"चटक" :'JJ',
"चटकदार" :'JJ',
"चटकारा" :'JJ',
"चटकीला" :'JJ',
"चटखारा" :'JJ',
"चटपटा" :'JJ',
"चटाखेदार" :'JJ',
"चटोर" :'JJ',
"चटोरा" :'JJ',
"चट्टानी" :'JJ',
"चंड" :'JJ',
"चंडिका" :'JJ',
"चंडी" :'JJ',
"चंडूल" :'JJ',
"चढ़ा" :'JJ',
"चढ़ाऊ" :'JJ',
"चण्डिका" :'JJ',
"चण्डी" :'JJ',
"चतरभंगा" :'JJ',
"चतुर" :'JJ',
"चतुर-चालाक" :'JJ',
"चतुर्गुण" :'JJ',
"चतुर्थ" :'JJ',
"चतुर्थिक" :'JJ',
"चतुर्दश" :'JJ',
"चतुर्भुज" :'JJ',
"चतुर्भुजा" :'JJ',
"चतुष्कोण" :'JJ',
"चंद" :'JJ',
"चंदनी" :'JJ',
"चँदला" :'JJ',
"चंदला" :'JJ',
"चंद्र विकासी" :'JJ',
"चंद्र-विकासी" :'JJ',
"चंद्रमुखी" :'JJ',
"चंद्रमौली" :'JJ',
"चंद्रवंशी" :'JJ',
"चंद्रवंशीय" :'JJ',
"चंद्रवंश्य" :'JJ',
"चंद्राकार" :'JJ',
"चन्द" :'JJ',
"चन्द्रमुखी" :'JJ',
"चन्द्रवंशी" :'JJ',
"चन्द्रवंशीय" :'JJ',
"चन्द्रवंश्य" :'JJ',
"चन्द्राकार" :'JJ',
"चंपई" :'JJ',
"चपटा" :'JJ',
"चपटी नाक वाला" :'JJ',
"चंपत" :'JJ',
"चपल" :'JJ',
"चभोक" :'JJ',
"चम चम" :'JJ',
"चमकता" :'JJ',
"चमकता-दमकता" :'JJ',
"चमकदार" :'JJ',
"चमकीला" :'JJ',
"चमचम" :'JJ',
"चमचमाता" :'JJ',
"चमचा" :'JJ',
"चमत्कारपूर्ण" :'JJ',
"चमत्कारी" :'JJ',
"चमत्कृत" :'JJ',
"चमरौधा" :'JJ',
"चमाऊ" :'JJ',
"चमाचम" :'JJ',
"चमारी" :'JJ',
"चमौवा" :'JJ',
"चम्पई" :'JJ',
"चयन कृत" :'JJ',
"चयनित" :'JJ',
"चयनीय" :'JJ',
"चयित" :'JJ',
"चर" :'JJ',
"चरणबद्ध" :'JJ',
"चरपरा" :'JJ',
"चरपहिया" :'JJ',
"चरबीदार" :'JJ',
"चरम" :'JJ',
"चरमपंथी" :'JJ',
"चरमपन्थी" :'JJ',
"चराचर" :'JJ',
"चरितार्थ" :'JJ',
"चरित्रवती" :'JJ',
"चरित्रवान" :'JJ',
"चरित्रहीन" :'JJ',
"चरित्रहीना" :'JJ',
"चर्चित" :'JJ',
"चर्बीदार" :'JJ',
"चर्म" :'JJ',
"चर्मी" :'JJ',
"चल" :'JJ',
"चल अचल" :'JJ',
"चल-अचल" :'JJ',
"चलता" :'JJ',
"चलनसार" :'JJ',
"चलबाँक" :'JJ',
"चलाऊ" :'JJ',
"चलाचल" :'JJ',
"चलायमान" :'JJ',
"चलिष्णु" :'JJ',
"चवर्गीय" :'JJ',
"चवालीस" :'JJ',
"चवालीसवाँ" :'JJ',
"चश्मदीद" :'JJ',
"चस्पाँ" :'JJ',
"चहेड़ी" :'JJ',
"चहेता" :'JJ',
"चाइनीज़" :'JJ',
"चाइनीस" :'JJ',
"चाई" :'JJ',
"चाईं" :'JJ',
"चाक-चौबंद" :'JJ',
"चाकचौबंद" :'JJ',
"चाक्षुष" :'JJ',
"चाटने योग्य" :'JJ',
"चाटा" :'JJ',
"चाटा हुआ" :'JJ',
"चाटुकार" :'JJ',
"चाटुकीय" :'JJ',
"चाटू" :'JJ',
"चाड-संबंधी" :'JJ',
"चाडियन" :'JJ',
"चाडी" :'JJ',
"चातुर्थक" :'JJ',
"चातुर्थिक" :'JJ',
"चातुर्दश" :'JJ',
"चातुर्दशिक" :'JJ',
"चातुर्मास" :'JJ',
"चातुर्मासिक" :'JJ',
"चाँद जैसा" :'JJ',
"चांद जैसा" :'JJ',
"चाँद सा" :'JJ',
"चांद सा" :'JJ',
"चाँद-सा" :'JJ',
"चांद-सा" :'JJ',
"चाँदनी" :'JJ',
"चांदनी" :'JJ',
"चाँदी का" :'JJ',
"चाँद्र" :'JJ',
"चांद्र" :'JJ',
"चान्द्र" :'JJ',
"चापलूस" :'JJ',
"चामत्कारिक" :'JJ',
"चामीकर" :'JJ',
"चायक" :'JJ',
"चार" :'JJ',
"चार गुना" :'JJ',
"चार सितारा" :'JJ',
"चार सौ" :'JJ',
"चार सौ बीस" :'JJ',
"चार-सौ-बीस" :'JJ',
"चारगुना" :'JJ',
"चारतरफा" :'JJ',
"चारतरफ़ा" :'JJ',
"चारतारंकित" :'JJ',
"चारतारा" :'JJ',
"चारपहिया" :'JJ',
"चारलड़" :'JJ',
"चारसौ" :'JJ',
"चारी" :'JJ',
"चारु" :'JJ',
"चारुलोचन" :'JJ',
"चारू" :'JJ',
"चारेक" :'JJ',
"चालक" :'JJ',
"चालाक" :'JJ',
"चालित" :'JJ',
"चालिस" :'JJ',
"चालिसवाँ" :'JJ',
"चालिसवां" :'JJ',
"चालिसेक" :'JJ',
"चालीस" :'JJ',
"चालीसवाँ" :'JJ',
"चालीसवां" :'JJ',
"चालीसेक" :'JJ',
"चालू" :'JJ',
"चिकट" :'JJ',
"चिकना" :'JJ',
"चिकनी" :'JJ',
"चिकित्सकीय" :'JJ',
"चिकित्सा" :'JJ',
"चिकित्सातीत" :'JJ',
"चिकित्सित" :'JJ',
"चिकित्सीय" :'JJ',
"चिकित्स्य" :'JJ',
"चिकीर्षक" :'JJ',
"चिकीर्षित" :'JJ',
"चिकीर्ष्य" :'JJ',
"चिक्कट" :'JJ',
"चिक्कण" :'JJ',
"चिक्कन" :'JJ',
"चिड़चिड़ा" :'JJ',
"चिढ़ाने वाला" :'JJ',
"चिढ़ानेवाला" :'JJ',
"चित" :'JJ',
"चितकबरा" :'JJ',
"चिंतनशील" :'JJ',
"चिंतनीय" :'JJ',
"चितला" :'JJ',
"चिंताग्रस्त" :'JJ',
"चिंताजनक" :'JJ',
"चिंतामुक्त" :'JJ',
"चिंतायुक्त" :'JJ',
"चिंतारहित" :'JJ',
"चिंताहीन" :'JJ',
"चिंतित" :'JJ',
"चित्त" :'JJ',
"चित्त-कलित" :'JJ',
"चित्तग्राही" :'JJ',
"चित्ताकर्षक" :'JJ',
"चित्तीदार" :'JJ',
"चिंत्य" :'JJ',
"चित्रमय" :'JJ',
"चित्रांकित" :'JJ',
"चित्राक्ष" :'JJ',
"चित्रात्मक" :'JJ',
"चित्रायुध" :'JJ',
"चित्रित" :'JJ',
"चित्रीय" :'JJ',
"चित्रोपम" :'JJ',
"चिन्तनशील" :'JJ',
"चिन्ताग्रस्त" :'JJ',
"चिन्तायुक्त" :'JJ',
"चिन्तारहित" :'JJ',
"चिन्ताहीन" :'JJ',
"चिन्तित" :'JJ',
"चिन्मय" :'JJ',
"चिन्हित" :'JJ',
"चिपका" :'JJ',
"चिपका हुआ" :'JJ',
"चिपकू" :'JJ',
"चिपचिपा" :'JJ',
"चिपटा" :'JJ',
"चिबिल्ला" :'JJ',
"चिबुक संबंधी" :'JJ',
"चिमड़ा" :'JJ',
"चिम्मड़" :'JJ',
"चिर-गामी" :'JJ',
"चिर-परिचित" :'JJ',
"चिर-स्थाई" :'JJ',
"चिर-स्थायी" :'JJ',
"चिरकालिक" :'JJ',
"चिरकालीन" :'JJ',
"चिरगामी" :'JJ',
"चिरचिरा" :'JJ',
"चिरंजी" :'JJ',
"चिरंजीव" :'JJ',
"चिरजीवी" :'JJ',
"चिरंजीवी" :'JJ',
"चिरंतन" :'JJ',
"चिरपरिचित" :'JJ',
"चिरयुवा" :'JJ',
"चिरयौवनपूर्ण" :'JJ',
"चिरस्थाई" :'JJ',
"चिरस्थायी" :'JJ',
"चिरायु" :'JJ',
"चिरौंजीदार" :'JJ',
"चिरौंजीयुक्त" :'JJ',
"चिलकता" :'JJ',
"चिलचिलाता" :'JJ',
"चिलबिला" :'JJ',
"चिलहला" :'JJ',
"चिलियन" :'JJ',
"चिह्नित" :'JJ',
"चीतल" :'JJ',
"चीन का" :'JJ',
"चीनी" :'JJ',
"चीनीयुक्त" :'JJ',
"चीमड़" :'JJ',
"चीमर" :'JJ',
"चीर्ण" :'JJ',
"चुकता" :'JJ',
"चुकाया हुआ" :'JJ',
"चुगद" :'JJ',
"चुग़द" :'JJ',
"चुगलखोर" :'JJ',
"चुग़लख़ोर" :'JJ',
"चुग़लीखोर" :'JJ',
"चुगुलखोर" :'JJ',
"चुटकी भर" :'JJ',
"चुटकीभर" :'JJ',
"चुटीला" :'JJ',
"चुनचुना" :'JJ',
"चुनटदार" :'JJ',
"चुननदार" :'JJ',
"चुना" :'JJ',
"चुना हुआ" :'JJ',
"चुना-चुनाया" :'JJ',
"चुनावी" :'JJ',
"चुनिंदा" :'JJ',
"चुनिन्दा" :'JJ',
"चुनौतीपूर्ण" :'JJ',
"चुनौतीभरा" :'JJ',
"चुनौतीयुक्त" :'JJ',
"चुन्नटदार" :'JJ',
"चुप" :'JJ',
"चुपड़ा" :'JJ',
"चुपड़ा हुआ" :'JJ',
"चुप्प" :'JJ',
"चुप्पा" :'JJ',
"चुंबकीय" :'JJ',
"चुभता" :'JJ',
"चुभता हुआ" :'JJ',
"चुभनशील" :'JJ',
"चुभने वाला" :'JJ',
"चुम्बकीय" :'JJ',
"चुरचुरा" :'JJ',
"चुरमुरा" :'JJ',
"चुराया" :'JJ',
"चुलबुला" :'JJ',
"चुस्त" :'JJ',
"चूक" :'JJ',
"चूड़ीदार" :'JJ',
"चूतिया" :'JJ',
"चूर" :'JJ',
"चूर-चूर" :'JJ',
"चूरचूर" :'JJ',
"चूर्णित" :'JJ',
"चूषणीय" :'JJ',
"चूष्य" :'JJ',
"चूसनीय" :'JJ',
"चेक" :'JJ',
"चेचकरू" :'JJ',
"चेतन" :'JJ',
"चेतनायुक्त" :'JJ',
"चेतनारहित" :'JJ',
"चेतनाशून्य" :'JJ',
"चेतनाहीन" :'JJ',
"चेहरा संबंधी" :'JJ',
"चेहरे का" :'JJ',
"चैतन्य" :'JJ',
"चैती" :'JJ',
"चॉकलेटी" :'JJ',
"चोंक" :'JJ',
"चोंकीला" :'JJ',
"चोखा" :'JJ',
"चोचलेबाज" :'JJ',
"चोचलेबाज़" :'JJ',
"चोंचलेबाज" :'JJ',
"चोंचलेबाज़" :'JJ',
"चोटिल" :'JJ',
"चौआलिस" :'JJ',
"चौंआलिस" :'JJ',
"चौआलिसवाँ" :'JJ',
"चौंआलिसवाँ" :'JJ',
"चौकन्ना" :'JJ',
"चौकस" :'JJ',
"चौकोन" :'JJ',
"चौकोना" :'JJ',
"चौकोर" :'JJ',
"चौखूँट" :'JJ',
"चौखूँटा" :'JJ',
"चौगुना" :'JJ',
"चौड़ा" :'JJ',
"चौतरफा" :'JJ',
"चौतरफ़ा" :'JJ',
"चौतिस" :'JJ',
"चौंतिस" :'JJ',
"चौतिसवाँ" :'JJ',
"चौंतिसवाँ" :'JJ',
"चौतीस" :'JJ',
"चौंतीस" :'JJ',
"चौतीसवाँ" :'JJ',
"चौंतीसवाँ" :'JJ',
"चौथा" :'JJ',
"चौथाई" :'JJ',
"चौथिया" :'JJ',
"चौदह" :'JJ',
"चौदहवाँ" :'JJ',
"चौदाँत" :'JJ',
"चौपट" :'JJ',
"चौपर्त" :'JJ',
"चौपहिया" :'JJ',
"चौबीस" :'JJ',
"चौबीसवाँ" :'JJ',
"चौबीसवां" :'JJ',
"चौमास" :'JJ',
"चौमासा" :'JJ',
"चौमासी" :'JJ',
"चौरंग" :'JJ',
"चौरंगा" :'JJ',
"चौरस" :'JJ',
"चौरानबे" :'JJ',
"चौरानबेवाँ" :'JJ',
"चौरानवे" :'JJ',
"चौरानवेवाँ" :'JJ',
"चौरासी" :'JJ',
"चौंरासी" :'JJ',
"चौरासीवाँ" :'JJ',
"चौंरासीवाँ" :'JJ',
"चौलड़" :'JJ',
"चौवन" :'JJ',
"चौवनवाँ" :'JJ',
"चौवालिस" :'JJ',
"चौंवालिस" :'JJ',
"चौवालिसवाँ" :'JJ',
"चौंवालिसवाँ" :'JJ',
"चौसठ" :'JJ',
"चौंसठ" :'JJ',
"चौसठवाँ" :'JJ',
"चौसिंघा" :'JJ',
"चौसिंहा" :'JJ',
"चौहत्तर" :'JJ',
"चौंहत्तर" :'JJ',
"चौहत्तरवाँ" :'JJ',
"चौंहत्तरवाँ" :'JJ',
"चौहरा" :'JJ',
"च्युत" :'JJ',
"च्यूत" :'JJ',
"छः" :'JJ',
"छः सौ" :'JJ',
"छकाछक" :'JJ',
"छंगा" :'JJ',
"छःगुना" :'JJ',
"छंगू" :'JJ',
"छँटा" :'JJ',
"छँटा हुआ" :'JJ',
"छठवाँ" :'JJ',
"छठा" :'JJ',
"छठाँ" :'JJ',
"छतनार" :'JJ',
"छत्तीस" :'JJ',
"छत्तीसगढ़िया" :'JJ',
"छत्तीसगढ़ी" :'JJ',
"छत्तीसवाँ" :'JJ',
"छत्रधारी" :'JJ',
"छत्रपति" :'JJ',
"छंदबद्ध" :'JJ',
"छंदात्मक" :'JJ',
"छंदोबद्ध" :'JJ',
"छद्म" :'JJ',
"छद्मपूर्ण" :'JJ',
"छद्महीन" :'JJ',
"छना" :'JJ',
"छना हुआ" :'JJ',
"छन्दबद्ध" :'JJ',
"छन्दोबद्ध" :'JJ',
"छपा" :'JJ',
"छपा हुआ" :'JJ',
"छप्पन" :'JJ',
"छप्पनवाँ" :'JJ',
"छबीला" :'JJ',
"छब्बीस" :'JJ',
"छब्बीसवाँ" :'JJ',
"छमाही" :'JJ',
"छरहरा" :'JJ',
"छलकता" :'JJ',
"छलकता हुआ" :'JJ',
"छलकाया" :'JJ',
"छलकाया हुआ" :'JJ',
"छलपूर्ण" :'JJ',
"छलमय" :'JJ',
"छलरहित" :'JJ',
"छलहीन" :'JJ',
"छलिया" :'JJ',
"छली" :'JJ',
"छल्लेदार" :'JJ',
"छह" :'JJ',
"छह सौ" :'JJ',
"छहगुना" :'JJ',
"छाछठ" :'JJ',
"छाछठवाँ" :'JJ',
"छात्रावासी" :'JJ',
"छाना" :'JJ',
"छापामार" :'JJ',
"छाम" :'JJ',
"छामोदरी" :'JJ',
"छायादार" :'JJ',
"छासठ" :'JJ',
"छासठवाँ" :'JJ',
"छाँहदार" :'JJ',
"छिछला" :'JJ',
"छिछोरा" :'JJ',
"छिट-पुट" :'JJ',
"छिटपुट" :'JJ',
"छितराया" :'JJ',
"छिद्रक" :'JJ',
"छिद्रयुक्त" :'JJ',
"छिद्ररहित" :'JJ',
"छिद्रहीन" :'JJ',
"छिद्रान्वेषक" :'JJ',
"छिद्रान्वेषी" :'JJ',
"छिद्रित" :'JJ',
"छिद्रिल" :'JJ',
"छिद्रीय" :'JJ',
"छिनाल" :'JJ',
"छिन्न" :'JJ',
"छिन्न-भिन्न" :'JJ',
"छिपा" :'JJ',
"छिपा हुआ" :'JJ',
"छियानबे" :'JJ',
"छियानबेवाँ" :'JJ',
"छियानवे" :'JJ',
"छियानवेवाँ" :'JJ',
"छियालिस" :'JJ',
"छियालिसवाँ" :'JJ',
"छियालीस" :'JJ',
"छियालीसवाँ" :'JJ',
"छियासठ" :'JJ',
"छियासठवाँ" :'JJ',
"छियासी" :'JJ',
"छियासीवाँ" :'JJ',
"छिरहा" :'JJ',
"छिला" :'JJ',
"छिला हुआ" :'JJ',
"छिहत्तर" :'JJ',
"छिहत्तरवाँ" :'JJ',
"छींटदार" :'JJ',
"छीना" :'JJ',
"छुआ" :'JJ',
"छुट-पुट" :'JJ',
"छुटपुट" :'JJ',
"छुटभैया" :'JJ',
"छुतिहर" :'JJ',
"छुतिहा" :'JJ',
"छुद्र" :'JJ',
"छुधित" :'JJ',
"छुपा" :'JJ',
"छुपा हुआ" :'JJ',
"छूटा" :'JJ',
"छूटा हुआ" :'JJ',
"छेदक" :'JJ',
"छेदनीय" :'JJ',
"छेदहीन" :'JJ',
"छेद्य" :'JJ',
"छेमंड" :'JJ',
"छैल-छबील" :'JJ',
"छैला" :'JJ',
"छैसठ" :'JJ',
"छैंसठ" :'JJ',
"छैसठवाँ" :'JJ',
"छैंसठवाँ" :'JJ',
"छोटा" :'JJ',
"छोटा छोटा" :'JJ',
"छोटा मोटा" :'JJ',
"छोटा सा" :'JJ',
"छोटा-छोटा" :'JJ',
"छोटा-मोटा" :'JJ',
"छोटा-सा" :'JJ',
"छोटामोटा" :'JJ',
"छोही" :'JJ',
"छौगुना" :'JJ',
"जईफ" :'JJ',
"ज़ईफ़" :'JJ',
"जकड़बंद" :'JJ',
"जखमी" :'JJ',
"ज़ख़मी" :'JJ',
"जख्मी" :'JJ',
"ज़ख़्मी" :'JJ',
"जगजयी" :'JJ',
"जगजाहिर" :'JJ',
"जगज़ाहिर" :'JJ',
"जगत्प्रसिद्ध" :'JJ',
"ज़ंगप्रतिरोधी" :'JJ',
"जंगप्रतिरोधी" :'JJ',
"जंगम" :'JJ',
"जगमग" :'JJ',
"जगमगाता" :'JJ',
"ज़ंगरोधी" :'JJ',
"जंगरोधी" :'JJ',
"जंगली" :'JJ',
"जगा" :'JJ',
"जगाने वाला" :'JJ',
"जंगारी" :'JJ',
"जंगी" :'JJ',
"जँचा" :'JJ',
"जँचा हुआ" :'JJ',
"जजबाती" :'JJ',
"जज़बाती" :'JJ',
"जंजर" :'JJ',
"जंजल" :'JJ',
"जंजालिया" :'JJ',
"जंजाली" :'JJ',
"जंजीरदार" :'JJ',
"जंजीरी" :'JJ',
"जज्बाती" :'JJ',
"जज़्बाती" :'JJ',
"जटाधर" :'JJ',
"जटाधारी" :'JJ',
"जटित" :'JJ',
"जटिल" :'JJ',
"जड़" :'JJ',
"जड़ मूर्ख" :'JJ',
"जड़त्वयुक्त" :'JJ',
"जड़दार" :'JJ',
"जड़मति" :'JJ',
"जड़रहित" :'JJ',
"जड़ा" :'JJ',
"जड़ाऊ" :'JJ',
"जड़ावदार" :'JJ',
"जड़ित" :'JJ',
"जड़ीला" :'JJ',
"जंतुरहित" :'JJ',
"जंत्री" :'JJ',
"जन" :'JJ',
"जन सम्मत" :'JJ',
"जनकल्याणकारी" :'JJ',
"जनजातीय" :'JJ',
"जनतंत्रात्मक" :'JJ',
"जनतंत्री" :'JJ',
"जनतंत्रीय" :'JJ',
"जनतन्त्रात्मक" :'JJ',
"जनतन्त्री" :'JJ',
"जनतन्त्रीय" :'JJ',
"जनता का" :'JJ',
"जनतांत्रिक" :'JJ',
"जनतान्त्रिक" :'JJ',
"जनन इंद्रिय संबंधी" :'JJ',
"जनन इन्द्रिय सम्बन्धी" :'JJ',
"जननेंद्रिय संबंधी" :'JJ',
"जननेन्द्रिय सम्बन्धी" :'JJ',
"जनपदीय" :'JJ',
"जनप्रधान" :'JJ',
"जनप्रिय" :'JJ',
"जनमुरीद" :'JJ',
"ज़नमुरीद" :'JJ',
"जनविरोधी" :'JJ',
"जनशून्य" :'JJ',
"जनश्रुत" :'JJ',
"जनाना" :'JJ',
"जनित" :'JJ',
"जनेटिक" :'JJ',
"जनोपयोगी" :'JJ',
"जन्तुरहित" :'JJ',
"जन्मगत" :'JJ',
"जन्मजात" :'JJ',
"जन्मसिद्ध" :'JJ',
"जन्मा" :'JJ',
"जन्मा हुआ" :'JJ',
"जन्मागत" :'JJ',
"जन्मांध" :'JJ',
"जन्य" :'JJ',
"जपनीय" :'JJ',
"जपिया" :'JJ',
"जपी" :'JJ',
"जप्त" :'JJ',
"जप्तव्य" :'JJ',
"जप्य" :'JJ',
"जबर" :'JJ',
"ज़बर" :'JJ',
"जबरजस्त" :'JJ',
"जबरदस्त" :'JJ',
"ज़बरदस्त" :'JJ',
"जबर्दस्त" :'JJ',
"ज़बर्दस्त" :'JJ',
"ज़बानदराज" :'JJ',
"ज़बानदराज़" :'JJ',
"ज़बानबंद" :'JJ',
"जबानी" :'JJ',
"ज़बानी" :'JJ',
"जब्त" :'JJ',
"ज़ब्त" :'JJ',
"जमा" :'JJ',
"जमा कर्ता" :'JJ',
"जमा कर्त्ता" :'JJ',
"जमाकर्ता" :'JJ',
"जमाकर्त्ता" :'JJ',
"जमानासाज" :'JJ',
"ज़मानासाज़" :'JJ',
"जमामार" :'JJ',
"जमींदोज" :'JJ',
"ज़मींदोज़" :'JJ',
"जमीनी" :'JJ',
"ज़मीनी" :'JJ',
"जमुनियाँ" :'JJ',
"जमैकन" :'JJ',
"जमैकाई" :'JJ',
"जमौआ" :'JJ',
"जय योग्य" :'JJ',
"जरकशी" :'JJ',
"ज़रकशी" :'JJ',
"जरकस" :'JJ',
"जरकसी" :'JJ',
"जरखेज" :'JJ',
"ज़रख़ेज़" :'JJ',
"जरतारी" :'JJ',
"ज़रतारी" :'JJ',
"जरदार" :'JJ',
"जरसी" :'JJ',
"जरा" :'JJ',
"ज़रा" :'JJ',
"ज़रा सा" :'JJ',
"जरायुज" :'JJ',
"जरारहित" :'JJ',
"जरिया" :'JJ',
"जरीदार" :'JJ',
"ज़रीदार" :'JJ',
"जरूरतमंद" :'JJ',
"ज़रूरतमंद" :'JJ',
"जरूरतमन्द" :'JJ',
"ज़रूरतमन्द" :'JJ',
"जरूरी" :'JJ',
"ज़रूरी" :'JJ',
"जर्जर" :'JJ',
"जर्द" :'JJ',
"ज़र्द" :'JJ',
"जर्मन" :'JJ',
"जर्राही" :'JJ',
"ज़र्राही" :'JJ',
"जर्सी" :'JJ',
"जल-चर" :'JJ',
"जल-स्थलचर" :'JJ',
"जलचर" :'JJ',
"जलचारी" :'JJ',
"जलचालित" :'JJ',
"जलज" :'JJ',
"जलजात" :'JJ',
"जलता" :'JJ',
"जलता हुआ" :'JJ',
"जलथली" :'JJ',
"जलपूरित" :'JJ',
"जलमग्न" :'JJ',
"जलमय" :'JJ',
"जलरहित" :'JJ',
"जलहीन" :'JJ',
"जला" :'JJ',
"जला हुआ" :'JJ',
"जलाऊ" :'JJ',
"जलातन" :'JJ',
"जलावतन" :'JJ',
"जलीय" :'JJ',
"ज़लील" :'JJ',
"जलोढ़" :'JJ',
"जल्द" :'JJ',
"जल्दबाज" :'JJ',
"जल्दबाज़" :'JJ',
"जवाँ" :'JJ',
"जवां" :'JJ',
"जवान" :'JJ',
"जवाबदेह" :'JJ',
"जवाबी" :'JJ',
"जवाही" :'JJ',
"जस" :'JJ',
"जसी" :'JJ',
"जस्तई" :'JJ',
"जहक" :'JJ',
"जहनी" :'JJ',
"ज़हनी" :'JJ',
"जहरदार" :'JJ',
"ज़हरदार" :'JJ',
"जहरी" :'JJ',
"ज़हरी" :'JJ',
"जहरीला" :'JJ',
"ज़हरीला" :'JJ',
"जहाँगर्द" :'JJ',
"जहाजी" :'JJ',
"जहाज़ी" :'JJ',
"जहाजी कौवा" :'JJ',
"जहाँदीद" :'JJ',
"जहाँदीदा" :'JJ',
"जहीन" :'JJ',
"ज़हीन" :'JJ',
"जागता हुआ" :'JJ',
"जागतिक" :'JJ',
"जाँगर चोर" :'JJ',
"जागरूक" :'JJ',
"जाँगलू" :'JJ',
"जागा" :'JJ',
"जागा हुआ" :'JJ',
"जागृत" :'JJ',
"जाग्रत" :'JJ',
"जाग्रत्" :'JJ',
"जाँघिल" :'JJ',
"जांघिल" :'JJ',
"जाज्वल्यमान" :'JJ',
"जात" :'JJ',
"जांतव" :'JJ',
"जाति निर्वासित" :'JJ',
"जाति बहिष्कृत" :'JJ',
"जाति-वाचक" :'JJ',
"जातिगत" :'JJ',
"जातिच्युत" :'JJ',
"जातिरहित" :'JJ',
"जातिवाचक" :'JJ',
"जातिवादी" :'JJ',
"जातिहीन" :'JJ',
"ज़ाती" :'JJ',
"जातीय" :'JJ',
"जात्यंध" :'JJ',
"जात्यन्ध" :'JJ',
"जादुई" :'JJ',
"जानकार" :'JJ',
"जानदार" :'JJ',
"जानपद" :'JJ',
"जानपदिक" :'JJ',
"जानलेवा" :'JJ',
"जाना-पहचाना" :'JJ',
"जाना-माना" :'JJ',
"जानामाना" :'JJ',
"जाँनिसार" :'JJ',
"जानी" :'JJ',
"जान्तव" :'JJ',
"जापानी" :'JJ',
"जापी" :'JJ',
"जाप्य" :'JJ',
"जाफरानी" :'JJ',
"ज़ाफ़रानी" :'JJ',
"जाफराबादी" :'JJ',
"जाफ़राबादी" :'JJ',
"जाँबाज" :'JJ',
"जाँबाज़" :'JJ',
"जामुनी" :'JJ',
"ज़ाम्बियन" :'JJ',
"जाम्बियाई" :'JJ',
"ज़ाम्बियाई" :'JJ',
"जायकेदार" :'JJ',
"ज़ायकेदार" :'JJ',
"जायज" :'JJ',
"जायज़" :'JJ',
"जारज" :'JJ',
"जारी" :'JJ',
"जार्जियन" :'JJ',
"जार्जियाई" :'JJ',
"जार्डनियन" :'JJ',
"जार्डनी" :'JJ',
"जाल-साज" :'JJ',
"जालदार" :'JJ',
"जालसाज" :'JJ',
"जालिम" :'JJ',
"ज़ालिम" :'JJ',
"जाली" :'JJ',
"जालीदार" :'JJ',
"जावक" :'JJ',
"जावाई" :'JJ',
"जासूसी" :'JJ',
"जाहिर" :'JJ',
"ज़ाहिर" :'JJ',
"जाहिल" :'JJ',
"जिगरी" :'JJ',
"जिच" :'JJ',
"जिच्च" :'JJ',
"जिज्ञासाजनक" :'JJ',
"जिज्ञासाहीन" :'JJ',
"जिज्ञासित" :'JJ',
"जिज्ञासु" :'JJ',
"जितना" :'JJ',
"जितवार" :'JJ',
"जितवैया" :'JJ',
"जितात्मा" :'JJ',
"जितार" :'JJ',
"जितेक" :'JJ',
"जितेंद्र" :'JJ',
"जितेंद्रिय" :'JJ',
"जितेन्द्र" :'JJ',
"जितेन्द्रिय" :'JJ',
"जित्ता" :'JJ',
"जित्य" :'JJ',
"जिंदा" :'JJ',
"ज़िंदा" :'JJ',
"जिंदादिल" :'JJ',
"ज़िंदादिल" :'JJ',
"जिद्दी" :'JJ',
"ज़िद्दी" :'JJ',
"जिनाकार" :'JJ',
"ज़िनाकार" :'JJ',
"जिनेटिक" :'JJ',
"जिन्दा" :'JJ',
"जिन्दादिल" :'JJ',
"ज़िन्दादिल" :'JJ',
"जिप्सी" :'JJ',
"जिभला" :'JJ',
"जिम्बाबवेइयाई" :'JJ',
"ज़िम्बाबवेइयाई" :'JJ',
"जिम्बाबवेयन" :'JJ',
"ज़िम्बाबवेयन" :'JJ',
"जिम्मादार" :'JJ',
"ज़िम्मादार" :'JJ',
"जिम्मेदार" :'JJ',
"ज़िम्मेदार" :'JJ',
"जिम्मेवार" :'JJ',
"ज़िम्मेवार" :'JJ',
"जिरही" :'JJ',
"ज़िरही" :'JJ',
"ज़िलाई" :'JJ',
"जिलेटिनी" :'JJ',
"जिष्णु" :'JJ',
"जिस्मानी" :'JJ',
"जिहनी" :'JJ',
"ज़िहनी" :'JJ',
"जिहादी" :'JJ',
"जिह्वा लोलुप" :'JJ',
"जिह्वामूलीय" :'JJ',
"जीता जागता" :'JJ',
"जीता हुआ" :'JJ',
"जीता-जागता" :'JJ',
"जीताजागता" :'JJ',
"जीनी" :'JJ',
"जीर्ण" :'JJ',
"जीर्ण शीर्ण" :'JJ',
"जीर्ण-शीर्ण" :'JJ',
"जीवंत" :'JJ',
"जीवधारी" :'JJ',
"जीवन-संगी" :'JJ',
"जीवनदायी" :'JJ',
"जीवनसंगी" :'JJ',
"जीवनहर" :'JJ',
"जीवनहीन" :'JJ',
"जीवनावश्यक" :'JJ',
"जीवन्त" :'JJ',
"जीवन्मुक्त" :'JJ',
"जीववादी" :'JJ',
"जीवाणुज" :'JJ',
"जीवाणुजनित" :'JJ',
"जीवाणुरोधक" :'JJ',
"जीवाणुरोधी" :'JJ',
"जीवाण्विक" :'JJ',
"जीविकाहीन" :'JJ',
"जीवित" :'JJ',
"जुआरी" :'JJ',
"जुगुप्सु" :'JJ',
"जुझाऊ" :'JJ',
"जुझार" :'JJ',
"जुझारू" :'JJ',
"जुटा" :'JJ',
"जुटा हुआ" :'JJ',
"जुठारा" :'JJ',
"जुड़वा" :'JJ',
"जुड़वाँ" :'JJ',
"जुड़ा" :'JJ',
"जुड़ीवाँ" :'JJ',
"जुता" :'JJ',
"जुता हुआ" :'JJ',
"जुदा" :'JJ',
"जुबानी" :'JJ',
"ज़ुबानी" :'JJ',
"जुल्मी" :'JJ',
"ज़ुल्मी" :'JJ',
"जुवारी" :'JJ',
"जूठा" :'JJ',
"जूताखोर" :'JJ',
"जूताख़ोर" :'JJ',
"जूतीखोर" :'JJ',
"जूतीख़ोर" :'JJ',
"जूनियर" :'JJ',
"जूँमुहाँ" :'JJ',
"जेठ" :'JJ',
"जेठा" :'JJ',
"जेनेटिक" :'JJ',
"जेबकट" :'JJ',
"जेबकतरा" :'JJ',
"जेबदार" :'JJ',
"ज़ेबदार" :'JJ',
"जेबा" :'JJ',
"ज़ेबा" :'JJ',
"जेय" :'JJ',
"जेर" :'JJ',
"जेहनदार" :'JJ',
"ज़ेहनदार" :'JJ',
"जेहनी" :'JJ',
"ज़ेहनी" :'JJ',
"जेहादी" :'JJ',
"जैनी" :'JJ',
"जैपनीज़" :'JJ',
"जैपनीस" :'JJ',
"जैव" :'JJ',
"जैवातृक" :'JJ',
"जैविक" :'JJ',
"जैसा" :'JJ',
"जैसे का तैसा" :'JJ',
"जॉर्जियन" :'JJ',
"जॉर्जियाई" :'JJ',
"जॉर्डनियन" :'JJ',
"जॉर्डनी" :'JJ',
"जोखा" :'JJ',
"जोखिमपूर्ण" :'JJ',
"जोखिमभरा" :'JJ',
"जोगिया" :'JJ',
"जोगी" :'JJ',
"जोड़ला" :'JJ',
"जोड़वाँ" :'JJ',
"जोता-बोया" :'JJ',
"जोताऊ" :'JJ',
"जोर" :'JJ',
"ज़ोर" :'JJ',
"जोर का" :'JJ',
"ज़ोर का" :'JJ',
"जोरदार" :'JJ',
"ज़ोरदार" :'JJ',
"जोरू का गुलाम" :'JJ',
"जोशवाला" :'JJ',
"जोशीला" :'JJ',
"ज्ञ" :'JJ',
"ज्ञात" :'JJ',
"ज्ञातव्य" :'JJ',
"ज्ञाता" :'JJ',
"ज्ञानगम्य" :'JJ',
"ज्ञानपूर्ण" :'JJ',
"ज्ञानमय" :'JJ',
"ज्ञानवान" :'JJ',
"ज्ञानशून्य" :'JJ',
"ज्ञानहीन" :'JJ',
"ज्ञानातीत" :'JJ',
"ज्ञानात्मक" :'JJ',
"ज्ञानी" :'JJ',
"ज्ञापित" :'JJ',
"ज्ञेय" :'JJ',
"ज्यादा" :'JJ',
"ज़्यादा" :'JJ',
"ज्यादा से ज्यादा" :'JJ',
"ज़्यादा से ज़्यादा" :'JJ',
"ज्यादातर" :'JJ',
"ज़्यादातर" :'JJ',
"ज्यामितीय" :'JJ',
"ज्येष्ठ" :'JJ',
"ज्येष्ठी" :'JJ',
"ज्यों का त्यों" :'JJ',
"ज्यों-का-त्यों" :'JJ',
"ज्योतित" :'JJ',
"ज्वलंत" :'JJ',
"ज्वलनशील" :'JJ',
"ज्वालामुखी" :'JJ',
"ज्वालामुखीय" :'JJ',
"झक" :'JJ',
"झकाझक" :'JJ',
"झक्की" :'JJ',
"झख" :'JJ',
"झगड़ालू" :'JJ',
"झंझटिया" :'JJ',
"झंझटी" :'JJ',
"झंझा" :'JJ',
"झंझामय" :'JJ',
"झञ्झटिया" :'JJ',
"झञ्झटी" :'JJ',
"झबरा" :'JJ',
"झबरीला" :'JJ',
"झब्बर-झब्बर" :'JJ',
"झमझम" :'JJ',
"झमाझम" :'JJ',
"झमेलिया" :'JJ',
"झल्ली" :'JJ',
"झागदार" :'JJ',
"झागरहित" :'JJ',
"झाँझर" :'JJ',
"झाड़ीदार" :'JJ',
"झालदार" :'JJ',
"झालर वाला" :'JJ',
"झालरदार" :'JJ',
"झाँसेबाज" :'JJ',
"झाँसेबाज़" :'JJ',
"झांसेबाज" :'JJ',
"झांसेबाज़" :'JJ',
"झिरझिरा" :'JJ',
"झिल्लित" :'JJ',
"झिल्लीदार" :'JJ',
"झीना" :'JJ',
"झुका" :'JJ',
"झुका हुआ" :'JJ',
"झुकाया हुआ" :'JJ',
"झुलौआ" :'JJ',
"झुलौवा" :'JJ',
"झूठ" :'JJ',
"झूठा" :'JJ',
"झूलना" :'JJ',
"झूलने वाला" :'JJ',
"झेंपू" :'JJ',
"झोलदार" :'JJ',
"टकटकी" :'JJ',
"टकला" :'JJ',
"टकहाई" :'JJ',
"टकाई" :'JJ',
"टकाटक" :'JJ',
"टकाही" :'JJ',
"टंकित" :'JJ',
"टक्कल" :'JJ',
"टघला" :'JJ',
"टट-पूँजिया" :'JJ',
"टटका" :'JJ',
"टटपूँजिया" :'JJ',
"टपका" :'JJ',
"टपका हुआ" :'JJ',
"टर्कमन" :'JJ',
"टर्कमेन" :'JJ',
"टवर्गीय" :'JJ',
"टाइड" :'JJ',
"टाइप किया हुआ" :'JJ',
"टिकाऊ" :'JJ',
"टिघला" :'JJ',
"टिप-टाप" :'JJ',
"टिप-टॉप" :'JJ',
"टिम्मा" :'JJ',
"टुकड़-तोड़" :'JJ',
"टुकड़तोड़" :'JJ',
"टुकड़ा टुकड़ा" :'JJ',
"टुकड़ा-टुकड़ा" :'JJ',
"टुच्चा" :'JJ',
"टुट-पूँजिया" :'JJ',
"टुटपूँजिया" :'JJ',
"टू स्टार" :'JJ',
"टूगर" :'JJ',
"टूटा" :'JJ',
"टूटा फूटा" :'JJ',
"टूटा हुआ" :'JJ',
"टूटा-फूटा" :'JJ',
"टूटाफूटा" :'JJ',
"टेक्निकल" :'JJ',
"टेढ़ा" :'JJ',
"टेढ़ा मेढ़ा" :'JJ',
"टेढ़ा-मेढ़ा" :'JJ',
"टेन्शन फ्री" :'JJ',
"टेंशन फ्री" :'JJ',
"टैक्सखोर" :'JJ',
"टोगोलीज" :'JJ',
"टोगोलीज़" :'JJ',
"टोगोलीस" :'JJ',
"टोनहा" :'JJ',
"ट्यूनीशियन" :'JJ',
"ट्यूनीशियाई" :'JJ',
"ठंठी" :'JJ',
"ठठेरी" :'JJ',
"ठंडा" :'JJ',
"ठंढा" :'JJ',
"ठण्डा" :'JJ',
"ठण्ढा" :'JJ',
"ठन्डा" :'JJ',
"ठन्ढा" :'JJ',
"ठप" :'JJ',
"ठप्प" :'JJ',
"ठरमरुआ" :'JJ',
"ठरुआ" :'JJ',
"ठसा ठस भरा हुआ" :'JJ',
"ठसा-ठस भरा हुआ" :'JJ',
"ठहरने योग्य" :'JJ',
"ठहरा" :'JJ',
"ठहरा हुआ" :'JJ',
"ठहराया" :'JJ',
"ठहराया हुआ" :'JJ',
"ठाटदार" :'JJ',
"ठाँठ" :'JJ',
"ठाठदार" :'JJ',
"ठिगना" :'JJ',
"ठिंगना" :'JJ',
"ठिठोलबाज" :'JJ',
"ठिठोलबाज़" :'JJ',
"ठिठोलिया" :'JJ',
"ठीक" :'JJ',
"ठीक ठाक" :'JJ',
"ठीक-ठाक" :'JJ',
"ठीकठाक" :'JJ',
"ठीकादार" :'JJ',
"ठीकेदार" :'JJ',
"ठुड्डीय" :'JJ',
"ठूँठ" :'JJ',
"ठूंठ" :'JJ',
"ठूँठा" :'JJ',
"ठेकादार" :'JJ',
"ठेकेदार" :'JJ',
"ठेंगना" :'JJ',
"ठेठ" :'JJ',
"ठेस पहुँचाने वाला" :'JJ',
"ठेसरा" :'JJ',
"ठोड़ीय" :'JJ',
"ठोढ़ीय" :'JJ',
"ठोस" :'JJ',
"डंकी" :'JJ',
"डँकीला" :'JJ',
"डंकीला" :'JJ',
"डगमग" :'JJ',
"डगमगाता" :'JJ',
"डगमगाता हुआ" :'JJ',
"डगमगाया हुआ" :'JJ',
"डंगर" :'JJ',
"डच" :'JJ',
"डटने वाला" :'JJ',
"डटा" :'JJ',
"डटा हुआ" :'JJ',
"डंडी" :'JJ',
"डबकौंहाँ" :'JJ',
"डबडबा" :'JJ',
"डबल" :'JJ',
"डभकौंहाँ" :'JJ',
"डरपोक" :'JJ',
"डरा" :'JJ',
"डरा हुआ" :'JJ',
"डरावना" :'JJ',
"डरीला" :'JJ',
"डाउन" :'JJ',
"डाबर" :'JJ',
"डायबिटीक" :'JJ',
"डालदार" :'JJ',
"डाँवाडोल" :'JJ',
"डाँवाँडोल" :'JJ',
"डिगा हुआ" :'JJ',
"डिठार" :'JJ',
"डिठियार" :'JJ',
"डिठियारा" :'JJ',
"डिंबज" :'JJ',
"डिम्बज" :'JJ',
"डिवेलप्ड" :'JJ',
"डींगबाज" :'JJ',
"डींगबाज़" :'JJ',
"डींगमार" :'JJ',
"डुप्लीकेट" :'JJ',
"डूंडा" :'JJ',
"डूबता" :'JJ',
"डूबता हुआ" :'JJ',
"डूबा" :'JJ',
"डूबा हुआ" :'JJ',
"डेढ़" :'JJ',
"डेढ़ गुना" :'JJ',
"डेढ़ सौ" :'JJ',
"डेनमार्की" :'JJ',
"डेनिश" :'JJ',
"डेयरी" :'JJ',
"डेरा" :'JJ',
"डेरी" :'JJ',
"डैमेज" :'JJ',
"डैमेज्ड" :'JJ',
"डोमिनिकन" :'JJ',
"डोमिनिकाई" :'JJ',
"डोलायमान" :'JJ',
"डौलदार" :'JJ',
"ड्योढ़ा" :'JJ',
"ढका" :'JJ',
"ढँका" :'JJ',
"ढका हुआ" :'JJ',
"ढकोसलेबाज़" :'JJ',
"ढबैला" :'JJ',
"ढरारा" :'JJ',
"ढल-मल" :'JJ',
"ढलमल" :'JJ',
"ढलवाँ" :'JJ',
"ढलाऊ" :'JJ',
"ढलावदार" :'JJ',
"ढलुआ" :'JJ',
"ढलुवाँ" :'JJ',
"ढहा" :'JJ',
"ढहा हुआ" :'JJ',
"ढाई" :'JJ',
"ढाई सौ" :'JJ',
"ढालवाँ" :'JJ',
"ढालुआँ" :'JJ',
"ढालू" :'JJ',
"ढीठ" :'JJ',
"ढीला" :'JJ',
"ढीला-ढाला" :'JJ',
"ढुल-मुल" :'JJ',
"ढुलमुल" :'JJ',
"ढेर सारा" :'JJ',
"ढेरों" :'JJ',
"ढोंगी" :'JJ',
"णकारांत" :'JJ',
"णकारान्त" :'JJ',
"तआला" :'JJ',
"तक़दीर वाला" :'JJ',
"तकनीक विषयक" :'JJ',
"तकनीकहीन" :'JJ',
"तकनीकी" :'JJ',
"तकरारी" :'JJ',
"तकलीफदेह" :'JJ',
"तकलीफ़देह" :'JJ',
"तकारांत" :'JJ',
"तकारान्त" :'JJ',
"तक्त्या" :'JJ',
"तंग" :'JJ',
"तगड़ा" :'JJ',
"तंगदस्त" :'JJ',
"तंगदिल" :'JJ',
"तंगमोहरी" :'JJ',
"तंगहाल" :'JJ',
"तच्छील" :'JJ',
"तजनीय" :'JJ',
"तजरबाकार" :'JJ',
"तजरबेकार" :'JJ',
"तजरुबाकार" :'JJ',
"तजर्बेकार" :'JJ',
"तंजानियन" :'JJ',
"तंज़ानियन" :'JJ',
"तंजानियाई" :'JJ',
"तंज़ानियाई" :'JJ',
"तजिकिस्तानी" :'JJ',
"तज़िकिस्तानी" :'JJ',
"तजुरबेकार" :'JJ',
"तजुर्बेकार" :'JJ',
"तट-संबंधी" :'JJ',
"तटवर्ती" :'JJ',
"तटवासी" :'JJ',
"तटस्थ" :'JJ',
"तटीय" :'JJ',
"तड़िन्मय" :'JJ',
"तत्कालिक" :'JJ',
"तत्कालीन" :'JJ',
"तत्त्वपूर्ण" :'JJ',
"तत्पर" :'JJ',
"तंत्र शुद्ध" :'JJ',
"तंत्र शोधित" :'JJ',
"तंत्र-शुद्ध" :'JJ',
"तंत्र-शोधित" :'JJ',
"तंत्रशुद्ध" :'JJ',
"तंत्रशोधित" :'JJ',
"तंत्रिका संबंधी" :'JJ',
"तंत्रिकासंबंधी" :'JJ',
"तंत्रिकीय" :'JJ',
"तत्वक" :'JJ',
"तत्वजिज्ञासु" :'JJ',
"तत्वज्ञानी" :'JJ',
"तत्वदर्शी" :'JJ',
"तत्वपूर्ण" :'JJ',
"तत्वशून्य" :'JJ',
"तत्सम" :'JJ',
"तथाकथित" :'JJ',
"तथाकथ्य" :'JJ',
"तथ्यपरक" :'JJ',
"तथ्यपूर्ण" :'JJ',
"तथ्यहीन" :'JJ',
"तथ्यात्मक" :'JJ',
"तदनुकूल" :'JJ',
"तदनुरूप" :'JJ',
"तदनुसार" :'JJ',
"तंदरुस्त" :'JJ',
"तदर्थ" :'JJ',
"तदाकार" :'JJ',
"तंदुरुस्त" :'JJ',
"तंदूरी" :'JJ',
"तंद्रालु" :'JJ',
"तंद्रित" :'JJ',
"तंद्रिल" :'JJ',
"तद्रूप" :'JJ',
"तनख़्वाहदार" :'JJ',
"तननशील" :'JJ',
"तननेवाला" :'JJ',
"तनपोषक" :'JJ',
"तनहा" :'JJ',
"तना" :'JJ',
"तना हुआ" :'JJ',
"तनाव भरा" :'JJ',
"तनावपूर्ण" :'JJ',
"तनावमुक्त" :'JJ',
"तनावयुक्त" :'JJ',
"तनि" :'JJ',
"तनिक" :'JJ',
"तनु" :'JJ',
"तनुधारी" :'JJ',
"तनुमध्या" :'JJ',
"तनेना" :'JJ',
"तन्त्र शुद्ध" :'JJ',
"तन्त्र शोधित" :'JJ',
"तन्त्र-शुद्ध" :'JJ',
"तन्त्र-शोधित" :'JJ',
"तन्त्रशुद्ध" :'JJ',
"तन्त्रशोधित" :'JJ',
"तन्दरुस्त" :'JJ',
"तन्दुरुस्त" :'JJ',
"तन्द्रिल" :'JJ',
"तन्मय" :'JJ',
"तन्यक" :'JJ',
"तन्वंग" :'JJ',
"तन्वी" :'JJ',
"तन्हा" :'JJ',
"तपसी" :'JJ',
"तपस्वी" :'JJ',
"तपा" :'JJ',
"तपाया" :'JJ',
"तपावंत" :'JJ',
"तपावन्त" :'JJ',
"तपित" :'JJ',
"तपिया" :'JJ',
"तपी" :'JJ',
"तपु" :'JJ',
"तपोज" :'JJ',
"तप्त" :'JJ',
"तबकिया" :'JJ',
"तबदील" :'JJ',
"तबाह" :'JJ',
"तबाहकुन" :'JJ',
"तँबिया" :'JJ',
"तंबिया" :'JJ',
"तबीयतदार" :'JJ',
"तब्दील" :'JJ',
"तमचर" :'JJ',
"तमस" :'JJ',
"तमस्वी" :'JJ',
"तमहाया" :'JJ',
"तमाम" :'JJ',
"तमिल" :'JJ',
"तमिस्रतम" :'JJ',
"तमीजदार" :'JJ',
"तमीज़दार" :'JJ',
"तमोगुणवाला" :'JJ',
"तमोगुणी" :'JJ',
"तमोमय" :'JJ',
"तमोहपह" :'JJ',
"तय" :'JJ',
"तयशुदा" :'JJ',
"तर" :'JJ',
"तर-ब-तर" :'JJ',
"तर-बतर" :'JJ',
"तरंगायित" :'JJ',
"तरंगिणी" :'JJ',
"तरंगित" :'JJ',
"तरंगी" :'JJ',
"तरतीबदार" :'JJ',
"तरतीबवार" :'JJ',
"तरफदार" :'JJ',
"तरफ़दार" :'JJ',
"तरबतर" :'JJ',
"तरबूजिया" :'JJ',
"तरल" :'JJ',
"तरलित" :'JJ',
"तरह-तरह का" :'JJ',
"तरह-तरह के" :'JJ',
"तराशा" :'JJ',
"तराशीदा" :'JJ',
"तरीदार" :'JJ',
"तरुण" :'JJ',
"तरो-ताजा" :'JJ',
"तरो-ताज़ा" :'JJ',
"तरोताजा" :'JJ',
"तरोताज़ा" :'JJ',
"तर्कगम्य" :'JJ',
"तर्कपूर्ण" :'JJ',
"तर्कयुक्त" :'JJ',
"तर्करहित" :'JJ',
"तर्कसंगत" :'JJ',
"तर्कहीन" :'JJ',
"तर्कागम्य" :'JJ',
"तर्कातीत" :'JJ',
"तर्काधीन" :'JJ',
"तर्की" :'JJ',
"तर्जदार" :'JJ',
"तलछटी" :'JJ',
"तलफ" :'JJ',
"तलफ़" :'JJ',
"तलवारधारी" :'JJ',
"तलहा" :'JJ',
"तला भुना" :'JJ',
"तला-भुना" :'JJ',
"तलाकशुदा" :'JJ',
"तलाक़शुदा" :'JJ',
"तलीय" :'JJ',
"तलोंछी" :'JJ',
"तलौछी" :'JJ',
"तल्ला" :'JJ',
"तल्लीन" :'JJ',
"तवर्गीय" :'JJ',
"तशन" :'JJ',
"तश्नः" :'JJ',
"तसव्वुफ" :'JJ',
"तसव्वुफ़" :'JJ',
"तसौवफ" :'JJ',
"तसौवफ़" :'JJ',
"तहजीब-याफ्ता" :'JJ',
"तहज़ीब-याफ़्ता" :'JJ',
"तहज़ीबयाफ़्ता" :'JJ',
"तहत" :'JJ',
"तहस नहस" :'JJ',
"तहस-नहस" :'JJ',
"तहेरा" :'JJ',
"ताइवानी" :'JJ',
"ताइवानीज़" :'JJ',
"ताइवानीस" :'JJ',
"ताऊसी" :'JJ',
"ताएरा" :'JJ',
"ताकतवर" :'JJ',
"ताक़तवर" :'JJ',
"ताकीदी" :'JJ',
"ताक़ीदी" :'JJ',
"ताजा" :'JJ',
"ताज़ा" :'JJ',
"ताजा तरीन" :'JJ',
"ताज़ा तरीन" :'JJ',
"ताजा ताजा" :'JJ',
"ताज़ा ताज़ा" :'JJ',
"ताजा-ताजा" :'JJ',
"ताज़ा-ताज़ा" :'JJ',
"ताजातरीन" :'JJ',
"ताज़ातरीन" :'JJ',
"ताजी" :'JJ',
"ताज़ी" :'JJ',
"ताड़ की तरह ऊँचा" :'JJ',
"ताड़ की तरह लंबा" :'JJ',
"ताड़ की तरह लम्बा" :'JJ',
"ताड़ के समान ऊँचा" :'JJ',
"ताड़ के समान लंबा" :'JJ',
"ताड़ के समान लम्बा" :'JJ',
"तातहीन" :'JJ',
"तातारी" :'JJ',
"तातारीय" :'JJ',
"ताँतिया" :'JJ',
"तात्कालिक" :'JJ',
"तानाकश" :'JJ',
"तानाजन" :'JJ',
"तानाज़न" :'JJ',
"तापनाशक" :'JJ',
"तापयुक्त" :'JJ',
"तापस" :'JJ',
"तापहर" :'JJ',
"तापित" :'JJ',
"ताबदार" :'JJ',
"ताँबिया" :'JJ',
"तांबिया" :'JJ',
"ताबेदार" :'JJ',
"ताम" :'JJ',
"तामड़ा" :'JJ',
"तामस" :'JJ',
"तामसिक" :'JJ',
"तामसी" :'JJ',
"तार-तार" :'JJ',
"तारकांकित" :'JJ',
"तारकिणी" :'JJ',
"तारकित" :'JJ',
"तारकी" :'JJ',
"तारल" :'JJ',
"तारांकित" :'JJ',
"तारायुक्त" :'JJ',
"ताराविहीन" :'JJ',
"ताराहीन" :'JJ',
"तारीक" :'JJ',
"तारों भरा" :'JJ',
"तार्किक" :'JJ',
"तालव्य" :'JJ',
"तालहीन" :'JJ',
"तालिब" :'JJ',
"तालिबानी" :'JJ',
"तालीमी" :'JJ',
"तिकड़मबाज" :'JJ',
"तिकड़मबाज़" :'JJ',
"तिकुनिया" :'JJ',
"तिकोन" :'JJ',
"तिकोना" :'JJ',
"तिकोनियाँ" :'JJ',
"तिक्त" :'JJ',
"तिखरा" :'JJ',
"तिगुना" :'JJ',
"तिजारती" :'JJ',
"तिज़ारती" :'JJ',
"तितर-बितर" :'JJ',
"तितरा" :'JJ',
"तितरी" :'JJ',
"तितल्ला" :'JJ',
"तितारा" :'JJ',
"तितिक्षु" :'JJ',
"तितेक" :'JJ',
"तितौ" :'JJ',
"तिपहिया" :'JJ',
"तिबासी" :'JJ',
"तिबाहा" :'JJ',
"तिब्बतन" :'JJ',
"तिब्बती" :'JJ',
"तिमंजिला" :'JJ',
"तिमंज़िला" :'JJ',
"तिमहला" :'JJ',
"तिमाही" :'JJ',
"तियतरा" :'JJ',
"तियतरी" :'JJ',
"तिरंगा" :'JJ',
"तिरछा" :'JJ',
"तिरता" :'JJ',
"तिरता हुआ" :'JJ',
"तिरपट" :'JJ',
"तिरपटा" :'JJ',
"तिरपन" :'JJ',
"तिरपनवाँ" :'JJ',
"तिरसठ" :'JJ',
"तिरसठवाँ" :'JJ',
"तिरस्कर" :'JJ',
"तिरस्करणीय" :'JJ',
"तिरस्करी" :'JJ',
"तिरस्कृत" :'JJ',
"तिरानबे" :'JJ',
"तिरानबेवाँ" :'JJ',
"तिरानवे" :'JJ',
"तिरानवेवाँ" :'JJ',
"तिरालीस" :'JJ',
"तिरालीसवाँ" :'JJ',
"तिरासी" :'JJ',
"तिरासीवाँ" :'JJ',
"तिरोहित" :'JJ',
"तिर्यक" :'JJ',
"तिलचावला" :'JJ',
"तिलस्मी" :'JJ',
"तिलिस्मी" :'JJ',
"तिल्लेदार" :'JJ',
"तिवासी" :'JJ',
"तिष्य" :'JJ',
"तिस्कार योग्य" :'JJ',
"तिहत्तर" :'JJ',
"तिहत्तरवाँ" :'JJ',
"तिहाई" :'JJ',
"तिहैया" :'JJ',
"तीक्ष्ण" :'JJ',
"तीक्ष्णबुद्धि" :'JJ',
"तीखा" :'JJ',
"तीखा चरपरा" :'JJ',
"तीखा-चरपरा" :'JJ',
"तीता" :'JJ',
"तीन" :'JJ',
"तीन गुना" :'JJ',
"तीन सितारा" :'JJ',
"तीन सौ" :'JJ',
"तीनगुना" :'JJ',
"तीनतरफा" :'JJ',
"तीनतरफ़ा" :'JJ',
"तीनपहिया" :'JJ',
"तीनसौ" :'JJ',
"तीनेक" :'JJ',
"तीनों" :'JJ',
"तीमारदार" :'JJ',
"तीर" :'JJ',
"तीरंदाज" :'JJ',
"तीरंदाज़" :'JJ',
"तीव्र" :'JJ',
"तीव्रगामी" :'JJ',
"तीव्रबुद्धि" :'JJ',
"तीस" :'JJ',
"तीसरा" :'JJ',
"तीसवाँ" :'JJ',
"तीसवां" :'JJ',
"तीसेक" :'JJ',
"तुकबद्ध" :'JJ',
"तुकयुक्त" :'JJ',
"तुकहीन" :'JJ',
"तुकांत" :'JJ',
"तुंग" :'JJ',
"तुङ्ग" :'JJ',
"तुच्छ" :'JJ',
"तुच्छ-बुद्धि" :'JJ',
"तुच्छातितुच्छ" :'JJ',
"तुच्छीकृत" :'JJ',
"तुड़ा-मुड़ा" :'JJ',
"तुतरा" :'JJ',
"तुतला" :'JJ',
"तुनक" :'JJ',
"तुनक-मिजाज" :'JJ',
"तुनक-मिज़ाज" :'JJ',
"तुनकमिजाज" :'JJ',
"तुनकमिज़ाज" :'JJ',
"तुनुक" :'JJ',
"तुनुक-मिजाज" :'JJ',
"तुनुक-मिज़ाज" :'JJ',
"तुनुकमिजाज" :'JJ',
"तुनुकमिज़ाज" :'JJ',
"तुम्र" :'JJ',
"तुर्क" :'JJ',
"तुर्कमेन" :'JJ',
"तुर्क़मेन" :'JJ',
"तुर्कमेनियाई" :'JJ',
"तुर्क़मेनियाई" :'JJ',
"तुर्कमेनिस्तानी" :'JJ',
"तुर्क़मेनिस्तानी" :'JJ',
"तुर्कमेनी" :'JJ',
"तुर्क़मेनी" :'JJ',
"तुर्किस्तान वासी" :'JJ',
"तुर्किस्तान-वासी" :'JJ',
"तुर्किस्तानवासी" :'JJ',
"तुर्की" :'JJ',
"तुर्श" :'JJ',
"तुर्श-मिजाज" :'JJ',
"तुर्श-मिज़ाज" :'JJ',
"तुर्शमिजाज" :'JJ',
"तुर्शमिज़ाज" :'JJ',
"तुलनात्मक" :'JJ',
"तुलनीय" :'JJ',
"तुला" :'JJ',
"तुल्य" :'JJ',
"तुष्ट" :'JJ',
"तूफानी" :'JJ',
"तूफ़ानी" :'JJ',
"तूल" :'JJ',
"तृण-चर" :'JJ',
"तृणचर" :'JJ',
"तृणजंभन्" :'JJ',
"तृणजम्भन्" :'JJ',
"तृणजीवन" :'JJ',
"तृणजीवी" :'JJ',
"तृणमय" :'JJ',
"तृतीय" :'JJ',
"तृप्त" :'JJ',
"तृषित" :'JJ',
"तृष्णारहित" :'JJ',
"तेइस" :'JJ',
"तेइसवाँ" :'JJ',
"तेइसवां" :'JJ',
"तेईस" :'JJ',
"तेईसवाँ" :'JJ',
"तेईसवां" :'JJ',
"तेखरा" :'JJ',
"तेज" :'JJ',
"तेज़" :'JJ',
"तेज-तर्रार" :'JJ',
"तेज़-तर्रार" :'JJ',
"तेजपूर्ण" :'JJ',
"तेजवंत" :'JJ',
"तेजवान" :'JJ',
"तेजस्वी" :'JJ',
"तेजहीन" :'JJ',
"तेजाबी" :'JJ',
"तेज़ाबी" :'JJ',
"तेजोमंडित" :'JJ',
"तेजोहीन" :'JJ',
"तेरह" :'JJ',
"तेरहवाँ" :'JJ',
"तेलगु" :'JJ',
"तेलगू" :'JJ',
"तेलहा" :'JJ',
"तेलीय" :'JJ',
"तेलुगु" :'JJ',
"तैतालीस" :'JJ',
"तैंतालीस" :'JJ',
"तैतालीसवाँ" :'JJ',
"तैंतालीसवाँ" :'JJ',
"तैतीस" :'JJ',
"तैंतीस" :'JJ',
"तैतीसवाँ" :'JJ',
"तैंतीसवाँ" :'JJ',
"तैनात" :'JJ',
"तैयार" :'JJ',
"तैरता" :'JJ',
"तैरता हुआ" :'JJ',
"तैराक" :'JJ',
"तैलंगी" :'JJ',
"तैलाक्त" :'JJ',
"तैलीय" :'JJ',
"तोतई" :'JJ',
"तोतर" :'JJ',
"तोतरा" :'JJ',
"तोतला" :'JJ',
"तोताचश्म" :'JJ',
"तोद" :'JJ',
"तोंदल" :'JJ',
"तोंदवाला" :'JJ',
"तोंदीला" :'JJ',
"तोंदू" :'JJ',
"तोंदूमल" :'JJ',
"तोंदेल" :'JJ',
"तोंदैला" :'JJ',
"तोयचर" :'JJ',
"तोयज" :'JJ',
"तोरणनुमा" :'JJ',
"तोल" :'JJ',
"तोलनीय" :'JJ',
"तोला" :'JJ',
"तोल्य" :'JJ',
"तोश" :'JJ',
"तोष" :'JJ',
"तोषक" :'JJ',
"तोषणिक" :'JJ',
"तोषप्रद" :'JJ',
"तोषयितव्य" :'JJ',
"तोषित" :'JJ',
"तोहमती" :'JJ',
"तौला" :'JJ',
"त्यक्त" :'JJ',
"त्यागी" :'JJ',
"त्याजनीय" :'JJ',
"त्याज्य" :'JJ',
"त्रपानिरस्त" :'JJ',
"त्रपावत" :'JJ',
"त्रपित" :'JJ',
"त्रय" :'JJ',
"त्रसित" :'JJ',
"त्रसुर" :'JJ',
"त्रस्त" :'JJ',
"त्रि-आयामिक" :'JJ',
"त्रि-आयामी" :'JJ',
"त्रिआयामिक" :'JJ',
"त्रिआयामी" :'JJ',
"त्रिकोणीय" :'JJ',
"त्रिघातीय" :'JJ',
"त्रितारंकित" :'JJ',
"त्रितारा" :'JJ',
"त्रिदोषज" :'JJ',
"त्रिनिदादियन" :'JJ',
"त्रिनिदादी" :'JJ',
"त्रिपद" :'JJ',
"त्रिपन" :'JJ',
"त्रिपनवाँ" :'JJ',
"त्रिपाद" :'JJ',
"त्रिभुजाकार" :'JJ',
"त्रिभुजी" :'JJ',
"त्रिभुजीय" :'JJ',
"त्रिमासीय" :'JJ',
"त्रिविम" :'JJ',
"त्रिविमीय" :'JJ',
"त्रिशूलधारी" :'JJ',
"त्रिशूली" :'JJ',
"त्रिसठ" :'JJ',
"त्रिसठवाँ" :'JJ',
"त्रुटिरहित" :'JJ',
"त्रुटिहीन" :'JJ',
"त्रेपन" :'JJ',
"त्रेपनवाँ" :'JJ',
"त्रैमासिक" :'JJ',
"त्वचा" :'JJ',
"त्वरित" :'JJ',
"थका" :'JJ',
"थका हुआ" :'JJ',
"थकाऊ" :'JJ',
"थकाने वाला" :'JJ',
"थकामाँदा" :'JJ',
"थकारांत" :'JJ',
"थकारादि" :'JJ',
"थकारान्त" :'JJ',
"थकाहारा" :'JJ',
"थकित" :'JJ',
"थनटुट्टू" :'JJ',
"थमा" :'JJ',
"थमा हुआ" :'JJ',
"थलचर" :'JJ',
"थलवासी" :'JJ',
"थलीय" :'JJ',
"थाई" :'JJ',
"थाईलैंडी" :'JJ',
"थाहरा" :'JJ',
"थिर" :'JJ',
"थुलथुल" :'JJ',
"थोक" :'JJ',
"थोड़ा" :'JJ',
"थोड़ा कड़ुआ" :'JJ',
"थोड़ा कड़ुवा" :'JJ',
"थोड़ा बहुत" :'JJ',
"थोड़ा मोटा-सा" :'JJ',
"थोड़ा-बहुत" :'JJ',
"थोड़ा-सा" :'JJ',
"थोथा" :'JJ',
"थ्री स्टार" :'JJ',
"दईमारा" :'JJ',
"दकारांत" :'JJ',
"दकारान्त" :'JJ',
"दकियानूस" :'JJ',
"दक़ियानूस" :'JJ',
"दकियानूसी" :'JJ',
"दक़ियानूसी" :'JJ',
"दक्खिनी" :'JJ',
"दक्ष" :'JJ',
"दक्षिण" :'JJ',
"दक्षिण अफ्रीका-संबंधी" :'JJ',
"दक्षिण अफ्रीकी" :'JJ',
"दक्षिण कोरियाई" :'JJ',
"दक्षिण ध्रुवी" :'JJ',
"दक्षिण ध्रुवीय" :'JJ',
"दक्षिण पच्छिमी" :'JJ',
"दक्षिण पश्चिमी" :'JJ',
"दक्षिण पूर्वी" :'JJ',
"दक्षिण मध्य" :'JJ',
"दक्षिण मध्यवर्ती" :'JJ',
"दक्षिण-पच्छिमी" :'JJ',
"दक्षिण-पश्चिमी" :'JJ',
"दक्षिण-पूर्वी" :'JJ',
"दक्षिण-मध्य" :'JJ',
"दक्षिण-मध्यवर्ती" :'JJ',
"दक्षिणपंथी" :'JJ',
"दक्षिणपन्थी" :'JJ',
"दक्षिणमार्गी" :'JJ',
"दक्षिणायण" :'JJ',
"दक्षिणायन" :'JJ',
"दक्षिणावर्त" :'JJ',
"दक्षिणावर्ती" :'JJ',
"दक्षिणी" :'JJ',
"दक्षिणी अमरीकी" :'JJ',
"दक्षिणी अमेरिकी" :'JJ',
"दक्षिणी कोरियाई" :'JJ',
"दक्षिणी पच्छिमी" :'JJ',
"दक्षिणी पश्चिमी" :'JJ',
"दक्षिणी पूर्वी" :'JJ',
"दक्षिणी मध्यवर्ती" :'JJ',
"दक्षिणी-अमरीकी" :'JJ',
"दक्षिणी-अमेरिकी" :'JJ',
"दक्षिणी-पच्छिमी" :'JJ',
"दक्षिणी-पश्चिमी" :'JJ',
"दक्षिणी-पूर्वी" :'JJ',
"दक्षिणी-मध्यवर्ती" :'JJ',
"दक्षिणीय" :'JJ',
"दखलंदाज" :'JJ',
"दख़लंदाज" :'JJ',
"दखलन्दाज" :'JJ',
"दख़लन्दाज" :'JJ',
"दंग" :'JJ',
"दंगई" :'JJ',
"दंगाई" :'JJ',
"दगाबाज" :'JJ',
"दग़ाबाज़" :'JJ',
"दंगाबाज" :'JJ',
"दंगाबाज़" :'JJ',
"दंगेबाज" :'JJ',
"दंगेबाज़" :'JJ',
"दंगैत" :'JJ',
"दगैल" :'JJ',
"दग्ध" :'JJ',
"दज्जाल" :'JJ',
"दंड पात्र" :'JJ',
"दंडनीय" :'JJ',
"दंडात्मक" :'JJ',
"दंडित" :'JJ',
"दढ़ियल" :'JJ',
"दण्डात्मक" :'JJ',
"दण्डित" :'JJ',
"दंत विषयक" :'JJ',
"दंतहीन" :'JJ',
"दंती" :'JJ',
"दंतीय" :'JJ',
"दँतुर" :'JJ',
"दंतुर" :'JJ',
"दँतुला" :'JJ',
"दंतुला" :'JJ',
"दतैल" :'JJ',
"दंतोष्ठ्य" :'JJ',
"दत्त" :'JJ',
"दत्तक" :'JJ',
"दत्तचित्त" :'JJ',
"दंत्य" :'JJ',
"ददिया" :'JJ',
"दन्त विषयक" :'JJ',
"दन्ती" :'JJ',
"दन्तीय" :'JJ',
"दन्तुर" :'JJ',
"दन्तोष्ठ्य" :'JJ',
"दन्त्य" :'JJ',
"दन्नाता" :'JJ',
"दफन" :'JJ',
"दफ़न" :'JJ',
"दफ्न" :'JJ',
"दफ़्न" :'JJ',
"दबंग" :'JJ',
"दबा" :'JJ',
"दबाया" :'JJ',
"दबाया हुआ" :'JJ',
"दब्बू" :'JJ',
"दंभहीन" :'JJ',
"दंभी" :'JJ',
"दमकता" :'JJ',
"दमघोंटू" :'JJ',
"दमदार" :'JJ',
"दमनकारी" :'JJ',
"दमनशील" :'JJ',
"दमयिता" :'JJ',
"दमित" :'JJ',
"दमी" :'JJ',
"दयनीय" :'JJ',
"दयानतदार" :'JJ',
"दयानिधान" :'JJ',
"दयानिधि" :'JJ',
"दयापात्र" :'JJ',
"दयामय" :'JJ',
"दयारहित" :'JJ',
"दयार्द्र" :'JJ',
"दयालु" :'JJ',
"दयावंत" :'JJ',
"दयावना" :'JJ',
"दयावान" :'JJ',
"दयावान्" :'JJ',
"दयाशील" :'JJ',
"दयासागर" :'JJ',
"दयाहीन" :'JJ',
"दर-माँदा" :'JJ',
"दरक" :'JJ',
"दरजन" :'JJ',
"दरदरा" :'JJ',
"दरबारी" :'JJ',
"दरमियाना" :'JJ',
"दराज" :'JJ',
"दराज़" :'JJ',
"दरित" :'JJ',
"दरिद्र" :'JJ',
"दरियाई" :'JJ',
"दरियादिल" :'JJ',
"दरैया" :'JJ',
"दर्ज" :'JJ',
"दर्ज़" :'JJ',
"दर्जन" :'JJ',
"दर्जनभर" :'JJ',
"दर्जेदार" :'JJ',
"दर्दनाक" :'JJ',
"दर्दमंद" :'JJ',
"दर्दमन्द" :'JJ',
"दर्दीला" :'JJ',
"दर्पहीन" :'JJ',
"दर्पित" :'JJ',
"दर्पी" :'JJ',
"दर्शक" :'JJ',
"दर्शनशास्त्रीय" :'JJ',
"दर्शनीय" :'JJ',
"दर्शित" :'JJ',
"दलदला" :'JJ',
"दलबदलू" :'JJ',
"दला" :'JJ',
"दला हुआ" :'JJ',
"दश" :'JJ',
"दश गुना" :'JJ',
"दशकीय" :'JJ',
"दशगुना" :'JJ',
"दशग्रंथी" :'JJ',
"दशधा" :'JJ',
"दशम" :'JJ',
"दशमलव" :'JJ',
"दशमिक" :'JJ',
"दस" :'JJ',
"दस करोड़" :'JJ',
"दस खरब" :'JJ',
"दस गुना" :'JJ',
"दस लाख" :'JJ',
"दस हजार" :'JJ',
"दस हज़ार" :'JJ',
"दसगुना" :'JJ',
"दसवाँ" :'JJ',
"दसेक" :'JJ',
"दस्तखती" :'JJ',
"दस्तख़ती" :'JJ',
"दस्तावर" :'JJ',
"दस्तावेजी" :'JJ',
"दस्तावेज़ी" :'JJ',
"दस्ती" :'JJ',
"दस्तेदार" :'JJ',
"दहकता" :'JJ',
"दहकता हुआ" :'JJ',
"दहशतगर्द" :'JJ',
"दहशतंगेज" :'JJ',
"दहशतंगेज़" :'JJ',
"दहशतजदा" :'JJ',
"दहशतज़दा" :'JJ',
"दहशतनाक" :'JJ',
"दहशतवादी" :'JJ',
"दहेजू" :'JJ',
"दाखिल" :'JJ',
"दाख़िल" :'JJ',
"दागदार" :'JJ',
"दाग़दार" :'JJ',
"दागरहित" :'JJ',
"दाग़रहित" :'JJ',
"दागी" :'JJ',
"दाग़ी" :'JJ',
"दाढ़ीवाला" :'JJ',
"दाँतरहित" :'JJ',
"दातव्य" :'JJ',
"दाता" :'JJ',
"दातृ" :'JJ',
"दाँतेदार" :'JJ',
"दान" :'JJ',
"दानकर्ता" :'JJ',
"दानवी" :'JJ',
"दानवीय" :'JJ',
"दानवीर" :'JJ',
"दानशील" :'JJ',
"दाना" :'JJ',
"दानिशमंद" :'JJ',
"दानिशमन्द" :'JJ',
"दानी" :'JJ',
"दानीय" :'JJ',
"दानेदार" :'JJ',
"दांपत्य" :'JJ',
"दाबदार" :'JJ',
"दांभिक" :'JJ',
"दामासाह" :'JJ',
"दाम्पत्य" :'JJ',
"दाय" :'JJ',
"दायक" :'JJ',
"दायर" :'JJ',
"दायाँ" :'JJ',
"दाँयाँ" :'JJ',
"दायाँवर्त" :'JJ',
"दायित्वहीन" :'JJ',
"दारु" :'JJ',
"दारुण" :'JJ',
"दार्शनिक" :'JJ',
"दाहक" :'JJ',
"दाहिक" :'JJ',
"दाहिना" :'JJ',
"दिक्-सूचक" :'JJ',
"दिक्सूचक" :'JJ',
"दिखनेवाला" :'JJ',
"दिखलाया हुआ" :'JJ',
"दिखाऊ" :'JJ',
"दिखावटी" :'JJ',
"दिखौआ" :'JJ',
"दिग्गज" :'JJ',
"दिग्दर्शक" :'JJ',
"दिग्भ्रमित" :'JJ',
"दिग्विजयी" :'JJ',
"दिग्व्यापी" :'JJ',
"दित्सु" :'JJ',
"दित्स्य" :'JJ',
"दिधिषू" :'JJ',
"दिधीषू" :'JJ',
"दिनदानी" :'JJ',
"दिनांकित" :'JJ',
"दिनारु" :'JJ',
"दिनौंध" :'JJ',
"दिनौंधा" :'JJ',
"दिनौन्ध" :'JJ',
"दिनौन्धा" :'JJ',
"दिमाग-चट" :'JJ',
"दिमागचट" :'JJ',
"दिमाग़चट" :'JJ',
"दिमागदार" :'JJ',
"दिमाग़दार" :'JJ',
"दिमागी" :'JJ',
"दिमाग़ी" :'JJ',
"दिया हुआ" :'JJ',
"दिल का बादशाह" :'JJ',
"दिल दहलाने वाला" :'JJ',
"दिल दहलानेवाला" :'JJ',
"दिलकश" :'JJ',
"दिलगीर" :'JJ',
"दिलचला" :'JJ',
"दिलचस्प" :'JJ',
"दिलचोर" :'JJ',
"दिलदरिया" :'JJ',
"दिलदार" :'JJ',
"दिलपसंद" :'JJ',
"दिलबर" :'JJ',
"दिलरुबा" :'JJ',
"दिलवाला" :'JJ',
"दिलशाद" :'JJ',
"दिलहेदार" :'JJ',
"दिलावर" :'JJ',
"दिली" :'JJ',
"दिलेर" :'JJ',
"दिल्लगीबाज" :'JJ',
"दिल्लगीबाज़" :'JJ',
"दिल्लीवाल" :'JJ',
"दिल्लेदार" :'JJ',
"दिवक्ष" :'JJ',
"दिवंगत" :'JJ',
"दिवस-अंध" :'JJ',
"दिवसीय" :'JJ',
"दिवांध" :'JJ',
"दिवाना" :'JJ',
"दिवानी" :'JJ',
"दिवान्ध" :'JJ',
"दिवालिया" :'JJ',
"दिविक्षया" :'JJ',
"दिव्य" :'JJ',
"दिशादर्शक" :'JJ',
"दिशाहीन" :'JJ',
"दिहाड़ीदार" :'JJ',
"दीक्षांत" :'JJ',
"दीक्षान्त" :'JJ',
"दीक्षित" :'JJ',
"दीगर" :'JJ',
"दीदारू" :'JJ',
"दीन" :'JJ',
"दीन पालक" :'JJ',
"दीन-पालक" :'JJ',
"दीन-हीन" :'JJ',
"दीनदयाल" :'JJ',
"दीनदयालु" :'JJ',
"दीनहीन" :'JJ',
"दीप्त" :'JJ',
"दीप्तिपूर्ण" :'JJ',
"दीप्तिमान" :'JJ',
"दीप्तिमान्" :'JJ',
"दीर्घ" :'JJ',
"दीर्घ-गामी" :'JJ',
"दीर्घ-सु-रत" :'JJ',
"दीर्घ-सूत्री" :'JJ',
"दीर्घकाय" :'JJ',
"दीर्घकालिक" :'JJ',
"दीर्घकालीन" :'JJ',
"दीर्घगामी" :'JJ',
"दीर्घजीवी" :'JJ',
"दीर्घतपा" :'JJ',
"दीर्घदर्शी" :'JJ',
"दीर्घप्रज्ञ" :'JJ',
"दीर्घरत" :'JJ',
"दीर्घरद" :'JJ',
"दीर्घसुरत" :'JJ',
"दीर्घसूत्री" :'JJ',
"दीर्घायु" :'JJ',
"दीवाना" :'JJ',
"दीवानी" :'JJ',
"दीवारी" :'JJ',
"दीवालिया" :'JJ',
"दु" :'JJ',
"दुख रहित" :'JJ',
"दुख-रहित" :'JJ',
"दुखकर" :'JJ',
"दुखंडा" :'JJ',
"दुखद" :'JJ',
"दुःखद" :'JJ',
"दुखदाई" :'JJ',
"दुःखदाई" :'JJ',
"दुखदायक" :'JJ',
"दुःखदायक" :'JJ',
"दुखदायी" :'JJ',
"दुखपूर्ण" :'JJ',
"दुखप्रद" :'JJ',
"दुखभरा" :'JJ',
"दुखमय" :'JJ',
"दुखरहित" :'JJ',
"दुःखरहित" :'JJ',
"दुखांत" :'JJ',
"दुखांतक" :'JJ',
"दुखात्मक" :'JJ',
"दुखान्त" :'JJ',
"दुखान्तक" :'JJ',
"दुखित" :'JJ',
"दुःखित" :'JJ',
"दुखियारा" :'JJ',
"दुखी" :'JJ',
"दुःखी" :'JJ',
"दुगना" :'JJ',
"दुगुना" :'JJ',
"दुग्ध" :'JJ',
"दुग्धयुक्त" :'JJ',
"दुग्धाहारी" :'JJ',
"दुग्धीय" :'JJ',
"दुतरफा" :'JJ',
"दुतरफ़ा" :'JJ',
"दुतर्फा" :'JJ',
"दुतर्फ़ा" :'JJ',
"दुतल्ला" :'JJ',
"दुधमुख" :'JJ',
"दुधमुँहा" :'JJ',
"दुधार" :'JJ',
"दुधारा" :'JJ',
"दुधारी" :'JJ',
"दुधारू" :'JJ',
"दुधिया" :'JJ',
"दुधैल" :'JJ',
"दुधैली" :'JJ',
"दुनली" :'JJ',
"दुनाली" :'JJ',
"दुनियाई" :'JJ',
"दुनियादार" :'JJ',
"दुनियाँदार" :'JJ',
"दुनियावी" :'JJ',
"दुपहरिया" :'JJ',
"दुपहरी" :'JJ',
"दुपहिया" :'JJ',
"दुबरा" :'JJ',
"दुबला" :'JJ',
"दुबला-पतला" :'JJ',
"दुबिधाग्रस्त" :'JJ',
"दुबिधाजनक" :'JJ',
"दुबिधाहीन" :'JJ',
"दुमछल्ला" :'JJ',
"दुमंजिला" :'JJ',
"दुमंज़िला" :'JJ',
"दुमदार" :'JJ',
"दुमहला" :'JJ',
"दुमुँहा" :'JJ',
"दुमुँहाँ" :'JJ',
"दुरंगा" :'JJ',
"दुरवार" :'JJ',
"दुराग्रही" :'JJ',
"दुराचरणी" :'JJ',
"दुराचारिणी" :'JJ',
"दुराचारी" :'JJ',
"दुरात्मा" :'JJ',
"दुराशय" :'JJ',
"दुरुस्त" :'JJ',
"दुरुस्तक" :'JJ',
"दुरुह" :'JJ',
"दुरूह" :'JJ',
"दुर्गंधपूर्ण" :'JJ',
"दुर्गंधयुक्त" :'JJ',
"दुर्गंधित" :'JJ',
"दुर्गन्धपूर्ण" :'JJ',
"दुर्गन्धयुक्त" :'JJ',
"दुर्गन्धित" :'JJ',
"दुर्गम" :'JJ',
"दुर्गम्य" :'JJ',
"दुर्गुणी" :'JJ',
"दुर्ग्रह" :'JJ',
"दुर्ग्राही" :'JJ',
"दुर्ग्राह्य" :'JJ',
"दुर्घट" :'JJ',
"दुर्जन" :'JJ',
"दुर्जेय" :'JJ',
"दुर्ज्ञेय" :'JJ',
"दुर्दम" :'JJ',
"दुर्दमनीय" :'JJ',
"दुर्दशाग्रस्त" :'JJ',
"दुर्नाम" :'JJ',
"दुर्निवार" :'JJ',
"दुर्निवार्य" :'JJ',
"दुर्निवार्य्य" :'JJ',
"दुर्बल" :'JJ',
"दुर्बोध" :'JJ',
"दुर्बोध्य" :'JJ',
"दुर्भर" :'JJ',
"दुर्भाग्यपूर्ण" :'JJ',
"दुर्भाग्यशाली" :'JJ',
"दुर्भेद्य" :'JJ',
"दुर्लभ" :'JJ',
"दुर्लिखित" :'JJ',
"दुर्वचनी" :'JJ',
"दुर्व्यवहारी" :'JJ',
"दुर्व्यसनी" :'JJ',
"दुलड़ा" :'JJ',
"दुलारा" :'JJ',
"दुविधाग्रस्त" :'JJ',
"दुविधाजनक" :'JJ',
"दुविधाहीन" :'JJ',
"दुशवार" :'JJ',
"दुश्चरित" :'JJ',
"दुश्चरिता" :'JJ',
"दुश्चरित्र" :'JJ',
"दुश्चरित्रा" :'JJ',
"दुश्मन" :'JJ',
"दुश्मनाना" :'JJ',
"दुश्वार" :'JJ',
"दुश्शील" :'JJ',
"दुष्कर" :'JJ',
"दुष्कर्मी" :'JJ',
"दुष्ट" :'JJ',
"दुष्टचित्त" :'JJ',
"दुष्टचेता" :'JJ',
"दुष्टमति" :'JJ',
"दुष्टात्मा" :'JJ',
"दुष्पाच्य" :'JJ',
"दुष्पार्य" :'JJ',
"दुष्प्रवृत्ति" :'JJ',
"दुष्प्रहर्ष" :'JJ',
"दुष्प्राप्य" :'JJ',
"दुःसह" :'JJ',
"दुःसाध्य" :'JJ',
"दुःसाहसी" :'JJ',
"दुस्तर" :'JJ',
"दुस्सह" :'JJ',
"दुस्साध्य" :'JJ',
"दुस्साहसी" :'JJ',
"दुहत्था" :'JJ',
"दुहरा" :'JJ',
"दुहराया" :'JJ',
"दुहा हुआ" :'JJ',
"दुहागिन" :'JJ',
"दुहाजू" :'JJ',
"दुहेजवाँ" :'JJ',
"दुहेजिया" :'JJ',
"दुहेजू" :'JJ',
"दुहेला" :'JJ',
"दूजा" :'JJ',
"दूध पीता" :'JJ',
"दूधमुँहा" :'JJ',
"दूधिया" :'JJ',
"दूना" :'JJ',
"दूभर" :'JJ',
"दूर" :'JJ',
"दूर का" :'JJ',
"दूर की कौड़ी" :'JJ',
"दूर दराज" :'JJ',
"दूर दराज़" :'JJ',
"दूर-दराज" :'JJ',
"दूर-दराज़" :'JJ',
"दूरगामी" :'JJ',
"दूरदराज" :'JJ',
"दूरदराज़" :'JJ',
"दूरदर्शी" :'JJ',
"दूरंदेश" :'JJ',
"दूरवर्ती" :'JJ',
"दूरस्थ" :'JJ',
"दूरागत" :'JJ',
"दूषित" :'JJ',
"दूसरा" :'JJ',
"दूसरी तरफ़ का" :'JJ',
"दूसरे का" :'JJ',
"दृढ़" :'JJ',
"दृढ़काय" :'JJ',
"दृढ़प्रतिज्ञ" :'JJ',
"दृढ़मत" :'JJ',
"दृढ़मतपूर्ण" :'JJ',
"दृढ़मतहीन" :'JJ',
"दृश्य" :'JJ',
"दृश्यमान" :'JJ',
"दृष्टिगत" :'JJ',
"दृष्टिगोचर" :'JJ',
"दृष्टियुक्त" :'JJ',
"दृष्टिवंत" :'JJ',
"दृष्टिवान" :'JJ',
"दृष्टिहीन" :'JJ',
"देखने योग्य" :'JJ',
"देखने लायक" :'JJ',
"देखा हुआ" :'JJ',
"देदीप्यमान" :'JJ',
"देनदार" :'JJ',
"देय" :'JJ',
"देर" :'JJ',
"देव कृत" :'JJ',
"देव-कृत" :'JJ',
"देवकीय" :'JJ',
"देवकृत" :'JJ',
"देवता कृत" :'JJ',
"देवता-कृत" :'JJ',
"देवताकृत" :'JJ',
"देवतातुल्य" :'JJ',
"देवतुल्य" :'JJ',
"देवत्त" :'JJ',
"देवत्य" :'JJ',
"देवदत्त" :'JJ',
"देवनिंदक" :'JJ',
"देवांशधारी" :'JJ',
"देवासुर" :'JJ',
"देवीय" :'JJ',
"देवैया" :'JJ',
"देश निर्वासित" :'JJ',
"देश भक्त" :'JJ',
"देश विरोधी" :'JJ',
"देश-निकाला" :'JJ',
"देश-भक्त" :'JJ',
"देश-विरोधी" :'JJ',
"देशज" :'JJ',
"देशत्यागी" :'JJ',
"देशद्रोही" :'JJ',
"देशनिकाला" :'JJ',
"देशभक्त" :'JJ',
"देशविरोधी" :'JJ',
"देशव्याप" :'JJ',
"देशव्यापी" :'JJ',
"देशान्तर्गत" :'JJ',
"देशी" :'JJ',
"देशीय" :'JJ',
"देसावरी" :'JJ',
"देसी" :'JJ',
"देहधारी" :'JJ',
"देहरहित" :'JJ',
"देहवान" :'JJ',
"देहवान्" :'JJ',
"देहातन" :'JJ',
"देहातिन" :'JJ',
"देहाती" :'JJ',
"देहीय" :'JJ',
"दैत्याकार" :'JJ',
"दैनिक" :'JJ',
"दैव" :'JJ',
"दैववादी" :'JJ',
"दैवागत" :'JJ',
"दैविक" :'JJ',
"दैवी" :'JJ',
"दैहिक" :'JJ',
"दो" :'JJ',
"दो तरफा" :'JJ',
"दो तरफ़ा" :'JJ',
"दो तिहाई" :'JJ',
"दो सितारा" :'JJ',
"दो सौ" :'JJ',
"दो सौ पचास" :'JJ',
"दो-एक" :'JJ',
"दो-चार" :'JJ',
"दो-चित्ता" :'JJ',
"दो-टूक" :'JJ',
"दो-तिहाई" :'JJ',
"दोखंडा" :'JJ',
"दोगला" :'JJ',
"दोग़ला" :'JJ',
"दोगुना" :'JJ',
"दोटूक" :'JJ',
"दोतरफा" :'JJ',
"दोतरफ़ा" :'JJ',
"दोतर्फा" :'JJ',
"दोतर्फ़ा" :'JJ',
"दोतल्ला" :'JJ',
"दोधारा" :'JJ',
"दोनली" :'JJ',
"दोनाली" :'JJ',
"दोनों" :'JJ',
"दोपहरिया" :'JJ',
"दोपहरी" :'JJ',
"दोपहिया" :'JJ',
"दोपाया" :'JJ',
"दोमंजिला" :'JJ',
"दोमंज़िला" :'JJ',
"दोमहला" :'JJ',
"दोमुँहा" :'JJ',
"दोमुँहाँ" :'JJ',
"दोरंगा" :'JJ',
"दोलायमान" :'JJ',
"दोषपूर्ण" :'JJ',
"दोषयुक्त" :'JJ',
"दोषरहित" :'JJ',
"दोषहीन" :'JJ',
"दोषिक" :'JJ',
"दोषित" :'JJ',
"दोषी" :'JJ',
"दोसौ" :'JJ',
"दोस्ताना" :'JJ',
"दोहत्था" :'JJ',
"दोहदवती" :'JJ',
"दोहरा" :'JJ',
"दोहराया" :'JJ',
"दोहला" :'JJ',
"दौग्ध" :'JJ',
"दौर्ग" :'JJ',
"दौर्ग्य" :'JJ',
"दौलतमंद" :'JJ',
"दौलतमन्द" :'JJ',
"द्युत" :'JJ',
"द्युतिकर" :'JJ',
"द्युतिधर" :'JJ',
"द्युतिमंत" :'JJ',
"द्युतिमत्" :'JJ',
"द्युतिमन्त" :'JJ',
"द्युतिमान" :'JJ',
"द्युतिमान्" :'JJ',
"द्योतक" :'JJ',
"द्रव" :'JJ',
"द्रवचालित" :'JJ',
"द्रवित" :'JJ',
"द्रवीभूत" :'JJ',
"द्रष्टा" :'JJ',
"द्रुत" :'JJ',
"द्रुतगति" :'JJ',
"द्रुतगामी" :'JJ',
"द्रोही" :'JJ',
"द्वय" :'JJ',
"द्वादश" :'JJ',
"द्वाविश" :'JJ',
"द्वाविंशति" :'JJ',
"द्वाषष्ठ" :'JJ',
"द्वाषष्ठि" :'JJ',
"द्वि" :'JJ',
"द्विअर्थी" :'JJ',
"द्विक" :'JJ',
"द्विगुण" :'JJ',
"द्विगुणित" :'JJ',
"द्विज" :'JJ',
"द्विजिह्व" :'JJ',
"द्वितारंकित" :'JJ',
"द्वितारा" :'JJ',
"द्वितीय" :'JJ',
"द्विदल" :'JJ',
"द्विदलीय" :'JJ',
"द्विदश" :'JJ',
"द्विपक्षी" :'JJ',
"द्विपक्षीय" :'JJ',
"द्विपद" :'JJ',
"द्विपाक्षिक" :'JJ',
"द्विपाद" :'JJ',
"द्विबाहु" :'JJ',
"द्विभाव" :'JJ',
"द्विभुज" :'JJ',
"द्विभुजा" :'JJ',
"द्विभूम" :'JJ',
"द्विवर्षी" :'JJ',
"द्विसीत्य" :'JJ',
"द्विहृदया" :'JJ',
"द्वींद्रिय" :'JJ',
"द्वीन्द्रिय" :'JJ',
"द्वीपीय" :'JJ',
"द्वेषपूर्ण" :'JJ',
"द्वेषमूलक" :'JJ',
"द्वेषहीन" :'JJ',
"द्वेषी" :'JJ',
"द्वैतवादी" :'JJ',
"द्वैती" :'JJ',
"धक्कादायक" :'JJ',
"धगड़बाज" :'JJ',
"धगड़बाज़" :'JJ',
"धगड़ी" :'JJ',
"धता" :'JJ',
"धधकता" :'JJ',
"धधकता हुआ" :'JJ',
"धंधार" :'JJ',
"धन" :'JJ',
"धन पिशाच" :'JJ',
"धन लोलुप" :'JJ',
"धन-लोलुप" :'JJ',
"धनत्तर" :'JJ',
"धनद" :'JJ',
"धनदत्त" :'JJ',
"धनदायी" :'JJ',
"धनधान्यपूर्ण" :'JJ',
"धनधान्यहीन" :'JJ',
"धनपिशाच" :'JJ',
"धनमूल" :'JJ',
"धनलोलुप" :'JJ',
"धनवंत" :'JJ',
"धनवन्त" :'JJ',
"धनवान" :'JJ',
"धनहर" :'JJ',
"धनहा" :'JJ',
"धनहीन" :'JJ',
"धनाढ्य" :'JJ',
"धनात्मक" :'JJ',
"धनी" :'JJ',
"धनुकी" :'JJ',
"धनुधर" :'JJ',
"धनुर्ग्रह" :'JJ',
"धनुर्ग्राह" :'JJ',
"धनुर्द्धर" :'JJ',
"धनुर्द्धारी" :'JJ',
"धनुर्धर" :'JJ',
"धनुर्धारी" :'JJ',
"धनुषधारी" :'JJ',
"धनुषाकार" :'JJ',
"धन्न" :'JJ',
"धन्य" :'JJ',
"धन्यवादी" :'JJ',
"धन्वाकार" :'JJ',
"धन्वी" :'JJ',
"धब्बेदार" :'JJ',
"धमधूसर" :'JJ',
"धमाकेदार" :'JJ',
"धरा-ढका" :'JJ',
"धराऊ" :'JJ',
"धरातली" :'JJ',
"धरातलीय" :'JJ',
"धराशायी" :'JJ',
"धर्म भीरु" :'JJ',
"धर्म-परायण" :'JJ',
"धर्म-भीरु" :'JJ',
"धर्मच्युत" :'JJ',
"धर्मज्ञ" :'JJ',
"धर्मज्ञानी" :'JJ',
"धर्मध्वजी" :'JJ',
"धर्मनिरपेक्ष" :'JJ',
"धर्मनिष्ठ" :'JJ',
"धर्मपति" :'JJ',
"धर्मपथभ्रष्ट" :'JJ',
"धर्मपरायण" :'JJ',
"धर्मभीरु" :'JJ',
"धर्मभ्रष्ट" :'JJ',
"धर्मविद" :'JJ',
"धर्मशास्त्री" :'JJ',
"धर्मशील" :'JJ',
"धर्महीन" :'JJ',
"धर्मात्मा" :'JJ',
"धर्मांध" :'JJ',
"धर्मानुयायी" :'JJ',
"धर्मान्ध" :'JJ',
"धर्मार्थ" :'JJ',
"धर्मावलंबी" :'JJ',
"धर्मी" :'JJ',
"धर्मोचित" :'JJ',
"धवरा" :'JJ',
"धँवरा" :'JJ',
"धवल" :'JJ',
"धवला" :'JJ',
"धंवी" :'JJ',
"धँसा" :'JJ',
"धाकड़" :'JJ',
"धाकदार" :'JJ',
"धात्विक" :'JJ',
"धात्वीय" :'JJ',
"धान-पान" :'JJ',
"धानक" :'JJ',
"धानकी" :'JJ',
"धानी" :'JJ',
"धानुक" :'JJ',
"धानुष्क" :'JJ',
"धारदार" :'JJ',
"धारवाला" :'JJ',
"धारा प्रवाह" :'JJ',
"धारा रेखित" :'JJ',
"धाराप्रवाह" :'JJ',
"धाराल" :'JJ',
"धारावत" :'JJ',
"धारावाहिक" :'JJ',
"धारावाही" :'JJ',
"धारी" :'JJ',
"धारीदार" :'JJ',
"धार्मिक" :'JJ',
"धीमा" :'JJ',
"धीमान" :'JJ',
"धीमान्" :'JJ',
"धीर" :'JJ',
"धीरज वाला" :'JJ',
"धुआँधार" :'JJ',
"धुआंधार" :'JJ',
"धुँआँधार" :'JJ',
"धुआँयँध" :'JJ',
"धुआँसा" :'JJ',
"धुत" :'JJ',
"धुत्त" :'JJ',
"धुँधला" :'JJ',
"धुँधलाया" :'JJ',
"धुँधियाला" :'JJ',
"धुर" :'JJ',
"धुरंधर" :'JJ',
"धुरन्धर" :'JJ',
"धुला" :'JJ',
"धुला हुआ" :'JJ',
"धूआँधार" :'JJ',
"धूँआँधार" :'JJ',
"धूपायित" :'JJ',
"धूपित" :'JJ',
"धूमल" :'JJ',
"धूमिल" :'JJ',
"धूर्त" :'JJ',
"धूर्ततापूर्ण" :'JJ',
"धूर्धर" :'JJ',
"धूल धूसरित" :'JJ',
"धूल भरा" :'JJ',
"धूल-धूसरित" :'JJ',
"धूल-भरा" :'JJ',
"धूलधूसरित" :'JJ',
"धूलभरा" :'JJ',
"धूलि धूसर" :'JJ',
"धूलि धूसरित" :'JJ',
"धूलि-धूसर" :'JJ',
"धूलि-धूसरित" :'JJ',
"धूलिधूसर" :'JJ',
"धूलिधूसरित" :'JJ',
"धूलिमय" :'JJ',
"धूसर" :'JJ',
"धूसरा" :'JJ',
"धूसरित" :'JJ',
"धृत" :'JJ',
"धृतराष्ट्री" :'JJ',
"धृष्ट" :'JJ',
"धृष्टभाषी" :'JJ',
"धेरा" :'JJ',
"धैर्यवान" :'JJ',
"धैर्यवान्" :'JJ',
"धैर्यशील" :'JJ',
"धैर्यहीन" :'JJ',
"धोखेबाज" :'JJ',
"धोखेबाज़" :'JJ',
"धोतीधारी" :'JJ',
"धोतीबंद" :'JJ',
"धोतीबन्द" :'JJ',
"धोने योग्य" :'JJ',
"धोमय" :'JJ',
"धोया" :'JJ',
"धोया हुआ" :'JJ',
"धोरी" :'JJ',
"धौत" :'JJ',
"धौंताल" :'JJ',
"धौरा" :'JJ',
"धौंरा" :'JJ',
"धौल" :'JJ',
"धौला" :'JJ',
"ध्याननिष्ठ" :'JJ',
"ध्यानमग्न" :'JJ',
"ध्यानयुक्त" :'JJ',
"ध्यानशील" :'JJ',
"ध्यानस्थ" :'JJ',
"ध्यानहीन" :'JJ',
"ध्यानाकर्षक" :'JJ',
"ध्यानावस्थित" :'JJ',
"ध्यानी" :'JJ',
"ध्रुवी" :'JJ',
"ध्रुवीय" :'JJ',
"ध्वजिक" :'JJ',
"ध्वजी" :'JJ',
"ध्वनिक" :'JJ',
"ध्वनिकारक" :'JJ',
"ध्वनित" :'JJ',
"ध्वनिमय" :'JJ',
"ध्वनिरहित" :'JJ',
"ध्वनिवेधी" :'JJ',
"ध्वन्यात्मक" :'JJ',
"ध्वंसक" :'JJ',
"ध्वंसकारी" :'JJ',
"ध्वंसनीय" :'JJ',
"ध्वंसित" :'JJ',
"ध्वस्त" :'JJ',
"ध्वंस्य" :'JJ',
"ध्वानिक" :'JJ',
"न तीन में न तेरह में" :'JJ',
"नककटा" :'JJ',
"नकचढ़ा" :'JJ',
"नकचिपटा" :'JJ',
"नकटा" :'JJ',
"नकतंचर" :'JJ',
"नकलची" :'JJ',
"नक़लची" :'JJ',
"नकली" :'JJ',
"नक़ली" :'JJ',
"नकारा" :'JJ',
"नकारांत" :'JJ',
"नकारात्मक" :'JJ',
"नकारान्त" :'JJ',
"नकारार्थक" :'JJ',
"नकारार्थी" :'JJ',
"नकाशीदार" :'JJ',
"नक्काशित" :'JJ',
"नक्क़ाशित" :'JJ',
"नक्काशीदार" :'JJ',
"नक्क़ाशीदार" :'JJ',
"नक्त" :'JJ',
"नक्तञ्चर" :'JJ',
"नक्श" :'JJ',
"नक़्श" :'JJ',
"नक्सल" :'JJ',
"नक्सलवादी" :'JJ',
"नक्सली" :'JJ',
"नखखादी" :'JJ',
"नखरीला" :'JJ',
"नखरेबाज" :'JJ',
"नखरेबाज़" :'JJ',
"नख़रेबाज़" :'JJ',
"नखशिख" :'JJ',
"नंग धड़ंग" :'JJ',
"नगण्य" :'JJ',
"नंगपैरा" :'JJ',
"नगर निवासी" :'JJ',
"नगर वासी" :'JJ',
"नगर-निवासी" :'JJ',
"नगर-वासी" :'JJ',
"नगरनिवासी" :'JJ',
"नगरवासी" :'JJ',
"नगरीकृत" :'JJ',
"नगरीय" :'JJ',
"नंगा" :'JJ',
"नग्न" :'JJ',
"नङ्ग धड़ङ्ग" :'JJ',
"नङ्गा" :'JJ',
"नजदीकी" :'JJ',
"नज़दीकी" :'JJ',
"नजर अंदाज" :'JJ',
"नज़र अंदाज़" :'JJ',
"नजर अन्दाज" :'JJ',
"नज़र अन्दाज़" :'JJ',
"नजर-अंदाज" :'JJ',
"नज़र-अंदाज़" :'JJ',
"नजर-अन्दाज" :'JJ',
"नज़र-अन्दाज़" :'JJ',
"नज़रअंदाज़ किया" :'JJ',
"नजरंदाज" :'JJ',
"नज़रंदाज़" :'JJ',
"नजरन्दाज" :'JJ',
"नज़रन्दाज़" :'JJ',
"नजरबंद" :'JJ',
"नज़रबंद" :'JJ',
"नटखट" :'JJ',
"नड़प्राय" :'JJ',
"नड़भय" :'JJ',
"नत" :'JJ',
"नतमस्तक" :'JJ',
"नतशीश" :'JJ',
"नतोदर" :'JJ',
"नंदक" :'JJ',
"नदारत" :'JJ',
"नदारद" :'JJ',
"नन्दक" :'JJ',
"नन्हा" :'JJ',
"नन्हाँ" :'JJ',
"नन्हा मुन्ना" :'JJ',
"नन्हा-मुन्ना" :'JJ',
"नन्हा-सा" :'JJ',
"नपा हुआ" :'JJ',
"नपा-तुला" :'JJ',
"नपातुला" :'JJ',
"नपुंसक" :'JJ',
"नफीस" :'JJ',
"नफ़ीस" :'JJ',
"नब्बे" :'JJ',
"नब्बेवाँ" :'JJ',
"नब्बेवां" :'JJ',
"नभगामी" :'JJ',
"नभचर" :'JJ',
"नभचारी" :'JJ',
"नभश्चर" :'JJ',
"नम" :'JJ',
"नमक हराम" :'JJ',
"नमकरहित" :'JJ',
"नमकहराम" :'JJ',
"नमकीन" :'JJ',
"नमनीय" :'JJ',
"नमित" :'JJ',
"नम्य" :'JJ',
"नम्र" :'JJ',
"नम्रतारहित" :'JJ',
"नयनगोचर" :'JJ',
"नयनरम्य" :'JJ',
"नयनाभिराम" :'JJ',
"नयनाभिरामी" :'JJ',
"नयशील" :'JJ',
"नया" :'JJ',
"नया नवेला" :'JJ',
"नया-नवेला" :'JJ',
"नर" :'JJ',
"नरकीय" :'JJ',
"नरभक्षक" :'JJ',
"नरभक्षी" :'JJ',
"नरम" :'JJ',
"नरम नरम" :'JJ',
"नरम-नरम" :'JJ',
"नर्तक" :'JJ',
"नर्तित" :'JJ',
"नर्म" :'JJ',
"नलिकाविहीन" :'JJ',
"नव" :'JJ',
"नव प्रशिक्षित" :'JJ',
"नव ब्याहता" :'JJ',
"नव विवाहिता" :'JJ',
"नव-प्रसूत" :'JJ',
"नवगुना" :'JJ',
"नवजात" :'JJ',
"नवनियुक्त" :'JJ',
"नवनिर्मित" :'JJ',
"नवपरिणीत" :'JJ',
"नवप्रसूत" :'JJ',
"नवब्याहता" :'JJ',
"नवब्याहा" :'JJ',
"नवम" :'JJ',
"नवरचित" :'JJ',
"नवल" :'JJ',
"नवलक्खा" :'JJ',
"नवलखा" :'JJ',
"नवविवाहित" :'JJ',
"नवविवाहिता" :'JJ',
"नवसिखा" :'JJ',
"नवसिखुआ" :'JJ',
"नवाँ" :'JJ',
"नवागत" :'JJ',
"नवागंतुक" :'JJ',
"नवागन्तुक" :'JJ',
"नवाज" :'JJ',
"नवाज़" :'JJ',
"नवाब" :'JJ',
"नवाबी" :'JJ',
"नवासी" :'JJ',
"नवासीवाँ" :'JJ',
"नवीकरणीय" :'JJ',
"नवीकृत" :'JJ',
"नवीन" :'JJ',
"नवीनतम" :'JJ',
"नवीनीकरणीय" :'JJ',
"नवीनीकृत" :'JJ',
"नवेक" :'JJ',
"नवोदित" :'JJ',
"नव्य" :'JJ',
"नशाखोर" :'JJ',
"नशाख़ोर" :'JJ',
"नशारहित" :'JJ',
"नशाहीन" :'JJ',
"नशीला" :'JJ',
"नशेड़ी" :'JJ',
"नशेदार" :'JJ',
"नशेबाज" :'JJ',
"नशेबाज़" :'JJ',
"नश्वर" :'JJ',
"नष्ट" :'JJ',
"नष्ट भ्रष्ट" :'JJ',
"नष्ट-भ्रष्ट" :'JJ',
"नष्टभ्रष्ट" :'JJ',
"नष्टविष" :'JJ',
"नष्टा" :'JJ',
"नष्टाशंक" :'JJ',
"नष्टासु" :'JJ',
"नसंक" :'JJ',
"नसतालीक" :'JJ',
"नसतालीक़" :'JJ',
"नसीब वाला" :'JJ',
"नसीय" :'JJ',
"नस्य" :'JJ',
"नस्ली" :'JJ',
"नहरी" :'JJ',
"नहाया" :'JJ',
"नहाया हुआ" :'JJ',
"नहिक" :'JJ',
"ना-गवार" :'JJ',
"ना-लायक" :'JJ',
"ना-लायाक" :'JJ',
"नाइजीरियन" :'JJ',
"नाइजीरिया-संबंधी" :'JJ',
"नाइजीरियाई" :'JJ',
"नाइजेरियन" :'JJ',
"नाइजेरिया-संबंधी" :'JJ',
"नाइजेरियाई" :'JJ',
"नाइट्रिक" :'JJ',
"नाइस्तमालशुदा" :'JJ',
"नाइस्तेमालशुदा" :'JJ',
"नाउम्मीद" :'JJ',
"नाएतबारा" :'JJ',
"नाकआउट" :'JJ',
"नाकाउट" :'JJ',
"नाकाफी" :'JJ',
"नाकाफ़ी" :'JJ',
"नाकाबिल" :'JJ',
"नाक़ाबिल" :'JJ',
"नाकाम" :'JJ',
"नाकामयाब" :'JJ',
"नाकारा" :'JJ',
"नाकुल" :'JJ',
"नाखुश" :'JJ',
"नाख़ुश" :'JJ',
"नागद्रुमा" :'JJ',
"नागपुरी" :'JJ',
"नागर" :'JJ',
"नागरिक" :'JJ',
"नागरीट" :'JJ',
"नागरेयक" :'JJ',
"नागवार" :'JJ',
"नागवीट" :'JJ',
"नागा" :'JJ',
"नाँगा" :'JJ',
"नांगा" :'JJ',
"नागालैंडी" :'JJ',
"नागालैण्डी" :'JJ',
"नाचता हुआ" :'JJ',
"नाचने वाला" :'JJ',
"नाचनेवाला" :'JJ',
"नाचीज" :'JJ',
"नाचीज़" :'JJ',
"नाजदार" :'JJ',
"नाज़दार" :'JJ',
"नाजनीन" :'JJ',
"नाज़नीन" :'JJ',
"नाजायज" :'JJ',
"नाजायज़" :'JJ',
"नाजिर" :'JJ',
"नाज़िर" :'JJ',
"नाजुक" :'JJ',
"नाज़ुक" :'JJ',
"नाटकीय" :'JJ',
"नाटा" :'JJ',
"नाथ पंथी" :'JJ',
"नाथ सम्प्रदायी" :'JJ',
"नाथ-पंथी" :'JJ',
"नाथपंथी" :'JJ',
"नाथहीन" :'JJ',
"नादान" :'JJ',
"नादित" :'JJ',
"नादिम" :'JJ',
"नादिर" :'JJ',
"नादिरशाही" :'JJ',
"नादुरुस्त" :'JJ',
"नाना" :'JJ',
"नाना प्रकार का" :'JJ',
"नापनीय" :'JJ',
"नापसंद" :'JJ',
"नापसंदीदा" :'JJ',
"नापसन्द" :'JJ',
"नापसन्दीदा" :'JJ',
"नापाक" :'JJ',
"नापास" :'JJ',
"नाबदानी" :'JJ',
"नाबाद" :'JJ',
"नाबालिग" :'JJ',
"नाबालिग़" :'JJ',
"नाभिकीय" :'JJ',
"नाम का" :'JJ',
"नाम चार का" :'JJ',
"नाम भर का" :'JJ',
"नामक" :'JJ',
"नामचीन" :'JJ',
"नामजद" :'JJ',
"नामज़द" :'JJ',
"नामंजूर" :'JJ',
"नामंज़ूर" :'JJ',
"नामदार" :'JJ',
"नामधारी" :'JJ',
"नामर्द" :'JJ',
"नामवर" :'JJ',
"नामहीन" :'JJ',
"नामा" :'JJ',
"नामांकित" :'JJ',
"नामाङ्कित" :'JJ',
"नामालूम" :'JJ',
"नामित" :'JJ',
"नामिबियन" :'JJ',
"नामिबिया-संबंधी" :'JJ',
"नामिबियाई" :'JJ',
"नामी" :'JJ',
"नामी गिरामी" :'JJ',
"नामी-गिरामी" :'JJ',
"नामीगिरामी" :'JJ',
"नामुनासिब" :'JJ',
"नामुमकिन" :'JJ',
"नाम्नी" :'JJ',
"नायाब" :'JJ',
"नार" :'JJ',
"नारकिक" :'JJ',
"नारकीय" :'JJ',
"नारंगी" :'JJ',
"नारदीय" :'JJ',
"नाराज" :'JJ',
"नाराज़" :'JJ',
"नार्मल" :'JJ',
"नार्मिन" :'JJ',
"नार्वेजियन" :'JJ',
"नालंब" :'JJ',
"नालायक" :'JJ',
"नावाकिफ" :'JJ',
"नावाक़िफ़" :'JJ',
"नाशक" :'JJ',
"नाशन" :'JJ',
"नाशवान" :'JJ',
"नाशी" :'JJ',
"नाशुक" :'JJ',
"नाश्य" :'JJ',
"नासपिटा" :'JJ',
"नासपीटा" :'JJ',
"नासमझ" :'JJ',
"नासिक्य" :'JJ',
"नास्तिक" :'JJ',
"नास्तिकतावादी" :'JJ',
"नि-जोर" :'JJ',
"निकट का" :'JJ',
"निकटतम" :'JJ',
"निकटवर्ती" :'JJ',
"निकटस्थ" :'JJ',
"निकंदन" :'JJ',
"निःकपट" :'JJ',
"निकम्मा" :'JJ',
"निकाय संबंधी" :'JJ',
"निकारगुअन" :'JJ',
"निकारगुआई" :'JJ',
"निकाला हुआ" :'JJ',
"निकासित" :'JJ',
"निकुंचित" :'JJ',
"निकुञ्चित" :'JJ',
"निकृतिप्रज्ञ" :'JJ',
"निकृष्ट" :'JJ',
"निकृष्टतम" :'JJ',
"निकृष्टतम्" :'JJ',
"निखट्टर" :'JJ',
"निखट्टू" :'JJ',
"निखर्व" :'JJ',
"निखात" :'JJ',
"निखालिस" :'JJ',
"निख़ालिस" :'JJ',
"निगटिव" :'JJ',
"निगंध" :'JJ',
"निगमी" :'JJ',
"निगमीय" :'JJ',
"निगरा" :'JJ',
"निगलित" :'JJ',
"निगुरा" :'JJ',
"निगेटिव" :'JJ',
"निगोड़ा" :'JJ',
"निगोड़ा नाथा" :'JJ',
"निग्रही" :'JJ',
"निघ्न" :'JJ',
"निचला" :'JJ',
"निचेय" :'JJ',
"निजकृत" :'JJ',
"निजधृति" :'JJ',
"निजरक्षित" :'JJ',
"निजाई" :'JJ',
"निज़ाई" :'JJ',
"निजामी" :'JJ',
"निजा़मी" :'JJ',
"निजी" :'JJ',
"निटर" :'JJ',
"निठल्ला" :'JJ',
"निठल्लू" :'JJ',
"निडर" :'JJ',
"निढाल" :'JJ',
"नित्य" :'JJ',
"नित्य आनेवाला" :'JJ',
"निंदक" :'JJ',
"निदद्रु" :'JJ',
"निंदनीय" :'JJ',
"निंदात्मक" :'JJ',
"निदारुण" :'JJ',
"निंदासा" :'JJ',
"निंदित" :'JJ',
"निद्य" :'JJ',
"निद्रा रहित" :'JJ',
"निद्रागत" :'JJ',
"निद्राग्रस्त" :'JJ',
"निद्रातुर" :'JJ',
"निद्रान्वित" :'JJ',
"निद्रामग्न" :'JJ',
"निद्रारहित" :'JJ',
"निद्रालु" :'JJ',
"निद्राविहीन" :'JJ',
"निद्राशील" :'JJ',
"निद्रित" :'JJ',
"निधड़क" :'JJ',
"निधनी" :'JJ',
"निधेय" :'JJ',
"निनादित" :'JJ',
"निनानबे" :'JJ',
"निनानबेवाँ" :'JJ',
"निनानवे" :'JJ',
"निनानवेवाँ" :'JJ',
"निन्दक" :'JJ',
"निन्दनीय" :'JJ',
"निन्दात्मक" :'JJ',
"निन्दित" :'JJ',
"निन्यानबे" :'JJ',
"निन्यानबेवाँ" :'JJ',
"निन्यानवे" :'JJ',
"निन्यानवेवाँ" :'JJ',
"निपंग" :'JJ',
"निपट" :'JJ',
"निपट गँवार" :'JJ',
"निपटा" :'JJ',
"निपटा हुआ" :'JJ',
"निपठित" :'JJ',
"निपात" :'JJ',
"निपातनीय" :'JJ',
"निपाती" :'JJ',
"निपुण" :'JJ',
"निपूत" :'JJ',
"निपूता" :'JJ',
"निपूती" :'JJ',
"निप्पोनीज़" :'JJ',
"निप्पोनीस" :'JJ',
"निःप्रयोजन" :'JJ',
"निबद्ध" :'JJ',
"निबल" :'JJ',
"निबहुर" :'JJ',
"निबहुरा" :'JJ',
"निभृत" :'JJ',
"निमग्न" :'JJ',
"निमज्जित" :'JJ',
"निमता" :'JJ',
"निमंत्रक" :'JJ',
"निमंत्रित" :'JJ',
"निमन्त्रित" :'JJ',
"निमेषरहित" :'JJ',
"निम्न" :'JJ',
"निम्न कुलीन" :'JJ',
"निम्न वर्गीय" :'JJ',
"निम्न वंशीय" :'JJ',
"निम्नलिखित" :'JJ',
"निम्नांकित" :'JJ',
"निम्नोक्त" :'JJ',
"नियत" :'JJ',
"नियततापी" :'JJ',
"नियति अधीन" :'JJ',
"नियतेंद्रिय" :'JJ',
"नियंत्रक" :'JJ',
"नियंत्रित" :'JJ',
"नियम पालक" :'JJ',
"नियम-रहित" :'JJ',
"नियमबद्ध" :'JJ',
"नियमरहित" :'JJ',
"नियमित" :'JJ',
"नियमी" :'JJ',
"नियामत" :'JJ',
"नियुक्त" :'JJ',
"नियोक्ता" :'JJ',
"नियोजित" :'JJ',
"नियोज्य" :'JJ',
"निरंकार" :'JJ',
"निरंकारी" :'JJ',
"निरंकुश" :'JJ',
"निरक्षर" :'JJ',
"निरंग" :'JJ',
"निरङ्ग" :'JJ',
"निरंजन" :'JJ',
"निरत" :'JJ',
"निरन्न" :'JJ',
"निरन्ना" :'JJ',
"निरन्वय" :'JJ',
"निरप" :'JJ',
"निरपत्रय" :'JJ',
"निरपराध" :'JJ',
"निरपराधी" :'JJ',
"निरपवाद" :'JJ',
"निरपेक्ष" :'JJ',
"निरपेक्षित" :'JJ',
"निरप्र" :'JJ',
"निरभिमान" :'JJ',
"निरभिमानी" :'JJ',
"निरभ्र" :'JJ',
"निरर्थक" :'JJ',
"निरव" :'JJ',
"निरवयव" :'JJ',
"निरवलंब" :'JJ',
"निरवलम्ब" :'JJ',
"निरवसाद" :'JJ',
"निरसित" :'JJ',
"निरस्त" :'JJ',
"निरस्त्र" :'JJ',
"निरहंकर" :'JJ',
"निरहंकार" :'JJ',
"निरहंकारी" :'JJ',
"निरहंकृत" :'JJ',
"निरहङ्कार" :'JJ',
"निरहङ्कृत" :'JJ',
"निरहङ्कृति" :'JJ',
"निरा" :'JJ',
"निराकांक्ष" :'JJ',
"निराकांक्षी" :'JJ',
"निराकार" :'JJ',
"निराकुल" :'JJ',
"निरागस" :'JJ',
"निरादरणीय" :'JJ',
"निरादृत" :'JJ',
"निराधार" :'JJ',
"निराधि" :'JJ',
"निरानंद" :'JJ',
"निरानन्द" :'JJ',
"निरापद" :'JJ',
"निरामय" :'JJ',
"निरामिष" :'JJ',
"निरायुध" :'JJ',
"निरालंब" :'JJ',
"निरालम्ब" :'JJ',
"निरालस" :'JJ',
"निरालस्य" :'JJ',
"निराला" :'JJ',
"निरावासित" :'JJ',
"निराश" :'JJ',
"निराशाजनक" :'JJ',
"निराशावादी" :'JJ',
"निराश्रय" :'JJ',
"निराश्रित" :'JJ',
"निराश्रिय" :'JJ',
"निराहार" :'JJ',
"निरिच्छ" :'JJ',
"निरीक्षक" :'JJ',
"निरीश्वरवादी" :'JJ',
"निरीह" :'JJ',
"निरुत्तर" :'JJ',
"निरुत्पाती" :'JJ',
"निरुत्साहित" :'JJ',
"निरुत्साही" :'JJ',
"निरुत्सुक" :'JJ',
"निरुदक" :'JJ',
"निरुद्देश्य" :'JJ',
"निरुद्ध" :'JJ',
"निरुद्यम" :'JJ',
"निरुद्यमी" :'JJ',
"निरुद्योगी" :'JJ',
"निरुद्विग्न" :'JJ',
"निरुद्वेग" :'JJ',
"निरुपद्रव" :'JJ',
"निरुपयोगी" :'JJ',
"निरुपाय" :'JJ',
"निरूपित" :'JJ',
"निरोग" :'JJ',
"निरोगकर" :'JJ',
"निरोगी" :'JJ',
"निरोठा" :'JJ',
"निरोधक" :'JJ',
"निरोधी" :'JJ',
"निर्गत" :'JJ',
"निर्गंध" :'JJ',
"निर्गुण" :'JJ',
"निर्गुन" :'JJ',
"निर्जन" :'JJ',
"निर्जल" :'JJ',
"निर्जला" :'JJ',
"निर्जीव" :'JJ',
"निर्ज्वर" :'JJ',
"निर्णायक" :'JJ',
"निर्णित" :'JJ',
"निर्णीत" :'JJ',
"निर्दय" :'JJ',
"निर्दयी" :'JJ',
"निर्दल" :'JJ',
"निर्दली" :'JJ',
"निर्दलीय" :'JJ',
"निर्दशन" :'JJ',
"निर्दिष्ट" :'JJ',
"निर्देशित" :'JJ',
"निर्दोष" :'JJ',
"निर्दोषी" :'JJ',
"निर्द्वंद्व" :'JJ',
"निर्द्वंद्वी" :'JJ',
"निर्द्वन्द्व" :'JJ',
"निर्द्वन्द्वी" :'JJ',
"निर्धन" :'JJ',
"निर्धारित" :'JJ',
"निर्निमेष" :'JJ',
"निर्पेक्ष" :'JJ',
"निर्बल" :'JJ',
"निर्बाध" :'JJ',
"निर्बीज" :'JJ',
"निर्बुद्धि" :'JJ',
"निर्भय" :'JJ',
"निर्भर" :'JJ',
"निर्भाग" :'JJ',
"निर्भाव" :'JJ',
"निर्भीक" :'JJ',
"निर्भीत" :'JJ',
"निर्भेद्य" :'JJ',
"निर्मम" :'JJ',
"निर्मर्याद" :'JJ',
"निर्मल" :'JJ',
"निर्मशक" :'JJ',
"निर्माणाधीन" :'JJ',
"निर्मान" :'JJ',
"निर्मित" :'JJ',
"निर्मुकुट" :'JJ',
"निर्मूल" :'JJ',
"निर्मोल" :'JJ',
"निर्मोही" :'JJ',
"निर्यत्न" :'JJ',
"निर्यातक" :'JJ',
"निर्यातित" :'JJ',
"निर्लज्ज" :'JJ',
"निर्लिप्त" :'JJ',
"निर्लोभ" :'JJ',
"निर्लोभी" :'JJ',
"निर्वचन" :'JJ',
"निर्वंश" :'JJ',
"निर्वस्त्र" :'JJ',
"निर्वाक" :'JJ',
"निर्वाक्य" :'JJ',
"निर्वाचित" :'JJ',
"निर्वाण प्राप्त" :'JJ',
"निर्वात" :'JJ',
"निर्वासित" :'JJ',
"निर्विकार" :'JJ',
"निर्विघ्न" :'JJ',
"निर्विभाग" :'JJ',
"निर्विरोध" :'JJ',
"निर्विवाद" :'JJ',
"निर्विवादित" :'JJ',
"निर्वीर" :'JJ',
"निर्वेतन" :'JJ',
"निर्व्यसनी" :'JJ',
"निर्व्याज" :'JJ',
"निर्व्याधि" :'JJ',
"निलज" :'JJ',
"निलज्ज" :'JJ',
"निलज्जा" :'JJ',
"निलंबित" :'JJ',
"निलम्बित" :'JJ',
"निवछरा" :'JJ',
"निवस्त्र" :'JJ',
"निवापक" :'JJ',
"निवारक" :'JJ',
"निवारित" :'JJ',
"निवार्य" :'JJ',
"निविड़" :'JJ',
"निविरीस" :'JJ',
"निवृत्त" :'JJ',
"निवेदक" :'JJ',
"निवेदित" :'JJ',
"निवेशक" :'JJ',
"निःशंक" :'JJ',
"निःशङ्क" :'JJ',
"निःशब्द" :'JJ',
"निशाचर" :'JJ',
"निशाचारी" :'JJ',
"निशाट" :'JJ',
"निशाद" :'JJ',
"निशांध" :'JJ',
"निशानेबाज" :'JJ',
"निशानेबाज़" :'JJ',
"निशान्ध" :'JJ',
"निशिचर" :'JJ',
"निशिचारी" :'JJ',
"निशित" :'JJ',
"निशुल्क" :'JJ',
"निःशुल्क" :'JJ',
"निश्चक्षु" :'JJ',
"निश्चयक" :'JJ',
"निश्चयकारक" :'JJ',
"निश्चयकारी" :'JJ',
"निश्चयात्मक" :'JJ',
"निश्चल" :'JJ',
"निश्चित" :'JJ',
"निश्चिंत" :'JJ',
"निश्चिन्त" :'JJ',
"निश्चेतक" :'JJ',
"निश्चेष्ट" :'JJ',
"निश्छल" :'JJ',
"निश्छिद्र" :'JJ',
"निश्शंक" :'JJ',
"निश्शब्द" :'JJ',
"निश्शस्त्र" :'JJ',
"निश्शुल्क" :'JJ',
"निषक्त" :'JJ',
"निषिद्ध" :'JJ',
"निषेधहीन" :'JJ',
"निषेधित" :'JJ',
"निष्कंटक" :'JJ',
"निष्कपट" :'JJ',
"निष्कलंक" :'JJ',
"निष्काम" :'JJ',
"निष्कामी" :'JJ',
"निष्काशित" :'JJ',
"निष्कासित" :'JJ',
"निष्क्रिय" :'JJ',
"निष्ठारहित" :'JJ',
"निष्ठावान" :'JJ',
"निष्ठाहीन" :'JJ',
"निष्ठुर" :'JJ',
"निष्णात" :'JJ',
"निष्पक्ष" :'JJ',
"निष्पत्र" :'JJ',
"निष्पन्न" :'JJ',
"निष्पादित" :'JJ',
"निष्पाप" :'JJ',
"निष्प्रयोजन" :'JJ',
"निष्प्राण" :'JJ',
"निष्फल" :'JJ',
"निष्फला" :'JJ',
"निष्य" :'JJ',
"निसंकोच" :'JJ',
"निःसंकोच" :'JJ',
"निसंकोची" :'JJ',
"निःसंकोची" :'JJ',
"निःसंग" :'JJ',
"निःसंतान" :'JJ',
"निःसत्व" :'JJ',
"निसर्गेण" :'JJ',
"निसवादला" :'JJ',
"निसस" :'JJ',
"निःसहाय" :'JJ',
"निसाँक" :'JJ',
"निसार" :'JJ',
"निःसार" :'JJ',
"निसाँस" :'JJ',
"निसाँसा" :'JJ',
"निसिचर" :'JJ',
"निस्कंप" :'JJ',
"निस्कम्प" :'JJ',
"निस्तत्त्व" :'JJ',
"निस्तत्व" :'JJ',
"निस्तब्ध" :'JJ',
"निस्तेज" :'JJ',
"निस्तेज़" :'JJ',
"निस्पंद" :'JJ',
"निस्पन्द" :'JJ',
"निस्पृह" :'JJ',
"निःस्पृह" :'JJ',
"निस्पृही" :'JJ',
"निःस्पृही" :'JJ',
"निःस्यंदन" :'JJ',
"निःस्यन्दन" :'JJ',
"निस्वार्थ" :'JJ',
"निःस्वार्थ" :'JJ',
"निःस्वार्थी" :'JJ',
"निस्संकोच" :'JJ',
"निस्संकोची" :'JJ',
"निस्संग" :'JJ',
"निस्संतान" :'JJ',
"निस्सहाय" :'JJ',
"निस्सार" :'JJ',
"निस्सीम" :'JJ',
"निहकाम" :'JJ',
"निहंग" :'JJ',
"निहंग-लाडला" :'JJ',
"निहंग-लाड़ला" :'JJ',
"निहंगम" :'JJ',
"निहङ्ग" :'JJ',
"निहङ्गम" :'JJ',
"निहत" :'JJ',
"निहत्था" :'JJ',
"निहाल" :'JJ',
"निहित" :'JJ',
"नीच" :'JJ',
"नीचकुलोत्पन्न" :'JJ',
"नीचा" :'JJ',
"नीचे उतारा हुआ" :'JJ',
"नीठो" :'JJ',
"नीठौ" :'JJ',
"नीतिकुशल" :'JJ',
"नीतिगत" :'JJ',
"नीतिज्ञ" :'JJ',
"नीतिनिपुण" :'JJ',
"नीतिपूर्ण" :'JJ',
"नीतिभ्रष्ट" :'JJ',
"नीतियुक्त" :'JJ',
"नीतिविरुद्ध" :'JJ',
"नीबर" :'JJ',
"नींबू-निचोड़" :'JJ',
"नीम" :'JJ',
"नीम चढ़ा" :'JJ',
"नीम पागल" :'JJ',
"नीम रजा" :'JJ',
"नीम रज़ा" :'JJ',
"नीम राजी" :'JJ',
"नीम राज़ी" :'JJ',
"नीमजोश" :'JJ',
"नीमटर" :'JJ',
"नीमपागल" :'JJ',
"नीमरजा" :'JJ',
"नीमरज़ा" :'JJ',
"नीमराजी" :'JJ',
"नीमराज़ी" :'JJ',
"नीरद" :'JJ',
"नीरंध्र" :'JJ',
"नीरन्ध्र" :'JJ',
"नीरव" :'JJ',
"नीरस" :'JJ',
"नीरोग" :'JJ',
"नीरोगकर" :'JJ',
"नील" :'JJ',
"नील-कंठ" :'JJ',
"नीलकंठ" :'JJ',
"नीला" :'JJ',
"नीलाक्ष" :'JJ',
"नीवानास" :'JJ',
"नीसक" :'JJ',
"नुकता-चीन" :'JJ',
"नुकताचीन" :'JJ',
"नुकरा" :'JJ',
"नुकसानकारी" :'JJ',
"नुक़सानकारी" :'JJ',
"नुकसानदायक" :'JJ',
"नुक़सानदायक" :'JJ',
"नुकसानदेह" :'JJ',
"नुक़सानदेह" :'JJ',
"नुकीला" :'JJ',
"नुक्ता-चीन" :'JJ',
"नुक्ताचीन" :'JJ',
"नुचा" :'JJ',
"नुत" :'JJ',
"नूक्लीअर" :'JJ',
"नूतन" :'JJ',
"नृजग्ध" :'JJ',
"नृतक" :'JJ',
"नृत्यकार" :'JJ',
"नृपरहित" :'JJ',
"नृशंस" :'JJ',
"नेक" :'JJ',
"नेकचलन" :'JJ',
"नेकदिल" :'JJ',
"नेकनीयत" :'JJ',
"नेगटिव" :'JJ',
"नेगेटिव" :'JJ',
"नेचरल" :'JJ',
"नेचुरल" :'JJ',
"नेतारहित" :'JJ',
"नेत्रहीन" :'JJ',
"नेत्रीय" :'JJ',
"नेपाली" :'JJ',
"नेमत" :'JJ',
"नेमी" :'JJ',
"नेशनल" :'JJ',
"नेस्तनाबूद" :'JJ',
"नेस्ती" :'JJ',
"नेस्तोनाबूद" :'JJ',
"नेहरहित" :'JJ',
"नेही" :'JJ',
"नैकटिक" :'JJ',
"नैतिक" :'JJ',
"नैतिकतापूर्ण" :'JJ',
"नैतिकताहीन" :'JJ',
"नैदाघ" :'JJ',
"नैदाघिक" :'JJ',
"नैदाघीय" :'JJ',
"नैदानिक" :'JJ',
"नैपाली" :'JJ',
"नैशनल" :'JJ',
"नैसर्गिक" :'JJ',
"नॉकआउट" :'JJ',
"नॉट आउट" :'JJ',
"नॉटआउट" :'JJ',
"नॉर्स" :'JJ',
"नोकदार" :'JJ',
"नोंकदार" :'JJ',
"नोकिला" :'JJ',
"नोकीला" :'JJ',
"नोचा हुआ" :'JJ',
"नोचू" :'JJ',
"नोना" :'JJ',
"नोर्स" :'JJ',
"नौ" :'JJ',
"नौ सैन्य" :'JJ',
"नौ-सैन्य" :'JJ',
"नौएक" :'JJ',
"नौकरी पेशा" :'JJ',
"नौकरी-पेशा" :'JJ',
"नौकरीपेशा" :'JJ',
"नौकरीशुदा" :'JJ',
"नौगुना" :'JJ',
"नौचर" :'JJ',
"नौतरणीय" :'JJ',
"नौलक्खा" :'JJ',
"नौलखा" :'JJ',
"नौवाँ" :'JJ',
"नौसिख" :'JJ',
"नौसिखिया" :'JJ',
"नौसिखुआ" :'JJ',
"नौसैन्य" :'JJ',
"न्यग्रोधिक" :'JJ',
"न्याय कर्ता" :'JJ',
"न्याय विषयक" :'JJ',
"न्याय-कर्ता" :'JJ',
"न्यायकर्ता" :'JJ',
"न्यायपूर्ण" :'JJ',
"न्यायसंगत" :'JJ',
"न्यायहीन" :'JJ',
"न्यायालयी" :'JJ',
"न्यायिक" :'JJ',
"न्यायी" :'JJ',
"न्यायोचित" :'JJ',
"न्याय्य" :'JJ',
"न्यारा" :'JJ',
"न्यू" :'JJ',
"न्यूक्लिअर" :'JJ',
"न्यूक्लियर" :'JJ',
"न्यूजीलैंडर" :'JJ',
"न्यूज़ीलैंडर" :'JJ',
"न्यूजीलैंडी" :'JJ',
"न्यूज़ीलैंडी" :'JJ',
"न्यूजीलैण्डर" :'JJ',
"न्यूज़ीलैण्डर" :'JJ',
"न्यूजीलैण्डी" :'JJ',
"न्यूज़ीलैण्डी" :'JJ',
"न्यूड" :'JJ',
"न्यून" :'JJ',
"न्यूनतम" :'JJ',
"न्यूनांशीय" :'JJ',
"न्यूरोलाजिकल" :'JJ',
"न्यूरोलॉजिकल" :'JJ',
"पंकज" :'JJ',
"पकड़ा हुआ" :'JJ',
"पंकभारक" :'JJ',
"पंकरहित" :'JJ',
"पका" :'JJ',
"पकाऊ" :'JJ',
"पकारांत" :'JJ',
"पकारान्त" :'JJ',
"पंकिल" :'JJ',
"पक्का" :'JJ',
"पक्व" :'JJ',
"पक्षधर" :'JJ',
"पक्षपातपूर्ण" :'JJ',
"पक्षपातरहित" :'JJ',
"पक्षपातशून्य" :'JJ',
"पक्षपातहीन" :'JJ',
"पक्षपाती" :'JJ',
"पक्षरहित" :'JJ',
"पक्षी संबंधी" :'JJ',
"पक्षीय" :'JJ',
"पंखदार" :'JJ',
"पंखयुक्त" :'JJ',
"पंखहीन" :'JJ',
"पगला" :'JJ',
"पंगा" :'JJ',
"पंगु" :'JJ',
"पंगुक" :'JJ',
"पंगुल" :'JJ',
"पङ्गु" :'JJ',
"पङ्गुक" :'JJ',
"पङ्गुल" :'JJ',
"पंच-कोण" :'JJ',
"पंचकुनिया" :'JJ',
"पंचकोण" :'JJ',
"पंचकोणीय" :'JJ',
"पंचकोना" :'JJ',
"पचखाना" :'JJ',
"पचख़ाना" :'JJ',
"पचगुना" :'JJ',
"पंचतंत्री" :'JJ',
"पंचतत्वीय" :'JJ',
"पंचतारंकित" :'JJ',
"पंचतारा" :'JJ',
"पचनीय" :'JJ',
"पचपन" :'JJ',
"पचपनवाँ" :'JJ',
"पचपनेक" :'JJ',
"पंचभुज" :'JJ',
"पंचभुजा" :'JJ',
"पंचभूतीय" :'JJ',
"पंचभौतिक" :'JJ',
"पंचम" :'JJ',
"पंचमास्य" :'JJ',
"पंचमाही" :'JJ',
"पंचमुख" :'JJ',
"पंचमुखी" :'JJ',
"पचमेल" :'JJ',
"पँचरंग" :'JJ',
"पचरंगा" :'JJ',
"पँचरंगा" :'JJ',
"पंचरंगा" :'JJ',
"पंचवर्षीय" :'JJ',
"पंचवार्षिक" :'JJ',
"पंचवाही" :'JJ',
"पचहत्तर" :'JJ',
"पचहत्तरवाँ" :'JJ',
"पचहत्तरवां" :'JJ',
"पचहत्तरेक" :'JJ',
"पचा" :'JJ',
"पंचाक्षरी" :'JJ',
"पंचानबे" :'JJ',
"पंचानबेवाँ" :'JJ',
"पंचानवे" :'JJ',
"पंचानवेवाँ" :'JJ',
"पंचायती" :'JJ',
"पंचावन" :'JJ',
"पचास" :'JJ',
"पचास प्रतिशत" :'JJ',
"पचास लाख" :'JJ',
"पचासवाँ" :'JJ',
"पचासवां" :'JJ',
"पचासी" :'JJ',
"पचासीवाँ" :'JJ',
"पचासेक" :'JJ',
"पचित" :'JJ',
"पचीस" :'JJ',
"पचीसवाँ" :'JJ',
"पचीसवां" :'JJ',
"पचीसेक" :'JJ',
"पच्चीस" :'JJ',
"पच्चीसवाँ" :'JJ',
"पच्चीसवां" :'JJ',
"पच्चीसेक" :'JJ',
"पच्छिम" :'JJ',
"पच्छिमी" :'JJ',
"पच्यासी" :'JJ',
"पच्यासीवाँ" :'JJ',
"पंजाबी" :'JJ',
"पंजीकृत" :'JJ',
"पंजीबद्ध" :'JJ',
"पञ्च-कोण" :'JJ',
"पञ्चकोण" :'JJ',
"पञ्चकोणीय" :'JJ',
"पञ्चभुज" :'JJ',
"पञ्चभुजा" :'JJ',
"पञ्चमुख" :'JJ',
"पञ्चमुखी" :'JJ',
"पञ्चाक्षरी" :'JJ',
"पट" :'JJ',
"पटु" :'JJ',
"पट्ठापछाड़" :'JJ',
"पठनीय" :'JJ',
"पठानी" :'JJ',
"पठारी" :'JJ',
"पठित" :'JJ',
"पठ्य" :'JJ',
"पंड" :'JJ',
"पंडित" :'JJ',
"पंडिताऊ" :'JJ',
"पड़ोसी" :'JJ',
"पढ़ंता" :'JJ',
"पंढरपुरी" :'JJ',
"पढ़ा लिखा" :'JJ',
"पढ़ा-लिखा" :'JJ',
"पणित" :'JJ',
"पण्ड" :'JJ',
"पण्डित" :'JJ',
"पण्य" :'JJ',
"पतछीन" :'JJ',
"पतझड़ी" :'JJ',
"पतनकारी" :'JJ',
"पतनशील" :'JJ',
"पतनोन्मुख" :'JJ',
"पतयिष्णु" :'JJ',
"पतला" :'JJ',
"पताकायुक्त" :'JJ',
"पताकित" :'JJ',
"पतित" :'JJ',
"पतितपावन" :'JJ',
"पतिता" :'JJ',
"पतिंबरा" :'JJ',
"पतिम्बरा" :'JJ',
"पतियार" :'JJ',
"पतिवंती" :'JJ',
"पतिव्रता" :'JJ',
"पतिहीन" :'JJ',
"पत्तीदार" :'JJ',
"पत्थ" :'JJ',
"पत्थर का कलेजा" :'JJ',
"पत्थर दिल" :'JJ',
"पत्थर निर्मित" :'JJ',
"पत्थरदिल" :'JJ',
"पत्नीभक्त" :'JJ',
"पत्नीव्रता" :'JJ',
"पत्रविहीन" :'JJ',
"पत्रहीन" :'JJ',
"पथभ्रष्ट" :'JJ',
"पथरीला" :'JJ',
"पथ्य" :'JJ',
"पदक्कड़" :'JJ',
"पदचर" :'JJ',
"पदचारी" :'JJ',
"पदच्युत" :'JJ',
"पददलित" :'JJ',
"पदना" :'JJ',
"पंदरह" :'JJ',
"पंदरहवाँ" :'JJ',
"पदस्थ" :'JJ',
"पदाक्रांत" :'JJ',
"पदाक्रान्त" :'JJ',
"पदार्थ" :'JJ',
"पदासा" :'JJ',
"पदासीन" :'JJ',
"पदेन" :'JJ',
"पदोड़ा" :'JJ',
"पद्म" :'JJ',
"पद्मनयन" :'JJ',
"पद्मलोचन" :'JJ',
"पद्माक्ष" :'JJ',
"पद्यात्मक" :'JJ',
"पंद्रह" :'JJ',
"पंद्रहवाँ" :'JJ',
"पनचानबे" :'JJ',
"पनचानबेवाँ" :'JJ',
"पनचानवे" :'JJ',
"पनचानवेवाँ" :'JJ',
"पनडुब्बा" :'JJ',
"पनालिया" :'JJ',
"पनियल" :'JJ',
"पनिया" :'JJ',
"पनियाँ" :'JJ',
"पनिहा" :'JJ',
"पनीयल" :'JJ',
"पनीरी" :'JJ',
"पनीला" :'JJ',
"पन्दरह" :'JJ',
"पन्दरहवाँ" :'JJ',
"पन्द्रह" :'JJ',
"पन्द्रहवाँ" :'JJ',
"पन्नई" :'JJ',
"पपड़ीदार" :'JJ',
"पपड़ीला" :'JJ',
"पपु" :'JJ',
"पब्लिक" :'JJ',
"पर-स्त्रीगामी" :'JJ',
"परकटा" :'JJ',
"परकाजी" :'JJ',
"परकीय" :'JJ',
"परकोटायुक्त" :'JJ',
"परकोटेदार" :'JJ',
"परगोत्री" :'JJ',
"परगोत्रीय" :'JJ',
"परग्रही" :'JJ',
"परजनीय" :'JJ',
"परजातीय" :'JJ',
"परजीवी" :'JJ',
"परतंत्र" :'JJ',
"परतदार" :'JJ',
"परदानशीन" :'JJ',
"परदायुक्त" :'JJ',
"परदार" :'JJ',
"परदारगामी" :'JJ',
"परदेदार" :'JJ',
"परदेशी" :'JJ',
"परदेशीय" :'JJ',
"परदेसी" :'JJ',
"परंपरा वादी" :'JJ',
"परंपरा-वादी" :'JJ',
"परंपरागत" :'JJ',
"परंपरावादी" :'JJ',
"परपोषी" :'JJ',
"परम" :'JJ',
"परम प्रिय" :'JJ',
"परमाणविक" :'JJ',
"परमाणुक" :'JJ',
"परमाण्विक" :'JJ',
"परमानेंट" :'JJ',
"परमानेन्ट" :'JJ',
"परमार्थी" :'JJ',
"परमावश्यक" :'JJ',
"परमेश्वरी" :'JJ',
"परम्परा वादी" :'JJ',
"परम्परा-वादी" :'JJ',
"परम्परागत" :'JJ',
"परम्परावादी" :'JJ',
"परला" :'JJ',
"परले दरजे का" :'JJ',
"परले दर्जे का" :'JJ',
"परले सिरे का" :'JJ',
"परलोकगत" :'JJ',
"परलोकवासी" :'JJ',
"परलोकीय" :'JJ',
"परलौकिक" :'JJ',
"परवर्ती" :'JJ',
"परवलाकार" :'JJ',
"परवश" :'JJ',
"परशियन" :'JJ',
"परसाधारी" :'JJ',
"परस्त्रीगामी" :'JJ',
"परहितैषी" :'JJ',
"परहेजगार" :'JJ',
"परहेज़गार" :'JJ',
"परहेजी" :'JJ',
"परहेज़ी" :'JJ',
"परा-बैंगनी" :'JJ',
"पराक्रमहीन" :'JJ',
"पराक्रमी" :'JJ',
"परांग्मुख" :'JJ',
"पराग्वेयन" :'JJ',
"पराजित" :'JJ',
"पराजेय" :'JJ',
"पराधीन" :'JJ',
"पराबैगनी" :'JJ',
"पराबैंगनी" :'JJ',
"परायण" :'JJ',
"पराया" :'JJ',
"परावर्तित" :'JJ',
"परावलंबित" :'JJ',
"परावलंबिन" :'JJ',
"परावलंबिनी" :'JJ',
"परावलंबी" :'JJ',
"परावलम्बित" :'JJ',
"परावलम्बिन" :'JJ',
"परावलम्बिनी" :'JJ',
"परावलम्बी" :'JJ',
"पराश्रयी" :'JJ',
"पराश्रित" :'JJ',
"पराश्रिता" :'JJ',
"परास्त" :'JJ',
"परास्नातक" :'JJ',
"परिग्रहीत" :'JJ',
"परिचर्चात्मक" :'JJ',
"परिचालित" :'JJ',
"परिचित" :'JJ',
"परिच्छिन्न" :'JJ',
"परिज्ञात" :'JJ',
"परिणत" :'JJ',
"परिणामरहित" :'JJ',
"परिणामित" :'JJ',
"परिणामी" :'JJ',
"परिणीत" :'JJ',
"परिणेया" :'JJ',
"परितप्त" :'JJ',
"परितुष्ट" :'JJ',
"परित्यक्त" :'JJ',
"परित्याज्य" :'JJ',
"परिधानित" :'JJ',
"परिधानीय" :'JJ',
"परिधेय" :'JJ',
"परिपक्व" :'JJ',
"परिपंथक" :'JJ',
"परिपंथिक" :'JJ',
"परिपंथी" :'JJ',
"परिपन्थक" :'JJ',
"परिपन्थिक" :'JJ',
"परिपन्थी" :'JJ',
"परिपालक" :'JJ',
"परिपालयिता" :'JJ',
"परिपूरित" :'JJ',
"परिपूर्ण" :'JJ',
"परिपूर्णकाय" :'JJ',
"परिपोषक" :'JJ',
"परिप्त" :'JJ',
"परिभाषित" :'JJ',
"परिमलित" :'JJ',
"परिमाणित" :'JJ',
"परिमार्जित" :'JJ',
"परिमित" :'JJ',
"परिमृदित" :'JJ',
"परिमोषी" :'JJ',
"परिरक्षक" :'JJ',
"परिरक्षित" :'JJ',
"परिलक्षित" :'JJ',
"परिवर्तनशील" :'JJ',
"परिवर्तनीय" :'JJ',
"परिवर्तित" :'JJ',
"परिवर्ती" :'JJ',
"परिवर्द्धित" :'JJ',
"परिवर्धित" :'JJ',
"परिवारयुक्त" :'JJ',
"परिवारहीन" :'JJ',
"परिवारीय" :'JJ',
"परिव्यक्त" :'JJ',
"परिव्यापक" :'JJ',
"परिव्राज" :'JJ',
"परिव्राजक" :'JJ',
"परिशिष्ट" :'JJ',
"परिशुद्ध" :'JJ',
"परिशोधित" :'JJ',
"परिश्रमी" :'JJ',
"परिश्रांत" :'JJ',
"परिश्रान्त" :'JJ',
"परिष्कृत" :'JJ',
"परिष्यंदी" :'JJ',
"परिष्यन्दी" :'JJ',
"परिसज्जित" :'JJ',
"परिसीमित" :'JJ',
"परिस्थितिजन्य" :'JJ',
"परिस्फुट" :'JJ',
"परिहरणीय" :'JJ',
"परिहासपूर्ण" :'JJ',
"परीक्षित" :'JJ',
"परे" :'JJ',
"परेशान" :'JJ',
"परोक्ष" :'JJ',
"परोपकारी" :'JJ',
"पर्णपाती" :'JJ',
"पर्णरहित" :'JJ',
"पर्णी" :'JJ',
"पर्णीत" :'JJ',
"पर्दानशीन" :'JJ',
"पर्दायुक्त" :'JJ',
"पर्देदार" :'JJ',
"पर्यटन प्रेमी" :'JJ',
"पर्यटन-प्रेमी" :'JJ',
"पर्यटनप्रिय" :'JJ',
"पर्यटनप्रेमी" :'JJ',
"पर्यवेक्षक" :'JJ',
"पर्याप्त" :'JJ',
"पर्याय" :'JJ',
"पर्यायवाचक" :'JJ',
"पर्यायवाची" :'JJ',
"पर्यावरणीय" :'JJ',
"पर्युषित" :'JJ',
"पर्वगामी" :'JJ',
"पर्वत वासी" :'JJ',
"पर्वत-वासी" :'JJ',
"पर्वताकार" :'JJ',
"पर्वती" :'JJ',
"पर्वतीय" :'JJ',
"पर्शियन" :'JJ',
"पर्हेजगार" :'JJ',
"पलकपीटा" :'JJ',
"पलायनवादी" :'JJ',
"पलायनशील" :'JJ',
"पलायित" :'JJ',
"पलीतायुक्त" :'JJ',
"पलीतेदार" :'JJ',
"पल्लवित" :'JJ',
"पल्लवी" :'JJ',
"पवर्गीय" :'JJ',
"पवित्र" :'JJ',
"पशु चिकित्सीय" :'JJ',
"पशु-चिकित्सीय" :'JJ',
"पशुचिकित्सीय" :'JJ',
"पशुवत" :'JJ',
"पश्च" :'JJ',
"पश्चगत" :'JJ',
"पश्चगंता" :'JJ',
"पश्चगामी" :'JJ',
"पश्चस्थ" :'JJ',
"पश्चात्तापी" :'JJ',
"पश्चिम" :'JJ',
"पश्चिमी" :'JJ',
"पसंद का" :'JJ',
"पसंददीदा" :'JJ',
"पसंदीदा" :'JJ',
"पसन्दीदा" :'JJ',
"पसीने से तर" :'JJ',
"पस्त" :'JJ',
"पस्तहिम्मत" :'JJ',
"पहलदार" :'JJ',
"पहला" :'JJ',
"पहलूदार" :'JJ',
"पहले का" :'JJ',
"पहलौटा" :'JJ',
"पहलौठा" :'JJ',
"पहलौंठा" :'JJ',
"पहाड़ी" :'JJ',
"पहिएदार" :'JJ',
"पहियेदार" :'JJ',
"पहिला" :'JJ',
"पाक" :'JJ',
"पाकिस्तानी" :'JJ',
"पाकीजा" :'JJ',
"पाक़ीज़ा" :'JJ',
"पाक्य" :'JJ',
"पाक्षपातिक" :'JJ',
"पाक्षिक" :'JJ',
"पाखंडी" :'JJ',
"पाखण्डी" :'JJ',
"पाँखदार" :'JJ',
"पागल" :'JJ',
"पागल जैसा" :'JJ',
"पाँच" :'JJ',
"पांच" :'JJ',
"पाँच सितारा" :'JJ',
"पाँच सौ" :'JJ',
"पांच सौ" :'JJ',
"पाचक" :'JJ',
"पाँचगुना" :'JJ',
"पाँचवाँ" :'JJ',
"पांचवाँ" :'JJ',
"पाँचसौ" :'JJ',
"पांचसौ" :'JJ',
"पाँचेक" :'JJ',
"पाच्य" :'JJ',
"पाछिल" :'JJ',
"पाजिटिव" :'JJ',
"पाजी" :'JJ',
"पाटक" :'JJ',
"पाटनदार" :'JJ',
"पाटल" :'JJ',
"पाटविक" :'JJ',
"पाटवी" :'JJ',
"पाठशालीय" :'JJ',
"पाठशालेय" :'JJ',
"पाठ्य" :'JJ',
"पांडित्यपूर्ण" :'JJ',
"पांडु" :'JJ',
"पाणिग्रहणिक" :'JJ',
"पाणिग्रहणीय" :'JJ',
"पाणिनीय" :'JJ',
"पाण्डु" :'JJ',
"पातकी" :'JJ',
"पातंजल" :'JJ',
"पातंजलीय" :'JJ',
"पातर" :'JJ',
"पाताली" :'JJ',
"पातुक" :'JJ',
"पात्र" :'JJ',
"पादचारी" :'JJ',
"पाददलित" :'JJ',
"पादरहित" :'JJ',
"पादहीन" :'JJ',
"पानस" :'JJ',
"पानीदार" :'JJ',
"पानेवाला" :'JJ',
"पापकर्मा" :'JJ',
"पापकर्मी" :'JJ',
"पापचेता" :'JJ',
"पापधी" :'JJ',
"पापनाम" :'JJ',
"पापनाशक" :'JJ',
"पापबुद्धि" :'JJ',
"पापमति" :'JJ',
"पापमय" :'JJ',
"पापयुक्त" :'JJ',
"पापरहित" :'JJ',
"पापलोक्य" :'JJ',
"पापशून्य" :'JJ',
"पापहीन" :'JJ',
"पापाचारी" :'JJ',
"पापात्मा" :'JJ',
"पापाधम" :'JJ',
"पापाशय" :'JJ',
"पापिष्ठ" :'JJ',
"पापी" :'JJ',
"पाबंद" :'JJ',
"पाबन्द" :'JJ',
"पामर" :'JJ',
"पामाल" :'JJ',
"पायदार" :'JJ',
"पायालू" :'JJ',
"पायेदार" :'JJ',
"पारंगत" :'JJ',
"पारगम्य" :'JJ',
"पारदर्शक" :'JJ',
"पारदर्शी" :'JJ',
"पारदारिक" :'JJ',
"पारदेशिक" :'JJ',
"पारदेश्य" :'JJ',
"पारंपरिक" :'JJ',
"पारभासक" :'JJ',
"पारभासी" :'JJ',
"पारम्परिक" :'JJ',
"पारलौकिक" :'JJ',
"पारश्वध" :'JJ',
"पारश्वधिक" :'JJ',
"पारस्परिक" :'JJ',
"पारित" :'JJ',
"पारिवारिक" :'JJ',
"पार्ट टाइम" :'JJ',
"पार्टटाइम" :'JJ',
"पार्थिव" :'JJ',
"पार्थी" :'JJ',
"पार्वतेय" :'JJ',
"पार्श्व का" :'JJ',
"पार्श्वग" :'JJ',
"पालक" :'JJ',
"पालतू" :'JJ',
"पालदार" :'JJ',
"पालनकर्ता" :'JJ',
"पालनहार" :'JJ',
"पाला-पोसा" :'JJ',
"पालित" :'JJ',
"पालू" :'JJ',
"पाव" :'JJ',
"पावन" :'JJ',
"पावित" :'JJ',
"पाशबद्ध" :'JJ',
"पाशव" :'JJ',
"पाशविक" :'JJ',
"पाशित" :'JJ',
"पाशुक" :'JJ',
"पाशुपत" :'JJ',
"पाश्चात्य" :'JJ',
"पाषंड" :'JJ',
"पाषंडी" :'JJ',
"पाषण्ड" :'JJ',
"पाषण्डी" :'JJ',
"पाषाण निर्मित" :'JJ',
"पाषाण हृदय" :'JJ',
"पाषाणमय" :'JJ',
"पाषाणहृदय" :'JJ',
"पाषाणी" :'JJ',
"पाषाणीय" :'JJ',
"पाष्मा" :'JJ',
"पास" :'JJ',
"पास का" :'JJ',
"पास्ड" :'JJ',
"पिंग" :'JJ',
"पिंगल" :'JJ',
"पिघला" :'JJ',
"पिङ्ग" :'JJ',
"पिङ्गल" :'JJ',
"पिचपिचा" :'JJ',
"पिच्छिल" :'JJ',
"पिछड़ता" :'JJ',
"पिछड़ता हुआ" :'JJ',
"पिछड़ा" :'JJ',
"पिछड़ा हुआ" :'JJ',
"पिछलगा" :'JJ',
"पिछलगु" :'JJ',
"पिछलग्गु" :'JJ',
"पिछलग्गू" :'JJ',
"पिछला" :'JJ',
"पिंजारत" :'JJ',
"पिट्टू" :'JJ',
"पिट्ठू" :'JJ',
"पिंडज" :'JJ',
"पिंडरहित" :'JJ',
"पिण्डज" :'JJ',
"पितरहा" :'JJ',
"पितरिया" :'JJ',
"पितरिहा" :'JJ',
"पितविहीन" :'JJ',
"पिताहीन" :'JJ',
"पितिआउत" :'JJ',
"पितृघाती" :'JJ',
"पितृविहीन" :'JJ',
"पितृहा" :'JJ',
"पितृहीन" :'JJ',
"पित्र्य" :'JJ',
"पिद्दा" :'JJ',
"पिद्दा सा" :'JJ',
"पिनपिनहाँ" :'JJ',
"पिपासित" :'JJ',
"पिपासु" :'JJ',
"पिरामिडीय" :'JJ',
"पिलपिल" :'JJ',
"पिलपिला" :'JJ',
"पिसा" :'JJ',
"पिसा हुआ" :'JJ',
"पिस्तई" :'JJ',
"पीड़क" :'JJ',
"पीड़ाकर" :'JJ',
"पीड़ाजनक" :'JJ',
"पीड़ादायक" :'JJ',
"पीड़ाप्रद" :'JJ',
"पीड़ित" :'JJ',
"पीत" :'JJ',
"पीतली" :'JJ',
"पीनसी" :'JJ',
"पीरक" :'JJ',
"पीला" :'JJ',
"पीवर" :'JJ',
"पुकारू" :'JJ',
"पुख्ता" :'JJ',
"पुख़्ता" :'JJ',
"पुंगव" :'JJ',
"पुच्छल" :'JJ',
"पुच्छहीन" :'JJ',
"पुच्छी" :'JJ',
"पुँछल" :'JJ',
"पुंजातीय" :'JJ',
"पुजेरी" :'JJ',
"पुजैया" :'JJ',
"पुंडरीकाक्ष" :'JJ',
"पुणेरी" :'JJ',
"पुणेवाला" :'JJ',
"पुणेवासी" :'JJ',
"पुण्य" :'JJ',
"पुण्यकर्ता" :'JJ',
"पुण्यकर्मा" :'JJ',
"पुण्यकर्मी" :'JJ',
"पुण्यरहित" :'JJ',
"पुण्यवान" :'JJ',
"पुण्यवान्" :'JJ',
"पुण्यहीन" :'JJ',
"पुण्यात्मा" :'JJ',
"पुत्रकाम" :'JJ',
"पुत्रतुल्य" :'JJ',
"पुत्ररहित" :'JJ',
"पुत्रवती" :'JJ',
"पुत्रवत्" :'JJ',
"पुत्रवान" :'JJ',
"पुत्रवान्" :'JJ',
"पुत्रवाला" :'JJ',
"पुत्रवाली" :'JJ',
"पुत्रहीन" :'JJ',
"पुत्राभिलाषी" :'JJ',
"पुत्रार्थी" :'JJ',
"पुद्गल" :'JJ',
"पुनरावासित" :'JJ',
"पुनरुक्त" :'JJ',
"पुनर्जीवित" :'JJ',
"पुनर्नियुक्त" :'JJ',
"पुनर्प्राप्य" :'JJ',
"पुनर्वासित" :'JJ',
"पुनर्संस्थापित" :'JJ',
"पुनर्स्थापित" :'JJ',
"पुनीत" :'JJ',
"पुनेरी" :'JJ',
"पुरखौती" :'JJ',
"पुरजोर" :'JJ',
"पुरज़ोर" :'JJ',
"पुरवासी" :'JJ',
"पुरषत्वहीन" :'JJ',
"पुरस्कृत" :'JJ',
"पुराकालीन" :'JJ',
"पुराणीय" :'JJ',
"पुरातत्त्वीय" :'JJ',
"पुरातन" :'JJ',
"पुरातन-पंथी" :'JJ',
"पुरातन-पन्थी" :'JJ',
"पुरातनपंथी" :'JJ',
"पुरातनपन्थी" :'JJ',
"पुरातात्त्विक" :'JJ',
"पुरातात्विक" :'JJ',
"पुराना" :'JJ',
"पुरुष संबंधी" :'JJ',
"पुरुष-संबंधी" :'JJ',
"पुरुष-सम्बन्धी" :'JJ',
"पुरुषार्थहीन" :'JJ',
"पुरुषार्थी" :'JJ',
"पुरुषीय" :'JJ',
"पुरूरवा" :'JJ',
"पुरोगामी" :'JJ',
"पुरोजन्मा" :'JJ',
"पुर्तगाली" :'JJ',
"पुलकित" :'JJ',
"पुलपुल" :'JJ',
"पुलपुला" :'JJ',
"पुलिस द्वारा अभिप्रेत" :'JJ',
"पुलिस द्वारा अभीष्ट" :'JJ',
"पुलिस द्वारा वाँछित" :'JJ',
"पुलिसिया" :'JJ',
"पुश्तैनी" :'JJ',
"पुष्कल" :'JJ',
"पुष्ट" :'JJ',
"पुष्टई" :'JJ',
"पुष्टिकर" :'JJ',
"पुष्टिकारक" :'JJ',
"पुष्टिद" :'JJ',
"पुष्टिप्रद" :'JJ',
"पुष्पयुक्त" :'JJ',
"पुष्परहित" :'JJ',
"पुष्पवटुक" :'JJ',
"पुष्पवती" :'JJ',
"पुष्पहीन" :'JJ',
"पुष्पित" :'JJ',
"पुष्पी" :'JJ',
"पुस्तकीय" :'JJ',
"पूँछकट्टा" :'JJ',
"पूँछयुक्त" :'JJ',
"पूँछरहित" :'JJ',
"पूंछरहित" :'JJ',
"पूँछल" :'JJ',
"पूँछवाला" :'JJ',
"पूजक" :'JJ',
"पूजनीय" :'JJ',
"पूजनीया" :'JJ',
"पूजमान" :'JJ',
"पूजार्ह" :'JJ',
"पूजित" :'JJ',
"पूजितव्य" :'JJ',
"पूजिता" :'JJ',
"पूजिल" :'JJ',
"पूँजी निवेशक" :'JJ',
"पूँजीगत" :'JJ',
"पूँजीवादी" :'JJ',
"पूंजीवादी" :'JJ',
"पूज्य" :'JJ',
"पूज्या" :'JJ',
"पूत" :'JJ',
"पूता" :'JJ',
"पूति" :'JJ',
"पूतिक" :'JJ',
"पूतिनासिक" :'JJ',
"पूनावाला" :'JJ',
"पूनेवासी" :'JJ',
"पूयित" :'JJ',
"पूरक" :'JJ',
"पूरब" :'JJ',
"पूरबी" :'JJ',
"पूरा" :'JJ',
"पूरा का पूरा" :'JJ',
"पूरा पूरा हुआ" :'JJ',
"पूरा-पूरा" :'JJ',
"पूरित" :'JJ',
"पूर्ण" :'JJ',
"पूर्ण-काम" :'JJ',
"पूर्णकाम" :'JJ',
"पूर्णकाय" :'JJ',
"पूर्णकालिक" :'JJ',
"पूर्णायु" :'JJ',
"पूर्तिकर" :'JJ',
"पूर्तिकर्ता" :'JJ',
"पूर्तिकर्त्ता" :'JJ',
"पूर्व" :'JJ',
"पूर्व कालिक" :'JJ',
"पूर्व कालीन" :'JJ',
"पूर्व निश्चित" :'JJ',
"पूर्व परिचित" :'JJ',
"पूर्व-कालिक" :'JJ',
"पूर्व-कालीन" :'JJ',
"पूर्वकथित" :'JJ',
"पूर्वकाल जात" :'JJ',
"पूर्वकालिक" :'JJ',
"पूर्वकालीन" :'JJ',
"पूर्वगामी" :'JJ',
"पूर्वज" :'JJ',
"पूर्ववतिता" :'JJ',
"पूर्ववर्ती" :'JJ',
"पूर्वविचारित" :'JJ',
"पूर्वी" :'JJ',
"पूर्वीय" :'JJ',
"पूर्वोक्त" :'JJ',
"पृथक" :'JJ',
"पृथक पृथक" :'JJ',
"पृथक-पृथक" :'JJ',
"पृथकचर" :'JJ',
"पृथक्" :'JJ',
"पृथुदर्शी" :'JJ',
"पृथुल" :'JJ',
"पृथूदर" :'JJ',
"पृथ्वीज" :'JJ',
"पृष्ठांकित" :'JJ',
"पेचदार" :'JJ',
"पेंचदार" :'JJ',
"पेचवाला" :'JJ',
"पेंचवाला" :'JJ',
"पेचीदा" :'JJ',
"पेचीला" :'JJ',
"पेंट किया हुआ" :'JJ',
"पेटभर" :'JJ',
"पेटार्थी" :'JJ',
"पेटार्थू" :'JJ',
"पेंटिड" :'JJ',
"पेटू" :'JJ',
"पेंटेड" :'JJ',
"पेन्टिड" :'JJ',
"पेन्टेड" :'JJ',
"पेय" :'JJ',
"पेश" :'JJ',
"पेशवराना" :'JJ',
"पेशावर" :'JJ',
"पेशीय" :'JJ',
"पेशेवर" :'JJ',
"पैतालिस" :'JJ',
"पैंतालिस" :'JJ',
"पैतालिसवाँ" :'JJ',
"पैंतालिसवाँ" :'JJ',
"पैतालिसेक" :'JJ',
"पैंतालिसेक" :'JJ',
"पैतालीस" :'JJ',
"पैंतालीस" :'JJ',
"पैतालीसवाँ" :'JJ',
"पैंतालीसवाँ" :'JJ',
"पैतालीसेक" :'JJ',
"पैंतालीसेक" :'JJ',
"पैतिसवाँ" :'JJ',
"पैतिसवां" :'JJ',
"पैंतिसवाँ" :'JJ',
"पैंतिसवां" :'JJ',
"पैतीस" :'JJ',
"पैंतीस" :'JJ',
"पैतीसवाँ" :'JJ',
"पैतीसवां" :'JJ',
"पैंतीसवाँ" :'JJ',
"पैंतीसवां" :'JJ',
"पैतीसेक" :'JJ',
"पैंतीसेक" :'JJ',
"पैतृक" :'JJ',
"पैत्त" :'JJ',
"पैत्तिक" :'JJ',
"पैत्रिक" :'JJ',
"पैदल" :'JJ',
"पैदा" :'JJ',
"पैदा हुआ" :'JJ',
"पैदाइशी" :'JJ',
"पैदाइशी अमीर" :'JJ',
"पैना" :'JJ',
"पैराक" :'JJ',
"पैराग्वेयन" :'JJ',
"पैशाचिक" :'JJ',
"पैशुनिक" :'JJ',
"पैसठ" :'JJ',
"पैंसठ" :'JJ',
"पैसठवाँ" :'JJ',
"पैसठवां" :'JJ',
"पैंसठवाँ" :'JJ',
"पैंसठवां" :'JJ',
"पैसठेक" :'JJ',
"पैंसठेक" :'JJ',
"पैसेदार" :'JJ',
"पैहारी" :'JJ',
"पॉजिटिव" :'JJ',
"पॉप" :'JJ',
"पॉपुलर" :'JJ',
"पॉलिटिकल" :'JJ',
"पॉलीटेकनिक" :'JJ',
"पॉलीटेकनिकल" :'JJ',
"पोंगा" :'JJ',
"पोच" :'JJ',
"पोपला" :'JJ',
"पोला" :'JJ',
"पोलिश" :'JJ',
"पोलैंडी" :'JJ',
"पोलैण्डी" :'JJ',
"पोशीदा" :'JJ',
"पोषक" :'JJ',
"पोषित" :'JJ',
"पोस्ट-ग्रेजुएट" :'JJ',
"पोस्ती" :'JJ',
"पौआ" :'JJ',
"पौन" :'JJ',
"पौना" :'JJ',
"पौर" :'JJ',
"पौरव" :'JJ',
"पौराण" :'JJ',
"पौराणिक" :'JJ',
"पौरुषहीन" :'JJ',
"पौरुषेय" :'JJ',
"पौवा" :'JJ',
"पौष्टिक" :'JJ',
"प्याजी" :'JJ',
"प्याज़ी" :'JJ',
"प्यारा" :'JJ',
"प्यासा" :'JJ',
"प्रकट" :'JJ',
"प्रकटित" :'JJ',
"प्रकट्य" :'JJ',
"प्रकांड" :'JJ',
"प्रकाण्ड" :'JJ',
"प्रकाशक" :'JJ',
"प्रकाशनीय" :'JJ',
"प्रकाशपूर्ण" :'JJ',
"प्रकाशमान" :'JJ',
"प्रकाशमान्" :'JJ',
"प्रकाशयुक्त" :'JJ',
"प्रकाशरहित" :'JJ',
"प्रकाशवान" :'JJ',
"प्रकाशशून्य\ufeff" :'JJ',
"प्रकाशित" :'JJ',
"प्रकाशी" :'JJ',
"प्रकाशीय" :'JJ',
"प्रकाश्य" :'JJ',
"प्रकीर्ण" :'JJ',
"प्रकृत" :'JJ',
"प्रकृति विरुद्ध" :'JJ',
"प्रकृष्ट" :'JJ',
"प्रक्षिप्त" :'JJ',
"प्रक्षेपित" :'JJ',
"प्रक्षेप्य" :'JJ',
"प्रखर" :'JJ',
"प्रखरबुद्धि" :'JJ',
"प्रख्यात" :'JJ',
"प्रगट" :'JJ',
"प्रगत" :'JJ',
"प्रगति कर्ता" :'JJ',
"प्रगतिकर्ता" :'JJ',
"प्रगतिशील" :'JJ',
"प्रगल्भ" :'JJ',
"प्रगाढ़" :'JJ',
"प्रचंड" :'JJ',
"प्रचण्ड" :'JJ',
"प्रचलित" :'JJ',
"प्रचारक" :'JJ',
"प्रचारित" :'JJ',
"प्रचारी" :'JJ',
"प्रचालित" :'JJ',
"प्रचुर" :'JJ',
"प्रच्छन्न" :'JJ',
"प्रजनक" :'JJ',
"प्रजनित" :'JJ',
"प्रजातंत्रात्मक" :'JJ',
"प्रजातंत्री" :'JJ',
"प्रजातंत्रीय" :'JJ',
"प्रजातन्त्रात्मक" :'JJ',
"प्रजातन्त्री" :'JJ',
"प्रजातन्त्रीय" :'JJ',
"प्रजातांत्रिक" :'JJ',
"प्रजातान्त्रिक" :'JJ',
"प्रजातीय" :'JJ',
"प्रज्ज्वलित" :'JJ',
"प्रज्ञात" :'JJ',
"प्रज्ञाहीन" :'JJ',
"प्रज्वलक" :'JJ',
"प्रज्वलित" :'JJ',
"प्रणत" :'JJ',
"प्रणम्य" :'JJ',
"प्रणीत" :'JJ',
"प्रतप्त" :'JJ',
"प्रताड़ित" :'JJ',
"प्रतापशाली" :'JJ',
"प्रतापी" :'JJ',
"प्रतारक" :'JJ',
"प्रति पक्ष" :'JJ',
"प्रतिकारी" :'JJ',
"प्रतिकुंचित" :'JJ',
"प्रतिकुञ्चित" :'JJ',
"प्रतिकूल" :'JJ',
"प्रतिक्रुष्टि" :'JJ',
"प्रतिख्यात" :'JJ',
"प्रतिगत" :'JJ',
"प्रतिगामी" :'JJ',
"प्रतिजीवाणु" :'JJ',
"प्रतिजैविक" :'JJ',
"प्रतिज्ञात" :'JJ',
"प्रतिदीप्तिशील" :'JJ',
"प्रतिदेय" :'JJ',
"प्रतिद्वंद्वी" :'JJ',
"प्रतिद्वन्द्वी" :'JJ',
"प्रतिध्वनित" :'JJ',
"प्रतिनिधि-संबंधी" :'JJ',
"प्रतिनिधिक" :'JJ',
"प्रतिपक्ष" :'JJ',
"प्रतिपक्षी" :'JJ',
"प्रतिपक्षीय" :'JJ',
"प्रतिपन्न्" :'JJ',
"प्रतिपादित" :'JJ',
"प्रतिपाद्य" :'JJ',
"प्रतिबद्ध" :'JJ',
"प्रतिबंधक" :'JJ',
"प्रतिबंधित" :'JJ',
"प्रतिबन्धक" :'JJ',
"प्रतिबन्धित" :'JJ',
"प्रतिबिंबित" :'JJ',
"प्रतिबिम्बित" :'JJ',
"प्रतिभारहित" :'JJ',
"प्रतिभावान" :'JJ',
"प्रतिभाविहीन" :'JJ',
"प्रतिभाशाली" :'JJ',
"प्रतिभासंपन्न" :'JJ',
"प्रतिभासम्पन्न" :'JJ',
"प्रतिभाहीन" :'JJ',
"प्रतिभिन्न" :'JJ',
"प्रतियोगितात्मक" :'JJ',
"प्रतियोगी" :'JJ',
"प्रतिरूपी" :'JJ',
"प्रतिरोधक" :'JJ',
"प्रतिरोधी" :'JJ',
"प्रतिरोपित" :'JJ',
"प्रतिलिपित" :'JJ',
"प्रतिवेदित" :'JJ',
"प्रतिष्ठापित" :'JJ',
"प्रतिष्ठारहित" :'JJ',
"प्रतिष्ठित" :'JJ',
"प्रतिस्थापित" :'JJ',
"प्रतिस्पर्धात्मक" :'JJ',
"प्रतिस्पर्धी" :'JJ',
"प्रतीकात्मक" :'JJ',
"प्रतीक्षक" :'JJ',
"प्रतीक्षित" :'JJ',
"प्रतीत" :'JJ',
"प्रतीप" :'JJ',
"प्रत्यक्ष" :'JJ',
"प्रत्यक्षदर्शी" :'JJ',
"प्रत्यारोपित" :'JJ',
"प्रत्याशातीत" :'JJ',
"प्रत्याशानुकूल" :'JJ',
"प्रत्याशित" :'JJ',
"प्रत्याशी" :'JJ',
"प्रत्युत्पन्न-मति" :'JJ',
"प्रत्येक" :'JJ',
"प्रथम" :'JJ',
"प्रदत्त" :'JJ',
"प्रदर्शनकर्ता" :'JJ',
"प्रदर्शनकारी" :'JJ',
"प्रदर्शनीय" :'JJ',
"प्रदर्शित" :'JJ',
"प्रदीप्त" :'JJ',
"प्रदूषणरहित" :'JJ',
"प्रदूषित" :'JJ',
"प्रदेय" :'JJ',
"प्रधान" :'JJ',
"प्रध्वंसक" :'JJ',
"प्रपंचक" :'JJ',
"प्रपंची" :'JJ',
"प्रपञ्चक" :'JJ',
"प्रपथा" :'JJ',
"प्रफुलित" :'JJ',
"प्रफुल्ल" :'JJ',
"प्रफुल्लित" :'JJ',
"प्रबंधित" :'JJ',
"प्रबर्ह" :'JJ',
"प्रबल" :'JJ',
"प्रबुद्ध" :'JJ',
"प्रभारहित" :'JJ',
"प्रभावक" :'JJ',
"प्रभावकारी" :'JJ',
"प्रभावशाली" :'JJ',
"प्रभावशील" :'JJ',
"प्रभावशून्य" :'JJ',
"प्रभावहीन" :'JJ',
"प्रभावित" :'JJ',
"प्रभावी" :'JJ',
"प्रभाहीन" :'JJ',
"प्रभुप्रदत्त" :'JJ',
"प्रभुहीन" :'JJ',
"प्रभेदक" :'JJ',
"प्रमत्त" :'JJ',
"प्रमाणभूत" :'JJ',
"प्रमाणरहित" :'JJ',
"प्रमाणित" :'JJ',
"प्रमाणीकृत" :'JJ',
"प्रमाणीभूत" :'JJ',
"प्रमीत" :'JJ',
"प्रमुख" :'JJ',
"प्रमुदित" :'JJ',
"प्रमेय" :'JJ',
"प्रमेही" :'JJ',
"प्रयत्नवान" :'JJ',
"प्रयत्नशील" :'JJ',
"प्रयत्नी" :'JJ',
"प्रयासरत" :'JJ',
"प्रयासशील" :'JJ',
"प्रयासी" :'JJ',
"प्रयुक्त" :'JJ',
"प्रयोगात्मक" :'JJ',
"प्रयोजनरहित" :'JJ',
"प्रयोजनहीन" :'JJ',
"प्रयोजनार्थी" :'JJ',
"प्रयोजनी" :'JJ',
"प्रयोजनीय" :'JJ',
"प्रलंबित" :'JJ',
"प्रलम्बित" :'JJ',
"प्रलयकर" :'JJ',
"प्रलयकारी" :'JJ',
"प्रलापी" :'JJ',
"प्रवण" :'JJ',
"प्रवर्तित" :'JJ',
"प्रवर्त्तित" :'JJ',
"प्रवासी" :'JJ',
"प्रवाह पतित" :'JJ',
"प्रवाह-पतित" :'JJ',
"प्रवाहपतित" :'JJ',
"प्रवाहमय" :'JJ',
"प्रवाहशील" :'JJ',
"प्रवाहहीन" :'JJ',
"प्रवाहित" :'JJ',
"प्रवाही" :'JJ',
"प्रविष्ट" :'JJ',
"प्रवीण" :'JJ',
"प्रवृत्त" :'JJ',
"प्रवेशनीय" :'JJ',
"प्रवेशित" :'JJ',
"प्रवेश्य" :'JJ',
"प्रशंसक" :'JJ',
"प्रशंसनीय" :'JJ',
"प्रशंसाजनक" :'JJ',
"प्रशंसित" :'JJ',
"प्रशंसी" :'JJ',
"प्रशस्त" :'JJ',
"प्रशस्य" :'JJ',
"प्रशंस्य" :'JJ',
"प्रशाखित" :'JJ',
"प्रशांत" :'JJ',
"प्रशान्त" :'JJ',
"प्रशामक" :'JJ',
"प्रशासकीय" :'JJ',
"प्रशासनिक" :'JJ',
"प्रशासित" :'JJ',
"प्रशासी" :'JJ',
"प्रशिक्षित" :'JJ',
"प्रशिक्षु" :'JJ',
"प्रशीतक" :'JJ',
"प्रशीतित" :'JJ',
"प्रश्न कर्ता" :'JJ',
"प्रश्न कर्त्ता" :'JJ',
"प्रश्न-कर्ता" :'JJ',
"प्रश्न-कर्त्ता" :'JJ',
"प्रश्नकर्ता" :'JJ',
"प्रश्नकर्त्ता" :'JJ',
"प्रश्नबोधक" :'JJ',
"प्रश्नवाचक" :'JJ',
"प्रश्नवाची" :'JJ',
"प्रश्नसूचक" :'JJ',
"प्रश्नात्मक" :'JJ',
"प्रश्नार्थक" :'JJ',
"प्रश्रयी" :'JJ',
"प्रसंग-संबंधी" :'JJ',
"प्रसंगहीन" :'JJ',
"प्रसङ्गहीन" :'JJ',
"प्रसन्न" :'JJ',
"प्रसन्नचित्त" :'JJ',
"प्रसन्नतादायक" :'JJ',
"प्रसन्नमना" :'JJ',
"प्रसन्नमुख" :'JJ',
"प्रसन्नवदन" :'JJ',
"प्रसारक" :'JJ',
"प्रसारित" :'JJ',
"प्रसिद्ध" :'JJ',
"प्रसुत" :'JJ',
"प्रसूत" :'JJ',
"प्रसून" :'JJ',
"प्रस्तावित" :'JJ',
"प्रस्तुत" :'JJ',
"प्रस्तुति योग्य" :'JJ',
"प्रस्थापित" :'JJ',
"प्रस्फुट" :'JJ',
"प्रस्फुटित" :'JJ',
"प्रस्मृत" :'JJ',
"प्रस्वेदित" :'JJ',
"प्रहर्षित" :'JJ',
"प्रहारक" :'JJ',
"प्रहारी" :'JJ',
"प्रहित" :'JJ',
"प्रह्लादित" :'JJ',
"प्राइवेट" :'JJ',
"प्राकृत" :'JJ',
"प्राकृतिक" :'JJ',
"प्राकृतिक तरीके से सड़नशील" :'JJ',
"प्राकृतिक रूप से सड़नशील" :'JJ',
"प्राक्कालीन" :'JJ',
"प्रागैतिहासिक" :'JJ',
"प्राचीन" :'JJ',
"प्राचीनतम" :'JJ',
"प्राच्य" :'JJ',
"प्रांजल" :'JJ',
"प्राज्ञ" :'JJ',
"प्राज्ञी" :'JJ',
"प्राणकर" :'JJ',
"प्राणघातक" :'JJ',
"प्राणलेवा" :'JJ',
"प्राणवंत" :'JJ',
"प्राणवान" :'JJ',
"प्राणांतक" :'JJ',
"प्राणान्तक" :'JJ',
"प्राणिक" :'JJ',
"प्राणिज" :'JJ',
"प्रांतीय" :'JJ',
"प्राथमिक" :'JJ',
"प्रादेशिक" :'JJ',
"प्राधिकृत" :'JJ',
"प्रान्तीय" :'JJ',
"प्रापक" :'JJ',
"प्रापयिता" :'JJ',
"प्रापी" :'JJ',
"प्राप्त" :'JJ',
"प्राप्त कर्ता" :'JJ',
"प्राप्तकर्ता" :'JJ',
"प्राप्ता" :'JJ',
"प्राप्य" :'JJ',
"प्रामाणिक" :'JJ',
"प्रायः आनेवाला" :'JJ',
"प्रायद्वीपीय" :'JJ',
"प्रायमरी" :'JJ',
"प्रायोगिक" :'JJ',
"प्रायोजित" :'JJ',
"प्रारब्धवादी" :'JJ',
"प्रारब्धाधीन" :'JJ',
"प्रारंभहीन" :'JJ',
"प्रारंभिक" :'JJ',
"प्रारम्भिक" :'JJ',
"प्रारूपित" :'JJ',
"प्रार्थना कर्ता" :'JJ',
"प्रार्थनीय" :'JJ',
"प्रार्थित" :'JJ',
"प्रार्थी" :'JJ',
"प्रालेय" :'JJ',
"प्राविधिक" :'JJ',
"प्राविधिहीन" :'JJ',
"प्रांशु" :'JJ',
"प्रासंगिक" :'JJ',
"प्रासङ्गिक" :'JJ',
"प्रास्थानिक" :'JJ',
"प्रिमिटिव" :'JJ',
"प्रिय" :'JJ',
"प्रियतम" :'JJ',
"प्रियदर्शन" :'JJ',
"प्रियभाषी" :'JJ',
"प्रियंवद" :'JJ',
"प्रियवादी" :'JJ',
"प्रीतिकर" :'JJ',
"प्रीतिपात्र" :'JJ',
"प्रेक्षक" :'JJ',
"प्रेक्षणीय" :'JJ',
"प्रेग्नेंट" :'JJ',
"प्रेग्नेन्ट" :'JJ',
"प्रेतहा" :'JJ',
"प्रेमपात्र" :'JJ',
"प्रेमपूर्ण" :'JJ',
"प्रेममय" :'JJ',
"प्रेमयुक्त" :'JJ',
"प्रेमासक्त" :'JJ',
"प्रेमी" :'JJ',
"प्रेरक" :'JJ',
"प्रेरणाजन्य" :'JJ',
"प्रेरणात्मक" :'JJ',
"प्रेरणादायक" :'JJ',
"प्रेरणास्पद" :'JJ',
"प्रेरित" :'JJ',
"प्रेषित" :'JJ',
"प्रोटेस्टेंट" :'JJ',
"प्रोत्साहक" :'JJ',
"प्रोत्साहित" :'JJ',
"प्रोथ" :'JJ',
"प्रोन्नत" :'JJ',
"प्रोषित" :'JJ',
"प्रौढ़" :'JJ',
"प्रौद्योगिक" :'JJ',
"प्लावित" :'JJ',
"फक" :'JJ',
"फकारांत" :'JJ',
"फकारान्त" :'JJ',
"फकीराना" :'JJ',
"फ़क़ीराना" :'JJ',
"फकीरी" :'JJ',
"फ़क़ीरी" :'JJ',
"फक्कड़" :'JJ',
"फक्कड़ाना" :'JJ',
"फगुनई" :'JJ',
"फजूल" :'JJ',
"फ़जूल" :'JJ',
"फ़ज़ूल" :'JJ',
"फजूलखर्च" :'JJ',
"फ़ज़ूलख़र्च" :'JJ',
"फटहा" :'JJ',
"फटा" :'JJ',
"फटा हुआ" :'JJ',
"फटा-पुराना" :'JJ',
"फटीचर" :'JJ',
"फटेहाल" :'JJ',
"फतूरी" :'JJ',
"फ़तूरी" :'JJ',
"फना" :'JJ',
"फ़ना" :'JJ',
"फनैन्शल" :'JJ',
"फनैन्सल" :'JJ',
"फनैंशल" :'JJ',
"फनैंसल" :'JJ',
"फप्फस" :'JJ',
"फफसा" :'JJ',
"फर फर" :'JJ',
"फर-फर" :'JJ',
"फरजी" :'JJ',
"फ़रज़ी" :'JJ',
"फरफंदी" :'JJ',
"फरफर" :'JJ',
"फरमाइशी" :'JJ',
"फ़रमाइशी" :'JJ',
"फरमाँबरदार" :'JJ',
"फरार" :'JJ',
"फ़रार" :'JJ',
"फरारी" :'JJ',
"फ़रारी" :'JJ',
"फरियादी" :'JJ',
"फ़रियादी" :'JJ',
"फरेबी" :'JJ',
"फ़रेबी" :'JJ',
"फर्जी" :'JJ',
"फ़र्ज़ी" :'JJ',
"फर्माइशी" :'JJ',
"फ़र्माइशी" :'JJ',
"फर्माबरदार" :'JJ',
"फल वाला" :'JJ',
"फलता-फूलता" :'JJ',
"फलता-फूलता हुआ" :'JJ',
"फलद" :'JJ',
"फलदायक" :'JJ',
"फलदायी" :'JJ',
"फलदार" :'JJ',
"फलप्रद" :'JJ',
"फलरहित" :'JJ',
"फलवान" :'JJ',
"फलवाला" :'JJ',
"फलविहीन" :'JJ',
"फलस्तीनी" :'JJ',
"फ़लस्तीनी" :'JJ',
"फलहीन" :'JJ',
"फला" :'JJ',
"फलाँ" :'JJ',
"फलां" :'JJ',
"फ़लाँ" :'JJ',
"फलाना" :'JJ',
"फ़लाना" :'JJ',
"फलाहारी" :'JJ',
"फलित" :'JJ',
"फलीदार" :'JJ',
"फलीभूत" :'JJ',
"फलीस्तीनी" :'JJ',
"फ़लीस्तीनी" :'JJ',
"फसली" :'JJ',
"फ़सली" :'JJ',
"फँसा" :'JJ',
"फंसा" :'JJ',
"फँसाने वाला" :'JJ',
"फ़हश" :'JJ',
"फाइनल" :'JJ',
"फाइनैन्शल" :'JJ',
"फाइनैन्सल" :'JJ',
"फाइनैंशल" :'JJ',
"फाइनैंसल" :'JJ',
"फाइव स्टार" :'JJ',
"फाखतई" :'JJ',
"फ़ाख़तई" :'JJ',
"फाख्तई" :'JJ',
"फ़ाख़्तई" :'JJ',
"फागुनी" :'JJ',
"फानी" :'JJ',
"फ़ानी" :'JJ',
"फायदामंद" :'JJ',
"फ़ायदामंद" :'JJ',
"फायदामन्द" :'JJ',
"फायदेमंद" :'JJ',
"फ़ायदेमंद" :'JJ',
"फायदेमन्द" :'JJ',
"फार्मास्युटिकल" :'JJ',
"फालतू" :'JJ',
"फ़ालतू" :'JJ',
"फालसई" :'JJ',
"फाल्गुनी" :'JJ',
"फास्ट" :'JJ',
"फास्फोरिक" :'JJ',
"फिकरमंद" :'JJ',
"फिकरमन्द" :'JJ',
"फिक्रमंद" :'JJ',
"फ़िक्रमंद" :'JJ',
"फिक्रमन्द" :'JJ',
"फ़िक्रमन्द" :'JJ',
"फिजूल" :'JJ',
"फ़िजूल" :'JJ',
"फ़िज़ूल" :'JJ',
"फिजूलखर्च" :'JJ',
"फ़िज़ूलख़र्च" :'JJ',
"फिट" :'JJ',
"फिदा" :'JJ',
"फ़िदा" :'JJ',
"फिनलैंडी" :'JJ',
"फ़िनलैंडी" :'JJ',
"फिनलैण्डी" :'JJ',
"फ़िनलैण्डी" :'JJ',
"फिनिश" :'JJ',
"फिनैन्शल" :'JJ',
"फिनैन्सल" :'JJ',
"फिनैंशल" :'JJ',
"फिनैंसल" :'JJ',
"फिराया हुआ" :'JJ',
"फिलिपीनी" :'JJ',
"फिलिपीनो" :'JJ',
"फिलिस्तीनी" :'JJ',
"फ़िलिस्तीनी" :'JJ',
"फिल्मी" :'JJ',
"फ़िल्मी" :'JJ',
"फिसड्डी" :'JJ',
"फिसलन भरा" :'JJ',
"फिसलनयुक्त" :'JJ',
"फिसलहा" :'JJ',
"फिसला" :'JJ',
"फिसलाऊ" :'JJ',
"फीका" :'JJ',
"फ़ीका" :'JJ',
"फीरोजी" :'JJ',
"फ़ीरोज़ी" :'JJ',
"फुजूलखर्च" :'JJ',
"फुटकर" :'JJ',
"फुटकल" :'JJ',
"फुटपथिया" :'JJ',
"फ़ुटपथिया" :'JJ',
"फुटपाथी" :'JJ',
"फ़ुटपाथी" :'JJ',
"फुतूरी" :'JJ',
"फ़ुतूरी" :'JJ',
"फुफिया" :'JJ',
"फुफीआउत" :'JJ',
"फुफेरा" :'JJ',
"फुरतीला" :'JJ',
"फुर्तीला" :'JJ',
"फुल टाइम" :'JJ',
"फुलका" :'JJ',
"फुलही" :'JJ',
"फूटा" :'JJ',
"फूटा हुआ" :'JJ',
"फूफीजाद" :'JJ',
"फूल जैसा" :'JJ',
"फूल वाला" :'JJ',
"फूलदार" :'JJ',
"फूलपान" :'JJ',
"फूलवाला" :'JJ',
"फूलसँपेल" :'JJ',
"फूला" :'JJ',
"फूहड़" :'JJ',
"फेंकने योग्य" :'JJ',
"फेंकने लायक" :'JJ',
"फेंका" :'JJ',
"फेंका हुआ" :'JJ',
"फेनदार" :'JJ',
"फेनयुक्त" :'JJ',
"फेनल" :'JJ',
"फेनिल" :'JJ',
"फेरा" :'JJ',
"फेल" :'JJ',
"फ़ेल" :'JJ',
"फैला" :'JJ',
"फैलाया हुआ" :'JJ',
"फॉस्फोरिक" :'JJ',
"फोर स्टार" :'JJ',
"फोर्मोसन" :'JJ',
"फौजदारी" :'JJ',
"फ़ौजदारी" :'JJ',
"फौजी" :'JJ',
"फ़ौजी" :'JJ',
"फौत" :'JJ',
"फौलादी" :'JJ',
"फ़ौलादी" :'JJ',
"फ्रांसीसी" :'JJ',
"फ़्रांसीसी" :'JJ',
"फ्रेंच" :'JJ',
"फ़्रेंच" :'JJ',
"फ्रेंच गीअनन" :'JJ',
"फ्रेंच गीअनीज़" :'JJ',
"फ्रेंच गीअनीस" :'JJ',
"फ्रेंच गीआनाई" :'JJ',
"फ्रेंच गुअनन" :'JJ',
"फ्रेंच गुअनीज़" :'JJ',
"फ्रेंच गुअनीस" :'JJ',
"फ्रेंच गुआनाई" :'JJ',
"फ्रेन्च" :'JJ',
"फ़्रेन्च" :'JJ',
"फ्लाप" :'JJ',
"फ्लोविंग" :'JJ',
"बंक" :'JJ',
"बंकट" :'JJ',
"बकतरबंद" :'JJ',
"बकतरबन्द" :'JJ',
"बकबका" :'JJ',
"बकबकिया" :'JJ',
"बकमौन" :'JJ',
"बकलोल" :'JJ',
"बकवादी" :'JJ',
"बकवास" :'JJ',
"बकवासपूर्ण" :'JJ',
"बकवासी" :'JJ',
"बकव्रती" :'JJ',
"बकसीला" :'JJ',
"बकाया" :'JJ',
"बक़ाया" :'JJ',
"बकायादार" :'JJ',
"बक़ायादार" :'JJ',
"बकारांत" :'JJ',
"बकारादि" :'JJ',
"बकारान्त" :'JJ',
"बंकिम" :'JJ',
"बकेन" :'JJ',
"बकेना" :'JJ',
"बक्की" :'JJ',
"बख्तरबंद" :'JJ',
"बख़्तरबंद" :'JJ',
"बख्तरबन्द" :'JJ',
"बख़्तरबन्द" :'JJ',
"बगछुट" :'JJ',
"बगटुट" :'JJ',
"बगल का" :'JJ',
"बँगला" :'JJ',
"बंगला" :'JJ',
"बंगला देशी" :'JJ',
"बंगलादेशी" :'JJ',
"बंगलादेशीय" :'JJ',
"बगली" :'JJ',
"बग़ली" :'JJ',
"बंगलूरी" :'JJ',
"बंगलोरी" :'JJ',
"बंगलौरी" :'JJ',
"बंगा" :'JJ',
"बंगाली" :'JJ',
"बगैर" :'JJ',
"बग़ैर" :'JJ',
"बग़ैरदस्तख़ती" :'JJ',
"बंग्लादेशी" :'JJ',
"बंग्लादेशीय" :'JJ',
"बचकाना" :'JJ',
"बचा" :'JJ',
"बचा खुचा" :'JJ',
"बचा हुआ" :'JJ',
"बचा-खुचा" :'JJ',
"बचे" :'JJ',
"बचे हुए" :'JJ',
"बच्चाकश" :'JJ',
"बच्चेवाली" :'JJ',
"बछिया का ताऊ" :'JJ',
"बछिया का बाबा" :'JJ',
"बजटीय" :'JJ',
"बंजारा" :'JJ',
"बजारी" :'JJ',
"बजारू" :'JJ',
"बज़ारू" :'JJ',
"बज्र" :'JJ',
"बटवाँ" :'JJ',
"बटा" :'JJ',
"बँटा" :'JJ',
"बटा हुआ" :'JJ',
"बँटा हुआ" :'JJ',
"बंटाढार" :'JJ',
"बँटाधार" :'JJ',
"बंटाधार" :'JJ',
"बट्टाढाल" :'JJ',
"बट्टेबाज" :'JJ',
"बट्टेबाज़" :'JJ',
"बड़कन्ना" :'JJ',
"बड़दंता" :'JJ',
"बड़दन्ता" :'JJ',
"बड़नक्का" :'JJ',
"बड़पेटा" :'JJ',
"बड़बोल" :'JJ',
"बड़बोला" :'JJ',
"बड़ा" :'JJ',
"बड़ा बड़ा" :'JJ',
"बड़ा बुजुर्ग" :'JJ',
"बड़ा बुज़ुर्ग" :'JJ',
"बड़ा-बड़ा" :'JJ',
"बड़ा-बुजुर्ग" :'JJ',
"बड़ा-बुज़ुर्ग" :'JJ',
"बढ़कर" :'JJ',
"बढ़ता" :'JJ',
"बढ़ता हुआ" :'JJ',
"बढ़िया" :'JJ',
"बतरसिया" :'JJ',
"बताया" :'JJ',
"बताया गया" :'JJ',
"बताया हुआ" :'JJ',
"बत्तीस" :'JJ',
"बत्तीसवाँ" :'JJ',
"बद" :'JJ',
"बंद" :'JJ',
"बद से बदतर" :'JJ',
"बदकार" :'JJ',
"बदकिस्मत" :'JJ',
"बदक़िस्मत" :'JJ',
"बदखत" :'JJ',
"बदगो" :'JJ',
"बदचलन" :'JJ',
"बदजबान" :'JJ',
"बदज़बान" :'JJ',
"बदतमीज" :'JJ',
"बदतमीज़" :'JJ',
"बदतर" :'JJ',
"बदनसीब" :'JJ',
"बदनाम" :'JJ',
"बदनीयत" :'JJ',
"बदनुमा" :'JJ',
"बदबूदार" :'JJ',
"बदमाश" :'JJ',
"बदमिजाज" :'JJ',
"बदमिज़ाज" :'JJ',
"बदरंग" :'JJ',
"बदरङ्ग" :'JJ',
"बंदरी" :'JJ',
"बदलगाम" :'JJ',
"बदलता" :'JJ',
"बदला" :'JJ',
"बदशक्ल" :'JJ',
"बदसलूक" :'JJ',
"बदसूरत" :'JJ',
"बदहवास" :'JJ',
"बदहाल" :'JJ',
"बदामी" :'JJ',
"बंदीकृत" :'JJ',
"बद्तर" :'JJ',
"बद्ध" :'JJ',
"बंधनमुक्त" :'JJ',
"बँधा" :'JJ',
"बँधा हुआ" :'JJ',
"बधिया" :'JJ',
"बधिर" :'JJ',
"बँधुआ" :'JJ',
"बंधुआ" :'JJ',
"बंधुत्वपूर्ण" :'JJ',
"बंधुर" :'JJ',
"बंधुरहित" :'JJ',
"बँधुवा" :'JJ',
"बंधुहीन" :'JJ',
"बध्य" :'JJ',
"बंध्या" :'JJ',
"बनजारा" :'JJ',
"बना ठना" :'JJ',
"बना बनाया" :'JJ',
"बना-ठना" :'JJ',
"बना-सँवरा" :'JJ',
"बनाती" :'JJ',
"बनारसी" :'JJ',
"बनावटी" :'JJ',
"बनैला" :'JJ',
"बनौवा" :'JJ',
"बन्द" :'JJ',
"बन्धनमुक्त" :'JJ',
"बन्धुर" :'JJ',
"बन्धुरहित" :'JJ',
"बन्धुहीन" :'JJ',
"बन्ध्या" :'JJ',
"बपुरा" :'JJ',
"बंबइया" :'JJ',
"बंबैया" :'JJ',
"बमबाज" :'JJ',
"बमबाज़" :'JJ',
"बमवर्षक" :'JJ',
"बम्बइया" :'JJ',
"बम्बैया" :'JJ',
"बयँहत्था" :'JJ',
"बयँहत्थी" :'JJ',
"बयानबे" :'JJ',
"बयानबेवाँ" :'JJ',
"बयानवे" :'JJ',
"बयानवेवाँ" :'JJ',
"बयाबान" :'JJ',
"बयालिस" :'JJ',
"बयालिसवाँ" :'JJ',
"बयालीस" :'JJ',
"बयालीसवाँ" :'JJ',
"बयासी" :'JJ',
"बयासीवाँ" :'JJ',
"बरकरार" :'JJ',
"बरक़रार" :'JJ',
"बरखास्त" :'JJ',
"बरख़ास्त" :'JJ',
"बरख्वास्त" :'JJ',
"बरख़्वास्त" :'JJ',
"बरपा" :'JJ',
"बरफ आच्छादित" :'JJ',
"बरफ़ आच्छादित" :'JJ',
"बरफानी" :'JJ',
"बरफ़ानी" :'JJ',
"बरफीला" :'JJ',
"बरफ़ीला" :'JJ',
"बरबंड" :'JJ',
"बरबडोसी" :'JJ',
"बरबदोसी" :'JJ',
"बरबाद" :'JJ',
"बरमूडन" :'JJ',
"बरमूडाई" :'JJ',
"बरसा" :'JJ',
"बरसाऊ" :'JJ',
"बरसाती" :'JJ',
"बरसौंहा" :'JJ',
"बराबर" :'JJ',
"बरामद" :'JJ',
"बरी" :'JJ',
"बरुंडियन" :'JJ',
"बरुंडी" :'JJ',
"बरुण्डियन" :'JJ',
"बरुण्डी" :'JJ',
"बर्खास्त" :'JJ',
"बर्फ आच्छादित" :'JJ',
"बर्फ़ आच्छादित" :'JJ',
"बर्फमय" :'JJ',
"बर्फानी" :'JJ',
"बर्फ़ानी" :'JJ',
"बर्फीला" :'JJ',
"बर्फ़ीला" :'JJ',
"बर्बर" :'JJ',
"बर्बाद" :'JJ',
"बर्मी" :'JJ',
"बर्मीज़" :'JJ',
"बर्मीस" :'JJ',
"बल खाता" :'JJ',
"बलकारक" :'JJ',
"बलकारी" :'JJ',
"बलखाता" :'JJ',
"बलवंत" :'JJ',
"बलवन्त" :'JJ',
"बलवर्द्धक" :'JJ',
"बलवर्धक" :'JJ',
"बलवाई" :'JJ',
"बलवान" :'JJ',
"बलशाली" :'JJ',
"बलसुम" :'JJ',
"बलहीन" :'JJ',
"बलात्कारक" :'JJ',
"बलात्कारी" :'JJ',
"बलात्कृत" :'JJ',
"बलिदानी" :'JJ',
"बलिष्ठ" :'JJ',
"बली" :'JJ',
"बलुआ" :'JJ',
"बलुआई" :'JJ',
"बलुआही" :'JJ',
"बलुई" :'JJ',
"बस" :'JJ',
"बसंती" :'JJ',
"बसा" :'JJ',
"बसा हुआ" :'JJ',
"बसिया" :'JJ',
"बसीकर" :'JJ',
"बँसीला" :'JJ',
"बहता" :'JJ',
"बहता हुआ" :'JJ',
"बहत्तर" :'JJ',
"बहत्तरवाँ" :'JJ',
"बहमाई" :'JJ',
"बहरा" :'JJ',
"बहरीनी" :'JJ',
"बहरेनी" :'JJ',
"बहादुर" :'JJ',
"बहानेबाज" :'JJ',
"बहानेबाज़" :'JJ',
"बहाल" :'JJ',
"बहिरंग" :'JJ',
"बहिरभिमुखी" :'JJ',
"बहिरा" :'JJ',
"बहिर्भिमुखी" :'JJ',
"बहिर्मुखी" :'JJ',
"बहिश्ती" :'JJ',
"बहिष्क" :'JJ',
"बहिष्कृत" :'JJ',
"बहु ब्रांड" :'JJ',
"बहु ब्रान्ड" :'JJ',
"बहु मार्का" :'JJ',
"बहुचर्चित" :'JJ',
"बहुत" :'JJ',
"बहुत अधिक" :'JJ',
"बहुत कड़वा" :'JJ',
"बहुत कड़ुआ" :'JJ',
"बहुत कम" :'JJ',
"बहुत कुछ" :'JJ',
"बहुत खराब" :'JJ',
"बहुत ख़राब" :'JJ',
"बहुत ज्यादा" :'JJ',
"बहुत ज्यादा नरम" :'JJ',
"बहुत ज्यादा मुलायम" :'JJ',
"बहुत ठंडा" :'JJ',
"बहुत दूर" :'JJ',
"बहुत बड़ा" :'JJ',
"बहुत बुरा" :'JJ',
"बहुत लंबा-चौड़ा" :'JJ',
"बहुत विस्तृत" :'JJ',
"बहुत सारा" :'JJ',
"बहुत ही बुरा" :'JJ',
"बहुत-कुछ" :'JJ',
"बहुत-सा" :'JJ',
"बहुतांश" :'JJ',
"बहुतेरे" :'JJ',
"बहुदलीय" :'JJ',
"बहुदेशीय" :'JJ',
"बहुधंधी" :'JJ',
"बहुधन" :'JJ',
"बहुधन्धी" :'JJ',
"बहुधर्मी" :'JJ',
"बहुधार्मिक" :'JJ',
"बहुभाषिक" :'JJ',
"बहुभाषी" :'JJ',
"बहुभाषीय" :'JJ',
"बहुभुज" :'JJ',
"बहुभुजी" :'JJ',
"बहुमंजिला" :'JJ',
"बहुमंज़िला" :'JJ',
"बहुमूल्य" :'JJ',
"बहुरंग" :'JJ',
"बहुरंगा" :'JJ',
"बहुराष्ट्रीय" :'JJ',
"बहुरूपिया" :'JJ',
"बहुल" :'JJ',
"बहुवर्षी" :'JJ',
"बहुवर्षीय" :'JJ',
"बहुविध" :'JJ',
"बहुशिल्प" :'JJ',
"बहुशिल्पीय" :'JJ',
"बहुसंख्य" :'JJ',
"बहुसंख्यक" :'JJ',
"बह्वक्षर" :'JJ',
"बाइख्तियार" :'JJ',
"बाइख़्तियार" :'JJ',
"बाइस" :'JJ',
"बाइसवाँ" :'JJ',
"बाइसवां" :'JJ',
"बाईस" :'JJ',
"बाईसवाँ" :'JJ',
"बाईसवां" :'JJ',
"बाँकड़ा" :'JJ',
"बांकड़ा" :'JJ',
"बाँकदार" :'JJ',
"बांकदार" :'JJ',
"बाँका" :'JJ',
"बांका" :'JJ',
"बाकी" :'JJ',
"बाक़ी" :'JJ',
"बाँकुड़ा" :'JJ',
"बांकुड़ा" :'JJ',
"बाँकुरा" :'JJ',
"बाखबर" :'JJ',
"बाख़बर" :'JJ',
"बागड़बिल्ला" :'JJ',
"बाँगड़ू" :'JJ',
"बागी" :'JJ',
"बाग़ी" :'JJ',
"बाँग्ला देशी" :'JJ',
"बांग्लादेशी" :'JJ',
"बाँग्लादेशी " :'JJ',
"बाँग्लादेशीय" :'JJ',
"बाँछित" :'JJ',
"बाँछी" :'JJ',
"बाज" :'JJ',
"बाजायका" :'JJ',
"बाज़ायका" :'JJ',
"बाजारी" :'JJ',
"बाज़ारी" :'JJ',
"बाजारू" :'JJ',
"बाज़ारू" :'JJ',
"बाजू का" :'JJ',
"बाँझ" :'JJ',
"बाँड़" :'JJ',
"बाँड़ा" :'JJ',
"बाढ़ पीड़ित" :'JJ',
"बाढ़-ग्रस्त" :'JJ',
"बाढ़-पीड़ित" :'JJ',
"बाढ़ग्रस्त" :'JJ',
"बाढ़पीड़ित" :'JJ',
"बातूनी" :'JJ',
"बातें बनानेवाला" :'JJ',
"बादशाही" :'JJ',
"बादामा" :'JJ',
"बादामी" :'JJ',
"बादी" :'JJ',
"बाँदू" :'JJ',
"बाधक" :'JJ',
"बाधाग्रस्त" :'JJ',
"बाधारहित" :'JJ',
"बाधाहीन" :'JJ',
"बाधित" :'JJ',
"बाध्य" :'JJ',
"बाध्यकारी" :'JJ',
"बानबे" :'JJ',
"बानबेवाँ" :'JJ',
"बानवे" :'JJ',
"बानवेवाँ" :'JJ',
"बापुरा" :'JJ',
"बाबरी" :'JJ',
"बायाँ" :'JJ',
"बाँयाँ" :'JJ',
"बायो-डिग्रेडबल" :'JJ',
"बायो-डिग्रैडेबल" :'JJ',
"बायो-डीग्रेडबल" :'JJ',
"बायो-डीग्रैडबल" :'JJ',
"बायोडिग्रेडेबल" :'JJ',
"बायोडिग्रैडेबल" :'JJ',
"बायोडीग्रेडेबल" :'JJ',
"बायोडीग्रैडबल" :'JJ',
"बार-बार आनेवाला" :'JJ',
"बारबैडोसी" :'JJ',
"बारबैदोसी" :'JJ',
"बारह" :'JJ',
"बारह-मासी" :'JJ',
"बारहमासी" :'JJ',
"बारहवाँ" :'JJ',
"बारानी" :'JJ',
"बारीक" :'JJ',
"बारीक़" :'JJ',
"बाल" :'JJ',
"बाल बच्चे वाला" :'JJ',
"बाल बच्चों वाला" :'JJ',
"बाल बराबर" :'JJ',
"बाल विधवा" :'JJ',
"बाल-बच्चे वाला" :'JJ',
"बाल-बच्चेदार" :'JJ',
"बाल-बच्चों वाला" :'JJ',
"बाल-विधवा" :'JJ',
"बालबच्चे वाला" :'JJ',
"बालबच्चों वाला" :'JJ',
"बालवत" :'JJ',
"बालविधवा" :'JJ',
"बालसुलभ" :'JJ',
"बालाई" :'JJ',
"बालानशीन" :'JJ',
"बालिग" :'JJ',
"बालिग़" :'JJ',
"बालुई" :'JJ',
"बालूकामय" :'JJ',
"बालूदार" :'JJ',
"बालोचित" :'JJ',
"बालोपयोगी" :'JJ',
"बावन" :'JJ',
"बावनवाँ" :'JJ',
"बावरा" :'JJ',
"बावला" :'JJ',
"बावाँ" :'JJ',
"बासठ" :'JJ',
"बासठवाँ" :'JJ',
"बासंती" :'JJ',
"बासयुक्त" :'JJ',
"बासहीन" :'JJ',
"बासी" :'JJ',
"बाहत्तर" :'JJ',
"बाहत्तरवाँ" :'JJ',
"बाहर आया हुआ" :'JJ',
"बाहर हुआ" :'JJ',
"बाहरी" :'JJ',
"बाहुहीन" :'JJ',
"बाह्य" :'JJ',
"बिकनेवाला" :'JJ',
"बिका हुआ" :'JJ',
"बिकाऊ" :'JJ',
"बिक्रमी" :'JJ',
"बिक्रू" :'JJ',
"बिखरा" :'JJ',
"बिखरा हुआ" :'JJ',
"बिगड़ता" :'JJ',
"बिगड़ा" :'JJ',
"बिगड़ैल" :'JJ',
"बिगुर" :'JJ',
"बिचला" :'JJ',
"बिजैला" :'JJ',
"बिज्जू" :'JJ',
"बिंदास" :'JJ',
"बिंदुकित" :'JJ',
"बिदेसी" :'JJ',
"बिद्ध" :'JJ',
"बिनब्याहा" :'JJ',
"बिनब्याही" :'JJ',
"बिना" :'JJ',
"बिना निगला" :'JJ',
"बिना मूल्य" :'JJ',
"बिन्दास" :'JJ',
"बिन्दुकित" :'JJ',
"बियाबान" :'JJ',
"बियावान" :'JJ',
"बिरला" :'JJ',
"बिरही" :'JJ',
"बिराना" :'JJ',
"बिलल्ला" :'JJ',
"बिला" :'JJ',
"बिलियन" :'JJ',
"बिली" :'JJ',
"बिल्डिंग" :'JJ',
"बिल्लौरी" :'JJ',
"बिहारी" :'JJ',
"बिहिश्ती" :'JJ',
"बीजदार" :'JJ',
"बीजयुक्त" :'JJ',
"बीजरहित" :'JJ',
"बीजल" :'JJ',
"बीजवाप" :'JJ',
"बीजवाला" :'JJ',
"बीजशून्य" :'JJ',
"बीजाकृत" :'JJ',
"बीजारोपित" :'JJ',
"बीजित" :'JJ',
"बीजी" :'JJ',
"बीजू" :'JJ',
"बीझा" :'JJ',
"बीता" :'JJ',
"बीता भर" :'JJ',
"बीता भर का" :'JJ',
"बीभत्स" :'JJ',
"बीमाकर्ता" :'JJ',
"बीमार" :'JJ',
"बीस" :'JJ',
"बीसवाँ" :'JJ',
"बीसवां" :'JJ',
"बीसेक" :'JJ',
"बीहड़" :'JJ',
"बुआ" :'JJ',
"बुजदिल" :'JJ',
"बुज़दिल" :'JJ',
"बुजुर्ग" :'JJ',
"बुज़ुर्ग" :'JJ',
"बुझा" :'JJ',
"बुझा हुआ" :'JJ',
"बुड्ढा" :'JJ',
"बुढ़वा" :'JJ',
"बुँदकीदार" :'JJ',
"बुंदेलखंडी" :'JJ',
"बुद्ध" :'JJ',
"बुद्धि का भसुर" :'JJ',
"बुद्धिगम्य" :'JJ',
"बुद्धिजीवी" :'JJ',
"बुद्धिमती" :'JJ',
"बुद्धिमान" :'JJ',
"बुद्धिवादी" :'JJ',
"बुद्धिहीन" :'JJ',
"बुद्धू" :'JJ',
"बुधंगड़" :'JJ',
"बुधवारी" :'JJ',
"बुनियादी" :'JJ',
"बुरा" :'JJ',
"बुरुंडियन" :'JJ',
"बुरुंडी" :'JJ',
"बुरुण्डियन" :'JJ',
"बुरुण्डी" :'JJ',
"बुलगारियन" :'JJ',
"बुलगारियाई" :'JJ',
"बुलंद" :'JJ',
"बुलंदपरवाज" :'JJ',
"बुलंदपरवाज़" :'JJ',
"बुलन्द" :'JJ',
"बुलेट प्रूफ" :'JJ',
"बुलेटप्रूफ" :'JJ',
"बुल्गारियन" :'JJ',
"बुल्गारियाई" :'JJ',
"बुसा हुआ" :'JJ',
"बूचा" :'JJ',
"बूढ़ा" :'JJ',
"बृहत्" :'JJ',
"बृहत्काय" :'JJ',
"बृहत्तर" :'JJ',
"बृहद्" :'JJ',
"बे-इज्जत" :'JJ',
"बे-औलाद" :'JJ',
"बे-करार" :'JJ',
"बे-तार" :'JJ',
"बे-नजीर" :'JJ',
"बे-फायदा" :'JJ',
"बे-बुनियाद" :'JJ',
"बे-लज्जत" :'JJ',
"बे-शर्म" :'JJ',
"बे-हया" :'JJ',
"बेअकल" :'JJ',
"बेअक़ल" :'JJ',
"बेअक्ल" :'JJ',
"बेअक़्ल" :'JJ',
"बेअदब" :'JJ',
"बेअंदाज" :'JJ',
"बेअसर" :'JJ',
"बेआँच" :'JJ',
"बेआबरू" :'JJ',
"बेआराम" :'JJ',
"बेआश्रय" :'JJ',
"बेइज्जत" :'JJ',
"बेइज़्ज़त" :'JJ',
"बेईमान" :'JJ',
"बेऐब" :'JJ',
"बेऔलाद" :'JJ',
"बेकतार" :'JJ',
"बेक़तार" :'JJ',
"बेकदर" :'JJ',
"बेक़दर" :'JJ',
"बेकद्र" :'JJ',
"बेक़द्र" :'JJ',
"बेकमाया" :'JJ',
"बेकरार" :'JJ',
"बेकल" :'JJ',
"बेकस" :'JJ',
"बेकसूर" :'JJ',
"बेकाबू" :'JJ',
"बेक़ाबू" :'JJ',
"बेकाम" :'JJ',
"बेकायदा" :'JJ',
"बेक़ायदा" :'JJ',
"बेकार" :'JJ',
"बेखटक" :'JJ',
"बेखबर" :'JJ',
"बेख़बर" :'JJ',
"बेखौफ" :'JJ',
"बेख़ौफ़" :'JJ',
"बेगमी" :'JJ',
"बेग़मी" :'JJ',
"बेगरज" :'JJ',
"बेग़रज़" :'JJ',
"बेगाना" :'JJ',
"बेगुनाह" :'JJ',
"बेगैरत" :'JJ',
"बेग़ैरत" :'JJ',
"बेघर" :'JJ',
"बेघर-बार" :'JJ',
"बेघरबार" :'JJ',
"बेचखा" :'JJ',
"बेचा हुआ" :'JJ',
"बेचारा" :'JJ',
"बेचैन" :'JJ',
"बेजबान" :'JJ',
"बेज़बान" :'JJ',
"बेजमीन" :'JJ',
"बेज़मीन" :'JJ',
"बेजवाब" :'JJ',
"बेजा" :'JJ',
"बेजान" :'JJ',
"बेजायका" :'JJ',
"बेज़ायक़ा" :'JJ',
"बेज़ार" :'JJ',
"बेजुबान" :'JJ',
"बेज़ुबान" :'JJ',
"बेजोड़" :'JJ',
"बेझिझक" :'JJ',
"बेठोकर" :'JJ',
"बेडर" :'JJ',
"बेड़ा" :'JJ',
"बेडौल" :'JJ',
"बेढंगा" :'JJ',
"बेढप" :'JJ',
"बेढब" :'JJ',
"बेतकल्लुफ" :'JJ',
"बेतकल्लुफ़" :'JJ',
"बेतरतीब" :'JJ',
"बेतहाशा" :'JJ',
"बेताज" :'JJ',
"बेताज़" :'JJ',
"बेताब" :'JJ',
"बेतार" :'JJ',
"बेताल" :'JJ',
"बेताला" :'JJ',
"बेतुका" :'JJ',
"बेदखल" :'JJ',
"बेदख़ल" :'JJ',
"बेदम" :'JJ',
"बेदाग" :'JJ',
"बेदाग़" :'JJ',
"बेदाँत" :'JJ',
"बेदार" :'JJ',
"बेधक" :'JJ',
"बेधड़क" :'JJ',
"बेनकाब" :'JJ',
"बेनक़ाब" :'JJ',
"बेनजीर" :'JJ',
"बेनतीजा" :'JJ',
"बेनाम" :'JJ',
"बेनिनी" :'JJ',
"बेनिनीज़" :'JJ',
"बेनिनीस" :'JJ',
"बेनिमून" :'JJ',
"बेपढ़ा" :'JJ',
"बेपरवा" :'JJ',
"बेपरवाह" :'JJ',
"बेपर्दा" :'JJ',
"बेपेंदा" :'JJ',
"बेफायदा" :'JJ',
"बेफ़ायदा" :'JJ',
"बेफिक्र" :'JJ',
"बेफ़िक्र" :'JJ',
"बेफ़िक़्र" :'JJ',
"बेबस" :'JJ',
"बेबाक" :'JJ',
"बेबुनियाद" :'JJ',
"बेमजा" :'JJ',
"बेमज़ा" :'JJ',
"बेमतलब का" :'JJ',
"बेमन का" :'JJ',
"बेमर्याद" :'JJ',
"बेमानी" :'JJ',
"बेमियादी" :'JJ',
"बेमिलावटी" :'JJ',
"बेमिसाल" :'JJ',
"बेमुद्दती" :'JJ',
"बेमुरव्वत" :'JJ',
"बेमुरौवत" :'JJ',
"बेमेल" :'JJ',
"बेमौसम" :'JJ',
"बेरंग" :'JJ',
"बेरङ्ग" :'JJ',
"बेरस" :'JJ',
"बेरहम" :'JJ',
"बेरोक" :'JJ',
"बेरोक-टोक" :'JJ',
"बेरोजगार" :'JJ',
"बेरोज़गार" :'JJ',
"बेरौनक" :'JJ',
"बेलगाम" :'JJ',
"बेलज्जत" :'JJ',
"बेलनाकार" :'JJ',
"बेलरसी" :'JJ',
"बेलरूसियन" :'JJ',
"बेला हुआ" :'JJ',
"बेलिजियन" :'JJ',
"बेलिज़ियन" :'JJ',
"बेलिजी" :'JJ',
"बेलिज़ी" :'JJ',
"बेलिहाज" :'JJ',
"बेलिहाज़" :'JJ',
"बेल्जियन" :'JJ',
"बेल्जियमी" :'JJ',
"बेवकूफ" :'JJ',
"बेवकूफ़" :'JJ',
"बेवक्त" :'JJ',
"बेवड़ा" :'JJ',
"बेवफा" :'JJ',
"बेवफ़ा" :'JJ',
"बेवा" :'JJ',
"बेशऊर" :'JJ',
"बेशकीमती" :'JJ',
"बेशक़ीमती" :'JJ',
"बेशक्ल" :'JJ',
"बेशरम" :'JJ',
"बेशर्म" :'JJ',
"बेशुमार" :'JJ',
"बेसनी" :'JJ',
"बेसबूत" :'JJ',
"बेसब्र" :'JJ',
"बेसमझ" :'JJ',
"बेसहारा" :'JJ',
"बेसिंगा" :'JJ',
"बेसिंघा" :'JJ',
"बेसुध" :'JJ',
"बेसुर" :'JJ',
"बेसुरा" :'JJ',
"बेस्ट" :'JJ',
"बेस्वाद" :'JJ',
"बेहंगम" :'JJ',
"बेहतर" :'JJ',
"बेहतरीन" :'JJ',
"बेहथियार" :'JJ',
"बेहद" :'JJ',
"बेहया" :'JJ',
"बेहवास" :'JJ',
"बेहाल" :'JJ',
"बेहिसाब" :'JJ',
"बेहिसाबी" :'JJ',
"बेहिसामाम" :'JJ',
"बेहूदा" :'JJ',
"बेहोश" :'JJ',
"बैंकिंग" :'JJ',
"बैक्टीरियल" :'JJ',
"बैक्टीरिया रोधी" :'JJ',
"बैक्टीरिया-रोधी" :'JJ',
"बैक्टीरियारोधी" :'JJ',
"बैगनी" :'JJ',
"बैंगनी" :'JJ',
"बैंगलोरी" :'JJ',
"बैंजनी" :'JJ',
"बैजवी" :'JJ',
"बैज़वी" :'JJ',
"बैठा" :'JJ',
"बैठा हुआ" :'JJ',
"बैतड़ा" :'JJ',
"बैतला" :'JJ',
"बैरंग" :'JJ',
"बैरन" :'JJ',
"बैरपूर्ण" :'JJ',
"बैरागी" :'JJ',
"बैरी" :'JJ',
"बैल" :'JJ',
"बैलेन्स्ड" :'JJ',
"बैलेंस्ड" :'JJ',
"बैसाखी" :'JJ',
"बैसिक" :'JJ',
"बैस्ट" :'JJ',
"बोझल" :'JJ',
"बोझिल" :'JJ',
"बोझैल" :'JJ',
"बोत्सवानन" :'JJ',
"बोत्सवानाई" :'JJ',
"बोदा" :'JJ',
"बोद्दा" :'JJ',
"बोद्ध्य" :'JJ',
"बोधक" :'JJ',
"बोधगम्य" :'JJ',
"बोधातीत" :'JJ',
"बोध्य" :'JJ',
"बोनेवाला" :'JJ',
"बोबा" :'JJ',
"बोया" :'JJ',
"बोया हुआ" :'JJ',
"बोलता" :'JJ',
"बोलीविआई" :'JJ',
"बोलीवियन" :'JJ',
"बोलीवियाई" :'JJ',
"बोसनिआई" :'JJ',
"बोसनियाई" :'JJ',
"बौद्ध" :'JJ',
"बौद्ध धर्मावलंबी" :'JJ',
"बौद्धकालीन" :'JJ',
"बौद्धयुगीन" :'JJ',
"बौद्धिक" :'JJ',
"बौना" :'JJ',
"बौरा" :'JJ',
"ब्याहता" :'JJ',
"ब्याहा" :'JJ',
"ब्योरेवार" :'JJ',
"ब्रह्मज्ञानी" :'JJ',
"ब्रह्मभूत" :'JJ',
"ब्रह्मलीन" :'JJ',
"ब्रह्मांडीय" :'JJ',
"ब्रह्मावर्ती" :'JJ',
"ब्रह्मीभूत" :'JJ',
"ब्राजील-संबंधी" :'JJ',
"ब्राज़ील-संबंधी" :'JJ',
"ब्राजीलियन" :'JJ',
"ब्राज़ीलियन" :'JJ',
"ब्राडबैंड" :'JJ',
"ब्राह्मणी" :'JJ',
"ब्रिटिश" :'JJ',
"ब्रिटिश गुईनाई" :'JJ',
"ब्रिटिश गुएनाई" :'JJ',
"ब्रितानी" :'JJ',
"ब्रॉडबैंड" :'JJ',
"भकराँधा" :'JJ',
"भकसा" :'JJ',
"भकुआ" :'JJ',
"भकुवा" :'JJ',
"भकोसू" :'JJ',
"भक्त" :'JJ',
"भक्तवत्सल" :'JJ',
"भक्तिपूर्ण" :'JJ',
"भक्तिशून्य" :'JJ',
"भक्तिहीन" :'JJ',
"भक्षक" :'JJ',
"भक्षित" :'JJ',
"भक्षी" :'JJ',
"भक्ष्य" :'JJ',
"भगत-बछल" :'JJ',
"भगवद्दत्त" :'JJ',
"भगवा" :'JJ',
"भगवान" :'JJ',
"भगवान्" :'JJ',
"भगीरथ" :'JJ',
"भंगुर" :'JJ',
"भगेड़ू" :'JJ',
"भगोड़" :'JJ',
"भगोड़ा" :'JJ',
"भग्गू" :'JJ',
"भग्न" :'JJ',
"भग्नपृष्ठ" :'JJ',
"भग्नाश" :'JJ',
"भंजक" :'JJ',
"भंजनशील" :'JJ',
"भंजनीय" :'JJ',
"भंजित" :'JJ',
"भटका" :'JJ',
"भड़कदार" :'JJ',
"भड़का" :'JJ',
"भड़काऊ" :'JJ',
"भड़कीला" :'JJ',
"भँडफोड़" :'JJ',
"भंडा-फोड़" :'JJ',
"भंडाफोड़" :'JJ',
"भतहा" :'JJ',
"भदई" :'JJ',
"भदईं" :'JJ',
"भदेस" :'JJ',
"भदेसिल" :'JJ',
"भदौंहा" :'JJ',
"भद्दा" :'JJ',
"भद्र" :'JJ',
"भयंकर" :'JJ',
"भयग्रस्त" :'JJ',
"भयङ्कर" :'JJ',
"भयपूर्ण" :'JJ',
"भयभीत" :'JJ',
"भययुक्त" :'JJ',
"भयहीन" :'JJ',
"भयाकुल" :'JJ',
"भयाक्रांत" :'JJ',
"भयाक्रान्त" :'JJ',
"भयातुर" :'JJ',
"भयानक" :'JJ',
"भयान्वित" :'JJ',
"भयावन" :'JJ',
"भयावना" :'JJ',
"भयावह" :'JJ',
"भर" :'JJ',
"भरपूर" :'JJ',
"भरपेट" :'JJ',
"भरवाँ" :'JJ',
"भरा" :'JJ',
"भरा हुआ" :'JJ',
"भरा-पूरा" :'JJ',
"भरापूरा" :'JJ',
"भरोसी" :'JJ',
"भरोसेमंद" :'JJ',
"भला" :'JJ',
"भला-चंगा" :'JJ',
"भवितव्य" :'JJ',
"भविष्णु" :'JJ',
"भविष्य कालीन" :'JJ',
"भविष्यज्ञानी" :'JJ',
"भव्य" :'JJ',
"भस्म" :'JJ',
"भस्मकारी" :'JJ',
"भस्मित" :'JJ',
"भस्मीभूत" :'JJ',
"भागता हुआ" :'JJ',
"भागलपुरी" :'JJ',
"भागीरथ" :'JJ',
"भाग्यवादी" :'JJ',
"भाग्यवान" :'JJ',
"भाग्यशाली" :'JJ',
"भाग्यहीन" :'JJ',
"भाजपाई" :'JJ',
"भाँजा" :'JJ',
"भाँजा हुआ" :'JJ',
"भाज्य" :'JJ',
"भाँति भाँति" :'JJ',
"भाँति-भाँति" :'JJ',
"भाद्रपदीय" :'JJ',
"भामी" :'JJ',
"भारग्रस्त" :'JJ',
"भारतीय" :'JJ',
"भारवाह" :'JJ',
"भारवाहक" :'JJ',
"भारवाही" :'JJ',
"भारित" :'JJ',
"भारी" :'JJ',
"भारी भड़कम" :'JJ',
"भारी भरकम" :'JJ',
"भारी-भड़कम" :'JJ',
"भारी-भरकम" :'JJ',
"भारीभड़कम" :'JJ',
"भारीभरकम" :'JJ',
"भार्गव" :'JJ',
"भाव प्रवण" :'JJ',
"भावक" :'JJ',
"भावता" :'JJ',
"भावनात्मक" :'JJ',
"भावनापूर्ण" :'JJ',
"भावनाहीन" :'JJ',
"भावपूर्ण" :'JJ',
"भावभीना" :'JJ',
"भावभीनी" :'JJ',
"भावमय" :'JJ',
"भावरहित" :'JJ',
"भावशून्य" :'JJ',
"भावसंयुक्त" :'JJ',
"भावहीन" :'JJ',
"भावात्मक" :'JJ',
"भाविता" :'JJ',
"भावी" :'JJ',
"भावुक" :'JJ',
"भाषाई" :'JJ',
"भाषांतरकार" :'JJ',
"भाषांतरणीय" :'JJ',
"भाषांतरित" :'JJ',
"भाषान्तरणीय" :'JJ',
"भाषान्तरित" :'JJ',
"भाषायी" :'JJ',
"भाषिक" :'JJ',
"भाषित" :'JJ',
"भाषी" :'JJ',
"भाषीय" :'JJ',
"भिज्ञ" :'JJ',
"भितरिया" :'JJ',
"भिन्न" :'JJ',
"भिन्न जातीय" :'JJ',
"भिन्न भिन्न" :'JJ',
"भिन्न-भिन्न" :'JJ',
"भिन्न-भिन्न प्रकार का" :'JJ',
"भिन्नरूप" :'JJ',
"भिन्नरूपी" :'JJ',
"भीक" :'JJ',
"भीगा" :'JJ',
"भीत" :'JJ',
"भीतरी" :'JJ',
"भीमकाय" :'JJ',
"भीरु" :'JJ',
"भीरू" :'JJ',
"भीली" :'JJ',
"भीलीय" :'JJ',
"भीषण" :'JJ',
"भुक्कड़" :'JJ',
"भुक्खड़" :'JJ',
"भुक्त" :'JJ',
"भुक्तभोगी" :'JJ',
"भुखमरा" :'JJ',
"भुगतान कृत" :'JJ',
"भुग्गल" :'JJ',
"भुच्च" :'JJ',
"भुच्चड़" :'JJ',
"भुजाहीन" :'JJ',
"भुतहा" :'JJ',
"भुना" :'JJ',
"भुना हुआ" :'JJ',
"भुरभुरा" :'JJ',
"भुलक्कड़" :'JJ',
"भू-गर्भीय" :'JJ',
"भू-गोलीय" :'JJ',
"भू-लुठिंत" :'JJ',
"भू-लुण्ठित" :'JJ',
"भू-वैज्ञानिक" :'JJ',
"भू-संरचनात्मक" :'JJ',
"भूखड़" :'JJ',
"भूखवर्धक" :'JJ',
"भूखा" :'JJ',
"भूगर्भस्थ" :'JJ',
"भूगर्भीय" :'JJ',
"भूगोलीय" :'JJ',
"भूटानी" :'JJ',
"भूत" :'JJ',
"भूत कालीन" :'JJ',
"भूत विषयक" :'JJ',
"भूतकालीन" :'JJ',
"भूतपूर्व" :'JJ',
"भूतहर" :'JJ',
"भूधराकार" :'JJ',
"भूपरिवेष्ठित" :'JJ',
"भूमंडलीय" :'JJ',
"भूमध्यरेखीय" :'JJ',
"भूमि-गत" :'JJ',
"भूमिगत" :'JJ',
"भूमिज" :'JJ',
"भूमिरहित" :'JJ',
"भूमिल" :'JJ',
"भूमिसात" :'JJ',
"भूमिसात्" :'JJ',
"भूमिहीन" :'JJ',
"भूरा" :'JJ',
"भूरि" :'JJ',
"भूलड़" :'JJ',
"भूला हुआ" :'JJ',
"भूला-भटका" :'JJ',
"भूलुठिंत" :'JJ',
"भूलुण्ठित" :'JJ',
"भूल्लड़" :'JJ',
"भूविज्ञानीय" :'JJ',
"भूवैज्ञानिक" :'JJ',
"भूषित" :'JJ',
"भूसंरचनात्मक" :'JJ',
"भृष्ट" :'JJ',
"भेंगा" :'JJ',
"भेजा हुआ" :'JJ',
"भेड़-संबंधी" :'JJ',
"भेड़-सम्बन्धी" :'JJ',
"भेंडा" :'JJ',
"भेदक" :'JJ',
"भेदकारी" :'JJ',
"भेदनशील" :'JJ',
"भेदनीय" :'JJ',
"भेदभावपूर्ण" :'JJ',
"भेदभावहीन" :'JJ',
"भेदित" :'JJ',
"भेद्य" :'JJ',
"भैरवी" :'JJ',
"भैंसा" :'JJ',
"भैंसीय" :'JJ',
"भैहा" :'JJ',
"भोकस" :'JJ',
"भोक्ता" :'JJ',
"भोगलिप्त" :'JJ',
"भोगलिप्सु" :'JJ',
"भोगी" :'JJ',
"भोग्य" :'JJ',
"भोजनकर्ता" :'JJ',
"भोजनकर्त्ता" :'JJ',
"भोजपुरिया" :'JJ',
"भोजपुरी" :'JJ',
"भोज्य" :'JJ',
"भोंडा" :'JJ',
"भोंतरा" :'JJ',
"भोंतला" :'JJ',
"भोथरा" :'JJ',
"भोंदू" :'JJ',
"भोला" :'JJ',
"भोला भाला" :'JJ',
"भोला-भाला" :'JJ',
"भोलाभाला" :'JJ',
"भौगोलिक" :'JJ',
"भौचक" :'JJ',
"भौंचक" :'JJ',
"भौचक्का" :'JJ',
"भौंचक्का" :'JJ',
"भौंड़ा" :'JJ',
"भौतिक" :'JJ',
"भौम" :'JJ',
"भ्रमण-प्रेमी" :'JJ',
"भ्रमणप्रेमी" :'JJ',
"भ्रमणशील" :'JJ',
"भ्रमणीय" :'JJ',
"भ्रमरहित" :'JJ',
"भ्रमित" :'JJ',
"भ्रष्ट" :'JJ',
"भ्रष्टणीय" :'JJ',
"भ्रष्टाचारी" :'JJ',
"भ्रांत" :'JJ',
"भ्रांतिशून्य" :'JJ',
"भ्रान्त" :'JJ',
"मकतूब" :'JJ',
"मकतूल" :'JJ',
"मक़तूल" :'JJ',
"मकदूनियाई" :'JJ',
"मक़बूल" :'JJ',
"मकरुह" :'JJ',
"मकरूह" :'JJ',
"मक़रूह" :'JJ',
"मकारांत" :'JJ',
"मकारादि" :'JJ',
"मकारान्त" :'JJ',
"मकैनिकल" :'JJ',
"मक्कार" :'JJ',
"मक्खनी" :'JJ',
"मक्खीचूस" :'JJ',
"मक्खीमार" :'JJ',
"मखत्राता" :'JJ',
"मखमली" :'JJ',
"मख़मली" :'JJ',
"मगजचट" :'JJ',
"मगन" :'JJ',
"मगरा" :'JJ',
"मगरिबी" :'JJ',
"मगरूर" :'JJ',
"मंगल जनक" :'JJ',
"मंगल भाषित" :'JJ',
"मंगल-भाषित" :'JJ',
"मंगलकारक" :'JJ',
"मंगलकारी" :'JJ',
"मंगलदायक" :'JJ',
"मंगलप्रद" :'JJ',
"मंगलवारी" :'JJ',
"मंगला" :'JJ',
"मंगल्य" :'JJ',
"मगही" :'JJ',
"मँगोल" :'JJ',
"मंगोल" :'JJ',
"मंगोलियन" :'JJ',
"मंगोलियाई" :'JJ',
"मग्न" :'JJ',
"मंचनीय" :'JJ',
"मचा" :'JJ',
"मंचायोग्य" :'JJ',
"मंचित" :'JJ',
"मंचीय" :'JJ',
"मच्छररहित" :'JJ',
"मंच्य" :'JJ',
"मजबूत" :'JJ',
"मज़बूत" :'JJ',
"मजबूर" :'JJ',
"मंजरित" :'JJ',
"मजरूआ" :'JJ',
"मंजला" :'JJ',
"मंज़ला" :'JJ',
"मजलूम" :'JJ',
"मज़लूम" :'JJ',
"मजहबी" :'JJ',
"मज़हबी" :'JJ',
"मँजा" :'JJ',
"मंजा" :'JJ',
"मँजा हुआ" :'JJ',
"मंजा हुआ" :'JJ',
"मजाकिया" :'JJ',
"मज़ाक़िया" :'JJ',
"मजाज" :'JJ',
"मजाज़" :'JJ',
"मंजिला" :'JJ',
"मंज़िला" :'JJ',
"मजीठी" :'JJ',
"मंजु" :'JJ',
"मंजुल" :'JJ',
"मंजूर" :'JJ',
"मंज़ूर" :'JJ',
"मंजूरशुदा" :'JJ',
"मंज़ूरशुदा" :'JJ',
"मजेदार" :'JJ',
"मज़ेदार" :'JJ',
"मझला" :'JJ',
"मँझला" :'JJ',
"मंझला" :'JJ',
"मँझा" :'JJ',
"मंझा" :'JJ',
"मँझा हुआ" :'JJ',
"मंझा हुआ" :'JJ',
"मझीला" :'JJ',
"मंझीला" :'JJ',
"मँझुवा" :'JJ',
"मझेला" :'JJ',
"मझोला" :'JJ',
"मँझोला" :'JJ',
"मंझोला" :'JJ',
"मटमैला" :'JJ',
"मटरीला" :'JJ',
"मटिया" :'JJ',
"मटिया मेट" :'JJ',
"मटियाला" :'JJ',
"मट्ठर" :'JJ',
"मडगास्करी" :'JJ',
"मंडलाकार" :'JJ',
"मंडलीय" :'JJ',
"मड़हा" :'JJ',
"मंडित" :'JJ',
"मढ़ा" :'JJ',
"मढ़ा हुआ" :'JJ',
"मणिपुरी" :'JJ',
"मण्डलीय" :'JJ',
"मण्डित" :'JJ',
"मतभेदरहित" :'JJ',
"मतलब परस्त" :'JJ',
"मतलबपरस्त" :'JJ',
"मतलबिया" :'JJ',
"मतलबी" :'JJ',
"मतवार" :'JJ',
"मतवाला" :'JJ',
"मताग्रही" :'JJ',
"मतांध" :'JJ',
"मताधिकारी" :'JJ',
"मतानुयायी" :'JJ',
"मतिगर्भ" :'JJ',
"मतिमंत" :'JJ',
"मतिमंद" :'JJ',
"मतिमान" :'JJ',
"मतिमाह" :'JJ',
"मतिहीन" :'JJ',
"मत्त" :'JJ',
"मंत्रमुग्ध" :'JJ',
"मंत्रि-मंडलीय" :'JJ',
"मंत्रिमंडलीय" :'JJ',
"मंत्रोपदेशक" :'JJ',
"मत्सर" :'JJ',
"मथनीय" :'JJ',
"मंथर" :'JJ',
"मथा हुआ" :'JJ',
"मथित" :'JJ',
"मथुरिया" :'JJ',
"मथ्य" :'JJ',
"मंद" :'JJ',
"मददगार" :'JJ',
"मंदबुद्धि" :'JJ',
"मंदभाग्य" :'JJ',
"मंदमति" :'JJ',
"मदमस्त" :'JJ',
"मदरहित" :'JJ',
"मदशून्य" :'JJ',
"मदहोश" :'JJ',
"मंदा" :'JJ',
"मदांध" :'JJ',
"मदान्ध" :'JJ',
"मदिरोन्मत्त" :'JJ',
"मदोन्मत्त" :'JJ',
"मंदोष्ण" :'JJ',
"मद्धिम" :'JJ',
"मद्यप" :'JJ',
"मद्योन्मत्त" :'JJ',
"मद्रासी" :'JJ',
"मधुपर्क्य" :'JJ',
"मधुमेही" :'JJ',
"मधुर" :'JJ',
"मधुरभाषी" :'JJ',
"मध्य" :'JJ',
"मध्य युगीन" :'JJ',
"मध्यक" :'JJ',
"मध्यकालीन" :'JJ',
"मध्यम" :'JJ',
"मध्यम वर्गीय" :'JJ',
"मध्यमवर्गी" :'JJ',
"मध्यमवर्गीय" :'JJ',
"मध्यमान" :'JJ',
"मध्ययुगीन" :'JJ',
"मध्यवय" :'JJ',
"मध्यवयस्क" :'JJ',
"मध्यवर्गी" :'JJ',
"मध्यवर्गीय" :'JJ',
"मध्यवर्ती" :'JJ',
"मध्यस्थित" :'JJ',
"मध्यावधि" :'JJ',
"मनः" :'JJ',
"मनकरा" :'JJ',
"मनकूला" :'JJ',
"मनगढ़ंत" :'JJ',
"मनचला" :'JJ',
"मनचाहा" :'JJ',
"मननशील" :'JJ',
"मननीय" :'JJ',
"मनपसंद" :'JJ',
"मनपसन्द" :'JJ',
"मनभाता" :'JJ',
"मनभावन" :'JJ',
"मनमर्जी" :'JJ',
"मनमर्ज़ी" :'JJ',
"मनमर्ज़ी का" :'JJ',
"मनमाना" :'JJ',
"मनमानी" :'JJ',
"मनमोहक" :'JJ',
"मनमौजी" :'JJ',
"मनसा" :'JJ',
"मनहर" :'JJ',
"मनहसर" :'JJ',
"मनहूस" :'JJ',
"मना" :'JJ',
"मना किया हुआ" :'JJ',
"मनाक" :'JJ',
"मनाग" :'JJ',
"मनुजाद" :'JJ',
"मनुजोचित" :'JJ',
"मनुष्यभक्षी" :'JJ',
"मनोगत" :'JJ',
"मनोज्ञ" :'JJ',
"मनोनीत" :'JJ',
"मनोभिराम" :'JJ',
"मनोमुग्धकारी" :'JJ',
"मनोरंजक" :'JJ',
"मनोरंजनपूर्ण" :'JJ',
"मनोरंजित" :'JJ',
"मनोरम" :'JJ',
"मनोरम्य" :'JJ',
"मनोवांछित" :'JJ',
"मनोवैज्ञानिक" :'JJ',
"मनोहर" :'JJ',
"मनोहारी" :'JJ',
"मन्जू" :'JJ',
"मन्जूर" :'JJ',
"मन्त्रि-मण्डलीय" :'JJ',
"मन्त्रिमण्डलीय" :'JJ',
"मन्थर" :'JJ',
"मन्द" :'JJ',
"मन्दभाग्य" :'JJ',
"मन्दा" :'JJ',
"मन्दोष्ण" :'JJ',
"मन्नथी" :'JJ',
"ममिआउत" :'JJ',
"ममिया" :'JJ',
"ममेरा" :'JJ',
"मयस्सर" :'JJ',
"मरकहा" :'JJ',
"मरखंडा" :'JJ',
"मरखण्डा" :'JJ',
"मरखनहा" :'JJ',
"मरखना" :'JJ',
"मरखन्ना" :'JJ',
"मरखाह" :'JJ',
"मरखाहा" :'JJ',
"मरखैना" :'JJ',
"मरखौवा" :'JJ',
"मरणकारक" :'JJ',
"मरणतुल्य" :'JJ',
"मरणशील" :'JJ',
"मरणाभिलाषी" :'JJ',
"मरणासन्न" :'JJ',
"मरणोत्तर" :'JJ',
"मरणोत्तरक" :'JJ',
"मरणोपरांत" :'JJ',
"मरणोपरान्त" :'JJ',
"मरदाना" :'JJ',
"मरभुक्खा" :'JJ',
"मरहठा" :'JJ',
"मरहठी" :'JJ',
"मरहूम" :'JJ',
"मरा" :'JJ',
"मरा हुआ" :'JJ',
"मराठी" :'JJ',
"मराठी भाषी" :'JJ',
"मराठी-भाषी" :'JJ',
"मराठीभाषी" :'JJ',
"मरायल" :'JJ',
"मरियल" :'JJ',
"मरुस्थलीय" :'JJ',
"मर्त्य" :'JJ',
"मर्दानगीभरा" :'JJ',
"मर्दाना" :'JJ',
"मर्दित" :'JJ',
"मर्दुमखोर" :'JJ',
"मर्दुमख़ोर" :'JJ',
"मर्द्दित" :'JJ',
"मर्मघाती" :'JJ',
"मर्मज्ञ" :'JJ',
"मर्मभेदी" :'JJ',
"मर्मस्पर्शी" :'JJ',
"मर्यादारहित" :'JJ',
"मर्यादाहीन" :'JJ',
"मर्यादित" :'JJ',
"मर्षणीय" :'JJ',
"मल अवरोधक" :'JJ',
"मलता" :'JJ',
"मलमला" :'JJ',
"मलमली" :'JJ',
"मलयालम" :'JJ',
"मलयाली" :'JJ',
"मला" :'JJ',
"मलाबारी" :'JJ',
"मलावरोधक" :'JJ',
"मलिन" :'JJ',
"मलिनमुख" :'JJ',
"मलूक" :'JJ',
"मलूल" :'JJ',
"मलेशियन" :'JJ',
"मलेशियाई" :'JJ',
"मल्टि ब्रांड" :'JJ',
"मल्टि ब्रान्ड" :'JJ',
"मल्टि ब्रैंड" :'JJ',
"मल्टि ब्रैन्ड" :'JJ',
"मल्लाही" :'JJ',
"मशगूल" :'JJ',
"मशग़ूल" :'JJ',
"मशहूर" :'JJ',
"मशीनी" :'JJ',
"मसकीन" :'JJ',
"मसखरा" :'JJ',
"मसजिदी" :'JJ',
"मसरूफ" :'JJ',
"मसरूफ़" :'JJ',
"मसला" :'JJ',
"मसहार" :'JJ',
"मसालेदार" :'JJ',
"मसीही" :'JJ',
"मंसूख" :'JJ',
"मसृण" :'JJ',
"मस्जिदी" :'JJ',
"मस्त" :'JJ',
"मस्त मौला" :'JJ',
"मस्तमौला" :'JJ',
"मस्ताना" :'JJ',
"मस्तीखोर" :'JJ',
"मस्तीख़ोर" :'JJ',
"महकदार" :'JJ',
"महँगा" :'JJ',
"महंगा" :'JJ',
"मँहगा" :'JJ',
"मंहगा" :'JJ',
"महँगा से महँगा" :'JJ',
"महज" :'JJ',
"महज़" :'JJ',
"महत" :'JJ',
"महत्" :'JJ',
"महत्तर" :'JJ',
"महत्त्वपूर्ण" :'JJ',
"महत्वपूर्ण" :'JJ',
"महत्वहीन" :'JJ',
"महत्वाकांक्षी" :'JJ',
"महफूज" :'JJ',
"महफूज़" :'JJ',
"महमूद" :'JJ',
"महर" :'JJ',
"महरूम" :'JJ',
"महसूली" :'JJ',
"महसूस" :'JJ',
"महा" :'JJ',
"महाकाय" :'JJ',
"महाचंड" :'JJ',
"महाचण्ड" :'JJ',
"महाजनी" :'JJ',
"महादानी" :'JJ',
"महाद्वीपीय" :'JJ',
"महान" :'JJ',
"महानगरीय" :'JJ',
"महानीच" :'JJ',
"महापातकी" :'JJ',
"महापापी" :'JJ',
"महाबली" :'JJ',
"महाबाहु" :'JJ',
"महाबीर" :'JJ',
"महाभुज" :'JJ',
"महामना" :'JJ',
"महामहिम" :'JJ',
"महामान्य" :'JJ',
"महामूर्ख" :'JJ',
"महाराष्ट्रियन" :'JJ',
"महाराष्ट्री" :'JJ',
"महाराष्ट्रीयन" :'JJ',
"महार्घ" :'JJ',
"महार्थक" :'JJ',
"महाविद्यालयीन" :'JJ',
"महाविद्यालयीय" :'JJ',
"महावीर" :'JJ',
"महाशंख" :'JJ',
"महासागरी" :'JJ',
"महासागरीय" :'JJ',
"महिमावान" :'JJ',
"महिमावान्" :'JJ',
"महीन" :'JJ',
"महीनेवार" :'JJ',
"महुला" :'JJ',
"महोत्सवी" :'JJ',
"महोबिया" :'JJ',
"महोबिहा" :'JJ',
"महोबी" :'JJ',
"माकूल" :'JJ',
"माँगने योग्य" :'JJ',
"मांगने योग्य" :'JJ',
"मांगलिक" :'JJ',
"माँगा" :'JJ',
"माघी" :'JJ',
"माँजा" :'JJ',
"मांजा" :'JJ',
"माँजा हुआ" :'JJ',
"मांजा हुआ" :'JJ',
"माठू" :'JJ',
"माड़दार" :'JJ',
"माँड़दार" :'JJ',
"मातमी" :'JJ',
"मातहत" :'JJ',
"माताविहीन" :'JJ',
"माताहीन" :'JJ',
"मातृक" :'JJ',
"मातृविहीन" :'JJ',
"मातृहीन" :'JJ',
"मात्र" :'JJ',
"मात्र एक" :'JJ',
"मात्रारहित" :'JJ',
"मात्रिक" :'JJ',
"मादक" :'JJ',
"मादन" :'JJ',
"मादनीय" :'JJ',
"मादरजाद" :'JJ',
"मादरी" :'JJ',
"मादा" :'JJ',
"माध्य" :'JJ',
"माध्यम" :'JJ',
"माध्यमिक" :'JJ',
"माननीय" :'JJ',
"माननीया" :'JJ',
"मानरहित" :'JJ',
"मानव कृत" :'JJ',
"मानव चालित" :'JJ',
"मानव निर्मित" :'JJ',
"मानव रचित" :'JJ',
"मानव-कृत" :'JJ',
"मानव-चालित" :'JJ',
"मानव-निर्मित" :'JJ',
"मानवकृत" :'JJ',
"मानवचालित" :'JJ',
"मानवतावादी" :'JJ',
"मानवनिर्मित" :'JJ',
"मानवभक्षक" :'JJ',
"मानवभक्षी" :'JJ',
"मानववादी" :'JJ',
"मानवी" :'JJ',
"मानवीकृत" :'JJ',
"मानवीय" :'JJ',
"मानवोचित" :'JJ',
"मानस" :'JJ',
"मानसिक" :'JJ',
"मानसूनी" :'JJ',
"मानिनी" :'JJ',
"मानिन्द" :'JJ',
"मानुषिक" :'JJ',
"मान्य" :'JJ',
"मान्यताप्राप्त" :'JJ',
"मान्यवर" :'JJ',
"मान्या" :'JJ',
"मापक" :'JJ',
"मापनीय" :'JJ',
"मापा हुआ" :'JJ',
"मापित" :'JJ',
"माफ" :'JJ',
"माफ़" :'JJ',
"माफिक" :'JJ',
"माफिक़" :'JJ',
"माफ़िक" :'JJ',
"मामूजाद" :'JJ',
"मामूर" :'JJ',
"मामूली" :'JJ',
"मायारहित" :'JJ',
"मायावादी" :'JJ',
"मायावी" :'JJ',
"मायाशून्य" :'JJ',
"मायिक" :'JJ',
"मायूर" :'JJ',
"मायूस" :'JJ',
"मारक" :'JJ',
"मारवाड़ी" :'JJ',
"मारा" :'JJ',
"मारा हुआ" :'JJ',
"मारिशस-संबंधी" :'JJ',
"मारिशियन" :'JJ',
"मारीशस-संबंधी" :'JJ',
"मारीशियन" :'JJ',
"मार्क्सवादी" :'JJ',
"मार्गच्युत" :'JJ',
"मार्जित" :'JJ',
"मार्मिक" :'JJ',
"माल वाहक" :'JJ',
"मालदार" :'JJ',
"मालदीवियन" :'JJ',
"मालदीवी" :'JJ',
"मालवाहक" :'JJ',
"मालाबारी" :'JJ',
"मालामाल" :'JJ',
"मालिकाना" :'JJ',
"माली" :'JJ',
"मालूम" :'JJ',
"माल्टाई" :'JJ',
"माँस पेशीय" :'JJ',
"मांस पेशीय" :'JJ',
"माँस-पेशीय" :'JJ',
"मांस-पेशीय" :'JJ',
"मांसखोर" :'JJ',
"मांसख़ोर" :'JJ',
"मासजात" :'JJ',
"माँसपेशीय" :'JJ',
"मांसपेशीय" :'JJ',
"मांसभक्षी" :'JJ',
"मांसरहित" :'JJ',
"मांसल" :'JJ',
"मांसहीन" :'JJ',
"मांसाहारी" :'JJ',
"मासिक" :'JJ',
"मासूम" :'JJ',
"माहवार" :'JJ',
"माहवारी" :'JJ',
"माहिर" :'JJ',
"माहिष" :'JJ',
"मिजाजदार" :'JJ',
"मिजो" :'JJ',
"मिज़ो" :'JJ',
"मिटने वाला" :'JJ',
"मिटनेवाला" :'JJ',
"मिटिया" :'JJ',
"मिट्टी का घोंघा" :'JJ',
"मिट्ठू" :'JJ',
"मिडल" :'JJ',
"मित" :'JJ',
"मितभाषी" :'JJ',
"मितव्ययी" :'JJ',
"मिताहारी" :'JJ',
"मित्रतापूर्ण" :'JJ',
"मित्ररहित" :'JJ',
"मित्रवत" :'JJ',
"मित्रवान" :'JJ',
"मित्रवान्" :'JJ',
"मित्रहीन" :'JJ',
"मिथकीय" :'JJ',
"मिथ्या" :'JJ',
"मिथ्यापूर्ण" :'JJ',
"मिथ्याभाषी" :'JJ',
"मिथ्यारोपित" :'JJ',
"मिथ्यावादी" :'JJ',
"मियादी" :'JJ',
"मिर्चदार" :'JJ',
"मिर्चीला" :'JJ',
"मिलता जुलता" :'JJ',
"मिलता-जुलता" :'JJ',
"मिलनसार" :'JJ',
"मिला" :'JJ',
"मिला जुला" :'JJ',
"मिला हुआ" :'JJ',
"मिला-जुला" :'JJ',
"मिलाजुला" :'JJ',
"मिलावटी" :'JJ',
"मिलित" :'JJ',
"मिलियन" :'JJ',
"मिशनरी" :'JJ',
"मिश्र" :'JJ',
"मिश्रणीय" :'JJ',
"मिश्रित" :'JJ',
"मिष्ट" :'JJ',
"मिष्टप्रिय" :'JJ',
"मिष्ठभाषी" :'JJ',
"मिसकिन" :'JJ',
"मिसकीन" :'JJ',
"मिस्किन" :'JJ',
"मिस्री" :'JJ',
"मीजो" :'JJ',
"मीज़ो" :'JJ',
"मीठबोला" :'JJ',
"मीठा" :'JJ',
"मीठा-मीठा" :'JJ',
"मीनाक्ष" :'JJ',
"मुअत्तल" :'JJ',
"मुआफ़" :'JJ',
"मुआफिक" :'JJ',
"मुआफ़िक़" :'JJ',
"मुकद्दस" :'JJ',
"मुक़द्दस" :'JJ',
"मुकम्मल" :'JJ',
"मुकर्रर" :'JJ',
"मुकव्वी" :'JJ',
"मुकुलित" :'JJ',
"मुक्त" :'JJ',
"मुक्तकंठ" :'JJ',
"मुक्तकर" :'JJ',
"मुक्तहस्त" :'JJ',
"मुखतलिफ" :'JJ',
"मुखतलिफ़" :'JJ',
"मुखर" :'JJ',
"मुखरित" :'JJ',
"मुखवल्लभ" :'JJ',
"मुखस्थ" :'JJ',
"मुखाग्र" :'JJ',
"मुखातिब" :'JJ',
"मुख़ातिब" :'JJ',
"मुखालिफ" :'JJ',
"मुख़ालिफ़" :'JJ',
"मुखिया" :'JJ',
"मुख्तलिफ" :'JJ',
"मुख़्तलिफ़" :'JJ',
"मुख्य" :'JJ',
"मुगल" :'JJ',
"मुग़ल" :'JJ',
"मुगलई" :'JJ',
"मुग़लई" :'JJ',
"मुगलाई" :'JJ',
"मुगलिया" :'JJ',
"मुग़लिया" :'JJ',
"मुगली" :'JJ',
"मुग़ली" :'JJ',
"मुग्ध" :'JJ',
"मुग्धकारी" :'JJ',
"मुग्धमति" :'JJ',
"मुंच" :'JJ',
"मुच्छड़" :'JJ',
"मुच्छल" :'JJ',
"मुच्छैल" :'JJ',
"मुछड़" :'JJ',
"मुछंदर" :'JJ',
"मुछियल" :'JJ',
"मुछैल" :'JJ',
"मुछ्क्कड़" :'JJ',
"मुजरिम" :'JJ',
"मुजल्लद" :'JJ',
"मुट्ठी भर" :'JJ',
"मुट्ठी-भर" :'JJ',
"मुट्ठीभर" :'JJ',
"मुड़नशील" :'JJ',
"मुड़ा" :'JJ',
"मुंडा" :'JJ',
"मुड़ा हुआ" :'JJ',
"मुड़ा-तुड़ा" :'JJ',
"मुंतजिर" :'JJ',
"मुतवफ्फा" :'JJ',
"मुतवफ़्फ़ा" :'JJ',
"मुताबिक" :'JJ',
"मुताबिक़" :'JJ',
"मुताबिक़" :'JJ',
"मुताल्लिक" :'JJ',
"मुताल्लिक़" :'JJ',
"मुत्तफिक" :'JJ',
"मुत्तसिल" :'JJ',
"मुदित" :'JJ',
"मुद्दालह" :'JJ',
"मुद्दालेह" :'JJ',
"मुद्रक" :'JJ',
"मुद्रांकित" :'JJ',
"मुद्रित" :'JJ',
"मुनहसर" :'JJ',
"मुनाफाखोर" :'JJ',
"मुनाफ़ाख़ोर" :'JJ',
"मुनासिब" :'JJ',
"मुफलिस" :'JJ',
"मुफ़लिस" :'JJ',
"मुफीद" :'JJ',
"मुफ़ीद" :'JJ',
"मुफ्त" :'JJ',
"मुफ़्त" :'JJ',
"मुफ्तखोर" :'JJ',
"मुफ़्तखोर" :'JJ',
"मुंबइया" :'JJ',
"मुबारक" :'JJ',
"मुंबैया" :'JJ',
"मुमकिन" :'JJ',
"मुमुक्षु" :'JJ',
"मुमुच्छु" :'JJ',
"मुमूर्ष" :'JJ',
"मुमूर्षु" :'JJ',
"मुम्बइया" :'JJ',
"मुम्बैया" :'JJ',
"मुयस्य" :'JJ',
"मुयस्सर" :'JJ',
"मुरझाया" :'JJ',
"मुरदा" :'JJ',
"मुरदाखोर" :'JJ',
"मुरदाख़ोर" :'JJ',
"मुरदार" :'JJ',
"मुरदारी" :'JJ',
"मुरहा" :'JJ',
"मुरादी" :'JJ',
"मुरीद" :'JJ',
"मुर्दा" :'JJ',
"मुर्दादिल" :'JJ',
"मुलजिम" :'JJ',
"मुलज़िम" :'JJ',
"मुलतवी" :'JJ',
"मुलतानी" :'JJ',
"मुलायम" :'JJ',
"मुल्की" :'JJ',
"मुल्तवी" :'JJ',
"मुवाफिक" :'JJ',
"मुंशी संबंधी" :'JJ',
"मुश्कबू" :'JJ',
"मुश्किल" :'JJ',
"मुश्की" :'JJ',
"मुश्कीं" :'JJ',
"मुश्तबहा" :'JJ',
"मुश्ताक" :'JJ',
"मुश्ताक़" :'JJ',
"मुष्कशून्य" :'JJ',
"मुसम्मा" :'JJ',
"मुसलमानी" :'JJ',
"मुसल्लम" :'JJ',
"मुसाहिब" :'JJ',
"मुस्कराता" :'JJ',
"मुस्कराता हुआ" :'JJ',
"मुस्काता" :'JJ',
"मुस्काता हुआ" :'JJ',
"मुस्कुराता" :'JJ',
"मुस्कुराता हुआ" :'JJ',
"मुस्तनद" :'JJ',
"मुस्तहक" :'JJ',
"मुस्तहक़" :'JJ',
"मुस्तहकम" :'JJ',
"मुस्तैद" :'JJ',
"मुस्तौजिर" :'JJ',
"मुस्लिम" :'JJ',
"मुँह बोला" :'JJ',
"मुँह-छुट" :'JJ',
"मुँह-जबानी" :'JJ',
"मुँह-ज़बानी" :'JJ',
"मुँह-जोर" :'JJ',
"मुँह-ज़ोर" :'JJ',
"मुँह-देखा" :'JJ',
"मुँह-पड़ा" :'JJ',
"मुँह-फट" :'JJ',
"मुँह-बोला" :'JJ',
"मुँहअखरी" :'JJ',
"मुँहचोर" :'JJ',
"मुँहछुट" :'JJ',
"मुँहजबानी" :'JJ',
"मुँहज़बानी" :'JJ',
"मुँहजोर" :'JJ',
"मुँहज़ोर" :'JJ',
"मुहताज" :'JJ',
"मुँहतोड़" :'JJ',
"मुँहपड़ा" :'JJ',
"मुँहफट" :'JJ',
"मुँहबोला" :'JJ',
"मुँहमाँगा" :'JJ',
"मुंहमांगा" :'JJ',
"मुहरबंद" :'JJ',
"मुहरबन्द" :'JJ',
"मुहर्रम" :'JJ',
"मुहाफिज" :'JJ',
"मुहाफ़िज़" :'JJ',
"मुहावरेदार" :'JJ',
"मुहिर" :'JJ',
"मुहैया" :'JJ',
"मुहैय्या" :'JJ',
"मूक" :'JJ',
"मूँगिया" :'JJ',
"मूठदार" :'JJ',
"मूँठदार" :'JJ',
"मूंठदार" :'JJ',
"मूडी" :'JJ',
"मूढ़" :'JJ',
"मूढ़मति" :'JJ',
"मूढ़ाग्रही" :'JJ',
"मूढ़ात्मा" :'JJ',
"मूरख" :'JJ',
"मूर्ख" :'JJ',
"मूर्खतापूर्ण" :'JJ',
"मूर्च्छित" :'JJ',
"मूर्छित" :'JJ',
"मूर्तित" :'JJ',
"मूर्तिमान" :'JJ',
"मूर्तिमान्" :'JJ',
"मूर्तिरहित" :'JJ',
"मूर्द्धन्य" :'JJ',
"मूर्धन्य" :'JJ',
"मूल" :'JJ',
"मूलगत" :'JJ',
"मूलभूत" :'JJ',
"मूल्यवान" :'JJ',
"मूल्यातीत" :'JJ',
"मूष्यायण" :'JJ',
"मूसर" :'JJ',
"मूसरचंद" :'JJ',
"मूसरचन्द" :'JJ',
"मूसलचंद" :'JJ',
"मूसलचन्द" :'JJ',
"मूसलधार" :'JJ',
"मूसलाधार" :'JJ',
"मृत" :'JJ',
"मृतक" :'JJ',
"मृतजात" :'JJ',
"मृतप्राय" :'JJ',
"मृतवत्सा" :'JJ',
"मृत्यु विजेता" :'JJ',
"मृत्युकर" :'JJ',
"मृत्युकारी" :'JJ',
"मृत्युंजयी" :'JJ',
"मृत्युमारक" :'JJ',
"मृत्यूपरांत" :'JJ',
"मृत्यूपरान्त" :'JJ',
"मृदु" :'JJ',
"मृदुभाषी" :'JJ',
"मृदुल" :'JJ',
"मृषा" :'JJ',
"मेकअप किया हुआ" :'JJ',
"मेक्सिकन" :'JJ',
"मेघरहित" :'JJ',
"मेघहीन" :'JJ',
"मेघाच्छन्न" :'JJ',
"मेघाच्छादित" :'JJ',
"मेघालयी" :'JJ',
"मेचक" :'JJ',
"मेजर" :'JJ',
"मेंटल" :'JJ',
"मेडिकल" :'JJ',
"मेदुर" :'JJ',
"मेधावी" :'JJ',
"मेध्य" :'JJ',
"मेन्टल" :'JJ',
"मेरुदंडी" :'JJ',
"मेलपूर्ण" :'JJ',
"मेली" :'JJ',
"मेसीडोनियाई" :'JJ',
"मेहनतकश" :'JJ',
"मेहनती" :'JJ',
"मेहमानदार" :'JJ',
"मेहमाननवाज" :'JJ',
"मेहमाननवाज़" :'JJ',
"मेहरबान" :'JJ',
"मेहराबदार" :'JJ',
"मैकेनिकल" :'JJ',
"मैक्सिकन" :'JJ',
"मैचिंग" :'JJ',
"मैडगास्कन" :'JJ',
"मैडगास्कर-संबंधी" :'JJ',
"मैडगास्करी" :'JJ',
"मैडगैस्कन" :'JJ',
"मैडगैस्कर-संबंधी" :'JJ',
"मैडगैस्करी" :'JJ',
"मैत्रीपूर्ण" :'JJ',
"मैथिल" :'JJ',
"मैथिली" :'JJ',
"मैदानी" :'JJ',
"मैरॉक" :'JJ',
"मैरोक" :'JJ',
"मैलखोरा" :'JJ',
"मैलख़ोरा" :'JJ',
"मैला" :'JJ',
"मैला-कुचैला" :'JJ',
"मैलाकुचैला" :'JJ',
"मैसीडोनियाई" :'JJ',
"मोक्ष इच्छुक" :'JJ',
"मोक्ष प्राप्त" :'JJ',
"मोक्षदायक" :'JJ',
"मोक्षदायिनी" :'JJ',
"मोक्षदायी" :'JJ',
"मोक्षेच्छुक" :'JJ',
"मोटा" :'JJ',
"मोटा तगड़ा" :'JJ',
"मोटा ताजा" :'JJ',
"मोटा ताज़ा" :'JJ',
"मोटा-तगड़ा" :'JJ',
"मोटा-ताजा" :'JJ',
"मोटा-ताज़ा" :'JJ',
"मोड़दार" :'JJ',
"मोड़हीन" :'JJ',
"मोतिया" :'JJ',
"मोथरा" :'JJ',
"मोमना" :'JJ',
"मोमिया" :'JJ',
"मोमी" :'JJ',
"मोरक्कन" :'JJ',
"मोरक्को-संबंधी" :'JJ',
"मोलडोवाई" :'JJ',
"मोल्डोवाई" :'JJ',
"मोहक" :'JJ',
"मोहताज" :'JJ',
"मोहनाशक" :'JJ',
"मोहनी" :'JJ',
"मोहरबंद" :'JJ',
"मोहरबन्द" :'JJ',
"मोहित" :'JJ',
"मोहिनी" :'JJ',
"मौकापरस्त" :'JJ',
"मौखिक" :'JJ',
"मौजी" :'JJ',
"मौजूँ" :'JJ',
"मौजूं" :'JJ',
"मौज़ू" :'JJ',
"मौज़ूँ" :'JJ',
"मौजूद" :'JJ',
"मौजूदा" :'JJ',
"मौज़ूदा" :'JJ',
"मौद्रिक" :'JJ',
"मौन" :'JJ',
"मौनव्रती" :'JJ',
"मौनावलंबी" :'JJ',
"मौनी" :'JJ',
"मौरिटानिआई" :'JJ',
"मौरिटानिया-संबंधी" :'JJ',
"मौरिटानियाई" :'JJ',
"मौरिटैनियन" :'JJ',
"मौरूसी" :'JJ',
"मौलिक" :'JJ',
"मौसमी" :'JJ',
"मौसिया" :'JJ',
"मौसियाउत" :'JJ',
"मौसेरा" :'JJ',
"म्यानमारी" :'JJ',
"म्यूनिसपल" :'JJ',
"म्यूनिसिपल" :'JJ',
"म्लान" :'JJ',
"म्लेच्छ" :'JJ',
"यकीनी" :'JJ',
"यक़ीनी" :'JJ',
"यजुर्वेदी" :'JJ',
"यजुष्य" :'JJ',
"यज्ञीय" :'JJ',
"यतीम" :'JJ',
"यत्नरहित" :'JJ',
"यंत्र चालित" :'JJ',
"यंत्र-संचालित" :'JJ',
"यथाचारी" :'JJ',
"यथार्थ" :'JJ',
"यथार्थवादी" :'JJ',
"यथार्थहीन" :'JJ',
"यथावांछित" :'JJ',
"यथेच्छाचारी" :'JJ',
"यथेष्ट" :'JJ',
"यथोचित" :'JJ',
"यथोचित्" :'JJ',
"यमज" :'JJ',
"यमनी" :'JJ',
"यमल" :'JJ',
"यशस्वी" :'JJ',
"यशी" :'JJ',
"यहूदी" :'JJ',
"याचित" :'JJ',
"याची" :'JJ',
"याजुष" :'JJ',
"याज्ञिक" :'JJ',
"याज्ञिय" :'JJ',
"याज्ञीय" :'JJ',
"यांत्रिक" :'JJ',
"यांत्रिकी" :'JJ',
"यादगार" :'JJ',
"यादव" :'JJ',
"यान आरूढ़" :'JJ',
"यानहीन" :'JJ',
"यानारूढ़" :'JJ',
"यामिनिचर" :'JJ',
"याम्यायन" :'JJ',
"यायावर" :'JJ',
"याराना" :'JJ',
"याल्टोप्याई" :'JJ',
"यावर" :'JJ',
"युक्त" :'JJ',
"युक्तार्थ" :'JJ',
"युक्तिपूर्ण" :'JJ',
"युक्तियुक्त" :'JJ',
"युक्तिहीन" :'JJ',
"युगांडन" :'JJ',
"युगांडाई" :'JJ',
"युगोस्लावियाई" :'JJ',
"युग्मज" :'JJ',
"युज्य" :'JJ',
"युद्ध इच्छुक" :'JJ',
"युद्धक" :'JJ',
"युद्धग्रस्त" :'JJ',
"युद्धवीर" :'JJ',
"युद्धातुर" :'JJ',
"युद्धार्थी" :'JJ',
"युद्धीय" :'JJ',
"युद्धेच्छु" :'JJ',
"युद्धेच्छुक" :'JJ',
"युद्धोन्मत" :'JJ',
"युयुक्षमान" :'JJ',
"युयुत्सु" :'JJ',
"युवन्यु" :'JJ',
"युवपलित" :'JJ',
"युवा" :'JJ',
"यूक्रेनियन" :'JJ',
"यूक्रेनी" :'JJ',
"यूगांडन" :'JJ',
"यूगांडाई" :'JJ',
"यूजर" :'JJ',
"यूनानी" :'JJ',
"यूरेशियाई" :'JJ',
"यूरोपियन" :'JJ',
"यूरोपी" :'JJ',
"यूरोपीय" :'JJ',
"योगी" :'JJ',
"योग्य" :'JJ',
"योजक" :'JJ',
"योजनानुसार" :'JJ',
"योजनाबद्ध" :'JJ',
"योजनीय" :'JJ',
"योजित" :'JJ',
"योज्य" :'JJ',
"योद्धा" :'JJ',
"योध्य" :'JJ',
"योनिज" :'JJ',
"योनीय" :'JJ',
"यौगिक" :'JJ',
"यौन" :'JJ',
"रंक" :'JJ',
"रकीब" :'JJ',
"रक़ीब" :'JJ',
"रक्त-वर्ण" :'JJ',
"रक्तक्षयजन्य" :'JJ',
"रक्तक्षीणताजन्य" :'JJ',
"रक्तप" :'JJ',
"रक्तपायी" :'JJ',
"रक्तरंजित" :'JJ',
"रक्तरञ्जित" :'JJ',
"रक्तरहित" :'JJ',
"रक्तवर्णी" :'JJ',
"रक्तशून्य" :'JJ',
"रक्तस्रावी" :'JJ',
"रक्तहीन" :'JJ',
"रक्ताभ" :'JJ',
"रक्ताल्पताजन्य" :'JJ',
"रक्तिम" :'JJ',
"रक्षक" :'JJ',
"रक्षकरहित" :'JJ',
"रक्षणीय" :'JJ',
"रक्षा कर्ता" :'JJ',
"रक्षात्मक" :'JJ',
"रक्षित" :'JJ',
"रक्षी" :'JJ',
"रक्ष्य" :'JJ',
"रक्ष्यमाण" :'JJ',
"रखेल" :'JJ',
"रखैल" :'JJ',
"रंग परिवर्तनशील" :'JJ',
"रंग परिवर्तनीय" :'JJ',
"रंग परिवर्ती" :'JJ',
"रंग बिरंगा" :'JJ',
"रंग-परिवर्तनशील" :'JJ',
"रंग-परिवर्तनीय" :'JJ',
"रंग-परिवर्ती" :'JJ',
"रंग-बिरंगा" :'JJ',
"रगड़ा" :'JJ',
"रगड़ा हुआ" :'JJ',
"रंगदार" :'JJ',
"रंगबिरंगा" :'JJ',
"रँगराता" :'JJ',
"रंगहीन" :'JJ',
"रंगा" :'JJ',
"रंगा हुआ" :'JJ',
"रंगा-रंग" :'JJ',
"रंगारंग" :'JJ',
"रंगी" :'JJ',
"रंगीन" :'JJ',
"रंगीनमिजाज" :'JJ',
"रंगीनमिज़ाज" :'JJ',
"रँगीला" :'JJ',
"रंगीला" :'JJ',
"रङ्गदार" :'JJ',
"रङ्गहीन" :'JJ',
"रङ्गा-रङ्ग" :'JJ',
"रङ्गारङ्ग" :'JJ',
"रङ्गीन" :'JJ',
"रचनात्मक" :'JJ',
"रचनीय" :'JJ',
"रचित" :'JJ',
"रचेता" :'JJ',
"रजत" :'JJ',
"रजवती" :'JJ',
"रजस्वला" :'JJ',
"रजामंद" :'JJ',
"रज़ामंद" :'JJ',
"रजामन्द" :'JJ',
"रज़ामन्द" :'JJ',
"रंजित" :'JJ',
"रजिस्टर्ड" :'JJ',
"रजिस्ट्रीकृत" :'JJ',
"रंजीदा" :'JJ',
"रजोनिवृत्त" :'JJ',
"रंञ्जित" :'JJ',
"रटने वाला" :'JJ',
"रट्टू" :'JJ',
"रंडीबाज" :'JJ',
"रंडीबाज़" :'JJ',
"रणकामी" :'JJ',
"रणधीर" :'JJ',
"रणनीतिक" :'JJ',
"रणनैतिक" :'JJ',
"रणवीर" :'JJ',
"रत" :'JJ',
"रतनार" :'JJ',
"रतनारा" :'JJ',
"रतौंधिया" :'JJ',
"रतौन्धिया" :'JJ',
"रत्नधर" :'JJ',
"रथ आरूढ़" :'JJ',
"रथविरहित" :'JJ',
"रथहीन" :'JJ',
"रथारूढ़" :'JJ',
"रथारोही" :'JJ',
"रथी" :'JJ',
"रद्द" :'JJ',
"रद्दी" :'JJ',
"रंध्रयुक्त" :'JJ',
"रंध्रहीन" :'JJ',
"रन्ध्रयुक्त" :'JJ',
"रपटीला" :'JJ',
"रफू चक्कर" :'JJ',
"रफ़ू चक्कर" :'JJ',
"रफूचक्कर" :'JJ',
"रफ़ूचक्कर" :'JJ',
"रंभोरु" :'JJ',
"रंभोरू" :'JJ',
"रमण" :'JJ',
"रमणीक" :'JJ',
"रमणीय" :'JJ',
"रमता" :'JJ',
"रमन" :'JJ',
"रम्भोरु" :'JJ',
"रम्भोरू" :'JJ',
"रम्य" :'JJ',
"रवरहित" :'JJ',
"रवांडन" :'JJ',
"रवांडाई" :'JJ',
"रवाण्डाई" :'JJ',
"रवाना" :'JJ',
"रविवारी" :'JJ',
"रशियन" :'JJ',
"रसदार" :'JJ',
"रसपूर्ण" :'JJ',
"रसभरा" :'JJ',
"रसल" :'JJ',
"रसवंत" :'JJ',
"रसवान" :'JJ',
"रसहीन" :'JJ',
"रसात्मक" :'JJ',
"रसापायी" :'JJ',
"रसायनिक" :'JJ',
"रसाल" :'JJ',
"रसिक" :'JJ',
"रसिकमिजाज" :'JJ',
"रसिकमिज़ाज" :'JJ',
"रसिया" :'JJ',
"रसीला" :'JJ',
"रसूखदार" :'JJ',
"रसूख़दार" :'JJ',
"रसेदार" :'JJ',
"रहस्यपूर्ण" :'JJ',
"रहस्यमय" :'JJ',
"रहस्यहीन" :'JJ',
"रहस्यात्मक" :'JJ',
"रहस्योद्घाटक" :'JJ',
"रहाइशी" :'JJ',
"रहायशी" :'JJ',
"रहित" :'JJ',
"राक्षसी" :'JJ',
"राक्षसीय" :'JJ',
"रागरहित" :'JJ',
"रागहीन" :'JJ',
"रागारु" :'JJ',
"रागी" :'JJ',
"राजकीय" :'JJ',
"राजकोशीय" :'JJ',
"राजकोषीय" :'JJ',
"राजत" :'JJ',
"राजद्रोही" :'JJ',
"राजनयिक" :'JJ',
"राजनीति विषयक" :'JJ',
"राजनीतिक" :'JJ',
"राजनैतिक" :'JJ',
"राजपत्रित" :'JJ',
"राजपूती" :'JJ',
"राजयक्ष्मी" :'JJ',
"राजसी" :'JJ',
"राजसूयिक" :'JJ',
"राजस्थानी" :'JJ',
"राजस्थानीय" :'JJ',
"राजहीन" :'JJ',
"राजाऊ" :'JJ',
"राजापुरी" :'JJ',
"राजिस्थानी" :'JJ',
"राजिस्थानीय" :'JJ',
"राजी" :'JJ',
"राज़ी" :'JJ',
"राजीव" :'JJ',
"राजीवलोचन" :'JJ',
"राज्य विषयक" :'JJ',
"राज्यीय" :'JJ',
"राँड" :'JJ',
"राँड़" :'JJ',
"रांड" :'JJ',
"रांड़" :'JJ',
"रात्रिचर" :'JJ',
"राम-बाण" :'JJ',
"राम-बान" :'JJ',
"राम-वाण" :'JJ',
"रामनामी" :'JJ',
"रामबाण" :'JJ',
"रामबान" :'JJ',
"रामवाण" :'JJ',
"रामायणी" :'JJ',
"रारी" :'JJ',
"रावन" :'JJ',
"राशनी" :'JJ',
"राशी" :'JJ',
"राष्ट्र घातक" :'JJ',
"राष्ट्र घाती" :'JJ',
"राष्ट्र निष्कासित" :'JJ',
"राष्ट्र भक्त" :'JJ',
"राष्ट्र विरोधी" :'JJ',
"राष्ट्र-निष्काषित" :'JJ',
"राष्ट्र-भक्त" :'JJ',
"राष्ट्र-विरोधी" :'JJ',
"राष्ट्रघातक" :'JJ',
"राष्ट्रघाती" :'JJ',
"राष्ट्रद्रोही" :'JJ',
"राष्ट्रभक्त" :'JJ',
"राष्ट्रविरोधी" :'JJ',
"राष्ट्रव्यापी" :'JJ',
"राष्ट्रिक" :'JJ',
"राष्ट्रीय" :'JJ',
"रास" :'JJ',
"रासायनिक" :'JJ',
"रास्तबाज" :'JJ',
"रास्तबाज़" :'JJ',
"रिआयती" :'JJ',
"रिकार्ड किया" :'JJ',
"रिकार्डतोड़" :'JJ',
"रिकार्डर" :'JJ',
"रिकॉर्ड किया" :'JJ',
"रिकॉर्डतोड़" :'JJ',
"रिकॉर्डर" :'JJ',
"रिक्त" :'JJ',
"रिच" :'JJ',
"रिजर्व्ड" :'JJ',
"रिज़र्व्ड" :'JJ',
"रिजु" :'JJ',
"रिटायर" :'JJ',
"रिटायर्ड" :'JJ',
"रिटेल" :'JJ',
"रिता" :'JJ',
"रिपुदमन" :'JJ',
"रिपुसूदन" :'JJ',
"रिफ्यूजी" :'JJ',
"रिफ्लेक्टिड" :'JJ',
"रिफ्लेक्टेड" :'JJ',
"रिम-झिम" :'JJ',
"रिमझिम" :'JJ',
"रियल" :'JJ',
"रियायती" :'JJ',
"रियासती" :'JJ',
"रिरिहा" :'JJ',
"रिश्वतखोर" :'JJ',
"रिश्वतख़ोर" :'JJ',
"रिश्वती" :'JJ',
"रिसाऊ" :'JJ',
"रिस्की" :'JJ',
"रिहाइशी" :'JJ',
"रिहायशी" :'JJ',
"रीटेल" :'JJ',
"रीता" :'JJ',
"रुआबदार" :'JJ',
"रुआँसा" :'JJ',
"रुआंसा" :'JJ',
"रुईदार" :'JJ',
"रुका" :'JJ',
"रुका हुआ" :'JJ',
"रुक्ष" :'JJ',
"रुखसत" :'JJ',
"रुख़सत" :'JJ',
"रुख्सत" :'JJ',
"रुख़्सत" :'JJ',
"रुग्ण" :'JJ',
"रुचिकर" :'JJ',
"रुचिकारक" :'JJ',
"रुचिकारी" :'JJ',
"रुचिर" :'JJ',
"रुचिहीन" :'JJ',
"रुजी" :'JJ',
"रुंडित" :'JJ',
"रुण्डित" :'JJ',
"रुतबेदार" :'JJ',
"रुदनशील" :'JJ',
"रुद्ध" :'JJ',
"रुद्र" :'JJ',
"रुँधा" :'JJ',
"रुधिरहीन" :'JJ',
"रुपये-पैसे का" :'JJ',
"रुपहरा" :'JJ',
"रुपहला" :'JJ',
"रुपौला" :'JJ',
"रुमानी" :'JJ',
"रुवाबदार" :'JJ',
"रुष्ट" :'JJ',
"रुष्टा" :'JJ',
"रुसवा" :'JJ',
"रुसी" :'JJ',
"रुसूखदार" :'JJ',
"रुसूख़दार" :'JJ',
"रूईदार" :'JJ',
"रूख" :'JJ',
"रूखड़ा" :'JJ',
"रूखरा" :'JJ',
"रूखा" :'JJ',
"रूखा सूखा" :'JJ',
"रूखा-सूखा" :'JJ',
"रूखासूखा" :'JJ',
"रूठा" :'JJ',
"रूढ़" :'JJ',
"रूढ़िवादी" :'JJ',
"रूप अभिमानिनी" :'JJ',
"रूपक अलंकार रहित" :'JJ',
"रूपक अलंकार-रहित" :'JJ',
"रूपगर्विता" :'JJ',
"रूपमनी" :'JJ',
"रूपमय" :'JJ',
"रूपमयी" :'JJ',
"रूपमान" :'JJ',
"रूपवंत" :'JJ',
"रूपवती" :'JJ',
"रूपवन्त" :'JJ',
"रूपवान" :'JJ',
"रूपसी" :'JJ',
"रूपस्थ" :'JJ',
"रूपांतरित" :'JJ',
"रूपान्तरित" :'JJ',
"रूपित" :'JJ',
"रूपोश" :'JJ',
"रूम वासी" :'JJ',
"रूम-वासी" :'JJ',
"रूमवासी" :'JJ',
"रूमानियन" :'JJ',
"रूमानियाई" :'JJ',
"रूमानी" :'JJ',
"रूमी" :'JJ',
"रूसी" :'JJ',
"रूहानी" :'JJ',
"रेकार्ड किया" :'JJ',
"रेकार्डर" :'JJ',
"रेकॉर्ड किया" :'JJ',
"रेकॉर्डर" :'JJ',
"रेखता" :'JJ',
"रेखांकित" :'JJ',
"रेखागणितीय" :'JJ',
"रेंगनेवाला" :'JJ',
"रेगिस्तानी" :'JJ',
"रेगुलर" :'JJ',
"रेग्युलर" :'JJ',
"रेग्यूलर" :'JJ',
"रेचक" :'JJ',
"रेजिस्टर्ड" :'JJ',
"रेडिमेड" :'JJ',
"रेडियोएक्टिव" :'JJ',
"रेडियोधर्मी" :'JJ',
"रेडियोसक्रिय" :'JJ',
"रेडीमेड" :'JJ',
"रेतीला" :'JJ',
"रेतोधा" :'JJ',
"रेप" :'JJ',
"रेफ" :'JJ',
"रेशमी" :'JJ',
"रेशमीं" :'JJ',
"रेशायुक्त" :'JJ',
"रेशेदार" :'JJ',
"रेहुआ" :'JJ',
"रैतिक" :'JJ',
"रैदासी" :'JJ',
"रैनचर" :'JJ',
"रोआँसा" :'JJ',
"रोआंसा" :'JJ',
"रोएँदार" :'JJ',
"रोकनेवाला" :'JJ',
"रोगकारक" :'JJ',
"रोगकारी" :'JJ',
"रोगग्रस्त" :'JJ',
"रोगजनक" :'JJ',
"रोगजन्य" :'JJ',
"रोगनदार" :'JJ',
"रोग़नदार" :'JJ',
"रोगनी" :'JJ',
"रोगमुक्त" :'JJ',
"रोगरहित" :'JJ',
"रोगशून्य" :'JJ',
"रोगहीन" :'JJ',
"रोगाणुनाशक" :'JJ',
"रोगी" :'JJ',
"रोचक" :'JJ',
"रोचन" :'JJ',
"रोजीदार" :'JJ',
"रोज़ीदार" :'JJ',
"रोटिया" :'JJ',
"रोटिहा" :'JJ',
"रोता" :'JJ',
"रोता हुआ" :'JJ',
"रोंदू" :'JJ',
"रोधक" :'JJ',
"रोधात्मक" :'JJ',
"रोधी" :'JJ',
"रोनहा" :'JJ',
"रोनी" :'JJ',
"रोपक" :'JJ',
"रोपणीय" :'JJ',
"रोपनीय" :'JJ',
"रोपने योग्य" :'JJ',
"रोपा हुआ" :'JJ',
"रोप्य" :'JJ',
"रोबदार" :'JJ',
"रोबीला" :'JJ',
"रोमंथक" :'JJ',
"रोमंथी" :'JJ',
"रोमन" :'JJ',
"रोमन्थक" :'JJ',
"रोमन्थी" :'JJ',
"रोमल" :'JJ',
"रोमश" :'JJ',
"रोमहर्षित" :'JJ',
"रोमांचक" :'JJ',
"रोमांचकारी" :'JJ',
"रोमांचित" :'JJ',
"रोमानियन" :'JJ',
"रोमानियाई" :'JJ',
"रोमिल" :'JJ',
"रोमी" :'JJ',
"रोमीय" :'JJ',
"रोयेंदार" :'JJ',
"रोवना" :'JJ',
"रोवनिया" :'JJ',
"रोवासा" :'JJ',
"रोशन" :'JJ',
"रोहित" :'JJ',
"रोही" :'JJ',
"रौद्र" :'JJ',
"रौबदार" :'JJ',
"रौरव" :'JJ',
"लक-दक" :'JJ',
"लकड़ी का" :'JJ',
"लकदक" :'JJ',
"लकारांत" :'JJ',
"लकारान्त" :'JJ',
"लक्ष" :'JJ',
"लक्षणरहित" :'JJ',
"लक्षणीय" :'JJ',
"लक्षपति" :'JJ',
"लक्षवाँ" :'JJ',
"लक्षवेधी" :'JJ',
"लक्षित" :'JJ',
"लक्ष्मीक" :'JJ',
"लक्ष्य" :'JJ',
"लक्ष्य च्युत" :'JJ',
"लक्ष्य विमुख" :'JJ',
"लक्ष्यभेदी" :'JJ',
"लक्ष्यवेधक" :'JJ',
"लक्ष्यवेधी" :'JJ',
"लक्ष्यानुगामी" :'JJ',
"लक्समबर्गी" :'JJ',
"लक्समबोर्गी" :'JJ',
"लक्सेमबोर्गी" :'JJ',
"लख-पेड़ा" :'JJ',
"लखटकिया" :'JJ',
"लखपति" :'JJ',
"लखपती" :'JJ',
"लखपेड़ा" :'JJ',
"लखलुटा" :'JJ',
"लँगड़" :'JJ',
"लँगड़ा" :'JJ',
"लंगड़ा" :'JJ',
"लँगड़ा-लूला" :'JJ',
"लगभग आधा" :'JJ',
"लंगर" :'JJ',
"लगा लिपटा" :'JJ',
"लगा हुआ" :'JJ',
"लगा-लिपटा" :'JJ',
"लगातार" :'JJ',
"लगाया हुआ" :'JJ',
"लगुआ" :'JJ',
"लग्जरी" :'JJ',
"लग्ज़री" :'JJ',
"लंघक" :'JJ',
"लंघनीय" :'JJ',
"लघु" :'JJ',
"लघु पाक" :'JJ',
"लघुकाय" :'JJ',
"लघुप्रयत्न" :'JJ',
"लघुमति" :'JJ',
"लङ्घक" :'JJ',
"लङ्घनीय" :'JJ',
"लचकदार" :'JJ',
"लचकीला" :'JJ',
"लचकौंहाँ" :'JJ',
"लचर" :'JJ',
"लचीला" :'JJ',
"लच्छेदार" :'JJ',
"लजाऊ" :'JJ',
"लजाधुर" :'JJ',
"लजालू" :'JJ',
"लजीज" :'JJ',
"लज़ीज" :'JJ',
"लज़ीज़" :'JJ',
"लजीला" :'JJ',
"लज्जतदार" :'JJ',
"लज़्ज़तदार" :'JJ',
"लज़्ज़तपसंद" :'JJ',
"लज्जाकर" :'JJ',
"लज्जाजनक" :'JJ',
"लज्जाप्रद" :'JJ',
"लज्जालु" :'JJ',
"लज्जावान" :'JJ',
"लज्जाशील" :'JJ',
"लज्जाहीन" :'JJ',
"लज्जित" :'JJ',
"लटपटा" :'JJ',
"लटपटाता" :'JJ',
"लटपटाता हुआ" :'JJ',
"लटीनो" :'JJ',
"लट्ठमार" :'JJ',
"लंठ" :'JJ',
"लठमार" :'JJ',
"लठैत" :'JJ',
"लड़कोरी" :'JJ',
"लड़कौरी" :'JJ',
"लड़खड़ाता" :'JJ',
"लड़खड़ाता हुआ" :'JJ',
"लड़ाका" :'JJ',
"लड़ाकी" :'JJ',
"लड़ाकू" :'JJ',
"लँडूरा" :'JJ',
"लतखोर" :'JJ',
"लतखोरा" :'JJ',
"लतहा" :'JJ',
"लतियर" :'JJ',
"लतियल" :'JJ',
"लतिहर" :'JJ',
"लतिहल" :'JJ',
"लतीफ़" :'JJ',
"लथ-पथ" :'JJ',
"लथपथ" :'JJ',
"लंद-फंद" :'JJ',
"लदा" :'JJ',
"लदा हुआ" :'JJ',
"लदुआ" :'JJ',
"लंपट" :'JJ',
"लपेटा" :'JJ',
"लपेटा हुआ" :'JJ',
"लफंगा" :'JJ',
"लंब" :'JJ',
"लंब-तड़ंग" :'JJ',
"लंबतड़ंग" :'JJ',
"लबरा" :'JJ',
"लंबवत" :'JJ',
"लंबवत्" :'JJ',
"लंबा" :'JJ',
"लंबा चौड़ा" :'JJ',
"लंबा-चौड़ा" :'JJ',
"लबार" :'JJ',
"लबालब" :'JJ',
"लंबित" :'JJ',
"लंबोतरा" :'JJ',
"लब्ध" :'JJ',
"लब्धनाम" :'JJ',
"लम-गोड़ा" :'JJ',
"लमगोड़ा" :'JJ',
"लमटंगा" :'JJ',
"लम्पट" :'JJ',
"लम्ब" :'JJ',
"लम्ब-तड़ंग" :'JJ',
"लम्बतड़ंग" :'JJ',
"लम्बवत" :'JJ',
"लम्बवत्" :'JJ',
"लम्बा" :'JJ',
"लम्बा-चौड़ा" :'JJ',
"लम्बित" :'JJ',
"लम्बोतरा" :'JJ',
"ललकित" :'JJ',
"ललचाई" :'JJ',
"ललचौंहा" :'JJ',
"ललछौंह" :'JJ',
"ललछौंहा" :'JJ',
"ललाम" :'JJ',
"ललित" :'JJ',
"ललितलोचन" :'JJ',
"ललिया" :'JJ',
"ललौहाँ" :'JJ',
"ललौंहाँ" :'JJ',
"लवणयुक्त" :'JJ',
"लवणरहित" :'JJ',
"लवणीय" :'JJ',
"लश्करी" :'JJ',
"लसदार" :'JJ',
"लसलसा" :'JJ',
"लसिकाभ" :'JJ',
"लसीकाभ" :'JJ',
"लसीला" :'JJ',
"लहरदार" :'JJ',
"लहराता" :'JJ',
"लहरिएदार" :'JJ',
"लहरित" :'JJ',
"लहरियेदार" :'JJ',
"लहू-लुहान" :'JJ',
"लहूलुहान" :'JJ',
"ला-वल्द" :'JJ',
"ला-वारिस" :'JJ',
"लाइलाज" :'JJ',
"लाइव" :'JJ',
"लाइसेन्सरहित" :'JJ',
"लाइसेन्सी" :'JJ',
"लाइसेंसरहित" :'JJ',
"लाइसेंसी" :'JJ',
"लाओ" :'JJ',
"लाओशियन" :'JJ',
"लाक्षणिक" :'JJ',
"लाख" :'JJ',
"लाखवाँ" :'JJ',
"लाखों" :'JJ',
"लागना" :'JJ',
"लागू" :'JJ',
"लाचार" :'JJ',
"लांछित" :'JJ',
"लाजमी" :'JJ',
"लाज़मी" :'JJ',
"लाजवर्दी" :'JJ',
"लाजवाब" :'JJ',
"लाजिम" :'JJ',
"लाज़िम" :'JJ',
"लाजिमी" :'JJ',
"लाज़िमी" :'JJ',
"लाटीनो" :'JJ',
"लाड़ला" :'JJ',
"लातविआई" :'JJ',
"लातवियन" :'JJ',
"लातवियाई" :'JJ',
"लातिन" :'JJ',
"लातिनी" :'JJ',
"लातीनी" :'JJ',
"लापता" :'JJ',
"लापरवाह" :'JJ',
"लाभ प्राप्तकर्ता" :'JJ',
"लाभकर" :'JJ',
"लाभकारी" :'JJ',
"लाभजनक" :'JJ',
"लाभदायक" :'JJ',
"लाभप्रद" :'JJ',
"लाभहीन" :'JJ',
"लाभान्वित" :'JJ',
"लाभांवित" :'JJ',
"लायक" :'JJ',
"लायक़" :'JJ',
"लाया" :'JJ',
"लाया हुआ" :'JJ',
"लाल" :'JJ',
"लाल कटसरैया जैसा" :'JJ',
"लाल कटसरैया वाला" :'JJ',
"लाल कटसरैयाई" :'JJ',
"लाल जैसा" :'JJ',
"लाल-सा" :'JJ',
"लालक" :'JJ',
"लालचहीन" :'JJ',
"लालची" :'JJ',
"लालसारहित" :'JJ',
"लालसी" :'JJ',
"लालायित" :'JJ',
"लालिमा लिए हुए भूरा" :'JJ',
"लालीयुक्त" :'JJ',
"लावण्यमय" :'JJ',
"लावण्यमयी" :'JJ',
"लावण्यवती" :'JJ',
"लावारिस" :'JJ',
"लासानी" :'JJ',
"लिखा" :'JJ',
"लिखा हुआ" :'JJ',
"लिखित" :'JJ',
"लिंगरहित" :'JJ',
"लिंगीय" :'JJ',
"लिङ्गरहित" :'JJ',
"लिडार" :'JJ',
"लिथुआनियाई" :'JJ',
"लिथुएनियाई" :'JJ',
"लिथुनिआई" :'JJ',
"लिथुनियाई" :'JJ',
"लिथूएनियाई" :'JJ',
"लिपटा" :'JJ',
"लिपिबद्ध" :'JJ',
"लिप्त" :'JJ',
"लिप्तक" :'JJ',
"लिप्सु" :'JJ',
"लिमिटेड" :'JJ',
"लिलोही" :'JJ',
"लिष्व" :'JJ',
"लीन" :'JJ',
"लीबियन" :'JJ',
"लीबियाई" :'JJ',
"लीबेरिआ-संबंधी" :'JJ',
"लीबेरिआई" :'JJ',
"लीबेरियन" :'JJ',
"लीबेरिया-संबंधी" :'JJ',
"लीबेरियाई" :'JJ',
"लीलावती" :'JJ',
"लुख्खा" :'JJ',
"लुगरा" :'JJ',
"लुच्चा" :'JJ',
"लुंज" :'JJ',
"लुजा" :'JJ',
"लुटा" :'JJ',
"लुंटाक" :'JJ',
"लुंडा" :'JJ',
"लुण्टाक" :'JJ',
"लुण्डा" :'JJ',
"लुतरा" :'JJ',
"लुप्त" :'JJ',
"लुप्तप्राय" :'JJ',
"लुब्ध" :'JJ',
"लुभावन" :'JJ',
"लुभावना" :'JJ',
"लूटा" :'JJ',
"लूटा हुआ" :'JJ',
"लूला" :'JJ',
"लूला-लँगड़ा" :'JJ',
"लेखन-संबंधी" :'JJ',
"लेखन-सम्बन्धी" :'JJ',
"लेखनीय" :'JJ',
"लेखांकित" :'JJ',
"लेखाकृत" :'JJ',
"लेख्य" :'JJ',
"लेट" :'JJ',
"लेट लतीफ़" :'JJ',
"लेटा" :'JJ',
"लेटिन" :'JJ',
"लेटेस्ट" :'JJ',
"लेनहार" :'JJ',
"लेनिहार" :'JJ',
"लेपित" :'JJ',
"लेबनानी" :'JJ',
"लेबनीज़" :'JJ',
"लेबनीस" :'JJ',
"लेबरा" :'JJ',
"लेबल वाला" :'JJ',
"लेबलवाला" :'JJ',
"लेश" :'JJ',
"लेसदार" :'JJ',
"लेसोथी" :'JJ',
"लेसोथो-संबंधी" :'JJ',
"लैंग" :'JJ',
"लैंगिक" :'JJ',
"लैटिन" :'JJ',
"लैस" :'JJ',
"लोक" :'JJ',
"लोक प्रसिद्ध" :'JJ',
"लोक मोहन" :'JJ',
"लोक लुभावन" :'JJ',
"लोक सम्मत" :'JJ',
"लोक हितैषी" :'JJ',
"लोक-मोहन" :'JJ',
"लोक-लुभावन" :'JJ',
"लोकतंत्रात्मक" :'JJ',
"लोकतंत्री" :'JJ',
"लोकतंत्रीय" :'JJ',
"लोकतन्त्रात्मक" :'JJ',
"लोकतन्त्री" :'JJ',
"लोकतन्त्रीय" :'JJ',
"लोकतांत्रिक" :'JJ',
"लोकतान्त्रिक" :'JJ',
"लोकप्रधान" :'JJ',
"लोकप्रिय" :'JJ',
"लोकल" :'JJ',
"लोकलुभावन" :'JJ',
"लोकातीत" :'JJ',
"लोकित" :'JJ',
"लोकोत्तर" :'JJ',
"लोकोपकारी" :'JJ',
"लोकोपयोगी" :'JJ',
"लोचदार" :'JJ',
"लोचनातीत" :'JJ',
"लोटा हुआ" :'JJ',
"लोनिया" :'JJ',
"लोपोन्मुख" :'JJ',
"लोभरहित" :'JJ',
"लोभहीन" :'JJ',
"लोभित" :'JJ',
"लोभी" :'JJ',
"लोमश" :'JJ',
"लोमहर्षक" :'JJ',
"लोलुप" :'JJ',
"लोह" :'JJ',
"लोहित" :'JJ',
"लोहिया" :'JJ',
"लौकिक" :'JJ',
"लौटाया" :'JJ',
"लौह" :'JJ',
"वंक" :'JJ',
"वक़्त का पाबंद" :'JJ',
"वक्तव्य" :'JJ',
"वक्ता" :'JJ',
"वक्त्रभेदी" :'JJ',
"वक्र" :'JJ',
"वक्रगामी" :'JJ',
"वक्रनक्र" :'JJ',
"वक्रपाद" :'JJ',
"वक्रहीन" :'JJ',
"वक्रांग" :'JJ',
"वचनकारी" :'JJ',
"वचनबद्ध" :'JJ',
"वचस्कर" :'JJ',
"वचस्य" :'JJ',
"वंचित" :'JJ',
"वजनदार" :'JJ',
"वजनी" :'JJ',
"वज़नी" :'JJ',
"वज्र" :'JJ',
"वज्र मूर्ख" :'JJ',
"वज्रधी" :'JJ',
"वत्सकाम" :'JJ',
"वत्सल" :'JJ',
"वंदनीय" :'JJ',
"वदन्य" :'JJ',
"वदान्य" :'JJ',
"वंदित" :'JJ',
"वंद्य" :'JJ',
"वधित" :'JJ',
"वध्य" :'JJ',
"वंध्या" :'JJ',
"वध्रि" :'JJ',
"वन स्टार" :'JJ',
"वनजात" :'JJ',
"वनडे" :'JJ',
"वनवासी" :'JJ',
"वनस्पतिहीन" :'JJ',
"वनस्पतीय" :'JJ',
"वनित" :'JJ',
"वनिन" :'JJ',
"वनीय" :'JJ',
"वनौकस" :'JJ',
"वन्दनीय" :'JJ',
"वन्दनीया" :'JJ',
"वन्दित" :'JJ',
"वन्द्य" :'JJ',
"वन्ध्या" :'JJ',
"वन्य" :'JJ',
"वन्यतापूर्ण" :'JJ',
"वपनीय" :'JJ',
"वपित" :'JJ',
"वप्ता" :'JJ',
"वफादार" :'JJ',
"वफ़ादार" :'JJ',
"वफापरस्त" :'JJ',
"वफ़ापरस्त" :'JJ',
"वयस्क" :'JJ',
"वयोधा" :'JJ',
"वयोवृद्ध" :'JJ',
"वरद" :'JJ',
"वरदाता" :'JJ',
"वरदायक" :'JJ',
"वरदीधारी" :'JJ',
"वरली" :'JJ',
"वराक" :'JJ',
"वरानन" :'JJ',
"वरानना" :'JJ',
"वरित" :'JJ',
"वरिष्ठ" :'JJ',
"वरेण्य" :'JJ',
"वर्किंग" :'JJ',
"वर्गरहित" :'JJ',
"वर्गहीन" :'JJ',
"वर्गाकार" :'JJ',
"वर्गीकृत" :'JJ',
"वर्गीय" :'JJ',
"वर्जनीय" :'JJ',
"वर्जित" :'JJ',
"वर्ज्य" :'JJ',
"वर्ण संकर" :'JJ',
"वर्ण-धर्मरहित" :'JJ',
"वर्णनातीत" :'JJ',
"वर्णनात्मक" :'JJ',
"वर्णनीय" :'JJ',
"वर्णवाला" :'JJ',
"वर्णशून्य" :'JJ',
"वर्णहीन" :'JJ',
"वर्णात्मक" :'JJ',
"वर्णांध" :'JJ',
"वर्णांधता से पीड़ित" :'JJ',
"वर्णिक" :'JJ',
"वर्णित" :'JJ',
"वर्णी" :'JJ',
"वर्णीय" :'JJ',
"वर्ण्य" :'JJ',
"वर्तमान" :'JJ',
"वर्तमान कालीन" :'JJ',
"वर्तुल" :'JJ',
"वर्तुलाकार" :'JJ',
"वर्दीधारी" :'JJ',
"वर्द्धक" :'JJ',
"वर्द्धनीय" :'JJ',
"वर्द्धयिता" :'JJ',
"वर्द्धित" :'JJ',
"वर्द्धिष्णु" :'JJ',
"वर्धक" :'JJ',
"वर्धनीय" :'JJ',
"वर्धयिता" :'JJ',
"वर्धित" :'JJ',
"वर्धिष्णु" :'JJ',
"वर्ली" :'JJ',
"वर्ल्ड" :'JJ',
"वर्षा कालीन" :'JJ',
"वर्षाकालीन" :'JJ',
"वर्षीय" :'JJ',
"वर्हाड़ी" :'JJ',
"वल्कलसंवीत" :'JJ',
"वल्कली" :'JJ',
"वश से परे" :'JJ',
"वंशमय" :'JJ',
"वंशहीन" :'JJ',
"वंशागत" :'JJ',
"वंशानुक्रमिक" :'JJ',
"वशीकरण" :'JJ',
"वशीकृत" :'JJ',
"वशीभूत" :'JJ',
"वंशीय" :'JJ',
"वंशोद्भव" :'JJ',
"वश्य" :'JJ',
"वसंतकालीन" :'JJ',
"वसंती" :'JJ',
"वसामुक्त" :'JJ',
"वसायुक्त" :'JJ',
"वसाहीन" :'JJ',
"वसीम" :'JJ',
"वसूल" :'JJ',
"वस्तुनिष्ठ" :'JJ',
"वस्त्र-धारी" :'JJ',
"वस्त्रधारी" :'JJ',
"वस्त्रहीन" :'JJ',
"वस्त्राभूषित" :'JJ',
"वहनीय" :'JJ',
"वहशी" :'JJ',
"वहित" :'JJ',
"वहीद" :'JJ',
"वाइड" :'JJ',
"वाइरसरोधी" :'JJ',
"वाकिफ" :'JJ',
"वाक़िफ़" :'JJ',
"वाक् चपल" :'JJ',
"वाक्चपल" :'JJ',
"वाक्पटु" :'JJ',
"वाग्दत्त" :'JJ',
"वाचक" :'JJ',
"वाचनीय" :'JJ',
"वाचारुद्ध" :'JJ',
"वाचाल" :'JJ',
"वाचिक" :'JJ',
"वाची" :'JJ',
"वाच्य" :'JJ',
"वांछनीय" :'JJ',
"वाँछित" :'JJ',
"वांछित" :'JJ',
"वाजह" :'JJ',
"वाज़ह" :'JJ',
"वाजिब" :'JJ',
"वाज़िब" :'JJ',
"वाणिज्यिक" :'JJ',
"वात-शून्य" :'JJ',
"वातकारक" :'JJ',
"वातरहित" :'JJ',
"वातल" :'JJ',
"वातवर्धक" :'JJ',
"वातशून्य" :'JJ',
"वातानुकूलक" :'JJ',
"वातानुकूलित" :'JJ',
"वातावरणीय" :'JJ',
"वादक" :'JJ',
"वादग्रस्त" :'JJ',
"वादा किया हुआ" :'JJ',
"वादातीत" :'JJ',
"वादिक" :'JJ',
"वादित" :'JJ',
"वादी" :'JJ',
"वानप्रस्थाश्रमी" :'JJ',
"वानप्रस्थी" :'JJ',
"वानरी" :'JJ',
"वानस्पतिक" :'JJ',
"वापक" :'JJ',
"वापसी" :'JJ',
"वापित" :'JJ',
"वाम" :'JJ',
"वामन" :'JJ',
"वामनयन" :'JJ',
"वामल" :'JJ',
"वामावर्त" :'JJ',
"वामावर्ती" :'JJ',
"वामेतर" :'JJ',
"वायरल" :'JJ',
"वायरलेस" :'JJ',
"वायरसरोधी" :'JJ',
"वायव" :'JJ',
"वायविक" :'JJ',
"वायवीय" :'JJ',
"वायव्य" :'JJ',
"वायुकारक" :'JJ',
"वायुगतिकीय" :'JJ',
"वायुमंडलीय" :'JJ',
"वायुमण्डलीय" :'JJ',
"वायुरहित" :'JJ',
"वायुवर्धक" :'JJ',
"वारली" :'JJ',
"वारिज" :'JJ',
"वारिजात" :'JJ',
"वारित" :'JJ',
"वार्णिक" :'JJ',
"वार्ली" :'JJ',
"वार्षिक" :'JJ',
"वाष्पशील" :'JJ',
"वासंतक" :'JJ',
"वासंतिक" :'JJ',
"वासंती" :'JJ',
"वासनाहीन" :'JJ',
"वासन्तक" :'JJ',
"वासन्तिक" :'JJ',
"वासयुक्त" :'JJ',
"वासहीन" :'JJ',
"वास्तव" :'JJ',
"वास्तविक" :'JJ',
"वास्तुशिल्पीय" :'JJ',
"वाहक" :'JJ',
"वाहनहीन" :'JJ',
"वाहनीय" :'JJ',
"वाहियात" :'JJ',
"वाही" :'JJ',
"विकट" :'JJ',
"विकराल" :'JJ',
"विकल" :'JJ',
"विकलांग" :'JJ',
"विकलांग विज्ञान संबंधी" :'JJ',
"विकल्पयुक्त" :'JJ',
"विकल्पहीन" :'JJ',
"विकल्पी" :'JJ',
"विकसित" :'JJ',
"विकार रहित" :'JJ',
"विकार-रहित" :'JJ',
"विकारग्रस्त" :'JJ',
"विकारयुक्त" :'JJ',
"विकारशून्य" :'JJ',
"विकारहीन" :'JJ',
"विकारी" :'JJ',
"विकासपरक" :'JJ',
"विकासशील" :'JJ',
"विकासात्मक" :'JJ',
"विकीर्ण" :'JJ',
"विकृत" :'JJ',
"विकेश" :'JJ',
"विक्टोरियन" :'JJ',
"विक्टोरिया कालीन" :'JJ',
"विक्रमी" :'JJ',
"विक्रयार्थ" :'JJ',
"विक्रांत" :'JJ',
"विक्रान्त" :'JJ',
"विक्रीत" :'JJ',
"विक्रेय" :'JJ',
"विक्षिप्त" :'JJ',
"विखंडित" :'JJ',
"विखंडी" :'JJ',
"विखण्डी" :'JJ',
"विख्यात" :'JJ',
"विगत" :'JJ',
"विघ्न संतोषी" :'JJ',
"विघ्न-कर्ता" :'JJ',
"विघ्न-कर्त्ता" :'JJ',
"विघ्न-संतोषी" :'JJ',
"विघ्नकर्ता" :'JJ',
"विघ्नकर्त्ता" :'JJ',
"विघ्नकारी" :'JJ',
"विघ्नसंतोषी" :'JJ',
"विचक्षण" :'JJ',
"विचक्षु" :'JJ',
"विचल" :'JJ',
"विचलित" :'JJ',
"विचार विषयक" :'JJ',
"विचारणीय" :'JJ',
"विचारपूर्ण" :'JJ',
"विचारवान" :'JJ',
"विचारवान्" :'JJ',
"विचारशील" :'JJ',
"विचारशून्य" :'JJ',
"विचारहीन" :'JJ',
"विचारात्मक" :'JJ',
"विचाराधीन" :'JJ',
"विचारित" :'JJ',
"विचार्य" :'JJ',
"विचिंतित" :'JJ',
"विचित्र" :'JJ',
"विचिन्तित" :'JJ',
"विचेतन" :'JJ',
"विच्छिन्न" :'JJ',
"विजन" :'JJ',
"विजयाभिलाषी" :'JJ',
"विजयी" :'JJ',
"विजात" :'JJ',
"विजाति" :'JJ',
"विजातीय" :'JJ',
"विजिगीषु" :'JJ',
"विजित" :'JJ',
"विजेता" :'JJ',
"विज्ञ" :'JJ',
"विज्ञप्त" :'JJ',
"विज्ञात" :'JJ',
"विज्ञाता" :'JJ',
"विज्ञापित" :'JJ',
"विटपक" :'JJ',
"वितंडावादी" :'JJ',
"वितरित" :'JJ',
"वितान" :'JJ',
"वित्तीय" :'JJ',
"विदारक" :'JJ',
"विदारित" :'JJ',
"विदित" :'JJ',
"विदीर्ण" :'JJ',
"विदुषी" :'JJ',
"विदेशी" :'JJ',
"विदेह" :'JJ',
"विद्ध" :'JJ',
"विद्यमान" :'JJ',
"विद्यालयी" :'JJ',
"विद्यालयीन" :'JJ',
"विद्यालयीय" :'JJ',
"विद्युत चुंबकीय" :'JJ',
"विद्युत चुम्बकीय" :'JJ',
"विद्युत-चुंबकीय" :'JJ',
"विद्युत-चुम्बकीय" :'JJ',
"विद्युतचुंबकीय" :'JJ',
"विद्युतचुम्बकीय" :'JJ',
"विद्युतीय" :'JJ',
"विद्रूप" :'JJ',
"विद्रोही" :'JJ',
"विद्वतापूर्ण" :'JJ',
"विद्वत् " :'JJ',
"विद्वान" :'JJ',
"विद्वेशपूर्ण" :'JJ',
"विद्वेषी" :'JJ',
"विधन" :'JJ',
"विधवा" :'JJ',
"विधानीय" :'JJ',
"विधिक" :'JJ',
"विधिमान्य" :'JJ',
"विधिवश" :'JJ',
"विधिविरुद्ध" :'JJ',
"विधेयात्मक" :'JJ',
"विध्वंसक" :'JJ',
"विध्वंसनीय" :'JJ',
"विध्वस्त" :'JJ',
"विनम्य" :'JJ',
"विनम्र" :'JJ',
"विनययुक्त" :'JJ',
"विनयशील" :'JJ',
"विनयी" :'JJ',
"विनष्ट" :'JJ',
"विनस" :'JJ',
"विनायक" :'JJ',
"विनाश कारक" :'JJ',
"विनाशक" :'JJ',
"विनाशकारक" :'JJ',
"विनाशकारी" :'JJ',
"विनाशी" :'JJ',
"विनाशोन्मुख" :'JJ',
"विनाश्य" :'JJ',
"विनिमयित" :'JJ',
"विनीत" :'JJ',
"विनोदित" :'JJ',
"विनोदी" :'JJ',
"विन्यस्त" :'JJ',
"विपक्षधर" :'JJ',
"विपक्षी" :'JJ',
"विपक्षीय" :'JJ',
"विपत्तिकर" :'JJ',
"विपत्तिकारी" :'JJ',
"विपत्तिग्रस्त" :'JJ',
"विपदाग्रस्त" :'JJ',
"विपन्न" :'JJ',
"विपरीत" :'JJ',
"विपुत्र" :'JJ',
"विपुत्रा" :'JJ',
"विपुल" :'JJ',
"विप्रिय" :'JJ',
"विफल" :'JJ',
"विबोधित" :'JJ',
"विभक्त" :'JJ',
"विभागीय" :'JJ',
"विभाजक" :'JJ',
"विभाजनीय" :'JJ',
"विभाजित" :'JJ',
"विभाज्य" :'JJ',
"विभिन्न" :'JJ',
"विभिन्न प्रकार का" :'JJ',
"विभु" :'JJ',
"विभूषित" :'JJ',
"विभोर" :'JJ',
"विमर्शित" :'JJ',
"विमल" :'JJ',
"विमुख" :'JJ',
"विमोघ" :'JJ',
"विमोचित" :'JJ',
"वियंग" :'JJ',
"वियङ्ग" :'JJ',
"वियतनामी" :'JJ',
"वियतनामीज़" :'JJ',
"वियतनामीस" :'JJ',
"वियुक्त" :'JJ',
"वियोगरहित" :'JJ',
"वियोगी" :'JJ',
"विरक्त" :'JJ',
"विरचित" :'JJ',
"विरत" :'JJ',
"विरथ" :'JJ',
"विरल" :'JJ',
"विरला" :'JJ',
"विरहणी" :'JJ',
"विरहिणी" :'JJ',
"विरही" :'JJ',
"विरागी" :'JJ',
"विराजमान" :'JJ',
"विराजित" :'JJ',
"विराट" :'JJ',
"विराट्" :'JJ',
"विरासती" :'JJ',
"विरुज" :'JJ',
"विरुद्ध" :'JJ',
"विरुद्धार्थी" :'JJ',
"विरूप" :'JJ',
"विरूपक" :'JJ',
"विरूपाक्ष" :'JJ',
"विरूपी" :'JJ',
"विरेचक" :'JJ',
"विरोधक" :'JJ',
"विरोधजन्य" :'JJ',
"विरोधात्मक" :'JJ',
"विरोधित" :'JJ',
"विरोधी" :'JJ',
"विलक्षण" :'JJ',
"विलक्षणपूर्ण" :'JJ',
"विलक्षित" :'JJ',
"विलग" :'JJ',
"विलंबित" :'JJ',
"विलम्बित" :'JJ',
"विलायती" :'JJ',
"विलासवती" :'JJ',
"विलासी" :'JJ',
"विलीन" :'JJ',
"विलुप्त" :'JJ',
"विलेय" :'JJ',
"विलोकनीय" :'JJ',
"विलोकित" :'JJ',
"विलोडित" :'JJ',
"विलोपक" :'JJ',
"विलोप्य" :'JJ',
"विलोम" :'JJ',
"विलोल" :'JJ',
"विवरण-युक्त" :'JJ',
"विवरणात्मक" :'JJ',
"विवर्ण" :'JJ',
"विवश" :'JJ',
"विवसन" :'JJ',
"विवस्त्र" :'JJ',
"विवादग्रस्त" :'JJ',
"विवादरहित" :'JJ',
"विवादहीन" :'JJ',
"विवादातीत" :'JJ',
"विवादास्पद" :'JJ',
"विवादित" :'JJ',
"विवादी" :'JJ',
"विवाद्य" :'JJ',
"विवाहित" :'JJ',
"विवाहिता" :'JJ',
"विवाह्य" :'JJ',
"विविध" :'JJ',
"विविध प्रकार का" :'JJ',
"विविधतापूर्ण" :'JJ',
"विवेकवान" :'JJ',
"विवेकशील" :'JJ',
"विवेकहीन" :'JJ',
"विवेकाधीन" :'JJ',
"विवेकी" :'JJ',
"विशद" :'JJ',
"विशद्" :'JJ',
"विशयी" :'JJ',
"विशाख" :'JJ',
"विशारद" :'JJ',
"विशाल" :'JJ',
"विशालकाय" :'JJ',
"विशालतम" :'JJ',
"विशालतम्" :'JJ',
"विशालहृदय" :'JJ',
"विशिष्ट" :'JJ',
"विशुद्ध" :'JJ',
"विशृंखलित" :'JJ',
"विशृंग" :'JJ',
"विशेष" :'JJ',
"विशेषज्ञ" :'JJ',
"विशेषणयुक्त" :'JJ',
"विशेषित" :'JJ',
"विशोक" :'JJ',
"विशोधित" :'JJ',
"विश्रब्ध" :'JJ',
"विश्रांत" :'JJ',
"विश्रान्त" :'JJ',
"विश्लेषणकर्ता" :'JJ',
"विश्लेषणकर्त्ता" :'JJ',
"विश्लेषी" :'JJ',
"विश्व" :'JJ',
"विश्व प्रसिद्ध" :'JJ',
"विश्व विख्यात" :'JJ',
"विश्व विजेता" :'JJ',
"विश्वक" :'JJ',
"विश्वकद्रु" :'JJ',
"विश्वप्रसिद्ध" :'JJ',
"विश्वविख्यात" :'JJ',
"विश्वविजयी" :'JJ',
"विश्वविद्यालयी" :'JJ',
"विश्वविद्यालयीन" :'JJ',
"विश्वविद्यालयीय" :'JJ',
"विश्वव्यापी" :'JJ',
"विश्वव्याप्त" :'JJ',
"विश्वसनीय" :'JJ',
"विश्वसित" :'JJ',
"विश्वस्त" :'JJ',
"विश्वस्तरीय" :'JJ',
"विश्वास करनेवाला" :'JJ',
"विश्वास कर्ता" :'JJ',
"विश्वासघाती" :'JJ',
"विश्वासपात्र" :'JJ',
"विश्वासशील" :'JJ',
"विश्वासी" :'JJ',
"विषघ्न" :'JJ',
"विषण" :'JJ',
"विषधर" :'JJ',
"विषनाशक" :'JJ',
"विषम" :'JJ',
"विषमबाहु" :'JJ',
"विषमय" :'JJ',
"विषमरूपी" :'JJ',
"विषमलिंगी" :'JJ',
"विषमलिंगीय" :'JJ',
"विषमलैंगिक" :'JJ',
"विषयक" :'JJ',
"विषयपरक" :'JJ',
"विषयरहित" :'JJ',
"विषयशून्य" :'JJ',
"विषयात्मक" :'JJ',
"विषयासक्त" :'JJ',
"विषयी" :'JJ',
"विषयुक्त" :'JJ',
"विषरहित" :'JJ',
"विषववृत्तीय" :'JJ',
"विषह" :'JJ',
"विषहंता" :'JJ',
"विषहारक" :'JJ',
"विषहीन" :'JJ',
"विषाक्त" :'JJ',
"विषाणी" :'JJ',
"विषाणुक" :'JJ',
"विषाणुज" :'JJ',
"विषाणुजनित" :'JJ',
"विषाणुजन्य" :'JJ',
"विषाणुरोधी" :'JJ',
"विषाद रहित" :'JJ',
"विषाद-रहित" :'JJ',
"विषादग्रस्त" :'JJ',
"विषादरहित" :'JJ',
"विषुवत" :'JJ',
"विषुवतरेखीय" :'JJ',
"विषुवतीय" :'JJ',
"विषुवत्" :'JJ',
"विषुवरेखीय" :'JJ',
"विषैला" :'JJ',
"विसंगत" :'JJ',
"विसन्न" :'JJ',
"विसम" :'JJ',
"विसर्जित" :'JJ',
"विसर्पी" :'JJ',
"विस्कासी" :'JJ',
"विस्तारक" :'JJ',
"विस्तारहीन" :'JJ',
"विस्तारित" :'JJ',
"विस्तीर्ण" :'JJ',
"विस्तृत" :'JJ',
"विस्थापित" :'JJ',
"विस्फारित" :'JJ',
"विस्फोटक" :'JJ',
"विस्फोटकारी" :'JJ',
"विस्मयकारक" :'JJ',
"विस्मयकारी" :'JJ',
"विस्मयजनक" :'JJ',
"विस्मरणीय" :'JJ',
"विस्मित" :'JJ',
"विस्मृत" :'JJ',
"विहंगी" :'JJ',
"विहंगीय" :'JJ',
"विहँसता" :'JJ',
"विहँसता हुआ" :'JJ',
"विहित" :'JJ',
"विहीन" :'JJ',
"विह्वल" :'JJ',
"वीत" :'JJ',
"वीतराग" :'JJ',
"वीभत्स" :'JJ',
"वीर" :'JJ',
"वीरतापूर्ण" :'JJ',
"वीरान" :'JJ',
"वीर्यकृत" :'JJ',
"वीर्यरहित" :'JJ',
"वीर्यवत्" :'JJ',
"वीर्यवान्" :'JJ',
"वीर्यहीन" :'JJ',
"वीर्यान्वित" :'JJ',
"वृक्ष-वासी" :'JJ',
"वृक्षवासी" :'JJ',
"वृत्त संबंधी" :'JJ',
"वृत्ताकार" :'JJ',
"वृत्तीय" :'JJ',
"वृथा" :'JJ',
"वृद्ध" :'JJ',
"वृद्धिकर" :'JJ',
"वृद्धिकारी" :'JJ',
"वृद्धियुक्त" :'JJ',
"वृद्धिरहित" :'JJ',
"वृद्धिशील" :'JJ',
"वृद्धिहीन" :'JJ',
"वृष्ट" :'JJ',
"वृष्णि" :'JJ',
"वृहत्" :'JJ',
"वेतनभोगी" :'JJ',
"वेत्ता" :'JJ',
"वेद-विरुद्ध" :'JJ',
"वेदज्ञ" :'JJ',
"वेदविरुद्ध" :'JJ',
"वेदितव्य" :'JJ',
"वेदिष्ठ" :'JJ',
"वेदीय" :'JJ',
"वेद्धव्य" :'JJ',
"वेधक" :'JJ',
"वेधनशील" :'JJ',
"वेधनीय" :'JJ',
"वेधित" :'JJ',
"वेध्य" :'JJ',
"वेनिजुएलन" :'JJ',
"वेनिज़ुएलन" :'JJ',
"वेनिजुएलाई" :'JJ',
"वेनिज़ुएलाई" :'JJ',
"वेनीजुएलन" :'JJ',
"वेनीज़ुएलन" :'JJ',
"वेनीजुएलाई" :'JJ',
"वेनीज़ुएलाई" :'JJ',
"वेनेजुएलाई" :'JJ',
"वेलापवर्ती" :'JJ',
"वेश भूषित" :'JJ',
"वेश-भूषित" :'JJ',
"वेशभूषित" :'JJ',
"वेशित" :'JJ',
"वेश्यागामी" :'JJ',
"वेष्टित" :'JJ',
"वेस्टर्न" :'JJ',
"वैकल्पिक" :'JJ',
"वैकुंठीय" :'JJ',
"वैक्रमीय" :'JJ',
"वैचारिक" :'JJ',
"वैज्ञानिक" :'JJ',
"वैतनिक" :'JJ',
"वैदिक" :'JJ',
"वैद्युत" :'JJ',
"वैद्युतिक" :'JJ',
"वैध" :'JJ',
"वैधवेय" :'JJ',
"वैधानिक" :'JJ',
"वैनेजुएलाई" :'JJ',
"वैभवशाली" :'JJ',
"वैमात्र" :'JJ',
"वैमात्रेय" :'JJ',
"वैमानिक" :'JJ',
"वैयक्तिक" :'JJ',
"वैरपूर्ण" :'JJ',
"वैरागी" :'JJ',
"वैरी" :'JJ',
"वैवाह" :'JJ',
"वैवाहिक" :'JJ',
"वैवाह्य" :'JJ',
"वैविध्यपूर्ण" :'JJ',
"वैशाखी" :'JJ',
"वैशेषिक" :'JJ',
"वैश्विक" :'JJ',
"वैषयिक" :'JJ',
"वैष्णव" :'JJ',
"वैसा" :'JJ',
"वोटाधिकारी" :'JJ',
"वोद" :'JJ',
"व्यक्त" :'JJ',
"व्यक्तिगत" :'JJ',
"व्यंग्यपूर्ण" :'JJ',
"व्यंग्यात्मक" :'JJ',
"व्यग्र" :'JJ',
"व्यतीत" :'JJ',
"व्यथित" :'JJ',
"व्यभिचारिणी" :'JJ',
"व्यभिचारी" :'JJ',
"व्ययशील" :'JJ',
"व्ययी" :'JJ',
"व्यर्थ" :'JJ',
"व्यवधानरहित" :'JJ',
"व्यवसायिक" :'JJ',
"व्यवस्थागत" :'JJ',
"व्यवस्थाहीन" :'JJ',
"व्यवस्थित" :'JJ',
"व्यवहार अकुशल" :'JJ',
"व्यवहार कुशल" :'JJ',
"व्यवहार-कुशल" :'JJ',
"व्यवहारकुशल" :'JJ',
"व्यवहारशील" :'JJ',
"व्यवहारिक" :'JJ',
"व्यवहारी" :'JJ',
"व्यवहार्य" :'JJ',
"व्यवहृत" :'JJ',
"व्यंसक" :'JJ',
"व्यसनी" :'JJ',
"व्यस्त" :'JJ',
"व्यस्ततम" :'JJ',
"व्याकरणिक" :'JJ',
"व्याकरणीय" :'JJ',
"व्याकुल" :'JJ',
"व्याकुलतारहित" :'JJ',
"व्याख्यासहित" :'JJ',
"व्याजमय" :'JJ',
"व्याधित" :'JJ',
"व्याधिहीन" :'JJ',
"व्यापक" :'JJ',
"व्यापारिक" :'JJ',
"व्यापारीय" :'JJ',
"व्यापी" :'JJ',
"व्याप्त" :'JJ',
"व्यायामिक" :'JJ',
"व्यायामी" :'JJ',
"व्यावसायिक" :'JJ',
"व्यावहारिक" :'JJ',
"व्यावहृत" :'JJ',
"व्याससिद्ध" :'JJ',
"व्याहत" :'JJ',
"व्युत्त" :'JJ',
"व्युत्पन्न" :'JJ',
"व्यूढ़" :'JJ',
"व्रतगामी" :'JJ',
"व्रतहीन" :'JJ',
"व्रीडित" :'JJ',
"व्रीड़ित" :'JJ',
"शऊरदार" :'JJ',
"शंकर" :'JJ',
"शकरी" :'JJ',
"शंकायुक्त" :'JJ',
"शंकारहित" :'JJ',
"शंकालु" :'JJ',
"शंकाशील" :'JJ',
"शंकाहीन" :'JJ',
"शंकित" :'JJ',
"शंकु" :'JJ',
"शक्करी" :'JJ',
"शक्की" :'JJ',
"शक्तिपूर्ण" :'JJ',
"शक्तिमान" :'JJ',
"शक्तिमान्" :'JJ',
"शक्तिवर्द्धक" :'JJ',
"शक्तिवर्धक" :'JJ',
"शक्तिवान" :'JJ',
"शक्तिशाली" :'JJ',
"शक्तिष्ठ" :'JJ',
"शक्तिसंपन्न" :'JJ',
"शक्तिसम्पन्न" :'JJ',
"शक्तिहीन" :'JJ',
"शक्य" :'JJ',
"शंक्वाकार" :'JJ',
"शंख" :'JJ',
"शंखद्राव" :'JJ',
"शंखद्रावक" :'JJ',
"शख्सी" :'JJ',
"शख़्सी" :'JJ',
"शङ्कर" :'JJ',
"शङ्कायुक्त" :'JJ',
"शङ्कित" :'JJ',
"शङ्कु" :'JJ',
"शङ्ख" :'JJ',
"शठ" :'JJ',
"शंड" :'JJ',
"शत" :'JJ',
"शत प्रतिशत" :'JJ',
"शत-प्रतिशत" :'JJ',
"शतकीय" :'JJ',
"शतगु" :'JJ',
"शतपथिक" :'JJ',
"शतपथी" :'JJ',
"शतप्रतिशत" :'JJ',
"शतमन्यु" :'JJ',
"शतानीक" :'JJ',
"शतायु" :'JJ',
"शतायुध" :'JJ',
"शत्रु" :'JJ',
"शत्रुघ्न" :'JJ',
"शत्रुजित्" :'JJ',
"शत्रुतापूर्ण" :'JJ',
"शत्रुनाशक" :'JJ',
"शत्रुपूर्ण" :'JJ',
"शत्रुविहीन" :'JJ',
"शत्रुसाल" :'JJ',
"शत्रुहन" :'JJ',
"शत्रुहा" :'JJ',
"शत्रुहीन" :'JJ',
"शनिवारी" :'JJ',
"शनीचरी" :'JJ',
"शन्तिदायक" :'JJ',
"शन्तिप्रद" :'JJ',
"शप्त" :'JJ',
"शबर" :'JJ',
"शबल" :'JJ',
"शबलक" :'JJ',
"शबलित" :'JJ',
"शब्दकार" :'JJ',
"शब्दकारी" :'JJ',
"शब्दभेदी" :'JJ',
"शब्दरहित" :'JJ',
"शब्दवेधी" :'JJ',
"शब्दहीन" :'JJ',
"शब्दाडंबरपूर्ण" :'JJ',
"शब्दाडंबरयुक्त" :'JJ',
"शब्दाडम्बरपूर्ण" :'JJ',
"शब्दाडम्बरयुक्त" :'JJ',
"शब्दातीत" :'JJ',
"शब्दायमान" :'JJ',
"शब्दित" :'JJ',
"शमक" :'JJ',
"शमित" :'JJ',
"शयनरत" :'JJ',
"शरणागत" :'JJ',
"शरणार्थी" :'JJ',
"शरण्य" :'JJ',
"शरत कालीन" :'JJ',
"शरद कालीन" :'JJ',
"शरबती" :'JJ',
"शरमसार" :'JJ',
"शरमाऊ" :'JJ',
"शरमाया" :'JJ',
"शरमाया हुआ" :'JJ',
"शरमालू" :'JJ',
"शरमिंदा" :'JJ',
"शरमिन्दा" :'JJ',
"शरमीला" :'JJ',
"शराबी" :'JJ',
"शराबोर" :'JJ',
"शरारती" :'JJ',
"शरीक" :'JJ',
"शरीफ" :'JJ',
"शरीफ़" :'JJ',
"शरीरधारी" :'JJ',
"शरीरविहीन" :'JJ',
"शरीरहीन" :'JJ',
"शरीरी" :'JJ',
"शर्करायुक्त" :'JJ',
"शर्तिया" :'JJ',
"शर्मनाक" :'JJ',
"शर्मसार" :'JJ',
"शर्मिंदा" :'JJ',
"शर्मिन्दा" :'JJ',
"शर्मीला" :'JJ',
"शल्योपचारिक" :'JJ',
"शव भक्षी" :'JJ',
"शवल" :'JJ',
"शवाश" :'JJ',
"शस्त्रधारी" :'JJ',
"शस्त्रविहीन" :'JJ',
"शस्त्रहीन" :'JJ',
"शस्यहीन" :'JJ',
"शहजोर" :'JJ',
"शहराती" :'JJ',
"शहरी" :'JJ',
"शहरीकृत" :'JJ',
"शहरुआ" :'JJ',
"शहरुवा" :'JJ',
"शाकजीवी" :'JJ',
"शाकभक्ष्य" :'JJ',
"शाकाहारी" :'JJ',
"शाकिर" :'JJ',
"शाकी" :'JJ',
"शाकुन" :'JJ',
"शाकोपजीवी" :'JJ',
"शाक्त" :'JJ',
"शाक्वर" :'JJ',
"शाखायुक्त" :'JJ',
"शाखारहित" :'JJ',
"शाखाविहीन" :'JJ',
"शाखाहीन" :'JJ',
"शांखिक" :'JJ',
"शाखी" :'JJ',
"शाङ्खिक" :'JJ',
"शांत" :'JJ',
"शांति-प्रेमी" :'JJ',
"शांतिकर" :'JJ',
"शांतिदायक" :'JJ',
"शांतिदायी" :'JJ',
"शांतिपूर्ण" :'JJ',
"शांतिप्रद" :'JJ',
"शांतिप्रदायक" :'JJ',
"शांतिप्रिय" :'JJ',
"शांतिमय" :'JJ',
"शातिर" :'JJ',
"शाद" :'JJ',
"शादमन" :'JJ',
"शादाब" :'JJ',
"शादी शुदा" :'JJ',
"शादीशुदा" :'JJ',
"शाद्वल" :'JJ',
"शानदार" :'JJ',
"शान्त" :'JJ',
"शान्तिदायी" :'JJ',
"शान्तिपूर्ण" :'JJ',
"शान्तिप्रदायक" :'JJ',
"शान्तिमय" :'JJ',
"शापग्रस्त" :'JJ',
"शापित" :'JJ',
"शाबर" :'JJ',
"शाब्द" :'JJ',
"शाब्दिक" :'JJ',
"शामक" :'JJ',
"शामिल" :'JJ',
"शायराना" :'JJ',
"शार" :'JJ',
"शारंगधारी" :'JJ',
"शारद" :'JJ',
"शारदीय" :'JJ',
"शारीरिक" :'JJ',
"शारुक" :'JJ',
"शालिहोत्रीय" :'JJ',
"शालीन" :'JJ',
"शाश्वत" :'JJ',
"शासकीय" :'JJ',
"शासित" :'JJ',
"शास्त्र असंगत" :'JJ',
"शास्त्र विरुद्ध" :'JJ',
"शास्त्र-विरुद्ध" :'JJ',
"शास्त्रविरुद्ध" :'JJ',
"शास्त्रीय" :'JJ',
"शाही" :'JJ',
"शिकायतकर्ता" :'JJ',
"शिकायतकर्त्ता" :'JJ',
"शिकायती" :'JJ',
"शिकारी" :'JJ',
"शिक्षात्मक" :'JJ',
"शिक्षार्थी" :'JJ',
"शिक्षित" :'JJ',
"शित" :'JJ',
"शिति" :'JJ',
"शिथिल" :'JJ',
"शिथिलित" :'JJ',
"शिलाबद्ध" :'JJ',
"शिवनामी" :'JJ',
"शिष्ट" :'JJ',
"शिष्टाचारहीन" :'JJ',
"शिष्टाचारी" :'JJ',
"शीघ्र" :'JJ',
"शीघ्रकोपी" :'JJ',
"शीघ्रगामी" :'JJ',
"शीत" :'JJ',
"शीत कटिबंधी" :'JJ',
"शीत कटिबंधीय" :'JJ',
"शीत कटिबन्धी" :'JJ',
"शीत कटिबन्धीय" :'JJ',
"शीत कालीन" :'JJ',
"शीतकटिबंधी" :'JJ',
"शीतकटिबंधीय" :'JJ',
"शीतकटिबन्धी" :'JJ',
"शीतकटिबन्धीय" :'JJ',
"शीतकालीन" :'JJ',
"शीतल" :'JJ',
"शीन" :'JJ',
"शीर्ण" :'JJ',
"शीर्ष" :'JJ',
"शीर्षस्थ" :'JJ',
"शील" :'JJ',
"शीलरहित" :'JJ',
"शीलवती" :'JJ',
"शीलवान" :'JJ',
"शीलहीन" :'JJ',
"शीलहीना" :'JJ',
"शीशायुक्त" :'JJ',
"शीशेदार" :'JJ',
"शुकवारी" :'JJ',
"शुक्र" :'JJ',
"शुक्रगुजार" :'JJ',
"शुक्रग़ुज़ार" :'JJ',
"शुक्रवारी" :'JJ',
"शुक्रहीन" :'JJ',
"शुक्ल" :'JJ',
"शुद्ध" :'JJ',
"शुभ" :'JJ',
"शुभचिंतक" :'JJ',
"शुभचिन्तक" :'JJ',
"शुभाकांक्षी" :'JJ',
"शुभेच्छुक" :'JJ',
"शुभ्र" :'JJ',
"शुरुआती" :'JJ',
"शुरुवाती" :'JJ',
"शुरू" :'JJ',
"शुल्क मुक्त" :'JJ',
"शुष्क" :'JJ',
"शुष्क हृदय" :'JJ',
"शुष्क-हृदय" :'JJ',
"शुष्कहृदय" :'JJ',
"शून्य" :'JJ',
"शूर" :'JJ',
"शूरता युक्त" :'JJ',
"शूरतापूर्ण" :'JJ',
"शूरमा" :'JJ',
"शूरवीर" :'JJ',
"शूलहीन" :'JJ',
"शृंखलाबद्ध" :'JJ',
"शृंगयुक्त" :'JJ',
"शृंगहीन" :'JJ',
"शृंगारिक" :'JJ',
"शृंगारित" :'JJ',
"शृंगी" :'JJ',
"शेखर" :'JJ',
"शेखी" :'JJ',
"शेखीखोर" :'JJ',
"शेख़ीख़ोर" :'JJ',
"शेखीबाज" :'JJ',
"शेखीबाज़" :'JJ',
"शेख़ीबाज़" :'JJ',
"शेख़ीबाज़" :'JJ',
"शेखीमार" :'JJ',
"शेख़ीमार" :'JJ',
"शेष" :'JJ',
"शैक्षणिक" :'JJ',
"शैक्षिक" :'JJ',
"शैतान" :'JJ',
"शैलज" :'JJ',
"शैलाज" :'JJ',
"शैलेय" :'JJ',
"शैव" :'JJ',
"शोकग्रस्त" :'JJ',
"शोकपूर्ण" :'JJ',
"शोकरहित" :'JJ',
"शोकहीन" :'JJ',
"शोकाकुल" :'JJ',
"शोकांत" :'JJ',
"शोकांतक" :'JJ',
"शोकान्त" :'JJ',
"शोकान्तक" :'JJ',
"शोख" :'JJ',
"शोख़" :'JJ',
"शोचनीय" :'JJ',
"शोणित" :'JJ',
"शोधक" :'JJ',
"शोधकर्ता" :'JJ',
"शोधकर्त्ता" :'JJ',
"शोधनीय" :'JJ',
"शोधित" :'JJ',
"शोध्य" :'JJ',
"शोभनीय" :'JJ',
"शोभा रहित" :'JJ',
"शोभा हीन" :'JJ',
"शोभा-रहित" :'JJ',
"शोभा-हीन" :'JJ',
"शोभादायक" :'JJ',
"शोभान्वित" :'JJ',
"शोभायमान" :'JJ',
"शोभारहित" :'JJ',
"शोभाहीन" :'JJ',
"शोभित" :'JJ',
"शोरबेदार" :'JJ',
"शोरभरा" :'JJ',
"शोषित" :'JJ',
"शोहदा" :'JJ',
"शोहरतमंद" :'JJ',
"शोहरतमन्द" :'JJ',
"शौकिया" :'JJ',
"शौकीन" :'JJ',
"शौक़ीन" :'JJ',
"शौंड" :'JJ',
"शौंडीर" :'JJ',
"शौण्ड" :'JJ',
"शौण्डीर" :'JJ',
"श्यान" :'JJ',
"श्याम" :'JJ',
"श्यामल" :'JJ',
"श्रद्धा पात्र" :'JJ',
"श्रद्धा योग्य" :'JJ',
"श्रद्धारहित" :'JJ',
"श्रद्धालु" :'JJ',
"श्रद्धास्पद" :'JJ',
"श्रद्धाहीन" :'JJ',
"श्रद्धेय" :'JJ',
"श्रम साध्य" :'JJ',
"श्रम-साध्य" :'JJ',
"श्रमसाध्य" :'JJ',
"श्रमी" :'JJ',
"श्रवणीय" :'JJ',
"श्रवनीय" :'JJ',
"श्रव्य" :'JJ',
"श्रांत" :'JJ',
"श्री लंकाई" :'JJ',
"श्रील" :'JJ',
"श्रीलंकन" :'JJ',
"श्रीलंकाई" :'JJ',
"श्रीहत" :'JJ',
"श्रीहीन" :'JJ',
"श्रुत" :'JJ',
"श्रृंगारिक" :'JJ',
"श्रेणीय" :'JJ',
"श्रेयस्कर" :'JJ',
"श्रेष्ठ" :'JJ',
"श्रेष्ठतर" :'JJ',
"श्रोतव्य" :'JJ',
"श्रोतहीन" :'JJ',
"श्लाघनीय" :'JJ',
"श्लाघित" :'JJ',
"श्लाघ्य" :'JJ',
"श्लिष्ट" :'JJ',
"श्लीपदी" :'JJ',
"श्लील" :'JJ',
"श्लेषयुक्त" :'JJ',
"श्लेष्मी" :'JJ',
"श्वेत" :'JJ',
"श्वेत पोश" :'JJ',
"श्वेत-पोश" :'JJ',
"श्वेतपोश" :'JJ',
"श्वेतसारयुक्त" :'JJ',
"श्वेतसारीय" :'JJ',
"षटमासिक" :'JJ',
"षट्" :'JJ',
"षट्कोण" :'JJ',
"षट्कोना" :'JJ',
"षट्पद" :'JJ',
"षट्पाद" :'JJ',
"षडश्व" :'JJ',
"षडानन" :'JJ',
"षड्भुज" :'JJ',
"षड्भुजा" :'JJ',
"षष्टम" :'JJ',
"षोडश" :'JJ',
"सउदिया" :'JJ',
"सउदी" :'JJ',
"सऊदी" :'JJ',
"संकट नाशक" :'JJ',
"संकट मोचक" :'JJ',
"संकट हर्ता" :'JJ',
"संकटकर" :'JJ',
"संकटकारी" :'JJ',
"संकटग्रस्त" :'JJ',
"संकटदायक" :'JJ',
"संकटनाशक" :'JJ',
"संकटपूर्ण" :'JJ',
"संकटप्रद" :'JJ',
"संकटमय" :'JJ',
"संकटमोचक" :'JJ',
"संकटमोचन" :'JJ',
"संकटस्थ" :'JJ',
"संकटहर्ता" :'JJ',
"संकटापन्न" :'JJ',
"सँकड़ा" :'JJ',
"संकर" :'JJ',
"सकरा" :'JJ',
"सँकरा" :'JJ',
"संकरा" :'JJ',
"संकरित" :'JJ',
"सकर्मक" :'JJ',
"सकल" :'JJ',
"संकलित" :'JJ',
"संकल्पित" :'JJ',
"सकाम" :'JJ',
"सकामा" :'JJ',
"सकार" :'JJ',
"सकारथ" :'JJ',
"सकारात्मक" :'JJ',
"संकीर्ण" :'JJ',
"संकुचनशील" :'JJ',
"संकुचित" :'JJ',
"संकुल" :'JJ',
"सकुल्य" :'JJ',
"संकेतिक" :'JJ',
"संकेतित" :'JJ',
"संकेंद्रित" :'JJ',
"संकेन्द्रित" :'JJ',
"संकोचहीन" :'JJ',
"संकोची" :'JJ',
"संक्रमित" :'JJ',
"संक्रामक" :'JJ',
"सक्रिय" :'JJ',
"सक्षम" :'JJ',
"संक्षिप्त" :'JJ',
"सखाहीन" :'JJ',
"सख्त" :'JJ',
"सख़्त" :'JJ',
"सख्तज़बान" :'JJ',
"संख्यात्मक" :'JJ',
"संगठनहीन" :'JJ',
"संगठित" :'JJ',
"संगणकीकृत" :'JJ',
"संगणकीय" :'JJ',
"संगत" :'JJ',
"संगदिल" :'JJ',
"सगंध" :'JJ',
"संगमरमरी" :'JJ',
"सगर्भ" :'JJ',
"सगर्भ्य" :'JJ',
"सगा" :'JJ',
"संगीतप्रिय" :'JJ',
"संगीतप्रेमी" :'JJ',
"संगीतमय" :'JJ',
"संगीतात्मक" :'JJ',
"संगीन" :'JJ',
"सगुण" :'JJ',
"सगुन" :'JJ',
"संगृहीत" :'JJ',
"सगोत्री" :'JJ',
"सगोत्रीय" :'JJ',
"संग्रह-कर्ता" :'JJ',
"संग्रह-कर्त्ता" :'JJ',
"संग्रहकर्ता" :'JJ',
"संग्रहकर्त्ता" :'JJ',
"संग्रहणीय" :'JJ',
"संग्रहित" :'JJ',
"संग्रही" :'JJ',
"संग्रामी" :'JJ',
"संग्राह्य" :'JJ',
"संघटित" :'JJ',
"सघन" :'JJ',
"संघर्षपूर्ण" :'JJ',
"संघर्षमय" :'JJ',
"संघर्षरत" :'JJ',
"संघर्षशील" :'JJ',
"संघर्षी" :'JJ',
"संघात" :'JJ',
"संघीय" :'JJ',
"सघोष" :'JJ',
"सङ्कर" :'JJ',
"सङ्कुल" :'JJ',
"सङ्घात" :'JJ',
"सच" :'JJ',
"संचयी" :'JJ',
"सचल" :'JJ',
"संचारित" :'JJ',
"संचारी" :'JJ',
"संचालित" :'JJ',
"संचित" :'JJ',
"सचित्र" :'JJ',
"सचेत" :'JJ',
"सचेतन" :'JJ',
"सचेल" :'JJ',
"सचैल" :'JJ',
"सच्चरित्र" :'JJ',
"सच्चरित्रा" :'JJ',
"सच्चा" :'JJ',
"सछिद्र" :'JJ',
"सजग" :'JJ',
"सजल" :'JJ',
"सजला" :'JJ',
"सजा" :'JJ',
"सजा धजा" :'JJ',
"सजा हुआ" :'JJ',
"सजा-धजा" :'JJ',
"सजा-याफता" :'JJ',
"सज़ा-याफता" :'JJ',
"सजा-सजाया" :'JJ',
"संजात" :'JJ',
"सजाति" :'JJ',
"सजातीय" :'JJ',
"सजाया हुआ" :'JJ',
"सजायाफता" :'JJ',
"सज़ायाफ़ता" :'JJ',
"सजायाफ्ता" :'JJ',
"सज़ायाफ्ता" :'JJ',
"सज़ायाफ़्ता" :'JJ',
"सज़ायाब" :'JJ',
"सजावटी" :'JJ',
"सजिल्द" :'JJ',
"सज़िल्द" :'JJ',
"संजीदा" :'JJ',
"सजीला" :'JJ',
"सजीव" :'JJ',
"संजीवनी" :'JJ',
"सज्जन" :'JJ',
"सज्जित" :'JJ',
"संज्ञात" :'JJ',
"संज्ञायुक्त" :'JJ',
"संज्ञारहित" :'JJ',
"संज्ञाशून्य" :'JJ',
"संज्ञाहीन" :'JJ',
"सझला" :'JJ',
"सँझला" :'JJ',
"संझला" :'JJ',
"सञ्चारी" :'JJ',
"सञ्जीवनी" :'JJ',
"सटकारा" :'JJ',
"सटा" :'JJ',
"सटीक" :'JJ',
"सठ" :'JJ',
"सड़कछाप" :'JJ',
"सड़नशील" :'JJ',
"सड़सठ" :'JJ',
"सड़सठवाँ" :'JJ',
"सड़ा" :'JJ',
"सड़ा गला" :'JJ',
"सड़ा हुआ" :'JJ',
"सड़ा-गला" :'JJ',
"सड़ियल" :'JJ',
"सतगुना" :'JJ',
"सततप्रवाहिनी" :'JJ',
"सतमासा" :'JJ',
"सतरंग" :'JJ',
"सतरंगा" :'JJ',
"सतरह" :'JJ',
"सतरहवाँ" :'JJ',
"सतर्क" :'JJ',
"सतलखा" :'JJ',
"सतलड़ा" :'JJ',
"सतवंती" :'JJ',
"सतवन्ती" :'JJ',
"सतवाँसा" :'JJ',
"सतहत्तर" :'JJ',
"सतहत्तरवाँ" :'JJ',
"सतही" :'JJ',
"सताइसवाँ" :'JJ',
"सताईस" :'JJ',
"सताईसवाँ" :'JJ',
"संतान वाला" :'JJ',
"संतान संपन्न" :'JJ',
"सतानबे" :'JJ',
"सतानबेवाँ" :'JJ',
"संतानरहित" :'JJ',
"सतानवे" :'JJ',
"सतानवेवाँ" :'JJ',
"संतानहीन" :'JJ',
"संतानीय" :'JJ',
"सताया" :'JJ',
"सतारी" :'JJ',
"सतावन" :'JJ',
"सतावनवाँ" :'JJ',
"सतासी" :'JJ',
"सतासीवाँ" :'JJ',
"सती" :'JJ',
"संतुलनरहित" :'JJ',
"संतुलित" :'JJ',
"संतुष्ट" :'JJ',
"संतृप्त" :'JJ',
"सतोगुणी" :'JJ',
"संतोषजनक" :'JJ',
"संतोषप्रद" :'JJ',
"संतोषशील" :'JJ',
"संतोषी" :'JJ',
"सतौसर" :'JJ',
"सत्कार कृत" :'JJ',
"सत्कृत" :'JJ',
"सत्तर" :'JJ',
"सत्तरवाँ" :'JJ',
"सत्तरवां" :'JJ',
"सत्तरह" :'JJ',
"सत्तरहवाँ" :'JJ',
"सत्तरेक" :'JJ',
"सत्ताइसवाँ" :'JJ',
"सत्ताईस" :'JJ',
"सत्ताईसवाँ" :'JJ',
"सत्ताईसवां" :'JJ',
"सत्तांतरित" :'JJ',
"सत्तानबे" :'JJ',
"सत्तानबेवाँ" :'JJ',
"सत्तानवे" :'JJ',
"सत्तानवेवाँ" :'JJ',
"सत्तारूढ़" :'JJ',
"सत्तावन" :'JJ',
"संत्तावन" :'JJ',
"सत्तावनवाँ" :'JJ',
"संत्तावनवाँ" :'JJ',
"सत्तासी" :'JJ',
"सत्तासीवाँ" :'JJ',
"सत्ताहीन" :'JJ',
"सत्पात्र" :'JJ',
"सत्य" :'JJ',
"सत्यनिष्ठ" :'JJ',
"सत्यपर" :'JJ',
"सत्यभाषिणी" :'JJ',
"सत्यभाषी" :'JJ',
"सत्यवक्ता" :'JJ',
"सत्यवती" :'JJ',
"सत्यवादिनी" :'JJ',
"सत्यवादी" :'JJ',
"सत्यव्रत" :'JJ',
"सत्याग्रही" :'JJ',
"सत्यानाशी" :'JJ',
"सत्यापित" :'JJ',
"सत्यासी" :'JJ',
"सत्यासीवाँ" :'JJ',
"संत्रस्त" :'JJ',
"सत्रह" :'JJ',
"सत्रहवाँ" :'JJ',
"सत्रि" :'JJ',
"सत्वहीन" :'JJ',
"सदर" :'JJ',
"सदस्यीय" :'JJ',
"सदा-बहार" :'JJ',
"सदाचारिणी" :'JJ',
"सदाचारी" :'JJ',
"सदानंद" :'JJ',
"सदानन्द" :'JJ',
"सदानीरा" :'JJ',
"सदाबहार" :'JJ',
"सदाशय" :'JJ',
"सदाहरित" :'JJ',
"संदिग्ध" :'JJ',
"संदीपन" :'JJ',
"सदृश" :'JJ',
"सदृश्य" :'JJ',
"संदेश वाहक" :'JJ',
"संदेशवाहक" :'JJ',
"संदेह रहित" :'JJ',
"संदेहपूर्ण" :'JJ',
"संदेहयुक्त" :'JJ',
"संदेहहीन" :'JJ',
"संदेहात्मक" :'JJ',
"संदेहास्पद" :'JJ',
"सदेही" :'JJ',
"संदेही" :'JJ',
"सदोष" :'JJ',
"सद्गुणी" :'JJ',
"सद्योजात" :'JJ',
"सद्व्यवहारी" :'JJ',
"सधर्म" :'JJ',
"सधर्मक" :'JJ',
"सधर्मी" :'JJ',
"सधवा" :'JJ',
"सधा हुआ" :'JJ',
"सधुक्कड़ी" :'JJ',
"सनकी" :'JJ',
"सनत्तावन" :'JJ',
"सनत्तावनवाँ" :'JJ',
"सनसनीखेज" :'JJ',
"सनसनीख़ेज" :'JJ',
"सनसनीख़ेज़" :'JJ',
"सनसनीदार" :'JJ',
"सना" :'JJ',
"सना हुआ" :'JJ',
"सनातन" :'JJ',
"सनातनी" :'JJ',
"सनाथ" :'JJ',
"सनेही" :'JJ',
"सन्तान वाला" :'JJ',
"सन्तान सम्पन्न" :'JJ',
"सन्तुष्ट" :'JJ',
"सन्त्तावन" :'JJ',
"सन्त्तावनवाँ" :'JJ',
"सन्दिग्ध" :'JJ',
"सन्दीपन" :'JJ',
"सन्देहपूर्ण" :'JJ',
"सन्देहयुक्त" :'JJ',
"सन्देहहीन" :'JJ',
"सन्देहास्पद" :'JJ',
"सन्न" :'JJ',
"सन्नद्ध" :'JJ',
"सन्नासी" :'JJ',
"सन्निकट" :'JJ',
"सन्निहित" :'JJ',
"संन्यस्त" :'JJ',
"सन्यासी" :'JJ',
"संन्यासी" :'JJ',
"संपत्तिवान" :'JJ',
"सपत्नजित्" :'JJ',
"संपन्न" :'JJ',
"सपरिधान" :'JJ',
"सपाट" :'JJ',
"संपादकीय" :'JJ',
"संपादनीय" :'JJ',
"संपादित" :'JJ',
"सपुर्द" :'JJ',
"संपूरक" :'JJ',
"संपूर्ण" :'JJ',
"संपोषक" :'JJ',
"सप्त" :'JJ',
"सप्तदश" :'JJ',
"सप्तम" :'JJ',
"संप्रभु" :'JJ',
"संप्राप्त" :'JJ',
"संप्रेषित" :'JJ',
"सफल" :'JJ',
"सफ़ल" :'JJ',
"सफल-मनोरथ" :'JJ',
"सफेद" :'JJ',
"सफ़ेद" :'JJ',
"सफेद पोश" :'JJ',
"सफ़ेद पोश" :'JJ',
"सफेद-पोश" :'JJ',
"सफ़ेद-पोश" :'JJ',
"सफेदपोश" :'JJ',
"सफ़ेदपोश" :'JJ',
"सब" :'JJ',
"संबद्ध" :'JJ',
"संबंधरहित" :'JJ',
"संबंधहीन" :'JJ',
"संबंधित" :'JJ',
"संबंधी" :'JJ',
"संबंधीय" :'JJ',
"सबल" :'JJ',
"सबसे अधिक" :'JJ',
"सबसे ज्यादा" :'JJ',
"सबसे ज़्यादा" :'JJ',
"सबसे महँगा" :'JJ',
"सबसे सस्ता" :'JJ',
"संबोधक" :'JJ',
"संबोधन कर्ता" :'JJ',
"संबोधन कर्त्ता" :'JJ',
"संबोधित" :'JJ',
"संबोध्य" :'JJ',
"सब्रहीन" :'JJ',
"संभव" :'JJ',
"संभागीय" :'JJ',
"सभानिष्कासित" :'JJ',
"संभावनीय" :'JJ',
"संभावित" :'JJ',
"संभावी" :'JJ',
"संभाव्य" :'JJ',
"संभाषणशील" :'JJ',
"संभाषित" :'JJ',
"सभी" :'JJ',
"संभोगी" :'JJ',
"सभ्य" :'JJ',
"सभ्रांत" :'JJ',
"संभ्रांत" :'JJ',
"सभ्रान्त" :'JJ',
"संभ्रान्त" :'JJ',
"सम" :'JJ',
"सम-वयस्क" :'JJ',
"समकक्ष" :'JJ',
"समकालिक" :'JJ',
"समकालीन" :'JJ',
"समक्ष" :'JJ',
"समग्र" :'JJ',
"समग्रीकृत" :'JJ',
"समझदार" :'JJ',
"समतल" :'JJ',
"समतापी" :'JJ',
"समतावादी" :'JJ',
"समतुल्य" :'JJ',
"समदर्शी" :'JJ',
"समद्विबाहु" :'JJ',
"समद्विभुज" :'JJ',
"समधिक" :'JJ',
"समन्वयवादी" :'JJ',
"समन्वित" :'JJ',
"समबाहु" :'JJ',
"समभुज" :'JJ',
"समभूमिक" :'JJ',
"समय अपालक" :'JJ',
"समय का पाबंद" :'JJ',
"समय का पाबन्द" :'JJ',
"समय खाऊ" :'JJ',
"समय पालक" :'JJ',
"समय साध्य" :'JJ',
"समय-निष्ठ" :'JJ',
"समय-साध्य" :'JJ',
"समयखाऊ" :'JJ',
"समयनिष्ठ" :'JJ',
"समयसाध्य" :'JJ',
"समयानुकूल" :'JJ',
"समयोचित" :'JJ',
"समरूप" :'JJ',
"समरूपी" :'JJ',
"समर्थ" :'JJ',
"समर्थक" :'JJ',
"समर्थित" :'JJ',
"समर्पित" :'JJ',
"समलैंगिक" :'JJ',
"समवयस्क" :'JJ',
"समवर्गीय" :'JJ',
"समशीतोष्ण कटिबंधी" :'JJ',
"समशीतोष्ण कटिबंधीय" :'JJ',
"समशीतोष्ण कटिबन्धी" :'JJ',
"समशीतोष्ण कटिबन्धीय" :'JJ',
"समशीतोष्णकटिबंधी" :'JJ',
"समशीतोष्णकटिबंधीय" :'JJ',
"समशीतोष्णकटिबन्धी" :'JJ',
"समशीतोष्णकटिबन्धीय" :'JJ',
"समसामयिक" :'JJ',
"समस्त" :'JJ',
"समागत" :'JJ',
"समाचरपत्रीय" :'JJ',
"समाजवादी" :'JJ',
"समांतर" :'JJ',
"समादरणीय" :'JJ',
"समादरणीया" :'JJ',
"समाधानित" :'JJ',
"समाधान्य" :'JJ',
"समाधित" :'JJ',
"समाधिस्थ" :'JJ',
"समाधेय" :'JJ',
"समान" :'JJ',
"समानतावादी" :'JJ',
"समानांतर" :'JJ',
"समानान्तर" :'JJ',
"समानार्थक" :'JJ',
"समानार्थी" :'JJ',
"समानुपातिक" :'JJ',
"समानुपाती" :'JJ',
"समान्तर" :'JJ',
"समापनीय" :'JJ',
"समाप्त" :'JJ',
"समाप्तिक" :'JJ',
"समाप्य" :'JJ',
"समाविष्ट" :'JJ',
"समावेशित" :'JJ',
"समाहित" :'JJ',
"समाहृत" :'JJ',
"समित्र" :'JJ',
"समिषाहारी" :'JJ',
"समीप का" :'JJ',
"समीपवर्ती" :'JJ',
"समीपस्थ" :'JJ',
"समीपागत" :'JJ',
"समीपी" :'JJ',
"समुचित" :'JJ',
"समुद्र तटीय" :'JJ',
"समुद्रज" :'JJ',
"समुद्रतटीय" :'JJ',
"समुद्रिय" :'JJ',
"समुद्री" :'JJ',
"समुद्रीय" :'JJ',
"समूचा" :'JJ',
"समृद्ध" :'JJ',
"समृद्धशाली" :'JJ',
"समृद्धिदायक" :'JJ',
"समृद्धिदायी" :'JJ',
"समृद्धिप्रद" :'JJ',
"समृद्धिप्रदायक" :'JJ',
"समृद्धिप्रदायी" :'JJ',
"समृद्धिरहित" :'JJ',
"समृद्धिशाली" :'JJ',
"समौरिया" :'JJ',
"सम्पन्न" :'JJ',
"सम्पादकीय" :'JJ',
"सम्पादनीय" :'JJ',
"सम्पादित" :'JJ',
"सम्पूरित" :'JJ',
"सम्पूर्ण" :'JJ',
"सम्प्राप्त" :'JJ',
"सम्बद्ध" :'JJ',
"सम्बन्धरहित" :'JJ',
"सम्बन्धहीन" :'JJ',
"सम्बन्धित" :'JJ',
"सम्बन्धी" :'JJ',
"सम्बन्धीय" :'JJ',
"सम्बोधित" :'JJ',
"सम्भव" :'JJ',
"सम्भागीय" :'JJ',
"सम्भावनीय" :'JJ',
"सम्भावित" :'JJ',
"सम्भाव्य" :'JJ',
"सम्भाषणशील" :'JJ',
"सम्भ्रांत" :'JJ',
"सम्भ्रान्त" :'JJ',
"सम्मत" :'JJ',
"सम्मानजनक" :'JJ',
"सम्माननीय" :'JJ',
"सम्माननीया" :'JJ',
"सम्मानित" :'JJ',
"सम्मानीय" :'JJ',
"सम्मान्य" :'JJ',
"सम्मिलित" :'JJ',
"सम्मिश्रित" :'JJ',
"सम्मुख" :'JJ',
"सम्मुखागत" :'JJ',
"सम्मोहनपूर्ण" :'JJ',
"सम्मोहित" :'JJ',
"सम्वादशील" :'JJ',
"सय" :'JJ',
"सयण" :'JJ',
"संयत" :'JJ',
"संयतरहित" :'JJ',
"संयमशील" :'JJ',
"संयमित" :'JJ',
"संयमी" :'JJ',
"सयाना" :'JJ',
"संयुक्त" :'JJ',
"संयोगजन्य" :'JJ',
"संयोगी" :'JJ',
"संयोजक" :'JJ',
"संयोजित" :'JJ',
"सरकारी" :'JJ',
"संरक्षात्मक" :'JJ',
"संरक्षित" :'JJ',
"सरग-पताली" :'JJ',
"सरगपताली" :'JJ',
"सरगरम" :'JJ',
"सरगर्म" :'JJ',
"संरचनात्मक" :'JJ',
"संरचित" :'JJ',
"सरजीवन" :'JJ',
"सरद" :'JJ',
"सरंध्र" :'JJ',
"सरप्लस" :'JJ',
"सरफरोश" :'JJ',
"सरफ़रोश" :'JJ',
"सरबियाई" :'JJ',
"सरल" :'JJ',
"सरस" :'JJ',
"सरसब्ज़" :'JJ',
"सरहदी" :'JJ',
"सराबोर" :'JJ',
"सराहनीय" :'JJ',
"सरिस" :'JJ',
"सरीखा" :'JJ',
"सरूप" :'JJ',
"सरोजमुखी" :'JJ',
"सर्गपताली" :'JJ',
"सर्जक" :'JJ',
"सर्जनात्मक" :'JJ',
"सर्जिकल" :'JJ',
"सर्जित" :'JJ',
"सर्द" :'JJ',
"सर्दमिजाज" :'JJ',
"सर्दमिज़ाज" :'JJ',
"सर्पिल" :'JJ',
"सर्पिला" :'JJ',
"सर्पी" :'JJ',
"सर्प्लस" :'JJ',
"सर्बियाई" :'JJ',
"सर्व" :'JJ',
"सर्व संज्ञात" :'JJ',
"सर्व साधारण" :'JJ',
"सर्व सामान्य" :'JJ',
"सर्व-दलीय" :'JJ',
"सर्व-सामान्य" :'JJ',
"सर्वगुण संपन्न" :'JJ',
"सर्वगुण सम्पन्न" :'JJ',
"सर्वगुणसंपन्न" :'JJ',
"सर्वगुणसम्पन्न" :'JJ',
"सर्वगुणी" :'JJ',
"सर्वचारी" :'JJ',
"सर्वजनीन" :'JJ',
"सर्वज्ञ" :'JJ',
"सर्वज्ञात" :'JJ',
"सर्वज्ञाता" :'JJ',
"सर्वतोमुख" :'JJ',
"सर्वतोमुखी" :'JJ',
"सर्वदलीय" :'JJ',
"सर्वदेशी" :'JJ',
"सर्वदेशीय" :'JJ',
"सर्वनाशी" :'JJ',
"सर्वप्रधान प्रभु" :'JJ',
"सर्वप्रधान सत्ताधारी" :'JJ',
"सर्वप्रिय" :'JJ',
"सर्वभक्षी" :'JJ',
"सर्वभक्ष्य" :'JJ',
"सर्वभोगी" :'JJ',
"सर्वभोग्य" :'JJ',
"सर्वमान्य" :'JJ',
"सर्ववर्तुल" :'JJ',
"सर्वविदित" :'JJ',
"सर्वविद्यमान" :'JJ',
"सर्ववेत्ता" :'JJ',
"सर्वव्यापक" :'JJ',
"सर्वव्यापी" :'JJ',
"सर्वव्याप्त" :'JJ',
"सर्वशक्तिमान" :'JJ',
"सर्वशक्तिशाली" :'JJ',
"सर्वश्रेष्ठ" :'JJ',
"सर्वसम्मत" :'JJ',
"सर्वसाधारण" :'JJ',
"सर्वसामान्य" :'JJ',
"सर्वांग" :'JJ',
"सर्वांगीक" :'JJ',
"सर्वांगीण" :'JJ',
"सर्वांगीय" :'JJ',
"सर्वात्मवादी" :'JJ',
"सर्वाधिक" :'JJ',
"सर्वांश उदित" :'JJ',
"सर्वांशोदित" :'JJ',
"सर्वाहारी" :'JJ',
"सर्वेश" :'JJ',
"सर्वेश्वर" :'JJ',
"सर्वेश्वरवादी" :'JJ',
"सर्वोच्च" :'JJ',
"सर्वोत्कृष्ट" :'JJ',
"सर्वोत्तम" :'JJ',
"सर्वोपरि" :'JJ',
"संलग्न" :'JJ',
"सलज्ज" :'JJ',
"सलामत" :'JJ',
"सलामी" :'JJ',
"सलिल योनि" :'JJ',
"सलिल-योनि" :'JJ',
"सलिलचर" :'JJ',
"सलिलज" :'JJ',
"सलिलयोनि" :'JJ',
"सलीकादार" :'JJ',
"सलीकामंद" :'JJ',
"सलीक़ामंद" :'JJ',
"सलीकामन्द" :'JJ',
"सलीक़ामन्द" :'JJ',
"सलीकेदार" :'JJ',
"सलीक़ेदार" :'JJ',
"सलीकेमंद" :'JJ',
"सलीक़ेमंद" :'JJ',
"सलीकेमन्द" :'JJ',
"सलीक़ेमन्द" :'JJ',
"सलोना" :'JJ',
"सल्वाडोरी" :'JJ',
"सवर्गीय" :'JJ',
"सवर्ण" :'JJ',
"संवर्द्धक" :'JJ',
"संवर्द्धनीय" :'JJ',
"संवर्द्धित" :'JJ',
"संवर्धक" :'JJ',
"संवर्धनीय" :'JJ',
"संवर्धित" :'JJ',
"सवस्त्र" :'JJ',
"सवा" :'JJ',
"सवा गुना" :'JJ',
"सवाई" :'JJ',
"संवादशील" :'JJ',
"संवादी" :'JJ',
"सवाया" :'JJ',
"सवार" :'JJ',
"सवालिया" :'JJ',
"संविधानिक" :'JJ',
"संविधानीय" :'JJ',
"सविस्तार" :'JJ',
"संवृत" :'JJ',
"संवृत्त" :'JJ',
"संवेदनशील" :'JJ',
"संवेदनशून्य" :'JJ',
"संवेदनहारी" :'JJ',
"संवेदनारहित" :'JJ',
"संवेदनाशून्य" :'JJ',
"संवेदनाहारी" :'JJ',
"संवेदनाहीन" :'JJ',
"संवेदी" :'JJ',
"संवेद्य" :'JJ',
"संवैधानिक" :'JJ',
"सव्यसाची" :'JJ',
"सशंक" :'JJ',
"सशंकित" :'JJ',
"सशक्त" :'JJ',
"सशङ्क" :'JJ',
"सशङ्कित" :'JJ',
"सशत्रु" :'JJ',
"सशब्द" :'JJ',
"संशयशील" :'JJ',
"संशयहीन" :'JJ',
"संशयी" :'JJ',
"सशरीरी" :'JJ',
"सशस्त्र" :'JJ',
"सशुल्क" :'JJ',
"संशोधित" :'JJ',
"सश्रम" :'JJ',
"संश्लिष्ट" :'JJ',
"संसक्त" :'JJ',
"ससखा" :'JJ',
"संसदीय" :'JJ',
"संसर्गजन्य" :'JJ',
"ससहाय" :'JJ',
"संसारी" :'JJ',
"संसिद्ध" :'JJ',
"ससीम" :'JJ',
"संसूचित" :'JJ',
"संसृष्ट" :'JJ',
"संस्कारहीन" :'JJ',
"संस्कारात्मक" :'JJ',
"संस्कारी" :'JJ',
"संस्कृत" :'JJ',
"संस्कृति-संबंधी" :'JJ',
"सस्ता" :'JJ',
"सस्ता से सस्ता" :'JJ',
"संस्थागत" :'JJ',
"संस्थापनीय" :'JJ',
"संस्थापित" :'JJ',
"सह-संक्रामक" :'JJ',
"सहकारी" :'JJ',
"सहगामी" :'JJ',
"सहचर" :'JJ',
"सहज" :'JJ',
"सहज पाच्य" :'JJ',
"सहज प्राप्य" :'JJ',
"सहज विश्वासशील" :'JJ',
"सहज विश्वासी" :'JJ',
"सहजात" :'JJ',
"सहधर्म" :'JJ',
"सहधर्मी" :'JJ',
"सहनक्षम" :'JJ',
"सहनशील" :'JJ',
"सहनीय" :'JJ',
"सहभागी" :'JJ',
"सहमत" :'JJ',
"सहमति अप्राप्त" :'JJ',
"सहमति-प्राप्त" :'JJ',
"सहमतिहीन" :'JJ',
"सहयात्री" :'JJ',
"सहयोगी" :'JJ',
"सहल" :'JJ',
"सहसंक्रामक" :'JJ',
"सहसैनिक" :'JJ',
"सहस्त्राब्दि" :'JJ',
"सहस्र" :'JJ',
"सहस्राब्धि" :'JJ',
"सहानुभूतिशील" :'JJ',
"सहायक" :'JJ',
"सहायकयुक्त" :'JJ',
"सहायता प्राप्त" :'JJ',
"सहायतायुक्त" :'JJ',
"सहिष्णु" :'JJ',
"सही" :'JJ',
"संहृत" :'JJ',
"सहृदय" :'JJ',
"सहृदयी" :'JJ',
"सहोदर" :'JJ',
"सह्य" :'JJ',
"साइप्रसी" :'JJ',
"साइबर" :'JJ',
"साइबेरियाई" :'JJ',
"साइमीज़" :'JJ',
"साइमीस" :'JJ',
"साउज" :'JJ',
"साकार" :'JJ',
"सांकेतिक" :'JJ',
"साक्षर" :'JJ',
"साक्षात" :'JJ',
"साक्षात्" :'JJ',
"साक्षात्कारक" :'JJ',
"सागरी" :'JJ',
"सागरीय" :'JJ',
"सांगीतिक" :'JJ',
"सांग्रामिक" :'JJ',
"साँच" :'JJ',
"सांच" :'JJ',
"साँचा" :'JJ',
"सांचा" :'JJ',
"साचिविक" :'JJ',
"साठ" :'JJ',
"साठवाँ" :'JJ',
"साठवां" :'JJ',
"साठेक" :'JJ',
"साढ़े" :'JJ',
"साढ़े तीन" :'JJ',
"सात" :'JJ',
"सात सौ" :'JJ',
"सातगुना" :'JJ',
"सातवाँ" :'JJ',
"सातसौ" :'JJ',
"सातारी" :'JJ',
"सातेक" :'JJ',
"सात्विक" :'JJ',
"सादा" :'JJ',
"सांद्र" :'JJ',
"साधक" :'JJ',
"साधक-बाधक" :'JJ',
"साधकबाधक" :'JJ',
"साधन संपन्न" :'JJ',
"साधन सम्पन्न" :'JJ',
"साधनपूर्ण" :'JJ',
"साधनयुक्त" :'JJ',
"साधनरहित" :'JJ',
"साधनविहीन" :'JJ',
"साधनहीन" :'JJ',
"साधनीय" :'JJ',
"साधर्म" :'JJ',
"साधारण" :'JJ',
"साधिकार" :'JJ',
"साधित" :'JJ',
"साधुज" :'JJ',
"साधुजात" :'JJ',
"साध्य" :'JJ',
"साध्वी" :'JJ',
"सानंद" :'JJ',
"सानी" :'JJ',
"सान्द्र" :'JJ',
"सांपत्तिक" :'JJ',
"सांपरायिक" :'JJ',
"सापेक्ष" :'JJ',
"साप्ताहिक" :'JJ',
"सांप्रतिक" :'JJ',
"सांप्रदायिक" :'JJ',
"साफ" :'JJ',
"साफ़" :'JJ',
"साफ सुथरा" :'JJ',
"साफ-सुथरा" :'JJ',
"साफ़-सुथरा" :'JJ',
"साबित" :'JJ',
"साबुत" :'JJ',
"साबूत" :'JJ',
"सामंजस्यपूर्ण" :'JJ',
"सामंजस्यहीन" :'JJ',
"सामंतकालीन" :'JJ',
"सामंतवादी" :'JJ',
"सामंती" :'JJ',
"सामंतीय" :'JJ',
"सामने आया हुआ" :'JJ',
"सामने का" :'JJ',
"सामन्तकालीन" :'JJ',
"सामन्तवादी" :'JJ',
"सामन्ती" :'JJ',
"सामन्तीय" :'JJ',
"सामयिक" :'JJ',
"सामरिक" :'JJ',
"सामर्थी" :'JJ',
"सामर्थ्यवान" :'JJ',
"सामर्थ्यहीन" :'JJ',
"सामवेदिक" :'JJ',
"सामवेदीय" :'JJ',
"सामाजिक" :'JJ',
"सामान्य" :'JJ',
"सामिष" :'JJ',
"सामुदायिक" :'JJ',
"सामुद्रिक" :'JJ',
"सामूहिक" :'JJ',
"साम्परायिक" :'JJ',
"साम्प्रतिक" :'JJ',
"साम्प्रदायिक" :'JJ',
"साम्यवादी" :'JJ',
"सायमीज़" :'JJ',
"सायमीस" :'JJ',
"सारंग" :'JJ',
"सारपूर्ण" :'JJ',
"साररहित" :'JJ',
"सारस्वतीय" :'JJ',
"सारस्वत्य" :'JJ',
"सारहीन" :'JJ',
"सारा" :'JJ',
"सारा का सारा" :'JJ',
"सारिक" :'JJ',
"सार्थक" :'JJ',
"सार्वकालिक" :'JJ',
"सार्वजनिक" :'JJ',
"सार्वजनीन" :'JJ',
"सार्वजन्य" :'JJ',
"सार्वत्रिक" :'JJ',
"सार्वदेशिक" :'JJ',
"सार्वनामिक" :'JJ',
"सार्वभौम" :'JJ',
"सार्वभौमिक" :'JJ',
"सार्वलौकिक" :'JJ',
"सार्ववैदिक" :'JJ',
"साला" :'JJ',
"सालाना" :'JJ',
"सालियाना" :'JJ',
"सावज" :'JJ',
"सांवत्सरिक" :'JJ',
"सावधान" :'JJ',
"सावधि" :'JJ',
"सावधिक" :'JJ',
"सावनी" :'JJ',
"सावरिया" :'JJ',
"साँवरिया" :'JJ',
"साँवला" :'JJ',
"साँवलिया" :'JJ',
"सावित्र" :'JJ',
"साविद्वेष" :'JJ',
"सांविधानिक" :'JJ',
"सांविधिक" :'JJ',
"साश्रु" :'JJ',
"साँस रोक देनेवाला" :'JJ',
"सांसदीय" :'JJ',
"सांसारिक" :'JJ',
"सासूय" :'JJ',
"सांस्कृतिक" :'JJ',
"साहसपूर्ण" :'JJ',
"साहसहीन" :'JJ',
"साहसिक" :'JJ',
"साहसी" :'JJ',
"साहित्य प्रेमी" :'JJ',
"साहित्यिक" :'JJ',
"साहूकारी" :'JJ',
"सिएरा लिओनियन" :'JJ',
"सिएरा लिओनी" :'JJ',
"सिकतिल" :'JJ',
"सिकुड़ा" :'JJ',
"सिक्त" :'JJ',
"सिंगल स्टार" :'JJ',
"सिंगापुरी" :'JJ',
"सिंचा" :'JJ',
"सिंचित" :'JJ',
"सित" :'JJ',
"सितमगर" :'JJ',
"सितारापेशानी" :'JJ',
"सिंदूरिया" :'JJ',
"सिंदूरी" :'JJ',
"सिद्ध" :'JJ',
"सिद्धहस्त" :'JJ',
"सिद्धांतीय" :'JJ',
"सिंधव" :'JJ',
"सिंधी" :'JJ',
"सिंधुरगामिनी" :'JJ',
"सिनेगली" :'JJ',
"सिनेगलीज़" :'JJ',
"सिनेगलीस" :'JJ',
"सिन्दूरिया" :'JJ',
"सिन्दूरी" :'JJ',
"सिन्धव" :'JJ',
"सिन्धी" :'JJ',
"सिन्धुरगामिनी" :'JJ',
"सिंपल" :'JJ',
"सिपाहियाना" :'JJ',
"सिफला" :'JJ',
"सिफ़ला" :'JJ',
"सिमटा" :'JJ',
"सिम्पल" :'JJ',
"सियासती" :'JJ',
"सियासी" :'JJ',
"सियाह" :'JJ',
"सिरचढ़ा" :'JJ',
"सिरजनहार" :'JJ',
"सिरफिरा" :'JJ',
"सिर्फ" :'JJ',
"सिर्फ़" :'JJ',
"सिलसिला" :'JJ',
"सिलसिलेवार" :'JJ',
"सिलहपोश" :'JJ',
"सिला" :'JJ',
"सिल्क" :'JJ',
"सिल्की" :'JJ',
"सिंहली" :'JJ',
"सिंहोदरी" :'JJ',
"सींकिया पहलवान" :'JJ',
"सीक्रेट" :'JJ',
"सींगदार" :'JJ',
"सींगरहित" :'JJ',
"सींगहीन" :'JJ',
"सींगी" :'JJ',
"सीठा" :'JJ',
"सीढ़ीनुमा" :'JJ',
"सीधा" :'JJ',
"सीधा सरल" :'JJ',
"सीधा सादा" :'JJ',
"सीधा-सरल" :'JJ',
"सीधा-सादा" :'JJ',
"सीनाजोर" :'JJ',
"सीनाज़ोर" :'JJ',
"सीनियर" :'JJ',
"सीमा रक्षक" :'JJ',
"सीमा संरक्षक" :'JJ',
"सीमांकित" :'JJ',
"सीमापार" :'JJ',
"सीमापाल" :'JJ',
"सीमाबद्ध" :'JJ',
"सीमायुक्त" :'JJ',
"सीमारहित" :'JJ',
"सीमावर्ती" :'JJ',
"सीमित" :'JJ',
"सीया" :'JJ',
"सीरियन" :'JJ',
"सीरियाई" :'JJ',
"सीलनभरा" :'JJ',
"सीलबंद" :'JJ',
"सीलबन्द" :'JJ',
"सीला" :'JJ',
"सुकुमार" :'JJ',
"सुकुमारी" :'JJ',
"सुकूँ बख्श" :'JJ',
"सुकूँ बख़्श" :'JJ',
"सुकेतु" :'JJ',
"सुकेश" :'JJ',
"सुकेशा" :'JJ',
"सुकेशी" :'JJ',
"सुखकारी" :'JJ',
"सुखद" :'JJ',
"सुखदर्शन" :'JJ',
"सुखदाई" :'JJ',
"सुखदाय" :'JJ',
"सुखदायक" :'JJ',
"सुखदायी" :'JJ',
"सुखदैन" :'JJ',
"सुखप्रद" :'JJ',
"सुखभरा" :'JJ',
"सुखमय" :'JJ',
"सुखांत" :'JJ',
"सुखात्मक" :'JJ',
"सुखासीन" :'JJ',
"सुखिया" :'JJ',
"सुखी" :'JJ',
"सुखेच्छु" :'JJ',
"सुख्यात" :'JJ',
"सुगठित" :'JJ',
"सुगंधपूर्ण" :'JJ',
"सुगंधित" :'JJ',
"सुगन्धित" :'JJ',
"सुगम" :'JJ',
"सुगम्य" :'JJ',
"सुग्राही" :'JJ',
"सुग्राह्य" :'JJ',
"सुग्रीवा" :'JJ',
"सुघड़" :'JJ',
"सुघढ़" :'JJ',
"सुघर" :'JJ',
"सुचारु" :'JJ',
"सुचालक" :'JJ',
"सुचित" :'JJ',
"सुचित्त" :'JJ',
"सुजात" :'JJ',
"सुजातिया" :'JJ',
"सुजान" :'JJ',
"सुज्ञ" :'JJ',
"सुडौल" :'JJ',
"सुत्रीय" :'JJ',
"सुंदर" :'JJ',
"सुंदरतम" :'JJ',
"सुदर्श" :'JJ',
"सुदर्शन" :'JJ',
"सुदाम" :'JJ',
"सुदामन" :'JJ',
"सुदामा" :'JJ',
"सुदूर" :'JJ',
"सुदूरवर्ती" :'JJ',
"सुदृढ़" :'JJ',
"सुदेश" :'JJ',
"सुदेह" :'JJ',
"सुदोग्धी" :'JJ',
"सुदोघ" :'JJ',
"सुधमना" :'JJ',
"सुधर्मी" :'JJ',
"सुनम्य" :'JJ',
"सुनयन" :'JJ',
"सुनसान" :'JJ',
"सुनहरा" :'JJ',
"सुनहला" :'JJ',
"सुना" :'JJ',
"सुना हुआ" :'JJ',
"सुनाभ" :'JJ',
"सुनाभि" :'JJ',
"सुनामन्" :'JJ',
"सुनामा" :'JJ',
"सुनियत" :'JJ',
"सुनियोजित" :'JJ',
"सुनिर्धारित" :'JJ',
"सुनिवार्य" :'JJ',
"सुनिश्चित" :'JJ',
"सुनेत्र" :'JJ',
"सुन्दर" :'JJ',
"सुन्न" :'JJ',
"सुपक्व" :'JJ',
"सुपरिचित" :'JJ',
"सुपर्णक" :'JJ',
"सुपाच्य" :'JJ',
"सुपाठ्य" :'JJ',
"सुपात्र" :'JJ',
"सुपुर्द" :'JJ',
"सुप्त" :'JJ',
"सुप्तविग्रह" :'JJ',
"सुप्तस्थ" :'JJ',
"सुप्रकेत" :'JJ',
"सुप्रतिष्ठ" :'JJ',
"सुप्रतिष्ठित" :'JJ',
"सुप्रतीक" :'JJ',
"सुप्रसिद्ध" :'JJ',
"सुप्राप्य" :'JJ',
"सुफल" :'JJ',
"सुबाहु" :'JJ',
"सुबोध" :'JJ',
"सुभाषी" :'JJ',
"सुभी" :'JJ',
"सुमनित" :'JJ',
"सुमसुखड़ा" :'JJ',
"सुमुखी" :'JJ',
"सुयोग्य" :'JJ',
"सुरक्षात्मक" :'JJ',
"सुरक्षित" :'JJ',
"सुरत्य" :'JJ',
"सुरधामी" :'JJ',
"सुरभित" :'JJ',
"सुरमई" :'JJ',
"सुरम्य" :'JJ',
"सुरहीन" :'JJ',
"सुरामेही" :'JJ',
"सुराहीदार" :'JJ',
"सुरीनामी" :'JJ',
"सुरीनामीज़" :'JJ',
"सुरीनामीस" :'JJ',
"सुरीय" :'JJ',
"सुरीला" :'JJ',
"सुर्ख" :'JJ',
"सुर्ख़" :'JJ',
"सुर्खरू" :'JJ',
"सुर्ख़रू" :'JJ',
"सुर्ख़रूगण्य" :'JJ',
"सुलक्ष" :'JJ',
"सुलक्षण" :'JJ',
"सुलक्षणा" :'JJ',
"सुलक्षणी" :'JJ',
"सुलक्षन" :'JJ',
"सुलच्छन" :'JJ',
"सुलच्छना" :'JJ',
"सुलच्छनी" :'JJ',
"सुलझा" :'JJ',
"सुलझा हुआ" :'JJ',
"सुलतानी" :'JJ',
"सुलब्ध" :'JJ',
"सुलभ" :'JJ',
"सुलिखित" :'JJ',
"सुलेमानी" :'JJ',
"सुलोचन" :'JJ',
"सुल्तानी" :'JJ',
"सुवपु" :'JJ',
"सुवर्ण" :'JJ',
"सुवर्णीय" :'JJ',
"सुवासित" :'JJ',
"सुविकसित" :'JJ',
"सुविख्यात" :'JJ',
"सुविचारित" :'JJ',
"सुविज्ञ" :'JJ',
"सुविधाजनक" :'JJ',
"सुविधापूर्ण" :'JJ',
"सुविन्यस्त" :'JJ',
"सुविमर्शित" :'JJ',
"सुव्यवस्थित" :'JJ',
"सुशिक्षित" :'JJ',
"सुशील" :'JJ',
"सुशोभित" :'JJ',
"सुश्रुत" :'JJ',
"सुषिर" :'JJ',
"सुसज्जित" :'JJ',
"सुसंस्कृत" :'JJ',
"सुसुप्त" :'JJ',
"सुस्त" :'JJ',
"सुस्वर" :'JJ',
"सुस्वाद" :'JJ',
"सुस्वादु" :'JJ',
"सुहंग" :'JJ',
"सुहंगम" :'JJ',
"सुहागन" :'JJ',
"सुहागिन" :'JJ',
"सुहागिनी" :'JJ',
"सुहाना" :'JJ',
"सुहावन" :'JJ',
"सुहावना" :'JJ',
"सुहृद" :'JJ',
"सुहृदय" :'JJ',
"सुहेलरा" :'JJ',
"सुहेला" :'JJ',
"सूक्ष्म" :'JJ',
"सूक्ष्मतम" :'JJ',
"सूक्ष्मदर्शी" :'JJ',
"सूखा" :'JJ',
"सूखा-ग्रस्त" :'JJ',
"सूखाग्रस्त" :'JJ',
"सूँघा" :'JJ',
"सूंघा" :'JJ',
"सूँघा हुआ" :'JJ',
"सूंघा हुआ" :'JJ',
"सूचक" :'JJ',
"सूचनादायक" :'JJ',
"सूचनापरक" :'JJ',
"सूचित" :'JJ',
"सूचीबद्ध" :'JJ',
"सूच्य" :'JJ',
"सूच्यग्र" :'JJ',
"सूच्याकार" :'JJ',
"सूजा" :'JJ',
"सूडान-संबंधी" :'JJ',
"सूडानी" :'JJ',
"सूडानीज़" :'JJ',
"सूडानीस" :'JJ',
"सूत" :'JJ',
"सूती" :'JJ',
"सूत्री" :'JJ',
"सूत्रीय" :'JJ',
"सूना" :'JJ',
"सूफिया" :'JJ',
"सूफ़िया" :'JJ',
"सूफियाना" :'JJ',
"सूफ़ियाना" :'JJ',
"सूफी" :'JJ',
"सूफ़ी" :'JJ',
"सूम" :'JJ',
"सूरमा" :'JJ',
"सूराखदार" :'JJ',
"सूराख़दार" :'JJ',
"सूरीनामी" :'JJ',
"सूरीनामीज़" :'JJ',
"सूरीनामीस" :'JJ',
"सूर्यवंशी" :'JJ',
"सूर्यवंशीय" :'JJ',
"सृजक" :'JJ',
"सृजनकर्ता" :'JJ',
"सृजनशील" :'JJ',
"सृजनात्मक" :'JJ',
"सृजित" :'JJ',
"सृष्ट" :'JJ',
"सेचक" :'JJ',
"सेंचक" :'JJ',
"सेचित" :'JJ',
"सेंटिग्रेड" :'JJ',
"सेंदूरी" :'JJ',
"सेंद्रिय" :'JJ',
"सेनारहित" :'JJ',
"सेन्टिग्रेड" :'JJ',
"सेन्दूरी" :'JJ',
"सेन्द्रिय" :'JJ',
"सेफ" :'JJ',
"सेवनीय" :'JJ',
"सेवानिवृत्त" :'JJ',
"सेवामुक्त" :'JJ',
"सेवारत" :'JJ',
"सेवित" :'JJ',
"सेवितव्य" :'JJ',
"सेवी" :'JJ',
"सेव्य" :'JJ',
"सेशिल्जी" :'JJ',
"सेशिल्ज़ी" :'JJ',
"सेहतमंद" :'JJ',
"सैकड़ों" :'JJ',
"सैकत" :'JJ',
"सैंतालिस" :'JJ',
"सैंतालिसवाँ" :'JJ',
"सैंतालीस" :'JJ',
"सैंतालीसवाँ" :'JJ',
"सैंतिस" :'JJ',
"सैंतिसवाँ" :'JJ',
"सैंतीस" :'JJ',
"सैंतीसवाँ" :'JJ',
"सैद्धांतिक" :'JJ',
"सैद्धान्तिक" :'JJ',
"सैंधव" :'JJ',
"सैंधवक" :'JJ',
"सैन्धव" :'JJ',
"सैन्धवक" :'JJ',
"सैन्य" :'JJ',
"सोचनीय" :'JJ',
"सोचा विचारा" :'JJ',
"सोचा समझा" :'JJ',
"सोता" :'JJ',
"सोता हुआ" :'JJ',
"सोंधा" :'JJ',
"सोम" :'JJ',
"सोमवंशीय" :'JJ',
"सोमवंश्य" :'JJ',
"सोमवारी" :'JJ',
"सोमाल" :'JJ',
"सोमालियन" :'JJ',
"सोमालिया-संबंधी" :'JJ',
"सोमालियाई" :'JJ',
"सोमाली" :'JJ',
"सोया" :'JJ',
"सोल" :'JJ',
"सोलपोल" :'JJ',
"सोलह" :'JJ',
"सोलहवाँ" :'JJ',
"सोलापुरी" :'JJ',
"सोहन" :'JJ',
"सौ" :'JJ',
"सौ फीसदी" :'JJ',
"सौआँ" :'JJ',
"सौआं" :'JJ',
"सौएक" :'JJ',
"सौघा" :'JJ',
"सौतिया" :'JJ',
"सौतेला" :'JJ',
"सौंदर्य बोधात्मक" :'JJ',
"सौंदर्य शास्त्रीय" :'JJ',
"सौंदर्यपरक" :'JJ',
"सौंदर्यशास्त्रीय" :'JJ',
"सौंदर्यात्मक" :'JJ',
"सौंधा" :'JJ',
"सौन्दर्य शास्त्रीय" :'JJ',
"सौन्दर्यशास्त्रीय" :'JJ',
"सौंपा" :'JJ',
"सौंपा हुआ" :'JJ',
"सौफीसदी" :'JJ',
"सौभाग्यवती" :'JJ',
"सौभाग्यशाली" :'JJ',
"सौम" :'JJ',
"सौम्य" :'JJ',
"सौर" :'JJ',
"सौंरा" :'JJ',
"सौराथी" :'JJ',
"सौराष्ट्री" :'JJ',
"सौर्य" :'JJ',
"सौवाँ" :'JJ',
"सौवां" :'JJ',
"सौहार्दपूर्ण" :'JJ',
"स्कूली" :'JJ',
"स्कैंडिनेवियाई" :'JJ',
"स्खलित" :'JJ',
"स्टार्चयुक्त" :'JJ',
"स्टोनिआई" :'JJ',
"स्टोनियाई" :'JJ',
"स्ट्रेस फ्री" :'JJ',
"स्तनंधय" :'JJ',
"स्तनप" :'JJ',
"स्तनपायी" :'JJ',
"स्तनीय" :'JJ',
"स्तन्य" :'JJ',
"स्तब्ध" :'JJ',
"स्तंभित" :'JJ',
"स्तरयुक्त" :'JJ',
"स्तरित" :'JJ',
"स्तरीय" :'JJ',
"स्तुत्य" :'JJ',
"स्त्री संबंधी" :'JJ',
"स्त्री-संबंधी" :'JJ',
"स्त्री-सम्बन्धी" :'JJ',
"स्त्रीकार्य" :'JJ',
"स्त्रीजीत" :'JJ',
"स्त्रीनिर्जित" :'JJ',
"स्त्रीवश" :'JJ',
"स्त्रीवश्य" :'JJ',
"स्त्रैण" :'JJ',
"स्थगित" :'JJ',
"स्थलवासी" :'JJ',
"स्थलीय" :'JJ',
"स्थविर" :'JJ',
"स्थाई" :'JJ',
"स्थानच्युत" :'JJ',
"स्थानांतरित" :'JJ',
"स्थानान्तरित" :'JJ',
"स्थानापन्न" :'JJ',
"स्थानिक" :'JJ',
"स्थानीय" :'JJ',
"स्थापत्य" :'JJ',
"स्थापनीय" :'JJ',
"स्थापित" :'JJ',
"स्थाप्य" :'JJ',
"स्थायी" :'JJ',
"स्थावर" :'JJ',
"स्थित" :'JJ',
"स्थित-प्रज्ञ" :'JJ',
"स्थितप्रज्ञ" :'JJ',
"स्थिर" :'JJ',
"स्थिर-चित्त" :'JJ',
"स्थिरचित्त" :'JJ',
"स्थूल" :'JJ',
"स्थूलकाय" :'JJ',
"स्नात" :'JJ',
"स्नातकीय" :'JJ',
"स्नातकोत्तर" :'JJ',
"स्नानीय" :'JJ',
"स्नालु" :'JJ',
"स्निग्ध" :'JJ',
"स्नेहक" :'JJ',
"स्नेहन" :'JJ',
"स्नेहनीय" :'JJ',
"स्नेहरहित" :'JJ',
"स्नेही" :'JJ',
"स्पर्द्धी" :'JJ',
"स्पर्धात्मक" :'JJ',
"स्पर्धी" :'JJ',
"स्पर्शित" :'JJ',
"स्पर्शी" :'JJ',
"स्पष्ट" :'JJ',
"स्पष्ट लिखित" :'JJ',
"स्पष्टवादी" :'JJ',
"स्पिन" :'JJ',
"स्पिनर" :'JJ',
"स्पृश्य" :'JJ',
"स्पेनिश" :'JJ',
"स्पेनी" :'JJ',
"स्पेशल" :'JJ',
"स्पैनिश" :'JJ',
"स्फटिकाभ" :'JJ',
"स्फुटित" :'JJ',
"स्फूर्तिदायक" :'JJ',
"स्फूर्तिपूर्ण" :'JJ',
"स्फूर्तिप्रद" :'JJ',
"स्फूर्तियुक्त" :'JJ',
"स्फूर्तिहीन" :'JJ',
"स्मरणार्थ" :'JJ',
"स्मरणीय" :'JJ',
"स्मार्ट" :'JJ',
"स्मार्त" :'JJ',
"स्मित" :'JJ',
"स्मृतिहीन" :'JJ',
"स्याना" :'JJ',
"स्याह" :'JJ',
"स्रष्टा" :'JJ',
"स्रावित" :'JJ',
"स्लीक" :'JJ',
"स्लेटी" :'JJ',
"स्लोवाकियन" :'JJ',
"स्लोवाकियाई" :'JJ',
"स्लोवाकी" :'JJ',
"स्लोवेनिआई" :'JJ',
"स्लोवेनियाई" :'JJ',
"स्व" :'JJ',
"स्व-चालित" :'JJ',
"स्वकीय" :'JJ',
"स्वकृत" :'JJ',
"स्वगत" :'JJ',
"स्वचालित" :'JJ',
"स्वच्छ" :'JJ',
"स्वच्छंद" :'JJ',
"स्वच्छन्द" :'JJ',
"स्वजन भावनापूर्ण" :'JJ',
"स्वजनीय" :'JJ',
"स्वजन्मा" :'JJ',
"स्वजाति" :'JJ',
"स्वजातीय" :'JJ',
"स्वतंत्र" :'JJ',
"स्वतन्त्र" :'JJ',
"स्वत्वहीन" :'JJ',
"स्वदर्शी" :'JJ',
"स्वदेशी" :'JJ',
"स्वदेशीय" :'JJ',
"स्वनाम-धन्य" :'JJ',
"स्वनामधन्य" :'JJ',
"स्वनिर्भर" :'JJ',
"स्वपक्षी" :'JJ',
"स्वपक्षीय" :'JJ',
"स्वप्न द्रष्टा" :'JJ',
"स्वप्न-द्रष्टा" :'JJ',
"स्वप्नदर्शी" :'JJ',
"स्वप्नद्रष्टा" :'JJ',
"स्वप्नशील" :'JJ',
"स्वप्नालु" :'JJ',
"स्वप्निल" :'JJ',
"स्वप्नीय" :'JJ',
"स्वभावगत" :'JJ',
"स्वयधिगत" :'JJ',
"स्वयंपोषी" :'JJ',
"स्वयंबरा" :'JJ',
"स्वयंभु" :'JJ',
"स्वयंभू" :'JJ',
"स्वयमर्जित" :'JJ',
"स्वयंवरा" :'JJ',
"स्वयंसिद्ध" :'JJ',
"स्वरक्षित" :'JJ',
"स्वरचित" :'JJ',
"स्वरित" :'JJ',
"स्वरूप" :'JJ',
"स्वर्गवासी" :'JJ',
"स्वर्गिक" :'JJ',
"स्वर्गी" :'JJ',
"स्वर्गीय" :'JJ',
"स्वर्ण" :'JJ',
"स्वर्ण निर्मित" :'JJ',
"स्वर्णिम" :'JJ',
"स्वर्णिल" :'JJ',
"स्वल्प" :'JJ',
"स्वल्पायु" :'JJ',
"स्वल्पाहारी" :'JJ',
"स्वशिक्षित" :'JJ',
"स्वस्थ" :'JJ',
"स्वागतार्ह" :'JJ',
"स्वांगीकृत" :'JJ',
"स्वाजी" :'JJ',
"स्वाज़ी" :'JJ',
"स्वादपूर्ण" :'JJ',
"स्वादयुक्त" :'JJ',
"स्वादलोलुप" :'JJ',
"स्वादहीन" :'JJ',
"स्वादिष्ट" :'JJ',
"स्वादिष्ठ" :'JJ',
"स्वाधीन" :'JJ',
"स्वाध्यायी" :'JJ',
"स्वापक" :'JJ',
"स्वाभाविक" :'JJ',
"स्वाभाविक तरीके से सड़नशील" :'JJ',
"स्वाभाविक रूप से सड़नशील" :'JJ',
"स्वाभिमानहीन" :'JJ',
"स्वाभिमानी" :'JJ',
"स्वायत्त" :'JJ',
"स्वार्जित" :'JJ',
"स्वार्थपर" :'JJ',
"स्वार्थपरायण" :'JJ',
"स्वार्थहीन" :'JJ',
"स्वार्थांध" :'JJ',
"स्वार्थी" :'JJ',
"स्वावलंबिनी" :'JJ',
"स्वावलंबी" :'JJ',
"स्वावलम्बी" :'JJ',
"स्वास्थ्यकर" :'JJ',
"स्वास्थ्यनाशक" :'JJ',
"स्वास्थ्यप्रद" :'JJ',
"स्वास्थ्यवर्द्धक" :'JJ',
"स्वास्थ्यवर्धक" :'JJ',
"स्वाहा" :'JJ',
"स्वाहिलियन" :'JJ',
"स्वाहिली" :'JJ',
"स्वाहीलियन" :'JJ',
"स्वाहीली" :'JJ',
"स्विजरलैंडी" :'JJ',
"स्विजरलैण्डी" :'JJ',
"स्विट्जरलैंडी" :'JJ',
"स्विट्जरलैण्डी" :'JJ',
"स्विस" :'JJ',
"स्वीकरणीय" :'JJ',
"स्वीकारात्मक" :'JJ',
"स्वीकार्य" :'JJ',
"स्वीकृत" :'JJ',
"स्वीडिश" :'JJ',
"स्वेच्छाचारी" :'JJ',
"स्वेच्छित" :'JJ',
"स्वेदक" :'JJ',
"स्वेदज" :'JJ',
"स्वेदित" :'JJ',
"स्वेदी" :'JJ',
"स्वैच्छिक" :'JJ',
"स्वैजी" :'JJ',
"स्वैज़ी" :'JJ',
"स्वोपार्जित" :'JJ',
"हकदार" :'JJ',
"हक़दार" :'JJ',
"हकारांत" :'JJ',
"हकारादि" :'JJ',
"हकारान्त" :'JJ',
"हकीमी" :'JJ',
"हक़ीमी" :'JJ',
"हकीर" :'JJ',
"हक्का-बक्का" :'JJ',
"हंगामेदार" :'JJ',
"हजम" :'JJ',
"हज़म" :'JJ',
"हजार" :'JJ',
"हज़ार" :'JJ',
"हजारवाँ" :'JJ',
"हज़ारवाँ" :'JJ',
"हजारेक" :'JJ',
"हज़ारेक" :'JJ',
"हजारों" :'JJ',
"हज़ारों" :'JJ',
"हजूरी" :'JJ',
"हज़ूरी" :'JJ',
"हज्म" :'JJ',
"हज़्म" :'JJ',
"हटा" :'JJ',
"हटा हुआ" :'JJ',
"हटाया" :'JJ',
"हटाया हुआ" :'JJ',
"हट्टा कट्टा" :'JJ',
"हट्टा-कट्टा" :'JJ',
"हठयोगी" :'JJ',
"हठी" :'JJ',
"हठीला" :'JJ',
"हड़ताली" :'JJ',
"हड़बड़िया" :'JJ',
"हड़ीला" :'JJ',
"हत" :'JJ',
"हतप्रभ" :'JJ',
"हतबुद्धि" :'JJ',
"हताश" :'JJ',
"हताहत" :'JJ',
"हतोत्साहित" :'JJ',
"हत्थेदार" :'JJ',
"हत्यारा" :'JJ',
"हथकुटा" :'JJ',
"हथपिसा" :'JJ',
"हथियाया" :'JJ',
"हथियार-बंद" :'JJ',
"हथियारबंद" :'JJ',
"हद दरजे का" :'JJ',
"हद दर्जे का" :'JJ',
"हनु संबंधी" :'JJ',
"हन्य" :'JJ',
"हफ्तेवार" :'JJ',
"हबड़ा" :'JJ',
"हमउम्र" :'JJ',
"हमदर्द" :'JJ',
"हमराह" :'JJ',
"हमलावर" :'JJ',
"हमवार" :'JJ',
"हयारोही" :'JJ',
"हयावान्" :'JJ',
"हर" :'JJ',
"हर एक" :'JJ',
"हरजाई" :'JJ',
"हरणीय" :'JJ',
"हरना" :'JJ',
"हरफ़न मौला" :'JJ',
"हरफनमौला" :'JJ',
"हरयारणवी" :'JJ',
"हरा" :'JJ',
"हरा भरा" :'JJ',
"हरा-भरा" :'JJ',
"हराभरा" :'JJ',
"हराम" :'JJ',
"हरामजादा" :'JJ',
"हरामज़ादा" :'JJ',
"हरामी" :'JJ',
"हरित" :'JJ',
"हरियाणवी" :'JJ',
"हरियाणी" :'JJ',
"हरीरी" :'JJ',
"हरेक" :'JJ',
"हरैया" :'JJ',
"हर्ता" :'JJ',
"हर्त्ता" :'JJ',
"हर्वत्स्काई" :'JJ',
"हर्षदायक" :'JJ',
"हर्षित" :'JJ',
"हलका" :'JJ',
"हलका फुलका" :'JJ',
"हलका-फुलका" :'JJ',
"हलकान" :'JJ',
"हलचल मचाने वाला" :'JJ',
"हलंत" :'JJ',
"हलन्त" :'JJ',
"हलाल" :'JJ',
"हल्का" :'JJ',
"हल्का नीला" :'JJ',
"हल्का फुलका" :'JJ',
"हल्का फुल्का" :'JJ',
"हल्का लाल" :'JJ',
"हल्का-फुलका" :'JJ',
"हल्का-फुल्का" :'JJ',
"हवनीय" :'JJ',
"हवाई" :'JJ',
"हवादार" :'JJ',
"हवाबंद" :'JJ',
"हवालाती" :'JJ',
"हविष्य" :'JJ',
"हंसगमना" :'JJ',
"हंसगामिनी" :'JJ',
"हँसता" :'JJ',
"हँसता हुआ" :'JJ',
"हसमुख" :'JJ',
"हँसमुख" :'JJ',
"हसीं" :'JJ',
"हसीन" :'JJ',
"हसील" :'JJ',
"हँसोड़" :'JJ',
"हस्त चालित" :'JJ',
"हस्त-चालित" :'JJ',
"हस्त-निर्मित" :'JJ',
"हस्तक्षेपायोग्य" :'JJ',
"हस्तगत" :'JJ',
"हस्तचालित" :'JJ',
"हस्तनिर्मित" :'JJ',
"हस्तलिखित" :'JJ',
"हस्तांकित" :'JJ',
"हस्ताक्षरित" :'JJ',
"हस्तांतरित" :'JJ',
"हस्तान्कित" :'JJ',
"हस्तान्तरित" :'JJ',
"हस्तिदंती" :'JJ',
"हस्तिदन्ती" :'JJ',
"हाइब्रिड" :'JJ',
"हाई" :'JJ',
"हाई टेक" :'JJ',
"हाई-टेक" :'JJ',
"हाजिर" :'JJ',
"हाज़िर" :'JJ',
"हाजिरजवाब" :'JJ',
"हाज़िरजवाब" :'JJ',
"हाँडुरन" :'JJ',
"हाँडुरसी" :'JJ',
"हाथ का झूठा" :'JJ',
"हाथकुटा" :'JJ',
"हाथपिसा" :'JJ',
"हानिकर" :'JJ',
"हानिकारक" :'JJ',
"हानिप्रद" :'JJ',
"हामला" :'JJ',
"हामिला" :'JJ',
"हार्दिक" :'JJ',
"हार्य" :'JJ',
"हाल का" :'JJ',
"हालिया" :'JJ',
"हावी" :'JJ',
"हासिल" :'JJ',
"हास्य" :'JJ',
"हास्यजनक" :'JJ',
"हास्यपूर्ण" :'JJ',
"हास्यप्रद" :'JJ',
"हास्यरहित" :'JJ',
"हास्यहीन" :'JJ',
"हास्यास्पद" :'JJ',
"हास्योत्पादक" :'JJ',
"हितकर" :'JJ',
"हितकारक" :'JJ',
"हितकारी" :'JJ',
"हितचिंतक" :'JJ',
"हिताकांक्षी" :'JJ',
"हितैषी" :'JJ',
"हिंदी" :'JJ',
"हिंदुस्तानी" :'JJ',
"हिंदोस्तानी" :'JJ',
"हिन्दी" :'JJ',
"हिन्दुस्तानी" :'JJ',
"हिन्दोस्तानी" :'JJ',
"हिबरू" :'JJ',
"हिब्रू" :'JJ',
"हिमज" :'JJ',
"हिममय" :'JJ',
"हिमयुक्त" :'JJ',
"हिमवत्" :'JJ',
"हिमवान्" :'JJ',
"हिमाचल प्रदेशी" :'JJ',
"हिमाचल प्रदेशीय" :'JJ',
"हिमाचली" :'JJ',
"हिमाच्छादित" :'JJ',
"हिमायती" :'JJ',
"हिमालयी" :'JJ',
"हिम्मती" :'JJ',
"हिरण्मय" :'JJ',
"हिरासाँ" :'JJ',
"हिलता" :'JJ',
"हिलता-डुलता" :'JJ',
"हिला" :'JJ',
"हिला हुआ" :'JJ',
"हिलाया" :'JJ',
"हिलाया हुआ" :'JJ',
"हिंसक" :'JJ',
"हिंसाग्रस्त" :'JJ',
"हिंसात्मक" :'JJ',
"हिंसापीड़ित" :'JJ',
"हिसाबिया" :'JJ',
"हिसाबी" :'JJ',
"हिस्पानी" :'JJ',
"हिस्पैनिक" :'JJ',
"हिंस्र" :'JJ',
"हिंस्रक" :'JJ',
"हीन" :'JJ',
"हीनव्रत" :'JJ',
"हीलेबाज" :'JJ',
"हीलेबाज़" :'JJ',
"हुजूरी" :'JJ',
"हुज़ूरी" :'JJ',
"हुज्जती" :'JJ',
"हुनरमंद" :'JJ',
"हुनरमन्द" :'JJ',
"हुल्लड़बाज" :'JJ',
"हुल्लड़बाज़" :'JJ',
"हू-ब-हू" :'JJ',
"हूबहू" :'JJ',
"हृदय भंजक" :'JJ',
"हृदय विदारक" :'JJ',
"हृदय-विदारक" :'JJ',
"हृदयंगम" :'JJ',
"हृदयग्राही" :'JJ',
"हृदयवान" :'JJ',
"हृदयस्पर्शी" :'JJ',
"हृदयहारी" :'JJ',
"हृदयहीन" :'JJ',
"हृदयालु" :'JJ',
"हृदयिक" :'JJ',
"हृदयी" :'JJ',
"हृषु" :'JJ',
"हृष्ट" :'JJ',
"हृष्ट पुष्ट" :'JJ',
"हृष्ट-पुष्ट" :'JJ',
"हेक" :'JJ',
"हेकड़" :'JJ',
"हेममय" :'JJ',
"हेय" :'JJ',
"हेली-मेली" :'JJ',
"हैटियन" :'JJ',
"हैटी-संबंधी" :'JJ',
"हैतुक" :'JJ',
"हैदराबादी" :'JJ',
"हैबतनाक" :'JJ',
"हैम" :'JJ',
"हैमन" :'JJ',
"हैमना" :'JJ',
"हैमवत" :'JJ',
"हैरत अंगेज" :'JJ',
"हैरत अंगेज़" :'JJ',
"हैरतअंगेज" :'JJ',
"हैरतंगेज" :'JJ',
"हैरतजदा" :'JJ',
"हैरतज़दा" :'JJ',
"हैरान" :'JJ',
"हैवानी" :'JJ',
"हॉन्डुरन" :'JJ',
"हॉन्डुरसी" :'JJ',
"होंडुरन" :'JJ',
"होंडुरसी" :'JJ',
"होनहार" :'JJ',
"होन्डुरन" :'JJ',
"होन्डुरसी" :'JJ',
"होममेड" :'JJ',
"होमियोपैथिक" :'JJ',
"होम्योपैथिक" :'JJ',
"होर" :'JJ',
"होशमंद" :'JJ',
"होशमन्द" :'JJ',
"होशियार" :'JJ',
"हौलदिला" :'JJ',
"हौसलेवाला" :'JJ',
"ह्रस्व" :'JJ',
"ह्रीकु" :'JJ'
}
|
"""Fluke 8588A 8.5 digit DMM"""
import testgear.base_classes as base
class F8588A(base.meter):
def init(self):
self.idstr = self.query("*IDN?").strip()
self.set_timeout(30)
def get_reading(self, channel=None):
#self.__select_channel(channel)
return float(self.query("READ?"))
def conf_function_DCV(self, mrange=1000, nplc=200, AutoZero=True, HiZ=True, channel=None):
"""configures the meter to measure DCV. if range=None the meter is set to Autorange"""
self.__select_channel(channel)
self.__conf_range("VOLT:DC", mrange, nplc)
if HiZ:
self.write(":SENSE:VOLT:DC:IMPedance AUTO")
else:
self.write(":SENSE:VOLT:DC:IMPedance 10M")
def conf_function_DCI(self, mrange=None, nplc=100, AutoZero=True, HiZ=True, channel=None):
"""configures the meter to measure DCI. if range=None the meter is set to Autorange"""
self.__select_channel(channel)
self.__conf_range("CURR:DC", mrange, nplc)
def conf_function_ACV(self, mrange=None, nplc=100, AutoZero=True, HiZ=True, channel=None):
"""configures the meter to measure DCV. if range=None the meter is set to Autorange"""
self.__select_channel(channel)
self.__conf_range("VOLT:AC", mrange, nplc)
def conf_function_ACI(self, mrange=None, nplc=100, AutoZero=True, HiZ=True, channel=None):
"""configures the meter to measure DCV. if range=None the meter is set to Autorange"""
self.__select_channel(channel)
self.__conf_range("CURR:AC", mrange, nplc)
def conf_function_OHM2W(self, mrange=None, nplc=100, AutoZero=True, OffsetCompensation=False, channel=1):
"""configures the meter to measure DCV. if range=None the meter is set to Autorange"""
self.__select_channel(channel)
self.__conf_range("RES", mrange, nplc)
#Offset Compensation only supported on 4W mode
def conf_function_OHM4W(self, mrange=None, nplc=200, AutoZero=True, OffsetCompensation=True, channel=1):
"""configures the meter to measure 4w resistance. if range=None the meter is set to Autorange"""
self.__select_channel(channel)
self.__conf_range("FRES", mrange, nplc)
if OffsetCompensation:
self.write(":SENSE:FRES:MODE TRUE") #True Ohms
else:
self.write(":SENSE:FRES:MODE NORM")
def __select_channel(self, channel):
if channel is None:
return 0
if channel == 2:
self.select_terminal("REAR")
else:
self.select_terminal("FRONT")
return 1
def select_terminal(self, terminal="FRONT"):
"""select terminal for measurement FRONT or REAR"""
self.write(":ROUTe:Terminals {0}".format(terminal))
def __conf_range(self, prefix:str, mrange, nplc):
self.write(':SENS:FUNC "{0:s}"'.format(prefix))
self.write(":SENSE:{0:s}:RES MIN".format(prefix))
if mrange is None:
self.write(":SENS:{0:s}:RANGE:AUTO ON".format(prefix))
else:
self.write(":SENSE:{0:s}:RANGE {1:0.6g}".format(prefix, mrange))
self.__set_nplc(prefix, nplc)
def __set_nplc(self, prefix:str, nplc):
self.write(":SENSE:{0:s}:NPLC {1:d}".format(prefix, nplc))
|
from typing import Sequence
from apispec import APISpec
from starlette.routing import BaseRoute, Mount, Route
from .operation import setup_route_operations
from .utils import convert_path
__all__ = ('setup_routes',)
def setup_routes(routes: Sequence[BaseRoute],
spec: APISpec, version: int = 2,
add_head_methods: bool = False,
path: str = ''):
for route in routes:
if isinstance(route, Mount):
setup_routes(route.routes, spec, version=version, add_head_methods=add_head_methods,
path=f'{path}{route.path}')
continue
elif isinstance(route, Route):
if not route.include_in_schema:
continue
endpoint = getattr(route.endpoint, '__endpoint__', None)
if endpoint is None:
continue
operations = setup_route_operations(route, endpoint, version=version,
add_head_methods=add_head_methods)
route_path = f'{path}{route.path}'
spec.path(convert_path(route_path), operations=operations)
|
'''
################################################################################
#
# SiEPIC-Tools
#
################################################################################
Circuit simulations using Lumerical INTERCONNECT and a Compact Model Library
- run_INTC: run INTERCONNECT using Python integration
- INTC_commandline: invoke INTC via the command line, with an lsf file as input.
- Setup_Lumerical_KLayoutPython_integration
Configure PATH env, import lumapi, run interconnect,
Install technology CML, read CML elements
- circuit_simulation: netlist extract and run simulation
- circuit_simulation_update_netlist: update netlist and run simulation
- circuit_simulation_monte_carlo: perform many simulations
- component_simulation: single component simulation
usage:
import SiEPIC.lumerical.interconnect
################################################################################
'''
import pya
def run_INTC(verbose=False):
from . import load_lumapi
from .. import _globals
lumapi = _globals.LUMAPI
if not lumapi:
print("SiEPIC.lumerical.interconnect.run_INTC: lumapi not loaded; reloading load_lumapi.")
import sys
if sys.version_info[0] == 3:
if sys.version_info[1] < 4:
from imp import reload
else:
from importlib import reload
elif sys.version_info[0] == 2:
from imp import reload
reload(load_lumapi)
if not lumapi:
print("SiEPIC.lumerical.interconnect.run_INTC: lumapi not loaded")
pya.MessageBox.warning("Cannot load Lumerical Python integration.", "Cannot load Lumerical Python integration. \nSome SiEPIC-Tools Lumerical functionality will not be available.", pya.MessageBox.Cancel)
return
if verbose:
print(_globals.INTC) # Python Lumerical INTERCONNECT integration handle
if not _globals.INTC: # Not running, start a new session
_globals.INTC = lumapi.open('interconnect')
if verbose:
print(_globals.INTC) # Python Lumerical INTERCONNECT integration handle
else: # found open INTC session
try:
lumapi.evalScript(_globals.INTC, "?'KLayout integration test.\n';\n")
except: # but can't communicate with INTC; perhaps it was closed by the user
_globals.INTC = lumapi.open('interconnect') # run again.
if verbose:
print(_globals.INTC) # Python Lumerical INTERCONNECT integration handle
try: # check again
lumapi.evalScript(_globals.INTC, "?'KLayout integration test.\n';\n")
except:
raise Exception ("Can't run Lumerical INTERCONNECT via Python integration.")
def Setup_Lumerical_KLayoutPython_integration(verbose=False):
import sys, os, string, pya
from ..utils import get_technology, get_technology_by_name
# get current technology
TECHNOLOGY = get_technology(query_activecellview_technology=True)
# load more technology details (CML file location)
TECHNOLOGY = get_technology_by_name(TECHNOLOGY['technology_name'])
# location for the where the CMLs will locally be installed:
dir_path = os.path.join(pya.Application.instance().application_data_path(), 'Lumerical_CMLs')
try:
libraries = [n for n in pya.Library.library_names() if (pya.Library.library_by_name(n).technology == TECHNOLOGY['technology_name'])]
for n in [pya.Library.library_by_name(l) for l in libraries]:
print(n.layout().meta_info_value("path"))
except:
pass
question = pya.QMessageBox()
question.setStandardButtons(pya.QMessageBox.Yes | pya.QMessageBox.No)
question.setDefaultButton(pya.QMessageBox.Yes)
question.setText("SiEPIC-Tools will install the Compact Model Library (CML) in Lumerical INTERCONNECT for the currently active technology. \nThis includes the libraries %s. \nProceed?" % libraries)
question.setInformativeText("\nTechnology: %s\nSource CML file: %s\nInstall location: %s" % (TECHNOLOGY['technology_name'], TECHNOLOGY['INTC_CML_path'], dir_path ))
if(pya.QMessageBox_StandardButton(question.exec_()) == pya.QMessageBox.No):
return
##################################################################
# Load Lumerical API:
from .. import _globals
run_INTC()
lumapi = _globals.LUMAPI
if not lumapi:
print('SiEPIC.lumerical.interconnect.Setup_Lumerical_KLayoutPython_integration: lumapi not loaded')
return
import os
# Read INTC element library
lumapi.evalScript(_globals.INTC, "out=library;")
_globals.INTC_ELEMENTS=lumapi.getVar(_globals.INTC, "out")
# Install technology CML if missing in INTC
# check if the latest version of the CML is in KLayout's tech
if not ("design kits::"+TECHNOLOGY['technology_name'].lower()+"::"+TECHNOLOGY['INTC_CML_version'].lower().replace('.cml','').lower()) in _globals.INTC_ELEMENTS:
# install CML
print("Lumerical INTC, installdesignkit ('%s', '%s', true);" % (TECHNOLOGY['INTC_CML_path'], dir_path ) )
lumapi.evalScript(_globals.INTC, "installdesignkit ('%s', '%s', true);" % (TECHNOLOGY['INTC_CML_path'], dir_path ) )
# Re-Read INTC element library
lumapi.evalScript(_globals.INTC, "out=library;")
_globals.INTC_ELEMENTS=lumapi.getVar(_globals.INTC, "out")
# Close INTERCONNECT so that the library information is saved, then re-open
lumapi.close(_globals.INTC)
run_INTC()
# Save INTC element library to KLayout application data path
if not os.path.exists(dir_path):
os.makedirs(dir_path)
fh = open(os.path.join(dir_path,"Lumerical_INTC_CMLs.txt"), "w")
fh.writelines(_globals.INTC_ELEMENTS)
fh.close()
lumapi.evalScript(_globals.INTC, "message('KLayout-Lumerical INTERCONNECT integration successful, CML library (%s) is available.');switchtodesign;\n" % ("design kits::"+TECHNOLOGY['technology_name'].lower()) )
# instantiate all library elements onto the canvas
question = pya.QMessageBox()
question.setStandardButtons(pya.QMessageBox.Yes | pya.QMessageBox.No)
question.setDefaultButton(pya.QMessageBox.Yes)
question.setText("Do you wish to see all the components in the library?")
# question.setInformativeText("Do you wish to see all the components in the library?")
if(pya.QMessageBox_StandardButton(question.exec_()) == pya.QMessageBox.No):
# lumapi.evalScript(_globals.INTC, "b=0:0.01:10; plot(b,sin(b),'Congratulations, Lumerical is now available from KLayout','','Congratulations, Lumerical is now available from KLayout');")
return
intc_elements = _globals.INTC_ELEMENTS.split('\n')
# tech_elements = [ e.split('::')[-1] for e in intc_elements if "design kits::"+TECHNOLOGY['technology_name'].lower()+"::" in e ]
tech_elements = [ e for e in intc_elements if "design kits::"+TECHNOLOGY['technology_name'].lower()+"::" in e ]
i, x, y, num = 0, 0, 0, len(tech_elements)
for i in range(0, num):
lumapi.evalScript(_globals.INTC, "a=addelement('%s'); setposition(a,%s,%s); " % (tech_elements[i],x,y) )
y += 250
if (i+1) % int(num**0.5) == 0:
x += 250
y = 0
def INTC_commandline(filename2):
print ("Running Lumerical INTERCONNECT using the command interface.")
import sys, os, string
if sys.platform.startswith('linux'):
import subprocess
# Linux-specific code here...
print("Running INTERCONNECT")
# Location of INTERCONNECT program (this found from RPM installation)
file_path = '/opt/lumerical/interconnect/bin/interconnect'
subprocess.Popen([file_path, '-run', filename2])
elif sys.platform.startswith('darwin'):
# OSX specific
import sys
if int(sys.version[0]) > 2:
import subprocess
subprocess.Popen(['/usr/bin/open -n /Applications/Lumerical/INTERCONNECT/INTERCONNECT.app', '-run', '--args -run %s' % filename2])
else:
import commands
print("Running INTERCONNECT")
runcmd = ('source ~/.bash_profile; /usr/bin/open -n /Applications/Lumerical/INTERCONNECT/INTERCONNECT.app --args -run %s' % filename2)
print("Running in shell: %s" % runcmd)
a=commands.getstatusoutput(runcmd)
print(a)
elif sys.platform.startswith('win'):
# Windows specific code here
import subprocess
print("Running INTERCONNECT")
#check Interconnect installation directory
file_path_a = 'C:\\Program Files\\Lumerical\\INTERCONNECT\\bin\\interconnect.exe'
file_path_b = 'C:\\Program Files (x86)\\Lumerical\\INTERCONNECT\\bin\\interconnect.exe'
if(os.path.isfile(file_path_a)==True):
subprocess.Popen(args=[file_path_a, '-run', filename2], shell=True)
elif(os.path.isfile(file_path_b)==True):
subprocess.Popen(args=[file_path_b, '-run', filename2], shell=True)
else:
warning_window = pya.QMessageBox()
warning_window.setText("Warning: The program could not find INTERCONNECT.")
warning_window.setInformativeText("Do you want to specify it manually?")
warning_window.setStandardButtons(pya.QMessageBox.Yes | pya.QMessageBox.Cancel);
warning_window.setDefaultButton(pya.QMessageBox.Yes)
response = warning_window.exec_()
if(response == pya.QMessageBox.Yes):
dialog = pya.QFileDialog()
path = str(dialog.getOpenFileName())
path = path.replace('/', '\\')
subprocess.Popen(args=[path, '-run', filename2], shell=True)
def component_simulation(verbose=False, simulate=True):
import sys, os, string
from .. import _globals
# get selected instances
from ..utils import select_instances
selected_instances = select_instances()
from ..utils import get_layout_variables
TECHNOLOGY, lv, ly, cell = get_layout_variables()
# check that it is one or more:
error = pya.QMessageBox()
error.setStandardButtons(pya.QMessageBox.Ok )
if len(selected_instances) == 0:
error.setText("Error: Need to have a component selected.")
return
warning = pya.QMessageBox()
warning.setStandardButtons(pya.QMessageBox.Yes | pya.QMessageBox.Cancel)
warning.setDefaultButton(pya.QMessageBox.Yes)
if len(selected_instances) > 1 :
warning.setText("Warning: More than one component selected.")
warning.setInformativeText("Do you want to Proceed?")
if(pya.QMessageBox_StandardButton(warning.exec_()) == pya.QMessageBox.Cancel):
return
# Check if the component has a compact model loaded in INTERCONNECT
# Loop if more than one component selected
for obj in selected_instances:
# *** not working. .returns Flattened.
# c = obj.inst().cell.find_components()[0]
if verbose:
print(" selected component: %s" % obj.inst().cell )
c = cell.find_components(cell_selected=[obj.inst().cell])
if c:
c=c[0]
else:
continue
if not c.has_model():
if len(selected_instances) == 0:
error.setText("Error: Component '%s' does not have a compact model. Cannot perform simulation." % c)
continue
# GUI to ask which pin to inject light into
pin_names = [p.pin_name for p in c.pins if p.type == _globals.PIN_TYPES.OPTICAL or p.type == _globals.PIN_TYPES.OPTICALIO]
if not pin_names:
continue
pin_injection = pya.InputDialog.ask_item("Pin selection", "Choose one of the pins in component '%s' to inject light into." % c.component, pin_names, 0)
if not pin_injection:
return
if verbose:
print("Pin selected from InputDialog = %s, for component '%s'." % (pin_injection, c.component) )
# Write spice netlist and simulation script
from ..utils import get_technology
TECHNOLOGY = get_technology() # get current technology
import SiEPIC
from time import strftime
text_main = '* Spice output from KLayout SiEPIC-Tools v%s, %s technology (SiEPIC.lumerical.interconnect.component_simulation), %s.\n\n' % (SiEPIC.__version__, TECHNOLOGY['technology_name'], strftime("%Y-%m-%d %H:%M:%S") )
# find electrical IO pins
electricalIO_pins = ""
DCsources = "" # string to create DC sources for each pin
Vn = 1
# (2) or to individual DC sources
# create individual sources:
for p in c.pins:
if p.type == _globals.PIN_TYPES.ELECTRICAL:
NetName = " " + c.component +'_' + str(c.idx) + '_' + p.pin_name
electricalIO_pins += NetName
DCsources += "N" + str(Vn) + NetName + " dcsource amplitude=0 sch_x=%s sch_y=%s\n" % (-2-Vn/3., -2+Vn/8.)
Vn += 1
electricalIO_pins_subckt = electricalIO_pins
# component nets: must be ordered electrical, optical IO, then optical
nets_str = ''
DCsources = "" # string to create DC sources for each pin
Vn = 1
for p in c.pins:
if p.type == _globals.PIN_TYPES.ELECTRICAL:
if not p.pin_name:
continue
NetName = " " + c.component +'_' + str(c.idx) + '_' + p.pin_name
nets_str += NetName
DCsources += "N" + str(Vn) + NetName + " dcsource amplitude=0 sch_x=%s sch_y=%s\n" % (-2-Vn/3., -2+Vn/8.)
Vn += 1
if p.type == _globals.PIN_TYPES.OPTICAL or p.type == _globals.PIN_TYPES.OPTICALIO:
nets_str += " " + str(p.pin_name)
# *** todo: some other way of getting this information; not hard coded.
# GUI? Defaults from PCell?
orthogonal_identifier=1
wavelength_start=1500
wavelength_stop=1600
wavelength_points=2000
text_main += '* Optical Network Analyzer:\n'
text_main += '.ona input_unit=wavelength input_parameter=start_and_stop\n + minimum_loss=80\n + analysis_type=scattering_data\n + multithreading=user_defined number_of_threads=1\n'
text_main += ' + orthogonal_identifier=%s\n' % orthogonal_identifier
text_main += ' + start=%4.3fe-9\n' % wavelength_start
text_main += ' + stop=%4.3fe-9\n' % wavelength_stop
text_main += ' + number_of_points=%s\n' % wavelength_points
for i in range(0,len(pin_names)):
text_main += ' + input(%s)=SUBCIRCUIT,%s\n' % (i+1, pin_names[i])
text_main += ' + output=SUBCIRCUIT,%s\n\n' % (pin_injection)
text_main += DCsources
text_main += 'SUBCIRCUIT %s SUBCIRCUIT sch_x=-1 sch_y=-1 \n\n' % (nets_str)
text_main += '.subckt SUBCIRCUIT %s\n' % (nets_str)
text_main += ' %s %s %s ' % ( c.component.replace(' ', '_') +"_1", nets_str, c.component.replace(' ', '_') )
if c.library != None:
text_main += 'library="%s" %s ' % (c.library, c.params)
text_main += '\n.ends SUBCIRCUIT\n'
from .. import _globals
tmp_folder = _globals.TEMP_FOLDER
import os
filename = os.path.join(tmp_folder, '%s_main.spi' % c.component)
filename2 = os.path.join(tmp_folder, '%s.lsf' % c.component)
filename_icp = os.path.join(tmp_folder, '%s.icp' % c.component)
# Write the Spice netlist to file
file = open(filename, 'w')
file.write (text_main)
file.close()
if verbose:
print(text_main)
'''
# Ask user whether to start a new visualizer, or use an existing one.
opt_in_labels = [o['opt_in'] for o in opt_in]
opt_in_labels.insert(0,'All opt-in labels')
opt_in_selection_text = pya.InputDialog.ask_item("opt_in selection", "Choose one of the opt_in labels, to fetch experimental data.", opt_in_labels, 0)
if not opt_in_selection_text: # user pressed cancel
pass
'''
# Write the Lumerical INTERCONNECT start-up script.
text_lsf = 'switchtolayout;\n'
text_lsf += "cd('%s');\n" % tmp_folder
text_lsf += 'deleteall;\n'
text_lsf += "importnetlist('%s');\n" % filename
text_lsf += "save('%s');\n" % filename_icp
text_lsf += 'run;\n'
if 0:
for i in range(0, len(pin_names)):
text_lsf += 'h%s = haveresult("ONA_1", "input %s/mode 1/gain");\n' % (i+1, i+1)
text_lsf += 'if (h%s>0) { visualize(getresult("ONA_1", "input %s/mode 1/gain")); } \n' % (i+1, i+1)
if 1:
text_lsf += 't = "";\n'
for i in range(0, len(pin_names)):
text_lsf += 'h%s = haveresult("ONA_1", "input %s/mode 1/gain");\n' % (i+1, i+1)
text_lsf += 'if (h%s>0) { t%s = getresult("ONA_1", "input %s/mode 1/gain"); t=t+"t%s,"; } \n' % (i+1, i+1, i+1, i+1)
text_lsf += 't = substring(t, 1, length(t) - 1);\n'
text_lsf += 'eval("visualize(" + t + ");");\n'
file = open(filename2, 'w')
file.write (text_lsf)
file.close()
if verbose:
print(text_lsf)
if simulate:
# Run using Python integration:
try:
from .. import _globals
run_INTC()
# Run using Python integration:
lumapi = _globals.LUMAPI
lumapi.evalScript(_globals.INTC, "cd ('" + tmp_folder + "');")
lumapi.evalScript(_globals.INTC, "feval('"+ c.component + "');\n")
except:
from .. import scripts
scripts.open_folder(tmp_folder)
INTC_commandline(filename)
else:
from .. import scripts
scripts.open_folder(tmp_folder)
def circuit_simulation_toolbar():
circuit_simulation(verbose=False,opt_in_selection_text=[], matlab_data_files=[], simulate=True)
def circuit_simulation(verbose=False,opt_in_selection_text=[], matlab_data_files=[], simulate=True):
print ('*** circuit_simulation(), opt_in: %s' % opt_in_selection_text)
if verbose:
print('*** circuit_simulation()')
# check for supported operating system, tested on:
# Windows 7, 10
# OSX Sierra, High Sierra
# Linux
import sys
if not any([sys.platform.startswith(p) for p in {"win","linux","darwin"}]):
raise Exception("Unsupported operating system: %s" % sys.platform)
from .. import _globals
from SiEPIC.utils import get_layout_variables
TECHNOLOGY, lv, layout, topcell = get_layout_variables()
# Save the layout prior to running simulations, if there are changes.
mw = pya.Application.instance().main_window()
if mw.manager().has_undo():
mw.cm_save()
layout_filename = mw.current_view().active_cellview().filename()
if len(layout_filename) == 0:
raise Exception("Please save your layout before running the simulation")
# *** todo
# Add the "disconnected" component to all disconnected pins
# optical_waveguides, optical_components = terminate_all_disconnected_pins()
# Output the Spice netlist:
text_Spice, text_Spice_main, num_detectors, detector_list = \
topcell.spice_netlist_export(verbose=verbose, opt_in_selection_text=opt_in_selection_text)
if not text_Spice:
raise Exception("No netlist available. Cannot run simulation.")
return
if verbose:
print(text_Spice)
circuit_name = topcell.name.replace('.','') # remove "."
if '_' in circuit_name[0]:
circuit_name = ''.join(circuit_name.split('_', 1)) # remove leading _
from .. import _globals
tmp_folder = _globals.TEMP_FOLDER
import os
filename = os.path.join(tmp_folder, '%s_main.spi' % circuit_name)
filename_subckt = os.path.join(tmp_folder, '%s.spi' % circuit_name)
filename2 = os.path.join(tmp_folder, '%s.lsf' % circuit_name)
filename_icp = os.path.join(tmp_folder, '%s.icp' % circuit_name)
text_Spice_main += '.INCLUDE "%s"\n\n' % (filename_subckt)
# Write the Spice netlist to file
file = open(filename, 'w')
file.write (text_Spice_main)
file.close()
file = open(filename_subckt, 'w')
file.write (text_Spice)
file.close()
# Write the Lumerical INTERCONNECT start-up script.
file = open(filename2, 'w')
text_lsf = 'switchtolayout;\n'
text_lsf += 'deleteall;\n'
text_lsf += "importnetlist('%s');\n" % filename
text_lsf += 'addproperty("::Root Element::%s", "MC_uniformity_thickness", "wafer", "Matrix");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_uniformity_width", "wafer", "Matrix");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_grid", "wafer", "Number");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_resolution_x", "wafer", "Number");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_resolution_y", "wafer", "Number");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_non_uniform", "wafer", "Number");\n' % circuit_name
text_lsf += 'select("::Root Element::%s");\n' % circuit_name
text_lsf += 'set("run setup script",2);\n'
text_lsf += "save('%s');\n" % filename_icp
text_lsf += 'run;\n'
for i in range(1, num_detectors+1):
if matlab_data_files:
# convert simulation data into simple datasets:
wavelenth_scale = 1e9
text_lsf += 'temp = getresult("ONA_1", "input %s/mode 1/gain");\n' % i
text_lsf += 't%s = matrixdataset("Simulation");\n' % i
text_lsf += 't%s.addparameter("wavelength",temp.wavelength*%s);\n' % (i, wavelenth_scale)
text_lsf += 't%s.addattribute("Simulation, Detector %s",getresultdata("ONA_1", "input %s/mode 1/gain"));\n' % (i,i, i)
else:
text_lsf += 't%s = getresult("ONA_1", "input %s/mode 1/gain");\n' % (i, i)
# load measurement data files
m_count=0
if matlab_data_files:
for m in matlab_data_files:
if '.mat' in m:
m_count += 1
# *** todo, use DFT rules to determine which measurements we should load.
# INTERCONNECT load data
head, tail = os.path.split(m)
tail = tail.split('.mat')[0]
text_lsf += 'matlabload("%s", scandata);\n' % m
text_lsf += 'm%s = matrixdataset("Measurement");\n' % m_count
text_lsf += 'm%s.addparameter("wavelength",scandata.wavelength*%s);\n' % (m_count, wavelenth_scale)
for d in detector_list:
text_lsf += 'm%s.addattribute("Measured: %s",scandata.power(:,%s));\n' % (m_count, tail, d)
text_lsf += 'visualize(t1'
for i in range(2, num_detectors+1):
text_lsf += ', t%s' % i
for i in range(1, m_count+1):
text_lsf += ', m%s' % i
text_lsf += ');\n'
file.write (text_lsf)
file.close()
if verbose:
print(text_lsf)
if simulate:
# Run using Python integration:
try:
from .. import _globals
run_INTC()
# Run using Python integration:
lumapi = _globals.LUMAPI
lumapi.evalScript(_globals.INTC, "?'';")
except:
from .. import scripts
scripts.open_folder(tmp_folder)
INTC_commandline(filename)
print('SiEPIC.lumerical.interconnect: circuit_simulation: error 1')
try:
lumapi.evalScript(_globals.INTC, "cd ('" + tmp_folder + "');\n")
print("feval('"+ circuit_name + "');\n")
lumapi.evalScript(_globals.INTC, "feval('"+ circuit_name + "');\n")
except:
print('SiEPIC.lumerical.interconnect: circuit_simulation: error 2')
pass
else:
from .. import scripts
scripts.open_folder(tmp_folder)
if verbose:
print('Done Lumerical INTERCONNECT circuit simulation.')
def circuit_simulation_update_netlist():
print('update netlist')
def circuit_simulation_monte_carlo(params = None, topcell = None, verbose=True, opt_in_selection_text=[], matlab_data_files=[], simulate=True):
print('*** circuit_simulation_monte_carlo()')
from .. import _globals
from ..utils import get_layout_variables
if topcell is None:
TECHNOLOGY, lv, ly, topcell = get_layout_variables()
else:
TECHNOLOGY, lv, _, _ = get_layout_variables()
ly = topcell.layout()
if params is None: params = _globals.MC_GUI.get_parameters()
if params is None:
pya.MessageBox.warning("No MC parameters", "No Monte Carlo parameters. Cancelling.", pya.MessageBox.Cancel)
return
print(params)
if int(params['num_wafers'])<1:
pya.MessageBox.warning("Insufficient number of wafers", "The number of wafers for Monte Carlo simulations need to be 1 or more.", pya.MessageBox.Cancel)
return
if int(params['num_dies'])<1:
pya.MessageBox.warning("Insufficient number of dies", "The number of die per wafer for Monte Carlo simulations need to be 1 or more.", pya.MessageBox.Cancel)
return
circuit_name = topcell.name.replace('.','') # remove "."
if '_' in circuit_name[0]:
circuit_name = ''.join(circuit_name.split('_', 1)) # remove leading _
if verbose:
print('*** circuit_simulation_monte_carlo()')
# check for supported operating system, tested on:
# Windows 7, 10
# OSX Sierra, High Sierra
# Linux
import sys
if not any([sys.platform.startswith(p) for p in {"win","linux","darwin"}]):
raise Exception("Unsupported operating system: %s" % sys.platform)
# Save the layout prior to running simulations, if there are changes.
mw = pya.Application.instance().main_window()
if mw.manager().has_undo():
mw.cm_save()
layout_filename = mw.current_view().active_cellview().filename()
if len(layout_filename) == 0:
pya.MessageBox.warning("Please save your layout before running the simulation.", "Please save your layout before running the simulation.", pya.MessageBox.Cancel)
return
# *** todo
# Add the "disconnected" component to all disconnected pins
# optical_waveguides, optical_components = terminate_all_disconnected_pins()
# Output the Spice netlist:
text_Spice, text_Spice_main, num_detectors, detector_list = \
topcell.spice_netlist_export(verbose=verbose, opt_in_selection_text=opt_in_selection_text)
if not text_Spice:
pya.MessageBox.warning("No netlist available.", "No netlist available. Cannot run simulation.", pya.MessageBox.Cancel)
return
if verbose:
print(text_Spice)
tmp_folder = _globals.TEMP_FOLDER
import os
filename = os.path.join(tmp_folder, '%s_main.spi' % circuit_name)
filename_subckt = os.path.join(tmp_folder, '%s.spi' % circuit_name)
filename2 = os.path.join(tmp_folder, '%s.lsf' % circuit_name)
filename_icp = os.path.join(tmp_folder, '%s.icp' % circuit_name)
text_Spice_main += '.INCLUDE "%s"\n\n' % (filename_subckt)
# Write the Spice netlist to file
file = open(filename, 'w')
file.write (text_Spice_main)
file.close()
file = open(filename_subckt, 'w')
file.write (text_Spice)
file.close()
# Write the Lumerical INTERCONNECT start-up script.
file = open(filename2, 'w')
text_lsf = '###DEVELOPER:Zeqin Lu, zqlu@ece.ubc.ca, University of British Columbia \n'
text_lsf += 'switchtolayout;\n'
text_lsf += 'deleteall;\n'
text_lsf += "importnetlist('%s');\n" % filename
text_lsf += 'addproperty("::Root Element", "wafer_uniformity_thickness", "wafer", "Matrix");\n'
text_lsf += 'addproperty("::Root Element", "wafer_uniformity_width", "wafer", "Matrix");\n'
text_lsf += 'addproperty("::Root Element", "N", "wafer", "Number");\n'
text_lsf += 'addproperty("::Root Element", "selected_die", "wafer", "Number");\n'
text_lsf += 'addproperty("::Root Element", "wafer_length", "wafer", "Number");\n'
text_lsf += 'addproperty("::Root Element::%s", "MC_uniformity_thickness", "wafer", "Matrix");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_uniformity_width", "wafer", "Matrix");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_grid", "wafer", "Number");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_resolution_x", "wafer", "Number");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_resolution_y", "wafer", "Number");\n' % circuit_name
text_lsf += 'addproperty("::Root Element::%s", "MC_non_uniform", "wafer", "Number");\n' % circuit_name
text_lsf += 'select("::Root Element::%s");\n' % circuit_name
text_lsf += 'set("MC_non_uniform",99);\n'
text_lsf += 'n_wafer = %s; \n' % params['num_wafers'] # GUI INPUT: Number of testing wafer
text_lsf += 'n_die = %s; \n' % params['num_dies'] # GUI INPUT: Number of testing die per wafer
text_lsf += 'kk = 1; \n'
text_lsf += 'select("ONA_1");\n'
text_lsf += 'num_points = get("number of points");\n'
for i in range(0, num_detectors):
text_lsf += 'mc%s = matrixdataset("mc%s"); # initialize visualizer data, mc%s \n' % (i+1, i+1, i+1)
text_lsf += 'Gain_Data_input%s = matrix(num_points,n_wafer*n_die); \n' % (i+1)
###Define histograms datasets
if(params['histograms']['fsr']==True):
text_lsf += 'fsr_dataset = matrix(1,n_wafer*n_die,1);\n'
if(params['histograms']['wavelength']==True):
text_lsf += 'freq_dataset = matrix(1,n_wafer*n_die,1);\n'
if(params['histograms']['gain']==True):
text_lsf += 'gain_dataset = matrix(1,n_wafer*n_die,1);\n'
text_lsf += '#Run Monte Carlo simulations; \n'
text_lsf += 'for (jj=1; jj<=n_wafer; jj=jj+1) { \n'
############################## Wafer generation ###########################################
text_lsf += ' wafer_length = %s; \n' % 100e-3 # datadict["wafer_length_x"] # [m], GUI INPUT: wafer length
text_lsf += ' wafer_cl_width = %s; \n' % params['waf_var']['width']['corr_len'] # [m], GUI INPUT: wafer correlation length
text_lsf += ' wafer_cl_thickness = %s; \n' % params['waf_var']['height']['corr_len'] # [m], GUI INPUT: wafer correlation length
text_lsf += ' wafer_clx_width = wafer_cl_width; \n'
text_lsf += ' wafer_cly_width = wafer_cl_width; \n'
text_lsf += ' wafer_clx_thickness = wafer_cl_thickness; \n'
text_lsf += ' wafer_cly_thickness = wafer_cl_thickness; \n'
text_lsf += ' N = 500; \n'
text_lsf += ' wafer_grid=wafer_length/N; \n'
text_lsf += ' wafer_RMS_w = %s; \n' % params['waf_var']['width']['std_dev'] # [nm], GUI INPUT: Within wafer Sigma RMS for width
text_lsf += ' wafer_RMS_t = %s; \n' % params['waf_var']['height']['std_dev'] # [nm], GUI INPUT: Within wafer Sigma RMS for thickness
text_lsf += ' x = linspace(-wafer_length/2,wafer_length/2,N); \n'
text_lsf += ' y = linspace(-wafer_length/2,wafer_length/2,N); \n'
text_lsf += ' xx = meshgridx(x,y) ; \n'
text_lsf += ' yy = meshgridy(x,y) ; \n'
text_lsf += ' wafer_Z_thickness = wafer_RMS_t*randnmatrix(N,N); \n'
text_lsf += ' wafer_F_thickness = exp(-(xx^2/(wafer_clx_thickness^2/2)+yy^2/(wafer_cly_thickness^2/2))); \n' # Gaussian filter
text_lsf += ' wafer_uniformity_thickness = real( 2/sqrt(pi)*wafer_length/N/sqrt(wafer_clx_thickness)/sqrt(wafer_cly_thickness)*invfft(fft(wafer_Z_thickness,1,0)*fft(wafer_F_thickness,1,0), 1, 0) ); \n' # wafer created using Gaussian filter
text_lsf += ' wafer_Z_width = wafer_RMS_w*randnmatrix(N,N); \n'
text_lsf += ' wafer_F_width = exp(-(xx^2/(wafer_clx_width^2/2)+yy^2/(wafer_cly_width^2/2))); \n' # Gaussian filter
text_lsf += ' wafer_uniformity_width = real( 2/sqrt(pi)*wafer_length/N/sqrt(wafer_clx_width)/sqrt(wafer_cly_width)*invfft(fft(wafer_Z_width,1,0)*fft(wafer_F_width,1,0), 1, 0) ); \n' # wafer created using Gaussian filter
######################## adjust Wafer mean ###################
text_lsf += ' mean_RMS_w = %s; \n' % params['waf_to_waf_var']['width']['std_dev'] # [nm], GUI INPUT: wafer Sigma RMS for width
text_lsf += ' mean_RMS_t = %s; \n' % params['waf_to_waf_var']['thickness']['std_dev'] # [nm], GUI INPUT: wafer Sigma RMS for thickness
text_lsf += ' wafer_uniformity_thickness = wafer_uniformity_thickness + randn(0,mean_RMS_t); \n'
text_lsf += ' wafer_uniformity_width = wafer_uniformity_width + randn(0,mean_RMS_w); \n'
##################################### pass wafer to Root ###################
text_lsf += ' #pass wafers to object \n'
text_lsf += ' select("::Root Element"); \n'
text_lsf += ' set("wafer_uniformity_thickness", wafer_uniformity_thickness); \n'
text_lsf += ' set("wafer_uniformity_width", wafer_uniformity_width); \n'
text_lsf += ' set("N",N); \n'
text_lsf += ' set("wafer_length",wafer_length); \n'
#################################### embed wafer selection script in Root ###################
text_lsf += ' select("::Root Element");\n'
text_lsf += ' set("setup script",'+ "'" + ' \n'
text_lsf += ' ######################## high resolution interpolation for dies ################# \n'
text_lsf += ' MC_grid = 5e-6; \n' # [m], mesh grid
text_lsf += ' die_span_x = %s; \n' % 5e-3 # datadict["die_length_x"] # [m] GUI INPUT: die length X
text_lsf += ' die_span_y = %s; \n' % 5e-3 # datadict["die_length_y"] # [m] GUI INPUT: die length Y
text_lsf += ' MC_resolution_x = die_span_x/MC_grid; \n'
text_lsf += ' MC_resolution_y = die_span_y/MC_grid; \n'
text_lsf += ' die_num_x = floor(wafer_length/die_span_x); \n'
text_lsf += ' die_num_y = floor(wafer_length/die_span_y); \n'
text_lsf += ' die_num_total = die_num_x*die_num_y; \n'
text_lsf += ' x = linspace(-wafer_length/2,wafer_length/2,N); \n'
text_lsf += ' y = linspace(-wafer_length/2,wafer_length/2,N); \n'
# pick die for simulation, and do high resolution interpolation
text_lsf += ' j=selected_die; \n'
text_lsf += ' die_min_x = -wafer_length/2+(j-1)*die_span_x -floor((j-1)/die_num_x)*wafer_length; \n'
text_lsf += ' die_max_x = -wafer_length/2+j*die_span_x -floor((j-1)/die_num_x)*wafer_length; \n'
text_lsf += ' die_min_y = wafer_length/2-ceil(j/die_num_y)*die_span_y; \n'
text_lsf += ' die_max_y = wafer_length/2-(ceil(j/die_num_y)-1)*die_span_y; \n'
text_lsf += ' x_die = linspace(die_min_x, die_max_x, MC_resolution_x); \n'
text_lsf += ' y_die = linspace(die_min_y, die_max_y, MC_resolution_y); \n'
text_lsf += ' die_xx = meshgridx(x_die,y_die) ; \n'
text_lsf += ' die_yy = meshgridy(x_die,y_die) ; \n'
text_lsf += ' MC_uniformity_thickness = interp(wafer_uniformity_thickness, x, y, x_die, y_die); # interpolation \n'
text_lsf += ' MC_uniformity_width = interp(wafer_uniformity_width, x, y, x_die, y_die); # interpolation \n'
######################### pass die to object ####################################
text_lsf += ' select("::Root Element::%s"); \n' % circuit_name
text_lsf += ' set("MC_uniformity_thickness",MC_uniformity_thickness); \n'
text_lsf += ' set("MC_uniformity_width",MC_uniformity_width); \n'
text_lsf += ' set("MC_resolution_x",MC_resolution_x); \n'
text_lsf += ' set("MC_resolution_y",MC_resolution_y); \n'
text_lsf += ' set("MC_grid",MC_grid); \n'
text_lsf += ' set("MC_non_uniform",1); \n'
text_lsf += " '"+'); \n'
text_lsf += ' for (ii=1; ii<=n_die; ii=ii+1) { \n'
text_lsf += ' switchtodesign; \n'
text_lsf += ' setnamed("ONA_1","peak analysis", "single");\n'
text_lsf += ' select("::Root Element"); \n'
text_lsf += ' set("selected_die",ii); \n'
text_lsf += ' run;\n'
text_lsf += ' select("ONA_1");\n'
text_lsf += ' T=getresult("ONA_1","input 1/mode 1/transmission");\n'
text_lsf += ' wavelength = T.wavelength;\n'
for i in range(0, num_detectors):
text_lsf += ' if (kk==1) { mc%s.addparameter("wavelength",wavelength);} \n' % (i+1)
text_lsf += ' mc%s.addattribute("run", getattribute( getresult("ONA_1", "input %s/mode 1/gain"), getattribute(getresult("ONA_1", "input %s/mode 1/gain")) ) );\n' % (i+1, i+1, i+1)
text_lsf += ' Gain_Data_input%s(1:num_points, kk) = getattribute( getresult("ONA_1", "input %s/mode 1/gain"), getattribute(getresult("ONA_1", "input %s/mode 1/gain")) ); \n' % (i+1, i+1, i+1)
#add simulation data to their corresponding datalists
if(params['histograms']['fsr']==True):
text_lsf += ' fsr_select = getresult("ONA_1", "input 1/mode 1/peak/free spectral range");\n'
text_lsf += ' fsr_dataset(1,kk) = real(fsr_select.getattribute(getattribute(fsr_select)));\n'
if(params['histograms']['wavelength']==True):
text_lsf += ' freq_dataset(1,kk) = getresult("ONA_1", "input 1/mode 1/peak/frequency");\n'
if(params['histograms']['gain']==True):
text_lsf += ' gain_select = getresult("ONA_1", "input 1/mode 1/peak/gain");\n'
text_lsf += ' gain_dataset(1,kk) = real(gain_select.getattribute(getattribute(gain_select)));\n'
text_lsf += ' switchtodesign; \n'
text_lsf += ' kk = kk + 1; \n'
text_lsf += ' }\n' # end for wafer iteration
text_lsf += '}\n' # end for die iteration
text_lsf += '?"Spectrum data for each input can be found in the Script Workspace tab:";\n'
for i in range(0, num_detectors):
text_lsf += '?"Gain_Data_input%s"; \n' %(i+1)
text_lsf += '?"Plot spectrums using script: plot(wavelength, Gain_Data_input#)";\n'
for i in range(0, num_detectors):
text_lsf += 'visualize(mc%s);\n' % (i+1)
#### Display Histograms for the selected components
#FSR
if(params['histograms']['fsr']==True):
text_lsf += 'dataset = fsr_dataset*1e9;\n' #select fsr dataset defined above
text_lsf += 'bin_hist = max( [ 10, (max(dataset)-min(dataset)) / std(dataset) * 10 ]);\n' #define number of bins according to the number of data
text_lsf += 'histc(dataset, bin_hist, "Free Spectral Range (nm)", "Count", "Histogram - FSR");\n' #generate histogram
text_lsf += 'legend("Mean: " + num2str(mean(dataset)) + ", Std Dev: " + num2str(std(dataset)));\n' #define plot legends
#wavelength
if(params['histograms']['wavelength']==True):
text_lsf += 'dataset = freq_dataset*1e9;\n'
text_lsf += 'num_hist = max( [ 10, (max(dataset)-min(dataset)) / std(dataset) * 10 ]);\n'
text_lsf += 'histc(dataset, bin_hist, "Wavelength (nm)", "Count", "Histogram - Peak wavelength");\n'
text_lsf += 'legend("Mean: " + num2str(mean(dataset)) + ", Std Dev: " + num2str(std(dataset)));\n'
#Gain
if(params['histograms']['gain']==True):
text_lsf += 'dataset = gain_dataset;\n'
text_lsf += 'num_hist = max( [ 10, (max(dataset)-min(dataset)) / std(dataset) * 10 ]);\n'
text_lsf += 'histc(dataset, bin_hist, "Gain (dB)", "Count", "Histogram - Peak gain");\n'
text_lsf += 'legend("Mean: " + num2str(mean(dataset)) + ", Std Dev: " + num2str(std(dataset)));\n'
'''
for i in range(1, num_detectors+1):
if matlab_data_files:
# convert simulation data into simple datasets:
wavelenth_scale = 1e9
text_lsf += 'temp = getresult("ONA_1", "input %s/mode 1/gain");\n' % i
text_lsf += 't%s = matrixdataset("Simulation");\n' % i
text_lsf += 't%s.addparameter("wavelength",temp.wavelength*%s);\n' % (i, wavelenth_scale)
text_lsf += 't%s.addattribute("Simulation, Detector %s",getresultdata("ONA_1", "input %s/mode 1/gain"));\n' % (i,i, i)
else:
text_lsf += 't%s = getresult("ONA_1", "input %s/mode 1/gain");\n' % (i, i)
# load measurement data files
m_count=0
if matlab_data_files:
for m in matlab_data_files:
if '.mat' in m:
m_count += 1
# INTERCONNECT can't deal with our measurement files... load and save data.
from scipy.io import loadmat, savemat # used to load MATLAB data files
# *** todo, use DFT rules to determine which measurements we should load.
PORT=2 # Which Fibre array port is the output connected to?
matData = loadmat(m, squeeze_me=True, struct_as_record=False)
wavelength = matData['scandata'].wavelength
power = matData['scandata'].power[:,PORT-1]
savemat(m, {'wavelength': wavelength, 'power': power})
# INTERCONNECT load data
head, tail = os.path.split(m)
tail = tail.split('.mat')[0]
text_lsf += 'matlabload("%s");\n' % m
text_lsf += 'm%s = matrixdataset("Measurement");\n' % m_count
text_lsf += 'm%s.addparameter("wavelength",wavelength*%s);\n' % (m_count, wavelenth_scale)
text_lsf += 'm%s.addattribute("Measured: %s",power);\n' % (m_count, tail)
text_lsf += 'visualize(t1'
for i in range(2, num_detectors+1):
text_lsf += ', t%s' % i
for i in range(1, m_count+1):
text_lsf += ', m%s' % i
text_lsf += ');\n'
'''
file.write (text_lsf)
file.close()
if verbose:
print(text_lsf)
if simulate:
# Run using Python integration:
try:
from .. import _globals
run_INTC()
# Run using Python integration:
lumapi = _globals.LUMAPI
lumapi.evalScript(_globals.INTC, "cd ('" + tmp_folder + "');")
lumapi.evalScript(_globals.INTC, "feval('"+ circuit_name + "');\n")
except:
from .. import scripts
scripts.open_folder(tmp_folder)
INTC_commandline(filename)
else:
from .. import scripts
scripts.open_folder(tmp_folder)
if verbose:
print('Done Lumerical INTERCONNECT Monte Carlo circuit simulation.')
|
from collections import defaultdict, deque
class Graph(object):
# makes the default value for all vertices an empty list
def __init__(self):
self.nodes = set()
self.edges = defaultdict(list)
self.distances = {}
def add_node(self, value):
self.nodes.add(value)
def add_edge(self, from_node, to_node, distance):
self.edges[from_node].append(to_node)
self.edges[to_node].append(from_node)
self.distances[(from_node, to_node)] = distance
def dijkstra(graph, initial):
# initializations
visited = {initial: 0}
path = {}
nodes = set(graph.nodes)
while nodes:
#while min node is none
min_node = None
#go through nodes in nodes set
for node in nodes:
if node in visited:
if min_node is None:
#set node that is visiterd first as minimal
min_node = node
#if visited node is < than visited min node set it as min node
elif visited[node] < visited[min_node]:
min_node = node
#if min node is not found break
if min_node is None:
break
nodes.remove(min_node)
#set curreng weight of node as min
current_weight = visited[min_node]
for edge in graph.edges[min_node]:
try:
# node weigth + vertex to next node
weight = current_weight + graph.distances[(min_node, edge)]
except:
continue
# if its not visited set them weight an min node
if edge not in visited or weight < visited[edge]:
visited[edge] = weight
path[edge] = min_node
return visited, path
def shortest_path(graph, origin, destination):
#set all path tha was found
visited, paths = dijkstra(graph, origin)
full_path = deque()
_destination = paths[destination]
#while end point is not start point append destination to path
while _destination != origin:
full_path.appendleft(_destination)
_destination = paths[_destination]
full_path.appendleft(origin)
full_path.append(destination)
#return shortest way
return visited[destination], list(full_path)
if __name__ == '__main__':
graph = Graph()
with open('input.txt') as read_file:
n = int(read_file.readline())
for i in range(n):
node_list = read_file.readline().split()
graph.add_node(node_list[0])
graph.add_node(node_list[1])
graph.add_edge(node_list[0], node_list[1], int(node_list[2]))
points = read_file.readline().split()
start_point = points[0]
end_point = points[1]
print( shortest_path(graph, start_point, end_point))
|
import torch
import numpy as np
from models import PointCMLP
from utils import score, create_test_set
MODEL_PATH = 'pretrained_models/mlgp_clean.tar'
# MODEL_PATH = 'pretrained_models/mlgp_pi4_noisy_02.tar'
# MODEL_PATH = 'pretrained_models/baseline_pi4_noisy_02.tar'
# MODEL_PATH = 'pretrained_models/vanilla_pi4_noisy_02.tar'
if __name__ == '__main__':
# get the data:
print('\ncreating test data............')
Xtest, Ytest = create_test_set(distortion=0.0)
# or, e.g., for the noisy theta-split experiment:
# Xtest, Ytest = create_test_set(distortion=0.2, theta_train=[[0.0, 1/2], [1/8, 5/8]], theta_test=[[1/8, 5/8], [1/2, 1.0]])
# other options (depending on the pretrained model):
# Xtest_clean, Ytest_clean = create_test_set(distortion=None)
# Xtest_noisy, Ytest_noisy = create_test_set(distortion=0.1)
# Xtest_noisy_02, Ytest_noisy_02 = create_test_set(distortion=0.2)
# Xtest_pi4_clean, Ytest_pi4_clean = create_test_set(distortion=None, theta_train=[[0.0, 1/2], [1/8, 5/8]], theta_test=[[1/8, 5/8], [1/2, 1.0]])
# Xtest_pi4_noisy, Ytest_pi4_noisy = create_test_set(distortion=0.1, theta_train=[[0.0, 1/2], [1/8, 5/8]], theta_test=[[1/8, 5/8], [1/2, 1.0]])
if 'baseline' in MODEL_PATH:
sample_size = torch.tensor(Xtest[0].shape).prod().item()
Xtest = Xtest.reshape(-1, 1, sample_size)
# load the model:
if not torch.cuda.is_available():
model_dic = torch.load(MODEL_PATH, map_location ='cpu')
else:
model_dic = torch.load(MODEL_PATH)
model = model_dic['model']
if torch.cuda.is_available():
model = model.cuda()
Xtest, Ytest = Xtest.cuda(), Ytest.cuda()
# evaluate on the test data:
Ytest_pred = model(Xtest).detach_()
test_acc = score(Ytest_pred, Ytest)
print('\nmodel:', model_dic['name'], '\n\ntest acc:', np.round(test_acc, 5))
|
"""Utilities for progress tracking and display to the user."""
import importlib
import os
import sys
import threading
import time
import uuid
import warnings
from datetime import timedelta
from html import escape
from shutil import get_terminal_size
import numpy as np
from ..exceptions import ValidationError
from ..rc import rc
from .ipython import check_ipy_version, get_ipython
if get_ipython() is not None:
from IPython.display import Javascript, display # pragma: no cover
class MemoryLeakWarning(UserWarning):
pass
warnings.filterwarnings("once", category=MemoryLeakWarning)
def timestamp2timedelta(timestamp):
"""Convert timestamp to timedelta."""
if timestamp == -1:
return "Unknown"
return timedelta(seconds=np.ceil(timestamp))
def _load_class(name):
mod_name, cls_name = name.rsplit(".", 1)
mod = importlib.import_module(mod_name)
return getattr(mod, cls_name)
class Progress:
"""Stores and tracks information about the progress of some process.
This class is to be used as part of a ``with`` statement. Use ``step()`` to
update the progress.
Parameters
----------
max_steps : int
The total number of calculation steps of the process.
name_during : str, optional
Short description of the task to be used while it is running.
name_after : str, optional
Short description of the task to be used after it has
finished. Defaults to ``name_during``.
Attributes
----------
max_steps : int, optional
The total number of calculation steps of the process, if known.
name_after : str
Name of the task to be used after it has finished.
name_during : str
Name of the task to be used while it is running.
steps : int
Number of completed steps.
success : bool or None
Whether the process finished successfully. ``None`` if the process
did not finish yet.
time_end : float
Time stamp of the time the process was finished or aborted.
time_start : float
Time stamp of the time the process was started.
Examples
--------
.. testcode::
from nengo.utils.progress import Progress
max_steps = 10
with Progress(max_steps=max_steps) as progress:
for i in range(max_steps):
# do something
progress.step()
"""
def __init__(self, name_during="", name_after=None, max_steps=None):
if max_steps is not None and max_steps <= 0:
raise ValidationError(
f"must be at least 1 (got {max_steps})", attr="max_steps"
)
self.n_steps = 0
self.max_steps = max_steps
self.name_during = name_during
if name_after is None:
name_after = name_during
self.name_after = name_after
self.time_start = self.time_end = time.time()
self.finished = False
self.success = None
@property
def progress(self):
"""The current progress as a number from 0 to 1 (inclusive).
Returns
-------
float
"""
if self.max_steps is None:
return 0.0
return min(1.0, self.n_steps / self.max_steps)
def elapsed_seconds(self):
"""The number of seconds passed since entering the ``with`` statement.
Returns
-------
float
"""
if self.finished:
return self.time_end - self.time_start
else:
return time.time() - self.time_start
def eta(self):
"""The estimated number of seconds until the process is finished.
Stands for estimated time of arrival (ETA).
If no estimate is available -1 will be returned.
Returns
-------
float
"""
if self.progress > 0.0:
return (1.0 - self.progress) * self.elapsed_seconds() / self.progress
else:
return -1
def __enter__(self):
self.finished = False
self.success = None
self.n_steps = 0
self.time_start = time.time()
return self
def __exit__(self, exc_type, dummy_exc_value, dummy_traceback):
self.success = exc_type is None
if self.success and self.max_steps is not None:
self.n_steps = self.max_steps
self.time_end = time.time()
self.finished = True
def step(self, n=1):
"""Advances the progress.
Parameters
----------
n : int
Number of steps to advance the progress by.
"""
self.n_steps += n
class ProgressBar:
"""Visualizes the progress of a process.
This is an abstract base class that progress bar classes some inherit from.
Progress bars should visually displaying the progress in some way.
"""
def update(self, progress):
"""Updates the displayed progress.
Parameters
----------
progress : Progress
The progress information to display.
"""
raise NotImplementedError()
def close(self):
"""Closes the progress bar.
Indicates that not further updates will be made.
"""
class NoProgressBar(ProgressBar):
"""A progress bar that does not display anything.
Helpful in headless situations or when using Nengo as a library.
"""
def update(self, progress):
pass
class TerminalProgressBar(ProgressBar):
"""A progress bar that is displayed as ASCII output on ``stdout``."""
def update(self, progress):
if progress.finished:
line = self._get_finished_line(progress)
elif progress.max_steps is None:
line = self._get_unknown_progress_line(progress)
else:
line = self._get_in_progress_line(progress)
sys.stdout.write(line)
sys.stdout.flush()
def _get_in_progress_line(self, progress):
line = f"[{{}}] ETA: {timestamp2timedelta(progress.eta())}"
percent_str = f" {progress.name_during}... {int(100 * progress.progress)}% "
width, _ = get_terminal_size()
progress_width = max(0, width - len(line))
progress_str = (int(progress_width * progress.progress) * "#").ljust(
progress_width
)
percent_pos = (len(progress_str) - len(percent_str)) // 2
if percent_pos > 0:
progress_str = (
progress_str[:percent_pos]
+ percent_str
+ progress_str[percent_pos + len(percent_str) :]
)
return "\r" + line.format(progress_str)
def _get_unknown_progress_line(self, progress):
"""Generates a progress line with continuously moving marker.
This is to indicate processing while not knowing how far along we
progressed with the processing.
"""
duration = progress.elapsed_seconds()
line = f"[{{}}] duration: {timestamp2timedelta(duration)}"
text = f" {progress.name_during}... "
width, _ = get_terminal_size()
marker = ">>>>"
progress_width = max(0, width - len(line) + 2)
index_width = progress_width + len(marker)
i = int(10.0 * duration) % (index_width + 1)
progress_str = (" " * i) + marker + (" " * (index_width - i))
progress_str = progress_str[len(marker) : -len(marker)]
text_pos = (len(progress_str) - len(text)) // 2
progress_str = (
progress_str[:text_pos] + text + progress_str[text_pos + len(text) :]
)
return "\r" + line.format(progress_str)
def _get_finished_line(self, progress):
width, _ = get_terminal_size()
elapsed_seconds = timestamp2timedelta(progress.elapsed_seconds())
line = f"{progress.name_after} finished in {elapsed_seconds}.".ljust(width)
return "\r" + line
def close(self):
sys.stdout.write(os.linesep)
sys.stdout.flush()
class VdomProgressBar(ProgressBar): # pragma: no cover
"""A progress bar using a virtual DOM representation.
This HTML representation can be used in Jupyter lab (>=0.32) environments.
.. versionadded: 3.0.0
"""
def __init__(self):
super().__init__()
self._uuid = uuid.uuid4()
self._handle = None
self.progress = None
def update(self, progress):
self.progress = progress
if self._handle is None:
self._handle = display(self, display_id=True)
else:
self._handle.update(self)
def _repr_mimebundle_(self, include, exclude, **kwargs):
return {"application/vdom.v1+json": self._get_vdom(self.progress)}
def _get_vdom(self, progress):
return {
"tagName": "div",
"attributes": {
"id": str(self._uuid),
"style": {
"width": "100%",
"boxSizing": "border-box",
"border": "1px solid #cfcfcf",
"borderRadius": "4px",
"textAlign": "center",
"position": "relative",
},
},
"children": [
{
"tagName": "div",
"attributes": {
"class": "pb-text",
"style": {"position": "absolute", "width": "100%"},
},
"children": [self._get_text(self.progress)],
},
{
"tagName": "div",
"attributes": {
"class": "pb-fill",
"style": self._get_fill_style(self.progress),
},
"children": [
{
"tagName": "style",
"attributes": {"type": "text/css", "scoped": "scoped"},
"children": [
"""
@keyframes pb-fill-anim {
0% { background-position: 0 0; }
100% { background-position: 100px 0; }
}}"""
],
},
"\u00A0", # non-breaking space
],
},
],
}
def _get_text(self, progress):
if progress is None:
text = ""
elif progress.finished:
text = "{} finished in {}.".format(
escape(progress.name_after),
timestamp2timedelta(progress.elapsed_seconds()),
)
elif progress.max_steps is None:
text = "{task}\u2026 duration: {duration}".format(
task=escape(progress.name_during),
duration=timestamp2timedelta(progress.elapsed_seconds()),
)
else:
text = "{task}\u2026 {progress:.0f}%, ETA: {eta}".format(
task=escape(progress.name_during),
progress=100.0 * progress.progress,
eta=timestamp2timedelta(progress.eta()),
)
return text
def _get_fill_style(self, progress):
if progress.max_steps is None:
style = self._get_unknown_steps_fill_style(progress)
else:
style = self._get_known_steps_fill_style(progress)
if progress.finished:
style["animation"] = "none"
style["backgroundImage"] = "none"
return style
def _get_known_steps_fill_style(self, progress):
return {
"width": f"{100.0 * progress.progress:.0f}%",
"animation": "none",
"backgroundColor": "#bdd2e6",
"backgroundImage": "none",
"transition": "width 0.1s linear" if progress.progress > 0.0 else "none",
}
def _get_unknown_steps_fill_style(self, progress):
return {
"width": "100%",
"animation": "pb-fill-anim 2s linear infinite",
"backgroundColor": "#bdd2e6",
"backgroundSize": "100px 100%",
"backgroundImage": (
"repeating-linear-gradient("
"90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)"
),
}
class HtmlProgressBar(ProgressBar): # pragma: no cover
"""A progress bar using a HTML representation.
This HTML representation can be used in Jupyter notebook environments
and is provided by the *_repr_html_* method that will be automatically
used by IPython interpreters.
If the kernel frontend does not support HTML (e.g., in Jupyter qtconsole),
a warning message will be issued as the ASCII representation.
"""
def __init__(self):
super().__init__()
self._uuid = uuid.uuid4()
self._handle = None
def update(self, progress):
if self._handle is None:
display(self._HtmlBase(self._uuid))
self._handle = display(self._js_update(progress), display_id=True)
else:
self._handle.update(self._js_update(progress))
class _HtmlBase:
def __init__(self, my_uuid):
self.uuid = my_uuid
def __repr__(self):
return (
"HtmlProgressBar cannot be displayed. Please use the "
"TerminalProgressBar. It can be enabled with `nengo.rc['progress']"
"['progress_bar'] = 'nengo.utils.progress.TerminalProgressBar'`."
)
def _repr_html_(self):
return """
<script>
if (Jupyter.version.split(".")[0] < 5) {{
var pb = document.getElementById("{uuid}");
var text = document.createTextNode(
"HMTL progress bar requires Jupyter Notebook >= " +
"5.0 or Jupyter Lab. Alternatively, you can use " +
"TerminalProgressBar().");
pb.parentNode.insertBefore(text, pb);
}}
</script>
<div id="{uuid}" style="
width: 100%;
border: 1px solid #cfcfcf;
border-radius: 4px;
text-align: center;
position: relative;">
<div class="pb-text" style="
position: absolute;
width: 100%;">
0%
</div>
<div class="pb-fill" style="
background-color: #bdd2e6;
width: 0%;">
<style type="text/css" scoped="scoped">
@keyframes pb-fill-anim {{
0% {{ background-position: 0 0; }}
100% {{ background-position: 100px 0; }}
}}
</style>
</div>
</div>""".format(
uuid=self.uuid
)
def _js_update(self, progress):
if progress is None:
text = ""
elif progress.finished:
text = "{} finished in {}.".format(
escape(progress.name_after),
timestamp2timedelta(progress.elapsed_seconds()),
)
elif progress.max_steps is None:
text = "{task}… duration: {duration}".format(
task=escape(progress.name_during),
duration=timestamp2timedelta(progress.elapsed_seconds()),
)
else:
text = "{task}… {progress:.0f}%, ETA: {eta}".format(
task=escape(progress.name_during),
progress=100.0 * progress.progress,
eta=timestamp2timedelta(progress.eta()),
)
if progress.max_steps is None:
update = self._update_unknown_steps(progress)
else:
update = self._update_known_steps(progress)
if progress.finished:
finish = """
fill.style.animation = 'none';
fill.style.backgroundImage = 'none';
"""
else:
finish = ""
return Javascript(
f"""
(function () {{
var root = document.getElementById('{self._uuid}');
var text = root.getElementsByClassName('pb-text')[0];
var fill = root.getElementsByClassName('pb-fill')[0];
text.innerHTML = '{text}';
{update}
{finish}
}})();
"""
)
def _update_known_steps(self, progress):
return """
if ({progress} > 0.) {{
fill.style.transition = 'width 0.1s linear';
}} else {{
fill.style.transition = 'none';
}}
fill.style.width = '{progress}%';
fill.style.animation = 'none';
fill.style.backgroundImage = 'none'
""".format(
progress=100.0 * progress.progress
)
def _update_unknown_steps(self, progress):
return """
fill.style.width = '100%';
fill.style.animation = 'pb-fill-anim 2s linear infinite';
fill.style.backgroundSize = '100px 100%';
fill.style.backgroundImage = 'repeating-linear-gradient(' +
'90deg, #bdd2e6, #edf2f8 40%, #bdd2e6 80%, #bdd2e6)';
"""
class VdomOrHtmlProgressBar(ProgressBar): # pragma: no cover
"""Progress bar using the VDOM or HTML progress bar.
This progress bar will transmit both representations as part of a MIME
bundle and it is up to the Jupyter client to pick the preferred version.
Usually this will be the VDOM if supported, and the HMTL version where VDOM
is not supported.
.. versionadded: 3.0.0
"""
def __init__(self):
super().__init__()
self._handle = None
self._vdom = VdomProgressBar()
self._html = HtmlProgressBar()
def update(self, progress):
self._vdom.progress = progress
if self._handle is None:
display(self._get_initial_bundle(progress), raw=True)
self._handle = display(
self._get_update_bundle(progress), raw=True, display_id=True
)
self._handle.update(self._get_update_bundle(progress), raw=True)
def _get_initial_bundle(self, progress):
return {
"application/vdom.v1+json": {"tagName": "div", "attributes": {}},
"text/html": self._html._HtmlBase(self._html._uuid)._repr_html_(),
"text/plain": repr(self._html._HtmlBase(self._html._uuid)),
}
def _get_update_bundle(self, progress):
bundle = self._vdom._repr_mimebundle_([], [])
bundle["text/html"] = (
"<script>"
+ self._html._js_update(progress)._repr_javascript_()
+ "</script>"
)
return bundle
class IPython5ProgressBar(ProgressBar): # pragma: no cover
"""ProgressBar for IPython>=5 environments.
Provides a VDOM/HTML representation, except for in a pure terminal IPython
(i.e. not an IPython kernel that was connected to via ZMQ), where a
ASCII progress bar will be used.
Note that some Jupyter environments (like qtconsole) will try to use the
VDOM/HTML version, but do not support HTML and will show a warning instead
of an actual progress bar.
"""
def __init__(self):
super().__init__()
class Displayable:
def __init__(self):
self.display_requested = False
def _ipython_display_(self):
self.display_requested = True
d = Displayable()
display(d, exclude=["text/plain"])
if d.display_requested:
self._progress_bar = VdomOrHtmlProgressBar()
else:
self._progress_bar = TerminalProgressBar()
def update(self, progress):
self._progress_bar.update(progress)
class WriteProgressToFile(ProgressBar):
"""Writes progress to a file.
This is useful for remotely and intermittently monitoring progress.
Note that this file will be overwritten on each update of the progress!
Parameters
----------
filename : str
Path to the file to write the progress to.
"""
def __init__(self, filename):
self.filename = filename
super().__init__()
def update(self, progress):
if progress.finished:
text = "{} finished in {}.".format(
progress.name_after, timestamp2timedelta(progress.elapsed_seconds())
)
else:
text = "{progress:.0f}%, ETA: {eta}".format(
progress=100 * progress.progress,
eta=timestamp2timedelta(progress.eta()),
)
with open(self.filename, "w") as f:
f.write(text + os.linesep)
class AutoProgressBar(ProgressBar):
"""Suppresses the progress bar unless the ETA exceeds a threshold.
Parameters
----------
delegate : ProgressBar
The actual progress bar to display, if ETA is high enough.
min_eta : float, optional
The minimum ETA threshold for displaying the progress bar.
"""
def __init__(self, delegate, min_eta=1.0):
self.delegate = delegate
super().__init__()
self.min_eta = min_eta
self._visible = False
def update(self, progress):
min_delay = progress.time_start + 0.1
long_eta = (
progress.elapsed_seconds() + progress.eta() > self.min_eta
and min_delay < time.time()
)
if self._visible:
self.delegate.update(progress)
elif long_eta or progress.finished:
self._visible = True
self.delegate.update(progress)
def close(self):
self.delegate.close()
class ProgressTracker:
"""Tracks the progress of some process with a progress bar.
Parameters
----------
progress_bar : ProgressBar or bool or None
The progress bar to display the progress (or True to use the default
progress bar, False/None to disable progress bar).
total_progress : int
Maximum number of steps of the process.
update_interval : float, optional
Time to wait (in seconds) between updates to progress bar display.
"""
def __init__(self, progress_bar, total_progress, update_interval=0.1):
self.progress_bar = to_progressbar(progress_bar)
self.total_progress = total_progress
self.update_interval = update_interval
self.update_thread = threading.Thread(target=self.update_loop)
self.update_thread.daemon = True
self._closing = False
self.sub_progress = None
def next_stage(self, name_during="", name_after=None, max_steps=None):
"""Begin tracking progress of a new stage.
Parameters
----------
max_steps : int, optional
The total number of calculation steps of the process.
name_during : str, optional
Short description of the task to be used while it is running.
name_after : str, optional
Short description of the task to be used after it has
finished. Defaults to *name_during*.
"""
if self.sub_progress is not None:
self.total_progress.step()
self.sub_progress = Progress(name_during, name_after, max_steps)
return self.sub_progress
def __enter__(self):
self._closing = False
self.total_progress.__enter__()
if not isinstance(self.progress_bar, NoProgressBar):
self.update_thread.start()
return self
def __exit__(self, exc_type, exc_value, traceback):
self._closing = True
self.total_progress.__exit__(exc_type, exc_value, traceback)
if not isinstance(self.progress_bar, NoProgressBar):
self.update_thread.join()
self.progress_bar.update(self.total_progress)
self.progress_bar.close()
def update_loop(self):
"""Update the progress bar display (will run in a separate thread)."""
while not self._closing:
if self.sub_progress is not None and not self.sub_progress.finished:
self.progress_bar.update(self.sub_progress)
else:
self.progress_bar.update(self.total_progress)
time.sleep(self.update_interval)
def get_default_progressbar():
"""The default progress bar to use depending on the execution environment.
Returns
-------
``ProgressBar``
"""
try:
pbar = rc["progress"].getboolean("progress_bar")
if pbar:
pbar = "auto"
else:
pbar = "none"
except ValueError:
pbar = rc["progress"]["progress_bar"]
if pbar.lower() == "auto":
if get_ipython() is not None and check_ipy_version((5, 0)): # pragma: no cover
return AutoProgressBar(IPython5ProgressBar())
else:
return AutoProgressBar(TerminalProgressBar())
if pbar.lower() == "none":
return NoProgressBar()
return _load_class(pbar)()
def to_progressbar(progress_bar):
"""Converts to a ``ProgressBar`` instance.
Parameters
----------
progress_bar : None, bool, or ProgressBar
Object to be converted to a ``ProgressBar``.
Returns
-------
ProgressBar
Return ``progress_bar`` if it is already a progress bar, the default
progress bar if ``progress_bar`` is ``True``, and ``NoProgressBar`` if
it is ``None`` or ``False``.
"""
if progress_bar is False or progress_bar is None:
progress_bar = NoProgressBar()
if progress_bar is True:
progress_bar = get_default_progressbar()
return progress_bar
|
#!/usr/bin/env python
from random import randint
n = input()
l = []
print(n)
while len(l) < n:
pair = (randint(1, 100), randint(1, 100))
if pair not in l:
l.append(pair)
for p in l:
print("%d %d" % p)
|
#!/usr/bin/env python
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You 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 sys
import json
from kafka import KafkaProducer
from metrics_pb2 import Metrics
producer = KafkaProducer(bootstrap_servers='localhost:9092')
topic = 'metrics_pb'
for row in iter(sys.stdin):
d = json.loads(row)
metrics = Metrics()
for k, v in d.items():
setattr(metrics, k, v)
pb = metrics.SerializeToString()
producer.send(topic, pb)
|
import io
import struct
class MinecraftIO(io.BytesIO):
def read_varint(self, size: int = 5) -> int:
result = 0
for i in range(size):
data = self.read(1)
shift = 7 * i
result |= (data[0] & 0x7F) << shift
if data[0] >> 7 == 0:
return result
else:
raise ValueError(f'Varnum was too big, expected {size}')
def write_varint(self, value: int):
while value > 0x7F:
self.write(bytes([value & 0x7F | 0x80]))
value >>= 7
self.write(bytes([value]))
def read_string(self) -> str:
length = self.read_varint()
data = self.read(length)
return data.decode('utf-8')
def write_string(self, value: str):
value_data = value.encode('utf-8')
self.write_varint(len(value_data))
self.write(value_data)
def write_ushort(self, value: int):
self.write(struct.pack('H', value))
def read_ulong(self) -> int:
data = self.read(8)
return struct.unpack('Q', data)[0]
def write_ulong(self, value: int):
self.write(struct.pack('Q', value))
|
from copy import deepcopy
lista1 = []
lista2 = []
for _ in range(int(input())):
name = input()
score = float(input())
lista1.append(name)
lista2.append(score)
lista3 = deepcopy(lista2)
lista3.sort()
lista03 = sorted(set(lista3))
nota01 = []
nota = lista03[1]
nota01 = [i for i, item in enumerate(lista2) if item == nota]
nome01 = [lista1[i] for i in nota01]
nome01.sort()
print(end='\n'.join(nome01))
|
import re
def split_selection(input):
""" Break up input string with selection delimiters into selection and content. """
# Create a placeholder selection
sel = []
# Find all indications for selection
while True:
# Find the next matching selection
# TODO: Robustify with multi-char selection and escaping
# TODO: Take notes from CSV and template engines (e.g. ejs) to proper handle escaped delimiters
match = re.search(r'\|', input)
# If there was a match
if match:
# Save the selection
start = match.start(0)
sel.append((start, start))
# Remove the match from the input
input = input[:start] + input[match.end(0):]
# Otherwise, break
else:
break
# Return a selection and content
return {
'selection': sel,
'content': input
}
|
import sys
import datetime
from django.conf import settings
from django.core.management.base import BaseCommand, CommandError
from django.contrib.auth.models import User, Group, Permission
from tastypie.models import ApiKey
from esmond.api.models import Device, OIDSet, DeviceOIDSetMap
class Command(BaseCommand):
args = 'username'
help = 'Add a user with just an api key - no extended permissions.'
def handle(self, *args, **options):
self.options = options
if len(args) < 1 or len(args) > 1:
print >>sys.stderr, "takes one argument: %s" % self.args
return
user = args[0]
u = None
try:
u = User.objects.get(username=user)
print 'User {0} exists'.format(user)
except User.DoesNotExist:
print 'User {0} does not exist - creating'.format(user)
u = User(username=user, is_staff=True)
u.save()
try:
key = ApiKey.objects.get(user=u)
print 'User {0} already has api key, skipping creation'.format(user)
except ApiKey.DoesNotExist:
print 'User {0} does not have an api key - creating'.format(user)
u_apikey = ApiKey(user=u)
u_apikey.key = u_apikey.generate_key()
u_apikey.save()
u.save()
key = ApiKey.objects.get(user=u)
print 'Key: {0}'.format(key)
|
import time
from jina.executors.crafters import BaseCrafter
from .helper import foo
class DummyHubExecutorSlow(BaseCrafter):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
time.sleep(15)
foo()
|
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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.
# ============================================================================
"""
derivative
"""
from inspect import isfunction
import numpy as np
import mindspore
import mindspore.numpy as mnp
from mindspore import Tensor, nn, ops
from mindspore.ops import constexpr
from mindspore import dtype as mstype
from ..architecture.util import check_mode
def _transfer_tensor_to_tuple(inputs):
"""
If the input is a tensor, convert it to a tuple. If not, the output is unchanged.
"""
if isinstance(inputs, Tensor):
return (inputs,)
return inputs
class _GenerateMultiSens(nn.Cell):
"""generate sens for multi-outputs"""
def construct(self, o, net_out, sens):
if len(net_out) == 1:
return sens
all_sens = ()
for i in range(len(net_out)):
if i != o:
all_sens += (mnp.zeros(net_out[i].shape, mnp.float32),)
else:
all_sens += (sens,)
return all_sens
class _MergeOutput(nn.Cell):
"""merge output"""
def construct(self, out_tmp, gout, iters):
for i in range(iters):
out_tmp[i] = out_tmp[i] + (gout[i],)
return out_tmp
@constexpr
def _generate_sens(batch_size, out_chanel, i):
sens = np.zeros((batch_size, out_chanel), np.float32)
sens[:, i] = 1
return Tensor(sens)
@constexpr
def _generate_indices(j):
return Tensor([j], mindspore.int32)
@constexpr
def _check_type(net_in, net_out, input_idx=None, output_idx=None):
"""check type of input"""
if net_in is not None:
raise TypeError("The Type of network input should be Tensor but got {}".format(type(net_in)))
if input_idx is not None and (not isinstance(input_idx, int) or isinstance(input_idx, bool)):
raise TypeError("The Type of column index of input should be int but got {}".format(type(input_idx)))
if output_idx is not None and (not isinstance(output_idx, int) or isinstance(output_idx, bool)):
raise TypeError("The Type of column index of output should be int but got {}".format(type(output_idx)))
if net_out is not None:
raise TypeError("The Type of network output should be Tensor but got {}".format(type(net_out)))
@constexpr
def _check_dimension(in_shape, out_shape, in_idx, out_idx):
"""check dimension of input"""
if len(in_shape) != 2:
raise ValueError("The dimension of network input should be 2, but got {}".format(len(in_shape)))
if len(out_shape) != 2:
raise ValueError("The dimension of network output should be 2, but got {}".format(len(out_shape)))
if in_idx is not None and out_idx is not None:
if in_idx >= in_shape[1]:
raise ValueError("input index should be in range (0, {}), but got {}".format(in_shape[1], in_idx))
if out_idx >= out_shape[1]:
raise ValueError("output index should be in range (0, {}), but got {}".format(out_shape[1], out_idx))
class Grad(nn.Cell):
"""
Computes and returns the gradients of the specified column of outputs with respect to the specified column of
inputs.
Args:
model (Cell): a function or network that takes Tensor inputs.
argnum (int): specifies which input the output takes the first derivative of. Default: 0.
Inputs:
- **x** - The input is variable-length argument. Notes that the last three inputs are column index of
input (int), column index of output (int) and output of network (Tensor). Besides these inputs, the
first is the network inputs (Tensor), which should be two dimensions.
Outputs:
Tensor.
Raises:
TypeError: If the type of `argnum` is not int.
Supported Platforms:
``Ascend``
Examples:
>>> import numpy as np
>>> from mindspore import nn, Tensor
>>> from mindelec.operators import Grad
...
>>> class Net(nn.Cell):
... def __init__(self):
... super(Net, self).__init__()
... def construct(self, x):
... return x * x
...
>>> x = Tensor(np.array([[1.0, -2.0], [-3.0, 4.0]]).astype(np.float32))
>>> net = Net()
>>> out = net(x)
>>> grad = Grad(net)
>>> print(grad(x, 0, 0, out).asnumpy())
[[ 2.]
[-6.]]
"""
def __init__(self, model, argnum=0):
super(Grad, self).__init__()
check_mode("Grad")
if not isinstance(model, nn.Cell) and not isfunction(model):
raise TypeError("The type of model should be a function or network, but got {}".format(type(model)))
self.model = model
if isinstance(argnum, bool) or not isinstance(argnum, int):
raise TypeError("The type of argnum should be int, but get {}".format(type(argnum)))
self.argnum = argnum
self.grad = ops.GradOperation(get_all=True, sens_param=True)
self.gather = ops.Gather()
self.cast = ops.Cast()
self.dtype = ops.DType()
def construct(self, *x):
x = _transfer_tensor_to_tuple(x)
input_idx, output_idx, net_out = x[-3], x[-2], x[-1]
net_in = x[:-3]
_check_type(net_in[0], net_out, input_idx, output_idx)
if net_out is None:
net_out = self.model(*net_in)
net_out = _transfer_tensor_to_tuple(net_out)[0]
_check_dimension(net_in[self.argnum].shape, net_out.shape, input_idx, output_idx)
batch_size, out_chanel = net_out.shape
sens = _generate_sens(batch_size, out_chanel, output_idx)
gradient_function = self.grad(self.model)
sens = self.cast(sens, self.dtype(net_out))
gradient = gradient_function(*net_in, sens)
if input_idx is None:
output = gradient[self.argnum]
else:
out_indices = _generate_indices(input_idx)
output = self.gather(gradient[self.argnum], out_indices, 1)
return output
class SecondOrderGrad(nn.Cell):
"""
Computes and returns the second order gradients of the specified column of outputs with respect to the specified
column of inputs.
Args:
model (Cell): a function or network that takes a single Tensor input and returns a single Tensor.
input_idx1 (int): specifies the column index of input to take the first derivative of.
input_idx2 (int): specifies the column index of input to take the second derivative of.
output_idx (int): specifies the column index of output.
Inputs:
- **input** - The input of given function or network `model`.
Outputs:
Tensor.
Raises:
TypeError: If the type of `input_idx1`, `input_idx2` or `output_idx` is not int.
Supported Platforms:
``Ascend``
Examples:
>>> import numpy as np
>>> from mindspore import nn, Tensor
>>> from mindelec.operators import SecondOrderGrad
>>> class Net(nn.Cell):
... def __init__(self):
... super(Net, self).__init__()
...
... def construct(self, x):
... return x * x * x
>>> x = Tensor(np.array([[1.0, -2.0], [-3.0, 4.0]]).astype(np.float32))
>>> net = Net()
>>> out = net(x)
>>> grad = SecondOrderGrad(net, 0, 0, 0)
>>> print(grad(x).asnumpy())
[[ 6.]
[-18.]]
"""
def __init__(self, model, input_idx1, input_idx2, output_idx):
super(SecondOrderGrad, self).__init__()
check_mode("SecondOrderGrad")
if not isinstance(model, nn.Cell) and not isfunction(model):
raise TypeError("The type of model should be a function or network, but got {}".format(type(model)))
if isinstance(input_idx1, bool) or not isinstance(input_idx1, int):
raise TypeError("The type of input_idx1 should be int, but got {}".format(type(input_idx1)))
if isinstance(input_idx2, bool) or not isinstance(input_idx2, int):
raise TypeError("The type of input_idx1 should be int, but got {}".format(type(input_idx2)))
if isinstance(output_idx, bool) or not isinstance(output_idx, int):
raise TypeError("The type of input_idx1 should be int, but got {}".format(type(output_idx)))
self.jac1 = _FirstOrderGrad(model, input_idx=input_idx1, output_idx=output_idx)
self.jac2 = _FirstOrderGrad(self.jac1, input_idx=input_idx2, output_idx=0)
def construct(self, x):
hes = self.jac2(x)
return hes
class Jacobian(nn.Cell):
r"""
Computes the Jacobian of a given function or network.
Note:
The output of the given function or network should be a single Tensor.
Args:
net (Union[function, Cell]): a function or network that takes Tensor inputs.
arg_nums (int): specifies which input the output takes the first derivative of.
out_idx (int): specifies which output to take the first derivative of.
Inputs:
- **x** (Tensor) - The inputs of the function or network `net`.
Outputs:
Tensor or tuple of Tensors. If `arg_nums` is int, output will be a Tensor whose shape is the shape of
specified output * the shape of specified input. If `arg_nums` is None, output will be a tuple of Tensors
where output[i] will contain the Jacobian of the specified output and ith input and will have as size the
concatenation of the sizes of the corresponding output and the corresponding input
Raises:
TypeError: if the type of `arg_nums` or `out_idx` is not int.
Supported Platforms:
``Ascend``
Examples:
>>> import numpy as np
>>> from mindelec.operators import Jacobian
>>> from mindspore import Tensor
>>> def func(x, y):
>>> return (x * x * x * y + 3 * y * y * x).sum()
...
>>> a = Tensor(np.array([[1, 3], [5, 9], [8, 2]], np.float32))
>>> b = Tensor(np.array([[4, 6], [7, 2], [2, 1]], np.float32))
>>> jac = Jacobian(func, 0, 0)
>>> output = jac(a, b)
>>> print(output.shape)
(3, 2)
"""
def __init__(self, net, argnums=0, out_idx=0):
super(Jacobian, self).__init__()
if not (isinstance(argnums, int) or argnums is None) or not isinstance(out_idx, int):
raise TypeError("The type of argnums should be int or None and out_idx should be int.")
self.net = net
self.argnums = argnums
self.out_idx = out_idx
self.grad_op = ops.GradOperation(get_all=True, sens_param=True)
self.eye = ops.Eye()
self.concat = ops.Concat()
self.reshape = ops.Reshape()
self.tuple_len = ops.Primitive("tuple_len")
self.make_list = ops.Primitive("make_list")
self._merge_output = _MergeOutput()
self._generate_multi_sens = _GenerateMultiSens()
def construct(self, *x):
"""
forward
Args:
inputs (tuple): input tensor.
"""
net_out = _transfer_tensor_to_tuple(self.net(*x))
net_out_target = net_out[self.out_idx]
grad_fn = self.grad_op(self.net)
input_len = self.tuple_len(x)
identity_matrix = self.eye(net_out_target.size, net_out_target.size, mstype.float32)
identity_matrix = ops.Split(0, net_out_target.size)(identity_matrix)
if self.argnums is None:
out_tmp = [()] * input_len
for line in identity_matrix:
sens = self.reshape(line, net_out_target.shape)
grad_wrt_output = self._generate_multi_sens(self.out_idx, net_out, sens)
grad = grad_fn(*x, grad_wrt_output)
out_tmp = self._merge_output(out_tmp, grad, input_len)
output = ()
for i in range(input_len):
out_tmp[i] = self.concat(out_tmp[i])
output = output + (self.reshape(out_tmp[i], net_out_target.shape + x[i].shape),)
return output
output = ()
for line in identity_matrix:
sens = self.reshape(line, net_out_target.shape)
grad_wrt_output = self._generate_multi_sens(self.out_idx, net_out, sens)
grad = grad_fn(*x, grad_wrt_output)
output = output + (grad[self.argnums],)
output = self.concat(output)
return self.reshape(output, net_out_target.shape + x[self.argnums].shape)
class Hessian(nn.Cell):
r"""
Computes the Hessian of a given function or network.
Note:
The output of the given function or network should be a single Tensor.
Args:
net (Union[function, Cell]): a function or network that takes Tensor inputs and returns a single Tensor.
diff1_idx (int): specifies which input the output takes the first derivative of.
diff2_idx (int): specifies which input the output takes the second derivative of.
Inputs:
- **x** (Tensor) - The inputs of the function or network `net`.
Outputs:
Tensor, the shape is the shape output * shape of specified input * the shape of specified input.
Raises:
TypeError: if the type of `diff1_idx` or `diff2_idx` is not int.
Supported Platforms:
``Ascend``
Examples:
>>> import numpy as np
>>> from mindelec.operators import Hessian
>>> from mindspore import Tensor
>>> def func(x, y):
>>> return (x * x * x * y + 3 * y * y * x).sum()
>>> a = Tensor(np.array([[1, 3], [5, 9], [8, 2]], np.float32))
>>> b = Tensor(np.array([[4, 6], [7, 2], [2, 1]], np.float32))
>>> hes = Hessian(func, 0, 0)
>>> output = hes(a, b)
>>> print(output.shape)
(3, 2, 3, 2)
"""
def __init__(self, net, diff1_idx, diff2_idx, out_idx=0):
super(Hessian, self).__init__()
if not isinstance(diff1_idx, int) or not (isinstance(diff2_idx, int) or diff2_idx is None):
raise TypeError("The type of diff1 should be int and diff2 should be int or None.")
self.jac1 = Jacobian(net, argnums=None, out_idx=out_idx)
self.jac2 = Jacobian(self.jac1, argnums=diff2_idx, out_idx=diff1_idx)
def construct(self, *x):
return self.jac2(*x)
def jacobian(func, inputs):
r"""
Function that computes the Jacobian of a given function or network.
Parameters:
func: a function or network that takes Tensor inputs.
inputs: The inputs of the function or network `net`.
"""
inputs = _transfer_tensor_to_tuple(inputs)
func_out = _transfer_tensor_to_tuple(func(*inputs))
output = ()
for i in range(len(func_out)):
jac = Jacobian(func, argnums=None, out_idx=i)
output = output + _transfer_tensor_to_tuple(jac(*inputs))
return output
def hessian(func, inputs):
r"""
Function that computes the Hessian of a given function or network.
Parameters:
func: a function or network that takes Tensor inputs.
inputs: The inputs of the function or network `net`.
"""
inputs = _transfer_tensor_to_tuple(inputs)
func_out = _transfer_tensor_to_tuple(func(*inputs))
output = ()
for i in range(len(func_out)):
out_tmp = ()
for j in range(len(inputs)):
hes = Hessian(func, diff1_idx=j, diff2_idx=None, out_idx=i)
out_tmp = out_tmp + _transfer_tensor_to_tuple(hes(*inputs))
output = output + out_tmp
return output
class _FirstOrderGrad(nn.Cell):
"""compute first-order derivative"""
def __init__(self, model, argnums=0, input_idx=None, output_idx=1):
super(_FirstOrderGrad, self).__init__()
self.model = model
self.argnums = argnums
self.input_idx = input_idx
self.output_idx = output_idx
self.grad = ops.GradOperation(get_all=True, sens_param=True)
self.gather = ops.Gather()
self.cast = ops.Cast()
self.dtype = ops.DType()
def construct(self, *x):
"""Defines the computation to be performed"""
x = _transfer_tensor_to_tuple(x)
_check_type(x[self.argnums], None)
net_out = self.model(*x)
net_out = _transfer_tensor_to_tuple(net_out)[0]
_check_dimension(x[self.argnums].shape, net_out.shape, self.input_idx, self.output_idx)
batch_size, out_chanel = net_out.shape
sens = _generate_sens(batch_size, out_chanel, self.output_idx)
gradient_function = self.grad(self.model)
sens = self.cast(sens, self.dtype(net_out))
gradient = gradient_function(*x, sens)
outout_indices = _generate_indices(self.input_idx)
output = self.gather(gradient[self.argnums], outout_indices, 1)
return output
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.