

<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: images.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># This file contains methods to deal with criu images.
#
# According to http://criu.org/Images, criu images can be described
# with such IOW:
#
# IMAGE_FILE ::= MAGIC { ENTRY }
# ENTRY      ::= SIZE PAYLOAD [ EXTRA ]
# PAYLOAD    ::= &quot;message encoded in ProtocolBuffer format&quot;
# EXTRA      ::= &quot;arbitrary blob, depends on the PAYLOAD contents&quot;
#
# MAGIC      ::= &quot;32 bit integer&quot;
# SIZE       ::= &quot;32 bit integer, equals the PAYLOAD length&quot;
#
# Images v1.1 NOTE: MAGIC now consist of 2 32 bit integers, first one is
#    MAGIC_COMMON or MAGIC_SERVICE and the second one is same as MAGIC
#    in images V1.0. We don&#039;t keep &quot;first&quot; magic in json images.
#
# In order to convert images to human-readable format, we use dict(json).
# Using json not only allows us to easily read\write images, but also
# to use a great variety of tools out there to manipulate them.
# It also allows us to clearly describe criu images structure.
#
# Using dict(json) format, criu images can be described like:
#
# {
#    &#039;magic&#039; : &#039;FOO&#039;,
#    &#039;entries&#039; : [
#        entry,
#        ...
#    ]
# }
#
# Entry, in its turn, could be described as:
#
# {
#    pb_msg,
#    &#039;extra&#039; : extra_msg
# }
#
import io
import base64
import struct
import os
import array

from . import magic
from . import pb
from . import pb2dict

if &quot;encodebytes&quot; not in dir(base64):
    base64.encodebytes = base64.encodestring
    base64.decodebytes = base64.decodestring

#
# Predefined hardcoded constants
sizeof_u16 = 2
sizeof_u32 = 4
sizeof_u64 = 8


# A helper for rounding
def round_up(x, y):
    return (((x - 1) | (y - 1)) + 1)


class MagicException(Exception):
    def __init__(self, magic):
        self.magic = magic


def decode_base64_data(data):
    &quot;&quot;&quot;A helper function to decode base64 data.&quot;&quot;&quot;
    return base64.decodebytes(str.encode(data))


def write_base64_data(f, data):
    &quot;&quot;&quot;A helper function to write base64 encoded data to a file.&quot;&quot;&quot;
    f.write(base64.decodebytes(str.encode(data)))


