code
stringlengths 501
5.19M
| package
stringlengths 2
81
| path
stringlengths 9
304
| filename
stringlengths 4
145
|
|---|---|---|---|
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017,2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import sys
from typing import TYPE_CHECKING
from typing import Callable as TCallable, Union as TUnion
from typing import List as TList, Optional
from traitlets import observe
from traitlets import Unicode, DottedObjectName
from traitlets import default
from traitlets import CInt, CBool
from traitlets import Union
from traitlets import List
from traitlets.config import import_item
from yuuno.trait_types import Callable
from yuuno.core.extension import Extension
from yuuno.core.registry import Registry
from yuuno.vs.utils import get_proxy_or_core
from yuuno.vs.utils import MessageLevel, is_single
from yuuno.vs.flags import Features
from yuuno.vs.alpha import AlphaOutputClip
from yuuno.multi_scripts.subprocess.provider import ScriptProviderRegistration
if TYPE_CHECKING:
import vapoursynth as vs
from yuuno.multi_scripts.extension import MultiScriptExtension
class VapourSynth(Extension):
"""
Entry-Point for VapourSynth support of Yuuno
"""
_name = "VapourSynth"
hook_messages: bool = CBool(True, help="""Redirect the message handler to this extension so other parts of Yuuno can handle it.
Note that this feature is disabled on vsscript-environments (vsedit, vspipe, etc.)""", config=True)
yuv_matrix: str = Unicode("709", help="The YUV-Matrix to use when converting to RGB", config=True)
prefer_props: bool = CBool(True, help="If set, the data of the video node will be preferred.", config=True)
merge_bands: bool = CBool(False, help="Manually extract the planes and merge them using PIL. Defaults to automatically detecting the correct choice.", config=True)
post_processor = Union(
[DottedObjectName(), Callable()], allow_none=True,
default_value=None,
help="Define a post-processor function. It gets an RGB24 clip and returns an RGB24 clip.",
config=True
)
resizer: TUnion[str, TCallable] = Union(
[DottedObjectName(), Callable()],
default_value="resize.Spline36",
help="""Defines the resizer to use when converting from YUV to RGB.
It is essentially a function which takes the same arguments as a VapourSynth internal
resizer. The clip is passed as the first argument.
Yuuno will first try to match it to a VapourSynth-function defined by a plugin before
attempting to import it from a module and treat it as a normal function.
If the passed object is a callable, it will just use the callable.
""",
config=True
)
push_values: bool = CBool(True, help="""Push vs and the current core instance onto the current environment.""", config=True)
core_num_threads: int = CInt(-1, help="""The number of concurrent threads used by the core. Can be set the change the number.
Settings to a value less than one makes it default to the number of hardware threads.
""", config=True)
core_add_cache: bool = CBool(True, help="For debugging purposes only. When set to `False` no caches will be automatically inserted between filters.", config=True)
core_accept_lowercase: bool = CBool(False, help="When set to `True` function name lookups in the core are case insensitive. Don't distribute scripts that need it to be set.", config=True)
core_max_cache_size: int = CBool(None, allow_none=True, help="Set the upper framebuffer cache size after which memory is aggressively freed. The value is in mediabytes.", config=True)
vsscript_environment_wrap: bool = CBool(True, help="Allow Yuuno to automatically wrap the internal frame-extractor into the current environment. Do not disable while running multiple cores at once.", config=True)
raw_force_compat: bool = CBool(True, "In raw image exports, force Planar RGB output", config=True)
log_handlers: TList[TCallable[[int, str], None]] = List(Callable())
@default("log_handlers")
def _default_log_handlers(self):
return []
def _update_core_values(name=None):
def _func(self, change=None):
core = get_proxy_or_core()
if name is None:
core.num_threads = self.core_num_threads
core.add_cache = self.core_add_cache
if hasattr(core, 'accept_lowercase'):
core.accept_lowercase = self.core_accept_lowercase
# There is no obvious default for max_cache_size
if self.core_max_cache_size is not None:
core.max_cache_size = self.core_max_cache_size
elif hasattr(core, name):
setattr(core, name, change.new)
return _func
update_core_values = _update_core_values()
_observe_num_threads = observe("core_num_threads")(_update_core_values("num_threads"))
_observe_add_cache = observe("core_add_cache")(_update_core_values("add_cache"))
_observe_accept_lowercase = observe("core_accept_lowercase")(_update_core_values("accept_lowercase"))
_observe_max_cache_size = observe("core_max_cache_size")(_update_core_values("max_cache_size"))
@classmethod
def is_supported(cls):
return not Features.NOT_SUPPORTED
@property
def resize_filter(self) -> TCallable[['vs.VideoNode', 'int'], 'vs.VideoNode']:
"""
Loads the resize-filter for any image operations.
:return: The returned filter
"""
from yuuno.vs.utils import filter_or_import
if callable(self.resizer):
return self.resizer
return filter_or_import(self.resizer)
@property
def processor(self):
if self.post_processor is None:
return
func = self.post_processor
if not callable(func):
func = import_item(func)
return func
def _on_vs_log(self, level: MessageLevel, message: str):
try:
for cb in self.log_handlers:
cb(level, message)
except Exception as e:
import traceback
print("During logging of a vapoursynth-message, this exception occured:", file=sys.stderr)
traceback.print_exc(file=sys.stderr)
@property
def can_hook_log(self):
return self.hook_messages and is_single()
def initialize_hook(self, vapoursynth):
if self.can_hook_log:
vapoursynth.set_message_handler(self._on_vs_log)
elif self.hook_messages:
self.parent.log.debug("vsscript-Environment detected. Skipping hook on message-handler.")
def initialize_namespace(self, vapoursynth):
core = get_proxy_or_core()
self.parent.namespace['vs'] = vapoursynth
self.parent.namespace['core'] = core
def initialize_registry(self):
self.parent.log.debug("Registering wrappers.")
from vapoursynth import VideoNode, VideoFrame
from yuuno.vs.clip import VapourSynthClip, VapourSynthFrame
from yuuno.vs.clip import VapourSynthAlphaClip
# Detected VSScript.
wrapperfunc = lambda cls: cls
if self.script_manager is not None and self.vsscript_environment_wrap:
wrapperfunc = self.script_manager.env_wrapper_for
self.registry = Registry()
self.registry.register(wrapperfunc(VapourSynthClip), VideoNode)
self.registry.register(wrapperfunc(VapourSynthFrame), VideoFrame)
self.registry.register(wrapperfunc(VapourSynthAlphaClip), AlphaOutputClip)
if Features.SUPPORT_ALPHA_OUTPUT_TUPLE:
# Required so that IPython automatically supports alpha outputs
from vapoursynth import AlphaOutputTuple
self.registry.register(wrapperfunc(VapourSynthAlphaClip), AlphaOutputTuple)
self.parent.registry.add_subregistry(self.registry)
def initialize_multi_script(self):
self.script_manager = None
managers: Optional['MultiScriptExtension'] = self.parent.get_extension('MultiScript')
if managers is None:
self.parent.log.debug("MultiScript not found. Skipping VSScript.")
return
managers.register_provider('vapoursynth', ScriptProviderRegistration(
providercls="yuuno.vs.provider.VSScriptProvider",
extensions=[]
))
# Check support for vapoursynth/#389 at R44
if not Features.EXPORT_VSSCRIPT_ENV:
self.parent.log.info("Yuuno doesn't support VSScript for VS<R44")
return
self.parent.log.debug("Enabling VSScript.")
from yuuno.vs.vsscript.script import VSScriptManager
from yuuno.vs.vsscript.vs_capi import enable_vsscript
enable_vsscript()
self.script_manager = VSScriptManager()
managers.register_manager('VSScript', self.script_manager)
self.parent.log.debug("VSScript enabled.")
def initialize(self):
import vapoursynth
self.initialize_hook(vapoursynth)
self.initialize_namespace(vapoursynth)
self.initialize_multi_script()
self.initialize_registry()
if self.script_manager is None:
self.update_core_values()
def deinitialize(self):
self.parent.registry.remove_subregistry(self.registry)
del self.parent.namespace['vs']
del self.parent.namespace['core']
if self.can_hook_log:
import vapoursynth
vapoursynth.set_message_handler(None)
if Features.EXPORT_VSSCRIPT_ENV and self.script_manager is not None:
self.script_manager.disable() | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/extension.py | extension.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import enum
import platform
from operator import or_
from functools import reduce
from typing import TYPE_CHECKING
if TYPE_CHECKING:
import vapoursynth
class classproperty(object):
__slots__ = ('func',)
def __init__(self, func):
self.func = func
def __get__(self, instance, owner):
return self.func(owner)
class flag(int):
def __new__(cls, val, func=None):
f = super(flag, cls).__new__(cls, val)
f.func = None
f(func)
return f
def __and__(self, other):
if not isinstance(other, flag):
return NotImplemented
return flag(int(self) & other, lambda *a, **kwa: (self(*a, **kwa) and other(*a, **kwa)))
def __or__(self, other):
if not isinstance(other, flag):
return NotImplemented
return flag(int(self) | other, lambda *a, **kwa: (self(*a, **kwa) or other(*a, **kwa)))
def __xor__(self, other):
if not isinstance(other, flag):
return NotImplemented
return flag(int(self) ^ other, lambda *a, **kwa: (self(*a, **kwa) == other(*a, **kwa)))
def __call__(self, *args, **kwargs):
if self.func is None:
self.func = args[0]
return self
return self.func.__get__(None, Features)(*args, **kwargs)
class Features(enum.Flag):
NOT_SUPPORTED = flag(1, lambda vs: False)
@flag(2)
@staticmethod
def FUNCTIONS_INTROSPECTABLE(vs: 'vapoursynth'):
# AT R36
return hasattr(vs, 'construct_signature')
@flag(4)
@staticmethod
def SUPPORT_CORE_PROXY(vs: 'vapoursynth'):
# AT R37
return hasattr(vs, 'core')
@flag(8)
@staticmethod
def EXTRACT_VIA_ARRAY(vs: 'vapoursynth'):
# AT R37
return hasattr(vs.VideoNode, 'get_read_array')
@flag(16)
@staticmethod
def EXPORT_OUTPUT_DICT(vs: 'vapoursynth'):
# AT R39
return hasattr(vs, 'get_outputs')
@flag(32)
@staticmethod
def SUPPORT_ALPHA_OUTPUT_TUPLE(vs: 'vapoursynth'):
# AT R43
return hasattr(vs, 'AlphaOutputTuple')
@flag(64)
@staticmethod
def COMPATBGR_IS_XRGB(vs):
# AT <=R43 AND DARWIN
return platform.system() == 'Darwin' and not hasattr(vs, 'Environment')
@flag(128)
@staticmethod
def EXPORT_VSSCRIPT_ENV(vs):
# AT R44
return hasattr(vs, 'Environment')
@flag(256)
@staticmethod
def ENVIRONMENT_POLICIES(vs):
# AT R51
return hasattr(vs, 'EnvironmentPolicy')
def __bool__(self):
return self.value and self in self.current
@classproperty
def current(cls):
try:
import vapoursynth
except ImportError:
return cls.NOT_SUPPORTED
cur = reduce(or_, (m for m in cls.__members__.values() if m.value(vapoursynth)))
# Don't always calculate the current environments.
cls.current = cur
return cur | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/flags.py | flags.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017,2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import ctypes
from typing import Tuple, overload
from concurrent.futures import Future
from PIL import Image
from traitlets import HasTraits, Instance, observe
import vapoursynth as vs
from vapoursynth import VideoNode, VideoFrame
from yuuno import Yuuno
from yuuno.utils import future_yield_coro, gather
from yuuno.clip import Clip, Frame, Size, RawFormat
from yuuno.vs.extension import VapourSynth
from yuuno.vs.utils import get_proxy_or_core, is_single
from yuuno.vs.flags import Features
from yuuno.vs.alpha import AlphaOutputClip
# On MAC OSX VapourSynth<=R43 is actually returned as XRGB instead of RGBX
COMPAT_PIXEL_FORMAT = "XRGB" if Features.COMPATBGR_IS_XRGB else "BGRX"
def calculate_size(frame: VideoFrame, planeno: int) -> Tuple[int, int]:
"""
Calculates the size of the plane
:param frame: The frame
:param planeno: The plane
:return: (width, height)
"""
width, height = frame.width, frame.height
if planeno != 0:
width >>= frame.format.subsampling_w
height >>= frame.format.subsampling_h
return width, height
@overload
def extract_plane_r36compat(frame: VideoFrame, planeno: int, *, compat: bool=False , direction: int = -1, raw=True) -> bytes: pass
@overload
def extract_plane_r36compat(frame: VideoFrame, planeno: int, *, compat: bool=False, direction: int = -1, raw=False) -> Image.Image: pass
def extract_plane_r36compat(frame, planeno, *, compat=False, direction=-1, raw=False):
"""
Extracts the plane using the old VapourSynth API for reading a frame.
Since we are doing raw memory operations using ctypes, this function has proven to be prone
to SIGSEGV while developing.
This code will subseqently be dropped from this codebase when VapourSynth r36 is officially dropped
with the official release of R39.
:param frame: The frame
:param planeno: The plane number
:param compat: Are we dealing with a compat format.
:param direction: -1 bottom to top, 1 top to bottom
:param raw: Return bytes instead of an image.
:return: The extracted image.
"""
width, height = calculate_size(frame, planeno)
stride = frame.get_stride(planeno)
s_plane = height * stride
buf = (ctypes.c_byte*s_plane).from_address(frame.get_read_ptr(planeno).value)
if raw:
return bytes(buf)
else:
if not compat:
return Image.frombuffer('L', (width, height), buf, "raw", "L", stride, direction)
else:
return Image.frombuffer('RGB', (width, height), buf, "raw", COMPAT_PIXEL_FORMAT, stride, direction)
@overload
def extract_plane_new(frame: VideoFrame, planeno: int, *, compat: bool=False , direction: int = -1, raw=True) -> bytes: pass
@overload
def extract_plane_new(frame: VideoFrame, planeno: int, *, compat: bool=False, direction: int = -1, raw=False) -> Image.Image: pass
def extract_plane_new(frame, planeno, *, compat=False, direction=-1, raw=False):
"""
Extracts the plane with the VapourSynth R37+ array-API.
:param frame: The frame
:param planeno: The plane number
:param compat: Are we dealing with a compat format.
:param direction: -1 bottom to top, 1 top to bottom
:param raw: Return bytes instead of an image.
:return: The extracted image.
"""
arr = frame.get_read_array(planeno)
height, width = arr.shape
stride = frame.format.bytes_per_sample * width
if raw:
return bytes(arr)
else:
if not compat:
return Image.frombuffer('L', (width, height), bytes(arr), "raw", "L", stride, direction)
else:
return Image.frombuffer('RGB', (width, height), bytes(arr), "raw", COMPAT_PIXEL_FORMAT, stride, direction)
if Features.EXTRACT_VIA_ARRAY:
extract_plane = extract_plane_new
else:
extract_plane = extract_plane_r36compat
class VapourSynthFrameWrapper(HasTraits, Frame):
pil_cache: Image.Image = Instance(Image.Image, allow_none=True)
frame: VideoFrame = Instance(VideoFrame)
rgb_frame: VideoFrame = Instance(VideoFrame)
compat_frame: VideoFrame = Instance(VideoFrame)
@property
def extension(self) -> VapourSynth:
return Yuuno.instance().get_extension(VapourSynth)
def _extract(self):
if self.extension.merge_bands:
r = extract_plane(self.rgb_frame, 0, compat=False, direction=1)
g = extract_plane(self.rgb_frame, 1, compat=False, direction=1)
b = extract_plane(self.rgb_frame, 2, compat=False, direction=1)
self.pil_cache = Image.merge('RGB', (r, g, b))
else:
self.pil_cache = extract_plane(self.compat_frame, 0, compat=True)
def to_pil(self) -> Image.Image:
if self.pil_cache is None:
self._extract()
# noinspection PyTypeChecker
return self.pil_cache
def size(self) -> Size:
return Size(self.frame.width, self.frame.height)
def format(self) -> RawFormat:
if self.extension.raw_force_compat:
frame = self.rgb_frame
else:
frame = self.frame
ff: vs.Format = frame.format
samples = RawFormat.SampleType.INTEGER if ff.sample_type==vs.INTEGER else RawFormat.SampleType.FLOAT
fam = {
vs.RGB: RawFormat.ColorFamily.RGB,
vs.GRAY: RawFormat.ColorFamily.GREY,
vs.YUV: RawFormat.ColorFamily.YUV,
vs.YCOCG: RawFormat.ColorFamily.YUV
}[ff.color_family]
return RawFormat(
sample_type=samples,
family=fam,
num_planes=ff.num_planes,
subsampling_w=ff.subsampling_w,
subsampling_h=ff.subsampling_h,
bits_per_sample=ff.bits_per_sample
)
def to_raw(self):
if self.extension.raw_force_compat:
frame = self.rgb_frame
else:
frame = self.frame
return b"".join(
extract_plane(frame, i, compat=False, raw=True)
for i in range(frame.format.num_planes)
)
class VapourSynthClipMixin(HasTraits, Clip):
clip: VideoNode
@property
def extension(self) -> VapourSynth:
return Yuuno.instance().get_extension(VapourSynth)
@staticmethod
def _wrap_frame(frame: VideoFrame) -> VideoNode:
core = get_proxy_or_core()
bc = core.std.BlankClip(
width=frame.width,
height=frame.height,
length=1,
fpsnum=1,
fpsden=1,
format=frame.format.id
)
return bc.std.ModifyFrame([bc], lambda n, f: frame.copy())
def _to_rgb32(self, clip: VideoNode) -> VideoNode:
if clip.format.color_family == vs.YUV:
clip = self.extension.resize_filter(
clip,
format=vs.RGB24,
matrix_in_s=self.extension.yuv_matrix,
prefer_props=self.extension.prefer_props
)
if clip.format.color_family == vs.RGB or clip.format.bits_per_sample != 8:
clip = self.extension.resize_filter(clip, format=vs.RGB24)
processor = self.extension.processor
if processor is not None:
clip = processor(clip)
return clip
def to_rgb32(self, frame: VideoNode) -> VideoNode:
return self._to_rgb32(frame)
def to_compat_rgb32(self, frame: VideoNode) -> VideoNode:
return self.extension.resize_filter(frame, format=vs.COMPATBGR32)
def __len__(self):
return len(self.clip)
@future_yield_coro
def __getitem__(self, item) -> VapourSynthFrameWrapper:
if not is_single():
try:
get_proxy_or_core().std.BlankClip()
except vs.Error:
raise RuntimeError("Tried to access clip of a dead core.") from None
frame = yield self.clip.get_frame_async(item)
wrapped = self._wrap_frame(frame)
_rgb24: Future = self.to_rgb32(wrapped)
rgb24 = _rgb24.get_frame_async(0)
compat: Future = self.to_compat_rgb32(_rgb24).get_frame_async(0)
(yield gather([rgb24, compat]))
rgb24_frame, compat_frame = rgb24.result(), compat.result()
return VapourSynthFrameWrapper(
frame=frame,
compat_frame=compat_frame,
rgb_frame=rgb24_frame
)
class VapourSynthClip(VapourSynthClipMixin, HasTraits):
clip: VideoNode = Instance(VideoNode)
def __init__(self, clip):
super(VapourSynthClip, self).__init__(clip)
class VapourSynthFrame(VapourSynthClipMixin, HasTraits):
frame: VideoFrame = Instance(VideoFrame)
clip: VideoNode = Instance(VideoNode, allow_none=True)
def __init__(self, frame):
super(VapourSynthFrame, self).__init__(None)
self.frame = frame
@observe("frame")
def _frame_observe(self, value):
self.clip = self._wrap_frame(value['new'])
class VapourSynthAlphaFrameWrapper(HasTraits):
clip: VapourSynthFrameWrapper = Instance(VapourSynthFrameWrapper)
alpha: VapourSynthFrameWrapper = Instance(VapourSynthFrameWrapper)
_cache: Image.Image = Instance(Image.Image, allow_none=True)
@property
def color(self):
return self.clip
def to_pil(self):
if self._cache is None:
color = self.clip.to_pil()
alpha = extract_plane(self.alpha.frame, 0, direction=1)
color.putalpha(alpha)
self._cache = color
return self._cache
def size(self) -> Size:
return self.clip.size()
def format(self) -> RawFormat:
f = self.clip.format()
return RawFormat(
bits_per_sample=f.bits_per_sample,
family=f.family,
num_planes=f.num_planes+1,
subsampling_h=f.subsampling_h,
subsampling_w=f.subsampling_w,
sample_type=f.sample_type
)
def to_raw(self):
return b"".join([self.clip.to_raw(), self.alpha.to_raw()])
class VapourSynthAlphaClip(Clip):
def __init__(self, clip):
if not isinstance(clip, AlphaOutputClip):
raise ValueError("Passed non Alpha-Clip into the wrapper")
self.clip = VapourSynthClip(clip[0])
if clip[1] is None:
self.alpha = None
else:
self.alpha = VapourSynthClip(clip[1])
def __len__(self):
if self.alpha is None:
return len(self.clip)
return min(map(len, (self.clip, self.alpha)))
@future_yield_coro
def __getitem__(self, item):
if self.alpha is None:
return (yield self.clip[item])
f1 = yield self.clip[item]
f2 = yield self.alpha[item]
return VapourSynthAlphaFrameWrapper(clip=f1, alpha=f2) | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/clip.py | clip.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import base64
import ctypes
import marshal
import functools
import vapoursynth
from yuuno.vs.vsscript.capsules import Capsules
from yuuno.vs.flags import Features
class Counter(object):
def __init__(self):
self._counter = 0
def __call__(self):
self._counter += 1
return self._counter
_run_counter = Counter()
_script_counter = Counter()
class VPYScriptExport(ctypes.Structure):
_fields_ = [
('pyenvdict', ctypes.py_object),
('errstr', ctypes.c_void_p),
('id', ctypes.c_int)
]
class _VapourSynthCAPI(Capsules):
_module_ = vapoursynth
vpy_initVSScript = ctypes.CFUNCTYPE(ctypes.c_int)
vpy_createScript = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(VPYScriptExport))
vpy_getError = ctypes.CFUNCTYPE(ctypes.c_char_p, ctypes.POINTER(VPYScriptExport))
vpy_evaluateScript = ctypes.CFUNCTYPE(ctypes.c_int, ctypes.POINTER(VPYScriptExport), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_int)
vpy_getVSApi = ctypes.CFUNCTYPE(ctypes.c_void_p)
vpy_freeScript = ctypes.CFUNCTYPE(None, ctypes.POINTER(VPYScriptExport))
VapourSynthCAPI = _VapourSynthCAPI()
_controlling_vsscript = False
def enable_vsscript():
global _controlling_vsscript
# VapourSynth R51:
# > Fake a reload.
if Features.ENVIRONMENT_POLICIES:
if _controlling_vsscript:
if not vapoursynth._using_vsscript:
vapoursynth._using_vsscript = True
return
if VapourSynthCAPI.vpy_getVSApi() == ctypes.c_void_p(0):
raise OSError("Couldn't detect a VapourSynth API Instance")
if VapourSynthCAPI.vpy_initVSScript():
raise OSError("Failed to initialize VSScript.")
if not vapoursynth._using_vsscript:
raise RuntimeError("Failed to enable vsscript.")
_controlling_vsscript = True
def does_own_vsscript():
global _controlling_vsscript
return _controlling_vsscript
def disable_vsscript():
if not Features.ENVIRONMENT_POLICIES:
return
if not vapoursynth._using_vsscript:
return
vapoursynth._using_vsscript = False
def _perform_in_environment(func):
@functools.wraps(func)
def _wrapper(self, *args, **kwargs):
return self.perform(lambda: func(self, *args, **kwargs))
return _wrapper
_call_funcs = {}
class ScriptEnvironment(object):
__slots__ = ('filename', 'id', 'export', '_core', '_outputs', '_env')
def __init__(self, filename=None):
enable_vsscript()
self.filename = filename
self.id = _script_counter()
self.export = None
self._core = None
self._outputs = None
self._env = None
def enable(self):
if self.export is not None:
return
self.export = VPYScriptExport()
self.export.pyenvdict = {}
self.export.id = self.id
if VapourSynthCAPI.vpy_createScript(self._handle):
self._raise_error()
self._env = self._perform_raw(vapoursynth.vpy_current_environment)
@property
def _handle(self):
if self.export is None:
return
return ctypes.pointer(self.export)
@property
def alive(self):
return self.export is not None
def dispose(self):
if self.export is None:
return
VapourSynthCAPI.vpy_freeScript(self._handle)
self.export = None
def _raise_error(self):
raise vapoursynth.Error(VapourSynthCAPI.vpy_getError(self._handle).decode('utf-8'))
def _perform_raw(self, func, counter=None):
if self.export is None:
raise vapoursynth.Error("Tried to access dead core.")
if not counter:
counter = _run_counter()
name = '__yuuno_%d_run_%d' % (id(self), counter)
# This technique allows arbitrary code to be executed
# without ever touching the global pyenv-dict.
c = compile('''from yuuno.vs.vsscript.vs_capi import _call_funcs; _call_funcs["%s"]()'''%name, filename="<yuuno-bootstrap>", mode="exec")
c = marshal.dumps(c)
c = base64.b64encode(c)
c = c.decode("ascii")
c = '(lambda marshal, base64: exec(marshal.loads(base64.b64decode(b"%s")), {}, {}))(__import__("marshal"), __import__("base64"))'%c
result = None
error = None
def _execute_func():
nonlocal result, error
try:
result = func()
except Exception as e:
error = e
filename = '<Yuuno:%d>' % counter
if self.filename:
filename = self.filename
filename = filename.encode('utf-8')
_call_funcs[name] = _execute_func
try:
if VapourSynthCAPI.vpy_evaluateScript(self._handle, c.encode('ascii'), filename, 0):
self._raise_error()
finally:
del _call_funcs[name]
if error is not None:
raise error
return result
def perform(self, func):
ewrapper = self._env
# R51 requires the use of Environment.use for threadsafe
# environment changes.
if hasattr(ewrapper, "use"):
ewrapper = ewrapper.use()
with ewrapper:
return func()
def exec(self, code):
counter = _run_counter()
compiled = compile(code, '<Yuuno %r:%d>' % (self.filename, counter), 'exec')
def _exec():
exec(compiled, self.export.pyenvdict, {})
self._perform_raw(_exec, counter)
@_perform_in_environment
def _get_core(self):
return vapoursynth.get_core()
@property
def core(self):
if self._core is None:
self._core = self._get_core()
return self._core
@_perform_in_environment
def _get_outputs(self):
return vapoursynth.get_outputs()
@property
def outputs(self):
if self._outputs is None:
self._outputs = self._get_outputs()
return self._outputs
def get_output(self, index=0):
return self.outputs[index]
def __del__(self):
self.dispose() | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/vsscript/vs_capi.py | vs_capi.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import ctypes
PyCapsule_GetName = ctypes.pythonapi.PyCapsule_GetName
PyCapsule_GetName.argtypes = [ctypes.py_object]
PyCapsule_GetName.restype = ctypes.c_char_p
PyCapsule_GetPointer = ctypes.pythonapi.PyCapsule_GetPointer
PyCapsule_GetPointer.argtypes = [ctypes.py_object, ctypes.c_char_p]
PyCapsule_GetPointer.restype = ctypes.c_void_p
_CData = ctypes.c_int.mro()[-2]
class CapsulesMeta(type):
def __new__(cls, name, bases, dict):
types = {}
for k in tuple(dict):
if hasattr(dict[k], "mro") and _CData in dict[k].mro():
types[k] = dict[k]
del dict[k]
dict['_types_'] = types
return type.__new__(cls, name, bases, dict)
class Capsules(metaclass=CapsulesMeta):
_module_ = None
def __init__(self):
if not hasattr(self._module_, '__pyx_capi__'):
raise ValueError("Not a cython module.")
self.module = self._module_
self.capsules = self._module_.__pyx_capi__
self._cache = {}
def _convert(self, name, capsule_ptr):
return self._types_[name](capsule_ptr)
def _extract(self, item):
try:
capsule = self.capsules[item]
except KeyError as e:
raise AttributeError(item) from e
name = PyCapsule_GetName(capsule)
return self._convert(item, PyCapsule_GetPointer(capsule, name))
def __getattr__(self, item):
if item not in self._cache:
self._cache[item] = self._extract(item)
return self._cache[item] | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/vsscript/capsules.py | capsules.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from pathlib import Path
from typing import Dict, Union, Callable, Any, Optional
import vapoursynth
from yuuno import Yuuno
from yuuno.clip import Clip
from yuuno.utils import inline_resolved
from yuuno.multi_scripts.script import ScriptManager, Script
from yuuno.vs.vsscript.containermodule import create_module
from yuuno.vs.vsscript.vs_capi import ScriptEnvironment, does_own_vsscript
from yuuno.vs.vsscript.vs_capi import enable_vsscript, disable_vsscript
from yuuno.vs.vsscript.clip import WrappedClip
from yuuno.vs.utils import is_single
class VSScript(Script):
def __init__(self, manager, name):
self.manager = manager
self.name = name
self.env = ScriptEnvironment()
self.exec_counter = 0
self.module_dict = {}
self.manager._on_create(self, self.env.id, self.name)
@property
def _yuuno(self):
return Yuuno.instance()
@property
def alive(self) -> bool:
"""
Checks if the environment is still alive.
"""
return self.env is not None and self.env.alive
def initialize(self) -> None:
self.env.enable()
self.env.perform(lambda: self._yuuno.get_extension('VapourSynth').update_core_values())
def _invoke_exec_counter(self):
self.exec_counter += 1
return self.exec_counter
def dispose(self) -> None:
"""
Disposes the script.
"""
self.manager._on_dispose(self.env.id, self.name)
self.env.dispose()
@inline_resolved
def get_results(self) -> Dict[str, Clip]:
"""
Returns a dictionary with clips
that represent the results of the script.
"""
return {str(k): WrappedClip(self, self._yuuno.wrap(v)) for k, v in self.env.outputs.items()}
@inline_resolved
def perform(self, cb: Callable[[], Any]) -> Any:
return self.env.perform(cb)
@inline_resolved
def execute(self, code: Union[str, Path]) -> None:
"""
Executes the code inside the environment
"""
filename = "<yuuno %d:%d>" % (self.env.id, self._invoke_exec_counter())
if isinstance(code, Path):
filename = str(code)
with open(code, "rb") as f:
code = f.read()
script = compile(code, filename, 'exec', dont_inherit=True)
def _run():
exec(script, self.module_dict, {})
self.env.perform(_run)
class VSScriptManager(ScriptManager):
def __init__(self):
self._does_manage_vsscript = False
self.envs: Dict[int, VSScript] = {}
self.scripts: Dict[str, VSScript] = {}
create_module(self._select_current_dict)
def _current_script(self):
assert hasattr(vapoursynth, 'vpy_current_environment')
try:
env = vapoursynth.vpy_current_environment()
except RuntimeError:
return None
return self.envs.get(env.env_id, None)
def _select_current_dict(self):
env = self._current_script()
if env is None:
return {}
return env.module_dict
def _on_create(self, script, id, name):
self.envs[id] = script
self.scripts[name] = script
def _on_dispose(self, id, name):
del self.envs[id]
del self.scripts[name]
def env_wrapper_for(self, cls):
def _wrapper(*args, **kwargs):
current_env = self._current_script()
return WrappedClip(current_env, cls(*args, **kwargs))
return _wrapper
def create(self, name: str, *, initialize=False) -> Script:
"""
Creates a new script environment.
"""
if is_single():
enable_vsscript()
self._does_manage_vsscript = True
elif does_own_vsscript():
pass
# Make sure we have full control of VSScript
elif not self._does_manage_vsscript:
raise RuntimeError("The script manager does not control VSScript.")
if name in self.scripts:
raise ValueError("The script already exists.")
# Create the core now.
script = VSScript(self, name)
self.scripts[name] = script
if initialize:
script.initialize()
return script
def get(self, name: str) -> Optional[Script]:
"""
Returns the script with the given name.
"""
return self.scripts[name]
def dispose_all(self) -> None:
"""
Disposes all scripts
"""
for script in list(self.scripts.values()):
script.dispose()
def disable(self) -> None:
"""
Disposes all scripts and tries to clean up.
"""
self.dispose_all()
if self._does_manage_vsscript:
disable_vsscript()
self._does_manage_vsscript = False | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/vsscript/script.py | script.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from types import ModuleType
from typing import Callable, Type, MutableMapping, Any, Dict
from collections import ChainMap
from importlib.machinery import ModuleSpec, BuiltinImporter
from sys import modules
def create_module(manager: Callable[[], Dict[str, Any]]) -> Type[ModuleType]:
def get_dict() -> MutableMapping[str, Any]:
d = manager()
return ChainMap(d, {
'__name__': '__vapoursynth__',
'__spec__': ModuleSpec(name='__vapoursynth__', loader=BuiltinImporter, origin='yuuno'),
'__package__': None,
'__doc__': None
})
class _EnvLocalModule(ModuleType):
"""
The __vapoursynth__-Module has to be backed by a environment backed
dictionary.
"""
def __getattribute__(self, item):
try:
get_dict()[item]
except KeyError as e:
raise AttributeError(item) from e
def __setattr__(self, key, value):
nonlocal manager
get_dict()[key] = value
def __delattr__(self, item):
d = get_dict()
del d[item]
def __dir__(self):
nonlocal manager
return [
"__dir__",
"__getattribute__",
"__setattr__",
"__delattr__",
"__repr__"
] + list(manager.keys())
def __repr__(self):
return "<module '__vapoursynth__' (provided)>"
modules['__vapoursynth__'] = _EnvLocalModule("__vapoursynth__") | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/vsscript/containermodule.py | containermodule.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import TYPE_CHECKING, Callable, Any, TypeVar, Generic
from yuuno.utils import future_yield_coro, auto_join
from yuuno.clip import Clip, Frame
if TYPE_CHECKING:
from yuuno.vs.vsscript.script import VSScript
T = TypeVar("T", Clip, Frame)
class WrappedMixin(Generic[T]):
env: 'VSScript'
parent: T
def __init__(self, env: 'VSScript', parent: T):
self.env = env
self.parent = parent
@staticmethod
def wrap(name: str) -> Callable[..., Any]:
@auto_join
@future_yield_coro
def _func(self: 'WrappedMixin', *args, **kwargs):
func = getattr(self.parent, name)
result = yield self.env.perform(lambda: func(*args, **kwargs))
result = yield result
if isinstance(result, Frame):
result = WrappedFrame(self.env, result)
return result
return _func
@staticmethod
def wrap_future(name: str):
@future_yield_coro
def _func(self: 'WrappedMixin', *args, **kwargs):
func = getattr(self.parent, name)
result = yield self.env.perform(lambda: func(*args, **kwargs))
result = yield result
if isinstance(result, Frame):
result = WrappedFrame(self.env, result)
return result
return _func
class WrappedFrame(WrappedMixin[Frame], Frame):
to_pil = WrappedMixin.wrap('to_pil')
to_raw = WrappedMixin.wrap('to_raw')
size = WrappedMixin.wrap('size')
format = WrappedMixin.wrap('format')
get_raw_data_async = WrappedMixin.wrap_future('get_raw_data_async')
class WrappedClip(WrappedMixin[Clip], Clip):
__len__ = WrappedMixin.wrap('__len__')
__getitem__ = WrappedMixin.wrap_future('__getitem__')
@property
def clip(self):
return self.parent.clip | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/vs/vsscript/clip.py | clip.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import List as TList, Callable as TCallable, Dict as TDict
from typing import Any as TAny, AnyStr
from typing import Iterator, Tuple as TTuple
from traitlets import HasTraits, default
from traitlets import List, Dict
from traitlets import Unicode, Any
from yuuno.trait_types import Callable
class Namespace(HasTraits):
"""
Essentially a view of the current variables
pushed to the user namespace.
"""
watchers: TList[TCallable[[AnyStr, TAny, TAny], None]] = List(Callable())
namespace: TDict[AnyStr, TAny] = Dict(key_trait=Unicode(), value_trait= Any())
# Sentinel object
Undefined: object = object()
@default("watchers")
def _watchers_default(self):
return []
@default("namespace")
def _namespace_default(self):
return {}
def watch(self, callback: TCallable[[AnyStr, TAny, TAny], None]) -> None:
"""
Register a new callback that pushes or undefines the object
from the actual environmental namespace.
:param callback: The callback to run
"""
self.watchers.append(callback)
def unwatch(self, callback: TCallable[[AnyStr, TAny, TAny], None]) -> None:
"""
Unregister a given callback
:param callback: The callback to unregister
"""
self.watchers.remove(callback)
def _notify(self, key: AnyStr, value: TAny, old: TAny):
for watcher in self.watchers:
watcher(key, value, old)
def as_dict(self) -> TDict[AnyStr, TAny]:
return self.namespace.copy()
def items(self) -> Iterator[TTuple[AnyStr, TAny]]:
return self.namespace.items()
def __iter__(self):
return iter(self.namespace)
def __getitem__(self, item: AnyStr) -> TAny:
return self.namespace[item]
def __setitem__(self, key: AnyStr, value: TAny):
old = self.namespace.get(key, self.Undefined)
self.namespace[key] = value
self._notify(key, value, old)
def __delitem__(self, key: AnyStr):
old = self.namespace.pop(key)
self._notify(key, self.Undefined, old) | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/core/namespace.py | namespace.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017,2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from traitlets import Type as Class, Dict, List, HasTraits
from traitlets import This
from traitlets import default
from typing import Dict as Dictionary
from typing import List as Listing
from typing import Type, Optional, Callable, Iterator
from yuuno.clip import Clip, T
class Registry(HasTraits):
"""
Stores which Clip-Type is responsible for wrapping
specific applications.
"""
clip_types: Dictionary = Dict(value_trait=Class(klass=Clip), key_trait=Class())
sub_registries: Listing['Registry'] = List(This())
@default("clip_types")
def _init_cliptypes(self) -> Dictionary[Type[Clip], Type[T]]:
return {}
@default("sub_registries")
def _init_subregistries(self) -> Listing['Registry']:
return []
def all_types(self) -> Iterator[Type]:
"""
A generator that returns all supported types.
"""
yield from self.clip_types.keys()
for registry in self.sub_registries:
yield from registry.all_types()
def add_subregistry(self, registry: 'Registry') -> None:
"""
Adds a subregistry to the registry.
These registries can be removed at any time.
:param registry: The registry to add
"""
self.sub_registries.append(registry)
def remove_subregistry(self, registry: 'Registry') -> None:
"""
Removes a subregistry from the registry.
:param registry: The registry to remove.
"""
self.sub_registries.remove(registry)
def register(self, base: Type[Clip], type: Type[T]=None) -> Optional[Callable[[Type[Clip]], Type[Clip]]]:
"""
Registers a new clip type for the given clip.
:param base: The clip-type
:param type: The type the clip is wrapping. (If omitted it will represent a decorator)
:return: A decorator or none.
"""
# Decorator Syntax
if type is None:
def _decorator(type: Type[T]) -> Type[T]:
self.register(type, base)
return type
return _decorator
# Normal handling
self.clip_types[type] = base
def get_clip_type_for(self, item: T) -> Optional[Type[Clip]]:
"""
Returns the clip type for the given object.
:param item: The clip to convert.
:return: Type clip-type responsible for wrapping the object
"""
own_result = self._find_own(item)
if own_result is not None:
return own_result
# Then find in foreign
for registry in self.sub_registries:
result = registry.get_clip_type_for(item)
if result is not None:
return result
return None
def _find_own(self, item: T) -> Optional[Type[Clip]]:
# Find in own first
for cls in type(item).mro():
if cls in self.clip_types:
return self.clip_types[cls]
for cls in self.clip_types:
if isinstance(item, cls):
return self.clip_types[cls]
return None
def wrap(self, item: T) -> Clip:
"""
Returns a wrapper for the clip type.
:param item: The item to convert.
:return: The clip wrapping the item.
"""
clip_type = self.get_clip_type_for(item)
if clip_type is None:
raise ValueError(f"Unsupported type {type(item)!r}")
return clip_type(item) | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/core/registry.py | registry.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import Dict, Optional, Union
from pathlib import Path
from concurrent.futures import Future
from yuuno.clip import Clip
class Script(object):
"""
Represents a script.
"""
@property
def alive(self) -> bool:
"""
Checks if the environment is still alive.
"""
return False
def initialize(self) -> None:
"""
Called when the script is going to be
initialized.
We need this to find out if script-creation
is actually costly.
"""
def dispose(self) -> None:
"""
Disposes the script.
"""
raise NotImplementedError
def get_results(self) -> Future:
"""
Returns a dictionary with clips
that represent the results of the script.
"""
raise NotImplementedError
def execute(self, code: Union[str, Path]) -> Future:
"""
Executes the code inside the environment
"""
raise NotImplementedError
class ScriptManager(object):
"""
Manages and creates script-environments.
"""
def create(self, name: str, *, initialize=False) -> Script:
"""
Creates a new script environment.
"""
raise NotImplementedError
def get(self, name: str) -> Optional[Script]:
"""
Returns the script with the given name.
"""
raise NotImplementedError
def dispose_all(self) -> None:
"""
Disposes all scripts
"""
raise NotImplementedError
def disable(self) -> None:
"""
Disposes all scripts and tries to clean up.
"""
raise NotImplementedError | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/script.py | script.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import Dict, Optional, Iterator, TYPE_CHECKING
from yuuno.core.extension import Extension
if TYPE_CHECKING:
from yuuno.multi_scripts.script import ScriptManager
from yuuno.multi_scripts.subprocess.provider import ScriptProviderRegistration
class MultiScriptExtension(Extension):
_name = "MultiScript"
managers: Dict[str, 'ScriptManager']
providers: Dict[str, 'ScriptProviderRegistration']
@classmethod
def is_supported(self):
return True
def __init__(self, *args, **kwargs):
super(MultiScriptExtension, self).__init__(*args, **kwargs)
self.managers = {}
self.providers = {}
def initialize(self):
pass
def register_manager(self, name: str, manager: 'ScriptManager'):
"""
Registers a new manager.
:param name: The name of the manager.
:param manager: The manager to register.
:return: The registered manager.
"""
if name in self.managers:
raise ValueError("A manager with this name already exists.")
self.managers[name] = manager
def get_manager(self, name: str) -> Optional['ScriptManager']:
"""
Returns the manager with the givern name.
:param name: The name of the manager.
:return: The manager that has been registered with this name.
"""
return self.managers.get(name, None)
def get_manager_names(self) -> Iterator[str]:
"""
Returns all currently registered managers.
:return: The currently registered manager.
"""
yield from self.managers.keys()
def register_provider(self, name: str, registration: 'ScriptProviderRegistration') -> None:
"""
Register a new provider.
:param name: The name of the provider.
:param registration: The registration.
"""
if name in self.providers:
raise ValueError("A provider with this name has already been registered.")
self.providers[name] = registration
def get_provider(self, name: str) -> Optional['ScriptProviderRegistration']:
"""
Get the provider with the given name.
:param name: The name of the provider.
:return: The registration-information.
"""
return self.providers.get(name, None)
def get_provider_names(self) -> Iterator[str]:
"""
Returns the name of all provider.
:return: The provider
"""
yield from self.providers.keys()
def deinitialize(self):
for manager in self.managers.values():
manager.dispose_all()
self.managers = {}
self.providers = {} | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/extension.py | extension.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import List, NamedTuple, Optional, TYPE_CHECKING, Dict
from yuuno import Yuuno
if TYPE_CHECKING:
from yuuno.multi_scripts.script import ScriptManager, Script
from yuuno.multi_scripts.subprocess.process import LocalSubprocessEnvironment
class ScriptProviderRegistration(NamedTuple):
providercls: str
extensions: List[str]
def with_config(self, **kwargs: str) -> 'ScriptProviderInfo':
return ScriptProviderInfo(*self, providerparams=kwargs)
class ScriptProviderInfo(NamedTuple):
providercls: str
extensions: List[str]
providerparams: Dict[str, str]
class ScriptProvider(object):
"""
Provider for single scripts.
"""
yuuno: Yuuno
def __init__(self, yuuno: Yuuno, **kwargs: Dict[str, str]):
self.yuuno = yuuno
def initialize(self, env: 'LocalSubprocessEnvironment') -> None:
"""
Called after _all_ extensions have been loaded
and the system is ready to be loaded.
"""
pass
def deinitialize(self) -> None:
"""
Called when the environment is being disabled.
"""
pass
def get_script(self) -> 'Script':
"""
Returns the script.
"""
pass
class ManagedScriptProvider(ScriptProvider):
manager_name: str
manager: Optional['ScriptManager']
script: Optional['Script']
def __init__(self, yuuno: Yuuno, *, manager_name: str, **kwargs: Dict[str, str]):
super(ManagedScriptProvider, self).__init__(yuuno, **kwargs)
self.manager_name = manager_name
self.manager = None
self.script = None
def initialize(self, env: 'LocalSubprocessEnvironment') -> None:
mscr = self.yuuno.get_extension('MultiScript')
self.manager = mscr.get_manager(self.manager_name)
if self.manager is None:
raise ValueError("Unknown Script Manager detected.")
self.script = self.manager.create('subprocess', initialize=True)
def get_script(self) -> 'Script':
return self.script | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/subprocess/provider.py | provider.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
import traceback
from multiprocessing.connection import Connection
from threading import Thread, RLock as Lock, Event
from typing import MutableMapping, Mapping, Optional, Any, Callable, Union
from typing import NamedTuple, List
from concurrent.futures import Future
class Response(NamedTuple):
id: int
data: Optional[Any] = None
error: Optional[Exception] = None
traceback: Optional[List[str]] = None
protected: bool = False
def store(self, fut: Future):
if self.error is not None:
fut.set_exception(self.error)
else:
fut.set_result(self.data)
class Request(NamedTuple):
id: int
type: str
data: Any
protect: bool = False
def respond(self, data=None) -> Response:
return Response(id=self.id, data=data, protected=self.protect)
def fail(self, error=None) -> Response:
return Response(
id=self.id,
error=error,
traceback=traceback.format_tb(error.__traceback__),
protected=self.protect
)
class Handler(Thread):
read: Connection
write: Connection
write_lock: Lock
stopped: Event
def __init__(self, read: Connection, write: Connection):
super(Handler, self).__init__(daemon=True)
self.read = read
self.write = write
self.stopped = Event()
self.lock = Lock()
def _handle(self, obj: Union[Request, Response]):
pass
def run(self):
while not self.stopped.is_set():
if not self.read.poll(1):
continue
data = self.read.recv()
self._handle(data)
def send(self, obj):
with self.lock:
self.write.send(obj)
def stop(self):
self.stopped.set()
self.join()
class Responder(Handler):
"""
Runs in the subprocess.
It responds to the requests of the main-process.
"""
handlers: Mapping[str, Callable[[Any], Future]]
def __init__(self, read: Connection, write: Connection, handlers: Mapping[str, Callable[[Any], Future]]):
super(Responder, self).__init__(read, write)
self.handlers = handlers
def _handle(self, obj: Request):
print(os.getpid(), ">", obj)
if obj.type not in self.handlers:
self._send(obj.fail(NotImplementedError("Request not supported")))
return
cb = self.handlers[obj.type]
fut = cb(obj.data)
fut.add_done_callback(lambda f: self._respond(obj, f))
def _respond(self, req: Request, res: Future):
if res.exception():
resp = req.fail(res.exception())
else:
resp = req.respond(res.result())
self._send(resp)
def _send(self, resp):
self.send(resp)
if resp.protected:
resp = "(protected)"
print(os.getpid(), ">", resp)
class Requester(Handler):
"""
Runs in the main process.
It waits for responses and sends new requests.
"""
max_id: int
max_id_lock: Lock
waiting: MutableMapping[int, Future]
def __init__(self, read: Connection, write: Connection):
super(Requester, self).__init__(read, write)
self.max_id = 0
self.max_id_lock = Lock()
self.waiting = {}
def _handle(self, obj: Response):
if obj.id not in self.waiting:
return
fut = self.waiting[obj.id]
if fut.cancelled():
return
obj.store(fut)
def _generate_id(self) -> int:
with self.max_id_lock:
new_id = self.max_id
self.max_id += 1
return new_id
def submit(self, type: str, data: Any, protect: bool = False) -> Future:
req = Request(id=self._generate_id(), type=type, data=data, protect=protect)
fut = Future()
fut.set_running_or_notify_cancel()
self.waiting[req.id] = fut
self.send(req)
return fut | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/subprocess/proxy.py | proxy.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import Optional, Dict
from multiprocessing import Pool, get_context
from multiprocessing.context import BaseContext as Context
from yuuno.multi_scripts.script import ScriptManager, Script
from yuuno.multi_scripts.subprocess.process import Subprocess
from yuuno.multi_scripts.subprocess.provider import ScriptProviderInfo
class SubprocessScriptManager(ScriptManager):
"""
Manages and creates script-environments.
"""
instances: Dict[str, Subprocess]
starter: ScriptProviderInfo
pool: Pool
_next_process: Subprocess
def __init__(self, starter: ScriptProviderInfo):
self.instances = {}
self.starter = starter
ctx: Context = get_context("spawn")
self.pool = ctx.Pool()
self._next_process = None
self._checkout_next()
def _checkout_next(self):
prev = self._next_process
self._next_process = Subprocess(self.pool, self.starter)
return prev
def create(self, name: str, *, initialize=False) -> Script:
"""
Creates a new script environment.
"""
if name in self.instances and self.instances[name].alive:
raise ValueError("A core with this name already exists.")
process = self._checkout_next()
self.instances[name] = process
if initialize:
process.initialize()
return process
def get(self, name: str) -> Optional[Script]:
"""
Returns the script with the given name.
"""
return self.instances.get(name)
def dispose_all(self) -> None:
"""
Disposes all scripts
"""
for process in list(self.instances.values()):
if process.alive:
return
process.dispose()
def disable(self) -> None:
"""
Disposes all scripts and tries to clean up.
"""
self.dispose_all()
self._next_process.dispose() | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/subprocess/manager.py | manager.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from pathlib import Path
from typing import TYPE_CHECKING
from yuuno.utils import future_yield_coro
from yuuno.multi_scripts.script import Script
if TYPE_CHECKING:
from yuuno.multi_scripts.subprocess.process import LocalSubprocessEnvironment
class BasicCommands(object):
script: Script
env: 'LocalSubprocessEnvironment'
def __init__(self, script: Script, env: 'LocalSubprocessEnvironment'):
self.script = script
self.env = env
@property
def commands(self):
return {
'script/subprocess/execute': self.execute,
'script/subprocess/results': self.results,
'script/subprocess/results/raw': self.frame_data,
'script/subprocess/results/meta': self.frame_meta
}
@future_yield_coro
def execute(self, type: str, code: str):
if type == 'path':
code = Path(code)
return (yield self.script.execute(code))
@future_yield_coro
def results(self):
outputs = yield self.script.get_results()
return {
str(k): len(v)
for k, v in outputs.items()
}
@future_yield_coro
def frame_meta(self, id: str, frame: int):
outputs = yield self.script.get_results()
clip = outputs.get(id, None)
if clip is None:
return None
try:
frame = yield clip[frame]
except IndexError:
return None
return frame.size(), frame.format()
@future_yield_coro
def frame_data(self, id: str, frame: int):
outputs = yield self.script.get_results()
clip = outputs.get(id, None)
if clip is None:
return None
try:
frame = yield clip[frame]
except IndexError:
return None
frame = frame.to_raw()
from yuuno.multi_scripts.subprocess.process import FRAME_BUFFER_SIZE
if len(frame) > FRAME_BUFFER_SIZE:
return frame
with self.env.framebuffer() as f:
f[:len(frame)] = frame
return len(frame) | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/subprocess/basic_commands.py | basic_commands.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os
import functools
from pathlib import Path
from contextlib import contextmanager
from threading import Lock, Event, Thread
from queue import Queue, Empty
from concurrent.futures import Future
from ctypes import c_ubyte
from multiprocessing import Pipe, Pool, Process
from multiprocessing.sharedctypes import RawArray as Array
from multiprocessing.connection import Connection
from typing import List, Callable, Any, NamedTuple, Sequence, Dict, Union
from typing import TYPE_CHECKING
from traitlets.utils.importstring import import_item
from traitlets import Instance
from yuuno.multi_scripts.subprocess.basic_commands import BasicCommands
from yuuno.utils import future_yield_coro
from yuuno.core.environment import Environment
from yuuno.multi_scripts.utils import ConvertingMappingProxy
from yuuno.multi_scripts.script import Script
from yuuno.multi_scripts.environments import RequestManager
from yuuno.multi_scripts.subprocess.provider import ScriptProviderInfo, ScriptProvider
from yuuno.multi_scripts.subprocess.proxy import Responder, Requester
from yuuno.multi_scripts.subprocess.clip import ProxyClip
if TYPE_CHECKING:
from yuuno.clip import Clip
# This sets the size of the frame-buffer.
# I expect 8K to be enough for now.
FRAME_BUFFER_SIZE = 7680*4320*3
class RequestQueueItem(NamedTuple):
future: Future
cb: Callable[[Any], Any]
args: Sequence[Any]
class LocalSubprocessEnvironment(RequestManager, Environment):
"""
Implements functions for a local subprocess environment.
"""
_provider_meta: ScriptProviderInfo
write: Connection
read: Connection
provider: ScriptProvider = Instance(ScriptProvider)
_framebuffer: Array
_framebuffer_lock: Lock
queue: Queue
stopped: Event
responder: Responder
commands: ConvertingMappingProxy[str, Callable[..., Any], Callable[[Any], Future]]
def additional_extensions(self) -> List[str]:
"""
Defines additional extensions that should be
loaded inside the environment
"""
result = []
for ext in self._provider_meta.extensions:
if not ext.startswith("="):
ext = "="+ext
name, extension = [s.strip() for s in ext.split("=")]
extension = import_item(extension)
if name:
extension._name = name
result.append(extension)
return result
def post_extension_load(self) -> None:
"""
Called directly after extensions have been loaded
(but not enabled)
"""
self.queue = Queue()
self.stopped = Event()
self.handlers = {}
self.commands = ConvertingMappingProxy(self.handlers, self._wrap2queue)
# Let's initialize it here.
provider_class = import_item(self._provider_meta.providercls)
self.provider = provider_class(self.parent, **self._provider_meta.providerparams)
def _wrap2queue(self, unwrapped: Callable[[Any], Any]) -> Callable[[Any], Future]:
@functools.wraps(unwrapped)
def _wrapper(data: Any) -> Future:
fut = Future()
self.queue.put(RequestQueueItem(fut, unwrapped, data))
return fut
return _wrapper
def initialize(self) -> None:
"""
Called by yuuno to tell it that yuuno has
initialized to the point that it can now initialize
interoperability for the given environment.
"""
self.provider.initialize(self)
self.handlers.update(BasicCommands(self.provider.get_script(), self).commands)
self._framebuffer_lock = Lock()
@contextmanager
def framebuffer(self):
with self._framebuffer_lock:
yield memoryview(self._framebuffer).cast("B")
def _copy_result(self, source: Future, destination: Future):
def _done(_):
if source.exception() is not None:
destination.set_exception(source.exception())
else:
destination.set_result(source.result())
self.queue.task_done()
source.add_done_callback(_done)
def run(self):
"""
Wait for commands.
"""
self.responder = Responder(self.read, self.write, self.commands)
self.responder.start()
self.responder.send(None)
while not self.stopped.set():
try:
rqi: RequestQueueItem = self.queue.get(timeout=1)
except Empty:
continue
if not rqi.future.set_running_or_notify_cancel():
continue
try:
result = rqi.cb(**rqi.args)
except KeyboardInterrupt:
self.stop()
except Exception as e:
rqi.future.set_exception(e)
else:
if not isinstance(result, Future):
rqi.future.set_result(result)
self.queue.task_done()
else:
self._copy_result(result, rqi.future)
while True:
try:
rqi: RequestQueueItem = self.queue.get_nowait()
except Empty:
break
rqi.future.set_exception(RuntimeError("System stoppped."))
self.responder.stop()
def stop(self):
self.stopped.set()
def deinitialize(self) -> None:
"""
Called by yuuno before it deconfigures itself.
"""
self.provider.deinitialize()
@staticmethod
def _preload():
print(os.getpid(), ">", "Preloading.")
from yuuno import init_standalone
y = init_standalone()
y.start()
y.stop()
print(os.getpid(), ">", "Preload complete.")
@staticmethod
def _check_parent():
import psutil
current = psutil.Process()
current.parent().wait()
print(os.getpid(), ">", "Parent died. Kill own process...")
current.kill()
@classmethod
def execute(cls, read: Connection, write: Connection, framebuffer: Array):
cls._preload()
Thread(target=cls._check_parent, daemon=True).start()
from yuuno import Yuuno
yuuno = Yuuno.instance(parent=None)
env = cls(parent=yuuno, read=read, write=write)
env._framebuffer = framebuffer
yuuno.environment = env
# Wait for the ProviderMeta to be set.
print(os.getpid(), ">", "Ready to deploy!")
env._provider_meta = read.recv()
yuuno.start()
print(os.getpid(), ">", "Deployed", env._provider_meta)
# Run the environment
env.run()
# Stop Yuuno.
yuuno.stop()
class Subprocess(Script):
process: Process
self_read: Connection
self_write: Connection
child_read: Connection
child_write: Connection
requester: Requester
pool: Pool
provider_info: ScriptProviderInfo
running: bool
def __init__(self, pool: Pool, provider_info: ScriptProviderInfo):
self.process = None
self.pool = pool
self.self_read, self.self_write = Pipe(duplex=False)
self.child_read, self.child_write = Pipe(duplex=False)
self.requester = Requester(self.child_read, self.self_write)
self.provider_info = provider_info
# Allow an 8K image to be transmitted.
# This should be enough.
self._fb = Array(c_ubyte, FRAME_BUFFER_SIZE)
self._fb_lock = Lock()
self._create()
self.running = False
def _create(self):
self.process = self.pool.Process(
target=LocalSubprocessEnvironment.execute,
args=(
self.self_read, self.child_write, # Commands
self._fb
)
)
self.process.start()
@property
def alive(self) -> bool:
return self.running and self.process is not None and self.process.is_alive()
def initialize(self):
if self.alive:
return
if self.running:
raise ValueError("Already disposed!")
self.self_write.send(self.provider_info)
# Block until initialization completes.
self.child_read.recv()
self.running = True
self.requester.start()
def dispose(self) -> None:
"""
Disposes the script.
"""
if not self.alive:
return
if self.requester.is_alive():
self.requester.stop()
self.requester.join()
self.child_write.close()
self.child_read.close()
self.self_write.close()
self.self_read.close()
self.process.terminate()
def __del__(self):
self.dispose()
@contextmanager
def framebuffer(self):
with self._fb_lock:
yield memoryview(self._fb).cast("B")
@future_yield_coro
def get_results(self) -> Dict[str, 'Clip']:
"""
Returns a dictionary with clips
that represent the results of the script.
"""
indexes = yield self.requester.submit("script/subprocess/results", {})
return {name: ProxyClip(name, length, self) for name, length in indexes.items()}
def execute(self, code: Union[str, Path]) -> Future:
"""
Executes the code inside the environment
"""
return self.requester.submit("script/subprocess/execute", {
"type": "path" if isinstance(code, Path) else "string",
"code": str(code)
}) | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/subprocess/process.py | process.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 StuxCrystal (Roland Netzsch <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import TYPE_CHECKING
from typing import Optional, Tuple
from PIL.Image import Image, frombuffer, merge
from yuuno.clip import Clip, Frame, Size, RawFormat
from yuuno.utils import future_yield_coro, auto_join, inline_resolved, gather
if TYPE_CHECKING:
from yuuno.multi_scripts.subprocess.process import Subprocess
class ProxyFrame(Frame):
clip: str
frameno: int
script: 'Subprocess'
_cached_img: Optional[Image]
_cached_meta: Optional[Tuple[Size, RawFormat]]
_cached_raw: Optional[bytes]
def __init__(self, clip: str, frameno: int, script: 'Subprocess'):
self.clip = clip
self.frameno = frameno
self.script = script
self._cached_img = None
self._cached_meta = None
self._cached_raw = None
@future_yield_coro
def _meta(self):
if self._cached_meta is None:
self._cached_meta = yield self.script.requester.submit('script/subprocess/results/meta', {
"id": self.clip,
"frame": self.frameno
})
return self._cached_meta
def size(self) -> Size:
return self._meta().result()[0]
def format(self) -> RawFormat:
return self._meta().result()[1]
@future_yield_coro
def _raw_async(self) -> bytes:
if self._cached_raw is None:
with self.script.framebuffer() as buf:
result = yield self.script.requester.submit('script/subprocess/results/raw', {
"id": self.clip,
"frame": self.frameno
}, protect=True)
if isinstance(result, int):
self._cached_raw = bytes(buf[:result])
else:
# We got the actual object pickled.
# This means we are dealing with extremely huge frames
self._cached_raw = result
return self._cached_raw
def to_raw(self) -> bytes:
return self._raw_async().result()
@auto_join
@future_yield_coro
def to_pil(self):
if self._cached_img is not None:
return self._cached_img
size, format, raw = yield self.get_raw_data_async()
raw = memoryview(raw)
index = 0
planes = []
for i in range(format.num_planes):
plane = self.plane_size(i)
planedata = raw[index:index+plane]
planes.append(frombuffer('L', size, planedata, 'raw', "L", 0, 1))
index += plane
pil_format = "RGB"
if format.num_planes == 4:
pil_format += "A"
return merge(pil_format, planes)
@future_yield_coro
def get_raw_data_async(self) -> Tuple[Size, RawFormat, bytes]:
m, raw = yield gather([self._meta(), self._raw_async()])
return m[0], m[1], raw
class ProxyClip(Clip):
script: 'Subprocess'
length: int
def __init__(self, clip: str, length: int, script: 'Subprocess'):
super(ProxyClip, self).__init__(clip)
self.script = script
self.length = length
def __len__(self):
return self.length
@inline_resolved
def __getitem__(self, item):
if item >= len(self):
raise IndexError("The clip does not have as many frames.")
return ProxyFrame(clip=self.clip, frameno=item, script=self.script) | yuuno-core | /yuuno-core-1.3.1.zip/yuuno-core-1.3.1/yuuno/multi_scripts/subprocess/clip.py | clip.py |
=======
History
=======
1.4.0 (Moscow)
---------------
* Reintegrated Yuuno Core into Yuuno proper.
* I am using a nix-flakes now.
* You don't need to manually install the extension anymore.
* It works with APIv4 now.
* In %%vspreview if there are only two outputs, automatically start diff-view.
* Yuuno now works with JupyterLab
* Added rudimentary audio support. You cannot encode audio right now but if it's the output of a cell
it will show a simple audio player. It however requires VapourSynth R58 to work.
1.3.0 (Jakarta)
----------------
* We use our own Output Code now. This should allow us more flexibility.
1.2.0 (New York)
----------------
* Added %%vspreview and %%vspipe (which just emulates vspipe for now) implements a new workflow for
Yuuno users.
* %diff is now an alias for %preview
* Previews can now do a diff.
* Removed the completely useless %show
* Instead of showing the first frame, we are now showing a preview on browsers. It will gracefully degrade.
* Auto-Completion for core.* works again!
1.1.0 (Sรฃo Paulo)
-----------------
* Removed %inspect and %compare (See deprecation of 1.0.0)
* Recreated %encode and %preview in JavaScript.
* Added %reattach to reattach to encodes.
1.0.0 (Marun Field)
-------------------
* Split up the core-parts of Yuuno into its own repository.
* Show log messages sent from VapourSynth
* From VapourSynth R44 onwards, we can reset core objects.
* Deprecated %inspect and %compare
0.8.0 (Glastig Uaine)
---------------------
* Now I name my releases because I feel like it.
* Fixed color profile not included in PNGs by default. Do so by emitting an sRGB-chunk.
* Completed first version of Comm-Protocol for Yuuno-Kernels.
* Added progressbar to %encode-magic.
* Added support for R41+ alpha clips. (Also with R43+ AlphaOutputTuple support: vapoursynth/#362)
* Use %show for IPython. It will convert the clip to a PIL image. (Can also work for Alpha-Tuples pre R41).
0.7.0
-----
* Added support for clips with variable video formats
* Added support for zlib compression and ICCP-chunk on PNG outputter
0.6.0 (2017-07-24)
------------------
* `%runvpy` can now return the outputs of a vapoursynth-script (.vpy) as a dict.
* Settings of VapourSynth cores are now exposed as configuration variables
* [Misc] Extracted `%encode` and stuck it inside its own sub-package.
0.5.0 (2017-06-18)
------------------
Rewrite of the yuuno codebase to prepare for Yuuno 1.0.0-release.
* You don't have to do `%yuuno install` anymore.
* To configure settings while in your IPython-shell, use the %config-magic, which is available in any IPython installation.
* The minimum Python-version of Yuuno is Python 3.6. Make sure you are running this version when upgrading.
* Using `%unload_ext yuuno` you can now completely deactivate Yuuno on your notebook.
* The `%encode`-magic has become more robust now.
* There is a `%render`-magic now, which does everything %encode does but stores the output into a io.BytesIO.
* All interactive applications are now IPython-magics.
* %preview returns a Preview-object. By changing the clip-Attribute of these objects, you can change the clip without losing the frame number.
0.4.0 (2017-05-18)
------------------
* Allow `vapoursynth.VideoFrames` to be inline-rendered.
* Fixed incorrect aspect-ratio on all `ipywidget` based features.
* Add f-string parsing inside `%encode`. (Will fallback to regular string.format for Python < 3.6) [thanks for the idea @๐eXmendiC]
* Switched to Jinja2 Templates for Raw-HTML output
* Omit iCCP-chunk since apparently the csp has to be set manually by the user on media players. Of course it can be changed back at any time.
0.3.0 (2017-03-20)
------------------
* An ICCP-chunk is now sent along with the PNG. Currently the default is the 709-CSP ICC. Color-Managed browsers will honor this chunk.
* The variables `core` (referencing the current VS-Core) and `vs` (as a referece to the vapoursynth) will now be pushed to the user-namespace on Yuuno activation.
* `%yuuno install` is now the installation command
* `%yuuno version` shows the current version of yuuno
* `%yuuno help` shows the help for Yuuno.
* `%yuuno get` and `%yuuno set` can be used for configuring Yuuno.
* You have to use `%load_ext yuuno` for initiating yuuno now.
| yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/HISTORY.rst | HISTORY.rst |
.. highlight:: shell
============
Contributing
============
Contributions are welcome, and they are greatly appreciated! Every
little bit helps, and credit will always be given.
You can contribute in many ways:
Types of Contributions
----------------------
Report Bugs
~~~~~~~~~~~
Report bugs at https://todo.sr.ht/~cid-chan/yuuno
If you are reporting a bug, please include:
* Your operating system name and version.
* Any details about your local setup that might be helpful in troubleshooting.
* Detailed steps to reproduce the bug.
Fix Bugs
~~~~~~~~
Look through the GitHub issues for bugs. Anything tagged with "bug"
and "help wanted" is open to whoever wants to implement it.
Implement Features
~~~~~~~~~~~~~~~~~~
Look through the GitHub issues for features. Anything tagged with "enhancement"
and "help wanted" is open to whoever wants to implement it.
Write Documentation
~~~~~~~~~~~~~~~~~~~
yuuno could always use more documentation, whether as part of the
official yuuno docs, in docstrings, or even on the web in blog posts,
articles, and such.
Submit Feedback
~~~~~~~~~~~~~~~
The best way to send feedback is to send an email to ~cid-chan/[email protected]
If you are proposing a feature:
* Explain in detail how it would work.
* Keep the scope as narrow as possible, to make it easier to implement.
* Remember that this is a volunteer-driven project, and that contributions
are welcome :)
| yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/CONTRIBUTING.rst | CONTRIBUTING.rst |
import sys
import subprocess
def jupyter():
"""Commands for Yuuno 4 IPython"""
if len(sys.argv) == 1:
print("Use 'yuuno jupyter --help' for a full help page.")
sys.exit(1)
if sys.argv[1] == "--help":
print("Yuuno for IPython and Jupyter")
print("Usage:")
print("\tyuuno jupyter --help\tShow this help page.")
print("\tyuuno jupyter run\tRuns the Jupyter notebook.")
print("\tyuuno jupyter install\tInstalls and enables all required notebook extensions.")
print("\tyuuno jupyter version\tShows the version of Yuuno 4 Jupyter.")
return
executable = sys.executable
if sys.argv[1] == "run":
print("Yuuno is now automatically integrating into Jupyter.")
print("Run 'jupyter notebook' (without quotes) instead.")
sys.exit(1)
elif sys.argv[1] == "install":
print("Yuuno is now automatically integrating into Jupyter.")
print("Nothing to do.")
return
elif sys.argv[1] == "version":
try:
import vapoursynth as vs
except ImportError:
vs_ver = "Failed to import. (Is vapoursynth installed?)"
except Exception as e:
vs_ver = f"Failed to import: {e!r}"
else:
if hasattr(vs, "__version__"):
vs_ver = f"{vs.__version__[0]}.{vs.__version__[1]}"
else:
vs_ver = vs.core.version()
from yuuno_ipython import __version__ as y4ipy_ver
if "--for-debug" in sys.argv:
import json
from yuuno import __version__ as ycore_ver
print(
'{',
f' "yuuno": "{ycore_ver}",',
f' "yuuno-core": "{ycore_ver}",',
f' "python": {json.dumps(tuple(sys.version_info))},',
f' "vapoursynth": {json.dumps(vs_ver)}',
'}',
sep="\n")
else:
print(f"Yuuno for IPython v{y4ipy_ver}")
else:
print("Command not found.")
print("Use 'yuuno jupyter --help' for a full help page.")
sys.exit(1) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/commands.py | commands.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import Callable as TCallable
from typing import AnyStr, Any
from traitlets import default
from yuuno.trait_types import Callable
from yuuno.core.namespace import Namespace as YuunoNamespace
from yuuno_ipython.ipython.feature import Feature
class Namespace(Feature):
"""
Represents the namespace synchronization feature.
"""
cb: TCallable[[AnyStr, Any], None] = Callable()
@default("cb")
def _set_cb_unique(self) -> TCallable[[AnyStr, Any], None]:
return self.push_value
def push_value(self, key: AnyStr, value: Any, old: Any) -> None:
if value is YuunoNamespace.Undefined:
self.environment.parent.log.debug(f"Popping from user namespace: {key}")
self.environment.ipython.drop_by_id({key: old})
else:
self.environment.parent.log.debug(f"Pushing to user namespace: {key}: {value!r}")
self.environment.ipython.push({key: value})
def initialize(self):
namespace = self.environment.parent.namespace
namespace.watch(self.cb)
for key, value in namespace.items():
self.push_value(key, value, YuunoNamespace.Undefined)
def deinitialize(self):
namespace = self.environment.parent.namespace
for key, value in namespace.items():
self.push_value(key, YuunoNamespace.Undefined, value)
namespace.unwatch(self.cb) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/namespace.py | namespace.py |
๏ปฟ# -*- encoding: utf-8 -*-
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from weakref import WeakKeyDictionary
from PIL.Image import Image
from traitlets import observe, default
from traitlets import HasTraits, Instance, Any
from IPython.display import Image as IPyImage
from yuuno.clip import Clip, Frame
from yuuno.audio import Audio
from yuuno_ipython.ipython.feature import Feature
from yuuno_ipython.ipython.environment import Environment
from yuuno_ipython.ipython.apps.preview import Preview
from yuuno_ipython.ipython.apps.audio import AudioWidget
class AbstractInlineFormat(HasTraits):
clip: Clip = Any()
environment: Environment = Instance(Environment)
REPR_TYPES = {
}
def _repr_mimebundle_(self, include=None, exclude=None):
data_dict = {}
md_dict = {}
mimes = set(include) if include is not None else set(self.REPR_TYPES.keys())
mimes &= set(self.REPR_TYPES.keys())
if exclude is not None:
mimes ^= set(exclude)
for mime in mimes:
funcname = self.REPR_TYPES[mime]
if not hasattr(self, funcname):
continue
raw = getattr(self, funcname)()
if isinstance(raw, tuple) and len(raw) == 2:
data, md = raw
else:
data = raw
md = None
if data is None:
continue
data_dict[mime] = data
if md is not None:
md_dict[mime] = md
return data_dict, md_dict
class InlineFormatAudio(AbstractInlineFormat):
preview: AudioWidget = Instance(AudioWidget, allow_none=True)
REPR_TYPES = {
"text/plain": "_repr_pretty",
'application/vnd.jupyter.widget-view+json': '_repr_player'
}
@observe("clip")
def _update_initial_frame(self, value):
value = value['new']
self.preview.clip = value
@default("preview")
def _default_preview(self):
return AudioWidget(self.clip)
def _repr_pretty(self):
return f"<Audio {self.clip.format()!r} (backed: {self.clip.clip!r})>"
def _repr_player(self):
if self.preview._view_name is None:
return
return self.preview.get_view_spec()
class InlineFormatVideo(AbstractInlineFormat):
"""
Represents an inline formatted object.
"""
preview: Preview = Instance(Preview, allow_none=True)
first_frame: Frame = Any(allow_none=True)
_ipy_image_cache: IPyImage = None
@observe("clip")
def _update_initial_frame(self, value):
value = value['new']
self.first_frame = value[0].result()
self._ipy_image_cache = None
self.preview.clip = value
@default("preview")
def _default_preview(self):
return Preview(self.clip)
@property
def ipy_image(self) -> IPyImage:
"""
Converts a clip to an image.
"""
if self._ipy_image_cache is not None:
return self._ipy_image_cache
size = self.first_frame.size()
raw = self.environment.parent.output.bytes_of(self.first_frame.to_pil())
self._ipy_image_cache = IPyImage(
data=raw,
format="png",
embed=True,
unconfined=True,
width=size.width,
height=size.height
)
return self._ipy_image_cache
REPR_TYPES = {
'image/png': '_repr_png',
'text/plain': '_repr_pretty',
'application/vnd.jupyter.widget-view+json': '_repr_preview'
}
def _repr_pretty(self):
size = self.first_frame.size()
return f"<{self.clip.clip!r} {size.width}x{size.height}, {len(self.clip)} frames>"
def _repr_png(self, *args, **kwargs):
return self.ipy_image._repr_png_(*args, **kwargs)
def _repr_preview(self):
if self.preview._view_name is None:
return
return self.preview.get_view_spec()
def InlineFormat(environment, clip):
if isinstance(clip, Audio):
return InlineFormatAudio(environment=environment, clip=clip)
else:
return InlineFormatVideo(environment=environment, clip=clip)
class Formatter(Feature):
cache: WeakKeyDictionary = Instance(WeakKeyDictionary)
@default("cache")
def _default__cache(self):
return WeakKeyDictionary()
@property
def display_formatters(self):
return self.environment.ipython.display_formatter
def wrap_cached(self, obj) -> Any:
if obj in self.cache:
return self.cache[obj]
clip = self.environment.parent.registry.wrap(obj)
wrapped = InlineFormat(environment=self.environment, clip=clip)
self.cache[obj] = wrapped
return wrapped
def display(self, obj, *args, **kwargs):
wrapper = self.wrap_cached(obj)
return wrapper._repr_mimebundle_(*args, **kwargs)
def initialize(self):
for type in self.environment.parent.registry.all_types():
self.environment.parent.log.debug(f"Registering {type!r} to IPython")
self.display_formatters.mimebundle_formatter.for_type(type, self.display)
def deinitialize(self):
for type in self.environment.parent.registry.all_types():
self.environment.parent.log.debug(f"Unregistering {type!r} from IPython")
self.display_formatters.mimebundle_formatter.pop(type) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/formatter.py | formatter.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import ast
import time
import hashlib
import linecache
from typing import Callable
from yuuno.yuuno import Yuuno
EXECUTE_CODE_LINENO = 0
RESULT_VAR = '_yuuno_exec_last_'
def _code_name(code, file, number=0):
hash_digest = hashlib.sha1(code.encode("utf-8")).hexdigest()
return f"<{file}-{number}-{hash_digest[:12]}>"
def compile_with_cache(ipython, code, ast, file, symbol):
# Increment the cache name.
global EXECUTE_CODE_LINENO
exec_no = EXECUTE_CODE_LINENO
EXECUTE_CODE_LINENO += 1
# Directly drop the fake python file into the cache.
name = _code_name(code, file, exec_no)
entry = (len(code), time.time(), [line + '\n' for line in code.splitlines()], name)
linecache.cache[name] = entry
if hasattr(linecache, '_ipython_cache'):
linecache._ipython_cache[name] = entry
# Compile the code
return ipython.compile(ast, name, symbol)
def execute_code(expr, file, fail_on_error=True, ns=None):
ipy = Yuuno.instance().environment.ipython
expr = ipy.input_transformer_manager.transform_cell(expr)
expr_ast = ipy.compile.ast_parse(expr)
expr_ast = ipy.transform_ast(expr_ast)
if len(expr_ast.body) == 0:
# There is no code to execute.
# Take the fast path and skip executing.
return None
elif isinstance(expr_ast.body[-1], ast.Expr):
last_expr = expr_ast.body[-1]
assign = ast.Assign( # _yuuno_exec_last_ = <LAST_EXPR>
targets=[ast.Name(
id=RESULT_VAR,
ctx=ast.Store()
)],
value=last_expr.value
)
expr_ast.body[-1] = assign
else:
assign = ast.Assign( # _yuuno_exec_last_ = None
targets=[ast.Name(
id=RESULT_VAR,
ctx=ast.Store(),
)],
value=ast.NameConstant(
value=None
)
)
expr_ast.body.append(assign)
ast.fix_missing_locations(expr_ast)
code = compile_with_cache(ipy, expr, expr_ast, file, "exec")
if ns is None:
ns = ipy.user_ns
try:
exec(code, ipy.user_ns, ns)
result = ipy.user_ns.get(RESULT_VAR, None)
finally:
ns.pop(RESULT_VAR, None)
return result | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/utils.py | utils.py |
๏ปฟ# -*- encoding: utf-8 -*-
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017,2018,2022 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import Sequence, Tuple as TTuple
from IPython.core.interactiveshell import InteractiveShell
from traitlets import Instance
from traitlets import List
from traitlets import Bool, Integer, Float
from traitlets import DottedObjectName
from traitlets import CaselessStrEnum
from traitlets.utils.importstring import import_item
from yuuno_ipython.ipython.feature import Feature
from yuuno.core.environment import Environment
from yuuno.yuuno import Yuuno
class YuunoIPythonEnvironment(Environment):
"""
Stores the state containing the current
"""
ipython: InteractiveShell = Instance(InteractiveShell)
features: Sequence[Feature] = List(Instance(Feature))
no_env_wrap: bool = Bool(True, help="Overwrite the setting of Yuuno to execute all formatting calls inside the correct environment", config=True)
formatter: bool = Bool(True, help="Register IPython-formatters for objects", config=True)
namespace: bool = Bool(True, help="Automatically push modules and extensions into the user namespace.", config=True)
apps: bool = Bool(True, help="Register interactive apps as line-magics to IPython", config=True)
use_vsscript: bool = Bool(True, help="Use VSScript", config=True)
feature_classes: Sequence[str] = List(DottedObjectName(), default_value=[
"yuuno_ipython.ipython.formatter.Formatter",
"yuuno_ipython.ipython.namespace.Namespace",
"yuuno_ipython.ipython.apps.feature.Apps",
], config=True)
def init_feature(self, cls):
feature_name = cls.feature_name()
if not getattr(self, feature_name, False):
return None
feature = cls(environment=self)
feature.initialize()
return feature
def additional_extensions(self):
result = []
result.append("yuuno_ipython.ipy_vs.extension.IPythonVapoursynthExtension")
if self.use_vsscript:
result.append("yuuno.multi_scripts.extension.MultiScriptExtension")
return result
def load_features(self):
features = []
for feature in self.feature_classes:
self.parent.log.debug(f"Loading feature: {feature}")
feature_class = import_item(feature)
feature_instance = self.init_feature(feature_class)
if feature_instance is not None:
features.append(feature_instance)
self.features = features
def unload_features(self):
for feature in self.features:
feature.deinitialize()
def post_extension_load(self):
if self.no_env_wrap:
vs = self.parent.get_extension('VapourSynth')
if vs is not None:
vs.vsscript_environment_wrap = False
self.parent.log.debug("Disabling Env-Wrapping for VapourSynth clips.")
def initialize(self):
self.ipython.configurables += [self.parent, self.parent.output]
self.ipython.configurables += [self]
self.ipython.configurables += self.parent.extensions
self.load_features()
self.parent.log.debug("Yuuno for IPython configured")
def deinitialize(self):
self.unload_features()
self.ipython.configurables.remove(self)
self.ipython.configurables.remove(self.parent)
self.ipython.configurables.remove(self.parent.output)
for extension in self.parent.extensions:
self.ipython.configurables.remove(extension)
self.parent.log.debug("Yuuno for IPython unloaded")
def load_ipython_extension(ipython: InteractiveShell) -> None:
"""
Called when IPython load this extension.
:param ipython: The current IPython-console instance.
"""
yuuno = Yuuno.instance(parent=ipython)
yuuno.environment = YuunoIPythonEnvironment(parent=yuuno, ipython=ipython)
yuuno.start()
def unload_ipython_extension(ipython) -> None:
"""
Called when IPython unloads the extension.
"""
yuuno = Yuuno.instance()
yuuno.stop() | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/environment.py | environment.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017,2022 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import Type as TType
from typing import Dict as TDict
from traitlets import Dict, Type, Instance
from traitlets import default
from IPython.core.magic import Magics, magic_kinds
from yuuno_ipython.ipython.formatter import Feature
class MagicFeature(Feature):
magics: TDict[TType[Magics], Magics] = Dict(key_traits=Type(Magics), value_traits=Instance(Magics))
@default("magics")
def _default_magics(self):
return {}
@property
def magic_manager(self):
return self.environment.ipython.magics_manager
def register_magics(self, magic: TType[Magics]) -> None:
"""
Registers a new magic into the IPython console.
:param magic: The magics to use.
"""
instance = magic(shell=self.environment.ipython)
self.magics[magic] = instance
self.environment.ipython.register_magics(instance)
self.environment.parent.log.debug(f"Registered magics class: {magic.__class__}")
def unregister_magics(self, magic: TType[Magics]) -> None:
"""
Unregisters the magic-type from IPython.
Rant: Why the fuck does IPython define it's own unregister function?
:param magic: The magics-type you wish to deactivate.
"""
actual_magics = self.magics[magic].magics
for kind in magic_kinds:
for key in actual_magics[kind]:
self.magic_manager.magics[kind].pop(key, None)
del self.magics[magic]
self.environment.parent.log.debug(f"Unregistered magics class: {magic}")
def deinitialize(self):
for magic in tuple(self.magics.keys()):
self.unregister_magics(magic) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/magic.py | magic.py |
from ipywidgets import DOMWidget
from traitlets import Unicode, Any
from yuuno.utils import future_yield_coro
from yuuno.audio import Audio
class AudioWidget(DOMWidget):
_view_name = Unicode('AudioPlaybackWidget').tag(sync=True)
_view_module = Unicode('@yuuno/jupyter').tag(sync=True)
_view_module_version = Unicode('1.2').tag(sync=True)
clip: Audio = Any().tag(sync=True, to_json=(lambda v,w: id(v) if v is not None else None), from_json=(lambda v, w: w.clip))
def __init__(self, clip, **kwargs):
super(AudioWidget, self).__init__(**kwargs, clip=clip)
self.on_msg(self._handle_request_meta)
self.on_msg(self._handle_request_render)
@future_yield_coro
def _handle_request_render(self, _, content, buffers):
if content.get("type", "") != "render": return
rqid = content.get('id', None)
if "payload" not in content: return
payload = content["payload"]
requested_frame = payload.get("frame", None)
if requested_frame is None:
self.send({
"type": "failure",
"id": rqid,
"payload": {
"data": "Missing argument: Frame."
}
})
return
try:
rendered = yield self.clip[int(requested_frame)]
self.send({
"type": "response",
"id": rqid,
"payload": {
"size": len(rendered[0]) // 4
}
}, rendered)
except Exception as e:
import traceback
data = traceback.format_exception(type(e), e, e.__traceback__)
self.send({
"type": "failure",
"id": rqid,
"payload": {
"data": data
}
})
return
def _handle_request_meta(self, _, content, buffers):
if content.get("type", "") != "meta": return
rqid = content.get('id', None)
format = self.clip.format()
self.send({
"type": "response",
"id": rqid,
"payload": {
"channel_count": format.channel_count,
"samples_per_second": format.samples_per_second,
"frames": format.frames,
"sample_count": format.sample_count
}
}) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/apps/audio.py | audio.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import base64
from typing import Any as TAny
from ipywidgets import DOMWidget
from traitlets import default, directional_link, observe
from traitlets import Any
from traitlets import Integer, Unicode, Float
from yuuno.clip import Clip
from yuuno.utils import future_yield_coro
from yuuno import Yuuno
EMPTY_IMAGE = base64.b64decode(
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAACklEQVR4nGMAAQAABQABDQottAAAAABJRU5ErkJggg=="
)
class _Cache(object):
def __init__(self, source, updater):
self._cache_obj_id = None
self._cache_inst = None
self._cache_source = source
self._cache_updater = updater
def _update(self, obj):
self._cache_obj_id = id(obj)
self._cache_inst = self._cache_updater(obj)
return self._cache_inst
def get(self):
obj = self._cache_source()
if self._cache_obj_id != id(obj):
return self._update(obj)
return self._cache_inst
class Preview(DOMWidget):
"""
Implements a preview widget
.. automethod:: __init__
"""
_view_name = Unicode('PreviewWindowWidget').tag(sync=True)
_view_module = Unicode('@yuuno/jupyter').tag(sync=True)
_view_module_version = Unicode('1.2').tag(sync=True)
# Ignore the changes
clip: Clip = Any().tag(sync=True, to_json=(lambda v,w: id(v) if v is not None else None), from_json=(lambda v, w: w.clip))
diff: Clip = Any().tag(sync=True, to_json=(lambda v,w: id(v) if v is not None else None), from_json=(lambda v, w: w.diff))
frame = Integer(0).tag(sync=True)
zoom = Float(1.0).tag(sync=True)
def __init__(self, clip, **kwargs):
super(Preview, self).__init__(**kwargs, clip=clip)
self._clip_cache = _Cache(lambda: self.clip, self._wrap_for)
self._diff_cache = _Cache(lambda: self.diff, self._wrap_for)
self.on_msg(self._handle_request_length)
self.on_msg(self._handle_request_frame)
def _handle_request_length(self, _, content, buffers):
if content.get('type', '') != 'length':
return
rqid = content.get('id', None)
target = self._target_for(content)
if target is None:
self.send({
'type': 'response',
'id': rqid,
'payload': {
'length': 0
}
})
return
self.send({
'type': 'response',
'id': rqid,
'payload': {
'length': len(target)
},
})
def _target_for(self, content):
if content.get('payload', {}).get('image', 'clip') == "diff":
target = self._diff_cache
else:
target = self._clip_cache
return target.get()
def _wrap_for(self, target):
if target is None:
return None
elif not isinstance(target, Clip):
target = Yuuno.instance().wrap(target)
return target
@future_yield_coro
def _handle_request_frame(self, _, content, buffers):
if content.get('type', '') != 'frame':
return
rqid = content.get('id', None)
wrapped = self._target_for(content)
if wrapped is None:
self.send({
'type': 'response',
'id': rqid,
'payload': {
'size': [0, 0]
}
}, [EMPTY_IMAGE])
return
frameno = content.get('payload', {}).get('frame', self.frame)
if frameno >= len(wrapped):
frameno = len(wrapped) - 1
try:
frame = yield wrapped[frameno]
except Exception as e:
import traceback
self.send({
'type': 'failure',
'id': rqid,
'payload': {
'message': ''.join(traceback.format_exception(type(e), e, e.__traceback__))
}
})
raise
data = Yuuno.instance().output.bytes_of(frame.to_pil())
self.send({
'type': 'response',
'id': rqid,
'payload': {
'size': frame.size()
}
}, [data]) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipython/apps/preview.py | preview.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import runpy
from typing import Dict, Optional
import vapoursynth
from IPython.core.magic import Magics, magics_class
from IPython.core.magic import line_magic, line_cell_magic
from yuuno import Yuuno
from yuuno_ipython.ipython.magic import MagicFeature
from yuuno_ipython.ipython.utils import execute_code
from yuuno_ipython.ipy_vs.vs_feature import VSFeature
from yuuno.vs.utils import VapourSynthEnvironment
@magics_class
class RunVPyMagic(Magics):
"""
Implements the Magics
"""
@property
def environment(self):
return Yuuno.instance().environment
@line_cell_magic
def runvpy(self, line: str, cell: Optional[str]=None) -> Dict[int, vapoursynth.VideoNode]:
if cell is None:
return self.runvpy_line(line)
return self.runvpy_cell(line, cell)
@line_magic
def execvpy(self, line: str):
runpy.run_path(line, {}, "__vapoursynth__")
def runvpy_line(self, line: str) -> Dict[int, vapoursynth.VideoNode]:
outputs = VapourSynthEnvironment()
with outputs:
self.execvpy(line)
return outputs.outputs
def runvpy_cell(self, line: str, cell: str) -> Dict[int, vapoursynth.VideoNode]:
outputs = VapourSynthEnvironment()
with outputs:
execute_code(cell, '<yuuno:runvpy>')
raw_split = line.split(" ", 2)
var_name = raw_split[0]
if len(raw_split) == 1:
self.environment.ipython.push({var_name: outputs.outputs})
else:
index = int(raw_split[1])
self.environment.ipython.push({line.split()[0]: outputs.outputs[index]})
return outputs.outputs
class RunVPy(VSFeature, MagicFeature):
def initialize(self):
self.register_magics(RunVPyMagic) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/runvpy.py | runvpy.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018,2022 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import typing as t
from threading import RLock
from concurrent.futures import Future
import vapoursynth as vs
from yuuno.vs.utils import get_proxy_or_core
from yuuno.vs.flags import Features
T = t.TypeVar("T")
def as_completed(futures: t.Iterable[Future], prefetch: int, backlog: t.Optional[int]=None) -> t.Iterable[T]:
if backlog is None:
backlog = prefetch*3
if backlog < prefetch:
backlog = prefetch
enum_fut = enumerate(futures)
finished = False
running = 0
lock = RLock()
reorder = {}
def _request_next():
nonlocal finished, running
with lock:
if finished:
return
ni = next(enum_fut, None)
if ni is None:
finished = True
return
running += 1
idx, fut = ni
reorder[idx] = fut
fut.add_done_callback(_finished)
def _finished(f):
nonlocal finished, running
with lock:
running -= 1
if finished:
return
if f.exception() is not None:
finished = True
return
_refill()
def _refill():
if finished:
return
with lock:
# Two rules: 1. Don't exceed the concurrency barrier.
# 2. Don't exceed unused-frames-backlog
while (not finished) and (running < prefetch) and len(reorder)<backlog:
_request_next()
_refill()
sidx = 0
fut: Future
try:
while (not finished) or (len(reorder)>0) or running>0:
if sidx not in reorder:
# Spin. Reorder being empty should never happen.
continue
# Get next requested frame
fut = reorder[sidx]
result = fut.result()
del reorder[sidx]
_refill()
sidx += 1
yield result
finally:
finished = True
def frames(clip, prefetch, backlog):
return as_completed((clip.get_frame_async(frameno) for frameno in range(len(clip))), prefetch, backlog)
def encode(
clip: vs.VideoNode,
stream: t.IO[t.ByteString],
*,
y4m: bool = False,
prefetch: t.Optional[int]=None,
backlog: t.Optional[int]=None,
progress: t.Optional[t.Callable[[int, int], None]]=None
) -> None:
if prefetch is None:
prefetch = get_proxy_or_core().num_threads
if not isinstance(clip, vs.VideoNode):
clip = clip[0]
if y4m:
if clip.format.color_family == vs.GRAY:
y4mformat = 'mono'
if clip.format.bits_per_sample > 8:
y4mformat = y4mformat + str(clip.format.bits_per_sample)
elif clip.format.color_family == vs.YUV:
if clip.format.subsampling_w == 1 and clip.format.subsampling_h == 1:
y4mformat = '420'
elif clip.format.subsampling_w == 1 and clip.format.subsampling_h == 0:
y4mformat = '422'
elif clip.format.subsampling_w == 0 and clip.format.subsampling_h == 0:
y4mformat = '444'
elif clip.format.subsampling_w == 2 and clip.format.subsampling_h == 2:
y4mformat = '410'
elif clip.format.subsampling_w == 2 and clip.format.subsampling_h == 0:
y4mformat = '411'
elif clip.format.subsampling_w == 0 and clip.format.subsampling_h == 1:
y4mformat = '440'
else:
raise ValueError("This is a very strange subsampling config.")
if clip.format.bits_per_sample > 8:
y4mformat = y4mformat + 'p' + str(clip.format.bits_per_sample)
else:
raise ValueError("Can only use vs.GRAY and vs.YUV for V4M-Streams")
if len(y4mformat) > 0:
y4mformat = 'C' + y4mformat
data = f'YUV4MPEG2 {y4mformat} W{clip.width} H{clip.height} F{clip.fps_num}:{clip.fps_den} Ip A0:0 XLENGTH={len(clip)}\n'
stream.write(data.encode("ascii"))
if hasattr(stream, "flush"):
stream.flush()
frame: vs.VideoFrame
for idx, frame in enumerate(frames(clip, prefetch, backlog)):
if y4m:
stream.write(b"FRAME\n")
if Features.API4:
iterator = frame
else:
iterator = frame.planes()
for planeno, plane in enumerate(iterator):
# This is a quick fix.
# Calling bytes(VideoPlane) should make the buffer continuous by
# copying the frame to a continous buffer
# if the stride does not match the width*bytes_per_sample.
try:
if frame.get_stride(planeno) != frame.width*clip.format.bytes_per_sample:
stream.write(bytes(plane))
else:
stream.write(plane)
except BrokenPipeError:
return
if hasattr(stream, "flush"):
stream.flush()
if progress is not None:
progress(idx+1, len(clip))
stream.close() | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/outputter.py | outputter.py |
๏ปฟ# -*- encoding: utf-8 -*-
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import NamedTuple
import sys
import time
import shlex
import queue
import codecs
import random
import subprocess
from threading import Thread, Lock, Event
import jinja2
from traitlets import Instance, default
from IPython.display import display
from IPython.core.magic import Magics, magics_class
from IPython.core.magic import line_cell_magic, line_magic
from yuuno import Yuuno
from yuuno.vs.utils import get_proxy_or_core, get_environment
from yuuno.multi_scripts.os import popen, interrupt_process, kill_process
from yuuno_ipython.utils import get_data_file, log_errors
from yuuno_ipython.ipython.utils import execute_code
from yuuno_ipython.ipython.magic import MagicFeature
from yuuno_ipython.ipython.environment import YuunoIPythonEnvironment
from yuuno_ipython.ipy_vs.vs_feature import VSFeature
from collections import deque
from ipywidgets import DOMWidget
from traitlets import Unicode, Tuple, Integer, Bool
_running = {}
class EncodeWidget(DOMWidget):
_view_name = Unicode('EncodeWindowWidget').tag(sync=True)
_view_module = Unicode('@yuuno/jupyter').tag(sync=True)
_view_module_version = Unicode('1.2').tag(sync=True)
current = Integer(0).tag(sync=True)
length = Integer(1).tag(sync=True)
terminated = Bool(False).tag(sync=True)
commandline = Unicode("").tag(sync=True)
start_time = Integer(0).tag(sync=True)
end_time = Integer(0).tag(sync=True)
_win32 = Bool(sys.platform=="win32").tag(sync=True)
def __init__(self, *args, kill, process, commandline, **kwargs):
super().__init__(*args, **kwargs)
self._lock = Lock()
self._kill = kill
self._process = process
self._commandline = commandline
self.commandline = self._commandline
self._latest_writes = deque(maxlen=10000)
self.start_time = int(time.time())
self.on_msg(self._rcv_message)
def write(self, string):
string = string.replace("\n", "\r\n")
if not string:
return
with self._lock:
self._latest_writes.append(string)
self.send({'type': 'write', 'data': string, 'target': 'broadcast'})
def join(self, timeout=None):
self._kill.wait(timeout=timeout)
def _rcv_message(self, _, content, buffer):
cid = content.get("id", None)
if content['type'] == "refresh":
data = content
if "payload" in data:
data = data["payload"]
with self._lock:
writes = ''.join(self._latest_writes)
if cid is not None:
self.send({'type': 'response', 'id': cid, 'payload': {"data": writes}})
self.send({'type': 'write', 'data': writes, 'target': data['source']})
self.send({'type': 'refresh_finish', 'data': None, 'target': data['source']})
elif content['type'] == 'kill':
kill_process(self._process)
self._kill.set()
with self._lock:
self.send({'type': 'response', 'id': cid, 'payload': {}})
elif content['type'] == "interrupt":
interrupt_process(self._process)
with self._lock:
self.send({'type': 'response', 'id': cid, 'payload': {}})
class _EData(NamedTuple):
id: str
command: str
current: int
length: int
class EncodeData(object):
_template_txt = None
_template_html = None
@classmethod
def template_txt(cls):
if cls._template_txt is None:
path = get_data_file("txt") / "encodes.txt"
with open(path, "r") as f:
cls._template_txt = jinja2.Template(f.read())
return cls._template_txt
@classmethod
def template_html(cls):
if cls._template_html is None:
path = get_data_file("html") / "encodes.html"
with open(path, "r") as f:
cls._template_html = jinja2.Template(f.read())
return cls._template_html
@staticmethod
def _map_value(eid, encoder):
return _EData(
str(eid),
encoder._commandline,
encoder.current,
encoder.length
)
def __init__(self, current_encodes):
self.current_encodes = current_encodes.copy()
def _repr_pretty_(self, p, cycle):
p.text(self.template_txt().render({
"encodes": [self._map_value(*i) for i in self.current_encodes.items()]
}))
def _repr_html_(self):
return self.template_html().render({
"random_id": hex(random.randint(0, 2**32))[2:],
"encodes": [self._map_value(*i) for i in self.current_encodes.items()]
})
@magics_class
class EncodeMagic(Magics):
"""
Encode magics.
"""
environment: YuunoIPythonEnvironment = Instance(YuunoIPythonEnvironment)
@default("environment")
def _default_environment(self):
return Yuuno.instance().environment
@log_errors
def _reader(self, dead: Event, process: subprocess.Popen, pipe_r, term_q, encode, after_exit):
while process.poll() is None and not dead.is_set():
d = pipe_r.read(1)
if d:
term_q.put(d)
if process.poll() is None:
process.terminate()
try:
process.stdin.close()
except OSError:
pass
if not dead.is_set():
dead.set()
encode.end_time = int(time.time())
encode.terminated = True
del _running[str(process.pid)]
d = pipe_r.read()
if d:
term_q.put(d)
if after_exit is not None:
after_exit()
term_q.put(b"\n\n[Process Terminated]")
term_q.put(None)
@log_errors
def _terminal_writer(self, term_q, encode: EncodeWidget):
decoder = codecs.getincrementaldecoder(sys.getdefaultencoding())('replace')
killed = False
while not killed:
data = []
while not term_q.empty():
raw = term_q.get_nowait()
if raw is None:
killed = True
break
data.append(raw)
data = b''.join(data)
if data:
encode.write(decoder.decode(data))
time.sleep(0.1)
encode.write(decoder.decode(b'', final=True))
@log_errors
def _state_updater(self, dead, encode, state):
while not dead.is_set():
encode.current, encode.length = state
time.sleep(0.5)
encode.current, encode.length = state
@log_errors
def _clip_output(self, env, clip, dead, encode, stdin, state, y4m):
def _progress(current, length):
state[0], state[1] = current, length
try:
from yuuno_ipython.ipy_vs.outputter import encode as raw_encode
with env():
raw_encode(clip, stdin, y4m=y4m, progress=_progress)
except Exception as e:
if dead.is_set():
return
encode._process.terminate()
raise e
try:
stdin.close()
except OSError:
pass
def begin_encode(self, clip, commandline, stdout=None, after_exit=None, **kwargs):
"""
Implements the actual encoding process
:param clip: The clip to encode.
:param commandline: The command to execute
:param stdout: Where to send the stdout.
:return: The return code.
"""
raw = commandline
commandline = shlex.split(commandline)
shell = kwargs.pop('shell', False)
kill = Event()
state = [0, len(clip)]
process = popen(
raw if shell else commandline,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
shell=shell,
bufsize=0
)
encode = EncodeWidget(kill=kill, process=process, commandline=raw)
encode.length = len(clip)
_running[str(process.pid)] = encode
q = queue.Queue()
Thread(target=self._reader, args=(kill, process, process.stdout, q, encode, after_exit), daemon=True).start()
Thread(target=self._terminal_writer, args=(q, encode), daemon=True).start()
if clip is not None:
Thread(target=self._clip_output, args=(get_environment(), clip, kill, encode, process.stdin, state, kwargs.get("y4m", False))).start()
Thread(target=self._state_updater, args=(kill, encode, state), daemon=True).start()
return encode
def prepare_encode(self, line, cell, stdout=None):
if cell is None:
cell, line = line.split(" ", 1)
y4m = False
multi = False
# Switch to Argparse if this gets more complicated
while True:
if line.startswith("--y4m"):
y4m = True
line = line[6:]
elif line.startswith("--no-progress"):
print("--no-progress has no use anymore and is ignored.")
elif line.startswith("--multi"):
multi = True
line = line[8:]
else:
break
if not multi and len(_running):
print(r"You are already running an encode. Use %reattach to view the latest encode or use --multi to run multiple instances")
return
commandline = self.environment.ipython.var_expand(line)
clip = execute_code(cell, '<yuuno:encode>')
encode = self.begin_encode(clip, commandline, stdout=stdout, y4m=y4m)
return encode
@line_magic
def reattach(self, line):
if not line:
if len(_running) != 1:
display(EncodeData(_running))
else:
return next(iter(_running.values()))
elif line not in _running:
print("Encode was not found.")
else:
return _running[line]
@line_cell_magic
def encode(self, line, cell=None):
"""
Encodes the video directly displaying the output.
:param line: The line
:param cell: The cell
:return: The result-code
"""
return self.prepare_encode(line, cell)
class Encode(VSFeature, MagicFeature):
def initialize(self):
self.register_magics(EncodeMagic) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/encode.py | encode.py |
๏ปฟ# -*- encoding: utf-8 -*-
# Yuuno - IPython + VapourSynth
# Copyright (C) 2017,2018 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import List as Listing
from traitlets import default
from traitlets import Instance, List, DottedObjectName
from traitlets.utils.importstring import import_item
from yuuno.yuuno import Yuuno
from yuuno.core.extension import Extension
from yuuno_ipython.ipython.feature import Feature
class IPythonVapoursynthExtension(Extension):
"""
This extension implements VapourSynth-specific features for IPython.
"""
_name = "ipy_vs"
feature_classes: Listing[str] = List(DottedObjectName(), default_value=[
"yuuno_ipython.ipy_vs.log.LogWriterFeature",
"yuuno_ipython.ipy_vs.encode.Encode",
"yuuno_ipython.ipy_vs.runvpy.RunVPy",
"yuuno_ipython.ipy_vs.vsscript.Use_VSScript",
"yuuno_ipython.ipy_vs.stateful_editor.StatefulEditorFeature"
], config=True, help="List of additional features to load.")
features: Listing[Feature] = List(Instance(Feature))
yuuno: Yuuno = Instance(Yuuno)
@default("features")
def _default_features(self):
return []
@default("yuuno")
def _default_yuuno(self):
return Yuuno.instance()
@classmethod
def is_supported(cls):
try:
import IPython
except ImportError:
return False
from yuuno_ipython.ipython.environment import YuunoIPythonEnvironment
if not isinstance(Yuuno.instance().environment, YuunoIPythonEnvironment):
return False
from yuuno.vs.extension import VapourSynth
return VapourSynth.is_supported()
def initialize(self):
for feature in self.feature_classes:
self.yuuno.log.debug(f"Loading feature: {feature}")
feature = import_item(feature)
feature_inst = feature(extension=self)
self.features.append(feature_inst)
feature_inst.initialize()
def deinitialize(self):
for feature in self.features[:]:
feature.deinitialize()
self.features.remove(feature) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/extension.py | extension.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from typing import TYPE_CHECKING
from contextlib import contextmanager
from IPython import InteractiveShell
from IPython.core.magic import line_magic, cell_magic, magics_class
from yuuno import Yuuno
from yuuno_ipython.ipython.magic import MagicFeature, Magics
from yuuno_ipython.ipython.utils import execute_code
from yuuno_ipython.ipy_vs.vs_feature import VSFeature
from yuuno.vs.flags import Features
if TYPE_CHECKING:
from vapoursynth import Environment
from yuuno.vs.vsscript.script import ScriptManager, VSScript
_cur_env = None
def get_current_env() -> 'Environment':
global _cur_env
if _cur_env is None:
import vapoursynth
if Features.ENVIRONMENT_POLICIES:
def __new_cur_env():
return vapoursynth.get_current_environment().use()
_cur_env = __new_cur_env
else:
_cur_env = vapoursynth.vpy_current_environment
try:
return _cur_env()
except RuntimeError:
return None
def env_from_script(script: 'VSScript') -> 'Environment':
return script.perform(get_current_env).result()
@magics_class
class CoreControlMagics(Magics):
@property
def vsscript_feature(self) -> 'Use_VSScript':
for feature in self.yuuno.get_extension('ipy_vs').features:
if isinstance(feature, Use_VSScript):
return feature
raise Exception("Couldn't find Feature Instance? Report this error.")
@property
def script_manager(self) -> 'ScriptManager':
return self.yuuno.get_extension('MultiScript').get_manager('VSScript')
@property
def yuuno(self):
return Yuuno.instance()
@cell_magic
def isolated_core(self, line, cell):
script: VSScript = self.script_manager.create('isolated-1', initialize=True)
env = env_from_script(script)
try:
with env:
with self.vsscript_feature.protect():
result = execute_code(cell, '<yuuno:isolated_core>', False)
if result is not None:
return result
finally:
script.dispose()
@line_magic
def reset_core(self, line):
self.vsscript_feature.reset_script()
class VSScriptWrapper(object):
def __init__(self, script):
self.script = script
self._env = env_from_script(self.script)
@classmethod
def with_name(cls, name):
mgr = Yuuno.instance().get_extension('MultiScript')
environment = Yuuno.instance().environment
if mgr is None or not environment.use_vsscript:
# VSScript is not enabled. Don't do anything.
return
manager: ScriptManager = mgr.get_manager('VSScript')
if manager is None:
# VSScript is not enabled. Don't do anything.
return
return cls(manager.create(name, initialize=True))
def __enter__(self):
return self._env.__enter__()
def __exit__(self, *args, **kwargs):
return self._env.__exit__(*args, **kwargs)
def replace(self):
"""
Replaces the top-most VapourSynth-Environment stack
with the given VapourSynth environment.
"""
cur_env = get_current_env()
if get_current_env() != self._env:
if not Features.ENVIRONMENT_POLICIES:
# Hack to forcibly remove the environment from the stack.
if cur_env is not None:
cur_env.__exit__()
self._env.__enter__()
def dispose(self):
if get_current_env() == self._env:
self._env.__exit__()
self.script.dispose()
# noinspection PyPep8Naming
class Use_VSScript(VSFeature, MagicFeature):
def __init__(self, *args, **kwargs):
super(Use_VSScript, self).__init__(*args, **kwargs)
self.events = {}
def initialize(self):
mgr = self.environment.parent.get_extension('MultiScript')
if mgr is None or not self.environment.use_vsscript:
# VSScript is not enabled. Don't do anything.
return
self.manager: ScriptManager = mgr.get_manager('VSScript')
if self.manager is None:
# VSScript is not enabled. Don't do anything.
return
self.events = {
'pre_execute': [self._enter_env],
'post_execute': [self._exit_env]
}
ipy: InteractiveShell = self.environment.ipython
for name, evts in self.events.items():
for evt in evts:
ipy.events.register(name, evt)
self.register_magics(CoreControlMagics)
self._cell_level = 0
self.manager: ScriptManager = mgr.get_manager('VSScript')
self.script = None
self.reset_script()
@contextmanager
def protect(self):
self._cell_level += 1
try:
yield
finally:
self._cell_level -= 1
def reset_script(self):
if self.script is not None:
self.script.dispose()
self.script: VSScriptWrapper = VSScriptWrapper(self.manager.create('ipython', initialize=True))
self._enter_env()
def _enter_env(self):
if self._cell_level > 0:
return
self.script.replace()
def _exit_env(self):
if self._cell_level > 0:
return
# Do nothing anymore.
def deinitialize(self):
if not self.events:
return
self.manager.dispose_all()
ipy: InteractiveShell = self.environment.ipython
for name, evts in self.events.items():
for evt in evts:
ipy.events.unregister(name, evt)
super(Use_VSScript, self).deinitialize() | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/vsscript.py | vsscript.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018,2022 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import shutil
from collections import ChainMap
from contextlib import contextmanager
from IPython.display import display
from yuuno_ipython.ipython.apps.preview import Preview
from yuuno_ipython.ipy_vs.vs_feature import VSFeature
from yuuno_ipython.ipy_vs.encode import EncodeMagic, _running as running_encodes
from yuuno_ipython.ipython.magic import MagicFeature
from yuuno_ipython.ipython.utils import execute_code
from yuuno import Yuuno
from yuuno.vs.utils import VapourSynthEnvironment
from IPython.core.magic import Magics, magics_class
from IPython.core.magic import cell_magic
@contextmanager
def _noop():
return (yield)
@magics_class
class EditorMagics(Magics):
preview = Preview(None)
encode = EncodeMagic()
yuuno_header = """
import vapoursynth as vs
from vapoursynth import core
"""
@property
def yuuno(self):
return Yuuno.instance()
@property
def vsscript_feature(self) -> 'Use_VSScript':
from yuuno_ipython.ipy_vs.vsscript import Use_VSScript
for feature in self.yuuno.get_extension('ipy_vs').features:
if isinstance(feature, Use_VSScript):
return feature
return None
def parse_parameters(self, line):
data = {}
current_flag = None
current_info = []
rest_type = None
rest = None
for word in line.split():
if rest is not None:
rest.append(word)
continue
elif word in ("--", '|'):
if current_flag is not None:
data[current_flag] = current_info
current_flag = None
rest = []
rest_type = word
elif word.startswith("--"):
if current_flag is not None:
data[current_flag] = current_info
current_flag = word[2:]
current_info = []
else:
current_info.append(word)
if rest is not None:
data['--'] = rest
if current_flag is not None:
data[current_flag] = current_info
return data
@cell_magic
def vspipe(self, line, cell):
line = self.parse_parameters(line)
if "help" in line:
print("%%vspipe [--outputindex <OUTPUT-ID>] [OPTIONS] | [commandline]")
print()
print("%%vspipe emulates the vspipe-binary. It uses %encode under the hood.")
print("Note that only one %%vspipe can run at the same time.")
print()
print("Options special to %%vspipe")
print("--outputindex <OUTPUT-ID> - Select output index")
print("--y4m - Add YUV4MPEG headers to output")
print("--start N - Set the output frame range (first frame)")
print("--end N - Set the output frame range (last frame)")
print("--requests N - Set the number of concurrent frame requests")
print()
print("General options")
print("--reset-core - Reset the core before running the cell.")
print("--isolate-core - Use a temporary core for the encode.")
print("--isolate-variables - Make sure that variables set inside this cell do not affect the global environment.")
return
if len(running_encodes) > 0:
print("There is already an encode running.")
print("Please stop or finish the encode(s) and try again. Use %reattach to find running encodes.")
return
if "--" not in line and "|" not in line:
print("Please provide a valid command-line.")
return
main = int(line.get("outputindex", [0])[0])
start = None
if "start" in line:
start = int(line["start"][0])
end = None
if "end" in line:
end = int(line["end"][0])+1
requests = None
if "requests" in line:
requests = int(line["requests"][0])
reset_core = False
if self.vsscript_feature is not None and not VapourSynthEnvironment.single() and "reset-core" in line:
reset_core = True
ns = self.yuuno.environment.ipython.user_ns
if "isolate-variables" in line:
ns = ChainMap({}, ns)
if reset_core:
self.vsscript_feature.reset_script()
script = _noop()
after_exit = None
if "isolate-core" in line:
from yuuno_ipython.ipy_vs.vsscript import VSScriptWrapper
script = VSScriptWrapper.with_name("vspipe-emulation")
after_exit = lambda: script.dispose()
with script:
env = VapourSynthEnvironment()
with env:
execute_code(cell, "<vspreview>", True, ns=ns)
outputs = env.outputs
if main not in env.outputs:
print("Couldn't find your output. Aborting.")
return
clip = outputs[main][start:end]
encode = self.encode.begin_encode(clip, ' '.join(line['--']), y4m=('y4m' in line), prefetch=requests, after_exit=after_exit)
display(encode)
@cell_magic
def vspreview(self, line, cell):
line = self.parse_parameters(line)
if "help" in line:
print("%%vspreview [--main <OUTPUT-ID>] [--diff <OUTPUT-ID>] [OPTIONS]")
print()
print("%%vspreview shows a preview of the given script. It can diff two outputs with --diff.")
print("It does not modify the outputs of the vapoursynth environment.")
print("You can use --isolate-variables to sandbox changes of the environment to the cell. Any changes to variables")
print("will not be visible outside the cell.")
print()
print("--main and --diff are ignored if there are less than 3 output-clips.")
print()
print("Options special to %%vspreview")
print("--main <OUTPUT-ID> - Select the output number to show as the main (defaults to 0 if not given.)")
print("--diff <OUTPUT-IDS> - Set the id to compare to")
print()
print("General options")
print("--reset-core - Reset the core.")
print("--isolate-variables - Make sure that variables set inside this cell do not affect the global environment.")
return
reset_core = False
if self.vsscript_feature is not None and not VapourSynthEnvironment.single() and "reset-core" in line:
reset_core = True
diff = None
if "diff" in line:
diff = 1 if len(line["diff"]) == 0 else int(line["diff"][0])
main = 1
if "main" in line:
if len(line["main"]) == 0:
raise ValueError("You need to provide an output-id")
main = int(line["main"][0])
ns = self.yuuno.environment.ipython.user_ns
if "isolate-variables" in line:
ns = ChainMap({}, ns)
# Reset the actual script
if reset_core:
self.vsscript_feature.reset_script()
env = VapourSynthEnvironment()
with env:
execute_code(cell, "<vspreview>", True, ns=ns)
outputs = env.outputs
if len(outputs) == 1:
main = next(iter(outputs))
elif len(outputs) == 2:
oiter = iter(sorted(iter(outputs)))
main = next(oiter)
diff = next(oiter)
self.preview.clip = outputs.get(main, None)
self.preview.diff = None if diff is None else outputs.get(diff, None)
display(self.preview)
class StatefulEditorFeature(VSFeature, MagicFeature):
def initialize(self):
self.register_magics(EditorMagics) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/stateful_editor.py | stateful_editor.py |
# Yuuno - IPython + VapourSynth
# Copyright (C) 2018,2022 cid-chan (Sarah <[email protected]>)
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import random
import jinja2
from IPython.display import display, HTML
from yuuno import Yuuno
from yuuno_ipython.utils import get_data_file
from yuuno.vs.utils import MessageLevel
from yuuno.vs.extension import VapourSynth
from yuuno_ipython.ipy_vs.vs_feature import VSFeature
class LogMessage(object):
_jinja_template = None
@classmethod
def template(cls):
if cls._jinja_template is None:
path = get_data_file("html") / "log-message.html"
with open(path, "r") as f:
cls._jinja_template = jinja2.Template(f.read())
return cls._jinja_template
def __init__(self, level, message):
self.level = level
self.message = message
def _repr_html_(self):
return self.template().render({
"random_id": hex(random.randint(0, 2**32))[2:],
"level_class": self.level.lower(),
"level": self.level,
"message": self.message
})
def _repr_pretty_(self, p, cycle):
p.text("[VapourSynth] %s: %s" % (self.level, self.message))
class LogWriterFeature(VSFeature):
def _push_log_msg(self, level: MessageLevel, msg: str) -> None:
level = level.value
if level == MessageLevel.mtDebug:
level = "Debug"
elif level == MessageLevel.mtInfo:
level = "Info"
elif level == MessageLevel.mtWarning:
level = "Warning"
elif level == MessageLevel.mtCritical:
level = "Critical"
else:
level = "Fatal"
display(LogMessage(level, msg))
def initialize(self):
extension: VapourSynth = Yuuno.instance().get_extension('VapourSynth')
if extension is None:
return
extension.log_handlers.append(self._push_log_msg)
def deinitialize(self):
extension: VapourSynth = Yuuno.instance().get_extension('VapourSynth')
if extension is None:
return
extension.log_handlers.remove(self._push_log_msg) | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_ipython/ipy_vs/log.py | log.py |
"use strict";
(self["webpackChunk_yuuno_jupyterlab"] = self["webpackChunk_yuuno_jupyterlab"] || []).push([["style_index_js"],{
/***/ "./node_modules/css-loader/dist/cjs.js!./style/base.css":
/*!**************************************************************!*\
!*** ./node_modules/css-loader/dist/cjs.js!./style/base.css ***!
\**************************************************************/
/***/ ((module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_css_loader_dist_runtime_cssWithMappingToString_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../node_modules/css-loader/dist/runtime/cssWithMappingToString.js */ "./node_modules/css-loader/dist/runtime/cssWithMappingToString.js");
/* harmony import */ var _node_modules_css_loader_dist_runtime_cssWithMappingToString_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_cssWithMappingToString_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../node_modules/css-loader/dist/runtime/api.js */ "./node_modules/css-loader/dist/runtime/api.js");
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_cssWithMappingToString_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, "", "",{"version":3,"sources":[],"names":[],"mappings":"","sourceRoot":""}]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
/***/ }),
/***/ "./style/base.css":
/*!************************!*\
!*** ./style/base.css ***!
\************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! !../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js */ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js");
/* harmony import */ var _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_cjs_js_base_css__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! !!../node_modules/css-loader/dist/cjs.js!./base.css */ "./node_modules/css-loader/dist/cjs.js!./style/base.css");
var options = {};
options.insert = "head";
options.singleton = false;
var update = _node_modules_style_loader_dist_runtime_injectStylesIntoStyleTag_js__WEBPACK_IMPORTED_MODULE_0___default()(_node_modules_css_loader_dist_cjs_js_base_css__WEBPACK_IMPORTED_MODULE_1__["default"], options);
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (_node_modules_css_loader_dist_cjs_js_base_css__WEBPACK_IMPORTED_MODULE_1__["default"].locals || {});
/***/ }),
/***/ "./style/index.js":
/*!************************!*\
!*** ./style/index.js ***!
\************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony import */ var _base_css__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./base.css */ "./style/base.css");
/***/ })
}]);
//# sourceMappingURL=style_index_js.046a091dd193851c3746.js.map | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_jupyterlab/static/static/style_index_js.046a091dd193851c3746.js | style_index_js.046a091dd193851c3746.js |
"use strict";
(self["webpackChunk_yuuno_jupyterlab"] = self["webpackChunk_yuuno_jupyterlab"] || []).push([["vendors-node_modules_svelte_index_mjs"],{
/***/ "./node_modules/svelte/index.mjs":
/*!***************************************!*\
!*** ./node_modules/svelte/index.mjs ***!
\***************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "SvelteComponent": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.SvelteComponentDev),
/* harmony export */ "SvelteComponentTyped": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.SvelteComponentTyped),
/* harmony export */ "afterUpdate": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.afterUpdate),
/* harmony export */ "beforeUpdate": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.beforeUpdate),
/* harmony export */ "createEventDispatcher": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.createEventDispatcher),
/* harmony export */ "getAllContexts": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.getAllContexts),
/* harmony export */ "getContext": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.getContext),
/* harmony export */ "hasContext": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.hasContext),
/* harmony export */ "onDestroy": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.onDestroy),
/* harmony export */ "onMount": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.onMount),
/* harmony export */ "setContext": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.setContext),
/* harmony export */ "tick": () => (/* reexport safe */ _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__.tick)
/* harmony export */ });
/* harmony import */ var _internal_index_mjs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./internal/index.mjs */ "./node_modules/svelte/internal/index.mjs");
/***/ }),
/***/ "./node_modules/svelte/internal/index.mjs":
/*!************************************************!*\
!*** ./node_modules/svelte/internal/index.mjs ***!
\************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "HtmlTag": () => (/* binding */ HtmlTag),
/* harmony export */ "HtmlTagHydration": () => (/* binding */ HtmlTagHydration),
/* harmony export */ "SvelteComponent": () => (/* binding */ SvelteComponent),
/* harmony export */ "SvelteComponentDev": () => (/* binding */ SvelteComponentDev),
/* harmony export */ "SvelteComponentTyped": () => (/* binding */ SvelteComponentTyped),
/* harmony export */ "SvelteElement": () => (/* binding */ SvelteElement),
/* harmony export */ "action_destroyer": () => (/* binding */ action_destroyer),
/* harmony export */ "add_attribute": () => (/* binding */ add_attribute),
/* harmony export */ "add_classes": () => (/* binding */ add_classes),
/* harmony export */ "add_flush_callback": () => (/* binding */ add_flush_callback),
/* harmony export */ "add_location": () => (/* binding */ add_location),
/* harmony export */ "add_render_callback": () => (/* binding */ add_render_callback),
/* harmony export */ "add_resize_listener": () => (/* binding */ add_resize_listener),
/* harmony export */ "add_transform": () => (/* binding */ add_transform),
/* harmony export */ "afterUpdate": () => (/* binding */ afterUpdate),
/* harmony export */ "append": () => (/* binding */ append),
/* harmony export */ "append_dev": () => (/* binding */ append_dev),
/* harmony export */ "append_empty_stylesheet": () => (/* binding */ append_empty_stylesheet),
/* harmony export */ "append_hydration": () => (/* binding */ append_hydration),
/* harmony export */ "append_hydration_dev": () => (/* binding */ append_hydration_dev),
/* harmony export */ "append_styles": () => (/* binding */ append_styles),
/* harmony export */ "assign": () => (/* binding */ assign),
/* harmony export */ "attr": () => (/* binding */ attr),
/* harmony export */ "attr_dev": () => (/* binding */ attr_dev),
/* harmony export */ "attribute_to_object": () => (/* binding */ attribute_to_object),
/* harmony export */ "beforeUpdate": () => (/* binding */ beforeUpdate),
/* harmony export */ "bind": () => (/* binding */ bind),
/* harmony export */ "binding_callbacks": () => (/* binding */ binding_callbacks),
/* harmony export */ "blank_object": () => (/* binding */ blank_object),
/* harmony export */ "bubble": () => (/* binding */ bubble),
/* harmony export */ "check_outros": () => (/* binding */ check_outros),
/* harmony export */ "children": () => (/* binding */ children),
/* harmony export */ "claim_component": () => (/* binding */ claim_component),
/* harmony export */ "claim_element": () => (/* binding */ claim_element),
/* harmony export */ "claim_html_tag": () => (/* binding */ claim_html_tag),
/* harmony export */ "claim_space": () => (/* binding */ claim_space),
/* harmony export */ "claim_svg_element": () => (/* binding */ claim_svg_element),
/* harmony export */ "claim_text": () => (/* binding */ claim_text),
/* harmony export */ "clear_loops": () => (/* binding */ clear_loops),
/* harmony export */ "component_subscribe": () => (/* binding */ component_subscribe),
/* harmony export */ "compute_rest_props": () => (/* binding */ compute_rest_props),
/* harmony export */ "compute_slots": () => (/* binding */ compute_slots),
/* harmony export */ "createEventDispatcher": () => (/* binding */ createEventDispatcher),
/* harmony export */ "create_animation": () => (/* binding */ create_animation),
/* harmony export */ "create_bidirectional_transition": () => (/* binding */ create_bidirectional_transition),
/* harmony export */ "create_component": () => (/* binding */ create_component),
/* harmony export */ "create_in_transition": () => (/* binding */ create_in_transition),
/* harmony export */ "create_out_transition": () => (/* binding */ create_out_transition),
/* harmony export */ "create_slot": () => (/* binding */ create_slot),
/* harmony export */ "create_ssr_component": () => (/* binding */ create_ssr_component),
/* harmony export */ "current_component": () => (/* binding */ current_component),
/* harmony export */ "custom_event": () => (/* binding */ custom_event),
/* harmony export */ "dataset_dev": () => (/* binding */ dataset_dev),
/* harmony export */ "debug": () => (/* binding */ debug),
/* harmony export */ "destroy_block": () => (/* binding */ destroy_block),
/* harmony export */ "destroy_component": () => (/* binding */ destroy_component),
/* harmony export */ "destroy_each": () => (/* binding */ destroy_each),
/* harmony export */ "detach": () => (/* binding */ detach),
/* harmony export */ "detach_after_dev": () => (/* binding */ detach_after_dev),
/* harmony export */ "detach_before_dev": () => (/* binding */ detach_before_dev),
/* harmony export */ "detach_between_dev": () => (/* binding */ detach_between_dev),
/* harmony export */ "detach_dev": () => (/* binding */ detach_dev),
/* harmony export */ "dirty_components": () => (/* binding */ dirty_components),
/* harmony export */ "dispatch_dev": () => (/* binding */ dispatch_dev),
/* harmony export */ "each": () => (/* binding */ each),
/* harmony export */ "element": () => (/* binding */ element),
/* harmony export */ "element_is": () => (/* binding */ element_is),
/* harmony export */ "empty": () => (/* binding */ empty),
/* harmony export */ "end_hydrating": () => (/* binding */ end_hydrating),
/* harmony export */ "escape": () => (/* binding */ escape),
/* harmony export */ "escape_attribute_value": () => (/* binding */ escape_attribute_value),
/* harmony export */ "escape_object": () => (/* binding */ escape_object),
/* harmony export */ "escaped": () => (/* binding */ escaped),
/* harmony export */ "exclude_internal_props": () => (/* binding */ exclude_internal_props),
/* harmony export */ "fix_and_destroy_block": () => (/* binding */ fix_and_destroy_block),
/* harmony export */ "fix_and_outro_and_destroy_block": () => (/* binding */ fix_and_outro_and_destroy_block),
/* harmony export */ "fix_position": () => (/* binding */ fix_position),
/* harmony export */ "flush": () => (/* binding */ flush),
/* harmony export */ "getAllContexts": () => (/* binding */ getAllContexts),
/* harmony export */ "getContext": () => (/* binding */ getContext),
/* harmony export */ "get_all_dirty_from_scope": () => (/* binding */ get_all_dirty_from_scope),
/* harmony export */ "get_binding_group_value": () => (/* binding */ get_binding_group_value),
/* harmony export */ "get_current_component": () => (/* binding */ get_current_component),
/* harmony export */ "get_custom_elements_slots": () => (/* binding */ get_custom_elements_slots),
/* harmony export */ "get_root_for_style": () => (/* binding */ get_root_for_style),
/* harmony export */ "get_slot_changes": () => (/* binding */ get_slot_changes),
/* harmony export */ "get_spread_object": () => (/* binding */ get_spread_object),
/* harmony export */ "get_spread_update": () => (/* binding */ get_spread_update),
/* harmony export */ "get_store_value": () => (/* binding */ get_store_value),
/* harmony export */ "globals": () => (/* binding */ globals),
/* harmony export */ "group_outros": () => (/* binding */ group_outros),
/* harmony export */ "handle_promise": () => (/* binding */ handle_promise),
/* harmony export */ "hasContext": () => (/* binding */ hasContext),
/* harmony export */ "has_prop": () => (/* binding */ has_prop),
/* harmony export */ "identity": () => (/* binding */ identity),
/* harmony export */ "init": () => (/* binding */ init),
/* harmony export */ "insert": () => (/* binding */ insert),
/* harmony export */ "insert_dev": () => (/* binding */ insert_dev),
/* harmony export */ "insert_hydration": () => (/* binding */ insert_hydration),
/* harmony export */ "insert_hydration_dev": () => (/* binding */ insert_hydration_dev),
/* harmony export */ "intros": () => (/* binding */ intros),
/* harmony export */ "invalid_attribute_name_character": () => (/* binding */ invalid_attribute_name_character),
/* harmony export */ "is_client": () => (/* binding */ is_client),
/* harmony export */ "is_crossorigin": () => (/* binding */ is_crossorigin),
/* harmony export */ "is_empty": () => (/* binding */ is_empty),
/* harmony export */ "is_function": () => (/* binding */ is_function),
/* harmony export */ "is_promise": () => (/* binding */ is_promise),
/* harmony export */ "listen": () => (/* binding */ listen),
/* harmony export */ "listen_dev": () => (/* binding */ listen_dev),
/* harmony export */ "loop": () => (/* binding */ loop),
/* harmony export */ "loop_guard": () => (/* binding */ loop_guard),
/* harmony export */ "missing_component": () => (/* binding */ missing_component),
/* harmony export */ "mount_component": () => (/* binding */ mount_component),
/* harmony export */ "noop": () => (/* binding */ noop),
/* harmony export */ "not_equal": () => (/* binding */ not_equal),
/* harmony export */ "now": () => (/* binding */ now),
/* harmony export */ "null_to_empty": () => (/* binding */ null_to_empty),
/* harmony export */ "object_without_properties": () => (/* binding */ object_without_properties),
/* harmony export */ "onDestroy": () => (/* binding */ onDestroy),
/* harmony export */ "onMount": () => (/* binding */ onMount),
/* harmony export */ "once": () => (/* binding */ once),
/* harmony export */ "outro_and_destroy_block": () => (/* binding */ outro_and_destroy_block),
/* harmony export */ "prevent_default": () => (/* binding */ prevent_default),
/* harmony export */ "prop_dev": () => (/* binding */ prop_dev),
/* harmony export */ "query_selector_all": () => (/* binding */ query_selector_all),
/* harmony export */ "raf": () => (/* binding */ raf),
/* harmony export */ "run": () => (/* binding */ run),
/* harmony export */ "run_all": () => (/* binding */ run_all),
/* harmony export */ "safe_not_equal": () => (/* binding */ safe_not_equal),
/* harmony export */ "schedule_update": () => (/* binding */ schedule_update),
/* harmony export */ "select_multiple_value": () => (/* binding */ select_multiple_value),
/* harmony export */ "select_option": () => (/* binding */ select_option),
/* harmony export */ "select_options": () => (/* binding */ select_options),
/* harmony export */ "select_value": () => (/* binding */ select_value),
/* harmony export */ "self": () => (/* binding */ self),
/* harmony export */ "setContext": () => (/* binding */ setContext),
/* harmony export */ "set_attributes": () => (/* binding */ set_attributes),
/* harmony export */ "set_current_component": () => (/* binding */ set_current_component),
/* harmony export */ "set_custom_element_data": () => (/* binding */ set_custom_element_data),
/* harmony export */ "set_data": () => (/* binding */ set_data),
/* harmony export */ "set_data_dev": () => (/* binding */ set_data_dev),
/* harmony export */ "set_input_type": () => (/* binding */ set_input_type),
/* harmony export */ "set_input_value": () => (/* binding */ set_input_value),
/* harmony export */ "set_now": () => (/* binding */ set_now),
/* harmony export */ "set_raf": () => (/* binding */ set_raf),
/* harmony export */ "set_store_value": () => (/* binding */ set_store_value),
/* harmony export */ "set_style": () => (/* binding */ set_style),
/* harmony export */ "set_svg_attributes": () => (/* binding */ set_svg_attributes),
/* harmony export */ "space": () => (/* binding */ space),
/* harmony export */ "spread": () => (/* binding */ spread),
/* harmony export */ "src_url_equal": () => (/* binding */ src_url_equal),
/* harmony export */ "start_hydrating": () => (/* binding */ start_hydrating),
/* harmony export */ "stop_propagation": () => (/* binding */ stop_propagation),
/* harmony export */ "subscribe": () => (/* binding */ subscribe),
/* harmony export */ "svg_element": () => (/* binding */ svg_element),
/* harmony export */ "text": () => (/* binding */ text),
/* harmony export */ "tick": () => (/* binding */ tick),
/* harmony export */ "time_ranges_to_array": () => (/* binding */ time_ranges_to_array),
/* harmony export */ "to_number": () => (/* binding */ to_number),
/* harmony export */ "toggle_class": () => (/* binding */ toggle_class),
/* harmony export */ "transition_in": () => (/* binding */ transition_in),
/* harmony export */ "transition_out": () => (/* binding */ transition_out),
/* harmony export */ "trusted": () => (/* binding */ trusted),
/* harmony export */ "update_await_block_branch": () => (/* binding */ update_await_block_branch),
/* harmony export */ "update_keyed_each": () => (/* binding */ update_keyed_each),
/* harmony export */ "update_slot": () => (/* binding */ update_slot),
/* harmony export */ "update_slot_base": () => (/* binding */ update_slot_base),
/* harmony export */ "validate_component": () => (/* binding */ validate_component),
/* harmony export */ "validate_each_argument": () => (/* binding */ validate_each_argument),
/* harmony export */ "validate_each_keys": () => (/* binding */ validate_each_keys),
/* harmony export */ "validate_slots": () => (/* binding */ validate_slots),
/* harmony export */ "validate_store": () => (/* binding */ validate_store),
/* harmony export */ "xlink_attr": () => (/* binding */ xlink_attr)
/* harmony export */ });
function noop() { }
const identity = x => x;
function assign(tar, src) {
// @ts-ignore
for (const k in src)
tar[k] = src[k];
return tar;
}
function is_promise(value) {
return value && typeof value === 'object' && typeof value.then === 'function';
}
function add_location(element, file, line, column, char) {
element.__svelte_meta = {
loc: { file, line, column, char }
};
}
function run(fn) {
return fn();
}
function blank_object() {
return Object.create(null);
}
function run_all(fns) {
fns.forEach(run);
}
function is_function(thing) {
return typeof thing === 'function';
}
function safe_not_equal(a, b) {
return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}
let src_url_equal_anchor;
function src_url_equal(element_src, url) {
if (!src_url_equal_anchor) {
src_url_equal_anchor = document.createElement('a');
}
src_url_equal_anchor.href = url;
return element_src === src_url_equal_anchor.href;
}
function not_equal(a, b) {
return a != a ? b == b : a !== b;
}
function is_empty(obj) {
return Object.keys(obj).length === 0;
}
function validate_store(store, name) {
if (store != null && typeof store.subscribe !== 'function') {
throw new Error(`'${name}' is not a store with a 'subscribe' method`);
}
}
function subscribe(store, ...callbacks) {
if (store == null) {
return noop;
}
const unsub = store.subscribe(...callbacks);
return unsub.unsubscribe ? () => unsub.unsubscribe() : unsub;
}
function get_store_value(store) {
let value;
subscribe(store, _ => value = _)();
return value;
}
function component_subscribe(component, store, callback) {
component.$$.on_destroy.push(subscribe(store, callback));
}
function create_slot(definition, ctx, $$scope, fn) {
if (definition) {
const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
return definition[0](slot_ctx);
}
}
function get_slot_context(definition, ctx, $$scope, fn) {
return definition[1] && fn
? assign($$scope.ctx.slice(), definition[1](fn(ctx)))
: $$scope.ctx;
}
function get_slot_changes(definition, $$scope, dirty, fn) {
if (definition[2] && fn) {
const lets = definition[2](fn(dirty));
if ($$scope.dirty === undefined) {
return lets;
}
if (typeof lets === 'object') {
const merged = [];
const len = Math.max($$scope.dirty.length, lets.length);
for (let i = 0; i < len; i += 1) {
merged[i] = $$scope.dirty[i] | lets[i];
}
return merged;
}
return $$scope.dirty | lets;
}
return $$scope.dirty;
}
function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
if (slot_changes) {
const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
slot.p(slot_context, slot_changes);
}
}
function update_slot(slot, slot_definition, ctx, $$scope, dirty, get_slot_changes_fn, get_slot_context_fn) {
const slot_changes = get_slot_changes(slot_definition, $$scope, dirty, get_slot_changes_fn);
update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn);
}
function get_all_dirty_from_scope($$scope) {
if ($$scope.ctx.length > 32) {
const dirty = [];
const length = $$scope.ctx.length / 32;
for (let i = 0; i < length; i++) {
dirty[i] = -1;
}
return dirty;
}
return -1;
}
function exclude_internal_props(props) {
const result = {};
for (const k in props)
if (k[0] !== '$')
result[k] = props[k];
return result;
}
function compute_rest_props(props, keys) {
const rest = {};
keys = new Set(keys);
for (const k in props)
if (!keys.has(k) && k[0] !== '$')
rest[k] = props[k];
return rest;
}
function compute_slots(slots) {
const result = {};
for (const key in slots) {
result[key] = true;
}
return result;
}
function once(fn) {
let ran = false;
return function (...args) {
if (ran)
return;
ran = true;
fn.call(this, ...args);
};
}
function null_to_empty(value) {
return value == null ? '' : value;
}
function set_store_value(store, ret, value) {
store.set(value);
return ret;
}
const has_prop = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
function action_destroyer(action_result) {
return action_result && is_function(action_result.destroy) ? action_result.destroy : noop;
}
const is_client = typeof window !== 'undefined';
let now = is_client
? () => window.performance.now()
: () => Date.now();
let raf = is_client ? cb => requestAnimationFrame(cb) : noop;
// used internally for testing
function set_now(fn) {
now = fn;
}
function set_raf(fn) {
raf = fn;
}
const tasks = new Set();
function run_tasks(now) {
tasks.forEach(task => {
if (!task.c(now)) {
tasks.delete(task);
task.f();
}
});
if (tasks.size !== 0)
raf(run_tasks);
}
/**
* For testing purposes only!
*/
function clear_loops() {
tasks.clear();
}
/**
* Creates a new task that runs on each raf frame
* until it returns a falsy value or is aborted
*/
function loop(callback) {
let task;
if (tasks.size === 0)
raf(run_tasks);
return {
promise: new Promise(fulfill => {
tasks.add(task = { c: callback, f: fulfill });
}),
abort() {
tasks.delete(task);
}
};
}
// Track which nodes are claimed during hydration. Unclaimed nodes can then be removed from the DOM
// at the end of hydration without touching the remaining nodes.
let is_hydrating = false;
function start_hydrating() {
is_hydrating = true;
}
function end_hydrating() {
is_hydrating = false;
}
function upper_bound(low, high, key, value) {
// Return first index of value larger than input value in the range [low, high)
while (low < high) {
const mid = low + ((high - low) >> 1);
if (key(mid) <= value) {
low = mid + 1;
}
else {
high = mid;
}
}
return low;
}
function init_hydrate(target) {
if (target.hydrate_init)
return;
target.hydrate_init = true;
// We know that all children have claim_order values since the unclaimed have been detached if target is not <head>
let children = target.childNodes;
// If target is <head>, there may be children without claim_order
if (target.nodeName === 'HEAD') {
const myChildren = [];
for (let i = 0; i < children.length; i++) {
const node = children[i];
if (node.claim_order !== undefined) {
myChildren.push(node);
}
}
children = myChildren;
}
/*
* Reorder claimed children optimally.
* We can reorder claimed children optimally by finding the longest subsequence of
* nodes that are already claimed in order and only moving the rest. The longest
* subsequence subsequence of nodes that are claimed in order can be found by
* computing the longest increasing subsequence of .claim_order values.
*
* This algorithm is optimal in generating the least amount of reorder operations
* possible.
*
* Proof:
* We know that, given a set of reordering operations, the nodes that do not move
* always form an increasing subsequence, since they do not move among each other
* meaning that they must be already ordered among each other. Thus, the maximal
* set of nodes that do not move form a longest increasing subsequence.
*/
// Compute longest increasing subsequence
// m: subsequence length j => index k of smallest value that ends an increasing subsequence of length j
const m = new Int32Array(children.length + 1);
// Predecessor indices + 1
const p = new Int32Array(children.length);
m[0] = -1;
let longest = 0;
for (let i = 0; i < children.length; i++) {
const current = children[i].claim_order;
// Find the largest subsequence length such that it ends in a value less than our current value
// upper_bound returns first greater value, so we subtract one
// with fast path for when we are on the current longest subsequence
const seqLen = ((longest > 0 && children[m[longest]].claim_order <= current) ? longest + 1 : upper_bound(1, longest, idx => children[m[idx]].claim_order, current)) - 1;
p[i] = m[seqLen] + 1;
const newLen = seqLen + 1;
// We can guarantee that current is the smallest value. Otherwise, we would have generated a longer sequence.
m[newLen] = i;
longest = Math.max(newLen, longest);
}
// The longest increasing subsequence of nodes (initially reversed)
const lis = [];
// The rest of the nodes, nodes that will be moved
const toMove = [];
let last = children.length - 1;
for (let cur = m[longest] + 1; cur != 0; cur = p[cur - 1]) {
lis.push(children[cur - 1]);
for (; last >= cur; last--) {
toMove.push(children[last]);
}
last--;
}
for (; last >= 0; last--) {
toMove.push(children[last]);
}
lis.reverse();
// We sort the nodes being moved to guarantee that their insertion order matches the claim order
toMove.sort((a, b) => a.claim_order - b.claim_order);
// Finally, we move the nodes
for (let i = 0, j = 0; i < toMove.length; i++) {
while (j < lis.length && toMove[i].claim_order >= lis[j].claim_order) {
j++;
}
const anchor = j < lis.length ? lis[j] : null;
target.insertBefore(toMove[i], anchor);
}
}
function append(target, node) {
target.appendChild(node);
}
function append_styles(target, style_sheet_id, styles) {
const append_styles_to = get_root_for_style(target);
if (!append_styles_to.getElementById(style_sheet_id)) {
const style = element('style');
style.id = style_sheet_id;
style.textContent = styles;
append_stylesheet(append_styles_to, style);
}
}
function get_root_for_style(node) {
if (!node)
return document;
const root = node.getRootNode ? node.getRootNode() : node.ownerDocument;
if (root && root.host) {
return root;
}
return node.ownerDocument;
}
function append_empty_stylesheet(node) {
const style_element = element('style');
append_stylesheet(get_root_for_style(node), style_element);
return style_element;
}
function append_stylesheet(node, style) {
append(node.head || node, style);
}
function append_hydration(target, node) {
if (is_hydrating) {
init_hydrate(target);
if ((target.actual_end_child === undefined) || ((target.actual_end_child !== null) && (target.actual_end_child.parentElement !== target))) {
target.actual_end_child = target.firstChild;
}
// Skip nodes of undefined ordering
while ((target.actual_end_child !== null) && (target.actual_end_child.claim_order === undefined)) {
target.actual_end_child = target.actual_end_child.nextSibling;
}
if (node !== target.actual_end_child) {
// We only insert if the ordering of this node should be modified or the parent node is not target
if (node.claim_order !== undefined || node.parentNode !== target) {
target.insertBefore(node, target.actual_end_child);
}
}
else {
target.actual_end_child = node.nextSibling;
}
}
else if (node.parentNode !== target || node.nextSibling !== null) {
target.appendChild(node);
}
}
function insert(target, node, anchor) {
target.insertBefore(node, anchor || null);
}
function insert_hydration(target, node, anchor) {
if (is_hydrating && !anchor) {
append_hydration(target, node);
}
else if (node.parentNode !== target || node.nextSibling != anchor) {
target.insertBefore(node, anchor || null);
}
}
function detach(node) {
node.parentNode.removeChild(node);
}
function destroy_each(iterations, detaching) {
for (let i = 0; i < iterations.length; i += 1) {
if (iterations[i])
iterations[i].d(detaching);
}
}
function element(name) {
return document.createElement(name);
}
function element_is(name, is) {
return document.createElement(name, { is });
}
function object_without_properties(obj, exclude) {
const target = {};
for (const k in obj) {
if (has_prop(obj, k)
// @ts-ignore
&& exclude.indexOf(k) === -1) {
// @ts-ignore
target[k] = obj[k];
}
}
return target;
}
function svg_element(name) {
return document.createElementNS('http://www.w3.org/2000/svg', name);
}
function text(data) {
return document.createTextNode(data);
}
function space() {
return text(' ');
}
function empty() {
return text('');
}
function listen(node, event, handler, options) {
node.addEventListener(event, handler, options);
return () => node.removeEventListener(event, handler, options);
}
function prevent_default(fn) {
return function (event) {
event.preventDefault();
// @ts-ignore
return fn.call(this, event);
};
}
function stop_propagation(fn) {
return function (event) {
event.stopPropagation();
// @ts-ignore
return fn.call(this, event);
};
}
function self(fn) {
return function (event) {
// @ts-ignore
if (event.target === this)
fn.call(this, event);
};
}
function trusted(fn) {
return function (event) {
// @ts-ignore
if (event.isTrusted)
fn.call(this, event);
};
}
function attr(node, attribute, value) {
if (value == null)
node.removeAttribute(attribute);
else if (node.getAttribute(attribute) !== value)
node.setAttribute(attribute, value);
}
function set_attributes(node, attributes) {
// @ts-ignore
const descriptors = Object.getOwnPropertyDescriptors(node.__proto__);
for (const key in attributes) {
if (attributes[key] == null) {
node.removeAttribute(key);
}
else if (key === 'style') {
node.style.cssText = attributes[key];
}
else if (key === '__value') {
node.value = node[key] = attributes[key];
}
else if (descriptors[key] && descriptors[key].set) {
node[key] = attributes[key];
}
else {
attr(node, key, attributes[key]);
}
}
}
function set_svg_attributes(node, attributes) {
for (const key in attributes) {
attr(node, key, attributes[key]);
}
}
function set_custom_element_data(node, prop, value) {
if (prop in node) {
node[prop] = typeof node[prop] === 'boolean' && value === '' ? true : value;
}
else {
attr(node, prop, value);
}
}
function xlink_attr(node, attribute, value) {
node.setAttributeNS('http://www.w3.org/1999/xlink', attribute, value);
}
function get_binding_group_value(group, __value, checked) {
const value = new Set();
for (let i = 0; i < group.length; i += 1) {
if (group[i].checked)
value.add(group[i].__value);
}
if (!checked) {
value.delete(__value);
}
return Array.from(value);
}
function to_number(value) {
return value === '' ? null : +value;
}
function time_ranges_to_array(ranges) {
const array = [];
for (let i = 0; i < ranges.length; i += 1) {
array.push({ start: ranges.start(i), end: ranges.end(i) });
}
return array;
}
function children(element) {
return Array.from(element.childNodes);
}
function init_claim_info(nodes) {
if (nodes.claim_info === undefined) {
nodes.claim_info = { last_index: 0, total_claimed: 0 };
}
}
function claim_node(nodes, predicate, processNode, createNode, dontUpdateLastIndex = false) {
// Try to find nodes in an order such that we lengthen the longest increasing subsequence
init_claim_info(nodes);
const resultNode = (() => {
// We first try to find an element after the previous one
for (let i = nodes.claim_info.last_index; i < nodes.length; i++) {
const node = nodes[i];
if (predicate(node)) {
const replacement = processNode(node);
if (replacement === undefined) {
nodes.splice(i, 1);
}
else {
nodes[i] = replacement;
}
if (!dontUpdateLastIndex) {
nodes.claim_info.last_index = i;
}
return node;
}
}
// Otherwise, we try to find one before
// We iterate in reverse so that we don't go too far back
for (let i = nodes.claim_info.last_index - 1; i >= 0; i--) {
const node = nodes[i];
if (predicate(node)) {
const replacement = processNode(node);
if (replacement === undefined) {
nodes.splice(i, 1);
}
else {
nodes[i] = replacement;
}
if (!dontUpdateLastIndex) {
nodes.claim_info.last_index = i;
}
else if (replacement === undefined) {
// Since we spliced before the last_index, we decrease it
nodes.claim_info.last_index--;
}
return node;
}
}
// If we can't find any matching node, we create a new one
return createNode();
})();
resultNode.claim_order = nodes.claim_info.total_claimed;
nodes.claim_info.total_claimed += 1;
return resultNode;
}
function claim_element_base(nodes, name, attributes, create_element) {
return claim_node(nodes, (node) => node.nodeName === name, (node) => {
const remove = [];
for (let j = 0; j < node.attributes.length; j++) {
const attribute = node.attributes[j];
if (!attributes[attribute.name]) {
remove.push(attribute.name);
}
}
remove.forEach(v => node.removeAttribute(v));
return undefined;
}, () => create_element(name));
}
function claim_element(nodes, name, attributes) {
return claim_element_base(nodes, name, attributes, element);
}
function claim_svg_element(nodes, name, attributes) {
return claim_element_base(nodes, name, attributes, svg_element);
}
function claim_text(nodes, data) {
return claim_node(nodes, (node) => node.nodeType === 3, (node) => {
const dataStr = '' + data;
if (node.data.startsWith(dataStr)) {
if (node.data.length !== dataStr.length) {
return node.splitText(dataStr.length);
}
}
else {
node.data = dataStr;
}
}, () => text(data), true // Text nodes should not update last index since it is likely not worth it to eliminate an increasing subsequence of actual elements
);
}
function claim_space(nodes) {
return claim_text(nodes, ' ');
}
function find_comment(nodes, text, start) {
for (let i = start; i < nodes.length; i += 1) {
const node = nodes[i];
if (node.nodeType === 8 /* comment node */ && node.textContent.trim() === text) {
return i;
}
}
return nodes.length;
}
function claim_html_tag(nodes) {
// find html opening tag
const start_index = find_comment(nodes, 'HTML_TAG_START', 0);
const end_index = find_comment(nodes, 'HTML_TAG_END', start_index);
if (start_index === end_index) {
return new HtmlTagHydration();
}
init_claim_info(nodes);
const html_tag_nodes = nodes.splice(start_index, end_index + 1);
detach(html_tag_nodes[0]);
detach(html_tag_nodes[html_tag_nodes.length - 1]);
const claimed_nodes = html_tag_nodes.slice(1, html_tag_nodes.length - 1);
for (const n of claimed_nodes) {
n.claim_order = nodes.claim_info.total_claimed;
nodes.claim_info.total_claimed += 1;
}
return new HtmlTagHydration(claimed_nodes);
}
function set_data(text, data) {
data = '' + data;
if (text.wholeText !== data)
text.data = data;
}
function set_input_value(input, value) {
input.value = value == null ? '' : value;
}
function set_input_type(input, type) {
try {
input.type = type;
}
catch (e) {
// do nothing
}
}
function set_style(node, key, value, important) {
node.style.setProperty(key, value, important ? 'important' : '');
}
function select_option(select, value) {
for (let i = 0; i < select.options.length; i += 1) {
const option = select.options[i];
if (option.__value === value) {
option.selected = true;
return;
}
}
select.selectedIndex = -1; // no option should be selected
}
function select_options(select, value) {
for (let i = 0; i < select.options.length; i += 1) {
const option = select.options[i];
option.selected = ~value.indexOf(option.__value);
}
}
function select_value(select) {
const selected_option = select.querySelector(':checked') || select.options[0];
return selected_option && selected_option.__value;
}
function select_multiple_value(select) {
return [].map.call(select.querySelectorAll(':checked'), option => option.__value);
}
// unfortunately this can't be a constant as that wouldn't be tree-shakeable
// so we cache the result instead
let crossorigin;
function is_crossorigin() {
if (crossorigin === undefined) {
crossorigin = false;
try {
if (typeof window !== 'undefined' && window.parent) {
void window.parent.document;
}
}
catch (error) {
crossorigin = true;
}
}
return crossorigin;
}
function add_resize_listener(node, fn) {
const computed_style = getComputedStyle(node);
if (computed_style.position === 'static') {
node.style.position = 'relative';
}
const iframe = element('iframe');
iframe.setAttribute('style', 'display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; ' +
'overflow: hidden; border: 0; opacity: 0; pointer-events: none; z-index: -1;');
iframe.setAttribute('aria-hidden', 'true');
iframe.tabIndex = -1;
const crossorigin = is_crossorigin();
let unsubscribe;
if (crossorigin) {
iframe.src = "data:text/html,<script>onresize=function(){parent.postMessage(0,'*')}</script>";
unsubscribe = listen(window, 'message', (event) => {
if (event.source === iframe.contentWindow)
fn();
});
}
else {
iframe.src = 'about:blank';
iframe.onload = () => {
unsubscribe = listen(iframe.contentWindow, 'resize', fn);
};
}
append(node, iframe);
return () => {
if (crossorigin) {
unsubscribe();
}
else if (unsubscribe && iframe.contentWindow) {
unsubscribe();
}
detach(iframe);
};
}
function toggle_class(element, name, toggle) {
element.classList[toggle ? 'add' : 'remove'](name);
}
function custom_event(type, detail, bubbles = false) {
const e = document.createEvent('CustomEvent');
e.initCustomEvent(type, bubbles, false, detail);
return e;
}
function query_selector_all(selector, parent = document.body) {
return Array.from(parent.querySelectorAll(selector));
}
class HtmlTag {
constructor() {
this.e = this.n = null;
}
c(html) {
this.h(html);
}
m(html, target, anchor = null) {
if (!this.e) {
this.e = element(target.nodeName);
this.t = target;
this.c(html);
}
this.i(anchor);
}
h(html) {
this.e.innerHTML = html;
this.n = Array.from(this.e.childNodes);
}
i(anchor) {
for (let i = 0; i < this.n.length; i += 1) {
insert(this.t, this.n[i], anchor);
}
}
p(html) {
this.d();
this.h(html);
this.i(this.a);
}
d() {
this.n.forEach(detach);
}
}
class HtmlTagHydration extends HtmlTag {
constructor(claimed_nodes) {
super();
this.e = this.n = null;
this.l = claimed_nodes;
}
c(html) {
if (this.l) {
this.n = this.l;
}
else {
super.c(html);
}
}
i(anchor) {
for (let i = 0; i < this.n.length; i += 1) {
insert_hydration(this.t, this.n[i], anchor);
}
}
}
function attribute_to_object(attributes) {
const result = {};
for (const attribute of attributes) {
result[attribute.name] = attribute.value;
}
return result;
}
function get_custom_elements_slots(element) {
const result = {};
element.childNodes.forEach((node) => {
result[node.slot || 'default'] = true;
});
return result;
}
const active_docs = new Set();
let active = 0;
// https://github.com/darkskyapp/string-hash/blob/master/index.js
function hash(str) {
let hash = 5381;
let i = str.length;
while (i--)
hash = ((hash << 5) - hash) ^ str.charCodeAt(i);
return hash >>> 0;
}
function create_rule(node, a, b, duration, delay, ease, fn, uid = 0) {
const step = 16.666 / duration;
let keyframes = '{\n';
for (let p = 0; p <= 1; p += step) {
const t = a + (b - a) * ease(p);
keyframes += p * 100 + `%{${fn(t, 1 - t)}}\n`;
}
const rule = keyframes + `100% {${fn(b, 1 - b)}}\n}`;
const name = `__svelte_${hash(rule)}_${uid}`;
const doc = get_root_for_style(node);
active_docs.add(doc);
const stylesheet = doc.__svelte_stylesheet || (doc.__svelte_stylesheet = append_empty_stylesheet(node).sheet);
const current_rules = doc.__svelte_rules || (doc.__svelte_rules = {});
if (!current_rules[name]) {
current_rules[name] = true;
stylesheet.insertRule(`@keyframes ${name} ${rule}`, stylesheet.cssRules.length);
}
const animation = node.style.animation || '';
node.style.animation = `${animation ? `${animation}, ` : ''}${name} ${duration}ms linear ${delay}ms 1 both`;
active += 1;
return name;
}
function delete_rule(node, name) {
const previous = (node.style.animation || '').split(', ');
const next = previous.filter(name
? anim => anim.indexOf(name) < 0 // remove specific animation
: anim => anim.indexOf('__svelte') === -1 // remove all Svelte animations
);
const deleted = previous.length - next.length;
if (deleted) {
node.style.animation = next.join(', ');
active -= deleted;
if (!active)
clear_rules();
}
}
function clear_rules() {
raf(() => {
if (active)
return;
active_docs.forEach(doc => {
const stylesheet = doc.__svelte_stylesheet;
let i = stylesheet.cssRules.length;
while (i--)
stylesheet.deleteRule(i);
doc.__svelte_rules = {};
});
active_docs.clear();
});
}
function create_animation(node, from, fn, params) {
if (!from)
return noop;
const to = node.getBoundingClientRect();
if (from.left === to.left && from.right === to.right && from.top === to.top && from.bottom === to.bottom)
return noop;
const { delay = 0, duration = 300, easing = identity,
// @ts-ignore todo: should this be separated from destructuring? Or start/end added to public api and documentation?
start: start_time = now() + delay,
// @ts-ignore todo:
end = start_time + duration, tick = noop, css } = fn(node, { from, to }, params);
let running = true;
let started = false;
let name;
function start() {
if (css) {
name = create_rule(node, 0, 1, duration, delay, easing, css);
}
if (!delay) {
started = true;
}
}
function stop() {
if (css)
delete_rule(node, name);
running = false;
}
loop(now => {
if (!started && now >= start_time) {
started = true;
}
if (started && now >= end) {
tick(1, 0);
stop();
}
if (!running) {
return false;
}
if (started) {
const p = now - start_time;
const t = 0 + 1 * easing(p / duration);
tick(t, 1 - t);
}
return true;
});
start();
tick(0, 1);
return stop;
}
function fix_position(node) {
const style = getComputedStyle(node);
if (style.position !== 'absolute' && style.position !== 'fixed') {
const { width, height } = style;
const a = node.getBoundingClientRect();
node.style.position = 'absolute';
node.style.width = width;
node.style.height = height;
add_transform(node, a);
}
}
function add_transform(node, a) {
const b = node.getBoundingClientRect();
if (a.left !== b.left || a.top !== b.top) {
const style = getComputedStyle(node);
const transform = style.transform === 'none' ? '' : style.transform;
node.style.transform = `${transform} translate(${a.left - b.left}px, ${a.top - b.top}px)`;
}
}
let current_component;
function set_current_component(component) {
current_component = component;
}
function get_current_component() {
if (!current_component)
throw new Error('Function called outside component initialization');
return current_component;
}
function beforeUpdate(fn) {
get_current_component().$$.before_update.push(fn);
}
function onMount(fn) {
get_current_component().$$.on_mount.push(fn);
}
function afterUpdate(fn) {
get_current_component().$$.after_update.push(fn);
}
function onDestroy(fn) {
get_current_component().$$.on_destroy.push(fn);
}
function createEventDispatcher() {
const component = get_current_component();
return (type, detail) => {
const callbacks = component.$$.callbacks[type];
if (callbacks) {
// TODO are there situations where events could be dispatched
// in a server (non-DOM) environment?
const event = custom_event(type, detail);
callbacks.slice().forEach(fn => {
fn.call(component, event);
});
}
};
}
function setContext(key, context) {
get_current_component().$$.context.set(key, context);
}
function getContext(key) {
return get_current_component().$$.context.get(key);
}
function getAllContexts() {
return get_current_component().$$.context;
}
function hasContext(key) {
return get_current_component().$$.context.has(key);
}
// TODO figure out if we still want to support
// shorthand events, or if we want to implement
// a real bubbling mechanism
function bubble(component, event) {
const callbacks = component.$$.callbacks[event.type];
if (callbacks) {
// @ts-ignore
callbacks.slice().forEach(fn => fn.call(this, event));
}
}
const dirty_components = [];
const intros = { enabled: false };
const binding_callbacks = [];
const render_callbacks = [];
const flush_callbacks = [];
const resolved_promise = Promise.resolve();
let update_scheduled = false;
function schedule_update() {
if (!update_scheduled) {
update_scheduled = true;
resolved_promise.then(flush);
}
}
function tick() {
schedule_update();
return resolved_promise;
}
function add_render_callback(fn) {
render_callbacks.push(fn);
}
function add_flush_callback(fn) {
flush_callbacks.push(fn);
}
// flush() calls callbacks in this order:
// 1. All beforeUpdate callbacks, in order: parents before children
// 2. All bind:this callbacks, in reverse order: children before parents.
// 3. All afterUpdate callbacks, in order: parents before children. EXCEPT
// for afterUpdates called during the initial onMount, which are called in
// reverse order: children before parents.
// Since callbacks might update component values, which could trigger another
// call to flush(), the following steps guard against this:
// 1. During beforeUpdate, any updated components will be added to the
// dirty_components array and will cause a reentrant call to flush(). Because
// the flush index is kept outside the function, the reentrant call will pick
// up where the earlier call left off and go through all dirty components. The
// current_component value is saved and restored so that the reentrant call will
// not interfere with the "parent" flush() call.
// 2. bind:this callbacks cannot trigger new flush() calls.
// 3. During afterUpdate, any updated components will NOT have their afterUpdate
// callback called a second time; the seen_callbacks set, outside the flush()
// function, guarantees this behavior.
const seen_callbacks = new Set();
let flushidx = 0; // Do *not* move this inside the flush() function
function flush() {
const saved_component = current_component;
do {
// first, call beforeUpdate functions
// and update components
while (flushidx < dirty_components.length) {
const component = dirty_components[flushidx];
flushidx++;
set_current_component(component);
update(component.$$);
}
set_current_component(null);
dirty_components.length = 0;
flushidx = 0;
while (binding_callbacks.length)
binding_callbacks.pop()();
// then, once components are updated, call
// afterUpdate functions. This may cause
// subsequent updates...
for (let i = 0; i < render_callbacks.length; i += 1) {
const callback = render_callbacks[i];
if (!seen_callbacks.has(callback)) {
// ...so guard against infinite loops
seen_callbacks.add(callback);
callback();
}
}
render_callbacks.length = 0;
} while (dirty_components.length);
while (flush_callbacks.length) {
flush_callbacks.pop()();
}
update_scheduled = false;
seen_callbacks.clear();
set_current_component(saved_component);
}
function update($$) {
if ($$.fragment !== null) {
$$.update();
run_all($$.before_update);
const dirty = $$.dirty;
$$.dirty = [-1];
$$.fragment && $$.fragment.p($$.ctx, dirty);
$$.after_update.forEach(add_render_callback);
}
}
let promise;
function wait() {
if (!promise) {
promise = Promise.resolve();
promise.then(() => {
promise = null;
});
}
return promise;
}
function dispatch(node, direction, kind) {
node.dispatchEvent(custom_event(`${direction ? 'intro' : 'outro'}${kind}`));
}
const outroing = new Set();
let outros;
function group_outros() {
outros = {
r: 0,
c: [],
p: outros // parent group
};
}
function check_outros() {
if (!outros.r) {
run_all(outros.c);
}
outros = outros.p;
}
function transition_in(block, local) {
if (block && block.i) {
outroing.delete(block);
block.i(local);
}
}
function transition_out(block, local, detach, callback) {
if (block && block.o) {
if (outroing.has(block))
return;
outroing.add(block);
outros.c.push(() => {
outroing.delete(block);
if (callback) {
if (detach)
block.d(1);
callback();
}
});
block.o(local);
}
}
const null_transition = { duration: 0 };
function create_in_transition(node, fn, params) {
let config = fn(node, params);
let running = false;
let animation_name;
let task;
let uid = 0;
function cleanup() {
if (animation_name)
delete_rule(node, animation_name);
}
function go() {
const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
if (css)
animation_name = create_rule(node, 0, 1, duration, delay, easing, css, uid++);
tick(0, 1);
const start_time = now() + delay;
const end_time = start_time + duration;
if (task)
task.abort();
running = true;
add_render_callback(() => dispatch(node, true, 'start'));
task = loop(now => {
if (running) {
if (now >= end_time) {
tick(1, 0);
dispatch(node, true, 'end');
cleanup();
return running = false;
}
if (now >= start_time) {
const t = easing((now - start_time) / duration);
tick(t, 1 - t);
}
}
return running;
});
}
let started = false;
return {
start() {
if (started)
return;
started = true;
delete_rule(node);
if (is_function(config)) {
config = config();
wait().then(go);
}
else {
go();
}
},
invalidate() {
started = false;
},
end() {
if (running) {
cleanup();
running = false;
}
}
};
}
function create_out_transition(node, fn, params) {
let config = fn(node, params);
let running = true;
let animation_name;
const group = outros;
group.r += 1;
function go() {
const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
if (css)
animation_name = create_rule(node, 1, 0, duration, delay, easing, css);
const start_time = now() + delay;
const end_time = start_time + duration;
add_render_callback(() => dispatch(node, false, 'start'));
loop(now => {
if (running) {
if (now >= end_time) {
tick(0, 1);
dispatch(node, false, 'end');
if (!--group.r) {
// this will result in `end()` being called,
// so we don't need to clean up here
run_all(group.c);
}
return false;
}
if (now >= start_time) {
const t = easing((now - start_time) / duration);
tick(1 - t, t);
}
}
return running;
});
}
if (is_function(config)) {
wait().then(() => {
// @ts-ignore
config = config();
go();
});
}
else {
go();
}
return {
end(reset) {
if (reset && config.tick) {
config.tick(1, 0);
}
if (running) {
if (animation_name)
delete_rule(node, animation_name);
running = false;
}
}
};
}
function create_bidirectional_transition(node, fn, params, intro) {
let config = fn(node, params);
let t = intro ? 0 : 1;
let running_program = null;
let pending_program = null;
let animation_name = null;
function clear_animation() {
if (animation_name)
delete_rule(node, animation_name);
}
function init(program, duration) {
const d = (program.b - t);
duration *= Math.abs(d);
return {
a: t,
b: program.b,
d,
duration,
start: program.start,
end: program.start + duration,
group: program.group
};
}
function go(b) {
const { delay = 0, duration = 300, easing = identity, tick = noop, css } = config || null_transition;
const program = {
start: now() + delay,
b
};
if (!b) {
// @ts-ignore todo: improve typings
program.group = outros;
outros.r += 1;
}
if (running_program || pending_program) {
pending_program = program;
}
else {
// if this is an intro, and there's a delay, we need to do
// an initial tick and/or apply CSS animation immediately
if (css) {
clear_animation();
animation_name = create_rule(node, t, b, duration, delay, easing, css);
}
if (b)
tick(0, 1);
running_program = init(program, duration);
add_render_callback(() => dispatch(node, b, 'start'));
loop(now => {
if (pending_program && now > pending_program.start) {
running_program = init(pending_program, duration);
pending_program = null;
dispatch(node, running_program.b, 'start');
if (css) {
clear_animation();
animation_name = create_rule(node, t, running_program.b, running_program.duration, 0, easing, config.css);
}
}
if (running_program) {
if (now >= running_program.end) {
tick(t = running_program.b, 1 - t);
dispatch(node, running_program.b, 'end');
if (!pending_program) {
// we're done
if (running_program.b) {
// intro โ we can tidy up immediately
clear_animation();
}
else {
// outro โ needs to be coordinated
if (!--running_program.group.r)
run_all(running_program.group.c);
}
}
running_program = null;
}
else if (now >= running_program.start) {
const p = now - running_program.start;
t = running_program.a + running_program.d * easing(p / running_program.duration);
tick(t, 1 - t);
}
}
return !!(running_program || pending_program);
});
}
}
return {
run(b) {
if (is_function(config)) {
wait().then(() => {
// @ts-ignore
config = config();
go(b);
});
}
else {
go(b);
}
},
end() {
clear_animation();
running_program = pending_program = null;
}
};
}
function handle_promise(promise, info) {
const token = info.token = {};
function update(type, index, key, value) {
if (info.token !== token)
return;
info.resolved = value;
let child_ctx = info.ctx;
if (key !== undefined) {
child_ctx = child_ctx.slice();
child_ctx[key] = value;
}
const block = type && (info.current = type)(child_ctx);
let needs_flush = false;
if (info.block) {
if (info.blocks) {
info.blocks.forEach((block, i) => {
if (i !== index && block) {
group_outros();
transition_out(block, 1, 1, () => {
if (info.blocks[i] === block) {
info.blocks[i] = null;
}
});
check_outros();
}
});
}
else {
info.block.d(1);
}
block.c();
transition_in(block, 1);
block.m(info.mount(), info.anchor);
needs_flush = true;
}
info.block = block;
if (info.blocks)
info.blocks[index] = block;
if (needs_flush) {
flush();
}
}
if (is_promise(promise)) {
const current_component = get_current_component();
promise.then(value => {
set_current_component(current_component);
update(info.then, 1, info.value, value);
set_current_component(null);
}, error => {
set_current_component(current_component);
update(info.catch, 2, info.error, error);
set_current_component(null);
if (!info.hasCatch) {
throw error;
}
});
// if we previously had a then/catch block, destroy it
if (info.current !== info.pending) {
update(info.pending, 0);
return true;
}
}
else {
if (info.current !== info.then) {
update(info.then, 1, info.value, promise);
return true;
}
info.resolved = promise;
}
}
function update_await_block_branch(info, ctx, dirty) {
const child_ctx = ctx.slice();
const { resolved } = info;
if (info.current === info.then) {
child_ctx[info.value] = resolved;
}
if (info.current === info.catch) {
child_ctx[info.error] = resolved;
}
info.block.p(child_ctx, dirty);
}
const globals = (typeof window !== 'undefined'
? window
: typeof globalThis !== 'undefined'
? globalThis
: __webpack_require__.g);
function destroy_block(block, lookup) {
block.d(1);
lookup.delete(block.key);
}
function outro_and_destroy_block(block, lookup) {
transition_out(block, 1, 1, () => {
lookup.delete(block.key);
});
}
function fix_and_destroy_block(block, lookup) {
block.f();
destroy_block(block, lookup);
}
function fix_and_outro_and_destroy_block(block, lookup) {
block.f();
outro_and_destroy_block(block, lookup);
}
function update_keyed_each(old_blocks, dirty, get_key, dynamic, ctx, list, lookup, node, destroy, create_each_block, next, get_context) {
let o = old_blocks.length;
let n = list.length;
let i = o;
const old_indexes = {};
while (i--)
old_indexes[old_blocks[i].key] = i;
const new_blocks = [];
const new_lookup = new Map();
const deltas = new Map();
i = n;
while (i--) {
const child_ctx = get_context(ctx, list, i);
const key = get_key(child_ctx);
let block = lookup.get(key);
if (!block) {
block = create_each_block(key, child_ctx);
block.c();
}
else if (dynamic) {
block.p(child_ctx, dirty);
}
new_lookup.set(key, new_blocks[i] = block);
if (key in old_indexes)
deltas.set(key, Math.abs(i - old_indexes[key]));
}
const will_move = new Set();
const did_move = new Set();
function insert(block) {
transition_in(block, 1);
block.m(node, next);
lookup.set(block.key, block);
next = block.first;
n--;
}
while (o && n) {
const new_block = new_blocks[n - 1];
const old_block = old_blocks[o - 1];
const new_key = new_block.key;
const old_key = old_block.key;
if (new_block === old_block) {
// do nothing
next = new_block.first;
o--;
n--;
}
else if (!new_lookup.has(old_key)) {
// remove old block
destroy(old_block, lookup);
o--;
}
else if (!lookup.has(new_key) || will_move.has(new_key)) {
insert(new_block);
}
else if (did_move.has(old_key)) {
o--;
}
else if (deltas.get(new_key) > deltas.get(old_key)) {
did_move.add(new_key);
insert(new_block);
}
else {
will_move.add(old_key);
o--;
}
}
while (o--) {
const old_block = old_blocks[o];
if (!new_lookup.has(old_block.key))
destroy(old_block, lookup);
}
while (n)
insert(new_blocks[n - 1]);
return new_blocks;
}
function validate_each_keys(ctx, list, get_context, get_key) {
const keys = new Set();
for (let i = 0; i < list.length; i++) {
const key = get_key(get_context(ctx, list, i));
if (keys.has(key)) {
throw new Error('Cannot have duplicate keys in a keyed each');
}
keys.add(key);
}
}
function get_spread_update(levels, updates) {
const update = {};
const to_null_out = {};
const accounted_for = { $$scope: 1 };
let i = levels.length;
while (i--) {
const o = levels[i];
const n = updates[i];
if (n) {
for (const key in o) {
if (!(key in n))
to_null_out[key] = 1;
}
for (const key in n) {
if (!accounted_for[key]) {
update[key] = n[key];
accounted_for[key] = 1;
}
}
levels[i] = n;
}
else {
for (const key in o) {
accounted_for[key] = 1;
}
}
}
for (const key in to_null_out) {
if (!(key in update))
update[key] = undefined;
}
return update;
}
function get_spread_object(spread_props) {
return typeof spread_props === 'object' && spread_props !== null ? spread_props : {};
}
// source: https://html.spec.whatwg.org/multipage/indices.html
const boolean_attributes = new Set([
'allowfullscreen',
'allowpaymentrequest',
'async',
'autofocus',
'autoplay',
'checked',
'controls',
'default',
'defer',
'disabled',
'formnovalidate',
'hidden',
'ismap',
'loop',
'multiple',
'muted',
'nomodule',
'novalidate',
'open',
'playsinline',
'readonly',
'required',
'reversed',
'selected'
]);
const invalid_attribute_name_character = /[\s'">/=\u{FDD0}-\u{FDEF}\u{FFFE}\u{FFFF}\u{1FFFE}\u{1FFFF}\u{2FFFE}\u{2FFFF}\u{3FFFE}\u{3FFFF}\u{4FFFE}\u{4FFFF}\u{5FFFE}\u{5FFFF}\u{6FFFE}\u{6FFFF}\u{7FFFE}\u{7FFFF}\u{8FFFE}\u{8FFFF}\u{9FFFE}\u{9FFFF}\u{AFFFE}\u{AFFFF}\u{BFFFE}\u{BFFFF}\u{CFFFE}\u{CFFFF}\u{DFFFE}\u{DFFFF}\u{EFFFE}\u{EFFFF}\u{FFFFE}\u{FFFFF}\u{10FFFE}\u{10FFFF}]/u;
// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
// https://infra.spec.whatwg.org/#noncharacter
function spread(args, classes_to_add) {
const attributes = Object.assign({}, ...args);
if (classes_to_add) {
if (attributes.class == null) {
attributes.class = classes_to_add;
}
else {
attributes.class += ' ' + classes_to_add;
}
}
let str = '';
Object.keys(attributes).forEach(name => {
if (invalid_attribute_name_character.test(name))
return;
const value = attributes[name];
if (value === true)
str += ' ' + name;
else if (boolean_attributes.has(name.toLowerCase())) {
if (value)
str += ' ' + name;
}
else if (value != null) {
str += ` ${name}="${value}"`;
}
});
return str;
}
const escaped = {
'"': '"',
"'": ''',
'&': '&',
'<': '<',
'>': '>'
};
function escape(html) {
return String(html).replace(/["'&<>]/g, match => escaped[match]);
}
function escape_attribute_value(value) {
return typeof value === 'string' ? escape(value) : value;
}
function escape_object(obj) {
const result = {};
for (const key in obj) {
result[key] = escape_attribute_value(obj[key]);
}
return result;
}
function each(items, fn) {
let str = '';
for (let i = 0; i < items.length; i += 1) {
str += fn(items[i], i);
}
return str;
}
const missing_component = {
$$render: () => ''
};
function validate_component(component, name) {
if (!component || !component.$$render) {
if (name === 'svelte:component')
name += ' this={...}';
throw new Error(`<${name}> is not a valid SSR component. You may need to review your build config to ensure that dependencies are compiled, rather than imported as pre-compiled modules`);
}
return component;
}
function debug(file, line, column, values) {
console.log(`{@debug} ${file ? file + ' ' : ''}(${line}:${column})`); // eslint-disable-line no-console
console.log(values); // eslint-disable-line no-console
return '';
}
let on_destroy;
function create_ssr_component(fn) {
function $$render(result, props, bindings, slots, context) {
const parent_component = current_component;
const $$ = {
on_destroy,
context: new Map(context || (parent_component ? parent_component.$$.context : [])),
// these will be immediately discarded
on_mount: [],
before_update: [],
after_update: [],
callbacks: blank_object()
};
set_current_component({ $$ });
const html = fn(result, props, bindings, slots);
set_current_component(parent_component);
return html;
}
return {
render: (props = {}, { $$slots = {}, context = new Map() } = {}) => {
on_destroy = [];
const result = { title: '', head: '', css: new Set() };
const html = $$render(result, props, {}, $$slots, context);
run_all(on_destroy);
return {
html,
css: {
code: Array.from(result.css).map(css => css.code).join('\n'),
map: null // TODO
},
head: result.title + result.head
};
},
$$render
};
}
function add_attribute(name, value, boolean) {
if (value == null || (boolean && !value))
return '';
return ` ${name}${value === true ? '' : `=${typeof value === 'string' ? JSON.stringify(escape(value)) : `"${value}"`}`}`;
}
function add_classes(classes) {
return classes ? ` class="${classes}"` : '';
}
function bind(component, name, callback) {
const index = component.$$.props[name];
if (index !== undefined) {
component.$$.bound[index] = callback;
callback(component.$$.ctx[index]);
}
}
function create_component(block) {
block && block.c();
}
function claim_component(block, parent_nodes) {
block && block.l(parent_nodes);
}
function mount_component(component, target, anchor, customElement) {
const { fragment, on_mount, on_destroy, after_update } = component.$$;
fragment && fragment.m(target, anchor);
if (!customElement) {
// onMount happens before the initial afterUpdate
add_render_callback(() => {
const new_on_destroy = on_mount.map(run).filter(is_function);
if (on_destroy) {
on_destroy.push(...new_on_destroy);
}
else {
// Edge case - component was destroyed immediately,
// most likely as a result of a binding initialising
run_all(new_on_destroy);
}
component.$$.on_mount = [];
});
}
after_update.forEach(add_render_callback);
}
function destroy_component(component, detaching) {
const $$ = component.$$;
if ($$.fragment !== null) {
run_all($$.on_destroy);
$$.fragment && $$.fragment.d(detaching);
// TODO null out other refs, including component.$$ (but need to
// preserve final state?)
$$.on_destroy = $$.fragment = null;
$$.ctx = [];
}
}
function make_dirty(component, i) {
if (component.$$.dirty[0] === -1) {
dirty_components.push(component);
schedule_update();
component.$$.dirty.fill(0);
}
component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
}
function init(component, options, instance, create_fragment, not_equal, props, append_styles, dirty = [-1]) {
const parent_component = current_component;
set_current_component(component);
const $$ = component.$$ = {
fragment: null,
ctx: null,
// state
props,
update: noop,
not_equal,
bound: blank_object(),
// lifecycle
on_mount: [],
on_destroy: [],
on_disconnect: [],
before_update: [],
after_update: [],
context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
// everything else
callbacks: blank_object(),
dirty,
skip_bound: false,
root: options.target || parent_component.$$.root
};
append_styles && append_styles($$.root);
let ready = false;
$$.ctx = instance
? instance(component, options.props || {}, (i, ret, ...rest) => {
const value = rest.length ? rest[0] : ret;
if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
if (!$$.skip_bound && $$.bound[i])
$$.bound[i](value);
if (ready)
make_dirty(component, i);
}
return ret;
})
: [];
$$.update();
ready = true;
run_all($$.before_update);
// `false` as a special case of no DOM component
$$.fragment = create_fragment ? create_fragment($$.ctx) : false;
if (options.target) {
if (options.hydrate) {
start_hydrating();
const nodes = children(options.target);
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
$$.fragment && $$.fragment.l(nodes);
nodes.forEach(detach);
}
else {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
$$.fragment && $$.fragment.c();
}
if (options.intro)
transition_in(component.$$.fragment);
mount_component(component, options.target, options.anchor, options.customElement);
end_hydrating();
flush();
}
set_current_component(parent_component);
}
let SvelteElement;
if (typeof HTMLElement === 'function') {
SvelteElement = class extends HTMLElement {
constructor() {
super();
this.attachShadow({ mode: 'open' });
}
connectedCallback() {
const { on_mount } = this.$$;
this.$$.on_disconnect = on_mount.map(run).filter(is_function);
// @ts-ignore todo: improve typings
for (const key in this.$$.slotted) {
// @ts-ignore todo: improve typings
this.appendChild(this.$$.slotted[key]);
}
}
attributeChangedCallback(attr, _oldValue, newValue) {
this[attr] = newValue;
}
disconnectedCallback() {
run_all(this.$$.on_disconnect);
}
$destroy() {
destroy_component(this, 1);
this.$destroy = noop;
}
$on(type, callback) {
// TODO should this delegate to addEventListener?
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
callbacks.push(callback);
return () => {
const index = callbacks.indexOf(callback);
if (index !== -1)
callbacks.splice(index, 1);
};
}
$set($$props) {
if (this.$$set && !is_empty($$props)) {
this.$$.skip_bound = true;
this.$$set($$props);
this.$$.skip_bound = false;
}
}
};
}
/**
* Base class for Svelte components. Used when dev=false.
*/
class SvelteComponent {
$destroy() {
destroy_component(this, 1);
this.$destroy = noop;
}
$on(type, callback) {
const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
callbacks.push(callback);
return () => {
const index = callbacks.indexOf(callback);
if (index !== -1)
callbacks.splice(index, 1);
};
}
$set($$props) {
if (this.$$set && !is_empty($$props)) {
this.$$.skip_bound = true;
this.$$set($$props);
this.$$.skip_bound = false;
}
}
}
function dispatch_dev(type, detail) {
document.dispatchEvent(custom_event(type, Object.assign({ version: '3.44.3' }, detail), true));
}
function append_dev(target, node) {
dispatch_dev('SvelteDOMInsert', { target, node });
append(target, node);
}
function append_hydration_dev(target, node) {
dispatch_dev('SvelteDOMInsert', { target, node });
append_hydration(target, node);
}
function insert_dev(target, node, anchor) {
dispatch_dev('SvelteDOMInsert', { target, node, anchor });
insert(target, node, anchor);
}
function insert_hydration_dev(target, node, anchor) {
dispatch_dev('SvelteDOMInsert', { target, node, anchor });
insert_hydration(target, node, anchor);
}
function detach_dev(node) {
dispatch_dev('SvelteDOMRemove', { node });
detach(node);
}
function detach_between_dev(before, after) {
while (before.nextSibling && before.nextSibling !== after) {
detach_dev(before.nextSibling);
}
}
function detach_before_dev(after) {
while (after.previousSibling) {
detach_dev(after.previousSibling);
}
}
function detach_after_dev(before) {
while (before.nextSibling) {
detach_dev(before.nextSibling);
}
}
function listen_dev(node, event, handler, options, has_prevent_default, has_stop_propagation) {
const modifiers = options === true ? ['capture'] : options ? Array.from(Object.keys(options)) : [];
if (has_prevent_default)
modifiers.push('preventDefault');
if (has_stop_propagation)
modifiers.push('stopPropagation');
dispatch_dev('SvelteDOMAddEventListener', { node, event, handler, modifiers });
const dispose = listen(node, event, handler, options);
return () => {
dispatch_dev('SvelteDOMRemoveEventListener', { node, event, handler, modifiers });
dispose();
};
}
function attr_dev(node, attribute, value) {
attr(node, attribute, value);
if (value == null)
dispatch_dev('SvelteDOMRemoveAttribute', { node, attribute });
else
dispatch_dev('SvelteDOMSetAttribute', { node, attribute, value });
}
function prop_dev(node, property, value) {
node[property] = value;
dispatch_dev('SvelteDOMSetProperty', { node, property, value });
}
function dataset_dev(node, property, value) {
node.dataset[property] = value;
dispatch_dev('SvelteDOMSetDataset', { node, property, value });
}
function set_data_dev(text, data) {
data = '' + data;
if (text.wholeText === data)
return;
dispatch_dev('SvelteDOMSetData', { node: text, data });
text.data = data;
}
function validate_each_argument(arg) {
if (typeof arg !== 'string' && !(arg && typeof arg === 'object' && 'length' in arg)) {
let msg = '{#each} only iterates over array-like objects.';
if (typeof Symbol === 'function' && arg && Symbol.iterator in arg) {
msg += ' You can use a spread to convert this iterable into an array.';
}
throw new Error(msg);
}
}
function validate_slots(name, slot, keys) {
for (const slot_key of Object.keys(slot)) {
if (!~keys.indexOf(slot_key)) {
console.warn(`<${name}> received an unexpected slot "${slot_key}".`);
}
}
}
/**
* Base class for Svelte components with some minor dev-enhancements. Used when dev=true.
*/
class SvelteComponentDev extends SvelteComponent {
constructor(options) {
if (!options || (!options.target && !options.$$inline)) {
throw new Error("'target' is a required option");
}
super();
}
$destroy() {
super.$destroy();
this.$destroy = () => {
console.warn('Component was already destroyed'); // eslint-disable-line no-console
};
}
$capture_state() { }
$inject_state() { }
}
/**
* Base class to create strongly typed Svelte components.
* This only exists for typing purposes and should be used in `.d.ts` files.
*
* ### Example:
*
* You have component library on npm called `component-library`, from which
* you export a component called `MyComponent`. For Svelte+TypeScript users,
* you want to provide typings. Therefore you create a `index.d.ts`:
* ```ts
* import { SvelteComponentTyped } from "svelte";
* export class MyComponent extends SvelteComponentTyped<{foo: string}> {}
* ```
* Typing this makes it possible for IDEs like VS Code with the Svelte extension
* to provide intellisense and to use the component like this in a Svelte file
* with TypeScript:
* ```svelte
* <script lang="ts">
* import { MyComponent } from "component-library";
* </script>
* <MyComponent foo={'bar'} />
* ```
*
* #### Why not make this part of `SvelteComponent(Dev)`?
* Because
* ```ts
* class ASubclassOfSvelteComponent extends SvelteComponent<{foo: string}> {}
* const component: typeof SvelteComponent = ASubclassOfSvelteComponent;
* ```
* will throw a type error, so we need to separate the more strictly typed class.
*/
class SvelteComponentTyped extends SvelteComponentDev {
constructor(options) {
super(options);
}
}
function loop_guard(timeout) {
const start = Date.now();
return () => {
if (Date.now() - start > timeout) {
throw new Error('Infinite loop detected');
}
};
}
/***/ })
}]);
//# sourceMappingURL=vendors-node_modules_svelte_index_mjs.8c87196f35a3feefaf57.js.map | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_jupyterlab/static/static/vendors-node_modules_svelte_index_mjs.8c87196f35a3feefaf57.js | vendors-node_modules_svelte_index_mjs.8c87196f35a3feefaf57.js |
"use strict";
(self["webpackChunk_yuuno_jupyterlab"] = self["webpackChunk_yuuno_jupyterlab"] || []).push([["vendors-node_modules_css-loader_dist_runtime_api_js-node_modules_css-loader_dist_runtime_cssW-72eba1"],{
/***/ "./node_modules/css-loader/dist/runtime/api.js":
/*!*****************************************************!*\
!*** ./node_modules/css-loader/dist/runtime/api.js ***!
\*****************************************************/
/***/ ((module) => {
/*
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
// css base code, injected by the css-loader
// eslint-disable-next-line func-names
module.exports = function (cssWithMappingToString) {
var list = []; // return the list of modules as css string
list.toString = function toString() {
return this.map(function (item) {
var content = cssWithMappingToString(item);
if (item[2]) {
return "@media ".concat(item[2], " {").concat(content, "}");
}
return content;
}).join("");
}; // import a list of modules into the list
// eslint-disable-next-line func-names
list.i = function (modules, mediaQuery, dedupe) {
if (typeof modules === "string") {
// eslint-disable-next-line no-param-reassign
modules = [[null, modules, ""]];
}
var alreadyImportedModules = {};
if (dedupe) {
for (var i = 0; i < this.length; i++) {
// eslint-disable-next-line prefer-destructuring
var id = this[i][0];
if (id != null) {
alreadyImportedModules[id] = true;
}
}
}
for (var _i = 0; _i < modules.length; _i++) {
var item = [].concat(modules[_i]);
if (dedupe && alreadyImportedModules[item[0]]) {
// eslint-disable-next-line no-continue
continue;
}
if (mediaQuery) {
if (!item[2]) {
item[2] = mediaQuery;
} else {
item[2] = "".concat(mediaQuery, " and ").concat(item[2]);
}
}
list.push(item);
}
};
return list;
};
/***/ }),
/***/ "./node_modules/css-loader/dist/runtime/cssWithMappingToString.js":
/*!************************************************************************!*\
!*** ./node_modules/css-loader/dist/runtime/cssWithMappingToString.js ***!
\************************************************************************/
/***/ ((module) => {
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _iterableToArrayLimit(arr, i) { var _i = arr && (typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]); if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
module.exports = function cssWithMappingToString(item) {
var _item = _slicedToArray(item, 4),
content = _item[1],
cssMapping = _item[3];
if (!cssMapping) {
return content;
}
if (typeof btoa === "function") {
// eslint-disable-next-line no-undef
var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
var sourceMapping = "/*# ".concat(data, " */");
var sourceURLs = cssMapping.sources.map(function (source) {
return "/*# sourceURL=".concat(cssMapping.sourceRoot || "").concat(source, " */");
});
return [content].concat(sourceURLs).concat([sourceMapping]).join("\n");
}
return [content].join("\n");
};
/***/ }),
/***/ "./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js":
/*!****************************************************************************!*\
!*** ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js ***!
\****************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
var isOldIE = function isOldIE() {
var memo;
return function memorize() {
if (typeof memo === 'undefined') {
// Test for IE <= 9 as proposed by Browserhacks
// @see http://browserhacks.com/#hack-e71d8692f65334173fee715c222cb805
// Tests for existence of standard globals is to allow style-loader
// to operate correctly into non-standard environments
// @see https://github.com/webpack-contrib/style-loader/issues/177
memo = Boolean(window && document && document.all && !window.atob);
}
return memo;
};
}();
var getTarget = function getTarget() {
var memo = {};
return function memorize(target) {
if (typeof memo[target] === 'undefined') {
var styleTarget = document.querySelector(target); // Special case to return head of iframe instead of iframe itself
if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
try {
// This will throw an exception if access to iframe is blocked
// due to cross-origin restrictions
styleTarget = styleTarget.contentDocument.head;
} catch (e) {
// istanbul ignore next
styleTarget = null;
}
}
memo[target] = styleTarget;
}
return memo[target];
};
}();
var stylesInDom = [];
function getIndexByIdentifier(identifier) {
var result = -1;
for (var i = 0; i < stylesInDom.length; i++) {
if (stylesInDom[i].identifier === identifier) {
result = i;
break;
}
}
return result;
}
function modulesToDom(list, options) {
var idCountMap = {};
var identifiers = [];
for (var i = 0; i < list.length; i++) {
var item = list[i];
var id = options.base ? item[0] + options.base : item[0];
var count = idCountMap[id] || 0;
var identifier = "".concat(id, " ").concat(count);
idCountMap[id] = count + 1;
var index = getIndexByIdentifier(identifier);
var obj = {
css: item[1],
media: item[2],
sourceMap: item[3]
};
if (index !== -1) {
stylesInDom[index].references++;
stylesInDom[index].updater(obj);
} else {
stylesInDom.push({
identifier: identifier,
updater: addStyle(obj, options),
references: 1
});
}
identifiers.push(identifier);
}
return identifiers;
}
function insertStyleElement(options) {
var style = document.createElement('style');
var attributes = options.attributes || {};
if (typeof attributes.nonce === 'undefined') {
var nonce = true ? __webpack_require__.nc : 0;
if (nonce) {
attributes.nonce = nonce;
}
}
Object.keys(attributes).forEach(function (key) {
style.setAttribute(key, attributes[key]);
});
if (typeof options.insert === 'function') {
options.insert(style);
} else {
var target = getTarget(options.insert || 'head');
if (!target) {
throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
}
target.appendChild(style);
}
return style;
}
function removeStyleElement(style) {
// istanbul ignore if
if (style.parentNode === null) {
return false;
}
style.parentNode.removeChild(style);
}
/* istanbul ignore next */
var replaceText = function replaceText() {
var textStore = [];
return function replace(index, replacement) {
textStore[index] = replacement;
return textStore.filter(Boolean).join('\n');
};
}();
function applyToSingletonTag(style, index, remove, obj) {
var css = remove ? '' : obj.media ? "@media ".concat(obj.media, " {").concat(obj.css, "}") : obj.css; // For old IE
/* istanbul ignore if */
if (style.styleSheet) {
style.styleSheet.cssText = replaceText(index, css);
} else {
var cssNode = document.createTextNode(css);
var childNodes = style.childNodes;
if (childNodes[index]) {
style.removeChild(childNodes[index]);
}
if (childNodes.length) {
style.insertBefore(cssNode, childNodes[index]);
} else {
style.appendChild(cssNode);
}
}
}
function applyToTag(style, options, obj) {
var css = obj.css;
var media = obj.media;
var sourceMap = obj.sourceMap;
if (media) {
style.setAttribute('media', media);
} else {
style.removeAttribute('media');
}
if (sourceMap && typeof btoa !== 'undefined') {
css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */");
} // For old IE
/* istanbul ignore if */
if (style.styleSheet) {
style.styleSheet.cssText = css;
} else {
while (style.firstChild) {
style.removeChild(style.firstChild);
}
style.appendChild(document.createTextNode(css));
}
}
var singleton = null;
var singletonCounter = 0;
function addStyle(obj, options) {
var style;
var update;
var remove;
if (options.singleton) {
var styleIndex = singletonCounter++;
style = singleton || (singleton = insertStyleElement(options));
update = applyToSingletonTag.bind(null, style, styleIndex, false);
remove = applyToSingletonTag.bind(null, style, styleIndex, true);
} else {
style = insertStyleElement(options);
update = applyToTag.bind(null, style, options);
remove = function remove() {
removeStyleElement(style);
};
}
update(obj);
return function updateStyle(newObj) {
if (newObj) {
if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap) {
return;
}
update(obj = newObj);
} else {
remove();
}
};
}
module.exports = function (list, options) {
options = options || {}; // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
// tags it will allow on a page
if (!options.singleton && typeof options.singleton !== 'boolean') {
options.singleton = isOldIE();
}
list = list || [];
var lastIdentifiers = modulesToDom(list, options);
return function update(newList) {
newList = newList || [];
if (Object.prototype.toString.call(newList) !== '[object Array]') {
return;
}
for (var i = 0; i < lastIdentifiers.length; i++) {
var identifier = lastIdentifiers[i];
var index = getIndexByIdentifier(identifier);
stylesInDom[index].references--;
}
var newLastIdentifiers = modulesToDom(newList, options);
for (var _i = 0; _i < lastIdentifiers.length; _i++) {
var _identifier = lastIdentifiers[_i];
var _index = getIndexByIdentifier(_identifier);
if (stylesInDom[_index].references === 0) {
stylesInDom[_index].updater();
stylesInDom.splice(_index, 1);
}
}
lastIdentifiers = newLastIdentifiers;
};
};
/***/ })
}]);
//# sourceMappingURL=vendors-node_modules_css-loader_dist_runtime_api_js-node_modules_css-loader_dist_runtime_cssW-72eba1.1ec5ea217651b461b775.js.map | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_jupyterlab/static/static/vendors-node_modules_css-loader_dist_runtime_api_js-node_modules_css-loader_dist_runtime_cssW-72eba1.1ec5ea217651b461b775.js | vendors-node_modules_css-loader_dist_runtime_api_js-node_modules_css-loader_dist_runtime_cssW-72eba1.1ec5ea217651b461b775.js |
(self["webpackChunk_yuuno_jupyterlab"] = self["webpackChunk_yuuno_jupyterlab"] || []).push([["node_modules_xterm-addon-fit_lib_xterm-addon-fit_js"],{
/***/ "./node_modules/xterm-addon-fit/lib/xterm-addon-fit.js":
/*!*************************************************************!*\
!*** ./node_modules/xterm-addon-fit/lib/xterm-addon-fit.js ***!
\*************************************************************/
/***/ ((module) => {
!function(e,t){ true?module.exports=t():0}(self,(function(){return(()=>{"use strict";var e={775:(e,t)=>{Object.defineProperty(t,"__esModule",{value:!0}),t.FitAddon=void 0;var r=function(){function e(){}return e.prototype.activate=function(e){this._terminal=e},e.prototype.dispose=function(){},e.prototype.fit=function(){var e=this.proposeDimensions();if(e&&this._terminal){var t=this._terminal._core;this._terminal.rows===e.rows&&this._terminal.cols===e.cols||(t._renderService.clear(),this._terminal.resize(e.cols,e.rows))}},e.prototype.proposeDimensions=function(){if(this._terminal&&this._terminal.element&&this._terminal.element.parentElement){var e=this._terminal._core;if(0!==e._renderService.dimensions.actualCellWidth&&0!==e._renderService.dimensions.actualCellHeight){var t=window.getComputedStyle(this._terminal.element.parentElement),r=parseInt(t.getPropertyValue("height")),i=Math.max(0,parseInt(t.getPropertyValue("width"))),n=window.getComputedStyle(this._terminal.element),o=r-(parseInt(n.getPropertyValue("padding-top"))+parseInt(n.getPropertyValue("padding-bottom"))),a=i-(parseInt(n.getPropertyValue("padding-right"))+parseInt(n.getPropertyValue("padding-left")))-e.viewport.scrollBarWidth;return{cols:Math.max(2,Math.floor(a/e._renderService.dimensions.actualCellWidth)),rows:Math.max(1,Math.floor(o/e._renderService.dimensions.actualCellHeight))}}}},e}();t.FitAddon=r}},t={};return function r(i){if(t[i])return t[i].exports;var n=t[i]={exports:{}};return e[i](n,n.exports,r),n.exports}(775)})()}));
//# sourceMappingURL=xterm-addon-fit.js.map
/***/ })
}]);
//# sourceMappingURL=node_modules_xterm-addon-fit_lib_xterm-addon-fit_js.d5085c68658a9a02c319.js.map | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_jupyterlab/static/static/node_modules_xterm-addon-fit_lib_xterm-addon-fit_js.d5085c68658a9a02c319.js | node_modules_xterm-addon-fit_lib_xterm-addon-fit_js.d5085c68658a9a02c319.js |
"use strict";
(self["webpackChunk_yuuno_jupyterlab"] = self["webpackChunk_yuuno_jupyterlab"] || []).push([["lib_index_js"],{
/***/ "./lib/index.js":
/*!**********************!*\
!*** ./lib/index.js ***!
\**********************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _jupyterlab_settingregistry__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyterlab/settingregistry */ "webpack/sharing/consume/default/@jupyterlab/settingregistry");
/* harmony import */ var _jupyterlab_settingregistry__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_settingregistry__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @jupyter-widgets/base */ "webpack/sharing/consume/default/@jupyter-widgets/base");
/* harmony import */ var _jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _widgets_preview_index__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./widgets/preview/index */ "./lib/widgets/preview/index.js");
/* harmony import */ var _widgets_encode_index__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./widgets/encode/index */ "./lib/widgets/encode/index.js");
/* harmony import */ var _widgets_audio_index__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./widgets/audio/index */ "./lib/widgets/audio/index.js");
/**
* Initialization data for the @yuuno/jupyterlab extension.
*/
const plugin = {
id: '@yuuno/jupyterlab:plugin',
autoStart: true,
requires: [_jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_1__.IJupyterWidgetRegistry],
optional: [_jupyterlab_settingregistry__WEBPACK_IMPORTED_MODULE_0__.ISettingRegistry],
activate: (app, widgets, settingRegistry) => {
console.log('JupyterLab extension @yuuno/jupyterlab is activated!');
widgets.registerWidget({
name: "@yuuno/jupyter",
version: "1.2.0",
exports: {
PreviewWindowWidget: _widgets_preview_index__WEBPACK_IMPORTED_MODULE_2__.PreviewWindowWidget,
EncodeWindowWidget: _widgets_encode_index__WEBPACK_IMPORTED_MODULE_3__.EncodeWindowWidget,
AudioPlaybackWidget: _widgets_audio_index__WEBPACK_IMPORTED_MODULE_4__.AudioPlaybackWidget
}
});
console.log('@yuuno/jupyterlab: Widgets registered.');
if (settingRegistry) {
settingRegistry
.load(plugin.id)
.then(settings => {
console.log('@yuuno/jupyterlab settings loaded:', settings.composite);
})
.catch(reason => {
console.error('Failed to load settings for @yuuno/jupyterlab.', reason);
});
}
// requestAPI<any>('get_example')
// .then(data => {
// console.log(data);
// })
// .catch(reason => {
// console.error(
// `The yuuno_jupyterlab server extension appears to be missing.\n${reason}`
// );
// });
}
};
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (plugin);
/***/ }),
/***/ "./lib/model-rpc.js":
/*!**************************!*\
!*** ./lib/model-rpc.js ***!
\**************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "WidgetChannel": () => (/* binding */ WidgetChannel)
/* harmony export */ });
class WidgetChannel {
constructor(model) {
this.model = model;
}
/**
* Sends a message through this channel.
*/
async send(message) {
const buffers = ("buffers" in message ? message.buffers : []) || [];
if ("buffers" in message)
delete message["buffers"];
this.model.send(message, buffers);
}
/**
* Subscribe to messages.
*/
subscribe(subscriber) {
const cb = (content, buffers) => {
if (buffers.length > 0) {
content.buffers = buffers.map((b) => {
if (b instanceof ArrayBuffer) {
return b;
}
else {
var dst = new ArrayBuffer(b.byteLength);
new Uint8Array(dst).set(new Uint8Array(b.buffer));
return dst;
}
});
}
subscriber(content);
};
this.model.on("msg:custom", cb);
return () => {
this.model.off("msg:custom", cb);
};
}
;
}
/***/ }),
/***/ "./lib/rpc.js":
/*!********************!*\
!*** ./lib/rpc.js ***!
\********************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "RPCServer": () => (/* binding */ RPCServer),
/* harmony export */ "RPCClient": () => (/* binding */ RPCClient),
/* harmony export */ "timeout": () => (/* binding */ timeout),
/* harmony export */ "race": () => (/* binding */ race)
/* harmony export */ });
let _instance_counter = 0;
class RPCServer {
constructor(functions, channel) {
this.functions = functions;
this.channel = channel;
this.subscription = null;
}
_closeSubscription() {
if (this.subscription !== null) {
this.subscription();
this.subscription = null;
}
}
open() {
this._closeSubscription();
this.subscription = this.channel.subscribe((p) => this._receive(p).catch(console.log));
}
close() {
this._closeSubscription();
}
async _send(packet) {
if (this.subscription === null)
return;
this.channel.send(packet);
}
async _receive(packet) {
if (!packet.id) {
await this._send({
id: "",
type: "failure",
payload: "Unknown ID"
});
return;
}
if (!packet.type) {
await this._send({
id: packet.id,
type: "failure",
payload: "No method called."
});
return;
}
if (!(packet.type in this.functions)) {
await this._send({
id: packet.id,
type: "failure",
payload: "Unknown method."
});
return;
}
let input_buffers = [];
if (!!packet.buffers) {
input_buffers = packet.buffers;
delete packet.buffers;
}
let result = undefined;
try {
let raw_result = this.functions[packet.type];
let p_result = raw_result(packet.payload, input_buffers);
if ("then" in p_result)
result = await p_result;
else
result = raw_result;
}
catch (e) {
await this._send({
id: packet.id,
type: "failure",
payload: e.toString()
});
return;
}
let buffers = [];
if ("buffers" in result) {
buffers = result.buffers;
delete result["buffers"];
}
await this._send({
id: packet.id,
type: "response",
payload: result,
buffers: buffers
});
}
}
class RPCClient {
constructor(channel) {
this._requests = new Map();
this._instance_number = _instance_counter++;
this._current_packet_counter = 0;
this.channel = channel;
this.subscription = null;
}
_closeSubscription() {
if (this.subscription !== null) {
this.subscription();
this.subscription = null;
}
}
open() {
this._closeSubscription();
this.subscription = this.channel.subscribe((pkt) => this._receive(pkt));
}
_receive(packet) {
// Drop packets not for us.
if (!this._requests.has(packet.id))
return;
const awaiter = this._requests.get(packet.id);
this._requests.delete(packet.id);
awaiter(packet);
}
makeProxy(cancel) {
const cache = {
open: () => this.open(),
close: () => this.close()
};
return new Proxy(cache, {
get: (_, name) => {
return name in cache
? cache[name]
: (cache[name] = (payload = {}, buffers = undefined) => {
return this.request(name.toString(), payload, buffers, cancel);
});
}
});
}
request(name, payload, buffers = undefined, cancel) {
const id = `${this._instance_number}--${this._current_packet_counter++}`;
return new Promise((rs, rj) => {
let finished = () => { };
const awaiter = (packet) => {
if (packet === null) {
rj(new Error("Client closed."));
return;
}
finished();
if (!!packet.buffers) {
packet.payload.buffers = packet.buffers;
}
if (packet.type == "failure") {
rj(packet.payload);
}
else {
rs(packet.payload);
}
};
if (cancel !== undefined) {
finished = cancel(() => {
this._requests.delete(id);
rj(new Error("Request timed out."));
});
}
this._requests.set(id, awaiter);
this.channel.send({
id,
type: name,
payload,
buffers
});
});
}
close() {
this._closeSubscription();
const awaiters = [...this._requests.values()];
this._requests.clear();
for (let awaiter of awaiters)
awaiter(null);
}
}
function timeout(time) {
return (cancel) => {
const id = setTimeout(() => cancel(), time);
return () => clearTimeout(id);
};
}
function race(other) {
return (cancel) => {
other.then(() => cancel(), () => cancel());
return () => { };
};
}
/***/ }),
/***/ "./lib/svelte-widget.js":
/*!******************************!*\
!*** ./lib/svelte-widget.js ***!
\******************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "SvelteWidgetView": () => (/* binding */ SvelteWidgetView),
/* harmony export */ "widgetFor": () => (/* binding */ widgetFor)
/* harmony export */ });
/* harmony import */ var _jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/base */ "webpack/sharing/consume/default/@jupyter-widgets/base");
/* harmony import */ var _jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_0__);
/**
* Simple Wrapper-Type for Svelte Components.
*/
class SvelteWidgetView extends _jupyter_widgets_base__WEBPACK_IMPORTED_MODULE_0__.DOMWidgetView {
constructor() {
super(...arguments);
this.component = null;
}
/**
* Destroys a svelte component.
*/
_destroyComponent() {
if (this.component !== null) {
this.component.$destroy();
this.component = null;
}
}
/**
* Renders the svelte component.
*
* Svelte will subscribe to model changes it cares about by itself.
*/
render() {
this._destroyComponent();
this.component = this.buildComponent();
}
/**
* Unmounts a svelte component.
*/
remove() {
this._destroyComponent();
return super.remove();
}
}
/**
* Creates a new class for a specific widget.
*/
function widgetFor(c) {
return class SvelteWidgetImpl extends SvelteWidgetView {
buildComponent() {
return new c({
target: this.el,
props: { component: this.model }
});
}
};
}
/***/ }),
/***/ "./lib/utils.js":
/*!**********************!*\
!*** ./lib/utils.js ***!
\**********************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "model_attribute": () => (/* binding */ model_attribute),
/* harmony export */ "debounce": () => (/* binding */ debounce)
/* harmony export */ });
/**
* Creates a Svelte-Store out of a backbone model attribute.
*
* @param model The backbone model this to attach
* @param name The name of the attribute to watch.
*/
function model_attribute(model, name) {
return {
// Just set the value
set(value) {
model.set(name, value);
model.save();
},
// Change the value.
update(updater) {
model.set(name, updater(model.get(name)));
},
// Subscribe to changes to the value.
subscribe(subscriber) {
// Create our own function instance to make sure
// one can remove it again with the Unsubscriber.
const cb = (_, value) => {
subscriber(value);
};
model.on(`change:${name}`, cb);
subscriber(model.get(name));
return () => {
model.off(`change:${name}`, cb);
};
}
};
}
function debounce(time, parent) {
let currentId = -1;
return {
set(value) {
if (currentId != -1)
clearTimeout(currentId);
currentId = setTimeout(() => {
currentId = -1;
parent.set(value);
}, time);
},
update(update) {
parent.update(update);
},
subscribe(subscriber) {
return parent.subscribe(subscriber);
}
};
}
/***/ }),
/***/ "./lib/widgets/audio/index.js":
/*!************************************!*\
!*** ./lib/widgets/audio/index.js ***!
\************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "AudioPlaybackWidget": () => (/* binding */ AudioPlaybackWidget)
/* harmony export */ });
/* harmony import */ var _Widget_svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Widget.svelte */ "./lib/widgets/audio/Widget.svelte");
/* harmony import */ var _svelte_widget__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../svelte-widget */ "./lib/svelte-widget.js");
const AudioPlaybackWidget = (0,_svelte_widget__WEBPACK_IMPORTED_MODULE_0__.widgetFor)(_Widget_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]);
/***/ }),
/***/ "./lib/widgets/audio/player.js":
/*!*************************************!*\
!*** ./lib/widgets/audio/player.js ***!
\*************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "AudioPlayer": () => (/* binding */ AudioPlayer)
/* harmony export */ });
const COMBINED_FRAMES = 24;
const SAMPLES_PER_VS_FRAME = 3072;
const SAMPLES_PER_REQUEST = COMBINED_FRAMES * SAMPLES_PER_VS_FRAME;
// How many seconds should be loaded before
// playback should resume.
const PREFETCH_SECONDS = 5;
// How many seconds can be buffered before we
// pause requesting new chunks every second.
const BUFFER_HIGH_MARK_SECONDS = 30;
// How many seconds should be left before we
// suspend the audio.
const BUFFER_LOW_MARK_SECONDS = 2;
function calculatePosition(sample) {
const frame = Math.floor(sample / SAMPLES_PER_REQUEST);
const offset = sample % SAMPLES_PER_REQUEST;
return [frame, offset];
}
async function clock(tickTime, tick) {
let skipped = 0;
let shouldContinue = true;
do {
const start = new Date().valueOf();
shouldContinue = await tick(skipped);
const end = new Date().valueOf();
const dT = end - start;
if (dT < tickTime) {
skipped = 0;
if (tickTime - dT < 100)
continue; // Increase stability by skipping timeout on short times.
await new Promise(rs => setTimeout(rs, tickTime - dT));
}
else {
skipped = Math.ceil(tickTime / dT);
}
} while (shouldContinue);
}
function microtask(func) {
new Promise(rs => rs()).then(() => func());
}
class AudioPlayer {
constructor(source) {
this._paused = true;
this._onpause = null;
this.ontick = () => { };
this.source = source;
}
get playable() {
return this._onpause === null;
}
async play(startAt = 0) {
if (!this._paused)
return;
if (this._onpause !== null)
return;
this._paused = false;
// Ensure we have a full integer start at.
startAt = Math.floor(startAt);
// Make sure the metadata is loaded.
await this.source.loadMetadata();
// Create a new audio context and suspend it until we got the data we need.
const ctx = new AudioContext();
await ctx.suspend();
// Register the neccessary callbacks.
this._onpause = () => ctx.suspend();
// Find out where the seeked position starts at.
let [nextFrame, currentOffset] = calculatePosition(startAt);
// Calculation for the UI.
let currentSecond = 0;
const startSecond = startAt / this.source.sample_rate;
const maxLength = (this.source.samples - startAt) / this.source.sample_rate;
// Schedule a callback to inform the UI of the new state.
let lastCurrentTime = 0;
clock(500, async () => {
if (ctx.state !== "closed")
lastCurrentTime = ctx.currentTime;
const event = {
currentTime: Math.min(lastCurrentTime, maxLength) + startSecond,
bufferSecond: Math.min(currentSecond, maxLength) + startSecond,
playing: !this._paused
};
microtask(() => {
this.ontick(event);
});
return !this._paused;
}).catch(console.error);
let lastBuffers;
if (SAMPLES_PER_REQUEST - currentOffset > this.source.sample_rate) {
// 1. >1 second left at the sample to start:
// Make the offset negative to cause the initial buffer to
// take from beyond the start of b2 below.
//
// <OFFSET>
// SECOND |----------------|
// BUFFER |-----------------------------|:-----....
//
// or before:
lastBuffers = new Array(this.source.channels);
lastBuffers.fill(new ArrayBuffer(SAMPLES_PER_REQUEST * 4));
currentOffset *= -1;
}
else {
// 2. <1 second left:
// Prefetch the buffer and set it as the last buffer.
// <-- OFFSET -->
// SECOND |----------------|
// BUFFER |-----------------------------|:-----....
await this.source.render(nextFrame, (_, __, buffers) => {
lastBuffers = buffers;
return false;
});
nextFrame++;
currentOffset = SAMPLES_PER_REQUEST - currentOffset;
}
try {
await clock(1000, async (skipped) => {
if (this._paused)
return false;
// If we finished rendering the node, play to the end.
if (nextFrame >= this.source.frames) {
return currentSecond >= ctx.currentTime;
}
// Stop rendering after having buffered for 30 seconds and we did not skip any ticks.
if (skipped == 0 && currentSecond - ctx.currentTime > BUFFER_HIGH_MARK_SECONDS)
return true;
// All other cases: Process additional frames
await this.source.render(nextFrame, (frameNo, _, buffers) => {
// Bail on pausing.
if (this._paused)
return false;
if (currentSecond - ctx.currentTime < BUFFER_LOW_MARK_SECONDS) {
ctx.suspend();
}
// Advance the frame counter.
nextFrame = frameNo + 1;
// Build the AudioBuffer instances that we can construct.
// All of them are for exactly one full second.
const result = buildBuffer(this.source, lastBuffers, buffers, currentOffset, this.source.sample_rate);
currentOffset = result[1];
lastBuffers = buffers;
// Queue the samples.
for (let audio of result[0]) {
const node = new AudioBufferSourceNode(ctx, { buffer: audio });
node.connect(ctx.destination);
node.start(currentSecond++);
}
// Stop fetching additional chunks if we step over prefetch.
return currentSecond - ctx.currentTime < PREFETCH_SECONDS;
});
if (ctx.state === "suspended" && !this._paused)
await ctx.resume();
return !this._paused;
});
}
finally {
ctx.close();
this._onpause = null;
this._paused = true;
}
}
pause() {
if (!!this._onpause)
this._onpause();
this._paused = true;
}
async open() {
this.source.open();
await this.source.loadMetadata();
}
}
function buildBuffer(source, buffer1, buffer2, offset, length) {
const b1 = buffer1[0].byteLength / 4;
const b2 = buffer2[0].byteLength / 4;
const lb = length - offset;
let rest = b2 - lb;
const result = [];
if (offset >= 0) {
const buffer = new AudioBuffer({
length,
sampleRate: source.sample_rate,
numberOfChannels: source.channels
});
result.push(buffer);
if (offset > 0) {
copyFromBuffers(buffer, buffer1, b1 - offset, 0);
}
copyFromBuffers(buffer, buffer2, 0, offset);
}
while (rest > length) {
const buffer = new AudioBuffer({
length,
sampleRate: source.sample_rate,
numberOfChannels: source.channels
});
result.push(buffer);
copyFromBuffers(buffer, buffer2, b2 - rest, 0);
rest -= length;
}
return [result, rest];
}
function copyFromBuffers(buffer, channels, channelOffset, startOffset) {
for (let channel = 0; channel < channels.length; channel++) {
buffer.copyToChannel(new Float32Array(channels[channel], channelOffset * 4), channel, startOffset);
}
}
/***/ }),
/***/ "./lib/widgets/audio/rpc.js":
/*!**********************************!*\
!*** ./lib/widgets/audio/rpc.js ***!
\**********************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "AudioSource": () => (/* binding */ AudioSource)
/* harmony export */ });
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../rpc */ "./lib/rpc.js");
/* harmony import */ var _model_rpc__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../model-rpc */ "./lib/model-rpc.js");
class AudioSource {
constructor(model) {
this._open = false;
this._channels = 0;
this._frames = 0;
this._loaded = 0;
this._samples = 0;
this._sample_rate = 0;
this.ondata = () => { };
this.rpc = new _rpc__WEBPACK_IMPORTED_MODULE_0__.RPCClient(new _model_rpc__WEBPACK_IMPORTED_MODULE_1__.WidgetChannel(model)).makeProxy((0,_rpc__WEBPACK_IMPORTED_MODULE_0__.timeout)(10000));
}
open() {
this.rpc.open();
this._open = true;
}
close() {
this._open = false;
this.rpc.close();
}
get channels() {
return this._channels;
}
get loaded() {
return this._loaded;
}
get samples() {
return this._samples;
}
get sample_rate() {
return this._sample_rate;
}
get frames() {
return this._frames;
}
get duration() {
return this._samples / this._sample_rate;
}
async loadMetadata() {
if (this._frames === 0) {
const { frames, channel_count, samples_per_second, sample_count } = await this.rpc.meta();
this._frames = frames;
this._sample_rate = samples_per_second;
this._samples = sample_count;
this._channels = channel_count;
}
this.ondata();
}
async render(start, received) {
if (this._frames === 0)
await this.loadMetadata();
for (let frame = start; frame < this._frames; frame++) {
if (!this._open)
break;
const { size, buffers } = await this.rpc.render({ frame });
this._loaded += size;
if (!received(frame, size, buffers))
break;
}
}
}
/***/ }),
/***/ "./lib/widgets/encode/index.js":
/*!*************************************!*\
!*** ./lib/widgets/encode/index.js ***!
\*************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "EncodeWindowWidget": () => (/* binding */ EncodeWindowWidget)
/* harmony export */ });
/* harmony import */ var _Widget_svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Widget.svelte */ "./lib/widgets/encode/Widget.svelte");
/* harmony import */ var _svelte_widget__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../svelte-widget */ "./lib/svelte-widget.js");
const EncodeWindowWidget = (0,_svelte_widget__WEBPACK_IMPORTED_MODULE_0__.widgetFor)(_Widget_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]);
/***/ }),
/***/ "./lib/widgets/encode/rpc.js":
/*!***********************************!*\
!*** ./lib/widgets/encode/rpc.js ***!
\***********************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "getRPCForModel": () => (/* binding */ getRPCForModel)
/* harmony export */ });
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../rpc */ "./lib/rpc.js");
/* harmony import */ var _model_rpc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../model-rpc */ "./lib/model-rpc.js");
function getRPCForModel(model) {
const channel = new _model_rpc__WEBPACK_IMPORTED_MODULE_0__.WidgetChannel(model);
return new _rpc__WEBPACK_IMPORTED_MODULE_1__.RPCClient(channel).makeProxy((0,_rpc__WEBPACK_IMPORTED_MODULE_1__.timeout)(10000));
}
/***/ }),
/***/ "./lib/widgets/preview/index.js":
/*!**************************************!*\
!*** ./lib/widgets/preview/index.js ***!
\**************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "PreviewWindowWidget": () => (/* binding */ PreviewWindowWidget)
/* harmony export */ });
/* harmony import */ var _Widget_svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Widget.svelte */ "./lib/widgets/preview/Widget.svelte");
/* harmony import */ var _svelte_widget__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../svelte-widget */ "./lib/svelte-widget.js");
const PreviewWindowWidget = (0,_svelte_widget__WEBPACK_IMPORTED_MODULE_0__.widgetFor)(_Widget_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]);
/***/ }),
/***/ "./lib/widgets/preview/rpc.js":
/*!************************************!*\
!*** ./lib/widgets/preview/rpc.js ***!
\************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "getRPCForModel": () => (/* binding */ getRPCForModel)
/* harmony export */ });
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../rpc */ "./lib/rpc.js");
/* harmony import */ var _model_rpc__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../model-rpc */ "./lib/model-rpc.js");
class CachedPreviewRPC {
constructor(parent, model) {
this._cache = new Map();
this._lru = [];
this.parent = parent;
this.model = model;
}
clear() {
this._cache.clear();
}
open() {
this.parent.open();
}
close() {
this.parent.close();
}
length() {
return this.parent.length();
}
frame({ frame, image }) {
if (!image)
image = "clip";
const _lru_id = `${this.model.get(image + "Id")}--${image}--${frame}`;
if (!this._cache.has(_lru_id)) {
this._evict();
this._cache.set(_lru_id, this.parent.frame({ frame, image }));
}
this._hit(_lru_id);
return this._cache.get(_lru_id);
}
_hit(id) {
if (this._lru.indexOf(id) == 0)
return;
this._lru = [id, ...this._lru.filter(f => f != id)];
}
_evict() {
if (this._lru.length <= 10)
return;
const evicted = this._lru.pop();
this._cache.delete(evicted);
}
}
function getRPCForModel(model) {
const channel = new _model_rpc__WEBPACK_IMPORTED_MODULE_0__.WidgetChannel(model);
return new CachedPreviewRPC(new _rpc__WEBPACK_IMPORTED_MODULE_1__.RPCClient(channel).makeProxy((0,_rpc__WEBPACK_IMPORTED_MODULE_1__.timeout)(10000)), model);
}
/***/ }),
/***/ "./lib/widgets/audio/BufferSlider.svelte":
/*!***********************************************!*\
!*** ./lib/widgets/audio/BufferSlider.svelte ***!
\***********************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* lib/widgets/audio/BufferSlider.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1035j7a", ".buffer-slider.svelte-1035j7a.svelte-1035j7a{position:relative;width:100%;height:100%;display:block;border-left:var(--jp-border-width) solid var(--jp-cell-editor-border-color);border-right:var(--jp-border-width) solid var(--jp-cell-editor-border-color)}.buffer-slider.svelte-1035j7a>.svelte-1035j7a{position:absolute;height:20%;bottom:40%}.past.svelte-1035j7a.svelte-1035j7a{left:0;background-color:var(--jp-brand-color1);z-index:1}.buffered.svelte-1035j7a.svelte-1035j7a{left:0;background-color:var(--jp-cell-editor-border-color)}.select.svelte-1035j7a.svelte-1035j7a,.proposed.svelte-1035j7a.svelte-1035j7a{height:100%;top:0;width:var(--jp-border-width);background-color:var(--jp-brand-color1);z-index:2}");
}
// (5:4) {:else}
function create_else_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "proposed svelte-1035j7a");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*proposedPerc*/ ctx[1] * 100 + "%");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p(ctx, dirty) {
if (dirty & /*proposedPerc*/ 2) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*proposedPerc*/ ctx[1] * 100 + "%");
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (3:4) {#if proposedValue === null}
function create_if_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "select svelte-1035j7a");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*percPast*/ ctx[4] * 100 + "%");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p(ctx, dirty) {
if (dirty & /*percPast*/ 16) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*percPast*/ ctx[4] * 100 + "%");
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
function create_fragment(ctx) {
let div2;
let div0;
let t0;
let t1;
let div1;
let mounted;
let dispose;
function select_block_type(ctx, dirty) {
if (/*proposedValue*/ ctx[0] === null) return create_if_block;
return create_else_block;
}
let current_block_type = select_block_type(ctx, -1);
let if_block = current_block_type(ctx);
return {
c() {
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
if_block.c();
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "past svelte-1035j7a");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div0, "width", /*percPast*/ ctx[4] * 100 + "%");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "buffered svelte-1035j7a");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div1, "width", /*percFuture*/ ctx[3] * 100 + "%");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "buffer-slider svelte-1035j7a");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, div0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, t0);
if_block.m(div2, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, div1);
/*div2_binding*/ ctx[14](div2);
if (!mounted) {
dispose = [
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "mouseenter", /*enter*/ ctx[5]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "mouseleave", /*leave*/ ctx[6]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "mousemove", /*move*/ ctx[7]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "click", /*submit*/ ctx[8])
];
mounted = true;
}
},
p(ctx, [dirty]) {
if (dirty & /*percPast*/ 16) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div0, "width", /*percPast*/ ctx[4] * 100 + "%");
}
if (current_block_type === (current_block_type = select_block_type(ctx, dirty)) && if_block) {
if_block.p(ctx, dirty);
} else {
if_block.d(1);
if_block = current_block_type(ctx);
if (if_block) {
if_block.c();
if_block.m(div2, t1);
}
}
if (dirty & /*percFuture*/ 8) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div1, "width", /*percFuture*/ ctx[3] * 100 + "%");
}
},
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div2);
if_block.d();
/*div2_binding*/ ctx[14](null);
mounted = false;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.run_all)(dispose);
}
};
}
function clamp(v, ma, mi) {
return Math.max(Math.min(v, ma), mi);
}
function instance($$self, $$props, $$invalidate) {
let span;
let percPast;
let percFuture;
let { value = 0 } = $$props;
let { max = 1 } = $$props;
let { min = 0 } = $$props;
let { buffered = 0 } = $$props;
let { proposedValue = null } = $$props;
let { proposedPerc = null } = $$props;
const dispatch = (0,svelte__WEBPACK_IMPORTED_MODULE_1__.createEventDispatcher)();
let myself;
function enter(event) {
$$invalidate(0, proposedValue = min);
move(event);
}
function leave() {
$$invalidate(0, proposedValue = null);
}
function move(event) {
const { pageX, pageY } = event;
const { left, top, right } = myself.getBoundingClientRect();
const width = right - left;
const vX = pageX - left;
$$invalidate(1, proposedPerc = vX / width);
const rawProposal = proposedPerc * span + min;
$$invalidate(0, proposedValue = Math.round(rawProposal));
}
function submit() {
dispatch('update', { old: value, new: proposedValue });
$$invalidate(9, value = proposedValue);
}
function div2_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
myself = $$value;
$$invalidate(2, myself);
});
}
$$self.$$set = $$props => {
if ('value' in $$props) $$invalidate(9, value = $$props.value);
if ('max' in $$props) $$invalidate(10, max = $$props.max);
if ('min' in $$props) $$invalidate(11, min = $$props.min);
if ('buffered' in $$props) $$invalidate(12, buffered = $$props.buffered);
if ('proposedValue' in $$props) $$invalidate(0, proposedValue = $$props.proposedValue);
if ('proposedPerc' in $$props) $$invalidate(1, proposedPerc = $$props.proposedPerc);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*max, min*/ 3072) {
$: $$invalidate(13, span = max - min);
}
if ($$self.$$.dirty & /*value, min, span*/ 10752) {
$: $$invalidate(4, percPast = clamp((value - min) / span, 1, 0));
}
if ($$self.$$.dirty & /*buffered, min, span*/ 14336) {
$: $$invalidate(3, percFuture = clamp((buffered - min) / span, 1, 0));
}
};
return [
proposedValue,
proposedPerc,
myself,
percFuture,
percPast,
enter,
leave,
move,
submit,
value,
max,
min,
buffered,
span,
div2_binding
];
}
class BufferSlider extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(
this,
options,
instance,
create_fragment,
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal,
{
value: 9,
max: 10,
min: 11,
buffered: 12,
proposedValue: 0,
proposedPerc: 1
},
add_css
);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (BufferSlider);
/***/ }),
/***/ "./lib/widgets/audio/Widget.svelte":
/*!*****************************************!*\
!*** ./lib/widgets/audio/Widget.svelte ***!
\*****************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _BufferSlider_svelte__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./BufferSlider.svelte */ "./lib/widgets/audio/BufferSlider.svelte");
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./rpc */ "./lib/widgets/audio/rpc.js");
/* harmony import */ var _player__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./player */ "./lib/widgets/audio/player.js");
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @jupyterlab/ui-components */ "webpack/sharing/consume/default/@jupyterlab/ui-components");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_2__);
/* lib/widgets/audio/Widget.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-62r26p", ".audio.svelte-62r26p.svelte-62r26p{border:var(--jp-border-width) solid var(--jp-cell-editor-border-color);border-radius:0px;background:var(--jp-cell-editor-background);display:flex;height:28px}.audio.svelte-62r26p>.svelte-62r26p{padding:0px 10px}.audio.svelte-62r26p>.svelte-62r26p:not(:last-child){border-right:var(--jp-border-width) solid var(--jp-cell-editor-border-color)}.audio.svelte-62r26p>.meta.svelte-62r26p{line-height:28px}.audio.svelte-62r26p>.slider.svelte-62r26p{padding:0;flex-grow:1;flex-shrink:1}.toolbar.svelte-62r26p.svelte-62r26p{border:0;background:transparent;margin:0;padding:0;line-height:35px}.toolbar.svelte-62r26p.svelte-62r26p:not(:last-child){padding-right:5px}");
}
// (11:8) {:else}
function create_else_block(ctx) {
let button;
let mounted;
let dispose;
return {
c() {
button = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button, "class", "toolbar svelte-62r26p");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, button, anchor);
/*button_binding_1*/ ctx[25](button);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button, "click", /*click_handler_1*/ ctx[24]);
mounted = true;
}
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(button);
/*button_binding_1*/ ctx[25](null);
mounted = false;
dispose();
}
};
}
// (9:8) {#if playing}
function create_if_block(ctx) {
let button;
let mounted;
let dispose;
return {
c() {
button = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button, "class", "toolbar svelte-62r26p");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, button, anchor);
/*button_binding*/ ctx[23](button);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button, "click", /*click_handler*/ ctx[22]);
mounted = true;
}
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(button);
/*button_binding*/ ctx[23](null);
mounted = false;
dispose();
}
};
}
function create_fragment(ctx) {
let div3;
let div0;
let t0;
let t1;
let div1;
let bufferslider;
let updating_value;
let updating_proposedValue;
let t2;
let div2;
let t3;
let button;
let current;
let mounted;
let dispose;
function bufferslider_value_binding(value) {
/*bufferslider_value_binding*/ ctx[20](value);
}
function bufferslider_proposedValue_binding(value) {
/*bufferslider_proposedValue_binding*/ ctx[21](value);
}
let bufferslider_props = {
buffered: /*loaded*/ ctx[3],
samples: /*samples*/ ctx[2],
max: /*sample_count*/ ctx[8]
};
if (/*playhead*/ ctx[0] !== void 0) {
bufferslider_props.value = /*playhead*/ ctx[0];
}
if (/*proposed*/ ctx[1] !== void 0) {
bufferslider_props.proposedValue = /*proposed*/ ctx[1];
}
bufferslider = new _BufferSlider_svelte__WEBPACK_IMPORTED_MODULE_3__["default"]({ props: bufferslider_props });
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(bufferslider, 'value', bufferslider_value_binding));
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(bufferslider, 'proposedValue', bufferslider_proposedValue_binding));
bufferslider.$on("update", /*seek*/ ctx[11]);
function select_block_type(ctx, dirty) {
if (/*playing*/ ctx[9]) return create_if_block;
return create_else_block;
}
let current_block_type = select_block_type(ctx, [-1, -1]);
let if_block = current_block_type(ctx);
return {
c() {
div3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(/*displayTime*/ ctx[10]);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(bufferslider.$$.fragment);
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
if_block.c();
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
button = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "meta svelte-62r26p");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "slider svelte-62r26p");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button, "class", "toolbar svelte-62r26p");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", " svelte-62r26p");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div3, "class", "audio svelte-62r26p");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div3, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div0, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(bufferslider, div1, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div2);
if_block.m(div2, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, t3);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, button);
/*button_binding_2*/ ctx[27](button);
current = true;
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button, "click", /*click_handler_2*/ ctx[26]);
mounted = true;
}
},
p(ctx, dirty) {
if (!current || dirty[0] & /*displayTime*/ 1024) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t0, /*displayTime*/ ctx[10]);
const bufferslider_changes = {};
if (dirty[0] & /*loaded*/ 8) bufferslider_changes.buffered = /*loaded*/ ctx[3];
if (dirty[0] & /*samples*/ 4) bufferslider_changes.samples = /*samples*/ ctx[2];
if (dirty[0] & /*sample_count*/ 256) bufferslider_changes.max = /*sample_count*/ ctx[8];
if (!updating_value && dirty[0] & /*playhead*/ 1) {
updating_value = true;
bufferslider_changes.value = /*playhead*/ ctx[0];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_value = false);
}
if (!updating_proposedValue && dirty[0] & /*proposed*/ 2) {
updating_proposedValue = true;
bufferslider_changes.proposedValue = /*proposed*/ ctx[1];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_proposedValue = false);
}
bufferslider.$set(bufferslider_changes);
if (current_block_type === (current_block_type = select_block_type(ctx, dirty)) && if_block) {
if_block.p(ctx, dirty);
} else {
if_block.d(1);
if_block = current_block_type(ctx);
if (if_block) {
if_block.c();
if_block.m(div2, t3);
}
}
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(bufferslider.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(bufferslider.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div3);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(bufferslider);
if_block.d();
/*button_binding_2*/ ctx[27](null);
mounted = false;
dispose();
}
};
}
function instance($$self, $$props, $$invalidate) {
let percBuffered;
let displaySamples;
let raw_seconds;
let seconds;
let minutes;
let hours;
let displayTimeMinutes;
let displayTime;
let { component } = $$props;
let myself;
const audioSource = new _rpc__WEBPACK_IMPORTED_MODULE_4__.AudioSource(component);
const player = new _player__WEBPACK_IMPORTED_MODULE_5__.AudioPlayer(audioSource);
let playhead = 0;
let proposed = null;
let sample_count = 0;
let sample_rate = 0;
let samples = 1;
let loaded = 0;
let seeking = false;
let playing = false;
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onMount)(async () => {
audioSource.open();
audioSource.loadMetadata();
audioSource.ondata = () => {
$$invalidate(8, sample_count = audioSource.samples);
$$invalidate(13, sample_rate = audioSource.sample_rate);
$$invalidate(2, samples = audioSource.samples);
};
$$invalidate(
7,
player.ontick = event => {
if (seeking) return;
$$invalidate(9, playing = event.playing);
$$invalidate(0, playhead = event.currentTime * audioSource.sample_rate);
$$invalidate(3, loaded = event.bufferSecond * audioSource.sample_rate);
},
player
);
});
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onDestroy)(() => {
audioSource.close();
player.pause();
});
async function seek(event) {
// Run as expected if we are not playing back.
if (!playing) return;
// Pause and restart at the desired position.
seeking = true;
player.pause();
while (!player.playable) {
await new Promise(rs => setTimeout(rs, 1));
}
seeking = false;
player.play(event.detail.new);
}
let playBtn, pauseBtn, stopBtn;
function bufferslider_value_binding(value) {
playhead = value;
$$invalidate(0, playhead);
}
function bufferslider_proposedValue_binding(value) {
proposed = value;
$$invalidate(1, proposed);
}
const click_handler = () => {
player.pause();
};
function button_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
pauseBtn = $$value;
$$invalidate(5, pauseBtn);
});
}
const click_handler_1 = () => {
player.play(playhead);
};
function button_binding_1($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
playBtn = $$value;
$$invalidate(4, playBtn);
});
}
const click_handler_2 = () => {
player.pause();
$$invalidate(0, playhead = 0);
};
function button_binding_2($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
stopBtn = $$value;
$$invalidate(6, stopBtn);
});
}
$$self.$$set = $$props => {
if ('component' in $$props) $$invalidate(12, component = $$props.component);
};
$$self.$$.update = () => {
if ($$self.$$.dirty[0] & /*samples, loaded*/ 12) {
$: percBuffered = samples / loaded;
}
if ($$self.$$.dirty[0] & /*proposed, playhead*/ 3) {
$: $$invalidate(19, displaySamples = proposed === null ? playhead : proposed);
}
if ($$self.$$.dirty[0] & /*displaySamples, sample_rate*/ 532480) {
$: $$invalidate(18, raw_seconds = Math.round(displaySamples / sample_rate));
}
if ($$self.$$.dirty[0] & /*raw_seconds*/ 262144) {
$: $$invalidate(16, seconds = raw_seconds % 60);
}
if ($$self.$$.dirty[0] & /*raw_seconds*/ 262144) {
$: $$invalidate(17, minutes = Math.floor(raw_seconds / 60) % 60);
}
if ($$self.$$.dirty[0] & /*raw_seconds*/ 262144) {
$: $$invalidate(15, hours = Math.floor(raw_seconds / 3600));
}
if ($$self.$$.dirty[0] & /*minutes, seconds*/ 196608) {
$: $$invalidate(14, displayTimeMinutes = `${(minutes + "").padStart(2, "0")}:${(seconds + "").padStart(2, "0")}`);
}
if ($$self.$$.dirty[0] & /*hours, displayTimeMinutes*/ 49152) {
$: $$invalidate(10, displayTime = hours < 1
? displayTimeMinutes
: `${hours}:${displayTimeMinutes}`);
}
if ($$self.$$.dirty[0] & /*stopBtn*/ 64) {
$: if (!!stopBtn) _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_2__.refreshIcon.element({
container: stopBtn,
width: '16px',
height: '16px',
marginLeft: '2px'
});
}
if ($$self.$$.dirty[0] & /*playBtn*/ 16) {
$: if (!!playBtn) _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_2__.runIcon.element({
container: playBtn,
width: '16px',
height: '16px',
marginLeft: '2px'
});
}
if ($$self.$$.dirty[0] & /*pauseBtn*/ 32) {
$: if (!!pauseBtn) _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_2__.stopIcon.element({
container: pauseBtn,
width: '16px',
height: '16px',
marginLeft: '2px'
});
}
};
return [
playhead,
proposed,
samples,
loaded,
playBtn,
pauseBtn,
stopBtn,
player,
sample_count,
playing,
displayTime,
seek,
component,
sample_rate,
displayTimeMinutes,
hours,
seconds,
minutes,
raw_seconds,
displaySamples,
bufferslider_value_binding,
bufferslider_proposedValue_binding,
click_handler,
button_binding,
click_handler_1,
button_binding_1,
click_handler_2,
button_binding_2
];
}
class Widget extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { component: 12 }, add_css, [-1, -1]);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Widget);
/***/ }),
/***/ "./lib/widgets/encode/Clock.svelte":
/*!*****************************************!*\
!*** ./lib/widgets/encode/Clock.svelte ***!
\*****************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* lib/widgets/encode/Clock.svelte generated by Svelte v3.44.3 */
function create_fragment(ctx) {
let span;
let t;
return {
c() {
span = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("span");
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(/*running_time*/ ctx[0]);
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, span, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(span, t);
},
p(ctx, [dirty]) {
if (dirty & /*running_time*/ 1) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t, /*running_time*/ ctx[0]);
},
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(span);
}
};
}
function instance($$self, $$props, $$invalidate) {
let current_time;
let dTime;
let seconds;
let minutes;
let hours;
let days;
let intra_day;
let running_time;
let { end_time } = $$props;
let { start_time } = $$props;
let { terminated } = $$props;
let clock = new Date().valueOf();
let interval = setInterval(
() => {
$$invalidate(4, clock = new Date().valueOf());
},
1000
);
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onDestroy)(() => {
clearInterval(interval);
});
$$self.$$set = $$props => {
if ('end_time' in $$props) $$invalidate(1, end_time = $$props.end_time);
if ('start_time' in $$props) $$invalidate(2, start_time = $$props.start_time);
if ('terminated' in $$props) $$invalidate(3, terminated = $$props.terminated);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*terminated, end_time, clock*/ 26) {
$: $$invalidate(11, current_time = terminated ? end_time : Math.round(clock / 1000));
}
if ($$self.$$.dirty & /*current_time, start_time*/ 2052) {
$: $$invalidate(10, dTime = current_time - start_time);
}
if ($$self.$$.dirty & /*dTime*/ 1024) {
$: $$invalidate(8, seconds = dTime % 60);
}
if ($$self.$$.dirty & /*dTime*/ 1024) {
$: $$invalidate(9, minutes = Math.round(dTime / 60) % 60);
}
if ($$self.$$.dirty & /*dTime*/ 1024) {
$: $$invalidate(6, hours = Math.round(dTime / 3600) % 24);
}
if ($$self.$$.dirty & /*dTime*/ 1024) {
$: $$invalidate(7, days = Math.round(dTime / 86400));
}
if ($$self.$$.dirty & /*minutes, seconds*/ 768) {
$: $$invalidate(5, intra_day = `${(minutes + "").padStart(2, "0")}:${(seconds + "").padStart(2, "0")}`);
}
if ($$self.$$.dirty & /*days, hours, intra_day*/ 224) {
$: $$invalidate(0, running_time = days > 0
? `${days + ""}:${(hours + "").padStart(2, "0")}:${intra_day}`
: `${hours + ""}:${intra_day}`);
}
};
return [
running_time,
end_time,
start_time,
terminated,
clock,
intra_day,
hours,
days,
seconds,
minutes,
dTime,
current_time
];
}
class Clock extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, {
end_time: 1,
start_time: 2,
terminated: 3
});
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Clock);
/***/ }),
/***/ "./lib/widgets/encode/Header.svelte":
/*!******************************************!*\
!*** ./lib/widgets/encode/Header.svelte ***!
\******************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _Progress_svelte__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Progress.svelte */ "./lib/widgets/encode/Progress.svelte");
/* harmony import */ var _Clock_svelte__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Clock.svelte */ "./lib/widgets/encode/Clock.svelte");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @jupyterlab/ui-components */ "webpack/sharing/consume/default/@jupyterlab/ui-components");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../../utils */ "./lib/utils.js");
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./rpc */ "./lib/widgets/encode/rpc.js");
/* lib/widgets/encode/Header.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-14bawlj", ".header.svelte-14bawlj.svelte-14bawlj{width:100%}.top-bg.svelte-14bawlj.svelte-14bawlj{width:100%;top:0;left:0}.top.svelte-14bawlj.svelte-14bawlj{display:flex;line-height:27px;height:27px}.top.svelte-14bawlj>.svelte-14bawlj{padding:0px 10px}.top.svelte-14bawlj>.svelte-14bawlj:not(:last-child){border-right:var(--jp-border-width) solid var(--jp-cell-editor-border-color)}.spacer.svelte-14bawlj.svelte-14bawlj{flex-grow:1;flex-shrink:1}.toolbar.svelte-14bawlj.svelte-14bawlj{border:0;background:transparent;margin:0;padding:0;line-height:35px}.toolbar.svelte-14bawlj.svelte-14bawlj:not(:last-child){padding-right:5px}");
}
// (13:8) {:else}
function create_else_block(ctx) {
let div;
let t;
let button;
let mounted;
let dispose;
let if_block = !/*$_w32*/ ctx[9] && create_if_block_1(ctx);
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
if (if_block) if_block.c();
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
button = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button, "class", "toolbar svelte-14bawlj");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-14bawlj");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
if (if_block) if_block.m(div, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, button);
/*button_binding_1*/ ctx[21](button);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button, "click", /*click_handler_1*/ ctx[20]);
mounted = true;
}
},
p(ctx, dirty) {
if (!/*$_w32*/ ctx[9]) {
if (if_block) {
if_block.p(ctx, dirty);
} else {
if_block = create_if_block_1(ctx);
if_block.c();
if_block.m(div, t);
}
} else if (if_block) {
if_block.d(1);
if_block = null;
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
if (if_block) if_block.d();
/*button_binding_1*/ ctx[21](null);
mounted = false;
dispose();
}
};
}
// (11:8) {#if $terminated}
function create_if_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Terminated";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-14bawlj");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (15:16) {#if !$_w32}
function create_if_block_1(ctx) {
let button;
let mounted;
let dispose;
return {
c() {
button = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button, "class", "toolbar svelte-14bawlj");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, button, anchor);
/*button_binding*/ ctx[19](button);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button, "click", /*click_handler*/ ctx[18]);
mounted = true;
}
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(button);
/*button_binding*/ ctx[19](null);
mounted = false;
dispose();
}
};
}
function create_fragment(ctx) {
let div5;
let div0;
let progress;
let t0;
let div4;
let div1;
let t1;
let t2;
let t3;
let t4;
let div2;
let clock;
let t5;
let div3;
let t6;
let t7;
let current;
progress = new _Progress_svelte__WEBPACK_IMPORTED_MODULE_2__["default"]({
props: {
min: 0,
max: /*$length*/ ctx[3],
value: /*$current*/ ctx[4]
}
});
clock = new _Clock_svelte__WEBPACK_IMPORTED_MODULE_3__["default"]({
props: {
start_time: /*$start_time*/ ctx[5],
end_time: /*$end_time*/ ctx[6],
terminated: /*$terminated*/ ctx[7]
}
});
function select_block_type(ctx, dirty) {
if (/*$terminated*/ ctx[7]) return create_if_block;
return create_else_block;
}
let current_block_type = select_block_type(ctx, -1);
let if_block = current_block_type(ctx);
return {
c() {
div5 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(progress.$$.fragment);
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div4 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(/*$current*/ ctx[4]);
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(" / ");
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(/*$length*/ ctx[3]);
t4 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(clock.$$.fragment);
t5 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t6 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(/*$commandline*/ ctx[8]);
t7 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
if_block.c();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "top-bg svelte-14bawlj");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "svelte-14bawlj");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "svelte-14bawlj");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div3, "class", "spacer svelte-14bawlj");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div4, "class", "top svelte-14bawlj");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div5, "class", "header svelte-14bawlj");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div5, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div5, div0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(progress, div0, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div5, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div5, div4);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div4, div1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div1, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div1, t2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div1, t3);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div4, t4);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div4, div2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(clock, div2, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div4, t5);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div4, div3);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t6);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div4, t7);
if_block.m(div4, null);
current = true;
},
p(ctx, [dirty]) {
const progress_changes = {};
if (dirty & /*$length*/ 8) progress_changes.max = /*$length*/ ctx[3];
if (dirty & /*$current*/ 16) progress_changes.value = /*$current*/ ctx[4];
progress.$set(progress_changes);
if (!current || dirty & /*$current*/ 16) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t1, /*$current*/ ctx[4]);
if (!current || dirty & /*$length*/ 8) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t3, /*$length*/ ctx[3]);
const clock_changes = {};
if (dirty & /*$start_time*/ 32) clock_changes.start_time = /*$start_time*/ ctx[5];
if (dirty & /*$end_time*/ 64) clock_changes.end_time = /*$end_time*/ ctx[6];
if (dirty & /*$terminated*/ 128) clock_changes.terminated = /*$terminated*/ ctx[7];
clock.$set(clock_changes);
if (!current || dirty & /*$commandline*/ 256) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t6, /*$commandline*/ ctx[8]);
if (current_block_type === (current_block_type = select_block_type(ctx, dirty)) && if_block) {
if_block.p(ctx, dirty);
} else {
if_block.d(1);
if_block = current_block_type(ctx);
if (if_block) {
if_block.c();
if_block.m(div4, null);
}
}
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(progress.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(clock.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(progress.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(clock.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div5);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(progress);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(clock);
if_block.d();
}
};
}
function instance($$self, $$props, $$invalidate) {
let rpc;
let $length;
let $current;
let $start_time;
let $end_time;
let $terminated;
let $commandline;
let $_w32;
let { component } = $$props;
let interruptBtn, stopBtn;
const commandline = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "commandline");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, commandline, value => $$invalidate(8, $commandline = value));
const current = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "current");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, current, value => $$invalidate(4, $current = value));
const length = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "length");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, length, value => $$invalidate(3, $length = value));
const terminated = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "terminated");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, terminated, value => $$invalidate(7, $terminated = value));
const start_time = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "start_time");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, start_time, value => $$invalidate(5, $start_time = value));
const end_time = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "end_time");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, end_time, value => $$invalidate(6, $end_time = value));
const _w32 = (0,_utils__WEBPACK_IMPORTED_MODULE_4__.model_attribute)(component, "_w32");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, _w32, value => $$invalidate(9, $_w32 = value));
const click_handler = () => {
rpc.interrupt();
};
function button_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
interruptBtn = $$value;
$$invalidate(0, interruptBtn);
});
}
const click_handler_1 = () => {
rpc.kill();
};
function button_binding_1($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
stopBtn = $$value;
$$invalidate(1, stopBtn);
});
}
$$self.$$set = $$props => {
if ('component' in $$props) $$invalidate(17, component = $$props.component);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*component*/ 131072) {
$: $$invalidate(2, rpc = (0,_rpc__WEBPACK_IMPORTED_MODULE_5__.getRPCForModel)(component));
}
if ($$self.$$.dirty & /*interruptBtn*/ 1) {
$: [interruptBtn].forEach(e => {
if (!!e) _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__.closeIcon.element({
container: e,
width: '16px',
height: '16px',
marginLeft: '2px'
});
});
}
if ($$self.$$.dirty & /*stopBtn*/ 2) {
$: [stopBtn].forEach(e => {
if (!!e) _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__.stopIcon.element({
container: e,
width: '16px',
height: '16px',
marginLeft: '2px'
});
});
}
};
return [
interruptBtn,
stopBtn,
rpc,
$length,
$current,
$start_time,
$end_time,
$terminated,
$commandline,
$_w32,
commandline,
current,
length,
terminated,
start_time,
end_time,
_w32,
component,
click_handler,
button_binding,
click_handler_1,
button_binding_1
];
}
class Header extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { component: 17 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Header);
/***/ }),
/***/ "./lib/widgets/encode/Progress.svelte":
/*!********************************************!*\
!*** ./lib/widgets/encode/Progress.svelte ***!
\********************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* lib/widgets/encode/Progress.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1f3ta7d", ".progress.svelte-1f3ta7d.svelte-1f3ta7d{display:block;border-left:var(--jp-border-width) solid var(--jp-cell-editor-border-color);border-right:var(--jp-border-width) solid var(--jp-cell-editor-border-color)}.progress.svelte-1f3ta7d>.svelte-1f3ta7d{position:absolute;height:2px;top:0}.past.svelte-1f3ta7d.svelte-1f3ta7d{left:0;background-color:var(--jp-brand-color1)}");
}
function create_fragment(ctx) {
let div1;
let div0;
return {
c() {
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "past svelte-1f3ta7d");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div0, "width", /*percPast*/ ctx[0] * 100 + "%");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "progress svelte-1f3ta7d");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div1, div0);
},
p(ctx, [dirty]) {
if (dirty & /*percPast*/ 1) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div0, "width", /*percPast*/ ctx[0] * 100 + "%");
}
},
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div1);
}
};
}
function instance($$self, $$props, $$invalidate) {
let span;
let percPast;
let { value = 0 } = $$props;
let { max = 100 } = $$props;
let { min = 0 } = $$props;
$$self.$$set = $$props => {
if ('value' in $$props) $$invalidate(1, value = $$props.value);
if ('max' in $$props) $$invalidate(2, max = $$props.max);
if ('min' in $$props) $$invalidate(3, min = $$props.min);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*max, min*/ 12) {
$: $$invalidate(4, span = max - min);
}
if ($$self.$$.dirty & /*value, min, span*/ 26) {
$: $$invalidate(0, percPast = (value - min) / span);
}
};
return [percPast, value, max, min, span];
}
class Progress extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { value: 1, max: 2, min: 3 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Progress);
/***/ }),
/***/ "./lib/widgets/encode/Terminal.svelte":
/*!********************************************!*\
!*** ./lib/widgets/encode/Terminal.svelte ***!
\********************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* harmony import */ var xterm__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! xterm */ "webpack/sharing/consume/default/xterm/xterm");
/* harmony import */ var xterm__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(xterm__WEBPACK_IMPORTED_MODULE_2__);
/* harmony import */ var xterm_addon_fit__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! xterm-addon-fit */ "webpack/sharing/consume/default/xterm-addon-fit/xterm-addon-fit");
/* harmony import */ var xterm_addon_fit__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(xterm_addon_fit__WEBPACK_IMPORTED_MODULE_3__);
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./rpc */ "./lib/widgets/encode/rpc.js");
/* lib/widgets/encode/Terminal.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1kwq8fs", ".terminal.svelte-1kwq8fs{width:100%;min-height:480px\n }");
}
function create_fragment(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "terminal svelte-1kwq8fs");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
/*div_binding*/ ctx[2](div);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
/*div_binding*/ ctx[2](null);
}
};
}
let self_id = 0;
function instance($$self, $$props, $$invalidate) {
let { component } = $$props;
const myOwnId = `terminal-${self_id}`;
let target;
let state = "attaching";
const terminal = new xterm__WEBPACK_IMPORTED_MODULE_2__.Terminal();
const fit = new xterm_addon_fit__WEBPACK_IMPORTED_MODULE_3__.FitAddon();
terminal.loadAddon(fit);
const rpc = (0,_rpc__WEBPACK_IMPORTED_MODULE_4__.getRPCForModel)(component);
const cb = msg => {
if (msg.type !== "write") return;
if (state !== "ready") return;
if (msg.target !== "broadcast") return;
terminal.write(msg.data);
};
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onMount)(async () => {
rpc.open();
component.on("msg:custom", cb);
terminal.write((await rpc.refresh({ source: myOwnId })).data);
state = "ready";
});
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onMount)(async () => {
// Let's do our best to enforce style calculations.
await new Promise(rs => requestAnimationFrame(rs));
await new Promise(rs => requestAnimationFrame(rs));
// This is a trick.
window.getComputedStyle(target).width;
// Now fit the terminal size.
fit.fit();
});
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onDestroy)(() => {
component.off("msg:custom", cb);
rpc.close();
});
function div_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
target = $$value;
$$invalidate(0, target);
});
}
$$self.$$set = $$props => {
if ('component' in $$props) $$invalidate(1, component = $$props.component);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*target*/ 1) {
$: if (!!target) terminal.open(target);
}
};
return [target, component, div_binding];
}
class Terminal_1 extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { component: 1 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Terminal_1);
/***/ }),
/***/ "./lib/widgets/encode/Widget.svelte":
/*!******************************************!*\
!*** ./lib/widgets/encode/Widget.svelte ***!
\******************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _Header_svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Header.svelte */ "./lib/widgets/encode/Header.svelte");
/* harmony import */ var _Terminal_svelte__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Terminal.svelte */ "./lib/widgets/encode/Terminal.svelte");
/* lib/widgets/encode/Widget.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1vyoag3", ".encode.svelte-1vyoag3.svelte-1vyoag3{border:var(--jp-border-width) solid var(--jp-cell-editor-border-color);border-radius:0px;background:var(--jp-cell-editor-background);display:flex;flex-direction:column}.encode.svelte-1vyoag3>.svelte-1vyoag3{width:100%}");
}
function create_fragment(ctx) {
let div2;
let div0;
let header;
let t;
let div1;
let terminal;
let current;
header = new _Header_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]({
props: { component: /*component*/ ctx[0] }
});
terminal = new _Terminal_svelte__WEBPACK_IMPORTED_MODULE_2__["default"]({
props: { component: /*component*/ ctx[0] }
});
return {
c() {
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(header.$$.fragment);
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(terminal.$$.fragment);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "svelte-1vyoag3");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "svelte-1vyoag3");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "encode svelte-1vyoag3");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, div0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(header, div0, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, t);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, div1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(terminal, div1, null);
current = true;
},
p(ctx, [dirty]) {
const header_changes = {};
if (dirty & /*component*/ 1) header_changes.component = /*component*/ ctx[0];
header.$set(header_changes);
const terminal_changes = {};
if (dirty & /*component*/ 1) terminal_changes.component = /*component*/ ctx[0];
terminal.$set(terminal_changes);
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(header.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(terminal.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(header.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(terminal.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(header);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(terminal);
}
};
}
function instance($$self, $$props, $$invalidate) {
let { component } = $$props;
$$self.$$set = $$props => {
if ('component' in $$props) $$invalidate(0, component = $$props.component);
};
return [component];
}
class Widget extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { component: 0 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Widget);
/***/ }),
/***/ "./lib/widgets/preview/Footer.svelte":
/*!*******************************************!*\
!*** ./lib/widgets/preview/Footer.svelte ***!
\*******************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _LineSlider_svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./LineSlider.svelte */ "./lib/widgets/preview/LineSlider.svelte");
/* harmony import */ var _JupyterSelect_svelte__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./JupyterSelect.svelte */ "./lib/widgets/preview/JupyterSelect.svelte");
/* lib/widgets/preview/Footer.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1uhq7gv", ".bottom.svelte-1uhq7gv.svelte-1uhq7gv{display:flex}.current-frame.svelte-1uhq7gv.svelte-1uhq7gv{line-height:100%;padding-top:4px;padding-right:5px}.current-frame.svelte-1uhq7gv>input.svelte-1uhq7gv{border:0;width:50px;text-align:right;background:transparent;color:var(--jp-widgets-color)}.line-slider.svelte-1uhq7gv.svelte-1uhq7gv{flex-grow:1;flex-shrink:1}");
}
// (5:8) {:else}
function create_else_block(ctx) {
let input;
let mounted;
let dispose;
return {
c() {
input = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("input");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(input, "type", "number");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(input, "class", "svelte-1uhq7gv");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, input, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_input_value)(input, /*proposedValue*/ ctx[3]);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(input, "input", /*input_input_handler_1*/ ctx[5]);
mounted = true;
}
},
p(ctx, dirty) {
if (dirty & /*proposedValue*/ 8 && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.to_number)(input.value) !== /*proposedValue*/ ctx[3]) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_input_value)(input, /*proposedValue*/ ctx[3]);
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(input);
mounted = false;
dispose();
}
};
}
// (3:8) {#if proposedValue === null}
function create_if_block(ctx) {
let input;
let mounted;
let dispose;
return {
c() {
input = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("input");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(input, "type", "number");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(input, "class", "svelte-1uhq7gv");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, input, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_input_value)(input, /*frame*/ ctx[0]);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(input, "input", /*input_input_handler*/ ctx[4]);
mounted = true;
}
},
p(ctx, dirty) {
if (dirty & /*frame*/ 1 && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.to_number)(input.value) !== /*frame*/ ctx[0]) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_input_value)(input, /*frame*/ ctx[0]);
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(input);
mounted = false;
dispose();
}
};
}
// (15:8) <JupyterSelect bind:value={ zoom }>
function create_default_slot(ctx) {
let option0;
let option0_value_value;
let t1;
let option1;
let option1_value_value;
let t3;
let option2;
let option2_value_value;
let t5;
let option3;
let option3_value_value;
let t7;
let option4;
let option4_value_value;
let t9;
let option5;
let option5_value_value;
let t11;
let option6;
let option6_value_value;
return {
c() {
option0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option0.textContent = "25%";
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
option1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option1.textContent = "50%";
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
option2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option2.textContent = "75%";
t5 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
option3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option3.textContent = "100%";
t7 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
option4 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option4.textContent = "150%";
t9 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
option5 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option5.textContent = "200%";
t11 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
option6 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("option");
option6.textContent = "300%";
option0.__value = option0_value_value = .25;
option0.value = option0.__value;
option1.__value = option1_value_value = .50;
option1.value = option1.__value;
option2.__value = option2_value_value = .70;
option2.value = option2.__value;
option3.__value = option3_value_value = 1;
option3.value = option3.__value;
option4.__value = option4_value_value = 1.5;
option4.value = option4.__value;
option5.__value = option5_value_value = 2.0;
option5.value = option5.__value;
option6.__value = option6_value_value = 3.0;
option6.value = option6.__value;
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option0, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t3, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t5, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option3, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t7, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option4, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t9, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option5, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t11, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, option6, anchor);
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option0);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t1);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option1);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t3);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option2);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t5);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option3);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t7);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option4);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t9);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option5);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t11);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(option6);
}
};
}
function create_fragment(ctx) {
let div3;
let div0;
let t0;
let t1;
let t2;
let div1;
let lineslider;
let updating_value;
let updating_proposedValue;
let t3;
let div2;
let jupyterselect;
let updating_value_1;
let current;
function select_block_type(ctx, dirty) {
if (/*proposedValue*/ ctx[3] === null) return create_if_block;
return create_else_block;
}
let current_block_type = select_block_type(ctx, -1);
let if_block = current_block_type(ctx);
function lineslider_value_binding(value) {
/*lineslider_value_binding*/ ctx[6](value);
}
function lineslider_proposedValue_binding(value) {
/*lineslider_proposedValue_binding*/ ctx[7](value);
}
let lineslider_props = { min: 0, max: /*length*/ ctx[2] };
if (/*frame*/ ctx[0] !== void 0) {
lineslider_props.value = /*frame*/ ctx[0];
}
if (/*proposedValue*/ ctx[3] !== void 0) {
lineslider_props.proposedValue = /*proposedValue*/ ctx[3];
}
lineslider = new _LineSlider_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]({ props: lineslider_props });
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(lineslider, 'value', lineslider_value_binding));
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(lineslider, 'proposedValue', lineslider_proposedValue_binding));
function jupyterselect_value_binding(value) {
/*jupyterselect_value_binding*/ ctx[8](value);
}
let jupyterselect_props = {
$$slots: { default: [create_default_slot] },
$$scope: { ctx }
};
if (/*zoom*/ ctx[1] !== void 0) {
jupyterselect_props.value = /*zoom*/ ctx[1];
}
jupyterselect = new _JupyterSelect_svelte__WEBPACK_IMPORTED_MODULE_2__["default"]({ props: jupyterselect_props });
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(jupyterselect, 'value', jupyterselect_value_binding));
return {
c() {
div3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
if_block.c();
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("\n /\n ");
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(/*length*/ ctx[2]);
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(lineslider.$$.fragment);
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(jupyterselect.$$.fragment);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "current-frame svelte-1uhq7gv");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "line-slider svelte-1uhq7gv");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "zoom");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div3, "class", "bottom svelte-1uhq7gv");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div3, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div0);
if_block.m(div0, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div0, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div0, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(lineslider, div1, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t3);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(jupyterselect, div2, null);
current = true;
},
p(ctx, [dirty]) {
if (current_block_type === (current_block_type = select_block_type(ctx, dirty)) && if_block) {
if_block.p(ctx, dirty);
} else {
if_block.d(1);
if_block = current_block_type(ctx);
if (if_block) {
if_block.c();
if_block.m(div0, t0);
}
}
if (!current || dirty & /*length*/ 4) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t1, /*length*/ ctx[2]);
const lineslider_changes = {};
if (dirty & /*length*/ 4) lineslider_changes.max = /*length*/ ctx[2];
if (!updating_value && dirty & /*frame*/ 1) {
updating_value = true;
lineslider_changes.value = /*frame*/ ctx[0];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_value = false);
}
if (!updating_proposedValue && dirty & /*proposedValue*/ 8) {
updating_proposedValue = true;
lineslider_changes.proposedValue = /*proposedValue*/ ctx[3];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_proposedValue = false);
}
lineslider.$set(lineslider_changes);
const jupyterselect_changes = {};
if (dirty & /*$$scope*/ 512) {
jupyterselect_changes.$$scope = { dirty, ctx };
}
if (!updating_value_1 && dirty & /*zoom*/ 2) {
updating_value_1 = true;
jupyterselect_changes.value = /*zoom*/ ctx[1];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_value_1 = false);
}
jupyterselect.$set(jupyterselect_changes);
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(lineslider.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(jupyterselect.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(lineslider.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(jupyterselect.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div3);
if_block.d();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(lineslider);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(jupyterselect);
}
};
}
function instance($$self, $$props, $$invalidate) {
let { frame } = $$props;
let { length } = $$props;
let { zoom } = $$props;
let proposedValue;
function input_input_handler() {
frame = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.to_number)(this.value);
$$invalidate(0, frame);
}
function input_input_handler_1() {
proposedValue = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.to_number)(this.value);
$$invalidate(3, proposedValue);
}
function lineslider_value_binding(value) {
frame = value;
$$invalidate(0, frame);
}
function lineslider_proposedValue_binding(value) {
proposedValue = value;
$$invalidate(3, proposedValue);
}
function jupyterselect_value_binding(value) {
zoom = value;
$$invalidate(1, zoom);
}
$$self.$$set = $$props => {
if ('frame' in $$props) $$invalidate(0, frame = $$props.frame);
if ('length' in $$props) $$invalidate(2, length = $$props.length);
if ('zoom' in $$props) $$invalidate(1, zoom = $$props.zoom);
};
return [
frame,
zoom,
length,
proposedValue,
input_input_handler,
input_input_handler_1,
lineslider_value_binding,
lineslider_proposedValue_binding,
jupyterselect_value_binding
];
}
class Footer extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { frame: 0, length: 2, zoom: 1 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Footer);
/***/ }),
/***/ "./lib/widgets/preview/Header.svelte":
/*!*******************************************!*\
!*** ./lib/widgets/preview/Header.svelte ***!
\*******************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @jupyterlab/ui-components */ "webpack/sharing/consume/default/@jupyterlab/ui-components");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* lib/widgets/preview/Header.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1b04bb5", ".top.svelte-1b04bb5.svelte-1b04bb5{display:flex;line-height:27px;height:27px}.top.svelte-1b04bb5>.svelte-1b04bb5:not(.spacer){padding:0px 10px}.top.svelte-1b04bb5>.svelte-1b04bb5:not(:last-child){border-right:var(--jp-border-width) solid var(--jp-cell-editor-border-color)}.spacer.svelte-1b04bb5.svelte-1b04bb5{flex-grow:1;flex-shrink:1}.toolbar.svelte-1b04bb5.svelte-1b04bb5{border:0;background:transparent;margin:0;padding:0;line-height:35px}.toolbar.svelte-1b04bb5.svelte-1b04bb5:not(:last-child){padding-right:5px}");
}
// (26:4) {:else}
function create_else_block(ctx) {
let div0;
let t1;
let promise;
let t2;
let div1;
let button0;
let t3;
let div2;
let t4;
let div3;
let promise_1;
let t5;
let div4;
let t6;
let div5;
let button1;
let t7;
let promise_2;
let t8;
let div6;
let mounted;
let dispose;
let info = {
ctx,
current: null,
token: null,
hasCatch: true,
pending: create_pending_block_4,
then: create_then_block_4,
catch: create_catch_block_4,
value: 16
};
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise = /*frameDataPromiseLeft*/ ctx[5], info);
let info_1 = {
ctx,
current: null,
token: null,
hasCatch: false,
pending: create_pending_block_3,
then: create_then_block_3,
catch: create_catch_block_3,
value: 17
};
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise_1 = /*lengthPromise*/ ctx[6], info_1);
let info_2 = {
ctx,
current: null,
token: null,
hasCatch: true,
pending: create_pending_block_2,
then: create_then_block_2,
catch: create_catch_block_2,
value: 16
};
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise_2 = /*frameDataPromiseRight*/ ctx[4], info_2);
return {
c() {
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0.textContent = "A";
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
info.block.c();
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
button0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t4 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
info_1.block.c();
t5 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div4 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t6 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div5 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
button1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
t7 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
info_2.block.c();
t8 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div6 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div6.textContent = "B";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button0, "class", "toolbar svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "spacer svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div3, "class", "svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div4, "class", "spacer svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button1, "class", "toolbar svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div5, "class", "svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div6, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div0, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t1, anchor);
info.block.m(target, info.anchor = anchor);
info.mount = () => t2.parentNode;
info.anchor = t2;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div1, button0);
/*button0_binding*/ ctx[13](button0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t3, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t4, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div3, anchor);
info_1.block.m(div3, info_1.anchor = null);
info_1.mount = () => div3;
info_1.anchor = null;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t5, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div4, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t6, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div5, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div5, button1);
/*button1_binding*/ ctx[15](button1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t7, anchor);
info_2.block.m(target, info_2.anchor = anchor);
info_2.mount = () => t8.parentNode;
info_2.anchor = t8;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t8, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div6, anchor);
if (!mounted) {
dispose = [
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button0, "click", /*click_handler_1*/ ctx[12]('clip')),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button1, "click", /*click_handler_2*/ ctx[14]('diff'))
];
mounted = true;
}
},
p(new_ctx, dirty) {
ctx = new_ctx;
info.ctx = ctx;
if (dirty & /*frameDataPromiseLeft*/ 32 && promise !== (promise = /*frameDataPromiseLeft*/ ctx[5]) && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise, info)) {
} else {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_await_block_branch)(info, ctx, dirty);
}
info_1.ctx = ctx;
if (dirty & /*lengthPromise*/ 64 && promise_1 !== (promise_1 = /*lengthPromise*/ ctx[6]) && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise_1, info_1)) {
} else {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_await_block_branch)(info_1, ctx, dirty);
}
info_2.ctx = ctx;
if (dirty & /*frameDataPromiseRight*/ 16 && promise_2 !== (promise_2 = /*frameDataPromiseRight*/ ctx[4]) && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise_2, info_2)) {
} else {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_await_block_branch)(info_2, ctx, dirty);
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div0);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t1);
info.block.d(detaching);
info.token = null;
info = null;
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t2);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div1);
/*button0_binding*/ ctx[13](null);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t3);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div2);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t4);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div3);
info_1.block.d();
info_1.token = null;
info_1 = null;
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t5);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div4);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t6);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div5);
/*button1_binding*/ ctx[15](null);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t7);
info_2.block.d(detaching);
info_2.token = null;
info_2 = null;
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t8);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div6);
mounted = false;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.run_all)(dispose);
}
};
}
// (4:30)
function create_if_block_1(ctx) {
let div0;
let promise;
let t0;
let promise_1;
let t1;
let div1;
let t2;
let div2;
let button;
let mounted;
let dispose;
let info = {
ctx,
current: null,
token: null,
hasCatch: false,
pending: create_pending_block_1,
then: create_then_block_1,
catch: create_catch_block_1,
value: 17
};
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise = /*lengthPromise*/ ctx[6], info);
let info_1 = {
ctx,
current: null,
token: null,
hasCatch: true,
pending: create_pending_block,
then: create_then_block,
catch: create_catch_block,
value: 16
};
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise_1 = /*frameDataPromiseLeft*/ ctx[5], info_1);
return {
c() {
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
info.block.c();
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
info_1.block.c();
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
button = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("button");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "spacer svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(button, "class", "toolbar svelte-1b04bb5");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div0, anchor);
info.block.m(div0, info.anchor = null);
info.mount = () => div0;
info.anchor = null;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t0, anchor);
info_1.block.m(target, info_1.anchor = anchor);
info_1.mount = () => t1.parentNode;
info_1.anchor = t1;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, button);
/*button_binding*/ ctx[11](button);
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(button, "click", /*click_handler*/ ctx[10]('clip'));
mounted = true;
}
},
p(new_ctx, dirty) {
ctx = new_ctx;
info.ctx = ctx;
if (dirty & /*lengthPromise*/ 64 && promise !== (promise = /*lengthPromise*/ ctx[6]) && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise, info)) {
} else {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_await_block_branch)(info, ctx, dirty);
}
info_1.ctx = ctx;
if (dirty & /*frameDataPromiseLeft*/ 32 && promise_1 !== (promise_1 = /*frameDataPromiseLeft*/ ctx[5]) && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise_1, info_1)) {
} else {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_await_block_branch)(info_1, ctx, dirty);
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div0);
info.block.d();
info.token = null;
info = null;
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t0);
info_1.block.d(detaching);
info_1.token = null;
info_1 = null;
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t1);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div1);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t2);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div2);
/*button_binding*/ ctx[11](null);
mounted = false;
dispose();
}
};
}
// (2:4) {#if clip_id == null}
function create_if_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "No image";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (36:8) {:catch}
function create_catch_block_4(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Error";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (34:8) {:then frameData}
function create_then_block_4(ctx) {
let div;
let t0_value = /*frameData*/ ctx[16].size[0] + "";
let t0;
let t1;
let t2_value = /*frameData*/ ctx[16].size[1] + "";
let t2;
let t3;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t0_value);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("px ร ");
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t2_value);
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("px");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t3);
},
p(ctx, dirty) {
if (dirty & /*frameDataPromiseLeft*/ 32 && t0_value !== (t0_value = /*frameData*/ ctx[16].size[0] + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t0, t0_value);
if (dirty & /*frameDataPromiseLeft*/ 32 && t2_value !== (t2_value = /*frameData*/ ctx[16].size[1] + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t2, t2_value);
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (32:37) <div>Updating ...</div> {:then frameData}
function create_pending_block_4(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Updating ...";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (1:0) <div class="top"> {#if clip_id == null}
function create_catch_block_3(ctx) {
return { c: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop, m: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop, p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop, d: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop };
}
// (49:12) {:then length}
function create_then_block_3(ctx) {
let t0_value = /*length*/ ctx[17].length + "";
let t0;
let t1;
return {
c() {
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t0_value);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(" frames");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t0, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t1, anchor);
},
p(ctx, dirty) {
if (dirty & /*lengthPromise*/ 64 && t0_value !== (t0_value = /*length*/ ctx[17].length + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t0, t0_value);
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t0);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t1);
}
};
}
// (47:34) ... frames {:then length}
function create_pending_block_3(ctx) {
let t;
return {
c() {
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("... frames");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t);
}
};
}
// (63:8) {:catch}
function create_catch_block_2(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Error";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (61:8) {:then frameData}
function create_then_block_2(ctx) {
let div;
let t0_value = /*frameData*/ ctx[16].size[0] + "";
let t0;
let t1;
let t2_value = /*frameData*/ ctx[16].size[1] + "";
let t2;
let t3;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t0_value);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("px ร ");
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t2_value);
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("px");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t3);
},
p(ctx, dirty) {
if (dirty & /*frameDataPromiseRight*/ 16 && t0_value !== (t0_value = /*frameData*/ ctx[16].size[0] + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t0, t0_value);
if (dirty & /*frameDataPromiseRight*/ 16 && t2_value !== (t2_value = /*frameData*/ ctx[16].size[1] + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t2, t2_value);
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (59:38) <div>Updating ...</div> {:then frameData}
function create_pending_block_2(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Updating ...";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (1:0) <div class="top"> {#if clip_id == null}
function create_catch_block_1(ctx) {
return { c: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop, m: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop, p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop, d: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop };
}
// (8:12) {:then length}
function create_then_block_1(ctx) {
let t0_value = /*length*/ ctx[17].length + "";
let t0;
let t1;
return {
c() {
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t0_value);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(" frames");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t0, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t1, anchor);
},
p(ctx, dirty) {
if (dirty & /*lengthPromise*/ 64 && t0_value !== (t0_value = /*length*/ ctx[17].length + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t0, t0_value);
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t0);
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t1);
}
};
}
// (6:34) ... frames {:then length}
function create_pending_block_1(ctx) {
let t;
return {
c() {
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("... frames");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, t, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(t);
}
};
}
// (16:8) {:catch}
function create_catch_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Error";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (14:8) {:then frameData}
function create_then_block(ctx) {
let div;
let t0_value = /*frameData*/ ctx[16].size[0] + "";
let t0;
let t1;
let t2_value = /*frameData*/ ctx[16].size[1] + "";
let t2;
let t3;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t0_value);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("px ร ");
t2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)(t2_value);
t3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.text)("px");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t3);
},
p(ctx, dirty) {
if (dirty & /*frameDataPromiseLeft*/ 32 && t0_value !== (t0_value = /*frameData*/ ctx[16].size[0] + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t0, t0_value);
if (dirty & /*frameDataPromiseLeft*/ 32 && t2_value !== (t2_value = /*frameData*/ ctx[16].size[1] + "")) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_data)(t2, t2_value);
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (12:37) <div>Updating ...</div> {:then frameData}
function create_pending_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Updating ...";
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
function create_fragment(ctx) {
let div;
function select_block_type(ctx, dirty) {
if (/*clip_id*/ ctx[0] == null) return create_if_block;
if (/*diff_id*/ ctx[1] == null) return create_if_block_1;
return create_else_block;
}
let current_block_type = select_block_type(ctx, -1);
let if_block = current_block_type(ctx);
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
if_block.c();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "top svelte-1b04bb5");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
if_block.m(div, null);
},
p(ctx, [dirty]) {
if (current_block_type === (current_block_type = select_block_type(ctx, dirty)) && if_block) {
if_block.p(ctx, dirty);
} else {
if_block.d(1);
if_block = current_block_type(ctx);
if (if_block) {
if_block.c();
if_block.m(div, null);
}
}
},
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
if_block.d();
}
};
}
function instance($$self, $$props, $$invalidate) {
let lengthPromise;
let frameDataPromiseLeft;
let frameDataPromiseRight;
let { rpc } = $$props;
let { frame } = $$props;
let { clip_id } = $$props;
let { diff_id } = $$props;
let diffDLIcon, clipDLIcon;
async function download(type) {
const rawFrame = await rpc.frame({ frame, image: type });
const blob = URL.createObjectURL(new Blob([rawFrame.buffers[0]], { type: 'image/png' }));
const a = document.createElement("a");
document.body.append(a);
a.href = blob;
a.download = `Image-${type}-${frame}.png`;
a.click();
await (0,svelte__WEBPACK_IMPORTED_MODULE_2__.tick)();
URL.revokeObjectURL(blob);
a.remove();
}
const click_handler = ty => () => download(ty);
function button_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
clipDLIcon = $$value;
$$invalidate(3, clipDLIcon);
});
}
const click_handler_1 = ty => () => download(ty);
function button0_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
clipDLIcon = $$value;
$$invalidate(3, clipDLIcon);
});
}
const click_handler_2 = ty => () => download(ty);
function button1_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
diffDLIcon = $$value;
$$invalidate(2, diffDLIcon);
});
}
$$self.$$set = $$props => {
if ('rpc' in $$props) $$invalidate(8, rpc = $$props.rpc);
if ('frame' in $$props) $$invalidate(9, frame = $$props.frame);
if ('clip_id' in $$props) $$invalidate(0, clip_id = $$props.clip_id);
if ('diff_id' in $$props) $$invalidate(1, diff_id = $$props.diff_id);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*diff_id, clip_id, rpc*/ 259) {
$: $$invalidate(6, lengthPromise = [diff_id, clip_id, rpc.length()][2]);
}
if ($$self.$$.dirty & /*diff_id, clip_id, rpc, frame*/ 771) {
$: $$invalidate(5, frameDataPromiseLeft = [diff_id, clip_id, rpc.frame({ frame })][2]);
}
if ($$self.$$.dirty & /*diff_id, clip_id, rpc, frame*/ 771) {
$: $$invalidate(4, frameDataPromiseRight = [diff_id, clip_id, rpc.frame({ frame, image: "diff" })][2]);
}
if ($$self.$$.dirty & /*diffDLIcon, clipDLIcon*/ 12) {
$: [diffDLIcon, clipDLIcon].forEach(e => {
if (!!e) _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__.downloadIcon.element({
container: e,
width: '16px',
height: '16px',
marginLeft: '2px'
});
});
}
};
return [
clip_id,
diff_id,
diffDLIcon,
clipDLIcon,
frameDataPromiseRight,
frameDataPromiseLeft,
lengthPromise,
download,
rpc,
frame,
click_handler,
button_binding,
click_handler_1,
button0_binding,
click_handler_2,
button1_binding
];
}
class Header extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { rpc: 8, frame: 9, clip_id: 0, diff_id: 1 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Header);
/***/ }),
/***/ "./lib/widgets/preview/Image.svelte":
/*!******************************************!*\
!*** ./lib/widgets/preview/Image.svelte ***!
\******************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* lib/widgets/preview/Image.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-30pkt", "img.zoomed.svelte-30pkt{image-rendering:pixelated}");
}
function create_fragment(ctx) {
let img;
let img_src_value;
let img_alt_value;
let img_width_value;
let img_height_value;
let img_class_value;
return {
c() {
img = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("img");
if (!(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.src_url_equal)(img.src, img_src_value = /*currentImageURL*/ ctx[1])) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "src", img_src_value);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "alt", img_alt_value = "Frame: " + /*frame*/ ctx[0]);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "width", img_width_value = "" + (/*size*/ ctx[3][0] + "px"));
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "height", img_height_value = "" + (/*size*/ ctx[3][1] + "px"));
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "class", img_class_value = "" + ((0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.null_to_empty)(/*extraZoomClass*/ ctx[2]) + " svelte-30pkt"));
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, img, anchor);
},
p(ctx, [dirty]) {
if (dirty & /*currentImageURL*/ 2 && !(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.src_url_equal)(img.src, img_src_value = /*currentImageURL*/ ctx[1])) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "src", img_src_value);
}
if (dirty & /*frame*/ 1 && img_alt_value !== (img_alt_value = "Frame: " + /*frame*/ ctx[0])) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "alt", img_alt_value);
}
if (dirty & /*size*/ 8 && img_width_value !== (img_width_value = "" + (/*size*/ ctx[3][0] + "px"))) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "width", img_width_value);
}
if (dirty & /*size*/ 8 && img_height_value !== (img_height_value = "" + (/*size*/ ctx[3][1] + "px"))) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "height", img_height_value);
}
if (dirty & /*extraZoomClass*/ 4 && img_class_value !== (img_class_value = "" + ((0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.null_to_empty)(/*extraZoomClass*/ ctx[2]) + " svelte-30pkt"))) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(img, "class", img_class_value);
}
},
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(img);
}
};
}
function scaleSize(sz, factor) {
return [
Math.max(1, Math.floor(sz[0] * factor)),
Math.max(1, Math.floor(sz[1] * factor))
];
}
function instance($$self, $$props, $$invalidate) {
let zoomFactor;
let size;
let extraZoomClass;
let { rpc } = $$props;
let { frame } = $$props;
let { type = "clip" } = $$props;
let { zoom = 1 } = $$props;
let currentSize = [1, 1];
let currentImageURL = null;
let nextRequestFrame = null;
let currentPromise = null;
let pixelRatio = window.devicePixelRatio;
let pixelRatioInterval = setInterval(1000, () => {
$$invalidate(8, pixelRatio = window.devicePixelRatio);
});
function updateByFrameNo() {
nextRequestFrame = frame;
requestNext();
}
function requestNext() {
if (currentPromise !== null) return;
const currentFrame = nextRequestFrame;
currentPromise = rpc.frame({ frame, image: type });
currentPromise.then(() => {
currentPromise = null;
if (nextRequestFrame === currentFrame) return;
requestNext();
});
currentPromise.then(({ size, buffers }) => {
destroyExistingBlob();
$$invalidate(1, currentImageURL = URL.createObjectURL(new Blob([buffers[0]], { type: "application/json" })));
$$invalidate(7, currentSize = size);
});
currentPromise.catch(console.error);
}
function destroyExistingBlob() {
if (currentImageURL !== null) {
URL.revokeObjectURL(currentImageURL);
$$invalidate(1, currentImageURL = null);
}
}
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onDestroy)(() => {
destroyExistingBlob();
clearInterval(pixelRatioInterval);
});
$$self.$$set = $$props => {
if ('rpc' in $$props) $$invalidate(4, rpc = $$props.rpc);
if ('frame' in $$props) $$invalidate(0, frame = $$props.frame);
if ('type' in $$props) $$invalidate(5, type = $$props.type);
if ('zoom' in $$props) $$invalidate(6, zoom = $$props.zoom);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*frame*/ 1) {
$: updateByFrameNo(frame);
}
if ($$self.$$.dirty & /*zoom, pixelRatio*/ 320) {
$: $$invalidate(9, zoomFactor = zoom / pixelRatio);
}
if ($$self.$$.dirty & /*currentSize, zoomFactor*/ 640) {
$: $$invalidate(3, size = scaleSize(currentSize, zoomFactor));
}
if ($$self.$$.dirty & /*zoom*/ 64) {
$: $$invalidate(2, extraZoomClass = zoom != 1 ? "zoomed" : "");
}
};
return [
frame,
currentImageURL,
extraZoomClass,
size,
rpc,
type,
zoom,
currentSize,
pixelRatio,
zoomFactor
];
}
class Image extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { rpc: 4, frame: 0, type: 5, zoom: 6 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Image);
/***/ }),
/***/ "./lib/widgets/preview/JupyterSelect.svelte":
/*!**************************************************!*\
!*** ./lib/widgets/preview/JupyterSelect.svelte ***!
\**************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @jupyterlab/ui-components */ "webpack/sharing/consume/default/@jupyterlab/ui-components");
/* harmony import */ var _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__);
/* lib/widgets/preview/JupyterSelect.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1gk8783", ".yuuno-fake.svelte-1gk8783{display:flex}");
}
function create_fragment(ctx) {
let div;
let select;
let t;
let span;
let current;
let mounted;
let dispose;
const default_slot_template = /*#slots*/ ctx[4].default;
const default_slot = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_slot)(default_slot_template, ctx, /*$$scope*/ ctx[3], null);
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
select = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("select");
if (default_slot) default_slot.c();
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
span = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("span");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(select, "title", /*title*/ ctx[1]);
if (/*value*/ ctx[0] === void 0) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_render_callback)(() => /*select_change_handler*/ ctx[5].call(select));
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "jp-HTMLSelect jp-DefaultStyle jp-Notebook-toolbarCellTypeDropdown yuuno-fake svelte-1gk8783");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, select);
if (default_slot) {
default_slot.m(select, null);
}
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.select_option)(select, /*value*/ ctx[0]);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, t);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div, span);
/*span_binding*/ ctx[6](span);
current = true;
if (!mounted) {
dispose = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(select, "change", /*select_change_handler*/ ctx[5]);
mounted = true;
}
},
p(ctx, [dirty]) {
if (default_slot) {
if (default_slot.p && (!current || dirty & /*$$scope*/ 8)) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_slot_base)(
default_slot,
default_slot_template,
ctx,
/*$$scope*/ ctx[3],
!current
? (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.get_all_dirty_from_scope)(/*$$scope*/ ctx[3])
: (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.get_slot_changes)(default_slot_template, /*$$scope*/ ctx[3], dirty, null),
null
);
}
}
if (!current || dirty & /*title*/ 2) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(select, "title", /*title*/ ctx[1]);
}
if (dirty & /*value*/ 1) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.select_option)(select, /*value*/ ctx[0]);
}
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(default_slot, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(default_slot, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
if (default_slot) default_slot.d(detaching);
/*span_binding*/ ctx[6](null);
mounted = false;
dispose();
}
};
}
function instance($$self, $$props, $$invalidate) {
let { $$slots: slots = {}, $$scope } = $$props;
let { title = "" } = $$props;
let { value } = $$props;
let iconTarget;
function select_change_handler() {
value = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.select_value)(this);
$$invalidate(0, value);
}
function span_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
iconTarget = $$value;
$$invalidate(2, iconTarget);
});
}
$$self.$$set = $$props => {
if ('title' in $$props) $$invalidate(1, title = $$props.title);
if ('value' in $$props) $$invalidate(0, value = $$props.value);
if ('$$scope' in $$props) $$invalidate(3, $$scope = $$props.$$scope);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*iconTarget*/ 4) {
$: _jupyterlab_ui_components__WEBPACK_IMPORTED_MODULE_1__.caretDownEmptyIcon.element({
container: iconTarget,
width: '16px',
height: '16px',
marginLeft: '2px'
});
}
};
return [value, title, iconTarget, $$scope, slots, select_change_handler, span_binding];
}
class JupyterSelect extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { title: 1, value: 0 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (JupyterSelect);
/***/ }),
/***/ "./lib/widgets/preview/LineSlider.svelte":
/*!***********************************************!*\
!*** ./lib/widgets/preview/LineSlider.svelte ***!
\***********************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* lib/widgets/preview/LineSlider.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-kk8zs1", ".line-slider.svelte-kk8zs1.svelte-kk8zs1{position:relative;width:100%;height:100%;display:block;border-left:var(--jp-border-width) solid var(--jp-cell-editor-border-color);border-right:var(--jp-border-width) solid var(--jp-cell-editor-border-color)}.line-slider.svelte-kk8zs1>.svelte-kk8zs1{position:absolute;height:20%;bottom:0}.past.svelte-kk8zs1.svelte-kk8zs1{left:0;background-color:var(--jp-brand-color1)}.future.svelte-kk8zs1.svelte-kk8zs1{right:0;background-color:var(--jp-cell-editor-border-color)}.select.svelte-kk8zs1.svelte-kk8zs1,.proposed.svelte-kk8zs1.svelte-kk8zs1{height:100%;top:0;width:var(--jp-border-width);background-color:var(--jp-brand-color1)}");
}
// (5:4) {:else}
function create_else_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "proposed svelte-kk8zs1");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*proposedPerc*/ ctx[1] * 100 + "%");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p(ctx, dirty) {
if (dirty & /*proposedPerc*/ 2) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*proposedPerc*/ ctx[1] * 100 + "%");
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
// (3:4) {#if proposedValue === null}
function create_if_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "select svelte-kk8zs1");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*percPast*/ ctx[2] * 100 + "%");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p(ctx, dirty) {
if (dirty & /*percPast*/ 4) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div, "left", /*percPast*/ ctx[2] * 100 + "%");
}
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
function create_fragment(ctx) {
let div2;
let div0;
let t0;
let t1;
let div1;
let mounted;
let dispose;
function select_block_type(ctx, dirty) {
if (/*proposedValue*/ ctx[0] === null) return create_if_block;
return create_else_block;
}
let current_block_type = select_block_type(ctx, -1);
let if_block = current_block_type(ctx);
return {
c() {
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
if_block.c();
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "past svelte-kk8zs1");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div0, "width", /*percPast*/ ctx[2] * 100 + "%");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "future svelte-kk8zs1");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div1, "width", /*percFuture*/ ctx[4] * 100 + "%");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "line-slider svelte-kk8zs1");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div2, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, div0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, t0);
if_block.m(div2, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div2, div1);
/*div2_binding*/ ctx[13](div2);
if (!mounted) {
dispose = [
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "mouseenter", /*enter*/ ctx[5]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "mouseleave", /*leave*/ ctx[6]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "mousemove", /*move*/ ctx[7]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div2, "click", /*submit*/ ctx[8])
];
mounted = true;
}
},
p(ctx, [dirty]) {
if (dirty & /*percPast*/ 4) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div0, "width", /*percPast*/ ctx[2] * 100 + "%");
}
if (current_block_type === (current_block_type = select_block_type(ctx, dirty)) && if_block) {
if_block.p(ctx, dirty);
} else {
if_block.d(1);
if_block = current_block_type(ctx);
if (if_block) {
if_block.c();
if_block.m(div2, t1);
}
}
if (dirty & /*percFuture*/ 16) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.set_style)(div1, "width", /*percFuture*/ ctx[4] * 100 + "%");
}
},
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div2);
if_block.d();
/*div2_binding*/ ctx[13](null);
mounted = false;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.run_all)(dispose);
}
};
}
function instance($$self, $$props, $$invalidate) {
let span;
let percPast;
let percFuture;
let { value = 0 } = $$props;
let { max = 100 } = $$props;
let { min = 0 } = $$props;
let { proposedValue = null } = $$props;
let { proposedPerc = null } = $$props;
let myself;
function enter(event) {
$$invalidate(0, proposedValue = min);
move(event);
}
function leave() {
$$invalidate(0, proposedValue = null);
}
function move(event) {
const { pageX, pageY } = event;
const { left, top, right } = myself.getBoundingClientRect();
const width = right - left;
const vX = pageX - left;
$$invalidate(1, proposedPerc = vX / width);
const rawProposal = proposedPerc * span + min;
$$invalidate(0, proposedValue = Math.round(rawProposal));
}
function submit() {
$$invalidate(9, value = proposedValue);
}
function div2_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
myself = $$value;
$$invalidate(3, myself);
});
}
$$self.$$set = $$props => {
if ('value' in $$props) $$invalidate(9, value = $$props.value);
if ('max' in $$props) $$invalidate(10, max = $$props.max);
if ('min' in $$props) $$invalidate(11, min = $$props.min);
if ('proposedValue' in $$props) $$invalidate(0, proposedValue = $$props.proposedValue);
if ('proposedPerc' in $$props) $$invalidate(1, proposedPerc = $$props.proposedPerc);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*max, min*/ 3072) {
$: $$invalidate(12, span = max - min);
}
if ($$self.$$.dirty & /*value, min, span*/ 6656) {
$: $$invalidate(2, percPast = (value - min) / span);
}
if ($$self.$$.dirty & /*percPast*/ 4) {
$: $$invalidate(4, percFuture = 1 - percPast);
}
};
return [
proposedValue,
proposedPerc,
percPast,
myself,
percFuture,
enter,
leave,
move,
submit,
value,
max,
min,
span,
div2_binding
];
}
class LineSlider extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(
this,
options,
instance,
create_fragment,
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal,
{
value: 9,
max: 10,
min: 11,
proposedValue: 0,
proposedPerc: 1
},
add_css
);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (LineSlider);
/***/ }),
/***/ "./lib/widgets/preview/Viewport.svelte":
/*!*********************************************!*\
!*** ./lib/widgets/preview/Viewport.svelte ***!
\*********************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _Image_svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Image.svelte */ "./lib/widgets/preview/Image.svelte");
/* lib/widgets/preview/Viewport.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-19n1gk", ".viewport.svelte-19n1gk.svelte-19n1gk{display:flex;flex-grow:1;flex-shrink:1;background-image:linear-gradient(45deg, #808080 25%, transparent 25%),\n linear-gradient(-45deg, #808080 25%, transparent 25%),\n linear-gradient(45deg, transparent 75%, #808080 75%),\n linear-gradient(-45deg, transparent 75%, #808080 75%);background-size:20px 20px;background-position:0 0, 0 10px, 10px -10px, -10px 0px;overflow:auto}.zero-sizer.svelte-19n1gk.svelte-19n1gk{position:relative;width:0;height:0}.zero-sizer.svelte-19n1gk>.item.svelte-19n1gk{position:absolute;top:0;left:0}.item.main.svelte-19n1gk.svelte-19n1gk,.item.diff.svelte-19n1gk.svelte-19n1gk{display:none}.main.svelte-19n1gk>.item.main.svelte-19n1gk{display:block}.diff.svelte-19n1gk>.item.diff.svelte-19n1gk{display:block}");
}
// (3:8) {#if clip_id !== null}
function create_if_block_1(ctx) {
let div;
let image;
let current;
image = new _Image_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]({
props: {
rpc: /*rpc*/ ctx[0],
frame: /*frame*/ ctx[1],
zoom: /*zoom*/ ctx[2],
type: "clip"
}
});
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(image.$$.fragment);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "item main svelte-19n1gk");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(image, div, null);
current = true;
},
p(ctx, dirty) {
const image_changes = {};
if (dirty & /*rpc*/ 1) image_changes.rpc = /*rpc*/ ctx[0];
if (dirty & /*frame*/ 2) image_changes.frame = /*frame*/ ctx[1];
if (dirty & /*zoom*/ 4) image_changes.zoom = /*zoom*/ ctx[2];
image.$set(image_changes);
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(image.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(image.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(image);
}
};
}
// (9:8) {#if diff_id !== null}
function create_if_block(ctx) {
let div;
let image;
let current;
image = new _Image_svelte__WEBPACK_IMPORTED_MODULE_1__["default"]({
props: {
rpc: /*rpc*/ ctx[0],
frame: /*frame*/ ctx[1],
zoom: /*zoom*/ ctx[2],
type: "diff"
}
});
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(image.$$.fragment);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div, "class", "item diff svelte-19n1gk");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(image, div, null);
current = true;
},
p(ctx, dirty) {
const image_changes = {};
if (dirty & /*rpc*/ 1) image_changes.rpc = /*rpc*/ ctx[0];
if (dirty & /*frame*/ 2) image_changes.frame = /*frame*/ ctx[1];
if (dirty & /*zoom*/ 4) image_changes.zoom = /*zoom*/ ctx[2];
image.$set(image_changes);
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(image.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(image.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(image);
}
};
}
function create_fragment(ctx) {
let div1;
let div0;
let t;
let div0_class_value;
let current;
let mounted;
let dispose;
let if_block0 = /*clip_id*/ ctx[3] !== null && create_if_block_1(ctx);
let if_block1 = /*diff_id*/ ctx[4] !== null && create_if_block(ctx);
return {
c() {
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
if (if_block0) if_block0.c();
t = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
if (if_block1) if_block1.c();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", div0_class_value = "zero-sizer " + /*mode*/ ctx[6] + " svelte-19n1gk");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "viewport svelte-19n1gk");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div1, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div1, div0);
if (if_block0) if_block0.m(div0, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div0, t);
if (if_block1) if_block1.m(div0, null);
/*div1_binding*/ ctx[16](div1);
current = true;
if (!mounted) {
dispose = [
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div1, "mouseenter", /*enter*/ ctx[7]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div1, "mouseleave", /*leave*/ ctx[8]),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div1, "mousedown", (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.stop_propagation)((0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.prevent_default)(/*down*/ ctx[9])), true),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div1, "mouseup", (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.stop_propagation)((0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.prevent_default)(/*up*/ ctx[10])), true),
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.listen)(div1, "mousemove", /*move*/ ctx[11])
];
mounted = true;
}
},
p(ctx, [dirty]) {
if (/*clip_id*/ ctx[3] !== null) {
if (if_block0) {
if_block0.p(ctx, dirty);
if (dirty & /*clip_id*/ 8) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(if_block0, 1);
}
} else {
if_block0 = create_if_block_1(ctx);
if_block0.c();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(if_block0, 1);
if_block0.m(div0, t);
}
} else if (if_block0) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.group_outros)();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(if_block0, 1, 1, () => {
if_block0 = null;
});
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.check_outros)();
}
if (/*diff_id*/ ctx[4] !== null) {
if (if_block1) {
if_block1.p(ctx, dirty);
if (dirty & /*diff_id*/ 16) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(if_block1, 1);
}
} else {
if_block1 = create_if_block(ctx);
if_block1.c();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(if_block1, 1);
if_block1.m(div0, null);
}
} else if (if_block1) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.group_outros)();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(if_block1, 1, 1, () => {
if_block1 = null;
});
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.check_outros)();
}
if (!current || dirty & /*mode*/ 64 && div0_class_value !== (div0_class_value = "zero-sizer " + /*mode*/ ctx[6] + " svelte-19n1gk")) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", div0_class_value);
}
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(if_block0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(if_block1);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(if_block0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(if_block1);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div1);
if (if_block0) if_block0.d();
if (if_block1) if_block1.d();
/*div1_binding*/ ctx[16](null);
mounted = false;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.run_all)(dispose);
}
};
}
function instance($$self, $$props, $$invalidate) {
let single_clip;
let single_clip_mode;
let multi_clip_mode;
let mode;
let { rpc } = $$props;
let { frame } = $$props;
let { zoom = 1 } = $$props;
let { clip_id, diff_id } = $$props;
let myself;
let entered = false;
function enter() {
$$invalidate(12, entered = true);
}
function leave() {
$$invalidate(12, entered = false);
}
let panning = null;
function down(event) {
panning = [event.screenX, event.screenY, myself.scrollLeft, myself.scrollTop];
}
function up() {
panning = null;
}
function move(event) {
if (panning === null) return;
const { screenX, screenY } = event;
const [startX, startY, scrollLeft, scrollTop] = panning;
const dX = startX - screenX;
const dY = startY - screenY;
$$invalidate(5, myself.scrollLeft = scrollLeft + dX, myself);
$$invalidate(5, myself.scrollTop = scrollTop + dY, myself);
}
function div1_binding($$value) {
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks[$$value ? 'unshift' : 'push'](() => {
myself = $$value;
$$invalidate(5, myself);
});
}
$$self.$$set = $$props => {
if ('rpc' in $$props) $$invalidate(0, rpc = $$props.rpc);
if ('frame' in $$props) $$invalidate(1, frame = $$props.frame);
if ('zoom' in $$props) $$invalidate(2, zoom = $$props.zoom);
if ('clip_id' in $$props) $$invalidate(3, clip_id = $$props.clip_id);
if ('diff_id' in $$props) $$invalidate(4, diff_id = $$props.diff_id);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*clip_id, diff_id*/ 24) {
$: $$invalidate(15, single_clip = clip_id === null != (diff_id === null));
}
if ($$self.$$.dirty & /*clip_id*/ 8) {
$: $$invalidate(14, single_clip_mode = clip_id !== null ? "main" : "diff");
}
if ($$self.$$.dirty & /*entered*/ 4096) {
$: $$invalidate(13, multi_clip_mode = entered ? "diff" : "main");
}
if ($$self.$$.dirty & /*single_clip, single_clip_mode, multi_clip_mode*/ 57344) {
$: $$invalidate(6, mode = single_clip ? single_clip_mode : multi_clip_mode);
}
};
return [
rpc,
frame,
zoom,
clip_id,
diff_id,
myself,
mode,
enter,
leave,
down,
up,
move,
entered,
multi_clip_mode,
single_clip_mode,
single_clip,
div1_binding
];
}
class Viewport extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(
this,
options,
instance,
create_fragment,
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal,
{
rpc: 0,
frame: 1,
zoom: 2,
clip_id: 3,
diff_id: 4
},
add_css
);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Viewport);
/***/ }),
/***/ "./lib/widgets/preview/Widget.svelte":
/*!*******************************************!*\
!*** ./lib/widgets/preview/Widget.svelte ***!
\*******************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var svelte_internal__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! svelte/internal */ "./node_modules/svelte/internal/index.mjs");
/* harmony import */ var _Header_svelte__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Header.svelte */ "./lib/widgets/preview/Header.svelte");
/* harmony import */ var _Viewport_svelte__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Viewport.svelte */ "./lib/widgets/preview/Viewport.svelte");
/* harmony import */ var _Footer_svelte__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./Footer.svelte */ "./lib/widgets/preview/Footer.svelte");
/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ../../utils */ "./lib/utils.js");
/* harmony import */ var _rpc__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./rpc */ "./lib/widgets/preview/rpc.js");
/* harmony import */ var svelte__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! svelte */ "./node_modules/svelte/index.mjs");
/* lib/widgets/preview/Widget.svelte generated by Svelte v3.44.3 */
function add_css(target) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append_styles)(target, "svelte-1nz724k", ".preview.svelte-1nz724k.svelte-1nz724k{border:var(--jp-border-width) solid var(--jp-cell-editor-border-color);border-radius:0px;background:var(--jp-cell-editor-background);display:flex;flex-direction:column}.preview.svelte-1nz724k>.svelte-1nz724k{width:100%}.viewport.svelte-1nz724k.svelte-1nz724k{min-height:640px;flex-grow:1;flex-shrink:1;display:flex;flex-direction:column}");
}
// (1:0) {#await currentPreview}
function create_catch_block(ctx) {
return {
c: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
m: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop
};
}
// (4:0) {:then length}
function create_then_block(ctx) {
let div3;
let div0;
let header;
let t0;
let div1;
let viewport;
let t1;
let div2;
let footer;
let updating_frame;
let updating_zoom;
let current;
header = new _Header_svelte__WEBPACK_IMPORTED_MODULE_2__["default"]({
props: {
clip_id: /*$clip_id*/ ctx[1],
diff_id: /*$diff_id*/ ctx[0],
rpc: /*preview*/ ctx[9],
frame: /*$frame*/ ctx[3]
}
});
viewport = new _Viewport_svelte__WEBPACK_IMPORTED_MODULE_3__["default"]({
props: {
clip_id: /*$clip_id*/ ctx[1],
diff_id: /*$diff_id*/ ctx[0],
rpc: /*preview*/ ctx[9],
frame: /*$frame*/ ctx[3],
zoom: /*$zoom*/ ctx[4]
}
});
function footer_frame_binding(value) {
/*footer_frame_binding*/ ctx[11](value);
}
function footer_zoom_binding(value) {
/*footer_zoom_binding*/ ctx[12](value);
}
let footer_props = { length: /*length*/ ctx[14].length };
if (/*$frame*/ ctx[3] !== void 0) {
footer_props.frame = /*$frame*/ ctx[3];
}
if (/*$zoom*/ ctx[4] !== void 0) {
footer_props.zoom = /*$zoom*/ ctx[4];
}
footer = new _Footer_svelte__WEBPACK_IMPORTED_MODULE_4__["default"]({ props: footer_props });
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(footer, 'frame', footer_frame_binding));
svelte_internal__WEBPACK_IMPORTED_MODULE_0__.binding_callbacks.push(() => (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.bind)(footer, 'zoom', footer_zoom_binding));
return {
c() {
div3 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(header.$$.fragment);
t0 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(viewport.$$.fragment);
t1 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.space)();
div2 = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.create_component)(footer.$$.fragment);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div0, "class", "header svelte-1nz724k");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div1, "class", "viewport svelte-1nz724k");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div2, "class", "footer svelte-1nz724k");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.attr)(div3, "class", "preview svelte-1nz724k");
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div3, anchor);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(header, div0, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t0);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(viewport, div1, null);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, t1);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.append)(div3, div2);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.mount_component)(footer, div2, null);
current = true;
},
p(ctx, dirty) {
const header_changes = {};
if (dirty & /*$clip_id*/ 2) header_changes.clip_id = /*$clip_id*/ ctx[1];
if (dirty & /*$diff_id*/ 1) header_changes.diff_id = /*$diff_id*/ ctx[0];
if (dirty & /*$frame*/ 8) header_changes.frame = /*$frame*/ ctx[3];
header.$set(header_changes);
const viewport_changes = {};
if (dirty & /*$clip_id*/ 2) viewport_changes.clip_id = /*$clip_id*/ ctx[1];
if (dirty & /*$diff_id*/ 1) viewport_changes.diff_id = /*$diff_id*/ ctx[0];
if (dirty & /*$frame*/ 8) viewport_changes.frame = /*$frame*/ ctx[3];
if (dirty & /*$zoom*/ 16) viewport_changes.zoom = /*$zoom*/ ctx[4];
viewport.$set(viewport_changes);
const footer_changes = {};
if (dirty & /*currentPreview*/ 4) footer_changes.length = /*length*/ ctx[14].length;
if (!updating_frame && dirty & /*$frame*/ 8) {
updating_frame = true;
footer_changes.frame = /*$frame*/ ctx[3];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_frame = false);
}
if (!updating_zoom && dirty & /*$zoom*/ 16) {
updating_zoom = true;
footer_changes.zoom = /*$zoom*/ ctx[4];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.add_flush_callback)(() => updating_zoom = false);
}
footer.$set(footer_changes);
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(header.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(viewport.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(footer.$$.fragment, local);
current = true;
},
o(local) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(header.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(viewport.$$.fragment, local);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(footer.$$.fragment, local);
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div3);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(header);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(viewport);
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.destroy_component)(footer);
}
};
}
// (2:23) <div>Loading ...</div> {:then length}
function create_pending_block(ctx) {
let div;
return {
c() {
div = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.element)("div");
div.textContent = "Loading ...";
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, div, anchor);
},
p: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
i: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
o: svelte_internal__WEBPACK_IMPORTED_MODULE_0__.noop,
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(div);
}
};
}
function create_fragment(ctx) {
let await_block_anchor;
let promise;
let current;
let info = {
ctx,
current: null,
token: null,
hasCatch: false,
pending: create_pending_block,
then: create_then_block,
catch: create_catch_block,
value: 14,
blocks: [,,,]
};
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise = /*currentPreview*/ ctx[2], info);
return {
c() {
await_block_anchor = (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.empty)();
info.block.c();
},
m(target, anchor) {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.insert)(target, await_block_anchor, anchor);
info.block.m(target, info.anchor = anchor);
info.mount = () => await_block_anchor.parentNode;
info.anchor = await_block_anchor;
current = true;
},
p(new_ctx, [dirty]) {
ctx = new_ctx;
info.ctx = ctx;
if (dirty & /*currentPreview*/ 4 && promise !== (promise = /*currentPreview*/ ctx[2]) && (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.handle_promise)(promise, info)) {
} else {
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.update_await_block_branch)(info, ctx, dirty);
}
},
i(local) {
if (current) return;
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_in)(info.block);
current = true;
},
o(local) {
for (let i = 0; i < 3; i += 1) {
const block = info.blocks[i];
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.transition_out)(block);
}
current = false;
},
d(detaching) {
if (detaching) (0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.detach)(await_block_anchor);
info.block.d(detaching);
info.token = null;
info = null;
}
};
}
function instance($$self, $$props, $$invalidate) {
let currentPreview;
let $diff_id;
let $clip_id;
let $frame;
let $zoom;
let { component } = $$props;
const frame = (0,_utils__WEBPACK_IMPORTED_MODULE_5__.model_attribute)(component, "frame");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, frame, value => $$invalidate(3, $frame = value));
const zoom = (0,_utils__WEBPACK_IMPORTED_MODULE_5__.model_attribute)(component, "zoom");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, zoom, value => $$invalidate(4, $zoom = value));
const clip_id = (0,_utils__WEBPACK_IMPORTED_MODULE_5__.model_attribute)(component, "clip");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, clip_id, value => $$invalidate(1, $clip_id = value));
const diff_id = (0,_utils__WEBPACK_IMPORTED_MODULE_5__.model_attribute)(component, "diff");
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.component_subscribe)($$self, diff_id, value => $$invalidate(0, $diff_id = value));
const debouncedFrame = (0,_utils__WEBPACK_IMPORTED_MODULE_5__.debounce)(100, frame);
const preview = (0,_rpc__WEBPACK_IMPORTED_MODULE_6__.getRPCForModel)(component);
preview.open();
(0,svelte__WEBPACK_IMPORTED_MODULE_1__.onDestroy)(() => preview.close());
function footer_frame_binding(value) {
$frame = value;
frame.set($frame);
}
function footer_zoom_binding(value) {
$zoom = value;
zoom.set($zoom);
}
$$self.$$set = $$props => {
if ('component' in $$props) $$invalidate(10, component = $$props.component);
};
$$self.$$.update = () => {
if ($$self.$$.dirty & /*$clip_id, $diff_id*/ 3) {
$: $$invalidate(2, currentPreview = [$clip_id, $diff_id, preview.length()][2]);
}
if ($$self.$$.dirty & /*component*/ 1024) {
$: console.log(component);
}
};
return [
$diff_id,
$clip_id,
currentPreview,
$frame,
$zoom,
frame,
zoom,
clip_id,
diff_id,
preview,
component,
footer_frame_binding,
footer_zoom_binding
];
}
class Widget extends svelte_internal__WEBPACK_IMPORTED_MODULE_0__.SvelteComponent {
constructor(options) {
super();
(0,svelte_internal__WEBPACK_IMPORTED_MODULE_0__.init)(this, options, instance, create_fragment, svelte_internal__WEBPACK_IMPORTED_MODULE_0__.safe_not_equal, { component: 10 }, add_css);
}
}
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Widget);
/***/ })
}]);
//# sourceMappingURL=lib_index_js.8261d50cfcdd262765d1.js.map | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_jupyterlab/static/static/lib_index_js.8261d50cfcdd262765d1.js | lib_index_js.8261d50cfcdd262765d1.js |
var _JUPYTERLAB;
/******/ (() => { // webpackBootstrap
/******/ "use strict";
/******/ var __webpack_modules__ = ({
/***/ "webpack/container/entry/@yuuno/jupyterlab":
/*!***********************!*\
!*** container entry ***!
\***********************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
var moduleMap = {
"./index": () => {
return Promise.all([__webpack_require__.e("vendors-node_modules_svelte_index_mjs"), __webpack_require__.e("lib_index_js")]).then(() => (() => ((__webpack_require__(/*! ./lib/index.js */ "./lib/index.js")))));
},
"./extension": () => {
return Promise.all([__webpack_require__.e("vendors-node_modules_svelte_index_mjs"), __webpack_require__.e("lib_index_js")]).then(() => (() => ((__webpack_require__(/*! ./lib/index.js */ "./lib/index.js")))));
},
"./style": () => {
return Promise.all([__webpack_require__.e("vendors-node_modules_css-loader_dist_runtime_api_js-node_modules_css-loader_dist_runtime_cssW-72eba1"), __webpack_require__.e("style_index_js")]).then(() => (() => ((__webpack_require__(/*! ./style/index.js */ "./style/index.js")))));
}
};
var get = (module, getScope) => {
__webpack_require__.R = getScope;
getScope = (
__webpack_require__.o(moduleMap, module)
? moduleMap[module]()
: Promise.resolve().then(() => {
throw new Error('Module "' + module + '" does not exist in container.');
})
);
__webpack_require__.R = undefined;
return getScope;
};
var init = (shareScope, initScope) => {
if (!__webpack_require__.S) return;
var name = "default"
var oldScope = __webpack_require__.S[name];
if(oldScope && oldScope !== shareScope) throw new Error("Container initialization failed as it has already been initialized with a different share scope");
__webpack_require__.S[name] = shareScope;
return __webpack_require__.I(name, initScope);
};
// This exports getters to disallow modifications
__webpack_require__.d(exports, {
get: () => (get),
init: () => (init)
});
/***/ })
/******/ });
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ id: moduleId,
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = __webpack_modules__;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = __webpack_module_cache__;
/******/
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = (module) => {
/******/ var getter = module && module.__esModule ?
/******/ () => (module['default']) :
/******/ () => (module);
/******/ __webpack_require__.d(getter, { a: getter });
/******/ return getter;
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = (exports, definition) => {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/ensure chunk */
/******/ (() => {
/******/ __webpack_require__.f = {};
/******/ // This file contains only the entry chunk.
/******/ // The chunk loading function for additional chunks
/******/ __webpack_require__.e = (chunkId) => {
/******/ return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
/******/ __webpack_require__.f[key](chunkId, promises);
/******/ return promises;
/******/ }, []));
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/get javascript chunk filename */
/******/ (() => {
/******/ // This function allow to reference async chunks
/******/ __webpack_require__.u = (chunkId) => {
/******/ // return url for filenames based on template
/******/ return "" + chunkId + "." + {"vendors-node_modules_svelte_index_mjs":"8c87196f35a3feefaf57","lib_index_js":"8261d50cfcdd262765d1","vendors-node_modules_css-loader_dist_runtime_api_js-node_modules_css-loader_dist_runtime_cssW-72eba1":"1ec5ea217651b461b775","style_index_js":"046a091dd193851c3746","node_modules_xterm-addon-fit_lib_xterm-addon-fit_js":"d5085c68658a9a02c319","vendors-node_modules_xterm_lib_xterm_js":"ce6747742315951ea661"}[chunkId] + ".js";
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/global */
/******/ (() => {
/******/ __webpack_require__.g = (function() {
/******/ if (typeof globalThis === 'object') return globalThis;
/******/ try {
/******/ return this || new Function('return this')();
/******/ } catch (e) {
/******/ if (typeof window === 'object') return window;
/******/ }
/******/ })();
/******/ })();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/
/******/ /* webpack/runtime/load script */
/******/ (() => {
/******/ var inProgress = {};
/******/ var dataWebpackPrefix = "@yuuno/jupyterlab:";
/******/ // loadScript function to load a script via script tag
/******/ __webpack_require__.l = (url, done, key, chunkId) => {
/******/ if(inProgress[url]) { inProgress[url].push(done); return; }
/******/ var script, needAttach;
/******/ if(key !== undefined) {
/******/ var scripts = document.getElementsByTagName("script");
/******/ for(var i = 0; i < scripts.length; i++) {
/******/ var s = scripts[i];
/******/ if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
/******/ }
/******/ }
/******/ if(!script) {
/******/ needAttach = true;
/******/ script = document.createElement('script');
/******/
/******/ script.charset = 'utf-8';
/******/ script.timeout = 120;
/******/ if (__webpack_require__.nc) {
/******/ script.setAttribute("nonce", __webpack_require__.nc);
/******/ }
/******/ script.setAttribute("data-webpack", dataWebpackPrefix + key);
/******/ script.src = url;
/******/ }
/******/ inProgress[url] = [done];
/******/ var onScriptComplete = (prev, event) => {
/******/ // avoid mem leaks in IE.
/******/ script.onerror = script.onload = null;
/******/ clearTimeout(timeout);
/******/ var doneFns = inProgress[url];
/******/ delete inProgress[url];
/******/ script.parentNode && script.parentNode.removeChild(script);
/******/ doneFns && doneFns.forEach((fn) => (fn(event)));
/******/ if(prev) return prev(event);
/******/ }
/******/ ;
/******/ var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
/******/ script.onerror = onScriptComplete.bind(null, script.onerror);
/******/ script.onload = onScriptComplete.bind(null, script.onload);
/******/ needAttach && document.head.appendChild(script);
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/make namespace object */
/******/ (() => {
/******/ // define __esModule on exports
/******/ __webpack_require__.r = (exports) => {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/sharing */
/******/ (() => {
/******/ __webpack_require__.S = {};
/******/ var initPromises = {};
/******/ var initTokens = {};
/******/ __webpack_require__.I = (name, initScope) => {
/******/ if(!initScope) initScope = [];
/******/ // handling circular init calls
/******/ var initToken = initTokens[name];
/******/ if(!initToken) initToken = initTokens[name] = {};
/******/ if(initScope.indexOf(initToken) >= 0) return;
/******/ initScope.push(initToken);
/******/ // only runs once
/******/ if(initPromises[name]) return initPromises[name];
/******/ // creates a new share scope if needed
/******/ if(!__webpack_require__.o(__webpack_require__.S, name)) __webpack_require__.S[name] = {};
/******/ // runs all init snippets from all modules reachable
/******/ var scope = __webpack_require__.S[name];
/******/ var warn = (msg) => (typeof console !== "undefined" && console.warn && console.warn(msg));
/******/ var uniqueName = "@yuuno/jupyterlab";
/******/ var register = (name, version, factory, eager) => {
/******/ var versions = scope[name] = scope[name] || {};
/******/ var activeVersion = versions[version];
/******/ if(!activeVersion || (!activeVersion.loaded && (!eager != !activeVersion.eager ? eager : uniqueName > activeVersion.from))) versions[version] = { get: factory, from: uniqueName, eager: !!eager };
/******/ };
/******/ var initExternal = (id) => {
/******/ var handleError = (err) => (warn("Initialization of sharing external failed: " + err));
/******/ try {
/******/ var module = __webpack_require__(id);
/******/ if(!module) return;
/******/ var initFn = (module) => (module && module.init && module.init(__webpack_require__.S[name], initScope))
/******/ if(module.then) return promises.push(module.then(initFn, handleError));
/******/ var initResult = initFn(module);
/******/ if(initResult && initResult.then) return promises.push(initResult['catch'](handleError));
/******/ } catch(err) { handleError(err); }
/******/ }
/******/ var promises = [];
/******/ switch(name) {
/******/ case "default": {
/******/ register("@yuuno/jupyterlab", "1.4.0", () => (Promise.all([__webpack_require__.e("vendors-node_modules_svelte_index_mjs"), __webpack_require__.e("lib_index_js")]).then(() => (() => (__webpack_require__(/*! ./lib/index.js */ "./lib/index.js"))))));
/******/ register("xterm-addon-fit", "0.5.0", () => (__webpack_require__.e("node_modules_xterm-addon-fit_lib_xterm-addon-fit_js").then(() => (() => (__webpack_require__(/*! ./node_modules/xterm-addon-fit/lib/xterm-addon-fit.js */ "./node_modules/xterm-addon-fit/lib/xterm-addon-fit.js"))))));
/******/ register("xterm", "4.16.0", () => (__webpack_require__.e("vendors-node_modules_xterm_lib_xterm_js").then(() => (() => (__webpack_require__(/*! ./node_modules/xterm/lib/xterm.js */ "./node_modules/xterm/lib/xterm.js"))))));
/******/ }
/******/ break;
/******/ }
/******/ if(!promises.length) return initPromises[name] = 1;
/******/ return initPromises[name] = Promise.all(promises).then(() => (initPromises[name] = 1));
/******/ };
/******/ })();
/******/
/******/ /* webpack/runtime/publicPath */
/******/ (() => {
/******/ var scriptUrl;
/******/ if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
/******/ var document = __webpack_require__.g.document;
/******/ if (!scriptUrl && document) {
/******/ if (document.currentScript)
/******/ scriptUrl = document.currentScript.src
/******/ if (!scriptUrl) {
/******/ var scripts = document.getElementsByTagName("script");
/******/ if(scripts.length) scriptUrl = scripts[scripts.length - 1].src
/******/ }
/******/ }
/******/ // When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
/******/ // or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
/******/ if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
/******/ scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
/******/ __webpack_require__.p = scriptUrl;
/******/ })();
/******/
/******/ /* webpack/runtime/consumes */
/******/ (() => {
/******/ var parseVersion = (str) => {
/******/ // see webpack/lib/util/semver.js for original code
/******/ var p=p=>{return p.split(".").map((p=>{return+p==p?+p:p}))},n=/^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;
/******/ }
/******/ var versionLt = (a, b) => {
/******/ // see webpack/lib/util/semver.js for original code
/******/ a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}
/******/ }
/******/ var rangeToString = (range) => {
/******/ // see webpack/lib/util/semver.js for original code
/******/ var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\((.+)\)$/,"$1")}
/******/ }
/******/ var satisfy = (range, version) => {
/******/ // see webpack/lib/util/semver.js for original code
/******/ if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1;a=!1}else"s"!=g&&"n"!=g&&(a=!1,i--)}}var t=[],o=t.pop.bind(t);for(n=1;n<range.length;n++){var u=range[n];t.push(1==u?o()|o():2==u?o()&o():u?satisfy(u,version):!o())}return!!o();
/******/ }
/******/ var ensureExistence = (scopeName, key) => {
/******/ var scope = __webpack_require__.S[scopeName];
/******/ if(!scope || !__webpack_require__.o(scope, key)) throw new Error("Shared module " + key + " doesn't exist in shared scope " + scopeName);
/******/ return scope;
/******/ };
/******/ var findVersion = (scope, key) => {
/******/ var versions = scope[key];
/******/ var key = Object.keys(versions).reduce((a, b) => {
/******/ return !a || versionLt(a, b) ? b : a;
/******/ }, 0);
/******/ return key && versions[key]
/******/ };
/******/ var findSingletonVersionKey = (scope, key) => {
/******/ var versions = scope[key];
/******/ return Object.keys(versions).reduce((a, b) => {
/******/ return !a || (!versions[a].loaded && versionLt(a, b)) ? b : a;
/******/ }, 0);
/******/ };
/******/ var getInvalidSingletonVersionMessage = (scope, key, version, requiredVersion) => {
/******/ return "Unsatisfied version " + version + " from " + (version && scope[key][version].from) + " of shared singleton module " + key + " (required " + rangeToString(requiredVersion) + ")"
/******/ };
/******/ var getSingleton = (scope, scopeName, key, requiredVersion) => {
/******/ var version = findSingletonVersionKey(scope, key);
/******/ return get(scope[key][version]);
/******/ };
/******/ var getSingletonVersion = (scope, scopeName, key, requiredVersion) => {
/******/ var version = findSingletonVersionKey(scope, key);
/******/ if (!satisfy(requiredVersion, version)) typeof console !== "undefined" && console.warn && console.warn(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));
/******/ return get(scope[key][version]);
/******/ };
/******/ var getStrictSingletonVersion = (scope, scopeName, key, requiredVersion) => {
/******/ var version = findSingletonVersionKey(scope, key);
/******/ if (!satisfy(requiredVersion, version)) throw new Error(getInvalidSingletonVersionMessage(scope, key, version, requiredVersion));
/******/ return get(scope[key][version]);
/******/ };
/******/ var findValidVersion = (scope, key, requiredVersion) => {
/******/ var versions = scope[key];
/******/ var key = Object.keys(versions).reduce((a, b) => {
/******/ if (!satisfy(requiredVersion, b)) return a;
/******/ return !a || versionLt(a, b) ? b : a;
/******/ }, 0);
/******/ return key && versions[key]
/******/ };
/******/ var getInvalidVersionMessage = (scope, scopeName, key, requiredVersion) => {
/******/ var versions = scope[key];
/******/ return "No satisfying version (" + rangeToString(requiredVersion) + ") of shared module " + key + " found in shared scope " + scopeName + ".\n" +
/******/ "Available versions: " + Object.keys(versions).map((key) => {
/******/ return key + " from " + versions[key].from;
/******/ }).join(", ");
/******/ };
/******/ var getValidVersion = (scope, scopeName, key, requiredVersion) => {
/******/ var entry = findValidVersion(scope, key, requiredVersion);
/******/ if(entry) return get(entry);
/******/ throw new Error(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));
/******/ };
/******/ var warnInvalidVersion = (scope, scopeName, key, requiredVersion) => {
/******/ typeof console !== "undefined" && console.warn && console.warn(getInvalidVersionMessage(scope, scopeName, key, requiredVersion));
/******/ };
/******/ var get = (entry) => {
/******/ entry.loaded = 1;
/******/ return entry.get()
/******/ };
/******/ var init = (fn) => (function(scopeName, a, b, c) {
/******/ var promise = __webpack_require__.I(scopeName);
/******/ if (promise && promise.then) return promise.then(fn.bind(fn, scopeName, __webpack_require__.S[scopeName], a, b, c));
/******/ return fn(scopeName, __webpack_require__.S[scopeName], a, b, c);
/******/ });
/******/
/******/ var load = /*#__PURE__*/ init((scopeName, scope, key) => {
/******/ ensureExistence(scopeName, key);
/******/ return get(findVersion(scope, key));
/******/ });
/******/ var loadFallback = /*#__PURE__*/ init((scopeName, scope, key, fallback) => {
/******/ return scope && __webpack_require__.o(scope, key) ? get(findVersion(scope, key)) : fallback();
/******/ });
/******/ var loadVersionCheck = /*#__PURE__*/ init((scopeName, scope, key, version) => {
/******/ ensureExistence(scopeName, key);
/******/ return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));
/******/ });
/******/ var loadSingleton = /*#__PURE__*/ init((scopeName, scope, key) => {
/******/ ensureExistence(scopeName, key);
/******/ return getSingleton(scope, scopeName, key);
/******/ });
/******/ var loadSingletonVersionCheck = /*#__PURE__*/ init((scopeName, scope, key, version) => {
/******/ ensureExistence(scopeName, key);
/******/ return getSingletonVersion(scope, scopeName, key, version);
/******/ });
/******/ var loadStrictVersionCheck = /*#__PURE__*/ init((scopeName, scope, key, version) => {
/******/ ensureExistence(scopeName, key);
/******/ return getValidVersion(scope, scopeName, key, version);
/******/ });
/******/ var loadStrictSingletonVersionCheck = /*#__PURE__*/ init((scopeName, scope, key, version) => {
/******/ ensureExistence(scopeName, key);
/******/ return getStrictSingletonVersion(scope, scopeName, key, version);
/******/ });
/******/ var loadVersionCheckFallback = /*#__PURE__*/ init((scopeName, scope, key, version, fallback) => {
/******/ if(!scope || !__webpack_require__.o(scope, key)) return fallback();
/******/ return get(findValidVersion(scope, key, version) || warnInvalidVersion(scope, scopeName, key, version) || findVersion(scope, key));
/******/ });
/******/ var loadSingletonFallback = /*#__PURE__*/ init((scopeName, scope, key, fallback) => {
/******/ if(!scope || !__webpack_require__.o(scope, key)) return fallback();
/******/ return getSingleton(scope, scopeName, key);
/******/ });
/******/ var loadSingletonVersionCheckFallback = /*#__PURE__*/ init((scopeName, scope, key, version, fallback) => {
/******/ if(!scope || !__webpack_require__.o(scope, key)) return fallback();
/******/ return getSingletonVersion(scope, scopeName, key, version);
/******/ });
/******/ var loadStrictVersionCheckFallback = /*#__PURE__*/ init((scopeName, scope, key, version, fallback) => {
/******/ var entry = scope && __webpack_require__.o(scope, key) && findValidVersion(scope, key, version);
/******/ return entry ? get(entry) : fallback();
/******/ });
/******/ var loadStrictSingletonVersionCheckFallback = /*#__PURE__*/ init((scopeName, scope, key, version, fallback) => {
/******/ if(!scope || !__webpack_require__.o(scope, key)) return fallback();
/******/ return getStrictSingletonVersion(scope, scopeName, key, version);
/******/ });
/******/ var installedModules = {};
/******/ var moduleToHandlerMapping = {
/******/ "webpack/sharing/consume/default/@jupyterlab/settingregistry": () => (loadSingletonVersionCheck("default", "@jupyterlab/settingregistry", [1,3,2,8])),
/******/ "webpack/sharing/consume/default/@jupyter-widgets/base": () => (loadSingletonVersionCheck("default", "@jupyter-widgets/base", [1,4,0,0])),
/******/ "webpack/sharing/consume/default/@jupyterlab/ui-components": () => (loadSingletonVersionCheck("default", "@jupyterlab/ui-components", [1,3,2,8])),
/******/ "webpack/sharing/consume/default/xterm/xterm": () => (loadStrictVersionCheckFallback("default", "xterm", [1,4,16,0], () => (__webpack_require__.e("vendors-node_modules_xterm_lib_xterm_js").then(() => (() => (__webpack_require__(/*! xterm */ "./node_modules/xterm/lib/xterm.js"))))))),
/******/ "webpack/sharing/consume/default/xterm-addon-fit/xterm-addon-fit": () => (loadStrictVersionCheckFallback("default", "xterm-addon-fit", [2,0,5,0], () => (__webpack_require__.e("node_modules_xterm-addon-fit_lib_xterm-addon-fit_js").then(() => (() => (__webpack_require__(/*! xterm-addon-fit */ "./node_modules/xterm-addon-fit/lib/xterm-addon-fit.js")))))))
/******/ };
/******/ // no consumes in initial chunks
/******/ var chunkMapping = {
/******/ "lib_index_js": [
/******/ "webpack/sharing/consume/default/@jupyterlab/settingregistry",
/******/ "webpack/sharing/consume/default/@jupyter-widgets/base",
/******/ "webpack/sharing/consume/default/@jupyterlab/ui-components",
/******/ "webpack/sharing/consume/default/xterm/xterm",
/******/ "webpack/sharing/consume/default/xterm-addon-fit/xterm-addon-fit"
/******/ ]
/******/ };
/******/ __webpack_require__.f.consumes = (chunkId, promises) => {
/******/ if(__webpack_require__.o(chunkMapping, chunkId)) {
/******/ chunkMapping[chunkId].forEach((id) => {
/******/ if(__webpack_require__.o(installedModules, id)) return promises.push(installedModules[id]);
/******/ var onFactory = (factory) => {
/******/ installedModules[id] = 0;
/******/ __webpack_require__.m[id] = (module) => {
/******/ delete __webpack_require__.c[id];
/******/ module.exports = factory();
/******/ }
/******/ };
/******/ var onError = (error) => {
/******/ delete installedModules[id];
/******/ __webpack_require__.m[id] = (module) => {
/******/ delete __webpack_require__.c[id];
/******/ throw error;
/******/ }
/******/ };
/******/ try {
/******/ var promise = moduleToHandlerMapping[id]();
/******/ if(promise.then) {
/******/ promises.push(installedModules[id] = promise.then(onFactory)['catch'](onError));
/******/ } else onFactory(promise);
/******/ } catch(e) { onError(e); }
/******/ });
/******/ }
/******/ }
/******/ })();
/******/
/******/ /* webpack/runtime/jsonp chunk loading */
/******/ (() => {
/******/ // no baseURI
/******/
/******/ // object to store loaded and loading chunks
/******/ // undefined = chunk not loaded, null = chunk preloaded/prefetched
/******/ // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
/******/ var installedChunks = {
/******/ "@yuuno/jupyterlab": 0
/******/ };
/******/
/******/ __webpack_require__.f.j = (chunkId, promises) => {
/******/ // JSONP chunk loading for javascript
/******/ var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
/******/ if(installedChunkData !== 0) { // 0 means "already installed".
/******/
/******/ // a Promise means "currently loading".
/******/ if(installedChunkData) {
/******/ promises.push(installedChunkData[2]);
/******/ } else {
/******/ if(true) { // all chunks have JS
/******/ // setup Promise in chunk cache
/******/ var promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));
/******/ promises.push(installedChunkData[2] = promise);
/******/
/******/ // start chunk loading
/******/ var url = __webpack_require__.p + __webpack_require__.u(chunkId);
/******/ // create error before stack unwound to get useful stacktrace later
/******/ var error = new Error();
/******/ var loadingEnded = (event) => {
/******/ if(__webpack_require__.o(installedChunks, chunkId)) {
/******/ installedChunkData = installedChunks[chunkId];
/******/ if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
/******/ if(installedChunkData) {
/******/ var errorType = event && (event.type === 'load' ? 'missing' : event.type);
/******/ var realSrc = event && event.target && event.target.src;
/******/ error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
/******/ error.name = 'ChunkLoadError';
/******/ error.type = errorType;
/******/ error.request = realSrc;
/******/ installedChunkData[1](error);
/******/ }
/******/ }
/******/ };
/******/ __webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
/******/ } else installedChunks[chunkId] = 0;
/******/ }
/******/ }
/******/ };
/******/
/******/ // no prefetching
/******/
/******/ // no preloaded
/******/
/******/ // no HMR
/******/
/******/ // no HMR manifest
/******/
/******/ // no on chunks loaded
/******/
/******/ // install a JSONP callback for chunk loading
/******/ var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
/******/ var [chunkIds, moreModules, runtime] = data;
/******/ // add "moreModules" to the modules object,
/******/ // then flag all "chunkIds" as loaded and fire callback
/******/ var moduleId, chunkId, i = 0;
/******/ if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
/******/ for(moduleId in moreModules) {
/******/ if(__webpack_require__.o(moreModules, moduleId)) {
/******/ __webpack_require__.m[moduleId] = moreModules[moduleId];
/******/ }
/******/ }
/******/ if(runtime) var result = runtime(__webpack_require__);
/******/ }
/******/ if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
/******/ for(;i < chunkIds.length; i++) {
/******/ chunkId = chunkIds[i];
/******/ if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
/******/ installedChunks[chunkId][0]();
/******/ }
/******/ installedChunks[chunkIds[i]] = 0;
/******/ }
/******/
/******/ }
/******/
/******/ var chunkLoadingGlobal = self["webpackChunk_yuuno_jupyterlab"] = self["webpackChunk_yuuno_jupyterlab"] || [];
/******/ chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
/******/ chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
/******/ })();
/******/
/************************************************************************/
/******/
/******/ // module cache are used so entry inlining is disabled
/******/ // startup
/******/ // Load entry module and return exports
/******/ var __webpack_exports__ = __webpack_require__("webpack/container/entry/@yuuno/jupyterlab");
/******/ (_JUPYTERLAB = typeof _JUPYTERLAB === "undefined" ? {} : _JUPYTERLAB)["@yuuno/jupyterlab"] = __webpack_exports__;
/******/
/******/ })()
;
//# sourceMappingURL=remoteEntry.4159836c3d9a8dde01b9.js.map | yuuno | /yuuno-1.4.tar.gz/yuuno-1.4/yuuno_jupyterlab/static/static/remoteEntry.4159836c3d9a8dde01b9.js | remoteEntry.4159836c3d9a8dde01b9.js |
<div align="center">
<img align="center" src="logo.png" width="520" alt=โYUVIOโ />
</div>
Welcome to **yuvio**, a python package for reading and writing uncompressed yuv
image and video data. **yuvio** supports many pixel formats specified by ffmpeg.
And if it doesn't, it's fast and easy to add support for your own pixel formats.
## Install
`yuvio` is easily installed using python's `pip` package manager.
```sh
pip install yuvio
```
## Usage
To read and write yuv files, `yuvio` provides the functions `imread`, `imwrite`, `mimread` and
`mimwrite` for single and multiple frames, respectively. Both require the specification of a
pixel format to use for the yuv data.
```python
import yuvio
yuv_frame = yuvio.imread("example_yuv420p.yuv", 1920, 1080, "yuv420p")
yuvio.imwrite("example_yuv420p_copy.yuv", yuv_frame)
yuv_frames = yuvio.mimread("example_yuv420p.yuv", 1920, 1080, "yuv420p")
yuvio.mimwrite("example_yuv420p_copy.yuv", yuv_frames)
```
Thereby, `yuvio` is not restricted to file objects and can read and write from/to other `io`
streams as well. For example, this allows to conveniently unpack the individual yuv planes from
interleaved yuv data available in memory.
```python
import io
import yuvio
data = ... # e.g. np.ndarray
buffer = io.BytesIO(data)
yuv_frame = yuvio.imread(buffer, 1920, 1080, "yuyv422")
y = yuv_frame.y
u = yuv_frame.u
v = yuv_frame.v
```
For advanced use cases, `yuvio` also provides direct access to the `Reader` and `Writer` objects.
This allows sequential reading and writing from/to yuv files and may be beneficial for iterating
over large files without keeping all frames in memory.
```python
import yuvio
reader = yuvio.get_reader("example_yuv420p.yuv", 1920, 1080, "yuv420p")
writer = yuvio.get_writer("example_yuv420p_copy.yuv", 1920, 1080, "yuv420p")
for yuv_frame in reader:
writer.write(yuv_frame)
```
To create custom yuv data, `yuvio` provides access to convenient yuv frame
initializers `empty`, `zeros` and `ones` similar to numpys convenience array
initializers.
```python
import yuvio
empty = yuvio.empty(1920, 1080, "yuv420p")
zeros = yuvio.zeros(1920, 1080, "yuv420p")
ones = yuvio.ones(1920, 1080, "yuv420p")
```
For advanced use cases, `yuvio` also allows direct yuv frame initialization
from custom data using the `frame` initializer.
```python
import yuvio
import numpy as np
y = 255 * np.ones((1920, 1080), dtype=np.uint8)
u = np.zeros((960, 540), dtype=np.uint8)
v = np.zeros((960, 540), dtype=np.uint8)
frame_420 = yuvio.frame((y, u, v), "yuv420p")
frame_400 = yuvio.frame((y, None, None), "gray")
```
## Formats
Print a complete list of available pixel formats using `print(yuvio.pixel_formats)`.
To get detailed information on the IO format of a specific `pix_fmt` use
`print(yuvio.pixel_formats[pix_fmt].io_info())`.
Currently, the following pixel formats (`pix_fmt`) are available:
* `'gray'`
* `'gray10le'`
* `'gray10be'`
* `'gray16le'`
* `'gray16be'`
* `'gray9le'`
* `'gray9be'`
* `'gray12le'`
* `'gray12be'`
* `'gray14le'`
* `'gray14be'`
* `'yuv420p'`
* `'yuv420p10le'`
* `'yuv420p10be'`
* `'yuv420p16le'`
* `'yuv420p16be'`
* `'yuv420p9le'`
* `'yuv420p9be'`
* `'yuv420p12le'`
* `'yuv420p12be'`
* `'yuv420p14le'`
* `'yuv420p14be'`
* `'yuv422p'`
* `'yuv422p10le'`
* `'yuv422p10be'`
* `'yuv422p16le'`
* `'yuv422p16be'`
* `'yuv422p9le'`
* `'yuv422p9be'`
* `'yuv422p12le'`
* `'yuv422p12be'`
* `'yuv422p14le'`
* `'yuv422p14be'`
* `'yuv444p'`
* `'yuv444p10le'`
* `'yuv444p10be'`
* `'yuv444p16le'`
* `'yuv444p16be'`
* `'yuv444p9le'`
* `'yuv444p9be'`
* `'yuv444p12le'`
* `'yuv444p12be'`
* `'yuv444p14le'`
* `'yuv444p14be'`
* `'yuyv422'`
* `'uyvy422'`
* `'yvyu422'`
| yuvio | /yuvio-1.1.tar.gz/yuvio-1.1/README.md | README.md |
# Yuyu Scanner Packages
## A simple package to make your own Information Gathering Scanner
Create your Hacking Tools with Yuyu Scanner Packages.
Yuyu Scanner was created by @justakazh using the python programming language which is integrated with several tools including:
- nmap
- wappalyzer
- whois
Yuyu uses several public APIs to get fast and maximum results, including:
- Subdomain
```
https://threatcrowd.org/
https://urlscan.io/
https://rapiddns.io/
https://otx.alienvault.com/
https://dnsdumpster.com/
https://crt.sh/
https://api.threatminer.org/
https://api.certspotter.com/
https://api.hackertarget.com/
https://riddler.io/
http://index.commoncrawl.org/
```
- Collect URL
```
http://web.archive.org/
```
- Reverse IP
```
https://hackertarget.com/
```
- Email Discovery
```
https://hunter.io
```
## Features
- Subdomain Enumeration
- Port Scanner
- Find Sensitive Files
- Check for live host
- Collect Information From Website (Technology used)
- Collect URL From Waybackurl
- Reverse IP
- WHOIS
- Find Email Address
> Reconnaissance Is Key For Hacking
## Installation
Requirements:
```sh
sudo apt install nmap
sudo apt install whois
pip install yuyu
```
## Usage
### Subdomain Enumeration
Collecting subdomain from Public API
```python
from yuyu_scanner import subdomain
target = "target.domain"
get = subdomain.check(target).result # get list of subdomain are found
#['subdomain1.target.domain', 'subdomain2.target.domain', 'subdomain3.target.domain']
```
### Check Host
Checking host if live or die
```python
from yuyu_scanner import host
lst_domain = ['target1.site', 'target2.site']
get = host.check(lst_domain)
get_All = get.result # get all host with ip/status
#[['target1.site', '0.0.0.0'], ['target2.site', '0.0.0.0']]
get_Live = get.live # get host are live
#['target1.site', 'target2.site']
```
### Collecting Information From Website
Collecting Information from website target (title, technology, technology version, ip address)
```python
from yuyu_scanner import information
lst_domain = ['target1.site', 'target2.site']
get = information.check(lst_domain).result # get list information found
#[['target1.site', {'Bootstrap': {'versions': ['5.1.3']}, 'Google Tag Manager': {'versions': []}, 'jsDelivr': {'versions': []}, 'DoubleClick for Publishers (DFP)': {'versions': []}, 'Nginx': {'versions': []}, 'jQuery': {'versions': ['3.6.0']}}, 'WEBSITE TITLE'], ['target2.site', {'Bootstrap': {'versions': ['5.1.3']}, 'Google Tag Manager': {'versions': []}, 'jsDelivr': {'versions': []}, 'DoubleClick for Publishers (DFP)': {'versions': []}, 'Nginx': {'versions': []}, 'jQuery': {'versions': ['3.6.0']}}, 'WEBSITE TITLE']]
```
### Reverse IP
Reverse IP from hackertarget API
```python
from yuyu_scanner import reverse_ip
target = "target.domain"
apikey = "" #you can blank it for trial
get = reverse_ip.check(target, apikey).result #get list of result reverse ip
#['reverse.target.domain', 'randomdomain.domain']
```
### WHOIS
Whois for find information about domain created, registry, owner name, email, address, phone
```python
from yuyu_scanner import whois
target = "example.com"
get = whois.check(target).result #get result of whois
#Domain Name: EXAMPLE.COM\n Registry Domain ID: 2336799_DOMAIN_COM-VRSN\n Registrar WHOIS Server: whois.iana.org\n Registrar URL: http://res-dom.iana.org\n Updated Date: 2021-08-14T07:01:44Z\n Creation Date: 1995-08-14T04:00:00Z\n Registry Expiry Date: 2022-08-13T04:00:00Z\n Registrar: RESERVED-Internet Assigned Numbers Authority\n Registrar IANA ID: 376\n Registrar Abuse Contact Email:\n Registrar Abuse Contact Phone:\n Domain Status: clientDeleteProhibited https://icann.org/epp#clientDeleteProhibited\n Domain Status: clientTransferProhibited https://icann.org/epp#clientTransferProhibited\n Domain Status: clientUpdateProhibited https://icann.org/epp#clientUpdateProhibited\n Name Server: A.IANA-SERVERS.NET\n Name Server: B.IANA-SERVERS.NET\n DNSSEC: signedDelegation\n DNSSEC DS Data: 31589 8 1 3490A6806D47F17A34C29E2CE80E8A999FFBE4BE\n DNSSEC DS Data: 31589 8 2 CDE0D742D6998AA554A92D890F8184C698CFAC8A26FA59875A990C03E576343C\n DNSSEC DS Data: 43547 8 1 B6225AB2CC613E0DCA7962BDC2342EA4F1B56083\n DNSSEC DS Data: 43547 8 2 615A64233543F66F44D68933625B17497C89A70E858ED76A2145997EDF96A918\n DNSSEC DS Data: 31406 8 1 189968811E6EBA862DD6C209F75623D8D9ED9142\n DNSSEC DS Data: 31406 8 2 F78CF3344F72137235098ECBBD08947C2C9001C7F6A085A17F518B5D8F6B916D\n URL of the ICANN Whois Inaccuracy Complaint Form: https://www.icann.org/wicf/\n'
```
### Collecting URL
Collection URL from Public API (waybackurl)
```python
from yuyu_scanner import collect_url
target = "target.domain"
get = collect_url.check(target).result #get list of result url
#['https://subdo.target.domain/?url', 'https://target.domain/path']
```
### Find Email Address
Find Email address from Public API
```python
from yuyu_scanner import email
target = "target.domain"
apikey = "" #required! get your apikey from hunter.io
get = email.check(target, apikey).result #get list of result Email
#['[email protected]', '[email protected]']
```
### Scan Port
Scanning common port (21,22,23,25,53,80,110,115,135,139,143,194,443,445,1433,3306,3389,5632,5900,25565)
```python
from yuyu_scanner import scan_port
lst_target = ['target1.domain', 'target2.domain']
get = scan_port.check(lst_target).result #get list of result scan port
#[['139.162.2.200', [['21', 'ftp', 'open'], ['53', 'domain', 'open'], ['80', 'http', 'open'], ['110', 'pop3', 'open'], ['143', 'imap', 'open'], ['443', 'https', 'open']]], ['172.67.136.101', [['53', 'domain', 'open'], ['80', 'http', 'open'], ['443', 'https', 'open']]]]
```
### Find Sensitive Files
Find Sensitive Files
- /.git/config
- /.git/HEAD
- /.env
- /.env.bak
- /xmlrpc.php
- /robots.txt
- /.svg
```python
from yuyu_scanner import files
lst_target = ['target1.domain', 'target2.domain']
get = files.check(lst_target).result #get list of result scan port
# ['http://target1.domain/.git/HEAD', 'http://target1.domain/.env']
```
## Yuyu Scanner Tool
Web Information Gathering And Analyst
- https://github.com/justakazh/Yuyu_Scanner/
## Publication
- https://www.researchgate.net/publication/352295423_PENGEMBANGAN_APLIKASI_INFORMATION_GATHERING_MENGGUNAKAN_METODE_HYBRID_SCAN_BERBASIS_GRAPHICAL_USER_INTERFACE
## Contact me
- [akazh](https://twitter.com/akazh18/) - Twitter
## References
- https://github.com/screetsec/Sudomy
- https://github.com/aboul3la/Sublist3r
## Credits & Thanks
- [Deddy Hariyadi](https://www.instagram.com/milisd4d/)
- [Redho Maland](https://github.com/screetsec/)
| yuyu | /yuyu-0.4.4.tar.gz/yuyu-0.4.4/README.md | README.md |
import requests
import sys
import json
import re
import threading
import os
import warnings
warnings.filterwarnings("ignore")
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
class check:
def __init__(self, target):
self.subdomain = []
self.result = []
self.timeout = 5
self.ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/97.0.4692.71 Safari/537.36"
target = target.replace("https://", "").replace("http://", "").replace("www.", "").replace("/", "").strip()
self._findSubdomain(target)
asw = []
liss = [i.strip() for i in self.subdomain]
for i in liss:
if target not in i:
pass
else:
asw.append(i)
subdomain = list(dict.fromkeys(asw))
self.subdomain.clear()
for subdo in subdomain:
if subdo != "" and "*." not in subdo and ":" not in subdo and "\n" not in subdo and "\r" not in subdo and "@" not in subdo and "?" not in subdo :
self.result.append(subdo)
def _findSubdomain(self, target):
self.alienvault(target)
self.certspotter(target)
self.commoncrawl(target)
self.crt(target)
self.dnsdumpster(target)
self.hackertarget(target)
self.rapiddns(target)
self.riddler(target)
self.threatminer(target)
self.threatcrowd(target)
self.urlscan(target)
self.omnisint(target)
def alienvault(self, domain):
try:
# print("alienvault")
s = requests.session()
r = s.get("https://otx.alienvault.com/api/v1/indicators/domain/"+domain+"/passive_dns", timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d['passive_dns']:
self.subdomain.append(i['hostname'])
except Exception as e:
# print( e)
pass
def certspotter(self, domain):
try:
# print("certspotter")
s = requests.session()
r = s.get("https://api.certspotter.com/v1/issuances?domain="+domain+"&include_subdomains=true&expand=dns_names", timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d:
self.subdomain.append(i['dns_names'][0])
except Exception as e:
# print( e)
pass
def commoncrawl(self, domain):
try:
# print("commoncrawl")
s = requests.session()
r = s.get("http://index.commoncrawl.org/CC-MAIN-2020-50-index?url=*."+domain+"&output=json", timeout=self.timeout, headers={"User-Agent": self.ua}).text
get = re.findall('"url": "(.*?)"', r)
for i in get:
s = i.split("/")
self.subdomain.append(s[2])
except Exception as e:
# print( e)
pass
def crt(self, domain):
try:
# print("crt")
s = requests.session()
r = s.get("https://crt.sh/?q="+domain+"&output=json", timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d:
self.subdomain.append(i['name_value'])
except Exception as e:
# print( e)
pass
def dnsdumpster(self, domain):
try:
# print("dnsdumpster")
s = requests.session()
get_token = s.get("https://dnsdumpster.com/")
csrftoken = re.findall("csrftoken=(.*?);", get_token.headers['Set-Cookie'])[0]
token = re.findall('<form role="form" action="." method="post"><input type="hidden" name="csrfmiddlewaretoken" value="(.*?)">', get_token.text)[0]
data = {
"csrfmiddlewaretoken":token,
"targetip":domain,
"user":"free",
}
headers={
"csrftoken": csrftoken,
"Referer":"https://dnsdumpster.com/"
}
r = s.post("https://dnsdumpster.com/", data=data, headers=headers, timeout=self.timeout).text
get_all = re.findall('<a class="external nounderline" data-toggle="modal" href="(.*?)" data-target="#myModal"><span class="glyphicon glyphicon-globe" data-toggle="tooltip" data-placement="top" title="Get HTTP Headers"></span></a>', r)
for i in get_all:
filters = i.split("https://api.hackertarget.com/httpheaders/?q=")[1]
filtersproto = filters.split("/")
self.subdomain.append(filtersproto[2])
except Exception as e:
# print( e)
pass
def hackertarget(self, domain):
try:
# print("hackertarget")
s = requests.session()
r = s.get("https://api.hackertarget.com/hostsearch/?q="+domain, timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = r.split("\n")
for i in d:
if "API count exceeded " in i:
pass
else:
filters = i.split(",")
self.subdomain.append(filters[0])
except Exception as e:
# print( e)
pass
def rapiddns(self, domain):
try:
# print("rapiddns")
s = requests.session()
r = s.get("https://rapiddns.io/subdomain/"+domain, timeout=self.timeout, headers={"User-Agent": self.ua}).text
get = re.findall('<tr>\n<th scope="row ">(.*?)</th>\n<td>(.*?)</td>\n', r)
for i in get:
self.subdomain.append(i[1])
except Exception as e:
# print( e)
pass
def riddler(self, domain):
try:
# print("riddler")
s = requests.session()
r = s.get("https://riddler.io/search/exportcsv?q=pld:"+domain, timeout=self.timeout, headers={"User-Agent": self.ua}).text
ss = r.split("\n")
for i in ss:
s = re.findall(',(.*?),', r)
self.subdomain.append(s[5])
except Exception as e:
# print( e)
pass
def threatminer(self, domain):
try:
# print("threatminer")
s = requests.session()
r = s.get("https://api.threatminer.org/v2/domain.php?q="+domain+"&rt=5", timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d:
self.subdomain.append(i['name_value'])
except Exception as e:
# print( e)
pass
def threatcrowd(self, domain):
try:
# print("threatcrowd")
s = requests.session()
r = s.get("https://threatcrowd.org/searchApi/v2/domain/report/?domain="+domain, timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d['subdomains']:
self.subdomain.append(i)
except Exception as e:
# print( e)
pass
def urlscan(self, domain):
try:
# print("urlscan")
s = requests.session()
r = s.get("https://urlscan.io/api/v1/search/?q="+domain, timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d['results']:
self.subdomain.append(i['task']['domain'])
except Exception as e:
# print( e)
pass
def omnisint(self, domain):
try:
# print("urlscan")
s = requests.session()
r = s.get("https://sonar.omnisint.io/subdomains/"+domain, timeout=self.timeout, headers={"User-Agent": self.ua}).text
d = json.loads(r)
for i in d:
self.subdomain.append(i)
except Exception as e:
# print( e)
pass | yuyu | /yuyu-0.4.4.tar.gz/yuyu-0.4.4/yuyu_scanner/subdomain.py | subdomain.py |
# yuzu
Tired of spinning around in your chair while your feature attribution calculations slowly churn away? Introducing Yuzu, a compressed sensing approach that can make in-silico mutagenesis calculations on DNA, RNA, and proteins an order of magnitude faster, and enable breezy interactive exploration! Yuzu can be run on any sequential PyTorch model that takes a biological sequence as input (no graph structures or multi-input/output supported yet) on either a CPU or GPU, and exhibits large speedups in both settings.
### How fast is it?
### How does it work?
Yuzu relies on two complimentary components: computing only on deltas, and compressed sensing.
(1) The first component, computing only on deltas, speeds up the process because each mutated sequences contains only a single mutation and that mutation's effect on the output from each layer in the model is limited by the receptive field of that layer. For example, a convolution layer with a kernel size of 7 applied to a sequence with a single mutation in it will exhibit the same output as the original sequence outside the 13-bp window (6 bp in either direction and the central bp) will not exhibit changes in the output 7 bp in either direction from a mutation in the input.
(2) The second component, compressed sensing, speeds up the process by compressing these deltas from one span per mutated sequence into a small set of dense "probes." Each probe contains a Gaussian random projection of the deltas from all of the mutated sequences. Although the principles of compressed sensing are for linear models, and neural networks are notoriously non-linear, each layer before the activation is a linear operation. So, for each convolution in the model, Yuzu constructs probes from the delta matrix, runs them through a compressed convolution operation, and decodes the outputs back into a new delta matrix. When activation layers are encountered, the reference sequence is added to the delta matrix to recover the original values, the non-linear operation is applied, and the deltas are re-extracted.
### Installation
`pip install yuzu-ism`
### Usage
Yuzu has two steps: (1) a precomputation step where statistics about a model, and the sequence length being considered, are cached, and (2) the calculation step for an example. Although the first step takes time equivalent to a traditional ISM run on a single example, it only has to be run once. Then, the second step is run on each example (or batch of examples) that you want to calculate saliency for!
```
from yuzu import precompute
from yuzu import yuzu_ism
from yuzu.models import ToyNet # An example model with three convolution layers
# Create toy sequences that are one-hot encoded
# The sequences should have shape (n_seqs, n_characters, seq_len)
idxs = numpy.random.RandomState(0).randn(3, 4, 1000).argmax(axis=1)
X_0 = numpy.zeros((3, 4, 1000), dtype='float32')
for i in range(3):
X_0[i, idxs[i], numpy.arange(1000)] = 1
model = ToyNet(n_inputs=4, seq_len=1000)
# Do the precomputation once or load your previously-calculated precomputation
yuzu_stats = precompute(model, X_0[:1], device='cpu')
# Run yuzu_ism on as many sequences as you'd like.
yuzu_ism, layer_timings, within_layer_timings = yuzu_ism(model, X_0, *yuzu_stats, device='cpu')
```
### Limitations
Currently, Yuzu can only be run on models of modest size (unfortunately, no Bassenji- or Enformer-scale models quite yet). This is because a limitation of the compressed sensing formulation is that all mutated sequences must be solved simultaneously. However, remember that the mutated sequences are compressed into a much smaller set of probes. A GPU with 12GB of memory can easily handle a Basset-sized model with a sequence length of 2,000 (6,000 sequences decoded simultaneously) because Yuzu only operates on the compressed probes directly.
A second limitation is that Yuzu requires that, when the model is specified, that each operation is listed sequentially in the order that it is executed in the forward pass and that no operations other than these layers are performed in the forward pass. This is because Yuzu sequentially iterates over the layers of the model using the `model.children()` function rather than through the forward function. So, if the data is resized or flattened, it must be done through a custom layer that wraps the operation.
| yuzu-ism | /yuzu-ism-0.0.1.tar.gz/yuzu-ism-0.0.1/README.md | README.md |
import numpy
import pickle
import torch
import random
from .models import Flatten
from .utils import calculate_flanks
from .utils import perturbations
from .naive_ism import naive_ism
from .yuzu_ism import yuzu_ism
global use_layers, ignore_layers
use_layers = torch.nn.Conv1d, torch.nn.MaxPool1d, torch.nn.AvgPool1d
ignore_layers = torch.nn.ReLU, torch.nn.BatchNorm1d, torch.nn.LogSoftmax
class Precomputation(object):
"""A container for all of the precomputed statistics for Yuzu.
This object will store all the statistics that are calculated during the
precompute step, as well as methods for saving and loading the statistics
to disk so that they don't need to be redone.
Parameters
----------
As: list of torch.Tensor, shape=(n_probes, n)
A list of tensors containing the random Gaussian values for the
sensing matrix that compresses the sequences into probes. Each
layer in the model that can be sped up using this approach has
a different A tensor. This list of tensors is precomputed as
part of the `precompute` function.
betas: list of torch.Tensor
A list of tensor containing slices of the A matrix that are
ready to be used to solve a regression task. This list of
tensors is precomputed as part of the `precompute` function.
masks: list of tuples of torch.Tensor
A list of tuples of tensors containing a mask of the receptive field
for each example. This mask is empirically derived by running
the examples through the network and recording where positions
change with respect to the reference. The first tuple contains the
mask before the layer is applied and the second tuple contains the
mask after the layer is applied. Within those tuples, the first
item is a list of the masks applied to the edges of the sequence
and the second item is a mask to be applied to the middle of the
sequence.
receptive_fields: list of tuple of ints or None
A list of tuples of integers showing the maximum receptive field
size for each layer before (first element) and after (second element)
applying each layer. The receptive field is the span from the left-most
sequence position to the right-most sequence position that are
changed in the given sequences, even if some of the internal
positions are not changed. This list of values is precomputed
as part of the `precompute` function.
n_probes: list of ints or None
A list of values showing the number of probes to construct
for each layer that is being compressed. This list of values
is precomputed as part of the `precompute` function.
seq_lens: list of tuples of ints
A list of tuples showing the length of the sequence before
applying the layer (first element) and after applying the layer
(second element).
n_nonzeros: list of tuples of ints
A list of tuples showing the maximum number of nonzero elements per
column before applying the layer (first element) and after applying the
layer (second element).
"""
def __init__(self, As, betas, masks, receptive_fields, n_probes,
seq_lens, n_nonzeros):
self.As = As
self.betas = betas
self.masks = masks
self.receptive_fields = receptive_fields
self.n_probes = n_probes
self.seq_lens = seq_lens
self.n_nonzeros = n_nonzeros
def save(self, filename):
with open(filename, "w") as outfile:
pickle.dump(self, outfile)
@classmethod
def load(self, filename, device):
with open(filename, "r") as infile:
stats = pickle.load(infile)
return stats
@torch.inference_mode()
def precompute_mask(model, X_0, use_layers, ignore_layers, device,
random_state, verbose):
"""This function will empirically calculate the mask for each layer.
This function calculates the empirical mask specifying where deltas are
non-zero between the mutated sequences and the original sequence. From this
mask, it also calculates other properties, such as the receptive field and
the number of non-zero elements per row. Note: This function does not
calculate the statistics required for compressed sensing.
Parameters
----------
model: torch.nn.Module
A PyTorch model that can contain any number and types of layers.
However, this model must be defined in a particular way. Specifically,
all of the operations must be defined -in order- in the `__init__`
function. No operations can be performed outside of the context of a
layer in the forward function, such as reshaping or applying
activation functions. See `models.py` for examples.
X_0: numpy.ndarray
A randomly generated, one-hot encoded sequence to operate on.
use_layers: tuple
A tuple of the layers that the compressed sensing algorithm should
be applied to. These layers should only have sparse differences in
activation when mutated sequences are run through, such as a convolution.
ignore_layers: tuple, optional
Layers to ignore when passing through. ReLU layers, in particular, can
cause trouble in determining the mask when paired with max pooling layers.
Default is an empty tuple.
device: str, either 'cpu' or 'cuda', optional
The device to save the operations to, in terms of PyTorch contexts.
random_state: int or None, optional
The seed to use for the random state. Use None for no random
seed to be set. Default is None.
verbose: bool, optional
Whether to print out statements showing timings and the progression
of the computation.
Returns
-------
masks: list of tuples of torch.tensors
A list of the empirically calculated masks. The shape is:
[(before_operation_flanks, before_operation_core),
(after_operation_flanks, after_operation_core)]
where before/after operation indicate the mask before or after the
layer at the same index as the mask is in the list.
receptive_fields: list of tuples of ints
A list of the receptive fields, where each tuple contains the
receptive field before and after the layer is applied.
seq_lens: list of tuples of ints
A list of the sequence lengths, where each tuple contains the
sequence length before and after the layer is applied.
n_nonzeros: list of tuples of ints
A list of the maximum number of nonzero elements at each position
in the sequence before and after the layer is applied.
"""
masks, receptive_fields, seq_lens, n_nonzeros = [], [], [], []
# Generate all the single edit mutations of that sequence
X = perturbations(X_0)[0]
X_0 = torch.from_numpy(X_0)
n_seqs, n_choices, seq_len = X.shape
for l, layer in enumerate(model.children()):
# Replace convolution weights with a range to ensure differences
# are observed in intermediate values between differing inputs
# or just ones if it's an intermediary convolution to propogate
# those differences forward.
if isinstance(layer, torch.nn.Conv1d):
layer = torch.nn.Conv1d(in_channels=layer.in_channels,
out_channels=layer.out_channels,
kernel_size=layer.kernel_size, padding=layer.padding,
dilation=layer.dilation, groups=layer.groups,
bias=False, padding_mode=layer.padding_mode)
if l == 0:
w = torch.arange(layer.in_channels)
w = torch.tile(w, (layer.out_channels, layer.kernel_size[0], 1))
layer.weight[:] = w.permute(0, 2, 1)
else:
layer.weight[:] = 1
# For the purpose of empirically defining the receptive field,
# replace max pools by average pools because max pools can be
# effected solely by values outside the known receptive field.
if isinstance(layer, torch.nn.MaxPool1d):
layer = torch.nn.AvgPool1d(kernel_size=layer.kernel_size,
stride=layer.stride, padding=layer.padding,
ceil_mode=layer.ceil_mode)
# Only go through manually specified layers.
if isinstance(layer, use_layers) and not isinstance(layer, ignore_layers):
X_delta = torch.abs(X - X_0).max(axis=1).values
before_mask = (X_delta >= 1).type(dtype=torch.bool)
bn_nonzero = int(before_mask.sum(dim=0).max())
bseq_len = X_0.shape[-1]
b_receptive_field = 0
rows, cols = torch.where(before_mask == True)
for row in torch.unique(rows):
col_idxs = cols[rows == row]
field = col_idxs.max() - col_idxs.min() + 1
b_receptive_field = max(b_receptive_field, field.item())
bfl, bfr, bidxs = calculate_flanks(bseq_len, b_receptive_field)
###
X_0, X = layer(X_0), layer(X)
# Ensure that the average can't go below if the kernel size
# of the max pooling layer goes over the receptive field.
if isinstance(layer, torch.nn.AvgPool1d):
X_0 = X_0 * layer.kernel_size[0]
X = X * layer.kernel_size[0]
X = X - X_0
X_0 = X_0 - X_0
X_delta = torch.abs(X).max(axis=1).values
mask = (X_delta >= 1).type(dtype=torch.bool)
n_nonzero = int(mask.sum(dim=0).max())
seq_len = X_0.shape[2]
receptive_field = 0
rows, cols = torch.where(mask == True)
for row in torch.unique(rows):
col_idxs = cols[rows == row]
field = col_idxs.max() - col_idxs.min() + 1
receptive_field = max(receptive_field, field.item())
fl, fr, idxs = calculate_flanks(seq_len, receptive_field)
receptive_field_ = (b_receptive_field, receptive_field)
seq_lens_ = (bseq_len, seq_len)
n_nonzeros_ = (bn_nonzero, n_nonzero)
# Calculate clipped masks (ignoring edges)
if device[:4] == 'cuda':
before_mask = before_mask.cuda()
mask = mask.cuda()
clipped_before_mask = torch.clone(before_mask)
clipped_before_mask[:, :bfl] = False
clipped_before_mask[:, bseq_len-bfr:] = False
clipped_mask = torch.clone(mask)
clipped_mask[:, :fl] = False
clipped_mask[:, seq_len-fr:] = False
mask_ = [([], torch.where(clipped_before_mask.T == True)),
([], torch.where(clipped_mask.T == True))]
# Calculate masks in edges
for i, idx in enumerate(bidxs):
m = torch.where(before_mask[:, idx] == True)[0]
mask_[0][0].append(m)
for i, idx in enumerate(idxs):
m = torch.where(mask[:, idx] == True)[0]
mask_[1][0].append(m)
del mask, clipped_mask, X_delta
else:
# If the layer shouldn't be ignored but also won't be applied
# to the deltas and so doesn't need anything special (e.g.,
# a flatten or unsqueeze layer) then run it through as normal.
if not isinstance(layer, ignore_layers):
bseq_len = X.shape[-1]
X_0, X = layer(X_0), layer(X)
X_delta = torch.abs(X - X_0)
# Depending on the layer, modify the deltas and extract
# the sequence length.
if len(X_delta.shape) > 2:
X_delta = X_delta.max(axis=1).values
seq_len = X_0.shape[-1]
else:
seq_len = seq_lens_[1]
mask = (X_delta >= 1).type(dtype=torch.bool)
n_nonzero = mask.sum(dim=0).max()
seq_lens_ = bseq_len, seq_len
del X_delta
else:
seq_lens_ = seq_lens_[1], seq_lens_[1]
receptive_field_ = receptive_field_[1], receptive_field_[1]
mask_ = mask_[1], mask_[1]
if verbose:
print(l, layer, receptive_field_, seq_lens_, n_nonzeros_)
masks.append(mask_)
receptive_fields.append(receptive_field_)
seq_lens.append(seq_lens_)
n_nonzeros.append(n_nonzeros_)
if device[:4] == 'cuda':
torch.cuda.synchronize()
torch.cuda.empty_cache()
return masks, receptive_fields, seq_lens, n_nonzeros
@torch.inference_mode()
def precompute_alpha(model, n_seqs, alpha, precomputation, device, random_state,
verbose):
"""Calculate the compressed sensing-associated statistics.
Given an alpha and a set of mask-associated statistics stored in the
precomputation object, generate the sensing matrix/tensor, the regression
coefficients tensor, and the number of probes needed for each layer.
Because this function does not involve computation from the model, it
enables alpha-associated statistics to be generated and evaluated quickly.
Parameters
----------
model: torch.nn.Module
A PyTorch model that can contain any number and types of layers.
However, this model must be defined in a particular way. Specifically,
all of the operations must be defined -in order- in the `__init__`
function. No operations can be performed outside of the context of a
layer in the forward function, such as reshaping or applying
activation functions. See `models.py` for examples.
alpha: float
A multiplier on the number of nonzero values per position to specify
the number of probes.
precomputation: yuzu.precompute.Precomputation
An object that caches the calculated statistics.
device: str, either 'cpu' or 'cuda', optional
The device to save the operations to, in terms of PyTorch contexts.
random_state: int or None, optional
The seed to use for the random state. Use None for no random
seed to be set. Default is None.
verbose: bool, optional
Whether to print out statements showing timings and the progression
of the computation.
Returns
-------
As: list of torch.tensors
A list of the sensing tensors used to construct the probes,
one for each convolution layer.
betas: list of torch.tensors
A list of the regression coefficients used in the decoding step,
one for each convolution layer
n_probes: list of integers
A list of the number of probes necessary for each layer.
"""
As, betas, n_probess = [], [], []
for l, layer in enumerate(model.children()):
n_probes = int(precomputation.n_nonzeros[l][1] * alpha)
# If the layer is a convolution layer, pre-compute the
# random values and regression coefficients.
if isinstance(layer, torch.nn.Conv1d):
A = torch.FloatTensor(n_seqs, n_probes).normal_(0, 1)
A = A.to(device)
mask = precomputation.masks[l]
n_nonzero = precomputation.n_nonzeros[l][1]
seq_len = precomputation.seq_lens[l][1]
fl, fr, idxs = calculate_flanks(seq_len,
precomputation.receptive_fields[l][1])
# Calculate regression statistics for the middle of the
# sequences where a constant number of features are present
phis = A[mask[1][1][1]].reshape(seq_len-fl-fr, n_nonzero, n_probes)
phis = phis.to(device)
# Calculate betas, the regression coefficients
beta = torch.zeros(seq_len, n_nonzero, n_probes, device=device)
for i, idx in enumerate(idxs):
m = mask[1][0][i]
p = A[m]
beta[idx, :len(m)] = torch.linalg.inv(p.matmul(p.T)).matmul(p)
grams = torch.bmm(phis, phis.permute(0, 2, 1))
beta[fl:seq_len-fr] = torch.linalg.inv(grams).bmm(phis)
# Compact alphas
n_nonzero = precomputation.n_nonzeros[l][0]
seq_len = precomputation.seq_lens[l][0]
fl, fr, idxs = calculate_flanks(seq_len,
precomputation.receptive_fields[l][0])
A_ = torch.empty(seq_len, n_probes, n_nonzero, device=device)
A_[fl:seq_len-fr] = A[mask[0][1][1]].reshape(
seq_len-fl-fr, n_nonzero, n_probes).permute(0, 2, 1)
for i, idx in enumerate(idxs):
m = mask[0][0][i]
A_[idx, :, :len(m)] = A[m].T
del A
else:
A_, beta = False, False
As.append(A_)
betas.append(beta)
n_probess.append(n_probes)
return As, betas, n_probess
@torch.inference_mode()
def precompute(model, seq_len, n_choices=4, alpha=None, threshold=0.9999,
use_layers=use_layers, ignore_layers=ignore_layers, device='cpu',
random_state=None, verbose=False):
"""Precomputing properties of the model for a Yuzu-ISM run.
This function will take in a model, a reference sequence, and a set
of sequences that each contain perturbations from the reference, and
return a set of tensors that encode properties of the model that can
speed up subsequent calculation. Because one of these properties is
the empirical receptive field, this function will take time equal to
one full ISM run. However, it only needs to be performed once per
model and alpha setting and the properties can be re-used for any
subsequent reference sequence.
Parameters
----------
model: torch.nn.Module
A PyTorch model that can contain any number and types of layers.
However, this model must be defined in a particular way. Specifically,
all of the operations must be defined -in order- in the `__init__`
function. No operations can be performed outside of the context of a
layer in the forward function, such as reshaping or applying
activation functions. See `models.py` for examples.
seq_len: int
The length of the sequences to operate on.
n_choices: int, optional
The number of categories in the input sequence. This should be 4 for
DNA and 20 for protein inputs.
alpha: float, optional
A multiplier on the number of nonzero values per position to specify
the number of probes. Default is 1.5.
use_layers: tuple
A tuple of the layers that the compressed sensing algorithm should
be applied to. These layers should only have sparse differences in
activation when mutated sequences are run through, such as a convolution.
ignore_layers: tuple, optional
Layers to ignore when passing through. ReLU layers, in particular, can
cause trouble in determining the mask when paired with max pooling layers.
Default is an empty tuple.
device: str, either 'cpu' or 'cuda', optional
The device to save the operations to, in terms of PyTorch contexts.
random_state: int or None, optional
The seed to use for the random state. Use None for no random
seed to be set. Default is None.
verbose: bool, optional
Whether to print out statements showing timings and the progression
of the computation.
Returns
-------
precomputation: yuzu.precompute.Precomputation
An object storing all the precomputation statistics.
"""
if random_state is not None:
random.seed(random_state)
torch.manual_seed(random_state)
if alpha is None:
alphas = numpy.arange(1, 1.5, 0.01)
elif isinstance(alpha, (int, float)):
alphas = numpy.array([alpha])
elif isinstance(alpha, list):
alphas = numpy.array(alpha)
elif isinstance(alpha, numpy.ndarray):
alphas = alpha
else:
raise ValueError("Cannot interpret alpha value. Must be integer, float, list, or numpy.ndarray.")
# Generate a random sequence of the desired shape
idxs = numpy.random.RandomState(0).randn(n_choices, seq_len).argmax(axis=0)
X_0 = numpy.zeros((1, n_choices, seq_len), dtype='float32')
X_0[0, idxs, numpy.arange(seq_len)] = 1
masks, receptive_fields, seq_lens, n_nonzeros = precompute_mask(
model=model, X_0=X_0, use_layers=use_layers,
ignore_layers=ignore_layers, device=device, random_state=random_state,
verbose=verbose)
precomputation = Precomputation(As=None,
betas=None,
masks=masks,
receptive_fields=receptive_fields,
n_probes=None,
seq_lens=seq_lens,
n_nonzeros=n_nonzeros)
## Evaluation suite.
model = model.to(device)
naive_isms = naive_ism(model, X_0, batch_size=128, device='cpu')
results = []
for alpha in alphas:
As, betas, n_probes = precompute_alpha(model=model, n_seqs=3*seq_len,
alpha=alpha, precomputation=precomputation, device=device,
random_state=random_state, verbose=verbose)
precomputation.As = As
precomputation.betas = betas
precomputation.n_probes = n_probes
precomputation.alpha = alpha
yuzu_isms = yuzu_ism(model, X_0, precomputation, device=device)
x = naive_isms.flatten()
y = yuzu_isms.flatten()
mae = numpy.abs(x - y).mean()
pcorr = numpy.corrcoef(x, y)[0, 1]
results.append([alpha, mae, pcorr])
if verbose:
print(alpha, mae, pcorr)
if pcorr > threshold:
break
precomputation.results = numpy.array(results)
return precomputation | yuzu-ism | /yuzu-ism-0.0.1.tar.gz/yuzu-ism-0.0.1/yuzu/precompute.py | precompute.py |
import time
import numpy
import torch
from .models import Flatten
from .models import Unsqueeze
from .utils import safe_to_device
from .utils import calculate_flanks
from .utils import delta_perturbations
global use_layers, ignore_layers, terminal_layers
use_layers = torch.nn.Conv1d, torch.nn.MaxPool1d, torch.nn.AvgPool1d
ignore_layers = torch.nn.ReLU, torch.nn.BatchNorm1d, torch.nn.LogSoftmax
terminal_layers = Unsqueeze, Flatten
@torch.inference_mode()
def _compressed_sensing_convolution(layer, X_delta, A, beta, mask,
n_probes, return_timings=False, verbose=False):
"""Calculate the output of a single layer using compressed sensing.
This function will take a single layer, the input to that layer from
a reference sequence, and the input to that layer from a set of sequences
that each contain perturbations from the reference, and return the output
of the layer for each of the sequences. Naively, this can be done by
simply calling the layer on the sequences, i.e., `layer(X)`. This method
will speed up the computation by using compressed sensing and a reference
sequence to perform a significantly smaller number of calculations.
Specifically, rather than running `X.shape[0]` sequences through the
layer, this approach runs `n_probes` sequences through the layer.
Parameters
----------
layer: torch.nn.Module
A layer in a PyTorch model.
X_0: torch.Tensor, shape=(1, n_filters, seq_len)
A tensor containing the input to the layer from the reference sequence
that ISM is being performed on.
X: torch.Tensor, shape=(n, n_filters, seq_len)
A tensor containing the input to the layer for each sequence being
evaluated.
A: torch.Tensor, shape=(n_probes, n)
A tensor of random Gaussian values for the sensing matrix that
compresses the sequences into probes.
betas: torch.Tensor
A tensor containing slices of the A matrix that are ready to be used to
solve a regression task.
masks: torch.Tensor
A tensors containing a mask of the receptive field for each example.
This mask is empirically derived by running the examples through the
network and recording where positions change with respect to the
reference.
n_probes: int
The number of probes to construct from the total number of sequences
passed in.
verbose: bool, optional
Whether to print out statements showing timings and the progression
of the computation.
Returns
-------
X: torch.Tensor
The output of the model after `X` is passed through all of the layers,
as if one had simply run `model(X)`.
"""
device = str(X_delta.device)[:4]
if verbose:
overall_tic = time.time()
tic = time.time()
bias = torch.clone(layer.bias[:])
layer.bias[:] = 0
n_seqs, n_nonzero, in_filters, seq_len = X_delta.shape
# Construct the probes using the sparse contributions
X_probe = A.matmul(X_delta.permute(0, 3, 1, 2)).permute(0, 2, 3, 1)
X_probe = X_probe.reshape(-1, in_filters, seq_len).contiguous()
if verbose:
if device == 'cuda': torch.cuda.synchronize()
tic_a = time.time() - tic
tic = time.time()
# Run the probes, and the original sequence, through the convolution
Y = layer(X_probe)
Y = Y.reshape(n_seqs, -1, Y.shape[1], seq_len)
Y = Y.permute(0, 3, 1, 2).contiguous()
if verbose:
if device == 'cuda': torch.cuda.synchronize()
tic_b = time.time() - tic
tic = time.time()
X = torch.matmul(beta, Y).permute(0, 2, 3, 1)
if verbose:
if device == 'cuda': torch.cuda.synchronize()
tic_c = time.time() - tic
tic = time.time()
if verbose:
if device == 'cuda': torch.cuda.synchronize()
final_tic = time.time() - overall_tic
print("A:{:3.3}\tB:{:3.3}\tC:{:3.3}\tTot:{:3.3}\t".format(tic_a, tic_b, tic_c, final_tic))
layer.bias[:] = bias
if return_timings == True:
t = tic_a, tic_b, tic_c, final_tic
return X, t
return X
@torch.inference_mode()
def _delta_pooling(layer, X_0, X_delta, masks, receptive_fields, n_probes,
seq_lens, n_nonzeros, n_perturbs):
"""Performs an exact pooling operation given only the deltas.
This function will take in the reference sequence and the delta matrix and
will perform an exact pooling layer without reconstructing the sequences
in their entirety. Unlike the compressed convolution layer this operation
is exact and accounts for instances where the kernel width of the pooling
operation falls outside the receptive field. This function works for any
type of pooling layer, not just max-pooling.
Parameters
----------
layer: torch.nn.Module
The pooling operation to be applied.
X_0: torch.Tensor, shape=(1, n_filters, seq_lens[0])
A tensor containing the input to the layer from the reference sequence
that ISM is being performed on.
X_delta: torch.Tensor, shape=(n, n_nonzeros[0], seq_lens[0])
A tensor containing only the deltas between the reference sequence and
the perturbed sequences. This can be thought of as taking the values
that are within the receptive field, a diagonal band along the original
set of sequences, and pushing them up into a long skinny matrix.
masks: tuple list of torch.Tensor
A list of tensors containing a mask of the receptive field
for each example. This mask is empirically derived by running
the examples through the network and recording where positions
change with respect to the reference. The first element in the
tuple contains the masks before the pooling operation is applied and
the second element contains the masks after the pooling operation
is applied. These values are precomputed as part of the `precompute`
function.
receptive_fields: tuple
A tuple of integers indicating the maximum receptive field size
before and after the layer is applied. The receptive field is the span
from the left-most sequence position to the right-most sequence
position that are changed in the given sequences, even if some of the
internal positions are not changed. These values are precomputed as
part of the `precompute` function.
"""
n_seqs, n_filters, _ = X_0.shape
device = str(X_delta.device)
seq_len0, seq_len1 = seq_lens
rf0, rf1 = receptive_fields
fl0, fr0, idxs0 = calculate_flanks(seq_len0, rf0)
fl1, fr1, idxs1 = calculate_flanks(seq_len1, rf1)
ks = layer.kernel_size
size = int((numpy.ceil(rf0 / ks) + 1) * ks)
step = (n_nonzeros[0] // rf0) * ks
offset = n_nonzeros[0] - fl0 * n_nonzeros[0] // rf0
##
mask_map = numpy.maximum(numpy.arange(n_perturbs) - offset, 0) // step * ks
mask_map2 = numpy.maximum(numpy.arange(n_perturbs) - offset, 0) // step
row_mask0 = safe_to_device(masks[0][1][0], 'cpu')
col_mask0 = safe_to_device(masks[0][1][1], 'cpu')
row_mask1 = safe_to_device(masks[1][1][0], 'cpu')
col_mask1 = safe_to_device(masks[1][1][1], 'cpu')
row_mask00 = row_mask0 - mask_map[col_mask0]
row_mask10 = row_mask1 - mask_map2[col_mask1]
rows = torch.repeat_interleave(torch.arange(n_perturbs), size)
rows = rows.reshape(n_perturbs, size)
t_min = torch.tensor(seq_len0-1).expand(n_perturbs, size)
cols = torch.tile(torch.arange(size), dims=(n_perturbs, 1))
cols = torch.minimum((cols.T + mask_map[rows[:,0]]).T, t_min)
##
# .permute(0, 2, 1) -> 0, 2, 1
# .permute(1, 0, 2) -> 2, 0, 1
X1 = X_0.unsqueeze(1).expand(-1, n_perturbs, -1, -1).permute(1, 3, 0, 2)
X1 = X1[(rows, cols)].permute(1, 0, 2, 3)
#X1 = X1.reshape(X1.shape[0]*X1.shape[1], X1.shape[2], X1.shape[3])
for j, idx in enumerate(idxs0):
r = safe_to_device(masks[0][0][j], "cpu")
c = torch.full_like(r, idx) - mask_map[r]
X1[(c, r)] += X_delta[:, :len(r), :, idx].permute(1, 0, 2)
X_update = X_delta[:, :, :, fl0:seq_len0-fr0]
# .permute(2, 0, 1).reshape(-1, X_update.shape[1])
X_update = X_update.permute(3, 1, 0, 2).reshape(-1, n_seqs, n_filters)
X1[(row_mask00, col_mask0)] += X_update
# .permute(1, 2, 0)
X1 = X1.permute(2, 1, 3, 0).reshape(n_perturbs*n_seqs, n_filters, -1)
##
X_0 = layer(X_0)
# .permute(2, 0, 1)
X_1 = X_0.unsqueeze(1).expand(-1, n_perturbs, -1, -1).permute(3, 1, 0, 2)
# .permute(2, 0, 1)
X1 = layer(X1)
X1 = X1.reshape(n_seqs, n_perturbs, n_filters, -1).permute(3, 1, 0, 2)
X_delta_ = X1[(row_mask10, col_mask1)] - X_1[(row_mask1, col_mask1)]
X_delta_ = X_delta_.reshape(seq_len1-fl1-fr1, n_nonzeros[1], n_seqs, n_filters)
X_delta_ = X_delta_.permute(1, 0, 2, 3)
X_delta = torch.zeros(n_nonzeros[1], seq_len1, n_seqs, n_filters, device=device)
X_delta[:, fl1:seq_len1-fr1] = X_delta_
for j, idx in enumerate(idxs1):
r = safe_to_device(masks[1][0][j], "cpu")
c = torch.full_like(r, idx) - mask_map2[r]
X_delta[:len(r), idx] = X1[(c, r)] - X_0[:, :, idx].unsqueeze(0)
X_delta = X_delta.permute(2, 0, 3, 1).contiguous()
del X_update, X1, rows, cols
return X_0, X_delta
@torch.inference_mode()
def _yuzu_ism(model, X_0, precomputation, device='cpu', use_layers=use_layers,
ignore_layers=ignore_layers, terminal_layers=terminal_layers, verbose=False):
"""Perform ISM using compressed sensing to reduce the necessary compute.
This function will take a model, a reference sequence, and a set of
sequences that each contain pertubations from the reference, and return
predicted outputs from the model for each of those sequences. Naively,
this can be done by simply calling the model on the sequences, i.e.,
`model(X)`. This approach uses compressed sensing to leverage the
sparsity pattern in the difference between the reference the and
perturbed sequence at each intermediary layer to speed up computations.
Specifically, rather than running `X.shape[0]` sequences through each
layer, this approach runs `n_probess[i]` sequences through layer i.
Parameters
----------
model: torch.nn.Module
A PyTorch model that can contain any number and types of layers.
However, this model must be defined in a particular way. Specifically,
all of the operations must be defined -in order- in the `__init__`
function. No operations can be performed outside of the context of a
layer in the forward function, such as reshaping or applying
activation functions. See `models.py` for examples.
X_0: torch.Tensor, shape=(1, n_filters, seq_len)
A tensor containing the reference sequence that ISM is being
performed on.
precomputation: yuzu.Precomputation
An object containing the precomputation performed using the
`yuzu.precompute` function.
use_layers: tuple, optional
The layer classes to apply compressed sensing to.
ignore_layers: tuple, optional
The layer classes to ignore when iterating through the layers.
terminal_layers: tuple, optional
The layer classes that, when encountered, cause the method to stop
making calculations with the deltas. The calculations will return
to the original space and layers will be applied normally from
this point.
verbose: bool, optional
Whether to print out statements showing timings and the progression
of the computation. Default is False.
Returns
-------
X: torch.Tensor
The output of the model after `X` is passed through all of the layers,
as if one had simply run `model(X)`.
"""
layer_timings, within_layer_timings = [], []
n_seqs, n_choices, seq_len = X_0.shape
X_idxs = X_0.argmax(axis=1)
X_delta = delta_perturbations(X_0)
X_0 = torch.from_numpy(X_0)
model = safe_to_device(model, device)
X_delta = safe_to_device(X_delta, device)
X_0 = safe_to_device(X_0, device)
n_perturbs = X_delta.shape[1] * X_delta.shape[-1]
_, n_nonzero, in_filters, seq_len = X_delta.shape
deltas = True
for i, layer in enumerate(model.children()):
tic = time.time()
within_layer_times = None
n_probes = precomputation.n_probes[i]
# If it is not computationally efficient to use deltas and the deltas
# have already been decoded back to the full sequences, simply pass
# those sequences through the next layer.
# X_i -> X_i+1
if deltas == False:
X_0 = layer(X_0)
X = X.reshape(X.shape[0]*X.shape[1], *X.shape[2:])
X = layer(X)
X = X.reshape(n_seqs, -1, *X.shape[1:])
if verbose:
print("A", layer, time.time() - tic)
# If the layer is a Flatten operation, run the reference sequence
# through the layer but ignore the deltas. We are assuming that the
# Flatten layer will come after a convolution layer but before a
# dense layer, and we have an efficient way for decoding those.
elif isinstance(layer, Flatten):
X_0 = layer(X_0)
if verbose:
print("F", layer, time.time() - tic)
# If the layer is a linear layer and we still have deltas then we
# can calculate the output of the linear layer using the sparse
# deltas and the weight matrix of the linear layer in a fairly
# easy manner.
# X_conv_out -> X_dense_out
elif isinstance(layer, torch.nn.Linear):
X_0 = layer(X_0)
X = torch.tile(X_0.unsqueeze(1), (1, n_perturbs, 1))
_, _, n_filters, seq_len = X_delta.shape
fl, fr, idxs = calculate_flanks(seq_len,
precomputation.receptive_fields[i][0])
n_out = layer.weight.shape[0]
weight = layer.weight.reshape(n_out, seq_len, n_filters)
weight = weight.permute(1, 2, 0).contiguous()
# .permute(2, 0, 1)
X_delta = X_delta.permute(0, 3, 1, 2).contiguous()
X_update = torch.matmul(X_delta, weight)
mask = precomputation.masks[i][0][1][1]
mask = mask.expand(n_seqs, n_out, -1).permute(0, 2, 1)
X.scatter_add_(1, mask, X_update[:, fl:seq_len-fr].reshape(n_seqs, -1, n_out))
for j, idx in enumerate(idxs):
m = precomputation.masks[i][0][0][j]
X[:, m] += X_update[:, idx, :len(m)]
deltas = False
del X_delta, X_update
if verbose:
print("Z", layer, time.time() - tic)
# If it previously was computationally efficient to operate on deltas
# but is now no longer, or if you've hit a terminal layer where the
# deltas can't be used anymore, decode the full sequences from the deltas and
# pass them through the next layer.
# X_dense -> X
elif n_probes > n_perturbs or isinstance(layer, terminal_layers):
_, n_filters, seq_len = X_0.shape
fl, fr, idxs = calculate_flanks(seq_len,
precomputation.receptive_fields[i][0])
X = torch.tile(X_0.unsqueeze(1), dims=(1, n_perturbs, 1, 1))
for j, idx in enumerate(idxs):
m = precomputation.masks[i][0][0][j]
X[:, m, :, idx] += X_delta[:, :len(m), :, idx]
X_update = X_delta[:, :, :, fl:seq_len-fr].permute(3, 1, 0, 2)
mask = precomputation.masks[i][0][1]
X = X.permute(3, 1, 0, 2)
X[mask] += X_update.reshape(-1, n_seqs, n_filters)
X = X.permute(2, 1, 3, 0)
X = X.reshape(n_seqs*n_perturbs, n_filters, seq_len)
#
X_0 = layer(X_0)
X = layer(X)
_, n_filters, seq_len = X.shape
X = X.reshape(n_seqs, n_perturbs, n_filters, seq_len)
deltas = False
del X_delta, X_update
if verbose:
print("B", layer, time.time() - tic)
# If you're still operating on the deltas but encounter a max pooling
# layer, decode the full sequences from the deltas, pass them through
# the max pooling layer, and recover the deltas on the other side.
elif isinstance(layer, torch.nn.MaxPool1d):
X_0, X_delta = _delta_pooling(layer=layer,
X_0=X_0, X_delta=X_delta,
masks=precomputation.masks[i],
receptive_fields=precomputation.receptive_fields[i],
n_probes=precomputation.n_probes[i],
seq_lens=precomputation.seq_lens[i],
n_nonzeros=precomputation.n_nonzeros[i],
n_perturbs=n_perturbs)
if verbose:
print("M", layer, time.time() - tic)
# If it is still computationally efficient to operate on deltas
# and the layer is a type that can be quickly processed using
# compressed sensing then use the Yuzu-ISM procedure
elif isinstance(layer, use_layers):
X_0 = layer(X_0)
X_delta = _compressed_sensing_convolution(layer=layer,
X_delta=X_delta, A=precomputation.As[i],
beta=precomputation.betas[i],
mask=precomputation.masks[i],
n_probes=precomputation.n_probes[i],
return_timings=verbose,
verbose=verbose)
if verbose:
within_layer_times = X_delta[1]
X_delta = X_delta[0]
print("D", layer, time.time() - tic)
# If it is still computationally efficient to operate on deltas
# but the layer is a pass-through layer, e.g. activations, then
# add the reference in, pass through the layer, and subtract
# the reference out
# X_dense -> X_dense
else:
X_delta += X_0.unsqueeze(1)
X_delta = X_delta.reshape(-1, X_0.shape[1], X_0.shape[2])
X_delta = layer(X_delta)
X_0 = layer(X_0)
X_delta = X_delta.reshape(n_seqs, -1, X_0.shape[1], X_0.shape[2])
X_delta -= X_0.unsqueeze(1)
if verbose:
print("E", layer, time.time() - tic)
within_layer_timings.append(within_layer_times)
layer_timings.append(time.time() - tic)
if deltas == False:
seq_len = precomputation.seq_lens[0][0]
Xfs = torch.square(X - X_0.unsqueeze(1)).sum(axis=-1)
if len(Xfs.shape) == 3:
Xfs = torch.sum(Xfs, axis=-1)
Xfs = torch.sqrt(Xfs).reshape(n_seqs, seq_len, n_choices-1)
else:
### Calculate ISM scores
seq_len = precomputation.seq_lens[-1][1]
fl, fr, idxs = calculate_flanks(seq_len,
precomputation.receptive_fields[-1][1])
X_ism = torch.sum(torch.square(X_delta), dim=2)
Xfs = torch.zeros(n_seqs, n_perturbs, device=device)
mask = precomputation.masks[-1][1][1][1]
X_ism_ = X_ism[:, :, fl:seq_len-fr]
X_ism_ = X_ism_.permute(0, 2, 1).reshape(n_seqs, -1)
Xfs.scatter_add_(1, mask.expand(n_seqs, -1), X_ism_)
for i, idx in enumerate(idxs):
m = precomputation.masks[-1][1][0][i]
Xfs[:, m] += X_ism[:, :len(m), idx]
seq_len = precomputation.seq_lens[0][0]
Xfs = torch.sqrt(Xfs)
Xfs = Xfs.reshape(n_seqs, seq_len, n_choices-1)
seq_len = precomputation.seq_lens[0][0]
j_idxs = torch.arange(n_seqs*seq_len)
X_ism = torch.zeros(n_seqs*seq_len, n_choices, device=device)
for i in range(1, n_choices):
i_idxs = (X_idxs.flatten() + i) % n_choices
X_ism[j_idxs, i_idxs] = Xfs[:, :, i-1].flatten()
X_ism = X_ism.reshape(n_seqs, seq_len, n_choices).permute(0, 2, 1)
X_ism = safe_to_device(X_ism, "cpu").numpy()
#print("AFTER TIME: {:4.4} {:4.4} {:4.4}".format(time.time() - tic, toc - tic, time.time() - toc))
return X_ism, layer_timings, within_layer_timings
def yuzu_ism(model, X_0, precomputation, batch_size=1, device='cpu',
use_layers=use_layers, ignore_layers=ignore_layers,
terminal_layers=terminal_layers, return_timings=False, verbose=False):
"""Perform ISM using compressed sensing to reduce the necessary compute.
This function will take a model, a reference sequence, and a set of
sequences that each contain pertubations from the reference, and return
predicted outputs from the model for each of those sequences. Naively,
this can be done by simply calling the model on the sequences, i.e.,
`model(X)`. This approach uses compressed sensing to leverage the
sparsity pattern in the difference between the reference the and
perturbed sequence at each intermediary layer to speed up computations.
Specifically, rather than running `X.shape[0]` sequences through each
layer, this approach runs `n_probess[i]` sequences through layer i.
Parameters
----------
model: torch.nn.Module
A PyTorch model that can contain any number and types of layers.
However, this model must be defined in a particular way. Specifically,
all of the operations must be defined -in order- in the `__init__`
function. No operations can be performed outside of the context of a
layer in the forward function, such as reshaping or applying
activation functions. See `models.py` for examples.
X_0: torch.Tensor, shape=(1, n_filters, seq_len)
A tensor containing the reference sequence that ISM is being
performed on.
precomputation: yuzu.Precomputation
An object containing the precomputation performed using the
`yuzu.precompute` function.
batch_size: int, optional
The number of sequences to decode at the same time. Default is 1.
use_layers: tuple, optional
The layer classes to apply compressed sensing to.
ignore_layers: tuple, optional
The layer classes to ignore when iterating through the layers.
terminal_layers: tuple, optional
The layer classes that, when encountered, cause the method to stop
making calculations with the deltas. The calculations will return
to the original space and layers will be applied normally from
this point.
verbose: bool, optional
Whether to print out statements showing timings and the progression
of the computation. Default is False.
Returns
-------
X: torch.Tensor
The output of the model after `X` is passed through all of the layers,
as if one had simply run `model(X)`.
"""
X_ism, layer_timings, within_layer_timings = [], [], []
model = model.eval()
starts = numpy.arange(0, len(X_0), batch_size)
for start in starts:
X = X_0[start:start+batch_size]
X_ism_, layer_timings_, within_layer_timings_ = _yuzu_ism(model=model,
X_0=X, precomputation=precomputation, device=device,
use_layers=use_layers, ignore_layers=ignore_layers,
terminal_layers=terminal_layers, verbose=verbose)
X_ism.append(X_ism_)
layer_timings.append(layer_timings_)
within_layer_timings.append(within_layer_timings_)
if return_timings:
return numpy.vstack(X_ism), layer_timings, within_layer_timings
return numpy.vstack(X_ism) | yuzu-ism | /yuzu-ism-0.0.1.tar.gz/yuzu-ism-0.0.1/yuzu/yuzu_ism.py | yuzu_ism.py |
import time
import numpy
import torch
import itertools as it
try:
import tensorflow as tf
except:
pass
def perturbations(X_0):
"""Produce all edit-distance-one pertuabtions of a sequence.
This function will take in a single one-hot encoded sequence of length N
and return a batch of N*(n_choices-1) sequences, each containing a single
perturbation from the given sequence.
Parameters
----------
X_0: numpy.ndarray, shape=(n_seqs, n_choices, seq_len)
A one-hot encoded sequence to generate all potential perturbations.
Returns
-------
X: torch.Tensor, shape=(n_seqs, (n_choices-1)*seq_len, n_choices, seq_len)
Each single-position perturbation of seq.
"""
if not isinstance(X_0, numpy.ndarray):
raise ValueError("X_0 must be of type numpy.ndarray, not {}".format(type(X_0)))
if len(X_0.shape) != 3:
raise ValueError("X_0 must have three dimensions: (n_seqs, n_choices, seq_len).")
n_seqs, n_choices, seq_len = X_0.shape
idxs = X_0.argmax(axis=1)
X_0 = torch.from_numpy(X_0)
n = seq_len*(n_choices-1)
X = torch.tile(X_0, (n, 1, 1))
X = X.reshape(n, n_seqs, n_choices, seq_len).permute(1, 0, 2, 3)
for i in range(n_seqs):
for k in range(1, n_choices):
idx = numpy.arange(seq_len)*(n_choices-1) + (k-1)
X[i, idx, idxs[i], numpy.arange(seq_len)] = 0
X[i, idx, (idxs[i]+k) % n_choices, numpy.arange(seq_len)] = 1
return X
def delta_perturbations(X_0):
"""Produce the deltas of all edit-distance-one perturbations of a sequence.
This function is similar to the `perturbation` function except that, rather
than returning the entire sequence, it returns a compressed version of the
deltas, i.e., where the sequence is changing.
Parameters
----------
X_0: numpy.ndarray, shape=(n_seqs, n_choices, seq_len)
A one-hot encoded sequence to generate all potential perturbations.
Returns
-------
X: torch.Tensor, shape=(n_seqs, (n_choices-1)*seq_len, n_choices, seq_len)
Each single-position perturbation of seq.
"""
if not isinstance(X_0, numpy.ndarray):
raise ValueError("X_0 must be of type numpy.ndarray, not {}".format(type(X_0)))
if len(X_0.shape) != 3:
raise ValueError("X_0 must have three dimensions: (n_seqs, n_choices, seq_len).")
n_seqs, n_choices, seq_len = X_0.shape
idxs = X_0.argmax(axis=1)
X = numpy.zeros((n_seqs, n_choices-1, n_choices, seq_len), dtype='float32')
for i in range(n_seqs):
for k in range(n_choices-1):
X[i, k, idxs[i], numpy.arange(seq_len)] = -1
X[i, k, (idxs[i] + k + 1) % n_choices, numpy.arange(seq_len)] = 1
return torch.from_numpy(X)
def calculate_flanks(seq_len, receptive_field):
"""A helper function to calculate the flanking regions.
This function will return the flanking regions given a receptive field and
a sequence length. The flanking regions are those where the receptive field
falls off the side of the sequence length which makes normal tensor
operations not work. Instead, we have to handle these positions one at a
time.
Parameters
----------
seq_len: int
The length of the sequence we are calculating the flanking regions for.
receptive_field: int
The receptive field of the model.
Returns
-------
fl: int
The flanking region on the left side.
fr: int
The flanking region on the right side.
idxs: list
The position indexes of the flanking regions.
"""
fl = receptive_field // 2
fr = receptive_field - fl - receptive_field % 2
idxs = list(it.chain(range(fl), range(seq_len-fr, seq_len)))
return fl, fr, idxs
def safe_to_device(X, device):
"""Move the tensor or model to the device if it doesn't already live there.
This function will avoid copying if the object already lives in the
correct context. Works on PyTorch tensors and PyTorch models that inherit
from the torch.nn.Module class.
Parameters
----------
X: torch.tensor
The tensor to move to a device.
device: str
The PyTorch context to move the tensor to.
Returns
-------
X: torch.tensor
The tensor on the desired device.
"""
if isinstance(X, torch.Tensor):
if X.device == device:
return X
return X.to(device)
elif isinstance(X, torch.nn.Module):
if next(X.parameters()).device == device:
return X
return X.to(device)
def tensorflow_to_pytorch(tf_model, torch_model):
"""Copy the weights from a Tensorflow model to a PyTorch model.
This function will take in a Tensorflow model and a PyTorch model
with the same architecture and will transfer the weights from the
TensorFlow model to the PyTorch model. It will disable additional
functionality provided by PyTorch or Tensorflow to ensure that the
models are equivalent.
Parameters
----------
tf_model: tf.keras.Model
A model implemented in Tensorflow
torch_model: torch.nn.Module
A model implemented in PyTorch
Returns
-------
torch_model: torch.nn.Module
A model implemented in PyTorch with the weights transferred
from the Tensorflow model.
"""
try:
tf_use_layers = (tf.keras.layers.Conv1D,
tf.keras.layers.BatchNormalization,
tf.keras.layers.Dense)
except:
raise ValueError("TensorFlow must be installed to use this function.")
torch_use_layers = (torch.nn.Conv1d,
torch.nn.BatchNorm1d,
torch.nn.Linear)
model2_layers = list(torch_model.children())
with torch.no_grad():
i, j = -1, -1
while i < len(tf_model.layers) - 1 and j < len(model2_layers) - 1:
while i < len(tf_model.layers) - 1:
i += 1
if isinstance(tf_model.layers[i], tf_use_layers):
break
while j < len(model2_layers) - 1:
j += 1
if isinstance(model2_layers[j], torch_use_layers):
break
if isinstance(tf_model.layers[i], tf_use_layers[0]):
weight = numpy.array(tf_model.layers[i].weights[0])
weight = weight.transpose(2, 1, 0)
bias = numpy.array(tf_model.layers[i].weights[1])
model2_layers[j].weight[:] = torch.tensor(weight)
model2_layers[j].bias[:] = torch.tensor(bias)
elif isinstance(tf_model.layers[i], tf_use_layers[1]):
mu = numpy.array(tf_model.layers[i].weights[2])
sigma = numpy.array(tf_model.layers[i].weights[3])
model2_layers[j].affine = False
model2_layers[j].eps = tf_model.layers[i].epsilon
model2_layers[j].running_mean[:] = torch.tensor(mu)
model2_layers[j].running_var[:] = torch.tensor(sigma)
elif isinstance(tf_model.layers[i], tf_use_layers[2]):
weight = numpy.array(tf_model.layers[i].weights[0])
bias = numpy.array(tf_model.layers[i].weights[1])
model2_layers[j].weight[:] = torch.tensor(weight.T)
model2_layers[j].bias[:] = torch.tensor(bias)
return torch_model | yuzu-ism | /yuzu-ism-0.0.1.tar.gz/yuzu-ism-0.0.1/yuzu/utils.py | utils.py |
import numpy
import torch
from .utils import perturbations
@torch.inference_mode()
def naive_ism(model, X_0, batch_size=128, device='cpu'):
"""In-silico mutagenesis saliency scores.
This function will perform in-silico mutagenesis in a naive manner, i.e.,
where each input sequence has a single mutation in it and the entirety
of the sequence is run through the given model. It returns the ISM score,
which is a vector of the L2 difference between the reference sequence
and the perturbed sequences with one value for each output of the model.
Parameters
----------
model: torch.nn.Module
The model to use.
X_0: numpy.ndarray
The one-hot encoded sequence to calculate saliency for.
batch_size: int, optional
The size of the batches.
device: str, optional
Whether to use a 'cpu' or 'gpu'.
Returns
-------
X_ism: numpy.ndarray
The saliency score for each perturbation.
"""
n_seqs, n_choices, seq_len = X_0.shape
X_idxs = X_0.argmax(axis=1)
X = perturbations(X_0)
X_0 = torch.from_numpy(X_0)
if device[:4] != str(next(model.parameters()).device):
model = model.to(device)
if device[:4] != X_0.device:
X_0 = X_0.to(device)
model = model.eval()
reference = model(X_0).unsqueeze(1)
starts = numpy.arange(0, X.shape[1], batch_size)
isms = []
for i in range(n_seqs):
y = []
for start in starts:
X_ = X[i, start:start+batch_size]
if device[:4] == 'cuda':
X_ = X_.to(device)
y_ = model(X_)
y.append(y_)
del X_
y = torch.cat(y)
ism = torch.square(y - reference[i]).sum(axis=-1)
if len(ism.shape) == 2:
ism = ism.sum(axis=-1)
ism = torch.sqrt(ism)
isms.append(ism)
if device[:4] == 'cuda':
torch.cuda.synchronize()
torch.cuda.empty_cache()
isms = torch.stack(isms)
isms = isms.reshape(n_seqs, seq_len, n_choices-1)
j_idxs = torch.arange(n_seqs*seq_len)
X_ism = torch.zeros(n_seqs*seq_len, n_choices, device=device)
for i in range(1, n_choices):
i_idxs = (X_idxs.flatten() + i) % n_choices
X_ism[j_idxs, i_idxs] = isms[:, :, i-1].flatten()
X_ism = X_ism.reshape(n_seqs, seq_len, n_choices).permute(0, 2, 1)
if device[:4] == 'cuda':
X_ism = X_ism.cpu()
X_ism = X_ism.numpy()
return X_ism | yuzu-ism | /yuzu-ism-0.0.1.tar.gz/yuzu-ism-0.0.1/yuzu/naive_ism.py | naive_ism.py |
import time
import numpy
import torch
import random
class Flatten(torch.nn.Module):
def __init__(self):
super(Flatten, self).__init__()
def forward(self, x):
return x.permute(0, 2, 1).contiguous().view(x.shape[0], -1)
class Unsqueeze(torch.nn.Module):
def __init__(self, dim):
super(Unsqueeze, self).__init__()
self.dim = dim
def forward(self, x):
return x.unsqueeze(self.dim)
class OneLayer(torch.nn.Module):
def __init__(self, n_inputs, n_filters=64, kernel_size=7, seq_len=None, random_state=0):
super(OneLayer, self).__init__()
torch.manual_seed(random_state)
self.conv = torch.nn.Conv1d(n_inputs, n_filters, kernel_size=kernel_size, padding=kernel_size // 2)
def forward(self, X):
with torch.no_grad():
return self.conv(X)
class ToyNet(torch.nn.Module):
def __init__(self, n_inputs, n_filters=32, kernel_size=7, seq_len=None, random_state=0):
super(ToyNet, self).__init__()
torch.manual_seed(random_state)
self.conv1 = torch.nn.Conv1d(n_inputs, n_filters, kernel_size=kernel_size, padding=kernel_size // 2)
self.relu1 = torch.nn.ReLU()
self.conv2 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=kernel_size, padding=kernel_size // 2)
self.relu2 = torch.nn.ReLU()
self.conv3 = torch.nn.Conv1d(n_filters, 2, kernel_size=kernel_size, padding=kernel_size // 2)
def forward(self, X):
with torch.no_grad():
return self.conv3(self.relu2(self.conv2(self.relu1(self.conv1(X)))))
class DeepSEA(torch.nn.Module):
def __init__(self, n_inputs, seq_len=None, random_state=0):
super(DeepSEA, self).__init__()
torch.manual_seed(random_state)
k = 4
self.conv1 = torch.nn.Conv1d(4, 320, kernel_size=2*k+1, padding=k)
self.relu1 = torch.nn.ReLU()
self.mp1 = torch.nn.MaxPool1d(k)
self.conv2 = torch.nn.Conv1d(320, 480, kernel_size=2*k+1, padding=k)
self.relu2 = torch.nn.ReLU()
self.mp2 = torch.nn.MaxPool1d(k)
self.conv3 = torch.nn.Conv1d(480, 960, kernel_size=2*k+1, padding=k)
self.relu3 = torch.nn.ReLU()
self.reshape = Flatten()
self.fc = torch.nn.Linear((seq_len // k // k) * 960, 925)
self.sigmoid = torch.nn.Sigmoid()
self.unsqueeze = Unsqueeze(1)
def forward(self, X):
with torch.no_grad():
X = self.mp1(self.relu1(self.conv1(X)))
X = self.mp2(self.relu2(self.conv2(X)))
X = self.relu3(self.conv3(X))
X = self.reshape(X)
X = self.sigmoid(self.fc(X))
X = self.unsqueeze(X)
return X
class Basset(torch.nn.Module):
def __init__(self, n_inputs, seq_len=None, random_state=0):
super(Basset, self).__init__()
torch.manual_seed(random_state)
self.conv1 = torch.nn.Conv1d(4, 300, kernel_size=19, padding=9)
self.relu1 = torch.nn.ReLU()
self.bn1 = torch.nn.BatchNorm1d(300)
self.maxpool1 = torch.nn.MaxPool1d(3)
self.conv2 = torch.nn.Conv1d(300, 200, kernel_size=11, padding=5)
self.relu2 = torch.nn.ReLU()
self.bn2 = torch.nn.BatchNorm1d(200)
self.maxpool2 = torch.nn.MaxPool1d(4)
self.conv3 = torch.nn.Conv1d(200, 200, kernel_size=7, padding=3)
self.relu3 = torch.nn.ReLU()
self.bn3 = torch.nn.BatchNorm1d(200)
self.maxpool3 = torch.nn.MaxPool1d(4)
self.reshape = Flatten()
self.fc1 = torch.nn.Linear((seq_len // 3 // 4 // 4) * 200, 1000)
self.relu4 = torch.nn.ReLU()
self.bn4 = torch.nn.BatchNorm1d(1000)
self.fc2 = torch.nn.Linear(1000, 1000)
self.relu5 = torch.nn.ReLU()
self.bn5 = torch.nn.BatchNorm1d(1000)
self.fc3 = torch.nn.Linear(1000, 164)
self.unsqueeze = Unsqueeze(1)
def forward(self, X):
with torch.no_grad():
X = self.maxpool1(self.bn1(self.relu1(self.conv1(X))))
X = self.maxpool2(self.bn2(self.relu2(self.conv2(X))))
X = self.maxpool3(self.bn3(self.relu3(self.conv3(X))))
X = self.reshape(X)
X = self.bn4(self.relu4(self.fc1(X)))
X = self.bn5(self.relu5(self.fc2(X)))
X = self.fc3(X)
X = self.unsqueeze(X)
return X
class FactorizedBasset(torch.nn.Module):
def __init__(self, n_inputs, seq_len=None, random_state=0):
super(FactorizedBasset, self).__init__()
torch.manual_seed(random_state)
#
self.conv11 = torch.nn.Conv1d(n_inputs, 48, kernel_size=3, padding=1)
self.bn11 = torch.nn.BatchNorm1d(48)
self.relu11 = torch.nn.ReLU()
self.conv12 = torch.nn.Conv1d(48, 64, kernel_size=3, padding=1)
self.bn12 = torch.nn.BatchNorm1d(64)
self.relu12 = torch.nn.ReLU()
self.conv13 = torch.nn.Conv1d(64, 100, kernel_size=3, padding=1)
self.bn13 = torch.nn.BatchNorm1d(100)
self.relu13 = torch.nn.ReLU()
self.conv14 = torch.nn.Conv1d(100, 150, kernel_size=7, padding=3)
self.bn14 = torch.nn.BatchNorm1d(150)
self.relu14 = torch.nn.ReLU()
self.conv15 = torch.nn.Conv1d(150, 300, kernel_size=7, padding=3)
self.bn15 = torch.nn.BatchNorm1d(300)
self.relu15 = torch.nn.ReLU()
self.mp1 = torch.nn.MaxPool1d(3)
#
self.conv21 = torch.nn.Conv1d(300, 200, kernel_size=7, padding=3)
self.bn21 = torch.nn.BatchNorm1d(200)
self.relu21 = torch.nn.ReLU()
self.conv22 = torch.nn.Conv1d(200, 200, kernel_size=3, padding=1)
self.bn22 = torch.nn.BatchNorm1d(200)
self.relu22 = torch.nn.ReLU()
self.conv23 = torch.nn.Conv1d(200, 200, kernel_size=3, padding=1)
self.bn23 = torch.nn.BatchNorm1d(200)
self.relu23 = torch.nn.ReLU()
self.mp2 = torch.nn.MaxPool1d(4)
#
self.conv3 = torch.nn.Conv1d(200, 200, kernel_size=7, padding=3)
self.bn3 = torch.nn.BatchNorm1d(200)
self.relu3 = torch.nn.ReLU()
self.mp3 = torch.nn.MaxPool1d(4)
self.flatten = Flatten()
self.fc1 = torch.nn.Linear((seq_len // 3 // 4 // 4) * 200, 1000)
self.relu4 = torch.nn.ReLU()
self.bn4 = torch.nn.BatchNorm1d(1000)
self.fc2 = torch.nn.Linear(1000, 1000)
self.relu5 = torch.nn.ReLU()
self.bn5 = torch.nn.BatchNorm1d(1000)
self.fc3 = torch.nn.Linear(1000, 1)
self.unsqueeze = Unsqueeze(1)
def forward(self, x):
with torch.no_grad():
x = self.relu11(self.bn11(self.conv11(x)))
x = self.relu12(self.bn12(self.conv12(x)))
x = self.relu13(self.bn13(self.conv13(x)))
x = self.relu14(self.bn14(self.conv14(x)))
x = self.relu15(self.bn15(self.conv15(x)))
x = self.mp1(x)
x = self.relu21(self.bn21(self.conv21(x)))
x = self.relu22(self.bn22(self.conv22(x)))
x = self.relu23(self.bn23(self.conv23(x)))
x = self.mp2(x)
x = self.relu3(self.bn3(self.conv3(x)))
x = self.mp3(x)
x = self.flatten(x)
x = self.bn4(self.relu4(self.fc1(x)))
x = self.bn5(self.relu5(self.fc2(x)))
x = self.fc3(x)
x = self.unsqueeze(x)
return x
class BPNet(torch.nn.Module):
def __init__(self, n_inputs, n_filters=64, kernel_size=21, seq_len=None, n_layers=4, random_state=0):
super(BPNet, self).__init__()
torch.manual_seed(random_state)
self.iconv = torch.nn.Conv1d(n_inputs, n_filters, kernel_size=21, padding=10)
self.irelu = torch.nn.ReLU()
self.dconv1 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=2, dilation=2)
self.drelu1 = torch.nn.ReLU()
self.dconv2 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=4, dilation=4)
self.drelu2 = torch.nn.ReLU()
self.dconv3 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=8, dilation=8)
self.drelu3 = torch.nn.ReLU()
#self.dconv4 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=16, dilation=16)
#self.drelu4 = torch.nn.ReLU()
#self.dconv5 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=32, dilation=32)
#self.drelu5 = torch.nn.ReLU()
#self.dconv6 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=64, dilation=64)
#self.drelu6 = torch.nn.ReLU()
#self.dconv7 = torch.nn.Conv1d(n_filters, n_filters, kernel_size=3, padding=128, dilation=128)
#self.drelu7 = torch.nn.ReLU()
self.fconv = torch.nn.Conv1d(n_filters, 1, kernel_size=75, padding=37)
#self.logsoftmax = torch.nn.LogSoftmax(dim=-1)
def forward(self, X):
with torch.no_grad():
X = self.irelu(self.iconv(X))
X = self.drelu1(self.dconv1(X))
X = self.drelu2(self.dconv2(X))
X = self.drelu3(self.dconv3(X))
X = self.fconv(X)
#X = self.logsoftmax(self.fconv(X))
return X | yuzu-ism | /yuzu-ism-0.0.1.tar.gz/yuzu-ism-0.0.1/yuzu/models.py | models.py |
==============
yuzu
==============
.. image:: https://img.shields.io/pypi/v/yuzu.svg
:target: https://pypi.python.org/pypi/yuzu
.. image:: https://readthedocs.org/projects/yuzu-python/badge/?version=latest
:target: https://yuzu-python.readthedocs.io/en/latest/?badge=latest
:alt: Documentation Status
Lightweight and useful annotation package for logging and caching
* Free software: MIT license
* Documentation: https://yuzu-python.readthedocs.io.
Features
--------
* TODO
- write document
Credits
-------
| yuzu | /yuzu-4.1.1.tar.gz/yuzu-4.1.1/README.rst | README.rst |
from tqdm.auto import tqdm
import multiprocessing as mp
import numpy as np
import pandas as pd
import os
from datetime import datetime
import pytz
import gc
""" ENV SETUP """
pd.set_option('display.max_rows', 500)
pd.set_option('display.max_columns', 500)
pd.set_option('display.width', 1000)
import warnings
warnings.filterwarnings('ignore')
""" VERIFICATION UTILS """
def run_sample_tqdm():
for i in tqdm(range(100000)):
pass
""" PANDAS CODE """
def _initialize_mp():
cores = mp.cpu_count()
print(f"Making processes faster with {cores} cores!")
return cores
def pd_parallel_apply(Series, fun):
cores = _initialize_mp()
split_ser = np.array_split(Series, cores)
with mp.Pool(cores) as p:
app = pd.concat(p.map(fun, split_ser), axis=0)
return app
def reduce_memory(df):
for col in df.columns:
col_type = df[col].dtypes
if col_type != object:
cmin = df[col].min()
cmax = df[col].max()
if str(col_type)[:3] == 'int':
if cmin > np.iinfo(np.int8).min and cmax < np.iinfo(np.int8).max:
df[col] = df[col].astype(np.int8)
elif cmin > np.iinfo(np.int16).min and cmax < np.iinfo(np.int16).max:
df[col] = df[col].astype(np.int16)
elif cmin > np.iinfo(np.int32).min and cmax < np.iinfo(np.int32).max:
df[col] = df[col].astype(np.int32)
elif cmin > np.iinfo(np.int64).min and cmax < np.iinfo(np.int64).max:
df[col] = df[col].astype(np.int64)
else:
if cmin > np.finfo(np.float16).min and cmax < np.finfo(np.float16).max:
df[col] = df[col].astype(np.float16)
elif cmin > np.finfo(np.float32).min and cmax < np.finfo(np.float32).max:
df[col] = df[col].astype(np.float32)
else:
df[col] = df[col].astype(np.float64)
return df
""" SEAMLESS PYTHON EXPERIENCE """
# downloads content from drive
def download_drive(id, name):
os.system(f"sudo wget --load-cookies /tmp/cookies.txt 'https://docs.google.com/uc?export=download&confirm=t&id={id}' -O {name} && rm -rf /tmp/cookies.txt")
def get_current_time(utc=False):
TZ = pytz.timezone('Asia/Kolkata') if not utc else pytz.utc
return datetime.now(TZ).strftime('%Y:%m:%d %H:%M:%S %Z %z')
# garbage collect
def gc_clear():
gc.collect()
for _ in range(10):
s = gc.collect() | yv-utils | /yv_utils-1.11.tar.gz/yv_utils-1.11/src/yv_utils/main/main.py | main.py |
from .infrastructure import SuperMap
# ไปฃ่กจไธไธช(็๏ผๅธ๏ผๅบ)็ปๆ็ๅฐ็น
class Location:
# ็ด่พๅธ
# municipality = ["ๅไบฌๅธ", "ๅคฉๆดฅๅธ", "ไธๆตทๅธ", "้ๅบๅธ"]
def __init__(self):
self.province = Province()
self.city = City()
self.area = Area()
def setPlace(self, name, place_type):
if not hasattr(self, place_type):
from .exceptions import PlaceTypeNotExistException
raise PlaceTypeNotExistException(place_type + " ๅฐๅบ็ฑปๅไธๅญๅจ")
if getattr(self, place_type).isEmpty():
getattr(self, place_type).setPlace(name)
def pca_map(self, umap):
if self.area.isEmpty():
self.__city_and_province()
else:
if (self.area.name not in SuperMap.rep_areas) or (umap.get(self.area.name)):
if umap.get(self.area.name):
tmp = umap.get(self.area.name)
else:
tmp = SuperMap.area_city_mapper.get(self.area.name)
if self.city.isEmpty() or self.city.precision == 0:
self.city.setPlace(tmp)
elif self.city.isNotEmpty() and self.city.precision == 1:
if not self.area.isBlong(self.city.name) \
and umap.get(self.area.name) != self.city.name:
self.area.reset()
self.__city_and_province()
else: # ้ๅคๅบๅ ไปฃ็ ๆง่ก่ทฏๅพ
import logging
SuperMap.rep_area_set.add(self.area.name)
if self.city.isNotEmpty():
self.__city_and_province()
if self.city.name.isdigit():
self.city.reset()
import pandas as pd
# ็ป่ฃ
ๆDataFrame
return pd.DataFrame({"็": [self.province.name], "ๅธ": [self.city.name], \
"ๅบ": [self.area.name]})
def __city_and_province(self):
if self.city.isNotEmpty() and self.province.isNotEmpty():
if not self.city.isBlong(self.province.name):
if self.city.precision > self.province.precision:
self.province.name = self.city.belong
else:
self.city.reset()
elif self.city.isNotEmpty() and self.province.isEmpty():
self.province.name = self.city.belong
class Place:
def __init__(self, name=""):
self.name = name
self.precision = 1
def reset(self):
self.name = ""
def isBlong(self, mayBe):
return self.belong == mayBe
def isEmpty(self):
return False if self.name else True
def isNotEmpty(self):
return True if self.name else False
class City(Place):
def __init__(self, name=""):
super().__init__()
def __getBlong(self):
return SuperMap.city_province_mapper.get(self.name)
def setPlace(self, name):
self.name, isfilled = SuperMap.fillCity(name)
if isfilled: # ๅฆๆๆฏ้่ฆ่กฅๅ
ๅญ็๏ผๅ่ฎคไธบ่ฟไธชๅน้
ๅ็กฎ็ๆฏ่พไฝ
self.precision = 0
self.belong = self.__getBlong()
class Province(Place):
def __init__(self, name=""):
super().__init__()
def __getBlong(self):
return SuperMap.province_country_mapper.get(self.name)
def setPlace(self, name):
self.name, isfilled = SuperMap.fillProvince(name)
if isfilled: # ๅฆๆๆฏ้่ฆ่กฅๅ
ๅญ็๏ผๅ่ฎคไธบ่ฟไธชๅน้
ๅ็กฎ็ๆฏ่พไฝ
self.precision = 0
self.belong = self.__getBlong()
class Area(Place):
def __init__(self, name=""):
super().__init__()
def __getBlong(self):
return SuperMap.area_city_mapper.get(self.name)
def setPlace(self, name):
self.name = name
self.precision = 1
self.belong = self.__getBlong() | yve | /yve-0.0.21-py3-none-any.whl/mapper/domain.py | domain.py |
area_city_mapper = {
'ไธๅๅบ':'ๅไบฌๅธ',
'่ฅฟๅๅบ':'ๅไบฌๅธ',
'ๅดๆๅบ':'ๅไบฌๅธ',
'ๅฎฃๆญฆๅบ':'ๅไบฌๅธ',
'ๆ้ณๅบ':'ๅไบฌๅธ',
'ไธฐๅฐๅบ':'ๅไบฌๅธ',
'็ณๆฏๅฑฑๅบ':'ๅไบฌๅธ',
'ๆตทๆทๅบ':'ๅไบฌๅธ',
'้จๅคดๆฒๅบ':'ๅไบฌๅธ',
'ๆฟๅฑฑๅบ':'ๅไบฌๅธ',
'้ๅทๅบ':'ๅไบฌๅธ',
'้กบไนๅบ':'ๅไบฌๅธ',
'ๆๅนณๅบ':'ๅไบฌๅธ',
'ๅคงๅ
ดๅบ':'ๅไบฌๅธ',
'ๆๆๅบ':'ๅไบฌๅธ',
'ๅนณ่ฐทๅบ':'ๅไบฌๅธ',
'ๅฏไบๅฟ':'ๅไบฌๅธ',
'ๅปถๅบๅฟ':'ๅไบฌๅธ',
'ๅๅนณๅบ':'ๅคฉๆดฅๅธ',
'ๆฒณไธๅบ':'ๅคฉๆดฅๅธ',
'ๆฒณ่ฅฟๅบ':'ๅคฉๆดฅๅธ',
'ๅๅผๅบ':'ๅคฉๆดฅๅธ',
'ๆฒณๅๅบ':'ๅคฉๆดฅๅธ',
'็บขๆกฅๅบ':'ๅคฉๆดฅๅธ',
'ๅกๆฒฝๅบ':'ๅคฉๆดฅๅธ',
'ๆฑๆฒฝๅบ':'ๅคฉๆดฅๅธ',
'ๅคงๆธฏๅบ':'ๅคฉๆดฅๅธ',
'ไธไธฝๅบ':'ๅคฉๆดฅๅธ',
'่ฅฟ้ๅบ':'ๅคฉๆดฅๅธ',
'ๆดฅๅๅบ':'ๅคฉๆดฅๅธ',
'ๅ่พฐๅบ':'ๅคฉๆดฅๅธ',
'ๆญฆๆธ
ๅบ':'ๅคฉๆดฅๅธ',
'ๅฎๅปๅบ':'ๅคฉๆดฅๅธ',
'ๅฎๆฒณๅฟ':'ๅคฉๆดฅๅธ',
'้ๆตทๅฟ':'ๅคฉๆดฅๅธ',
'่ๅฟ':'ๅคฉๆดฅๅธ',
'ๅธ่พๅบ':'็ณๅฎถๅบๅธ',
'้ฟๅฎๅบ':'็ณๅฎถๅบๅธ',
'ๆกฅไธๅบ':'็ณๅฎถๅบๅธ',
'ๆกฅ่ฅฟๅบ':'็ณๅฎถๅบๅธ',
'ๆฐๅๅบ':'็ณๅฎถๅบๅธ',
'ไบ้็ฟๅบ':'็ณๅฎถๅบๅธ',
'่ฃๅๅบ':'็ณๅฎถๅบๅธ',
'ไบ้ๅฟ':'็ณๅฎถๅบๅธ',
'ๆญฃๅฎๅฟ':'็ณๅฎถๅบๅธ',
'ๆ พๅๅฟ':'็ณๅฎถๅบๅธ',
'่กๅๅฟ':'็ณๅฎถๅบๅธ',
'็ตๅฏฟๅฟ':'็ณๅฎถๅบๅธ',
'้ซ้ๅฟ':'็ณๅฎถๅบๅธ',
'ๆทฑๆณฝๅฟ':'็ณๅฎถๅบๅธ',
'่ต็ๅฟ':'็ณๅฎถๅบๅธ',
'ๆ ๆๅฟ':'็ณๅฎถๅบๅธ',
'ๅนณๅฑฑๅฟ':'็ณๅฎถๅบๅธ',
'ๅ
ๆฐๅฟ':'็ณๅฎถๅบๅธ',
'่ตตๅฟ':'็ณๅฎถๅบๅธ',
'่พ้ๅธ':'็ณๅฎถๅบๅธ',
'่ๅๅธ':'็ณๅฎถๅบๅธ',
'ๆๅทๅธ':'็ณๅฎถๅบๅธ',
'ๆฐไนๅธ':'็ณๅฎถๅบๅธ',
'้นฟๆณๅธ':'็ณๅฎถๅบๅธ',
'ๅธ่พๅบ':'ๅๅฑฑๅธ',
'่ทฏๅๅบ':'ๅๅฑฑๅธ',
'่ทฏๅๅบ':'ๅๅฑฑๅธ',
'ๅคๅถๅบ':'ๅๅฑฑๅธ',
'ๅผๅนณๅบ':'ๅๅฑฑๅธ',
'ไธฐๅๅบ':'ๅๅฑฑๅธ',
'ไธฐๆถฆๅบ':'ๅๅฑฑๅธ',
'ๆปฆๅฟ':'ๅๅฑฑๅธ',
'ๆปฆๅๅฟ':'ๅๅฑฑๅธ',
'ไนไบญๅฟ':'ๅๅฑฑๅธ',
'่ฟ่ฅฟๅฟ':'ๅๅฑฑๅธ',
'็็ฐๅฟ':'ๅๅฑฑๅธ',
'ๅๆตทๅฟ':'ๅๅฑฑๅธ',
'้ตๅๅธ':'ๅๅฑฑๅธ',
'่ฟๅฎๅธ':'ๅๅฑฑๅธ',
'ๅธ่พๅบ':'็งฆ็ๅฒๅธ',
'ๆตทๆธฏๅบ':'็งฆ็ๅฒๅธ',
'ๅฑฑๆตทๅ
ณๅบ':'็งฆ็ๅฒๅธ',
'ๅๆดๆฒณๅบ':'็งฆ็ๅฒๅธ',
'้้พๆปกๆ่ชๆฒปๅฟ':'็งฆ็ๅฒๅธ',
'ๆ้ปๅฟ':'็งฆ็ๅฒๅธ',
'ๆๅฎๅฟ':'็งฆ็ๅฒๅธ',
'ๅข้พๅฟ':'็งฆ็ๅฒๅธ',
'ๅธ่พๅบ':'้ฏ้ธๅธ',
'้ฏๅฑฑๅบ':'้ฏ้ธๅธ',
'ไธๅฐๅบ':'้ฏ้ธๅธ',
'ๅคๅ
ดๅบ':'้ฏ้ธๅธ',
'ๅณฐๅณฐ็ฟๅบ':'้ฏ้ธๅธ',
'้ฏ้ธๅฟ':'้ฏ้ธๅธ',
'ไธดๆผณๅฟ':'้ฏ้ธๅธ',
'ๆๅฎๅฟ':'้ฏ้ธๅธ',
'ๅคงๅๅฟ':'้ฏ้ธๅธ',
'ๆถๅฟ':'้ฏ้ธๅธ',
'็ฃๅฟ':'้ฏ้ธๅธ',
'่ฅไนกๅฟ':'้ฏ้ธๅธ',
'ๆฐธๅนดๅฟ':'้ฏ้ธๅธ',
'้ฑๅฟ':'้ฏ้ธๅธ',
'้ธกๆณฝๅฟ':'้ฏ้ธๅธ',
'ๅนฟๅนณๅฟ':'้ฏ้ธๅธ',
'้ฆ้ถๅฟ':'้ฏ้ธๅธ',
'้ญๅฟ':'้ฏ้ธๅธ',
'ๆฒๅจๅฟ':'้ฏ้ธๅธ',
'ๆญฆๅฎๅธ':'้ฏ้ธๅธ',
'ๅธ่พๅบ':'้ขๅฐๅธ',
'ๆกฅไธๅบ':'้ขๅฐๅธ',
'ๆกฅ่ฅฟๅบ':'้ขๅฐๅธ',
'้ขๅฐๅฟ':'้ขๅฐๅธ',
'ไธดๅๅฟ':'้ขๅฐๅธ',
'ๅ
ไธๅฟ':'้ขๅฐๅธ',
'ๆไนกๅฟ':'้ขๅฐๅธ',
'้ๅฐงๅฟ':'้ขๅฐๅธ',
'ไปปๅฟ':'้ขๅฐๅธ',
'ๅๅๅฟ':'้ขๅฐๅธ',
'ๅฎๆๅฟ':'้ขๅฐๅธ',
'ๅทจ้นฟๅฟ':'้ขๅฐๅธ',
'ๆฐๆฒณๅฟ':'้ขๅฐๅธ',
'ๅนฟๅฎๅฟ':'้ขๅฐๅธ',
'ๅนณไนกๅฟ':'้ขๅฐๅธ',
'ๅจๅฟ':'้ขๅฐๅธ',
'ๆธ
ๆฒณๅฟ':'้ขๅฐๅธ',
'ไธด่ฅฟๅฟ':'้ขๅฐๅธ',
'ๅๅฎซๅธ':'้ขๅฐๅธ',
'ๆฒๆฒณๅธ':'้ขๅฐๅธ',
'ๅธ่พๅบ':'ไฟๅฎๅธ',
'ๆฐๅธๅบ':'ไฟๅฎๅธ',
'ๅๅธๅบ':'ไฟๅฎๅธ',
'ๅๅธๅบ':'ไฟๅฎๅธ',
'ๆปกๅๅฟ':'ไฟๅฎๅธ',
'ๆธ
่ๅฟ':'ไฟๅฎๅธ',
'ๆถๆฐดๅฟ':'ไฟๅฎๅธ',
'้ๅนณๅฟ':'ไฟๅฎๅธ',
'ๅพๆฐดๅฟ':'ไฟๅฎๅธ',
'ๅฎๅ
ดๅฟ':'ไฟๅฎๅธ',
'ๅๅฟ':'ไฟๅฎๅธ',
'้ซ้ณๅฟ':'ไฟๅฎๅธ',
'ๅฎนๅๅฟ':'ไฟๅฎๅธ',
'ๆถๆบๅฟ':'ไฟๅฎๅธ',
'ๆ้ฝๅฟ':'ไฟๅฎๅธ',
'ๅฎๆฐๅฟ':'ไฟๅฎๅธ',
'ๆๅฟ':'ไฟๅฎๅธ',
'ๆฒ้ณๅฟ':'ไฟๅฎๅธ',
'่ กๅฟ':'ไฟๅฎๅธ',
'้กบๅนณๅฟ':'ไฟๅฎๅธ',
'ๅ้ๅฟ':'ไฟๅฎๅธ',
'้ๅฟ':'ไฟๅฎๅธ',
'ๆถฟๅทๅธ':'ไฟๅฎๅธ',
'ๅฎๅทๅธ':'ไฟๅฎๅธ',
'ๅฎๅฝๅธ':'ไฟๅฎๅธ',
'้ซ็ขๅบๅธ':'ไฟๅฎๅธ',
'ๅธ่พๅบ':'ๅผ ๅฎถๅฃๅธ',
'ๆกฅไธๅบ':'ๅผ ๅฎถๅฃๅธ',
'ๆกฅ่ฅฟๅบ':'ๅผ ๅฎถๅฃๅธ',
'ๅฎฃๅๅบ':'ๅผ ๅฎถๅฃๅธ',
'ไธ่ฑๅญๅบ':'ๅผ ๅฎถๅฃๅธ',
'ๅฎฃๅๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๅผ ๅๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๅบทไฟๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๆฒฝๆบๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๅฐไนๅฟ':'ๅผ ๅฎถๅฃๅธ',
'่ๅฟ':'ๅผ ๅฎถๅฃๅธ',
'้ณๅๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๆๅฎๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ไธๅ
จๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๆๆฅๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๆถฟ้นฟๅฟ':'ๅผ ๅฎถๅฃๅธ',
'่ตคๅๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๅด็คผๅฟ':'ๅผ ๅฎถๅฃๅธ',
'ๅธ่พๅบ':'ๆฟๅพทๅธ',
'ๅๆกฅๅบ':'ๆฟๅพทๅธ',
'ๅๆปฆๅบ':'ๆฟๅพทๅธ',
'้นฐๆ่ฅๅญ็ฟๅบ':'ๆฟๅพทๅธ',
'ๆฟๅพทๅฟ':'ๆฟๅพทๅธ',
'ๅ
ด้ๅฟ':'ๆฟๅพทๅธ',
'ๅนณๆณๅฟ':'ๆฟๅพทๅธ',
'ๆปฆๅนณๅฟ':'ๆฟๅพทๅธ',
'้ๅๅฟ':'ๆฟๅพทๅธ',
'ไธฐๅฎๆปกๆ่ชๆฒปๅฟ':'ๆฟๅพทๅธ',
'ๅฎฝๅๆปกๆ่ชๆฒปๅฟ':'ๆฟๅพทๅธ',
'ๅดๅบๆปกๆ่ๅคๆ่ชๆฒปๅฟ':'ๆฟๅพทๅธ',
'ๅธ่พๅบ':'ๆฒงๅทๅธ',
'ๆฐๅๅบ':'ๆฒงๅทๅธ',
'่ฟๆฒณๅบ':'ๆฒงๅทๅธ',
'ๆฒงๅฟ':'ๆฒงๅทๅธ',
'้ๅฟ':'ๆฒงๅทๅธ',
'ไธๅ
ๅฟ':'ๆฒงๅทๅธ',
'ๆตทๅ
ดๅฟ':'ๆฒงๅทๅธ',
'็ๅฑฑๅฟ':'ๆฒงๅทๅธ',
'่ๅฎๅฟ':'ๆฒงๅทๅธ',
'ๅ็ฎๅฟ':'ๆฒงๅทๅธ',
'ๅดๆกฅๅฟ':'ๆฒงๅทๅธ',
'็ฎๅฟ':'ๆฒงๅทๅธ',
'ๅญๆๅๆ่ชๆฒปๅฟ':'ๆฒงๅทๅธ',
'ๆณๅคดๅธ':'ๆฒงๅทๅธ',
'ไปปไธๅธ':'ๆฒงๅทๅธ',
'้ป้ช
ๅธ':'ๆฒงๅทๅธ',
'ๆฒณ้ดๅธ':'ๆฒงๅทๅธ',
'ๅธ่พๅบ':'ๅปๅๅธ',
'ๅฎๆฌกๅบ':'ๅปๅๅธ',
'ๅนฟ้ณๅบ':'ๅปๅๅธ',
'ๅบๅฎๅฟ':'ๅปๅๅธ',
'ๆฐธๆธ
ๅฟ':'ๅปๅๅธ',
'้ฆๆฒณๅฟ':'ๅปๅๅธ',
'ๅคงๅๅฟ':'ๅปๅๅธ',
'ๆๅฎๅฟ':'ๅปๅๅธ',
'ๅคงๅๅๆ่ชๆฒปๅฟ':'ๅปๅๅธ',
'้ธๅทๅธ':'ๅปๅๅธ',
'ไธๆฒณๅธ':'ๅปๅๅธ',
'ๅธ่พๅบ':'่กกๆฐดๅธ',
'ๆกๅๅบ':'่กกๆฐดๅธ',
'ๆฃๅผบๅฟ':'่กกๆฐดๅธ',
'ๆญฆ้ๅฟ':'่กกๆฐดๅธ',
'ๆญฆๅผบๅฟ':'่กกๆฐดๅธ',
'้ฅถ้ณๅฟ':'่กกๆฐดๅธ',
'ๅฎๅนณๅฟ':'่กกๆฐดๅธ',
'ๆ
ๅๅฟ':'่กกๆฐดๅธ',
'ๆฏๅฟ':'่กกๆฐดๅธ',
'้ๅๅฟ':'่กกๆฐดๅธ',
'ๅๅทๅธ':'่กกๆฐดๅธ',
'ๆทฑๅทๅธ':'่กกๆฐดๅธ',
'ๅธ่พๅบ':'ๅคชๅๅธ',
'ๅฐๅบๅบ':'ๅคชๅๅธ',
'่ฟๆณฝๅบ':'ๅคชๅๅธ',
'ๆ่ฑๅฒญๅบ':'ๅคชๅๅธ',
'ๅฐ่ๅชๅบ':'ๅคชๅๅธ',
'ไธๆๆๅบ':'ๅคชๅๅธ',
'ๆๆบๅบ':'ๅคชๅๅธ',
'ๆธ
ๅพๅฟ':'ๅคชๅๅธ',
'้ณๆฒๅฟ':'ๅคชๅๅธ',
'ๅจ็ฆๅฟ':'ๅคชๅๅธ',
'ๅคไบคๅธ':'ๅคชๅๅธ',
'ๅธ่พๅบ':'ๅคงๅๅธ',
'ๅๅบ':'ๅคงๅๅธ',
'็ฟๅบ':'ๅคงๅๅธ',
'ๅ้ๅบ':'ๅคงๅๅธ',
'ๆฐ่ฃๅบ':'ๅคงๅๅธ',
'้ณ้ซๅฟ':'ๅคงๅๅธ',
'ๅคฉ้ๅฟ':'ๅคงๅๅธ',
'ๅนฟ็ตๅฟ':'ๅคงๅๅธ',
'็ตไธๅฟ':'ๅคงๅๅธ',
'ๆตๆบๅฟ':'ๅคงๅๅธ',
'ๅทฆไบๅฟ':'ๅคงๅๅธ',
'ๅคงๅๅฟ':'ๅคงๅๅธ',
'ๅธ่พๅบ':'้ณๆณๅธ',
'ๅๅบ':'้ณๆณๅธ',
'็ฟๅบ':'้ณๆณๅธ',
'้ๅบ':'้ณๆณๅธ',
'ๅนณๅฎๅฟ':'้ณๆณๅธ',
'็ๅฟ':'้ณๆณๅธ',
'ๅธ่พๅบ':'้ฟๆฒปๅธ',
'ๅๅบ':'้ฟๆฒปๅธ',
'้ๅบ':'้ฟๆฒปๅธ',
'้ฟๆฒปๅฟ':'้ฟๆฒปๅธ',
'่ฅๅฃๅฟ':'้ฟๆฒปๅธ',
'ๅฑฏ็ๅฟ':'้ฟๆฒปๅธ',
'ๅนณ้กบๅฟ':'้ฟๆฒปๅธ',
'้ปๅๅฟ':'้ฟๆฒปๅธ',
'ๅฃถๅ
ณๅฟ':'้ฟๆฒปๅธ',
'้ฟๅญๅฟ':'้ฟๆฒปๅธ',
'ๆญฆไนกๅฟ':'้ฟๆฒปๅธ',
'ๆฒๅฟ':'้ฟๆฒปๅธ',
'ๆฒๆบๅฟ':'้ฟๆฒปๅธ',
'ๆฝๅๅธ':'้ฟๆฒปๅธ',
'ๅธ่พๅบ':'ๆๅๅธ',
'ๅๅบ':'ๆๅๅธ',
'ๆฒๆฐดๅฟ':'ๆๅๅธ',
'้ณๅๅฟ':'ๆๅๅธ',
'้ตๅทๅฟ':'ๆๅๅธ',
'ๆณฝๅทๅฟ':'ๆๅๅธ',
'้ซๅนณๅธ':'ๆๅๅธ',
'ๅธ่พๅบ':'ๆๅทๅธ',
'ๆๅๅบ':'ๆๅทๅธ',
'ๅนณ้ฒๅบ':'ๆๅทๅธ',
'ๅฑฑ้ดๅฟ':'ๆๅทๅธ',
'ๅบๅฟ':'ๆๅทๅธ',
'ๅณ็ๅฟ':'ๆๅทๅธ',
'ๆไปๅฟ':'ๆๅทๅธ',
'ๅธ่พๅบ':'ๆไธญๅธ',
'ๆฆๆฌกๅบ':'ๆไธญๅธ',
'ๆฆ็คพๅฟ':'ๆไธญๅธ',
'ๅทฆๆๅฟ':'ๆไธญๅธ',
'ๅ้กบๅฟ':'ๆไธญๅธ',
'ๆ้ณๅฟ':'ๆไธญๅธ',
'ๅฏฟ้ณๅฟ':'ๆไธญๅธ',
'ๅคช่ฐทๅฟ':'ๆไธญๅธ',
'็ฅๅฟ':'ๆไธญๅธ',
'ๅนณ้ฅๅฟ':'ๆไธญๅธ',
'็ต็ณๅฟ':'ๆไธญๅธ',
'ไปไผๅธ':'ๆไธญๅธ',
'ๅธ่พๅบ':'่ฟๅๅธ',
'็ๆนๅบ':'่ฟๅๅธ',
'ไธด็ๅฟ':'่ฟๅๅธ',
'ไธ่ฃๅฟ':'่ฟๅๅธ',
'้ปๅๅฟ':'่ฟๅๅธ',
'็จทๅฑฑๅฟ':'่ฟๅๅธ',
'ๆฐ็ปๅฟ':'่ฟๅๅธ',
'็ปๅฟ':'่ฟๅๅธ',
'ๅฃๆฒๅฟ':'่ฟๅๅธ',
'ๅคๅฟ':'่ฟๅๅธ',
'ๅนณ้ๅฟ':'่ฟๅๅธ',
'่ฎๅๅฟ':'่ฟๅๅธ',
'ๆฐธๆตๅธ':'่ฟๅๅธ',
'ๆฒณๆดฅๅธ':'่ฟๅๅธ',
'ๅธ่พๅบ':'ๅฟปๅทๅธ',
'ๅฟปๅบๅบ':'ๅฟปๅทๅธ',
'ๅฎ่ฅๅฟ':'ๅฟปๅทๅธ',
'ไบๅฐๅฟ':'ๅฟปๅทๅธ',
'ไปฃๅฟ':'ๅฟปๅทๅธ',
'็นๅณๅฟ':'ๅฟปๅทๅธ',
'ๅฎๆญฆๅฟ':'ๅฟปๅทๅธ',
'้ไนๅฟ':'ๅฟปๅทๅธ',
'็ฅๆฑ ๅฟ':'ๅฟปๅทๅธ',
'ไบๅฏจๅฟ':'ๅฟปๅทๅธ',
'ๅฒขๅฒๅฟ':'ๅฟปๅทๅธ',
'ๆฒณๆฒๅฟ':'ๅฟปๅทๅธ',
'ไฟๅพทๅฟ':'ๅฟปๅทๅธ',
'ๅๅ
ณๅฟ':'ๅฟปๅทๅธ',
'ๅๅนณๅธ':'ๅฟปๅทๅธ',
'ๅธ่พๅบ':'ไธดๆฑพๅธ',
'ๅฐง้ฝๅบ':'ไธดๆฑพๅธ',
'ๆฒๆฒๅฟ':'ไธดๆฑพๅธ',
'็ฟผๅๅฟ':'ไธดๆฑพๅธ',
'่ฅๆฑพๅฟ':'ไธดๆฑพๅธ',
'ๆดชๆดๅฟ':'ไธดๆฑพๅธ',
'ๅคๅฟ':'ไธดๆฑพๅธ',
'ๅฎๆณฝๅฟ':'ไธดๆฑพๅธ',
'ๆตฎๅฑฑๅฟ':'ไธดๆฑพๅธ',
'ๅๅฟ':'ไธดๆฑพๅธ',
'ไนกๅฎๅฟ':'ไธดๆฑพๅธ',
'ๅคงๅฎๅฟ':'ไธดๆฑพๅธ',
'้ฐๅฟ':'ไธดๆฑพๅธ',
'ๆฐธๅๅฟ':'ไธดๆฑพๅธ',
'่ฒๅฟ':'ไธดๆฑพๅธ',
'ๆฑพ่ฅฟๅฟ':'ไธดๆฑพๅธ',
'ไพฏ้ฉฌๅธ':'ไธดๆฑพๅธ',
'้ๅทๅธ':'ไธดๆฑพๅธ',
'ๅธ่พๅบ':'ๅๆขๅธ',
'็ฆป็ณๅบ':'ๅๆขๅธ',
'ๆๆฐดๅฟ':'ๅๆขๅธ',
'ไบคๅๅฟ':'ๅๆขๅธ',
'ๅ
ดๅฟ':'ๅๆขๅธ',
'ไธดๅฟ':'ๅๆขๅธ',
'ๆณๆๅฟ':'ๅๆขๅธ',
'็ณๆฅผๅฟ':'ๅๆขๅธ',
'ๅฒๅฟ':'ๅๆขๅธ',
'ๆนๅฑฑๅฟ':'ๅๆขๅธ',
'ไธญ้ณๅฟ':'ๅๆขๅธ',
'ไบคๅฃๅฟ':'ๅๆขๅธ',
'ๅญไนๅธ':'ๅๆขๅธ',
'ๆฑพ้ณๅธ':'ๅๆขๅธ',
'ๅธ่พๅบ':'ๅผๅๆตฉ็นๅธ',
'ๆฐๅๅบ':'ๅผๅๆตฉ็นๅธ',
'ๅๆฐๅบ':'ๅผๅๆตฉ็นๅธ',
'็ๆณๅบ':'ๅผๅๆตฉ็นๅธ',
'่ต็ฝๅบ':'ๅผๅๆตฉ็นๅธ',
'ๅ้ป็นๅทฆๆ':'ๅผๅๆตฉ็นๅธ',
'ๆๅ
ๆๅฟ':'ๅผๅๆตฉ็นๅธ',
'ๅๆๆ ผๅฐๅฟ':'ๅผๅๆตฉ็นๅธ',
'ๆธ
ๆฐดๆฒณๅฟ':'ๅผๅๆตฉ็นๅธ',
'ๆญฆๅทๅฟ':'ๅผๅๆตฉ็นๅธ',
'ๅธ่พๅบ':'ๅ
ๅคดๅธ',
'ไธๆฒณๅบ':'ๅ
ๅคดๅธ',
'ๆ้ฝไปๅบ':'ๅ
ๅคดๅธ',
'้ๅฑฑๅบ':'ๅ
ๅคดๅธ',
'็ณๆๅบ':'ๅ
ๅคดๅธ',
'็ฝไบ็ฟๅบ':'ๅ
ๅคดๅธ',
'ไนๅๅบ':'ๅ
ๅคดๅธ',
'ๅ้ป็นๅณๆ':'ๅ
ๅคดๅธ',
'ๅบ้ณๅฟ':'ๅ
ๅคดๅธ',
'่พพๅฐ็ฝ่ๆๅฎ่ๅๆ':'ๅ
ๅคดๅธ',
'ๅธ่พๅบ':'ไนๆตทๅธ',
'ๆตทๅๆนพๅบ':'ไนๆตทๅธ',
'ๆตทๅๅบ':'ไนๆตทๅธ',
'ไน่พพๅบ':'ไนๆตทๅธ',
'ๅธ่พๅบ':'่ตคๅณฐๅธ',
'็บขๅฑฑๅบ':'่ตคๅณฐๅธ',
'ๅ
ๅฎๅฑฑๅบ':'่ตคๅณฐๅธ',
'ๆพๅฑฑๅบ':'่ตคๅณฐๅธ',
'้ฟ้ฒ็งๅฐๆฒๆ':'่ตคๅณฐๅธ',
'ๅทดๆๅทฆๆ':'่ตคๅณฐๅธ',
'ๅทดๆๅณๆ':'่ตคๅณฐๅธ',
'ๆ่ฅฟๅฟ':'่ตคๅณฐๅธ',
'ๅ
ไปๅ
่
พๆ':'่ตคๅณฐๅธ',
'็ฟ็็นๆ':'่ตคๅณฐๅธ',
'ๅๅๆฒๆ':'่ตคๅณฐๅธ',
'ๅฎๅๅฟ':'่ตคๅณฐๅธ',
'ๆๆฑๆ':'่ตคๅณฐๅธ',
'ๅธ่พๅบ':'้่พฝๅธ',
'็งๅฐๆฒๅบ':'้่พฝๅธ',
'็งๅฐๆฒๅทฆ็ฟผไธญๆ':'้่พฝๅธ',
'็งๅฐๆฒๅทฆ็ฟผๅๆ':'้่พฝๅธ',
'ๅผ้ฒๅฟ':'้่พฝๅธ',
'ๅบไผฆๆ':'้่พฝๅธ',
'ๅฅๆผๆ':'้่พฝๅธ',
'ๆ้ฒ็นๆ':'้่พฝๅธ',
'้ๆ้ญๅๅธ':'้่พฝๅธ',
'ไธ่ๅบ':'้ๅฐๅคๆฏๅธ',
'่พพๆ็นๆ':'้ๅฐๅคๆฏๅธ',
'ๅๆ ผๅฐๆ':'้ๅฐๅคๆฏๅธ',
'้ๆๅ
ๅๆ':'้ๅฐๅคๆฏๅธ',
'้ๆๅ
ๆ':'้ๅฐๅคๆฏๅธ',
'ๆญ้ฆๆ':'้ๅฐๅคๆฏๅธ',
'ไนๅฎกๆ':'้ๅฐๅคๆฏๅธ',
'ไผ้้ๆดๆ':'้ๅฐๅคๆฏๅธ',
'ๅธ่พๅบ':'ๅผไผฆ่ดๅฐๅธ',
'ๆตทๆๅฐๅบ':'ๅผไผฆ่ดๅฐๅธ',
'้ฟ่ฃๆ':'ๅผไผฆ่ดๅฐๅธ',
'่ซๅ่พพ็ฆ่พพๆกๅฐๆ่ชๆฒปๆ':'ๅผไผฆ่ดๅฐๅธ',
'้ไผฆๆฅ่ชๆฒปๆ':'ๅผไผฆ่ดๅฐๅธ',
'้ๆธฉๅ
ๆ่ชๆฒปๆ':'ๅผไผฆ่ดๅฐๅธ',
'้ๅทดๅฐ่ๆ':'ๅผไผฆ่ดๅฐๅธ',
'ๆฐๅทดๅฐ่ๅทฆๆ':'ๅผไผฆ่ดๅฐๅธ',
'ๆฐๅทดๅฐ่ๅณๆ':'ๅผไผฆ่ดๅฐๅธ',
'ๆปกๆดฒ้ๅธ':'ๅผไผฆ่ดๅฐๅธ',
'็ๅ
็ณๅธ':'ๅผไผฆ่ดๅฐๅธ',
'ๆๅ
ฐๅฑฏๅธ':'ๅผไผฆ่ดๅฐๅธ',
'้ขๅฐๅค็บณๅธ':'ๅผไผฆ่ดๅฐๅธ',
'ๆ นๆฒณๅธ':'ๅผไผฆ่ดๅฐๅธ',
'ๅธ่พๅบ':'ๅทดๅฝฆๆทๅฐๅธ',
'ไธดๆฒณๅบ':'ๅทดๅฝฆๆทๅฐๅธ',
'ไบๅๅฟ':'ๅทดๅฝฆๆทๅฐๅธ',
'็ฃดๅฃๅฟ':'ๅทดๅฝฆๆทๅฐๅธ',
'ไนๆ็นๅๆ':'ๅทดๅฝฆๆทๅฐๅธ',
'ไนๆ็นไธญๆ':'ๅทดๅฝฆๆทๅฐๅธ',
'ไนๆ็นๅๆ':'ๅทดๅฝฆๆทๅฐๅธ',
'ๆญ้ฆๅๆ':'ๅทดๅฝฆๆทๅฐๅธ',
'ๅธ่พๅบ':'ไนๅ
ฐๅฏๅธๅธ',
'้ๅฎๅบ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅ่ตๅฟ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅๅพทๅฟ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅ้ฝๅฟ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅ
ดๅๅฟ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅๅๅฟ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅฏๅๅฐๅณ็ฟผๅๆ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅฏๅๅฐๅณ็ฟผไธญๆ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅฏๅๅฐๅณ็ฟผๅๆ':'ไนๅ
ฐๅฏๅธๅธ',
'ๅๅญ็ๆ':'ไนๅ
ฐๅฏๅธๅธ',
'ไธฐ้ๅธ':'ไนๅ
ฐๅฏๅธๅธ',
'ไนๅ
ฐๆตฉ็นๅธ':'ๅ
ดๅฎ็',
'้ฟๅฐๅฑฑๅธ':'ๅ
ดๅฎ็',
'็งๅฐๆฒๅณ็ฟผๅๆ':'ๅ
ดๅฎ็',
'็งๅฐๆฒๅณ็ฟผไธญๆ':'ๅ
ดๅฎ็',
'ๆ่ต็นๆ':'ๅ
ดๅฎ็',
'็ชๆณๅฟ':'ๅ
ดๅฎ็',
'ไบ่ฟๆตฉ็นๅธ':'้กๆ้ญๅ็',
'้กๆๆตฉ็นๅธ':'้กๆ้ญๅ็',
'้ฟๅทดๅๆ':'้กๆ้ญๅ็',
'่ๅฐผ็นๅทฆๆ':'้กๆ้ญๅ็',
'่ๅฐผ็นๅณๆ':'้กๆ้ญๅ็',
'ไธไน็ ็ฉๆฒๆ':'้กๆ้ญๅ็',
'่ฅฟไน็ ็ฉๆฒๆ':'้กๆ้ญๅ็',
'ๅคชไปๅฏบๆ':'้กๆ้ญๅ็',
'้ถ้ปๆ':'้กๆ้ญๅ็',
'ๆญฃ้ถ็ฝๆ':'้กๆ้ญๅ็',
'ๆญฃ่ๆ':'้กๆ้ญๅ็',
'ๅคไผฆๅฟ':'้กๆ้ญๅ็',
'้ฟๆๅๅทฆๆ':'้ฟๆๅ็',
'้ฟๆๅๅณๆ':'้ฟๆๅ็',
'้ขๆต็บณๆ':'้ฟๆๅ็',
'ๅธ่พๅบ':'ๆฒ้ณๅธ',
'ๅๅนณๅบ':'ๆฒ้ณๅธ',
'ๆฒๆฒณๅบ':'ๆฒ้ณๅธ',
'ๅคงไธๅบ':'ๆฒ้ณๅธ',
'็ๅงๅบ':'ๆฒ้ณๅธ',
'้่ฅฟๅบ':'ๆฒ้ณๅธ',
'่ๅฎถๅฑฏๅบ':'ๆฒ้ณๅธ',
'ไธ้ตๅบ':'ๆฒ้ณๅธ',
'ๆฐๅๅญๅบ':'ๆฒ้ณๅธ',
'ไบๆดชๅบ':'ๆฒ้ณๅธ',
'่พฝไธญๅฟ':'ๆฒ้ณๅธ',
'ๅบทๅนณๅฟ':'ๆฒ้ณๅธ',
'ๆณๅบๅฟ':'ๆฒ้ณๅธ',
'ๆฐๆฐๅธ':'ๆฒ้ณๅธ',
'ๅธ่พๅบ':'ๅคง่ฟๅธ',
'ไธญๅฑฑๅบ':'ๅคง่ฟๅธ',
'่ฅฟๅฒๅบ':'ๅคง่ฟๅธ',
'ๆฒๆฒณๅฃๅบ':'ๅคง่ฟๅธ',
'็ไบๅญๅบ':'ๅคง่ฟๅธ',
'ๆ
้กบๅฃๅบ':'ๅคง่ฟๅธ',
'้ๅทๅบ':'ๅคง่ฟๅธ',
'้ฟๆตทๅฟ':'ๅคง่ฟๅธ',
'็ฆๆฟๅบๅธ':'ๅคง่ฟๅธ',
'ๆฎๅ
ฐๅบๅธ':'ๅคง่ฟๅธ',
'ๅบๆฒณๅธ':'ๅคง่ฟๅธ',
'ๅธ่พๅบ':'้ๅฑฑๅธ',
'้ไธๅบ':'้ๅฑฑๅธ',
'้่ฅฟๅบ':'้ๅฑฑๅธ',
'็ซๅฑฑๅบ':'้ๅฑฑๅธ',
'ๅๅฑฑๅบ':'้ๅฑฑๅธ',
'ๅฐๅฎๅฟ':'้ๅฑฑๅธ',
'ๅฒซๅฒฉๆปกๆ่ชๆฒปๅฟ':'้ๅฑฑๅธ',
'ๆตทๅๅธ':'้ๅฑฑๅธ',
'ๅธ่พๅบ':'ๆ้กบๅธ',
'ๆฐๆๅบ':'ๆ้กบๅธ',
'ไธๆดฒๅบ':'ๆ้กบๅธ',
'ๆ่ฑๅบ':'ๆ้กบๅธ',
'้กบๅๅบ':'ๆ้กบๅธ',
'ๆ้กบๅฟ':'ๆ้กบๅธ',
'ๆฐๅฎพๆปกๆ่ชๆฒปๅฟ':'ๆ้กบๅธ',
'ๆธ
ๅๆปกๆ่ชๆฒปๅฟ':'ๆ้กบๅธ',
'ๅธ่พๅบ':'ๆฌๆบชๅธ',
'ๅนณๅฑฑๅบ':'ๆฌๆบชๅธ',
'ๆบชๆนๅบ':'ๆฌๆบชๅธ',
'ๆๅฑฑๅบ':'ๆฌๆบชๅธ',
'ๅ่ฌๅบ':'ๆฌๆบชๅธ',
'ๆฌๆบชๆปกๆ่ชๆฒปๅฟ':'ๆฌๆบชๅธ',
'ๆกไปๆปกๆ่ชๆฒปๅฟ':'ๆฌๆบชๅธ',
'ๅธ่พๅบ':'ไธนไธๅธ',
'ๅ
ๅฎๅบ':'ไธนไธๅธ',
'ๆฏๅ
ดๅบ':'ไธนไธๅธ',
'ๆฏๅฎๅบ':'ไธนไธๅธ',
'ๅฎฝ็ธๆปกๆ่ชๆฒปๅฟ':'ไธนไธๅธ',
'ไธๆธฏๅธ':'ไธนไธๅธ',
'ๅคๅๅธ':'ไธนไธๅธ',
'ๅธ่พๅบ':'้ฆๅทๅธ',
'ๅคๅกๅบ':'้ฆๅทๅธ',
'ๅๆฒณๅบ':'้ฆๅทๅธ',
'ๅคชๅๅบ':'้ฆๅทๅธ',
'้ปๅฑฑๅฟ':'้ฆๅทๅธ',
'ไนๅฟ':'้ฆๅทๅธ',
'ๅๆตทๅธ':'้ฆๅทๅธ',
'ๅๅฎๅธ':'้ฆๅทๅธ',
'ๅธ่พๅบ':'่ฅๅฃๅธ',
'็ซๅๅบ':'่ฅๅฃๅธ',
'่ฅฟๅธๅบ':'่ฅๅฃๅธ',
'้ฒ
้ฑผๅๅบ':'่ฅๅฃๅธ',
'่่พนๅบ':'่ฅๅฃๅธ',
'็ๅทๅธ':'่ฅๅฃๅธ',
'ๅคง็ณๆกฅๅธ':'่ฅๅฃๅธ',
'ๅธ่พๅบ':'้ๆฐๅธ',
'ๆตทๅทๅบ':'้ๆฐๅธ',
'ๆฐ้ฑๅบ':'้ๆฐๅธ',
'ๅคชๅนณๅบ':'้ๆฐๅธ',
'ๆธ
ๆฒณ้จๅบ':'้ๆฐๅธ',
'็ปๆฒณๅบ':'้ๆฐๅธ',
'้ๆฐ่ๅคๆ่ชๆฒปๅฟ':'้ๆฐๅธ',
'ๅฝฐๆญฆๅฟ':'้ๆฐๅธ',
'ๅธ่พๅบ':'่พฝ้ณๅธ',
'็ฝๅกๅบ':'่พฝ้ณๅธ',
'ๆๅฃๅบ':'่พฝ้ณๅธ',
'ๅฎไผๅบ':'่พฝ้ณๅธ',
'ๅผ้ฟๅฒญๅบ':'่พฝ้ณๅธ',
'ๅคชๅญๆฒณๅบ':'่พฝ้ณๅธ',
'่พฝ้ณๅฟ':'่พฝ้ณๅธ',
'็ฏๅกๅธ':'่พฝ้ณๅธ',
'ๅธ่พๅบ':'็้ฆๅธ',
'ๅๅฐๅญๅบ':'็้ฆๅธ',
'ๅ
ด้ๅฐๅบ':'็้ฆๅธ',
'ๅคงๆดผๅฟ':'็้ฆๅธ',
'็ๅฑฑๅฟ':'็้ฆๅธ',
'ๅธ่พๅบ':'้ๅฒญๅธ',
'้ถๅทๅบ':'้ๅฒญๅธ',
'ๆธ
ๆฒณๅบ':'้ๅฒญๅธ',
'้ๅฒญๅฟ':'้ๅฒญๅธ',
'่ฅฟไธฐๅฟ':'้ๅฒญๅธ',
'ๆๅพๅฟ':'้ๅฒญๅธ',
'่ฐๅ
ตๅฑฑๅธ':'้ๅฒญๅธ',
'ๅผๅๅธ':'้ๅฒญๅธ',
'ๅธ่พๅบ':'ๆ้ณๅธ',
'ๅๅกๅบ':'ๆ้ณๅธ',
'้พๅๅบ':'ๆ้ณๅธ',
'ๆ้ณๅฟ':'ๆ้ณๅธ',
'ๅปบๅนณๅฟ':'ๆ้ณๅธ',
'ๅๅๆฒๅทฆ็ฟผ่ๅคๆ่ชๆฒปๅฟ':'ๆ้ณๅธ',
'ๅ็ฅจๅธ':'ๆ้ณๅธ',
'ๅๆบๅธ':'ๆ้ณๅธ',
'ๅธ่พๅบ':'่ซ่ฆๅฒๅธ',
'่ฟๅฑฑๅบ':'่ซ่ฆๅฒๅธ',
'้พๆธฏๅบ':'่ซ่ฆๅฒๅธ',
'ๅ็ฅจๅบ':'่ซ่ฆๅฒๅธ',
'็ปฅไธญๅฟ':'่ซ่ฆๅฒๅธ',
'ๅปบๆๅฟ':'่ซ่ฆๅฒๅธ',
'ๅ
ดๅๅธ':'่ซ่ฆๅฒๅธ',
'ๅธ่พๅบ':'้ฟๆฅๅธ',
'ๅๅ
ณๅบ':'้ฟๆฅๅธ',
'ๅฎฝๅๅบ':'้ฟๆฅๅธ',
'ๆ้ณๅบ':'้ฟๆฅๅธ',
'ไบ้ๅบ':'้ฟๆฅๅธ',
'็ปฟๅญๅบ':'้ฟๆฅๅธ',
'ๅ้ณๅบ':'้ฟๆฅๅธ',
'ๅๅฎๅฟ':'้ฟๆฅๅธ',
'ไนๅฐๅธ':'้ฟๆฅๅธ',
'ๆฆๆ ๅธ':'้ฟๆฅๅธ',
'ๅพทๆ ๅธ':'้ฟๆฅๅธ',
'ๅธ่พๅบ':'ๅๆๅธ',
'ๆ้ๅบ':'ๅๆๅธ',
'้พๆฝญๅบ':'ๅๆๅธ',
'่น่ฅๅบ':'ๅๆๅธ',
'ไธฐๆปกๅบ':'ๅๆๅธ',
'ๆฐธๅๅฟ':'ๅๆๅธ',
'่ๆฒณๅธ':'ๅๆๅธ',
'ๆกฆ็ธๅธ':'ๅๆๅธ',
'่ๅ
ฐๅธ':'ๅๆๅธ',
'็ฃ็ณๅธ':'ๅๆๅธ',
'ๅธ่พๅบ':'ๅๅนณๅธ',
'้่ฅฟๅบ':'ๅๅนณๅธ',
'้ไธๅบ':'ๅๅนณๅธ',
'ๆขจๆ ๅฟ':'ๅๅนณๅธ',
'ไผ้ๆปกๆ่ชๆฒปๅฟ':'ๅๅนณๅธ',
'ๅ
ฌไธปๅฒญๅธ':'ๅๅนณๅธ',
'ๅ่พฝๅธ':'ๅๅนณๅธ',
'ๅธ่พๅบ':'่พฝๆบๅธ',
'้พๅฑฑๅบ':'่พฝๆบๅธ',
'่ฅฟๅฎๅบ':'่พฝๆบๅธ',
'ไธไธฐๅฟ':'่พฝๆบๅธ',
'ไธ่พฝๅฟ':'่พฝๆบๅธ',
'ๅธ่พๅบ':'้ๅๅธ',
'ไธๆๅบ':'้ๅๅธ',
'ไบ้ๆฑๅบ':'้ๅๅธ',
'้ๅๅฟ':'้ๅๅธ',
'่พๅๅฟ':'้ๅๅธ',
'ๆณๆฒณๅฟ':'้ๅๅธ',
'ๆข
ๆฒณๅฃๅธ':'้ๅๅธ',
'้ๅฎๅธ':'้ๅๅธ',
'ๅธ่พๅบ':'็ฝๅฑฑๅธ',
'ๅ
ซ้ๆฑๅบ':'็ฝๅฑฑๅธ',
'ๆๆพๅฟ':'็ฝๅฑฑๅธ',
'้ๅฎๅฟ':'็ฝๅฑฑๅธ',
'้ฟ็ฝๆ้ฒๆ่ชๆฒปๅฟ':'็ฝๅฑฑๅธ',
'ๆฑๆบๅฟ':'็ฝๅฑฑๅธ',
'ไธดๆฑๅธ':'็ฝๅฑฑๅธ',
'ๅธ่พๅบ':'ๆพๅๅธ',
'ๅฎๆฑๅบ':'ๆพๅๅธ',
'ๅ้ญๅฐ็ฝๆฏ่ๅคๆ่ชๆฒปๅฟ':'ๆพๅๅธ',
'้ฟๅฒญๅฟ':'ๆพๅๅธ',
'ไนพๅฎๅฟ':'ๆพๅๅธ',
'ๆถไฝๅฟ':'ๆพๅๅธ',
'ๅธ่พๅบ':'็ฝๅๅธ',
'ๆดฎๅๅบ':'็ฝๅๅธ',
'้่ตๅฟ':'็ฝๅๅธ',
'้ๆฆๅฟ':'็ฝๅๅธ',
'ๆดฎๅๅธ':'็ฝๅๅธ',
'ๅคงๅฎๅธ':'็ฝๅๅธ',
'ๅปถๅๅธ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'ๅพไปฌๅธ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'ๆฆๅๅธ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'็ฒๆฅๅธ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'้พไบๅธ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'ๅ้พๅธ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'ๆฑชๆธ
ๅฟ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'ๅฎๅพๅฟ':'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'ๅๅฐๆปจๅธ',
'้้ๅบ':'ๅๅฐๆปจๅธ',
'ๅๅฒๅบ':'ๅๅฐๆปจๅธ',
'้ๅคๅบ':'ๅๅฐๆปจๅธ',
'้ฆๅๅบ':'ๅๅฐๆปจๅธ',
'ๅจๅๅบ':'ๅๅฐๆปจๅธ',
'ๅนณๆฟๅบ':'ๅๅฐๆปจๅธ',
'ๆพๅๅบ':'ๅๅฐๆปจๅธ',
'ๅผๅ
ฐๅบ':'ๅๅฐๆปจๅธ',
'ไพๅ
ฐๅฟ':'ๅๅฐๆปจๅธ',
'ๆนๆญฃๅฟ':'ๅๅฐๆปจๅธ',
'ๅฎพๅฟ':'ๅๅฐๆปจๅธ',
'ๅทดๅฝฆๅฟ':'ๅๅฐๆปจๅธ',
'ๆจๅ
ฐๅฟ':'ๅๅฐๆปจๅธ',
'้ๆฒณๅฟ':'ๅๅฐๆปจๅธ',
'ๅปถๅฏฟๅฟ':'ๅๅฐๆปจๅธ',
'้ฟๅๅธ':'ๅๅฐๆปจๅธ',
'ๅๅๅธ':'ๅๅฐๆปจๅธ',
'ๅฐๅฟๅธ':'ๅๅฐๆปจๅธ',
'ไบๅธธๅธ':'ๅๅฐๆปจๅธ',
'ๅธ่พๅบ':'้ฝ้ฝๅๅฐๅธ',
'้พๆฒๅบ':'้ฝ้ฝๅๅฐๅธ',
'ๅปบๅๅบ':'้ฝ้ฝๅๅฐๅธ',
'้้ๅบ':'้ฝ้ฝๅๅฐๅธ',
'ๆๆๆบชๅบ':'้ฝ้ฝๅๅฐๅธ',
'ๅฏๆๅฐๅบๅบ':'้ฝ้ฝๅๅฐๅธ',
'็ขพๅญๅฑฑๅบ':'้ฝ้ฝๅๅฐๅธ',
'ๆข
้ๆฏ่พพๆกๅฐๆๅบ':'้ฝ้ฝๅๅฐๅธ',
'้พๆฑๅฟ':'้ฝ้ฝๅๅฐๅธ',
'ไพๅฎๅฟ':'้ฝ้ฝๅๅฐๅธ',
'ๆณฐๆฅๅฟ':'้ฝ้ฝๅๅฐๅธ',
'็ๅๅฟ':'้ฝ้ฝๅๅฐๅธ',
'ๅฏ่ฃๅฟ':'้ฝ้ฝๅๅฐๅธ',
'ๅ
ๅฑฑๅฟ':'้ฝ้ฝๅๅฐๅธ',
'ๅ
ไธๅฟ':'้ฝ้ฝๅๅฐๅธ',
'ๆๆณๅฟ':'้ฝ้ฝๅๅฐๅธ',
'่ฎทๆฒณๅธ':'้ฝ้ฝๅๅฐๅธ',
'ๅธ่พๅบ':'้ธก่ฅฟๅธ',
'้ธกๅ ๅบ':'้ธก่ฅฟๅธ',
'ๆๅฑฑๅบ':'้ธก่ฅฟๅธ',
'ๆปด้ๅบ':'้ธก่ฅฟๅธ',
'ๆขจๆ ๅบ':'้ธก่ฅฟๅธ',
'ๅๅญๆฒณๅบ':'้ธก่ฅฟๅธ',
'้บปๅฑฑๅบ':'้ธก่ฅฟๅธ',
'้ธกไธๅฟ':'้ธก่ฅฟๅธ',
'่ๆๅธ':'้ธก่ฅฟๅธ',
'ๅฏๅฑฑๅธ':'้ธก่ฅฟๅธ',
'ๅธ่พๅบ':'้นคๅฒๅธ',
'ๅ้ณๅบ':'้นคๅฒๅธ',
'ๅทฅๅๅบ':'้นคๅฒๅธ',
'ๅๅฑฑๅบ':'้นคๅฒๅธ',
'ๅ
ดๅฎๅบ':'้นคๅฒๅธ',
'ไธๅฑฑๅบ':'้นคๅฒๅธ',
'ๅ
ดๅฑฑๅบ':'้นคๅฒๅธ',
'่ๅๅฟ':'้นคๅฒๅธ',
'็ปฅๆปจๅฟ':'้นคๅฒๅธ',
'ๅธ่พๅบ':'ๅ้ธญๅฑฑๅธ',
'ๅฐๅฑฑๅบ':'ๅ้ธญๅฑฑๅธ',
'ๅฒญไธๅบ':'ๅ้ธญๅฑฑๅธ',
'ๅๆนๅฐๅบ':'ๅ้ธญๅฑฑๅธ',
'ๅฎๅฑฑๅบ':'ๅ้ธญๅฑฑๅธ',
'้่ดคๅฟ':'ๅ้ธญๅฑฑๅธ',
'ๅ่ฐๅฟ':'ๅ้ธญๅฑฑๅธ',
'ๅฎๆธ
ๅฟ':'ๅ้ธญๅฑฑๅธ',
'้ฅถๆฒณๅฟ':'ๅ้ธญๅฑฑๅธ',
'ๅธ่พๅบ':'ๅคงๅบๅธ',
'่จๅฐๅพๅบ':'ๅคงๅบๅธ',
'้พๅคๅบ':'ๅคงๅบๅธ',
'่ฎฉ่ก่ทฏๅบ':'ๅคงๅบๅธ',
'็บขๅฒๅบ':'ๅคงๅบๅธ',
'ๅคงๅๅบ':'ๅคงๅบๅธ',
'่ๅทๅฟ':'ๅคงๅบๅธ',
'่ๆบๅฟ':'ๅคงๅบๅธ',
'ๆ็ธๅฟ':'ๅคงๅบๅธ',
'ๆๅฐไผฏ็น่ๅคๆ่ชๆฒปๅฟ':'ๅคงๅบๅธ',
'ๅธ่พๅบ':'ไผๆฅๅธ',
'ไผๆฅๅบ':'ไผๆฅๅธ',
'ๅๅฒๅบ':'ไผๆฅๅธ',
'ๅๅฅฝๅบ':'ไผๆฅๅธ',
'่ฅฟๆๅบ':'ไผๆฅๅธ',
'็ฟ ๅณฆๅบ':'ไผๆฅๅธ',
'ๆฐ้ๅบ':'ไผๆฅๅธ',
'็พๆบชๅบ':'ไผๆฅๅธ',
'้ๅฑฑๅฑฏๅบ':'ไผๆฅๅธ',
'ไบ่ฅๅบ':'ไผๆฅๅธ',
'ไน้ฉฌๆฒณๅบ':'ไผๆฅๅธ',
'ๆฑคๆบๆฒณๅบ':'ไผๆฅๅธ',
'ๅธฆๅฒญๅบ':'ไผๆฅๅธ',
'ไนไผๅฒญๅบ':'ไผๆฅๅธ',
'็บขๆๅบ':'ไผๆฅๅธ',
'ไธ็ๅฒญๅบ':'ไผๆฅๅธ',
'ๅ่ซๅฟ':'ไผๆฅๅธ',
'้ๅๅธ':'ไผๆฅๅธ',
'ๅธ่พๅบ':'ไฝณๆจๆฏๅธ',
'ๆฐธ็บขๅบ':'ไฝณๆจๆฏๅธ',
'ๅ้ณๅบ':'ไฝณๆจๆฏๅธ',
'ๅ่ฟๅบ':'ไฝณๆจๆฏๅธ',
'ไธ้ฃๅบ':'ไฝณๆจๆฏๅธ',
'้ๅบ':'ไฝณๆจๆฏๅธ',
'ๆกฆๅๅฟ':'ไฝณๆจๆฏๅธ',
'ๆกฆๅทๅฟ':'ไฝณๆจๆฏๅธ',
'ๆฑคๅๅฟ':'ไฝณๆจๆฏๅธ',
'ๆ่ฟๅฟ':'ไฝณๆจๆฏๅธ',
'ๅๆฑๅธ':'ไฝณๆจๆฏๅธ',
'ๅฏ้ฆๅธ':'ไฝณๆจๆฏๅธ',
'ๅธ่พๅบ':'ไธๅฐๆฒณๅธ',
'ๆฐๅ
ดๅบ':'ไธๅฐๆฒณๅธ',
'ๆกๅฑฑๅบ':'ไธๅฐๆฒณๅธ',
'่ๅญๆฒณๅบ':'ไธๅฐๆฒณๅธ',
'ๅๅฉๅฟ':'ไธๅฐๆฒณๅธ',
'ๅธ่พๅบ':'็กไธนๆฑๅธ',
'ไธๅฎๅบ':'็กไธนๆฑๅธ',
'้ณๆๅบ':'็กไธนๆฑๅธ',
'็ฑๆฐๅบ':'็กไธนๆฑๅธ',
'่ฅฟๅฎๅบ':'็กไธนๆฑๅธ',
'ไธๅฎๅฟ':'็กไธนๆฑๅธ',
'ๆๅฃๅฟ':'็กไธนๆฑๅธ',
'็ปฅ่ฌๆฒณๅธ':'็กไธนๆฑๅธ',
'ๆตทๆๅธ':'็กไธนๆฑๅธ',
'ๅฎๅฎๅธ':'็กไธนๆฑๅธ',
'็ฉๆฃฑๅธ':'็กไธนๆฑๅธ',
'ๅธ่พๅบ':'้ปๆฒณๅธ',
'็ฑ่พๅบ':'้ปๆฒณๅธ',
'ๅซฉๆฑๅฟ':'้ปๆฒณๅธ',
'้ๅ
ๅฟ':'้ปๆฒณๅธ',
'ๅญๅดๅฟ':'้ปๆฒณๅธ',
'ๅๅฎๅธ':'้ปๆฒณๅธ',
'ไบๅคง่ฟๆฑ ๅธ':'้ปๆฒณๅธ',
'ๅธ่พๅบ':'็ปฅๅๅธ',
'ๅๆๅบ':'็ปฅๅๅธ',
'ๆๅฅๅฟ':'็ปฅๅๅธ',
'ๅ
ฐ่ฅฟๅฟ':'็ปฅๅๅธ',
'้ๅๅฟ':'็ปฅๅๅธ',
'ๅบๅฎๅฟ':'็ปฅๅๅธ',
'ๆๆฐดๅฟ':'็ปฅๅๅธ',
'็ปฅๆฃฑๅฟ':'็ปฅๅๅธ',
'ๅฎ่พพๅธ':'็ปฅๅๅธ',
'่ไธๅธ':'็ปฅๅๅธ',
'ๆตทไผฆๅธ':'็ปฅๅๅธ',
'ๅผ็ๅฟ':'ๅคงๅ
ดๅฎๅฒญๅฐๅบ',
'ๅกๆฒณๅฟ':'ๅคงๅ
ดๅฎๅฒญๅฐๅบ',
'ๆผ ๆฒณๅฟ':'ๅคงๅ
ดๅฎๅฒญๅฐๅบ',
'้ปๆตฆๅบ':'ไธๆตทๅธ',
'ๅขๆนพๅบ':'ไธๆตทๅธ',
'ๅพๆฑๅบ':'ไธๆตทๅธ',
'้ฟๅฎๅบ':'ไธๆตทๅธ',
'้ๅฎๅบ':'ไธๆตทๅธ',
'ๆฎ้ๅบ':'ไธๆตทๅธ',
'้ธๅๅบ':'ไธๆตทๅธ',
'่นๅฃๅบ':'ไธๆตทๅธ',
'ๆจๆตฆๅบ':'ไธๆตทๅธ',
'้ต่กๅบ':'ไธๆตทๅธ',
'ๅฎๅฑฑๅบ':'ไธๆตทๅธ',
'ๅๅฎๅบ':'ไธๆตทๅธ',
'ๆตฆไธๆฐๅบ':'ไธๆตทๅธ',
'้ๅฑฑๅบ':'ไธๆตทๅธ',
'ๆพๆฑๅบ':'ไธๆตทๅธ',
'้ๆตฆๅบ':'ไธๆตทๅธ',
'ๅๆฑๅบ':'ไธๆตทๅธ',
'ๅฅ่ดคๅบ':'ไธๆตทๅธ',
'ๅดๆๅฟ':'ไธๆตทๅธ',
'ๅธ่พๅบ':'ๅไบฌๅธ',
'็ๆญฆๅบ':'ๅไบฌๅธ',
'็ฝไธๅบ':'ๅไบฌๅธ',
'็งฆๆทฎๅบ':'ๅไบฌๅธ',
'ๅปบ้บๅบ':'ๅไบฌๅธ',
'้ผๆฅผๅบ':'ๅไบฌๅธ',
'ไธๅ
ณๅบ':'ๅไบฌๅธ',
'ๆตฆๅฃๅบ':'ๅไบฌๅธ',
'ๆ ้ๅบ':'ๅไบฌๅธ',
'้จ่ฑๅฐๅบ':'ๅไบฌๅธ',
'ๆฑๅฎๅบ':'ๅไบฌๅธ',
'ๅ
ญๅๅบ':'ๅไบฌๅธ',
'ๆบงๆฐดๅฟ':'ๅไบฌๅธ',
'้ซๆทณๅฟ':'ๅไบฌๅธ',
'ๅธ่พๅบ':'ๆ ้กๅธ',
'ๅดๅฎๅบ':'ๆ ้กๅธ',
'ๅ้ฟๅบ':'ๆ ้กๅธ',
'ๅๅกๅบ':'ๆ ้กๅธ',
'้กๅฑฑๅบ':'ๆ ้กๅธ',
'ๆ ๅฑฑๅบ':'ๆ ้กๅธ',
'ๆปจๆนๅบ':'ๆ ้กๅธ',
'ๆฑ้ดๅธ':'ๆ ้กๅธ',
'ๅฎๅ
ดๅธ':'ๆ ้กๅธ',
'ๅธ่พๅบ':'ๅพๅทๅธ',
'้ผๆฅผๅบ':'ๅพๅทๅธ',
'ไบ้พๅบ':'ๅพๅทๅธ',
'ไน้ๅบ':'ๅพๅทๅธ',
'่ดพๆฑชๅบ':'ๅพๅทๅธ',
'ๆณๅฑฑๅบ':'ๅพๅทๅธ',
'ไธฐๅฟ':'ๅพๅทๅธ',
'ๆฒๅฟ':'ๅพๅทๅธ',
'้ๅฑฑๅฟ':'ๅพๅทๅธ',
'็ขๅฎๅฟ':'ๅพๅทๅธ',
'ๆฐๆฒๅธ':'ๅพๅทๅธ',
'้ณๅทๅธ':'ๅพๅทๅธ',
'ๅธ่พๅบ':'ๅธธๅทๅธ',
'ๅคฉๅฎๅบ':'ๅธธๅทๅธ',
'้ๆฅผๅบ':'ๅธธๅทๅธ',
'ๆๅข
ๅ ฐๅบ':'ๅธธๅทๅธ',
'ๆฐๅๅบ':'ๅธธๅทๅธ',
'ๆญฆ่ฟๅบ':'ๅธธๅทๅธ',
'ๆบง้ณๅธ':'ๅธธๅทๅธ',
'้ๅๅธ':'ๅธธๅทๅธ',
'ๅธ่พๅบ':'่ๅทๅธ',
'ๆฒงๆตชๅบ':'่ๅทๅธ',
'ๅนณๆฑๅบ':'่ๅทๅธ',
'้้ๅบ':'่ๅทๅธ',
'่ไธๅบ':'่ๅทๅธ',
'ๅดไธญๅบ':'่ๅทๅธ',
'็ธๅๅบ':'่ๅทๅธ',
'ๅธธ็ๅธ':'่ๅทๅธ',
'ๅผ ๅฎถๆธฏๅธ':'่ๅทๅธ',
'ๆๅฑฑๅธ':'่ๅทๅธ',
'ๅดๆฑๅธ':'่ๅทๅธ',
'ๅคชไปๅธ':'่ๅทๅธ',
'ๅธ่พๅบ':'ๅ้ๅธ',
'ๅดๅทๅบ':'ๅ้ๅธ',
'ๆธฏ้ธๅบ':'ๅ้ๅธ',
'ๆตทๅฎๅฟ':'ๅ้ๅธ',
'ๅฆไธๅฟ':'ๅ้ๅธ',
'ๅฏไธๅธ':'ๅ้ๅธ',
'ๅฆ็ๅธ':'ๅ้ๅธ',
'้ๅทๅธ':'ๅ้ๅธ',
'ๆตท้จๅธ':'ๅ้ๅธ',
'ๅธ่พๅบ':'่ฟไบๆธฏๅธ',
'่ฟไบๅบ':'่ฟไบๆธฏๅธ',
'ๆฐๆตฆๅบ':'่ฟไบๆธฏๅธ',
'ๆตทๅทๅบ':'่ฟไบๆธฏๅธ',
'่ตฃๆฆๅฟ':'่ฟไบๆธฏๅธ',
'ไธๆตทๅฟ':'่ฟไบๆธฏๅธ',
'็ไบๅฟ':'่ฟไบๆธฏๅธ',
'็ๅๅฟ':'่ฟไบๆธฏๅธ',
'ๅธ่พๅบ':'ๆทฎๅฎๅธ',
'ๆธ
ๆฒณๅบ':'ๆทฎๅฎๅธ',
'ๆฅๅทๅบ':'ๆทฎๅฎๅธ',
'ๆทฎ้ดๅบ':'ๆทฎๅฎๅธ',
'ๆธ
ๆตฆๅบ':'ๆทฎๅฎๅธ',
'ๆถๆฐดๅฟ':'ๆทฎๅฎๅธ',
'ๆดชๆณฝๅฟ':'ๆทฎๅฎๅธ',
'็ฑ็ๅฟ':'ๆทฎๅฎๅธ',
'้ๆนๅฟ':'ๆทฎๅฎๅธ',
'ๅธ่พๅบ':'็ๅๅธ',
'ไบญๆนๅบ':'็ๅๅธ',
'็้ฝๅบ':'็ๅๅธ',
'ๅๆฐดๅฟ':'็ๅๅธ',
'ๆปจๆตทๅฟ':'็ๅๅธ',
'้ๅฎๅฟ':'็ๅๅธ',
'ๅฐ้ณๅฟ':'็ๅๅธ',
'ๅปบๆนๅฟ':'็ๅๅธ',
'ไธๅฐๅธ':'็ๅๅธ',
'ๅคงไธฐๅธ':'็ๅๅธ',
'ๅธ่พๅบ':'ๆฌๅทๅธ',
'ๅนฟ้ตๅบ':'ๆฌๅทๅธ',
'้ๆฑๅบ':'ๆฌๅทๅธ',
'้ๅบ':'ๆฌๅทๅธ',
'ๅฎๅบๅฟ':'ๆฌๅทๅธ',
'ไปชๅพๅธ':'ๆฌๅทๅธ',
'้ซ้ฎๅธ':'ๆฌๅทๅธ',
'ๆฑ้ฝๅธ':'ๆฌๅทๅธ',
'ๅธ่พๅบ':'้ๆฑๅธ',
'ไบฌๅฃๅบ':'้ๆฑๅธ',
'ๆถฆๅทๅบ':'้ๆฑๅธ',
'ไธนๅพๅบ':'้ๆฑๅธ',
'ไธน้ณๅธ':'้ๆฑๅธ',
'ๆฌไธญๅธ':'้ๆฑๅธ',
'ๅฅๅฎนๅธ':'้ๆฑๅธ',
'ๅธ่พๅบ':'ๆณฐๅทๅธ',
'ๆตท้ตๅบ':'ๆณฐๅทๅธ',
'้ซๆธฏๅบ':'ๆณฐๅทๅธ',
'ๅ
ดๅๅธ':'ๆณฐๅทๅธ',
'้ๆฑๅธ':'ๆณฐๅทๅธ',
'ๆณฐๅ
ดๅธ':'ๆณฐๅทๅธ',
'ๅงๅ ฐๅธ':'ๆณฐๅทๅธ',
'ๅธ่พๅบ':'ๅฎฟ่ฟๅธ',
'ๅฎฟๅๅบ':'ๅฎฟ่ฟๅธ',
'ๅฎฟ่ฑซๅบ':'ๅฎฟ่ฟๅธ',
'ๆฒญ้ณๅฟ':'ๅฎฟ่ฟๅธ',
'ๆณ้ณๅฟ':'ๅฎฟ่ฟๅธ',
'ๆณๆดชๅฟ':'ๅฎฟ่ฟๅธ',
'ๅธ่พๅบ':'ๆญๅทๅธ',
'ไธๅๅบ':'ๆญๅทๅธ',
'ไธๅๅบ':'ๆญๅทๅธ',
'ๆฑๅนฒๅบ':'ๆญๅทๅธ',
'ๆฑๅข
ๅบ':'ๆญๅทๅธ',
'่ฅฟๆนๅบ':'ๆญๅทๅธ',
'ๆปจๆฑๅบ':'ๆญๅทๅธ',
'่งๅฑฑๅบ':'ๆญๅทๅธ',
'ไฝๆญๅบ':'ๆญๅทๅธ',
'ๆกๅบๅฟ':'ๆญๅทๅธ',
'ๆทณๅฎๅฟ':'ๆญๅทๅธ',
'ๅปบๅพทๅธ':'ๆญๅทๅธ',
'ๅฏ้ณๅธ':'ๆญๅทๅธ',
'ไธดๅฎๅธ':'ๆญๅทๅธ',
'ๅธ่พๅบ':'ๅฎๆณขๅธ',
'ๆตทๆๅบ':'ๅฎๆณขๅธ',
'ๆฑไธๅบ':'ๅฎๆณขๅธ',
'ๆฑๅๅบ':'ๅฎๆณขๅธ',
'ๅไปๅบ':'ๅฎๆณขๅธ',
'้ๆตทๅบ':'ๅฎๆณขๅธ',
'้ๅทๅบ':'ๅฎๆณขๅธ',
'่ฑกๅฑฑๅฟ':'ๅฎๆณขๅธ',
'ๅฎๆตทๅฟ':'ๅฎๆณขๅธ',
'ไฝๅงๅธ':'ๅฎๆณขๅธ',
'ๆ
ๆบชๅธ':'ๅฎๆณขๅธ',
'ๅฅๅๅธ':'ๅฎๆณขๅธ',
'ๅธ่พๅบ':'ๆธฉๅทๅธ',
'้นฟๅๅบ':'ๆธฉๅทๅธ',
'้พๆนพๅบ':'ๆธฉๅทๅธ',
'็ฏๆตทๅบ':'ๆธฉๅทๅธ',
'ๆดๅคดๅฟ':'ๆธฉๅทๅธ',
'ๆฐธๅๅฟ':'ๆธฉๅทๅธ',
'ๅนณ้ณๅฟ':'ๆธฉๅทๅธ',
'่ๅๅฟ':'ๆธฉๅทๅธ',
'ๆๆๅฟ':'ๆธฉๅทๅธ',
'ๆณฐ้กบๅฟ':'ๆธฉๅทๅธ',
'็ๅฎๅธ':'ๆธฉๅทๅธ',
'ไนๆธ
ๅธ':'ๆธฉๅทๅธ',
'ๅธ่พๅบ':'ๅๅ
ดๅธ',
'็งๅๅบ':'ๅๅ
ดๅธ',
'็งๆดฒๅบ':'ๅๅ
ดๅธ',
'ๅๅๅฟ':'ๅๅ
ดๅธ',
'ๆตท็ๅฟ':'ๅๅ
ดๅธ',
'ๆตทๅฎๅธ':'ๅๅ
ดๅธ',
'ๅนณๆนๅธ':'ๅๅ
ดๅธ',
'ๆกไนกๅธ':'ๅๅ
ดๅธ',
'ๅธ่พๅบ':'ๆนๅทๅธ',
'ๅดๅ
ดๅบ':'ๆนๅทๅธ',
'ๅๆตๅบ':'ๆนๅทๅธ',
'ๅพทๆธ
ๅฟ':'ๆนๅทๅธ',
'้ฟๅ
ดๅฟ':'ๆนๅทๅธ',
'ๅฎๅๅฟ':'ๆนๅทๅธ',
'ๅธ่พๅบ':'็ปๅ
ดๅธ',
'่ถๅๅบ':'็ปๅ
ดๅธ',
'็ปๅ
ดๅฟ':'็ปๅ
ดๅธ',
'ๆฐๆๅฟ':'็ปๅ
ดๅธ',
'่ฏธๆจๅธ':'็ปๅ
ดๅธ',
'ไธ่ๅธ':'็ปๅ
ดๅธ',
'ๅตๅทๅธ':'็ปๅ
ดๅธ',
'ๅธ่พๅบ':'้ๅๅธ',
'ๅฉบๅๅบ':'้ๅๅธ',
'้ไธๅบ':'้ๅๅธ',
'ๆญฆไนๅฟ':'้ๅๅธ',
'ๆตฆๆฑๅฟ':'้ๅๅธ',
'็ฃๅฎๅฟ':'้ๅๅธ',
'ๅ
ฐๆบชๅธ':'้ๅๅธ',
'ไนไนๅธ':'้ๅๅธ',
'ไธ้ณๅธ':'้ๅๅธ',
'ๆฐธๅบทๅธ':'้ๅๅธ',
'ๅธ่พๅบ':'่กขๅทๅธ',
'ๆฏๅๅบ':'่กขๅทๅธ',
'่กขๆฑๅบ':'่กขๅทๅธ',
'ๅธธๅฑฑๅฟ':'่กขๅทๅธ',
'ๅผๅๅฟ':'่กขๅทๅธ',
'้พๆธธๅฟ':'่กขๅทๅธ',
'ๆฑๅฑฑๅธ':'่กขๅทๅธ',
'ๅธ่พๅบ':'่ๅฑฑๅธ',
'ๅฎๆตทๅบ':'่ๅฑฑๅธ',
'ๆฎ้ๅบ':'่ๅฑฑๅธ',
'ๅฒฑๅฑฑๅฟ':'่ๅฑฑๅธ',
'ๅตๆณๅฟ':'่ๅฑฑๅธ',
'ๅธ่พๅบ':'ๅฐๅทๅธ',
'ๆคๆฑๅบ':'ๅฐๅทๅธ',
'้ปๅฒฉๅบ':'ๅฐๅทๅธ',
'่ทฏๆกฅๅบ':'ๅฐๅทๅธ',
'็็ฏๅฟ':'ๅฐๅทๅธ',
'ไธ้จๅฟ':'ๅฐๅทๅธ',
'ๅคฉๅฐๅฟ':'ๅฐๅทๅธ',
'ไปๅฑ
ๅฟ':'ๅฐๅทๅธ',
'ๆธฉๅฒญๅธ':'ๅฐๅทๅธ',
'ไธดๆตทๅธ':'ๅฐๅทๅธ',
'ๅธ่พๅบ':'ไธฝๆฐดๅธ',
'่ฒ้ฝๅบ':'ไธฝๆฐดๅธ',
'้็ฐๅฟ':'ไธฝๆฐดๅธ',
'็ผไบๅฟ':'ไธฝๆฐดๅธ',
'้ๆๅฟ':'ไธฝๆฐดๅธ',
'ๆพ้ณๅฟ':'ไธฝๆฐดๅธ',
'ไบๅๅฟ':'ไธฝๆฐดๅธ',
'ๅบๅ
ๅฟ':'ไธฝๆฐดๅธ',
'ๆฏๅฎ็ฒๆ่ชๆฒปๅฟ':'ไธฝๆฐดๅธ',
'้พๆณๅธ':'ไธฝๆฐดๅธ',
'ๅธ่พๅบ':'ๅ่ฅๅธ',
'็ถๆตทๅบ':'ๅ่ฅๅธ',
'ๅบ้ณๅบ':'ๅ่ฅๅธ',
'่ๅฑฑๅบ':'ๅ่ฅๅธ',
'ๅ
ๆฒณๅบ':'ๅ่ฅๅธ',
'้ฟไธฐๅฟ':'ๅ่ฅๅธ',
'่ฅไธๅฟ':'ๅ่ฅๅธ',
'่ฅ่ฅฟๅฟ':'ๅ่ฅๅธ',
'ๅธ่พๅบ':'่ๆนๅธ',
'้ๆนๅบ':'่ๆนๅธ',
'้ฉฌๅกๅบ':'่ๆนๅธ',
'ๆฐ่ๅบ':'่ๆนๅธ',
'้ธ ๆฑๅบ':'่ๆนๅธ',
'่ๆนๅฟ':'่ๆนๅธ',
'็นๆๅฟ':'่ๆนๅธ',
'ๅ้ตๅฟ':'่ๆนๅธ',
'ๅธ่พๅบ':'่ๅ ๅธ',
'้พๅญๆนๅบ':'่ๅ ๅธ',
'่ๅฑฑๅบ':'่ๅ ๅธ',
'็ฆนไผๅบ':'่ๅ ๅธ',
'ๆทฎไธๅบ':'่ๅ ๅธ',
'ๆ่ฟๅฟ':'่ๅ ๅธ',
'ไบๆฒณๅฟ':'่ๅ ๅธ',
'ๅบ้ๅฟ':'่ๅ ๅธ',
'ๅธ่พๅบ':'ๆทฎๅๅธ',
'ๅคง้ๅบ':'ๆทฎๅๅธ',
'็ฐๅฎถๅบตๅบ':'ๆทฎๅๅธ',
'่ฐขๅฎถ้ๅบ':'ๆทฎๅๅธ',
'ๅ
ซๅ
ฌๅฑฑๅบ':'ๆทฎๅๅธ',
'ๆฝ้ๅบ':'ๆทฎๅๅธ',
'ๅคๅฐๅฟ':'ๆทฎๅๅธ',
'ๅธ่พๅบ':'้ฉฌ้ๅฑฑๅธ',
'้ๅฎถๅบๅบ':'้ฉฌ้ๅฑฑๅธ',
'่ฑๅฑฑๅบ':'้ฉฌ้ๅฑฑๅธ',
'้จๅฑฑๅบ':'้ฉฌ้ๅฑฑๅธ',
'ๅฝๆถๅฟ':'้ฉฌ้ๅฑฑๅธ',
'ๅธ่พๅบ':'ๆทฎๅๅธ',
'ๆ้ๅบ':'ๆทฎๅๅธ',
'็ธๅฑฑๅบ':'ๆทฎๅๅธ',
'็ๅฑฑๅบ':'ๆทฎๅๅธ',
'ๆฟๆบชๅฟ':'ๆทฎๅๅธ',
'ๅธ่พๅบ':'้้ตๅธ',
'้ๅฎๅฑฑๅบ':'้้ตๅธ',
'็ฎๅญๅฑฑๅบ':'้้ตๅธ',
'้ๅบ':'้้ตๅธ',
'้้ตๅฟ':'้้ตๅธ',
'ๅธ่พๅบ':'ๅฎๅบๅธ',
'่ฟๆฑๅบ':'ๅฎๅบๅธ',
'ๅคง่งๅบ':'ๅฎๅบๅธ',
'้ๅบ':'ๅฎๅบๅธ',
'ๆๅฎๅฟ':'ๅฎๅบๅธ',
'ๆ้ณๅฟ':'ๅฎๅบๅธ',
'ๆฝๅฑฑๅฟ':'ๅฎๅบๅธ',
'ๅคชๆนๅฟ':'ๅฎๅบๅธ',
'ๅฎฟๆพๅฟ':'ๅฎๅบๅธ',
'ๆๆฑๅฟ':'ๅฎๅบๅธ',
'ๅฒณ่ฅฟๅฟ':'ๅฎๅบๅธ',
'ๆกๅๅธ':'ๅฎๅบๅธ',
'ๅธ่พๅบ':'้ปๅฑฑๅธ',
'ๅฑฏๆบชๅบ':'้ปๅฑฑๅธ',
'้ปๅฑฑๅบ':'้ปๅฑฑๅธ',
'ๅพฝๅทๅบ':'้ปๅฑฑๅธ',
'ๆญๅฟ':'้ปๅฑฑๅธ',
'ไผๅฎๅฟ':'้ปๅฑฑๅธ',
'้ปๅฟ':'้ปๅฑฑๅธ',
'็ฅ้จๅฟ':'้ปๅฑฑๅธ',
'ๅธ่พๅบ':'ๆปๅทๅธ',
'็
็ๅบ':'ๆปๅทๅธ',
'ๅ่ฐฏๅบ':'ๆปๅทๅธ',
'ๆฅๅฎๅฟ':'ๆปๅทๅธ',
'ๅ
จๆคๅฟ':'ๆปๅทๅธ',
'ๅฎ่ฟๅฟ':'ๆปๅทๅธ',
'ๅค้ณๅฟ':'ๆปๅทๅธ',
'ๅคฉ้ฟๅธ':'ๆปๅทๅธ',
'ๆๅ
ๅธ':'ๆปๅทๅธ',
'ๅธ่พๅบ':'้้ณๅธ',
'้ขๅทๅบ':'้้ณๅธ',
'้ขไธๅบ':'้้ณๅธ',
'้ขๆณๅบ':'้้ณๅธ',
'ไธดๆณๅฟ':'้้ณๅธ',
'ๅคชๅๅฟ':'้้ณๅธ',
'้ๅๅฟ':'้้ณๅธ',
'้ขไธๅฟ':'้้ณๅธ',
'็้ฆๅธ':'้้ณๅธ',
'ๅธ่พๅบ':'ๅฎฟๅทๅธ',
'ๅขๆกฅๅบ':'ๅฎฟๅทๅธ',
'็ ๅฑฑๅฟ':'ๅฎฟๅทๅธ',
'่งๅฟ':'ๅฎฟๅทๅธ',
'็ต็งๅฟ':'ๅฎฟๅทๅธ',
'ๆณๅฟ':'ๅฎฟๅทๅธ',
'ๅธ่พๅบ':'ๅทขๆนๅธ',
'ๅฑ
ๅทขๅบ':'ๅทขๆนๅธ',
'ๅบๆฑๅฟ':'ๅทขๆนๅธ',
'ๆ ไธบๅฟ':'ๅทขๆนๅธ',
'ๅซๅฑฑๅฟ':'ๅทขๆนๅธ',
'ๅๅฟ':'ๅทขๆนๅธ',
'ๅธ่พๅบ':'ๅ
ญๅฎๅธ',
'้ๅฎๅบ':'ๅ
ญๅฎๅธ',
'่ฃๅฎๅบ':'ๅ
ญๅฎๅธ',
'ๅฏฟๅฟ':'ๅ
ญๅฎๅธ',
'้้ฑๅฟ':'ๅ
ญๅฎๅธ',
'่ๅๅฟ':'ๅ
ญๅฎๅธ',
'้ๅฏจๅฟ':'ๅ
ญๅฎๅธ',
'้ๅฑฑๅฟ':'ๅ
ญๅฎๅธ',
'ๅธ่พๅบ':'ไบณๅทๅธ',
'่ฐฏๅๅบ':'ไบณๅทๅธ',
'ๆถก้ณๅฟ':'ไบณๅทๅธ',
'่ๅๅฟ':'ไบณๅทๅธ',
'ๅฉ่พๅฟ':'ไบณๅทๅธ',
'ๅธ่พๅบ':'ๆฑ ๅทๅธ',
'่ดตๆฑ ๅบ':'ๆฑ ๅทๅธ',
'ไธ่ณๅฟ':'ๆฑ ๅทๅธ',
'็ณๅฐๅฟ':'ๆฑ ๅทๅธ',
'้้ณๅฟ':'ๆฑ ๅทๅธ',
'ๅธ่พๅบ':'ๅฎฃๅๅธ',
'ๅฎฃๅทๅบ':'ๅฎฃๅๅธ',
'้ๆบชๅฟ':'ๅฎฃๅๅธ',
'ๅนฟๅพทๅฟ':'ๅฎฃๅๅธ',
'ๆณพๅฟ':'ๅฎฃๅๅธ',
'็ปฉๆบชๅฟ':'ๅฎฃๅๅธ',
'ๆๅพทๅฟ':'ๅฎฃๅๅธ',
'ๅฎๅฝๅธ':'ๅฎฃๅๅธ',
'ๅธ่พๅบ':'็ฆๅทๅธ',
'้ผๆฅผๅบ':'็ฆๅทๅธ',
'ๅฐๆฑๅบ':'็ฆๅทๅธ',
'ไปๅฑฑๅบ':'็ฆๅทๅธ',
'้ฉฌๅฐพๅบ':'็ฆๅทๅธ',
'ๆๅฎๅบ':'็ฆๅทๅธ',
'้ฝไพฏๅฟ':'็ฆๅทๅธ',
'่ฟๆฑๅฟ':'็ฆๅทๅธ',
'็ฝๆบๅฟ':'็ฆๅทๅธ',
'้ฝๆธ
ๅฟ':'็ฆๅทๅธ',
'ๆฐธๆณฐๅฟ':'็ฆๅทๅธ',
'ๅนณๆฝญๅฟ':'็ฆๅทๅธ',
'็ฆๆธ
ๅธ':'็ฆๅทๅธ',
'้ฟไนๅธ':'็ฆๅทๅธ',
'ๅธ่พๅบ':'ๅฆ้จๅธ',
'ๆๆๅบ':'ๅฆ้จๅธ',
'ๆตทๆฒงๅบ':'ๅฆ้จๅธ',
'ๆน้ๅบ':'ๅฆ้จๅธ',
'้็พๅบ':'ๅฆ้จๅธ',
'ๅๅฎๅบ':'ๅฆ้จๅธ',
'็ฟๅฎๅบ':'ๅฆ้จๅธ',
'ๅธ่พๅบ':'่็ฐๅธ',
'ๅๅขๅบ':'่็ฐๅธ',
'ๆถตๆฑๅบ':'่็ฐๅธ',
'่ๅๅบ':'่็ฐๅธ',
'็งๅฑฟๅบ':'่็ฐๅธ',
'ไปๆธธๅฟ':'่็ฐๅธ',
'ๅธ่พๅบ':'ไธๆๅธ',
'ๆข
ๅๅบ':'ไธๆๅธ',
'ไธๅ
ๅบ':'ไธๆๅธ',
'ๆๆบชๅฟ':'ไธๆๅธ',
'ๆธ
ๆตๅฟ':'ไธๆๅธ',
'ๅฎๅๅฟ':'ไธๆๅธ',
'ๅคง็ฐๅฟ':'ไธๆๅธ',
'ๅฐคๆบชๅฟ':'ไธๆๅธ',
'ๆฒๅฟ':'ไธๆๅธ',
'ๅฐไนๅฟ':'ไธๆๅธ',
'ๆณฐๅฎๅฟ':'ไธๆๅธ',
'ๅปบๅฎๅฟ':'ไธๆๅธ',
'ๆฐธๅฎๅธ':'ไธๆๅธ',
'ๅธ่พๅบ':'ๆณๅทๅธ',
'้ฒคๅๅบ':'ๆณๅทๅธ',
'ไธฐๆณฝๅบ':'ๆณๅทๅธ',
'ๆดๆฑๅบ':'ๆณๅทๅธ',
'ๆณๆธฏๅบ':'ๆณๅทๅธ',
'ๆ ๅฎๅฟ':'ๆณๅทๅธ',
'ๅฎๆบชๅฟ':'ๆณๅทๅธ',
'ๆฐธๆฅๅฟ':'ๆณๅทๅธ',
'ๅพทๅๅฟ':'ๆณๅทๅธ',
'้้จๅฟ':'ๆณๅทๅธ',
'็ณ็ฎๅธ':'ๆณๅทๅธ',
'ๆๆฑๅธ':'ๆณๅทๅธ',
'ๅๅฎๅธ':'ๆณๅทๅธ',
'ๅธ่พๅบ':'ๆผณๅทๅธ',
'่ๅๅบ':'ๆผณๅทๅธ',
'้พๆๅบ':'ๆผณๅทๅธ',
'ไบ้ๅฟ':'ๆผณๅทๅธ',
'ๆผณๆตฆๅฟ':'ๆผณๅทๅธ',
'่ฏๅฎๅฟ':'ๆผณๅทๅธ',
'้ฟๆณฐๅฟ':'ๆผณๅทๅธ',
'ไธๅฑฑๅฟ':'ๆผณๅทๅธ',
'ๅ้ๅฟ':'ๆผณๅทๅธ',
'ๅนณๅๅฟ':'ๆผณๅทๅธ',
'ๅๅฎๅฟ':'ๆผณๅทๅธ',
'้พๆตทๅธ':'ๆผณๅทๅธ',
'ๅธ่พๅบ':'ๅๅนณๅธ',
'ๅปถๅนณๅบ':'ๅๅนณๅธ',
'้กบๆๅฟ':'ๅๅนณๅธ',
'ๆตฆๅๅฟ':'ๅๅนณๅธ',
'ๅ
ๆณฝๅฟ':'ๅๅนณๅธ',
'ๆพๆบชๅฟ':'ๅๅนณๅธ',
'ๆฟๅๅฟ':'ๅๅนณๅธ',
'้ตๆญฆๅธ':'ๅๅนณๅธ',
'ๆญฆๅคทๅฑฑๅธ':'ๅๅนณๅธ',
'ๅปบ็ฏๅธ':'ๅๅนณๅธ',
'ๅปบ้ณๅธ':'ๅๅนณๅธ',
'ๅธ่พๅบ':'้พๅฒฉๅธ',
'ๆฐ็ฝๅบ':'้พๅฒฉๅธ',
'้ฟๆฑๅฟ':'้พๅฒฉๅธ',
'ๆฐธๅฎๅฟ':'้พๅฒฉๅธ',
'ไธๆญๅฟ':'้พๅฒฉๅธ',
'ๆญฆๅนณๅฟ':'้พๅฒฉๅธ',
'่ฟๅๅฟ':'้พๅฒฉๅธ',
'ๆผณๅนณๅธ':'้พๅฒฉๅธ',
'ๅธ่พๅบ':'ๅฎๅพทๅธ',
'่ๅๅบ':'ๅฎๅพทๅธ',
'้ๆตฆๅฟ':'ๅฎๅพทๅธ',
'ๅค็ฐๅฟ':'ๅฎๅพทๅธ',
'ๅฑๅๅฟ':'ๅฎๅพทๅธ',
'ๅฏฟๅฎๅฟ':'ๅฎๅพทๅธ',
'ๅจๅฎๅฟ':'ๅฎๅพทๅธ',
'ๆ่ฃๅฟ':'ๅฎๅพทๅธ',
'็ฆๅฎๅธ':'ๅฎๅพทๅธ',
'็ฆ้ผๅธ':'ๅฎๅพทๅธ',
'ๅธ่พๅบ':'ๅๆๅธ',
'ไธๆนๅบ':'ๅๆๅธ',
'่ฅฟๆนๅบ':'ๅๆๅธ',
'้ไบ่ฐฑๅบ':'ๅๆๅธ',
'ๆนพ้ๅบ':'ๅๆๅธ',
'้ๅฑฑๆนๅบ':'ๅๆๅธ',
'ๅๆๅฟ':'ๅๆๅธ',
'ๆฐๅปบๅฟ':'ๅๆๅธ',
'ๅฎไนๅฟ':'ๅๆๅธ',
'่ฟ่ดคๅฟ':'ๅๆๅธ',
'ๅธ่พๅบ':'ๆฏๅพท้ๅธ',
'ๆๆฑๅบ':'ๆฏๅพท้ๅธ',
'็ ๅฑฑๅบ':'ๆฏๅพท้ๅธ',
'ๆตฎๆขๅฟ':'ๆฏๅพท้ๅธ',
'ไนๅนณๅธ':'ๆฏๅพท้ๅธ',
'ๅธ่พๅบ':'่ไนกๅธ',
'ๅฎๆบๅบ':'่ไนกๅธ',
'ๆนไธๅบ':'่ไนกๅธ',
'่ฒ่ฑๅฟ':'่ไนกๅธ',
'ไธๆ ๅฟ':'่ไนกๅธ',
'่ฆๆบชๅฟ':'่ไนกๅธ',
'ๅธ่พๅบ':'ไนๆฑๅธ',
'ๅบๅฑฑๅบ':'ไนๆฑๅธ',
'ๆต้ณๅบ':'ไนๆฑๅธ',
'ไนๆฑๅฟ':'ไนๆฑๅธ',
'ๆญฆๅฎๅฟ':'ไนๆฑๅธ',
'ไฟฎๆฐดๅฟ':'ไนๆฑๅธ',
'ๆฐธไฟฎๅฟ':'ไนๆฑๅธ',
'ๅพทๅฎๅฟ':'ไนๆฑๅธ',
'ๆๅญๅฟ':'ไนๆฑๅธ',
'้ฝๆๅฟ':'ไนๆฑๅธ',
'ๆนๅฃๅฟ':'ไนๆฑๅธ',
'ๅฝญๆณฝๅฟ':'ไนๆฑๅธ',
'็ๆๅธ':'ไนๆฑๅธ',
'ๅธ่พๅบ':'ๆฐไฝๅธ',
'ๆธๆฐดๅบ':'ๆฐไฝๅธ',
'ๅๅฎๅฟ':'ๆฐไฝๅธ',
'ๅธ่พๅบ':'้นฐๆฝญๅธ',
'ๆๆนๅบ':'้นฐๆฝญๅธ',
'ไฝๆฑๅฟ':'้นฐๆฝญๅธ',
'่ดตๆบชๅธ':'้นฐๆฝญๅธ',
'ๅธ่พๅบ':'่ตฃๅทๅธ',
'็ซ ่ดกๅบ':'่ตฃๅทๅธ',
'่ตฃๅฟ':'่ตฃๅทๅธ',
'ไฟกไธฐๅฟ':'่ตฃๅทๅธ',
'ๅคงไฝๅฟ':'่ตฃๅทๅธ',
'ไธ็นๅฟ':'่ตฃๅทๅธ',
'ๅดไนๅฟ':'่ตฃๅทๅธ',
'ๅฎ่ฟๅฟ':'่ตฃๅทๅธ',
'้พๅๅฟ':'่ตฃๅทๅธ',
'ๅฎๅๅฟ':'่ตฃๅทๅธ',
'ๅ
จๅๅฟ':'่ตฃๅทๅธ',
'ๅฎ้ฝๅฟ':'่ตฃๅทๅธ',
'ไบ้ฝๅฟ':'่ตฃๅทๅธ',
'ๅ
ดๅฝๅฟ':'่ตฃๅทๅธ',
'ไผๆๅฟ':'่ตฃๅทๅธ',
'ๅฏปไนๅฟ':'่ตฃๅทๅธ',
'็ณๅๅฟ':'่ตฃๅทๅธ',
'็้ๅธ':'่ตฃๅทๅธ',
'ๅๅบทๅธ':'่ตฃๅทๅธ',
'ๅธ่พๅบ':'ๅๅฎๅธ',
'ๅๅทๅบ':'ๅๅฎๅธ',
'้ๅๅบ':'ๅๅฎๅธ',
'ๅๅฎๅฟ':'ๅๅฎๅธ',
'ๅๆฐดๅฟ':'ๅๅฎๅธ',
'ๅณกๆฑๅฟ':'ๅๅฎๅธ',
'ๆฐๅนฒๅฟ':'ๅๅฎๅธ',
'ๆฐธไธฐๅฟ':'ๅๅฎๅธ',
'ๆณฐๅๅฟ':'ๅๅฎๅธ',
'้ๅทๅฟ':'ๅๅฎๅธ',
'ไธๅฎๅฟ':'ๅๅฎๅธ',
'ๅฎ็ฆๅฟ':'ๅๅฎๅธ',
'ๆฐธๆฐๅฟ':'ๅๅฎๅธ',
'ไบๅๅฑฑๅธ':'ๅๅฎๅธ',
'ๅธ่พๅบ':'ๅฎๆฅๅธ',
'่ขๅทๅบ':'ๅฎๆฅๅธ',
'ๅฅๆฐๅฟ':'ๅฎๆฅๅธ',
'ไธ่ฝฝๅฟ':'ๅฎๆฅๅธ',
'ไธ้ซๅฟ':'ๅฎๆฅๅธ',
'ๅฎไธฐๅฟ':'ๅฎๆฅๅธ',
'้ๅฎๅฟ':'ๅฎๆฅๅธ',
'้้ผๅฟ':'ๅฎๆฅๅธ',
'ไธฐๅๅธ':'ๅฎๆฅๅธ',
'ๆจๆ ๅธ':'ๅฎๆฅๅธ',
'้ซๅฎๅธ':'ๅฎๆฅๅธ',
'ๅธ่พๅบ':'ๆๅทๅธ',
'ไธดๅทๅบ':'ๆๅทๅธ',
'ๅๅๅฟ':'ๆๅทๅธ',
'้ปๅทๅฟ':'ๆๅทๅธ',
'ๅไธฐๅฟ':'ๆๅทๅธ',
'ๅดไปๅฟ':'ๆๅทๅธ',
'ไนๅฎๅฟ':'ๆๅทๅธ',
'ๅฎ้ปๅฟ':'ๆๅทๅธ',
'้ๆบชๅฟ':'ๆๅทๅธ',
'่ตๆบชๅฟ':'ๆๅทๅธ',
'ไธไนกๅฟ':'ๆๅทๅธ',
'ๅนฟๆๅฟ':'ๆๅทๅธ',
'ๅธ่พๅบ':'ไธ้ฅถๅธ',
'ไฟกๅทๅบ':'ไธ้ฅถๅธ',
'ไธ้ฅถๅฟ':'ไธ้ฅถๅธ',
'ๅนฟไธฐๅฟ':'ไธ้ฅถๅธ',
'็ๅฑฑๅฟ':'ไธ้ฅถๅธ',
'้
ๅฑฑๅฟ':'ไธ้ฅถๅธ',
'ๆจชๅณฐๅฟ':'ไธ้ฅถๅธ',
'ๅผ้ณๅฟ':'ไธ้ฅถๅธ',
'ไฝๅนฒๅฟ':'ไธ้ฅถๅธ',
'้ฑ้ณๅฟ':'ไธ้ฅถๅธ',
'ไธๅนดๅฟ':'ไธ้ฅถๅธ',
'ๅฉบๆบๅฟ':'ไธ้ฅถๅธ',
'ๅพทๅ
ดๅธ':'ไธ้ฅถๅธ',
'ๅธ่พๅบ':'ๆตๅๅธ',
'ๅไธๅบ':'ๆตๅๅธ',
'ๅธไธญๅบ':'ๆตๅๅธ',
'ๆง่ซๅบ':'ๆตๅๅธ',
'ๅคฉๆกฅๅบ':'ๆตๅๅธ',
'ๅๅๅบ':'ๆตๅๅธ',
'้ฟๆธ
ๅบ':'ๆตๅๅธ',
'ๅนณ้ดๅฟ':'ๆตๅๅธ',
'ๆต้ณๅฟ':'ๆตๅๅธ',
'ๅๆฒณๅฟ':'ๆตๅๅธ',
'็ซ ไธๅธ':'ๆตๅๅธ',
'ๅธ่พๅบ':'้ๅฒๅธ',
'ๅธๅๅบ':'้ๅฒๅธ',
'ๅธๅๅบ':'้ๅฒๅธ',
'ๅๆนๅบ':'้ๅฒๅธ',
'้ปๅฒๅบ':'้ๅฒๅธ',
'ๅดๅฑฑๅบ':'้ๅฒๅธ',
'ๆๆฒงๅบ':'้ๅฒๅธ',
'ๅ้ณๅบ':'้ๅฒๅธ',
'่ถๅทๅธ':'้ๅฒๅธ',
'ๅณๅขจๅธ':'้ๅฒๅธ',
'ๅนณๅบฆๅธ':'้ๅฒๅธ',
'่ถๅๅธ':'้ๅฒๅธ',
'่ฑ่ฅฟๅธ':'้ๅฒๅธ',
'ๅธ่พๅบ':'ๆทๅๅธ',
'ๆทๅทๅบ':'ๆทๅๅธ',
'ๅผ ๅบๅบ':'ๆทๅๅธ',
'ๅๅฑฑๅบ':'ๆทๅๅธ',
'ไธดๆทๅบ':'ๆทๅๅธ',
'ๅจๆๅบ':'ๆทๅๅธ',
'ๆกๅฐๅฟ':'ๆทๅๅธ',
'้ซ้ๅฟ':'ๆทๅๅธ',
'ๆฒๆบๅฟ':'ๆทๅๅธ',
'ๅธ่พๅบ':'ๆฃๅบๅธ',
'ๅธไธญๅบ':'ๆฃๅบๅธ',
'่ๅๅบ':'ๆฃๅบๅธ',
'ๅณๅๅบ':'ๆฃๅบๅธ',
'ๅฐๅฟๅบๅบ':'ๆฃๅบๅธ',
'ๅฑฑไบญๅบ':'ๆฃๅบๅธ',
'ๆปๅทๅธ':'ๆฃๅบๅธ',
'ๅธ่พๅบ':'ไธ่ฅๅธ',
'ไธ่ฅๅบ':'ไธ่ฅๅธ',
'ๆฒณๅฃๅบ':'ไธ่ฅๅธ',
'ๅฆๅฉๅฟ':'ไธ่ฅๅธ',
'ๅฉๆดฅๅฟ':'ไธ่ฅๅธ',
'ๅนฟ้ฅถๅฟ':'ไธ่ฅๅธ',
'ๅธ่พๅบ':'็ๅฐๅธ',
'่็ฝๅบ':'็ๅฐๅธ',
'็ฆๅฑฑๅบ':'็ๅฐๅธ',
'็ๅนณๅบ':'็ๅฐๅธ',
'่ฑๅฑฑๅบ':'็ๅฐๅธ',
'้ฟๅฒๅฟ':'็ๅฐๅธ',
'้พๅฃๅธ':'็ๅฐๅธ',
'่ฑ้ณๅธ':'็ๅฐๅธ',
'่ฑๅทๅธ':'็ๅฐๅธ',
'่ฌ่ฑๅธ':'็ๅฐๅธ',
'ๆ่ฟๅธ':'็ๅฐๅธ',
'ๆ ้ๅธ':'็ๅฐๅธ',
'ๆตท้ณๅธ':'็ๅฐๅธ',
'ๅธ่พๅบ':'ๆฝๅๅธ',
'ๆฝๅๅบ':'ๆฝๅๅธ',
'ๅฏไบญๅบ':'ๆฝๅๅธ',
'ๅๅญๅบ':'ๆฝๅๅธ',
'ๅฅๆๅบ':'ๆฝๅๅธ',
'ไธดๆๅฟ':'ๆฝๅๅธ',
'ๆไนๅฟ':'ๆฝๅๅธ',
'้ๅทๅธ':'ๆฝๅๅธ',
'่ฏธๅๅธ':'ๆฝๅๅธ',
'ๅฏฟๅ
ๅธ':'ๆฝๅๅธ',
'ๅฎไธๅธ':'ๆฝๅๅธ',
'้ซๅฏๅธ':'ๆฝๅๅธ',
'ๆ้ๅธ':'ๆฝๅๅธ',
'ๅธ่พๅบ':'ๆตๅฎๅธ',
'ๅธไธญๅบ':'ๆตๅฎๅธ',
'ไปปๅๅบ':'ๆตๅฎๅธ',
'ๅพฎๅฑฑๅฟ':'ๆตๅฎๅธ',
'้ฑผๅฐๅฟ':'ๆตๅฎๅธ',
'้ไนกๅฟ':'ๆตๅฎๅธ',
'ๅ็ฅฅๅฟ':'ๆตๅฎๅธ',
'ๆฑถไธๅฟ':'ๆตๅฎๅธ',
'ๆณๆฐดๅฟ':'ๆตๅฎๅธ',
'ๆขๅฑฑๅฟ':'ๆตๅฎๅธ',
'ๆฒ้ๅธ':'ๆตๅฎๅธ',
'ๅ
ๅทๅธ':'ๆตๅฎๅธ',
'้นๅๅธ':'ๆตๅฎๅธ',
'ๅธ่พๅบ':'ๆณฐๅฎๅธ',
'ๆณฐๅฑฑๅบ':'ๆณฐๅฎๅธ',
'ๅฒฑๅฒณๅบ':'ๆณฐๅฎๅธ',
'ๅฎ้ณๅฟ':'ๆณฐๅฎๅธ',
'ไธๅนณๅฟ':'ๆณฐๅฎๅธ',
'ๆฐๆณฐๅธ':'ๆณฐๅฎๅธ',
'่ฅๅๅธ':'ๆณฐๅฎๅธ',
'ๅธ่พๅบ':'ๅจๆตทๅธ',
'็ฏ็ฟ ๅบ':'ๅจๆตทๅธ',
'ๆ็ปๅธ':'ๅจๆตทๅธ',
'่ฃๆๅธ':'ๅจๆตทๅธ',
'ไนณๅฑฑๅธ':'ๅจๆตทๅธ',
'ๅธ่พๅบ':'ๆฅ็
งๅธ',
'ไธๆธฏๅบ':'ๆฅ็
งๅธ',
'ๅฒๅฑฑๅบ':'ๆฅ็
งๅธ',
'ไบ่ฒๅฟ':'ๆฅ็
งๅธ',
'่ๅฟ':'ๆฅ็
งๅธ',
'ๅธ่พๅบ':'่ฑ่ๅธ',
'่ฑๅๅบ':'่ฑ่ๅธ',
'้ขๅๅบ':'่ฑ่ๅธ',
'ๅธ่พๅบ':'ไธดๆฒๅธ',
'ๅ
ฐๅฑฑๅบ':'ไธดๆฒๅธ',
'็ฝๅบๅบ':'ไธดๆฒๅธ',
'ๆฒณไธๅบ':'ไธดๆฒๅธ',
'ๆฒๅๅฟ':'ไธดๆฒๅธ',
'้ฏๅๅฟ':'ไธดๆฒๅธ',
'ๆฒๆฐดๅฟ':'ไธดๆฒๅธ',
'่ๅฑฑๅฟ':'ไธดๆฒๅธ',
'่ดนๅฟ':'ไธดๆฒๅธ',
'ๅนณ้ๅฟ':'ไธดๆฒๅธ',
'่ๅๅฟ':'ไธดๆฒๅธ',
'่้ดๅฟ':'ไธดๆฒๅธ',
'ไธดๆฒญๅฟ':'ไธดๆฒๅธ',
'ๅธ่พๅบ':'ๅพทๅทๅธ',
'ๅพทๅๅบ':'ๅพทๅทๅธ',
'้ตๅฟ':'ๅพทๅทๅธ',
'ๅฎๆดฅๅฟ':'ๅพทๅทๅธ',
'ๅบไบๅฟ':'ๅพทๅทๅธ',
'ไธด้ๅฟ':'ๅพทๅทๅธ',
'้ฝๆฒณๅฟ':'ๅพทๅทๅธ',
'ๅนณๅๅฟ':'ๅพทๅทๅธ',
'ๅคๆดฅๅฟ':'ๅพทๅทๅธ',
'ๆญฆๅๅฟ':'ๅพทๅทๅธ',
'ไน้ตๅธ':'ๅพทๅทๅธ',
'็ฆนๅๅธ':'ๅพทๅทๅธ',
'ๅธ่พๅบ':'่ๅๅธ',
'ไธๆๅบๅบ':'่ๅๅธ',
'้ณ่ฐทๅฟ':'่ๅๅธ',
'่ๅฟ':'่ๅๅธ',
'่ๅนณๅฟ':'่ๅๅธ',
'ไธ้ฟๅฟ':'่ๅๅธ',
'ๅ ๅฟ':'่ๅๅธ',
'้ซๅๅฟ':'่ๅๅธ',
'ไธดๆธ
ๅธ':'่ๅๅธ',
'ๅธ่พๅบ':'ๆปจๅทๅธ',
'ๆปจๅๅบ':'ๆปจๅทๅธ',
'ๆ ๆฐๅฟ':'ๆปจๅทๅธ',
'้ณไฟกๅฟ':'ๆปจๅทๅธ',
'ๆ ๆฃฃๅฟ':'ๆปจๅทๅธ',
'ๆฒพๅๅฟ':'ๆปจๅทๅธ',
'ๅๅ
ดๅฟ':'ๆปจๅทๅธ',
'้นๅนณๅฟ':'ๆปจๅทๅธ',
'ๅธ่พๅบ':'่ทๆณฝๅธ',
'็กไธนๅบ':'่ทๆณฝๅธ',
'ๆนๅฟ':'่ทๆณฝๅธ',
'ๅๅฟ':'่ทๆณฝๅธ',
'ๆๆญฆๅฟ':'่ทๆณฝๅธ',
'ๅทจ้ๅฟ':'่ทๆณฝๅธ',
'้ๅๅฟ':'่ทๆณฝๅธ',
'้ๅๅฟ':'่ทๆณฝๅธ',
'ๅฎ้ถๅฟ':'่ทๆณฝๅธ',
'ไธๆๅฟ':'่ทๆณฝๅธ',
'ๅธ่พๅบ':'้ๅทๅธ',
'ไธญๅๅบ':'้ๅทๅธ',
'ไบไธๅบ':'้ๅทๅธ',
'็ฎกๅๅๆๅบ':'้ๅทๅธ',
'้ๆฐดๅบ':'้ๅทๅธ',
'ไธ่กๅบ':'้ๅทๅธ',
'้ๅฑฑๅบ':'้ๅทๅธ',
'ไธญ็ๅฟ':'้ๅทๅธ',
'ๅทฉไนๅธ':'้ๅทๅธ',
'่ฅ้ณๅธ':'้ๅทๅธ',
'ๆฐๅฏๅธ':'้ๅทๅธ',
'ๆฐ้ๅธ':'้ๅทๅธ',
'็ปๅฐๅธ':'้ๅทๅธ',
'ๅธ่พๅบ':'ๅผๅฐๅธ',
'้พไบญๅบ':'ๅผๅฐๅธ',
'้กบๆฒณๅๆๅบ':'ๅผๅฐๅธ',
'้ผๆฅผๅบ':'ๅผๅฐๅธ',
'ๅๅ
ณๅบ':'ๅผๅฐๅธ',
'้ๅบ':'ๅผๅฐๅธ',
'ๆๅฟ':'ๅผๅฐๅธ',
'้่ฎธๅฟ':'ๅผๅฐๅธ',
'ๅฐๆฐๅฟ':'ๅผๅฐๅธ',
'ๅผๅฐๅฟ':'ๅผๅฐๅธ',
'ๅ
ฐ่ๅฟ':'ๅผๅฐๅธ',
'ๅธ่พๅบ':'ๆด้ณๅธ',
'่ๅๅบ':'ๆด้ณๅธ',
'่ฅฟๅทฅๅบ':'ๆด้ณๅธ',
'ๅปๆฒณๅๆๅบ':'ๆด้ณๅธ',
'ๆถง่ฅฟๅบ':'ๆด้ณๅธ',
'ๅๅฉๅบ':'ๆด้ณๅธ',
'ๆด้พๅบ':'ๆด้ณๅธ',
'ๅญๆดฅๅฟ':'ๆด้ณๅธ',
'ๆฐๅฎๅฟ':'ๆด้ณๅธ',
'ๆ พๅทๅฟ':'ๆด้ณๅธ',
'ๅตฉๅฟ':'ๆด้ณๅธ',
'ๆฑ้ณๅฟ':'ๆด้ณๅธ',
'ๅฎ้ณๅฟ':'ๆด้ณๅธ',
'ๆดๅฎๅฟ':'ๆด้ณๅธ',
'ไผๅทๅฟ':'ๆด้ณๅธ',
'ๅๅธๅธ':'ๆด้ณๅธ',
'ๅธ่พๅบ':'ๅนณ้กถๅฑฑๅธ',
'ๆฐๅๅบ':'ๅนณ้กถๅฑฑๅธ',
'ๅซไธๅบ':'ๅนณ้กถๅฑฑๅธ',
'็ณ้พๅบ':'ๅนณ้กถๅฑฑๅธ',
'ๆนๆฒณๅบ':'ๅนณ้กถๅฑฑๅธ',
'ๅฎไธฐๅฟ':'ๅนณ้กถๅฑฑๅธ',
'ๅถๅฟ':'ๅนณ้กถๅฑฑๅธ',
'้ฒๅฑฑๅฟ':'ๅนณ้กถๅฑฑๅธ',
'้ๅฟ':'ๅนณ้กถๅฑฑๅธ',
'่้ขๅธ':'ๅนณ้กถๅฑฑๅธ',
'ๆฑๅทๅธ':'ๅนณ้กถๅฑฑๅธ',
'ๅธ่พๅบ':'ๅฎ้ณๅธ',
'ๆๅณฐๅบ':'ๅฎ้ณๅธ',
'ๅๅ
ณๅบ':'ๅฎ้ณๅธ',
'ๆฎท้ฝๅบ':'ๅฎ้ณๅธ',
'้พๅฎๅบ':'ๅฎ้ณๅธ',
'ๅฎ้ณๅฟ':'ๅฎ้ณๅธ',
'ๆฑค้ดๅฟ':'ๅฎ้ณๅธ',
'ๆปๅฟ':'ๅฎ้ณๅธ',
'ๅ
้ปๅฟ':'ๅฎ้ณๅธ',
'ๆๅทๅธ':'ๅฎ้ณๅธ',
'ๅธ่พๅบ':'้นคๅฃๅธ',
'้นคๅฑฑๅบ':'้นคๅฃๅธ',
'ๅฑฑๅๅบ':'้นคๅฃๅธ',
'ๆทๆปจๅบ':'้นคๅฃๅธ',
'ๆตๅฟ':'้นคๅฃๅธ',
'ๆทๅฟ':'้นคๅฃๅธ',
'ๅธ่พๅบ':'ๆฐไนกๅธ',
'็บขๆๅบ':'ๆฐไนกๅธ',
'ๅซๆปจๅบ':'ๆฐไนกๅธ',
'ๅคๆณๅบ':'ๆฐไนกๅธ',
'็ง้ๅบ':'ๆฐไนกๅธ',
'ๆฐไนกๅฟ':'ๆฐไนกๅธ',
'่ทๅๅฟ':'ๆฐไนกๅธ',
'ๅ้ณๅฟ':'ๆฐไนกๅธ',
'ๅปถๆดฅๅฟ':'ๆฐไนกๅธ',
'ๅฐไธๅฟ':'ๆฐไนกๅธ',
'้ฟๅฃๅฟ':'ๆฐไนกๅธ',
'ๅซ่พๅธ':'ๆฐไนกๅธ',
'่พๅฟๅธ':'ๆฐไนกๅธ',
'ๅธ่พๅบ':'็ฆไฝๅธ',
'่งฃๆพๅบ':'็ฆไฝๅธ',
'ไธญ็ซๅบ':'็ฆไฝๅธ',
'้ฉฌๆๅบ':'็ฆไฝๅธ',
'ๅฑฑ้ณๅบ':'็ฆไฝๅธ',
'ไฟฎๆญฆๅฟ':'็ฆไฝๅธ',
'ๅ็ฑๅฟ':'็ฆไฝๅธ',
'ๆญฆ้ๅฟ':'็ฆไฝๅธ',
'ๆธฉๅฟ':'็ฆไฝๅธ',
'ๆตๆบๅธ':'็ฆไฝๅธ',
'ๆฒ้ณๅธ':'็ฆไฝๅธ',
'ๅญๅทๅธ':'็ฆไฝๅธ',
'ๅธ่พๅบ':'ๆฟฎ้ณๅธ',
'ๅ้พๅบ':'ๆฟฎ้ณๅธ',
'ๆธ
ไธฐๅฟ':'ๆฟฎ้ณๅธ',
'ๅไนๅฟ':'ๆฟฎ้ณๅธ',
'่ๅฟ':'ๆฟฎ้ณๅธ',
'ๅฐๅๅฟ':'ๆฟฎ้ณๅธ',
'ๆฟฎ้ณๅฟ':'ๆฟฎ้ณๅธ',
'ๅธ่พๅบ':'่ฎธๆๅธ',
'้ญ้ฝๅบ':'่ฎธๆๅธ',
'่ฎธๆๅฟ':'่ฎธๆๅธ',
'้ข้ตๅฟ':'่ฎธๆๅธ',
'่ฅๅๅฟ':'่ฎธๆๅธ',
'็ฆนๅทๅธ':'่ฎธๆๅธ',
'้ฟ่ๅธ':'่ฎธๆๅธ',
'ๅธ่พๅบ':'ๆผฏๆฒณๅธ',
'ๆบๆฑๅบ':'ๆผฏๆฒณๅธ',
'้พๅๅบ':'ๆผฏๆฒณๅธ',
'ๅฌ้ตๅบ':'ๆผฏๆฒณๅธ',
'่้ณๅฟ':'ๆผฏๆฒณๅธ',
'ไธด้ขๅฟ':'ๆผฏๆฒณๅธ',
'ๅธ่พๅบ':'ไธ้จๅณกๅธ',
'ๆนๆปจๅบ':'ไธ้จๅณกๅธ',
'ๆธๆฑ ๅฟ':'ไธ้จๅณกๅธ',
'้ๅฟ':'ไธ้จๅณกๅธ',
'ๅขๆฐๅฟ':'ไธ้จๅณกๅธ',
'ไน้ฉฌๅธ':'ไธ้จๅณกๅธ',
'็ตๅฎๅธ':'ไธ้จๅณกๅธ',
'ๅธ่พๅบ':'ๅ้ณๅธ',
'ๅฎๅๅบ':'ๅ้ณๅธ',
'ๅง้พๅบ':'ๅ้ณๅธ',
'ๅๅฌๅฟ':'ๅ้ณๅธ',
'ๆนๅๅฟ':'ๅ้ณๅธ',
'่ฅฟๅณกๅฟ':'ๅ้ณๅธ',
'้ๅนณๅฟ':'ๅ้ณๅธ',
'ๅ
ไนกๅฟ':'ๅ้ณๅธ',
'ๆท
ๅทๅฟ':'ๅ้ณๅธ',
'็คพๆๅฟ':'ๅ้ณๅธ',
'ๅๆฒณๅฟ':'ๅ้ณๅธ',
'ๆฐ้ๅฟ':'ๅ้ณๅธ',
'ๆกๆๅฟ':'ๅ้ณๅธ',
'้ๅทๅธ':'ๅ้ณๅธ',
'ๅธ่พๅบ':'ๅไธๅธ',
'ๆขๅญๅบ':'ๅไธๅธ',
'็ข้ณๅบ':'ๅไธๅธ',
'ๆฐๆๅฟ':'ๅไธๅธ',
'็ขๅฟ':'ๅไธๅธ',
'ๅฎ้ตๅฟ':'ๅไธๅธ',
'ๆๅๅฟ':'ๅไธๅธ',
'่ๅๅฟ':'ๅไธๅธ',
'ๅค้ๅฟ':'ๅไธๅธ',
'ๆฐธๅๅธ':'ๅไธๅธ',
'ๅธ่พๅบ':'ไฟก้ณๅธ',
'ๅธๆฒณๅบ':'ไฟก้ณๅธ',
'ๅนณๆกฅๅบ':'ไฟก้ณๅธ',
'็ฝๅฑฑๅฟ':'ไฟก้ณๅธ',
'ๅ
ๅฑฑๅฟ':'ไฟก้ณๅธ',
'ๆฐๅฟ':'ไฟก้ณๅธ',
'ๅๅๅฟ':'ไฟก้ณๅธ',
'ๅบๅงๅฟ':'ไฟก้ณๅธ',
'ๆฝขๅทๅฟ':'ไฟก้ณๅธ',
'ๆทฎๆปจๅฟ':'ไฟก้ณๅธ',
'ๆฏๅฟ':'ไฟก้ณๅธ',
'ๅธ่พๅบ':'ๅจๅฃๅธ',
'ๅทๆฑๅบ':'ๅจๅฃๅธ',
'ๆถๆฒๅฟ':'ๅจๅฃๅธ',
'่ฅฟๅๅฟ':'ๅจๅฃๅธ',
'ๅๆฐดๅฟ':'ๅจๅฃๅธ',
'ๆฒไธๅฟ':'ๅจๅฃๅธ',
'้ธๅๅฟ':'ๅจๅฃๅธ',
'ๆทฎ้ณๅฟ':'ๅจๅฃๅธ',
'ๅคชๅบทๅฟ':'ๅจๅฃๅธ',
'้นฟ้ๅฟ':'ๅจๅฃๅธ',
'้กนๅๅธ':'ๅจๅฃๅธ',
'ๅธ่พๅบ':'้ฉป้ฉฌๅบๅธ',
'้ฉฟๅๅบ':'้ฉป้ฉฌๅบๅธ',
'่ฅฟๅนณๅฟ':'้ฉป้ฉฌๅบๅธ',
'ไธ่กๅฟ':'้ฉป้ฉฌๅบๅธ',
'ๅนณ่ๅฟ':'้ฉป้ฉฌๅบๅธ',
'ๆญฃ้ณๅฟ':'้ฉป้ฉฌๅบๅธ',
'็กฎๅฑฑๅฟ':'้ฉป้ฉฌๅบๅธ',
'ๆณ้ณๅฟ':'้ฉป้ฉฌๅบๅธ',
'ๆฑๅๅฟ':'้ฉป้ฉฌๅบๅธ',
'้ๅนณๅฟ':'้ฉป้ฉฌๅบๅธ',
'ๆฐ่กๅฟ':'้ฉป้ฉฌๅบๅธ',
'ๅธ่พๅบ':'ๆญฆๆฑๅธ',
'ๆฑๅฒธๅบ':'ๆญฆๆฑๅธ',
'ๆฑๆฑๅบ':'ๆญฆๆฑๅธ',
'ไนๅฃๅบ':'ๆญฆๆฑๅธ',
'ๆฑ้ณๅบ':'ๆญฆๆฑๅธ',
'ๆญฆๆๅบ':'ๆญฆๆฑๅธ',
'้ๅฑฑๅบ':'ๆญฆๆฑๅธ',
'ๆดชๅฑฑๅบ':'ๆญฆๆฑๅธ',
'ไธ่ฅฟๆนๅบ':'ๆญฆๆฑๅธ',
'ๆฑๅๅบ':'ๆญฆๆฑๅธ',
'่ก็ธๅบ':'ๆญฆๆฑๅธ',
'ๆฑๅคๅบ':'ๆญฆๆฑๅธ',
'้ป้ๅบ':'ๆญฆๆฑๅธ',
'ๆฐๆดฒๅบ':'ๆญฆๆฑๅธ',
'ๅธ่พๅบ':'้ป็ณๅธ',
'้ป็ณๆธฏๅบ':'้ป็ณๅธ',
'่ฅฟๅกๅฑฑๅบ':'้ป็ณๅธ',
'ไธ้ๅบ':'้ป็ณๅธ',
'้ๅฑฑๅบ':'้ป็ณๅธ',
'้ณๆฐๅฟ':'้ป็ณๅธ',
'ๅคงๅถๅธ':'้ป็ณๅธ',
'ๅธ่พๅบ':'ๅๅ ฐๅธ',
'่
็ฎญๅบ':'ๅๅ ฐๅธ',
'ๅผ ๆนพๅบ':'ๅๅ ฐๅธ',
'้งๅฟ':'ๅๅ ฐๅธ',
'้ง่ฅฟๅฟ':'ๅๅ ฐๅธ',
'็ซนๅฑฑๅฟ':'ๅๅ ฐๅธ',
'็ซนๆบชๅฟ':'ๅๅ ฐๅธ',
'ๆฟๅฟ':'ๅๅ ฐๅธ',
'ไธนๆฑๅฃๅธ':'ๅๅ ฐๅธ',
'ๅธ่พๅบ':'ๅฎๆๅธ',
'่ฅฟ้ตๅบ':'ๅฎๆๅธ',
'ไผๅฎถๅฒๅบ':'ๅฎๆๅธ',
'็นๅๅบ':'ๅฎๆๅธ',
'็ไบญๅบ':'ๅฎๆๅธ',
'ๅคท้ตๅบ':'ๅฎๆๅธ',
'่ฟๅฎๅฟ':'ๅฎๆๅธ',
'ๅ
ดๅฑฑๅฟ':'ๅฎๆๅธ',
'็งญๅฝๅฟ':'ๅฎๆๅธ',
'้ฟ้ณๅๅฎถๆ่ชๆฒปๅฟ':'ๅฎๆๅธ',
'ไบๅณฐๅๅฎถๆ่ชๆฒปๅฟ':'ๅฎๆๅธ',
'ๅฎ้ฝๅธ':'ๅฎๆๅธ',
'ๅฝ้ณๅธ':'ๅฎๆๅธ',
'ๆๆฑๅธ':'ๅฎๆๅธ',
'ๅธ่พๅบ':'่ฅๆจๅธ',
'่ฅๅๅบ':'่ฅๆจๅธ',
'ๆจๅๅบ':'่ฅๆจๅธ',
'่ฅ้ณๅบ':'่ฅๆจๅธ',
'ๅๆผณๅฟ':'่ฅๆจๅธ',
'่ฐทๅๅฟ':'่ฅๆจๅธ',
'ไฟๅบทๅฟ':'่ฅๆจๅธ',
'่ๆฒณๅฃๅธ':'่ฅๆจๅธ',
'ๆฃ้ณๅธ':'่ฅๆจๅธ',
'ๅฎๅๅธ':'่ฅๆจๅธ',
'ๅธ่พๅบ':'้ๅทๅธ',
'ๆขๅญๆนๅบ':'้ๅทๅธ',
'ๅๅฎนๅบ':'้ๅทๅธ',
'้ๅๅบ':'้ๅทๅธ',
'ๅธ่พๅบ':'่้จๅธ',
'ไธๅฎๅบ':'่้จๅธ',
'ๆๅๅบ':'่้จๅธ',
'ไบฌๅฑฑๅฟ':'่้จๅธ',
'ๆฒๆดๅฟ':'่้จๅธ',
'้็ฅฅๅธ':'่้จๅธ',
'ๅธ่พๅบ':'ๅญๆๅธ',
'ๅญๅๅบ':'ๅญๆๅธ',
'ๅญๆๅฟ':'ๅญๆๅธ',
'ๅคงๆๅฟ':'ๅญๆๅธ',
'ไบๆขฆๅฟ':'ๅญๆๅธ',
'ๅบๅๅธ':'ๅญๆๅธ',
'ๅฎ้ๅธ':'ๅญๆๅธ',
'ๆฑๅทๅธ':'ๅญๆๅธ',
'ๅธ่พๅบ':'่ๅทๅธ',
'ๆฒๅธๅบ':'่ๅทๅธ',
'่ๅทๅบ':'่ๅทๅธ',
'ๅ
ฌๅฎๅฟ':'่ๅทๅธ',
'็ๅฉๅฟ':'่ๅทๅธ',
'ๆฑ้ตๅฟ':'่ๅทๅธ',
'็ณ้ฆๅธ':'่ๅทๅธ',
'ๆดชๆนๅธ':'่ๅทๅธ',
'ๆพๆปๅธ':'่ๅทๅธ',
'ๅธ่พๅบ':'้ปๅๅธ',
'้ปๅทๅบ':'้ปๅๅธ',
'ๅข้ฃๅฟ':'้ปๅๅธ',
'็บขๅฎๅฟ':'้ปๅๅธ',
'็ฝ็ฐๅฟ':'้ปๅๅธ',
'่ฑๅฑฑๅฟ':'้ปๅๅธ',
'ๆต ๆฐดๅฟ':'้ปๅๅธ',
'่ฒๆฅๅฟ':'้ปๅๅธ',
'้ปๆข
ๅฟ':'้ปๅๅธ',
'้บปๅๅธ':'้ปๅๅธ',
'ๆญฆ็ฉดๅธ':'้ปๅๅธ',
'ๅธ่พๅบ':'ๅธๅฎๅธ',
'ๅธๅฎๅบ':'ๅธๅฎๅธ',
'ๅ้ฑผๅฟ':'ๅธๅฎๅธ',
'้ๅๅฟ':'ๅธๅฎๅธ',
'ๅด้ณๅฟ':'ๅธๅฎๅธ',
'้ๅฑฑๅฟ':'ๅธๅฎๅธ',
'่ตคๅฃๅธ':'ๅธๅฎๅธ',
'ๅธ่พๅบ':'้ๅทๅธ',
'ๆพ้ฝๅบ':'้ๅทๅธ',
'ๅนฟๆฐดๅธ':'้ๅทๅธ',
'ๆฉๆฝๅธ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅฉๅทๅธ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅปบๅงๅฟ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅทดไธๅฟ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅฎฃๆฉๅฟ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅธไธฐๅฟ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๆฅๅคๅฟ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'้นคๅณฐๅฟ':'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ไปๆกๅธ':'429000',
'ๆฝๆฑๅธ':'429000',
'ๅคฉ้จๅธ':'429000',
'็ฅๅๆถๆๅบ':'429000',
'ๅธ่พๅบ':'้ฟๆฒๅธ',
'่่ๅบ':'้ฟๆฒๅธ',
'ๅคฉๅฟๅบ':'้ฟๆฒๅธ',
'ๅฒณ้บๅบ':'้ฟๆฒๅธ',
'ๅผ็ฆๅบ':'้ฟๆฒๅธ',
'้จ่ฑๅบ':'้ฟๆฒๅธ',
'้ฟๆฒๅฟ':'้ฟๆฒๅธ',
'ๆๅๅฟ':'้ฟๆฒๅธ',
'ๅฎไนกๅฟ':'้ฟๆฒๅธ',
'ๆต้ณๅธ':'้ฟๆฒๅธ',
'ๅธ่พๅบ':'ๆ ชๆดฒๅธ',
'่ทๅกๅบ':'ๆ ชๆดฒๅธ',
'่ฆๆทๅบ':'ๆ ชๆดฒๅธ',
'็ณๅณฐๅบ':'ๆ ชๆดฒๅธ',
'ๅคฉๅ
ๅบ':'ๆ ชๆดฒๅธ',
'ๆ ชๆดฒๅฟ':'ๆ ชๆดฒๅธ',
'ๆธๅฟ':'ๆ ชๆดฒๅธ',
'่ถ้ตๅฟ':'ๆ ชๆดฒๅธ',
'็้ตๅฟ':'ๆ ชๆดฒๅธ',
'้ด้ตๅธ':'ๆ ชๆดฒๅธ',
'ๅธ่พๅบ':'ๆนๆฝญๅธ',
'้จๆนๅบ':'ๆนๆฝญๅธ',
'ๅฒณๅกๅบ':'ๆนๆฝญๅธ',
'ๆนๆฝญๅฟ':'ๆนๆฝญๅธ',
'ๆนไนกๅธ':'ๆนๆฝญๅธ',
'้ถๅฑฑๅธ':'ๆนๆฝญๅธ',
'ๅธ่พๅบ':'่กก้ณๅธ',
'็ ๆๅบ':'่กก้ณๅธ',
'้ๅณฐๅบ':'่กก้ณๅธ',
'็ณ้ผๅบ':'่กก้ณๅธ',
'่ธๆนๅบ':'่กก้ณๅธ',
'ๅๅฒณๅบ':'่กก้ณๅธ',
'่กก้ณๅฟ':'่กก้ณๅธ',
'่กกๅๅฟ':'่กก้ณๅธ',
'่กกๅฑฑๅฟ':'่กก้ณๅธ',
'่กกไธๅฟ':'่กก้ณๅธ',
'็ฅไธๅฟ':'่กก้ณๅธ',
'่้ณๅธ':'่กก้ณๅธ',
'ๅธธๅฎๅธ':'่กก้ณๅธ',
'ๅธ่พๅบ':'้ต้ณๅธ',
'ๅๆธ
ๅบ':'้ต้ณๅธ',
'ๅคง็ฅฅๅบ':'้ต้ณๅธ',
'ๅๅกๅบ':'้ต้ณๅธ',
'้ตไธๅฟ':'้ต้ณๅธ',
'ๆฐ้ตๅฟ':'้ต้ณๅธ',
'้ต้ณๅฟ':'้ต้ณๅธ',
'้ๅๅฟ':'้ต้ณๅธ',
'ๆดๅฃๅฟ':'้ต้ณๅธ',
'็ปฅๅฎๅฟ':'้ต้ณๅธ',
'ๆฐๅฎๅฟ':'้ต้ณๅธ',
'ๅๆญฅ่ๆ่ชๆฒปๅฟ':'้ต้ณๅธ',
'ๆญฆๅๅธ':'้ต้ณๅธ',
'ๅธ่พๅบ':'ๅฒณ้ณๅธ',
'ๅฒณ้ณๆฅผๅบ':'ๅฒณ้ณๅธ',
'ไบๆบชๅบ':'ๅฒณ้ณๅธ',
'ๅๅฑฑๅบ':'ๅฒณ้ณๅธ',
'ๅฒณ้ณๅฟ':'ๅฒณ้ณๅธ',
'ๅๅฎนๅฟ':'ๅฒณ้ณๅธ',
'ๆน้ดๅฟ':'ๅฒณ้ณๅธ',
'ๅนณๆฑๅฟ':'ๅฒณ้ณๅธ',
'ๆฑจ็ฝๅธ':'ๅฒณ้ณๅธ',
'ไธดๆนๅธ':'ๅฒณ้ณๅธ',
'ๅธ่พๅบ':'ๅธธๅพทๅธ',
'ๆญฆ้ตๅบ':'ๅธธๅพทๅธ',
'้ผๅๅบ':'ๅธธๅพทๅธ',
'ๅฎไนกๅฟ':'ๅธธๅพทๅธ',
'ๆฑๅฏฟๅฟ':'ๅธธๅพทๅธ',
'ๆพงๅฟ':'ๅธธๅพทๅธ',
'ไธดๆพงๅฟ':'ๅธธๅพทๅธ',
'ๆกๆบๅฟ':'ๅธธๅพทๅธ',
'็ณ้จๅฟ':'ๅธธๅพทๅธ',
'ๆดฅๅธๅธ':'ๅธธๅพทๅธ',
'ๅธ่พๅบ':'ๅผ ๅฎถ็ๅธ',
'ๆฐธๅฎๅบ':'ๅผ ๅฎถ็ๅธ',
'ๆญฆ้ตๆบๅบ':'ๅผ ๅฎถ็ๅธ',
'ๆ
ๅฉๅฟ':'ๅผ ๅฎถ็ๅธ',
'ๆกๆคๅฟ':'ๅผ ๅฎถ็ๅธ',
'ๅธ่พๅบ':'็้ณๅธ',
'่ต้ณๅบ':'็้ณๅธ',
'่ตซๅฑฑๅบ':'็้ณๅธ',
'ๅๅฟ':'็้ณๅธ',
'ๆกๆฑๅฟ':'็้ณๅธ',
'ๅฎๅๅฟ':'็้ณๅธ',
'ๆฒ
ๆฑๅธ':'็้ณๅธ',
'ๅธ่พๅบ':'้ดๅทๅธ',
'ๅๆนๅบ':'้ดๅทๅธ',
'่ไปๅบ':'้ดๅทๅธ',
'ๆก้ณๅฟ':'้ดๅทๅธ',
'ๅฎ็ซ ๅฟ':'้ดๅทๅธ',
'ๆฐธๅ
ดๅฟ':'้ดๅทๅธ',
'ๅ็ฆพๅฟ':'้ดๅทๅธ',
'ไธดๆญฆๅฟ':'้ดๅทๅธ',
'ๆฑๅๅฟ':'้ดๅทๅธ',
'ๆกไธๅฟ':'้ดๅทๅธ',
'ๅฎไปๅฟ':'้ดๅทๅธ',
'่ตๅ
ดๅธ':'้ดๅทๅธ',
'ๅธ่พๅบ':'ๆฐธๅทๅธ',
'่ๅฑฑๅบ':'ๆฐธๅทๅธ',
'ๅทๆฐดๆปฉๅบ':'ๆฐธๅทๅธ',
'็ฅ้ณๅฟ':'ๆฐธๅทๅธ',
'ไธๅฎๅฟ':'ๆฐธๅทๅธ',
'ๅ็ๅฟ':'ๆฐธๅทๅธ',
'้ๅฟ':'ๆฐธๅทๅธ',
'ๆฑๆฐธๅฟ':'ๆฐธๅทๅธ',
'ๅฎ่ฟๅฟ':'ๆฐธๅทๅธ',
'่ๅฑฑๅฟ':'ๆฐธๅทๅธ',
'ๆฐ็ฐๅฟ':'ๆฐธๅทๅธ',
'ๆฑๅ็ถๆ่ชๆฒปๅฟ':'ๆฐธๅทๅธ',
'ๅธ่พๅบ':'ๆๅๅธ',
'้นคๅๅบ':'ๆๅๅธ',
'ไธญๆนๅฟ':'ๆๅๅธ',
'ๆฒ
้ตๅฟ':'ๆๅๅธ',
'่พฐๆบชๅฟ':'ๆๅๅธ',
'ๆบๆตฆๅฟ':'ๆๅๅธ',
'ไผๅๅฟ':'ๆๅๅธ',
'้บป้ณ่ๆ่ชๆฒปๅฟ':'ๆๅๅธ',
'ๆฐๆไพๆ่ชๆฒปๅฟ':'ๆๅๅธ',
'่ทๆฑไพๆ่ชๆฒปๅฟ':'ๆๅๅธ',
'้ๅท่ๆไพๆ่ชๆฒปๅฟ':'ๆๅๅธ',
'้้ไพๆ่ชๆฒปๅฟ':'ๆๅๅธ',
'ๆดชๆฑๅธ':'ๆๅๅธ',
'ๅธ่พๅบ':'ๅจๅบๅธ',
'ๅจๆๅบ':'ๅจๅบๅธ',
'ๅๅณฐๅฟ':'ๅจๅบๅธ',
'ๆฐๅๅฟ':'ๅจๅบๅธ',
'ๅทๆฐดๆฑๅธ':'ๅจๅบๅธ',
'ๆถๆบๅธ':'ๅจๅบๅธ',
'ๅ้ฆๅธ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๆณธๆบชๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅคๅฐๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'่ฑๅฃๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ไฟ้ๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅคไธๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๆฐธ้กบๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'้พๅฑฑๅฟ':'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'ๅนฟๅทๅธ',
'ไธๅฑฑๅบ':'ๅนฟๅทๅธ',
'่ๆนพๅบ':'ๅนฟๅทๅธ',
'่ถ็งๅบ':'ๅนฟๅทๅธ',
'ๆตท็ ๅบ':'ๅนฟๅทๅธ',
'ๅคฉๆฒณๅบ':'ๅนฟๅทๅธ',
'่ณๆๅบ':'ๅนฟๅทๅธ',
'็ฝไบๅบ':'ๅนฟๅทๅธ',
'้ปๅๅบ':'ๅนฟๅทๅธ',
'็ช็ฆบๅบ':'ๅนฟๅทๅธ',
'่ฑ้ฝๅบ':'ๅนฟๅทๅธ',
'ๅขๅๅธ':'ๅนฟๅทๅธ',
'ไปๅๅธ':'ๅนฟๅทๅธ',
'ๅธ่พๅบ':'้ถๅ
ณๅธ',
'ๆญฆๆฑๅบ':'้ถๅ
ณๅธ',
'ๆตๆฑๅบ':'้ถๅ
ณๅธ',
'ๆฒๆฑๅบ':'้ถๅ
ณๅธ',
'ๅงๅ
ดๅฟ':'้ถๅ
ณๅธ',
'ไปๅๅฟ':'้ถๅ
ณๅธ',
'็ฟๆบๅฟ':'้ถๅ
ณๅธ',
'ไนณๆบ็ถๆ่ชๆฒปๅฟ':'้ถๅ
ณๅธ',
'ๆฐไธฐๅฟ':'้ถๅ
ณๅธ',
'ไนๆๅธ':'้ถๅ
ณๅธ',
'ๅ้ๅธ':'้ถๅ
ณๅธ',
'ๅธ่พๅบ':'ๆทฑๅณๅธ',
'็ฝๆนๅบ':'ๆทฑๅณๅธ',
'็ฆ็ฐๅบ':'ๆทฑๅณๅธ',
'ๅๅฑฑๅบ':'ๆทฑๅณๅธ',
'ๅฎๅฎๅบ':'ๆทฑๅณๅธ',
'้พๅฒๅบ':'ๆทฑๅณๅธ',
'็็ฐๅบ':'ๆทฑๅณๅธ',
'้พๅๅบ':'ๆทฑๅณๅธ',
'ๅธ่พๅบ':'็ ๆตทๅธ',
'้ฆๆดฒๅบ':'็ ๆตทๅธ',
'ๆ้จๅบ':'็ ๆตทๅธ',
'้ๆนพๅบ':'็ ๆตทๅธ',
'ๅธ่พๅบ':'ๆฑๅคดๅธ',
'้พๆนๅบ':'ๆฑๅคดๅธ',
'้ๅนณๅบ':'ๆฑๅคดๅธ',
'ๆฟ ๆฑๅบ':'ๆฑๅคดๅธ',
'ๆฝฎ้ณๅบ':'ๆฑๅคดๅธ',
'ๆฝฎๅๅบ':'ๆฑๅคดๅธ',
'ๆพๆตทๅบ':'ๆฑๅคดๅธ',
'ๅๆพณๅฟ':'ๆฑๅคดๅธ',
'ๅธ่พๅบ':'ไฝๅฑฑๅธ',
'็ฆ
ๅๅบ':'ไฝๅฑฑๅธ',
'ๅๆตทๅบ':'ไฝๅฑฑๅธ',
'้กบๅพทๅบ':'ไฝๅฑฑๅธ',
'ไธๆฐดๅบ':'ไฝๅฑฑๅธ',
'้ซๆๅบ':'ไฝๅฑฑๅธ',
'ๅธ่พๅบ':'ๆฑ้จๅธ',
'่ฌๆฑๅบ':'ๆฑ้จๅธ',
'ๆฑๆตทๅบ':'ๆฑ้จๅธ',
'ๆฐไผๅบ':'ๆฑ้จๅธ',
'ๅฐๅฑฑๅธ':'ๆฑ้จๅธ',
'ๅผๅนณๅธ':'ๆฑ้จๅธ',
'้นคๅฑฑๅธ':'ๆฑ้จๅธ',
'ๆฉๅนณๅธ':'ๆฑ้จๅธ',
'ๅธ่พๅบ':'ๆนๆฑๅธ',
'่ตคๅๅบ':'ๆนๆฑๅธ',
'้ๅฑฑๅบ':'ๆนๆฑๅธ',
'ๅกๅคดๅบ':'ๆนๆฑๅธ',
'้บป็ซ ๅบ':'ๆนๆฑๅธ',
'้ๆบชๅฟ':'ๆนๆฑๅธ',
'ๅพ้ปๅฟ':'ๆนๆฑๅธ',
'ๅปๆฑๅธ':'ๆนๆฑๅธ',
'้ทๅทๅธ':'ๆนๆฑๅธ',
'ๅดๅทๅธ':'ๆนๆฑๅธ',
'ๅธ่พๅบ':'่ๅๅธ',
'่ๅๅบ':'่ๅๅธ',
'่ๆธฏๅบ':'่ๅๅธ',
'็ต็ฝๅฟ':'่ๅๅธ',
'้ซๅทๅธ':'่ๅๅธ',
'ๅๅทๅธ':'่ๅๅธ',
'ไฟกๅฎๅธ':'่ๅๅธ',
'ๅธ่พๅบ':'่ๅบๅธ',
'็ซฏๅทๅบ':'่ๅบๅธ',
'้ผๆนๅบ':'่ๅบๅธ',
'ๅนฟๅฎๅฟ':'่ๅบๅธ',
'ๆ้ๅฟ':'่ๅบๅธ',
'ๅฐๅผๅฟ':'่ๅบๅธ',
'ๅพทๅบๅฟ':'่ๅบๅธ',
'้ซ่ฆๅธ':'่ๅบๅธ',
'ๅไผๅธ':'่ๅบๅธ',
'ๅธ่พๅบ':'ๆ ๅทๅธ',
'ๆ ๅๅบ':'ๆ ๅทๅธ',
'ๆ ้ณๅบ':'ๆ ๅทๅธ',
'ๅ็ฝๅฟ':'ๆ ๅทๅธ',
'ๆ ไธๅฟ':'ๆ ๅทๅธ',
'้พ้จๅฟ':'ๆ ๅทๅธ',
'ๅธ่พๅบ':'ๆข
ๅทๅธ',
'ๆข
ๆฑๅบ':'ๆข
ๅทๅธ',
'ๆข
ๅฟ':'ๆข
ๅทๅธ',
'ๅคงๅๅฟ':'ๆข
ๅทๅธ',
'ไธฐ้กบๅฟ':'ๆข
ๅทๅธ',
'ไบๅๅฟ':'ๆข
ๅทๅธ',
'ๅนณ่ฟๅฟ':'ๆข
ๅทๅธ',
'่ๅฒญๅฟ':'ๆข
ๅทๅธ',
'ๅ
ดๅฎๅธ':'ๆข
ๅทๅธ',
'ๅธ่พๅบ':'ๆฑๅฐพๅธ',
'ๅๅบ':'ๆฑๅฐพๅธ',
'ๆตทไธฐๅฟ':'ๆฑๅฐพๅธ',
'้ๆฒณๅฟ':'ๆฑๅฐพๅธ',
'้ไธฐๅธ':'ๆฑๅฐพๅธ',
'ๅธ่พๅบ':'ๆฒณๆบๅธ',
'ๆบๅๅบ':'ๆฒณๆบๅธ',
'็ดซ้ๅฟ':'ๆฒณๆบๅธ',
'้พๅทๅฟ':'ๆฒณๆบๅธ',
'่ฟๅนณๅฟ':'ๆฒณๆบๅธ',
'ๅๅนณๅฟ':'ๆฒณๆบๅธ',
'ไธๆบๅฟ':'ๆฒณๆบๅธ',
'ๅธ่พๅบ':'้ณๆฑๅธ',
'ๆฑๅๅบ':'้ณๆฑๅธ',
'้ณ่ฅฟๅฟ':'้ณๆฑๅธ',
'้ณไธๅฟ':'้ณๆฑๅธ',
'้ณๆฅๅธ':'้ณๆฑๅธ',
'ๅธ่พๅบ':'ๆธ
่ฟๅธ',
'ๆธ
ๅๅบ':'ๆธ
่ฟๅธ',
'ไฝๅๅฟ':'ๆธ
่ฟๅธ',
'้ณๅฑฑๅฟ':'ๆธ
่ฟๅธ',
'่ฟๅฑฑๅฃฎๆ็ถๆ่ชๆฒปๅฟ':'ๆธ
่ฟๅธ',
'่ฟๅ็ถๆ่ชๆฒปๅฟ':'ๆธ
่ฟๅธ',
'ๆธ
ๆฐๅฟ':'ๆธ
่ฟๅธ',
'่ฑๅพทๅธ':'ๆธ
่ฟๅธ',
'่ฟๅทๅธ':'ๆธ
่ฟๅธ',
'ๅธ่พๅบ':'ๆฝฎๅทๅธ',
'ๆนๆกฅๅบ':'ๆฝฎๅทๅธ',
'ๆฝฎๅฎๅฟ':'ๆฝฎๅทๅธ',
'้ฅถๅนณๅฟ':'ๆฝฎๅทๅธ',
'ๅธ่พๅบ':'ๆญ้ณๅธ',
'ๆฆๅๅบ':'ๆญ้ณๅธ',
'ๆญไธๅฟ':'ๆญ้ณๅธ',
'ๆญ่ฅฟๅฟ':'ๆญ้ณๅธ',
'ๆ ๆฅๅฟ':'ๆญ้ณๅธ',
'ๆฎๅฎๅธ':'ๆญ้ณๅธ',
'ๅธ่พๅบ':'ไบๆตฎๅธ',
'ไบๅๅบ':'ไบๆตฎๅธ',
'ๆฐๅ
ดๅฟ':'ไบๆตฎๅธ',
'้ๅๅฟ':'ไบๆตฎๅธ',
'ไบๅฎๅฟ':'ไบๆตฎๅธ',
'็ฝๅฎๅธ':'ไบๆตฎๅธ',
'ๅธ่พๅบ':'ๅๅฎๅธ',
'ๅ
ดๅฎๅบ':'ๅๅฎๅธ',
'้็งๅบ':'ๅๅฎๅธ',
'ๆฑๅๅบ':'ๅๅฎๅธ',
'่ฅฟไนกๅกๅบ':'ๅๅฎๅธ',
'่ฏๅบๅบ':'ๅๅฎๅธ',
'้ๅฎๅบ':'ๅๅฎๅธ',
'ๆญฆ้ธฃๅฟ':'ๅๅฎๅธ',
'้ๅฎๅฟ':'ๅๅฎๅธ',
'้ฉฌๅฑฑๅฟ':'ๅๅฎๅธ',
'ไธๆๅฟ':'ๅๅฎๅธ',
'ๅฎพ้ณๅฟ':'ๅๅฎๅธ',
'ๆจชๅฟ':'ๅๅฎๅธ',
'ๅธ่พๅบ':'ๆณๅทๅธ',
'ๅไธญๅบ':'ๆณๅทๅธ',
'้ฑผๅณฐๅบ':'ๆณๅทๅธ',
'ๆณๅๅบ':'ๆณๅทๅธ',
'ๆณๅๅบ':'ๆณๅทๅธ',
'ๆณๆฑๅฟ':'ๆณๅทๅธ',
'ๆณๅๅฟ':'ๆณๅทๅธ',
'้นฟๅฏจๅฟ':'ๆณๅทๅธ',
'่ๅฎๅฟ':'ๆณๅทๅธ',
'่ๆฐด่ๆ่ชๆฒปๅฟ':'ๆณๅทๅธ',
'ไธๆฑไพๆ่ชๆฒปๅฟ':'ๆณๅทๅธ',
'ๅธ่พๅบ':'ๆกๆๅธ',
'็งๅณฐๅบ':'ๆกๆๅธ',
'ๅ ๅฝฉๅบ':'ๆกๆๅธ',
'่ฑกๅฑฑๅบ':'ๆกๆๅธ',
'ไธๆๅบ':'ๆกๆๅธ',
'้ๅฑฑๅบ':'ๆกๆๅธ',
'้ณๆๅฟ':'ๆกๆๅธ',
'ไธดๆกๅฟ':'ๆกๆๅธ',
'็ตๅทๅฟ':'ๆกๆๅธ',
'ๅ
จๅทๅฟ':'ๆกๆๅธ',
'ๅ
ดๅฎๅฟ':'ๆกๆๅธ',
'ๆฐธ็ฆๅฟ':'ๆกๆๅธ',
'็้ณๅฟ':'ๆกๆๅธ',
'้พ่ๅๆ่ชๆฒปๅฟ':'ๆกๆๅธ',
'่ตๆบๅฟ':'ๆกๆๅธ',
'ๅนณไนๅฟ':'ๆกๆๅธ',
'่่ฒๅฟ':'ๆกๆๅธ',
'ๆญๅ็ถๆ่ชๆฒปๅฟ':'ๆกๆๅธ',
'ๅธ่พๅบ':'ๆขงๅทๅธ',
'ไธ็งๅบ':'ๆขงๅทๅธ',
'่ถๅฑฑๅบ':'ๆขงๅทๅธ',
'้ฟๆดฒๅบ':'ๆขงๅทๅธ',
'่ๆขงๅฟ':'ๆขงๅทๅธ',
'่คๅฟ':'ๆขงๅทๅธ',
'่ๅฑฑๅฟ':'ๆขงๅทๅธ',
'ๅฒๆบชๅธ':'ๆขงๅทๅธ',
'ๅธ่พๅบ':'ๅๆตทๅธ',
'ๆตทๅๅบ':'ๅๆตทๅธ',
'้ถๆตทๅบ':'ๅๆตทๅธ',
'้ๅฑฑๆธฏๅบ':'ๅๆตทๅธ',
'ๅๆตฆๅฟ':'ๅๆตทๅธ',
'ๅธ่พๅบ':'้ฒๅๆธฏๅธ',
'ๆธฏๅฃๅบ':'้ฒๅๆธฏๅธ',
'้ฒๅๅบ':'้ฒๅๆธฏๅธ',
'ไธๆๅฟ':'้ฒๅๆธฏๅธ',
'ไธๅ
ดๅธ':'้ฒๅๆธฏๅธ',
'ๅธ่พๅบ':'้ฆๅทๅธ',
'้ฆๅๅบ':'้ฆๅทๅธ',
'้ฆๅๅบ':'้ฆๅทๅธ',
'็ตๅฑฑๅฟ':'้ฆๅทๅธ',
'ๆตฆๅๅฟ':'้ฆๅทๅธ',
'ๅธ่พๅบ':'่ดตๆธฏๅธ',
'ๆธฏๅๅบ':'่ดตๆธฏๅธ',
'ๆธฏๅๅบ':'่ดตๆธฏๅธ',
'่ฆๅกๅบ':'่ดตๆธฏๅธ',
'ๅนณๅๅฟ':'่ดตๆธฏๅธ',
'ๆกๅนณๅธ':'่ดตๆธฏๅธ',
'ๅธ่พๅบ':'็ๆๅธ',
'็ๅทๅบ':'็ๆๅธ',
'ๅฎนๅฟ':'็ๆๅธ',
'้ๅทๅฟ':'็ๆๅธ',
'ๅ็ฝๅฟ':'็ๆๅธ',
'ๅ
ดไธๅฟ':'็ๆๅธ',
'ๅๆตๅธ':'็ๆๅธ',
'ๅธ่พๅบ':'็พ่ฒๅธ',
'ๅณๆฑๅบ':'็พ่ฒๅธ',
'็ฐ้ณๅฟ':'็พ่ฒๅธ',
'็ฐไธๅฟ':'็พ่ฒๅธ',
'ๅนณๆๅฟ':'็พ่ฒๅธ',
'ๅพทไฟๅฟ':'็พ่ฒๅธ',
'้่ฅฟๅฟ':'็พ่ฒๅธ',
'้ฃๅกๅฟ':'็พ่ฒๅธ',
'ๅไบๅฟ':'็พ่ฒๅธ',
'ไนไธๅฟ':'็พ่ฒๅธ',
'็ฐๆๅฟ':'็พ่ฒๅธ',
'่ฅฟๆๅฟ':'็พ่ฒๅธ',
'้ๆๅๆ่ชๆฒปๅฟ':'็พ่ฒๅธ',
'ๅธ่พๅบ':'่ดบๅทๅธ',
'ๅ
ซๆญฅๅบ':'่ดบๅทๅธ',
'ๆญๅนณๅฟ':'่ดบๅทๅธ',
'้ๅฑฑๅฟ':'่ดบๅทๅธ',
'ๅฏๅท็ถๆ่ชๆฒปๅฟ':'่ดบๅทๅธ',
'ๅธ่พๅบ':'ๆฒณๆฑ ๅธ',
'้ๅๆฑๅบ':'ๆฒณๆฑ ๅธ',
'ๅไธนๅฟ':'ๆฒณๆฑ ๅธ',
'ๅคฉๅณจๅฟ':'ๆฒณๆฑ ๅธ',
'ๅคๅฑฑๅฟ':'ๆฒณๆฑ ๅธ',
'ไธๅ
ฐๅฟ':'ๆฒณๆฑ ๅธ',
'็ฝๅไปซไฝฌๆ่ชๆฒปๅฟ':'ๆฒณๆฑ ๅธ',
'็ฏๆฑๆฏๅๆ่ชๆฒปๅฟ':'ๆฒณๆฑ ๅธ',
'ๅทด้ฉฌ็ถๆ่ชๆฒปๅฟ':'ๆฒณๆฑ ๅธ',
'้ฝๅฎ็ถๆ่ชๆฒปๅฟ':'ๆฒณๆฑ ๅธ',
'ๅคงๅ็ถๆ่ชๆฒปๅฟ':'ๆฒณๆฑ ๅธ',
'ๅฎๅทๅธ':'ๆฒณๆฑ ๅธ',
'ๅธ่พๅบ':'ๆฅๅฎพๅธ',
'ๅ
ดๅฎพๅบ':'ๆฅๅฎพๅธ',
'ๅฟปๅๅฟ':'ๆฅๅฎพๅธ',
'่ฑกๅทๅฟ':'ๆฅๅฎพๅธ',
'ๆญฆๅฎฃๅฟ':'ๆฅๅฎพๅธ',
'้็ง็ถๆ่ชๆฒปๅฟ':'ๆฅๅฎพๅธ',
'ๅๅฑฑๅธ':'ๆฅๅฎพๅธ',
'ๅธ่พๅบ':'ๅดๅทฆๅธ',
'ๆฑๆดฒๅบ':'ๅดๅทฆๅธ',
'ๆถ็ปฅๅฟ':'ๅดๅทฆๅธ',
'ๅฎๆๅฟ':'ๅดๅทฆๅธ',
'้พๅทๅฟ':'ๅดๅทฆๅธ',
'ๅคงๆฐๅฟ':'ๅดๅทฆๅธ',
'ๅคฉ็ญๅฟ':'ๅดๅทฆๅธ',
'ๅญ็ฅฅๅธ':'ๅดๅทฆๅธ',
'ๅธ่พๅบ':'ๆตทๅฃๅธ',
'็ง่ฑๅบ':'ๆตทๅฃๅธ',
'้พๅๅบ':'ๆตทๅฃๅธ',
'็ผๅฑฑๅบ':'ๆตทๅฃๅธ',
'็พๅ
ฐๅบ':'ๆตทๅฃๅธ',
'ๅธ่พๅบ':'ไธไบๅธ',
'ไบๆๅฑฑๅธ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'็ผๆตทๅธ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๅๅทๅธ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๆๆๅธ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไธๅฎๅธ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไธๆนๅธ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๅฎๅฎๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๅฑฏๆๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๆพ่ฟๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไธด้ซๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'็ฝๆฒ้ปๆ่ชๆฒปๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๆๆฑ้ปๆ่ชๆฒปๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไนไธ้ปๆ่ชๆฒปๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'้ตๆฐด้ปๆ่ชๆฒปๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไฟไบญ้ปๆ่ๆ่ชๆฒปๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'็ผไธญ้ปๆ่ๆ่ชๆฒปๅฟ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'่ฅฟๆฒ็พคๅฒ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ๅๆฒ็พคๅฒ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไธญๆฒ็พคๅฒ็ๅฒ็คๅๅ
ถๆตทๅ':'็็ด่พๅฟ็บง่กๆฟๅไฝ',
'ไธๅทๅบ':'้ๅบๅธ',
'ๆถช้ตๅบ':'้ๅบๅธ',
'ๆธไธญๅบ':'้ๅบๅธ',
'ๅคงๆธกๅฃๅบ':'้ๅบๅธ',
'ๆฑๅๅบ':'้ๅบๅธ',
'ๆฒๅชๅๅบ':'้ๅบๅธ',
'ไน้พๅกๅบ':'้ๅบๅธ',
'ๅๅฒธๅบ':'้ๅบๅธ',
'ๅ็ขๅบ':'้ๅบๅธ',
'ไธ็ๅบ':'้ๅบๅธ',
'ๅๆกฅๅบ':'้ๅบๅธ',
'ๆธๅๅบ':'้ๅบๅธ',
'ๅทดๅๅบ':'้ๅบๅธ',
'้ปๆฑๅบ':'้ๅบๅธ',
'้ฟๅฏฟๅบ':'้ๅบๅธ',
'็ถฆๆฑๅฟ':'้ๅบๅธ',
'ๆฝผๅๅฟ':'้ๅบๅธ',
'้ๆขๅฟ':'้ๅบๅธ',
'ๅคง่ถณๅฟ':'้ๅบๅธ',
'่ฃๆๅฟ':'้ๅบๅธ',
'็งๅฑฑๅฟ':'้ๅบๅธ',
'ๆขๅนณๅฟ':'้ๅบๅธ',
'ๅๅฃๅฟ':'้ๅบๅธ',
'ไธฐ้ฝๅฟ':'้ๅบๅธ',
'ๅซๆฑๅฟ':'้ๅบๅธ',
'ๆญฆ้ๅฟ':'้ๅบๅธ',
'ๅฟ ๅฟ':'้ๅบๅธ',
'ๅผๅฟ':'้ๅบๅธ',
'ไบ้ณๅฟ':'้ๅบๅธ',
'ๅฅ่ๅฟ':'้ๅบๅธ',
'ๅทซๅฑฑๅฟ':'้ๅบๅธ',
'ๅทซๆบชๅฟ':'้ๅบๅธ',
'็ณๆฑๅๅฎถๆ่ชๆฒปๅฟ':'้ๅบๅธ',
'็งๅฑฑๅๅฎถๆ่ๆ่ชๆฒปๅฟ':'้ๅบๅธ',
'้
้ณๅๅฎถๆ่ๆ่ชๆฒปๅฟ':'้ๅบๅธ',
'ๅฝญๆฐด่ๆๅๅฎถๆ่ชๆฒปๅฟ':'้ๅบๅธ',
'ๆฑๆดฅๅธ':'้ๅบๅธ',
'ๅๅทๅธ':'้ๅบๅธ',
'ๆฐธๅทๅธ':'้ๅบๅธ',
'ๅๅทๅธ':'้ๅบๅธ',
'ๅธ่พๅบ':'ๆ้ฝๅธ',
'้ฆๆฑๅบ':'ๆ้ฝๅธ',
'้็พๅบ':'ๆ้ฝๅธ',
'้็ๅบ':'ๆ้ฝๅธ',
'ๆญฆไพฏๅบ':'ๆ้ฝๅธ',
'ๆๅๅบ':'ๆ้ฝๅธ',
'้พๆณ้ฉฟๅบ':'ๆ้ฝๅธ',
'้็ฝๆฑๅบ':'ๆ้ฝๅธ',
'ๆฐ้ฝๅบ':'ๆ้ฝๅธ',
'ๆธฉๆฑๅบ':'ๆ้ฝๅธ',
'้ๅ ๅฟ':'ๆ้ฝๅธ',
'ๅๆตๅฟ':'ๆ้ฝๅธ',
'้ซๅฟ':'ๆ้ฝๅธ',
'ๅคง้ๅฟ':'ๆ้ฝๅธ',
'่ฒๆฑๅฟ':'ๆ้ฝๅธ',
'ๆฐๆดฅๅฟ':'ๆ้ฝๅธ',
'้ฝๆฑๅ ฐๅธ':'ๆ้ฝๅธ',
'ๅฝญๅทๅธ':'ๆ้ฝๅธ',
'้ๅดๅธ':'ๆ้ฝๅธ',
'ๅดๅทๅธ':'ๆ้ฝๅธ',
'ๅธ่พๅบ':'่ช่ดกๅธ',
'่ชๆตไบๅบ':'่ช่ดกๅธ',
'่ดกไบๅบ':'่ช่ดกๅธ',
'ๅคงๅฎๅบ':'่ช่ดกๅธ',
'ๆฒฟๆปฉๅบ':'่ช่ดกๅธ',
'่ฃๅฟ':'่ช่ดกๅธ',
'ๅฏ้กบๅฟ':'่ช่ดกๅธ',
'ๅธ่พๅบ':'ๆๆ่ฑๅธ',
'ไธๅบ':'ๆๆ่ฑๅธ',
'่ฅฟๅบ':'ๆๆ่ฑๅธ',
'ไปๅๅบ':'ๆๆ่ฑๅธ',
'็ฑณๆๅฟ':'ๆๆ่ฑๅธ',
'็่พนๅฟ':'ๆๆ่ฑๅธ',
'ๅธ่พๅบ':'ๆณธๅทๅธ',
'ๆฑ้ณๅบ':'ๆณธๅทๅธ',
'็บณๆบชๅบ':'ๆณธๅทๅธ',
'้พ้ฉฌๆฝญๅบ':'ๆณธๅทๅธ',
'ๆณธๅฟ':'ๆณธๅทๅธ',
'ๅๆฑๅฟ':'ๆณธๅทๅธ',
'ๅๆฐธๅฟ':'ๆณธๅทๅธ',
'ๅค่บๅฟ':'ๆณธๅทๅธ',
'ๅธ่พๅบ':'ๅพท้ณๅธ',
'ๆ้ณๅบ':'ๅพท้ณๅธ',
'ไธญๆฑๅฟ':'ๅพท้ณๅธ',
'็ฝๆฑๅฟ':'ๅพท้ณๅธ',
'ๅนฟๆฑๅธ':'ๅพท้ณๅธ',
'ไป้กๅธ':'ๅพท้ณๅธ',
'็ปต็ซนๅธ':'ๅพท้ณๅธ',
'ๅธ่พๅบ':'็ปต้ณๅธ',
'ๆถชๅๅบ':'็ปต้ณๅธ',
'ๆธธไปๅบ':'็ปต้ณๅธ',
'ไธๅฐๅฟ':'็ปต้ณๅธ',
'็ไบญๅฟ':'็ปต้ณๅธ',
'ๅฎๅฟ':'็ปต้ณๅธ',
'ๆขๆฝผๅฟ':'็ปต้ณๅธ',
'ๅๅท็พๆ่ชๆฒปๅฟ':'็ปต้ณๅธ',
'ๅนณๆญฆๅฟ':'็ปต้ณๅธ',
'ๆฑๆฒนๅธ':'็ปต้ณๅธ',
'ๅธ่พๅบ':'ๅนฟๅ
ๅธ',
'ๅธไธญๅบ':'ๅนฟๅ
ๅธ',
'ๅ
ๅๅบ':'ๅนฟๅ
ๅธ',
'ๆๅคฉๅบ':'ๅนฟๅ
ๅธ',
'ๆบ่ๅฟ':'ๅนฟๅ
ๅธ',
'้ๅทๅฟ':'ๅนฟๅ
ๅธ',
'ๅ้ๅฟ':'ๅนฟๅ
ๅธ',
'่ๆบชๅฟ':'ๅนฟๅ
ๅธ',
'ๅธ่พๅบ':'้ๅฎๅธ',
'่นๅฑฑๅบ':'้ๅฎๅธ',
'ๅฎๅฑ
ๅบ':'้ๅฎๅธ',
'่ฌๆบชๅฟ':'้ๅฎๅธ',
'ๅฐๆดชๅฟ':'้ๅฎๅธ',
'ๅคง่ฑๅฟ':'้ๅฎๅธ',
'ๅธ่พๅบ':'ๅ
ๆฑๅธ',
'ๅธไธญๅบ':'ๅ
ๆฑๅธ',
'ไธๅ
ดๅบ':'ๅ
ๆฑๅธ',
'ๅจ่ฟๅฟ':'ๅ
ๆฑๅธ',
'่ตไธญๅฟ':'ๅ
ๆฑๅธ',
'้ๆๅฟ':'ๅ
ๆฑๅธ',
'ๅธ่พๅบ':'ไนๅฑฑๅธ',
'ๅธไธญๅบ':'ไนๅฑฑๅธ',
'ๆฒๆนพๅบ':'ไนๅฑฑๅธ',
'ไบ้ๆกฅๅบ':'ไนๅฑฑๅธ',
'้ๅฃๆฒณๅบ':'ไนๅฑฑๅธ',
'็ไธบๅฟ':'ไนๅฑฑๅธ',
'ไบ็ ๅฟ':'ไนๅฑฑๅธ',
'ๅคนๆฑๅฟ':'ไนๅฑฑๅธ',
'ๆฒๅทๅฟ':'ไนๅฑฑๅธ',
'ๅณจ่พนๅฝๆ่ชๆฒปๅฟ':'ไนๅฑฑๅธ',
'้ฉฌ่พนๅฝๆ่ชๆฒปๅฟ':'ไนๅฑฑๅธ',
'ๅณจ็ๅฑฑๅธ':'ไนๅฑฑๅธ',
'ๅธ่พๅบ':'ๅๅ
ๅธ',
'้กบๅบๅบ':'ๅๅ
ๅธ',
'้ซๅชๅบ':'ๅๅ
ๅธ',
'ๅ้ตๅบ':'ๅๅ
ๅธ',
'ๅ้จๅฟ':'ๅๅ
ๅธ',
'่ฅๅฑฑๅฟ':'ๅๅ
ๅธ',
'่ฌๅฎๅฟ':'ๅๅ
ๅธ',
'ไปช้ๅฟ':'ๅๅ
ๅธ',
'่ฅฟๅ
ๅฟ':'ๅๅ
ๅธ',
'้ไธญๅธ':'ๅๅ
ๅธ',
'ๅธ่พๅบ':'็ๅฑฑๅธ',
'ไธๅกๅบ':'็ๅฑฑๅธ',
'ไปๅฏฟๅฟ':'็ๅฑฑๅธ',
'ๅฝญๅฑฑๅฟ':'็ๅฑฑๅธ',
'ๆดช้
ๅฟ':'็ๅฑฑๅธ',
'ไธนๆฃฑๅฟ':'็ๅฑฑๅธ',
'้็ฅๅฟ':'็ๅฑฑๅธ',
'ๅธ่พๅบ':'ๅฎๅฎพๅธ',
'็ฟ ๅฑๅบ':'ๅฎๅฎพๅธ',
'ๅฎๅฎพๅฟ':'ๅฎๅฎพๅธ',
'ๅๆบชๅฟ':'ๅฎๅฎพๅธ',
'ๆฑๅฎๅฟ':'ๅฎๅฎพๅธ',
'้ฟๅฎๅฟ':'ๅฎๅฎพๅธ',
'้ซๅฟ':'ๅฎๅฎพๅธ',
'็ๅฟ':'ๅฎๅฎพๅธ',
'็ญ ่ฟๅฟ':'ๅฎๅฎพๅธ',
'ๅ
ดๆๅฟ':'ๅฎๅฎพๅธ',
'ๅฑๅฑฑๅฟ':'ๅฎๅฎพๅธ',
'ๅธ่พๅบ':'ๅนฟๅฎๅธ',
'ๅนฟๅฎๅบ':'ๅนฟๅฎๅธ',
'ๅฒณๆฑ ๅฟ':'ๅนฟๅฎๅธ',
'ๆญฆ่ๅฟ':'ๅนฟๅฎๅธ',
'้ปๆฐดๅฟ':'ๅนฟๅฎๅธ',
'ๅ่นๅธ':'ๅนฟๅฎๅธ',
'ๅธ่พๅบ':'่พพๅทๅธ',
'้ๅทๅบ':'่พพๅทๅธ',
'่พพๅฟ':'่พพๅทๅธ',
'ๅฎฃๆฑๅฟ':'่พพๅทๅธ',
'ๅผๆฑๅฟ':'่พพๅทๅธ',
'ๅคง็ซนๅฟ':'่พพๅทๅธ',
'ๆธ ๅฟ':'่พพๅทๅธ',
'ไธๆบๅธ':'่พพๅทๅธ',
'ๅธ่พๅบ':'้
ๅฎๅธ',
'้จๅๅบ':'้
ๅฎๅธ',
'ๅๅฑฑๅฟ':'้
ๅฎๅธ',
'่ฅ็ปๅฟ':'้
ๅฎๅธ',
'ๆฑๆบๅฟ':'้
ๅฎๅธ',
'็ณๆฃๅฟ':'้
ๅฎๅธ',
'ๅคฉๅ
จๅฟ':'้
ๅฎๅธ',
'่ฆๅฑฑๅฟ':'้
ๅฎๅธ',
'ๅฎๅ
ดๅฟ':'้
ๅฎๅธ',
'ๅธ่พๅบ':'ๅทดไธญๅธ',
'ๅทดๅทๅบ':'ๅทดไธญๅธ',
'้ๆฑๅฟ':'ๅทดไธญๅธ',
'ๅๆฑๅฟ':'ๅทดไธญๅธ',
'ๅนณๆๅฟ':'ๅทดไธญๅธ',
'ๅธ่พๅบ':'่ต้ณๅธ',
'้ๆฑๅบ':'่ต้ณๅธ',
'ๅฎๅฒณๅฟ':'่ต้ณๅธ',
'ไน่ณๅฟ':'่ต้ณๅธ',
'็ฎ้ณๅธ':'่ต้ณๅธ',
'ๆฑถๅทๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'็ๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'่ๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'ๆพๆฝๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'ไนๅฏจๆฒๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'้ๅทๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'ๅฐ้ๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'้ปๆฐดๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'้ฉฌๅฐๅบทๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'ๅฃคๅกๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'้ฟๅๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'่ฅๅฐ็ๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'็บขๅๅฟ':'้ฟๅ่ๆ็พๆ่ชๆฒปๅท',
'ๅบทๅฎๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ๆณธๅฎๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ไธนๅทดๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ไน้พๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'้
ๆฑๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'้ๅญๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'็้ๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'็ๅญๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ๆฐ้พๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ๅพทๆ ผๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'็ฝ็ๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'็ณๆธ ๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'่ฒ่พพๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'็ๅกๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ๅทดๅกๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ไนกๅๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'็จปๅๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'ๅพ่ฃๅฟ':'็ๅญ่ๆ่ชๆฒปๅท',
'่ฅฟๆๅธ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๆจ้่ๆ่ชๆฒปๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'็ๆบๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๅพทๆๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ไผ็ๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ไผไธๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๅฎๅๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๆฎๆ ผๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๅธๆๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'้้ณๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๆญ่งๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๅๅพทๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๅๅฎๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'่ถ่ฅฟๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'็ๆดๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'็พๅงๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'้ทๆณขๅฟ':'ๅๅฑฑๅฝๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'่ดต้ณๅธ',
'ๅๆๅบ':'่ดต้ณๅธ',
'ไบๅฒฉๅบ':'่ดต้ณๅธ',
'่ฑๆบชๅบ':'่ดต้ณๅธ',
'ไนๅฝๅบ':'่ดต้ณๅธ',
'็ฝไบๅบ':'่ดต้ณๅธ',
'ๅฐๆฒณๅบ':'่ดต้ณๅธ',
'ๅผ้ณๅฟ':'่ดต้ณๅธ',
'ๆฏ็ฝๅฟ':'่ดต้ณๅธ',
'ไฟฎๆๅฟ':'่ดต้ณๅธ',
'ๆธ
้ๅธ':'่ดต้ณๅธ',
'้ๅฑฑๅบ':'ๅ
ญ็ๆฐดๅธ',
'ๅ
ญๆ็นๅบ':'ๅ
ญ็ๆฐดๅธ',
'ๆฐดๅๅฟ':'ๅ
ญ็ๆฐดๅธ',
'็ๅฟ':'ๅ
ญ็ๆฐดๅธ',
'ๅธ่พๅบ':'้ตไนๅธ',
'็บข่ฑๅฒๅบ':'้ตไนๅธ',
'ๆฑๅทๅบ':'้ตไนๅธ',
'้ตไนๅฟ':'้ตไนๅธ',
'ๆกๆขๅฟ':'้ตไนๅธ',
'็ปฅ้ณๅฟ':'้ตไนๅธ',
'ๆญฃๅฎๅฟ':'้ตไนๅธ',
'้็ไปกไฝฌๆ่ๆ่ชๆฒปๅฟ':'้ตไนๅธ',
'ๅกๅทไปกไฝฌๆ่ๆ่ชๆฒปๅฟ':'้ตไนๅธ',
'ๅคๅๅฟ':'้ตไนๅธ',
'ๆนๆฝญๅฟ':'้ตไนๅธ',
'ไฝๅบๅฟ':'้ตไนๅธ',
'ไน ๆฐดๅฟ':'้ตไนๅธ',
'่ตคๆฐดๅธ':'้ตไนๅธ',
'ไปๆๅธ':'้ตไนๅธ',
'ๅธ่พๅบ':'ๅฎ้กบๅธ',
'่ฅฟ็งๅบ':'ๅฎ้กบๅธ',
'ๅนณๅๅฟ':'ๅฎ้กบๅธ',
'ๆฎๅฎๅฟ':'ๅฎ้กบๅธ',
'้ๅฎๅธไพๆ่ๆ่ชๆฒปๅฟ':'ๅฎ้กบๅธ',
'ๅ
ณๅฒญๅธไพๆ่ๆ่ชๆฒปๅฟ':'ๅฎ้กบๅธ',
'็ดซไบ่ๆๅธไพๆ่ชๆฒปๅฟ':'ๅฎ้กบๅธ',
'้ไปๅธ':'้ไปๅฐๅบ',
'ๆฑๅฃๅฟ':'้ไปๅฐๅบ',
'็ๅฑไพๆ่ชๆฒปๅฟ':'้ไปๅฐๅบ',
'็ณ้กๅฟ':'้ไปๅฐๅบ',
'ๆๅๅฟ':'้ไปๅฐๅบ',
'ๅฐๆฑๅๅฎถๆ่ๆ่ชๆฒปๅฟ':'้ไปๅฐๅบ',
'ๅพทๆฑๅฟ':'้ไปๅฐๅบ',
'ๆฒฟๆฒณๅๅฎถๆ่ชๆฒปๅฟ':'้ไปๅฐๅบ',
'ๆพๆก่ๆ่ชๆฒปๅฟ':'้ไปๅฐๅบ',
'ไธๅฑฑ็นๅบ':'้ไปๅฐๅบ',
'ๅ
ดไนๅธ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๅ
ดไปๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๆฎๅฎๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๆด้ๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'่ดไธฐๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๆ่ฐๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๅไบจๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๅฎ้พๅฟ':'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๆฏ่ๅธ':'ๆฏ่ๅฐๅบ',
'ๅคงๆนๅฟ':'ๆฏ่ๅฐๅบ',
'้ป่ฅฟๅฟ':'ๆฏ่ๅฐๅบ',
'้ๆฒๅฟ':'ๆฏ่ๅฐๅบ',
'็ป้ๅฟ':'ๆฏ่ๅฐๅบ',
'็บณ้ๅฟ':'ๆฏ่ๅฐๅบ',
'ๅจๅฎๅฝๆๅๆ่ๆ่ชๆฒปๅฟ':'ๆฏ่ๅฐๅบ',
'่ตซ็ซ ๅฟ':'ๆฏ่ๅฐๅบ',
'ๅฏ้ๅธ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้ปๅนณๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ๆฝ็งๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ไธ็ฉๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้่ฟๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ๅฒๅทฉๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ๅคฉๆฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้ฆๅฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ๅๆฒณๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ๅฐๆฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้ปๅนณๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ๆฆๆฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ไปๆฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้ทๅฑฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้บปๆฑๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'ไธนๅฏจๅฟ':'้ปไธๅ่ๆไพๆ่ชๆฒปๅท',
'้ฝๅๅธ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'็ฆๆณๅธ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'่ๆณขๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'่ดตๅฎๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'็ฎๅฎๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'็ฌๅฑฑๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๅนณๅกๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'็ฝ็ธๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'้ฟ้กบๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'้พ้ๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๆ ๆฐดๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ไธ้ฝๆฐดๆ่ชๆฒปๅฟ':'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'ๆๆๅธ',
'ไบๅๅบ':'ๆๆๅธ',
'็้พๅบ':'ๆๆๅธ',
'ๅฎๆธกๅบ':'ๆๆๅธ',
'่ฅฟๅฑฑๅบ':'ๆๆๅธ',
'ไธๅทๅบ':'ๆๆๅธ',
'ๅ่ดกๅฟ':'ๆๆๅธ',
'ๆๅฎๅฟ':'ๆๆๅธ',
'ๅฏๆฐๅฟ':'ๆๆๅธ',
'ๅฎ่ฏๅฟ':'ๆๆๅธ',
'็ณๆๅฝๆ่ชๆฒปๅฟ':'ๆๆๅธ',
'ๅตฉๆๅฟ':'ๆๆๅธ',
'็ฆๅๅฝๆ่ๆ่ชๆฒปๅฟ':'ๆๆๅธ',
'ๅฏป็ธๅๆๅฝๆ่ชๆฒปๅฟ':'ๆๆๅธ',
'ๅฎๅฎๅธ':'ๆๆๅธ',
'ๅธ่พๅบ':'ๆฒ้ๅธ',
'้บ้บๅบ':'ๆฒ้ๅธ',
'้ฉฌ้พๅฟ':'ๆฒ้ๅธ',
'้่ฏๅฟ':'ๆฒ้ๅธ',
'ๅธๅฎๅฟ':'ๆฒ้ๅธ',
'็ฝๅนณๅฟ':'ๆฒ้ๅธ',
'ๅฏๆบๅฟ':'ๆฒ้ๅธ',
'ไผๆณฝๅฟ':'ๆฒ้ๅธ',
'ๆฒพ็ๅฟ':'ๆฒ้ๅธ',
'ๅฎฃๅจๅธ':'ๆฒ้ๅธ',
'ๅธ่พๅบ':'็ๆบชๅธ',
'็บขๅกๅบ':'็ๆบชๅธ',
'ๆฑๅทๅฟ':'็ๆบชๅธ',
'ๆพๆฑๅฟ':'็ๆบชๅธ',
'้ๆตทๅฟ':'็ๆบชๅธ',
'ๅๅฎๅฟ':'็ๆบชๅธ',
'ๆ้จๅฟ':'็ๆบชๅธ',
'ๅณจๅฑฑๅฝๆ่ชๆฒปๅฟ':'็ๆบชๅธ',
'ๆฐๅนณๅฝๆๅฃๆ่ชๆฒปๅฟ':'็ๆบชๅธ',
'ๅ
ๆฑๅๅฐผๆๅฝๆๅฃๆ่ชๆฒปๅฟ':'็ๆบชๅธ',
'ๅธ่พๅบ':'ไฟๅฑฑๅธ',
'้้ณๅบ':'ไฟๅฑฑๅธ',
'ๆฝ็ธๅฟ':'ไฟๅฑฑๅธ',
'่
พๅฒๅฟ':'ไฟๅฑฑๅธ',
'้พ้ตๅฟ':'ไฟๅฑฑๅธ',
'ๆๅฎๅฟ':'ไฟๅฑฑๅธ',
'ๅธ่พๅบ':'ๆญ้ๅธ',
'ๆญ้ณๅบ':'ๆญ้ๅธ',
'้ฒ็ธๅฟ':'ๆญ้ๅธ',
'ๅทงๅฎถๅฟ':'ๆญ้ๅธ',
'็ๆดฅๅฟ':'ๆญ้ๅธ',
'ๅคงๅ
ณๅฟ':'ๆญ้ๅธ',
'ๆฐธๅๅฟ':'ๆญ้ๅธ',
'็ปฅๆฑๅฟ':'ๆญ้ๅธ',
'้้ๅฟ':'ๆญ้ๅธ',
'ๅฝ่ฏๅฟ':'ๆญ้ๅธ',
'ๅจไฟกๅฟ':'ๆญ้ๅธ',
'ๆฐดๅฏๅฟ':'ๆญ้ๅธ',
'ๅธ่พๅบ':'ไธฝๆฑๅธ',
'ๅคๅๅบ':'ไธฝๆฑๅธ',
'็้พ็บณ่ฅฟๆ่ชๆฒปๅฟ':'ไธฝๆฑๅธ',
'ๆฐธ่ๅฟ':'ไธฝๆฑๅธ',
'ๅๅชๅฟ':'ไธฝๆฑๅธ',
'ๅฎ่ๅฝๆ่ชๆฒปๅฟ':'ไธฝๆฑๅธ',
'ๅธ่พๅบ':'ๆ่
ๅธ',
'็ฟ ไบๅบ':'ๆ่
ๅธ',
'ๆฎๆดฑๅๅฐผๆๅฝๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๆฏไธๅฝๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๆฏ่ฐทๅฃๆๅฝๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'้ๆฒ
ๅฝๆๅๅฐผๆๆ็ฅๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๆฑๅๅๅฐผๆๅฝๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๅญ่ฟๅฃๆๆ็ฅๆไฝคๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๆพๆฒงๆ็ฅๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'่ฅฟ็ไฝคๆ่ชๆฒปๅฟ':'ๆ่
ๅธ',
'ๅธ่พๅบ':'ไธดๆฒงๅธ',
'ไธด็ฟๅบ':'ไธดๆฒงๅธ',
'ๅคๅบๅฟ':'ไธดๆฒงๅธ',
'ไบๅฟ':'ไธดๆฒงๅธ',
'ๆฐธๅพทๅฟ':'ไธดๆฒงๅธ',
'้ๅบทๅฟ':'ไธดๆฒงๅธ',
'ๅๆฑๆ็ฅๆไฝคๆๅธๆๆๅฃๆ่ชๆฒปๅฟ':'ไธดๆฒงๅธ',
'่ฟ้ฉฌๅฃๆไฝคๆ่ชๆฒปๅฟ':'ไธดๆฒงๅธ',
'ๆฒงๆบไฝคๆ่ชๆฒปๅฟ':'ไธดๆฒงๅธ',
'ๆฅ้ๅธ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๅๆๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'็ๅฎๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๅๅๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๅงๅฎๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๅคงๅงๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๆฐธไปๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๅ
่ฐๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ๆญฆๅฎๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'็ฆไธฐๅฟ':'ๆฅ้ๅฝๆ่ชๆฒปๅท',
'ไธชๆงๅธ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๅผ่ฟๅธ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'่่ชๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๅฑ่พน่ๆ่ชๆฒปๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๅปบๆฐดๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'็ณๅฑๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๅผฅๅๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๆณธ่ฅฟๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๅ
้ณๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'็บขๆฒณๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'้ๅนณ่ๆ็ถๆๅฃๆ่ชๆฒปๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'็ปฟๆฅๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๆฒณๅฃ็ถๆ่ชๆฒปๅฟ':'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท',
'ๆๅฑฑๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'็ ๅฑฑๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'่ฅฟ็ดๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'้บปๆ ๅกๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'้ฉฌๅ
ณๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'ไธๅๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'ๅนฟๅๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'ๅฏๅฎๅฟ':'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท',
'ๆฏๆดชๅธ':'่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅท',
'ๅๆตทๅฟ':'่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅท',
'ๅ่
ๅฟ':'่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅท',
'ๅคง็ๅธ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๆผพๆฟๅฝๆ่ชๆฒปๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'็ฅฅไบๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๅฎพๅทๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๅผฅๆธกๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๅๆถงๅฝๆ่ชๆฒปๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๅทๅฑฑๅฝๆๅๆ่ชๆฒปๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๆฐธๅนณๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ไบ้พๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๆดฑๆบๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'ๅๅทๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'้นคๅบๅฟ':'ๅคง็็ฝๆ่ชๆฒปๅท',
'็ไธฝๅธ':'ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท',
'ๆฝ่ฅฟๅธ':'ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท',
'ๆขๆฒณๅฟ':'ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท',
'็ๆฑๅฟ':'ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท',
'้ๅทๅฟ':'ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท',
'ๆณธๆฐดๅฟ':'ๆๆฑๅๅณๆ่ชๆฒปๅท',
'็ฆ่ดกๅฟ':'ๆๆฑๅๅณๆ่ชๆฒปๅท',
'่ดกๅฑฑ็ฌ้พๆๆๆ่ชๆฒปๅฟ':'ๆๆฑๅๅณๆ่ชๆฒปๅท',
'ๅ
ฐๅช็ฝๆๆฎ็ฑณๆ่ชๆฒปๅฟ':'ๆๆฑๅๅณๆ่ชๆฒปๅท',
'้ฆๆ ผ้ๆๅฟ':'่ฟชๅบ่ๆ่ชๆฒปๅท',
'ๅพท้ฆๅฟ':'่ฟชๅบ่ๆ่ชๆฒปๅท',
'็ปด่ฅฟๅๅณๆ่ชๆฒปๅฟ':'่ฟชๅบ่ๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'ๆ่จๅธ',
'ๅๅ
ณๅบ':'ๆ่จๅธ',
'ๆๅจๅฟ':'ๆ่จๅธ',
'ๅฝ้ๅฟ':'ๆ่จๅธ',
'ๅฐผๆจๅฟ':'ๆ่จๅธ',
'ๆฒๆฐดๅฟ':'ๆ่จๅธ',
'ๅ ้พๅพทๅบๅฟ':'ๆ่จๅธ',
'่พพๅญๅฟ':'ๆ่จๅธ',
'ๅขจ็ซนๅทฅๅกๅฟ':'ๆ่จๅธ',
'ๆ้ฝๅฟ':'ๆ้ฝๅฐๅบ',
'ๆฑ่พพๅฟ':'ๆ้ฝๅฐๅบ',
'่ดก่งๅฟ':'ๆ้ฝๅฐๅบ',
'็ฑปไน้ฝๅฟ':'ๆ้ฝๅฐๅบ',
'ไธ้ๅฟ':'ๆ้ฝๅฐๅบ',
'ๅฏ้
ๅฟ':'ๆ้ฝๅฐๅบ',
'ๅ
ซๅฎฟๅฟ':'ๆ้ฝๅฐๅบ',
'ๅทฆ่ดกๅฟ':'ๆ้ฝๅฐๅบ',
'่ๅบทๅฟ':'ๆ้ฝๅฐๅบ',
'ๆด้ๅฟ':'ๆ้ฝๅฐๅบ',
'่พนๅๅฟ':'ๆ้ฝๅฐๅบ',
'ไนไธๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆๅๅฟ':'ๅฑฑๅๅฐๅบ',
'่ดกๅๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆกๆฅๅฟ':'ๅฑฑๅๅฐๅบ',
'็ผ็ปๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆฒๆพๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆช็พๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆดๆๅฟ':'ๅฑฑๅๅฐๅบ',
'ๅ ๆฅๅฟ':'ๅฑฑๅๅฐๅบ',
'้ๅญๅฟ':'ๅฑฑๅๅฐๅบ',
'้้ฃๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆตชๅกๅญๅฟ':'ๅฑฑๅๅฐๅบ',
'ๆฅๅๅๅธ':'ๆฅๅๅๅฐๅบ',
'ๅๆจๆๅฟ':'ๆฅๅๅๅฐๅบ',
'ๆฑๅญๅฟ':'ๆฅๅๅๅฐๅบ',
'ๅฎๆฅๅฟ':'ๆฅๅๅๅฐๅบ',
'่จ่ฟฆๅฟ':'ๆฅๅๅๅฐๅบ',
'ๆๅญๅฟ':'ๆฅๅๅๅฐๅบ',
'ๆไปๅฟ':'ๆฅๅๅๅฐๅบ',
'่ฐข้้จๅฟ':'ๆฅๅๅๅฐๅบ',
'็ฝๆๅฟ':'ๆฅๅๅๅฐๅบ',
'ไปๅธๅฟ':'ๆฅๅๅๅฐๅบ',
'ๅบท้ฉฌๅฟ':'ๆฅๅๅๅฐๅบ',
'ๅฎ็ปๅฟ':'ๆฅๅๅๅฐๅบ',
'ไปฒๅทดๅฟ':'ๆฅๅๅๅฐๅบ',
'ไบไธๅฟ':'ๆฅๅๅๅฐๅบ',
'ๅ้ๅฟ':'ๆฅๅๅๅฐๅบ',
'่ๆๆจๅฟ':'ๆฅๅๅๅฐๅบ',
'่จๅๅฟ':'ๆฅๅๅๅฐๅบ',
'ๅฒๅทดๅฟ':'ๆฅๅๅๅฐๅบ',
'้ฃๆฒๅฟ':'้ฃๆฒๅฐๅบ',
'ๅ้ปๅฟ':'้ฃๆฒๅฐๅบ',
'ๆฏๅฆๅฟ':'้ฃๆฒๅฐๅบ',
'่่ฃๅฟ':'้ฃๆฒๅฐๅบ',
'ๅฎๅคๅฟ':'้ฃๆฒๅฐๅบ',
'็ณๆๅฟ':'้ฃๆฒๅฐๅบ',
'็ดขๅฟ':'้ฃๆฒๅฐๅบ',
'็ญๆๅฟ':'้ฃๆฒๅฐๅบ',
'ๅทด้ๅฟ':'้ฃๆฒๅฐๅบ',
'ๅฐผ็ๅฟ':'้ฃๆฒๅฐๅบ',
'ๆฎๅ
ฐๅฟ':'้ฟ้ๅฐๅบ',
'ๆญ่พพๅฟ':'้ฟ้ๅฐๅบ',
'ๅถๅฐๅฟ':'้ฟ้ๅฐๅบ',
'ๆฅๅๅฟ':'้ฟ้ๅฐๅบ',
'้ฉๅๅฟ':'้ฟ้ๅฐๅบ',
'ๆนๅๅฟ':'้ฟ้ๅฐๅบ',
'ๆชๅคๅฟ':'้ฟ้ๅฐๅบ',
'ๆ่ๅฟ':'ๆ่ๅฐๅบ',
'ๅทฅๅธๆฑ่พพๅฟ':'ๆ่ๅฐๅบ',
'็ฑณๆๅฟ':'ๆ่ๅฐๅบ',
'ๅขจ่ฑๅฟ':'ๆ่ๅฐๅบ',
'ๆณขๅฏๅฟ':'ๆ่ๅฐๅบ',
'ๅฏ้
ๅฟ':'ๆ่ๅฐๅบ',
'ๆๅฟ':'ๆ่ๅฐๅบ',
'ๅธ่พๅบ':'่ฅฟๅฎๅธ',
'ๆฐๅๅบ':'่ฅฟๅฎๅธ',
'็ขๆๅบ':'่ฅฟๅฎๅธ',
'่ฒๆนๅบ':'่ฅฟๅฎๅธ',
'็ๆกฅๅบ':'่ฅฟๅฎๅธ',
'ๆชๅคฎๅบ':'่ฅฟๅฎๅธ',
'้ๅกๅบ':'่ฅฟๅฎๅธ',
'้่ฏๅบ':'่ฅฟๅฎๅธ',
'ไธดๆฝผๅบ':'่ฅฟๅฎๅธ',
'้ฟๅฎๅบ':'่ฅฟๅฎๅธ',
'่็ฐๅฟ':'่ฅฟๅฎๅธ',
'ๅจ่ณๅฟ':'่ฅฟๅฎๅธ',
'ๆทๅฟ':'่ฅฟๅฎๅธ',
'้ซ้ตๅฟ':'่ฅฟๅฎๅธ',
'ๅธ่พๅบ':'้ๅทๅธ',
'็็ๅบ':'้ๅทๅธ',
'ๅฐๅฐๅบ':'้ๅทๅธ',
'่ๅทๅบ':'้ๅทๅธ',
'ๅฎๅๅฟ':'้ๅทๅธ',
'ๅธ่พๅบ':'ๅฎ้ธกๅธ',
'ๆธญๆปจๅบ':'ๅฎ้ธกๅธ',
'้ๅฐๅบ':'ๅฎ้ธกๅธ',
'้ไปๅบ':'ๅฎ้ธกๅธ',
'ๅค็ฟๅฟ':'ๅฎ้ธกๅธ',
'ๅฒๅฑฑๅฟ':'ๅฎ้ธกๅธ',
'ๆถ้ฃๅฟ':'ๅฎ้ธกๅธ',
'็ๅฟ':'ๅฎ้ธกๅธ',
'้ๅฟ':'ๅฎ้ธกๅธ',
'ๅ้ณๅฟ':'ๅฎ้ธกๅธ',
'้บๆธธๅฟ':'ๅฎ้ธกๅธ',
'ๅคๅฟ':'ๅฎ้ธกๅธ',
'ๅคช็ฝๅฟ':'ๅฎ้ธกๅธ',
'ๅธ่พๅบ':'ๅธ้ณๅธ',
'็งฆ้ฝๅบ':'ๅธ้ณๅธ',
'ๆจๅๅบ':'ๅธ้ณๅธ',
'ๆธญๅๅบ':'ๅธ้ณๅธ',
'ไธๅๅฟ':'ๅธ้ณๅธ',
'ๆณพ้ณๅฟ':'ๅธ้ณๅธ',
'ไนพๅฟ':'ๅธ้ณๅธ',
'็คผๆณๅฟ':'ๅธ้ณๅธ',
'ๆฐธๅฏฟๅฟ':'ๅธ้ณๅธ',
'ๅฝฌๅฟ':'ๅธ้ณๅธ',
'้ฟๆญฆๅฟ':'ๅธ้ณๅธ',
'ๆฌ้ๅฟ':'ๅธ้ณๅธ',
'ๆทณๅๅฟ':'ๅธ้ณๅธ',
'ๆญฆๅๅฟ':'ๅธ้ณๅธ',
'ๅ
ดๅนณๅธ':'ๅธ้ณๅธ',
'ๅธ่พๅบ':'ๆธญๅๅธ',
'ไธดๆธญๅบ':'ๆธญๅๅธ',
'ๅๅฟ':'ๆธญๅๅธ',
'ๆฝผๅ
ณๅฟ':'ๆธญๅๅธ',
'ๅคง่ๅฟ':'ๆธญๅๅธ',
'ๅ้ณๅฟ':'ๆธญๅๅธ',
'ๆพๅๅฟ':'ๆธญๅๅธ',
'่ฒๅๅฟ':'ๆธญๅๅธ',
'็ฝๆฐดๅฟ':'ๆธญๅๅธ',
'ๅฏๅนณๅฟ':'ๆธญๅๅธ',
'้ฉๅๅธ':'ๆธญๅๅธ',
'ๅ้ดๅธ':'ๆธญๅๅธ',
'ๅธ่พๅบ':'ๅปถๅฎๅธ',
'ๅฎๅกๅบ':'ๅปถๅฎๅธ',
'ๅปถ้ฟๅฟ':'ๅปถๅฎๅธ',
'ๅปถๅทๅฟ':'ๅปถๅฎๅธ',
'ๅญ้ฟๅฟ':'ๅปถๅฎๅธ',
'ๅฎๅกๅฟ':'ๅปถๅฎๅธ',
'ๅฟไธนๅฟ':'ๅปถๅฎๅธ',
'ๅดๆๅฟ':'ๅปถๅฎๅธ',
'็ๆณๅฟ':'ๅปถๅฎๅธ',
'ๅฏๅฟ':'ๅปถๅฎๅธ',
'ๆดๅทๅฟ':'ๅปถๅฎๅธ',
'ๅฎๅทๅฟ':'ๅปถๅฎๅธ',
'้ป้พๅฟ':'ๅปถๅฎๅธ',
'้ป้ตๅฟ':'ๅปถๅฎๅธ',
'ๅธ่พๅบ':'ๆฑไธญๅธ',
'ๆฑๅฐๅบ':'ๆฑไธญๅธ',
'ๅ้ๅฟ':'ๆฑไธญๅธ',
'ๅๅบๅฟ':'ๆฑไธญๅธ',
'ๆดๅฟ':'ๆฑไธญๅธ',
'่ฅฟไนกๅฟ':'ๆฑไธญๅธ',
'ๅๅฟ':'ๆฑไธญๅธ',
'ๅฎๅผบๅฟ':'ๆฑไธญๅธ',
'็ฅ้ณๅฟ':'ๆฑไธญๅธ',
'้ๅทดๅฟ':'ๆฑไธญๅธ',
'็ๅๅฟ':'ๆฑไธญๅธ',
'ไฝๅชๅฟ':'ๆฑไธญๅธ',
'ๅธ่พๅบ':'ๆฆๆๅธ',
'ๆฆ้ณๅบ':'ๆฆๆๅธ',
'็ฅๆจๅฟ':'ๆฆๆๅธ',
'ๅบ่ฐทๅฟ':'ๆฆๆๅธ',
'ๆจชๅฑฑๅฟ':'ๆฆๆๅธ',
'้่พนๅฟ':'ๆฆๆๅธ',
'ๅฎ่พนๅฟ':'ๆฆๆๅธ',
'็ปฅๅพทๅฟ':'ๆฆๆๅธ',
'็ฑณ่ๅฟ':'ๆฆๆๅธ',
'ไฝณๅฟ':'ๆฆๆๅธ',
'ๅดๅ กๅฟ':'ๆฆๆๅธ',
'ๆธ
ๆถงๅฟ':'ๆฆๆๅธ',
'ๅญๆดฒๅฟ':'ๆฆๆๅธ',
'ๅธ่พๅบ':'ๅฎๅบทๅธ',
'ๆฑๆปจๅบ':'ๅฎๅบทๅธ',
'ๆฑ้ดๅฟ':'ๅฎๅบทๅธ',
'็ณๆณๅฟ':'ๅฎๅบทๅธ',
'ๅฎ้ๅฟ':'ๅฎๅบทๅธ',
'็ดซ้ณๅฟ':'ๅฎๅบทๅธ',
'ๅฒ็ๅฟ':'ๅฎๅบทๅธ',
'ๅนณๅฉๅฟ':'ๅฎๅบทๅธ',
'้ๅชๅฟ':'ๅฎๅบทๅธ',
'ๆฌ้ณๅฟ':'ๅฎๅบทๅธ',
'็ฝๆฒณๅฟ':'ๅฎๅบทๅธ',
'ๅธ่พๅบ':'ๅๆดๅธ',
'ๅๅทๅบ':'ๅๆดๅธ',
'ๆดๅๅฟ':'ๅๆดๅธ',
'ไธนๅคๅฟ':'ๅๆดๅธ',
'ๅๅๅฟ':'ๅๆดๅธ',
'ๅฑฑ้ณๅฟ':'ๅๆดๅธ',
'้ๅฎๅฟ':'ๅๆดๅธ',
'ๆๆฐดๅฟ':'ๅๆดๅธ',
'ๅธ่พๅบ':'ๅ
ฐๅทๅธ',
'ๅๅ
ณๅบ':'ๅ
ฐๅทๅธ',
'ไธ้ๆฒณๅบ':'ๅ
ฐๅทๅธ',
'่ฅฟๅบๅบ':'ๅ
ฐๅทๅธ',
'ๅฎๅฎๅบ':'ๅ
ฐๅทๅธ',
'็บขๅคๅบ':'ๅ
ฐๅทๅธ',
'ๆฐธ็ปๅฟ':'ๅ
ฐๅทๅธ',
'็ๅ
ฐๅฟ':'ๅ
ฐๅทๅธ',
'ๆฆไธญๅฟ':'ๅ
ฐๅทๅธ',
'ๅธ่พๅบ':'ๅๅณชๅ
ณๅธ',
'ๅธ่พๅบ':'้ๆๅธ',
'้ๅทๅบ':'้ๆๅธ',
'ๆฐธๆๅฟ':'้ๆๅธ',
'ๅธ่พๅบ':'็ฝ้ถๅธ',
'็ฝ้ถๅบ':'็ฝ้ถๅธ',
'ๅนณๅทๅบ':'็ฝ้ถๅธ',
'้่ฟๅฟ':'็ฝ้ถๅธ',
'ไผๅฎๅฟ':'็ฝ้ถๅธ',
'ๆฏๆณฐๅฟ':'็ฝ้ถๅธ',
'ๅธ่พๅบ':'ๅคฉๆฐดๅธ',
'็งฆๅๅบ':'ๅคฉๆฐดๅธ',
'ๅ้ๅบ':'ๅคฉๆฐดๅธ',
'ๆธ
ๆฐดๅฟ':'ๅคฉๆฐดๅธ',
'็งฆๅฎๅฟ':'ๅคฉๆฐดๅธ',
'็่ฐทๅฟ':'ๅคฉๆฐดๅธ',
'ๆญฆๅฑฑๅฟ':'ๅคฉๆฐดๅธ',
'ๅผ ๅฎถๅทๅๆ่ชๆฒปๅฟ':'ๅคฉๆฐดๅธ',
'ๅธ่พๅบ':'ๆญฆๅจๅธ',
'ๅๅทๅบ':'ๆญฆๅจๅธ',
'ๆฐๅคๅฟ':'ๆญฆๅจๅธ',
'ๅคๆตชๅฟ':'ๆญฆๅจๅธ',
'ๅคฉ็ฅ่ๆ่ชๆฒปๅฟ':'ๆญฆๅจๅธ',
'ๅธ่พๅบ':'ๅผ ๆๅธ',
'็ๅทๅบ':'ๅผ ๆๅธ',
'่ๅ่ฃๅบๆ่ชๆฒปๅฟ':'ๅผ ๆๅธ',
'ๆฐไนๅฟ':'ๅผ ๆๅธ',
'ไธดๆณฝๅฟ':'ๅผ ๆๅธ',
'้ซๅฐๅฟ':'ๅผ ๆๅธ',
'ๅฑฑไธนๅฟ':'ๅผ ๆๅธ',
'ๅธ่พๅบ':'ๅนณๅๅธ',
'ๅดๅณๅบ':'ๅนณๅๅธ',
'ๆณพๅทๅฟ':'ๅนณๅๅธ',
'็ตๅฐๅฟ':'ๅนณๅๅธ',
'ๅดไฟกๅฟ':'ๅนณๅๅธ',
'ๅไบญๅฟ':'ๅนณๅๅธ',
'ๅบๆตชๅฟ':'ๅนณๅๅธ',
'้ๅฎๅฟ':'ๅนณๅๅธ',
'ๅธ่พๅบ':'้
ๆณๅธ',
'่ๅทๅบ':'้
ๆณๅธ',
'้ๅกๅฟ':'้
ๆณๅธ',
'ๅฎ่ฅฟๅฟ':'้
ๆณๅธ',
'่ๅ่ๅคๆ่ชๆฒปๅฟ':'้
ๆณๅธ',
'้ฟๅ
ๅกๅ่จๅ
ๆ่ชๆฒปๅฟ':'้
ๆณๅธ',
'็้จๅธ':'้
ๆณๅธ',
'ๆฆ็
ๅธ':'้
ๆณๅธ',
'ๅธ่พๅบ':'ๅบ้ณๅธ',
'่ฅฟๅณฐๅบ':'ๅบ้ณๅธ',
'ๅบๅๅฟ':'ๅบ้ณๅธ',
'็ฏๅฟ':'ๅบ้ณๅธ',
'ๅๆฑ ๅฟ':'ๅบ้ณๅธ',
'ๅๆฐดๅฟ':'ๅบ้ณๅธ',
'ๆญฃๅฎๅฟ':'ๅบ้ณๅธ',
'ๅฎๅฟ':'ๅบ้ณๅธ',
'้ๅๅฟ':'ๅบ้ณๅธ',
'ๅธ่พๅบ':'ๅฎ่ฅฟๅธ',
'ๅฎๅฎๅบ':'ๅฎ่ฅฟๅธ',
'้ๆธญๅฟ':'ๅฎ่ฅฟๅธ',
'้่ฅฟๅฟ':'ๅฎ่ฅฟๅธ',
'ๆธญๆบๅฟ':'ๅฎ่ฅฟๅธ',
'ไธดๆดฎๅฟ':'ๅฎ่ฅฟๅธ',
'ๆผณๅฟ':'ๅฎ่ฅฟๅธ',
'ๅฒทๅฟ':'ๅฎ่ฅฟๅธ',
'ๅธ่พๅบ':'้ๅๅธ',
'ๆญฆ้ฝๅบ':'้ๅๅธ',
'ๆๅฟ':'้ๅๅธ',
'ๆๅฟ':'้ๅๅธ',
'ๅฎๆๅฟ':'้ๅๅธ',
'ๅบทๅฟ':'้ๅๅธ',
'่ฅฟๅๅฟ':'้ๅๅธ',
'็คผๅฟ':'้ๅๅธ',
'ๅพฝๅฟ':'้ๅๅธ',
'ไธคๅฝๅฟ':'้ๅๅธ',
'ไธดๅคๅธ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ไธดๅคๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ๅบทไนๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ๆฐธ้ๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ๅนฟๆฒณๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ๅๆฟๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ไธไนกๆ่ชๆฒปๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'็งฏ็ณๅฑฑไฟๅฎๆไธไนกๆๆๆๆ่ชๆฒปๅฟ':'ไธดๅคๅๆ่ชๆฒปๅท',
'ๅไฝๅธ':'็ๅ่ๆ่ชๆฒปๅท',
'ไธดๆฝญๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'ๅๅฐผๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'่ๆฒๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'่ฟญ้จๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'็ๆฒๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'็ขๆฒๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'ๅคๆฒณๅฟ':'็ๅ่ๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'่ฅฟๅฎๅธ',
'ๅไธๅบ':'่ฅฟๅฎๅธ',
'ๅไธญๅบ':'่ฅฟๅฎๅธ',
'ๅ่ฅฟๅบ':'่ฅฟๅฎๅธ',
'ๅๅๅบ':'่ฅฟๅฎๅธ',
'ๅคง้ๅๆๅๆ่ชๆฒปๅฟ':'่ฅฟๅฎๅธ',
'ๆนไธญๅฟ':'่ฅฟๅฎๅธ',
'ๆนๆบๅฟ':'่ฅฟๅฎๅธ',
'ๅนณๅฎๅฟ':'ๆตทไธๅฐๅบ',
'ๆฐๅๅๆๅๆ่ชๆฒปๅฟ':'ๆตทไธๅฐๅบ',
'ไน้ฝๅฟ':'ๆตทไธๅฐๅบ',
'ไบๅฉๅๆ่ชๆฒปๅฟ':'ๆตทไธๅฐๅบ',
'ๅ้ๅๆ่ชๆฒปๅฟ':'ๆตทไธๅฐๅบ',
'ๅพชๅๆๆๆ่ชๆฒปๅฟ':'ๆตทไธๅฐๅบ',
'้จๆบๅๆ่ชๆฒปๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'็ฅ่ฟๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'ๆตทๆๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'ๅๅฏๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'ๅไปๅฟ':'้ปๅ่ๆ่ชๆฒปๅท',
'ๅฐๆๅฟ':'้ปๅ่ๆ่ชๆฒปๅท',
'ๆณฝๅบๅฟ':'้ปๅ่ๆ่ชๆฒปๅท',
'ๆฒณๅ่ๅคๆ่ชๆฒปๅฟ':'้ปๅ่ๆ่ชๆฒปๅท',
'ๅ
ฑๅๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'ๅๅพทๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'่ดตๅพทๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'ๅ
ดๆตทๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'่ดตๅๅฟ':'ๆตทๅ่ๆ่ชๆฒปๅท',
'็ๆฒๅฟ':'ๆๆด่ๆ่ชๆฒปๅท',
'็ญ็ๅฟ':'ๆๆด่ๆ่ชๆฒปๅท',
'็ๅพทๅฟ':'ๆๆด่ๆ่ชๆฒปๅท',
'่พพๆฅๅฟ':'ๆๆด่ๆ่ชๆฒปๅท',
'ไน
ๆฒปๅฟ':'ๆๆด่ๆ่ชๆฒปๅท',
'็ๅคๅฟ':'ๆๆด่ๆ่ชๆฒปๅท',
'็ๆ ๅฟ':'็ๆ ่ๆ่ชๆฒปๅท',
'ๆๅคๅฟ':'็ๆ ่ๆ่ชๆฒปๅท',
'็งฐๅคๅฟ':'็ๆ ่ๆ่ชๆฒปๅท',
'ๆฒปๅคๅฟ':'็ๆ ่ๆ่ชๆฒปๅท',
'ๅ่ฐฆๅฟ':'็ๆ ่ๆ่ชๆฒปๅท',
'ๆฒ้บป่ฑๅฟ':'็ๆ ่ๆ่ชๆฒปๅท',
'ๆ ผๅฐๆจๅธ':'ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท',
'ๅพทไปคๅๅธ':'ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท',
'ไนๅ
ฐๅฟ':'ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท',
'้ฝๅ
ฐๅฟ':'ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท',
'ๅคฉๅณปๅฟ':'ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท',
'ๅธ่พๅบ':'้ถๅทๅธ',
'ๅ
ดๅบๅบ':'้ถๅทๅธ',
'่ฅฟๅคๅบ':'้ถๅทๅธ',
'้ๅคๅบ':'้ถๅทๅธ',
'ๆฐธๅฎๅฟ':'้ถๅทๅธ',
'่ดบๅ
ฐๅฟ':'้ถๅทๅธ',
'็ตๆญฆๅธ':'้ถๅทๅธ',
'ๅธ่พๅบ':'็ณๅดๅฑฑๅธ',
'ๅคงๆญฆๅฃๅบ':'็ณๅดๅฑฑๅธ',
'ๆ ๅๅบ':'็ณๅดๅฑฑๅธ',
'ๅนณ็ฝๅฟ':'็ณๅดๅฑฑๅธ',
'ๅธ่พๅบ':'ๅดๅฟ ๅธ',
'ๅฉ้ๅบ':'ๅดๅฟ ๅธ',
'็ๆฑ ๅฟ':'ๅดๅฟ ๅธ',
'ๅๅฟๅฟ':'ๅดๅฟ ๅธ',
'้้ๅณกๅธ':'ๅดๅฟ ๅธ',
'ๅธ่พๅบ':'ๅบๅๅธ',
'ๅๅทๅบ':'ๅบๅๅธ',
'่ฅฟๅๅฟ':'ๅบๅๅธ',
'้ๅพทๅฟ':'ๅบๅๅธ',
'ๆณพๆบๅฟ':'ๅบๅๅธ',
'ๅฝญ้ณๅฟ':'ๅบๅๅธ',
'ๅธ่พๅบ':'ไธญๅซๅธ',
'ๆฒๅกๅคดๅบ':'ไธญๅซๅธ',
'ไธญๅฎๅฟ':'ไธญๅซๅธ',
'ๆตทๅๅฟ':'ไธญๅซๅธ',
'ๅธ่พๅบ':'ไน้ฒๆจ้ฝๅธ',
'ๅคฉๅฑฑๅบ':'ไน้ฒๆจ้ฝๅธ',
'ๆฒไพๅทดๅ
ๅบ':'ไน้ฒๆจ้ฝๅธ',
'ๆฐๅธๅบ':'ไน้ฒๆจ้ฝๅธ',
'ๆฐด็ฃจๆฒๅบ':'ไน้ฒๆจ้ฝๅธ',
'ๅคดๅฑฏๆฒณๅบ':'ไน้ฒๆจ้ฝๅธ',
'่พพๅๅๅบ':'ไน้ฒๆจ้ฝๅธ',
'ไธๅฑฑๅบ':'ไน้ฒๆจ้ฝๅธ',
'ไน้ฒๆจ้ฝๅฟ':'ไน้ฒๆจ้ฝๅธ',
'ๅธ่พๅบ':'ๅ
ๆ็ไพๅธ',
'็ฌๅฑฑๅญๅบ':'ๅ
ๆ็ไพๅธ',
'ๅ
ๆ็ไพๅบ':'ๅ
ๆ็ไพๅธ',
'็ฝ็ขฑๆปฉๅบ':'ๅ
ๆ็ไพๅธ',
'ไนๅฐ็ฆพๅบ':'ๅ
ๆ็ไพๅธ',
'ๅ้ฒ็ชๅธ':'ๅ้ฒ็ชๅฐๅบ',
'้ฏๅๅฟ':'ๅ้ฒ็ชๅฐๅบ',
'ๆๅ
้ๅฟ':'ๅ้ฒ็ชๅฐๅบ',
'ๅๅฏๅธ':'ๅๅฏๅฐๅบ',
'ๅทด้ๅคๅ่จๅ
่ชๆฒปๅฟ':'ๅๅฏๅฐๅบ',
'ไผๅพๅฟ':'ๅๅฏๅฐๅบ',
'ๆๅๅธ':'ๆๅๅๆ่ชๆฒปๅท',
'้ๅบทๅธ':'ๆๅๅๆ่ชๆฒปๅท',
'็ฑณๆณๅธ':'ๆๅๅๆ่ชๆฒปๅท',
'ๅผๅพๅฃๅฟ':'ๆๅๅๆ่ชๆฒปๅท',
'็็บณๆฏๅฟ':'ๆๅๅๆ่ชๆฒปๅท',
'ๅฅๅฐๅฟ':'ๆๅๅๆ่ชๆฒปๅท',
'ๅๆจ่จๅฐๅฟ':'ๆๅๅๆ่ชๆฒปๅท',
'ๆจๅๅ่จๅ
่ชๆฒปๅฟ':'ๆๅๅๆ่ชๆฒปๅท',
'ๅไนๅธ':'ๅๅฐๅกๆ่ๅค่ชๆฒปๅท',
'็ฒพๆฒณๅฟ':'ๅๅฐๅกๆ่ๅค่ชๆฒปๅท',
'ๆธฉๆณๅฟ':'ๅๅฐๅกๆ่ๅค่ชๆฒปๅท',
'ๅบๅฐๅๅธ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'่ฝฎๅฐๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'ๅฐ็ๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'่ฅ็พๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'ไธๆซๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'็่ๅๆ่ชๆฒปๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'ๅ้ๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'ๅ็กๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'ๅๆนๅฟ':'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท',
'้ฟๅ
่ๅธ':'้ฟๅ
่ๅฐๅบ',
'ๆธฉๅฎฟๅฟ':'้ฟๅ
่ๅฐๅบ',
'ๅบ่ฝฆๅฟ':'้ฟๅ
่ๅฐๅบ',
'ๆฒ้
ๅฟ':'้ฟๅ
่ๅฐๅบ',
'ๆฐๅๅฟ':'้ฟๅ
่ๅฐๅบ',
'ๆๅๅฟ':'้ฟๅ
่ๅฐๅบ',
'ไนไปๅฟ':'้ฟๅ
่ๅฐๅบ',
'้ฟ็ฆๆๅฟ':'้ฟๅ
่ๅฐๅบ',
'ๆฏๅชๅฟ':'้ฟๅ
่ๅฐๅบ',
'้ฟๅพไปๅธ':'ๅ
ๅญๅ่ๆฏๅฐๅ
ๅญ่ชๆฒปๅท',
'้ฟๅ
้ถๅฟ':'ๅ
ๅญๅ่ๆฏๅฐๅ
ๅญ่ชๆฒปๅท',
'้ฟๅๅฅๅฟ':'ๅ
ๅญๅ่ๆฏๅฐๅ
ๅญ่ชๆฒปๅท',
'ไนๆฐๅฟ':'ๅ
ๅญๅ่ๆฏๅฐๅ
ๅญ่ชๆฒปๅท',
'ๅไปๅธ':'ๅไปๅฐๅบ',
'็้ๅฟ':'ๅไปๅฐๅบ',
'็ๅๅฟ':'ๅไปๅฐๅบ',
'่ฑๅๆฒๅฟ':'ๅไปๅฐๅบ',
'ๆณฝๆฎๅฟ':'ๅไปๅฐๅบ',
'่่ฝฆๅฟ':'ๅไปๅฐๅบ',
'ๅถๅๅฟ':'ๅไปๅฐๅบ',
'้บฆ็ๆๅฟ':'ๅไปๅฐๅบ',
'ๅฒณๆฎๆนๅฟ':'ๅไปๅฐๅบ',
'ไผฝๅธๅฟ':'ๅไปๅฐๅบ',
'ๅทดๆฅๅฟ':'ๅไปๅฐๅบ',
'ๅกไปๅบๅฐๅนฒๅกๅๅ
่ชๆฒปๅฟ':'ๅไปๅฐๅบ',
'ๅ็ฐๅธ':'ๅ็ฐๅฐๅบ',
'ๅ็ฐๅฟ':'ๅ็ฐๅฐๅบ',
'ๅขจ็ๅฟ':'ๅ็ฐๅฐๅบ',
'็ฎๅฑฑๅฟ':'ๅ็ฐๅฐๅบ',
'ๆดๆตฆๅฟ':'ๅ็ฐๅฐๅบ',
'็ญๅๅฟ':'ๅ็ฐๅฐๅบ',
'ไบ็ฐๅฟ':'ๅ็ฐๅฐๅบ',
'ๆฐไธฐๅฟ':'ๅ็ฐๅฐๅบ',
'ไผๅฎๅธ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๅฅๅฑฏๅธ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ไผๅฎๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๅฏๅธๆฅๅฐ้กไผฏ่ชๆฒปๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'้ๅๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๅทฉ็ๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๆฐๆบๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๆญ่ๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'็นๅ
ๆฏๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๅฐผๅๅ
ๅฟ':'ไผ็ๅ่จๅ
่ชๆฒปๅท',
'ๅกๅๅธ':'ๅกๅๅฐๅบ',
'ไน่ๅธ':'ๅกๅๅฐๅบ',
'้ขๆๅฟ':'ๅกๅๅฐๅบ',
'ๆฒๆนพๅฟ':'ๅกๅๅฐๅบ',
'ๆ้ๅฟ':'ๅกๅๅฐๅบ',
'่ฃๆฐๅฟ':'ๅกๅๅฐๅบ',
'ๅๅธๅ
่ตๅฐ่ๅค่ชๆฒปๅฟ':'ๅกๅๅฐๅบ',
'้ฟๅๆณฐๅธ':'้ฟๅๆณฐๅฐๅบ',
'ๅธๅฐๆดฅๅฟ':'้ฟๅๆณฐๅฐๅบ',
'ๅฏ่ดๅฟ':'้ฟๅๆณฐๅฐๅบ',
'็ฆๆตทๅฟ':'้ฟๅๆณฐๅฐๅบ',
'ๅๅทดๆฒณๅฟ':'้ฟๅๆณฐๅฐๅบ',
'้ๆฒณๅฟ':'้ฟๅๆณฐๅฐๅบ',
'ๅๆจไนๅฟ':'้ฟๅๆณฐๅฐๅบ',
'็ณๆฒณๅญๅธ':'659000',
'้ฟๆๅฐๅธ':'659000',
'ๅพๆจ่ๅ
ๅธ':'659000',
'ไบๅฎถๆธ ๅธ':'659000',
}
rep_areas = [
'ๅๆกฅๅบ',
'ๅ้ณๅบ',
'้ผๆฅผๅบ',
'ๅๅนณๅบ',
'ๆตทๅทๅบ',
'ๆฐๅธๅบ',
'ๆกฅไธๅบ',
'ๅๅ
ณๅบ',
'้่ฅฟๅบ',
'ๆฑๅๅบ',
'่ฅฟๆนๅบ',
'ๆกฅ่ฅฟๅบ',
'ๅๅฑฑๅบ',
'ๅธ่พๅบ',
'่ฅฟๅฎๅบ',
'็ฟๅบ',
'ๆฐๅๅบ',
'ๅไธญๅบ',
'็ฝไบๅบ',
'ๅธไธญๅบ',
'้ไธๅบ',
'ๆธ
ๆฒณๅบ',
'ๆ้ณๅบ',
'ๅๅ
ณๅบ',
'้ๅบ',
'ๅฎๅฑฑๅบ',
'ๆฐๅๅบ',
'ๆฎ้ๅบ',
'้ฟๅฎๅบ',
'ไธๅฑฑๅบ',
'ๅๅบ',
'้ๅฑฑๅบ',
'ๆฒณไธๅบ',
]
city_province_mapper = {
'ๅไบฌๅธ':'ๅไบฌๅธ',
'ๅไบฌ':'ๅไบฌๅธ',
'ๅคฉๆดฅๅธ':'ๅคฉๆดฅๅธ',
'ๅคฉๆดฅ':'ๅคฉๆดฅๅธ',
'็ณๅฎถๅบๅธ':'ๆฒณๅ็',
'็ณๅฎถๅบ':'ๆฒณๅ็',
'ๅๅฑฑๅธ':'ๆฒณๅ็',
'ๅๅฑฑ':'ๆฒณๅ็',
'็งฆ็ๅฒๅธ':'ๆฒณๅ็',
'็งฆ็ๅฒ':'ๆฒณๅ็',
'้ฏ้ธๅธ':'ๆฒณๅ็',
'้ฏ้ธ':'ๆฒณๅ็',
'้ขๅฐๅธ':'ๆฒณๅ็',
'้ขๅฐ':'ๆฒณๅ็',
'ไฟๅฎๅธ':'ๆฒณๅ็',
'ไฟๅฎ':'ๆฒณๅ็',
'ๅผ ๅฎถๅฃๅธ':'ๆฒณๅ็',
'ๅผ ๅฎถๅฃ':'ๆฒณๅ็',
'ๆฟๅพทๅธ':'ๆฒณๅ็',
'ๆฟๅพท':'ๆฒณๅ็',
'ๆฒงๅทๅธ':'ๆฒณๅ็',
'ๆฒงๅท':'ๆฒณๅ็',
'ๅปๅๅธ':'ๆฒณๅ็',
'ๅปๅ':'ๆฒณๅ็',
'่กกๆฐดๅธ':'ๆฒณๅ็',
'่กกๆฐด':'ๆฒณๅ็',
'ๅคชๅๅธ':'ๅฑฑ่ฅฟ็',
'ๅคชๅ':'ๅฑฑ่ฅฟ็',
'ๅคงๅๅธ':'ๅฑฑ่ฅฟ็',
'ๅคงๅ':'ๅฑฑ่ฅฟ็',
'้ณๆณๅธ':'ๅฑฑ่ฅฟ็',
'้ณๆณ':'ๅฑฑ่ฅฟ็',
'้ฟๆฒปๅธ':'ๅฑฑ่ฅฟ็',
'้ฟๆฒป':'ๅฑฑ่ฅฟ็',
'ๆๅๅธ':'ๅฑฑ่ฅฟ็',
'ๆๅ':'ๅฑฑ่ฅฟ็',
'ๆๅทๅธ':'ๅฑฑ่ฅฟ็',
'ๆๅท':'ๅฑฑ่ฅฟ็',
'ๆไธญๅธ':'ๅฑฑ่ฅฟ็',
'ๆไธญ':'ๅฑฑ่ฅฟ็',
'่ฟๅๅธ':'ๅฑฑ่ฅฟ็',
'่ฟๅ':'ๅฑฑ่ฅฟ็',
'ๅฟปๅทๅธ':'ๅฑฑ่ฅฟ็',
'ๅฟปๅท':'ๅฑฑ่ฅฟ็',
'ไธดๆฑพๅธ':'ๅฑฑ่ฅฟ็',
'ไธดๆฑพ':'ๅฑฑ่ฅฟ็',
'ๅๆขๅธ':'ๅฑฑ่ฅฟ็',
'ๅๆข':'ๅฑฑ่ฅฟ็',
'ๅผๅๆตฉ็นๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅผๅๆตฉ็น':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅ
ๅคดๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅ
ๅคด':'ๅ
่ๅค่ชๆฒปๅบ',
'ไนๆตทๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ไนๆตท':'ๅ
่ๅค่ชๆฒปๅบ',
'่ตคๅณฐๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'่ตคๅณฐ':'ๅ
่ๅค่ชๆฒปๅบ',
'้่พฝๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'้่พฝ':'ๅ
่ๅค่ชๆฒปๅบ',
'้ๅฐๅคๆฏๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'้ๅฐๅคๆฏ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅผไผฆ่ดๅฐๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅผไผฆ่ดๅฐ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅทดๅฝฆๆทๅฐๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅทดๅฝฆๆทๅฐ':'ๅ
่ๅค่ชๆฒปๅบ',
'ไนๅ
ฐๅฏๅธๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ไนๅ
ฐๅฏๅธ':'ๅ
่ๅค่ชๆฒปๅบ',
'ๅ
ดๅฎ็':'ๅ
่ๅค่ชๆฒปๅบ',
'้กๆ้ญๅ็':'ๅ
่ๅค่ชๆฒปๅบ',
'้ฟๆๅ็':'ๅ
่ๅค่ชๆฒปๅบ',
'ๆฒ้ณๅธ':'่พฝๅฎ็',
'ๆฒ้ณ':'่พฝๅฎ็',
'ๅคง่ฟๅธ':'่พฝๅฎ็',
'ๅคง่ฟ':'่พฝๅฎ็',
'้ๅฑฑๅธ':'่พฝๅฎ็',
'้ๅฑฑ':'่พฝๅฎ็',
'ๆ้กบๅธ':'่พฝๅฎ็',
'ๆ้กบ':'่พฝๅฎ็',
'ๆฌๆบชๅธ':'่พฝๅฎ็',
'ๆฌๆบช':'่พฝๅฎ็',
'ไธนไธๅธ':'่พฝๅฎ็',
'ไธนไธ':'่พฝๅฎ็',
'้ฆๅทๅธ':'่พฝๅฎ็',
'้ฆๅท':'่พฝๅฎ็',
'่ฅๅฃๅธ':'่พฝๅฎ็',
'่ฅๅฃ':'่พฝๅฎ็',
'้ๆฐๅธ':'่พฝๅฎ็',
'้ๆฐ':'่พฝๅฎ็',
'่พฝ้ณๅธ':'่พฝๅฎ็',
'่พฝ้ณ':'่พฝๅฎ็',
'็้ฆๅธ':'่พฝๅฎ็',
'็้ฆ':'่พฝๅฎ็',
'้ๅฒญๅธ':'่พฝๅฎ็',
'้ๅฒญ':'่พฝๅฎ็',
'ๆ้ณๅธ':'่พฝๅฎ็',
'ๆ้ณ':'่พฝๅฎ็',
'่ซ่ฆๅฒๅธ':'่พฝๅฎ็',
'่ซ่ฆๅฒ':'่พฝๅฎ็',
'้ฟๆฅๅธ':'ๅๆ็',
'้ฟๆฅ':'ๅๆ็',
'ๅๆๅธ':'ๅๆ็',
'ๅๆ':'ๅๆ็',
'ๅๅนณๅธ':'ๅๆ็',
'ๅๅนณ':'ๅๆ็',
'่พฝๆบๅธ':'ๅๆ็',
'่พฝๆบ':'ๅๆ็',
'้ๅๅธ':'ๅๆ็',
'้ๅ':'ๅๆ็',
'็ฝๅฑฑๅธ':'ๅๆ็',
'็ฝๅฑฑ':'ๅๆ็',
'ๆพๅๅธ':'ๅๆ็',
'ๆพๅ':'ๅๆ็',
'็ฝๅๅธ':'ๅๆ็',
'็ฝๅ':'ๅๆ็',
'ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท':'ๅๆ็',
'ๅๅฐๆปจๅธ':'้ป้พๆฑ็',
'ๅๅฐๆปจ':'้ป้พๆฑ็',
'้ฝ้ฝๅๅฐๅธ':'้ป้พๆฑ็',
'้ฝ้ฝๅๅฐ':'้ป้พๆฑ็',
'้ธก่ฅฟๅธ':'้ป้พๆฑ็',
'้ธก่ฅฟ':'้ป้พๆฑ็',
'้นคๅฒๅธ':'้ป้พๆฑ็',
'้นคๅฒ':'้ป้พๆฑ็',
'ๅ้ธญๅฑฑๅธ':'้ป้พๆฑ็',
'ๅ้ธญๅฑฑ':'้ป้พๆฑ็',
'ๅคงๅบๅธ':'้ป้พๆฑ็',
'ๅคงๅบ':'้ป้พๆฑ็',
'ไผๆฅๅธ':'้ป้พๆฑ็',
'ไผๆฅ':'้ป้พๆฑ็',
'ไฝณๆจๆฏๅธ':'้ป้พๆฑ็',
'ไฝณๆจๆฏ':'้ป้พๆฑ็',
'ไธๅฐๆฒณๅธ':'้ป้พๆฑ็',
'ไธๅฐๆฒณ':'้ป้พๆฑ็',
'็กไธนๆฑๅธ':'้ป้พๆฑ็',
'็กไธนๆฑ':'้ป้พๆฑ็',
'้ปๆฒณๅธ':'้ป้พๆฑ็',
'้ปๆฒณ':'้ป้พๆฑ็',
'็ปฅๅๅธ':'้ป้พๆฑ็',
'็ปฅๅ':'้ป้พๆฑ็',
'ๅคงๅ
ดๅฎๅฒญๅฐๅบ':'้ป้พๆฑ็',
'ไธๆตทๅธ':'ไธๆตทๅธ',
'ไธๆตท':'ไธๆตทๅธ',
'ๅไบฌๅธ':'ๆฑ่็',
'ๅไบฌ':'ๆฑ่็',
'ๆ ้กๅธ':'ๆฑ่็',
'ๆ ้ก':'ๆฑ่็',
'ๅพๅทๅธ':'ๆฑ่็',
'ๅพๅท':'ๆฑ่็',
'ๅธธๅทๅธ':'ๆฑ่็',
'ๅธธๅท':'ๆฑ่็',
'่ๅทๅธ':'ๆฑ่็',
'่ๅท':'ๆฑ่็',
'ๅ้ๅธ':'ๆฑ่็',
'ๅ้':'ๆฑ่็',
'่ฟไบๆธฏๅธ':'ๆฑ่็',
'่ฟไบๆธฏ':'ๆฑ่็',
'ๆทฎๅฎๅธ':'ๆฑ่็',
'ๆทฎๅฎ':'ๆฑ่็',
'็ๅๅธ':'ๆฑ่็',
'็ๅ':'ๆฑ่็',
'ๆฌๅทๅธ':'ๆฑ่็',
'ๆฌๅท':'ๆฑ่็',
'้ๆฑๅธ':'ๆฑ่็',
'้ๆฑ':'ๆฑ่็',
'ๆณฐๅทๅธ':'ๆฑ่็',
'ๆณฐๅท':'ๆฑ่็',
'ๅฎฟ่ฟๅธ':'ๆฑ่็',
'ๅฎฟ่ฟ':'ๆฑ่็',
'ๆญๅทๅธ':'ๆตๆฑ็',
'ๆญๅท':'ๆตๆฑ็',
'ๅฎๆณขๅธ':'ๆตๆฑ็',
'ๅฎๆณข':'ๆตๆฑ็',
'ๆธฉๅทๅธ':'ๆตๆฑ็',
'ๆธฉๅท':'ๆตๆฑ็',
'ๅๅ
ดๅธ':'ๆตๆฑ็',
'ๅๅ
ด':'ๆตๆฑ็',
'ๆนๅทๅธ':'ๆตๆฑ็',
'ๆนๅท':'ๆตๆฑ็',
'็ปๅ
ดๅธ':'ๆตๆฑ็',
'็ปๅ
ด':'ๆตๆฑ็',
'้ๅๅธ':'ๆตๆฑ็',
'้ๅ':'ๆตๆฑ็',
'่กขๅทๅธ':'ๆตๆฑ็',
'่กขๅท':'ๆตๆฑ็',
'่ๅฑฑๅธ':'ๆตๆฑ็',
'่ๅฑฑ':'ๆตๆฑ็',
'ๅฐๅทๅธ':'ๆตๆฑ็',
'ๅฐๅท':'ๆตๆฑ็',
'ไธฝๆฐดๅธ':'ๆตๆฑ็',
'ไธฝๆฐด':'ๆตๆฑ็',
'ๅ่ฅๅธ':'ๅฎๅพฝ็',
'ๅ่ฅ':'ๅฎๅพฝ็',
'่ๆนๅธ':'ๅฎๅพฝ็',
'่ๆน':'ๅฎๅพฝ็',
'่ๅ ๅธ':'ๅฎๅพฝ็',
'่ๅ ':'ๅฎๅพฝ็',
'ๆทฎๅๅธ':'ๅฎๅพฝ็',
'ๆทฎๅ':'ๅฎๅพฝ็',
'้ฉฌ้ๅฑฑๅธ':'ๅฎๅพฝ็',
'้ฉฌ้ๅฑฑ':'ๅฎๅพฝ็',
'ๆทฎๅๅธ':'ๅฎๅพฝ็',
'ๆทฎๅ':'ๅฎๅพฝ็',
'้้ตๅธ':'ๅฎๅพฝ็',
'้้ต':'ๅฎๅพฝ็',
'ๅฎๅบๅธ':'ๅฎๅพฝ็',
'ๅฎๅบ':'ๅฎๅพฝ็',
'้ปๅฑฑๅธ':'ๅฎๅพฝ็',
'้ปๅฑฑ':'ๅฎๅพฝ็',
'ๆปๅทๅธ':'ๅฎๅพฝ็',
'ๆปๅท':'ๅฎๅพฝ็',
'้้ณๅธ':'ๅฎๅพฝ็',
'้้ณ':'ๅฎๅพฝ็',
'ๅฎฟๅทๅธ':'ๅฎๅพฝ็',
'ๅฎฟๅท':'ๅฎๅพฝ็',
'ๅทขๆนๅธ':'ๅฎๅพฝ็',
'ๅทขๆน':'ๅฎๅพฝ็',
'ๅ
ญๅฎๅธ':'ๅฎๅพฝ็',
'ๅ
ญๅฎ':'ๅฎๅพฝ็',
'ไบณๅทๅธ':'ๅฎๅพฝ็',
'ไบณๅท':'ๅฎๅพฝ็',
'ๆฑ ๅทๅธ':'ๅฎๅพฝ็',
'ๆฑ ๅท':'ๅฎๅพฝ็',
'ๅฎฃๅๅธ':'ๅฎๅพฝ็',
'ๅฎฃๅ':'ๅฎๅพฝ็',
'็ฆๅทๅธ':'็ฆๅปบ็',
'็ฆๅท':'็ฆๅปบ็',
'ๅฆ้จๅธ':'็ฆๅปบ็',
'ๅฆ้จ':'็ฆๅปบ็',
'่็ฐๅธ':'็ฆๅปบ็',
'่็ฐ':'็ฆๅปบ็',
'ไธๆๅธ':'็ฆๅปบ็',
'ไธๆ':'็ฆๅปบ็',
'ๆณๅทๅธ':'็ฆๅปบ็',
'ๆณๅท':'็ฆๅปบ็',
'ๆผณๅทๅธ':'็ฆๅปบ็',
'ๆผณๅท':'็ฆๅปบ็',
'ๅๅนณๅธ':'็ฆๅปบ็',
'ๅๅนณ':'็ฆๅปบ็',
'้พๅฒฉๅธ':'็ฆๅปบ็',
'้พๅฒฉ':'็ฆๅปบ็',
'ๅฎๅพทๅธ':'็ฆๅปบ็',
'ๅฎๅพท':'็ฆๅปบ็',
'ๅๆๅธ':'ๆฑ่ฅฟ็',
'ๅๆ':'ๆฑ่ฅฟ็',
'ๆฏๅพท้ๅธ':'ๆฑ่ฅฟ็',
'ๆฏๅพท้':'ๆฑ่ฅฟ็',
'่ไนกๅธ':'ๆฑ่ฅฟ็',
'่ไนก':'ๆฑ่ฅฟ็',
'ไนๆฑๅธ':'ๆฑ่ฅฟ็',
'ไนๆฑ':'ๆฑ่ฅฟ็',
'ๆฐไฝๅธ':'ๆฑ่ฅฟ็',
'ๆฐไฝ':'ๆฑ่ฅฟ็',
'้นฐๆฝญๅธ':'ๆฑ่ฅฟ็',
'้นฐๆฝญ':'ๆฑ่ฅฟ็',
'่ตฃๅทๅธ':'ๆฑ่ฅฟ็',
'่ตฃๅท':'ๆฑ่ฅฟ็',
'ๅๅฎๅธ':'ๆฑ่ฅฟ็',
'ๅๅฎ':'ๆฑ่ฅฟ็',
'ๅฎๆฅๅธ':'ๆฑ่ฅฟ็',
'ๅฎๆฅ':'ๆฑ่ฅฟ็',
'ๆๅทๅธ':'ๆฑ่ฅฟ็',
'ๆๅท':'ๆฑ่ฅฟ็',
'ไธ้ฅถๅธ':'ๆฑ่ฅฟ็',
'ไธ้ฅถ':'ๆฑ่ฅฟ็',
'ๆตๅๅธ':'ๅฑฑไธ็',
'ๆตๅ':'ๅฑฑไธ็',
'้ๅฒๅธ':'ๅฑฑไธ็',
'้ๅฒ':'ๅฑฑไธ็',
'ๆทๅๅธ':'ๅฑฑไธ็',
'ๆทๅ':'ๅฑฑไธ็',
'ๆฃๅบๅธ':'ๅฑฑไธ็',
'ๆฃๅบ':'ๅฑฑไธ็',
'ไธ่ฅๅธ':'ๅฑฑไธ็',
'ไธ่ฅ':'ๅฑฑไธ็',
'็ๅฐๅธ':'ๅฑฑไธ็',
'็ๅฐ':'ๅฑฑไธ็',
'ๆฝๅๅธ':'ๅฑฑไธ็',
'ๆฝๅ':'ๅฑฑไธ็',
'ๆตๅฎๅธ':'ๅฑฑไธ็',
'ๆตๅฎ':'ๅฑฑไธ็',
'ๆณฐๅฎๅธ':'ๅฑฑไธ็',
'ๆณฐๅฎ':'ๅฑฑไธ็',
'ๅจๆตทๅธ':'ๅฑฑไธ็',
'ๅจๆตท':'ๅฑฑไธ็',
'ๆฅ็
งๅธ':'ๅฑฑไธ็',
'ๆฅ็
ง':'ๅฑฑไธ็',
'่ฑ่ๅธ':'ๅฑฑไธ็',
'่ฑ่':'ๅฑฑไธ็',
'ไธดๆฒๅธ':'ๅฑฑไธ็',
'ไธดๆฒ':'ๅฑฑไธ็',
'ๅพทๅทๅธ':'ๅฑฑไธ็',
'ๅพทๅท':'ๅฑฑไธ็',
'่ๅๅธ':'ๅฑฑไธ็',
'่ๅ':'ๅฑฑไธ็',
'ๆปจๅทๅธ':'ๅฑฑไธ็',
'ๆปจๅท':'ๅฑฑไธ็',
'่ทๆณฝๅธ':'ๅฑฑไธ็',
'่ทๆณฝ':'ๅฑฑไธ็',
'้ๅทๅธ':'ๆฒณๅ็',
'้ๅท':'ๆฒณๅ็',
'ๅผๅฐๅธ':'ๆฒณๅ็',
'ๅผๅฐ':'ๆฒณๅ็',
'ๆด้ณๅธ':'ๆฒณๅ็',
'ๆด้ณ':'ๆฒณๅ็',
'ๅนณ้กถๅฑฑๅธ':'ๆฒณๅ็',
'ๅนณ้กถๅฑฑ':'ๆฒณๅ็',
'ๅฎ้ณๅธ':'ๆฒณๅ็',
'ๅฎ้ณ':'ๆฒณๅ็',
'้นคๅฃๅธ':'ๆฒณๅ็',
'้นคๅฃ':'ๆฒณๅ็',
'ๆฐไนกๅธ':'ๆฒณๅ็',
'ๆฐไนก':'ๆฒณๅ็',
'็ฆไฝๅธ':'ๆฒณๅ็',
'็ฆไฝ':'ๆฒณๅ็',
'ๆฟฎ้ณๅธ':'ๆฒณๅ็',
'ๆฟฎ้ณ':'ๆฒณๅ็',
'่ฎธๆๅธ':'ๆฒณๅ็',
'่ฎธๆ':'ๆฒณๅ็',
'ๆผฏๆฒณๅธ':'ๆฒณๅ็',
'ๆผฏๆฒณ':'ๆฒณๅ็',
'ไธ้จๅณกๅธ':'ๆฒณๅ็',
'ไธ้จๅณก':'ๆฒณๅ็',
'ๅ้ณๅธ':'ๆฒณๅ็',
'ๅ้ณ':'ๆฒณๅ็',
'ๅไธๅธ':'ๆฒณๅ็',
'ๅไธ':'ๆฒณๅ็',
'ไฟก้ณๅธ':'ๆฒณๅ็',
'ไฟก้ณ':'ๆฒณๅ็',
'ๅจๅฃๅธ':'ๆฒณๅ็',
'ๅจๅฃ':'ๆฒณๅ็',
'้ฉป้ฉฌๅบๅธ':'ๆฒณๅ็',
'้ฉป้ฉฌๅบ':'ๆฒณๅ็',
'ๆญฆๆฑๅธ':'ๆนๅ็',
'ๆญฆๆฑ':'ๆนๅ็',
'้ป็ณๅธ':'ๆนๅ็',
'้ป็ณ':'ๆนๅ็',
'ๅๅ ฐๅธ':'ๆนๅ็',
'ๅๅ ฐ':'ๆนๅ็',
'ๅฎๆๅธ':'ๆนๅ็',
'ๅฎๆ':'ๆนๅ็',
'่ฅๆจๅธ':'ๆนๅ็',
'่ฅๆจ':'ๆนๅ็',
'้ๅทๅธ':'ๆนๅ็',
'้ๅท':'ๆนๅ็',
'่้จๅธ':'ๆนๅ็',
'่้จ':'ๆนๅ็',
'ๅญๆๅธ':'ๆนๅ็',
'ๅญๆ':'ๆนๅ็',
'่ๅทๅธ':'ๆนๅ็',
'่ๅท':'ๆนๅ็',
'้ปๅๅธ':'ๆนๅ็',
'้ปๅ':'ๆนๅ็',
'ๅธๅฎๅธ':'ๆนๅ็',
'ๅธๅฎ':'ๆนๅ็',
'้ๅทๅธ':'ๆนๅ็',
'้ๅท':'ๆนๅ็',
'ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท':'ๆนๅ็',
'429000':'ๆนๅ็',
'้ฟๆฒๅธ':'ๆนๅ็',
'้ฟๆฒ':'ๆนๅ็',
'ๆ ชๆดฒๅธ':'ๆนๅ็',
'ๆ ชๆดฒ':'ๆนๅ็',
'ๆนๆฝญๅธ':'ๆนๅ็',
'ๆนๆฝญ':'ๆนๅ็',
'่กก้ณๅธ':'ๆนๅ็',
'่กก้ณ':'ๆนๅ็',
'้ต้ณๅธ':'ๆนๅ็',
'้ต้ณ':'ๆนๅ็',
'ๅฒณ้ณๅธ':'ๆนๅ็',
'ๅฒณ้ณ':'ๆนๅ็',
'ๅธธๅพทๅธ':'ๆนๅ็',
'ๅธธๅพท':'ๆนๅ็',
'ๅผ ๅฎถ็ๅธ':'ๆนๅ็',
'ๅผ ๅฎถ็':'ๆนๅ็',
'็้ณๅธ':'ๆนๅ็',
'็้ณ':'ๆนๅ็',
'้ดๅทๅธ':'ๆนๅ็',
'้ดๅท':'ๆนๅ็',
'ๆฐธๅทๅธ':'ๆนๅ็',
'ๆฐธๅท':'ๆนๅ็',
'ๆๅๅธ':'ๆนๅ็',
'ๆๅ':'ๆนๅ็',
'ๅจๅบๅธ':'ๆนๅ็',
'ๅจๅบ':'ๆนๅ็',
'ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท':'ๆนๅ็',
'ๅนฟๅทๅธ':'ๅนฟไธ็',
'ๅนฟๅท':'ๅนฟไธ็',
'้ถๅ
ณๅธ':'ๅนฟไธ็',
'้ถๅ
ณ':'ๅนฟไธ็',
'ๆทฑๅณๅธ':'ๅนฟไธ็',
'ๆทฑๅณ':'ๅนฟไธ็',
'็ ๆตทๅธ':'ๅนฟไธ็',
'็ ๆตท':'ๅนฟไธ็',
'ๆฑๅคดๅธ':'ๅนฟไธ็',
'ๆฑๅคด':'ๅนฟไธ็',
'ไฝๅฑฑๅธ':'ๅนฟไธ็',
'ไฝๅฑฑ':'ๅนฟไธ็',
'ๆฑ้จๅธ':'ๅนฟไธ็',
'ๆฑ้จ':'ๅนฟไธ็',
'ๆนๆฑๅธ':'ๅนฟไธ็',
'ๆนๆฑ':'ๅนฟไธ็',
'่ๅๅธ':'ๅนฟไธ็',
'่ๅ':'ๅนฟไธ็',
'่ๅบๅธ':'ๅนฟไธ็',
'่ๅบ':'ๅนฟไธ็',
'ๆ ๅทๅธ':'ๅนฟไธ็',
'ๆ ๅท':'ๅนฟไธ็',
'ๆข
ๅทๅธ':'ๅนฟไธ็',
'ๆข
ๅท':'ๅนฟไธ็',
'ๆฑๅฐพๅธ':'ๅนฟไธ็',
'ๆฑๅฐพ':'ๅนฟไธ็',
'ๆฒณๆบๅธ':'ๅนฟไธ็',
'ๆฒณๆบ':'ๅนฟไธ็',
'้ณๆฑๅธ':'ๅนฟไธ็',
'้ณๆฑ':'ๅนฟไธ็',
'ๆธ
่ฟๅธ':'ๅนฟไธ็',
'ๆธ
่ฟ':'ๅนฟไธ็',
'ไธ่ๅธ':'ๅนฟไธ็',
'ไธ่':'ๅนฟไธ็',
'ไธญๅฑฑๅธ':'ๅนฟไธ็',
'ไธญๅฑฑ':'ๅนฟไธ็',
'ๆฝฎๅทๅธ':'ๅนฟไธ็',
'ๆฝฎๅท':'ๅนฟไธ็',
'ๆญ้ณๅธ':'ๅนฟไธ็',
'ๆญ้ณ':'ๅนฟไธ็',
'ไบๆตฎๅธ':'ๅนฟไธ็',
'ไบๆตฎ':'ๅนฟไธ็',
'ๅๅฎๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๅๅฎ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆณๅทๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆณๅท':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆกๆๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆกๆ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆขงๅทๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆขงๅท':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๅๆตทๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๅๆตท':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'้ฒๅๆธฏๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'้ฒๅๆธฏ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'้ฆๅทๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'้ฆๅท':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'่ดตๆธฏๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'่ดตๆธฏ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'็ๆๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'็ๆ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'็พ่ฒๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'็พ่ฒ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'่ดบๅทๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'่ดบๅท':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆฒณๆฑ ๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆฒณๆฑ ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆฅๅฎพๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆฅๅฎพ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๅดๅทฆๅธ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๅดๅทฆ':'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ',
'ๆตทๅฃๅธ':'ๆตทๅ็',
'ๆตทๅฃ':'ๆตทๅ็',
'ไธไบๅธ':'ๆตทๅ็',
'ไธไบ':'ๆตทๅ็',
'็็ด่พๅฟ็บง่กๆฟๅไฝ':'ๆตทๅ็',
'้ๅบๅธ':'้ๅบๅธ',
'้ๅบ':'้ๅบๅธ',
'ๆ้ฝๅธ':'ๅๅท็',
'ๆ้ฝ':'ๅๅท็',
'่ช่ดกๅธ':'ๅๅท็',
'่ช่ดก':'ๅๅท็',
'ๆๆ่ฑๅธ':'ๅๅท็',
'ๆๆ่ฑ':'ๅๅท็',
'ๆณธๅทๅธ':'ๅๅท็',
'ๆณธๅท':'ๅๅท็',
'ๅพท้ณๅธ':'ๅๅท็',
'ๅพท้ณ':'ๅๅท็',
'็ปต้ณๅธ':'ๅๅท็',
'็ปต้ณ':'ๅๅท็',
'ๅนฟๅ
ๅธ':'ๅๅท็',
'ๅนฟๅ
':'ๅๅท็',
'้ๅฎๅธ':'ๅๅท็',
'้ๅฎ':'ๅๅท็',
'ๅ
ๆฑๅธ':'ๅๅท็',
'ๅ
ๆฑ':'ๅๅท็',
'ไนๅฑฑๅธ':'ๅๅท็',
'ไนๅฑฑ':'ๅๅท็',
'ๅๅ
ๅธ':'ๅๅท็',
'ๅๅ
':'ๅๅท็',
'็ๅฑฑๅธ':'ๅๅท็',
'็ๅฑฑ':'ๅๅท็',
'ๅฎๅฎพๅธ':'ๅๅท็',
'ๅฎๅฎพ':'ๅๅท็',
'ๅนฟๅฎๅธ':'ๅๅท็',
'ๅนฟๅฎ':'ๅๅท็',
'่พพๅทๅธ':'ๅๅท็',
'่พพๅท':'ๅๅท็',
'้
ๅฎๅธ':'ๅๅท็',
'้
ๅฎ':'ๅๅท็',
'ๅทดไธญๅธ':'ๅๅท็',
'ๅทดไธญ':'ๅๅท็',
'่ต้ณๅธ':'ๅๅท็',
'่ต้ณ':'ๅๅท็',
'้ฟๅ่ๆ็พๆ่ชๆฒปๅท':'ๅๅท็',
'็ๅญ่ๆ่ชๆฒปๅท':'ๅๅท็',
'ๅๅฑฑๅฝๆ่ชๆฒปๅท':'ๅๅท็',
'่ดต้ณๅธ':'่ดตๅท็',
'่ดต้ณ':'่ดตๅท็',
'ๅ
ญ็ๆฐดๅธ':'่ดตๅท็',
'ๅ
ญ็ๆฐด':'่ดตๅท็',
'้ตไนๅธ':'่ดตๅท็',
'้ตไน':'่ดตๅท็',
'ๅฎ้กบๅธ':'่ดตๅท็',
'ๅฎ้กบ':'่ดตๅท็',
'้ไปๅฐๅบ':'่ดตๅท็',
'้ป่ฅฟๅๅธไพๆ่ๆ่ชๆฒปๅท':'่ดตๅท็',
'ๆฏ่ๅฐๅบ':'่ดตๅท็',
'้ปไธๅ่ๆไพๆ่ชๆฒปๅท':'่ดตๅท็',
'้ปๅๅธไพๆ่ๆ่ชๆฒปๅท':'่ดตๅท็',
'ๆๆๅธ':'ไบๅ็',
'ๆๆ':'ไบๅ็',
'ๆฒ้ๅธ':'ไบๅ็',
'ๆฒ้':'ไบๅ็',
'็ๆบชๅธ':'ไบๅ็',
'็ๆบช':'ไบๅ็',
'ไฟๅฑฑๅธ':'ไบๅ็',
'ไฟๅฑฑ':'ไบๅ็',
'ๆญ้ๅธ':'ไบๅ็',
'ๆญ้':'ไบๅ็',
'ไธฝๆฑๅธ':'ไบๅ็',
'ไธฝๆฑ':'ไบๅ็',
'ๆ่
ๅธ':'ไบๅ็',
'ๆ่
':'ไบๅ็',
'ไธดๆฒงๅธ':'ไบๅ็',
'ไธดๆฒง':'ไบๅ็',
'ๆฅ้ๅฝๆ่ชๆฒปๅท':'ไบๅ็',
'็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท':'ไบๅ็',
'ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท':'ไบๅ็',
'่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅท':'ไบๅ็',
'ๅคง็็ฝๆ่ชๆฒปๅท':'ไบๅ็',
'ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท':'ไบๅ็',
'ๆๆฑๅๅณๆ่ชๆฒปๅท':'ไบๅ็',
'่ฟชๅบ่ๆ่ชๆฒปๅท':'ไบๅ็',
'ๆ่จๅธ':'่ฅฟ่่ชๆฒปๅบ',
'ๆ่จ':'่ฅฟ่่ชๆฒปๅบ',
'ๆ้ฝๅฐๅบ':'่ฅฟ่่ชๆฒปๅบ',
'ๅฑฑๅๅฐๅบ':'่ฅฟ่่ชๆฒปๅบ',
'ๆฅๅๅๅฐๅบ':'่ฅฟ่่ชๆฒปๅบ',
'้ฃๆฒๅฐๅบ':'่ฅฟ่่ชๆฒปๅบ',
'้ฟ้ๅฐๅบ':'่ฅฟ่่ชๆฒปๅบ',
'ๆ่ๅฐๅบ':'่ฅฟ่่ชๆฒปๅบ',
'่ฅฟๅฎๅธ':'้่ฅฟ็',
'่ฅฟๅฎ':'้่ฅฟ็',
'้ๅทๅธ':'้่ฅฟ็',
'้ๅท':'้่ฅฟ็',
'ๅฎ้ธกๅธ':'้่ฅฟ็',
'ๅฎ้ธก':'้่ฅฟ็',
'ๅธ้ณๅธ':'้่ฅฟ็',
'ๅธ้ณ':'้่ฅฟ็',
'ๆธญๅๅธ':'้่ฅฟ็',
'ๆธญๅ':'้่ฅฟ็',
'ๅปถๅฎๅธ':'้่ฅฟ็',
'ๅปถๅฎ':'้่ฅฟ็',
'ๆฑไธญๅธ':'้่ฅฟ็',
'ๆฑไธญ':'้่ฅฟ็',
'ๆฆๆๅธ':'้่ฅฟ็',
'ๆฆๆ':'้่ฅฟ็',
'ๅฎๅบทๅธ':'้่ฅฟ็',
'ๅฎๅบท':'้่ฅฟ็',
'ๅๆดๅธ':'้่ฅฟ็',
'ๅๆด':'้่ฅฟ็',
'ๅ
ฐๅทๅธ':'็่็',
'ๅ
ฐๅท':'็่็',
'ๅๅณชๅ
ณๅธ':'็่็',
'ๅๅณชๅ
ณ':'็่็',
'้ๆๅธ':'็่็',
'้ๆ':'็่็',
'็ฝ้ถๅธ':'็่็',
'็ฝ้ถ':'็่็',
'ๅคฉๆฐดๅธ':'็่็',
'ๅคฉๆฐด':'็่็',
'ๆญฆๅจๅธ':'็่็',
'ๆญฆๅจ':'็่็',
'ๅผ ๆๅธ':'็่็',
'ๅผ ๆ':'็่็',
'ๅนณๅๅธ':'็่็',
'ๅนณๅ':'็่็',
'้
ๆณๅธ':'็่็',
'้
ๆณ':'็่็',
'ๅบ้ณๅธ':'็่็',
'ๅบ้ณ':'็่็',
'ๅฎ่ฅฟๅธ':'็่็',
'ๅฎ่ฅฟ':'็่็',
'้ๅๅธ':'็่็',
'้ๅ':'็่็',
'ไธดๅคๅๆ่ชๆฒปๅท':'็่็',
'็ๅ่ๆ่ชๆฒปๅท':'็่็',
'่ฅฟๅฎๅธ':'้ๆตท็',
'่ฅฟๅฎ':'้ๆตท็',
'ๆตทไธๅฐๅบ':'้ๆตท็',
'ๆตทๅ่ๆ่ชๆฒปๅท':'้ๆตท็',
'้ปๅ่ๆ่ชๆฒปๅท':'้ๆตท็',
'ๆตทๅ่ๆ่ชๆฒปๅท':'้ๆตท็',
'ๆๆด่ๆ่ชๆฒปๅท':'้ๆตท็',
'็ๆ ่ๆ่ชๆฒปๅท':'้ๆตท็',
'ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท':'้ๆตท็',
'้ถๅทๅธ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'้ถๅท':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'็ณๅดๅฑฑๅธ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'็ณๅดๅฑฑ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ๅดๅฟ ๅธ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ๅดๅฟ ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ๅบๅๅธ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ๅบๅ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ไธญๅซๅธ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ไธญๅซ':'ๅฎๅคๅๆ่ชๆฒปๅบ',
'ไน้ฒๆจ้ฝๅธ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ไน้ฒๆจ้ฝ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅ
ๆ็ไพๅธ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅ
ๆ็ไพ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅ้ฒ็ชๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅๅฏๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๆๅๅๆ่ชๆฒปๅท':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅๅฐๅกๆ่ๅค่ชๆฒปๅท':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'้ฟๅ
่ๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅ
ๅญๅ่ๆฏๅฐๅ
ๅญ่ชๆฒปๅท':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅไปๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅ็ฐๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ไผ็ๅ่จๅ
่ชๆฒปๅท':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'ๅกๅๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'้ฟๅๆณฐๅฐๅบ':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
'659000':'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ',
}
province_country_mapper = {
'ๅไบฌๅธ':'ไธญๅฝ',
'ๅไบฌ':'ไธญๅฝ',
'ๅคฉๆดฅๅธ':'ไธญๅฝ',
'ๅคฉๆดฅ':'ไธญๅฝ',
'ๆฒณๅ็':'ไธญๅฝ',
'ๆฒณๅ':'ไธญๅฝ',
'ๅฑฑ่ฅฟ็':'ไธญๅฝ',
'ๅฑฑ่ฅฟ':'ไธญๅฝ',
'ๅ
่ๅค่ชๆฒปๅบ':'ไธญๅฝ',
'่พฝๅฎ็':'ไธญๅฝ',
'่พฝๅฎ':'ไธญๅฝ',
'ๅๆ็':'ไธญๅฝ',
'ๅๆ':'ไธญๅฝ',
'้ป้พๆฑ็':'ไธญๅฝ',
'้ป้พๆฑ':'ไธญๅฝ',
'ไธๆตทๅธ':'ไธญๅฝ',
'ไธๆตท':'ไธญๅฝ',
'ๆฑ่็':'ไธญๅฝ',
'ๆฑ่':'ไธญๅฝ',
'ๆตๆฑ็':'ไธญๅฝ',
'ๆตๆฑ':'ไธญๅฝ',
'ๅฎๅพฝ็':'ไธญๅฝ',
'ๅฎๅพฝ':'ไธญๅฝ',
'็ฆๅปบ็':'ไธญๅฝ',
'็ฆๅปบ':'ไธญๅฝ',
'ๆฑ่ฅฟ็':'ไธญๅฝ',
'ๆฑ่ฅฟ':'ไธญๅฝ',
'ๅฑฑไธ็':'ไธญๅฝ',
'ๅฑฑไธ':'ไธญๅฝ',
'ๆฒณๅ็':'ไธญๅฝ',
'ๆฒณๅ':'ไธญๅฝ',
'ๆนๅ็':'ไธญๅฝ',
'ๆนๅ':'ไธญๅฝ',
'ๆนๅ็':'ไธญๅฝ',
'ๆนๅ':'ไธญๅฝ',
'ๅนฟไธ็':'ไธญๅฝ',
'ๅนฟไธ':'ไธญๅฝ',
'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ':'ไธญๅฝ',
'ๆตทๅ็':'ไธญๅฝ',
'ๆตทๅ':'ไธญๅฝ',
'้ๅบๅธ':'ไธญๅฝ',
'้ๅบ':'ไธญๅฝ',
'ๅๅท็':'ไธญๅฝ',
'ๅๅท':'ไธญๅฝ',
'่ดตๅท็':'ไธญๅฝ',
'่ดตๅท':'ไธญๅฝ',
'ไบๅ็':'ไธญๅฝ',
'ไบๅ':'ไธญๅฝ',
'่ฅฟ่่ชๆฒปๅบ':'ไธญๅฝ',
'้่ฅฟ็':'ไธญๅฝ',
'้่ฅฟ':'ไธญๅฝ',
'็่็':'ไธญๅฝ',
'็่':'ไธญๅฝ',
'้ๆตท็':'ไธญๅฝ',
'้ๆตท':'ไธญๅฝ',
'ๅฎๅคๅๆ่ชๆฒปๅบ':'ไธญๅฝ',
'ๆฐ็็ปดๅพๅฐ่ชๆฒปๅบ':'ไธญๅฝ',
'ๅฐๆนพ็':'ไธญๅฝ',
'ๅฐๆนพ':'ไธญๅฝ',
'้ฆๆธฏ็นๅซ่กๆฟๅบ':'ไธญๅฝ',
'ๆพณ้จ็นๅซ่กๆฟๅบ':'ไธญๅฝ',
}
#
# #(็,ๅธ,ๅบ):(็บฌๅบฆ,็ปๅบฆ)
# lat_lon_mapper = {
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅไบฌๅธ':(39.9,116.4),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅคฉๅฎ้จ':(39.9,116.38),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ไธๅๅบ':(39.93,116.42),
# 'ๅไบฌๅธ,ๅไบฌๅธ,่ฅฟๅๅบ':(39.92,116.37),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅดๆๅบ':(39.88,116.43),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅฎฃๆญฆๅบ':(39.87,116.35),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๆ้ณๅบ':(39.92,116.43),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ไธฐๅฐๅบ':(39.85,116.28),
# 'ๅไบฌๅธ,ๅไบฌๅธ,็ณๆฏๅฑฑๅบ':(39.9,116.22),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๆตทๆทๅบ':(39.95,116.3),
# 'ๅไบฌๅธ,ๅไบฌๅธ,้จๅคดๆฒๅบ':(39.93,116.1),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๆฟๅฑฑๅบ':(39.75,116.13),
# 'ๅไบฌๅธ,ๅไบฌๅธ,้ๅทๅบ':(39.92,116.65),
# 'ๅไบฌๅธ,ๅไบฌๅธ,้กบไนๅบ':(40.13,116.65),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๆๅนณๅบ':(40.22,116.23),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅคงๅ
ดๅบ':(39.73,116.33),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๆๆๅบ':(40.32,116.63),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅนณ่ฐทๅบ':(40.13,117.12),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅฏไบๅฟ':(40.37,116.83),
# 'ๅไบฌๅธ,ๅไบฌๅธ,ๅปถๅบๅฟ':(40.45,115.97),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ':(39.12,117.2),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅๅนณๅบ':(39.12,117.2),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆฒณไธๅบ':(39.12,117.22),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆฒณ่ฅฟๅบ':(39.12,117.22),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅๅผๅบ':(39.13,117.15),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆฒณๅๅบ':(39.15,117.18),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,็บขๆกฅๅบ':(39.17,117.15),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅกๆฒฝๅบ':(39.02,117.65),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆฑๆฒฝๅบ':(39.25,117.8),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅคงๆธฏๅบ':(38.83,117.45),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ไธไธฝๅบ':(39.08,117.3),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,่ฅฟ้ๅบ':(39.13,117.0),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆดฅๅๅบ':(38.98,117.38),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅ่พฐๅบ':(39.22,117.13),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆญฆๆธ
ๅบ':(39.38,117.03),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅฎๅปๅบ':(39.72,117.3),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๆปจๆตทๆฐๅบ':(39.03,117.68),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,ๅฎๆฒณๅฟ':(39.33,117.82),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,้ๆตทๅฟ':(38.93,116.92),
# 'ๅคฉๆดฅๅธ,ๅคฉๆดฅๅธ,่ๅฟ':(40.05,117.4),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,็ณๅฎถๅบๅธ':(38.05,114.52),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,้ฟๅฎๅบ':(38.05,114.52),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆกฅไธๅบ':(38.05,114.5),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆกฅไธๅบ':(40.78,114.9),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆกฅไธๅบ':(37.07,114.5),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆกฅ่ฅฟๅบ':(37.05,114.47),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆกฅ่ฅฟๅบ':(40.83,114.87),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆกฅ่ฅฟๅบ':(38.03,114.47),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆฐๅๅบ':(38.05,114.47),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆฐๅๅบ':(38.32,116.87),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ไบ้็ฟๅบ':(38.08,114.05),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,่ฃๅๅบ':(38.02,114.52),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ไบ้ๅฟ':(38.03,114.13),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆญฃๅฎๅฟ':(38.15,114.57),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆ พๅๅฟ':(37.88,114.65),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,่กๅๅฟ':(38.43,114.55),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,็ตๅฏฟๅฟ':(38.3,114.37),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,้ซ้ๅฟ':(37.6,114.6),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆทฑๆณฝๅฟ':(38.18,115.2),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,่ต็ๅฟ':(37.67,114.38),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆ ๆๅฟ':(38.18,114.97),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๅนณๅฑฑๅฟ':(38.25,114.2),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๅ
ๆฐๅฟ':(37.75,114.52),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,่ตตๅฟ':(37.75,114.77),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,่พ้ๅธ':(37.92,115.22),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,่ๅๅธ':(38.03,114.83),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆๅทๅธ':(38.03,115.03),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,ๆฐไนๅธ':(38.35,114.68),
# 'ๆฒณๅ็,็ณๅฎถๅบๅธ,้นฟๆณๅธ':(38.08,114.3),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ๅๅฑฑๅธ':(39.63,118.2),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,่ทฏๅๅบ':(39.63,118.17),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,่ทฏๅๅบ':(39.63,118.22),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ๅคๅถๅบ':(39.73,118.42),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ๅผๅนณๅบ':(39.68,118.27),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ไธฐๅๅบ':(39.57,118.1),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ไธฐๆถฆๅบ':(39.83,118.17),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ๆปฆๅฟ':(39.75,118.7),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ๆปฆๅๅฟ':(39.5,118.68),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ไนไบญๅฟ':(39.42,118.9),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,่ฟ่ฅฟๅฟ':(40.15,118.32),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,็็ฐๅฟ':(39.88,117.73),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,ๅๆตทๅฟ':(39.27,118.45),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,้ตๅๅธ':(40.18,117.95),
# 'ๆฒณๅ็,ๅๅฑฑๅธ,่ฟๅฎๅธ':(40.02,118.7),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,็งฆ็ๅฒๅธ':(39.93,119.6),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,ๆตทๆธฏๅบ':(39.93,119.6),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,ๅฑฑๆตทๅ
ณๅบ':(40.0,119.77),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,ๅๆดๆฒณๅบ':(39.83,119.48),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,้้พๆปกๆ่ชๆฒปๅฟ':(40.4,118.95),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,ๆ้ปๅฟ':(39.7,119.17),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,ๆๅฎๅฟ':(39.88,119.23),
# 'ๆฒณๅ็,็งฆ็ๅฒๅธ,ๅข้พๅฟ':(39.88,118.87),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ฏ้ธๅธ':(36.62,114.48),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ฏๅฑฑๅบ':(36.6,114.48),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ไธๅฐๅบ':(36.63,114.48),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๅคๅ
ดๅบ':(36.63,114.45),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๅณฐๅณฐ็ฟๅบ':(36.42,114.2),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ฏ้ธๅฟ':(36.6,114.53),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ไธดๆผณๅฟ':(36.35,114.62),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๆๅฎๅฟ':(36.43,114.68),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๅคงๅๅฟ':(36.28,115.15),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๆถๅฟ':(36.57,113.67),
# 'ๆฒณๅ็,้ฏ้ธๅธ,็ฃๅฟ':(36.35,114.37),
# 'ๆฒณๅ็,้ฏ้ธๅธ,่ฅไนกๅฟ':(36.55,114.8),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๆฐธๅนดๅฟ':(36.78,114.48),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ฑๅฟ':(36.82,115.17),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ธกๆณฝๅฟ':(36.92,114.87),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๅนฟๅนณๅฟ':(36.48,114.93),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ฆ้ถๅฟ':(36.53,115.3),
# 'ๆฒณๅ็,้ฏ้ธๅธ,้ญๅฟ':(36.37,114.93),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๆฒๅจๅฟ':(36.78,114.95),
# 'ๆฒณๅ็,้ฏ้ธๅธ,ๆญฆๅฎๅธ':(36.7,114.2),
# 'ๆฒณๅ็,้ขๅฐๅธ,้ขๅฐๅธ':(37.07,114.48),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆกฅไธๅบ':(38.05,114.5),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆกฅไธๅบ':(40.78,114.9),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆกฅไธๅบ':(37.07,114.5),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆกฅ่ฅฟๅบ':(40.83,114.87),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆกฅ่ฅฟๅบ':(38.03,114.47),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆกฅ่ฅฟๅบ':(37.05,114.47),
# 'ๆฒณๅ็,้ขๅฐๅธ,้ขๅฐๅฟ':(37.08,114.5),
# 'ๆฒณๅ็,้ขๅฐๅธ,ไธดๅๅฟ':(37.43,114.5),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅ
ไธๅฟ':(37.3,114.52),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆไนกๅฟ':(37.5,114.68),
# 'ๆฒณๅ็,้ขๅฐๅธ,้ๅฐงๅฟ':(37.35,114.77),
# 'ๆฒณๅ็,้ขๅฐๅธ,ไปปๅฟ':(37.13,114.68),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅๅๅฟ':(37.0,114.68),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅฎๆๅฟ':(37.62,114.92),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅทจ้นฟๅฟ':(37.22,115.03),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆฐๆฒณๅฟ':(37.53,115.25),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅนฟๅฎๅฟ':(37.07,115.15),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅนณไนกๅฟ':(37.07,115.03),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅจๅฟ':(36.98,115.25),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆธ
ๆฒณๅฟ':(37.07,115.67),
# 'ๆฒณๅ็,้ขๅฐๅธ,ไธด่ฅฟๅฟ':(36.85,115.5),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๅๅฎซๅธ':(37.35,115.38),
# 'ๆฒณๅ็,้ขๅฐๅธ,ๆฒๆฒณๅธ':(36.85,114.5),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ไฟๅฎๅธ':(38.87,115.47),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆฐๅธๅบ':(38.87,115.45),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅๅธๅบ':(38.87,115.48),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅๅธๅบ':(38.85,115.5),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆปกๅๅฟ':(38.95,115.32),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆธ
่ๅฟ':(38.77,115.48),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆถๆฐดๅฟ':(39.4,115.72),
# 'ๆฒณๅ็,ไฟๅฎๅธ,้ๅนณๅฟ':(38.85,114.18),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅพๆฐดๅฟ':(39.02,115.65),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅฎๅ
ดๅฟ':(39.27,115.77),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅๅฟ':(38.75,114.98),
# 'ๆฒณๅ็,ไฟๅฎๅธ,้ซ้ณๅฟ':(38.68,115.78),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅฎนๅๅฟ':(39.05,115.87),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆถๆบๅฟ':(39.35,114.68),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆ้ฝๅฟ':(38.72,115.15),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅฎๆฐๅฟ':(38.92,115.93),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆๅฟ':(39.35,115.5),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆฒ้ณๅฟ':(38.62,114.7),
# 'ๆฒณๅ็,ไฟๅฎๅธ,่ กๅฟ':(38.48,115.57),
# 'ๆฒณๅ็,ไฟๅฎๅธ,้กบๅนณๅฟ':(38.83,115.13),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅ้ๅฟ':(38.45,115.47),
# 'ๆฒณๅ็,ไฟๅฎๅธ,้ๅฟ':(38.98,116.1),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๆถฟๅทๅธ':(39.48,115.97),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅฎๅทๅธ':(38.52,114.97),
# 'ๆฒณๅ็,ไฟๅฎๅธ,ๅฎๅฝๅธ':(38.42,115.32),
# 'ๆฒณๅ็,ไฟๅฎๅธ,้ซ็ขๅบๅธ':(39.33,115.85),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅผ ๅฎถๅฃๅธ':(40.82,114.88),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆกฅไธๅบ':(38.05,114.5),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆกฅไธๅบ':(40.78,114.9),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆกฅไธๅบ':(37.07,114.5),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆกฅ่ฅฟๅบ':(40.83,114.87),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆกฅ่ฅฟๅบ':(38.03,114.47),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆกฅ่ฅฟๅบ':(37.05,114.47),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅฎฃๅๅบ':(40.6,115.05),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ไธ่ฑๅญๅบ':(40.48,115.27),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅฎฃๅๅฟ':(40.55,115.02),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅผ ๅๅฟ':(41.15,114.7),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅบทไฟๅฟ':(41.85,114.62),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆฒฝๆบๅฟ':(41.67,115.7),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅฐไนๅฟ':(41.08,113.97),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,่ๅฟ':(39.85,114.57),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,้ณๅๅฟ':(40.12,114.17),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆๅฎๅฟ':(40.67,114.42),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ไธๅ
จๅฟ':(40.75,114.72),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆๆฅๅฟ':(40.4,115.52),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๆถฟ้นฟๅฟ':(40.38,115.22),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,่ตคๅๅฟ':(40.92,115.83),
# 'ๆฒณๅ็,ๅผ ๅฎถๅฃๅธ,ๅด็คผๅฟ':(40.97,115.27),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๆฟๅพทๅธ':(40.97,117.93),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๅๆกฅๅบ':(40.97,117.93),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๅๆปฆๅบ':(40.95,117.78),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,้นฐๆ่ฅๅญ็ฟๅบ':(40.55,117.65),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๆฟๅพทๅฟ':(40.77,118.17),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๅ
ด้ๅฟ':(40.43,117.52),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๅนณๆณๅฟ':(41.0,118.68),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๆปฆๅนณๅฟ':(40.93,117.33),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,้ๅๅฟ':(41.32,117.72),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ไธฐๅฎๆปกๆ่ชๆฒปๅฟ':(41.2,116.65),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๅฎฝๅๆปกๆ่ชๆฒปๅฟ':(40.6,118.48),
# 'ๆฒณๅ็,ๆฟๅพทๅธ,ๅดๅบๆปกๆ่ๅคๆ่ชๆฒปๅฟ':(41.93,117.75),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆฒงๅทๅธ':(38.3,116.83),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆฐๅๅบ':(38.05,114.47),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆฐๅๅบ':(38.32,116.87),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,่ฟๆฒณๅบ':(38.32,116.85),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆฒงๅฟ':(38.3,116.87),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,้ๅฟ':(38.58,116.82),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ไธๅ
ๅฟ':(37.88,116.53),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆตทๅ
ดๅฟ':(38.13,117.48),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,็ๅฑฑๅฟ':(38.05,117.22),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,่ๅฎๅฟ':(38.43,115.83),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๅ็ฎๅฟ':(38.03,116.7),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๅดๆกฅๅฟ':(37.62,116.38),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,็ฎๅฟ':(38.18,116.12),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๅญๆๅๆ่ชๆฒปๅฟ':(38.07,117.1),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆณๅคดๅธ':(38.07,116.57),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ไปปไธๅธ':(38.72,116.1),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,้ป้ช
ๅธ':(38.37,117.35),
# 'ๆฒณๅ็,ๆฒงๅทๅธ,ๆฒณ้ดๅธ':(38.43,116.08),
# 'ๆฒณๅ็,ๅปๅๅธ,ๅปๅๅธ':(39.52,116.7),
# 'ๆฒณๅ็,ๅปๅๅธ,ๅฎๆฌกๅบ':(39.52,116.68),
# 'ๆฒณๅ็,ๅปๅๅธ,ๅนฟ้ณๅบ':(39.53,116.72),
# 'ๆฒณๅ็,ๅปๅๅธ,ๅบๅฎๅฟ':(39.43,116.3),
# 'ๆฒณๅ็,ๅปๅๅธ,ๆฐธๆธ
ๅฟ':(39.32,116.5),
# 'ๆฒณๅ็,ๅปๅๅธ,้ฆๆฒณๅฟ':(39.77,117.0),
# 'ๆฒณๅ็,ๅปๅๅธ,ๅคงๅๅฟ':(38.7,116.63),
# 'ๆฒณๅ็,ๅปๅๅธ,ๆๅฎๅฟ':(38.87,116.47),
# 'ๆฒณๅ็,ๅปๅๅธ,ๅคงๅๅๆ่ชๆฒปๅฟ':(39.88,116.98),
# 'ๆฒณๅ็,ๅปๅๅธ,้ธๅทๅธ':(39.1,116.4),
# 'ๆฒณๅ็,ๅปๅๅธ,ไธๆฒณๅธ':(39.98,117.07),
# 'ๆฒณๅ็,่กกๆฐดๅธ,่กกๆฐดๅธ':(37.73,115.68),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆกๅๅบ':(37.73,115.68),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆฃๅผบๅฟ':(37.52,115.72),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆญฆ้ๅฟ':(37.82,115.88),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆญฆๅผบๅฟ':(38.03,115.98),
# 'ๆฒณๅ็,่กกๆฐดๅธ,้ฅถ้ณๅฟ':(38.23,115.73),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๅฎๅนณๅฟ':(38.23,115.52),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆ
ๅๅฟ':(37.35,115.97),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆฏๅฟ':(37.7,116.27),
# 'ๆฒณๅ็,่กกๆฐดๅธ,้ๅๅฟ':(37.87,116.15),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๅๅทๅธ':(37.57,115.57),
# 'ๆฒณๅ็,่กกๆฐดๅธ,ๆทฑๅทๅธ':(38.02,115.55),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๅคชๅๅธ':(37.87,112.55),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๅฐๅบๅบ':(37.73,112.57),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,่ฟๆณฝๅบ':(37.87,112.57),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๆ่ฑๅฒญๅบ':(37.88,112.57),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๅฐ่ๅชๅบ':(37.93,112.48),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ไธๆๆๅบ':(37.87,112.52),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๆๆบๅบ':(37.73,112.48),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๆธ
ๅพๅฟ':(37.6,112.35),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,้ณๆฒๅฟ':(38.07,112.67),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๅจ็ฆๅฟ':(38.07,111.78),
# 'ๅฑฑ่ฅฟ็,ๅคชๅๅธ,ๅคไบคๅธ':(37.92,112.17),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅคงๅๅธ':(40.08,113.3),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅๅบ':(40.08,113.28),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅๅบ':(37.85,113.6),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅๅบ':(36.22,113.12),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅๅบ':(35.5,112.83),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,็ฟๅบ':(40.03,113.17),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,็ฟๅบ':(37.87,113.57),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅ้ๅบ':(40.0,113.13),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๆฐ่ฃๅบ':(40.27,113.15),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,้ณ้ซๅฟ':(40.37,113.75),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅคฉ้ๅฟ':(40.42,114.08),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅนฟ็ตๅฟ':(39.77,114.28),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,็ตไธๅฟ':(39.43,114.23),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๆตๆบๅฟ':(39.7,113.68),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅทฆไบๅฟ':(40.0,112.7),
# 'ๅฑฑ่ฅฟ็,ๅคงๅๅธ,ๅคงๅๅฟ':(40.03,113.6),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,้ณๆณๅธ':(37.85,113.57),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,ๅๅบ':(40.08,113.28),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,ๅๅบ':(37.85,113.6),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,ๅๅบ':(36.22,113.12),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,ๅๅบ':(35.5,112.83),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,็ฟๅบ':(40.03,113.17),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,็ฟๅบ':(37.87,113.57),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,้ๅบ':(37.93,113.58),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,้ๅบ':(36.2,113.12),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,ๅนณๅฎๅฟ':(37.8,113.62),
# 'ๅฑฑ่ฅฟ็,้ณๆณๅธ,็ๅฟ':(38.08,113.4),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,้ฟๆฒปๅธ':(36.2,113.12),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅๅบ':(40.08,113.28),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅๅบ':(37.85,113.6),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅๅบ':(36.22,113.12),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅๅบ':(35.5,112.83),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,้ๅบ':(37.93,113.58),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,้ๅบ':(36.2,113.12),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,้ฟๆฒปๅฟ':(36.05,113.03),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,่ฅๅฃๅฟ':(36.53,113.05),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅฑฏ็ๅฟ':(36.32,112.88),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅนณ้กบๅฟ':(36.2,113.43),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,้ปๅๅฟ':(36.5,113.38),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๅฃถๅ
ณๅฟ':(36.12,113.2),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,้ฟๅญๅฟ':(36.12,112.87),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๆญฆไนกๅฟ':(36.83,112.85),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๆฒๅฟ':(36.75,112.7),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๆฒๆบๅฟ':(36.5,112.33),
# 'ๅฑฑ่ฅฟ็,้ฟๆฒปๅธ,ๆฝๅๅธ':(36.33,113.22),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๆๅๅธ':(35.5,112.83),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๅๅบ':(40.08,113.28),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๅๅบ':(37.85,113.6),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๅๅบ':(36.22,113.12),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๅๅบ':(35.5,112.83),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๆฒๆฐดๅฟ':(35.68,112.18),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,้ณๅๅฟ':(35.48,112.42),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,้ตๅทๅฟ':(35.78,113.27),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,ๆณฝๅทๅฟ':(35.5,112.83),
# 'ๅฑฑ่ฅฟ็,ๆๅๅธ,้ซๅนณๅธ':(35.8,112.92),
# 'ๅฑฑ่ฅฟ็,ๆๅทๅธ,ๆๅทๅธ':(39.33,112.43),
# 'ๅฑฑ่ฅฟ็,ๆๅทๅธ,ๆๅๅบ':(39.33,112.43),
# 'ๅฑฑ่ฅฟ็,ๆๅทๅธ,ๅฑฑ้ดๅฟ':(39.52,112.82),
# 'ๅฑฑ่ฅฟ็,ๆๅทๅธ,ๅบๅฟ':(39.55,113.18),
# 'ๅฑฑ่ฅฟ็,ๆๅทๅธ,ๅณ็ๅฟ':(39.98,112.47),
# 'ๅฑฑ่ฅฟ็,ๆๅทๅธ,ๆไปๅฟ':(39.83,113.08),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๆไธญๅธ':(37.68,112.75),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๆฆๆฌกๅบ':(37.68,112.75),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๆฆ็คพๅฟ':(37.07,112.97),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๅทฆๆๅฟ':(37.07,113.37),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๅ้กบๅฟ':(37.33,113.57),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๆ้ณๅฟ':(37.62,113.7),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๅฏฟ้ณๅฟ':(37.88,113.18),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๅคช่ฐทๅฟ':(37.42,112.55),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,็ฅๅฟ':(37.35,112.33),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ๅนณ้ฅๅฟ':(37.18,112.17),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,็ต็ณๅฟ':(36.85,111.77),
# 'ๅฑฑ่ฅฟ็,ๆไธญๅธ,ไปไผๅธ':(37.03,111.92),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,่ฟๅๅธ':(35.02,110.98),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,็ๆนๅบ':(35.02,110.98),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ไธด็ๅฟ':(35.15,110.77),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ไธ่ฃๅฟ':(35.42,110.83),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,้ปๅๅฟ':(35.35,111.22),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,็จทๅฑฑๅฟ':(35.6,110.97),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ๆฐ็ปๅฟ':(35.62,111.22),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,็ปๅฟ':(35.48,111.57),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ๅฃๆฒๅฟ':(35.3,111.67),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ๅคๅฟ':(35.15,111.22),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ๅนณ้ๅฟ':(34.83,111.22),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,่ฎๅๅฟ':(34.7,110.68),
# 'ๅฑฑ่ฅฟ็,่ฟๅๅธ,ๆฒณๆดฅๅธ':(35.6,110.7),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅฟปๅทๅธ':(38.42,112.73),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅฟปๅบๅบ':(38.42,112.73),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅฎ่ฅๅฟ':(38.48,112.95),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ไบๅฐๅฟ':(38.73,113.25),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ไปฃๅฟ':(39.07,112.95),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,็นๅณๅฟ':(39.18,113.25),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅฎๆญฆๅฟ':(39.0,112.3),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,้ไนๅฟ':(38.37,111.93),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,็ฅๆฑ ๅฟ':(39.08,112.2),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ไบๅฏจๅฟ':(38.9,111.85),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅฒขๅฒๅฟ':(38.7,111.57),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๆฒณๆฒๅฟ':(39.38,111.13),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅๅ
ณๅฟ':(39.43,111.5),
# 'ๅฑฑ่ฅฟ็,ๅฟปๅทๅธ,ๅๅนณๅธ':(38.73,112.7),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ไธดๆฑพๅธ':(36.08,111.52),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๅฐง้ฝๅบ':(36.08,111.52),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๆฒๆฒๅฟ':(35.63,111.47),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,็ฟผๅๅฟ':(35.73,111.72),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,่ฅๆฑพๅฟ':(35.88,111.43),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๆดชๆดๅฟ':(36.25,111.67),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๅคๅฟ':(36.27,111.92),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๅฎๆณฝๅฟ':(36.15,112.25),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๆตฎๅฑฑๅฟ':(35.97,111.83),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๅๅฟ':(36.1,110.68),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ไนกๅฎๅฟ':(35.97,110.83),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๅคงๅฎๅฟ':(36.47,110.75),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,้ฐๅฟ':(36.7,110.93),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๆฐธๅๅฟ':(36.77,110.63),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,่ฒๅฟ':(36.42,111.08),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ๆฑพ่ฅฟๅฟ':(36.65,111.57),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,ไพฏ้ฉฌๅธ':(35.62,111.35),
# 'ๅฑฑ่ฅฟ็,ไธดๆฑพๅธ,้ๅทๅธ':(36.57,111.72),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๅๆขๅธ':(37.52,111.13),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,็ฆป็ณๅบ':(37.52,111.13),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๆๆฐดๅฟ':(37.43,112.02),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ไบคๅๅฟ':(37.55,112.15),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๅ
ดๅฟ':(38.47,111.12),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ไธดๅฟ':(37.95,110.98),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๆณๆๅฟ':(37.43,110.9),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,็ณๆฅผๅฟ':(37.0,110.83),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๅฒๅฟ':(38.28,111.67),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๆนๅฑฑๅฟ':(37.88,111.23),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ไธญ้ณๅฟ':(37.33,111.18),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ไบคๅฃๅฟ':(36.97,111.2),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๅญไนๅธ':(37.15,111.77),
# 'ๅฑฑ่ฅฟ็,ๅๆขๅธ,ๆฑพ้ณๅธ':(37.27,111.78),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๅผๅๆตฉ็นๅธ':(40.83,111.73),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๆฐๅๅบ':(40.87,111.65),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๅๆฐๅบ':(40.8,111.6),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,็ๆณๅบ':(40.75,111.67),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,่ต็ฝๅบ':(40.8,111.68),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๅ้ป็นๅทฆๆ':(40.72,111.13),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๆๅ
ๆๅฟ':(40.27,111.18),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๅๆๆ ผๅฐๅฟ':(40.38,111.82),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๆธ
ๆฐดๆฒณๅฟ':(39.92,111.68),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผๅๆตฉ็นๅธ,ๆญฆๅทๅฟ':(41.08,111.45),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,ๅ
ๅคดๅธ':(40.65,109.83),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,ไธๆฒณๅบ':(40.58,110.02),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,ๆ้ฝไปๅบ':(40.63,109.83),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,้ๅฑฑๅบ':(40.65,109.9),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,็ณๆๅบ':(40.68,110.27),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,ไนๅๅบ':(40.6,109.97),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,ๅ้ป็นๅณๆ':(40.57,110.52),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,ๅบ้ณๅฟ':(41.03,110.05),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ๅคดๅธ,่พพๅฐ็ฝ่ๆๅฎ่ๅๆ':(41.7,110.43),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๆตทๅธ,ไนๆตทๅธ':(39.67,106.82),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๆตทๅธ,ๆตทๅๆนพๅบ':(39.7,106.83),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๆตทๅธ,ๆตทๅๅบ':(39.43,106.88),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๆตทๅธ,ไน่พพๅบ':(39.5,106.7),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,่ตคๅณฐๅธ':(42.27,118.92),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,็บขๅฑฑๅบ':(42.28,118.97),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๅ
ๅฎๅฑฑๅบ':(42.03,119.28),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๆพๅฑฑๅบ':(42.28,118.92),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,้ฟ้ฒ็งๅฐๆฒๆ':(43.88,120.08),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๅทดๆๅทฆๆ':(43.98,119.38),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๅทดๆๅณๆ':(43.52,118.67),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๆ่ฅฟๅฟ':(43.6,118.05),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๅ
ไปๅ
่
พๆ':(43.25,117.53),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,็ฟ็็นๆ':(42.93,119.02),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๅๅๆฒๆ':(41.93,118.7),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๅฎๅๅฟ':(41.6,119.33),
# 'ๅ
่ๅค่ชๆฒปๅบ,่ตคๅณฐๅธ,ๆๆฑๆ':(42.28,119.9),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,้่พฝๅธ':(43.62,122.27),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,็งๅฐๆฒๅบ':(43.62,122.27),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,็งๅฐๆฒๅทฆ็ฟผไธญๆ':(44.13,123.32),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,็งๅฐๆฒๅทฆ็ฟผๅๆ':(42.95,122.35),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,ๅผ้ฒๅฟ':(43.6,121.3),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,ๅบไผฆๆ':(42.73,121.77),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,ๅฅๆผๆ':(42.85,120.65),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,ๆ้ฒ็นๆ':(44.55,120.92),
# 'ๅ
่ๅค่ชๆฒปๅบ,้่พฝๅธ,้ๆ้ญๅๅธ':(45.53,119.65),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,้ๅฐๅคๆฏๅธ':(39.62,109.8),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,ไธ่ๅบ':(39.82,110.0),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,่พพๆ็นๆ':(40.4,110.03),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,ๅๆ ผๅฐๆ':(39.87,111.23),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,้ๆๅ
ๅๆ':(38.18,107.48),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,้ๆๅ
ๆ':(39.1,107.98),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,ๆญ้ฆๆ':(39.83,108.72),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,ไนๅฎกๆ':(38.6,108.85),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ๅฐๅคๆฏๅธ,ไผ้้ๆดๆ':(39.57,109.73),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๅผไผฆ่ดๅฐๅธ':(49.22,119.77),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๆตทๆๅฐๅบ':(49.22,119.77),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,้ฟ่ฃๆ':(48.13,123.47),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,้ไผฆๆฅ่ชๆฒปๆ':(50.58,123.72),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,้ๆธฉๅ
ๆ่ชๆฒปๆ':(49.13,119.75),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,้ๅทดๅฐ่ๆ':(49.32,119.43),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๆฐๅทดๅฐ่ๅทฆๆ':(48.22,118.27),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๆฐๅทดๅฐ่ๅณๆ':(48.67,116.82),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๆปกๆดฒ้ๅธ':(49.58,117.45),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,็ๅ
็ณๅธ':(49.28,120.73),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๆๅ
ฐๅฑฏๅธ':(47.98,122.75),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,้ขๅฐๅค็บณๅธ':(50.23,120.18),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅผไผฆ่ดๅฐๅธ,ๆ นๆฒณๅธ':(50.78,121.52),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ๅทดๅฝฆๆทๅฐๅธ':(40.75,107.42),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ไธดๆฒณๅบ':(40.75,107.4),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ไบๅๅฟ':(41.1,108.27),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,็ฃดๅฃๅฟ':(40.33,107.02),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ไนๆ็นๅๆ':(40.72,108.65),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ไนๆ็นไธญๆ':(41.57,108.52),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ไนๆ็นๅๆ':(41.1,107.07),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅทดๅฝฆๆทๅฐๅธ,ๆญ้ฆๅๆ':(40.88,107.15),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ไนๅ
ฐๅฏๅธๅธ':(40.98,113.12),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,้ๅฎๅบ':(41.03,113.1),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅ่ตๅฟ':(40.9,112.57),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅๅพทๅฟ':(41.9,114.0),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅ้ฝๅฟ':(41.55,113.53),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅ
ดๅๅฟ':(40.88,113.88),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅๅๅฟ':(40.53,112.48),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅฏๅๅฐๅณ็ฟผๅๆ':(40.78,113.22),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅฏๅๅฐๅณ็ฟผไธญๆ':(41.27,112.63),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅฏๅๅฐๅณ็ฟผๅๆ':(41.45,113.18),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ๅๅญ็ๆ':(41.52,111.7),
# 'ๅ
่ๅค่ชๆฒปๅบ,ไนๅ
ฐๅฏๅธๅธ,ไธฐ้ๅธ':(40.43,113.15),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,ๅ
ดๅฎ็':(46.08,122.05),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,ไนๅ
ฐๆตฉ็นๅธ':(46.08,122.05),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,้ฟๅฐๅฑฑๅธ':(47.18,119.93),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,็งๅฐๆฒๅณ็ฟผๅๆ':(46.07,121.92),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,็งๅฐๆฒๅณ็ฟผไธญๆ':(45.05,121.47),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,ๆ่ต็นๆ':(46.73,122.9),
# 'ๅ
่ๅค่ชๆฒปๅบ,ๅ
ดๅฎ็ๅธ,็ชๆณๅฟ':(45.38,121.57),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,้กๆ้ญๅ็':(43.95,116.07),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,ไบ่ฟๆตฉ็นๅธ':(43.65,111.98),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,้กๆๆตฉ็นๅธ':(43.93,116.07),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,้ฟๅทดๅๆ':(44.02,114.97),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,่ๅฐผ็นๅทฆๆ':(43.85,113.63),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,่ๅฐผ็นๅณๆ':(42.75,112.65),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,ไธไน็ ็ฉๆฒๆ':(45.52,116.97),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,่ฅฟไน็ ็ฉๆฒๆ':(44.58,117.6),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,ๅคชไปๅฏบๆ':(41.9,115.28),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,้ถ้ปๆ':(42.23,113.83),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,ๆญฃ้ถ็ฝๆ':(42.3,115.0),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,ๆญฃ่ๆ':(42.25,116.0),
# 'ๅ
่ๅค่ชๆฒปๅบ,้กๆ้ญๅ็ๅธ,ๅคไผฆๅฟ':(42.18,116.47),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ฟๆๅ็ๅธ,้ฟๆๅ็':(38.83,105.67),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ฟๆๅ็ๅธ,้ฟๆๅๅทฆๆ':(38.83,105.67),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ฟๆๅ็ๅธ,้ฟๆๅๅณๆ':(39.2,101.68),
# 'ๅ
่ๅค่ชๆฒปๅบ,้ฟๆๅ็ๅธ,้ขๆต็บณๆ':(41.97,101.07),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๆฒ้ณๅธ':(41.8,123.43),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๅๅนณๅบ':(41.78,123.4),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๆฒๆฒณๅบ':(41.8,123.45),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๅคงไธๅบ':(41.8,123.47),
# '่พฝๅฎ็,ๆฒ้ณๅธ,็ๅงๅบ':(41.82,123.42),
# '่พฝๅฎ็,ๆฒ้ณๅธ,้่ฅฟๅบ':(41.12,122.95),
# '่พฝๅฎ็,ๆฒ้ณๅธ,้่ฅฟๅบ':(41.8,123.35),
# '่พฝๅฎ็,ๆฒ้ณๅธ,่ๅฎถๅฑฏๅบ':(41.67,123.33),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ไธ้ตๅบ':(41.77,123.47),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๆฐๅๅญๅบ':(42.05,123.52),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ไบๆดชๅบ':(41.78,123.3),
# '่พฝๅฎ็,ๆฒ้ณๅธ,่พฝไธญๅฟ':(41.52,122.72),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๅบทๅนณๅฟ':(42.75,123.35),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๆณๅบๅฟ':(42.5,123.4),
# '่พฝๅฎ็,ๆฒ้ณๅธ,ๆฐๆฐๅธ':(42.0,122.82),
# '่พฝๅฎ็,ๅคง่ฟๅธ,ๅคง่ฟๅธ':(38.92,121.62),
# '่พฝๅฎ็,ๅคง่ฟๅธ,ไธญๅฑฑๅบ':(38.92,121.63),
# '่พฝๅฎ็,ๅคง่ฟๅธ,่ฅฟๅฒๅบ':(38.92,121.6),
# '่พฝๅฎ็,ๅคง่ฟๅธ,ๆฒๆฒณๅฃๅบ':(38.9,121.58),
# '่พฝๅฎ็,ๅคง่ฟๅธ,็ไบๅญๅบ':(38.95,121.57),
# '่พฝๅฎ็,ๅคง่ฟๅธ,ๆ
้กบๅฃๅบ':(38.82,121.27),
# '่พฝๅฎ็,ๅคง่ฟๅธ,้ๅทๅบ':(39.1,121.7),
# '่พฝๅฎ็,ๅคง่ฟๅธ,้ฟๆตทๅฟ':(39.27,122.58),
# '่พฝๅฎ็,ๅคง่ฟๅธ,็ฆๆฟๅบๅธ':(39.62,122.0),
# '่พฝๅฎ็,ๅคง่ฟๅธ,ๆฎๅ
ฐๅบๅธ':(39.4,121.95),
# '่พฝๅฎ็,ๅคง่ฟๅธ,ๅบๆฒณๅธ':(39.7,122.98),
# '่พฝๅฎ็,้ๅฑฑๅธ,้ๅฑฑๅธ':(41.1,122.98),
# '่พฝๅฎ็,้ๅฑฑๅธ,้ไธๅบ':(41.1,122.98),
# '่พฝๅฎ็,้ๅฑฑๅธ,้่ฅฟๅบ':(41.12,122.95),
# '่พฝๅฎ็,้ๅฑฑๅธ,้่ฅฟๅบ':(41.8,123.35),
# '่พฝๅฎ็,้ๅฑฑๅธ,็ซๅฑฑๅบ':(41.15,123.0),
# '่พฝๅฎ็,้ๅฑฑๅธ,ๅๅฑฑๅบ':(41.07,122.97),
# '่พฝๅฎ็,้ๅฑฑๅธ,ๅฐๅฎๅฟ':(41.38,122.42),
# '่พฝๅฎ็,้ๅฑฑๅธ,ๅฒซๅฒฉๆปกๆ่ชๆฒปๅฟ':(40.28,123.28),
# '่พฝๅฎ็,้ๅฑฑๅธ,ๆตทๅๅธ':(40.88,122.7),
# '่พฝๅฎ็,ๆ้กบๅธ,ๆ้กบๅธ':(41.88,123.98),
# '่พฝๅฎ็,ๆ้กบๅธ,ๆฐๆๅบ':(41.87,123.88),
# '่พฝๅฎ็,ๆ้กบๅธ,ไธๆดฒๅบ':(41.85,124.02),
# '่พฝๅฎ็,ๆ้กบๅธ,ๆ่ฑๅบ':(41.85,123.78),
# '่พฝๅฎ็,ๆ้กบๅธ,้กบๅๅบ':(41.88,123.93),
# '่พฝๅฎ็,ๆ้กบๅธ,ๆ้กบๅฟ':(41.88,123.9),
# '่พฝๅฎ็,ๆ้กบๅธ,ๆฐๅฎพๆปกๆ่ชๆฒปๅฟ':(41.73,125.03),
# '่พฝๅฎ็,ๆ้กบๅธ,ๆธ
ๅๆปกๆ่ชๆฒปๅฟ':(42.1,124.92),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๆฌๆบชๅธ':(41.3,123.77),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๅนณๅฑฑๅบ':(41.3,123.77),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๆบชๆนๅบ':(41.33,123.77),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๆๅฑฑๅบ':(41.3,123.82),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๅ่ฌๅบ':(41.1,123.73),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๆฌๆบชๆปกๆ่ชๆฒปๅฟ':(41.3,124.12),
# '่พฝๅฎ็,ๆฌๆบชๅธ,ๆกไปๆปกๆ่ชๆฒปๅฟ':(41.27,125.35),
# '่พฝๅฎ็,ไธนไธๅธ,ไธนไธๅธ':(40.13,124.38),
# '่พฝๅฎ็,ไธนไธๅธ,ๅ
ๅฎๅบ':(40.13,124.38),
# '่พฝๅฎ็,ไธนไธๅธ,ๆฏๅ
ดๅบ':(40.08,124.35),
# '่พฝๅฎ็,ไธนไธๅธ,ๆฏๅฎๅบ':(40.17,124.42),
# '่พฝๅฎ็,ไธนไธๅธ,ๅฎฝ็ธๆปกๆ่ชๆฒปๅฟ':(40.73,124.78),
# '่พฝๅฎ็,ไธนไธๅธ,ไธๆธฏๅธ':(39.87,124.15),
# '่พฝๅฎ็,ไธนไธๅธ,ๅคๅๅธ':(40.45,124.07),
# '่พฝๅฎ็,้ฆๅทๅธ,้ฆๅทๅธ':(41.1,121.13),
# '่พฝๅฎ็,้ฆๅทๅธ,ๅคๅกๅบ':(41.13,121.12),
# '่พฝๅฎ็,้ฆๅทๅธ,ๅๆฒณๅบ':(41.12,121.15),
# '่พฝๅฎ็,้ฆๅทๅธ,ๅคชๅๅบ':(41.1,121.1),
# '่พฝๅฎ็,้ฆๅทๅธ,้ปๅฑฑๅฟ':(41.7,122.12),
# '่พฝๅฎ็,้ฆๅทๅธ,ไนๅฟ':(41.53,121.23),
# '่พฝๅฎ็,้ฆๅทๅธ,ๅๆตทๅธ':(41.17,121.35),
# '่พฝๅฎ็,่ฅๅฃๅธ,่ฅๅฃๅธ':(40.67,122.23),
# '่พฝๅฎ็,่ฅๅฃๅธ,็ซๅๅบ':(40.68,122.27),
# '่พฝๅฎ็,่ฅๅฃๅธ,่ฅฟๅธๅบ':(40.67,122.22),
# '่พฝๅฎ็,่ฅๅฃๅธ,้ฒ
้ฑผๅๅบ':(40.27,122.12),
# '่พฝๅฎ็,่ฅๅฃๅธ,่่พนๅบ':(40.67,122.37),
# '่พฝๅฎ็,่ฅๅฃๅธ,็ๅทๅธ':(40.4,122.35),
# '่พฝๅฎ็,่ฅๅฃๅธ,ๅคง็ณๆกฅๅธ':(40.65,122.5),
# '่พฝๅฎ็,้ๆฐๅธ,้ๆฐๅธ':(42.02,121.67),
# '่พฝๅฎ็,้ๆฐๅธ,ๆตทๅทๅบ':(42.02,121.65),
# '่พฝๅฎ็,้ๆฐๅธ,ๅคชๅนณๅบ':(42.02,121.67),
# '่พฝๅฎ็,้ๆฐๅธ,ๆธ
ๆฒณ้จๅบ':(41.75,121.42),
# '่พฝๅฎ็,้ๆฐๅธ,็ปๆฒณๅบ':(42.03,121.68),
# '่พฝๅฎ็,้ๆฐๅธ,้ๆฐ่ๅคๆ่ชๆฒปๅฟ':(42.07,121.75),
# '่พฝๅฎ็,้ๆฐๅธ,ๅฝฐๆญฆๅฟ':(42.38,122.53),
# '่พฝๅฎ็,่พฝ้ณๅธ,่พฝ้ณๅธ':(41.27,123.17),
# '่พฝๅฎ็,่พฝ้ณๅธ,็ฝๅกๅบ':(41.27,123.17),
# '่พฝๅฎ็,่พฝ้ณๅธ,ๆๅฃๅบ':(41.27,123.18),
# '่พฝๅฎ็,่พฝ้ณๅธ,ๅฎไผๅบ':(41.2,123.2),
# '่พฝๅฎ็,่พฝ้ณๅธ,ๅผ้ฟๅฒญๅบ':(41.13,123.45),
# '่พฝๅฎ็,่พฝ้ณๅธ,ๅคชๅญๆฒณๅบ':(41.25,123.18),
# '่พฝๅฎ็,่พฝ้ณๅธ,่พฝ้ณๅฟ':(41.22,123.07),
# '่พฝๅฎ็,่พฝ้ณๅธ,็ฏๅกๅธ':(41.42,123.33),
# '่พฝๅฎ็,็้ฆๅธ,็้ฆๅธ':(41.12,122.07),
# '่พฝๅฎ็,็้ฆๅธ,ๅๅฐๅญๅบ':(41.2,122.05),
# '่พฝๅฎ็,็้ฆๅธ,ๅ
ด้ๅฐๅบ':(41.12,122.07),
# '่พฝๅฎ็,็้ฆๅธ,ๅคงๆดผๅฟ':(40.98,122.07),
# '่พฝๅฎ็,็้ฆๅธ,็ๅฑฑๅฟ':(41.25,122.02),
# '่พฝๅฎ็,้ๅฒญๅธ,้ๅฒญๅธ':(42.28,123.83),
# '่พฝๅฎ็,้ๅฒญๅธ,้ถๅทๅบ':(42.28,123.85),
# '่พฝๅฎ็,้ๅฒญๅธ,ๆธ
ๆฒณๅบ':(42.53,124.15),
# '่พฝๅฎ็,้ๅฒญๅธ,้ๅฒญๅฟ':(42.3,123.83),
# '่พฝๅฎ็,้ๅฒญๅธ,่ฅฟไธฐๅฟ':(42.73,124.72),
# '่พฝๅฎ็,้ๅฒญๅธ,ๆๅพๅฟ':(42.78,124.1),
# '่พฝๅฎ็,้ๅฒญๅธ,่ฐๅ
ตๅฑฑๅธ':(42.47,123.55),
# '่พฝๅฎ็,้ๅฒญๅธ,ๅผๅๅธ':(42.55,124.03),
# '่พฝๅฎ็,ๆ้ณๅธ,ๆ้ณๅธ':(41.57,120.45),
# '่พฝๅฎ็,ๆ้ณๅธ,ๅๅกๅบ':(41.57,120.45),
# '่พฝๅฎ็,ๆ้ณๅธ,้พๅๅบ':(41.6,120.43),
# '่พฝๅฎ็,ๆ้ณๅธ,ๆ้ณๅฟ':(41.58,120.47),
# '่พฝๅฎ็,ๆ้ณๅธ,ๅปบๅนณๅฟ':(41.4,119.63),
# '่พฝๅฎ็,ๆ้ณๅธ,ๅ็ฅจๅธ':(41.8,120.77),
# '่พฝๅฎ็,ๆ้ณๅธ,ๅๆบๅธ':(41.25,119.4),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,่ซ่ฆๅฒๅธ':(40.72,120.83),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,่ฟๅฑฑๅบ':(40.77,120.87),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,้พๆธฏๅบ':(40.72,120.93),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,ๅ็ฅจๅบ':(41.1,120.75),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,็ปฅไธญๅฟ':(40.32,120.33),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,ๅปบๆๅฟ':(40.82,119.8),
# '่พฝๅฎ็,่ซ่ฆๅฒๅธ,ๅ
ดๅๅธ':(40.62,120.72),
# 'ๅๆ็,้ฟๆฅๅธ,้ฟๆฅๅธ':(43.9,125.32),
# 'ๅๆ็,้ฟๆฅๅธ,ๅๅ
ณๅบ':(43.87,125.33),
# 'ๅๆ็,้ฟๆฅๅธ,ๅฎฝๅๅบ':(43.92,125.32),
# 'ๅๆ็,้ฟๆฅๅธ,ๆ้ณๅบ':(43.83,125.28),
# 'ๅๆ็,้ฟๆฅๅธ,ไบ้ๅบ':(43.87,125.37),
# 'ๅๆ็,้ฟๆฅๅธ,็ปฟๅญๅบ':(43.88,125.25),
# 'ๅๆ็,้ฟๆฅๅธ,ๅ้ณๅบ':(43.52,125.67),
# 'ๅๆ็,้ฟๆฅๅธ,ๅๅฎๅฟ':(44.43,125.18),
# 'ๅๆ็,้ฟๆฅๅธ,ไนๅฐๅธ':(44.15,125.83),
# 'ๅๆ็,้ฟๆฅๅธ,ๆฆๆ ๅธ':(44.82,126.55),
# 'ๅๆ็,้ฟๆฅๅธ,ๅพทๆ ๅธ':(44.53,125.7),
# 'ๅๆ็,ๅๆๅธ,ๅๆๅธ':(43.83,126.55),
# 'ๅๆ็,ๅๆๅธ,ๆ้ๅบ':(43.88,126.57),
# 'ๅๆ็,ๅๆๅธ,้พๆฝญๅบ':(43.92,126.57),
# 'ๅๆ็,ๅๆๅธ,่น่ฅๅบ':(43.83,126.53),
# 'ๅๆ็,ๅๆๅธ,ไธฐๆปกๅบ':(43.82,126.57),
# 'ๅๆ็,ๅๆๅธ,ๆฐธๅๅฟ':(43.67,126.5),
# 'ๅๆ็,ๅๆๅธ,่ๆฒณๅธ':(43.72,127.33),
# 'ๅๆ็,ๅๆๅธ,ๆกฆ็ธๅธ':(42.97,126.73),
# 'ๅๆ็,ๅๆๅธ,่ๅ
ฐๅธ':(44.42,126.95),
# 'ๅๆ็,ๅๆๅธ,็ฃ็ณๅธ':(42.95,126.05),
# 'ๅๆ็,ๅๅนณๅธ,ๅๅนณๅธ':(43.17,124.35),
# 'ๅๆ็,ๅๅนณๅธ,้่ฅฟๅบ':(43.15,124.35),
# 'ๅๆ็,ๅๅนณๅธ,้ไธๅบ':(43.17,124.38),
# 'ๅๆ็,ๅๅนณๅธ,ๆขจๆ ๅฟ':(43.32,124.33),
# 'ๅๆ็,ๅๅนณๅธ,ไผ้ๆปกๆ่ชๆฒปๅฟ':(43.35,125.3),
# 'ๅๆ็,ๅๅนณๅธ,ๅ
ฌไธปๅฒญๅธ':(43.5,124.82),
# 'ๅๆ็,ๅๅนณๅธ,ๅ่พฝๅธ':(43.52,123.5),
# 'ๅๆ็,่พฝๆบๅธ,่พฝๆบๅธ':(42.88,125.13),
# 'ๅๆ็,่พฝๆบๅธ,้พๅฑฑๅบ':(42.9,125.12),
# 'ๅๆ็,่พฝๆบๅธ,่ฅฟๅฎๅบ':(42.92,125.15),
# 'ๅๆ็,่พฝๆบๅธ,ไธไธฐๅฟ':(42.68,125.53),
# 'ๅๆ็,่พฝๆบๅธ,ไธ่พฝๅฟ':(42.92,125.0),
# 'ๅๆ็,้ๅๅธ,้ๅๅธ':(41.73,125.93),
# 'ๅๆ็,้ๅๅธ,ไธๆๅบ':(41.73,125.95),
# 'ๅๆ็,้ๅๅธ,ไบ้ๆฑๅบ':(41.77,126.03),
# 'ๅๆ็,้ๅๅธ,้ๅๅฟ':(41.68,125.75),
# 'ๅๆ็,้ๅๅธ,่พๅๅฟ':(42.68,126.03),
# 'ๅๆ็,้ๅๅธ,ๆณๆฒณๅฟ':(42.28,125.73),
# 'ๅๆ็,้ๅๅธ,ๆข
ๆฒณๅฃๅธ':(42.53,125.68),
# 'ๅๆ็,้ๅๅธ,้ๅฎๅธ':(41.12,126.18),
# 'ๅๆ็,็ฝๅฑฑๅธ,็ฝๅฑฑๅธ':(41.93,126.42),
# 'ๅๆ็,็ฝๅฑฑๅธ,ๅ
ซ้ๆฑๅบ':(41.93,126.4),
# 'ๅๆ็,็ฝๅฑฑๅธ,ๆๆพๅฟ':(42.33,127.28),
# 'ๅๆ็,็ฝๅฑฑๅธ,้ๅฎๅฟ':(42.4,126.8),
# 'ๅๆ็,็ฝๅฑฑๅธ,้ฟ็ฝๆ้ฒๆ่ชๆฒปๅฟ':(41.42,128.2),
# 'ๅๆ็,็ฝๅฑฑๅธ,ไธดๆฑๅธ':(41.8,126.9),
# 'ๅๆ็,ๆพๅๅธ,ๆพๅๅธ':(45.13,124.82),
# 'ๅๆ็,ๆพๅๅธ,ๅฎๆฑๅบ':(45.17,124.8),
# 'ๅๆ็,ๆพๅๅธ,้ฟๅฒญๅฟ':(44.28,123.98),
# 'ๅๆ็,ๆพๅๅธ,ไนพๅฎๅฟ':(45.02,124.02),
# 'ๅๆ็,ๆพๅๅธ,ๆถไฝๅฟ':(44.98,126.02),
# 'ๅๆ็,็ฝๅๅธ,็ฝๅๅธ':(45.62,122.83),
# 'ๅๆ็,็ฝๅๅธ,ๆดฎๅๅบ':(45.62,122.85),
# 'ๅๆ็,็ฝๅๅธ,้่ตๅฟ':(45.85,123.2),
# 'ๅๆ็,็ฝๅๅธ,้ๆฆๅฟ':(44.82,123.08),
# 'ๅๆ็,็ฝๅๅธ,ๆดฎๅๅธ':(45.33,122.78),
# 'ๅๆ็,็ฝๅๅธ,ๅคงๅฎๅธ':(45.5,124.28),
# 'ๅๆ็,ๅปถ่พนๅธ,ๅปถ่พนๆ้ฒๆ่ชๆฒปๅท':(42.88,129.5),
# 'ๅๆ็,ๅปถ่พนๅธ,ๅปถๅๅธ':(42.88,129.5),
# 'ๅๆ็,ๅปถ่พนๅธ,ๅพไปฌๅธ':(42.97,129.83),
# 'ๅๆ็,ๅปถ่พนๅธ,ๆฆๅๅธ':(43.37,128.23),
# 'ๅๆ็,ๅปถ่พนๅธ,็ฒๆฅๅธ':(42.87,130.37),
# 'ๅๆ็,ๅปถ่พนๅธ,้พไบๅธ':(42.77,129.42),
# 'ๅๆ็,ๅปถ่พนๅธ,ๅ้พๅธ':(42.53,129.0),
# 'ๅๆ็,ๅปถ่พนๅธ,ๆฑชๆธ
ๅฟ':(43.32,129.75),
# 'ๅๆ็,ๅปถ่พนๅธ,ๅฎๅพๅฟ':(43.12,128.9),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅๅฐๆปจๅธ':(45.8,126.53),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,้้ๅบ':(45.77,126.62),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅๅฒๅบ':(45.77,126.68),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,้ๅคๅบ':(45.78,126.65),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,้ฆๅๅบ':(45.72,126.68),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅนณๆฟๅบ':(45.62,126.62),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๆพๅๅบ':(45.8,126.55),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅผๅ
ฐๅบ':(45.9,126.58),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ไพๅ
ฐๅฟ':(46.32,129.55),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๆนๆญฃๅฟ':(45.83,128.83),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅฎพๅฟ':(45.75,127.48),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅทดๅฝฆๅฟ':(46.08,127.4),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๆจๅ
ฐๅฟ':(45.95,128.03),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,้ๆฒณๅฟ':(45.97,128.75),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅปถๅฏฟๅฟ':(45.45,128.33),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅๅๅธ':(45.37,126.32),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ๅฐๅฟๅธ':(45.22,127.95),
# '้ป้พๆฑ็,ๅๅฐๆปจๅธ,ไบๅธธๅธ':(44.92,127.15),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,้ฝ้ฝๅๅฐๅธ':(47.33,123.95),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,้พๆฒๅบ':(47.32,123.95),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๅปบๅๅบ':(47.35,123.95),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,้้ๅบ':(47.35,123.98),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๆๆๆบชๅบ':(47.15,123.8),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๅฏๆๅฐๅบๅบ':(47.2,123.62),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,้พๆฑๅฟ':(47.33,123.18),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ไพๅฎๅฟ':(47.88,125.3),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๆณฐๆฅๅฟ':(46.4,123.42),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,็ๅๅฟ':(47.92,123.5),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๅฏ่ฃๅฟ':(47.82,124.47),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๅ
ๅฑฑๅฟ':(48.03,125.87),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๅ
ไธๅฟ':(48.03,126.25),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,ๆๆณๅฟ':(47.6,126.08),
# '้ป้พๆฑ็,้ฝ้ฝๅๅฐๅธ,่ฎทๆฒณๅธ':(48.48,124.87),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,้ธก่ฅฟๅธ':(45.3,130.97),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,้ธกๅ ๅบ':(45.3,130.97),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,ๆๅฑฑๅบ':(45.2,130.93),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,ๆปด้ๅบ':(45.37,130.78),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,ๆขจๆ ๅบ':(45.08,130.68),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,ๅๅญๆฒณๅบ':(45.33,131.0),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,้บปๅฑฑๅบ':(45.2,130.52),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,้ธกไธๅฟ':(45.25,131.13),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,่ๆๅธ':(45.77,132.98),
# '้ป้พๆฑ็,้ธก่ฅฟๅธ,ๅฏๅฑฑๅธ':(45.55,131.87),
# '้ป้พๆฑ็,้นคๅฒๅธ,้นคๅฒๅธ':(47.33,130.27),
# '้ป้พๆฑ็,้นคๅฒๅธ,ๅ้ณๅบ':(47.33,130.28),
# '้ป้พๆฑ็,้นคๅฒๅธ,ๅ้ณๅบ':(46.8,130.33),
# '้ป้พๆฑ็,้นคๅฒๅธ,ๅทฅๅๅบ':(47.32,130.25),
# '้ป้พๆฑ็,้นคๅฒๅธ,ๅๅฑฑๅบ':(47.3,130.28),
# '้ป้พๆฑ็,้นคๅฒๅธ,ๅ
ดๅฎๅบ':(47.27,130.22),
# '้ป้พๆฑ็,้นคๅฒๅธ,ไธๅฑฑๅบ':(47.33,130.32),
# '้ป้พๆฑ็,้นคๅฒๅธ,ๅ
ดๅฑฑๅบ':(47.37,130.3),
# '้ป้พๆฑ็,้นคๅฒๅธ,่ๅๅฟ':(47.58,130.83),
# '้ป้พๆฑ็,้นคๅฒๅธ,็ปฅๆปจๅฟ':(47.28,131.85),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅ้ธญๅฑฑๅธ':(46.63,131.15),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅฐๅฑฑๅบ':(46.63,131.17),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅฒญไธๅบ':(46.57,131.13),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅๆนๅฐๅบ':(46.58,131.33),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅฎๅฑฑๅบ':(46.57,131.4),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,้่ดคๅฟ':(46.72,131.13),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅ่ฐๅฟ':(46.78,131.8),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,ๅฎๆธ
ๅฟ':(46.32,132.2),
# '้ป้พๆฑ็,ๅ้ธญๅฑฑๅธ,้ฅถๆฒณๅฟ':(46.8,134.02),
# '้ป้พๆฑ็,ๅคงๅบๅธ,ๅคงๅบๅธ':(46.58,125.03),
# '้ป้พๆฑ็,ๅคงๅบๅธ,่จๅฐๅพๅบ':(46.6,125.02),
# '้ป้พๆฑ็,ๅคงๅบๅธ,้พๅคๅบ':(46.53,125.1),
# '้ป้พๆฑ็,ๅคงๅบๅธ,่ฎฉ่ก่ทฏๅบ':(46.65,124.85),
# '้ป้พๆฑ็,ๅคงๅบๅธ,็บขๅฒๅบ':(46.4,124.88),
# '้ป้พๆฑ็,ๅคงๅบๅธ,ๅคงๅๅบ':(46.03,124.82),
# '้ป้พๆฑ็,ๅคงๅบๅธ,่ๅทๅฟ':(45.7,125.27),
# '้ป้พๆฑ็,ๅคงๅบๅธ,่ๆบๅฟ':(45.52,125.08),
# '้ป้พๆฑ็,ๅคงๅบๅธ,ๆ็ธๅฟ':(47.18,124.87),
# '้ป้พๆฑ็,ๅคงๅบๅธ,ๆๅฐไผฏ็น่ๅคๆ่ชๆฒปๅฟ':(46.87,124.45),
# '้ป้พๆฑ็,ไผๆฅๅธ,ไผๆฅๅธ':(47.73,128.9),
# '้ป้พๆฑ็,ไผๆฅๅธ,ๅๅฒๅบ':(47.13,129.28),
# '้ป้พๆฑ็,ไผๆฅๅธ,ๅๅฅฝๅบ':(47.85,128.82),
# '้ป้พๆฑ็,ไผๆฅๅธ,่ฅฟๆๅบ':(47.48,129.28),
# '้ป้พๆฑ็,ไผๆฅๅธ,็ฟ ๅณฆๅบ':(47.72,128.65),
# '้ป้พๆฑ็,ไผๆฅๅธ,ๆฐ้ๅบ':(48.28,129.53),
# '้ป้พๆฑ็,ไผๆฅๅธ,็พๆบชๅบ':(47.63,129.13),
# '้ป้พๆฑ็,ไผๆฅๅธ,้ๅฑฑๅฑฏๅบ':(47.42,129.43),
# '้ป้พๆฑ็,ไผๆฅๅธ,ไบ่ฅๅบ':(48.12,129.25),
# '้ป้พๆฑ็,ไผๆฅๅธ,ไน้ฉฌๆฒณๅบ':(47.72,128.78),
# '้ป้พๆฑ็,ไผๆฅๅธ,ๆฑคๆบๆฒณๅบ':(48.45,129.57),
# '้ป้พๆฑ็,ไผๆฅๅธ,ๅธฆๅฒญๅบ':(47.02,129.02),
# '้ป้พๆฑ็,ไผๆฅๅธ,ไนไผๅฒญๅบ':(48.6,129.42),
# '้ป้พๆฑ็,ไผๆฅๅธ,็บขๆๅบ':(48.23,129.38),
# '้ป้พๆฑ็,ไผๆฅๅธ,ไธ็ๅฒญๅบ':(47.97,129.02),
# '้ป้พๆฑ็,ไผๆฅๅธ,ๅ่ซๅฟ':(48.88,130.38),
# '้ป้พๆฑ็,ไผๆฅๅธ,้ๅๅธ':(46.98,128.02),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ไฝณๆจๆฏๅธ':(46.82,130.37),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๅ้ณๅบ':(47.33,130.28),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๅ้ณๅบ':(46.8,130.33),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๅ่ฟๅบ':(46.82,130.37),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ไธ้ฃๅบ':(46.82,130.4),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,้ๅบ':(46.8,130.32),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๆกฆๅๅฟ':(46.23,130.57),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๆกฆๅทๅฟ':(47.02,130.72),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๆฑคๅๅฟ':(46.73,129.9),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๆ่ฟๅฟ':(48.37,134.28),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๅๆฑๅธ':(47.65,132.52),
# '้ป้พๆฑ็,ไฝณๆจๆฏๅธ,ๅฏ้ฆๅธ':(47.25,132.03),
# '้ป้พๆฑ็,ไธๅฐๆฒณๅธ,ไธๅฐๆฒณๅธ':(45.78,130.95),
# '้ป้พๆฑ็,ไธๅฐๆฒณๅธ,ๆฐๅ
ดๅบ':(45.8,130.83),
# '้ป้พๆฑ็,ไธๅฐๆฒณๅธ,ๆกๅฑฑๅบ':(45.77,130.97),
# '้ป้พๆฑ็,ไธๅฐๆฒณๅธ,่ๅญๆฒณๅบ':(45.77,131.07),
# '้ป้พๆฑ็,ไธๅฐๆฒณๅธ,ๅๅฉๅฟ':(45.75,130.57),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,็กไธนๆฑๅธ':(44.58,129.6),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,ไธๅฎๅบ':(44.58,129.62),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,้ณๆๅบ':(44.6,129.63),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,็ฑๆฐๅบ':(44.58,129.58),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,่ฅฟๅฎๅบ':(44.57,129.62),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,ไธๅฎๅฟ':(44.07,131.12),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,ๆๅฃๅฟ':(45.3,130.27),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,็ปฅ่ฌๆฒณๅธ':(44.42,131.15),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,ๆตทๆๅธ':(44.57,129.38),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,ๅฎๅฎๅธ':(44.35,129.47),
# '้ป้พๆฑ็,็กไธนๆฑๅธ,็ฉๆฃฑๅธ':(44.92,130.52),
# '้ป้พๆฑ็,้ปๆฒณๅธ,้ปๆฒณๅธ':(50.25,127.48),
# '้ป้พๆฑ็,้ปๆฒณๅธ,็ฑ่พๅบ':(50.25,127.48),
# '้ป้พๆฑ็,้ปๆฒณๅธ,้ๅ
ๅฟ':(49.58,128.47),
# '้ป้พๆฑ็,้ปๆฒณๅธ,ๅญๅดๅฟ':(49.42,127.32),
# '้ป้พๆฑ็,้ปๆฒณๅธ,ๅๅฎๅธ':(48.23,126.52),
# '้ป้พๆฑ็,้ปๆฒณๅธ,ไบๅคง่ฟๆฑ ๅธ':(48.52,126.2),
# '้ป้พๆฑ็,็ปฅๅๅธ,็ปฅๅๅธ':(46.63,126.98),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๅๆๅบ':(46.63,126.98),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๆๅฅๅฟ':(46.83,126.48),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๅ
ฐ่ฅฟๅฟ':(46.27,126.28),
# '้ป้พๆฑ็,็ปฅๅๅธ,้ๅๅฟ':(46.68,126.1),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๅบๅฎๅฟ':(46.88,127.52),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๆๆฐดๅฟ':(47.18,125.9),
# '้ป้พๆฑ็,็ปฅๅๅธ,็ปฅๆฃฑๅฟ':(47.25,127.1),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๅฎ่พพๅธ':(46.4,125.33),
# '้ป้พๆฑ็,็ปฅๅๅธ,่ไธๅธ':(46.07,125.98),
# '้ป้พๆฑ็,็ปฅๅๅธ,ๆตทไผฆๅธ':(47.47,126.97),
# '้ป้พๆฑ็,ๅคงๅ
ดๅฎๅฒญๅฐๅบๅธ,ๅคงๅ
ดๅฎๅฒญๅฐๅบ':(50.42,124.12),
# '้ป้พๆฑ็,ๅคงๅ
ดๅฎๅฒญๅฐๅบๅธ,ๅผ็ๅฟ':(51.73,126.65),
# '้ป้พๆฑ็,ๅคงๅ
ดๅฎๅฒญๅฐๅบๅธ,ๅกๆฒณๅฟ':(52.32,124.7),
# '้ป้พๆฑ็,ๅคงๅ
ดๅฎๅฒญๅฐๅบๅธ,ๆผ ๆฒณๅฟ':(52.97,122.53),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ไธๆตทๅธ':(31.23,121.47),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ปๆตฆๅบ':(31.23,121.48),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅขๆนพๅบ':(31.22,121.47),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅพๆฑๅบ':(31.18,121.43),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ฟๅฎๅบ':(31.22,121.42),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ๅฎๅบ':(31.23,121.45),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๆฎ้ๅบ':(31.25,121.4),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ธๅๅบ':(31.25,121.45),
# 'ไธๆตทๅธ,ไธๆตทๅธ,่นๅฃๅบ':(31.27,121.5),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๆจๆตฆๅบ':(31.27,121.52),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ต่กๅบ':(31.12,121.38),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅฎๅฑฑๅบ':(31.4,121.48),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅๅฎๅบ':(31.38,121.27),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๆตฆไธๆฐๅบ':(31.22,121.53),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ๅฑฑๅบ':(30.75,121.33),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๆพๆฑๅบ':(31.03,121.22),
# 'ไธๆตทๅธ,ไธๆตทๅธ,้ๆตฆๅบ':(31.15,121.12),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅๆฑๅบ':(31.05,121.75),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅฅ่ดคๅบ':(30.92,121.47),
# 'ไธๆตทๅธ,ไธๆตทๅธ,ๅดๆๅฟ':(31.62,121.4),
# 'ๆฑ่็,ๅไบฌๅธ,ๅไบฌๅธ':(32.07,118.78),
# 'ๆฑ่็,ๅไบฌๅธ,็ๆญฆๅบ':(32.05,118.8),
# 'ๆฑ่็,ๅไบฌๅธ,็ฝไธๅบ':(32.03,118.78),
# 'ๆฑ่็,ๅไบฌๅธ,็งฆๆทฎๅบ':(32.02,118.8),
# 'ๆฑ่็,ๅไบฌๅธ,ๅปบ้บๅบ':(32.03,118.75),
# 'ๆฑ่็,ๅไบฌๅธ,้ผๆฅผๅบ':(34.28,117.18),
# 'ๆฑ่็,ๅไบฌๅธ,้ผๆฅผๅบ':(32.07,118.77),
# 'ๆฑ่็,ๅไบฌๅธ,ไธๅ
ณๅบ':(32.08,118.73),
# 'ๆฑ่็,ๅไบฌๅธ,ๆตฆๅฃๅบ':(32.05,118.62),
# 'ๆฑ่็,ๅไบฌๅธ,ๆ ้ๅบ':(32.12,118.88),
# 'ๆฑ่็,ๅไบฌๅธ,้จ่ฑๅฐๅบ':(32.0,118.77),
# 'ๆฑ่็,ๅไบฌๅธ,ๆฑๅฎๅบ':(31.95,118.85),
# 'ๆฑ่็,ๅไบฌๅธ,ๅ
ญๅๅบ':(32.35,118.83),
# 'ๆฑ่็,ๅไบฌๅธ,ๆบงๆฐดๅฟ':(31.65,119.02),
# 'ๆฑ่็,ๅไบฌๅธ,้ซๆทณๅฟ':(31.33,118.88),
# 'ๆฑ่็,ๆ ้กๅธ,ๆ ้กๅธ':(31.57,120.3),
# 'ๆฑ่็,ๆ ้กๅธ,ๅดๅฎๅบ':(31.58,120.3),
# 'ๆฑ่็,ๆ ้กๅธ,ๅ้ฟๅบ':(31.57,120.3),
# 'ๆฑ่็,ๆ ้กๅธ,ๅๅกๅบ':(31.58,120.28),
# 'ๆฑ่็,ๆ ้กๅธ,้กๅฑฑๅบ':(31.6,120.35),
# 'ๆฑ่็,ๆ ้กๅธ,ๆ ๅฑฑๅบ':(31.68,120.28),
# 'ๆฑ่็,ๆ ้กๅธ,ๆปจๆนๅบ':(31.57,120.27),
# 'ๆฑ่็,ๆ ้กๅธ,ๆฑ้ดๅธ':(31.9,120.27),
# 'ๆฑ่็,ๆ ้กๅธ,ๅฎๅ
ดๅธ':(31.35,119.82),
# 'ๆฑ่็,ๅพๅทๅธ,ๅพๅทๅธ':(34.27,117.18),
# 'ๆฑ่็,ๅพๅทๅธ,้ผๆฅผๅบ':(34.28,117.18),
# 'ๆฑ่็,ๅพๅทๅธ,้ผๆฅผๅบ':(32.07,118.77),
# 'ๆฑ่็,ๅพๅทๅธ,ไบ้พๅบ':(34.25,117.22),
# 'ๆฑ่็,ๅพๅทๅธ,ไน้ๅบ':(34.3,117.13),
# 'ๆฑ่็,ๅพๅทๅธ,่ดพๆฑชๅบ':(34.45,117.45),
# 'ๆฑ่็,ๅพๅทๅธ,ๆณๅฑฑๅบ':(34.25,117.18),
# 'ๆฑ่็,ๅพๅทๅธ,ไธฐๅฟ':(34.7,116.6),
# 'ๆฑ่็,ๅพๅทๅธ,ๆฒๅฟ':(34.73,116.93),
# 'ๆฑ่็,ๅพๅทๅธ,้ๅฑฑๅฟ':(34.18,117.17),
# 'ๆฑ่็,ๅพๅทๅธ,็ขๅฎๅฟ':(33.9,117.95),
# 'ๆฑ่็,ๅพๅทๅธ,ๆฐๆฒๅธ':(34.38,118.35),
# 'ๆฑ่็,ๅพๅทๅธ,้ณๅทๅธ':(34.32,117.95),
# 'ๆฑ่็,ๅธธๅทๅธ,ๅธธๅทๅธ':(31.78,119.95),
# 'ๆฑ่็,ๅธธๅทๅธ,ๅคฉๅฎๅบ':(31.75,119.93),
# 'ๆฑ่็,ๅธธๅทๅธ,้ๆฅผๅบ':(31.78,119.93),
# 'ๆฑ่็,ๅธธๅทๅธ,ๆๅข
ๅ ฐๅบ':(31.73,120.05),
# 'ๆฑ่็,ๅธธๅทๅธ,ๆฐๅๅบ':(31.83,119.97),
# 'ๆฑ่็,ๅธธๅทๅธ,ๆญฆ่ฟๅบ':(31.72,119.93),
# 'ๆฑ่็,ๅธธๅทๅธ,ๆบง้ณๅธ':(31.42,119.48),
# 'ๆฑ่็,ๅธธๅทๅธ,้ๅๅธ':(31.75,119.57),
# 'ๆฑ่็,่ๅทๅธ,่ๅทๅธ':(31.3,120.58),
# 'ๆฑ่็,่ๅทๅธ,ๆฒงๆตชๅบ':(31.3,120.63),
# 'ๆฑ่็,่ๅทๅธ,ๅนณๆฑๅบ':(31.32,120.63),
# 'ๆฑ่็,่ๅทๅธ,้้ๅบ':(31.32,120.6),
# 'ๆฑ่็,่ๅทๅธ,่ไธๅบ':(31.3,120.57),
# 'ๆฑ่็,่ๅทๅธ,ๅดไธญๅบ':(31.27,120.63),
# 'ๆฑ่็,่ๅทๅธ,็ธๅๅบ':(31.37,120.63),
# 'ๆฑ่็,่ๅทๅธ,ๅธธ็ๅธ':(31.65,120.75),
# 'ๆฑ่็,่ๅทๅธ,ๅผ ๅฎถๆธฏๅธ':(31.87,120.55),
# 'ๆฑ่็,่ๅทๅธ,ๆๅฑฑๅธ':(31.38,120.98),
# 'ๆฑ่็,่ๅทๅธ,ๅดๆฑๅธ':(31.17,120.63),
# 'ๆฑ่็,่ๅทๅธ,ๅคชไปๅธ':(31.45,121.1),
# 'ๆฑ่็,ๅ้ๅธ,ๅ้ๅธ':(31.98,120.88),
# 'ๆฑ่็,ๅ้ๅธ,ๅดๅทๅบ':(32.0,120.85),
# 'ๆฑ่็,ๅ้ๅธ,ๆธฏ้ธๅบ':(32.03,120.8),
# 'ๆฑ่็,ๅ้ๅธ,ๆตทๅฎๅฟ':(32.55,120.45),
# 'ๆฑ่็,ๅ้ๅธ,ๅฆไธๅฟ':(32.32,121.18),
# 'ๆฑ่็,ๅ้ๅธ,ๅฏไธๅธ':(31.82,121.65),
# 'ๆฑ่็,ๅ้ๅธ,ๅฆ็ๅธ':(32.4,120.57),
# 'ๆฑ่็,ๅ้ๅธ,้ๅทๅธ':(32.08,121.07),
# 'ๆฑ่็,ๅ้ๅธ,ๆตท้จๅธ':(31.9,121.17),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,่ฟไบๆธฏๅธ':(34.6,119.22),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,่ฟไบๅบ':(34.75,119.37),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,ๆฐๆตฆๅบ':(34.6,119.17),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,ๆตทๅทๅบ':(34.57,119.12),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,่ตฃๆฆๅฟ':(34.83,119.12),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,ไธๆตทๅฟ':(34.53,118.77),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,็ไบๅฟ':(34.3,119.25),
# 'ๆฑ่็,่ฟไบๆธฏๅธ,็ๅๅฟ':(34.08,119.35),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆทฎๅฎๅธ':(33.62,119.02),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆธ
ๆฒณๅบ':(33.6,119.02),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆฅๅทๅบ':(33.5,119.13),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆทฎ้ดๅบ':(33.63,119.03),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆธ
ๆตฆๅบ':(33.58,119.03),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆถๆฐดๅฟ':(33.78,119.27),
# 'ๆฑ่็,ๆทฎๅฎๅธ,ๆดชๆณฝๅฟ':(33.3,118.83),
# 'ๆฑ่็,ๆทฎๅฎๅธ,็ฑ็ๅฟ':(33.0,118.48),
# 'ๆฑ่็,ๆทฎๅฎๅธ,้ๆนๅฟ':(33.02,119.02),
# 'ๆฑ่็,็ๅๅธ,็ๅๅธ':(33.35,120.15),
# 'ๆฑ่็,็ๅๅธ,ไบญๆนๅบ':(33.4,120.13),
# 'ๆฑ่็,็ๅๅธ,็้ฝๅบ':(33.33,120.15),
# 'ๆฑ่็,็ๅๅธ,ๅๆฐดๅฟ':(34.2,119.57),
# 'ๆฑ่็,็ๅๅธ,ๆปจๆตทๅฟ':(33.98,119.83),
# 'ๆฑ่็,็ๅๅธ,้ๅฎๅฟ':(33.78,119.8),
# 'ๆฑ่็,็ๅๅธ,ๅฐ้ณๅฟ':(33.78,120.25),
# 'ๆฑ่็,็ๅๅธ,ๅปบๆนๅฟ':(33.47,119.8),
# 'ๆฑ่็,็ๅๅธ,ไธๅฐๅธ':(32.85,120.3),
# 'ๆฑ่็,็ๅๅธ,ๅคงไธฐๅธ':(33.2,120.47),
# 'ๆฑ่็,ๆฌๅทๅธ,ๆฌๅทๅธ':(32.4,119.4),
# 'ๆฑ่็,ๆฌๅทๅธ,ๅนฟ้ตๅบ':(32.38,119.43),
# 'ๆฑ่็,ๆฌๅทๅธ,้ๆฑๅบ':(32.38,119.4),
# 'ๆฑ่็,ๆฌๅทๅธ,็ปดๆฌๅบ':(32.42,119.4),
# 'ๆฑ่็,ๆฌๅทๅธ,ๅฎๅบๅฟ':(33.23,119.3),
# 'ๆฑ่็,ๆฌๅทๅธ,ไปชๅพๅธ':(32.27,119.18),
# 'ๆฑ่็,ๆฌๅทๅธ,้ซ้ฎๅธ':(32.78,119.43),
# 'ๆฑ่็,ๆฌๅทๅธ,ๆฑ้ฝๅธ':(32.43,119.55),
# 'ๆฑ่็,้ๆฑๅธ,้ๆฑๅธ':(32.2,119.45),
# 'ๆฑ่็,้ๆฑๅธ,ไบฌๅฃๅบ':(32.2,119.47),
# 'ๆฑ่็,้ๆฑๅธ,ๆถฆๅทๅบ':(32.2,119.4),
# 'ๆฑ่็,้ๆฑๅธ,ไธนๅพๅบ':(32.13,119.45),
# 'ๆฑ่็,้ๆฑๅธ,ไธน้ณๅธ':(32.0,119.57),
# 'ๆฑ่็,้ๆฑๅธ,ๆฌไธญๅธ':(32.23,119.82),
# 'ๆฑ่็,้ๆฑๅธ,ๅฅๅฎนๅธ':(31.95,119.17),
# 'ๆฑ่็,ๆณฐๅทๅธ,ๆณฐๅทๅธ':(32.45,119.92),
# 'ๆฑ่็,ๆณฐๅทๅธ,ๅ
ดๅๅธ':(32.92,119.85),
# 'ๆฑ่็,ๆณฐๅทๅธ,้ๆฑๅธ':(32.02,120.27),
# 'ๆฑ่็,ๆณฐๅทๅธ,ๆณฐๅ
ดๅธ':(32.17,120.02),
# 'ๆฑ่็,ๆณฐๅทๅธ,ๅงๅ ฐๅธ':(32.52,120.15),
# 'ๆฑ่็,ๅฎฟ่ฟๅธ,ๅฎฟ่ฟๅธ':(33.97,118.28),
# 'ๆฑ่็,ๅฎฟ่ฟๅธ,ๅฎฟๅๅบ':(33.97,118.25),
# 'ๆฑ่็,ๅฎฟ่ฟๅธ,ๅฎฟ่ฑซๅบ':(33.95,118.32),
# 'ๆฑ่็,ๅฎฟ่ฟๅธ,ๆฒญ้ณๅฟ':(34.13,118.77),
# 'ๆฑ่็,ๅฎฟ่ฟๅธ,ๆณ้ณๅฟ':(33.72,118.68),
# 'ๆฑ่็,ๅฎฟ่ฟๅธ,ๆณๆดชๅฟ':(33.47,118.22),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๆญๅทๅธ':(30.28,120.15),
# 'ๆตๆฑ็,ๆญๅทๅธ,ไธๅๅบ':(30.25,120.17),
# 'ๆตๆฑ็,ๆญๅทๅธ,ไธๅๅบ':(30.28,120.17),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๆฑๅนฒๅบ':(30.27,120.2),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๆฑๅข
ๅบ':(30.32,120.13),
# 'ๆตๆฑ็,ๆญๅทๅธ,่ฅฟๆนๅบ':(30.27,120.13),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๆปจๆฑๅบ':(30.2,120.2),
# 'ๆตๆฑ็,ๆญๅทๅธ,่งๅฑฑๅบ':(30.17,120.27),
# 'ๆตๆฑ็,ๆญๅทๅธ,ไฝๆญๅบ':(30.42,120.3),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๆกๅบๅฟ':(29.8,119.67),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๆทณๅฎๅฟ':(29.6,119.03),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๅปบๅพทๅธ':(29.48,119.28),
# 'ๆตๆฑ็,ๆญๅทๅธ,ๅฏ้ณๅธ':(30.05,119.95),
# 'ๆตๆฑ็,ๆญๅทๅธ,ไธดๅฎๅธ':(30.23,119.72),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๅฎๆณขๅธ':(29.88,121.55),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๆตทๆๅบ':(29.87,121.55),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๆฑไธๅบ':(29.87,121.57),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๆฑๅๅบ':(29.88,121.55),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๅไปๅบ':(29.93,121.85),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,้ๆตทๅบ':(29.95,121.72),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,้ๅทๅบ':(29.83,121.53),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,่ฑกๅฑฑๅฟ':(29.48,121.87),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๅฎๆตทๅฟ':(29.28,121.43),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ไฝๅงๅธ':(30.03,121.15),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๆ
ๆบชๅธ':(30.17,121.23),
# 'ๆตๆฑ็,ๅฎๆณขๅธ,ๅฅๅๅธ':(29.65,121.4),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ๆธฉๅทๅธ':(28.0,120.7),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,้นฟๅๅบ':(28.02,120.65),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,้พๆนพๅบ':(27.93,120.82),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ๆดๅคดๅฟ':(27.83,121.15),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ๆฐธๅๅฟ':(28.15,120.68),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ๅนณ้ณๅฟ':(27.67,120.57),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,่ๅๅฟ':(27.5,120.4),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ๆๆๅฟ':(27.78,120.08),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ๆณฐ้กบๅฟ':(27.57,119.72),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,็ๅฎๅธ':(27.78,120.63),
# 'ๆตๆฑ็,ๆธฉๅทๅธ,ไนๆธ
ๅธ':(28.13,120.95),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,ๅๅ
ดๅธ':(30.75,120.75),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,็งๆดฒๅบ':(30.77,120.7),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,ๅๅๅฟ':(30.85,120.92),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,ๆตท็ๅฟ':(30.53,120.95),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,ๆตทๅฎๅธ':(30.53,120.68),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,ๅนณๆนๅธ':(30.7,121.02),
# 'ๆตๆฑ็,ๅๅ
ดๅธ,ๆกไนกๅธ':(30.63,120.57),
# 'ๆตๆฑ็,ๆนๅทๅธ,ๆนๅทๅธ':(30.9,120.08),
# 'ๆตๆฑ็,ๆนๅทๅธ,ๅดๅ
ดๅบ':(30.87,120.12),
# 'ๆตๆฑ็,ๆนๅทๅธ,ๅๆตๅบ':(30.88,120.43),
# 'ๆตๆฑ็,ๆนๅทๅธ,ๅพทๆธ
ๅฟ':(30.53,119.97),
# 'ๆตๆฑ็,ๆนๅทๅธ,้ฟๅ
ดๅฟ':(31.02,119.9),
# 'ๆตๆฑ็,ๆนๅทๅธ,ๅฎๅๅฟ':(30.63,119.68),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,็ปๅ
ดๅธ':(30.0,120.57),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,่ถๅๅบ':(30.0,120.57),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,็ปๅ
ดๅฟ':(30.08,120.47),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,ๆฐๆๅฟ':(29.5,120.9),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,่ฏธๆจๅธ':(29.72,120.23),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,ไธ่ๅธ':(30.03,120.87),
# 'ๆตๆฑ็,็ปๅ
ดๅธ,ๅตๅทๅธ':(29.58,120.82),
# 'ๆตๆฑ็,้ๅๅธ,้ๅๅธ':(29.08,119.65),
# 'ๆตๆฑ็,้ๅๅธ,ๅฉบๅๅบ':(29.08,119.65),
# 'ๆตๆฑ็,้ๅๅธ,้ไธๅบ':(29.08,119.7),
# 'ๆตๆฑ็,้ๅๅธ,ๆญฆไนๅฟ':(28.9,119.82),
# 'ๆตๆฑ็,้ๅๅธ,ๆตฆๆฑๅฟ':(29.45,119.88),
# 'ๆตๆฑ็,้ๅๅธ,็ฃๅฎๅฟ':(29.05,120.43),
# 'ๆตๆฑ็,้ๅๅธ,ๅ
ฐๆบชๅธ':(29.22,119.45),
# 'ๆตๆฑ็,้ๅๅธ,ไนไนๅธ':(29.3,120.07),
# 'ๆตๆฑ็,้ๅๅธ,ไธ้ณๅธ':(29.28,120.23),
# 'ๆตๆฑ็,้ๅๅธ,ๆฐธๅบทๅธ':(28.9,120.03),
# 'ๆตๆฑ็,่กขๅทๅธ,่กขๅทๅธ':(28.93,118.87),
# 'ๆตๆฑ็,่กขๅทๅธ,ๆฏๅๅบ':(28.93,118.87),
# 'ๆตๆฑ็,่กขๅทๅธ,่กขๆฑๅบ':(28.98,118.93),
# 'ๆตๆฑ็,่กขๅทๅธ,ๅธธๅฑฑๅฟ':(28.9,118.52),
# 'ๆตๆฑ็,่กขๅทๅธ,ๅผๅๅฟ':(29.13,118.42),
# 'ๆตๆฑ็,่กขๅทๅธ,้พๆธธๅฟ':(29.03,119.17),
# 'ๆตๆฑ็,่กขๅทๅธ,ๆฑๅฑฑๅธ':(28.75,118.62),
# 'ๆตๆฑ็,่ๅฑฑๅธ,่ๅฑฑๅธ':(30.0,122.2),
# 'ๆตๆฑ็,่ๅฑฑๅธ,ๅฎๆตทๅบ':(30.02,122.1),
# 'ๆตๆฑ็,่ๅฑฑๅธ,ๆฎ้ๅบ':(29.95,122.3),
# 'ๆตๆฑ็,่ๅฑฑๅธ,ๅฒฑๅฑฑๅฟ':(30.25,122.2),
# 'ๆตๆฑ็,่ๅฑฑๅธ,ๅตๆณๅฟ':(30.73,122.45),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ๅฐๅทๅธ':(28.68,121.43),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ๆคๆฑๅบ':(28.68,121.43),
# 'ๆตๆฑ็,ๅฐๅทๅธ,้ปๅฒฉๅบ':(28.65,121.27),
# 'ๆตๆฑ็,ๅฐๅทๅธ,่ทฏๆกฅๅบ':(28.58,121.38),
# 'ๆตๆฑ็,ๅฐๅทๅธ,็็ฏๅฟ':(28.13,121.23),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ไธ้จๅฟ':(29.12,121.38),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ๅคฉๅฐๅฟ':(29.13,121.03),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ไปๅฑ
ๅฟ':(28.87,120.73),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ๆธฉๅฒญๅธ':(28.37,121.37),
# 'ๆตๆฑ็,ๅฐๅทๅธ,ไธดๆตทๅธ':(28.85,121.12),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,ไธฝๆฐดๅธ':(28.45,119.92),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,่ฒ้ฝๅบ':(28.45,119.92),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,้็ฐๅฟ':(28.15,120.28),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,็ผไบๅฟ':(28.65,120.07),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,้ๆๅฟ':(28.6,119.27),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,ๆพ้ณๅฟ':(28.45,119.48),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,ไบๅๅฟ':(28.12,119.57),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,ๅบๅ
ๅฟ':(27.62,119.05),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,ๆฏๅฎ็ฒๆ่ชๆฒปๅฟ':(27.98,119.63),
# 'ๆตๆฑ็,ไธฝๆฐดๅธ,้พๆณๅธ':(28.08,119.13),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,ๅ่ฅๅธ':(31.83,117.25),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,็ถๆตทๅบ':(31.87,117.3),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,ๅบ้ณๅบ':(31.88,117.25),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,่ๅฑฑๅบ':(31.85,117.27),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,ๅ
ๆฒณๅบ':(31.8,117.3),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,้ฟไธฐๅฟ':(32.48,117.17),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,่ฅไธๅฟ':(31.88,117.47),
# 'ๅฎๅพฝ็,ๅ่ฅๅธ,่ฅ่ฅฟๅฟ':(31.72,117.17),
# 'ๅฎๅพฝ็,่ๆนๅธ,่ๆนๅธ':(31.33,118.38),
# 'ๅฎๅพฝ็,่ๆนๅธ,้ๆนๅบ':(31.35,118.37),
# 'ๅฎๅพฝ็,่ๆนๅธ,้ธ ๆฑๅบ':(31.37,118.38),
# 'ๅฎๅพฝ็,่ๆนๅธ,่ๆนๅฟ':(31.15,118.57),
# 'ๅฎๅพฝ็,่ๆนๅธ,็นๆๅฟ':(31.08,118.2),
# 'ๅฎๅพฝ็,่ๆนๅธ,ๅ้ตๅฟ':(30.92,118.33),
# 'ๅฎๅพฝ็,่ๅ ๅธ,่ๅ ๅธ':(32.92,117.38),
# 'ๅฎๅพฝ็,่ๅ ๅธ,้พๅญๆนๅบ':(32.95,117.38),
# 'ๅฎๅพฝ็,่ๅ ๅธ,่ๅฑฑๅบ':(32.95,117.35),
# 'ๅฎๅพฝ็,่ๅ ๅธ,็ฆนไผๅบ':(32.93,117.33),
# 'ๅฎๅพฝ็,่ๅ ๅธ,ๆทฎไธๅบ':(32.97,117.35),
# 'ๅฎๅพฝ็,่ๅ ๅธ,ๆ่ฟๅฟ':(32.97,117.18),
# 'ๅฎๅพฝ็,่ๅ ๅธ,ไบๆฒณๅฟ':(33.15,117.88),
# 'ๅฎๅพฝ็,่ๅ ๅธ,ๅบ้ๅฟ':(33.32,117.32),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๆทฎๅๅธ':(32.63,117.0),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๅคง้ๅบ':(32.63,117.05),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,็ฐๅฎถๅบตๅบ':(32.67,117.0),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,่ฐขๅฎถ้ๅบ':(32.6,116.85),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๅ
ซๅ
ฌๅฑฑๅบ':(32.63,116.83),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๆฝ้ๅบ':(32.78,116.82),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๅคๅฐๅฟ':(32.7,116.72),
# 'ๅฎๅพฝ็,้ฉฌ้ๅฑฑๅธ,้ฉฌ้ๅฑฑๅธ':(31.7,118.5),
# 'ๅฎๅพฝ็,้ฉฌ้ๅฑฑๅธ,้ๅฎถๅบๅบ':(31.73,118.48),
# 'ๅฎๅพฝ็,้ฉฌ้ๅฑฑๅธ,่ฑๅฑฑๅบ':(31.72,118.5),
# 'ๅฎๅพฝ็,้ฉฌ้ๅฑฑๅธ,้จๅฑฑๅบ':(31.68,118.48),
# 'ๅฎๅพฝ็,้ฉฌ้ๅฑฑๅธ,ๅฝๆถๅฟ':(31.55,118.48),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๆทฎๅๅธ':(33.95,116.8),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๆ้ๅบ':(34.0,116.82),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,็ธๅฑฑๅบ':(33.95,116.8),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,็ๅฑฑๅบ':(33.9,116.8),
# 'ๅฎๅพฝ็,ๆทฎๅๅธ,ๆฟๆบชๅฟ':(33.92,116.77),
# 'ๅฎๅพฝ็,้้ตๅธ,้้ตๅธ':(30.93,117.82),
# 'ๅฎๅพฝ็,้้ตๅธ,้ๅฎๅฑฑๅบ':(30.93,117.82),
# 'ๅฎๅพฝ็,้้ตๅธ,็ฎๅญๅฑฑๅบ':(30.95,117.85),
# 'ๅฎๅพฝ็,้้ตๅธ,้ๅบ':(30.92,117.78),
# 'ๅฎๅพฝ็,้้ตๅธ,้้ตๅฟ':(30.95,117.78),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๅฎๅบๅธ':(30.53,117.05),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,่ฟๆฑๅบ':(30.5,117.05),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๅคง่งๅบ':(30.52,117.03),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,้ๅบ':(30.92,117.78),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๆๅฎๅฟ':(30.72,116.83),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๆ้ณๅฟ':(30.7,117.2),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๆฝๅฑฑๅฟ':(30.63,116.57),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๅคชๆนๅฟ':(30.43,116.27),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๅฎฟๆพๅฟ':(30.15,116.12),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๆๆฑๅฟ':(30.13,116.68),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๅฒณ่ฅฟๅฟ':(30.85,116.35),
# 'ๅฎๅพฝ็,ๅฎๅบๅธ,ๆกๅๅธ':(31.05,116.95),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,้ปๅฑฑๅธ':(29.72,118.33),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,ๅฑฏๆบชๅบ':(29.72,118.33),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,้ปๅฑฑๅบ':(30.3,118.13),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,ๅพฝๅทๅบ':(29.82,118.33),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,ๆญๅฟ':(29.87,118.43),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,ไผๅฎๅฟ':(29.78,118.18),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,้ปๅฟ':(29.93,117.93),
# 'ๅฎๅพฝ็,้ปๅฑฑๅธ,็ฅ้จๅฟ':(29.87,117.72),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๆปๅทๅธ':(32.3,118.32),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,็
็ๅบ':(32.3,118.3),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๅ่ฐฏๅบ':(32.32,118.3),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๆฅๅฎๅฟ':(32.45,118.43),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๅ
จๆคๅฟ':(32.1,118.27),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๅฎ่ฟๅฟ':(32.53,117.67),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๅค้ณๅฟ':(32.87,117.57),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๅคฉ้ฟๅธ':(32.7,119.0),
# 'ๅฎๅพฝ็,ๆปๅทๅธ,ๆๅ
ๅธ':(32.78,117.98),
# 'ๅฎๅพฝ็,้้ณๅธ,้้ณๅธ':(32.9,115.82),
# 'ๅฎๅพฝ็,้้ณๅธ,้ขๅทๅบ':(32.88,115.8),
# 'ๅฎๅพฝ็,้้ณๅธ,้ขไธๅบ':(32.92,115.85),
# 'ๅฎๅพฝ็,้้ณๅธ,้ขๆณๅบ':(32.93,115.8),
# 'ๅฎๅพฝ็,้้ณๅธ,ไธดๆณๅฟ':(33.07,115.25),
# 'ๅฎๅพฝ็,้้ณๅธ,ๅคชๅๅฟ':(33.17,115.62),
# 'ๅฎๅพฝ็,้้ณๅธ,้ๅๅฟ':(32.63,115.58),
# 'ๅฎๅพฝ็,้้ณๅธ,้ขไธๅฟ':(32.63,116.27),
# 'ๅฎๅพฝ็,ๅฎฟๅทๅธ,ๅฎฟๅทๅธ':(33.63,116.98),
# 'ๅฎๅพฝ็,ๅฎฟๅทๅธ,ๅๆกฅๅบ':(33.63,116.97),
# 'ๅฎๅพฝ็,ๅฎฟๅทๅธ,็ ๅฑฑๅฟ':(34.42,116.35),
# 'ๅฎๅพฝ็,ๅฎฟๅทๅธ,่งๅฟ':(34.18,116.93),
# 'ๅฎๅพฝ็,ๅฎฟๅทๅธ,็ต็งๅฟ':(33.55,117.55),
# 'ๅฎๅพฝ็,ๅฎฟๅทๅธ,ๆณๅฟ':(33.48,117.88),
# 'ๅฎๅพฝ็,ๅทขๆนๅธ,ๅทขๆนๅธ':(31.6,117.87),
# 'ๅฎๅพฝ็,ๅทขๆนๅธ,ๅฑ
ๅทขๅบ':(31.6,117.85),
# 'ๅฎๅพฝ็,ๅทขๆนๅธ,ๅบๆฑๅฟ':(31.25,117.28),
# 'ๅฎๅพฝ็,ๅทขๆนๅธ,ๆ ไธบๅฟ':(31.3,117.92),
# 'ๅฎๅพฝ็,ๅทขๆนๅธ,ๅซๅฑฑๅฟ':(31.72,118.1),
# 'ๅฎๅพฝ็,ๅทขๆนๅธ,ๅๅฟ':(31.72,118.37),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,ๅ
ญๅฎๅธ':(31.77,116.5),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,้ๅฎๅบ':(31.77,116.5),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,่ฃๅฎๅบ':(31.77,116.48),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,ๅฏฟๅฟ':(32.58,116.78),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,้้ฑๅฟ':(32.33,116.27),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,่ๅๅฟ':(31.47,116.93),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,้ๅฏจๅฟ':(31.72,115.92),
# 'ๅฎๅพฝ็,ๅ
ญๅฎๅธ,้ๅฑฑๅฟ':(31.4,116.33),
# 'ๅฎๅพฝ็,ไบณๅทๅธ,ไบณๅทๅธ':(33.85,115.78),
# 'ๅฎๅพฝ็,ไบณๅทๅธ,่ฐฏๅๅบ':(33.88,115.77),
# 'ๅฎๅพฝ็,ไบณๅทๅธ,ๆถก้ณๅฟ':(33.52,116.22),
# 'ๅฎๅพฝ็,ไบณๅทๅธ,่ๅๅฟ':(33.27,116.57),
# 'ๅฎๅพฝ็,ไบณๅทๅธ,ๅฉ่พๅฟ':(33.15,116.2),
# 'ๅฎๅพฝ็,ๆฑ ๅทๅธ,ๆฑ ๅทๅธ':(30.67,117.48),
# 'ๅฎๅพฝ็,ๆฑ ๅทๅธ,่ดตๆฑ ๅบ':(30.65,117.48),
# 'ๅฎๅพฝ็,ๆฑ ๅทๅธ,ไธ่ณๅฟ':(30.1,117.02),
# 'ๅฎๅพฝ็,ๆฑ ๅทๅธ,็ณๅฐๅฟ':(30.22,117.48),
# 'ๅฎๅพฝ็,ๆฑ ๅทๅธ,้้ณๅฟ':(30.65,117.85),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,ๅฎฃๅๅธ':(30.95,118.75),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,ๅฎฃๅทๅบ':(30.95,118.75),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,้ๆบชๅฟ':(31.13,119.17),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,ๅนฟๅพทๅฟ':(30.9,119.42),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,ๆณพๅฟ':(30.7,118.4),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,็ปฉๆบชๅฟ':(30.07,118.6),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,ๆๅพทๅฟ':(30.28,118.53),
# 'ๅฎๅพฝ็,ๅฎฃๅๅธ,ๅฎๅฝๅธ':(30.63,118.98),
# '็ฆๅปบ็,็ฆๅทๅธ,็ฆๅทๅธ':(26.08,119.3),
# '็ฆๅปบ็,็ฆๅทๅธ,้ผๆฅผๅบ':(26.08,119.3),
# '็ฆๅปบ็,็ฆๅทๅธ,ๅฐๆฑๅบ':(26.07,119.3),
# '็ฆๅปบ็,็ฆๅทๅธ,ไปๅฑฑๅบ':(26.05,119.32),
# '็ฆๅปบ็,็ฆๅทๅธ,้ฉฌๅฐพๅบ':(26.0,119.45),
# '็ฆๅปบ็,็ฆๅทๅธ,ๆๅฎๅบ':(26.08,119.32),
# '็ฆๅปบ็,็ฆๅทๅธ,้ฝไพฏๅฟ':(26.15,119.13),
# '็ฆๅปบ็,็ฆๅทๅธ,่ฟๆฑๅฟ':(26.2,119.53),
# '็ฆๅปบ็,็ฆๅทๅธ,็ฝๆบๅฟ':(26.48,119.55),
# '็ฆๅปบ็,็ฆๅทๅธ,้ฝๆธ
ๅฟ':(26.22,118.85),
# '็ฆๅปบ็,็ฆๅทๅธ,ๆฐธๆณฐๅฟ':(25.87,118.93),
# '็ฆๅปบ็,็ฆๅทๅธ,ๅนณๆฝญๅฟ':(25.52,119.78),
# '็ฆๅปบ็,็ฆๅทๅธ,็ฆๆธ
ๅธ':(25.72,119.38),
# '็ฆๅปบ็,็ฆๅทๅธ,้ฟไนๅธ':(25.97,119.52),
# '็ฆๅปบ็,ๅฆ้จๅธ,ๅฆ้จๅธ':(24.48,118.08),
# '็ฆๅปบ็,ๅฆ้จๅธ,ๆๆๅบ':(24.45,118.08),
# '็ฆๅปบ็,ๅฆ้จๅธ,ๆตทๆฒงๅบ':(24.47,117.98),
# '็ฆๅปบ็,ๅฆ้จๅธ,ๆน้ๅบ':(24.52,118.08),
# '็ฆๅปบ็,ๅฆ้จๅธ,้็พๅบ':(24.57,118.1),
# '็ฆๅปบ็,ๅฆ้จๅธ,ๅๅฎๅบ':(24.73,118.15),
# '็ฆๅปบ็,ๅฆ้จๅธ,็ฟๅฎๅบ':(24.62,118.23),
# '็ฆๅปบ็,่็ฐๅธ,่็ฐๅธ':(25.43,119.0),
# '็ฆๅปบ็,่็ฐๅธ,ๅๅขๅบ':(25.43,119.0),
# '็ฆๅปบ็,่็ฐๅธ,ๆถตๆฑๅบ':(25.45,119.1),
# '็ฆๅปบ็,่็ฐๅธ,่ๅๅบ':(25.43,119.02),
# '็ฆๅปบ็,่็ฐๅธ,็งๅฑฟๅบ':(25.32,119.08),
# '็ฆๅปบ็,่็ฐๅธ,ไปๆธธๅฟ':(25.37,118.68),
# '็ฆๅปบ็,ไธๆๅธ,ไธๆๅธ':(26.27,117.62),
# '็ฆๅปบ็,ไธๆๅธ,ๆข
ๅๅบ':(26.27,117.63),
# '็ฆๅปบ็,ไธๆๅธ,ไธๅ
ๅบ':(26.23,117.6),
# '็ฆๅปบ็,ไธๆๅธ,ๆๆบชๅฟ':(26.37,117.2),
# '็ฆๅปบ็,ไธๆๅธ,ๆธ
ๆตๅฟ':(26.18,116.82),
# '็ฆๅปบ็,ไธๆๅธ,ๅฎๅๅฟ':(26.27,116.65),
# '็ฆๅปบ็,ไธๆๅธ,ๅคง็ฐๅฟ':(25.7,117.85),
# '็ฆๅปบ็,ไธๆๅธ,ๅฐคๆบชๅฟ':(26.17,118.18),
# '็ฆๅปบ็,ไธๆๅธ,ๆฒๅฟ':(26.4,117.78),
# '็ฆๅปบ็,ไธๆๅธ,ๅฐไนๅฟ':(26.73,117.47),
# '็ฆๅปบ็,ไธๆๅธ,ๆณฐๅฎๅฟ':(26.9,117.17),
# '็ฆๅปบ็,ไธๆๅธ,ๅปบๅฎๅฟ':(26.83,116.83),
# '็ฆๅปบ็,ไธๆๅธ,ๆฐธๅฎๅธ':(25.98,117.37),
# '็ฆๅปบ็,ๆณๅทๅธ,ๆณๅทๅธ':(24.88,118.67),
# '็ฆๅปบ็,ๆณๅทๅธ,้ฒคๅๅบ':(24.92,118.6),
# '็ฆๅปบ็,ๆณๅทๅธ,ไธฐๆณฝๅบ':(24.92,118.6),
# '็ฆๅปบ็,ๆณๅทๅธ,ๆดๆฑๅบ':(24.95,118.67),
# '็ฆๅปบ็,ๆณๅทๅธ,ๆณๆธฏๅบ':(25.12,118.88),
# '็ฆๅปบ็,ๆณๅทๅธ,ๆ ๅฎๅฟ':(25.03,118.8),
# '็ฆๅปบ็,ๆณๅทๅธ,ๅฎๆบชๅฟ':(25.07,118.18),
# '็ฆๅปบ็,ๆณๅทๅธ,ๆฐธๆฅๅฟ':(25.32,118.3),
# '็ฆๅปบ็,ๆณๅทๅธ,ๅพทๅๅฟ':(25.5,118.23),
# '็ฆๅปบ็,ๆณๅทๅธ,้้จๅฟ':(24.43,118.32),
# '็ฆๅปบ็,ๆณๅทๅธ,็ณ็ฎๅธ':(24.73,118.65),
# '็ฆๅปบ็,ๆณๅทๅธ,ๆๆฑๅธ':(24.82,118.58),
# '็ฆๅปบ็,ๆณๅทๅธ,ๅๅฎๅธ':(24.97,118.38),
# '็ฆๅปบ็,ๆผณๅทๅธ,ๆผณๅทๅธ':(24.52,117.65),
# '็ฆๅปบ็,ๆผณๅทๅธ,่ๅๅบ':(24.52,117.65),
# '็ฆๅปบ็,ๆผณๅทๅธ,้พๆๅบ':(24.52,117.72),
# '็ฆๅปบ็,ๆผณๅทๅธ,ไบ้ๅฟ':(23.95,117.33),
# '็ฆๅปบ็,ๆผณๅทๅธ,ๆผณๆตฆๅฟ':(24.13,117.62),
# '็ฆๅปบ็,ๆผณๅทๅธ,่ฏๅฎๅฟ':(23.72,117.18),
# '็ฆๅปบ็,ๆผณๅทๅธ,้ฟๆณฐๅฟ':(24.62,117.75),
# '็ฆๅปบ็,ๆผณๅทๅธ,ไธๅฑฑๅฟ':(23.7,117.43),
# '็ฆๅปบ็,ๆผณๅทๅธ,ๅ้ๅฟ':(24.52,117.37),
# '็ฆๅปบ็,ๆผณๅทๅธ,ๅนณๅๅฟ':(24.37,117.3),
# '็ฆๅปบ็,ๆผณๅทๅธ,ๅๅฎๅฟ':(25.02,117.53),
# '็ฆๅปบ็,ๆผณๅทๅธ,้พๆตทๅธ':(24.45,117.82),
# '็ฆๅปบ็,ๅๅนณๅธ,ๅๅนณๅธ':(26.65,118.17),
# '็ฆๅปบ็,ๅๅนณๅธ,ๅปถๅนณๅบ':(26.65,118.17),
# '็ฆๅปบ็,ๅๅนณๅธ,้กบๆๅฟ':(26.8,117.8),
# '็ฆๅปบ็,ๅๅนณๅธ,ๆตฆๅๅฟ':(27.92,118.53),
# '็ฆๅปบ็,ๅๅนณๅธ,ๅ
ๆณฝๅฟ':(27.55,117.33),
# '็ฆๅปบ็,ๅๅนณๅธ,ๆพๆบชๅฟ':(27.53,118.78),
# '็ฆๅปบ็,ๅๅนณๅธ,ๆฟๅๅฟ':(27.37,118.85),
# '็ฆๅปบ็,ๅๅนณๅธ,้ตๆญฆๅธ':(27.37,117.48),
# '็ฆๅปบ็,ๅๅนณๅธ,ๆญฆๅคทๅฑฑๅธ':(27.77,118.03),
# '็ฆๅปบ็,ๅๅนณๅธ,ๅปบ็ฏๅธ':(27.03,118.32),
# '็ฆๅปบ็,ๅๅนณๅธ,ๅปบ้ณๅธ':(27.33,118.12),
# '็ฆๅปบ็,้พๅฒฉๅธ,้พๅฒฉๅธ':(25.1,117.03),
# '็ฆๅปบ็,้พๅฒฉๅธ,ๆฐ็ฝๅบ':(25.1,117.03),
# '็ฆๅปบ็,้พๅฒฉๅธ,้ฟๆฑๅฟ':(25.83,116.35),
# '็ฆๅปบ็,้พๅฒฉๅธ,ๆฐธๅฎๅฟ':(24.72,116.73),
# '็ฆๅปบ็,้พๅฒฉๅธ,ไธๆญๅฟ':(25.05,116.42),
# '็ฆๅปบ็,้พๅฒฉๅธ,ๆญฆๅนณๅฟ':(25.1,116.1),
# '็ฆๅปบ็,้พๅฒฉๅธ,่ฟๅๅฟ':(25.72,116.75),
# '็ฆๅปบ็,้พๅฒฉๅธ,ๆผณๅนณๅธ':(25.3,117.42),
# '็ฆๅปบ็,ๅฎๅพทๅธ,ๅฎๅพทๅธ':(26.67,119.52),
# '็ฆๅปบ็,ๅฎๅพทๅธ,่ๅๅบ':(26.67,119.52),
# '็ฆๅปบ็,ๅฎๅพทๅธ,้ๆตฆๅฟ':(26.88,120.0),
# '็ฆๅปบ็,ๅฎๅพทๅธ,ๅค็ฐๅฟ':(26.58,118.75),
# '็ฆๅปบ็,ๅฎๅพทๅธ,ๅฑๅๅฟ':(26.92,118.98),
# '็ฆๅปบ็,ๅฎๅพทๅธ,ๅฏฟๅฎๅฟ':(27.47,119.5),
# '็ฆๅปบ็,ๅฎๅพทๅธ,ๅจๅฎๅฟ':(27.12,119.33),
# '็ฆๅปบ็,ๅฎๅพทๅธ,ๆ่ฃๅฟ':(27.23,119.9),
# '็ฆๅปบ็,ๅฎๅพทๅธ,็ฆๅฎๅธ':(27.08,119.65),
# '็ฆๅปบ็,ๅฎๅพทๅธ,็ฆ้ผๅธ':(27.33,120.22),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,ๅๆๅธ':(28.68,115.85),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,ไธๆนๅบ':(28.68,115.9),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,่ฅฟๆนๅบ':(28.67,115.87),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,้ไบ่ฐฑๅบ':(28.63,115.92),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,ๆนพ้ๅบ':(28.72,115.73),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,้ๅฑฑๆนๅบ':(28.68,115.95),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,ๅๆๅฟ':(28.55,115.93),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,ๆฐๅปบๅฟ':(28.7,115.82),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,ๅฎไนๅฟ':(28.85,115.55),
# 'ๆฑ่ฅฟ็,ๅๆๅธ,่ฟ่ดคๅฟ':(28.37,116.27),
# 'ๆฑ่ฅฟ็,ๆฏๅพท้ๅธ,ๆฏๅพท้ๅธ':(29.27,117.17),
# 'ๆฑ่ฅฟ็,ๆฏๅพท้ๅธ,ๆๆฑๅบ':(29.27,117.17),
# 'ๆฑ่ฅฟ็,ๆฏๅพท้ๅธ,็ ๅฑฑๅบ':(29.3,117.2),
# 'ๆฑ่ฅฟ็,ๆฏๅพท้ๅธ,ๆตฎๆขๅฟ':(29.37,117.25),
# 'ๆฑ่ฅฟ็,ๆฏๅพท้ๅธ,ไนๅนณๅธ':(28.97,117.12),
# 'ๆฑ่ฅฟ็,่ไนกๅธ,่ไนกๅธ':(27.63,113.85),
# 'ๆฑ่ฅฟ็,่ไนกๅธ,ๅฎๆบๅบ':(27.65,113.87),
# 'ๆฑ่ฅฟ็,่ไนกๅธ,ๆนไธๅบ':(27.65,113.73),
# 'ๆฑ่ฅฟ็,่ไนกๅธ,่ฒ่ฑๅฟ':(27.13,113.95),
# 'ๆฑ่ฅฟ็,่ไนกๅธ,ไธๆ ๅฟ':(27.88,113.8),
# 'ๆฑ่ฅฟ็,่ไนกๅธ,่ฆๆบชๅฟ':(27.63,114.03),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ไนๆฑๅธ':(29.7,116.0),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๅบๅฑฑๅบ':(29.68,115.98),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๆต้ณๅบ':(29.73,115.98),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ไนๆฑๅฟ':(29.62,115.88),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๆญฆๅฎๅฟ':(29.27,115.1),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ไฟฎๆฐดๅฟ':(29.03,114.57),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๆฐธไฟฎๅฟ':(29.03,115.8),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๅพทๅฎๅฟ':(29.33,115.77),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๆๅญๅฟ':(29.45,116.03),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,้ฝๆๅฟ':(29.27,116.18),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๆนๅฃๅฟ':(29.73,116.22),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,ๅฝญๆณฝๅฟ':(29.9,116.55),
# 'ๆฑ่ฅฟ็,ไนๆฑๅธ,็ๆๅธ':(29.68,115.67),
# 'ๆฑ่ฅฟ็,ๆฐไฝๅธ,ๆฐไฝๅธ':(27.82,114.92),
# 'ๆฑ่ฅฟ็,ๆฐไฝๅธ,ๆธๆฐดๅบ':(27.8,114.93),
# 'ๆฑ่ฅฟ็,ๆฐไฝๅธ,ๅๅฎๅฟ':(27.82,114.67),
# 'ๆฑ่ฅฟ็,้นฐๆฝญๅธ,้นฐๆฝญๅธ':(28.27,117.07),
# 'ๆฑ่ฅฟ็,้นฐๆฝญๅธ,ๆๆนๅบ':(28.23,117.05),
# 'ๆฑ่ฅฟ็,้นฐๆฝญๅธ,ไฝๆฑๅฟ':(28.2,116.82),
# 'ๆฑ่ฅฟ็,้นฐๆฝญๅธ,่ดตๆบชๅธ':(28.28,117.22),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,่ตฃๅทๅธ':(25.83,114.93),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,็ซ ่ดกๅบ':(25.87,114.93),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,่ตฃๅฟ':(25.87,115.0),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ไฟกไธฐๅฟ':(25.38,114.93),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅคงไฝๅฟ':(25.4,114.35),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ไธ็นๅฟ':(25.8,114.53),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅดไนๅฟ':(25.7,114.3),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅฎ่ฟๅฟ':(25.13,115.38),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,้พๅๅฟ':(24.92,114.78),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅฎๅๅฟ':(24.78,115.03),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅ
จๅๅฟ':(24.75,114.52),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅฎ้ฝๅฟ':(26.48,116.02),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ไบ้ฝๅฟ':(25.95,115.42),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅ
ดๅฝๅฟ':(26.33,115.35),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ไผๆๅฟ':(25.6,115.78),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅฏปไนๅฟ':(24.95,115.65),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,็ณๅๅฟ':(26.33,116.33),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,็้ๅธ':(25.88,116.03),
# 'ๆฑ่ฅฟ็,่ตฃๅทๅธ,ๅๅบทๅธ':(25.65,114.75),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๅๅฎๅธ':(27.12,114.98),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๅๅทๅบ':(27.12,114.98),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,้ๅๅบ':(27.1,115.0),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๅๅฎๅฟ':(27.05,114.9),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๅๆฐดๅฟ':(27.22,115.13),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๅณกๆฑๅฟ':(27.62,115.33),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๆฐๅนฒๅฟ':(27.77,115.4),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๆฐธไธฐๅฟ':(27.32,115.43),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๆณฐๅๅฟ':(26.8,114.88),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,้ๅทๅฟ':(26.33,114.52),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ไธๅฎๅฟ':(26.47,114.78),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๅฎ็ฆๅฟ':(27.38,114.62),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ๆฐธๆฐๅฟ':(26.95,114.23),
# 'ๆฑ่ฅฟ็,ๅๅฎๅธ,ไบๅๅฑฑๅธ':(26.72,114.27),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ๅฎๆฅๅธ':(27.8,114.38),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,่ขๅทๅบ':(27.8,114.38),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ๅฅๆฐๅฟ':(28.7,115.38),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ไธ่ฝฝๅฟ':(28.12,114.43),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ไธ้ซๅฟ':(28.23,114.92),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ๅฎไธฐๅฟ':(28.38,114.78),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,้ๅฎๅฟ':(28.87,115.35),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,้้ผๅฟ':(28.53,114.37),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ไธฐๅๅธ':(28.2,115.78),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,ๆจๆ ๅธ':(28.07,115.53),
# 'ๆฑ่ฅฟ็,ๅฎๆฅๅธ,้ซๅฎๅธ':(28.42,115.37),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ๆๅทๅธ':(28.0,116.35),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ไธดๅทๅบ':(27.98,116.35),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ๅๅๅฟ':(27.55,116.63),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,้ปๅทๅฟ':(27.3,116.92),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ๅไธฐๅฟ':(27.22,116.53),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ๅดไปๅฟ':(27.77,116.05),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ไนๅฎๅฟ':(27.43,115.83),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ๅฎ้ปๅฟ':(27.55,116.22),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,้ๆบชๅฟ':(27.92,116.77),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,่ตๆบชๅฟ':(27.7,117.07),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ไธไนกๅฟ':(28.23,116.62),
# 'ๆฑ่ฅฟ็,ๆๅทๅธ,ๅนฟๆๅฟ':(26.83,116.32),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ไธ้ฅถๅธ':(28.45,117.97),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ไฟกๅทๅบ':(28.43,117.95),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ไธ้ฅถๅฟ':(28.43,117.92),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ๅนฟไธฐๅฟ':(28.43,118.18),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,็ๅฑฑๅฟ':(28.68,118.25),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,้
ๅฑฑๅฟ':(28.32,117.7),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ๆจชๅณฐๅฟ':(28.42,117.6),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ๅผ้ณๅฟ':(28.4,117.43),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ไฝๅนฒๅฟ':(28.7,116.68),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,้ฑ้ณๅฟ':(29.0,116.67),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ไธๅนดๅฟ':(28.7,117.07),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ๅฉบๆบๅฟ':(29.25,117.85),
# 'ๆฑ่ฅฟ็,ไธ้ฅถๅธ,ๅพทๅ
ดๅธ':(28.95,117.57),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๆตๅๅธ':(36.67,116.98),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅไธๅบ':(36.67,117.08),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅธไธญๅบ':(36.65,117.0),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅธไธญๅบ':(35.4,116.58),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅธไธญๅบ':(34.87,117.57),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๆง่ซๅบ':(36.65,116.93),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅคฉๆกฅๅบ':(36.68,116.98),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅๅๅบ':(36.68,117.07),
# 'ๅฑฑไธ็,ๆตๅๅธ,้ฟๆธ
ๅบ':(36.55,116.73),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅนณ้ดๅฟ':(36.28,116.45),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๆต้ณๅฟ':(36.98,117.22),
# 'ๅฑฑไธ็,ๆตๅๅธ,ๅๆฒณๅฟ':(37.32,117.15),
# 'ๅฑฑไธ็,ๆตๅๅธ,็ซ ไธๅธ':(36.72,117.53),
# 'ๅฑฑไธ็,้ๅฒๅธ,้ๅฒๅธ':(36.07,120.38),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅธๅๅบ':(36.07,120.38),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅธๅๅบ':(36.08,120.38),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅๆนๅบ':(36.1,120.35),
# 'ๅฑฑไธ็,้ๅฒๅธ,้ปๅฒๅบ':(35.97,120.18),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅดๅฑฑๅบ':(36.1,120.47),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๆๆฒงๅบ':(36.15,120.43),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅ้ณๅบ':(36.3,120.37),
# 'ๅฑฑไธ็,้ๅฒๅธ,่ถๅทๅธ':(36.27,120.03),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅณๅขจๅธ':(36.38,120.45),
# 'ๅฑฑไธ็,้ๅฒๅธ,ๅนณๅบฆๅธ':(36.78,119.95),
# 'ๅฑฑไธ็,้ๅฒๅธ,่ถๅๅธ':(35.87,120.03),
# 'ๅฑฑไธ็,้ๅฒๅธ,่ฑ่ฅฟๅธ':(36.87,120.5),
# 'ๅฑฑไธ็,ๆทๅๅธ,ๆทๅๅธ':(36.82,118.05),
# 'ๅฑฑไธ็,ๆทๅๅธ,ๅผ ๅบๅบ':(36.82,118.03),
# 'ๅฑฑไธ็,ๆทๅๅธ,ๅๅฑฑๅบ':(36.5,117.85),
# 'ๅฑฑไธ็,ๆทๅๅธ,ไธดๆทๅบ':(36.82,118.3),
# 'ๅฑฑไธ็,ๆทๅๅธ,ๅจๆๅบ':(36.8,117.87),
# 'ๅฑฑไธ็,ๆทๅๅธ,ๆกๅฐๅฟ':(36.97,118.08),
# 'ๅฑฑไธ็,ๆทๅๅธ,้ซ้ๅฟ':(37.17,117.82),
# 'ๅฑฑไธ็,ๆทๅๅธ,ๆฒๆบๅฟ':(36.18,118.17),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๆฃๅบๅธ':(34.82,117.32),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๅธไธญๅบ':(36.65,117.0),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๅธไธญๅบ':(35.4,116.58),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๅธไธญๅบ':(34.87,117.57),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,่ๅๅบ':(34.8,117.25),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๅณๅๅบ':(34.77,117.58),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๅฐๅฟๅบๅบ':(34.57,117.73),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๅฑฑไบญๅบ':(35.08,117.45),
# 'ๅฑฑไธ็,ๆฃๅบๅธ,ๆปๅทๅธ':(35.08,117.15),
# 'ๅฑฑไธ็,ไธ่ฅๅธ,ไธ่ฅๅธ':(37.43,118.67),
# 'ๅฑฑไธ็,ไธ่ฅๅธ,ไธ่ฅๅบ':(37.47,118.5),
# 'ๅฑฑไธ็,ไธ่ฅๅธ,ๆฒณๅฃๅบ':(37.88,118.53),
# 'ๅฑฑไธ็,ไธ่ฅๅธ,ๅฆๅฉๅฟ':(37.58,118.55),
# 'ๅฑฑไธ็,ไธ่ฅๅธ,ๅฉๆดฅๅฟ':(37.48,118.25),
# 'ๅฑฑไธ็,ไธ่ฅๅธ,ๅนฟ้ฅถๅฟ':(37.07,118.4),
# 'ๅฑฑไธ็,็ๅฐๅธ,็ๅฐๅธ':(37.45,121.43),
# 'ๅฑฑไธ็,็ๅฐๅธ,่็ฝๅบ':(37.53,121.38),
# 'ๅฑฑไธ็,็ๅฐๅธ,็ฆๅฑฑๅบ':(37.5,121.25),
# 'ๅฑฑไธ็,็ๅฐๅธ,็ๅนณๅบ':(37.38,121.6),
# 'ๅฑฑไธ็,็ๅฐๅธ,่ฑๅฑฑๅบ':(37.5,121.43),
# 'ๅฑฑไธ็,็ๅฐๅธ,้ฟๅฒๅฟ':(37.92,120.73),
# 'ๅฑฑไธ็,็ๅฐๅธ,้พๅฃๅธ':(37.65,120.52),
# 'ๅฑฑไธ็,็ๅฐๅธ,่ฑ้ณๅธ':(36.98,120.7),
# 'ๅฑฑไธ็,็ๅฐๅธ,่ฑๅทๅธ':(37.18,119.93),
# 'ๅฑฑไธ็,็ๅฐๅธ,่ฌ่ฑๅธ':(37.82,120.75),
# 'ๅฑฑไธ็,็ๅฐๅธ,ๆ่ฟๅธ':(37.37,120.4),
# 'ๅฑฑไธ็,็ๅฐๅธ,ๆ ้ๅธ':(37.3,120.83),
# 'ๅฑฑไธ็,็ๅฐๅธ,ๆตท้ณๅธ':(36.78,121.15),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๆฝๅๅธ':(36.7,119.15),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๆฝๅๅบ':(36.72,119.1),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๅฏไบญๅบ':(36.77,119.22),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๅๅญๅบ':(36.67,119.17),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๅฅๆๅบ':(36.72,119.12),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ไธดๆๅฟ':(36.52,118.53),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๆไนๅฟ':(36.7,118.82),
# 'ๅฑฑไธ็,ๆฝๅๅธ,้ๅทๅธ':(36.68,118.47),
# 'ๅฑฑไธ็,ๆฝๅๅธ,่ฏธๅๅธ':(36.0,119.4),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๅฏฟๅ
ๅธ':(36.88,118.73),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๅฎไธๅธ':(36.43,119.2),
# 'ๅฑฑไธ็,ๆฝๅๅธ,้ซๅฏๅธ':(36.38,119.75),
# 'ๅฑฑไธ็,ๆฝๅๅธ,ๆ้ๅธ':(36.87,119.4),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๆตๅฎๅธ':(35.42,116.58),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๅธไธญๅบ':(36.65,117.0),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๅธไธญๅบ':(35.4,116.58),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๅธไธญๅบ':(34.87,117.57),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ไปปๅๅบ':(35.42,116.58),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๅพฎๅฑฑๅฟ':(34.82,117.13),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,้ฑผๅฐๅฟ':(35.0,116.65),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,้ไนกๅฟ':(35.07,116.3),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๅ็ฅฅๅฟ':(35.42,116.33),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๆฑถไธๅฟ':(35.73,116.48),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๆณๆฐดๅฟ':(35.67,117.27),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๆขๅฑฑๅฟ':(35.8,116.08),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๆฒ้ๅธ':(35.58,116.98),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,ๅ
ๅทๅธ':(35.55,116.83),
# 'ๅฑฑไธ็,ๆตๅฎๅธ,้นๅๅธ':(35.4,116.97),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,ๆณฐๅฎๅธ':(36.2,117.08),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,ๆณฐๅฑฑๅบ':(36.18,117.13),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,ๅฒฑๅฒณๅบ':(36.18,117.0),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,ๅฎ้ณๅฟ':(35.77,116.8),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,ไธๅนณๅฟ':(35.93,116.47),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,ๆฐๆณฐๅธ':(35.92,117.77),
# 'ๅฑฑไธ็,ๆณฐๅฎๅธ,่ฅๅๅธ':(36.18,116.77),
# 'ๅฑฑไธ็,ๅจๆตทๅธ,ๅจๆตทๅธ':(37.52,122.12),
# 'ๅฑฑไธ็,ๅจๆตทๅธ,็ฏ็ฟ ๅบ':(37.5,122.12),
# 'ๅฑฑไธ็,ๅจๆตทๅธ,ๆ็ปๅธ':(37.2,122.05),
# 'ๅฑฑไธ็,ๅจๆตทๅธ,่ฃๆๅธ':(37.17,122.42),
# 'ๅฑฑไธ็,ๅจๆตทๅธ,ไนณๅฑฑๅธ':(36.92,121.53),
# 'ๅฑฑไธ็,ๆฅ็
งๅธ,ๆฅ็
งๅธ':(35.42,119.52),
# 'ๅฑฑไธ็,ๆฅ็
งๅธ,ไธๆธฏๅบ':(35.42,119.45),
# 'ๅฑฑไธ็,ๆฅ็
งๅธ,ๅฒๅฑฑๅบ':(35.1,119.33),
# 'ๅฑฑไธ็,ๆฅ็
งๅธ,ไบ่ฒๅฟ':(35.75,119.2),
# 'ๅฑฑไธ็,ๆฅ็
งๅธ,่ๅฟ':(35.58,118.83),
# 'ๅฑฑไธ็,่ฑ่ๅธ,่ฑ่ๅธ':(36.22,117.67),
# 'ๅฑฑไธ็,่ฑ่ๅธ,่ฑๅๅบ':(36.2,117.65),
# 'ๅฑฑไธ็,่ฑ่ๅธ,้ขๅๅบ':(36.07,117.8),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ไธดๆฒๅธ':(35.05,118.35),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ๅ
ฐๅฑฑๅบ':(35.07,118.33),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,็ฝๅบๅบ':(34.98,118.28),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ๆฒณไธๅบ':(35.08,118.4),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ๆฒๅๅฟ':(35.55,118.47),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,้ฏๅๅฟ':(34.62,118.35),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ๆฒๆฐดๅฟ':(35.78,118.62),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,่ๅฑฑๅฟ':(34.85,118.05),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,่ดนๅฟ':(35.27,117.97),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ๅนณ้ๅฟ':(35.5,117.63),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,่ๅๅฟ':(35.18,118.83),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,่้ดๅฟ':(35.72,117.93),
# 'ๅฑฑไธ็,ไธดๆฒๅธ,ไธดๆฒญๅฟ':(34.92,118.65),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๅพทๅทๅธ':(37.45,116.3),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๅพทๅๅบ':(37.45,116.3),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,้ตๅฟ':(37.33,116.57),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๅฎๆดฅๅฟ':(37.65,116.78),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๅบไบๅฟ':(37.78,117.38),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ไธด้ๅฟ':(37.18,116.87),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,้ฝๆฒณๅฟ':(36.8,116.75),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๅนณๅๅฟ':(37.17,116.43),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๅคๆดฅๅฟ':(36.95,116.0),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ๆญฆๅๅฟ':(37.22,116.07),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,ไน้ตๅธ':(37.73,117.23),
# 'ๅฑฑไธ็,ๅพทๅทๅธ,็ฆนๅๅธ':(36.93,116.63),
# 'ๅฑฑไธ็,่ๅๅธ,่ๅๅธ':(36.45,115.98),
# 'ๅฑฑไธ็,่ๅๅธ,ไธๆๅบๅบ':(36.45,115.98),
# 'ๅฑฑไธ็,่ๅๅธ,้ณ่ฐทๅฟ':(36.12,115.78),
# 'ๅฑฑไธ็,่ๅๅธ,่ๅฟ':(36.23,115.67),
# 'ๅฑฑไธ็,่ๅๅธ,่ๅนณๅฟ':(36.58,116.25),
# 'ๅฑฑไธ็,่ๅๅธ,ไธ้ฟๅฟ':(36.33,116.25),
# 'ๅฑฑไธ็,่ๅๅธ,ๅ ๅฟ':(36.48,115.43),
# 'ๅฑฑไธ็,่ๅๅธ,้ซๅๅฟ':(36.87,116.23),
# 'ๅฑฑไธ็,่ๅๅธ,ไธดๆธ
ๅธ':(36.85,115.7),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,ๆปจๅทๅธ':(37.38,117.97),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,ๆปจๅๅบ':(37.38,118.0),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,ๆ ๆฐๅฟ':(37.48,117.5),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,้ณไฟกๅฟ':(37.63,117.58),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,ๆ ๆฃฃๅฟ':(37.73,117.6),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,ๆฒพๅๅฟ':(37.7,118.13),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,ๅๅ
ดๅฟ':(37.15,118.13),
# 'ๅฑฑไธ็,ๆปจๅทๅธ,้นๅนณๅฟ':(36.88,117.73),
# 'ๅฑฑไธ็,่ๆณฝๅธ,็กไธนๅบ':(35.25,115.43),
# 'ๅฑฑไธ็,่ๆณฝๅธ,ๆนๅฟ':(34.83,115.53),
# 'ๅฑฑไธ็,่ๆณฝๅธ,ๅๅฟ':(34.8,116.08),
# 'ๅฑฑไธ็,่ๆณฝๅธ,ๆๆญฆๅฟ':(34.95,115.88),
# 'ๅฑฑไธ็,่ๆณฝๅธ,ๅทจ้ๅฟ':(35.4,116.08),
# 'ๅฑฑไธ็,่ๆณฝๅธ,้ๅๅฟ':(35.6,115.93),
# 'ๅฑฑไธ็,่ๆณฝๅธ,้ๅๅฟ':(35.57,115.5),
# 'ๅฑฑไธ็,่ๆณฝๅธ,ๅฎ้ถๅฟ':(35.07,115.57),
# 'ๅฑฑไธ็,่ๆณฝๅธ,ไธๆๅฟ':(35.28,115.08),
# 'ๆฒณๅ็,้ๅทๅธ,้ๅทๅธ':(34.75,113.62),
# 'ๆฒณๅ็,้ๅทๅธ,ไธญๅๅบ':(34.75,113.6),
# 'ๆฒณๅ็,้ๅทๅธ,ไบไธๅบ':(34.73,113.65),
# 'ๆฒณๅ็,้ๅทๅธ,็ฎกๅๅๆๅบ':(34.75,113.67),
# 'ๆฒณๅ็,้ๅทๅธ,้ๆฐดๅบ':(34.78,113.65),
# 'ๆฒณๅ็,้ๅทๅธ,ไธ่กๅบ':(34.82,113.28),
# 'ๆฒณๅ็,้ๅทๅธ,ๆ ๆตๅบ':(34.87,113.6),
# 'ๆฒณๅ็,้ๅทๅธ,ไธญ็ๅฟ':(34.72,113.97),
# 'ๆฒณๅ็,้ๅทๅธ,ๅทฉไนๅธ':(34.77,112.98),
# 'ๆฒณๅ็,้ๅทๅธ,่ฅ้ณๅธ':(34.78,113.4),
# 'ๆฒณๅ็,้ๅทๅธ,ๆฐๅฏๅธ':(34.53,113.38),
# 'ๆฒณๅ็,้ๅทๅธ,ๆฐ้ๅธ':(34.4,113.73),
# 'ๆฒณๅ็,้ๅทๅธ,็ปๅฐๅธ':(34.47,113.03),
# 'ๆฒณๅ็,ๅผๅฐๅธ,ๅผๅฐๅธ':(34.8,114.3),
# 'ๆฒณๅ็,ๅผๅฐๅธ,้พไบญๅบ':(34.8,114.35),
# 'ๆฒณๅ็,ๅผๅฐๅธ,้กบๆฒณๅๆๅบ':(34.8,114.35),
# 'ๆฒณๅ็,ๅผๅฐๅธ,้ผๆฅผๅบ':(34.78,114.35),
# 'ๆฒณๅ็,ๅผๅฐๅธ,ๆๅฟ':(34.55,114.78),
# 'ๆฒณๅ็,ๅผๅฐๅธ,้่ฎธๅฟ':(34.48,114.47),
# 'ๆฒณๅ็,ๅผๅฐๅธ,ๅฐๆฐๅฟ':(34.42,114.18),
# 'ๆฒณๅ็,ๅผๅฐๅธ,ๅผๅฐๅฟ':(34.77,114.43),
# 'ๆฒณๅ็,ๅผๅฐๅธ,ๅ
ฐ่ๅฟ':(34.82,114.82),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆด้ณๅธ':(34.62,112.45),
# 'ๆฒณๅ็,ๆด้ณๅธ,่ๅๅบ':(34.68,112.47),
# 'ๆฒณๅ็,ๆด้ณๅธ,่ฅฟๅทฅๅบ':(34.67,112.43),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆถง่ฅฟๅบ':(34.67,112.4),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๅๅฉๅบ':(34.9,112.58),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆด้พๅบ':(34.62,112.45),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๅญๆดฅๅฟ':(34.83,112.43),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆฐๅฎๅฟ':(34.72,112.15),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆ พๅทๅฟ':(33.78,111.62),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๅตฉๅฟ':(34.15,112.1),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆฑ้ณๅฟ':(34.15,112.47),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๅฎ้ณๅฟ':(34.52,112.17),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๆดๅฎๅฟ':(34.38,111.65),
# 'ๆฒณๅ็,ๆด้ณๅธ,ไผๅทๅฟ':(34.42,112.42),
# 'ๆฒณๅ็,ๆด้ณๅธ,ๅๅธๅธ':(34.73,112.78),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๅนณ้กถๅฑฑๅธ':(33.77,113.18),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๆฐๅๅบ':(33.73,113.3),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๅซไธๅบ':(33.73,113.33),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,็ณ้พๅบ':(33.9,112.88),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๆนๆฒณๅบ':(33.73,113.28),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๅฎไธฐๅฟ':(33.88,113.07),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๅถๅฟ':(33.62,113.35),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,้ฒๅฑฑๅฟ':(33.73,112.9),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,้ๅฟ':(33.97,113.22),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,่้ขๅธ':(33.3,113.52),
# 'ๆฒณๅ็,ๅนณ้กถๅฑฑๅธ,ๆฑๅทๅธ':(34.17,112.83),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๅฎ้ณๅธ':(36.1,114.38),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๆๅณฐๅบ':(36.08,114.35),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๅๅ
ณๅบ':(36.12,114.35),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๆฎท้ฝๅบ':(36.12,114.3),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,้พๅฎๅบ':(36.1,114.32),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๅฎ้ณๅฟ':(36.1,114.35),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๆฑค้ดๅฟ':(35.92,114.35),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๆปๅฟ':(35.58,114.52),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๅ
้ปๅฟ':(35.95,114.9),
# 'ๆฒณๅ็,ๅฎ้ณๅธ,ๆๅทๅธ':(36.07,113.82),
# 'ๆฒณๅ็,้นคๅฃๅธ,้นคๅฃๅธ':(35.75,114.28),
# 'ๆฒณๅ็,้นคๅฃๅธ,้นคๅฑฑๅบ':(35.95,114.15),
# 'ๆฒณๅ็,้นคๅฃๅธ,ๅฑฑๅๅบ':(35.9,114.18),
# 'ๆฒณๅ็,้นคๅฃๅธ,ๆทๆปจๅบ':(35.73,114.3),
# 'ๆฒณๅ็,้นคๅฃๅธ,ๆตๅฟ':(35.67,114.55),
# 'ๆฒณๅ็,้นคๅฃๅธ,ๆทๅฟ':(35.6,114.2),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๆฐไนกๅธ':(35.3,113.9),
# 'ๆฒณๅ็,ๆฐไนกๅธ,็บขๆๅบ':(35.3,113.87),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๅซๆปจๅบ':(35.3,113.85),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๅคๆณๅบ':(35.38,113.92),
# 'ๆฒณๅ็,ๆฐไนกๅธ,็ง้ๅบ':(35.32,113.9),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๆฐไนกๅฟ':(35.2,113.8),
# 'ๆฒณๅ็,ๆฐไนกๅธ,่ทๅๅฟ':(35.27,113.65),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๅ้ณๅฟ':(35.05,113.97),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๅปถๆดฅๅฟ':(35.15,114.2),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๅฐไธๅฟ':(35.05,114.42),
# 'ๆฒณๅ็,ๆฐไนกๅธ,้ฟๅฃๅฟ':(35.2,114.68),
# 'ๆฒณๅ็,ๆฐไนกๅธ,ๅซ่พๅธ':(35.4,114.07),
# 'ๆฒณๅ็,ๆฐไนกๅธ,่พๅฟๅธ':(35.47,113.8),
# 'ๆฒณๅ็,็ฆไฝๅธ,็ฆไฝๅธ':(35.22,113.25),
# 'ๆฒณๅ็,็ฆไฝๅธ,่งฃๆพๅบ':(35.25,113.22),
# 'ๆฒณๅ็,็ฆไฝๅธ,ไธญ็ซๅบ':(35.23,113.17),
# 'ๆฒณๅ็,็ฆไฝๅธ,้ฉฌๆๅบ':(35.27,113.32),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๅฑฑ้ณๅบ':(35.22,113.25),
# 'ๆฒณๅ็,็ฆไฝๅธ,ไฟฎๆญฆๅฟ':(35.23,113.43),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๅ็ฑๅฟ':(35.17,113.07),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๆญฆ้ๅฟ':(35.1,113.38),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๆธฉๅฟ':(34.93,113.08),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๆตๆบๅธ':(35.07,112.58),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๆฒ้ณๅธ':(35.08,112.93),
# 'ๆฒณๅ็,็ฆไฝๅธ,ๅญๅทๅธ':(34.9,112.78),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,ๆฟฎ้ณๅธ':(35.77,115.03),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,ๅ้พๅบ':(35.78,115.07),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,ๆธ
ไธฐๅฟ':(35.9,115.12),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,ๅไนๅฟ':(36.08,115.2),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,่ๅฟ':(35.87,115.5),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,ๅฐๅๅฟ':(36.0,115.85),
# 'ๆฒณๅ็,ๆฟฎ้ณๅธ,ๆฟฎ้ณๅฟ':(35.7,115.02),
# 'ๆฒณๅ็,่ฎธๆๅธ,่ฎธๆๅธ':(34.03,113.85),
# 'ๆฒณๅ็,่ฎธๆๅธ,้ญ้ฝๅบ':(34.03,113.82),
# 'ๆฒณๅ็,่ฎธๆๅธ,่ฎธๆๅฟ':(34.0,113.83),
# 'ๆฒณๅ็,่ฎธๆๅธ,้ข้ตๅฟ':(34.1,114.2),
# 'ๆฒณๅ็,่ฎธๆๅธ,่ฅๅๅฟ':(33.85,113.48),
# 'ๆฒณๅ็,่ฎธๆๅธ,็ฆนๅทๅธ':(34.17,113.47),
# 'ๆฒณๅ็,่ฎธๆๅธ,้ฟ่ๅธ':(34.22,113.77),
# 'ๆฒณๅ็,ๆผฏๆฒณๅธ,ๆผฏๆฒณๅธ':(33.58,114.02),
# 'ๆฒณๅ็,ๆผฏๆฒณๅธ,้พๅๅบ':(33.58,114.0),
# 'ๆฒณๅ็,ๆผฏๆฒณๅธ,ๅฌ้ตๅบ':(33.57,114.07),
# 'ๆฒณๅ็,ๆผฏๆฒณๅธ,่้ณๅฟ':(33.43,113.6),
# 'ๆฒณๅ็,ๆผฏๆฒณๅธ,ไธด้ขๅฟ':(33.82,113.93),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,ไธ้จๅณกๅธ':(34.78,111.2),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,ๆนๆปจๅบ':(34.78,111.2),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,ๆธๆฑ ๅฟ':(34.77,111.75),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,้ๅฟ':(34.7,111.08),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,ๅขๆฐๅฟ':(34.05,111.05),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,ไน้ฉฌๅธ':(34.75,111.87),
# 'ๆฒณๅ็,ไธ้จๅณกๅธ,็ตๅฎๅธ':(34.52,110.87),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๅ้ณๅธ':(33.0,112.52),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๅฎๅๅบ':(33.02,112.55),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๅง้พๅบ':(32.98,112.53),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๅๅฌๅฟ':(33.5,112.43),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๆนๅๅฟ':(33.27,113.0),
# 'ๆฒณๅ็,ๅ้ณๅธ,่ฅฟๅณกๅฟ':(33.28,111.48),
# 'ๆฒณๅ็,ๅ้ณๅธ,้ๅนณๅฟ':(33.03,112.23),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๅ
ไนกๅฟ':(33.05,111.85),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๆท
ๅทๅฟ':(33.13,111.48),
# 'ๆฒณๅ็,ๅ้ณๅธ,็คพๆๅฟ':(33.05,112.93),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๅๆฒณๅฟ':(32.7,112.83),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๆฐ้ๅฟ':(32.52,112.35),
# 'ๆฒณๅ็,ๅ้ณๅธ,ๆกๆๅฟ':(32.37,113.4),
# 'ๆฒณๅ็,ๅ้ณๅธ,้ๅทๅธ':(32.68,112.08),
# 'ๆฒณๅ็,ๅไธๅธ,ๅไธๅธ':(34.45,115.65),
# 'ๆฒณๅ็,ๅไธๅธ,ๆขๅญๅบ':(34.45,115.63),
# 'ๆฒณๅ็,ๅไธๅธ,็ข้ณๅบ':(34.38,115.63),
# 'ๆฒณๅ็,ๅไธๅธ,ๆฐๆๅฟ':(34.65,115.13),
# 'ๆฒณๅ็,ๅไธๅธ,็ขๅฟ':(34.45,115.07),
# 'ๆฒณๅ็,ๅไธๅธ,ๅฎ้ตๅฟ':(34.45,115.32),
# 'ๆฒณๅ็,ๅไธๅธ,ๆๅๅฟ':(34.07,115.3),
# 'ๆฒณๅ็,ๅไธๅธ,่ๅๅฟ':(34.4,115.85),
# 'ๆฒณๅ็,ๅไธๅธ,ๅค้ๅฟ':(34.23,116.13),
# 'ๆฒณๅ็,ๅไธๅธ,ๆฐธๅๅธ':(33.92,116.43),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ไฟก้ณๅธ':(32.13,114.07),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๆตๆฒณๅบ':(32.12,114.05),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๅนณๆกฅๅบ':(32.1,114.12),
# 'ๆฒณๅ็,ไฟก้ณๅธ,็ฝๅฑฑๅฟ':(32.2,114.53),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๅ
ๅฑฑๅฟ':(32.02,114.9),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๆฐๅฟ':(31.63,114.87),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๅๅๅฟ':(31.8,115.4),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๅบๅงๅฟ':(32.18,115.68),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๆฝขๅทๅฟ':(32.13,115.03),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๆทฎๆปจๅฟ':(32.43,115.4),
# 'ๆฒณๅ็,ไฟก้ณๅธ,ๆฏๅฟ':(32.35,114.73),
# 'ๆฒณๅ็,ๅจๅฃๅธ,ๅจๅฃๅธ':(33.62,114.65),
# 'ๆฒณๅ็,ๅจๅฃๅธ,ๆถๆฒๅฟ':(34.07,114.38),
# 'ๆฒณๅ็,ๅจๅฃๅธ,่ฅฟๅๅฟ':(33.8,114.53),
# 'ๆฒณๅ็,ๅจๅฃๅธ,ๅๆฐดๅฟ':(33.53,114.6),
# 'ๆฒณๅ็,ๅจๅฃๅธ,ๆฒไธๅฟ':(33.4,115.07),
# 'ๆฒณๅ็,ๅจๅฃๅธ,้ธๅๅฟ':(33.65,115.2),
# 'ๆฒณๅ็,ๅจๅฃๅธ,ๆทฎ้ณๅฟ':(33.73,114.88),
# 'ๆฒณๅ็,ๅจๅฃๅธ,ๅคชๅบทๅฟ':(34.07,114.85),
# 'ๆฒณๅ็,ๅจๅฃๅธ,้นฟ้ๅฟ':(33.87,115.48),
# 'ๆฒณๅ็,ๅจๅฃๅธ,้กนๅๅธ':(33.45,114.9),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,้ฉป้ฉฌๅบๅธ':(32.98,114.02),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,้ฉฟๅๅบ':(32.97,114.05),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,่ฅฟๅนณๅฟ':(33.38,114.02),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,ไธ่กๅฟ':(33.27,114.27),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,ๅนณ่ๅฟ':(32.97,114.63),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,ๆญฃ้ณๅฟ':(32.6,114.38),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,็กฎๅฑฑๅฟ':(32.8,114.02),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,ๆณ้ณๅฟ':(32.72,113.32),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,ๆฑๅๅฟ':(33.0,114.35),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,้ๅนณๅฟ':(33.15,114.0),
# 'ๆฒณๅ็,้ฉป้ฉฌๅบๅธ,ๆฐ่กๅฟ':(32.75,114.98),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆญฆๆฑๅธ':(30.6,114.3),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆฑๅฒธๅบ':(30.6,114.3),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆฑๆฑๅบ':(30.6,114.27),
# 'ๆนๅ็,ๆญฆๆฑๅธ,็กๅฃๅบ':(30.57,114.27),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆฑ้ณๅบ':(30.55,114.27),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆญฆๆๅบ':(30.57,114.3),
# 'ๆนๅ็,ๆญฆๆฑๅธ,้ๅฑฑๅบ':(30.63,114.38),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆดชๅฑฑๅบ':(30.5,114.33),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ไธ่ฅฟๆนๅบ':(30.62,114.13),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆฑๅๅบ':(30.32,114.08),
# 'ๆนๅ็,ๆญฆๆฑๅธ,่ก็ธๅบ':(30.58,114.03),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆฑๅคๅบ':(30.35,114.32),
# 'ๆนๅ็,ๆญฆๆฑๅธ,้ป้ๅบ':(30.87,114.37),
# 'ๆนๅ็,ๆญฆๆฑๅธ,ๆฐๆดฒๅบ':(30.85,114.8),
# 'ๆนๅ็,้ป็ณๅธ,้ป็ณๅธ':(30.2,115.03),
# 'ๆนๅ็,้ป็ณๅธ,้ป็ณๆธฏๅบ':(30.23,115.07),
# 'ๆนๅ็,้ป็ณๅธ,่ฅฟๅกๅฑฑๅบ':(30.2,115.12),
# 'ๆนๅ็,้ป็ณๅธ,ไธ้ๅบ':(30.18,114.97),
# 'ๆนๅ็,้ป็ณๅธ,้ๅฑฑๅบ':(30.2,114.9),
# 'ๆนๅ็,้ป็ณๅธ,้ณๆฐๅฟ':(29.85,115.2),
# 'ๆนๅ็,้ป็ณๅธ,ๅคงๅถๅธ':(30.1,114.97),
# 'ๆนๅ็,ๅๅ ฐๅธ,ๅๅ ฐๅธ':(32.65,110.78),
# 'ๆนๅ็,ๅๅ ฐๅธ,่
็ฎญๅบ':(32.6,110.82),
# 'ๆนๅ็,ๅๅ ฐๅธ,ๅผ ๆนพๅบ':(32.65,110.78),
# 'ๆนๅ็,ๅๅ ฐๅธ,้งๅฟ':(32.83,110.82),
# 'ๆนๅ็,ๅๅ ฐๅธ,้ง่ฅฟๅฟ':(33.0,110.42),
# 'ๆนๅ็,ๅๅ ฐๅธ,็ซนๅฑฑๅฟ':(32.23,110.23),
# 'ๆนๅ็,ๅๅ ฐๅธ,็ซนๆบชๅฟ':(32.32,109.72),
# 'ๆนๅ็,ๅๅ ฐๅธ,ๆฟๅฟ':(32.07,110.73),
# 'ๆนๅ็,ๅๅ ฐๅธ,ไธนๆฑๅฃๅธ':(32.55,111.52),
# 'ๆนๅ็,ๅฎๆๅธ,ๅฎๆๅธ':(30.7,111.28),
# 'ๆนๅ็,ๅฎๆๅธ,่ฅฟ้ตๅบ':(30.7,111.27),
# 'ๆนๅ็,ๅฎๆๅธ,ไผๅฎถๅฒๅบ':(30.65,111.35),
# 'ๆนๅ็,ๅฎๆๅธ,็นๅๅบ':(30.7,111.27),
# 'ๆนๅ็,ๅฎๆๅธ,็ไบญๅบ':(30.53,111.42),
# 'ๆนๅ็,ๅฎๆๅธ,ๅคท้ตๅบ':(30.77,111.32),
# 'ๆนๅ็,ๅฎๆๅธ,่ฟๅฎๅฟ':(31.07,111.63),
# 'ๆนๅ็,ๅฎๆๅธ,ๅ
ดๅฑฑๅฟ':(31.35,110.75),
# 'ๆนๅ็,ๅฎๆๅธ,็งญๅฝๅฟ':(30.83,110.98),
# 'ๆนๅ็,ๅฎๆๅธ,้ฟ้ณๅๅฎถๆ่ชๆฒปๅฟ':(30.47,111.18),
# 'ๆนๅ็,ๅฎๆๅธ,ไบๅณฐๅๅฎถๆ่ชๆฒปๅฟ':(30.2,110.67),
# 'ๆนๅ็,ๅฎๆๅธ,ๅฎ้ฝๅธ':(30.4,111.45),
# 'ๆนๅ็,ๅฎๆๅธ,ๅฝ้ณๅธ':(30.82,111.78),
# 'ๆนๅ็,ๅฎๆๅธ,ๆๆฑๅธ':(30.43,111.77),
# 'ๆนๅ็,่ฅๆจๅธ,่ฅๆจๅธ':(32.02,112.15),
# 'ๆนๅ็,่ฅๆจๅธ,่ฅๅๅบ':(32.02,112.15),
# 'ๆนๅ็,่ฅๆจๅธ,ๆจๅๅบ':(32.03,112.13),
# 'ๆนๅ็,่ฅๆจๅธ,่ฅ้ณๅบ':(32.08,112.2),
# 'ๆนๅ็,่ฅๆจๅธ,ๅๆผณๅฟ':(31.78,111.83),
# 'ๆนๅ็,่ฅๆจๅธ,่ฐทๅๅฟ':(32.27,111.65),
# 'ๆนๅ็,่ฅๆจๅธ,ไฟๅบทๅฟ':(31.88,111.25),
# 'ๆนๅ็,่ฅๆจๅธ,่ๆฒณๅฃๅธ':(32.38,111.67),
# 'ๆนๅ็,่ฅๆจๅธ,ๆฃ้ณๅธ':(32.13,112.75),
# 'ๆนๅ็,่ฅๆจๅธ,ๅฎๅๅธ':(31.72,112.25),
# 'ๆนๅ็,้ๅทๅธ,้ๅทๅธ':(30.4,114.88),
# 'ๆนๅ็,้ๅทๅธ,ๆขๅญๆนๅบ':(30.08,114.67),
# 'ๆนๅ็,้ๅทๅธ,ๅๅฎนๅบ':(30.53,114.73),
# 'ๆนๅ็,้ๅทๅธ,้ๅๅบ':(30.4,114.88),
# 'ๆนๅ็,่้จๅธ,่้จๅธ':(31.03,112.2),
# 'ๆนๅ็,่้จๅธ,ไธๅฎๅบ':(31.05,112.2),
# 'ๆนๅ็,่้จๅธ,ๆๅๅบ':(30.98,112.2),
# 'ๆนๅ็,่้จๅธ,ไบฌๅฑฑๅฟ':(31.02,113.1),
# 'ๆนๅ็,่้จๅธ,ๆฒๆดๅฟ':(30.7,112.58),
# 'ๆนๅ็,่้จๅธ,้็ฅฅๅธ':(31.17,112.58),
# 'ๆนๅ็,ๅญๆๅธ,ๅญๆๅธ':(30.93,113.92),
# 'ๆนๅ็,ๅญๆๅธ,ๅญๅๅบ':(30.92,113.92),
# 'ๆนๅ็,ๅญๆๅธ,ๅญๆๅฟ':(31.25,113.97),
# 'ๆนๅ็,ๅญๆๅธ,ๅคงๆๅฟ':(31.57,114.12),
# 'ๆนๅ็,ๅญๆๅธ,ไบๆขฆๅฟ':(31.02,113.75),
# 'ๆนๅ็,ๅญๆๅธ,ๅบๅๅธ':(30.95,113.57),
# 'ๆนๅ็,ๅญๆๅธ,ๅฎ้ๅธ':(31.27,113.68),
# 'ๆนๅ็,ๅญๆๅธ,ๆฑๅทๅธ':(30.65,113.83),
# 'ๆนๅ็,่ๅทๅธ,่ๅทๅธ':(30.33,112.23),
# 'ๆนๅ็,่ๅทๅธ,ๆฒๅธๅบ':(30.32,112.25),
# 'ๆนๅ็,่ๅทๅธ,่ๅทๅบ':(30.35,112.18),
# 'ๆนๅ็,่ๅทๅธ,ๅ
ฌๅฎๅฟ':(30.07,112.23),
# 'ๆนๅ็,่ๅทๅธ,็ๅฉๅฟ':(29.82,112.88),
# 'ๆนๅ็,่ๅทๅธ,ๆฑ้ตๅฟ':(30.03,112.42),
# 'ๆนๅ็,่ๅทๅธ,็ณ้ฆๅธ':(29.73,112.4),
# 'ๆนๅ็,่ๅทๅธ,ๆดชๆนๅธ':(29.8,113.45),
# 'ๆนๅ็,่ๅทๅธ,ๆพๆปๅธ':(30.18,111.77),
# 'ๆนๅ็,้ปๅๅธ,้ปๅๅธ':(30.45,114.87),
# 'ๆนๅ็,้ปๅๅธ,้ปๅทๅบ':(30.43,114.88),
# 'ๆนๅ็,้ปๅๅธ,ๅข้ฃๅฟ':(30.63,114.87),
# 'ๆนๅ็,้ปๅๅธ,็บขๅฎๅฟ':(31.28,114.62),
# 'ๆนๅ็,้ปๅๅธ,็ฝ็ฐๅฟ':(30.78,115.4),
# 'ๆนๅ็,้ปๅๅธ,่ฑๅฑฑๅฟ':(30.75,115.67),
# 'ๆนๅ็,้ปๅๅธ,ๆต ๆฐดๅฟ':(30.45,115.27),
# 'ๆนๅ็,้ปๅๅธ,่ฒๆฅๅฟ':(30.23,115.43),
# 'ๆนๅ็,้ปๅๅธ,้ปๆข
ๅฟ':(30.08,115.93),
# 'ๆนๅ็,้ปๅๅธ,้บปๅๅธ':(31.18,115.03),
# 'ๆนๅ็,้ปๅๅธ,ๆญฆ็ฉดๅธ':(29.85,115.55),
# 'ๆนๅ็,ๅธๅฎๅธ,ๅธๅฎๅธ':(29.85,114.32),
# 'ๆนๅ็,ๅธๅฎๅธ,ๅธๅฎๅบ':(29.87,114.3),
# 'ๆนๅ็,ๅธๅฎๅธ,ๅ้ฑผๅฟ':(29.98,113.9),
# 'ๆนๅ็,ๅธๅฎๅธ,้ๅๅฟ':(29.25,113.82),
# 'ๆนๅ็,ๅธๅฎๅธ,ๅด้ณๅฟ':(29.55,114.03),
# 'ๆนๅ็,ๅธๅฎๅธ,้ๅฑฑๅฟ':(29.6,114.52),
# 'ๆนๅ็,ๅธๅฎๅธ,่ตคๅฃๅธ':(29.72,113.88),
# 'ๆนๅ็,้ๅทๅธ,้ๅทๅธ':(31.72,113.37),
# 'ๆนๅ็,้ๅทๅธ,ๆพ้ฝๅบ':(31.72,113.37),
# 'ๆนๅ็,้ๅทๅธ,ๅนฟๆฐดๅธ':(31.62,113.82),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅท':(30.3,109.47),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๆฉๆฝๅธ':(30.3,109.47),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅฉๅทๅธ':(30.3,108.93),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅปบๅงๅฟ':(30.6,109.73),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅทดไธๅฟ':(31.05,110.33),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅฎฃๆฉๅฟ':(29.98,109.48),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅธไธฐๅฟ':(29.68,109.15),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๆฅๅคๅฟ':(29.52,109.4),
# 'ๆนๅ็,ๆฉๆฝๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,้นคๅณฐๅฟ':(29.9,110.03),
# 'ๆนๅ็,ไปๆกๅธ,ไปๆกๅธ':(30.37,113.45),
# 'ๆนๅ็,ไปๆกๅธ,ๆฝๆฑๅธ':(30.42,112.88),
# 'ๆนๅ็,ไปๆกๅธ,ๅคฉ้จๅธ':(30.67,113.17),
# 'ๆนๅ็,ไปๆกๅธ,็ฅๅๆถๆๅบ':(31.75,110.67),
# 'ๆนๅ็,้ฟๆฒๅธ,้ฟๆฒๅธ':(28.23,112.93),
# 'ๆนๅ็,้ฟๆฒๅธ,่่ๅบ':(28.18,113.03),
# 'ๆนๅ็,้ฟๆฒๅธ,ๅคฉๅฟๅบ':(28.12,112.98),
# 'ๆนๅ็,้ฟๆฒๅธ,ๅฒณ้บๅบ':(28.23,112.93),
# 'ๆนๅ็,้ฟๆฒๅธ,ๅผ็ฆๅบ':(28.25,112.98),
# 'ๆนๅ็,้ฟๆฒๅธ,้จ่ฑๅบ':(28.13,113.03),
# 'ๆนๅ็,้ฟๆฒๅธ,้ฟๆฒๅฟ':(28.25,113.07),
# 'ๆนๅ็,้ฟๆฒๅธ,ๆๅๅฟ':(28.37,112.82),
# 'ๆนๅ็,้ฟๆฒๅธ,ๅฎไนกๅฟ':(28.25,112.55),
# 'ๆนๅ็,้ฟๆฒๅธ,ๆต้ณๅธ':(28.15,113.63),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,ๆ ชๆดฒๅธ':(27.83,113.13),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,่ทๅกๅบ':(27.87,113.17),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,่ฆๆทๅบ':(27.83,113.15),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,็ณๅณฐๅบ':(27.87,113.1),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,ๅคฉๅ
ๅบ':(27.83,113.12),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,ๆ ชๆดฒๅฟ':(27.72,113.13),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,ๆธๅฟ':(27.0,113.33),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,่ถ้ตๅฟ':(26.8,113.53),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,็้ตๅฟ':(26.48,113.77),
# 'ๆนๅ็,ๆ ชๆดฒๅธ,้ด้ตๅธ':(27.67,113.48),
# 'ๆนๅ็,ๆนๆฝญๅธ,ๆนๆฝญๅธ':(27.83,112.93),
# 'ๆนๅ็,ๆนๆฝญๅธ,้จๆนๅบ':(27.87,112.9),
# 'ๆนๅ็,ๆนๆฝญๅธ,ๅฒณๅกๅบ':(27.87,112.95),
# 'ๆนๅ็,ๆนๆฝญๅธ,ๆนๆฝญๅฟ':(27.78,112.95),
# 'ๆนๅ็,ๆนๆฝญๅธ,ๆนไนกๅธ':(27.73,112.53),
# 'ๆนๅ็,ๆนๆฝญๅธ,้ถๅฑฑๅธ':(27.93,112.52),
# 'ๆนๅ็,่กก้ณๅธ,่กก้ณๅธ':(26.9,112.57),
# 'ๆนๅ็,่กก้ณๅธ,็ ๆๅบ':(26.9,112.62),
# 'ๆนๅ็,่กก้ณๅธ,้ๅณฐๅบ':(26.88,112.6),
# 'ๆนๅ็,่กก้ณๅธ,็ณ้ผๅบ':(26.9,112.6),
# 'ๆนๅ็,่กก้ณๅธ,่ธๆนๅบ':(26.9,112.6),
# 'ๆนๅ็,่กก้ณๅธ,ๅๅฒณๅบ':(27.25,112.73),
# 'ๆนๅ็,่กก้ณๅธ,่กก้ณๅฟ':(26.97,112.37),
# 'ๆนๅ็,่กก้ณๅธ,่กกๅๅฟ':(26.73,112.67),
# 'ๆนๅ็,่กก้ณๅธ,่กกๅฑฑๅฟ':(27.23,112.87),
# 'ๆนๅ็,่กก้ณๅธ,่กกไธๅฟ':(27.08,112.95),
# 'ๆนๅ็,่กก้ณๅธ,็ฅไธๅฟ':(26.78,112.12),
# 'ๆนๅ็,่กก้ณๅธ,่้ณๅธ':(26.42,112.85),
# 'ๆนๅ็,่กก้ณๅธ,ๅธธๅฎๅธ':(26.42,112.38),
# 'ๆนๅ็,้ต้ณๅธ,้ต้ณๅธ':(27.25,111.47),
# 'ๆนๅ็,้ต้ณๅธ,ๅๆธ
ๅบ':(27.23,111.47),
# 'ๆนๅ็,้ต้ณๅธ,ๅคง็ฅฅๅบ':(27.23,111.45),
# 'ๆนๅ็,้ต้ณๅธ,ๅๅกๅบ':(27.25,111.45),
# 'ๆนๅ็,้ต้ณๅธ,้ตไธๅฟ':(27.25,111.75),
# 'ๆนๅ็,้ต้ณๅธ,ๆฐ้ตๅฟ':(27.32,111.45),
# 'ๆนๅ็,้ต้ณๅธ,้ต้ณๅฟ':(27.0,111.27),
# 'ๆนๅ็,้ต้ณๅธ,้ๅๅฟ':(27.12,111.03),
# 'ๆนๅ็,้ต้ณๅธ,ๆดๅฃๅฟ':(27.05,110.57),
# 'ๆนๅ็,้ต้ณๅธ,็ปฅๅฎๅฟ':(26.58,110.15),
# 'ๆนๅ็,้ต้ณๅธ,ๆฐๅฎๅฟ':(26.43,110.85),
# 'ๆนๅ็,้ต้ณๅธ,ๅๆญฅ่ๆ่ชๆฒปๅฟ':(26.37,110.32),
# 'ๆนๅ็,้ต้ณๅธ,ๆญฆๅๅธ':(26.73,110.63),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๅฒณ้ณๅธ':(29.37,113.12),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๅฒณ้ณๆฅผๅบ':(29.37,113.1),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ไบๆบชๅบ':(29.47,113.3),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๅๅฑฑๅบ':(29.43,113.0),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๅฒณ้ณๅฟ':(29.15,113.12),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๅๅฎนๅฟ':(29.52,112.57),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๆน้ดๅฟ':(28.68,112.88),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๅนณๆฑๅฟ':(28.72,113.58),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ๆฑจ็ฝๅธ':(28.8,113.08),
# 'ๆนๅ็,ๅฒณ้ณๅธ,ไธดๆนๅธ':(29.48,113.47),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๅธธๅพทๅธ':(29.05,111.68),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๆญฆ้ตๅบ':(29.03,111.68),
# 'ๆนๅ็,ๅธธๅพทๅธ,้ผๅๅบ':(29.02,111.68),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๅฎไนกๅฟ':(29.42,112.17),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๆฑๅฏฟๅฟ':(28.9,111.97),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๆพงๅฟ':(29.63,111.75),
# 'ๆนๅ็,ๅธธๅพทๅธ,ไธดๆพงๅฟ':(29.45,111.65),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๆกๆบๅฟ':(28.9,111.48),
# 'ๆนๅ็,ๅธธๅพทๅธ,็ณ้จๅฟ':(29.58,111.38),
# 'ๆนๅ็,ๅธธๅพทๅธ,ๆดฅๅธๅธ':(29.62,111.88),
# 'ๆนๅ็,ๅผ ๅฎถ็ๅธ,ๅผ ๅฎถ็ๅธ':(29.13,110.47),
# 'ๆนๅ็,ๅผ ๅฎถ็ๅธ,ๆฐธๅฎๅบ':(29.13,110.48),
# 'ๆนๅ็,ๅผ ๅฎถ็ๅธ,ๆญฆ้ตๆบๅบ':(29.35,110.53),
# 'ๆนๅ็,ๅผ ๅฎถ็ๅธ,ๆ
ๅฉๅฟ':(29.42,111.12),
# 'ๆนๅ็,ๅผ ๅฎถ็ๅธ,ๆกๆคๅฟ':(29.4,110.15),
# 'ๆนๅ็,็้ณๅธ,็้ณๅธ':(28.6,112.32),
# 'ๆนๅ็,็้ณๅธ,่ต้ณๅบ':(28.6,112.32),
# 'ๆนๅ็,็้ณๅธ,่ตซๅฑฑๅบ':(28.6,112.37),
# 'ๆนๅ็,็้ณๅธ,ๅๅฟ':(29.38,112.4),
# 'ๆนๅ็,็้ณๅธ,ๆกๆฑๅฟ':(28.53,112.12),
# 'ๆนๅ็,็้ณๅธ,ๅฎๅๅฟ':(28.38,111.22),
# 'ๆนๅ็,็้ณๅธ,ๆฒ
ๆฑๅธ':(28.85,112.38),
# 'ๆนๅ็,้ดๅทๅธ,้ดๅทๅธ':(25.78,113.02),
# 'ๆนๅ็,้ดๅทๅธ,ๅๆนๅบ':(25.8,113.02),
# 'ๆนๅ็,้ดๅทๅธ,่ไปๅบ':(25.8,113.03),
# 'ๆนๅ็,้ดๅทๅธ,ๆก้ณๅฟ':(25.73,112.73),
# 'ๆนๅ็,้ดๅทๅธ,ๅฎ็ซ ๅฟ':(25.4,112.95),
# 'ๆนๅ็,้ดๅทๅธ,ๆฐธๅ
ดๅฟ':(26.13,113.1),
# 'ๆนๅ็,้ดๅทๅธ,ๅ็ฆพๅฟ':(25.58,112.37),
# 'ๆนๅ็,้ดๅทๅธ,ไธดๆญฆๅฟ':(25.28,112.55),
# 'ๆนๅ็,้ดๅทๅธ,ๆฑๅๅฟ':(25.55,113.68),
# 'ๆนๅ็,้ดๅทๅธ,ๆกไธๅฟ':(26.08,113.93),
# 'ๆนๅ็,้ดๅทๅธ,ๅฎไปๅฟ':(26.7,113.27),
# 'ๆนๅ็,้ดๅทๅธ,่ตๅ
ดๅธ':(25.98,113.23),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๆฐธๅทๅธ':(26.43,111.62),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๅทๆฐดๆปฉๅบ':(26.43,111.6),
# 'ๆนๅ็,ๆฐธๅทๅธ,็ฅ้ณๅฟ':(26.58,111.85),
# 'ๆนๅ็,ๆฐธๅทๅธ,ไธๅฎๅฟ':(26.4,111.28),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๅ็ๅฟ':(25.97,111.65),
# 'ๆนๅ็,ๆฐธๅทๅธ,้ๅฟ':(25.53,111.58),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๆฑๆฐธๅฟ':(25.28,111.33),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๅฎ่ฟๅฟ':(25.6,111.93),
# 'ๆนๅ็,ๆฐธๅทๅธ,่ๅฑฑๅฟ':(25.37,112.18),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๆฐ็ฐๅฟ':(25.92,112.22),
# 'ๆนๅ็,ๆฐธๅทๅธ,ๆฑๅ็ถๆ่ชๆฒปๅฟ':(25.18,111.58),
# 'ๆนๅ็,ๆๅๅธ,ๆๅๅธ':(27.57,110.0),
# 'ๆนๅ็,ๆๅๅธ,้นคๅๅบ':(27.55,109.95),
# 'ๆนๅ็,ๆๅๅธ,ไธญๆนๅฟ':(27.4,109.93),
# 'ๆนๅ็,ๆๅๅธ,ๆฒ
้ตๅฟ':(28.47,110.38),
# 'ๆนๅ็,ๆๅๅธ,่พฐๆบชๅฟ':(28.0,110.18),
# 'ๆนๅ็,ๆๅๅธ,ๆบๆตฆๅฟ':(27.92,110.58),
# 'ๆนๅ็,ๆๅๅธ,ไผๅๅฟ':(26.87,109.72),
# 'ๆนๅ็,ๆๅๅธ,้บป้ณ่ๆ่ชๆฒปๅฟ':(27.87,109.8),
# 'ๆนๅ็,ๆๅๅธ,ๆฐๆไพๆ่ชๆฒปๅฟ':(27.37,109.17),
# 'ๆนๅ็,ๆๅๅธ,่ทๆฑไพๆ่ชๆฒปๅฟ':(27.45,109.68),
# 'ๆนๅ็,ๆๅๅธ,้ๅท่ๆไพๆ่ชๆฒปๅฟ':(26.58,109.68),
# 'ๆนๅ็,ๆๅๅธ,้้ไพๆ่ชๆฒปๅฟ':(26.17,109.78),
# 'ๆนๅ็,ๆๅๅธ,ๆดชๆฑๅธ':(27.2,109.82),
# 'ๆนๅ็,ๅจๅบๅธ,ๅจๅบๅธ':(27.73,112.0),
# 'ๆนๅ็,ๅจๅบๅธ,ๅจๆๅบ':(27.73,112.0),
# 'ๆนๅ็,ๅจๅบๅธ,ๅๅณฐๅฟ':(27.45,112.2),
# 'ๆนๅ็,ๅจๅบๅธ,ๆฐๅๅฟ':(27.75,111.3),
# 'ๆนๅ็,ๅจๅบๅธ,ๅทๆฐดๆฑๅธ':(27.68,111.43),
# 'ๆนๅ็,ๅจๅบๅธ,ๆถๆบๅธ':(27.7,111.67),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅท':(28.32,109.73),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅ้ฆๅธ':(28.32,109.73),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๆณธๆบชๅฟ':(28.22,110.22),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅคๅฐๅฟ':(27.95,109.6),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,่ฑๅฃๅฟ':(28.58,109.48),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ไฟ้ๅฟ':(28.72,109.65),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๅคไธๅฟ':(28.62,109.95),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,ๆฐธ้กบๅฟ':(29.0,109.85),
# 'ๆนๅ็,ๆน่ฅฟๅๅฎถๆ่ๆ่ชๆฒปๅทๅธ,้พๅฑฑๅฟ':(29.47,109.43),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,ๅนฟๅทๅธ':(23.13,113.27),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,่ๆนพๅบ':(23.13,113.23),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,่ถ็งๅบ':(23.13,113.27),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,ๆตท็ ๅบ':(23.1,113.25),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,ๅคฉๆฒณๅบ':(23.12,113.35),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,็ฝไบๅบ':(23.17,113.27),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,้ปๅๅบ':(23.1,113.45),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,็ช็ฆบๅบ':(22.95,113.35),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,่ฑ้ฝๅบ':(23.4,113.22),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,ๅขๅๅธ':(23.3,113.83),
# 'ๅนฟไธ็,ๅนฟๅทๅธ,ไปๅๅธ':(23.55,113.58),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,้ถๅ
ณๅธ':(24.82,113.6),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ๆญฆๆฑๅบ':(24.8,113.57),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ๆตๆฑๅบ':(24.8,113.6),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ๆฒๆฑๅบ':(24.68,113.6),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ๅงๅ
ดๅฟ':(24.95,114.07),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ไปๅๅฟ':(25.08,113.75),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,็ฟๆบๅฟ':(24.35,114.13),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ไนณๆบ็ถๆ่ชๆฒปๅฟ':(24.78,113.27),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ๆฐไธฐๅฟ':(24.07,114.2),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ไนๆๅธ':(25.13,113.35),
# 'ๅนฟไธ็,้ถๅ
ณๅธ,ๅ้ๅธ':(25.12,114.3),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,ๆทฑๅณๅธ':(22.55,114.05),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,็ฝๆนๅบ':(22.55,114.12),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,็ฆ็ฐๅบ':(22.53,114.05),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,ๅๅฑฑๅบ':(22.52,113.92),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,ๅฎๅฎๅบ':(22.57,113.9),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,้พๅฒๅบ':(22.73,114.27),
# 'ๅนฟไธ็,ๆทฑๅณๅธ,็็ฐๅบ':(22.55,114.22),
# 'ๅนฟไธ็,็ ๆตทๅธ,็ ๆตทๅธ':(22.27,113.57),
# 'ๅนฟไธ็,็ ๆตทๅธ,้ฆๆดฒๅบ':(22.27,113.55),
# 'ๅนฟไธ็,็ ๆตทๅธ,ๆ้จๅบ':(22.22,113.28),
# 'ๅนฟไธ็,็ ๆตทๅธ,้ๆนพๅบ':(22.07,113.4),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,ๆฑๅคดๅธ':(23.35,116.68),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,้พๆนๅบ':(23.37,116.72),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,้ๅนณๅบ':(23.37,116.7),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,ๆฝฎ้ณๅบ':(23.27,116.6),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,ๆฝฎๅๅบ':(23.25,116.43),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,ๆพๆตทๅบ':(23.48,116.77),
# 'ๅนฟไธ็,ๆฑๅคดๅธ,ๅๆพณๅฟ':(23.42,117.02),
# 'ๅนฟไธ็,ไฝๅฑฑๅธ,ไฝๅฑฑๅธ':(23.02,113.12),
# 'ๅนฟไธ็,ไฝๅฑฑๅธ,ๅๆตทๅบ':(23.03,113.15),
# 'ๅนฟไธ็,ไฝๅฑฑๅธ,้กบๅพทๅบ':(22.8,113.3),
# 'ๅนฟไธ็,ไฝๅฑฑๅธ,ไธๆฐดๅบ':(23.17,112.87),
# 'ๅนฟไธ็,ไฝๅฑฑๅธ,้ซๆๅบ':(22.9,112.88),
# 'ๅนฟไธ็,ๆฑ้จๅธ,ๆฑ้จๅธ':(22.58,113.08),
# 'ๅนฟไธ็,ๆฑ้จๅธ,ๆฐไผๅบ':(22.47,113.03),
# 'ๅนฟไธ็,ๆฑ้จๅธ,ๅฐๅฑฑๅธ':(22.25,112.78),
# 'ๅนฟไธ็,ๆฑ้จๅธ,ๅผๅนณๅธ':(22.38,112.67),
# 'ๅนฟไธ็,ๆฑ้จๅธ,้นคๅฑฑๅธ':(22.77,112.97),
# 'ๅนฟไธ็,ๆฑ้จๅธ,ๆฉๅนณๅธ':(22.18,112.3),
# 'ๅนฟไธ็,ๆนๆฑๅธ,ๆนๆฑๅธ':(21.27,110.35),
# 'ๅนฟไธ็,ๆนๆฑๅธ,่ตคๅๅบ':(21.27,110.37),
# 'ๅนฟไธ็,ๆนๆฑๅธ,้ๅฑฑๅบ':(21.2,110.4),
# 'ๅนฟไธ็,ๆนๆฑๅธ,ๅกๅคดๅบ':(21.23,110.47),
# 'ๅนฟไธ็,ๆนๆฑๅธ,้บป็ซ ๅบ':(21.27,110.32),
# 'ๅนฟไธ็,ๆนๆฑๅธ,้ๆบชๅฟ':(21.38,110.25),
# 'ๅนฟไธ็,ๆนๆฑๅธ,ๅพ้ปๅฟ':(20.33,110.17),
# 'ๅนฟไธ็,ๆนๆฑๅธ,ๅปๆฑๅธ':(21.62,110.27),
# 'ๅนฟไธ็,ๆนๆฑๅธ,้ทๅทๅธ':(20.92,110.08),
# 'ๅนฟไธ็,ๆนๆฑๅธ,ๅดๅทๅธ':(21.43,110.77),
# 'ๅนฟไธ็,่ๅๅธ,่ๅๅธ':(21.67,110.92),
# 'ๅนฟไธ็,่ๅๅธ,่ๅๅบ':(21.63,110.92),
# 'ๅนฟไธ็,่ๅๅธ,่ๆธฏๅบ':(21.47,111.02),
# 'ๅนฟไธ็,่ๅๅธ,็ต็ฝๅฟ':(21.5,111.0),
# 'ๅนฟไธ็,่ๅๅธ,้ซๅทๅธ':(21.92,110.85),
# 'ๅนฟไธ็,่ๅๅธ,ๅๅทๅธ':(21.67,110.63),
# 'ๅนฟไธ็,่ๅๅธ,ไฟกๅฎๅธ':(22.35,110.95),
# 'ๅนฟไธ็,่ๅบๅธ,่ๅบๅธ':(23.05,112.47),
# 'ๅนฟไธ็,่ๅบๅธ,็ซฏๅทๅบ':(23.05,112.48),
# 'ๅนฟไธ็,่ๅบๅธ,้ผๆนๅบ':(23.17,112.57),
# 'ๅนฟไธ็,่ๅบๅธ,ๅนฟๅฎๅฟ':(23.63,112.43),
# 'ๅนฟไธ็,่ๅบๅธ,ๆ้ๅฟ':(23.92,112.18),
# 'ๅนฟไธ็,่ๅบๅธ,ๅฐๅผๅฟ':(23.43,111.5),
# 'ๅนฟไธ็,่ๅบๅธ,ๅพทๅบๅฟ':(23.15,111.77),
# 'ๅนฟไธ็,่ๅบๅธ,้ซ่ฆๅธ':(23.03,112.45),
# 'ๅนฟไธ็,่ๅบๅธ,ๅไผๅธ':(23.33,112.68),
# 'ๅนฟไธ็,ๆ ๅทๅธ,ๆ ๅทๅธ':(23.12,114.42),
# 'ๅนฟไธ็,ๆ ๅทๅธ,ๆ ๅๅบ':(23.08,114.4),
# 'ๅนฟไธ็,ๆ ๅทๅธ,ๆ ้ณๅบ':(22.8,114.47),
# 'ๅนฟไธ็,ๆ ๅทๅธ,ๅ็ฝๅฟ':(23.18,114.28),
# 'ๅนฟไธ็,ๆ ๅทๅธ,ๆ ไธๅฟ':(22.98,114.72),
# 'ๅนฟไธ็,ๆ ๅทๅธ,้พ้จๅฟ':(23.73,114.25),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ๆข
ๅทๅธ':(24.28,116.12),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ๆข
ๆฑๅบ':(24.32,116.12),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ๆข
ๅฟ':(24.28,116.05),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ๅคงๅๅฟ':(24.35,116.7),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ไธฐ้กบๅฟ':(23.77,116.18),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ไบๅๅฟ':(23.93,115.77),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ๅนณ่ฟๅฟ':(24.57,115.88),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,่ๅฒญๅฟ':(24.67,116.17),
# 'ๅนฟไธ็,ๆข
ๅทๅธ,ๅ
ดๅฎๅธ':(24.15,115.73),
# 'ๅนฟไธ็,ๆฑๅฐพๅธ,ๆฑๅฐพๅธ':(22.78,115.37),
# 'ๅนฟไธ็,ๆฑๅฐพๅธ,ๆตทไธฐๅฟ':(22.97,115.33),
# 'ๅนฟไธ็,ๆฑๅฐพๅธ,้ๆฒณๅฟ':(23.3,115.65),
# 'ๅนฟไธ็,ๆฑๅฐพๅธ,้ไธฐๅธ':(22.95,115.65),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,ๆฒณๆบๅธ':(23.73,114.7),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,ๆบๅๅบ':(23.73,114.7),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,็ดซ้ๅฟ':(23.63,115.18),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,้พๅทๅฟ':(24.1,115.25),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,่ฟๅนณๅฟ':(24.37,114.48),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,ๅๅนณๅฟ':(24.45,114.93),
# 'ๅนฟไธ็,ๆฒณๆบๅธ,ไธๆบๅฟ':(23.82,114.77),
# 'ๅนฟไธ็,้ณๆฑๅธ,้ณๆฑๅธ':(21.87,111.98),
# 'ๅนฟไธ็,้ณๆฑๅธ,ๆฑๅๅบ':(21.87,111.95),
# 'ๅนฟไธ็,้ณๆฑๅธ,้ณ่ฅฟๅฟ':(21.75,111.62),
# 'ๅนฟไธ็,้ณๆฑๅธ,้ณไธๅฟ':(21.88,112.02),
# 'ๅนฟไธ็,้ณๆฑๅธ,้ณๆฅๅธ':(22.18,111.78),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,ๆธ
่ฟๅธ':(23.7,113.03),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,ๆธ
ๅๅบ':(23.7,113.02),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,ไฝๅๅฟ':(23.88,113.53),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,้ณๅฑฑๅฟ':(24.48,112.63),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,่ฟๅฑฑๅฃฎๆ็ถๆ่ชๆฒปๅฟ':(24.57,112.08),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,่ฟๅ็ถๆ่ชๆฒปๅฟ':(24.72,112.28),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,ๆธ
ๆฐๅฟ':(23.73,112.98),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,่ฑๅพทๅธ':(24.18,113.4),
# 'ๅนฟไธ็,ๆธ
่ฟๅธ,่ฟๅทๅธ':(24.78,112.38),
# 'ๅนฟไธ็,ไธ่ๅธ,ไธ่ๅธ':(23.05,113.75),
# 'ๅนฟไธ็,ไธญๅฑฑๅธ,ไธญๅฑฑๅธ':(22.52,113.38),
# 'ๅนฟไธ็,ๆฝฎๅทๅธ,ๆฝฎๅทๅธ':(23.67,116.62),
# 'ๅนฟไธ็,ๆฝฎๅทๅธ,ๆนๆกฅๅบ':(23.68,116.63),
# 'ๅนฟไธ็,ๆฝฎๅทๅธ,ๆฝฎๅฎๅฟ':(23.45,116.68),
# 'ๅนฟไธ็,ๆฝฎๅทๅธ,้ฅถๅนณๅฟ':(23.67,117.0),
# 'ๅนฟไธ็,ๆญ้ณๅธ,ๆญ้ณๅธ':(23.55,116.37),
# 'ๅนฟไธ็,ๆญ้ณๅธ,ๆญไธๅฟ':(23.57,116.42),
# 'ๅนฟไธ็,ๆญ้ณๅธ,ๆญ่ฅฟๅฟ':(23.43,115.83),
# 'ๅนฟไธ็,ๆญ้ณๅธ,ๆ ๆฅๅฟ':(23.03,116.28),
# 'ๅนฟไธ็,ๆญ้ณๅธ,ๆฎๅฎๅธ':(23.3,116.18),
# 'ๅนฟไธ็,ไบๆตฎๅธ,ไบๆตฎๅธ':(22.92,112.03),
# 'ๅนฟไธ็,ไบๆตฎๅธ,ไบๅๅบ':(22.93,112.03),
# 'ๅนฟไธ็,ไบๆตฎๅธ,ๆฐๅ
ดๅฟ':(22.7,112.23),
# 'ๅนฟไธ็,ไบๆตฎๅธ,้ๅๅฟ':(23.23,111.53),
# 'ๅนฟไธ็,ไบๆตฎๅธ,ไบๅฎๅฟ':(23.08,112.0),
# 'ๅนฟไธ็,ไบๆตฎๅธ,็ฝๅฎๅธ':(22.77,111.57),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ๅๅฎๅธ':(22.82,108.37),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ๅ
ดๅฎๅบ':(22.87,108.38),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ๆฑๅๅบ':(22.78,108.28),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,่ฅฟไนกๅกๅบ':(22.83,108.3),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,่ฏๅบๅบ':(22.77,108.32),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,้ๅฎๅบ':(22.75,108.48),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ๆญฆ้ธฃๅฟ':(23.17,108.27),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,้ๅฎๅฟ':(23.18,107.68),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,้ฉฌๅฑฑๅฟ':(23.72,108.17),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ไธๆๅฟ':(23.43,108.6),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ๅฎพ้ณๅฟ':(23.22,108.8),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๅฎๅธ,ๆจชๅฟ':(22.68,109.27),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,ๆณๅทๅธ':(24.33,109.42),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,ๆณๅๅบ':(24.35,109.38),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,ๆณๆฑๅฟ':(24.27,109.33),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,ๆณๅๅฟ':(24.65,109.23),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,้นฟๅฏจๅฟ':(24.48,109.73),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,่ๅฎๅฟ':(25.23,109.4),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,่ๆฐด่ๆ่ชๆฒปๅฟ':(25.07,109.25),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆณๅทๅธ,ไธๆฑไพๆ่ชๆฒปๅฟ':(25.78,109.6),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ๆกๆๅธ':(25.28,110.28),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,้ณๆๅฟ':(24.78,110.48),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ไธดๆกๅฟ':(25.23,110.2),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,็ตๅทๅฟ':(25.42,110.32),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ๅ
จๅทๅฟ':(25.93,111.07),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ๅ
ดๅฎๅฟ':(25.62,110.67),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ๆฐธ็ฆๅฟ':(24.98,109.98),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,็้ณๅฟ':(25.48,111.15),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,้พ่ๅๆ่ชๆฒปๅฟ':(25.8,110.0),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,่ตๆบๅฟ':(26.03,110.63),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ๅนณไนๅฟ':(24.63,110.63),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆกๆๅธ,ๆญๅ็ถๆ่ชๆฒปๅฟ':(24.83,110.83),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆขงๅทๅธ,ๆขงๅทๅธ':(23.48,111.27),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆขงๅทๅธ,่ๆขงๅฟ':(23.42,111.23),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆขงๅทๅธ,่คๅฟ':(23.38,110.92),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆขงๅทๅธ,่ๅฑฑๅฟ':(24.2,110.52),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆขงๅทๅธ,ๅฒๆบชๅธ':(22.92,110.98),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๆตทๅธ,ๅๆตทๅธ':(21.48,109.12),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๆตทๅธ,้ๅฑฑๆธฏๅบ':(21.53,109.43),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅๆตทๅธ,ๅๆตฆๅฟ':(21.67,109.2),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฒๅๆธฏๅธ,้ฒๅๆธฏๅธ':(21.7,108.35),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฒๅๆธฏๅธ,ๆธฏๅฃๅบ':(21.65,108.37),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฒๅๆธฏๅธ,้ฒๅๅบ':(21.77,108.35),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฒๅๆธฏๅธ,ไธๆๅฟ':(22.15,107.98),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฒๅๆธฏๅธ,ไธๅ
ดๅธ':(21.53,107.97),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฆๅทๅธ,้ฆๅทๅธ':(21.95,108.62),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฆๅทๅธ,้ฆๅๅบ':(21.98,108.63),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฆๅทๅธ,็ตๅฑฑๅฟ':(22.43,109.3),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,้ฆๅทๅธ,ๆตฆๅๅฟ':(22.27,109.55),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดตๆธฏๅธ,่ดตๆธฏๅธ':(23.1,109.6),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดตๆธฏๅธ,่ฆๅกๅบ':(23.13,109.42),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดตๆธฏๅธ,ๅนณๅๅฟ':(23.55,110.38),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดตๆธฏๅธ,ๆกๅนณๅธ':(23.4,110.08),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็ๆๅธ,็ๆๅธ':(22.63,110.17),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็ๆๅธ,ๅฎนๅฟ':(22.87,110.55),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็ๆๅธ,้ๅทๅฟ':(22.33,110.27),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็ๆๅธ,ๅ็ฝๅฟ':(22.28,109.97),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็ๆๅธ,ๅ
ดไธๅฟ':(22.75,109.87),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็ๆๅธ,ๅๆตๅธ':(22.72,110.35),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,็พ่ฒๅธ':(23.9,106.62),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,็ฐ้ณๅฟ':(23.73,106.92),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,็ฐไธๅฟ':(23.6,107.12),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,ๅนณๆๅฟ':(23.32,107.58),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,ๅพทไฟๅฟ':(23.33,106.62),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,้่ฅฟๅฟ':(23.13,106.42),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,้ฃๅกๅฟ':(23.42,105.83),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,ๅไบๅฟ':(24.35,106.57),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,ไนไธๅฟ':(24.78,106.55),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,็ฐๆๅฟ':(24.3,106.23),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,่ฅฟๆๅฟ':(24.5,105.1),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,็พ่ฒๅธ,้ๆๅๆ่ชๆฒปๅฟ':(24.77,105.33),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดบๅทๅธ,่ดบๅทๅธ':(24.42,111.55),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดบๅทๅธ,ๆญๅนณๅฟ':(24.17,110.8),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดบๅทๅธ,้ๅฑฑๅฟ':(24.53,111.3),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,่ดบๅทๅธ,ๅฏๅท็ถๆ่ชๆฒปๅฟ':(24.83,111.27),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๆฒณๆฑ ๅธ':(24.7,108.07),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,้ๅๆฑๅบ':(24.7,108.05),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๅไธนๅฟ':(24.98,107.53),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๅคฉๅณจๅฟ':(25.0,107.17),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๅคๅฑฑๅฟ':(24.55,107.05),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ไธๅ
ฐๅฟ':(24.52,107.37),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,็ฝๅไปซไฝฌๆ่ชๆฒปๅฟ':(24.78,108.9),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,็ฏๆฑๆฏๅๆ่ชๆฒปๅฟ':(24.83,108.25),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๅทด้ฉฌ็ถๆ่ชๆฒปๅฟ':(24.15,107.25),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,้ฝๅฎ็ถๆ่ชๆฒปๅฟ':(23.93,108.1),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๅคงๅ็ถๆ่ชๆฒปๅฟ':(23.73,107.98),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฒณๆฑ ๅธ,ๅฎๅทๅธ':(24.5,108.67),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฅๅฎพๅธ,ๆฅๅฎพๅธ':(23.73,109.23),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฅๅฎพๅธ,ๅฟปๅๅฟ':(24.07,108.67),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฅๅฎพๅธ,่ฑกๅทๅฟ':(23.97,109.68),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฅๅฎพๅธ,ๆญฆๅฎฃๅฟ':(23.6,109.67),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฅๅฎพๅธ,้็ง็ถๆ่ชๆฒปๅฟ':(24.13,110.18),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๆฅๅฎพๅธ,ๅๅฑฑๅธ':(23.82,108.87),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,ๅดๅทฆๅธ':(22.4,107.37),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,ๆถ็ปฅๅฟ':(22.63,107.9),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,ๅฎๆๅฟ':(22.13,107.07),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,้พๅทๅฟ':(22.35,106.85),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,ๅคงๆฐๅฟ':(22.83,107.2),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,ๅคฉ็ญๅฟ':(23.08,107.13),
# 'ๅนฟ่ฅฟๅฃฎๆ่ชๆฒปๅบ,ๅดๅทฆๅธ,ๅญ็ฅฅๅธ':(22.12,106.75),
# 'ๆตทๅ็,ๆตทๅฃๅธ,ๆตทๅฃๅธ':(20.03,110.32),
# 'ๆตทๅ็,ๆตทๅฃๅธ,็ง่ฑๅบ':(20.02,110.28),
# 'ๆตทๅ็,ๆตทๅฃๅธ,้พๅๅบ':(20.03,110.3),
# 'ๆตทๅ็,ๆตทๅฃๅธ,็ผๅฑฑๅบ':(20.0,110.35),
# 'ๆตทๅ็,ๆตทๅฃๅธ,็พๅ
ฐๅบ':(20.03,110.37),
# 'ๆตทๅ็,ไธไบๅธ,ไธไบๅธ':(18.25,109.5),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ไบๆๅฑฑๅธ':(18.78,109.52),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,็ผๆตทๅธ':(19.25,110.47),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ๅๅทๅธ':(19.52,109.57),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ๆๆๅธ':(19.55,110.8),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ไธๅฎๅธ':(18.8,110.4),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ไธๆนๅธ':(19.1,108.63),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ๅฎๅฎๅฟ':(19.7,110.32),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ๅฑฏๆๅฟ':(19.37,110.1),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ๆพ่ฟๅฟ':(19.73,110.0),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ไธด้ซๅฟ':(19.92,109.68),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,็ฝๆฒ้ปๆ่ชๆฒปๅฟ':(19.23,109.45),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ๆๆฑ้ปๆ่ชๆฒปๅฟ':(19.25,109.05),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ไนไธ้ปๆ่ชๆฒปๅฟ':(18.75,109.17),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,้ตๆฐด้ปๆ่ชๆฒปๅฟ':(18.5,110.03),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,ไฟไบญ้ปๆ่ๆ่ชๆฒปๅฟ':(18.63,109.7),
# 'ๆตทๅ็,ไบๆๅฑฑๅธ,็ผไธญ้ปๆ่ๆ่ชๆฒปๅฟ':(19.03,109.83),
# '้ๅบๅธ,้ๅบๅธ,้ๅบๅธ':(29.57,106.55),
# '้ๅบๅธ,้ๅบๅธ,ไธๅทๅบ':(30.82,108.4),
# '้ๅบๅธ,้ๅบๅธ,ๆถช้ตๅบ':(29.72,107.4),
# '้ๅบๅธ,้ๅบๅธ,ๆธไธญๅบ':(29.55,106.57),
# '้ๅบๅธ,้ๅบๅธ,ๅคงๆธกๅฃๅบ':(29.48,106.48),
# '้ๅบๅธ,้ๅบๅธ,ๆฑๅๅบ':(29.6,106.57),
# '้ๅบๅธ,้ๅบๅธ,ๆฒๅชๅๅบ':(29.53,106.45),
# '้ๅบๅธ,้ๅบๅธ,ไน้พๅกๅบ':(29.5,106.5),
# '้ๅบๅธ,้ๅบๅธ,ๅๅฒธๅบ':(29.52,106.57),
# '้ๅบๅธ,้ๅบๅธ,ๅ็ขๅบ':(29.8,106.4),
# '้ๅบๅธ,้ๅบๅธ,ไธ็ๅบ':(28.97,106.92),
# '้ๅบๅธ,้ๅบๅธ,ๅๆกฅๅบ':(29.48,105.78),
# '้ๅบๅธ,้ๅบๅธ,ๆธๅๅบ':(29.72,106.63),
# '้ๅบๅธ,้ๅบๅธ,ๅทดๅๅบ':(29.38,106.52),
# '้ๅบๅธ,้ๅบๅธ,้ปๆฑๅบ':(29.53,108.77),
# '้ๅบๅธ,้ๅบๅธ,้ฟๅฏฟๅบ':(29.87,107.08),
# '้ๅบๅธ,้ๅบๅธ,็ถฆๆฑๅฟ':(29.03,106.65),
# '้ๅบๅธ,้ๅบๅธ,ๆฝผๅๅฟ':(30.18,105.83),
# '้ๅบๅธ,้ๅบๅธ,้ๆขๅฟ':(29.85,106.05),
# '้ๅบๅธ,้ๅบๅธ,ๅคง่ถณๅฟ':(29.7,105.72),
# '้ๅบๅธ,้ๅบๅธ,่ฃๆๅฟ':(29.4,105.58),
# '้ๅบๅธ,้ๅบๅธ,็งๅฑฑๅฟ':(29.6,106.22),
# '้ๅบๅธ,้ๅบๅธ,ๆขๅนณๅฟ':(30.68,107.8),
# '้ๅบๅธ,้ๅบๅธ,ๅๅฃๅฟ':(31.95,108.67),
# '้ๅบๅธ,้ๅบๅธ,ไธฐ้ฝๅฟ':(29.87,107.73),
# '้ๅบๅธ,้ๅบๅธ,ๅซๆฑๅฟ':(30.33,107.35),
# '้ๅบๅธ,้ๅบๅธ,ๆญฆ้ๅฟ':(29.33,107.75),
# '้ๅบๅธ,้ๅบๅธ,ๅฟ ๅฟ':(30.3,108.02),
# '้ๅบๅธ,้ๅบๅธ,ๅผๅฟ':(31.18,108.42),
# '้ๅบๅธ,้ๅบๅธ,ไบ้ณๅฟ':(30.95,108.67),
# '้ๅบๅธ,้ๅบๅธ,ๅฅ่ๅฟ':(31.02,109.47),
# '้ๅบๅธ,้ๅบๅธ,ๅทซๅฑฑๅฟ':(31.08,109.88),
# '้ๅบๅธ,้ๅบๅธ,ๅทซๆบชๅฟ':(31.4,109.63),
# '้ๅบๅธ,้ๅบๅธ,็ณๆฑๅๅฎถๆ่ชๆฒปๅฟ':(30.0,108.12),
# '้ๅบๅธ,้ๅบๅธ,็งๅฑฑๅๅฎถๆ่ๆ่ชๆฒปๅฟ':(28.45,108.98),
# '้ๅบๅธ,้ๅบๅธ,้
้ณๅๅฎถๆ่ๆ่ชๆฒปๅฟ':(28.85,108.77),
# '้ๅบๅธ,้ๅบๅธ,ๅฝญๆฐด่ๆๅๅฎถๆ่ชๆฒปๅฟ':(29.3,108.17),
# 'ๅๅท็,ๆ้ฝๅธ,ๆ้ฝๅธ':(30.67,104.07),
# 'ๅๅท็,ๆ้ฝๅธ,้ฆๆฑๅบ':(30.67,104.08),
# 'ๅๅท็,ๆ้ฝๅธ,้็พๅบ':(30.68,104.05),
# 'ๅๅท็,ๆ้ฝๅธ,้็ๅบ':(30.7,104.05),
# 'ๅๅท็,ๆ้ฝๅธ,ๆญฆไพฏๅบ':(30.65,104.05),
# 'ๅๅท็,ๆ้ฝๅธ,ๆๅๅบ':(30.67,104.1),
# 'ๅๅท็,ๆ้ฝๅธ,้พๆณ้ฉฟๅบ':(30.57,104.27),
# 'ๅๅท็,ๆ้ฝๅธ,้็ฝๆฑๅบ':(30.88,104.23),
# 'ๅๅท็,ๆ้ฝๅธ,ๆฐ้ฝๅบ':(30.83,104.15),
# 'ๅๅท็,ๆ้ฝๅธ,ๆธฉๆฑๅบ':(30.7,103.83),
# 'ๅๅท็,ๆ้ฝๅธ,้ๅ ๅฟ':(30.85,104.43),
# 'ๅๅท็,ๆ้ฝๅธ,ๅๆตๅฟ':(30.58,103.92),
# 'ๅๅท็,ๆ้ฝๅธ,้ซๅฟ':(30.82,103.88),
# 'ๅๅท็,ๆ้ฝๅธ,ๅคง้ๅฟ':(30.58,103.52),
# 'ๅๅท็,ๆ้ฝๅธ,่ฒๆฑๅฟ':(30.2,103.5),
# 'ๅๅท็,ๆ้ฝๅธ,ๆฐๆดฅๅฟ':(30.42,103.82),
# 'ๅๅท็,ๆ้ฝๅธ,้ฝๆฑๅ ฐๅธ':(31.0,103.62),
# 'ๅๅท็,ๆ้ฝๅธ,ๅฝญๅทๅธ':(30.98,103.93),
# 'ๅๅท็,ๆ้ฝๅธ,้ๅดๅธ':(30.42,103.47),
# 'ๅๅท็,ๆ้ฝๅธ,ๅดๅทๅธ':(30.63,103.67),
# 'ๅๅท็,่ช่ดกๅธ,่ช่ดกๅธ':(29.35,104.78),
# 'ๅๅท็,่ช่ดกๅธ,่ชๆตไบๅบ':(29.35,104.77),
# 'ๅๅท็,่ช่ดกๅธ,่ดกไบๅบ':(29.35,104.72),
# 'ๅๅท็,่ช่ดกๅธ,ๅคงๅฎๅบ':(29.37,104.77),
# 'ๅๅท็,่ช่ดกๅธ,ๆฒฟๆปฉๅบ':(29.27,104.87),
# 'ๅๅท็,่ช่ดกๅธ,่ฃๅฟ':(29.47,104.42),
# 'ๅๅท็,่ช่ดกๅธ,ๅฏ้กบๅฟ':(29.18,104.98),
# 'ๅๅท็,ๆๆ่ฑๅธ,ๆๆ่ฑๅธ':(26.58,101.72),
# 'ๅๅท็,ๆๆ่ฑๅธ,ไธๅบ':(26.55,101.7),
# 'ๅๅท็,ๆๆ่ฑๅธ,่ฅฟๅบ':(26.6,101.6),
# 'ๅๅท็,ๆๆ่ฑๅธ,ไปๅๅบ':(26.5,101.73),
# 'ๅๅท็,ๆๆ่ฑๅธ,็ฑณๆๅฟ':(26.88,102.12),
# 'ๅๅท็,ๆๆ่ฑๅธ,็่พนๅฟ':(26.7,101.85),
# 'ๅๅท็,ๆณธๅทๅธ,ๆณธๅทๅธ':(28.87,105.43),
# 'ๅๅท็,ๆณธๅทๅธ,ๆฑ้ณๅบ':(28.88,105.45),
# 'ๅๅท็,ๆณธๅทๅธ,็บณๆบชๅบ':(28.77,105.37),
# 'ๅๅท็,ๆณธๅทๅธ,้พ้ฉฌๆฝญๅบ':(28.9,105.43),
# 'ๅๅท็,ๆณธๅทๅธ,ๆณธๅฟ':(29.15,105.38),
# 'ๅๅท็,ๆณธๅทๅธ,ๅๆฑๅฟ':(28.82,105.83),
# 'ๅๅท็,ๆณธๅทๅธ,ๅๆฐธๅฟ':(28.17,105.43),
# 'ๅๅท็,ๆณธๅทๅธ,ๅค่บๅฟ':(28.05,105.82),
# 'ๅๅท็,ๅพท้ณๅธ,ๅพท้ณๅธ':(31.13,104.38),
# 'ๅๅท็,ๅพท้ณๅธ,ๆ้ณๅบ':(31.13,104.38),
# 'ๅๅท็,ๅพท้ณๅธ,ไธญๆฑๅฟ':(31.03,104.68),
# 'ๅๅท็,ๅพท้ณๅธ,็ฝๆฑๅฟ':(31.32,104.5),
# 'ๅๅท็,ๅพท้ณๅธ,ๅนฟๆฑๅธ':(30.98,104.28),
# 'ๅๅท็,ๅพท้ณๅธ,ไป้กๅธ':(31.13,104.17),
# 'ๅๅท็,ๅพท้ณๅธ,็ปต็ซนๅธ':(31.35,104.2),
# 'ๅๅท็,็ปต้ณๅธ,็ปต้ณๅธ':(31.47,104.73),
# 'ๅๅท็,็ปต้ณๅธ,ๆถชๅๅบ':(31.47,104.73),
# 'ๅๅท็,็ปต้ณๅธ,ๆธธไปๅบ':(31.47,104.75),
# 'ๅๅท็,็ปต้ณๅธ,ไธๅฐๅฟ':(31.1,105.08),
# 'ๅๅท็,็ปต้ณๅธ,็ไบญๅฟ':(31.22,105.38),
# 'ๅๅท็,็ปต้ณๅธ,ๅฎๅฟ':(31.53,104.57),
# 'ๅๅท็,็ปต้ณๅธ,ๆขๆฝผๅฟ':(31.63,105.17),
# 'ๅๅท็,็ปต้ณๅธ,ๅๅท็พๆ่ชๆฒปๅฟ':(31.82,104.45),
# 'ๅๅท็,็ปต้ณๅธ,ๅนณๆญฆๅฟ':(32.42,104.53),
# 'ๅๅท็,็ปต้ณๅธ,ๆฑๆฒนๅธ':(31.78,104.75),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๅนฟๅ
ๅธ':(32.43,105.83),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๅธไธญๅบ':(29.58,105.05),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๅธไธญๅบ':(29.57,103.77),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๅ
ๅๅบ':(32.32,105.97),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๆๅคฉๅบ':(32.65,105.88),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๆบ่ๅฟ':(32.23,106.28),
# 'ๅๅท็,ๅนฟๅ
ๅธ,้ๅทๅฟ':(32.58,105.23),
# 'ๅๅท็,ๅนฟๅ
ๅธ,ๅ้ๅฟ':(32.28,105.52),
# 'ๅๅท็,ๅนฟๅ
ๅธ,่ๆบชๅฟ':(31.73,105.93),
# 'ๅๅท็,้ๅฎๅธ,้ๅฎๅธ':(30.52,105.57),
# 'ๅๅท็,้ๅฎๅธ,่นๅฑฑๅบ':(30.52,105.57),
# 'ๅๅท็,้ๅฎๅธ,ๅฎๅฑ
ๅบ':(30.35,105.45),
# 'ๅๅท็,้ๅฎๅธ,่ฌๆบชๅฟ':(30.78,105.72),
# 'ๅๅท็,้ๅฎๅธ,ๅฐๆดชๅฟ':(30.87,105.38),
# 'ๅๅท็,้ๅฎๅธ,ๅคง่ฑๅฟ':(30.58,105.25),
# 'ๅๅท็,ๅ
ๆฑๅธ,ๅ
ๆฑๅธ':(29.58,105.05),
# 'ๅๅท็,ๅ
ๆฑๅธ,ๅธไธญๅบ':(29.58,105.05),
# 'ๅๅท็,ๅ
ๆฑๅธ,ๅธไธญๅบ':(29.57,103.77),
# 'ๅๅท็,ๅ
ๆฑๅธ,ไธๅ
ดๅบ':(29.6,105.07),
# 'ๅๅท็,ๅ
ๆฑๅธ,ๅจ่ฟๅฟ':(29.53,104.67),
# 'ๅๅท็,ๅ
ๆฑๅธ,่ตไธญๅฟ':(29.78,104.85),
# 'ๅๅท็,ๅ
ๆฑๅธ,้??ๅฟ':(29.35,105.28),
# 'ๅๅท็,ไนๅฑฑๅธ,ไนๅฑฑๅธ':(29.57,103.77),
# 'ๅๅท็,ไนๅฑฑๅธ,ๅธไธญๅบ':(29.58,105.05),
# 'ๅๅท็,ไนๅฑฑๅธ,ๅธไธญๅบ':(29.57,103.77),
# 'ๅๅท็,ไนๅฑฑๅธ,ๆฒๆนพๅบ':(29.42,103.55),
# 'ๅๅท็,ไนๅฑฑๅธ,ไบ้ๆกฅๅบ':(29.4,103.82),
# 'ๅๅท็,ไนๅฑฑๅธ,้ๅฃๆฒณๅบ':(29.25,103.08),
# 'ๅๅท็,ไนๅฑฑๅธ,็ไธบๅฟ':(29.22,103.95),
# 'ๅๅท็,ไนๅฑฑๅธ,ไบ็ ๅฟ':(29.65,104.07),
# 'ๅๅท็,ไนๅฑฑๅธ,ๅคนๆฑๅฟ':(29.73,103.57),
# 'ๅๅท็,ไนๅฑฑๅธ,ๆฒๅทๅฟ':(28.97,103.9),
# 'ๅๅท็,ไนๅฑฑๅธ,ๅณจ่พนๅฝๆ่ชๆฒปๅฟ':(29.23,103.27),
# 'ๅๅท็,ไนๅฑฑๅธ,้ฉฌ่พนๅฝๆ่ชๆฒปๅฟ':(28.83,103.55),
# 'ๅๅท็,ไนๅฑฑๅธ,ๅณจ็ๅฑฑๅธ':(29.6,103.48),
# 'ๅๅท็,ๅๅ
ๅธ,ๅๅ
ๅธ':(30.78,106.08),
# 'ๅๅท็,ๅๅ
ๅธ,้กบๅบๅบ':(30.78,106.08),
# 'ๅๅท็,ๅๅ
ๅธ,้ซๅชๅบ':(30.77,106.1),
# 'ๅๅท็,ๅๅ
ๅธ,ๅ้ตๅบ':(30.77,106.05),
# 'ๅๅท็,ๅๅ
ๅธ,ๅ้จๅฟ':(31.35,106.07),
# 'ๅๅท็,ๅๅ
ๅธ,่ฅๅฑฑๅฟ':(31.08,106.57),
# 'ๅๅท็,ๅๅ
ๅธ,่ฌๅฎๅฟ':(31.03,106.42),
# 'ๅๅท็,ๅๅ
ๅธ,ไปช้ๅฟ':(31.27,106.28),
# 'ๅๅท็,ๅๅ
ๅธ,่ฅฟๅ
ๅฟ':(31.0,105.88),
# 'ๅๅท็,ๅๅ
ๅธ,้ไธญๅธ':(31.55,106.0),
# 'ๅๅท็,็ๅฑฑๅธ,็ๅฑฑๅธ':(30.05,103.83),
# 'ๅๅท็,็ๅฑฑๅธ,ไธๅกๅบ':(30.05,103.83),
# 'ๅๅท็,็ๅฑฑๅธ,ไปๅฏฟๅฟ':(30.0,104.15),
# 'ๅๅท็,็ๅฑฑๅธ,ๅฝญๅฑฑๅฟ':(30.2,103.87),
# 'ๅๅท็,็ๅฑฑๅธ,ๆดช้
ๅฟ':(29.92,103.37),
# 'ๅๅท็,็ๅฑฑๅธ,ไธนๆฃฑๅฟ':(30.02,103.52),
# 'ๅๅท็,็ๅฑฑๅธ,้็ฅๅฟ':(29.83,103.85),
# 'ๅๅท็,ๅฎๅฎพๅธ,ๅฎๅฎพๅธ':(28.77,104.62),
# 'ๅๅท็,ๅฎๅฎพๅธ,็ฟ ๅฑๅบ':(28.77,104.62),
# 'ๅๅท็,ๅฎๅฎพๅธ,ๅฎๅฎพๅฟ':(28.7,104.55),
# 'ๅๅท็,ๅฎๅฎพๅธ,ๅๆบชๅฟ':(28.85,104.98),
# 'ๅๅท็,ๅฎๅฎพๅธ,ๆฑๅฎๅฟ':(28.73,105.07),
# 'ๅๅท็,ๅฎๅฎพๅธ,้ฟๅฎๅฟ':(28.58,104.92),
# 'ๅๅท็,ๅฎๅฎพๅธ,้ซๅฟ':(28.43,104.52),
# 'ๅๅท็,ๅฎๅฎพๅธ,็ๅฟ':(28.45,104.72),
# 'ๅๅท็,ๅฎๅฎพๅธ,็ญ ่ฟๅฟ':(28.17,104.52),
# 'ๅๅท็,ๅฎๅฎพๅธ,ๅ
ดๆๅฟ':(28.3,105.23),
# 'ๅๅท็,ๅฎๅฎพๅธ,ๅฑๅฑฑๅฟ':(28.83,104.33),
# 'ๅๅท็,ๅนฟๅฎๅธ,ๅนฟๅฎๅธ':(30.47,106.63),
# 'ๅๅท็,ๅนฟๅฎๅธ,ๅฒณๆฑ ๅฟ':(30.55,106.43),
# 'ๅๅท็,ๅนฟๅฎๅธ,ๆญฆ่ๅฟ':(30.35,106.28),
# 'ๅๅท็,ๅนฟๅฎๅธ,้ปๆฐดๅฟ':(30.33,106.93),
# 'ๅๅท็,ๅนฟๅฎๅธ,ๅ่ฅๅธ':(30.38,106.77),
# 'ๅๅท็,่พพๅทๅธ,่พพๅทๅธ':(31.22,107.5),
# 'ๅๅท็,่พพๅทๅธ,้ๅทๅบ':(31.22,107.48),
# 'ๅๅท็,่พพๅทๅธ,่พพๅฟ':(31.2,107.5),
# 'ๅๅท็,่พพๅทๅธ,ๅฎฃๆฑๅฟ':(31.35,107.72),
# 'ๅๅท็,่พพๅทๅธ,ๅผๆฑๅฟ':(31.08,107.87),
# 'ๅๅท็,่พพๅทๅธ,ๅคง็ซนๅฟ':(30.73,107.2),
# 'ๅๅท็,่พพๅทๅธ,ๆธ ๅฟ':(30.83,106.97),
# 'ๅๅท็,่พพๅทๅธ,ไธๆบๅธ':(32.07,108.03),
# 'ๅๅท็,้
ๅฎๅธ,้
ๅฎๅธ':(29.98,103.0),
# 'ๅๅท็,้
ๅฎๅธ,้จๅๅบ':(29.98,103.0),
# 'ๅๅท็,้
ๅฎๅธ,ๅๅฑฑๅฟ':(30.08,103.12),
# 'ๅๅท็,้
ๅฎๅธ,่ฅ็ปๅฟ':(29.8,102.85),
# 'ๅๅท็,้
ๅฎๅธ,ๆฑๆบๅฟ':(29.35,102.65),
# 'ๅๅท็,้
ๅฎๅธ,็ณๆฃๅฟ':(29.23,102.37),
# 'ๅๅท็,้
ๅฎๅธ,ๅคฉๅ
จๅฟ':(30.07,102.75),
# 'ๅๅท็,้
ๅฎๅธ,่ฆๅฑฑๅฟ':(30.15,102.92),
# 'ๅๅท็,้
ๅฎๅธ,ๅฎๅ
ดๅฟ':(30.37,102.82),
# 'ๅๅท็,ๅทดไธญๅธ,ๅทดไธญๅธ':(31.85,106.77),
# 'ๅๅท็,ๅทดไธญๅธ,ๅทดๅทๅบ':(31.85,106.77),
# 'ๅๅท็,ๅทดไธญๅธ,้ๆฑๅฟ':(31.92,107.23),
# 'ๅๅท็,ๅทดไธญๅธ,ๅๆฑๅฟ':(32.35,106.83),
# 'ๅๅท็,ๅทดไธญๅธ,ๅนณๆๅฟ':(31.57,107.1),
# 'ๅๅท็,่ต้ณๅธ,่ต้ณๅธ':(30.12,104.65),
# 'ๅๅท็,่ต้ณๅธ,้ๆฑๅบ':(30.12,104.65),
# 'ๅๅท็,่ต้ณๅธ,ๅฎๅฒณๅฟ':(30.1,105.33),
# 'ๅๅท็,่ต้ณๅธ,ไน่ณๅฟ':(30.28,105.02),
# 'ๅๅท็,่ต้ณๅธ,็ฎ้ณๅธ':(30.4,104.55),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,้ฟๅ่ๆ็พๆ่ชๆฒปๅท':(31.9,102.22),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,ๆฑถๅทๅฟ':(31.48,103.58),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,็ๅฟ':(31.43,103.17),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,่ๅฟ':(31.68,103.85),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,ๆพๆฝๅฟ':(32.63,103.6),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,ไนๅฏจๆฒๅฟ':(33.27,104.23),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,้ๅทๅฟ':(31.48,102.07),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,ๅฐ้ๅฟ':(31.0,102.37),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,้ปๆฐดๅฟ':(32.07,102.98),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,้ฉฌๅฐๅบทๅฟ':(31.9,102.22),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,ๅฃคๅกๅฟ':(32.27,100.98),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,้ฟๅๅฟ':(32.9,101.7),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,่ฅๅฐ็ๅฟ':(33.58,102.95),
# 'ๅๅท็,้ฟๅ่ๆ็พๆ่ชๆฒปๅทๅธ,็บขๅๅฟ':(32.8,102.55),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็ๅญ่ๆ่ชๆฒปๅท':(30.05,101.97),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ๅบทๅฎๅฟ':(30.05,101.97),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ๆณธๅฎๅฟ':(29.92,102.23),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ไธนๅทดๅฟ':(30.88,101.88),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ไน้พๅฟ':(29.0,101.5),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,้
ๆฑๅฟ':(30.03,101.02),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,้ๅญๅฟ':(30.98,101.12),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็้ๅฟ':(31.4,100.68),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็ๅญๅฟ':(31.62,99.98),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ๆฐ้พๅฟ':(30.95,100.32),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ๅพทๆ ผๅฟ':(31.82,98.58),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็ฝ็ๅฟ':(31.22,98.83),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็ณๆธ ๅฟ':(32.98,98.1),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,่ฒ่พพๅฟ':(32.27,100.33),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็ๅกๅฟ':(30.0,100.27),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ๅทดๅกๅฟ':(30.0,99.1),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ไนกๅๅฟ':(28.93,99.8),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,็จปๅๅฟ':(29.03,100.3),
# 'ๅๅท็,็ๅญ่ๆ่ชๆฒปๅทๅธ,ๅพ่ฃๅฟ':(28.72,99.28),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๅๅฑฑๅฝๆ่ชๆฒปๅท':(27.9,102.27),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,่ฅฟๆๅธ':(27.9,102.27),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๆจ้่ๆ่ชๆฒปๅฟ':(27.93,101.28),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,็ๆบๅฟ':(27.43,101.5),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๅพทๆๅฟ':(27.4,102.18),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ไผ็ๅฟ':(26.67,102.25),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ไผไธๅฟ':(26.63,102.58),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๅฎๅๅฟ':(27.07,102.77),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๆฎๆ ผๅฟ':(27.38,102.53),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๅธๆๅฟ':(27.72,102.82),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,้้ณๅฟ':(27.7,103.25),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๆญ่งๅฟ':(28.02,102.85),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๅๅพทๅฟ':(28.32,102.42),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,ๅๅฎๅฟ':(28.55,102.17),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,่ถ่ฅฟๅฟ':(28.65,102.52),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,็ๆดๅฟ':(28.97,102.77),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,็พๅงๅฟ':(28.33,103.13),
# 'ๅๅท็,ๅๅฑฑๅฝๆ่ชๆฒปๅทๅธ,้ทๆณขๅฟ':(28.27,103.57),
# '่ดตๅท็,่ดต้ณๅธ,่ดต้ณๅธ':(26.65,106.63),
# '่ดตๅท็,่ดต้ณๅธ,ๅๆๅบ':(26.57,106.72),
# '่ดตๅท็,่ดต้ณๅธ,ไบๅฒฉๅบ':(26.62,106.72),
# '่ดตๅท็,่ดต้ณๅธ,ไนๅฝๅบ':(26.63,106.75),
# '่ดตๅท็,่ดต้ณๅธ,็ฝไบๅบ':(26.68,106.65),
# '่ดตๅท็,่ดต้ณๅธ,ๅฐๆฒณๅบ':(26.53,106.7),
# '่ดตๅท็,่ดต้ณๅธ,ๅผ้ณๅฟ':(27.07,106.97),
# '่ดตๅท็,่ดต้ณๅธ,ๆฏ็ฝๅฟ':(27.1,106.73),
# '่ดตๅท็,่ดต้ณๅธ,ไฟฎๆๅฟ':(26.83,106.58),
# '่ดตๅท็,่ดต้ณๅธ,ๆธ
้ๅธ':(26.55,106.47),
# '่ดตๅท็,ๅ
ญ็ๆฐดๅธ,ๅ
ญ็ๆฐดๅธ':(26.6,104.83),
# '่ดตๅท็,ๅ
ญ็ๆฐดๅธ,้ๅฑฑๅบ':(26.6,104.83),
# '่ดตๅท็,ๅ
ญ็ๆฐดๅธ,ๅ
ญๆ็นๅบ':(26.22,105.48),
# '่ดตๅท็,ๅ
ญ็ๆฐดๅธ,ๆฐดๅๅฟ':(26.55,104.95),
# '่ดตๅท็,ๅ
ญ็ๆฐดๅธ,็ๅฟ':(25.72,104.47),
# '่ดตๅท็,้ตไนๅธ,้ตไนๅธ':(27.73,106.92),
# '่ดตๅท็,้ตไนๅธ,็บข่ฑๅฒๅบ':(27.65,106.92),
# '่ดตๅท็,้ตไนๅธ,ๆฑๅทๅบ':(27.73,106.92),
# '่ดตๅท็,้ตไนๅธ,้ตไนๅฟ':(27.53,106.83),
# '่ดตๅท็,้ตไนๅธ,ๆกๆขๅฟ':(28.13,106.82),
# '่ดตๅท็,้ตไนๅธ,็ปฅ้ณๅฟ':(27.95,107.18),
# '่ดตๅท็,้ตไนๅธ,ๆญฃๅฎๅฟ':(28.55,107.43),
# '่ดตๅท็,้ตไนๅธ,้็ไปกไฝฌๆ่ๆ่ชๆฒปๅฟ':(28.88,107.6),
# '่ดตๅท็,้ตไนๅธ,ๅกๅทไปกไฝฌๆ่ๆ่ชๆฒปๅฟ':(28.53,107.88),
# '่ดตๅท็,้ตไนๅธ,ๅคๅๅฟ':(27.97,107.72),
# '่ดตๅท็,้ตไนๅธ,ๆนๆฝญๅฟ':(27.77,107.48),
# '่ดตๅท็,้ตไนๅธ,ไฝๅบๅฟ':(27.22,107.88),
# '่ดตๅท็,้ตไนๅธ,ไน ๆฐดๅฟ':(28.32,106.22),
# '่ดตๅท็,้ตไนๅธ,่ตคๆฐดๅธ':(28.58,105.7),
# '่ดตๅท็,้ตไนๅธ,ไปๆๅธ':(27.82,106.42),
# '่ดตๅท็,ๅฎ้กบๅธ,ๅฎ้กบๅธ':(26.25,105.95),
# '่ดตๅท็,ๅฎ้กบๅธ,่ฅฟ็งๅบ':(26.25,105.92),
# '่ดตๅท็,ๅฎ้กบๅธ,ๅนณๅๅฟ':(26.42,106.25),
# '่ดตๅท็,ๅฎ้กบๅธ,ๆฎๅฎๅฟ':(26.32,105.75),
# '่ดตๅท็,ๅฎ้กบๅธ,้ๅฎๅธไพๆ่ๆ่ชๆฒปๅฟ':(26.07,105.77),
# '่ดตๅท็,ๅฎ้กบๅธ,ๅ
ณๅฒญๅธไพๆ่ๆ่ชๆฒปๅฟ':(25.95,105.62),
# '่ดตๅท็,ๅฎ้กบๅธ,็ดซไบ่ๆๅธไพๆ่ชๆฒปๅฟ':(25.75,106.08),
# '่ดตๅท็,้ไปๅธ,้ไปๅฐๅบ':(27.72,109.18),
# '่ดตๅท็,้ไปๅธ,้ไปๅธ':(27.72,109.18),
# '่ดตๅท็,้ไปๅธ,ๆฑๅฃๅฟ':(27.7,108.85),
# '่ดตๅท็,้ไปๅธ,็ๅฑไพๆ่ชๆฒปๅฟ':(27.23,108.92),
# '่ดตๅท็,้ไปๅธ,็ณ้กๅฟ':(27.52,108.23),
# '่ดตๅท็,้ไปๅธ,ๆๅๅฟ':(27.93,108.25),
# '่ดตๅท็,้ไปๅธ,ๅฐๆฑๅๅฎถๆ่ๆ่ชๆฒปๅฟ':(28.0,108.4),
# '่ดตๅท็,้ไปๅธ,ๅพทๆฑๅฟ':(28.27,108.12),
# '่ดตๅท็,้ไปๅธ,ๆฒฟๆฒณๅๅฎถๆ่ชๆฒปๅฟ':(28.57,108.5),
# '่ดตๅท็,้ไปๅธ,ๆพๆก่ๆ่ชๆฒปๅฟ':(28.17,109.2),
# '่ดตๅท็,้ไปๅธ,ไธๅฑฑ็นๅบ':(27.52,109.2),
# '่ดตๅท็,ๅ
ดไนๅธ,ๅ
ดไนๅธ':(25.08,104.9),
# '่ดตๅท็,ๅ
ดไนๅธ,ๅ
ดไปๅฟ':(25.43,105.18),
# '่ดตๅท็,ๅ
ดไนๅธ,ๆฎๅฎๅฟ':(25.78,104.95),
# '่ดตๅท็,ๅ
ดไนๅธ,ๆด้ๅฟ':(25.83,105.22),
# '่ดตๅท็,ๅ
ดไนๅธ,่ดไธฐๅฟ':(25.38,105.65),
# '่ดตๅท็,ๅ
ดไนๅธ,ๆ่ฐๅฟ':(25.17,106.1),
# '่ดตๅท็,ๅ
ดไนๅธ,ๅไบจๅฟ':(24.98,105.82),
# '่ดตๅท็,ๅ
ดไนๅธ,ๅฎ้พๅฟ':(25.12,105.47),
# '่ดตๅท็,ๆฏ่ๅธ,ๆฏ่ๅฐๅบ':(27.3,105.28),
# '่ดตๅท็,ๆฏ่ๅธ,ๆฏ่ๅธ':(27.3,105.28),
# '่ดตๅท็,ๆฏ่ๅธ,ๅคงๆนๅฟ':(27.15,105.6),
# '่ดตๅท็,ๆฏ่ๅธ,้ป่ฅฟๅฟ':(27.03,106.03),
# '่ดตๅท็,ๆฏ่ๅธ,้ๆฒๅฟ':(27.47,106.22),
# '่ดตๅท็,ๆฏ่ๅธ,็ป้ๅฟ':(26.67,105.77),
# '่ดตๅท็,ๆฏ่ๅธ,็บณ้ๅฟ':(26.78,105.38),
# '่ดตๅท็,ๆฏ่ๅธ,่ตซ็ซ ๅฟ':(27.13,104.72),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้ปไธๅ่ๆไพๆ่ชๆฒปๅท':(26.58,107.97),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๅฏ้ๅธ':(26.58,107.97),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้ปๅนณๅฟ':(26.9,107.9),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๆฝ็งๅฟ':(27.03,108.12),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ไธ็ฉๅฟ':(26.97,108.68),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้่ฟๅฟ':(27.05,108.42),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๅฒๅทฉๅฟ':(27.18,108.82),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๅคฉๆฑๅฟ':(26.92,109.2),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้ฆๅฑๅฟ':(26.68,109.2),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๅๆฒณๅฟ':(26.73,108.45),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๅฐๆฑๅฟ':(26.67,108.32),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้ปๅนณๅฟ':(26.23,109.13),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ๆฆๆฑๅฟ':(25.93,108.52),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ไปๆฑๅฟ':(25.75,108.9),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้ทๅฑฑๅฟ':(26.38,108.07),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,้บปๆฑๅฟ':(26.5,107.58),
# '่ดตๅท็,้ปไธๅ่ๆไพๆ่ชๆฒปๅทๅธ,ไธนๅฏจๅฟ':(26.2,107.8),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,้ปๅๅธไพๆ่ๆ่ชๆฒปๅท':(26.27,107.52),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,้ฝๅๅธ':(26.27,107.52),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,็ฆๆณๅธ':(26.7,107.5),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,่ๆณขๅฟ':(25.42,107.88),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,่ดตๅฎๅฟ':(26.58,107.23),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,็ฎๅฎๅฟ':(27.07,107.47),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,็ฌๅฑฑๅฟ':(25.83,107.53),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,ๅนณๅกๅฟ':(25.83,107.32),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,็ฝ็ธๅฟ':(25.43,106.75),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,้ฟ้กบๅฟ':(26.03,106.45),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,้พ้ๅฟ':(26.45,106.97),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,ๆ ๆฐดๅฟ':(26.13,106.65),
# '่ดตๅท็,้ปๅๅธไพๆ่ๆ่ชๆฒปๅทๅธ,ไธ้ฝๆฐดๆ่ชๆฒปๅฟ':(25.98,107.87),
# 'ไบๅ็,ๆๆๅธ,ๆๆๅธ':(25.05,102.72),
# 'ไบๅ็,ๆๆๅธ,ไบๅๅบ':(25.05,102.7),
# 'ไบๅ็,ๆๆๅธ,็้พๅบ':(25.03,102.72),
# 'ไบๅ็,ๆๆๅธ,ๅฎๆธกๅบ':(25.02,102.75),
# 'ไบๅ็,ๆๆๅธ,่ฅฟๅฑฑๅบ':(25.03,102.67),
# 'ไบๅ็,ๆๆๅธ,ไธๅทๅบ':(26.08,103.18),
# 'ไบๅ็,ๆๆๅธ,ๅ่ดกๅฟ':(24.88,102.8),
# 'ไบๅ็,ๆๆๅธ,ๆๅฎๅฟ':(24.67,102.6),
# 'ไบๅ็,ๆๆๅธ,ๅฏๆฐๅฟ':(25.22,102.5),
# 'ไบๅ็,ๆๆๅธ,ๅฎ่ฏๅฟ':(24.92,103.15),
# 'ไบๅ็,ๆๆๅธ,็ณๆๅฝๆ่ชๆฒปๅฟ':(24.77,103.27),
# 'ไบๅ็,ๆๆๅธ,ๅตฉๆๅฟ':(25.35,103.03),
# 'ไบๅ็,ๆๆๅธ,็ฆๅๅฝๆ่ๆ่ชๆฒปๅฟ':(25.55,102.47),
# 'ไบๅ็,ๆๆๅธ,ๅฏป็ธๅๆๅฝๆ่ชๆฒปๅฟ':(25.57,103.25),
# 'ไบๅ็,ๆๆๅธ,ๅฎๅฎๅธ':(24.92,102.48),
# 'ไบๅ็,ๆฒ้ๅธ,ๆฒ้ๅธ':(25.5,103.8),
# 'ไบๅ็,ๆฒ้ๅธ,้บ้บๅบ':(25.5,103.8),
# 'ไบๅ็,ๆฒ้ๅธ,้ฉฌ้พๅฟ':(25.43,103.58),
# 'ไบๅ็,ๆฒ้ๅธ,้่ฏๅฟ':(25.03,103.67),
# 'ไบๅ็,ๆฒ้ๅธ,ๅธๅฎๅฟ':(24.83,103.98),
# 'ไบๅ็,ๆฒ้ๅธ,็ฝๅนณๅฟ':(24.88,104.3),
# 'ไบๅ็,ๆฒ้ๅธ,ๅฏๆบๅฟ':(25.67,104.25),
# 'ไบๅ็,ๆฒ้ๅธ,ไผๆณฝๅฟ':(26.42,103.3),
# 'ไบๅ็,ๆฒ้ๅธ,ๆฒพ็ๅฟ':(25.62,103.82),
# 'ไบๅ็,ๆฒ้ๅธ,ๅฎฃๅจๅธ':(26.22,104.1),
# 'ไบๅ็,็ๆบชๅธ,็ๆบชๅธ':(24.35,102.55),
# 'ไบๅ็,็ๆบชๅธ,ๆฑๅทๅฟ':(24.28,102.75),
# 'ไบๅ็,็ๆบชๅธ,ๆพๆฑๅฟ':(24.67,102.92),
# 'ไบๅ็,็ๆบชๅธ,้ๆตทๅฟ':(24.12,102.75),
# 'ไบๅ็,็ๆบชๅธ,ๅๅฎๅฟ':(24.2,102.93),
# 'ไบๅ็,็ๆบชๅธ,ๆ้จๅฟ':(24.67,102.17),
# 'ไบๅ็,็ๆบชๅธ,ๅณจๅฑฑๅฝๆ่ชๆฒปๅฟ':(24.18,102.4),
# 'ไบๅ็,็ๆบชๅธ,ๆฐๅนณๅฝๆๅฃๆ่ชๆฒปๅฟ':(24.07,101.98),
# 'ไบๅ็,ไฟๅฑฑๅธ,ไฟๅฑฑๅธ':(25.12,99.17),
# 'ไบๅ็,ไฟๅฑฑๅธ,้้ณๅบ':(25.12,99.17),
# 'ไบๅ็,ไฟๅฑฑๅธ,ๆฝ็ธๅฟ':(24.73,99.18),
# 'ไบๅ็,ไฟๅฑฑๅธ,่
พๅฒๅฟ':(25.03,98.5),
# 'ไบๅ็,ไฟๅฑฑๅธ,้พ้ตๅฟ':(24.58,98.68),
# 'ไบๅ็,ไฟๅฑฑๅธ,ๆๅฎๅฟ':(24.83,99.6),
# 'ไบๅ็,ๆญ้ๅธ,ๆญ้ๅธ':(27.33,103.72),
# 'ไบๅ็,ๆญ้ๅธ,ๆญ้ณๅบ':(27.33,103.72),
# 'ไบๅ็,ๆญ้ๅธ,้ฒ็ธๅฟ':(27.2,103.55),
# 'ไบๅ็,ๆญ้ๅธ,ๅทงๅฎถๅฟ':(26.92,102.92),
# 'ไบๅ็,ๆญ้ๅธ,็ๆดฅๅฟ':(28.12,104.23),
# 'ไบๅ็,ๆญ้ๅธ,ๅคงๅ
ณๅฟ':(27.75,103.88),
# 'ไบๅ็,ๆญ้ๅธ,ๆฐธๅๅฟ':(28.23,103.63),
# 'ไบๅ็,ๆญ้ๅธ,็ปฅๆฑๅฟ':(28.6,103.95),
# 'ไบๅ็,ๆญ้ๅธ,้้ๅฟ':(27.45,104.87),
# 'ไบๅ็,ๆญ้ๅธ,ๅฝ่ฏๅฟ':(27.63,104.05),
# 'ไบๅ็,ๆญ้ๅธ,ๅจไฟกๅฟ':(27.85,105.05),
# 'ไบๅ็,ๆญ้ๅธ,ๆฐดๅฏๅฟ':(28.63,104.4),
# 'ไบๅ็,ไธฝๆฑๅธ,ไธฝๆฑๅธ':(26.88,100.23),
# 'ไบๅ็,ไธฝๆฑๅธ,ๅคๅๅบ':(26.88,100.23),
# 'ไบๅ็,ไธฝๆฑๅธ,็้พ็บณ่ฅฟๆ่ชๆฒปๅฟ':(26.82,100.23),
# 'ไบๅ็,ไธฝๆฑๅธ,ๆฐธ่ๅฟ':(26.68,100.75),
# 'ไบๅ็,ไธฝๆฑๅธ,ๅๅชๅฟ':(26.63,101.27),
# 'ไบๅ็,ไธฝๆฑๅธ,ๅฎ่ๅฝๆ่ชๆฒปๅฟ':(27.28,100.85),
# 'ไบๅ็,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟๅธ,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟ':(23.43,101.68),
# 'ไบๅ็,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟๅธ,ๆฏไธๅฝๆ่ชๆฒปๅฟ':(24.45,100.83),
# 'ไบๅ็,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟๅธ,ๆฏ่ฐทๅฃๆๅฝๆ่ชๆฒปๅฟ':(23.5,100.7),
# 'ไบๅ็,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟๅธ,ๆฑๅๅๅฐผๆๅฝๆ่ชๆฒปๅฟ':(22.58,101.85),
# 'ไบๅ็,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟๅธ,ๆพๆฒงๆ็ฅๆ่ชๆฒปๅฟ':(22.55,99.93),
# 'ไบๅ็,ๅขจๆฑๅๅฐผๆ่ชๆฒปๅฟๅธ,่ฅฟ็ไฝคๆ่ชๆฒปๅฟ':(22.63,99.62),
# 'ไบๅ็,ไธดๆฒงๅธ,ไธดๆฒงๅธ':(23.88,100.08),
# 'ไบๅ็,ไธดๆฒงๅธ,ไธด็ฟๅบ':(23.88,100.08),
# 'ไบๅ็,ไธดๆฒงๅธ,ๅคๅบๅฟ':(24.6,99.92),
# 'ไบๅ็,ไธดๆฒงๅธ,ไบๅฟ':(24.45,100.13),
# 'ไบๅ็,ไธดๆฒงๅธ,ๆฐธๅพทๅฟ':(24.03,99.25),
# 'ไบๅ็,ไธดๆฒงๅธ,้ๅบทๅฟ':(23.78,98.83),
# 'ไบๅ็,ไธดๆฒงๅธ,่ฟ้ฉฌๅฃๆไฝคๆ่ชๆฒปๅฟ':(23.55,99.4),
# 'ไบๅ็,ไธดๆฒงๅธ,ๆฒงๆบไฝคๆ่ชๆฒปๅฟ':(23.15,99.25),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๆฅ้ๅฝๆ่ชๆฒปๅท':(25.03,101.55),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๆฅ้ๅธ':(25.03,101.55),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๅๆๅฟ':(24.7,101.63),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,็ๅฎๅฟ':(25.32,101.53),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๅๅๅฟ':(25.2,101.27),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๅงๅฎๅฟ':(25.5,101.23),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๅคงๅงๅฟ':(25.73,101.32),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๆฐธไปๅฟ':(26.07,101.67),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๅ
่ฐๅฟ':(25.7,101.88),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,ๆญฆๅฎๅฟ':(25.53,102.4),
# 'ไบๅ็,ๆฅ้ๅฝๆ่ชๆฒปๅทๅธ,็ฆไธฐๅฟ':(25.15,102.08),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅท':(23.37,103.4),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ไธชๆงๅธ':(23.37,103.15),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๅผ่ฟๅธ':(23.72,103.27),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,่่ชๅฟ':(23.37,103.4),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๅฑ่พน่ๆ่ชๆฒปๅฟ':(22.98,103.68),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๅปบๆฐดๅฟ':(23.62,102.83),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,็ณๅฑๅฟ':(23.72,102.5),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๅผฅๅๅฟ':(24.4,103.43),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๆณธ่ฅฟๅฟ':(24.53,103.77),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๅ
้ณๅฟ':(23.23,102.83),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,็บขๆฒณๅฟ':(23.37,102.42),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,็ปฟๆฅๅฟ':(23.0,102.4),
# 'ไบๅ็,็บขๆฒณๅๅฐผๆๅฝๆ่ชๆฒปๅทๅธ,ๆฒณๅฃ็ถๆ่ชๆฒปๅฟ':(22.52,103.97),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅท':(23.37,104.25),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,ๆๅฑฑๅฟ':(23.37,104.25),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,็ ๅฑฑๅฟ':(23.62,104.33),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,่ฅฟ็ดๅฟ':(23.45,104.67),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,้บปๆ ๅกๅฟ':(23.12,104.7),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,้ฉฌๅ
ณๅฟ':(23.02,104.4),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,ไธๅๅฟ':(24.05,104.18),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,ๅนฟๅๅฟ':(24.05,105.07),
# 'ไบๅ็,ๆๅฑฑๅฃฎๆ่ๆ่ชๆฒปๅทๅธ,ๅฏๅฎๅฟ':(23.63,105.62),
# 'ไบๅ็,่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅทๅธ,่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅท':(22.02,100.8),
# 'ไบๅ็,่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅทๅธ,ๆฏๆดชๅธ':(22.02,100.8),
# 'ไบๅ็,่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅทๅธ,ๅๆตทๅฟ':(21.97,100.45),
# 'ไบๅ็,่ฅฟๅ็็บณๅฃๆ่ชๆฒปๅทๅธ,ๅ่
ๅฟ':(21.48,101.57),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅคง็็ฝๆ่ชๆฒปๅท':(25.6,100.23),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅคง็ๅธ':(25.6,100.23),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๆผพๆฟๅฝๆ่ชๆฒปๅฟ':(25.67,99.95),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,็ฅฅไบๅฟ':(25.48,100.55),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅฎพๅทๅฟ':(25.83,100.58),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅผฅๆธกๅฟ':(25.35,100.48),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅๆถงๅฝๆ่ชๆฒปๅฟ':(25.05,100.52),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅทๅฑฑๅฝๆๅๆ่ชๆฒปๅฟ':(25.23,100.3),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๆฐธๅนณๅฟ':(25.47,99.53),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ไบ้พๅฟ':(25.88,99.37),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๆดฑๆบๅฟ':(26.12,99.95),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,ๅๅทๅฟ':(26.53,99.9),
# 'ไบๅ็,ๅคง็็ฝๆ่ชๆฒปๅทๅธ,้นคๅบๅฟ':(26.57,100.18),
# 'ไบๅ็,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅทๅธ,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅท':(24.43,98.58),
# 'ไบๅ็,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅทๅธ,็ไธฝๅธ':(24.02,97.85),
# 'ไบๅ็,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅทๅธ,ๆฝ่ฅฟๅธ':(24.43,98.58),
# 'ไบๅ็,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅทๅธ,ๆขๆฒณๅฟ':(24.82,98.3),
# 'ไบๅ็,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅทๅธ,็ๆฑๅฟ':(24.72,97.93),
# 'ไบๅ็,ๅพทๅฎๅฃๆๆฏ้ขๆ่ชๆฒปๅทๅธ,้ๅทๅฟ':(24.2,97.8),
# 'ไบๅ็,ๆๆฑๅๅณๆ่ชๆฒปๅทๅธ,ๆๆฑๅๅณๆ่ชๆฒปๅท':(25.85,98.85),
# 'ไบๅ็,ๆๆฑๅๅณๆ่ชๆฒปๅทๅธ,ๆณธๆฐดๅฟ':(25.85,98.85),
# 'ไบๅ็,ๆๆฑๅๅณๆ่ชๆฒปๅทๅธ,็ฆ่ดกๅฟ':(26.9,98.87),
# 'ไบๅ็,ๆๆฑๅๅณๆ่ชๆฒปๅทๅธ,่ดกๅฑฑ็ฌ้พๆๆๆ่ชๆฒปๅฟ':(27.73,98.67),
# 'ไบๅ็,ๆๆฑๅๅณๆ่ชๆฒปๅทๅธ,ๅ
ฐๅช็ฝๆๆฎ็ฑณๆ่ชๆฒปๅฟ':(26.45,99.42),
# 'ไบๅ็,่ฟชๅบ่ๆ่ชๆฒปๅทๅธ,่ฟชๅบ่ๆ่ชๆฒปๅท':(27.83,99.7),
# 'ไบๅ็,่ฟชๅบ่ๆ่ชๆฒปๅทๅธ,้ฆๆ ผ้ๆๅฟ':(27.83,99.7),
# 'ไบๅ็,่ฟชๅบ่ๆ่ชๆฒปๅทๅธ,ๅพท้ฆๅฟ':(28.48,98.92),
# 'ไบๅ็,่ฟชๅบ่ๆ่ชๆฒปๅทๅธ,็ปด่ฅฟๅๅณๆ่ชๆฒปๅฟ':(27.18,99.28),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๆ่จๅธ':(29.65,91.13),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๅๅ
ณๅบ':(29.65,91.13),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๆๅจๅฟ':(29.9,91.25),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๅฝ้ๅฟ':(30.48,91.1),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๅฐผๆจๅฟ':(29.45,90.15),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๆฒๆฐดๅฟ':(29.37,90.73),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๅ ้พๅพทๅบๅฟ':(29.65,91.0),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,่พพๅญๅฟ':(29.68,91.35),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่จๅธ,ๅขจ็ซนๅทฅๅกๅฟ':(29.83,91.73),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๆ้ฝๅฐๅบ':(31.13,97.18),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๆ้ฝๅฟ':(31.13,97.18),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๆฑ่พพๅฟ':(31.5,98.22),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,่ดก่งๅฟ':(30.87,98.27),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,็ฑปไน้ฝๅฟ':(31.22,96.6),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ไธ้ๅฟ':(31.42,95.6),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๅฏ้
ๅฟ':(30.65,97.57),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๅ
ซๅฎฟๅฟ':(30.05,96.92),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๅทฆ่ดกๅฟ':(29.67,97.85),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,่ๅบทๅฟ':(29.68,98.6),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,ๆด้ๅฟ':(30.75,95.83),
# '่ฅฟ่่ชๆฒปๅบ,ๆ้ฝๅฐๅบๅธ,่พนๅๅฟ':(30.93,94.7),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๅฑฑๅๅฐๅบ':(29.23,91.77),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ไนไธๅฟ':(29.23,91.77),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๆๅๅฟ':(29.25,91.33),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,่ดกๅๅฟ':(29.3,90.98),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๆกๆฅๅฟ':(29.27,92.02),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,็ผ็ปๅฟ':(29.03,91.68),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๆฒๆพๅฟ':(29.07,92.2),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๆช็พๅฟ':(28.43,91.43),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๆดๆๅฟ':(28.38,90.87),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๅ ๆฅๅฟ':(29.15,92.58),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,้ๅญๅฟ':(28.42,92.47),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,้้ฃๅฟ':(28.0,91.95),
# '่ฅฟ่่ชๆฒปๅบ,ๅฑฑๅๅฐๅบๅธ,ๆตชๅกๅญๅฟ':(28.97,90.4),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๆฅๅๅๅฐๅบ':(29.27,88.88),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๆฅๅๅๅธ':(29.27,88.88),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๅๆจๆๅฟ':(29.68,89.1),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๆฑๅญๅฟ':(28.92,89.6),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๅฎๆฅๅฟ':(28.67,87.12),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,่จ่ฟฆๅฟ':(28.9,88.02),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๆๅญๅฟ':(29.08,87.63),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๆไปๅฟ':(29.3,87.23),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,่ฐข้้จๅฟ':(29.43,88.27),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,็ฝๆๅฟ':(29.12,89.27),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ไปๅธๅฟ':(29.23,89.83),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๅบท้ฉฌๅฟ':(28.57,89.68),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๅฎ็ปๅฟ':(28.37,87.77),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ไปฒๅทดๅฟ':(29.77,84.03),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ไบไธๅฟ':(27.48,88.9),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๅ้ๅฟ':(28.85,85.3),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,่ๆๆจๅฟ':(28.17,85.98),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,่จๅๅฟ':(29.33,85.23),
# '่ฅฟ่่ชๆฒปๅบ,ๆฅๅๅๅฐๅบๅธ,ๅฒๅทดๅฟ':(28.28,88.52),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,้ฃๆฒๅฐๅบ':(31.48,92.07),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,้ฃๆฒๅฟ':(31.48,92.07),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,ๅ้ปๅฟ':(30.65,93.25),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,ๆฏๅฆๅฟ':(31.48,93.68),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,่่ฃๅฟ':(32.12,92.3),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,ๅฎๅคๅฟ':(32.27,91.68),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,็ณๆๅฟ':(30.93,88.7),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,็ดขๅฟ':(31.88,93.78),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,็ญๆๅฟ':(31.37,90.02),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,ๅทด้ๅฟ':(31.93,94.03),
# '่ฅฟ่่ชๆฒปๅบ,้ฃๆฒๅฐๅบๅธ,ๅฐผ็ๅฟ':(31.78,87.23),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,้ฟ้ๅฐๅบ':(32.5,80.1),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,ๆฎๅ
ฐๅฟ':(30.3,81.17),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,ๆญ่พพๅฟ':(31.48,79.8),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,ๅถๅฐๅฟ':(32.5,80.1),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,ๆฅๅๅฟ':(33.38,79.72),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,้ฉๅๅฟ':(32.4,81.12),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,ๆนๅๅฟ':(32.3,84.07),
# '่ฅฟ่่ชๆฒปๅบ,้ฟ้ๅฐๅบๅธ,ๆชๅคๅฟ':(31.02,85.17),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๆ่ๅฐๅบ':(29.68,94.37),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๆ่ๅฟ':(29.68,94.37),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๅทฅๅธๆฑ่พพๅฟ':(29.88,93.25),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,็ฑณๆๅฟ':(29.22,94.22),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๅขจ่ฑๅฟ':(29.33,95.33),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๆณขๅฏๅฟ':(29.87,95.77),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๅฏ้
ๅฟ':(28.67,97.47),
# '่ฅฟ่่ชๆฒปๅบ,ๆ่ๅฐๅบๅธ,ๆๅฟ':(29.05,93.07),
# '้่ฅฟ็,่ฅฟๅฎๅธ,่ฅฟๅฎๅธ':(34.27,108.93),
# '้่ฅฟ็,่ฅฟๅฎๅธ,ๆฐๅๅบ':(34.27,108.95),
# '้่ฅฟ็,่ฅฟๅฎๅธ,็ขๆๅบ':(34.23,108.93),
# '้่ฅฟ็,่ฅฟๅฎๅธ,่ฒๆนๅบ':(34.27,108.93),
# '้่ฅฟ็,่ฅฟๅฎๅธ,็ๆกฅๅบ':(34.27,109.07),
# '้่ฅฟ็,่ฅฟๅฎๅธ,ๆชๅคฎๅบ':(34.28,108.93),
# '้่ฅฟ็,่ฅฟๅฎๅธ,้ๅกๅบ':(34.22,108.95),
# '้่ฅฟ็,่ฅฟๅฎๅธ,้่ฏๅบ':(34.65,109.23),
# '้่ฅฟ็,่ฅฟๅฎๅธ,ไธดๆฝผๅบ':(34.37,109.22),
# '้่ฅฟ็,่ฅฟๅฎๅธ,้ฟๅฎๅบ':(34.17,108.93),
# '้่ฅฟ็,่ฅฟๅฎๅธ,่็ฐๅฟ':(34.15,109.32),
# '้่ฅฟ็,่ฅฟๅฎๅธ,ๅจ่ณๅฟ':(34.17,108.2),
# '้่ฅฟ็,่ฅฟๅฎๅธ,ๆทๅฟ':(34.1,108.6),
# '้่ฅฟ็,่ฅฟๅฎๅธ,้ซ้ตๅฟ':(34.53,109.08),
# '้่ฅฟ็,้ๅทๅธ,้ๅทๅธ':(34.9,108.93),
# '้่ฅฟ็,้ๅทๅธ,็็ๅบ':(35.07,109.07),
# '้่ฅฟ็,้ๅทๅธ,ๅฐๅฐๅบ':(35.1,109.1),
# '้่ฅฟ็,้ๅทๅธ,่ๅทๅบ':(34.92,108.98),
# '้่ฅฟ็,้ๅทๅธ,ๅฎๅๅฟ':(35.4,109.12),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๅฎ้ธกๅธ':(34.37,107.13),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๆธญๆปจๅบ':(34.37,107.15),
# '้่ฅฟ็,ๅฎ้ธกๅธ,้ๅฐๅบ':(34.38,107.13),
# '้่ฅฟ็,ๅฎ้ธกๅธ,้ไปๅบ':(34.37,107.37),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๅค็ฟๅฟ':(34.52,107.38),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๅฒๅฑฑๅฟ':(34.45,107.62),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๆถ้ฃๅฟ':(34.37,107.87),
# '้่ฅฟ็,ๅฎ้ธกๅธ,็ๅฟ':(34.28,107.75),
# '้่ฅฟ็,ๅฎ้ธกๅธ,้ๅฟ':(34.9,106.85),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๅ้ณๅฟ':(34.65,107.13),
# '้่ฅฟ็,ๅฎ้ธกๅธ,้บๆธธๅฟ':(34.68,107.78),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๅคๅฟ':(33.92,106.52),
# '้่ฅฟ็,ๅฎ้ธกๅธ,ๅคช็ฝๅฟ':(34.07,107.32),
# '้่ฅฟ็,ๅธ้ณๅธ,ๅธ้ณๅธ':(34.33,108.7),
# '้่ฅฟ็,ๅธ้ณๅธ,็งฆ้ฝๅบ':(34.35,108.72),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆจๅๅบ':(34.28,108.07),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆธญๅๅบ':(34.33,108.73),
# '้่ฅฟ็,ๅธ้ณๅธ,ไธๅๅฟ':(34.62,108.93),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆณพ้ณๅฟ':(34.53,108.83),
# '้่ฅฟ็,ๅธ้ณๅธ,ไนพๅฟ':(34.53,108.23),
# '้่ฅฟ็,ๅธ้ณๅธ,็คผๆณๅฟ':(34.48,108.42),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆฐธๅฏฟๅฟ':(34.7,108.13),
# '้่ฅฟ็,ๅธ้ณๅธ,ๅฝฌๅฟ':(35.03,108.08),
# '้่ฅฟ็,ๅธ้ณๅธ,้ฟๆญฆๅฟ':(35.2,107.78),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆฌ้ๅฟ':(35.12,108.33),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆทณๅๅฟ':(34.78,108.58),
# '้่ฅฟ็,ๅธ้ณๅธ,ๆญฆๅๅฟ':(34.27,108.2),
# '้่ฅฟ็,ๅธ้ณๅธ,ๅ
ดๅนณๅธ':(34.3,108.48),
# '้่ฅฟ็,ๆธญๅๅธ,ๆธญๅๅธ':(34.5,109.5),
# '้่ฅฟ็,ๆธญๅๅธ,ไธดๆธญๅบ':(34.5,109.48),
# '้่ฅฟ็,ๆธญๅๅธ,ๅๅฟ':(34.52,109.77),
# '้่ฅฟ็,ๆธญๅๅธ,ๆฝผๅ
ณๅฟ':(34.55,110.23),
# '้่ฅฟ็,ๆธญๅๅธ,ๅคง่ๅฟ':(34.8,109.93),
# '้่ฅฟ็,ๆธญๅๅธ,ๅ้ณๅฟ':(35.23,110.15),
# '้่ฅฟ็,ๆธญๅๅธ,ๆพๅๅฟ':(35.18,109.93),
# '้่ฅฟ็,ๆธญๅๅธ,่ฒๅๅฟ':(34.95,109.58),
# '้่ฅฟ็,ๆธญๅๅธ,็ฝๆฐดๅฟ':(35.18,109.58),
# '้่ฅฟ็,ๆธญๅๅธ,ๅฏๅนณๅฟ':(34.75,109.18),
# '้่ฅฟ็,ๆธญๅๅธ,้ฉๅๅธ':(35.48,110.43),
# '้่ฅฟ็,ๆธญๅๅธ,ๅ้ดๅธ':(34.57,110.08),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅปถๅฎๅธ':(36.6,109.48),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅฎๅกๅบ':(36.6,109.48),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅปถ้ฟๅฟ':(36.58,110.0),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅปถๅทๅฟ':(36.88,110.18),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅญ้ฟๅฟ':(37.13,109.67),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅฎๅกๅฟ':(36.87,109.32),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅฟไธนๅฟ':(36.82,108.77),
# '้่ฅฟ็,ๅปถๅฎๅธ,็ๆณๅฟ':(36.28,109.35),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅฏๅฟ':(35.98,109.37),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๆดๅทๅฟ':(35.77,109.43),
# '้่ฅฟ็,ๅปถๅฎๅธ,ๅฎๅทๅฟ':(36.05,110.17),
# '้่ฅฟ็,ๅปถๅฎๅธ,้ป้พๅฟ':(35.58,109.83),
# '้่ฅฟ็,ๅปถๅฎๅธ,้ป้ตๅฟ':(35.58,109.25),
# '้่ฅฟ็,ๆฑไธญๅธ,ๆฑไธญๅธ':(33.07,107.02),
# '้่ฅฟ็,ๆฑไธญๅธ,ๆฑๅฐๅบ':(33.07,107.03),
# '้่ฅฟ็,ๆฑไธญๅธ,ๅ้ๅฟ':(33.0,106.93),
# '้่ฅฟ็,ๆฑไธญๅธ,ๅๅบๅฟ':(33.15,107.33),
# '้่ฅฟ็,ๆฑไธญๅธ,ๆดๅฟ':(33.22,107.55),
# '้่ฅฟ็,ๆฑไธญๅธ,่ฅฟไนกๅฟ':(32.98,107.77),
# '้่ฅฟ็,ๆฑไธญๅธ,ๅๅฟ':(33.15,106.67),
# '้่ฅฟ็,ๆฑไธญๅธ,ๅฎๅผบๅฟ':(32.83,106.25),
# '้่ฅฟ็,ๆฑไธญๅธ,็ฅ้ณๅฟ':(33.33,106.15),
# '้่ฅฟ็,ๆฑไธญๅธ,้ๅทดๅฟ':(32.53,107.9),
# '้่ฅฟ็,ๆฑไธญๅธ,็ๅๅฟ':(33.62,106.92),
# '้่ฅฟ็,ๆฑไธญๅธ,ไฝๅชๅฟ':(33.53,107.98),
# '้่ฅฟ็,ๆฆๆๅธ,ๆฆๆๅธ':(38.28,109.73),
# '้่ฅฟ็,ๆฆๆๅธ,ๆฆ้ณๅบ':(38.28,109.75),
# '้่ฅฟ็,ๆฆๆๅธ,็ฅๆจๅฟ':(38.83,110.5),
# '้่ฅฟ็,ๆฆๆๅธ,ๅบ่ฐทๅฟ':(39.03,111.07),
# '้่ฅฟ็,ๆฆๆๅธ,ๆจชๅฑฑๅฟ':(37.95,109.28),
# '้่ฅฟ็,ๆฆๆๅธ,้่พนๅฟ':(37.6,108.8),
# '้่ฅฟ็,ๆฆๆๅธ,ๅฎ่พนๅฟ':(37.58,107.6),
# '้่ฅฟ็,ๆฆๆๅธ,็ปฅๅพทๅฟ':(37.5,110.25),
# '้่ฅฟ็,ๆฆๆๅธ,็ฑณ่ๅฟ':(37.75,110.18),
# '้่ฅฟ็,ๆฆๆๅธ,ไฝณๅฟ':(38.02,110.48),
# '้่ฅฟ็,ๆฆๆๅธ,ๅดๅ กๅฟ':(37.45,110.73),
# '้่ฅฟ็,ๆฆๆๅธ,ๆธ
ๆถงๅฟ':(37.08,110.12),
# '้่ฅฟ็,ๆฆๆๅธ,ๅญๆดฒๅฟ':(37.62,110.03),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๅฎๅบทๅธ':(32.68,109.02),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๆฑๆปจๅบ':(32.68,109.02),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๆฑ้ดๅฟ':(32.9,108.5),
# '้่ฅฟ็,ๅฎๅบทๅธ,็ณๆณๅฟ':(33.05,108.25),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๅฎ้ๅฟ':(33.32,108.32),
# '้่ฅฟ็,ๅฎๅบทๅธ,็ดซ้ณๅฟ':(32.52,108.53),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๅฒ็ๅฟ':(32.32,108.9),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๅนณๅฉๅฟ':(32.4,109.35),
# '้่ฅฟ็,ๅฎๅบทๅธ,้ๅชๅฟ':(31.88,109.52),
# '้่ฅฟ็,ๅฎๅบทๅธ,ๆฌ้ณๅฟ':(32.83,109.38),
# '้่ฅฟ็,ๅฎๅบทๅธ,็ฝๆฒณๅฟ':(32.82,110.1),
# '้่ฅฟ็,ๅๆดๅธ,ๅๆดๅธ':(33.87,109.93),
# '้่ฅฟ็,ๅๆดๅธ,ๅๅทๅบ':(33.87,109.93),
# '้่ฅฟ็,ๅๆดๅธ,ๆดๅๅฟ':(34.08,110.13),
# '้่ฅฟ็,ๅๆดๅธ,ไธนๅคๅฟ':(33.7,110.33),
# '้่ฅฟ็,ๅๆดๅธ,ๅๅๅฟ':(33.53,110.88),
# '้่ฅฟ็,ๅๆดๅธ,ๅฑฑ้ณๅฟ':(33.53,109.88),
# '้่ฅฟ็,ๅๆดๅธ,้ๅฎๅฟ':(33.43,109.15),
# '้่ฅฟ็,ๅๆดๅธ,ๆๆฐดๅฟ':(33.68,109.1),
# '็่็,ๅ
ฐๅทๅธ,ๅ
ฐๅทๅธ':(36.07,103.82),
# '็่็,ๅ
ฐๅทๅธ,ๅๅ
ณๅบ':(36.05,103.83),
# '็่็,ๅ
ฐๅทๅธ,่ฅฟๅบๅบ':(36.1,103.62),
# '็่็,ๅ
ฐๅทๅธ,็บขๅคๅบ':(36.33,102.87),
# '็่็,ๅ
ฐๅทๅธ,ๆฐธ็ปๅฟ':(36.73,103.27),
# '็่็,ๅ
ฐๅทๅธ,็ๅ
ฐๅฟ':(36.33,103.95),
# '็่็,ๅ
ฐๅทๅธ,ๆฆไธญๅฟ':(35.85,104.12),
# '็่็,ๅๅณชๅ
ณๅธ,ๅๅณชๅ
ณๅธ':(39.8,98.27),
# '็่็,้ๆๅธ,้ๆๅธ':(38.5,102.18),
# '็่็,้ๆๅธ,้ๅทๅบ':(38.5,102.18),
# '็่็,้ๆๅธ,ๆฐธๆๅฟ':(38.25,101.97),
# '็่็,็ฝ้ถๅธ,็ฝ้ถๅธ':(36.55,104.18),
# '็่็,็ฝ้ถๅธ,็ฝ้ถๅบ':(36.55,104.18),
# '็่็,็ฝ้ถๅธ,ๅนณๅทๅบ':(36.73,104.83),
# '็่็,็ฝ้ถๅธ,้่ฟๅฟ':(36.57,104.68),
# '็่็,็ฝ้ถๅธ,ไผๅฎๅฟ':(35.7,105.05),
# '็่็,็ฝ้ถๅธ,ๆฏๆณฐๅฟ':(37.15,104.07),
# '็่็,ๅคฉๆฐดๅธ,ๅคฉๆฐดๅธ':(34.58,105.72),
# '็่็,ๅคฉๆฐดๅธ,ๆธ
ๆฐดๅฟ':(34.75,106.13),
# '็่็,ๅคฉๆฐดๅธ,็งฆๅฎๅฟ':(34.87,105.67),
# '็่็,ๅคฉๆฐดๅธ,็่ฐทๅฟ':(34.73,105.33),
# '็่็,ๅคฉๆฐดๅธ,ๆญฆๅฑฑๅฟ':(34.72,104.88),
# '็่็,ๅคฉๆฐดๅธ,ๅผ ๅฎถๅทๅๆ่ชๆฒปๅฟ':(35.0,106.22),
# '็่็,ๆญฆๅจๅธ,ๆญฆๅจๅธ':(37.93,102.63),
# '็่็,ๆญฆๅจๅธ,ๅๅทๅบ':(37.93,102.63),
# '็่็,ๆญฆๅจๅธ,ๆฐๅคๅฟ':(38.62,103.08),
# '็่็,ๆญฆๅจๅธ,ๅคๆตชๅฟ':(37.47,102.88),
# '็่็,ๆญฆๅจๅธ,ๅคฉ็ฅ่ๆ่ชๆฒปๅฟ':(36.98,103.13),
# '็่็,ๅผ ๆๅธ,ๅผ ๆๅธ':(38.93,100.45),
# '็่็,ๅผ ๆๅธ,็ๅทๅบ':(38.93,100.45),
# '็่็,ๅผ ๆๅธ,่ๅ่ฃๅบๆ่ชๆฒปๅฟ':(38.83,99.62),
# '็่็,ๅผ ๆๅธ,ๆฐไนๅฟ':(38.43,100.82),
# '็่็,ๅผ ๆๅธ,ไธดๆณฝๅฟ':(39.13,100.17),
# '็่็,ๅผ ๆๅธ,้ซๅฐๅฟ':(39.38,99.82),
# '็่็,ๅผ ๆๅธ,ๅฑฑไธนๅฟ':(38.78,101.08),
# '็่็,ๅนณๅๅธ,ๅนณๅๅธ':(35.55,106.67),
# '็่็,ๅนณๅๅธ,ๅดๅณๅบ':(35.55,106.67),
# '็่็,ๅนณๅๅธ,ๆณพๅทๅฟ':(35.33,107.37),
# '็่็,ๅนณๅๅธ,็ตๅฐๅฟ':(35.07,107.62),
# '็่็,ๅนณๅๅธ,ๅดไฟกๅฟ':(35.3,107.03),
# '็่็,ๅนณๅๅธ,ๅไบญๅฟ':(35.22,106.65),
# '็่็,ๅนณๅๅธ,ๅบๆตชๅฟ':(35.2,106.05),
# '็่็,ๅนณๅๅธ,้ๅฎๅฟ':(35.52,105.72),
# '็่็,้
ๆณๅธ,้
ๆณๅธ':(39.75,98.52),
# '็่็,้
ๆณๅธ,่ๅทๅบ':(39.75,98.52),
# '็่็,้
ๆณๅธ,้ๅกๅฟ':(39.98,98.9),
# '็่็,้
ๆณๅธ,่ๅ่ๅคๆ่ชๆฒปๅฟ':(39.52,94.88),
# '็่็,้
ๆณๅธ,้ฟๅ
ๅกๅ่จๅ
ๆ่ชๆฒปๅฟ':(39.63,94.33),
# '็่็,้
ๆณๅธ,็้จๅธ':(40.28,97.05),
# '็่็,้
ๆณๅธ,ๆฆ็
ๅธ':(40.13,94.67),
# '็่็,ๅบ้ณๅธ,ๅบ้ณๅธ':(35.73,107.63),
# '็่็,ๅบ้ณๅธ,่ฅฟๅณฐๅบ':(35.73,107.63),
# '็่็,ๅบ้ณๅธ,ๅบๅๅฟ':(36.0,107.88),
# '็่็,ๅบ้ณๅธ,็ฏๅฟ':(36.58,107.3),
# '็่็,ๅบ้ณๅธ,ๅๆฑ ๅฟ':(36.47,107.98),
# '็่็,ๅบ้ณๅธ,ๅๆฐดๅฟ':(35.82,108.02),
# '็่็,ๅบ้ณๅธ,ๆญฃๅฎๅฟ':(35.5,108.37),
# '็่็,ๅบ้ณๅธ,ๅฎๅฟ':(35.5,107.92),
# '็่็,ๅบ้ณๅธ,้ๅๅฟ':(35.68,107.2),
# '็่็,ๅฎ่ฅฟๅธ,ๅฎ่ฅฟๅธ':(35.58,104.62),
# '็่็,ๅฎ่ฅฟๅธ,ๅฎๅฎๅบ':(35.58,104.62),
# '็่็,ๅฎ่ฅฟๅธ,้ๆธญๅฟ':(35.2,105.25),
# '็่็,ๅฎ่ฅฟๅธ,้่ฅฟๅฟ':(35.0,104.63),
# '็่็,ๅฎ่ฅฟๅธ,ๆธญๆบๅฟ':(35.13,104.22),
# '็่็,ๅฎ่ฅฟๅธ,ไธดๆดฎๅฟ':(35.38,103.87),
# '็่็,ๅฎ่ฅฟๅธ,ๆผณๅฟ':(34.85,104.47),
# '็่็,ๅฎ่ฅฟๅธ,ๅฒทๅฟ':(34.43,104.03),
# '็่็,้ๅๅธ,้ๅๅธ':(33.4,104.92),
# '็่็,้ๅๅธ,ๆญฆ้ฝๅบ':(33.4,104.92),
# '็่็,้ๅๅธ,ๆๅฟ':(33.73,105.72),
# '็่็,้ๅๅธ,ๆๅฟ':(32.95,104.68),
# '็่็,้ๅๅธ,ๅฎๆๅฟ':(34.05,104.38),
# '็่็,้ๅๅธ,ๅบทๅฟ':(33.33,105.6),
# '็่็,้ๅๅธ,่ฅฟๅๅฟ':(34.02,105.3),
# '็่็,้ๅๅธ,็คผๅฟ':(34.18,105.17),
# '็่็,้ๅๅธ,ๅพฝๅฟ':(33.77,106.08),
# '็่็,้ๅๅธ,ไธคๅฝๅฟ':(33.92,106.3),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ไธดๅคๅๆ่ชๆฒปๅท':(35.6,103.22),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ไธดๅคๅธ':(35.6,103.22),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ไธดๅคๅฟ':(35.5,103.0),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ๅบทไนๅฟ':(35.37,103.72),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ๆฐธ้ๅฟ':(35.93,103.32),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ๅนฟๆฒณๅฟ':(35.48,103.58),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ๅๆฟๅฟ':(35.43,103.35),
# '็่็,ไธดๅคๅๆ่ชๆฒปๅทๅธ,ไธไนกๆ่ชๆฒปๅฟ':(35.67,103.4),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,็ๅ่ๆ่ชๆฒปๅท':(34.98,102.92),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,ๅไฝๅธ':(34.98,102.92),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,ไธดๆฝญๅฟ':(34.7,103.35),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,ๅๅฐผๅฟ':(34.58,103.5),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,่ๆฒๅฟ':(33.78,104.37),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,่ฟญ้จๅฟ':(34.05,103.22),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,็ๆฒๅฟ':(34.0,102.07),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,็ขๆฒๅฟ':(34.58,102.48),
# '็่็,็ๅ่ๆ่ชๆฒปๅทๅธ,ๅคๆฒณๅฟ':(35.2,102.52),
# '้ๆตท็,่ฅฟๅฎๅธ,่ฅฟๅฎๅธ':(36.62,101.78),
# '้ๆตท็,่ฅฟๅฎๅธ,ๅไธๅบ':(36.62,101.8),
# '้ๆตท็,่ฅฟๅฎๅธ,ๅไธญๅบ':(36.62,101.78),
# '้ๆตท็,่ฅฟๅฎๅธ,ๅ่ฅฟๅบ':(36.62,101.77),
# '้ๆตท็,่ฅฟๅฎๅธ,ๅๅๅบ':(36.67,101.77),
# '้ๆตท็,่ฅฟๅฎๅธ,ๅคง้ๅๆๅๆ่ชๆฒปๅฟ':(36.93,101.68),
# '้ๆตท็,่ฅฟๅฎๅธ,ๆนไธญๅฟ':(36.5,101.57),
# '้ๆตท็,่ฅฟๅฎๅธ,ๆนๆบๅฟ':(36.68,101.27),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ๆตทไธๅฐๅบ':(36.5,102.12),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ๅนณๅฎๅฟ':(36.5,102.12),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ๆฐๅๅๆๅๆ่ชๆฒปๅฟ':(36.33,102.8),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ไน้ฝๅฟ':(36.48,102.4),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ไบๅฉๅๆ่ชๆฒปๅฟ':(36.83,101.95),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ๅ้ๅๆ่ชๆฒปๅฟ':(36.1,102.27),
# '้ๆตท็,ๆตทไธๅฐๅบๅธ,ๅพชๅๆๆๆ่ชๆฒปๅฟ':(35.85,102.48),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๆตทๅ่ๆ่ชๆฒปๅท':(36.97,100.9),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,้จๆบๅๆ่ชๆฒปๅฟ':(37.38,101.62),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,็ฅ่ฟๅฟ':(38.18,100.25),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๆตทๆๅฟ':(36.9,100.98),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๅๅฏๅฟ':(37.33,100.13),
# '้ๆตท็,้ปๅ่ๆ่ชๆฒปๅทๅธ,้ปๅ่ๆ่ชๆฒปๅท':(35.52,102.02),
# '้ๆตท็,้ปๅ่ๆ่ชๆฒปๅทๅธ,ๅไปๅฟ':(35.52,102.02),
# '้ๆตท็,้ปๅ่ๆ่ชๆฒปๅทๅธ,ๅฐๆๅฟ':(35.93,102.03),
# '้ๆตท็,้ปๅ่ๆ่ชๆฒปๅทๅธ,ๆณฝๅบๅฟ':(35.03,101.47),
# '้ๆตท็,้ปๅ่ๆ่ชๆฒปๅทๅธ,ๆฒณๅ่ๅคๆ่ชๆฒปๅฟ':(34.73,101.6),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๆตทๅ่ๆ่ชๆฒปๅท':(36.28,100.62),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๅ
ฑๅๅฟ':(36.28,100.62),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๅๅพทๅฟ':(35.25,100.57),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,่ดตๅพทๅฟ':(36.05,101.43),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,ๅ
ดๆตทๅฟ':(35.58,99.98),
# '้ๆตท็,ๆตทๅ่ๆ่ชๆฒปๅทๅธ,่ดตๅๅฟ':(35.58,100.75),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,ๆๆด่ๆ่ชๆฒปๅท':(34.48,100.23),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,็ๆฒๅฟ':(34.48,100.23),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,็ญ็ๅฟ':(32.93,100.73),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,็ๅพทๅฟ':(33.97,99.9),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,่พพๆฅๅฟ':(33.75,99.65),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,ไน
ๆฒปๅฟ':(33.43,101.48),
# '้ๆตท็,ๆๆด่ๆ่ชๆฒปๅทๅธ,็ๅคๅฟ':(34.92,98.18),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,็ๆ ่ๆ่ชๆฒปๅท':(33.0,97.02),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,็ๆ ๅฟ':(33.0,97.02),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,ๆๅคๅฟ':(32.9,95.3),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,็งฐๅคๅฟ':(33.37,97.1),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,ๆฒปๅคๅฟ':(33.85,95.62),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,ๅ่ฐฆๅฟ':(32.2,96.48),
# '้ๆตท็,็ๆ ่ๆ่ชๆฒปๅทๅธ,ๆฒ้บป่ฑๅฟ':(34.13,95.8),
# '้ๆตท็,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅทๅธ,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅท':(37.37,97.37),
# '้ๆตท็,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅทๅธ,ๆ ผๅฐๆจๅธ':(36.42,94.9),
# '้ๆตท็,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅทๅธ,ๅพทไปคๅๅธ':(37.37,97.37),
# '้ๆตท็,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅทๅธ,ไนๅ
ฐๅฟ':(36.93,98.48),
# '้ๆตท็,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅทๅธ,้ฝๅ
ฐๅฟ':(36.3,98.08),
# '้ๆตท็,ๆตท่ฅฟ่ๅคๆ่ๆ่ชๆฒปๅทๅธ,ๅคฉๅณปๅฟ':(37.3,99.02),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,้ถๅทๅธ':(38.47,106.28),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,ๅ
ดๅบๅบ':(38.48,106.28),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,่ฅฟๅคๅบ':(38.48,106.18),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,้ๅคๅบ':(38.47,106.25),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,ๆฐธๅฎๅฟ':(38.28,106.25),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,่ดบๅ
ฐๅฟ':(38.55,106.35),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,้ถๅทๅธ,็ตๆญฆๅธ':(38.1,106.33),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,็ณๅดๅฑฑๅธ,็ณๅดๅฑฑๅธ':(39.02,106.38),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,็ณๅดๅฑฑๅธ,ๅคงๆญฆๅฃๅบ':(39.02,106.38),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,็ณๅดๅฑฑๅธ,ๆ ๅๅบ':(39.25,106.78),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,็ณๅดๅฑฑๅธ,ๅนณ็ฝๅฟ':(38.9,106.53),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅดๅฟ ๅธ,ๅดๅฟ ๅธ':(37.98,106.2),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅดๅฟ ๅธ,ๅฉ้ๅบ':(37.98,106.2),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅดๅฟ ๅธ,็ๆฑ ๅฟ':(37.78,107.4),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅดๅฟ ๅธ,ๅๅฟๅฟ':(36.98,105.92),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅดๅฟ ๅธ,้้ๅณกๅธ':(38.02,106.07),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅบๅๅธ,ๅบๅๅธ':(36.0,106.28),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅบๅๅธ,ๅๅทๅบ':(36.0,106.28),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅบๅๅธ,่ฅฟๅๅฟ':(35.97,105.73),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅบๅๅธ,้ๅพทๅฟ':(35.62,106.12),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅบๅๅธ,ๆณพๆบๅฟ':(35.48,106.33),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ๅบๅๅธ,ๅฝญ้ณๅฟ':(35.85,106.63),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ไธญๅซๅธ,ไธญๅซๅธ':(37.52,105.18),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ไธญๅซๅธ,ๆฒๅกๅคดๅบ':(37.52,105.18),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ไธญๅซๅธ,ไธญๅฎๅฟ':(37.48,105.67),
# 'ๅฎๅคๅๆ่ชๆฒปๅบ,ไธญๅซๅธ,ๆตทๅๅฟ':(36.57,105.65),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ไน้ฒๆจ้ฝๅธ':(43.82,87.62),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ๅคฉๅฑฑๅบ':(43.78,87.65),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ๆฒไพๅทดๅ
ๅบ':(43.78,87.6),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ๆฐๅธๅบ':(43.85,87.6),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ๆฐด็ฃจๆฒๅบ':(43.83,87.63),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ๅคดๅฑฏๆฒณๅบ':(43.87,87.42),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,่พพๅๅๅบ':(43.35,88.3),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ไธๅฑฑๅบ':(43.95,87.68),
# 'ๆฐ็็ปดๅพๅฐ,ไน้ฒๆจ้ฝๅธ,ไน้ฒๆจ้ฝๅฟ':(43.8,87.6),
# 'ๆฐ็็ปดๅพๅฐ,ๅ
ๆ็ไพๅธ,ๅ
ๆ็ไพๅธ':(45.6,84.87),
# 'ๆฐ็็ปดๅพๅฐ,ๅ
ๆ็ไพๅธ,็ฌๅฑฑๅญๅบ':(44.32,84.85),
# 'ๆฐ็็ปดๅพๅฐ,ๅ
ๆ็ไพๅธ,ๅ
ๆ็ไพๅบ':(45.6,84.87),
# 'ๆฐ็็ปดๅพๅฐ,ๅ
ๆ็ไพๅธ,็ฝ็ขฑๆปฉๅบ':(45.7,85.13),
# 'ๆฐ็็ปดๅพๅฐ,ๅ
ๆ็ไพๅธ,ไนๅฐ็ฆพๅบ':(46.08,85.68),
# 'ๆฐ็็ปดๅพๅฐ,ๅ้ฒ็ชๅฐๅบๅธ,ๅ้ฒ็ชๅฐๅบ':(42.95,89.17),
# 'ๆฐ็็ปดๅพๅฐ,ๅ้ฒ็ชๅฐๅบๅธ,ๅ้ฒ็ชๅธ':(42.95,89.17),
# 'ๆฐ็็ปดๅพๅฐ,ๅ้ฒ็ชๅฐๅบๅธ,้ฏๅๅฟ':(42.87,90.22),
# 'ๆฐ็็ปดๅพๅฐ,ๅ้ฒ็ชๅฐๅบๅธ,ๆๅ
้ๅฟ':(42.78,88.65),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฏๅฐๅบๅธ,ๅๅฏๅฐๅบ':(42.83,93.52),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฏๅฐๅบๅธ,ๅๅฏๅธ':(42.83,93.52),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฏๅฐๅบๅธ,ไผๅพๅฟ':(43.25,94.7),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,ๆๅๅๆ่ชๆฒปๅท':(44.02,87.3),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,ๆๅๅธ':(44.02,87.3),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,้ๅบทๅธ':(44.15,87.98),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,็ฑณๆณๅธ':(43.97,87.65),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,ๅผๅพๅฃๅฟ':(44.18,86.9),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,็็บณๆฏๅฟ':(44.3,86.22),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,ๅฅๅฐๅฟ':(44.02,89.58),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,ๅๆจ่จๅฐๅฟ':(44.0,89.18),
# 'ๆฐ็็ปดๅพๅฐ,ๆๅๅๆ่ชๆฒปๅทๅธ,ๆจๅๅ่จๅ
่ชๆฒปๅฟ':(43.83,90.28),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฐๅกๆ่ๅค่ชๆฒปๅทๅธ,ๅๅฐๅกๆ่ๅค่ชๆฒปๅท':(44.9,82.07),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฐๅกๆ่ๅค่ชๆฒปๅทๅธ,ๅไนๅธ':(44.9,82.07),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฐๅกๆ่ๅค่ชๆฒปๅทๅธ,็ฒพๆฒณๅฟ':(44.6,82.88),
# 'ๆฐ็็ปดๅพๅฐ,ๅๅฐๅกๆ่ๅค่ชๆฒปๅทๅธ,ๆธฉๆณๅฟ':(44.97,81.03),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅท':(41.77,86.15),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ๅบๅฐๅๅธ':(41.77,86.15),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,่ฝฎๅฐๅฟ':(41.78,84.27),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ๅฐ็ๅฟ':(41.33,86.25),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,่ฅ็พๅฟ':(39.02,88.17),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ไธๆซๅฟ':(38.13,85.53),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,็่ๅๆ่ชๆฒปๅฟ':(42.07,86.57),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ๅ้ๅฟ':(42.32,86.4),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ๅ็กๅฟ':(42.27,86.87),
# 'ๆฐ็็ปดๅพๅฐ,ๅทด้ณ้ญๆฅ่ๅค่ชๆฒปๅทๅธ,ๅๆนๅฟ':(41.98,86.63),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,้ฟๅ
่ๅฐๅบ':(41.17,80.27),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,้ฟๅ
่ๅธ':(41.17,80.27),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ๆธฉๅฎฟๅฟ':(41.28,80.23),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ๅบ่ฝฆๅฟ':(41.72,82.97),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ๆฒ้
ๅฟ':(41.22,82.78),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ๆฐๅๅฟ':(41.55,82.6),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ๆๅๅฟ':(41.8,81.87),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ไนไปๅฟ':(41.22,79.23),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,้ฟ็ฆๆๅฟ':(40.63,80.38),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅ
่ๅฐๅบๅธ,ๆฏๅชๅฟ':(40.5,79.05),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅพไปๅธ,้ฟๅพไปๅธ':(39.72,76.17),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅพไปๅธ,้ฟๅ
้ถๅฟ':(39.15,75.95),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅพไปๅธ,้ฟๅๅฅๅฟ':(40.93,78.45),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅพไปๅธ,ไนๆฐๅฟ':(39.72,75.25),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ๅไปๅฐๅบ':(39.47,75.98),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ๅไปๅธ':(39.47,75.98),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,็้ๅฟ':(39.38,75.85),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,็ๅๅฟ':(39.4,76.05),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,่ฑๅๆฒๅฟ':(38.93,76.17),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ๆณฝๆฎๅฟ':(38.18,77.27),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,่่ฝฆๅฟ':(38.42,77.23),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ๅถๅๅฟ':(37.88,77.42),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,้บฆ็ๆๅฟ':(38.9,77.65),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ๅฒณๆฎๆนๅฟ':(39.23,76.77),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ไผฝๅธๅฟ':(39.5,76.73),
# 'ๆฐ็็ปดๅพๅฐ,ๅไปๅฐๅบๅธ,ๅทดๆฅๅฟ':(39.78,78.55),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ๅ็ฐๅฐๅบ':(37.12,79.92),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ๅ็ฐๅธ':(37.12,79.92),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ๅ็ฐๅฟ':(37.1,79.93),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ๅขจ็ๅฟ':(37.27,79.73),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,็ฎๅฑฑๅฟ':(37.62,78.28),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ๆดๆตฆๅฟ':(37.07,80.18),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,็ญๅๅฟ':(37.0,80.8),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ไบ็ฐๅฟ':(36.85,81.67),
# 'ๆฐ็็ปดๅพๅฐ,ๅ็ฐๅฐๅบๅธ,ๆฐไธฐๅฟ':(37.07,82.68),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ไผ็ๅ่จๅ
่ชๆฒปๅท':(43.92,81.32),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ไผๅฎๅธ':(43.92,81.32),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ๅฅๅฑฏๅธ':(44.42,84.9),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ไผๅฎๅฟ':(43.98,81.52),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ๅฏๅธๆฅๅฐ้กไผฏ่ชๆฒปๅฟ':(43.83,81.15),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,้ๅๅฟ':(44.05,80.88),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ๅทฉ็ๅฟ':(43.48,82.23),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ๆฐๆบๅฟ':(43.43,83.25),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ๆญ่ๅฟ':(43.15,81.13),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,็นๅ
ๆฏๅฟ':(43.22,81.83),
# 'ๆฐ็็ปดๅพๅฐ,ไผ็ๅ่จๅ
่ชๆฒปๅทๅธ,ๅฐผๅๅ
ๅฟ':(43.78,82.5),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,ๅกๅๅฐๅบ':(46.75,82.98),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,ๅกๅๅธ':(46.75,82.98),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,ไน่ๅธ':(44.43,84.68),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,้ขๆๅฟ':(46.53,83.63),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,ๆฒๆนพๅฟ':(44.33,85.62),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,ๆ้ๅฟ':(45.93,83.6),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,่ฃๆฐๅฟ':(46.2,82.98),
# 'ๆฐ็็ปดๅพๅฐ,ๅกๅๅฐๅบๅธ,ๅๅธๅ
่ตๅฐ่ๅค่ชๆฒปๅฟ':(46.8,85.72),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,้ฟๅๆณฐๅฐๅบ':(47.85,88.13),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,้ฟๅๆณฐๅธ':(47.85,88.13),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,ๅธๅฐๆดฅๅฟ':(47.7,86.85),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,ๅฏ่ดๅฟ':(47.0,89.52),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,็ฆๆตทๅฟ':(47.12,87.5),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,ๅๅทดๆฒณๅฟ':(48.07,86.42),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,้ๆฒณๅฟ':(46.67,90.38),
# 'ๆฐ็็ปดๅพๅฐ,้ฟๅๆณฐๅฐๅบๅธ,ๅๆจไนๅฟ':(47.43,85.88),
# 'ๆฐ็็ปดๅพๅฐ,็ณๆฒณๅญๅธ,็ณๆฒณๅญๅธ':(44.3,86.03),
# 'ๆฐ็็ปดๅพๅฐ,็ณๆฒณๅญๅธ,้ฟๆๅฐๅธ':(40.55,81.28),
# 'ๆฐ็็ปดๅพๅฐ,็ณๆฒณๅญๅธ,ๅพๆจ่ๅ
ๅธ':(39.85,79.13),
# 'ๆฐ็็ปดๅพๅฐ,็ณๆฒณๅญๅธ,ไบๅฎถๆธ ๅธ':(44.17,87.53),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,้ฆๆธฏ':(22.2,114.08),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๆพณ้จ':(22.13,113.33),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐๅๅธ':(25.03,121.5),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,้ซ้ๅธ':(22.62,120.28),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅบ้ๅธ':(25.13,121.73),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐไธญๅธ':(24.15,120.67),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐๅๅธ':(23.0,120.2),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๆฐ็ซนๅธ':(24.82,120.95),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅไนๅธ':(23.48,120.43),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐๅๅฟ':(25.02,121.47),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฎๅ
ฐๅฟ':(24.77,121.75),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๆกๅญๅฟ':(24.97,121.3),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,่ๆ ๅฟ':(24.53,120.8),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐไธญๅฟ':(24.25,120.72),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฝฐๅๅฟ':(24.08,120.53),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅๆๅฟ':(23.92,120.67),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ไบๆๅฟ':(23.72,120.53),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐๅๅฟ':(23.32,120.32),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,้ซ้ๅฟ':(22.63,120.37),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฑไธๅฟ':(22.67,120.48),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๅฐไธๅฟ':(22.75,121.15),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,่ฑ่ฒๅฟ':(23.98,121.6),
# 'ๆธฏๆพณๅฐ,ๆธฏๆพณๅฐๅธ,ๆพๆนๅฟ':(23.58,119.58),
# } | yve | /yve-0.0.21-py3-none-any.whl/mapper/mappers.py | mappers.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Gaussian(Distribution):
""" Gaussian distribution class for calculating and
visualizing a Gaussian distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats extracted from the data file
"""
def __init__(self, mu=0, sigma=1):
Distribution.__init__(self, mu, sigma)
def calculate_mean(self):
"""Function to calculate the mean of the data set.
Args:
None
Returns:
float: mean of the data set
"""
avg = 1.0 * sum(self.data) / len(self.data)
self.mean = avg
return self.mean
def calculate_stdev(self, sample=True):
"""Function to calculate the standard deviation of the data set.
Args:
sample (bool): whether the data represents a sample or population
Returns:
float: standard deviation of the data set
"""
if sample:
n = len(self.data) - 1
else:
n = len(self.data)
mean = self.calculate_mean()
sigma = 0
for d in self.data:
sigma += (d - mean) ** 2
sigma = math.sqrt(sigma / n)
self.stdev = sigma
return self.stdev
def plot_histogram(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.hist(self.data)
plt.title('Histogram of Data')
plt.xlabel('data')
plt.ylabel('count')
def pdf(self, x):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
return (1.0 / (self.stdev * math.sqrt(2*math.pi))) * math.exp(-0.5*((x - self.mean) / self.stdev) ** 2)
def plot_histogram_pdf(self, n_spaces = 50):
"""Function to plot the normalized histogram of the data and a plot of the
probability density function along the same range
Args:
n_spaces (int): number of data points
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
mu = self.mean
sigma = self.stdev
min_range = min(self.data)
max_range = max(self.data)
# calculates the interval between x values
interval = 1.0 * (max_range - min_range) / n_spaces
x = []
y = []
# calculate the x values to visualize
for i in range(n_spaces):
tmp = min_range + interval*i
x.append(tmp)
y.append(self.pdf(tmp))
# make the plots
fig, axes = plt.subplots(2,sharex=True)
fig.subplots_adjust(hspace=.5)
axes[0].hist(self.data, density=True)
axes[0].set_title('Normed Histogram of Data')
axes[0].set_ylabel('Density')
axes[1].plot(x, y)
axes[1].set_title('Normal Distribution for \n Sample Mean and Sample Standard Deviation')
axes[0].set_ylabel('Density')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Gaussian distributions
Args:
other (Gaussian): Gaussian instance
Returns:
Gaussian: Gaussian distribution
"""
result = Gaussian()
result.mean = self.mean + other.mean
result.stdev = math.sqrt(self.stdev ** 2 + other.stdev ** 2)
return result
def __repr__(self):
"""Function to output the characteristics of the Gaussian instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}".format(self.mean, self.stdev) | yves-distribution-gaussian-binomial | /yves_distribution_gaussian_binomial-1.4.tar.gz/yves_distribution_gaussian_binomial-1.4/yves_distribution_gaussian_binomial/Gaussiandistribution.py | Gaussiandistribution.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Binomial(Distribution):
""" Binomial distribution class for calculating and
visualizing a Binomial distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats to be extracted from the data file
p (float) representing the probability of an event occurring
n (int) number of trials
TODO: Fill out all functions below
"""
def __init__(self, prob=.5, size=20):
self.n = size
self.p = prob
Distribution.__init__(self, self.calculate_mean(), self.calculate_stdev())
def calculate_mean(self):
"""Function to calculate the mean from p and n
Args:
None
Returns:
float: mean of the data set
"""
self.mean = self.p * self.n
return self.mean
def calculate_stdev(self):
"""Function to calculate the standard deviation from p and n.
Args:
None
Returns:
float: standard deviation of the data set
"""
self.stdev = math.sqrt(self.n * self.p * (1 - self.p))
return self.stdev
def replace_stats_with_data(self):
"""Function to calculate p and n from the data set
Args:
None
Returns:
float: the p value
float: the n value
"""
self.n = len(self.data)
self.p = 1.0 * sum(self.data) / len(self.data)
self.mean = self.calculate_mean()
self.stdev = self.calculate_stdev()
def plot_bar(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.bar(x = ['0', '1'], height = [(1 - self.p) * self.n, self.p * self.n])
plt.title('Bar Chart of Data')
plt.xlabel('outcome')
plt.ylabel('count')
def pdf(self, k):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
a = math.factorial(self.n) / (math.factorial(k) * (math.factorial(self.n - k)))
b = (self.p ** k) * (1 - self.p) ** (self.n - k)
return a * b
def plot_bar_pdf(self):
"""Function to plot the pdf of the binomial distribution
Args:
None
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
x = []
y = []
# calculate the x values to visualize
for i in range(self.n + 1):
x.append(i)
y.append(self.pdf(i))
# make the plots
plt.bar(x, y)
plt.title('Distribution of Outcomes')
plt.ylabel('Probability')
plt.xlabel('Outcome')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Binomial distributions with equal p
Args:
other (Binomial): Binomial instance
Returns:
Binomial: Binomial distribution
"""
try:
assert self.p == other.p, 'p values are not equal'
except AssertionError as error:
raise
result = Binomial()
result.n = self.n + other.n
result.p = self.p
result.calculate_mean()
result.calculate_stdev()
return result
def __repr__(self):
"""Function to output the characteristics of the Binomial instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}, p {}, n {}".\
format(self.mean, self.stdev, self.p, self.n) | yves-distribution-gaussian-binomial | /yves_distribution_gaussian_binomial-1.4.tar.gz/yves_distribution_gaussian_binomial-1.4/yves_distribution_gaussian_binomial/Binomialdistribution.py | Binomialdistribution.py |
# ``| -> YvesCMD <- |``
<p align="center">
<b>pip install yvesCMD</b>
</p>
<p align="center">
This microframework is created for cmd applications based on the cmd module in Python, which is built-in by default.
</p>
<p align="center">
<b>Goals</b>
</p>
<p align="center">
The goal is to provide simple and useful tools for creating shell applications. Automate certain processes and introduce innovations in this area.
</p>
<p align="center">
<b>What's New</b>
</p>
<p align="center">
- do_command -> In the original module, all command options were placed in the first or first after self argument. In this version, each option occupies its place in the arguments, which provides more control over how many and what the user will enter.<br>
- void_command -> Completely without arguments, a dummy function that you call without options.<br>
- relative_prompt -> For some reason, in the original module, changing the prompt during code execution is impossible.
</p>
<p align="center">
<a href="https://github.com/Yveradvir/Yvescmd/tree/master/YvesCMD/src/extensions"><b>Extensions</b></a>
</p>
<p align="center">
This is a directory in the repository where various features will be introduced.
</p>
<p align="center">
<a href="https://github.com/Yveradvir/Yvescmd"><b>GitHub</b></a> | <a href="https://pypi.org/project/yvesCMD/"><b>PyPi</b></a>
</p> | yvesCMD | /yvesCMD-0.0.6.tar.gz/yvesCMD-0.0.6/README.md | README.md |
import string
from .utils.hooks import Hooks
from .utils.register import AutoRegisterCommandsMeta
from .utils.detector import Detector
IDENTCHARS = string.ascii_letters + string.digits + '_'
__all__ = ["YveCMD"]
class YveCMD(metaclass=AutoRegisterCommandsMeta):
identchars = IDENTCHARS
ruler = '='
lastcmd = ''
relative_prompt = '[ cmd ] '
admin = False
def __init__(self):
self.cmdqueue = []
self.hook = Hooks()
self.detect = Detector()
@classmethod
def register_handler(cls, cmd_handler):
cls.register_handler_method(cmd_handler)
def cmdloop(self, intro=None):
self.hook.preloop()
try:
stop = None
while not stop:
if self.cmdqueue:
line = self.cmdqueue.pop(0)
else:
line = input(self.relative_prompt)
line = self.hook.precmd(line)
stop = self.onecmd(line) # Use the Detector object to handle commands
stop = self.hook.postcmd(stop, line)
self.hook.postloop()
except KeyboardInterrupt:
self.hook.postloop()
def onecmd(self, line):
cmd, args, line = self.detect.parseline(line)
if not line:
return self.emptyline()
if cmd is None:
return self.default(line)
self.lastcmd = line
if line == 'EOF':
self.lastcmd = ''
if cmd == '':
return self.default(line)
else:
try:
func = getattr(self, 'do_' + cmd)
func(*args) # Call the do_ method with arguments
except AttributeError:
try:
func = getattr(self, 'void_' + cmd)
func() # Call the void_ method without arguments
except AttributeError:
return self.default(line)
except TypeError as e:
if not self.admin:
print("Error: Invalid number of arguments.")
print("Type 'help {}' for more information.".format(cmd))
else:
print(e)
except Exception as e:
print("Error:", e)
def emptyline(self):
if self.lastcmd:
return self.onecmd(self.lastcmd)
def default(self, line):
print('[ e r r o r > %s' % line) | yvesCMD | /yvesCMD-0.0.6.tar.gz/yvesCMD-0.0.6/YvesCMD/src/yvescmd.py | yvescmd.py |
# yvpn
> A CLI client to manage YOUR vpn.
## Overview
The yvpn tool is a command line client that allows users to manage VPN endpoints by communicating with the yourvpn.info service.
Users can create, use, and destroy VPN endpoints at will. These endpoints are Virtual Private Servers that are created for the exclusive use of the user unlike other VPN providers where thousands of users share a single endpoint.
This tool is meant to be extensible. Beneath the hood SSH is used for the initial wireguard key exchange and future releases will allow users to quickly drop directly into a shell on the remote machine, perform file transfers, or remotely execute scripts.
This is not just a a tool for managing your VPN needs, but also a powerful resource for quickly deploying on demand services limited only by your creativity.
## Installation
The quickest way to get up and running is to install the tool from pip:
`pip3 install yvpn`
You will need wireguard:
https://www.wireguard.com/install/
You need to set two environment variables:
1. The server url:
`URL_yVPN="https://yourvpn.info"`
2. Your token:
`TOKEN_yVPN="<token>"`
## Where to get tokens
Right now yvpn is in closed alpha. Tokens are available by invitation only.
## What even is a token? Like an account?
No, we do not and will never offer accounts. Privacy is a core principal and we figure the best way to preserve user's privacy is to simply store zero user information. That's where Tokens come in.
Think of a token as a sort of prepaid calling card. Remember those good old days? Where you'd buy a calling card with however many minutes preloaded and then you had to call a 1-800 number from a payphone and enter the little code beneath the scratch off material? That's what our token model will be.
One day, once we're ready for a beta, there will be a simple storefront where you can buy a token preloaded with some amount of credit and off you go.
## How will billing work then?
There will be no billing as in no invoicing. Your token's fund balance will be debited based directly on usage. If you don't have any endpoints running, you won't pay anything.
## Overview of commands
### `yvpn clean`
Destroys all of your endpoints and refreshes your wireguard keys.
### `yvpn connect`
Connect to an endpoint. You can pass the name or number of the endpoint to connect to a specific one, i.e. `yvpn connect 3`, or automatically connect to the first one on the list without.
### `yvpn create`
Create a new endpoint. You can optionally specify a specific datacenter, `yvpn create lon1`, see `yvpn datacenters` below, or create a new endpoint in a randomly selected datacenter by omitting the final argument.
### `yvpn datacenters`
Displays a list of the currently available datacenters.
### `yvpn destroy <num>`
Destroy the specified endpoint.
### `yvpn disconnect`
Disconnect from the active endpoint.
### `yvpn status`
Display a table of your endpoints with a number, name, location, and creation timestamp. Also displays your token's balance and expected depletion date at current usage.
### `yvpn admin`
For users with an admin token, create, delete, and get tokens.
| yvpn | /yvpn-0.2.0.tar.gz/yvpn-0.2.0/README.md | README.md |
import logging
from tinydb import TinyDB, where
from tinydb.storages import MemoryStorage
import requests
import re
import uiautomator2 as u2
import subprocess
from ReadConfig import ReadConfig
logger = logging.getLogger(__name__)
TinyDB.DEFAULT_STORAGE = MemoryStorage
class ATX_Server(object):
"""
According to users requirements to select devices
"""
def __init__(self, url):
"""
Construct method
"""
self._db = TinyDB(storage=MemoryStorage)
if url and re.match(r"(http://)?(\d+\.\d+\.\d+\.\d+:\d+)", url):
if '://' not in url:
url = 'http://' + url + '/list'
else:
url = url + '/list'
self._url = url
self.load()
else:
logger.error('Atx server addr error')
self.load()
def load(self):
"""
Use the data which got from stf platform to crate query db
:return: the len of records in the db's table
"""
res = requests.get(self._url).json()
if res is not None:
eids = self._db.insert_multiple(res)
return len(eids)
else:
return 0
def find(self, cond=None):
"""
According condition to filter devices and return
:param cond: condition to filter devices
:type cond: where
:return: stf_selector object and its db contains devices
"""
if cond is not None:
res = self._db.search(cond)
self.purge()
self._db.insert_multiple(res)
return self
def devices(self):
"""
return all devices that meeting the requirement
:return: list of devices
"""
return self._db.all()
def refresh(self):
"""
reload the devices info from stf
:return: the len of records in the db's table
"""
self.purge()
return self.load()
def count(self):
"""
count the records in the db's table
:return: the len of records in the db's table
"""
return len(self._db.all())
def purge(self):
"""
remove all the data from the db
:return:
"""
self._db.purge()
def ready_devices(self):
"""ๆฅๆพๆ ่ฎฐไธบready็่ฎพๅค"""
self.refresh()
devices = self.find(where('ready') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def online_devices(self):
"""ๆฅๆพonline ็่ฎพๅค"""
self.refresh()
devices = self.find(where('present') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def model_devices(self, model):
"""ๆฅๆพ็นๅฎๅๅท็่ฎพๅค"""
self.refresh()
devices = self.find(where('model') == model).devices()
if len(devices) > 0:
return devices
else:
return False
def brand_devices(self, brand):
"""ๆฅๆพ็นๅฎๅ็็่ฎพๅค"""
self.refresh()
devices = self.find(where('brand') == brand).devices()
if len(devices) > 0:
return devices
else:
return False
def sdk_devices(self, sdk):
'''ๆฅๆพ็นๅฎSDK็่ฎพๅค'''
self.refresh()
devices = self.find(where('sdk') == sdk).devices()
if len(devices) > 0:
return devices
else:
return False
def version_devices(self, version):
'''ๆฅๆพ็นๅฎSDK็่ฎพๅค'''
self.refresh()
devices = self.find(where('version') == version).devices()
if len(devices) > 0:
return devices
else:
return False
def serial_devices(self, serial):
'''ๆฅๆพ็นๅฎserial็่ฎพๅค'''
self.refresh()
devices = self.find(where('serial') == serial).devices()
if len(devices) > 0:
return devices
else:
return False
def all_devices(self):
'''่ฟๅๆๆ็่ฎพๅค'''
self.refresh()
devices = self.find().devices()
if len(devices) > 0:
return devices
else:
return False
'''
่ฟๆฅconfig.iniไธญๆๅฎIP่ฎพๅค
'''
def get_devices_config_ip():
"""get the devices from Pubilc/config.ini devices list
return alive devices"""
devices_ip = ReadConfig().get_devices_ip()
print('่ฟๆฅ่ฎพๅคๅนณๅฐไธญๆๅฎ่ฎพๅค๏ผIP๏ผ %s' % devices_ip)
devices_list = []
for i in devices_ip:
try:
device = u2.connect(i)
if device.alive:
dict_tmp = device.device_info
dict_tmp['ip'] = i
devices_list.append(dict_tmp)
else:
print('The IP %s device is not alive,please checkout!' % i)
except Exception as e:
print('Raise ERROR %s\nThe IP %s device is not alive,please checkout!' % (e, i))
return device
'''
่ฟๆฅserver่ฎพๅคๅ่กจไธญไธญ็ฌฌไธไธชonline่ฎพๅค
'''
def connect_devices_online_ip(devices_ip):
"""connect the devices from at-server devices list
return alive devices"""
print('่ฟๆฅ่ฎพๅคๅนณๅฐไธญ้ฆไธชๅจ็บฟ่ฎพๅค๏ผIP๏ผ %s' % devices_ip)
devices_list = []
try:
device = u2.connect(devices_ip)
if device.alive:
dict_tmp = device.device_info
dict_tmp['ip'] = devices_ip
devices_list.append(dict_tmp)
else:
print('The IP %s device is not alive,please checkout!' % devices_ip)
except Exception as e:
print('Raise ERROR %s\nThe IP %s device is not alive,please checkout!' % (e, devices_ip))
return device
'''
่ฟๆฅๅทฒๆ็บฟ่ฎพๅค
'''
def connect_usb_devices():
'''get the devices usb connected on PC
return alive devices'''
output = subprocess.check_output(['adb', 'devices'])
pattern = re.compile(
r'(?P<serial>[^\s]+)\t(?P<status>device|offline)')
matches = pattern.findall(output.decode())
valid_serials = [m[0] for m in matches if m[1] == 'device']
if valid_serials:
print('่ฟๆฅUSB่ฎพๅค๏ผ่ฎพๅคๅ %s' % valid_serials)
devices_list = []
for i in valid_serials:
try:
device = u2.connect_usb(i)
# device.healthcheck()
if device.alive:
dict_tmp = device.device_info
devices_list.append(dict_tmp)
else:
print('The serial %s device is not alive,please checkout!' % i)
except Exception as e:
print('Raise ERROR %s\nThe serial %s device is not alive,please checkout!' % (e, i))
return device
if len(valid_serials) == 0:
print("ๆชๅ็ฐๅฏ็จ็USB่ฎพๅค,่ฏทๆฃๆฅ่ฎพๅค่ฟๆฅๆ
ๅต!")
if __name__ == '__main__':
# # get device
#s from atx-server
s = ATX_Server('http://10.97.190.152:7100/api/v1/devices')
print(s.devices())
print(s.online_devices())
# print(s.ready_devices())
#
# # get devices from config.ini devices list
#print(get_devices())
#print(connect_devices_online_ip(s.online_devices()[0]['ip'])) | yw-AUT | /yw-AUT-0.1.0.tar.gz/yw-AUT-0.1.0/ywAUT/Devices.py | Devices.py |
import sys
from Devices import *
from Devices_s import *
from ReadConfig import ReadConfig
import uiautomator2.ext.htmlreport as htmlreport
reload(sys)
sys.setdefaultencoding('utf8')
class Driver(object):
# ๅฏๅจๆๅก
def __init__(self, path):
"""่ทๅATXๆๅก่ฟๆฅ"""
self.s = STF_Server(path)
self.path = path
"""่ฟๆฅ่ฎพๅค
USB:่ฟๆฅๆฌๆบ่ฎพๅค
IP:่ฟๆฅๆ ็บฟ่ฎพๅคๅนณๅฐ่ฎพๅค
"""
def connect_device(self):
global d
if ReadConfig(self.path).get_method() == "USB":
serial_id = ReadConfig(self.path).get_devices_serial()
if serial_id:
print('ๆๅฎๆง่ก่ฎพๅค'+serial_id)
d = self.s.connect_serial_usb_stf_devices(serial_id)
else:
print('่ชๅจ้ๆฉadb devices้ฆไธช่ฎพๅค')
d = self.s.connect_usb_devices()
# else:
# if len(ReadConfig().get_devices_ip()) == 0:
# d = connect_devices_online_ip(self.s.online_devices()[0]['ip'])
# else:
# d = get_devices_config_ip()
"""ๅฅๅบทๆฃๆฅ"""
if d:
d.healthcheck()
hrp = htmlreport.HTMLReport(d)
hrp.patch_click()
return d
else:
print("่ฟๆฅ่ฎพๅคๅคฑ่ดฅ!")
def app_install(self):
"""ๅฎ่ฃ
APP๏ผไผ ๅ
ฅurl"""
d.app_install(ReadConfig(self.path).get_apk_url())
def app_start(self):
"""ๅฏๅจAPP"""
d.app_stop_all()
d.app_start(ReadConfig(self.path).get_pkg_name())
def app_stop(self):
"""ๅ
ณ้ญAPP"""
d.app_stop(ReadConfig(self.path).get_pkg_name())
"""ๆง่กๅฎๆ๏ผๆ่ตทu2ไบฎๅฑ่ฟ็จ๏ผ้ฒๆญข็ๅฑๆญ็ฝ"""
d.shell('am start -n com.github.uiautomator/.IdentifyActivity')
def close_remote(self):
'''ๅ
ณ้ญ่ฟ็จๆงๅถ'''
self.s.close_stf_remote(ReadConfig(self.path).get_devices_serial())
def unlock_device(self):
"""unlock.apk install and launch"""
pkgs = re.findall('package:([^\s]+)', d.shell(['pm', 'list', 'packages', '-3'])[0])
if 'io.appium.unlock' in pkgs:
d.app_start('io.appium.unlock')
d.shell('input keyevent 3')
else:
# appium unlock.apk ไธ่ฝฝๅฎ่ฃ
print('installing io.appium.unlock')
d.app_install('https://raw.githubusercontent.com/ATX-GT/master/apk/unlock.apk')
d.app_start('io.appium.unlock')
d.shell('input keyevent 3') | yw-AUT | /yw-AUT-0.1.0.tar.gz/yw-AUT-0.1.0/ywAUT/Driver.py | Driver.py |
import os
import logging
import time
from stf_selector.selector import Selector
from stf_selector.query import where
from tinydb import TinyDB, where
from tinydb.storages import MemoryStorage
import re
import uiautomator2 as u2
import subprocess
from ReadConfig import ReadConfig
import requests
logger = logging.getLogger(__name__)
TinyDB.DEFAULT_STORAGE = MemoryStorage
s = Selector(url=ReadConfig().get_server_url(), token=ReadConfig().get_server_token())
s.load()
def devices_list():
"""่ทๅๅนณๅฐๆๆ่ฎพๅค"""
devices = s.devices()
return devices
def ready_devices():
"""ๆฅๆพๆ ่ฎฐไธบready็่ฎพๅค"""
devices = s.find(where('ready') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def online_devices():
"""ๆฅๆพonline ็่ฎพๅค"""
devices = s.find(where('present') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def model_devices(model):
"""ๆฅๆพ็นๅฎๅๅท็่ฎพๅค"""
devices = s.find(where('model') == model).devices()
if len(devices) > 0:
return devices
else:
return False
def brand_devices(brand):
"""ๆฅๆพ็นๅฎๅ็็่ฎพๅค"""
devices = s.find(where('brand') == brand).devices()
if len(devices) > 0:
return devices
else:
return False
def sdk_devices(sdk):
'''ๆฅๆพ็นๅฎSDK็่ฎพๅค'''
devices = s.find(where('sdk') == sdk).devices()
if len(devices) > 0:
return devices
else:
return False
def version_devices(version):
'''ๆฅๆพ็นๅฎSDK็่ฎพๅค'''
devices = s.find(where('version') == version).devices()
if len(devices) > 0:
return devices
else:
return False
def serial_devices(serial):
'''ๆฅๆพ็นๅฎserial็่ฎพๅค'''
devices = s.find(where('serial') == serial).devices()
if len(devices) > 0:
return devices
else:
return False
def get_remoteurl(serial):
'''ๆฅๆพ็นๅฎserial็่ฎพๅค'''
devices = s.find(where('serial') == serial).devices()
if len(devices) > 0:
return devices[0]['remoteConnectUrl']
else:
return False
'''
่ฟๆฅๅทฒๆ็บฟ่ฎพๅค
'''
def connect_usb_stf_devices():
'''get the devices usb connected on PC
return alive devices'''
output = subprocess.check_output(['adb', 'devices'])
pattern = re.compile(
r'(?P<serial>[^\s]+)\t(?P<status>device|offline)')
matches = pattern.findall(output.decode())
valid_serials = [m[0] for m in matches if m[1] == 'device']
if valid_serials:
print('่ฟๆฅUSB่ฎพๅค๏ผ่ฎพๅคๅ %s' % valid_serials)
devices_list = []
for i in valid_serials:
try:
device = u2.connect_usb(i)
# device.healthcheck()
if device.alive:
dict_tmp = device.device_info
devices_list.append(dict_tmp)
else:
print('่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % i)
except Exception as e:
print('่ฟๅ้่ฏฏ: %s\n ่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % (e, i))
return device
if len(valid_serials) == 0:
print("ๆชๅ็ฐๅฏ็จ็USB่ฎพๅค,่ฏทๆฃๆฅ่ฎพๅค่ฟๆฅๆ
ๅต!")
'''
่ฟๆฅUSBๆๅฎserial่ฎพๅค
'''
def connect_serial_usb_stf_devices(serial):
'''
adb connect
'''
remote_url = get_remoteurl('4b89b1ce9905')
'''get the devices usb connected on PC
return alive devices'''
output = subprocess.check_output(['adb', 'devices'])
pattern = re.compile(
r'(?P<serial>[^\s]+)\t(?P<status>device|offline)')
matches = pattern.findall(output.decode())
valid_serials = [m[0] for m in matches if m[1] == 'device']
if valid_serials:
print('่ฟๆฅUSB่ฎพๅค๏ผ่ฎพๅคๅ %s' % serial)
devices_list = []
try:
device = u2.connect_usb(remote_url)
device.healthcheck()
if device.alive:
dict_tmp = device.device_info
devices_list.append(dict_tmp)
else:
print('่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % serial)
except Exception as e:
print('่ฟๅ้่ฏฏ: %s\n ่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % (e, serial))
return device
if len(valid_serials) == 0:
print("ๆชๅ็ฐๅฏ็จ็USB่ฎพๅค,่ฏทๆฃๆฅ่ฎพๅค่ฟๆฅๆ
ๅต!")
'''
STFๆๅผremote
'''
def open_stf_remote(serial):
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + ReadConfig().get_server_token()
}
data = {
'serial': serial
}
r = requests.post('http://10.97.190.152:7100/api/v1/user/devices', json=data, headers=headers)
return r
'''
STFๅ
ณ้ญremote
'''
def close_stf_remote(serial):
headers = {
'Authorization': 'Bearer ' + ReadConfig().get_server_token()
}
r = requests.request('DELETE', 'http://10.97.190.152:7100/api/v1/user/devices/' + serial,
headers=headers)
return r
if __name__ == '__main__':
# print(len(online_devices()))
#print(model_devices(' 6T'))
#open_stf_remote('4b89b1ce9905')
#time.sleep(20)
remote_url = get_remoteurl('4b89b1ce9905')
print("before:"+str(remote_url))
open_stf_remote('4b89b1ce9905')
s = Selector(url=ReadConfig().get_server_url(), token=ReadConfig().get_server_token())
s.load()
remote_url = get_remoteurl('4b89b1ce9905')
print("after:"+str(remote_url))
print(serial_devices('4b89b1ce9905'))
os.system('adb connect '+remote_url)
time.sleep(10)
connect_serial_usb_stf_devices('4b89b1ce9905')
close_stf_remote('4b89b1ce9905') | yw-AUT | /yw-AUT-0.1.0.tar.gz/yw-AUT-0.1.0/ywAUT/Devices_stf.py | Devices_stf.py |
import os
import logging
import time
from stf_selector.selector import Selector
from stf_selector.query import where
from tinydb import TinyDB, where
from tinydb.storages import MemoryStorage
import re
import uiautomator2 as u2
import subprocess
from ReadConfig import ReadConfig
import requests
logger = logging.getLogger(__name__)
TinyDB.DEFAULT_STORAGE = MemoryStorage
class STF_Server(object):
def __init__(self, path):
"""
Construct method
"""
self.path = path
self.s = Selector(url=ReadConfig(path).get_server_url()+'/devices', token=ReadConfig(path).get_server_token())
self.s.load()
def devices_list(self):
"""่ทๅๅนณๅฐๆๆ่ฎพๅค"""
devices = self.s.devices()
return devices
def ready_devices(self):
"""ๆฅๆพๆ ่ฎฐไธบready็่ฎพๅค"""
devices = self.s.find(where('ready') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def online_devices(self):
"""ๆฅๆพonline ็่ฎพๅค"""
devices = self.s.find(where('present') == True).devices()
if len(devices) > 0:
return devices
else:
return False
def model_devices(self, model):
"""ๆฅๆพ็นๅฎๅๅท็่ฎพๅค"""
devices = self.s.find(where('model') == model).devices()
if len(devices) > 0:
return devices
else:
return False
def brand_devices(self, brand):
"""ๆฅๆพ็นๅฎๅ็็่ฎพๅค"""
devices = self.s.find(where('brand') == brand).devices()
if len(devices) > 0:
return devices
else:
return False
def sdk_devices(self, sdk):
'''ๆฅๆพ็นๅฎSDK็่ฎพๅค'''
devices = self.s.find(where('sdk') == sdk).devices()
if len(devices) > 0:
return devices
else:
return False
def version_devices(self, version):
'''ๆฅๆพ็นๅฎSDK็่ฎพๅค'''
devices = self.s.find(where('version') == version).devices()
if len(devices) > 0:
return devices
else:
return False
def serial_devices(self, serial):
'''ๆฅๆพ็นๅฎserial็่ฎพๅค'''
devices = self.s.find(where('serial') == serial).devices()
if len(devices) > 0:
return devices
else:
return False
def get_remoteurl(self, serial):
'''ๆฅๆพ็นๅฎserial็่ฎพๅค'''
devices = self.s.find(where('serial') == serial).devices()
if len(devices) > 0:
return devices[0]['remoteConnectUrl']
else:
return False
'''
่ฟๆฅๅทฒๆ็บฟ่ฎพๅค
'''
def connect_usb_devices(self):
'''get the devices usb connected on PC
return alive devices'''
output = subprocess.check_output(['adb', 'devices'])
pattern = re.compile(
r'(?P<serial>[^\s]+)\t(?P<status>device|offline)')
matches = pattern.findall(output.decode())
valid_serials = [m[0] for m in matches if m[1] == 'device']
if valid_serials:
print('่ฟๆฅUSB่ฎพๅค๏ผ่ฎพๅคๅบๅๅท %s' % valid_serials)
devices_list = []
for i in valid_serials:
try:
device = u2.connect_usb(i)
# device.healthcheck()
if device.alive:
dict_tmp = device.device_info
devices_list.append(dict_tmp)
else:
print('่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % i)
except Exception as e:
print('่ฟๅ้่ฏฏ: %s\n ่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % (e, i))
return device
if len(valid_serials) == 0:
print("ๆชๅ็ฐๅฏ็จ็USB่ฎพๅค,่ฏทๆฃๆฅ่ฎพๅค่ฟๆฅๆ
ๅต!")
'''
่ฟๆฅUSBๆๅฎserial่ฎพๅค
'''
def connect_serial_usb_stf_devices(self, serial):
'''
adb connect
'''
self.open_stf_remote(serial)
self.s = STF_Server(self.path)
remote_ip = self.s.get_remoteurl(serial)
print('่ฟ็จ่ฐ่ฏIP:'.decode("utf-8")+str(remote_ip))
os.system('adb connect ' + remote_ip)
time.sleep(10)
'''get the devices usb connected on PC
return alive devices'''
output = subprocess.check_output(['adb', 'devices'])
pattern = re.compile(
r'(?P<serial>[^\s]+)\t(?P<status>device|offline)')
matches = pattern.findall(output.decode())
valid_serials = [m[0] for m in matches if m[1] == 'device']
if valid_serials:
print('่ฟๆฅUSB่ฎพๅค๏ผ่ฎพๅคๅบๅๅท %s' % serial)
devices_list = []
try:
device = u2.connect_usb(remote_ip)
if device.alive:
dict_tmp = device.device_info
devices_list.append(dict_tmp)
else:
print('่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % serial)
except Exception as e:
print('่ฟๅ้่ฏฏ: %s\n ่ฎพๅค %s ไธๅฏ็จ,่ฏทๆฃๆฅusb้พๆฅ็ถๆ!' % (e, serial))
return device
if len(valid_serials) == 0:
print('ๆชๅ็ฐๅฏ็จ็USB่ฎพๅค,่ฏทๆฃๆฅ่ฎพๅค่ฟๆฅๆ
ๅต!')
'''
STFๆๅผremote
'''
def open_stf_remote(self, serial):
headers = {
'Content-Type': 'application/json',
'Authorization': 'Bearer ' + ReadConfig(self.path).get_server_token()
}
data = {
'serial': serial
}
r = requests.post(ReadConfig(self.path).get_server_url()+'/user/devices', json=data, headers=headers)
return r
'''
STFๅ
ณ้ญremote
'''
def close_stf_remote(self, serial):
headers = {
'Authorization': 'Bearer ' + ReadConfig(self.path).get_server_token()
}
r = requests.request('DELETE', ReadConfig(self.path).get_server_url()+'/user/devices/' + serial,
headers=headers)
return r
if __name__ == '__main__':
# print(len(online_devices()))
#print(model_devices(' 6T'))
#open_stf_remote('4b89b1ce9905')
#time.sleep(20)
s = STF_Server()
# remote_url = s.get_remoteurl('4b89b1ce9905')
# print("before:"+str(remote_url))
# s.open_stf_remote('4b89b1ce9905')
# s = STF_Server()
# remote_url = s.get_remoteurl('4b89b1ce9905')
# print("after:"+str(remote_url))
# print(s.serial_devices('4b89b1ce9905'))
# os.system('adb connect '+remote_url)
# time.sleep(10)
s.connect_serial_usb_stf_devices('4b89b1ce9905')
s.close_stf_remote('4b89b1ce9905') | yw-AUT | /yw-AUT-0.1.0.tar.gz/yw-AUT-0.1.0/ywAUT/Devices_s.py | Devices_s.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Gaussian(Distribution):
""" Gaussian distribution class for calculating and
visualizing a Gaussian distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats extracted from the data file
"""
def __init__(self, mu=0, sigma=1):
Distribution.__init__(self, mu, sigma)
def calculate_mean(self):
"""Function to calculate the mean of the data set.
Args:
None
Returns:
float: mean of the data set
"""
avg = 1.0 * sum(self.data) / len(self.data)
self.mean = avg
return self.mean
def calculate_stdev(self, sample=True):
"""Function to calculate the standard deviation of the data set.
Args:
sample (bool): whether the data represents a sample or population
Returns:
float: standard deviation of the data set
"""
if sample:
n = len(self.data) - 1
else:
n = len(self.data)
mean = self.calculate_mean()
sigma = 0
for d in self.data:
sigma += (d - mean) ** 2
sigma = math.sqrt(sigma / n)
self.stdev = sigma
return self.stdev
def plot_histogram(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.hist(self.data)
plt.title('Histogram of Data')
plt.xlabel('data')
plt.ylabel('count')
def pdf(self, x):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
return (1.0 / (self.stdev * math.sqrt(2*math.pi))) * math.exp(-0.5*((x - self.mean) / self.stdev) ** 2)
def plot_histogram_pdf(self, n_spaces = 50):
"""Function to plot the normalized histogram of the data and a plot of the
probability density function along the same range
Args:
n_spaces (int): number of data points
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
mu = self.mean
sigma = self.stdev
min_range = min(self.data)
max_range = max(self.data)
# calculates the interval between x values
interval = 1.0 * (max_range - min_range) / n_spaces
x = []
y = []
# calculate the x values to visualize
for i in range(n_spaces):
tmp = min_range + interval*i
x.append(tmp)
y.append(self.pdf(tmp))
# make the plots
fig, axes = plt.subplots(2,sharex=True)
fig.subplots_adjust(hspace=.5)
axes[0].hist(self.data, density=True)
axes[0].set_title('Normed Histogram of Data')
axes[0].set_ylabel('Density')
axes[1].plot(x, y)
axes[1].set_title('Normal Distribution for \n Sample Mean and Sample Standard Deviation')
axes[0].set_ylabel('Density')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Gaussian distributions
Args:
other (Gaussian): Gaussian instance
Returns:
Gaussian: Gaussian distribution
"""
result = Gaussian()
result.mean = self.mean + other.mean
result.stdev = math.sqrt(self.stdev ** 2 + other.stdev ** 2)
return result
def __repr__(self):
"""Function to output the characteristics of the Gaussian instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}".format(self.mean, self.stdev) | yw-distr | /yw_distr-0.1.tar.gz/yw_distr-0.1/yw_distr/Gaussiandistribution.py | Gaussiandistribution.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Binomial(Distribution):
""" Binomial distribution class for calculating and
visualizing a Binomial distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats to be extracted from the data file
p (float) representing the probability of an event occurring
n (int) number of trials
TODO: Fill out all functions below
"""
def __init__(self, prob=.5, size=20):
self.n = size
self.p = prob
Distribution.__init__(self, self.calculate_mean(), self.calculate_stdev())
def calculate_mean(self):
"""Function to calculate the mean from p and n
Args:
None
Returns:
float: mean of the data set
"""
self.mean = self.p * self.n
return self.mean
def calculate_stdev(self):
"""Function to calculate the standard deviation from p and n.
Args:
None
Returns:
float: standard deviation of the data set
"""
self.stdev = math.sqrt(self.n * self.p * (1 - self.p))
return self.stdev
def replace_stats_with_data(self):
"""Function to calculate p and n from the data set
Args:
None
Returns:
float: the p value
float: the n value
"""
self.n = len(self.data)
self.p = 1.0 * sum(self.data) / len(self.data)
self.mean = self.calculate_mean()
self.stdev = self.calculate_stdev()
def plot_bar(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.bar(x = ['0', '1'], height = [(1 - self.p) * self.n, self.p * self.n])
plt.title('Bar Chart of Data')
plt.xlabel('outcome')
plt.ylabel('count')
def pdf(self, k):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
a = math.factorial(self.n) / (math.factorial(k) * (math.factorial(self.n - k)))
b = (self.p ** k) * (1 - self.p) ** (self.n - k)
return a * b
def plot_bar_pdf(self):
"""Function to plot the pdf of the binomial distribution
Args:
None
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
x = []
y = []
# calculate the x values to visualize
for i in range(self.n + 1):
x.append(i)
y.append(self.pdf(i))
# make the plots
plt.bar(x, y)
plt.title('Distribution of Outcomes')
plt.ylabel('Probability')
plt.xlabel('Outcome')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Binomial distributions with equal p
Args:
other (Binomial): Binomial instance
Returns:
Binomial: Binomial distribution
"""
try:
assert self.p == other.p, 'p values are not equal'
except AssertionError as error:
raise
result = Binomial()
result.n = self.n + other.n
result.p = self.p
result.calculate_mean()
result.calculate_stdev()
return result
def __repr__(self):
"""Function to output the characteristics of the Binomial instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}, p {}, n {}".\
format(self.mean, self.stdev, self.p, self.n) | yw-distr | /yw_distr-0.1.tar.gz/yw_distr-0.1/yw_distr/Binomialdistribution.py | Binomialdistribution.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Gaussian(Distribution):
""" Gaussian distribution class for calculating and
visualizing a Gaussian distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats extracted from the data file
"""
def __init__(self, mu=0, sigma=1):
Distribution.__init__(self, mu, sigma)
def calculate_mean(self):
"""Function to calculate the mean of the data set.
Args:
None
Returns:
float: mean of the data set
"""
avg = 1.0 * sum(self.data) / len(self.data)
self.mean = avg
return self.mean
def calculate_stdev(self, sample=True):
"""Function to calculate the standard deviation of the data set.
Args:
sample (bool): whether the data represents a sample or population
Returns:
float: standard deviation of the data set
"""
if sample:
n = len(self.data) - 1
else:
n = len(self.data)
mean = self.calculate_mean()
sigma = 0
for d in self.data:
sigma += (d - mean) ** 2
sigma = math.sqrt(sigma / n)
self.stdev = sigma
return self.stdev
def plot_histogram(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.hist(self.data)
plt.title('Histogram of Data')
plt.xlabel('data')
plt.ylabel('count')
def pdf(self, x):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
return (1.0 / (self.stdev * math.sqrt(2*math.pi))) * math.exp(-0.5*((x - self.mean) / self.stdev) ** 2)
def plot_histogram_pdf(self, n_spaces = 50):
"""Function to plot the normalized histogram of the data and a plot of the
probability density function along the same range
Args:
n_spaces (int): number of data points
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
mu = self.mean
sigma = self.stdev
min_range = min(self.data)
max_range = max(self.data)
# calculates the interval between x values
interval = 1.0 * (max_range - min_range) / n_spaces
x = []
y = []
# calculate the x values to visualize
for i in range(n_spaces):
tmp = min_range + interval*i
x.append(tmp)
y.append(self.pdf(tmp))
# make the plots
fig, axes = plt.subplots(2,sharex=True)
fig.subplots_adjust(hspace=.5)
axes[0].hist(self.data, density=True)
axes[0].set_title('Normed Histogram of Data')
axes[0].set_ylabel('Density')
axes[1].plot(x, y)
axes[1].set_title('Normal Distribution for \n Sample Mean and Sample Standard Deviation')
axes[0].set_ylabel('Density')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Gaussian distributions
Args:
other (Gaussian): Gaussian instance
Returns:
Gaussian: Gaussian distribution
"""
result = Gaussian()
result.mean = self.mean + other.mean
result.stdev = math.sqrt(self.stdev ** 2 + other.stdev ** 2)
return result
def __repr__(self):
"""Function to output the characteristics of the Gaussian instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}".format(self.mean, self.stdev) | yw-distributions | /yw_distributions-0.1.tar.gz/yw_distributions-0.1/yw_distributions/Gaussiandistribution.py | Gaussiandistribution.py |
import math
import matplotlib.pyplot as plt
from .Generaldistribution import Distribution
class Binomial(Distribution):
""" Binomial distribution class for calculating and
visualizing a Binomial distribution.
Attributes:
mean (float) representing the mean value of the distribution
stdev (float) representing the standard deviation of the distribution
data_list (list of floats) a list of floats to be extracted from the data file
p (float) representing the probability of an event occurring
n (int) number of trials
TODO: Fill out all functions below
"""
def __init__(self, prob=.5, size=20):
self.n = size
self.p = prob
Distribution.__init__(self, self.calculate_mean(), self.calculate_stdev())
def calculate_mean(self):
"""Function to calculate the mean from p and n
Args:
None
Returns:
float: mean of the data set
"""
self.mean = self.p * self.n
return self.mean
def calculate_stdev(self):
"""Function to calculate the standard deviation from p and n.
Args:
None
Returns:
float: standard deviation of the data set
"""
self.stdev = math.sqrt(self.n * self.p * (1 - self.p))
return self.stdev
def replace_stats_with_data(self):
"""Function to calculate p and n from the data set
Args:
None
Returns:
float: the p value
float: the n value
"""
self.n = len(self.data)
self.p = 1.0 * sum(self.data) / len(self.data)
self.mean = self.calculate_mean()
self.stdev = self.calculate_stdev()
def plot_bar(self):
"""Function to output a histogram of the instance variable data using
matplotlib pyplot library.
Args:
None
Returns:
None
"""
plt.bar(x = ['0', '1'], height = [(1 - self.p) * self.n, self.p * self.n])
plt.title('Bar Chart of Data')
plt.xlabel('outcome')
plt.ylabel('count')
def pdf(self, k):
"""Probability density function calculator for the gaussian distribution.
Args:
x (float): point for calculating the probability density function
Returns:
float: probability density function output
"""
a = math.factorial(self.n) / (math.factorial(k) * (math.factorial(self.n - k)))
b = (self.p ** k) * (1 - self.p) ** (self.n - k)
return a * b
def plot_bar_pdf(self):
"""Function to plot the pdf of the binomial distribution
Args:
None
Returns:
list: x values for the pdf plot
list: y values for the pdf plot
"""
x = []
y = []
# calculate the x values to visualize
for i in range(self.n + 1):
x.append(i)
y.append(self.pdf(i))
# make the plots
plt.bar(x, y)
plt.title('Distribution of Outcomes')
plt.ylabel('Probability')
plt.xlabel('Outcome')
plt.show()
return x, y
def __add__(self, other):
"""Function to add together two Binomial distributions with equal p
Args:
other (Binomial): Binomial instance
Returns:
Binomial: Binomial distribution
"""
try:
assert self.p == other.p, 'p values are not equal'
except AssertionError as error:
raise
result = Binomial()
result.n = self.n + other.n
result.p = self.p
result.calculate_mean()
result.calculate_stdev()
return result
def __repr__(self):
"""Function to output the characteristics of the Binomial instance
Args:
None
Returns:
string: characteristics of the Gaussian
"""
return "mean {}, standard deviation {}, p {}, n {}".\
format(self.mean, self.stdev, self.p, self.n) | yw-distributions | /yw_distributions-0.1.tar.gz/yw_distributions-0.1/yw_distributions/Binomialdistribution.py | Binomialdistribution.py |
# tap-sqlalchemy
# Roadmap
### Supported RDBMS
- [x] SQLite, see [SQLite with SQLAlchemy](https://docs.sqlalchemy.org/en/14/dialects/sqlite.html#connect-strings)
- [x] SQL Server,
see [PyODBC with SQLAlchemy](https://docs.sqlalchemy.org/en/14/dialects/mssql.html#module-sqlalchemy.dialects.mssql.pyodbc)
> Driver query in connection string:
> `"mssql+pyodbc://scott:tiger@myhost:port/databasename?driver=ODBC+Driver+17+for+SQL+Server"`
> https://docs.sqlalchemy.org/en/14/dialects/mssql.html#hostname-connections
- [x] Impala
> Impala connection string is not natively supported by SQLAlchemy, but
tap-sqlalchemy provides a familiar connection string format as that of SQLite or SQL Server, and the
connection capability is supported by [impyla](https://github.com/cloudera/impyla)
>
> Example:
> Impala "connection.conn_string" format:
>
> impala+pyodbc://[username][:][password][@]host:port[/default_db]?auth_mechanism=LDAP
>
> - auth_mechanism is required, and supports only one value: LDAP
> - <host> and <port> are required
# Guide
### Tap Installation & Quick Start
1. Create a python virtual environment
2. install tap-sqlalchemy, `pip install yw-etl-tap-sqlalchemy`
3. invoke tap
```shell
$ <venv-bin>/tap-sqlalchemy -c '<config-json>' --catalog '<catalog-json>'
```
### Tap Configuration
Tap Configuration is a JSON document containing entries that will impact the behaviors of data extraction work load.
```json5
{
// mandatory
"connection.conn_string": "<SQLAlchemy compatible connection string>",
// mandatory
"sync.include_streams": [
"<tap_stream_id>",
/* refer to a stream described in Catalog*/
],
// optional
"sync.working_directory": "..."
}
```
* see SQLAlchemy: [Database URLs](https://docs.sqlalchemy.org/en/14/core/engines.html#database-urls)
* see [Working Directory](https://github.com/YiwenData/tap-sqlalchemy/issues/2)
### Tap Catalog
Tap Catalog is a JSON document of one object containing definitions of data stream.
```json5
{
"streams": [
{
// mandatory, unique identifier, used in [sync.include_streams] of Tap Configuration
"tap_stream_id": "...",
// mandatory, human-friendly identifier, possible to have duplicates inside on Catalog Document
"stream": "...",
// mandatory
// JSON Schema Object describing the shape of this data stream,
// used for data verification
//
// Empty Object means that schema check will be skipped
"schema": {},
// mandatory
// a list of metadata entries about the whole stream or about one field
"metadata": [
{
// mandatory
// breadcrumb points to a field to which this metadata entry applies.
// an array of string, like '["a", "b", "c"]', that is evaluated against this stream's JSON Schema document
//
// Empty List means this is the metadata about the whole stream
"breadcrumb": [],
// mandatory
// specific meta data entry, key value pair
"metadata": {
// Two special Keys that are of special interests
// for SQL-based replication
"replication-method": "CUSTOM_QUERY",
// relative path is resolved against
// <working-directory/sql
// absolute path is treated as it is
"replication-sql-file": "query.sql"
}
}
]
}
]
}
```
* see [JSON Schema](http://json-schema.org/)
# Developer Guide
The idea behind `tap-sqlalchemy` is rather simple: execute SQL query and emit each row to stdout in JSON format.
## Message Format
The emitted message format follows the [Singer Specification](https://github.com/singer-io/getting-started). Current
implementation will emit only `SCHEMA` and `RECORD` message.
## Add new RDBMS support
[SQLAlchemy](https://www.sqlalchemy.org/) is an abstraction layer over various types of Relational Databases (or storage
systems that speak in SQL). It provides a unified SQL execution entrypoint and a unified query return structure.
Out of the box, SQLAlchemy provides working guides for mainstream RDBMS,
including [PostgreSQL](https://docs.sqlalchemy.org/en/14/dialects/postgresql.html)
, [MySQL](https://docs.sqlalchemy.org/en/14/dialects/mysql.html)
, [SQLite](https://docs.sqlalchemy.org/en/14/dialects/sqlite.html#connect-strings)
, [Oracle](https://docs.sqlalchemy.org/en/14/dialects/oracle.html)
and [SQL Server](https://docs.sqlalchemy.org/en/14/dialects/mssql.html). In most cases, a RDBMS specific driver is
required for SQLAlchemy to talks to a RDBMS, but protocol like ODBC and its implementation in
python, [pyODBC](https://pypi.org/project/pyodbc/), can be used for multiple RDBMS.
For more exotic database technologies, like impala or clickhouse, 3rd party adaptor or driver is required. Take Impala
as an example. Impala provides its own driver [implementation in python](https://github.com/cloudera/impyla), however it
is not directly usable by SQLAlchemy,
see [post](https://stackoverflow.com/questions/39582842/impala-connection-via-sqlalchemy). In `Database.py#_get_engine`
, impala connection is treated specially to be compatible with SQAlchemy's `_engine.Engine` interface.
To add support for a new Database system:
1. find its driver implementation in python, it may be built on top of a general protocol,
like [impyla](https://github.com/cloudera/impyla) over ODBC or a community-maintained SQLAlchemy adaptor,
like [clickhouse-sqlalchemy](https://pypi.org/project/clickhouse-sqlalchemy/)
2. devise a connection string format that has similar structure as other db (easier to remember) and can express
special configuration entries for picked database, a common solution is to use URL and query terms.
3. augment method `Database.py#_get_engine` to parse connection string into a connection object and adapt the connection
object to be compatible with SQAlchemy's `_engine.Engine` interface.
4. at this point, you can issue SQL to new database system in the same fashion as other RDBMS
| yw-etl-tap-sqlalchemy | /yw_etl_tap_sqlalchemy-0.1.5.tar.gz/yw_etl_tap_sqlalchemy-0.1.5/README.md | README.md |
import os
from pathlib import Path
from yw_etl_tap_sqlalchemy.utils import Conf, Env
_pwd = Path(os.getcwd())
_wd_name = ".tap-sqlalchemy"
class WorkingDirectory:
@staticmethod
def get_sql_dir(conf: dict) -> Path:
return WorkingDirectory.get_directory(conf) / 'sql'
@staticmethod
def get_directory(conf: dict) -> Path:
"""
1. Configuration Entry: config["sync.working_directory"] (relative to pwd)
2. Environment Variable: TAP_SQLALCHEMY_HOME (must be absolute path)
3. Home directory: $HOME/.tap-sqlalchemy
"""
ok, p = WorkingDirectory._check_conf(conf)
if ok:
return p
ok, p = WorkingDirectory._check_env()
if ok:
return p
return WorkingDirectory._check_home_dir()
@staticmethod
def _check_home_dir() -> Path:
p = Path(os.path.expanduser("~")) / _wd_name
if p.is_file():
raise Exception(f"{p} already exists and is a file")
p.mkdir(exist_ok=True)
return p
@staticmethod
def _check_env() -> (bool, Path):
v = os.environ.get(Env.SYNC_WORKING_DIRECTORY, None)
if v is None:
return False, None
v = Path(v)
if not v.is_absolute():
raise Exception(f"environment variable {Env.SYNC_WORKING_DIRECTORY}={v} is not a absolute path")
if v.is_file():
raise Exception(f"{v} already exists and is a file")
v.mkdir(parents=True, exist_ok=True)
return True, v
@staticmethod
def _check_conf(conf: dict) -> (bool, Path):
wd = conf.get(Conf.SYNC_WORKING_DIRECTORY, None)
if wd is None:
return False, None
wd = Path(wd)
if wd.is_file():
raise Exception(f"{wd} already exists and is a file")
if not wd.is_absolute():
wd = _pwd / wd
wd.mkdir(parents=True, exist_ok=True)
return True, wd.resolve()
@staticmethod
def _has_sql_dir(wd: Path) -> bool:
return (wd / 'sql').is_dir() | yw-etl-tap-sqlalchemy | /yw_etl_tap_sqlalchemy-0.1.5.tar.gz/yw_etl_tap_sqlalchemy-0.1.5/yw_etl_tap_sqlalchemy/WorkingDirectory.py | WorkingDirectory.py |
from pathlib import Path
from urllib.parse import urlparse, parse_qs
from impala.dbapi import connect as impala_connect
from sqlalchemy import create_engine, text
class CONN_SCHEME:
IMPALA_PYODBC = "impala+pyodbc"
MYSSQL_PYODBC = "mssql+pyodbc"
SQLITE = "sqlite"
def _get_engine(conn_str: str):
conn_url = urlparse(conn_str)
scheme = conn_url.scheme
# Impala connection via SQLAlchemy
# see https://github.com/cloudera/impyla/issues/214
if scheme == CONN_SCHEME.IMPALA_PYODBC:
qs = parse_qs(conn_url.query)
auth_mechanism = qs.get('auth_mechanism', [None])[0]
if auth_mechanism is None:
raise Exception(
"impala+pyodbc connection string requires parameter: auth_mechanism, supported value "
"['LDAP', 'NOSASL', 'PLAIN', 'GSSAPI', 'JWT'] "
"see https://github.com/cloudera/impyla/blob/master/impala/dbapi.py#L71")
p = Path(conn_url.path)
database = None
if len(p.parts) >= 2:
database = p.parts[1]
def conn():
return impala_connect(
host=conn_url.hostname, port=conn_url.port,
database=database, user=conn_url.username, password=conn_url.password,
auth_mechanism=auth_mechanism
)
return create_engine("impala://", creator=conn)
else:
return create_engine(conn_str)
class Database:
def __init__(self, conn_str):
self.conn_str = conn_str
self._test_conn()
self._conn_ctx = None
def _test_conn(self):
engine = _get_engine(self.conn_str)
with engine.connect() as con:
sql = "select 1" if "oracle" not in self.conn_str else "select 1 AS a from DUAL"
con.execute(text(sql)).all()
self.engine = engine
def __enter__(self):
self._conn_ctx = self.engine.connect()
return self._conn_ctx.__enter__()
def __exit__(self, *args, **kwargs):
self._conn_ctx.__exit__(*args, **kwargs)
self._conn_ctx = None | yw-etl-tap-sqlalchemy | /yw_etl_tap_sqlalchemy-0.1.5.tar.gz/yw_etl_tap_sqlalchemy-0.1.5/yw_etl_tap_sqlalchemy/Database.py | Database.py |
import io
import json.decoder
import os
import sys
import traceback
import singer.utils
from yw_etl_target_clickhouse.Database import Database
from yw_etl_target_clickhouse.ReceiveStreamManager import receive_stream_manager
from yw_etl_target_clickhouse.WorkingDirectory import WorkingDirectory
from yw_etl_target_clickhouse.utils import targetlog
REQUIRED_CONFIG_KEYS = ['connection', 'sync.stream_table_map']
def main():
args = singer.utils.parse_args(REQUIRED_CONFIG_KEYS)
if args.discover:
raise Exception("Discover mode is not supported")
config = args.config
_stream_table_map = config['sync.stream_table_map']
stream_table_lookup = {k: _stream_table_map[k] for k in _stream_table_map.keys()}
database = Database.from_config(config)
working_dir = WorkingDirectory.get_directory(config)
retain_csv = config.get("sync.retain_csv", False)
with receive_stream_manager(stream_table_lookup, database, working_dir, retain_csv) as manager:
input_stream = io.TextIOWrapper(sys.stdin.buffer, encoding='utf8')
for msg_line in input_stream:
# ignore lines starts with #
if msg_line.startswith('#'):
continue
try:
msg = singer.parse_message(msg_line).asdict()
except json.decoder.JSONDecodeError:
targetlog.error(f"Unable to parse:\n{msg_line}")
raise
msg_type = msg['type']
match msg_type:
case 'RECORD':
stream_name = msg['stream']
rstream = manager.get_stream(stream_name)
record = msg['record']
rstream.write_record(record)
case 'SCHEMA' | 'STATE':
# SCHEMA and STATE message handling not implemented
continue
case _ as x:
targetlog.warning(f'unknown message type {x}')
if __name__ == '__main__':
try:
main()
except Exception as e:
targetlog.error(e)
if os.environ.get('DEBUG', None):
traceback.print_exception(e)
sys.exit(1) | yw-etl-target-clickhouse | /yw_etl_target_clickhouse-0.1.0-py3-none-any.whl/yw_etl_target_clickhouse/main.py | main.py |
import contextlib
from pathlib import Path
from typing import ContextManager
from yw_etl_target_clickhouse.Database import Database
from yw_etl_target_clickhouse.ReceiveStream import ReceiveStream
from yw_etl_target_clickhouse.utils import targetlog
@contextlib.contextmanager
def receive_stream_manager(stream_table_lookup: dict, database: Database, working_dir: Path,
retain_csv: bool) -> ContextManager['ReceiveStreamManager']:
manager = ReceiveStreamManager(stream_table_lookup, database, working_dir, retain_csv)
try:
yield manager
manager.sink_all()
except Exception as e:
targetlog.error(e)
raise e
finally:
manager.close_all()
class StreamIsNotDeclared(Exception):
def __init__(self, stream_name: str):
super().__init__(f"stream {stream_name} is not declared in stream-table mapping")
class ReceiveStreamManager:
"""Do not instantiate ReceiveStreamManager directly, use
with receive_stream_manager(...) as manager:
...
"""
def __init__(self, stream_table_lookup: dict, database: Database, working_dir: Path, retain_csv: bool):
self.retain_csv = retain_csv
self.working_dir = working_dir
self.database = database
self.stream_table_lookup = stream_table_lookup
self.opened_streams: dict[str, ReceiveStream] = {}
def get_stream(self, stream_name: str) -> 'ReceiveStream':
table_name = self.stream_table_lookup.get(stream_name, None)
if table_name is None:
raise StreamIsNotDeclared(stream_name)
if stream_name in self.opened_streams:
return self.opened_streams[stream_name]
else:
self.opened_streams[stream_name] = ReceiveStream(stream_name, table_name, self.database, self.working_dir,
self.retain_csv)
return self.get_stream(stream_name)
def sink_all(self):
for s in self.opened_streams.values():
targetlog.debug(f"sinking {s}")
s.sink()
def close_all(self):
for k, s in self.opened_streams.items():
targetlog.debug(f"closing {s}")
s.close()
self.opened_streams = [] | yw-etl-target-clickhouse | /yw_etl_target_clickhouse-0.1.0-py3-none-any.whl/yw_etl_target_clickhouse/ReceiveStreamManager.py | ReceiveStreamManager.py |
# Copyright (c) 2012-2013 Thomas Roten
# 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
# furnshished 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.
"""a Python module that provides an interface to the Yahoo! Weather RSS Feed.
Classes:
Client: interface with the Yahoo! Weather RSS Feed.
Constants:
WOEID_LOOKUP_URL: the URL used to fetch a locationโs corresponding WOEID.
WEATHER_URL: the URL used to fetch a WOEID's weather.
LID_LOOKUP_URL: the URL used to fetch a location's corresponding LID.
LID_WEATHER_URL: the URL used to fetch a LID's weather.
WEATHER_NS: the XML namespace used in the weather RSS feed.
GEO_NS: the XML namespace used for the coordinates in the RSS feed.
CONDITION_IMAGE_URL: the URL of an image depicting the current conditions.
UNITS: a dict that maps data names to units.
"""
try:
from urllib.request import urlopen
from urllib.parse import quote
except ImportError:
from urllib2 import urlopen
from urllib import quote
import contextlib
import re
import xml.etree.ElementTree
WOEID_LOOKUP_URL = ("http://locdrop.query.yahoo.com/v1/public/yql?"
"q=select%20woeid%20from%20locdrop.placefinder%20"
"where%20text='{0}'")
WEATHER_URL = "http://xml.weather.yahoo.com/forecastrss?w={0}&u={1}"
LID_LOOKUP_URL = WEATHER_URL
LID_WEATHER_URL = "http://xml.weather.yahoo.com/forecastrss/{0}_{1}.xml"
WEATHER_NS = "http://xml.weather.yahoo.com/ns/rss/1.0"
GEO_NS = "http://www.w3.org/2003/01/geo/wgs84_pos#"
CONDITION_IMAGE_URL = "http://l.yimg.com/a/i/us/we/52/{0}.gif"
UNITS = {
"c": {
"wind": {
"chill": "ยฐC",
"direction": "ยฐ",
"speed": "km/h"},
"atmosphere": {
"humidity": "%",
"visibility": "km",
"pressure": "hPa"},
"condition": {
"temp": "ยฐC"},
"forecast": {
"low": "ยฐC",
"high": "ยฐC"},
},
"f": {
"wind": {
"chill": "ยฐF",
"direction": "ยฐ",
"speed": "mph"},
"atmosphere": {
"humidity": "%",
"visibility": "mi",
"pressure": "psi"},
"condition": {
"temp": "ยฐF"},
"forecast": {
"low": "หF",
"high": "ยฐF"},
},
}
class Client(object):
"""Interface with the Yahoo! Weather RSS feed.
Provides methods to search for location data and fetch weather data.
Methods:
fetch_lid: fetch a location's LID.
fetch_woeid: fetch a location's WOEID.
fetch_weather: fetch a location's weather.
"""
def fetch_lid(self, woeid):
"""Fetch a location's corresponding LID.
Args:
woeid: (string) the location's WOEID.
Returns:
a string containing the requested LID or None if the LID could
not be found.
Raises:
urllib.error.URLError: urllib.request could not open the URL
(Python 3).
urllib2.URLError: urllib2 could not open the URL (Python 2).
xml.etree.ElementTree.ParseError: xml.etree.ElementTree failed to
parse the XML document.
"""
rss = self._fetch_xml(LID_LOOKUP_URL.format(woeid, "f"))
# We are pulling the LID from the permalink tag in the XML file
# returned by Yahoo.
try:
link = rss.find("channel/link").text
except AttributeError:
return None
# use regex or string.split
# regex assumes the format XXXXNNNN for the LID.
# string.split works more general of the context.
lid = re.search("[A-Za-z]{4}[0-9]{4}", link).group()
# lid = link.split("/forecast/")[1].split("_")[0]
return lid
def fetch_weather(self, id, metric=False):
"""Fetch a location's weather.
*id* can be either a WOEID or LID. The weather data returned for each
is identical except that the WOEID returns a 2-day forecast and the LID
returns a 5-day forecast. The LID uses an undocumented API, so use it
at your own risk.
Args:
id: (string) the location's WOEID or LID.
metric: (bool) return metric data; defaults to False.
Returns:
a dict containing the location's weather data or None if
the weather data couldn't be fetched.
Raises:
urllib.error.URLError: urllib.request could not open the URL
(Python 3).
urllib2.URLError: urllib2 could not open the URL (Python 2).
xml.etree.ElementTree.ParseError: xml.etree.ElementTree failed to
parse the XML document.
"""
units = "c" if metric else "f"
# WOEID is a 32-bit integer, while LID is XXXXNNNN, where X is a letter
# and N is a number. So, we pick the URL to use based on whether or not
# the *id* begins with a letter.
if re.match("^[A-Za-z]", id):
url = LID_WEATHER_URL.format(id, units)
else:
url = WEATHER_URL.format(id, units)
rss = self._fetch_xml(url)
if rss.find("channel/item/title").text == "City not found":
return None
# xml_items details which tags should be read and what their
# destination dict key should be. These tags don't appear
# multiple times.
# {XML tag: [ElementTree access method, dict key]}
xml_items = {
"channel/title": ["text", "title"],
"channel/link": ["text", "link"],
"channel/language": ["text", "language"],
"channel/description": ["text", "description"],
"channel/lastBuildDate": ["text", "lastBuildDate"],
"channel/ttl": ["text", "ttl"],
"channel/image/url": ["text", "logo"],
"channel/item/guid": ["text", "guid"],
"channel/{%s}location" % WEATHER_NS:
["attrib", "location"],
# "channel/{%s}units" % WEATHER_NS:
# ["attrib", "units"],
"channel/{%s}wind" % WEATHER_NS:
["attrib", "wind"],
"channel/{%s}atmosphere" % WEATHER_NS:
["attrib", "atmosphere"],
"channel/{%s}astronomy" % WEATHER_NS:
["attrib", "astronomy"],
"channel/item/{%s}condition" % WEATHER_NS:
["attrib", "condition"],
}
weather = {}
weather["units"] = UNITS[units]
for (tag, meta) in xml_items.items():
if meta[0] == "text":
try:
weather[meta[1]] = rss.find(tag).text
except AttributeError:
weather[meta[1]] = None
elif meta[0] == "attrib":
try:
weather[meta[1]] = rss.find(tag).attrib
except AttributeError:
weather[meta[1]] = None
else:
weather[meta[1]] = None
try:
image_url = CONDITION_IMAGE_URL.format(weather["condition"]["code"])
weather["condition"]["image"] = image_url
except (AttributeError, TypeError):
pass
try:
state = weather["atmosphere"]["rising"]
if state == "0":
weather["atmosphere"]["state"] = "steady"
elif state == "1":
weather["atmosphere"]["state"] = "rising"
elif state == "2":
weather["atmosphere"]["state"] = "falling"
else:
weather["atmosphere"]["state"] = None
except (AttributeError, TypeError):
pass
weather["forecast"] = []
try:
for item in rss.findall(
"channel/item/{%s}forecast" % WEATHER_NS):
weather["forecast"].append(item.attrib)
except AttributeError:
weather["forecast"] = None
weather["geo"] = {}
try:
weather["geo"]["lat"] = rss.find(
"channel/item/{%s}lat" % GEO_NS).text
weather["geo"]["long"] = rss.find(
"channel/item/{%s}long" % GEO_NS).text
except AttributeError:
weather["geo"] = None
try:
weather["wind"]["compass"] = self._degrees_to_direction(
weather["wind"]["direction"])
except TypeError:
pass
return weather
def fetch_woeid(self, location):
"""Fetch a location's corresponding WOEID.
Args:
location: (string) a location (e.g. 23454 or Berlin, Germany).
Returns:
a string containing the location's corresponding WOEID or None if
the WOEID could not be found.
Raises:
urllib.error.URLError: urllib.request could not open the URL
(Python 3).
urllib2.URLError: urllib2 could not open the URL (Python 2).
xml.etree.ElementTree.ParseError: xml.etree.ElementTree failed to
parse the XML document.
"""
rss = self._fetch_xml(
WOEID_LOOKUP_URL.format(quote(location)))
try:
woeid = rss.find("results/Result/woeid").text
except AttributeError:
return None
return woeid
def _degrees_to_direction(self, degrees):
"""Convert wind direction from degrees to compass direction."""
try:
degrees = float(degrees)
except ValueError:
return None
if degrees < 0 or degrees > 360:
return None
if degrees <= 11.25 or degrees >= 348.76:
return "N"
elif degrees <= 33.75:
return "NNE"
elif degrees <= 56.25:
return "NE"
elif degrees <= 78.75:
return "ENE"
elif degrees <= 101.25:
return "E"
elif degrees <= 123.75:
return "ESE"
elif degrees <= 146.25:
return "SE"
elif degrees <= 168.75:
return "SSE"
elif degrees <= 191.25:
return "S"
elif degrees <= 213.75:
return "SSW"
elif degrees <= 236.25:
return "SW"
elif degrees <= 258.75:
return "WSW"
elif degrees <= 281.25:
return "W"
elif degrees <= 303.75:
return "WNW"
elif degrees <= 326.25:
return "NW"
elif degrees <= 348.75:
return "NNW"
else:
return None
def _fetch_xml(self, url):
"""Fetch a url and parse the document's XML."""
with contextlib.closing(urlopen(url)) as f:
return xml.etree.ElementTree.parse(f).getroot() | yweather | /yweather-0.1.1.tar.gz/yweather-0.1.1/yweather.py | yweather.py |
yweather
========
About
-----
yweather is a Python module that provides an interface to the `Yahoo! Weather RSS feed <http://developer.yahoo.com/weather/>`_.
International Support
---------------------
.. code:: python
>>> client.fetch_woeid("Paris, France")
'615702'
>>> client.fetch_woeid("Seattle, Washington")
'2490383'
Location and weather data is not limited to a single country. Fetch data for any location that is available on Yahoo! Weather.
Different countries use different measurement systems (unfortunately). Fetch data according to United States customary units or the metric system.
.. code:: python
>>> paris_weather = client.fetch_weather("615702", metric=True)
>>> seattle_weather = client.fetch_weather("2490383", metric=False)
Data is Returned as a Dict
--------------------------
.. code:: python
>>> norfolk_weather = client.fetch_weather("2460389")
>>> norfolk_weather["astronomy"]["sunrise"]
'7:18 am'
>>> norfolk_weather["condition"]["text"]
'Partly Cloudy'
Weather data is returned as a Python ``dict``, not as an object of a confusing class.
No API Keys or Signup Needed
----------------------------
Unlike many weather APIs, Yahoo! Weather's RSS feed doesn't require sign ups, API keys, or special authorization to fetch and use their data. All you have to do is follow their `Terms of Use <http://developer.yahoo.com/weather/#terms>`_.
No Manual ID Lookups
--------------------
.. code:: python
>>> client.fetch_woeid("Raleigh, North Carolina")
'2478307'
>>> client.fetch_lid("2379574")
'USIL0228'
yweather doesn't assume you know location identifiers off the top of your head. You can call the ``fetch_woeid`` or ``fetch_lid`` methods to lookup a location's WOEID or LID. WOEID is Yahoo! Weather's location identifier. LID is The Weather Channel's location identifier.
5-day Forecast Support
----------------------
.. code:: python
>>> london_weather = client.fetch_weather("UKXX0085")
>>> len(london_weather["forecast"])
5
By using a The Weather Channel Location ID (LID), you can fetch a location's 5-day weather forecast. A little warning though -- it's using an undocumented API. If you aren't up for it, you can still get the 2-day forecast using a WOEID.
Documentation
-------------
yweather includes complete and easy-to-read `documentation <https://yweather.readthedocs.org/>`_. Check it out for a gentle introduction or the full API details.
Bug/Issues Tracker
------------------
yweather uses its `GitHub Issues page <https://github.com/tsroten/yweather/issues>`_ to track bugs, feature requests, and support questions.
License
-------
yweather is released under the OSI-approved `MIT License <http://opensource.org/licenses/MIT>`_. See the file LICENSE.txt for more information.
| yweather | /yweather-0.1.1.tar.gz/yweather-0.1.1/README.rst | README.rst |
Glossary
========
.. glossary::
LID
Location ID. The Weather Channel uses these to identify locations around the world. Because Yahoo! Weather gets their weather data from The Weather Channel, the Location ID can be used on Yahoo's RSS Feed to gain access to a 5-day weather forecast. Note: this usage is undocumented.
metric system
The metric system is a system of measurement that is used around the world (in all but three countries). It is often considered to be synonymous with the `International System of Units <http://en.wikipedia.org/wiki/International_System_of_Units>`_. Some example units include grams and meters. See `Wikipedia's article <http://en.wikipedia.org/wiki/Metric_system>`_ for more information.
United States customary units
A system of measurements commonly used across the United States. Some example units include miles, pounds, and inches. See `Wikipedia's article <http://en.wikipedia.org/wiki/United_States_customary_units>`_ for more information.
WOEID
Where On Earth IDentifier. Yahoo! GeoPlanet uses these 32-bit identifiers to reference spatial entities around the world. See `Yahoo! GeoPlanet's Key Concepts <http://developer.yahoo.com/geo/geoplanet/guide/concepts.html#woeids>`_ for more information.
| yweather | /yweather-0.1.1.tar.gz/yweather-0.1.1/docs/glossary.rst | glossary.rst |
Usage
=====
Let's learn how to use :mod:`yweather`.
Create a :class:`~yweather.Client` Object
-----------------------------------------
:mod:`yweather` consists of a single class, :class:`~yweather.Client`.
.. code-block:: python
>>> import yweather
>>> client = yweather.Client()
By creating an instance of :class:`~yweather.Client`, you've created an object that you can use to fetch location identifiers and weather data from Yahoo! Weather.
Fetch a Location's :term:`WOEID`
--------------------------------
Yahoo! Weather gives every location a unique :term:`WOEID`. In order to fetch weather data from Yahoo!, you must first know the location's :term:`WOEID`.
.. code-block:: python
>>> client.fetch_woeid("Beijing, China")
'2151330'
>>> client.fetch_woeid("96734")
'12798281'
>>> client.fetch_woeid("10 South Main Street, Harrisonburg, VA")
'12767058'
You can retrieve a :term:`WOEID` by passing a general or specific address. The above example used city and country, ZIP code, and complete address.
Fetch a Location's Weather
--------------------------
Once you have a location's :term:`WOEID`, you can use it to fetch the location's weather. Weather data is returned as a :class:`dict <python3:dict>`. Its structure is detailed in :meth:`~yweather.Client.fetch_weather`'s API documentation.
.. code-block:: python
>>> beijing_weather = client.fetch_weather("2151330")
>>> beijing_weather["guid"]
'CHXX0008_2013_01_06_7_00_CST'
>>> beijing_weather["description"]
'Yahoo! Weather for Beijing, CN'
>>> beijing_weather["condition"]["temp"]
'28'
The returned :class:`dict <python3:dict>` contains metadata along with the weather data itself. By default, :term:`United States customary units` are used, but by changing the *metric* argument, you can receive data according to the :term:`metric system`.
.. code-block:: python
>>> kailua_weather = client.fetch_weather("12798281", metric=True)
>>> kailua_weather["forecast"][0]["high"]
'25'
>>> kailua_weather["units"]["forecast"]["high"]
'ยฐC'
The units used for each data value are accessible with the *units* key.
Using a Location's :term:`LID`
------------------------------
Because Yahoo! Weather's data comes from `The Weather Channel <http://www.weather.com>`_, weather data is also accessible via a The Weather Channel :term:`LID`. This provides access to a 5-day forecast versus the 2-day forecast available with a location's :term:`WOEID`.
.. code-block:: python
>>> client.fetch_lid("2151330")
'CHXX0008'
>>> beijing_weather = client.fetch_weather("CHXX0008")
>>> len(beijing_weather["forecast"])
5
The :meth:`~yweather.Client.fetch_lid` method takes a :term:`WOEID` and returns a :term:`LID`. You can pass the :term:`LID` to the :meth:`~yweather.Client.fetch_weather` method.
| yweather | /yweather-0.1.1.tar.gz/yweather-0.1.1/docs/usage.rst | usage.rst |
API
===
.. py:module:: yweather
.. data:: WOEID_LOOKUP_URL
The URL used to fetch a location's corresponding :term:`WOEID`.
.. data:: WEATHER_URL
The URL used to fetch a :term:`WOEID`'s weather.
.. data:: LID_LOOKUP_URL
The URL used to fetch a location's corresponding :term:`LID`.
.. data:: LID_WEATHER_URL
The URL used to fetch a :term:`LID`'s weather.
.. data:: WEATHER_NS
The XML namespace used in the weather RSS feed.
.. data:: GEO_NS
The XML namespace used for the lat/long coordinates in the RSS feed.
.. data:: CONDITION_IMAGE_URL
The URL of an image depicting the current conditions.
.. data:: UNITS
A :class:`dict <python3:dict>` that maps data names to units.
.. class:: Client()
Interface with the Yahoo! Weather RSS feed. Provides methods to search for location data and fetch weather data.
.. method:: fetch_lid(woeid)
Fetch a location's corresponding :term:`LID`.
:param woeid: the location's :term:`WOEID`.
:type woeid: :mod:`string <python3:string>`
:returns: a :mod:`string <python3:string>` containing the requested :term:`LID` or :data:`None <python3:None>` if the :term:`LID` could not be found.
:raises urllib.error.URLError: :mod:`urllib.request <python3:urllib.request>` could not open the URL (Python 3).
:raises urllib2.URLError: :mod:`urllib2 <python2:urllib2>` could not open the URL (Python 2).
:raises xml.etree.ElementTree.ParseError: :mod:`xml.etree.ElementTree <python3:xml.etree.ElementTree>` failed to parse the XML document.
.. method:: fetch_weather(id[, metric=False])
Fetch a location's weather.
*id* can be either a :term:`WOEID` or :term:`LID`. The weather data returned for each is identical except that the :term:`WOEID` returns a 2-day forecast and the :term:`LID` returns a 5-day forecast. The :term:`LID` uses an undocumented API, so use it at your own risk.
The returned data is a :class:`dict <python3:dict>` with the requested weather data. It loosely follows the `Yahoo! Weather RSS feed response structure <http://developer.yahoo.com/weather/#response>`_, but has some noticeable differences. The following table outlines the data structure.
============== ========== ============ =====
Keys .. .. Value
============== ========== ============ =====
title The title of the feed, which includes the location city. For example "Yahoo! Weather - Sunnyvale, CA".
link The URL of the forecast for this location.
language The language of the weather forecast, for example, en-us for US English.
description The overall description of the feed including the location, for example "Yahoo! Weather for Sunnyvale, CA".
lastBuildDate The last time the feed was updated. For example, Fri, 04 Jan 2013 6:56 am PST.
ttl Time to Live; how long in minutes this feed should be cached.
logo The URL for the Yahoo! Weather logo associated with this feed.
guid Unique identifier for the forecast, made up of the location ID, the date, and the time.
location city city name
location region state, territory, or region, if given.
location country two-character country code
geo lat The latitude of the location.
geo long The longitude of the location.
units wind chill ยฐF or ยฐC
units wind direction ยฐ
units wind speed mph or km/h
units atmosphere humidity %
units atmosphere visbility mi or km
units atmosphere pressure psi or hPa
units condition temp ยฐF or ยฐC
units forecast low ยฐF or ยฐC
units forecast high ยฐF or ยฐC
wind chill wind chill in degrees
wind direction wind direction, in degrees
wind compass wind direction, according to a compass. For example, NNW, SE, or W.
wind speed wind speed in mph or km/h
atmosphere humidity humidity, in percent
atmosphere visibility visibility, in mi or km.
atmosphere pressure barometric pressure in psi or hPa.
atmosphere rising state of the barometric pressure as a number: 0 (steady), 1 (rising), or 2 (falling).
atmosphere state state of the barometric pressure as text: steady, rising, or falling.
astronomy sunrise today's sunrise time. The time is in a local time format of "h:mm am/pm", for example "7:02 am"
astronomy sunset today's sunset time. The time is in a local time format of "h:mm am/pm", for example "4:51 pm".
condition text a textual description of conditions, for example, "Partly Cloudy"
condition code the condition code for this forecast. Yahoo! Weather's developer network lists the `possible values <http://developer.yahoo.com/weather/#codes>`_.
condition image the URL of an image that depicts the current conditions (clouds, sun, rain, etc.).
condition temp the current temperature in ยฐF or ยฐC
condition date the current date and time for which this forecast applies. For example, Fri, 04 Jan 2013 6:56 am PST.
forecast contains a :class:`list <python3:list>`, where each item is a :class:`dict <python3:dict>` that contains the weather forecast for a specific day.
-- day day of the week to which this forecast applies. Possible values are Mon Tue Wed Thu Fri Sat Sun
-- date the date to which this forecast applies. The date is in "dd Mmm yyyy" format, for example "3 Nov 2005"
-- low the forecasted low temperature for this day in ยฐF or ยฐC
-- high the forecasted high temperature for this day in ยฐF or ยฐC
-- text a textual description of conditions, for example, "Partly Cloudy"
-- code the condition code for this forecast. Yahoo! Weather's developer network lists the `possible values <http://developer.yahoo.com/weather/#codes>`_.
============== ========== ============ =====
The differences between this data structure and Yahoo! Weather's are:
* *units* breaks down the data units further and uses more helpful key names.
* *logo* represents the RSS feed's ``<image>`` tag.
* *guid* was moved to the top level.
* *condition* has the *image* key, which provides easy access to a URL of an image depicting the current sky conditions.
* *atmosphere* has the *state* key, which gives a textual description of the barometric pressure state.
* *geo* is now a :class:`dict <python3:dict>` with *lat* and *long* keys.
* *wind* includes the *compass* key, which provides wind direction according to a compass (e.g. NNW, SE, or W).
Example usage of the returned :class:`dict <python3:dict>`:
.. code-block:: python
>>> print result["wind"]["compass"]
NNW
>>> print result["atmosphere"]["pressure"], result["units"]["atmosphere"]["pressure"]
29.95 psi
>>> print len(result["forecast"])
2
>>> print result["forecast"][0]["text"]
Partly Cloudy
:param id: the location's :term:`WOEID` or :term:`LID`.
:type id: :mod:`string <python3:string>`
:param metric: return metric data; defaults to :data:`False <python3:False>`.
:type metric: :func:`bool <python3:bool>`
:returns: a :class:`dict <python3:dict>` containing the location's weather data or :data:`None <python3:None>` if the weather data couldn't be fetched.
:raises urllib.error.URLError: :mod:`urllib.request <python3:urllib.request>` could not open the URL (Python 3).
:raises urllib2.URLError: :mod:`urllib2 <python2:urllib2>` could not open the URL (Python 2).
:raises xml.etree.ElementTree.ParseError: :mod:`xml.etree.ElementTree <python3:xml.etree.ElementTree>` failed to parse the XML document.
.. method:: fetch_woeid(location)
Fetch a location's corresponding :term:`WOEID`.
:param location: a location (e.g. 23454 or Berlin, Germany).
:type location: :mod:`string <python3:string>`
:returns: a :mod:`string <python3:string>` containing the requested :term:`WOEID` or :data:`None <python3:None>` if the :term:`WOEID` could not be found.
:raises urllib.error.URLError: :mod:`urllib.request <python3:urllib.request>` could not open the URL (Python 3).
:raises urllib2.URLError: :mod:`urllib2 <python2:urllib2>` could not open the URL (Python 2).
:raises xml.etree.ElementTree.ParseError: :mod:`xml.etree.ElementTree <python3:xml.etree.ElementTree>` failed to parse the XML document.
| yweather | /yweather-0.1.1.tar.gz/yweather-0.1.1/docs/api.rst | api.rst |
Introduction
============
This is the documentation for :mod:`yweather`. :mod:`yweather` is a Python module that provides an interface to the `Yahoo! Weather RSS feed <http://developer.yahoo.com/weather/>`_
Prerequisites
-------------
:mod:`yweather` requires Python 2.6, 2.7, or 3 to run.
Installation
------------
There are multiple ways to install :mod:`yweather`. If you are unsure about which method to use, try ``pip``.
pip (recommended)
~~~~~~~~~~~~~~~~~
`pip <http://www.pip-installer.org/>`_ is a tool for installing and managing Python packages. To install :mod:`yweather`, run:
.. code-block:: bash
$ pip install yweather
This will download :mod:`yweather` from `the Python Package Index <http://pypi.python.org/>`_ and install it in your Python's ``site-packages`` directory.
Tarball Release
~~~~~~~~~~~~~~~
1. Download the most recent release from `yweather's PyPi page <http://pypi.python.org/pypi/yweather/>`_.
2. Unpack the tarball.
3. From inside the ``yweather-0.X`` directory, run ``python setup.py install``
This will install :mod:`yweather` in your Python's ``site-packages`` directory.
Install the Development Version
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
`yweather's code <https://github.com/tsroten/yweather>`_ is hosted at GitHub. To install the development version, do the following:
1. Make sure `Git <http://git-scm.org/>`_ is installed. Test if it's installed by running ``git --version``
2. ``git clone git://github.com/tsroten/yweather.git``
3. ``pip install -e yweather``
This will link the ``yweather`` directory into your ``site-packages`` directory. You can find out where your ``site-packages`` directory is by running:
.. code-block:: bash
python -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())"
Basic Usage
-----------
.. code-block:: python
>>> import yweather
>>> client = yweather.Client()
>>> client.fetch_woeid("Oslo, Norway")
'862592'
>>> oslo_weather = client.fetch_weather("862592")
>>> oslo_weather["atmosphere"]["pressure"]
'30.24'
>>> oslo_weather["condition"]["text"]
'Mostly Cloudy'
This code creates a :class:`yweather.Client` instance that allows you to fetch a location's :term:`WOEID` and weather. The weather data is returned as a :class:`dict <python3:dict>`.
| yweather | /yweather-0.1.1.tar.gz/yweather-0.1.1/docs/intro.rst | intro.rst |
# YWH Collab
```
โโโ โโโโโโ โโโโโโ โโโ โโโโโโโ โโโโโโโ โโโ โโโ โโโโโโ โโโโโโโ
โโโโ โโโโโโโ โโโโโโ โโโ โโโโโโโโโโโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโ
โโโโโโโ โโโ โโ โโโโโโโโโโโโโโโโโโโโ โโโ โโโโโโ โโโ โโโโโโโโโโโโโโโโ
โโโโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโ โโโโโโ โโโ โโโโโโโโโโโโโโโโ
โโโ โโโโโโโโโโโโโ โโโ โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโ
โโโ โโโโโโโโ โโโ โโโ โโโโโโโ โโโโโโโ โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโ
```
## Description
YWH Collab is a comparator of private program for hunters collaboration.
The goal of this tool is to be able to find common programs that accept collaboration between hunters without revealing the names of the clients of the private programs to which you are invited.
> **Please note that if you share the list of anonymized programs publicly, it will be possible for all other members of the program to know that you are also invited!**
## Installation
Install from [pip](https://pypi.org/project/ywh-collab):
```
โถ pip install ywh-collab
```
## Usage
It is possible to provide the JWT as an argument or to provide credentials in an interactive session to log in your Yes We Hack account.
```bash
$ ywh-collab -h
usage: ywh-collab [-h] [-j JWT] -f FILENAME {export,compare}
Yes We Hack private program comparator for hunters collaboration by Aethlios.
positional arguments:
{export,compare} Export your list of program IDs or compare a list with your programs to find common programs that accept collab.
optional arguments:
-h, --help show this help message and exit
-j JWT, --jwt JWT The JWT token of the YWH session
-f FILENAME, --filename FILENAME
The input or output filename
```
### Export
First, you can export the list of program IDs into `output.txt` file to share it with another hunter :
```bash
ywh-collab -f output.txt export
```
### Compare
In a second step, you can compare the list of program IDs of another hunter stored in `input.txt` file with your private programs in order to find common programs that accept hunters' collaboration.
```bash
ywh-collab -f input.txt compare
```
## Changelog
- v1.0.0 - Initial release
| ywh-collab | /ywh-collab-1.0.tar.gz/ywh-collab-1.0/README.md | README.md |
# ywh2bt
ywh2bt synchronizes your vulnerability reports from the [Yes We Hack platform][YesWeHack-Platform]
with issues of your bug tracker(s). It automatically retrieves reports you want to copy in your bug tracker,
creates the related issue, and syncs further updates between issues and reports.
It comes with a handy GUI to set up and test the integration,
while completely controlling the information you allow to be synchronized from both side.
## Table of contents
- [User Guide](#user-guide)
- [Architecture](#architecture)
- [Requirements](#requirements)
- [Installation](#installation)
- [Supported trackers](#supported-trackers)
- [Changelog](#changelog)
- [Local development](#local-development)
- [Requirements](#requirements-1)
- [Installation](#installation-1)
- [Usage](#usage-1)
- [Updating User Guide](#updating-user-guide)
## User Guide
A User Guide is available in [PDF][User-Guide-pdf] and [HTML][User-Guide-html] formats.
## Architecture
YWH2BT embeds both the GUI to set up the integration,
and the application to be scheduled on your server to periodically poll and synchronize new reports.
You can either run both on a single machine, or prepare the configuration file
on a computer (with the GUI) and transfer it on the server and use it through a scheduled command.
Since data is pulled from YWH platform to your server, only regular outbound web connections need to be authorized on your server.
## Requirements
- `python` >= 3.7,<=3.9
- [`pip`](https://pip.pypa.io/en/stable/installing/)
## Supported trackers
- github
- gitlab
- jira / jiracloud
- servicenow
## Changelog
- v2.5:
- added Personal Access Token (PAT) authentication
- removed OAuth authentication
- v2.4:
- added option to prevent recreation of issues that were created by a previous synchronization
but are not found into the bug tracker anymore
- v2.3:
- added support for ServiceNow
- v2.2:
- added GitLab option for confidential issues
- v2.1:
- added feedback feature (synchronize from bug tracker to report)
- added [docker image yeswehack/ywh2bugtracker](https://hub.docker.com/r/yeswehack/ywh2bugtracker)
- added User Guide [PDF][User-Guide-pdf] and [HTML][User-Guide-html]
- v0.* to v2.0.0:
- behavior changes:
- reports logs can selectively be synchronized with the trackers:
- public comments
- private comments
- report details changes
- report status changes
- rewards
- a program can now only be synchronized with 1 tracker
- added support for JSON configuration files
- removed `ywh-bugtracker` command (use `ywh2bt synchronize`)
- added `ywh2bt` command:
- added `ywh2bt synchronize`:
- note: `ywh2bt synchronize --config-file FILE --config-format FORMAT`
is the equivalent of `ywh-bugtracker -n -f FILE` in v0.*
- added `ywh2bt validate`
- added `ywh2bt test`
- added `ywh2bt convert`
- added `ywh2bt schema`
- removed command line interactive mode
- added GUI via `ywh2bt-gui` command
## Local development
### Requirements
- [`poetry`](https://python-poetry.org/) (`pip install poetry`)
### Installation
- `make install` (or `poetry install`): creates a virtualenv and install dependencies
### Usage
Instead of `ywh2bt [command]`, run commands using `poetry run ywh2bt [command]`.
Same goes for `ywh2bt-gui`, run `poetry run ywh2bt-gui` instead.
### Updating User Guide
[PDF][User-Guide-pdf] and [HTML][User-Guide-html] versions of the User Guide are generated via Pandoc
using [docs/User-Guide.md][User-Guide-md] as an input file.
Any changes made to [docs/User-Guide.md][User-Guide-md] **must be followed** by the execution of the command
`make user-guide` in order to regenerate the PDF and HTML files, **otherwise the CI will fail**.
[YesWeHack-Platform]: https://www.yeswehack.com/
[User-Guide-md]: docs/User-Guide.md
[User-Guide-pdf]: docs/user-guide/User-Guide.pdf
[User-Guide-html]: docs/user-guide/User-Guide.html
| ywh2bt | /ywh2bt-2.7.2.tar.gz/ywh2bt-2.7.2/README.md | README.md |
ๅจฑ็ฝ็ง้ๅ
้จpython ๅ
ฌ็จๅ
===================================
ๅฎ่ฃ
-----
ไฝฟ็จ pip ๅฎ่ฃ
$ pip install ywkd_tools
pip ๅฐๅ
-----
https://pypi.org/project/ywkd-tools/
ไฝฟ็จ
-----
### PRC ่ฐ็จ
```python
from ywkd_tools.inner_service_apis import InnerServices
InnerServices.setup(service_name=<่ฐ็จ่
ๅ็งฐ>, base_url=<RPC Domain>, secret=<RPC ่ฎค่ฏๅฏ็ >)
# ๅ้็ญไฟก
InnerServices.MSG().send_sms([57], 'SMS_177552091', {'username': 'tester','password': 'pwd12345'})
# ็จๆท่ฟๆปค
InnerServices.Cperm().filter_users(group_codes__in=['ceo'])
# ่ฐ็จ่ชๅฎไนๆนๆณ fun
InnerServices.Cperm().rpc_client.fun(...)
# ่ทๅ็จๆท่ฏฆๆ
InnerServices.Cperm().get_user(1)
# ๅฎไพ1:
class AViewOrSerializer(xxx):
def some_method(...):
cperm = InnerServices.Cperm()
cperm.get_user(...)
cperm.filter_users(...)
cperm.rpc_client.fun(...)
...
# ๅฎไพ2:
@app.task(...)
def asyn_job(...):
cperm = InnerServices.Cperm(request_id='xxxxxxxxxx') # or cperm = InnerServices.Cperm(request=request)
cperm.get_user(...)
cperm.filter_users(...)
cperm.rpc_client.fun(...)
...
```
### Auth ่ฎค่ฏ
```python
# ๅจๅๅงๅๆไปถไธญๆง่ก
from ywkd_tools.auth import Auth
Auth.setup(service_name=<่ฐ็จ่
ๅ็งฐ>, rpc_base_url=<RPC Domain>, rpc_secret=<RPC ่ฎค่ฏๅฏ็ >)
# ๅจdjango viewๆไปถไธญ
from ywkd_tools.auth import Auth
class SomeView(BaseView):
"""้่ฆ่ฎค่ฏ็Django Vew"""
authentication_classes = [Auth.RSTFBasciAuthentication]
...
def get(self, request, *args, **kwargs):
return self.list(request, *args, **kwargs)
def post(self, request, *args, **kwargs):
return self.create(request, *args, **kwargs)
# ๅจๅฏนๅคๆไพRPCๆๅก็ๆไปถไธญ
from modernrpc.core import rpc_method
from modernrpc.auth import set_authentication_predicate
from ywkd_tools.auth import Auth
@rpc_method
def ping():
"""ไธ้่ฆ่ฎค่ฏ็rpc ๆฅๅฃ"""
return 'pong'
@rpc_method
@set_authentication_predicate(Auth.RPCBasciAuthentication().authenticate)
def get_import_info():
"""้่ฆ่ฎค่ฏ็rpc ๆฅๅฃ"""
return ...
```
ๅๅธๅ
-----
```bash
# ็กฎไฟๆจๆฅๆsetuptoolsๅนถwheel ๅฎ่ฃ
ไบๆๆฐ็ๆฌ
$ python3 -m pip install --upgrade setuptools wheel
# ๅฎ่ฃ
Twine
$ python3 -m pip install --upgrade twine
# ไปsetup.pyไฝไบ็ๅไธ็ฎๅฝ่ฟ่กๆญคๅฝไปค
$ python3 setup.py sdist bdist_wheel
# ่ฟ่กTwineไปฅไธไผ ๆๆๅญๆกฃdist
$ python3 -m twine upload dist/*
$ python3 -m twine upload --skip-existing dist/*
```
| ywkd-tools | /ywkd_tools-1.0.18.tar.gz/ywkd_tools-1.0.18/README.md | README.md |
import traceback
from base64 import b64decode
from rest_framework import authentication, exceptions
from ywkd_tools.inner_service_apis import InnerServices
from ywkd_tools.logger import logger
class Auth(object):
"""
Auth
"""
service_name = None
rpc_base_url = None
rpc_secret = None
inited = False
def __init__(self):
raise TypeError('Cannot create "Auth" instances.')
@classmethod
def setup(cls, service_name=None, rpc_base_url=None, rpc_secret=None):
cls.service_name = service_name
cls.rpc_base_url = rpc_base_url
cls.rpc_secret = rpc_secret
if InnerServices.inited:
cls.service_name = InnerServices.service_name
cls.rpc_base_url = InnerServices.base_url
cls.rpc_secret = InnerServices.secret
elif service_name and rpc_base_url:
InnerServices.setup(service_name=service_name,
base_url=rpc_base_url,
secret=rpc_secret)
cls.inited = True
@classmethod
def inner(cls, authentication_class):
authentication_class.auth_class = cls
setattr(cls, authentication_class.__name__, authentication_class)
@Auth.inner
class RPCBasciAuthentication(object):
"""
RPC ่ฎค่ฏ (ๅช่ฝ็จไบRPC)
headers:
HTTP_AUTHORIZATION=basci [username]:[password]
"""
auth_class = None
def do_check(self, request, username, password):
if password != self.auth_class.rpc_secret:
logger.info('ๅฏ็ /็จๆท้่ฏฏ')
return False
return True
def authenticate(self, request):
if not self.auth_class.inited:
raise Exception('Auth not setup yet, please do this first!')
# ๆฒกๆ่ฎพ็ฝฎ rpc sercret ๅๅฟฝ็ฅ่ฎค่ฏ
if not self.auth_class.rpc_secret:
return True
username = password = None
basic_auth = request.META.get('HTTP_AUTHORIZATION')
if not basic_auth:
logger.info('็ผบๅฐ basci authrization')
return False
try:
auth_method, auth_string = basic_auth.split(' ', 1)
except Exception:
logger.info('httpๅคด้จ HTTP_AUTHORIZATION ๆ ผๅผ้่ฏฏ')
return False
if auth_method.lower() == 'basic':
try:
auth_string = b64decode(auth_string.strip())
username, password = auth_string.decode().split(':', 1)
except Exception:
logger.info('้่ฏฏ็ Basic ๆ ผๅผ')
return False
else:
logger.info('้่ฆ basic authrization')
return False
res = self.do_check(request, username, password)
if not res:
return False
return True
@Auth.inner
class RSTFBasciAuthentication(authentication.BaseAuthentication):
"""
Django rest_framework Basci ่ฎค่ฏ: (ๅช่ฝ็จไบDjango rest_framework)
headers:
HTTP_AUTHORIZATION=basci [user_id]:[token]
"""
auth_class = None
def do_check(self, request, user_id, token):
service_name = self.auth_class.service_name
api_name = request.resolver_match.url_name
operator_type = request.method
# ๆฃๆตๆฅๅฃ่ฎฟ้ฎๆ้
res = None
try:
res = InnerServices.Cperm().check_api_operate_perms(
user_id=user_id,
token=token,
service_name=service_name,
api_name=api_name,
operator_type=operator_type)
except Exception as e:
traceback.print_exc()
raise exceptions.AuthenticationFailed('ไธ่ฎค่ฏๆๅกcperm้ไฟกๅคฑ่ดฅ')
if res['code'] != 0:
raise exceptions.AuthenticationFailed(res['codemsg'])
# ่ทๅ็จๆทไฟกๆฏ
user = InnerServices.Cperm().get_user(user_id)
user['token'] = request.token
user['basic_auth'] = request.basic_auth
return user
def authenticate(self, request):
if not self.auth_class.inited:
raise Exception('Auth not setup yet, please do this first!')
user_id = token = None
basic_auth = request.META.get('HTTP_AUTHORIZATION')
if not basic_auth:
raise exceptions.AuthenticationFailed('็ผบๅฐ basci authrization')
try:
auth_method, auth_string = basic_auth.split(' ', 1)
except Exception:
raise exceptions.AuthenticationFailed('httpๅคด้จ HTTP_AUTHORIZATION ๆ ผๅผ้่ฏฏ')
if auth_method.lower() == 'basic':
try:
auth_string = b64decode(auth_string.strip())
user_id, token = auth_string.decode().split(':', 1)
except Exception:
traceback.print_exc()
raise exceptions.AuthenticationFailed('้่ฏฏ็ Basic ๆ ผๅผ')
else:
raise exceptions.AuthenticationFailed('้่ฆ basic authrization')
request.token = token
request.basic_auth = basic_auth
res = self.do_check(request, user_id, token)
return (res, None) | ywkd-tools | /ywkd_tools-1.0.18.tar.gz/ywkd_tools-1.0.18/ywkd_tools/auth/auth.py | auth.py |
import re
import log_request_id
from xmlrpc.client import Transport, SafeTransport, ServerProxy
from base64 import b64encode
from urllib.parse import urljoin
from functools import wraps
from django.http import HttpRequest
from django.conf import settings
from rest_framework.request import Request
from ywkd_tools.inner_service_apis.errors import InnerAPIError
from ywkd_tools.logger import logger
from ywkd_tools.utils import get_request_id
class SpecialTransport(Transport):
"""
SpecialTransport (http)
"""
preset_headers = {}
def set_header(self, key, value):
if key.lower().startswith('http'):
key = key[5:]
if value == None:
self.preset_headers.pop(key, None)
else:
self.preset_headers[key] = value
def send_headers(self, connection, headers):
for key, val in self.preset_headers.items():
connection.putheader(key, val)
super().send_headers(connection, headers)
# def send_content(self, connection, request_body):
# connection.putheader("Content-Type", "text/xml")
# connection.putheader("Content-Length", str(len(request_body)))
# connection.endheaders()
# if request_body:
# connection.send(request_body)
class SpecialSafeTransport(SafeTransport):
"""
SpecialSafeTransport (https)
"""
preset_headers = {}
def set_header(self, key, value):
if key.lower().startswith('http'):
key = key[5:]
if value == None:
self.preset_headers.pop(key, None)
else:
self.preset_headers[key] = value
def send_headers(self, connection, headers):
for key, val in self.preset_headers.items():
connection.putheader(key, val)
super().send_headers(connection, headers)
# def send_content(self, connection, request_body):
# connection.putheader("Content-Type", "text/xml")
# connection.putheader("Content-Length", str(len(request_body)))
# connection.endheaders()
# if request_body:
# connection.send(request_body)
class InnerServices(object):
"""
InnerServices
"""
service_name = ''
base_url = ''
secret = ''
inited = False
def __init__(self):
raise TypeError('Cannot create "InnerServices" instances.')
@classmethod
def setup(cls, service_name, base_url, secret):
cls.base_url = base_url
services = [getattr(cls, key) for key in cls.__dict__ if isinstance(getattr(cls, key), InnerService)]
for service in services:
service.init(service_name, base_url, secret)
cls.inited = True
@classmethod
def inner(cls, service_cls):
service = service_cls()
setattr(cls, service_cls.__name__, service)
class InnerService(object):
"""
InnerService
"""
url = None
client = None
http_request = None
request_id = None
def __init__(self, http_request=None, request_id=None):
"""
@parms http_request: django.http.HttpRequest ๆ rest_framework.request.Request
@parms request_id: ไธๆๅฎๆถ ้ป่ฎคไฝฟ็จไธไธๆไธญ็request_id, ๅปบ่ฎฎๅจDjango View ไธญๆ ็นๆฎ้ๆฑๅๆ ้
ๆๅฎ http_request or request_id, ๅจๅผๆญฅไปปๅกไธญๅปบ่ฎฎๆๅฎ่ฏฅๅผ, ไฟ่ฏlogๆฅๅฟ็ๅฎๆดๆง
"""
if not hasattr(self, 'url'):
raise InnerAPIError('InnerService class "%s" need has a url attr!' %
self.__class__.__name__)
if http_request:
assert (isinstance(http_request, HttpRequest) or isinstance(http_request, Request)), (
'The `request` argument must be an instance of '
'`django.http.HttpRequest` or `rest_framework.request.Request`, not `{}.{}`.'
.format(http_request.__class__.__module__, http_request.__class__.__name__)
)
if http_request:
self.http_request = http_request
self.request_id = http_request.id
if request_id:
self.request_id = request_id
def __call__(self, http_request=None, request_id=None):
new_instance = self.__class__(http_request=http_request, request_id=request_id)
new_instance.init(self.service_name, self.base_url, self.secret)
return new_instance
def get_url(self):
"""่ทๅurl"""
url = self.url
if not re.match(r'^(http|https)://', self.url, re.I):
assert (self.base_url != None and re.match(r'^(http|https)://', self.base_url, re.I)), (
'base_url must not null and start with http or https'
)
url = urljoin(self.base_url, self.url)
return url
def get_transport(self):
"""่ทๅtransport"""
transport = None
if self.http_url.startswith('https'):
transport = SpecialSafeTransport()
else:
transport = SpecialTransport()
# ่ฎค่ฏ: HTTP_AUTHORIZATION basic xxxxxxxx
basic_auth_str = '{service_name}:{secret}'.format(**{
'service_name': self.service_name,
'secret': self.secret
})
header_auth_str = 'basic {}'.format(
b64encode(bytes(basic_auth_str, 'utf-8')).decode('utf-8'))
transport.set_header('Authorization', header_auth_str)
return transport
def init(self, service_name, base_url, secret):
# logger.debug('Init inner service: "{}"'.format(self.__class__.__name__))
self.service_name = service_name
self.base_url = base_url
self.secret = secret
self.http_url = self.get_url()
self.transport = self.get_transport()
self.client = ServerProxy(self.http_url, transport=self.transport, allow_none=True, use_datetime=True)
@property
def rpc_client(self):
assert self.client, (
'"{}" instance not setup yet, please do init first!'
.format(self.__class__.__name__)
)
# ๅจ่ฏทๆฑๅคดไธญๆทปๅ request_id
request_id = None
if self.request_id:
request_id = self.request_id
else:
request_id = get_request_id()
# request_id_header = getattr(settings, log_request_id.REQUEST_ID_HEADER_SETTING, 'X-Request-Id') # bug HTTP_X_REQUEST_ID ไธ่ฝ็ดๆฅไฝฟ็จ
self.transport.set_header('X-Request-Id', request_id)
return self.client | ywkd-tools | /ywkd_tools-1.0.18.tar.gz/ywkd_tools-1.0.18/ywkd_tools/inner_service_apis/inner_service_apis.py | inner_service_apis.py |
from ywkd_tools.inner_service_apis.inner_service_apis import InnerServices, InnerService
from ywkd_tools.inner_service_apis.errors import InnerAPIError
@InnerServices.inner
class Cperm(InnerService):
"""็จๆทไธญๅฟ"""
url = '/cperm/rpc/'
def get_user(self, user_id):
"""
่ทๅ็จๆท่ฏฆๆ
@param: user_id ็จๆทid
@out: { // ่ฟๅๅ
ๅฎนๅ่: http://yapi.yuwangkedao.com/project/251/interface/api/6341
id: [็จๆทid],
user_type: ็จๆท็ฑปๅ,
avatar: ๅคดๅ,
belong_participant: { // ๆๅฑๅ
ฌๅธ
id: [ๅ
ฌๅธid],
participant_type: [ๅ
ฌๅธ็ฑปๅ]
...
},
...
}
"""
return self.rpc_client.get_user(user_id)
def check_api_operate_perms(self, user_id, token, service_name, api_name, operator_type):
"""
ๆฃๆตๅฝๅtokenๆฏๅฆๅฏไปฅๅฏนๅฝๅ api ่ฟ่กๆไฝ
@param: user_id ็จๆทid
@param: token ็จๆทtoken
@param: service_name ๆๅกๅ็งฐ ไพๅฆ"KTV"
@param: api_name apiๅ
@param: operator_type ๆไฝ็ฑปๅ ๆฏๅฆ: GET, POST, PUT
@out {"code": [่ฟๅ็ ], "codemsg": [ๆถๆฏๅ
ๅฎน]}
ๆๅ: {"code": 0, "codemsg": u"่ฏทๆฑๆๅ"}
ๅคฑ่ดฅ: {"code": 500104, "codemsg": u"็จๆท่ขซ็ฆ็จๆtokenๅผไธๅฏน"}
{"code": 500102, "codemsg": u"็จๆทๆ ๆ้"}
{"code": 500016, "codemsg": u"็จๆท่ขซ็ฆ็จ/ๅทฒๅ ้ค"}
"""
if not service_name:
service_name = self.service_name
return self.rpc_client.check_api_operate_perms(
user_id, token, service_name, api_name, operator_type)
def filter_users(self, id__in=None, user_type__in=None, phone__in=None, nickname__contains=None,
is_active=None, is_all_area=None, belong_participant_id__in=None,
group_codes__in=None, permission_codes__in=None, page_index=1, page_size=100):
"""
่ฟๆปค็จๆท:
ไพ:
# ่ฟๆปค ่ง่ฒcode ไธบ CEO,CTO ็็จๆท
filter_users(None, None, None, None, None, None, None, ['ceo', 'cto'])
@out:
{
"total": 2, # ๆปๆฐ
"page_index": 1, # ๅฝๅ้กต ่ตทๅง้กต 1
"page_size": 100, # ๆฏ้กตๅคงๅฐ
"data": [{
"id": 57, # user_id
"user_type": "employee", # ็จๆท็ฑปๅ
"phone": "13644092", # ๆๆบๅท
"nickname": "ๆต็งฐA", # ๆต็งฐ
"gender": 1, # ๆงๅซ
"is_all_area": False, # ๆฏๅฆๅ
จๅฝ
"area_code_list": [], # ๅบๅcodes
"serial_number": "000018", # ๅบๅๅท
"belong_participant": None, # ๆๅฑๅ
ฌๅธ
"group_codes": ["ceo"] # ๆๅฑ็ป codes
}, {
"id": 21,
"user_type": "agentibus",
"phone": "13644099810",
"nickname": "ABC",
"gender": 1,
"is_all_area": True,
"area_code_list": ["00320200", "00330100"],
"serial_number": "110007",
"belong_participant": {
"id": 1005,
"participant_type": "agentibus",
"area_code_list": ["00120000", "00120100", "00120101"],
"address": "่ฅฟๆบชๅฃนๅท",
"contact": "่็ณปไบบA",
"telephone": "0411-84620027",
"comment": "ๅคๆณจB",
"serial_number": "DLS0005"
},
"group_codes": ["ceo"]
}]
}
"""
return self.rpc_client.filter_users(
id__in, user_type__in, phone__in, nickname__contains,
is_active, is_all_area, belong_participant_id__in,
group_codes__in, permission_codes__in, page_index, page_size) | ywkd-tools | /ywkd_tools-1.0.18.tar.gz/ywkd_tools-1.0.18/ywkd_tools/inner_service_apis/cperm/interface.py | interface.py |
from ywkd_tools.inner_service_apis.inner_service_apis import InnerServices, InnerService
from ywkd_tools.inner_service_apis.errors import InnerAPIError
@InnerServices.inner
class Participant(InnerService):
"""็จๆทไธญๅฟ"""
url = '/cperm/rpc/'
def get_participant(self, participant_type, participant_id):
"""
่ทๅๅไธๅฉๆถฆๅ้
็ๅ
ฌๅธ/ๅขไฝ่ฏฆๆ
@param: participant_type: ็ฑปๅ
KTV: ktv
VOD: vod
ไปฃ็ๅ: agentibus
่กไธๅไผ(ๆบๆ): industry_association
ๅซไปๆน: advance_party
้ณไน่ไฝๅไผ: music_copyright_society
ๆๅๆน: copyright_party
ๅนณๅฐ: platform
@param: id
@out: { // ่ฟๅๅ
ๅฎนๅ่: http://yapi.yuwangkedao.com/project/251/interface/api/6233
id: [id],
participant_type: ็ฑปๅ,
name: ๅ็งฐ,
area_code_list: ๅบๅๅ่กจ,
...
}
"""
return self.rpc_client.get_participant(participant_type, participant_id)
def filter_agentibus(self, id__in=None, name__contains=None, serial_number=None, pingpp_user_account_id=None,
agency_area_code=None, enabled=None, page_index=1, page_size=100):
"""
่ฟๆปคไปฃ็ๅ:
ไพ:
# ่ฟๆปค ไปฃ็ๅบๅไธบ"00420000", ๅฏ็จ็ถๆไธบTrue ็ไปฃ็ๅ
filter_agentibus(None, None, None, None, "00420000", True)
@param: id__in: ไปฃ็ๅid
@param: name__contains: ไปฃ็ๅๅ็งฐ
@param: serial_number: ไปฃ็ๅ็ผๅท
@param: pingpp_user_account_id: ping++่ดฆๆท
@param: agency_area_code: ไปฃ็ๅบๅ(code)
@param: enabled: ๆฏๅฆๅฏ็จ
@out:{
'data': [
# ๅ่: http://yapi.yuwangkedao.com/project/251/interface/api/6233 ่ฟๅๅผ
{
'id': 1092,
'name': 'ไปฃ็ๅๅ็งฐ',
'address': '่ฅฟๆบชๅฃนๅท24',
'agency_area_code': '00360000',
'enabled': True,
...
}
],
'page_index': 1,
'page_size': 100,
'total': 1
}
"""
return self.rpc_client.filter_agentibus(id__in, name__contains, serial_number, pingpp_user_account_id,
agency_area_code, enabled, page_index, page_size) | ywkd-tools | /ywkd_tools-1.0.18.tar.gz/ywkd_tools-1.0.18/ywkd_tools/inner_service_apis/participant/interface.py | interface.py |
from ywkd_tools.inner_service_apis.inner_service_apis import InnerServices, InnerService
from ywkd_tools.inner_service_apis.errors import InnerAPIError
@InnerServices.inner
class MSG(InnerService):
"""ๆถๆฏ"""
url = '/cperm/rpc/'
def send_msg(self, user_ids, msg, redirect_url=None, ignore_err=True):
"""
ๅ้็ซๅ
ๆถๆฏ
@parms user_ids: ๆฅๆถmessage ็็จๆทid (ๅฏไปฅไธบlist)
@parms msg: ๆถๆฏๅ
ๅฎน
@parms redirect_url: ่ทณ่ฝฌ้พๆฅ
@parms ignore_err: ๆฏๅฆๅฟฝ็ฅ้่ฏฏ
"""
return self.rpc_client.send_msg(user_ids, msg, redirect_url, ignore_err)
def send_email(self, user_ids, mail_subject, mail_message, countdown=None, eta=None, ignore_err=True):
"""
ๅ้email
@parms user_ids: ๆฅๆถemail ็็จๆทid (ๅฏไปฅไธบlist)
@parms mail_subject: ้ฎไปถไธป้ข
@parms mail_message: ้ฎไปถๅ
ๅฎน
@parms countdown: ๆฏๅฆๅปถ่ฟๅ้, ๅปถๆถๅ ็ง, ไพๅฆ: countdown=5
@parms eta: ๆฏๅฆๅปถ่ฟๅ้, ๅปถๆถๅ ็ง, ไพๅฆ: eta=datetime.datetime.utcnow() + datetime.timedelta(seconds=5) ๆณจๆๆถ้ดๅฟ
้กปไธบ utcๆถ้ด
@parms ignore_err: ๆฏๅฆๅฟฝ็ฅ้่ฏฏ
ไพ:
import datetime
eta = datetime.datetime.utcnow() + datetime.timedelta(seconds=3)
InnerServices.MSG().send_email([57], 'Email Test A', 'test', None, eta)
"""
return self.rpc_client.send_email(
user_ids, mail_subject, mail_message, countdown, eta, ignore_err)
def send_sms(self, user_ids, sms_code, sms_params, countdown=None, eta=None, ignore_err=True):
"""
ๅ้็ญไฟก
@parms user_ids: ๆฅๆถ็ญไฟก็็จๆทid (ๅฏไปฅไธบlist)
@parms sms_code: sms_code (ๅจ้ฟ้็ญไฟกๅๅฐ้
็ฝฎ)
@parms sms_params: ๆจกๆฟๅๆฐ (ๅฟ
้กปไธ้
็ฝฎ็ๆจกๆฟๅน้
)
@parms countdown: ๆฏๅฆๅปถ่ฟๅ้, ๅปถๆถๅ ็ง, ไพๅฆ: countdown=5
@parms eta: ๆฏๅฆๅปถ่ฟๅ้, ๅปถๆถๅ ็ง, ไพๅฆ: eta=datetime.datetime.utcnow() + datetime.timedelta(seconds=5) ๆณจๆๆถ้ดๅฟ
้กปไธบ utcๆถ้ด
@parms ignore_err: ๆฏๅฆๅฟฝ็ฅ้่ฏฏ
ไพ:
InnerServices.MSG().send_sms([57], 'SMS_177552091', {'username': 'tester','password': 'pwd12345'}, 3)
"""
return self.rpc_client.send_sms(user_ids, sms_code, sms_params, countdown, eta, ignore_err) | ywkd-tools | /ywkd_tools-1.0.18.tar.gz/ywkd_tools-1.0.18/ywkd_tools/inner_service_apis/msg/interface.py | interface.py |
=========
YWorkLog
=========
Stack based utility with CLI interface helping you to monitor time spent on
tasks.
The stack base helps with dealing with tasks interupted with other tasks,
unfortunately it can't deal with tasks running in parallel (yet).
Usage
======
Start an activity
::
$ wl start playing chess
Pause it with a random encounter
::
$ wl end fapping
Check out how long did the fapping take you
::
$ wl diff
2012-07-11 10:09:23.626468 end fapping
diff: 0:00:12.802342
Resume what you have started
::
$ wl resume
Check out your logs since you have started
::
$ wl end # <- this step shouldn't be needed in the future, before doing `diff -f`
$ wl diff -f
2012-07-11 10:09:09.823053 start playing chess
2012-07-11 10:09:23.626468 end fapping
2012-07-11 10:11:04.459657 resume
2012-07-11 10:11:15.852227 end
diff: 0:00:25.195985
List all your logs
::
$ wl list
2012-07-11 09:52:34.045907 start fuuu
2012-07-11 09:52:37.928545 end kek
2012-07-11 10:09:09.823053 start playing chess
2012-07-11 10:09:23.626468 end fapping
2012-07-11 10:11:04.459657 resume
2012-07-11 10:11:15.852227 end
And wrap up
::
$ wl pop
2012-07-11 10:09:09.823053 start playing chess
2012-07-11 10:09:23.626468 end fapping
2012-07-11 10:11:04.459657 resume
2012-07-11 10:11:15.852227 end
diff: 0:00:25.195985
$ wl list
2012-07-11 09:52:34.045907 start fuuu
2012-07-11 09:52:37.928545 end kek
Install
=========
::
$ python setup.py install
$ alembic upgrade head
| yworklog | /yworklog-0.0.7.tar.gz/yworklog-0.0.7/README.rst | README.rst |
from uuid import uuid1
from typing import Dict
from baseblock import BaseObject
class KeyByLabelLoader(BaseObject):
""" Accept Graph Data that is keyed by Label """
def __init__(self):
""" Change Log
Created:
18-Aug-2022
[email protected]
* design principles specified in
https://github.com/craigtrim/yworks-helper/issues/1
"""
BaseObject.__init__(self, __name__)
@staticmethod
def _uuid() -> str:
return str(uuid1()).replace('-', '_')
def _generate_nodes(self,
d_nodes: dict) -> tuple:
nodes = []
d_map = {}
for k in d_nodes:
node_id = self._uuid()
d_map[k] = node_id
def color():
if 'color' in d_nodes[k]:
return d_nodes[k]['color']
return '#17bebb' # default
def properties():
d = {
"label": k
}
inner_keys = [k for k in d_nodes[k] if k not in ['color']]
for inner_key in inner_keys:
d[inner_key] = d_nodes[k][inner_key]
return d
nodes.append({
"id": node_id,
"properties": properties(),
"color": color()
})
return nodes, d_map
def _generate_edges(self,
d_node_map: dict,
source_edges: list) -> dict:
target_edges = []
for d_source in source_edges:
# edge_id = self._uuid()
d_target = {
"start": d_node_map[d_source['start']],
"end": d_node_map[d_source['end']],
}
for k in [k for k in d_source.keys()
if k not in ['start', 'end']]:
d_target[k] = d_source[k]
target_edges.append(d_target)
return target_edges
def process(self,
d_nodes: dict,
edges: list = None) -> dict:
target_nodes, d_node_map = self._generate_nodes(d_nodes)
def target_edges() -> dict:
if not edges:
return {}
return self._generate_edges(d_node_map, edges)
return {
'nodes': target_nodes,
'edges': target_edges()
} | yworks-helper | /yworks-helper-0.1.9.tar.gz/yworks-helper-0.1.9/yworks_helper/core/svc/key_by_label_loader.py | key_by_label_loader.py |
from typing import Dict
from yfiles_jupyter_graphs import GraphWidget
from baseblock import BaseObject
from yworks_helper.core.svc import KeyByLabelLoader
class GenerateGraphWidget(BaseObject):
""" Generate a yWorks Graph Widget """
def __init__(self):
"""
Created:
18-Aug-2022
[email protected]
* design principles specified in
https://github.com/craigtrim/yworks-helper/issues/1
"""
BaseObject.__init__(self, __name__)
def process(self,
d_nodes: dict,
edges: list = None,
directed: bool = True) -> GraphWidget:
""" Create a Graph Widget
Args:
d_nodes (dict): the node input
Sample Input:
{
"john smith": {
"alpha": 22
},
"jane smith": {
"alpha": 233,
"beta": 400
}
}
edges (list, optional): the edge input
Sample Input:
[
{
'start': 'john smith',
'end': 'jane smith',
'label': 'knows'
}
]
directed (bool, optional): indicate if this is a directed graph. Defaults to True.
Returns:
GraphWidget: an instantiated GraphWidget
"""
d_result = KeyByLabelLoader().process(
d_nodes=d_nodes, edges=edges)
w = GraphWidget()
w.nodes = d_result['nodes']
w.edges = d_result['edges']
w.directed = directed
def color_mapping(index: int, node: Dict):
if 'color' in node:
return node['color']
return '#17bebb' # default
w.set_node_color_mapping(color_mapping)
w.set_edge_color_mapping(color_mapping)
return w | yworks-helper | /yworks-helper-0.1.9.tar.gz/yworks-helper-0.1.9/yworks_helper/core/bp/generate_graph_widget.py | generate_graph_widget.py |
# Yate Wรคhlsystem Digital
Ywsd is a telephone number routing engine for the [Yate](http://Yate.ro/) telephone engine to be used in event
telephone networks. It provides the routing backend for common PBX features such as group calls (including delayed
ringing and hunting groups), (conditional) call forwarding, caller verification or caller masquerading. The main design
goal of this backend to provide as much flexibility for call routing as possible while ensuring a certain set of
consistency conditions. To split the phone network into multiple failure domains or also allow for load
balancing, Ywsd is designed to support a PBX that consists of multiple Yate servers. Routing information is (globally)
stored in a PostgreSQL database that enforces consistency of basic participant properties and the links between
extensions (groups, forwards, etcโฆ).
Based on this consistent data model, the routing offers all kinds of degrees of freedom. There is no principle
limitation on nesting call groups or mixing groups with call forwards as needed. Extensions that are external to the
PBX can be added with a placeholder extension entry and also participate in groups and forwards. Still, the engine will
ensure that created calls do not create call loops and phones cannot be called from the same call more than once.
If you don't want to know the details, just [jump to the setup guide](#Getting-started)
## Basic Architecture
Ywsd based routing is split into two stages. Routing stage 1 calculates all extensions that are involved in a call
as well as their relation (groups, forwards, delays, etcโฆ). It does not resolve the call to SIP addresses of the
individual participant but only goes so far as to know on which SIP server the participant should be registered and
will route calls to this SIP server.
Routing 2 then takes care of the information which devices registered for a SIP extension. It supports multiple
device registrations per extensions and configurable call waiting support per extension.
## Stage1 Architecture
Routing is illustrated as a tree in ywsd. An extension is a leaf in such a tree if it can be immediately routed.
That is, it corresponds to a physical extension, has no forwards or other devices that should ring when a call
is routed to it. Otherwise, an extension is an inner node. This is most visible for call groups. They have all
call group members as children in the routing tree and don't correspond to a device themselves. The routing, however,
also supports a mixed-mode (called multi-ring) where an extension has a physical device and behaves like a call group at
the same time. This is used to, e.g., configure desktop SIP phone to also ring when your DECT is ringing.
Extensions can also become inner tree nodes if they forward to another extension. This can also lead to a situation
where this extension won't be called anymore (immediate forward) or will be called for a while and only then the
forward will be activated (delayed forward). The routing engine also supports forward on busy or forward on unavailable.
One might think that routing can and should rather be represented as DAG than as tree. In particular, if two nested
groups have the same member, shouldn't those be merged?. Unfortunately, call routing has unpredictable timing
behaviour. Depending on hunt group or delayed ring configuration it is not possible to consider all scenarios statically
while routing as the final behaviour can depend on which devices are currently active and/or busy. Thus, ywsd keeps the
tree representation and has additional measures to ensure devices don't ring twice on the same call at runtime.
### Tree Discovery
The final routing result is computed in two big steps. The first step called **tree discovery** retrieves the routing
tree node by node from the database. While walking along the tree, it ensures that no loops are created and disables
branches that would lead to a loop. It also decides in which direction the tree is expanded. For example, the members
of a group that have an active immediate forward are not loaded.
#### Groups and call forks
The implementation of call groups follows closely Yate's CallFork module. A fork may have multiple ranks. Each rank
represents a set of extensions that is called at the same time. The ranks are ordered. Each rank can either extend
the current call of the previous rank after a given time or replace all participants called in the previous rank(s).
Consequently, inner tree nodes can link immediately to another extension (with forwards) or a fork rank that
(itself) then links to extensions. The following examples illustrate the shape of call routing trees.
This shows a simple routing tree in which the extension 1010 calls the group 1011. This group has four participants.
These are the extensions 1002, 1004, 1005 and 1001. The user with extension 1001 has currently paused their membership
and was thus discovered but will not be considered in the generated call.
This is a more involved example of a routing tree that features groups with multiple and non-default fork ranks,
nested groups and a call forward from user 1001 to 1006. It illustrates no particular use case but should rather
serve as an example of how generic and complex routing trees might look like.
### Route Generation
The second routing step is called **route generation**. It uses a Visitor pattern to walk along the previously
calculated routing tree and generates an intermediate routing result for each inner node based on the intermediate
routing results of its children. So, the route generation process is bottom-up. The basic idea is that every inner node
of the routing tree will lead to a Yate call fork. The fork will contain all children of the respective tree node.
If the child can be routed immediately, this is then a reference to the sip module with a reference to which SIP server
to call. If the target is locally on the same Yate, it will just issue a `lateroute/` for the extension with a flag to
forward this to routing stage 2.
If the child is again an inner node, the call target is symbolic and of the form `lateroute/stage1-<callid>-<treepath>`.
To ensure consistency in the routing, all intermediate routing results will be cached after the initial routing
was completely calculated. Once the call progresses, Yate's lateroute module will query the routing engine again for the
symbolic names of the inner nodes. These requests will then be answered from the cache.
Altogether, this approach gives maximum flexibility and also allows for constructs that a single call fork would not
be able to provide. E.g., a single call fork is unable to provide forward on busy for one participant while
implementing delayed ringing for another. This is only possible by letting the forks follow the structure of the routing
tree.
## Stage2 Architecture
Stage 2 routing is relatively simple and dumb (compared to Stage 1). It is based on a simple user and registration
table in the database. In addition to this, Yate's register module is used to maintain a list of currently registered
SIP devices per extension in the registration table.
Stage 2 routing is either triggered by the flag *eventphone_stage2* in the `call.route` message (put there by
routing stage 1) or automatically triggered if a call is coming from a specific SIP listener. In our multi Yate PBX
setup, we use one network with special SIP listeners that exchanges all calls between the different Yate instances
of our PBX. Such calls from another Yate in our PBX where stage1-routed on their home Yate.
They only need stage 2 at this point.
The main job of stage 2 routing is to forward the call to the actual SIP extension. If there is only a single
registration, the sip module will be immediately called with the registered SIP endpoint. If there are multiple
devices registered, one last simple and flat call fork with all the registered SIP endpoints will be issued.
In addition to this, stage2 uses the cdrbuild module to keep track of calls that are currently active at an extension.
It tracks the number of calls currently active on a device as well as the callids (uuid4). Call id tracking is used to
ensure that a single call does not lead to a device ringing twice on the same call. The duplicate call is filtered here.
The number of active calls is used to signal busy if call waiting is deactivated for the extension. If call waiting is
active, the extension will be called independent of whether the line is currently busy or not.
So please note that stage2 needs a particular configuration of the `cdrbuild` and `register` module in Yate to
work correctly. See instructions below.
### Static target routing
Stage2 routing also supports static routing targets in addition to regular SIP users. Static routing targets can
be used to dynamically configure extensions that are not a SIP client but rather a special yate call target like
`conf/` or (most prominently) `external/`. In order to use static call routing, create an entry in the `users` table
of stage2 routing with `type` being `static` instead of (the default) `user`. Put the yate call target into
`static_target`. You may use the syntax
```
external/nodata//opt/script.tcl arg1 arg2;myparam=myvalue;โฆ
```
to popuate the semicolon separated `key=value` pairs into the `call.route`/`call.execute` message.
## Getting started
Ywsd uses a PostgeSQL database backend that is accessed via the asyncio aiopg module. As a consequence, a minimal test
setup needs a Postgres database and all python packages from requirements.txt installed. For production deployments,
cached routing results should be stored in a Redis instance. For development purposes, the simple python built-in
dictionary-based cache suffices.
Next, a `routing_engine.yaml` configuration file needs to be created. You can see the example file that ships with this
repository to get a feeling of how it could look like.
Once the configuration is complete, the database can be setup. Run `ywsd_init_db --config <your_config> --stage1` to
bootstrap the stage1 routing database. Then run `ywsd_init_db --config <your_config> --stage2` to bootstrap the stage2
routing database.
In principle, your ywsd instance is now ready to go. To actually route something, for sure, the database
needs to be populated with extensions.
If you want to test ywsd without a running Yate, you may use the webserver only mode. Start ywsd with
```
ywsd_engine --config <your_config> --web-only
```
Ywsd then starts without connecting to a Yate and just offers the webserver on the configured interface/port. You can
then ask for a sample routing and will get the results in JSON form. Depending on your test data, results can look
like this:
```
curl http://localhost:9000/stage1\?caller\=2001\&called\=4711 | jq .
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 172 100 172 0 0 24571 0 --:--:-- --:--:-- --:--:-- 24571
{
"routing_tree": null,
"main_routing_result": null,
"all_routing_results": {},
"routing_status": "ERROR",
"routing_status_details": "noroute: Routing target was not found"
curl http://localhost:9000/stage1\?caller\=2001\&called\=2000 | jq .
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 3550 100 3550 0 0 247k 0 --:--:-- --:--:-- --:--:-- 247k
{
"routing_tree": {
"id": 1,
"yate_id": null,
"extension": "2000",
"name": "PoC",
"short_name": null,
"outgoing_extension": null,
"outgoing_name": null,
"dialout_allowed": false,
"ringback": null,
"forwarding_delay": null,
"forwarding_extension_id": null,
"lang": "de_DE",
"type": "Type.GROUP",
"forwarding_mode": "ForwardingMode.DISABLED",
"tree_identifier": "1",
"logs": [],
"fork_ranks": [
{
"id": 1,
"extension_id": 1,
"index": 0,
"delay": null,
"mode": "Mode.DEFAULT",
"tree_identifier": "1-fr1",
"logs": [
{
"msg": "Discovery aborted for <Extension 2001, name=PoC Sascha, type=Type.MULTIRING> in <ForkRank id=1, extension_id=1, index=Mode.DEFAULT, mode=0, delay=Mode.DEFAULT>, was already present.\nTemporarily disable membership for this routing.",
"level": "WARN",
"related_node": "1-fr1-2"
}
],
"members": [
{
"type": "RankMemberType.DEFAULT",
"active": false,
"extension": {
"id": 2,
"yate_id": 2,
"extension": "2001",
"name": "PoC Sascha",
"short_name": null,
"outgoing_extension": null,
"outgoing_name": null,
"dialout_allowed": false,
"ringback": null,
"forwarding_delay": null,
"forwarding_extension_id": null,
"lang": "de_DE",
"type": "Type.MULTIRING",
"forwarding_mode": "ForwardingMode.DISABLED",
"tree_identifier": "1-fr1-2",
"logs": []
}
},
{
"type": "RankMemberType.DEFAULT",
"active": true,
"extension": {
"id": 3,
"yate_id": 2,
"extension": "2002",
"name": "PoC Bernie",
"short_name": null,
"outgoing_extension": null,
"outgoing_name": null,
"dialout_allowed": false,
"ringback": null,
"forwarding_delay": null,
"forwarding_extension_id": null,
"lang": "de_DE",
"type": "Type.SIMPLE",
"forwarding_mode": "ForwardingMode.DISABLED",
"tree_identifier": "1-fr1-3",
"logs": []
}
},
{
"type": "RankMemberType.DEFAULT",
"active": true,
"extension": {
"id": 4,
"yate_id": 2,
"extension": "2004",
"name": "PoC BeF",
"short_name": null,
"outgoing_extension": null,
"outgoing_name": null,
"dialout_allowed": false,
"ringback": null,
"forwarding_delay": null,
"forwarding_extension_id": null,
"lang": "de_DE",
"type": "Type.SIMPLE",
"forwarding_mode": "ForwardingMode.DISABLED",
"tree_identifier": "1-fr1-4",
"logs": []
}
},
{
"type": "RankMemberType.DEFAULT",
"active": true,
"extension": {
"id": 6,
"yate_id": 2,
"extension": "2042",
"name": "PoC Garwin",
"short_name": null,
"outgoing_extension": null,
"outgoing_name": null,
"dialout_allowed": false,
"ringback": null,
"forwarding_delay": null,
"forwarding_extension_id": null,
"lang": "de_DE",
"type": "Type.SIMPLE",
"forwarding_mode": "ForwardingMode.DISABLED",
"tree_identifier": "1-fr1-6",
"logs": []
}
}
]
}
]
},
"main_routing_result": {
"type": "Type.FORK",
"target": {
"target": "lateroute/stage1-d4490817a7954559ac801f81f3dbbd7e-1",
"parameters": {
"x_eventphone_id": "d4490817a7954559ac801f81f3dbbd7e",
"osip_X-Eventphone-Id": "d4490817a7954559ac801f81f3dbbd7e",
"callername": "PoC Sascha",
"osip_X-Caller-Language": "de_DE",
"calledname": "PoC"
}
},
"fork_targets": [
{
"target": "lateroute/2002",
"parameters": {
"eventphone_stage2": "1",
"x_eventphone_id": "d4490817a7954559ac801f81f3dbbd7e",
"osip_X-Eventphone-Id": "d4490817a7954559ac801f81f3dbbd7e"
}
},
{
"target": "lateroute/2004",
"parameters": {
"eventphone_stage2": "1",
"x_eventphone_id": "d4490817a7954559ac801f81f3dbbd7e",
"osip_X-Eventphone-Id": "d4490817a7954559ac801f81f3dbbd7e"
}
},
{
"target": "lateroute/2042",
"parameters": {
"eventphone_stage2": "1",
"x_eventphone_id": "d4490817a7954559ac801f81f3dbbd7e",
"osip_X-Eventphone-Id": "d4490817a7954559ac801f81f3dbbd7e"
}
}
]
},
"all_routing_results": {},
"routing_status": "OK",
"routing_status_details": ""
}
```
## Necessary Yate configuration to make it run
The Yate modules `register` and `cdrbuild` provide partial functionality to stage2 ywsd-based routing. In particular,
the register module is used to manage registrations of SIP clients in the stage2 database. The cdrbuild module keeps
track of the calls on a certain SIP client and fills the stage2 database with information that is needed to provide
deny-on-busy or filtering if a single call ends up twice with one SIP client.
The following configuration is needed in these modules to provide the desired functionality. Please also note
that Yate needs to be compiled and configured to use Postgres database via the `pgsqldb` module.
Example register.conf:
```
[general]
expires=30
user.auth=yes
user.register=yes
user.unregister=yes
engine.timer=yes
;call.preroute=no
call.cdr=yes
linetracker=yes
[default]
priority=10
account=default
[user.auth]
query=SELECT password FROM users WHERE username='${username}' AND password IS NOT NULL AND password<>'' AND type='user' LIMIT 1;
result=password
[user.register]
query=INSERT INTO registrations (username, location, oconnection_id, expires) VALUES ('${username}', '${data}', '${oconnection_id}', NOW() + INTERVAL '${expires} s') ON CONFLICT ON CONSTRAINT uniq_registrations DO UPDATE SET expires = NOW() + INTERVAL '${expires} s'
[user.unregister]
query=DELETE FROM registrations WHERE (username = '${username}' AND location = '${data}' AND oconnection_id = '${connection_id}') OR ('${username}' = '' AND '${data}' = '' AND oconnection_id = '${connection_id}')
[engine.timer]
query=DELETE FROM registrations WHERE expires<=CURRENT_TIMESTAMP;
[call.cdr]
critical=no
[linetracker]
critical=yes
initquery=UPDATE users SET inuse=0 WHERE inuse is not NULL;DELETE from active_calls;
cdr_initialize=UPDATE users SET inuse=inuse+1 WHERE username='${external}';INSERT INTO active_calls SELECT username, x_eventphone_id FROM (SELECT '${external}' as username, '${X-Eventphone-Id}' as x_eventphone_id, '${direction}' as direction) as active_call WHERE x_eventphone_id != '' AND x_eventphone_id IS NOT NULL and direction = 'outgoing';
cdr_finalize=UPDATE users SET inuse=(CASE WHEN inuse>0 THEN inuse-1 ELSE 0 END) WHERE username='${external}';DELETE FROM active_calls WHERE username = '${external}' AND x_eventphone_id = '${X-Eventphone-Id}' AND '${direction}' = 'outgoing';
```
To enable duplicate call filtering, the parameters section of your cdrbuild.conf should have a line for
X-Eventphone-Id like this
```
[parameters]
X-Eventphone-Id=false
```
## Project ToDos
There are currently no tests available for this project. There is a basic set of test data that was used during
development and integration with Yate but no automatic testing was developed so far. Due to the nature of this
project, it plans to add a suite of end-to-end functionality tests based on the webserver exposure of routing
results. An extensive set of unit tests for DB loading or data structure generation is currently not planned
but would be welcomed if contributed.
| ywsd | /ywsd-0.13.1.tar.gz/ywsd-0.13.1/README.md | README.md |
import time
import numpy as np
from dumpy.optimizers import *
from dumpy.utils import get_activation_function
class Model():
def __init__(self,nn_architecture,initializer='random'):
np.random.seed(42)
self.nn_architecture = nn_architecture
self.parameters = dict()
self.memory = dict()
for idx,layer in enumerate(self.nn_architecture):
layer_idx = idx + 1
if initializer == 'random':
self.parameters[f"W{layer_idx}"] = np.random.randn(layer['output_dim'],layer['input_dim']) * np.sqrt(1. / layer['input_dim'])
self.parameters[f"b{layer_idx}"] = np.random.randn(layer['output_dim'],1) * np.sqrt(1. / layer['input_dim'])
elif initializer == 'xavier':
l = np.sqrt(6.0 / (layer['output_dim'] +layer['input_dim']))
self.parameters[f"W{layer_idx}"] = np.random.uniform(-l,l,size=(layer['output_dim'],layer['input_dim']))
self.parameters[f"b{layer_idx}"] = np.random.uniform(-l,l,size=(layer['output_dim'],1))
else:
raise Exception(f"{initializer} is not a initializer options are 'random' and 'xavier' ")
def forward(self,xb):
self.memory = dict()
A_curr = xb
for idx, (layer) in enumerate(self.nn_architecture):
layer_idx = idx + 1
A_prev = A_curr
W_curr = self.parameters[f"W{layer_idx}"]
b_curr = self.parameters[f"b{layer_idx}"]
Z_curr = np.matmul(W_curr,A_prev) + b_curr
active_function = get_activation_function(layer['activation'])
A_curr = active_function(Z_curr)
self.memory[f"A{idx}"] = A_prev
self.memory[f"Z{layer_idx}"] = Z_curr
return A_curr
def train(X_train,y_train,X_test,y_test,nn_architecture,optim='sgd',initializer='random',lr=0.01,wd=0.01,momentum=0.9,beta1=0.9,beta2=0.99,epochs=500,batch_size=32,verbose=10,wandb_log=None):
def get_data_loader(X,y,batch_size,shuffle=False):
if shuffle:
permutation = np.random.permutation(X.shape[1])
X = X[:,permutation]
X = y[:,permutation]
for i in range(0,len(X),batch_size):
xb = X[:,i:i+batch_size]
yb = y[:,i:i+batch_size]
yield xb, yb
def compute_accuracy(outputs, targets):
return np.mean(np.argmax(targets,0)==np.argmax(outputs,0))
def compute_loss(targets,outputs):
L_sum = np.sum(np.multiply(targets, np.log(outputs)))
m = targets.shape[1]
L = -(1/m) * L_sum
return L
def one_hot(Y):
one_hot_Y = np.zeros((Y.size, Y.max() + 1))
one_hot_Y[np.arange(Y.size), Y] = 1
return one_hot_Y
X_train = X_train.T
X_test = X_test.T
y_train = one_hot(y_train).T
y_test = one_hot(y_test).T
model = Model(nn_architecture,initializer=initializer)
optimizers = {"sgd":SGD,
"nag":NAG,
"rmsprop":RMSprop,
"adam":Adam,
"nadam":NAdam}
if optimizers.get(optim):
if optim == 'adam' or optim == 'nadam':
optimizer = optimizers.get(optim)(lr = lr,wd=wd,beta1=beta1,beta2=beta2)
else:
optimizer = optimizers.get(optim)(lr = lr,wd=wd,momentum=momentum)
else:
raise Exception(f"{optim} is not a optimizer: options are 'sgd', 'nag','adagrad', 'adam', 'nadam' ")
best_acc = 0.0
for e in range(epochs):
train_dl = get_data_loader(X_train,y_train,batch_size=32)
start = time.time()
for i,(inputs,targets) in enumerate(train_dl):
outputs = model.forward(inputs)
model = optimizer.backward(model,targets,outputs)
train_outputs = model.forward(X_train)
train_acc = compute_accuracy(train_outputs,y_train)
train_loss = compute_loss(y_train,train_outputs)
test_outputs = model.forward(X_test)
test_acc = compute_accuracy(test_outputs,y_test)
test_loss = compute_loss(y_test,test_outputs)
epoch_time = time.time() - start
if wandb_log:
wandb_log.log({"Train loss":train_loss,'Train acc':train_acc,"Test loss":test_loss,'Test acc':test_acc})
if e % verbose == 0:
print(f"Iteration {e} : Train Accuracy: {train_acc:.3f} | Train Loss: {train_loss:.3f} | Test Accuracy: {test_acc:.3f} | Test Loss: {test_loss:.3f} | Epoch Time: {epoch_time:.2f}s")
return model | ywxb | /ywxb-0.0.1.tar.gz/ywxb-0.0.1/dumpy/train.py | train.py |
import numpy as np
from dumpy.utils import get_activation_function
class SGD():
def __init__(self,lr=0.01,wd=0.01,momentum= 0.9):
self.lr = lr
self.momentum = momentum
self.wd = wd
self.model = None
self.grads_values = {}
self.grads_values['w_sum'] = 0.0
def backward(self,model,targets,outputs):
self.model = model
nn_architecture = self.model.nn_architecture
parameters = self.model.parameters
memory = self.model.memory
dA_prev = 2*(outputs - targets)/outputs.shape[1] + self.wd * self.grads_values['w_sum']
for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):
layer_idx_curr = layer_idx_prev + 1
dA_curr = dA_prev
self.grads_values['w_sum'] += np.sum(parameters[f"W{layer_idx_curr}"]**2)
self.grads_values[f"dW_prev{layer_idx_curr}"] = self.grads_values[f"dW{layer_idx_curr}"] if (type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray) else 0.0
self.grads_values[f"db_prev{layer_idx_curr}"] = self.grads_values[f"db{layer_idx_curr}"] if (type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray) else 0.0
A_prev = memory[f"A{layer_idx_prev}"]
Z_curr = memory[f"Z{layer_idx_curr}"]
W_curr = parameters[f"W{layer_idx_curr}"]
b_curr = parameters[f"b{layer_idx_curr}"]
m = A_prev.shape[1]
backward_activation_func = get_activation_function(layer['activation'],backward=True)
dZ_curr = backward_activation_func(dA_curr, Z_curr)
dW_curr = (1. / m) * np.matmul(dZ_curr, A_prev.T)
db_curr = (1. / m) * np.sum(dZ_curr, axis=1, keepdims=True)
dA_prev = np.matmul(W_curr.T, dZ_curr)
self.grads_values[f"dW{layer_idx_curr}"] = dW_curr
self.grads_values[f"db{layer_idx_curr}"] = db_curr
self.grads_values['w_sum'] = 0.0
for idx, layer in enumerate(nn_architecture):
layer_idx = idx + 1
self.grads_values[f"dW{layer_idx}"] = self.grads_values[f"dW_prev{layer_idx}"] * self.momentum + self.lr * self.grads_values[f"dW{layer_idx}"]
self.grads_values[f"db{layer_idx}"] = self.grads_values[f"db_prev{layer_idx}"] * self.momentum + self.lr * self.grads_values[f"db{layer_idx}"]
parameters[f"W{layer_idx}"] -= self.grads_values[f"dW{layer_idx}"]
parameters[f"b{layer_idx}"] -= self.grads_values[f"db{layer_idx}"]
self.model.parameters = parameters
return self.model
class NAG():
def __init__(self,lr=0.01,wd=0.01,momentum= 0.9):
self.lr = lr
self.momentum = momentum
self.model = None
self.wd = wd
self.grads_values = {}
self.grads_values['w_sum'] = 0.0
def backward(self,model,targets,outputs):
self.model = model
nn_architecture = self.model.nn_architecture
parameters = self.model.parameters
memory = self.model.memory
dA_prev = 2*(outputs - targets)/outputs.shape[1] + self.wd * self.grads_values['w_sum']
for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):
layer_idx_curr = layer_idx_prev + 1
dA_curr = dA_prev
self.grads_values['w_sum'] += np.sum(parameters[f"W{layer_idx_curr}"]**2)
self.grads_values[f"dW_prev{layer_idx_curr}"] = self.grads_values[f"dW{layer_idx_curr}"] if (type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray) else 0.0
self.grads_values[f"db_prev{layer_idx_curr}"] = self.grads_values[f"db{layer_idx_curr}"] if (type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray) else 0.0
A_prev = memory[f"A{layer_idx_prev}"]
Z_curr = memory[f"Z{layer_idx_curr}"]
W_curr = parameters[f"W{layer_idx_curr}"] - self.momentum * self.grads_values[f"dW_prev{layer_idx_curr}"]
b_curr = parameters[f"b{layer_idx_curr}"] - self.momentum * self.grads_values[f"db_prev{layer_idx_curr}"]
m = A_prev.shape[1]
backward_activation_func = get_activation_function(layer['activation'],backward=True)
dZ_curr = backward_activation_func(dA_curr, Z_curr)
dW_curr = (1. / m) * np.matmul(dZ_curr, A_prev.T)
db_curr = (1. / m) * np.sum(dZ_curr, axis=1, keepdims=True)
dA_prev = np.matmul(W_curr.T, dZ_curr)
self.grads_values[f"dW{layer_idx_curr}"] = dW_curr
self.grads_values[f"db{layer_idx_curr}"] = db_curr
self.grads_values['w_sum'] = 0.0
for idx, layer in enumerate(nn_architecture):
layer_idx = idx + 1
self.grads_values[f"dW{layer_idx}"] = self.grads_values[f"dW_prev{layer_idx}"] * self.momentum + self.lr * self.grads_values[f"dW{layer_idx}"]
self.grads_values[f"db{layer_idx}"] = self.grads_values[f"db_prev{layer_idx}"] * self.momentum + self.lr * self.grads_values[f"db{layer_idx}"]
parameters[f"W{layer_idx}"] -= self.grads_values[f"dW{layer_idx}"]
parameters[f"b{layer_idx}"] -= self.grads_values[f"db{layer_idx}"]
self.model.parameters = parameters
return self.model
class Adagrad():
def __init__(self,lr=0.01,momentum= 0.9):
self.lr = lr
self.model = None
self.grads_values = {}
def backward(self,model,targets,outputs):
self.model = model
nn_architecture = self.model.nn_architecture
parameters = self.model.parameters
memory = self.model.memory
dA_prev = 2*(outputs - targets)/outputs.shape[1]
for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):
layer_idx_curr = layer_idx_prev + 1
dA_curr = dA_prev
if type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"dW_square{layer_idx_curr}"] += self.grads_values[f"dW{layer_idx_curr}"]**2
else:
self.grads_values[f"dW_square{layer_idx_curr}"] = 1.0
if type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"db_square{layer_idx_curr}"] += self.grads_values[f"db{layer_idx_curr}"]**2
else:
self.grads_values[f"db_square{layer_idx_curr}"] = 1.0
A_prev = memory[f"A{layer_idx_prev}"]
Z_curr = memory[f"Z{layer_idx_curr}"]
W_curr = parameters[f"W{layer_idx_curr}"]
b_curr = parameters[f"b{layer_idx_curr}"]
m = A_prev.shape[1]
backward_activation_func = get_activation_function(layer['activation'],backward=True)
dZ_curr = backward_activation_func(dA_curr, Z_curr)
dW_curr = (1. / m) * np.matmul(dZ_curr, A_prev.T)
db_curr = (1. / m) * np.sum(dZ_curr, axis=1, keepdims=True)
dA_prev = np.matmul(W_curr.T, dZ_curr)
self.grads_values[f"dW{layer_idx_curr}"] = dW_curr
self.grads_values[f"db{layer_idx_curr}"] = db_curr
for idx, layer in enumerate(nn_architecture):
layer_idx = idx +1
parameters[f"W{layer_idx}"] -= (self.lr/np.sqrt(self.grads_values[f"dW_square{layer_idx}"]+1e-8)) * self.grads_values[f"dW{layer_idx}"]
parameters[f"b{layer_idx}"] -= (self.lr/np.sqrt(self.grads_values[f"db_square{layer_idx}"]+1e-8)) * self.grads_values[f"db{layer_idx}"]
self.model.parameters = parameters
return self.model
class RMSprop():
def __init__(self,lr=0.01,wd= 0.01,momentum=0.9):
self.lr = lr
self.wd = wd
self.model = None
self.momentum = momentum
self.grads_values = {}
self.grads_values['w_sum'] = 0.0
def backward(self,model,targets,outputs):
self.model = model
nn_architecture = self.model.nn_architecture
parameters = self.model.parameters
memory = self.model.memory
dA_prev = 2*(outputs - targets)/outputs.shape[1] + self.wd *self.grads_values['w_sum']
for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):
layer_idx_curr = layer_idx_prev + 1
dA_curr = dA_prev
self.grads_values['w_sum'] += np.sum(parameters[f"W{layer_idx_curr}"]**2)
if type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"dW_square{layer_idx_curr}"] = self.momentum * self.grads_values[f"dW_square{layer_idx_curr}"] + (self.grads_values[f"dW{layer_idx_curr}"]**2)
else:
self.grads_values[f"dW_square{layer_idx_curr}"] = 1.0
if type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"db_square{layer_idx_curr}"] = self.momentum * self.grads_values[f"db_square{layer_idx_curr}"] + (1.0 - self.momentum) * (self.grads_values[f"db{layer_idx_curr}"]**2)
else:
self.grads_values[f"db_square{layer_idx_curr}"] = 1.0
A_prev = memory[f"A{layer_idx_prev}"]
Z_curr = memory[f"Z{layer_idx_curr}"]
W_curr = parameters[f"W{layer_idx_curr}"]
b_curr = parameters[f"b{layer_idx_curr}"]
m = A_prev.shape[1]
backward_activation_func = get_activation_function(layer['activation'],backward=True)
dZ_curr = backward_activation_func(dA_curr, Z_curr)
dW_curr = (1. / m) * np.matmul(dZ_curr, A_prev.T)
db_curr = (1. / m) * np.sum(dZ_curr, axis=1, keepdims=True)
dA_prev = np.matmul(W_curr.T, dZ_curr)
self.grads_values[f"dW{layer_idx_curr}"] = dW_curr
self.grads_values[f"db{layer_idx_curr}"] = db_curr
self.grads_values['w_sum'] = 0.0
for idx, layer in enumerate(nn_architecture):
layer_idx = idx +1
self.grads_values[f'dW{layer_idx}'] = self.lr/np.sqrt(self.grads_values[f"dW_square{layer_idx}"]+1e-8) * self.grads_values[f"dW{layer_idx}"]
self.grads_values[f'db{layer_idx}'] = self.lr/np.sqrt(self.grads_values[f"db_square{layer_idx}"]+1e-8) * self.grads_values[f"db{layer_idx}"]
parameters[f"W{layer_idx}"] -= self.lr * self.grads_values[f"dW{layer_idx}"]
parameters[f"b{layer_idx}"] -= self.lr * self.grads_values[f"db{layer_idx}"]
self.model.parameters = parameters
return self.model
class Adam():
def __init__(self,lr=0.01,wd=0.01,beta1=0.9,beta2=0.999):
self.lr = lr
self.wd = wd
self.model = None
self.grads_values = {}
self.beta1 = beta1
self.beta2 = beta2
self.grads_values['w_sum'] = 0.0
def backward(self,model,targets,outputs):
self.model = model
nn_architecture = self.model.nn_architecture
parameters = self.model.parameters
memory = self.model.memory
dA_prev = 2*(outputs - targets)/outputs.shape[1] + self.wd *self.grads_values['w_sum']
for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):
layer_idx_curr = layer_idx_prev + 1
dA_curr = dA_prev
self.grads_values['w_sum'] += np.sum(parameters[f"W{layer_idx_curr}"]**2)
if type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"dW_sum{layer_idx_curr}"] += self.grads_values[f"dW{layer_idx_curr}"]
else:
self.grads_values[f"dW_sum{layer_idx_curr}"] = 0.0
if type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"db_sum{layer_idx_curr}"] += self.grads_values[f"db{layer_idx_curr}"]
else:
self.grads_values[f"db_sum{layer_idx_curr}"] = 0.0
if type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray:
vw_curr = self.beta2 * self.grads_values[f"dW_square{layer_idx_curr}"] + (1.0) * self.grads_values[f"dW{layer_idx_curr}"]**2
self.grads_values[f"dW_square{layer_idx_curr}"] = vw_curr
else:
self.grads_values[f"dW_square{layer_idx_curr}"] = 1.0
if type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray:
vb_curr = self.beta2 * self.grads_values[f"db_square{layer_idx_curr}"] + (1.0) * self.grads_values[f"db{layer_idx_curr}"]**2
self.grads_values[f"db_square{layer_idx_curr}"] = vb_curr
else:
self.grads_values[f"db_square{layer_idx_curr}"] = 1.0
if self.grads_values.get("beta1"):
self.grads_values["beta1"] *= self.beta1
else:
self.grads_values["beta1"] = self.beta1
if self.grads_values.get("beta2"):
self.grads_values["beta2"] *= self.beta2
else:
self.grads_values["beta2"] = self.beta2
A_prev = memory[f"A{layer_idx_prev}"]
Z_curr = memory[f"Z{layer_idx_curr}"]
W_curr = parameters[f"W{layer_idx_curr}"]
b_curr = parameters[f"b{layer_idx_curr}"]
m = A_prev.shape[1]
backward_activation_func = get_activation_function(layer['activation'],backward=True)
dZ_curr = backward_activation_func(dA_curr, Z_curr)
dW_curr = (1. / m) * np.matmul(dZ_curr, A_prev.T)
db_curr = (1. / m) * np.sum(dZ_curr, axis=1, keepdims=True)
dA_prev = np.matmul(W_curr.T, dZ_curr)
mw_curr = self.beta1 * self.grads_values[f"dW_sum{layer_idx_curr}"] + dW_curr
mb_curr = self.beta1 * self.grads_values[f"db_sum{layer_idx_curr}"] + db_curr
self.grads_values[f"dW{layer_idx_curr}"] = dW_curr
self.grads_values[f"db{layer_idx_curr}"] = db_curr
self.grads_values['w_sum'] = 0.0
for idx, layer in enumerate(nn_architecture):
layer_idx = idx +1
vtw_curr = self.grads_values[f"dW_square{layer_idx}"] / (1.0 - self.grads_values['beta2'])
vtb_curr = self.grads_values[f"db_square{layer_idx}"] / (1.0 - self.grads_values['beta2'])
mtw_curr = self.grads_values[f"dW{layer_idx}"] / (1.0 - self.grads_values['beta1'])
mtb_curr = self.grads_values[f"db{layer_idx}"] / (1.0 - self.grads_values['beta1'])
parameters[f"W{layer_idx}"] -= self.lr/(np.sqrt(vtw_curr) + 1e-8) * mtw_curr
parameters[f"b{layer_idx}"] -= self.lr/(np.sqrt(vtb_curr) + 1e-8) * mtb_curr
self.model.parameters = parameters
return self.model
class NAdam():
def __init__(self,lr=0.01,wd=0.01,beta1=0.9,beta2=0.999):
self.lr = lr
self.wd = wd
self.model = None
self.grads_values = {}
self.beta1 = beta1
self.beta2 = beta2
self.grads_values['w_sum'] = 0.0
def backward(self,model,targets,outputs):
self.model = model
nn_architecture = self.model.nn_architecture
parameters = self.model.parameters
memory = self.model.memory
dA_prev = 2*(outputs - targets)/outputs.shape[1] + self.wd *self.grads_values['w_sum']
for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):
layer_idx_curr = layer_idx_prev + 1
dA_curr = dA_prev
self.grads_values['w_sum'] += np.sum(parameters[f"W{layer_idx_curr}"]**2)
if type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"dW_sum{layer_idx_curr}"] += self.grads_values[f"dW{layer_idx_curr}"]
else:
self.grads_values[f"dW_sum{layer_idx_curr}"] = 0.0
if type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray:
self.grads_values[f"db_sum{layer_idx_curr}"] += self.grads_values[f"db{layer_idx_curr}"]
else:
self.grads_values[f"db_sum{layer_idx_curr}"] = 0.0
if type(self.grads_values.get(f"dW{layer_idx_curr}")) == np.ndarray:
vw_curr = self.beta2 * self.grads_values[f"dW_square{layer_idx_curr}"] + (1.0) * self.grads_values[f"dW{layer_idx_curr}"]**2
self.grads_values[f"dW_square{layer_idx_curr}"] = vw_curr
else:
self.grads_values[f"dW_square{layer_idx_curr}"] = 1.0
if type(self.grads_values.get(f"db{layer_idx_curr}")) == np.ndarray:
vb_curr = self.beta2 * self.grads_values[f"db_square{layer_idx_curr}"] + (1.0) * self.grads_values[f"db{layer_idx_curr}"]**2
self.grads_values[f"db_square{layer_idx_curr}"] = vb_curr
else:
self.grads_values[f"db_square{layer_idx_curr}"] = 1.0
## beta
if self.grads_values.get("beta1"):
self.grads_values["beta1"] *= self.beta1
else:
self.grads_values["beta1"] = self.beta1
if self.grads_values.get("beta2"):
self.grads_values["beta2"] *= self.beta2
else:
self.grads_values["beta2"] = self.beta2
A_prev = memory[f"A{layer_idx_prev}"]
Z_curr = memory[f"Z{layer_idx_curr}"]
W_curr = parameters[f"W{layer_idx_curr}"]
b_curr = parameters[f"b{layer_idx_curr}"]
m = A_prev.shape[1]
backward_activation_func = get_activation_function(layer['activation'],backward=True)
dZ_curr = backward_activation_func(dA_curr, Z_curr)
dW_curr = (1. / m) * np.matmul(dZ_curr, A_prev.T)
db_curr = (1. / m) * np.sum(dZ_curr, axis=1, keepdims=True)
dA_prev = np.matmul(W_curr.T, dZ_curr)
mw_curr = self.beta1 * self.grads_values[f"dW_sum{layer_idx_curr}"] + (1.0 )* dW_curr
mb_curr = self.beta1 * self.grads_values[f"db_sum{layer_idx_curr}"] + (1.0 )* db_curr
self.grads_values[f"dW{layer_idx_curr}"] = dW_curr
self.grads_values[f"db{layer_idx_curr}"] = db_curr
self.grads_values['w_sum'] = 0.0
for idx, layer in enumerate(nn_architecture):
layer_idx = idx +1
vtw_curr = self.grads_values[f"dW_square{layer_idx}"] / (1.0 - self.grads_values['beta2'])
vtb_curr = self.grads_values[f"db_square{layer_idx}"] / (1.0 - self.grads_values['beta2'])
mtw_curr = self.grads_values[f"dW{layer_idx}"] / (1.0 - self.grads_values['beta1'])
mtb_curr = self.grads_values[f"db{layer_idx}"] / (1.0 - self.grads_values['beta1'])
parameters[f"W{layer_idx}"] -= self.lr/(np.sqrt(vtw_curr) + 1e-8) * (self.beta1 * mtw_curr + ((1-self.beta1) *\
self.grads_values[f"dW{layer_idx}"])/(1.0 - self.grads_values['beta1']))
parameters[f"b{layer_idx}"] -= self.lr/(np.sqrt(vtb_curr) + 1e-8) * (self.beta1 * mtb_curr + ((1-self.beta1) *\
self.grads_values[f"db{layer_idx}"])/(1.0 - self.grads_values['beta1']))
self.model.parameters = parameters
return self.model | ywxb | /ywxb-0.0.1.tar.gz/ywxb-0.0.1/dumpy/optimizers.py | optimizers.py |
## yxdb-py
yxdb-py is a library for reading YXDB files into Python.
install using `pip install yxdb`
The library does not have external dependencies and is a pure Python solution.
The public API is contained in the YxdbReader class. Instantiate YxdbReader with the following constructors:
* `YxdbReader(path=str)` - load from a file
* `YxdbReader(stream=BytesIO)` - load from an in-memory stream
Iterate through the records in the file using the `next()` method in a while loop:
```
while reader.next():
# do something
```
Fields can be access via the `read_index()` and `read_name()` methods on the YxdbReader class.
The list of fields in the YXDB file can be access via the `list_fields()` method.
| yxdb | /yxdb-0.0.4.tar.gz/yxdb-0.0.4/README.md | README.md |
OFFSTYLE="\x1b[38;5;246m"
EOA="\x1b[0m"
SEP0="\x1b[38;5;235mโ\x1b[0m"
SEP1="\x1b[38;5;235mโ\x1b[0m"
SEP2="\x1b[38;5;235mโ\x1b[0m"
template1 = """
import struct
import sys
import hashlib
def writeBin(b,h):
outfile = h + ".bin"
f = open(outfile,'wb')
f.write(b)
f.close()
print(outfile)
b = b\"\""""
template2 = """
m = hashlib.sha256()
m.update(b)
shorthash = m.digest().hex()[0:8]
writeBin(b,shorthash)
"""
cTemplate1 = """
#include <stdio.h>
#include <string.h>
"""
cTemplate2 = """
int main() {
printf("len:%d bytes\\n", strlen(code));
(*(void(*)()) code)();
return 0;
}
"""
# Bytes are individually styled, you can refer to this page for all the colors
# https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
bytez = {
0x00: "\x1b[38;5;240m",
0x01: "\x1b[38;5;219m",
0x02: "\x1b[38;5;219m",
0x03: "\x1b[38;5;219m",
0x04: "\x1b[38;5;219m",
0x05: "\x1b[38;5;219m",
0x06: "\x1b[38;5;219m",
0x07: "\x1b[38;5;219m",
0x08: "\x1b[38;5;219m",
0x09: "\x1b[38;5;219m",
0x0a: "\x1b[38;5;219m",
0x0b: "\x1b[38;5;219m",
0x0c: "\x1b[38;5;219m",
0x0d: "\x1b[38;5;219m",
0x0e: "\x1b[38;5;219m",
0x0f: "\x1b[38;5;219m",
0x10: "\x1b[38;5;219m",
0x11: "\x1b[38;5;219m",
0x12: "\x1b[38;5;219m",
0x13: "\x1b[38;5;219m",
0x14: "\x1b[38;5;219m",
0x15: "\x1b[38;5;219m",
0x16: "\x1b[38;5;219m",
0x17: "\x1b[38;5;219m",
0x18: "\x1b[38;5;219m",
0x19: "\x1b[38;5;219m",
0x1a: "\x1b[38;5;219m",
0x1b: "\x1b[38;5;219m",
0x1c: "\x1b[38;5;219m",
0x1d: "\x1b[38;5;219m",
0x1e: "\x1b[38;5;219m",
0x1f: "\x1b[38;5;219m",
# ASCII Symbols
0x20: "\x1b[38;5;27m",
0x21: "\x1b[38;5;27m",
0x22: "\x1b[38;5;27m",
0x23: "\x1b[38;5;27m",
0x24: "\x1b[38;5;27m",
0x25: "\x1b[38;5;27m",
0x26: "\x1b[38;5;27m",
0x27: "\x1b[38;5;27m",
0x28: "\x1b[38;5;27m",
0x29: "\x1b[38;5;27m",
0x2a: "\x1b[38;5;27m",
0x2b: "\x1b[38;5;27m",
0x2c: "\x1b[38;5;27m",
0x2d: "\x1b[38;5;27m",
0x2e: "\x1b[38;5;27m",
0x2f: "\x1b[38;5;27m",
# ASCII Numbers
0x30: "\x1b[38;5;81m",
0x31: "\x1b[38;5;81m",
0x32: "\x1b[38;5;81m",
0x33: "\x1b[38;5;81m",
0x34: "\x1b[38;5;81m",
0x35: "\x1b[38;5;81m",
0x36: "\x1b[38;5;81m",
0x37: "\x1b[38;5;81m",
0x38: "\x1b[38;5;81m",
0x39: "\x1b[38;5;81m",
# ASCII Symbols
0x3a: "\x1b[38;5;27m",
0x3b: "\x1b[38;5;27m",
0x3c: "\x1b[38;5;27m",
0x3d: "\x1b[38;5;27m",
0x3e: "\x1b[38;5;27m",
0x3f: "\x1b[38;5;27m",
0x40: "\x1b[38;5;27m",
# ASCII Capitals
0x41: "\x1b[38;5;39m",
0x42: "\x1b[38;5;39m",
0x43: "\x1b[38;5;39m",
0x44: "\x1b[38;5;39m",
0x45: "\x1b[38;5;39m",
0x46: "\x1b[38;5;39m",
0x47: "\x1b[38;5;39m",
0x48: "\x1b[38;5;39m",
0x49: "\x1b[38;5;39m",
0x4a: "\x1b[38;5;39m",
0x4b: "\x1b[38;5;39m",
0x4c: "\x1b[38;5;39m",
0x4d: "\x1b[38;5;39m",
0x4e: "\x1b[38;5;39m",
0x4f: "\x1b[38;5;39m",
0x50: "\x1b[38;5;39m",
0x51: "\x1b[38;5;39m",
0x52: "\x1b[38;5;39m",
0x53: "\x1b[38;5;39m",
0x54: "\x1b[38;5;39m",
0x55: "\x1b[38;5;39m",
0x56: "\x1b[38;5;39m",
0x57: "\x1b[38;5;39m",
0x58: "\x1b[38;5;39m",
0x59: "\x1b[38;5;39m",
0x5a: "\x1b[38;5;39m",
# ASCII Symbols
0x5b: "\x1b[38;5;27m",
0x5c: "\x1b[38;5;27m",
0x5d: "\x1b[38;5;27m",
0x5e: "\x1b[38;5;27m",
0x5f: "\x1b[38;5;27m",
0x60: "\x1b[38;5;27m",
# ASCII Lowercase
0x61: "\x1b[38;5;45m",
0x62: "\x1b[38;5;45m",
0x63: "\x1b[38;5;45m",
0x64: "\x1b[38;5;45m",
0x65: "\x1b[38;5;45m",
0x66: "\x1b[38;5;45m",
0x67: "\x1b[38;5;45m",
0x68: "\x1b[38;5;45m",
0x69: "\x1b[38;5;45m",
0x6a: "\x1b[38;5;45m",
0x6b: "\x1b[38;5;45m",
0x6c: "\x1b[38;5;45m",
0x6d: "\x1b[38;5;45m",
0x6e: "\x1b[38;5;45m",
0x6f: "\x1b[38;5;45m",
0x70: "\x1b[38;5;45m",
0x71: "\x1b[38;5;45m",
0x72: "\x1b[38;5;45m",
0x73: "\x1b[38;5;45m",
0x74: "\x1b[38;5;45m",
0x75: "\x1b[38;5;45m",
0x76: "\x1b[38;5;45m",
0x77: "\x1b[38;5;45m",
0x78: "\x1b[38;5;45m",
0x79: "\x1b[38;5;45m",
0x7a: "\x1b[38;5;45m",
# ASCII Symbols
0x7b: "\x1b[38;5;27m",
0x7c: "\x1b[38;5;27m",
0x7d: "\x1b[38;5;27m",
0x7e: "\x1b[38;5;27m",
# End of ascii
0x7f: "\x1b[38;5;88m",
0x80: "\x1b[38;5;208m",
0x81: "\x1b[38;5;226m",
0x82: "\x1b[38;5;226m",
0x83: "\x1b[38;5;226m",
0x84: "\x1b[38;5;226m",
0x85: "\x1b[38;5;226m",
0x86: "\x1b[38;5;226m",
0x87: "\x1b[38;5;226m",
0x88: "\x1b[38;5;226m",
0x89: "\x1b[38;5;226m",
0x8a: "\x1b[38;5;226m",
0x8b: "\x1b[38;5;226m",
0x8c: "\x1b[38;5;226m",
0x8d: "\x1b[38;5;226m",
0x8e: "\x1b[38;5;226m",
0x8f: "\x1b[38;5;226m",
0x90: "\x1b[38;5;208m",
0x91: "\x1b[38;5;226m",
0x92: "\x1b[38;5;226m",
0x93: "\x1b[38;5;226m",
0x94: "\x1b[38;5;226m",
0x95: "\x1b[38;5;226m",
0x96: "\x1b[38;5;226m",
0x97: "\x1b[38;5;226m",
0x98: "\x1b[38;5;226m",
0x99: "\x1b[38;5;226m",
0x9a: "\x1b[38;5;226m",
0x9b: "\x1b[38;5;226m",
0x9c: "\x1b[38;5;226m",
0x9d: "\x1b[38;5;226m",
0x9e: "\x1b[38;5;226m",
0x9f: "\x1b[38;5;226m",
0xa0: "\x1b[38;5;208m",
0xa1: "\x1b[38;5;226m",
0xa2: "\x1b[38;5;226m",
0xa3: "\x1b[38;5;226m",
0xa4: "\x1b[38;5;226m",
0xa5: "\x1b[38;5;226m",
0xa6: "\x1b[38;5;226m",
0xa7: "\x1b[38;5;226m",
0xa8: "\x1b[38;5;226m",
0xa9: "\x1b[38;5;226m",
0xaa: "\x1b[38;5;226m",
0xab: "\x1b[38;5;226m",
0xac: "\x1b[38;5;226m",
0xad: "\x1b[38;5;226m",
0xae: "\x1b[38;5;226m",
0xaf: "\x1b[38;5;226m",
0xb0: "\x1b[38;5;208m",
0xb1: "\x1b[38;5;226m",
0xb2: "\x1b[38;5;226m",
0xb3: "\x1b[38;5;226m",
0xb4: "\x1b[38;5;226m",
0xb5: "\x1b[38;5;226m",
0xb6: "\x1b[38;5;226m",
0xb7: "\x1b[38;5;226m",
0xb8: "\x1b[38;5;226m",
0xb9: "\x1b[38;5;226m",
0xba: "\x1b[38;5;226m",
0xbb: "\x1b[38;5;226m",
0xbc: "\x1b[38;5;226m",
0xbd: "\x1b[38;5;226m",
0xbe: "\x1b[38;5;226m",
0xbf: "\x1b[38;5;226m",
0xc0: "\x1b[38;5;208m",
0xc1: "\x1b[38;5;226m",
0xc2: "\x1b[38;5;226m",
0xc3: "\x1b[38;5;226m",
0xc4: "\x1b[38;5;226m",
0xc5: "\x1b[38;5;226m",
0xc6: "\x1b[38;5;226m",
0xc7: "\x1b[38;5;226m",
0xc8: "\x1b[38;5;226m",
0xc9: "\x1b[38;5;226m",
0xca: "\x1b[38;5;226m",
0xcb: "\x1b[38;5;226m",
0xcc: "\x1b[38;5;226m",
0xcd: "\x1b[38;5;226m",
0xce: "\x1b[38;5;226m",
0xcf: "\x1b[38;5;226m",
0xd0: "\x1b[38;5;208m",
0xd1: "\x1b[38;5;226m",
0xd2: "\x1b[38;5;226m",
0xd3: "\x1b[38;5;226m",
0xd4: "\x1b[38;5;226m",
0xd5: "\x1b[38;5;226m",
0xd6: "\x1b[38;5;226m",
0xd7: "\x1b[38;5;226m",
0xd8: "\x1b[38;5;226m",
0xd9: "\x1b[38;5;226m",
0xda: "\x1b[38;5;226m",
0xdb: "\x1b[38;5;226m",
0xdc: "\x1b[38;5;226m",
0xdd: "\x1b[38;5;226m",
0xde: "\x1b[38;5;226m",
0xdf: "\x1b[38;5;226m",
0xe0: "\x1b[38;5;208m",
0xe1: "\x1b[38;5;226m",
0xe2: "\x1b[38;5;226m",
0xe3: "\x1b[38;5;226m",
0xe4: "\x1b[38;5;226m",
0xe5: "\x1b[38;5;226m",
0xe6: "\x1b[38;5;226m",
0xe7: "\x1b[38;5;226m",
0xe8: "\x1b[38;5;226m",
0xe9: "\x1b[38;5;226m",
0xea: "\x1b[38;5;226m",
0xeb: "\x1b[38;5;226m",
0xec: "\x1b[38;5;226m",
0xed: "\x1b[38;5;226m",
0xee: "\x1b[38;5;226m",
0xef: "\x1b[38;5;226m",
0xf0: "\x1b[38;5;208m",
0xf1: "\x1b[38;5;91m",
0xf2: "\x1b[38;5;91m",
0xf3: "\x1b[38;5;91m",
0xf4: "\x1b[38;5;91m",
0xf5: "\x1b[38;5;91m",
0xf6: "\x1b[38;5;91m",
0xf7: "\x1b[38;5;91m",
0xf8: "\x1b[38;5;91m",
0xf9: "\x1b[38;5;91m",
0xfa: "\x1b[38;5;91m",
0xfb: "\x1b[38;5;91m",
0xfc: "\x1b[38;5;91m",
0xfd: "\x1b[38;5;91m",
0xfe: "\x1b[38;5;91m",
0xff: "\x1b[38;5;88m"
} | yxdump | /yxdump-1.0.1.tar.gz/yxdump-1.0.1/yxdconfig.py | yxdconfig.py |
# yxd
yxd is a hex dump tool similar to xxd, but with features that I wanted. It's written in python3, and doesn't have any requirements outside of the python3 standard library (sys, argparse, re). The script itself is pretty simple, and should be easy to add features to if needed.
## Install
You can install the `yxdump` package with pip
```
python3 -m pip install yxdump
```
## Usage
There are two ways to use yxd: from the command line, and as a library.
## Command Line
```
$ yxd -h
usage: yxd [-h] [-f INFILE] [-o STARTOFFSET] [-s BUFFERSIZE] [-r] [--plain] [--xx] [--ps] [--py] [--sc] [--style] [-v] [input]
yxd - Yuu's heX Dumper
positional arguments:
input File to open
options:
-h, --help show this help message and exit
-f INFILE File to open
-o STARTOFFSET Offset to start within file
-s BUFFERSIZE Size of buffer to dump
-r Do a reverse hex dump
--plain Print in xxd style plain text, compatible with xxd
--xx Print in xx format, a modified xxd-style dump for use with xx
--ps, -ps output in postscript plain hexdump style.
--py Create a python script to generate the buffer
--sc Create a C shellcode loader from buffer
--style Show Current Hex Style
-v Print Version Info
```
### Reading Files
Read a file with command line argument
```
$ yxd file.bin
```
You can also read from stdin
```
$ cat file.bin | yxd
```
### Specifying offsets and sizes
Specify the beginning offset with the `-o` flag, and the size of the buffer with the `-s` flag. You can use decimal or hex (prefixed with 0x) to represent these numbers.
```
$ yxd base.bin -o 0x40 -s 0x38
00000040โ0100 0000 0500 0000โ0000 0000 0000 0000โ................
00000050โ0000 4000 0000 0000โ0000 4000 0000 0000โ..@.......@.....
00000060โ0000 0000 0100 0000โ0000 0000 0100 0000โ................
00000070โ0000 2000 0000 0000โ โ.. .....
```
### xxd-style Output
yxd is also capable of producing xxd-style hex output with the `--plain` flag.
```
$ yxd base.bin --plain
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000 .ELF............
00000010: 0200 3e00 0100 0000 7800 4000 0000 0000 ..>.....x.@.....
00000020: 4000 0000 0000 0000 0000 0000 0000 0000 @...............
00000030: 0000 0000 4000 3800 0100 0000 0000 0000 [email protected].........
00000040: 0100 0000 0500 0000 0000 0000 0000 0000 ................
00000050: 0000 4000 0000 0000 0000 4000 0000 0000 ..@.......@.....
00000060: 0000 0000 0100 0000 0000 0000 0100 0000 ................
00000070: 0000 2000 0000 0000 b03c 66bf 0600 0f05 .. ......<f.....
```
### xx Compatible Hex Dump
yxd can create .xx files compatible with the [xx project](https://github.com/netspooky/xx) by using the flag `--xx`. These are modified xxd style hex dumps with the offset on the side within an `xx` comment, to allow for editing and markup while retaining offset data and the ASCII dump of the file.
```
$ yxd png.5e86c4ab.bin --xx
8950 4e47 0d0a 1a0a 0000 000d 4948 4452 ; 00000000: .PNG........IHDR
0000 0001 0000 0001 0100 0000 0037 6ef9 ; 00000010: .............7n.
2400 0000 1049 4441 5478 9c62 6001 0000 ; 00000020: $....IDATx.b`...
00ff ff03 0000 0600 0557 bfab d400 0000 ; 00000030: .........W......
0049 454e 44ae 4260 82 ; 00000040: .IEND.B`.
```
### Plain Hex Dump
This is a plain hex dump with all the hexbytes as one long line. This is equivalent to the xxd flag `-ps`. You can use `-ps` or `--ps` to produce this.
```
$ yxd png.5e86c4ab.bin -ps
89504e470d0a1a0a0000000d4948445200000001000000010100000000376ef9240000001049444154789c626001000000ffff03000006000557bfabd40000000049454e44ae426082
```
### Reverse Hex Dump
yxd does reverse hex dumps and supports both yxd and xxd style output.
```
$ yxd base.bin > base.yxd
$ yxd base.yxd -r
ELF>x@@@8@@ ๏ฟฝ<f๏ฟฝ
```
### Script Generation
One of my main use cases for this tool is to create buffers from files to manipulate them.
```
$ yxd base.bin --py
```
This dumps the following python script that willwrite the input file and give it a name based on the hash of the file. This is useful if you are doing file format research and need to help track minor changes in files as you edit them. A script form can also make it easier to comment on specific sections, and add your own calculations as needed.
```python
import struct
import sys
import hashlib
def writeBin(b,h):
outfile = h + ".bin"
f = open(outfile,'wb')
f.write(b)
f.close()
print(outfile)
b = b""
b += b"\x7f\x45\x4c\x46\x02\x01\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00" # 00000000 .ELF............
b += b"\x02\x00\x3e\x00\x01\x00\x00\x00\x78\x00\x40\x00\x00\x00\x00\x00" # 00000010 ..>.....x.@.....
b += b"\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" # 00000020 @...............
b += b"\x00\x00\x00\x00\x40\x00\x38\x00\x01\x00\x00\x00\x00\x00\x00\x00" # 00000030 [email protected].........
b += b"\x01\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00" # 00000040 ................
b += b"\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00" # 00000050 ..@.......@.....
b += b"\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00" # 00000060 ................
b += b"\x00\x00\x20\x00\x00\x00\x00\x00\xb0\x3c\x66\xbf\x06\x00\x0f\x05" # 00000070 .. ......<f.....
m = hashlib.sha256()
m.update(b)
shorthash = m.digest().hex()[0:8]
writeBin(b,shorthash)
```
Similarly, the `--sc` option can turn your file buffer into a C program that runs it as shellcode
```
$ yxd base.bin -o 0x78 --sc
```
This grabs the shellcode of this specific binary and turns it into a dropper.
```c
#include <stdio.h>
#include <string.h>
char code[] = "\xb0\x3c\x66\xbf\x06\x00\x0f\x05";
int main() {
printf("len:%d bytes\n", strlen(code));
(*(void(*)()) code)();
return 0;
}
```
## As a Library
The yxd library can do a hex dump with the same style options as in the command line tool, from a library.
Example of basic yxd API usage:
```
>>> import yxd
>>> a = b"\x41"*32
>>> a += b"\x42"*32
>>> yxd.yxd(a)
00000000: 4141 4141 4141 4141 4141 4141 4141 4141 AAAAAAAAAAAAAAAA
00000010: 4141 4141 4141 4141 4141 4141 4141 4141 AAAAAAAAAAAAAAAA
00000020: 4242 4242 4242 4242 4242 4242 4242 4242 BBBBBBBBBBBBBBBB
00000030: 4242 4242 4242 4242 4242 4242 4242 4242 BBBBBBBBBBBBBBBB
```
By default the yxd library does hex dumps in the xxd format. To output in a different format, you can set the `outFormat` variable to any of the available formats.
```python
import yxd
a = b"\x41"*32
a += b"\x42"*32
a += b"\xfa\xde\xdd\xdd\xec\xc5\xde\xee"
yxd.yxd(a, baseAddr=0x1000, outFormat="yxd")
```
## Styling
The yxdconfig.py file contains the style information for each byte, as well as templates for scripts. You can use ANSI escape codes in each, to enable everything from foreground and background colors, to blinking, underline, and more. These are all contained in a big dictionary called `bytez`
Use the `--style` flag to see what the current styling looks like.
## Contributing
PRs are welcome. There are still some features I'd like to add, and I would love to see other people's ideas. There are a lot of hex editing tools out there, but this one fits my usecase for simple, portable hex manipulation, that is also pretty looking.
Mastodon: https://haunted.computer/@netspooky
Twitter: [@netspooky](https://twitter.com/netspooky)
| yxdump | /yxdump-1.0.1.tar.gz/yxdump-1.0.1/README.md | README.md |
import sys
import argparse
import re
import yxdconfig as yc
parser = argparse.ArgumentParser(description="yxd - Yuu's heX Dumper")
parser.add_argument('-f', help='File to open', dest='inFile')
parser.add_argument('input', help='File to open', nargs='?')
parser.add_argument('-o', help='Offset to start within file', dest='startOffset', type=lambda x: int(x,0) )
parser.add_argument('-s', help='Size of buffer to dump', dest='bufferSize', type=lambda x: int(x,0) )
parser.add_argument('-r', help='Do a reverse hex dump', dest='reverseDump', action="store_true")
parser.add_argument('--plain', help='Print in xxd style plain text, compatible with xxd', dest='plainText', action="store_true")
parser.add_argument('--xx', help='Print in xx format, a modified xxd-style dump for use with xx', dest='xxFormat', action="store_true")
parser.add_argument('--ps','-ps', help='output in postscript plain hexdump style.', dest='psFormat', action="store_true")
parser.add_argument('--py', help='Create a python script to generate the buffer', dest='genPythonScript', action="store_true")
parser.add_argument('--sc', help='Create a C shellcode loader from buffer', dest='genShellcode', action="store_true")
parser.add_argument('--style', help='Show Current Hex Style', dest='dumpStyle', action="store_true")
parser.add_argument('-v', help='Print Version Info', dest='printVersion', action="store_true")
versionInfo="yxd - Yuu's heX Dumper Version 20230831.0"""
def styleDump():
"""
Dump all styles.
Dump the color and style information from the yxdconfig
"""
for i in range(0,256):
print(f"{yc.bytez[i]}{i:02X}{yc.EOA} ",end="")
if (i+1) % 16 == 0:
if i == 0:
continue
else:
print()
def dump(inBytes,baseAddr=0,dataLen=0,blockSize=16,outFormat="xxd",quiet=False):
"""
Dump hex.
This function performs a hex dump on the provided buffer with
the given parameters
Parameters
----------
inBytes : bytes
The hex text buffer to work with.
baseAddr : int
The base address of the buffer
dataLen : int
The length of data to dump from the buffer. Default 0 = All
blockSize : int
The number of bytes per line
outFormat : str
The format of hex dump format to do
quiet : bool
If true, don't print the output to the terminal
Returns
-------
hexDumpOut : str
The text form of the hex dump
"""
dataLen = len(inBytes) if ( dataLen == 0 ) or ( dataLen > len(inBytes) ) else dataLen # Sanity check
offs = 0
hexDumpOut = ""
# Style
dumpBytez = yc.bytez
dumpOffstyle = yc.OFFSTYLE
dumpSEP0 = yc.SEP0
dumpSEP1 = yc.SEP1
dumpSEP2 = yc.SEP2
dumpEOA = yc.EOA
if ( outFormat == "xxd" ) or ( outFormat == "xx" ) or ( outFormat == "ps" ):
dumpBytez = {}
dumpOffstyle = ""
dumpSEP0 = ": "
dumpSEP1 = " "
dumpSEP2 = " "
dumpEOA = ""
while offs < dataLen:
try:
hb = []
bAsc = ""
bChunk = inBytes[offs:offs+blockSize]
chunkBytes = 0
for b in bChunk:
bFmt = f"{dumpBytez[b]}" if b in dumpBytez.keys() else ""
bAsc += f"{bFmt}{chr(b)}{dumpEOA}" if chr(b).isprintable() and b < 0x7F else f"{bFmt}.{dumpEOA}"
hb.append(f"{bFmt}{b:02x}{dumpEOA}")
chunkBytes = chunkBytes + 1
if chunkBytes < blockSize:
neededChunks = blockSize - chunkBytes
for nullChunk in range(neededChunks):
hb.append(" ")
realOffs = offs+baseAddr
# This is where the buffer to print is built
offsetOut = f"{dumpOffstyle}{realOffs:08x}{dumpEOA}{dumpSEP0}"
hexOut = f"{hb[0]}{hb[1]} "
hexOut += f"{hb[2]}{hb[3]} "
hexOut += f"{hb[4]}{hb[5]} "
hexOut += f"{hb[6]}{hb[7]}{dumpSEP1}"
hexOut += f"{hb[8]}{hb[9]} "
hexOut += f"{hb[10]}{hb[11]} "
hexOut += f"{hb[12]}{hb[13]} "
hexOut += f"{hb[14]}{hb[15]}{dumpSEP2}"
if outFormat == "xx":
if quiet == False:
print(f"{hexOut}; {offsetOut}{bAsc}")
hexDumpOut += f"{hexOut}; {offsetOut}{bAsc}\n"
elif outFormat == "ps":
if quiet == False:
print("".join(hexOut.split()),end="")
hexDumpOut += "".join(hexOut.split())
else:
if quiet == False:
print(f"{offsetOut}{hexOut}{bAsc}")
hexDumpOut += f"{offsetOut}{hexOut}{bAsc}\n"
offs = offs + blockSize
except Exception as e:
print(f"yxd.dump: {e}")
if outFormat == "ps":
if quiet == False:
print() # Avoid annoying terminal behavior with a new line
return hexDumpOut
def hexString(bChunk):
"""
Create an escaped hex string.
This function performs turns a buffer of binary data into a
hex string in the style of "\x41\x41\x41\x41"
Parameters
----------
inBytes : bytes
The hex text buffer to work with.
Returns
-------
bHex : str
the hex string with double quotes around it
bAsc : str
printable characters in this buffer, if any
cSum : int
checksum, used to determine if all bytes were 0
"""
bHex = ""
bAsc = ""
cSum = 0
try:
for b in bChunk:
bAsc += chr(b) if chr(b).isprintable() and b < 0x7F else '.'
bHex += f"\\x{b:02x}"
cSum = cSum + b
bHex = f"\"{bHex}\""
return bHex, bAsc, cSum
except Exception as e:
print(f"yxd.hexString: {e}") # Maybe don't need
return bHex, bAsc, cSum
def genPythonScript(inBytes):
"""
Create a Python script loader.
This function performs turns a buffer of binary data into a
python script that creates a copy of your binary data.
Parameters
----------
inBytes : bytes
The hex text buffer to work with.
"""
print(yc.template1)
offs = 0
zeroCount = 0
savedOffset = 0
while offs < len(inBytes):
bChunk = inBytes[offs:offs+16]
chunkLen = len(bChunk)
bHex, bAsc, cSum = hexString(bChunk)
bHex = "b" + bHex
if cSum == 0:
if savedOffset == 0:
savedOffset = offs
zeroCount = zeroCount + chunkLen
else:
if zeroCount != 0:
print(f'b += b"\\x00"*{zeroCount} # {savedOffset:08X}')
zeroCount = 0
savedOffset = 0
print(f"b += {bHex} # {offs:08X} {bAsc}")
offs = offs + 16
if zeroCount != 0:
print(f'b += b"\\x00"*{zeroCount} # {savedOffset:08X}')
print(yc.template2)
def genShellcode(inBytes):
"""
Create a C shellcode loader.
This function performs turns a buffer of binary data into a
C-style shellcode loader.
Parameters
----------
inBytes : bytes
The hex text buffer to work with.
"""
print(yc.cTemplate1)
print("char code[] = ",end="")
scBuff, scAsc, scSum = hexString(inBytes)
print(f"{scBuff};")
print(yc.cTemplate2)
def reverseDump(inText):
"""
Reverse hex dump.
This function performs a reverse hex dump from a text buffer.
It can detect both xxd and yxd style hex dumps and convert them
back into binary buffers.
Parameters
----------
inText : bytes
The hex text buffer to work with.
"""
hexBuf = b""
if inText[0] == 0x1b:
# yxd Ansi output
linebuf = inText.decode("utf-8")
lines = linebuf.split("\n")
for l in lines:
try:
l = l.split("โ")
l = l[1] + l[2]
l = l.replace(" ", "")
escAnsi = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
l = escAnsi.sub('', l)
l = bytes.fromhex(l)
hexBuf += l
except:
break
elif inText[0:8] == b"00000000":
# xxd style output
linebuf = inText.decode("latin-1")
lines = linebuf.split("\n")
for l in lines:
try:
l = l.split(" ") # Shave off the last part
l.pop()
l = l[0].split(": ")
l = l[1]
l = l.replace(" ", "")
l = bytes.fromhex(l)
hexBuf += l
except:
break
else:
print("yxd.reverseDump: Wrong Format!")
sys.stdout.buffer.write(hexBuf)
return
class yxd:
"""
A class to represent a buffer of binary data.
The yxd class creates a reusable object that can access the features of the yxd library.
...
Attributes
----------
binData : bytes
a buffer of binary data
amount : int
the amount of data to output, 0 = all
baseAddr : int
the base address of the binary data
outFormat : str
output format, xx, xxd, yxd, python, shellcode, ps etc
color : str
the color scheme from the config options
blockSize : int
how many bytes per line
offset : int
offset within the buffer to do the hexdump from
quiet : bool
whether to dump to the terminal or not
Methods
-------
dump():
do hex dump on the binary data with configured settings
genPythonScript():
generate a python script that creates a copy of your binary data
genShellcode():
create a C shellcode loader from binary data
reverseDump():
do a reverse hex dump
"""
def __init__(self, binData, amount=0, baseAddr=0, outFormat="xxd", color="default", blockSize=16, offset=0, quiet=False ):
self.binData = binData
self.dataLen = len(binData)
self.baseAddr = baseAddr
self.outFormat = outFormat
self.color = color
self.offset = offset
self.blockSize = blockSize
self.amount = amount
self.quiet = quiet
if quiet != True:
self.dump()
def styleDump(self):
for i in range(0,256):
print(f"{yc.bytez[i]}{i:02X}{yc.EOA} ",end="")
if (i+1) % 16 == 0:
if i == 0:
continue
else:
print()
def dump(self):
return dump(self.binData,self.baseAddr,self.dataLen,self.blockSize,self.outFormat)
def genPythonScript(self):
genPythonScript(self.binData)
def genShellcode(self):
genShellcode(self.binData)
def reverseDump(self):
reverseDump(self.binData)
def main():
args = parser.parse_args()
if args.printVersion:
print(versionInfo)
sys.exit(0)
if args.dumpStyle:
styleDump()
sys.exit(0)
hexStyle = "yxd"
if args.plainText:
hexStyle = "xxd"
if args.xxFormat:
hexStyle = "xx"
if args.psFormat:
hexStyle = "ps"
bufferSize = args.bufferSize if args.bufferSize else 0
startOffset = args.startOffset if args.startOffset else 0
if args.inFile == None:
args.inFile = args.input
if args.inFile and args.inFile != "-":
inFile = args.inFile
with open(inFile,"rb") as f:
f.seek(startOffset)
binData = f.read(bufferSize) if bufferSize !=0 else f.read()
binSize = len(binData)
else:
binData = sys.stdin.buffer.read()
binSize = len(binData)
yxdd = yxd(binData, baseAddr=startOffset, outFormat=hexStyle, quiet=True)
if args.genPythonScript:
yxdd.genPythonScript()
elif args.genShellcode:
yxdd.genShellcode()
elif args.reverseDump:
yxdd.reverseDump()
else:
yxdd.dump()
if __name__ == '__main__':
main() | yxdump | /yxdump-1.0.1.tar.gz/yxdump-1.0.1/yxd.py | yxd.py |
# Convert from XLSForm to YAML and back
yxf (short for **Y**AML **X**LS**F**orms) is a converter between XLSForms and
YAML files. With yxf, you can store forms as text-files. This brings a number of
advantages to managing many forms. For example, you can store forms in version
control, view differences between two forms, and easily share updates between
multiple forms.
## Usage
To convert an XLSForm to a YAML file: `python -m yxf form.xlsx`.
By default, the result will be called `form.yaml`, in other words, the same name
as the input file with the extension changed to `.yaml`. You can specify a
different output file name using the `--output othername.yaml` option.
To convert a YAML file to an XLSForm: `python -m yxf form.yaml`.
Here's a screenshot showing the YAML and XLSForm version of a form side-by-side:
### Using Markdown
yxf can generate and read Markdown instead of YAML. The format is taken from
[md2xlsform](https://github.com/joshuaberetta/md2xlsform). This can be useful if
you would like something more compact than YAML, e.g., to paste into a community
forum.
To use Markdown, add a `--markdown` argument to the yxf invocation:
```shell
# Will generate form.md
python -m yxf --markdown form.xlsx
```
## Installation
Get the latest version from the GitHub repo:
```
python -m pip install yxf
```
## Features
### Comments in forms
yxf encourages adding comments to XLSForms. It uses a special column labeled `#`
to that end. Other tools ignore this column, so that it can be used for
explanations that are useful to the readers of the `.xlsx` or `.yaml` files.
### Pretty spreadsheets
yxf tries hard to make the XLSForm files look pretty. It is possible to use yxf
just for that purpose, without intending to store forms as YAML files. To do so,
simply convert a form to YAML and back:
```
python -m yxf form.xlsx
python -m yxf -o form-pretty.xlsx form.yaml
```
## Development
yxf is in an early stage of development. Feedback and contributions are welcome.
Please open issues in the [issue tracker](https://github.com/Sjlver/yxf/issues).
Please run all of the following before committing:
- Format the code: `black .`
- Run unit tests: `pytest`
- See lint warnings (and please fix them :)): `pylint yxf`
To publish on PyPI:
- Increment the version number in `setup.cfg`.
- Run `python -m build`.
- Upload using `python -m twine upload dist/*-version-*`. | yxf | /yxf-0.3.0.tar.gz/yxf-0.3.0/README.md | README.md |
Python utils
************
Tested in Python2.7, Python3.4.
callit
======
You can do::
from __future__ import print_function
print('x', 'y', sep=',')
But I can not do::
from __future__ import print_function
parameters = ('x', 'y', sep=',')
print(parameters)
With callit, I can do similar thing::
from __future__ import print_function
from yxpy.callit import CallIt
parameters = CallIt('x', 'y', sep=',')
parameters(print)
Sometimes, you may use Parameters(similar to CallIt)::
from __future__ import print_function
from yxpy.callit import Parameters
parameters = Parameters('x', 'y', sep=',')
parameters(format)
dotit
=====
Usually, dictionary can be used like this::
d = dict(a=1)
d['b'] = 2
x = d['a'] + d['b']
The members in dictionary can only be accessed by `[]`, But in some other
languages(eg. javascript), they can be access by `.`::
d.b = 2
x = d.a + d.b
With dotit, you can do same thing in similar manner, dotit provide thress
class to do it.
DotDict::
from dotit import DotDict
d = DotDict(a=1)
d.b = 2
x = d.a + d.b
DotOrderedDict, inherit from collections.OrderedDict::
... # similar to DotDict
DotIt, if you already have a dict like object, you can wrapper with DotIt::
d = dict(a=1, b=2)
...
d = DotIt(d)
x = d.a + d.b
DotIt can also deal with nest dict::
d = dict(a=dict(aa=1, ab=2), b=2)
...
d = DotIt(d)
x = d.a.aa + d.a.ab
loadit
======
Load or reload python object
import module::
import loadit
load moudule::
mod = loadit.load_it('mymodule')
load function::
func = loadit.load_it('mymodule.func')
load class::
MyClass = loadit.load_it('mymodule.MyClass')
reload module::
new_mod = loadit.reload_it(mod)
reload function::
new_func = loadit.reload_it(func)
reload class::
NewMyClass = loadit.reload_it(MyClass)
yamlfile
========
load config from YAML file, add a include tag.
main.yaml::
a: !include a.yaml
a.yaml::
name: a
usage::
from yxpy import yamlfile
yamlfile.load('main.yaml')
logginghandlers
===============
- SocketHandler(host, port)
- DatagramHandler(host, port)
- RedisListHandler(list_name, list_maxsize=1024, host='localhost', port=6379, password=None)
- RedisPublishHandler(self, channel, host='localhost', port=6379, password=None)
SocketHandler & DatagramHandler
-------------------------------
logging package provide many Handlers, include `SocketHandler` and
`DatagramHandler`, but the data transmit to server is packed as binary, this
module privide simular handler to transmit plain text to server.
example::
socket_handler = SocketHandler(host, port)
...
datagram_handler = DatagramHandler(host, port)
...
RedisListHandler & RedisPublishHandler
--------------------------------------
use Redis as log server, the two handler is just privide a singleway to redis
server. to keep simple, the handlers does check the response of redis.
example:
handler = RedisListHandler(list_name='logtest', list_maxsize=100, password='test')
...
handler = RedisPublishHandler(channel='logtest', password='test')
...
| yxpy | /yxpy-0.1.5.zip/yxpy-0.1.5/README.rst | README.rst |
from dataclasses import dataclass
from logging import getLogger
import re
from typing import Dict, Iterator, List, Optional, Tuple
from bs4 import BeautifulSoup
import bs4
from ac_core.constant import _SITE_URL
from ac_core.modal.problem_test_case import ProblemTestCase
from ac_core.utils import HTML_PARSER, get_direct_children_text, remove_prefix, remove_suffix
from ac_core.utils.html_parse_helper import parse_start_end, parse_url
logger = getLogger(__name__)
class SampleParseError(RuntimeError):
def __init__(self, message: str = 'failed to parse samples'):
super().__init__(message)
@dataclass
class ProblemResult():
id: str
url: str
name: str
score: int
tests: List[ProblemTestCase]
contest_name: str
contest_url: str
contest_start: int
contest_end: int
memory_limit_kb: int
time_limit_msec: int
def _parse_score(soup: bs4.BeautifulSoup) -> Optional[int]:
task_statement = soup.find('div', id='task-statement')
p = task_statement.find('p') # first
if isinstance(p, bs4.Tag) and p.text.startswith('้
็น : '):
score = remove_suffix(remove_prefix(p.text, '้
็น : '), ' ็น')
try:
return int(score)
except ValueError:
# some problems have scores like "<p>้
็น : \(100\) ็น</p>", not "<p>้
็น : 100 ็น</p>"
# example: https://atcoder.jp/contests/wupc2019/tasks/wupc2019_a
pass
return None
# Title in/out content
def _find_sample_tags(soup: BeautifulSoup) -> Iterator[Tuple[str, int, str]]:
# fix dup test case cause of lang-ja and lang-en
lang_soup = soup.find('span', class_="lang-en")
if lang_soup is None:
lang_soup = soup.find('span', class_="lang-ja")
if lang_soup is None:
lang_soup = soup.find(id='task-statement')
assert isinstance(lang_soup, bs4.Tag)
input_strings = ('ๅ
ฅๅไพ', 'Sample Input')
output_strings = ('ๅบๅไพ', 'Sample Output')
expected_strings = input_strings + output_strings
def h3_2_title_inout(s: str) -> Tuple[str, int]:
for prefix in input_strings:
if s.startswith(prefix):
return (s[len(prefix):].strip(), 0)
for prefix in output_strings:
if s.startswith(prefix):
return (s[len(prefix):].strip(), 1)
raise SampleParseError('Unknown input or output:' + str(h3))
def get_header(tag, expected_tag_name):
if tag and tag.name == expected_tag_name and tag.string and any(s in tag.string for s in expected_strings):
return tag
return None
for pre in lang_soup.find_all('pre'):
logger.debug('pre tag: %s', str(pre))
# the standard format: #task-statement h3+pre
# used by AtCoder's JavaScript, sometimes used with .prettyprint
# example: https://atcoder.jp/contests/abc114/tasks/abc114_d
# NOTE: The AtCoder's JavaScript (at https://atcoder.jp/public/js/contest.js?v=201911110917 version) supports:
# - "#task-statement h3+pre" format for Copy buttons of <h3> and <pre> tags
# - "pre.prettyprint" format for Copy buttons of <pre> tags
h3 = get_header(tag=pre.find_previous_sibling(), expected_tag_name='h3')
if h3:
yield h3_2_title_inout(h3.text) + (pre.text, )
continue
# a old format: #task-statement h3+section>pre:first-child
# partially supported by AtCoder's JavaScript
# NOTE: The relaxed format "#task-statement h3+section>pre" may cause false-positive. e.g. https://atcoder.jp/contests/abc003/tasks/abc003_4
# NOTE: The format "h3+section>pre.prettyprint" sometimes cause false-negative. e.g. https://atcoder.jp/contests/tdpc/tasks/tdpc_fibonacci
# example: https://atcoder.jp/contests/abc003/tasks/abc003_4
if pre.find_previous_sibling() is None and pre.parent.name == 'section':
h3 = get_header(tag=pre.parent.find_previous_sibling(), expected_tag_name='h3')
if h3:
yield h3_2_title_inout(h3.text) + (pre.text, )
continue
# a very old format: #task-statement p+pre.literal-block
# entirely unsupported by AtCoder's JavaScript
# example: https://atcoder.jp/contests/utpc2011/tasks/utpc2011_1
if 'literal-block' in pre.attrs.get('class', []):
p = get_header(tag=pre.find_previous_sibling(), expected_tag_name='p')
if p:
yield h3_2_title_inout(p) + (pre.text, )
continue
def _parse_sample_cases(soup: BeautifulSoup) -> List[ProblemTestCase]:
"""
:raises SampleParseError:
"""
s_dict: Dict[str, ProblemTestCase] = {}
for title, inout, content in _find_sample_tags(soup):
if title not in s_dict:
s_dict[title] = ProblemTestCase(title=title)
if inout == 0:
s_dict[title].input = content.lstrip()
elif inout == 1:
s_dict[title].output = content.lstrip()
else:
assert (False)
samples: List[ProblemTestCase] = []
for title, inout, content in _find_sample_tags(soup):
if inout == 0:
samples.append(s_dict[title])
return samples
def parse_task(html: str) -> ProblemResult:
"""parse problem page html to structured data
:param html: the html source get from ``https://atcoder.jp/contests/{contest_id}/tasks/{problem_id}``
:examples:
.. code-block::
import requests
from ac_core.problem import parse_task
r = requests.get('https://atcoder.jp/contests/abc260/tasks/abc260_a')
if r.status_code == 200:
print(parse_task(r.text))
"""
soup = BeautifulSoup(html, HTML_PARSER)
h2 = soup.find('span', class_='h2')
assert isinstance(h2, bs4.Tag)
alphabet, _, name = get_direct_children_text(h2).strip().partition(' - ')
time_limit, memory_limit = h2.find_next_sibling('p').text.strip().split(' / ')
for time_limit_prefix in ('ๅฎ่กๆ้ๅถ้: ', 'Time Limit: '):
if time_limit.startswith(time_limit_prefix):
break
else:
assert False
if time_limit.endswith(' msec'):
time_limit_msec = int(remove_suffix(remove_prefix(time_limit, time_limit_prefix), ' msec'))
elif time_limit.endswith(' sec'):
time_limit_msec = int(float(remove_suffix(remove_prefix(time_limit, time_limit_prefix), ' sec')) * 1000)
else:
assert False
# When login as the admin, a link is added after memory limit. See https://github.com/online-judge-tools/api-client/issues/90
parsed_memory_limit = re.search(r'^(ใกใขใชๅถ้|Memory Limit): ([0-9.]+) (KB|MB)', memory_limit)
assert parsed_memory_limit
memory_limit_value = parsed_memory_limit.group(2)
memory_limit_unit = parsed_memory_limit.group(3)
if memory_limit_unit == 'KB':
memory_limit_byte = int(float(memory_limit_value))
elif memory_limit_unit == 'MB':
memory_limit_byte = int(float(memory_limit_value) * 1000)
else:
assert False
try:
tests_list = _parse_sample_cases(soup) or [] # type: Optional[List[ProblemTestCase]]
except SampleParseError as e:
logger.error(str(e))
score = _parse_score(soup)
url = parse_url(soup)
contest_info = soup.find(class_="contest-title")
assert isinstance(contest_info, bs4.Tag)
contest_name = contest_info.text
contest_url = _SITE_URL + contest_info.attrs["href"]
start_time, end_time = parse_start_end(soup)
return ProblemResult(
id=alphabet,
url=url,
name=name,
time_limit_msec=time_limit_msec,
memory_limit_kb=memory_limit_byte,
tests=tests_list,
score=score,
contest_name=contest_name,
contest_url=contest_url,
contest_start=start_time,
contest_end=end_time,
) | yxr-atcoder-core | /yxr_atcoder_core-0.0.3.3-py3-none-any.whl/ac_core/problem.py | problem.py |
from dataclasses import dataclass
from typing import Dict, cast
from bs4 import BeautifulSoup
import bs4
from ac_core.constant import _SITE_URL
from ac_core.interfaces.HttpUtil import HttpUtilInterface, HttpRespInterface
from ac_core.url import url_2_contest_id
from ac_core.utils import HTML_PARSER
@dataclass
class SubmitResult:
url: str
def fetch_fields(html: str) -> Dict[str, str]:
"""parse necessary fields for requests header such as 'csrf_token'
:param html: the html source from ``https://atcoder.jp/contests/{contest_id}/submit``
"""
soup = BeautifulSoup(html, HTML_PARSER)
return {'csrf_token': cast(bs4.Tag, soup.find('input', attrs={'name': 'csrf_token'})).attrs['value']}
def problem_url_2_submit_url(problem_url: str) -> str:
"""covert tool for problem_url to submit_url.
:param problem_url: e.g. ``'https://atcoder.jp/contests/abc285/tasks/abc285_a'``
:returns: problem_url e.g. ``'https://atcoder.jp/contests/abc285/submit'``
:examples:
.. code-block::
from ac_core.submit import problem_url_2_submit_url
print(problem_url_2_submit_url('https://atcoder.jp/contests/abc285/tasks/abc285_a'))
"""
contest_id = url_2_contest_id(problem_url)
return _SITE_URL + '/contests/' + contest_id + '/submit'
def fetch_submit(http_util: HttpUtilInterface, problem_url: str, lang_id: str, source_code: str) -> HttpRespInterface:
"""Submit code. You need logged in before using this method.
:param http_util: e.g. requests.session()
:param problem_url: e.g. ``'https://atcoder.jp/contests/abc285/tasks/abc285_a'``
:param lang_id: e.g. ``'4003'`` for ``C++ (GCC 9.2.1)``, use :py:func:`ac_core.language.fetch_language()` to get language list
:param source_code: the code text
:examples:
.. code-block::
import requests
from ac_core.auth import fetch_login, is_logged_in
from ac_core.submit import fetch_submit
h = requests.session()
fetch_login(h, 'username', 'password')
assert(is_logged_in(h))
print(fetch_submit(h,'https://atcoder.jp/contests/abc285/tasks/abc285_a','4006','print("hello world.")'))
"""
problem_id = problem_url.split('/')[-1]
submit_url = problem_url_2_submit_url(problem_url)
html = (http_util.get(submit_url)).text
post_data = {
'sourceCode': source_code,
'data.LanguageId': lang_id,
'data.TaskScreenName': problem_id,
}
fields = fetch_fields(html)
for key, val in fields.items():
post_data[key] = val
# TODO add test
return http_util.post(url=submit_url, data=post_data) | yxr-atcoder-core | /yxr_atcoder_core-0.0.3.3-py3-none-any.whl/ac_core/submit.py | submit.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.