# Generic class to handle loading/dumping criu images entries from/to bin
# format to/from dict(json).
class entry_handler:
    &quot;&quot;&quot;
    Generic class to handle loading/dumping criu images
    entries from/to bin format to/from dict(json).
    &quot;&quot;&quot;

    def __init__(self, payload, extra_handler=None):
        &quot;&quot;&quot;
        Sets payload class and extra handler class.
        &quot;&quot;&quot;
        self.payload = payload
        self.extra_handler = extra_handler

    def load(self, f, pretty=False, no_payload=False):
        &quot;&quot;&quot;
        Convert criu image entries from binary format to dict(json).
        Takes a file-like object and returns a list with entries in
        dict(json) format.
        &quot;&quot;&quot;
        entries = []

        while True:
            entry = {}

            # Read payload
            pbuff = self.payload()
            buf = f.read(4)
            if len(buf) == 0:
                break
            size, = struct.unpack(&#039;i&#039;, buf)
            pbuff.ParseFromString(f.read(size))
            entry = pb2dict.pb2dict(pbuff, pretty)

            # Read extra
            if self.extra_handler:
                if no_payload:

                    def human_readable(num):
                        for unit in [&#039;&#039;, &#039;K&#039;, &#039;M&#039;, &#039;G&#039;, &#039;T&#039;, &#039;P&#039;, &#039;E&#039;, &#039;Z&#039;]:
                            if num &lt; 1024.0:
                                if int(num) == num:
                                    return &quot;%d%sB&quot; % (num, unit)
                                else:
                                    return &quot;%.1f%sB&quot; % (num, unit)
                            num /= 1024.0
                        return &quot;%.1fYB&quot; % num

                    pl_size = self.extra_handler.skip(f, pbuff)
                    entry[&#039;extra&#039;] = &#039;... &lt;%s&gt;&#039; % human_readable(pl_size)
                else:
                    entry[&#039;extra&#039;] = self.extra_handler.load(f, pbuff)

            entries.append(entry)

        return entries

    def loads(self, s, pretty=False):
        &quot;&quot;&quot;
        Same as load(), but takes a string as an argument.
        &quot;&quot;&quot;
        f = io.BytesIO(s)
        return self.load(f, pretty)

    def dump(self, entries, f):
        &quot;&quot;&quot;
        Convert criu image entries from dict(json) format to binary.
        Takes a list of entries and a file-like object to write entries
        in binary format to.
        &quot;&quot;&quot;
        for entry in entries:
            extra = entry.pop(&#039;extra&#039;, None)

            # Write payload
            pbuff = self.payload()
            pb2dict.dict2pb(entry, pbuff)
            pb_str = pbuff.SerializeToString()
            size = len(pb_str)
            f.write(struct.pack(&#039;i&#039;, size))
            f.write(pb_str)

            # Write extra
            if self.extra_handler and extra:
                self.extra_handler.dump(extra, f, pbuff)

    def dumps(self, entries):
        &quot;&quot;&quot;
        Same as dump(), but doesn&#039;t take file-like object and just
        returns a string.
        &quot;&quot;&quot;
        f = io.BytesIO(&#039;&#039;)
        self.dump(entries, f)
        return f.read()

    def count(self, f):
        &quot;&quot;&quot;
        Counts the number of top-level object in the image file
        &quot;&quot;&quot;
        entries = 0

        while True:
            buf = f.read(4)
            if len(buf) == 0:
                break
            size, = struct.unpack(&#039;i&#039;, buf)
            f.seek(size, 1)
            entries += 1

        return entries


# Special handler for pagemap.img
class pagemap_handler:
    &quot;&quot;&quot;
    Special entry handler for pagemap.img, which is unique in a way
    that it has a header of pagemap_head type followed by entries
    of pagemap_entry type.
    &quot;&quot;&quot;

    def load(self, f, pretty=False, no_payload=False):
        entries = []

        pbuff = pb.pagemap_head()
        while True:
            buf = f.read(4)
            if len(buf) == 0:
                break
            size, = struct.unpack(&#039;i&#039;, buf)
            pbuff.ParseFromString(f.read(size))
            entries.append(pb2dict.pb2dict(pbuff, pretty))

            pbuff = pb.pagemap_entry()

        return entries

    def loads(self, s, pretty=False):
        f = io.BytesIO(s)
        return self.load(f, pretty)

    def dump(self, entries, f):
        pbuff = pb.pagemap_head()
        for item in entries:
            pb2dict.dict2pb(item, pbuff)
            pb_str = pbuff.SerializeToString()
            size = len(pb_str)
            f.write(struct.pack(&#039;i&#039;, size))
            f.write(pb_str)

            pbuff = pb.pagemap_entry()

    def dumps(self, entries):
        f = io.BytesIO(&#039;&#039;)
        self.dump(entries, f)
        return f.read()

    def count(self, f):
        return entry_handler(None).count(f) - 1


# Special handler for ghost-file.img
class ghost_file_handler:
    def load(self, f, pretty=False, no_payload=False):
        entries = []

        gf = pb.ghost_file_entry()
        buf = f.read(4)
        size, = struct.unpack(&#039;i&#039;, buf)
        gf.ParseFromString(f.read(size))
        g_entry = pb2dict.pb2dict(gf, pretty)

        if gf.chunks:
            entries.append(g_entry)
            while True:
                gc = pb.ghost_chunk_entry()
                buf = f.read(4)
                if len(buf) == 0:
                    break
                size, = struct.unpack(&#039;i&#039;, buf)
                gc.ParseFromString(f.read(size))
                entry = pb2dict.pb2dict(gc, pretty)
                if no_payload:
                    f.seek(gc.len, os.SEEK_CUR)
                else:
                    entry[&#039;extra&#039;] = base64.encodebytes(f.read(gc.len)).decode(&#039;utf-8&#039;)
                entries.append(entry)
        else:
            if no_payload:
                f.seek(0, os.SEEK_END)
            else:
                g_entry[&#039;extra&#039;] = base64.encodebytes(f.read()).decode(&#039;utf-8&#039;)
            entries.append(g_entry)

        return entries

    def loads(self, s, pretty=False):
        f = io.BytesIO(s)
        return self.load(f, pretty)

    def dump(self, entries, f):
        pbuff = pb.ghost_file_entry()
        item = entries.pop(0)
        pb2dict.dict2pb(item, pbuff)
        pb_str = pbuff.SerializeToString()
        size = len(pb_str)
        f.write(struct.pack(&#039;i&#039;, size))
        f.write(pb_str)

        if pbuff.chunks:
            for item in entries:
                pbuff = pb.ghost_chunk_entry()
                pb2dict.dict2pb(item, pbuff)
                pb_str = pbuff.SerializeToString()
                size = len(pb_str)
                f.write(struct.pack(&#039;i&#039;, size))
                f.write(pb_str)
                write_base64_data(f, item[&#039;extra&#039;])
        else:
            write_base64_data(f, item[&#039;extra&#039;])

    def dumps(self, entries):
        f = io.BytesIO(&#039;&#039;)
        self.dump(entries, f)
        return f.read()


# In following extra handlers we use base64 encoding
# to store binary data. Even though, the nature
# of base64 is that it increases the total size,
# it doesn&#039;t really matter, because our images
# do not store big amounts of binary data. They
# are negligible comparing to pages size.
class pipes_data_extra_handler:
    def load(self, f, pload):
        size = pload.bytes
        data = f.read(size)
        return base64.encodebytes(data).decode(&#039;utf-8&#039;)

    def dump(self, extra, f, pload):
        data = decode_base64_data(extra)
        f.write(data)

    def skip(self, f, pload):
        f.seek(pload.bytes, os.SEEK_CUR)
        return pload.bytes


class sk_queues_extra_handler:
    def load(self, f, pload):
        size = pload.length
        data = f.read(size)
        return base64.encodebytes(data).decode(&#039;utf-8&#039;)

    def dump(self, extra, f, _unused):
        data = decode_base64_data(extra)
        f.write(data)

    def skip(self, f, pload):
        f.seek(pload.length, os.SEEK_CUR)
        return pload.length


class tcp_stream_extra_handler:
    def load(self, f, pbuff):
        d = {}

        inq = f.read(pbuff.inq_len)
        outq = f.read(pbuff.outq_len)

        d[&#039;inq&#039;] = base64.encodebytes(inq).decode(&#039;utf-8&#039;)
        d[&#039;outq&#039;] = base64.encodebytes(outq).decode(&#039;utf-8&#039;)

        return d

    def dump(self, extra, f, _unused):
        inq = decode_base64_data(extra[&#039;inq&#039;])
        outq = decode_base64_data(extra[&#039;outq&#039;])

        f.write(inq)
        f.write(outq)

    def skip(self, f, pbuff):
        f.seek(0, os.SEEK_END)
        return pbuff.inq_len + pbuff.outq_len


class bpfmap_data_extra_handler:
    def load(self, f, pload):
        size = pload.keys_bytes + pload.values_bytes
        data = f.read(size)
        return base64.encodebytes(data).decode(&#039;utf-8&#039;)

    def dump(self, extra, f, pload):
        data = base64.decodebytes(extra)
        f.write(data)

    def skip(self, f, pload):
        f.seek(pload.bytes, os.SEEK_CUR)
        return pload.bytes


class ipc_sem_set_handler:
    def load(self, f, pbuff):
        entry = pb2dict.pb2dict(pbuff)
        size = sizeof_u16 * entry[&#039;nsems&#039;]
        rounded = round_up(size, sizeof_u64)
        s = self._get_sem_array()
        s.frombytes(f.read(size))
        f.seek(rounded - size, 1)
        return s.tolist()

    def dump(self, extra, f, pbuff):
        entry = pb2dict.pb2dict(pbuff)
        size = sizeof_u16 * entry[&#039;nsems&#039;]
        rounded = round_up(size, sizeof_u64)
        s = self._get_sem_array()
        s.fromlist(extra)
        if len(s) != entry[&#039;nsems&#039;]:
            raise Exception(&quot;Number of semaphores mismatch&quot;)
        f.write(s.tobytes())
        f.write(b&#039;\0&#039; * (rounded - size))

    def skip(self, f, pbuff):
        entry = pb2dict.pb2dict(pbuff)
        size = sizeof_u16 * entry[&#039;nsems&#039;]
        f.seek(round_up(size, sizeof_u64), os.SEEK_CUR)
        return size

    def _get_sem_array(self):
        s = array.array(&#039;H&#039;)
        if s.itemsize != sizeof_u16:
            raise Exception(&quot;Array size mismatch&quot;)
        return s


class ipc_msg_queue_handler:
    def load(self, f, pbuff):
        messages, _ = self._read_messages(f, pbuff)
        return messages

    def dump(self, extra, f, pbuff):
        for i in range(0, len(extra), 2):
            msg = pb.ipc_msg()
            pb2dict.dict2pb(extra[i], msg)
            msg_str = msg.SerializeToString()
            size = len(msg_str)
            f.write(struct.pack(&#039;i&#039;, size))
            f.write(msg_str)
            rounded = round_up(msg.msize, sizeof_u64)
            data = decode_base64_data(extra[i + 1])
            f.write(data[:msg.msize])
            f.write(b&#039;\0&#039; * (rounded - msg.msize))

    def skip(self, f, pbuff):
        _, pl_len = self._read_messages(f, pbuff, skip_data=True)
        return pl_len

    def _read_messages(self, f, pbuff, skip_data=False):
        entry = pb2dict.pb2dict(pbuff)
        messages = []
        pl_len = 0
        for x in range(0, entry[&#039;qnum&#039;]):
            buf = f.read(4)
            if len(buf) == 0:
                break
            size, = struct.unpack(&#039;i&#039;, buf)
            msg = pb.ipc_msg()
            msg.ParseFromString(f.read(size))
            rounded = round_up(msg.msize, sizeof_u64)
            pl_len += size + msg.msize

            if skip_data:
                f.seek(rounded, os.SEEK_CUR)
            else:
                data = f.read(msg.msize)
                f.seek(rounded - msg.msize, 1)
                messages.append(pb2dict.pb2dict(msg))
                messages.append(base64.encodebytes(data).decode(&#039;utf-8&#039;))

        return messages, pl_len


class ipc_shm_handler:
    def load(self, f, pbuff):
        entry = pb2dict.pb2dict(pbuff)
        size = entry[&#039;size&#039;]
        data = f.read(size)
        rounded = round_up(size, sizeof_u32)
        f.seek(rounded - size, 1)
        return base64.encodebytes(data).decode(&#039;utf-8&#039;)

    def dump(self, extra, f, pbuff):
        entry = pb2dict.pb2dict(pbuff)
        size = entry[&#039;size&#039;]
        data = base64.decodebytes(extra)
        rounded = round_up(size, sizeof_u32)
        f.write(data[:size])
        f.write(b&#039;\0&#039; * (rounded - size))

    def skip(self, f, pbuff):
        entry = pb2dict.pb2dict(pbuff)
        size = entry[&#039;size&#039;]
        rounded = round_up(size, sizeof_u32)
        f.seek(rounded, os.SEEK_CUR)
        return size


handlers = {
    &#039;INVENTORY&#039;: entry_handler(pb.inventory_entry),
    &#039;CORE&#039;: entry_handler(pb.core_entry),
    &#039;IDS&#039;: entry_handler(pb.task_kobj_ids_entry),
    &#039;CREDS&#039;: entry_handler(pb.creds_entry),
    &#039;UTSNS&#039;: entry_handler(pb.utsns_entry),
    &#039;TIMENS&#039;: entry_handler(pb.timens_entry),
    &#039;PIDNS&#039;: entry_handler(pb.pidns_entry),
    &#039;IPC_VAR&#039;: entry_handler(pb.ipc_var_entry),
    &#039;FS&#039;: entry_handler(pb.fs_entry),
    &#039;GHOST_FILE&#039;: ghost_file_handler(),
    &#039;MM&#039;: entry_handler(pb.mm_entry),
    &#039;CGROUP&#039;: entry_handler(pb.cgroup_entry),
    &#039;TCP_STREAM&#039;: entry_handler(pb.tcp_stream_entry,
                                tcp_stream_extra_handler()),
    &#039;STATS&#039;: entry_handler(pb.stats_entry),
    &#039;PAGEMAP&#039;: pagemap_handler(),  # Special one
    &#039;PSTREE&#039;: entry_handler(pb.pstree_entry),
    &#039;REG_FILES&#039;: entry_handler(pb.reg_file_entry),
    &#039;NS_FILES&#039;: entry_handler(pb.ns_file_entry),
    &#039;EVENTFD_FILE&#039;: entry_handler(pb.eventfd_file_entry),
    &#039;EVENTPOLL_FILE&#039;: entry_handler(pb.eventpoll_file_entry),
    &#039;EVENTPOLL_TFD&#039;: entry_handler(pb.eventpoll_tfd_entry),
    &#039;SIGNALFD&#039;: entry_handler(pb.signalfd_entry),
    &#039;TIMERFD&#039;: entry_handler(pb.timerfd_entry),
    &#039;INOTIFY_FILE&#039;: entry_handler(pb.inotify_file_entry),
    &#039;INOTIFY_WD&#039;: entry_handler(pb.inotify_wd_entry),
    &#039;FANOTIFY_FILE&#039;: entry_handler(pb.fanotify_file_entry),
    &#039;FANOTIFY_MARK&#039;: entry_handler(pb.fanotify_mark_entry),
    &#039;VMAS&#039;: entry_handler(pb.vma_entry),
    &#039;PIPES&#039;: entry_handler(pb.pipe_entry),
    &#039;FIFO&#039;: entry_handler(pb.fifo_entry),
    &#039;SIGACT&#039;: entry_handler(pb.sa_entry),
    &#039;NETLINK_SK&#039;: entry_handler(pb.netlink_sk_entry),
    &#039;REMAP_FPATH&#039;: entry_handler(pb.remap_file_path_entry),
    &#039;MNTS&#039;: entry_handler(pb.mnt_entry),
    &#039;TTY_FILES&#039;: entry_handler(pb.tty_file_entry),
    &#039;TTY_INFO&#039;: entry_handler(pb.tty_info_entry),
    &#039;TTY_DATA&#039;: entry_handler(pb.tty_data_entry),
    &#039;RLIMIT&#039;: entry_handler(pb.rlimit_entry),
    &#039;TUNFILE&#039;: entry_handler(pb.tunfile_entry),
    &#039;EXT_FILES&#039;: entry_handler(pb.ext_file_entry),
    &#039;IRMAP_CACHE&#039;: entry_handler(pb.irmap_cache_entry),
    &#039;FILE_LOCKS&#039;: entry_handler(pb.file_lock_entry),
    &#039;FDINFO&#039;: entry_handler(pb.fdinfo_entry),
    &#039;UNIXSK&#039;: entry_handler(pb.unix_sk_entry),
    &#039;INETSK&#039;: entry_handler(pb.inet_sk_entry),
    &#039;PACKETSK&#039;: entry_handler(pb.packet_sock_entry),
    &#039;ITIMERS&#039;: entry_handler(pb.itimer_entry),
    &#039;POSIX_TIMERS&#039;: entry_handler(pb.posix_timer_entry),
    &#039;NETDEV&#039;: entry_handler(pb.net_device_entry),
    &#039;PIPES_DATA&#039;: entry_handler(pb.pipe_data_entry,
                                pipes_data_extra_handler()),
    &#039;FIFO_DATA&#039;: entry_handler(pb.pipe_data_entry, pipes_data_extra_handler()),
    &#039;SK_QUEUES&#039;: entry_handler(pb.sk_packet_entry, sk_queues_extra_handler()),
    &#039;IPCNS_SHM&#039;: entry_handler(pb.ipc_shm_entry, ipc_shm_handler()),
    &#039;IPCNS_SEM&#039;: entry_handler(pb.ipc_sem_entry, ipc_sem_set_handler()),
    &#039;IPCNS_MSG&#039;: entry_handler(pb.ipc_msg_entry, ipc_msg_queue_handler()),
    &#039;NETNS&#039;: entry_handler(pb.netns_entry),
    &#039;USERNS&#039;: entry_handler(pb.userns_entry),
    &#039;SECCOMP&#039;: entry_handler(pb.seccomp_entry),
    &#039;AUTOFS&#039;: entry_handler(pb.autofs_entry),
    &#039;FILES&#039;: entry_handler(pb.file_entry),
    &#039;CPUINFO&#039;: entry_handler(pb.cpuinfo_entry),
    &#039;MEMFD_FILE&#039;: entry_handler(pb.memfd_file_entry),
    &#039;MEMFD_INODE&#039;: entry_handler(pb.memfd_inode_entry),
    &#039;BPFMAP_FILE&#039;: entry_handler(pb.bpfmap_file_entry),
    &#039;BPFMAP_DATA&#039;: entry_handler(pb.bpfmap_data_entry,
                                 bpfmap_data_extra_handler()),
    &#039;APPARMOR&#039;: entry_handler(pb.apparmor_entry),
}


def __rhandler(f):
    # Images v1.1 NOTE: First read &quot;first&quot; magic.
    img_magic, = struct.unpack(&#039;i&#039;, f.read(4))
    if img_magic in (magic.by_name[&#039;IMG_COMMON&#039;],
                     magic.by_name[&#039;IMG_SERVICE&#039;]):
        img_magic, = struct.unpack(&#039;i&#039;, f.read(4))

    try:
        m = magic.by_val[img_magic]
    except Exception:
        raise MagicException(img_magic)

    try:
        handler = handlers[m]
    except Exception:
        raise Exception(&quot;No handler found for image with magic &quot; + m)

    return m, handler


def load(f, pretty=False, no_payload=False):
    &quot;&quot;&quot;
    Convert criu image from binary format to dict(json).
    Takes a file-like object to read criu image from.
    Returns criu image in dict(json) format.
    &quot;&quot;&quot;
    image = {}

    m, handler = __rhandler(f)

    image[&#039;magic&#039;] = m
    image[&#039;entries&#039;] = handler.load(f, pretty, no_payload)

    return image


def info(f):
    res = {}

    m, handler = __rhandler(f)

    res[&#039;magic&#039;] = m
    res[&#039;count&#039;] = handler.count(f)

    return res


def loads(s, pretty=False):
    &quot;&quot;&quot;
    Same as load(), but takes a string.
    &quot;&quot;&quot;
    f = io.BytesIO(s)
    return load(f, pretty)


def dump(img, f):
    &quot;&quot;&quot;
    Convert criu image from dict(json) format to binary.
    Takes an image in dict(json) format and file-like
    object to write to.
    &quot;&quot;&quot;
    m = img[&#039;magic&#039;]
    magic_val = magic.by_name[img[&#039;magic&#039;]]

    # Images v1.1 NOTE: use &quot;second&quot; magic to identify what &quot;first&quot;
    # should be written.
    if m != &#039;INVENTORY&#039;:
        if m in (&#039;STATS&#039;, &#039;IRMAP_CACHE&#039;):
            f.write(struct.pack(&#039;i&#039;, magic.by_name[&#039;IMG_SERVICE&#039;]))
        else:
            f.write(struct.pack(&#039;i&#039;, magic.by_name[&#039;IMG_COMMON&#039;]))

    f.write(struct.pack(&#039;i&#039;, magic_val))

    try:
        handler = handlers[m]
    except Exception:
        raise Exception(&quot;No handler found for image with such magic&quot;)

    handler.dump(img[&#039;entries&#039;], f)


def dumps(img):
    &quot;&quot;&quot;
    Same as dump(), but takes only an image and returns
    a string.
    &quot;&quot;&quot;
    f = io.BytesIO(b&#039;&#039;)
    dump(img, f)
    return f.getvalue()
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.6/site-packages/pycriu/images/images.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.6%2Fsite-packages%2Fpycriu%2Fimages' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>