text:
"""
Miscellaneous function (re)definitions from the Py3.4+ standard library
for Python 2.6/2.7.

- math.ceil                (for Python 2.7)
- collections.OrderedDict  (for Python 2.6)
- collections.Counter      (for Python 2.6)
- collections.ChainMap     (for all versions prior to Python 3.3)
- itertools.count          (for Python 2.6, with step parameter)
- subprocess.check_output  (for Python 2.6)
- reprlib.recursive_repr   (for Python 2.6+)
- functools.cmp_to_key     (for Python 2.6)
"""

from __future__ import absolute_import

import subprocess
from math import ceil as oldceil

from operator import itemgetter as _itemgetter, eq as _eq
import sys
import heapq as _heapq
from _weakref import proxy as _proxy
from itertools import repeat as _repeat, chain as _chain, starmap as _starmap
from socket import getaddrinfo, SOCK_STREAM, error, socket

from future.utils import iteritems, itervalues, PY2, PY26, PY3

if PY2:
    from collections import Mapping, MutableMapping
else:
    from collections.abc import Mapping, MutableMapping

def ceil(x):
    """
    Return the ceiling of x as an int.
    This is the smallest integral value >= x.
    """
    return int(oldceil(x))

########################################################################
###  reprlib.recursive_repr decorator from Py3.4
########################################################################

from itertools import islice

if PY26:
    # itertools.count in Py 2.6 doesn't accept a step parameter
    def count(start=0, step=1):
        while True:
            yield start
            start += step
else:
    from itertools import count

if PY3:
    try:
        from _thread import get_ident
    except ImportError:
        from _dummy_thread import get_ident
else:
    try:
        from thread import get_ident
    except ImportError:
        from dummy_thread import get_ident

def recursive_repr(fillvalue='...'):
    'Decorator to make a repr function return fillvalue for a recursive call'

    def decorating_function(user_function):
        repr_running = set()

        def wrapper(self):
            key = id(self), get_ident()
            if key in repr_running:
                return fillvalue
            repr_running.add(key)
            try:
                result = user_function(self)
            finally:
                repr_running.discard(key)
            return result

        # Can't use functools.wraps() here because of bootstrap issues
        wrapper.__module__ = getattr(user_function, '__module__')
        wrapper.__doc__ = getattr(user_function, '__doc__')
        wrapper.__name__ = getattr(user_function, '__name__')
        wrapper.__annotations__ = getattr(user_function, '__annotations__', {})
        return wrapper

    return decorating_function

# OrderedDict Shim from  Raymond Hettinger, python core dev
# http://code.activestate.com/recipes/576693-ordered-dictionary-for-py24/
# here to support version 2.6.

################################################################################
### OrderedDict
################################################################################

class _Link(object):
    __slots__ = 'prev', 'next', 'key', '__weakref__'

class OrderedDict(dict):
    'Dictionary that remembers insertion order'
    # An inherited dict maps keys to values.
    # The inherited dict provides __getitem__, __len__, __contains__, and get.
    # The remaining methods are order-aware.
    # Big-O running times for all methods are the same as regular dictionaries.

    # The internal self.__map dict maps keys to links in a doubly linked list.
    # The circular doubly linked list starts and ends with a sentinel element.
    # The sentinel element never gets deleted (this simplifies the algorithm).
    # The sentinel is in self.__hardroot with a weakref proxy in self.__root.
    # The prev links are weakref proxies (to prevent circular references).
    # Individual links are kept alive by the hard reference in self.__map.
    # Those hard references disappear when a key is deleted from an OrderedDict.

    def __init__(*args, **kwds):
        '''Initialize an ordered dictionary.  The signature is the same as
        regular dictionaries, but keyword arguments are not recommended because
        their insertion order is arbitrary.

        '''
        if not args:
            raise TypeError("descriptor '__init__' of 'OrderedDict' object "
                            "needs an argument")
        self = args[0]
        args = args[1:]
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        try:
            self.__root
        except AttributeError:
            self.__hardroot = _Link()
            self.__root = root = _proxy(self.__hardroot)
            root.prev = root.next = root
            self.__map = {}
        self.__update(*args, **kwds)

    def __setitem__(self, key, value,
                    dict_setitem=dict.__setitem__, proxy=_proxy, Link=_Link):
        'od.__setitem__(i, y) <==> od[i]=y'
        # Setting a new item creates a new link at the end of the linked list,
        # and the inherited dictionary is updated with the new key/value pair.
        if key not in self:
            self.__map[key] = link = Link()
            root = self.__root
            last = root.prev
            link.prev, link.next, link.key = last, root, key
            last.next = link
            root.prev = proxy(link)
        dict_setitem(self, key, value)

    def __delitem__(self, key, dict_delitem=dict.__delitem__):
        'od.__delitem__(y) <==> del od[y]'
        # Deleting an existing item uses self.__map to find the link which gets
        # removed by updating the links in the predecessor and successor nodes.
        dict_delitem(self, key)
        link = self.__map.pop(key)
        link_prev = link.prev
        link_next = link.next
        link_prev.next = link_next
        link_next.prev = link_prev

    def __iter__(self):
        'od.__iter__() <==> iter(od)'
        # Traverse the linked list in order.
        root = self.__root
        curr = root.next
        while curr is not root:
            yield curr.key
            curr = curr.next

    def __reversed__(self):
        'od.__reversed__() <==> reversed(od)'
        # Traverse the linked list in reverse order.
        root = self.__root
        curr = root.prev
        while curr is not root:
            yield curr.key
            curr = curr.prev

    def clear(self):
        'od.clear() -> None.  Remove all items from od.'
        root = self.__root
        root.prev = root.next = root
        self.__map.clear()
        dict.clear(self)

    def popitem(self, last=True):
        '''od.popitem() -> (k, v), return and remove a (key, value) pair.
        Pairs are returned in LIFO order if last is true or FIFO order if false.

        '''
        if not self:
            raise KeyError('dictionary is empty')
        root = self.__root
        if last:
            link = root.prev
            link_prev = link.prev
            link_prev.next = root
            root.prev = link_prev
        else:
            link = root.next
            link_next = link.next
            root.next = link_next
            link_next.prev = root
        key = link.key
        del self.__map[key]
        value = dict.pop(self, key)
        return key, value

    def move_to_end(self, key, last=True):
        '''Move an existing element to the end (or beginning if last==False).

        Raises KeyError if the element does not exist.
        When last=True, acts like a fast version of self[key]=self.pop(key).

        '''
        link = self.__map[key]
        link_prev = link.prev
        link_next = link.next
        link_prev.next = link_next
        link_next.prev = link_prev
        root = self.__root
        if last:
            last = root.prev
            link.prev = last
            link.next = root
            last.next = root.prev = link
        else:
            first = root.next
            link.prev = root
            link.next = first
            root.next = first.prev = link

    def __sizeof__(self):
        sizeof = sys.getsizeof
        n = len(self) + 1                       # number of links including root
        size = sizeof(self.__dict__)            # instance dictionary
        size += sizeof(self.__map) * 2          # internal dict and inherited dict
        size += sizeof(self.__hardroot) * n     # link objects
        size += sizeof(self.__root) * n         # proxy objects
        return size

    update = __update = MutableMapping.update
    keys = MutableMapping.keys
    values = MutableMapping.values
    items = MutableMapping.items
    __ne__ = MutableMapping.__ne__

    __marker = object()

    def pop(self, key, default=__marker):
        '''od.pop(k[,d]) -> v, remove specified key and return the corresponding
        value.  If key is not found, d is returned if given, otherwise KeyError
        is raised.

        '''
        if key in self:
            result = self[key]
            del self[key]
            return result
        if default is self.__marker:
            raise KeyError(key)
        return default

    def setdefault(self, key, default=None):
        'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
        if key in self:
            return self[key]
        self[key] = default
        return default

    @recursive_repr()
    def __repr__(self):
        'od.__repr__() <==> repr(od)'
        if not self:
            return '%s()' % (self.__class__.__name__,)
        return '%s(%r)' % (self.__class__.__name__, list(self.items()))

    def __reduce__(self):
        'Return state information for pickling'
        inst_dict = vars(self).copy()
        for k in vars(OrderedDict()):
            inst_dict.pop(k, None)
        return self.__class__, (), inst_dict or None, None, iter(self.items())

    def copy(self):
        'od.copy() -> a shallow copy of od'
        return self.__class__(self)

    @classmethod
    def fromkeys(cls, iterable, value=None):
        '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
        If not specified, the value defaults to None.

        '''
        self = cls()
        for key in iterable:
            self[key] = value
        return self

    def __eq__(self, other):
        '''od.__eq__(y) <==> od==y.  Comparison to another OD is order-sensitive
        while comparison to a regular mapping is order-insensitive.

        '''
        if isinstance(other, OrderedDict):
            return dict.__eq__(self, other) and all(map(_eq, self, other))
        return dict.__eq__(self, other)

# {{{ http://code.activestate.com/recipes/576611/ (r11)

try:
    from operator import itemgetter
    from heapq import nlargest
except ImportError:
    pass

########################################################################
###  Counter
########################################################################

def _count_elements(mapping, iterable):
    'Tally elements from the iterable.'
    mapping_get = mapping.get
    for elem in iterable:
        mapping[elem] = mapping_get(elem, 0) + 1

class Counter(dict):
    '''Dict subclass for counting hashable items.  Sometimes called a bag
    or multiset.  Elements are stored as dictionary keys and their counts
    are stored as dictionary values.

    >>> c = Counter('abcdeabcdabcaba')  # count elements from a string

    >>> c.most_common(3)                # three most common elements
    [('a', 5), ('b', 4), ('c', 3)]
    >>> sorted(c)                       # list all unique elements
    ['a', 'b', 'c', 'd', 'e']
    >>> ''.join(sorted(c.elements()))   # list elements with repetitions
    'aaaaabbbbcccdde'
    >>> sum(c.values())                 # total of all counts
    15

    >>> c['a']                          # count of letter 'a'
    5
    >>> for elem in 'shazam':           # update counts from an iterable
    ...     c[elem] += 1                # by adding 1 to each element's count
    >>> c['a']                          # now there are seven 'a'
    7
    >>> del c['b']                      # remove all 'b'
    >>> c['b']                          # now there are zero 'b'
    0

    >>> d = Counter('simsalabim')       # make another counter
    >>> c.update(d)                     # add in the second counter
    >>> c['a']                          # now there are nine 'a'
    9

    >>> c.clear()                       # empty the counter
    >>> c
    Counter()

    Note:  If a count is set to zero or reduced to zero, it will remain
    in the counter until the entry is deleted or the counter is cleared:

    >>> c = Counter('aaabbc')
    >>> c['b'] -= 2                     # reduce the count of 'b' by two
    >>> c.most_common()                 # 'b' is still in, but its count is zero
    [('a', 3), ('c', 1), ('b', 0)]

    '''
    # References:
    #   http://en.wikipedia.org/wiki/Multiset
    #   http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
    #   http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
    #   http://code.activestate.com/recipes/259174/
    #   Knuth, TAOCP Vol. II section 4.6.3

    def __init__(*args, **kwds):
        '''Create a new, empty Counter object.  And if given, count elements
        from an input iterable.  Or, initialize the count from another mapping
        of elements to their counts.

        >>> c = Counter()                           # a new, empty counter
        >>> c = Counter('gallahad')                 # a new counter from an iterable
        >>> c = Counter({'a': 4, 'b': 2})           # a new counter from a mapping
        >>> c = Counter(a=4, b=2)                   # a new counter from keyword args

        '''
        if not args:
            raise TypeError("descriptor '__init__' of 'Counter' object "
                            "needs an argument")
        self = args[0]
        args = args[1:]
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        super(Counter, self).__init__()
        self.update(*args, **kwds)

    def __missing__(self, key):
        'The count of elements not in the Counter is zero.'
        # Needed so that self[missing_item] does not raise KeyError
        return 0

    def most_common(self, n=None):
        '''List the n most common elements and their counts from the most
        common to the least.  If n is None, then list all element counts.

        >>> Counter('abcdeabcdabcaba').most_common(3)
        [('a', 5), ('b', 4), ('c', 3)]

        '''
        # Emulate Bag.sortedByCount from Smalltalk
        if n is None:
            return sorted(self.items(), key=_itemgetter(1), reverse=True)
        return _heapq.nlargest(n, self.items(), key=_itemgetter(1))

    def elements(self):
        '''Iterator over elements repeating each as many times as its count.

        >>> c = Counter('ABCABC')
        >>> sorted(c.elements())
        ['A', 'A', 'B', 'B', 'C', 'C']

        # Knuth's example for prime factors of 1836:  2**2 * 3**3 * 17**1
        >>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
        >>> product = 1
        >>> for factor in prime_factors.elements():     # loop over factors
        ...     product *= factor                       # and multiply them
        >>> product
        1836

        Note, if an element's count has been set to zero or is a negative
        number, elements() will ignore it.

        '''
        # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
        return _chain.from_iterable(_starmap(_repeat, self.items()))

    # Override dict methods where necessary

    @classmethod
    def fromkeys(cls, iterable, v=None):
        # There is no equivalent method for counters because setting v=1
        # means that no element can have a count greater than one.
        raise NotImplementedError(
            'Counter.fromkeys() is undefined.  Use Counter(iterable) instead.')

    def update(*args, **kwds):
        '''Like dict.update() but add counts instead of replacing them.

        Source can be an iterable, a dictionary, or another Counter instance.

        >>> c = Counter('which')
        >>> c.update('witch')           # add elements from another iterable
        >>> d = Counter('watch')
        >>> c.update(d)                 # add elements from another counter
        >>> c['h']                      # four 'h' in which, witch, and watch
        4

        '''
        # The regular dict.update() operation makes no sense here because the
        # replace behavior results in the some of original untouched counts
        # being mixed-in with all of the other counts for a mismash that
        # doesn't have a straight-forward interpretation in most counting
        # contexts.  Instead, we implement straight-addition.  Both the inputs
        # and outputs are allowed to contain zero and negative counts.

        if not args:
            raise TypeError("descriptor 'update' of 'Counter' object "
                            "needs an argument")
        self = args[0]
        args = args[1:]
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        iterable = args[0] if args else None
        if iterable is not None:
            if isinstance(iterable, Mapping):
                if self:
                    self_get = self.get
                    for elem, count in iterable.items():
                        self[elem] = count + self_get(elem, 0)
                else:
                    super(Counter, self).update(iterable) # fast path when counter is empty
            else:
                _count_elements(self, iterable)
        if kwds:
            self.update(kwds)

    def subtract(*args, **kwds):
        '''Like dict.update() but subtracts counts instead of replacing them.
        Counts can be reduced below zero.  Both the inputs and outputs are
        allowed to contain zero and negative counts.

        Source can be an iterable, a dictionary, or another Counter instance.

        >>> c = Counter('which')
        >>> c.subtract('witch')             # subtract elements from another iterable
        >>> c.subtract(Counter('watch'))    # subtract elements from another counter
        >>> c['h']                          # 2 in which, minus 1 in witch, minus 1 in watch
        0
        >>> c['w']                          # 1 in which, minus 1 in witch, minus 1 in watch
        -1

        '''
        if not args:
            raise TypeError("descriptor 'subtract' of 'Counter' object "
                            "needs an argument")
        self = args[0]
        args = args[1:]
        if len(args) > 1:
            raise TypeError('expected at most 1 arguments, got %d' % len(args))
        iterable = args[0] if args else None
        if iterable is not None:
            self_get = self.get
            if isinstance(iterable, Mapping):
                for elem, count in iterable.items():
                    self[elem] = self_get(elem, 0) - count
            else:
                for elem in iterable:
                    self[elem] = self_get(elem, 0) - 1
        if kwds:
            self.subtract(kwds)

    def copy(self):
        'Return a shallow copy.'
        return self.__class__(self)

    def __reduce__(self):
        return self.__class__, (dict(self),)

    def __delitem__(self, elem):
        'Like dict.__delitem__() but does not raise KeyError for missing values.'
        if elem in self:
            super(Counter, self).__delitem__(elem)

    def __repr__(self):
        if not self:
            return '%s()' % self.__class__.__name__
        try:
            items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
            return '%s({%s})' % (self.__class__.__name__, items)
        except TypeError:
            # handle case where values are not orderable
            return '{0}({1!r})'.format(self.__class__.__name__, dict(self))

    # Multiset-style mathematical operations discussed in:
    #       Knuth TAOCP Volume II section 4.6.3 exercise 19
    #       and at http://en.wikipedia.org/wiki/Multiset
    #
    # Outputs guaranteed to only include positive counts.
    #
    # To strip negative and zero counts, add-in an empty counter:
    #       c += Counter()

    def __add__(self, other):
        '''Add counts from two counters.

        >>> Counter('abbb') + Counter('bcc')
        Counter({'b': 4, 'c': 2, 'a': 1})

        '''
        if not isinstance(other, Counter):
            return NotImplemented
        result = Counter()
        for elem, count in self.items():
            newcount = count + other[elem]
            if newcount > 0:
                result[elem] = newcount
        for elem, count in other.items():
            if elem not in self and count > 0:
                result[elem] = count
        return result

    def __sub__(self, other):
        ''' Subtract count, but keep only results with positive counts.

        >>> Counter('abbbc') - Counter('bccd')
        Counter({'b': 2, 'a': 1})

        '''
        if not isinstance(other, Counter):
            return NotImplemented
        result = Counter()
        for elem, count in self.items():
            newcount = count - other[elem]
            if newcount > 0:
                result[elem] = newcount
        for elem, count in other.items():
            if elem not in self and count < 0:
                result[elem] = 0 - count
        return result

    def __or__(self, other):
        '''Union is the maximum of value in either of the input counters.

        >>> Counter('abbb') | Counter('bcc')
        Counter({'b': 3, 'c': 2, 'a': 1})

        '''
        if not isinstance(other, Counter):
            return NotImplemented
        result = Counter()
        for elem, count in self.items():
            other_count = other[elem]
            newcount = other_count if count < other_count else count
            if newcount > 0:
                result[elem] = newcount
        for elem, count in other.items():
            if elem not in self and count > 0:
                result[elem] = count
        return result

    def __and__(self, other):
        ''' Intersection is the minimum of corresponding counts.

        >>> Counter('abbb') & Counter('bcc')
        Counter({'b': 1})

        '''
        if not isinstance(other, Counter):
            return NotImplemented
        result = Counter()
        for elem, count in self.items():
            other_count = other[elem]
            newcount = count if count < other_count else other_count
            if newcount > 0:
                result[elem] = newcount
        return result

    def __pos__(self):
        'Adds an empty counter, effectively stripping negative and zero counts'
        return self + Counter()

    def __neg__(self):
        '''Subtracts from an empty counter.  Strips positive and zero counts,
        and flips the sign on negative counts.

        '''
        return Counter() - self

    def _keep_positive(self):
        '''Internal method to strip elements with a negative or zero count'''
        nonpositive = [elem for elem, count in self.items() if not count > 0]
        for elem in nonpositive:
            del self[elem]
        return self

    def __iadd__(self, other):
        '''Inplace add from another counter, keeping only positive counts.

        >>> c = Counter('abbb')
        >>> c += Counter('bcc')
        >>> c
        Counter({'b': 4, 'c': 2, 'a': 1})

        '''
        for elem, count in other.items():
            self[elem] += count
        return self._keep_positive()

    def __isub__(self, other):
        '''Inplace subtract counter, but keep only results with positive counts.

        >>> c = Counter('abbbc')
        >>> c -= Counter('bccd')
        >>> c
        Counter({'b': 2, 'a': 1})

        '''
        for elem, count in other.items():
            self[elem] -= count
        return self._keep_positive()

    def __ior__(self, other):
        '''Inplace union is the maximum of value from either counter.

        >>> c = Counter('abbb')
        >>> c |= Counter('bcc')
        >>> c
        Counter({'b': 3, 'c': 2, 'a': 1})

        '''
        for elem, other_count in other.items():
            count = self[elem]
            if other_count > count:
                self[elem] = other_count
        return self._keep_positive()

    def __iand__(self, other):
        '''Inplace intersection is the minimum of corresponding counts.

        >>> c = Counter('abbb')
        >>> c &= Counter('bcc')
        >>> c
        Counter({'b': 1})

        '''
        for elem, count in self.items():
            other_count = other[elem]
            if other_count < count:
                self[elem] = other_count
        return self._keep_positive()

def check_output(*popenargs, **kwargs):
    """
    For Python 2.6 compatibility: see
    http://stackoverflow.com/questions/4814970/
    """

    if 'stdout' in kwargs:
        raise ValueError('stdout argument not allowed, it will be overridden.')
    process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
    output, unused_err = process.communicate()
    retcode = process.poll()
    if retcode:
        cmd = kwargs.get("args")
        if cmd is None:
            cmd = popenargs[0]
        raise subprocess.CalledProcessError(retcode, cmd)
    return output

def count(start=0, step=1):
    """
    ``itertools.count`` in Py 2.6 doesn't accept a step
    parameter. This is an enhanced version of ``itertools.count``
    for Py2.6 equivalent to ``itertools.count`` in Python 2.7+.
    """
    while True:
        yield start
        start += step

########################################################################
###  ChainMap (helper for configparser and string.Template)
###  From the Py3.4 source code. See also:
###    https://github.com/kkxue/Py2ChainMap/blob/master/py2chainmap.py
########################################################################

class ChainMap(MutableMapping):
    ''' A ChainMap groups multiple dicts (or other mappings) together
    to create a single, updateable view.

    The underlying mappings are stored in a list.  That list is public and can
    accessed or updated using the *maps* attribute.  There is no other state.

    Lookups search the underlying mappings successively until a key is found.
    In contrast, writes, updates, and deletions only operate on the first
    mapping.

    '''

    def __init__(self, *maps):
        '''Initialize a ChainMap by setting *maps* to the given mappings.
        If no mappings are provided, a single empty dictionary is used.

        '''
        self.maps = list(maps) or [{}]          # always at least one map

    def __missing__(self, key):
        raise KeyError(key)

    def __getitem__(self, key):
        for mapping in self.maps:
            try:
                return mapping[key]             # can't use 'key in mapping' with defaultdict
            except KeyError:
                pass
        return self.__missing__(key)            # support subclasses that define __missing__

    def get(self, key, default=None):
        return self[key] if key in self else default

    def __len__(self):
        return len(set().union(*self.maps))     # reuses stored hash values if possible

    def __iter__(self):
        return iter(set().union(*self.maps))

    def __contains__(self, key):
        return any(key in m for m in self.maps)

    def __bool__(self):
        return any(self.maps)

    # Py2 compatibility:
    __nonzero__ = __bool__

    @recursive_repr()
    def __repr__(self):
        return '{0.__class__.__name__}({1})'.format(
            self, ', '.join(map(repr, self.maps)))

    @classmethod
    def fromkeys(cls, iterable, *args):
        'Create a ChainMap with a single dict created from the iterable.'
        return cls(dict.fromkeys(iterable, *args))

    def copy(self):
        'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]'
        return self.__class__(self.maps[0].copy(), *self.maps[1:])

    __copy__ = copy

    def new_child(self, m=None):                # like Django's Context.push()
        '''
        New ChainMap with a new map followed by all previous maps. If no
        map is provided, an empty dict is used.
        '''
        if m is None:
            m = {}
        return self.__class__(m, *self.maps)

    @property
    def parents(self):                          # like Django's Context.pop()
        'New ChainMap from maps[1:].'
        return self.__class__(*self.maps[1:])

    def __setitem__(self, key, value):
        self.maps[0][key] = value

    def __delitem__(self, key):
        try:
            del self.maps[0][key]
        except KeyError:
            raise KeyError('Key not found in the first mapping: {0!r}'.format(key))

    def popitem(self):
        'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.'
        try:
            return self.maps[0].popitem()
        except KeyError:
            raise KeyError('No keys found in the first mapping.')

    def pop(self, key, *args):
        'Remove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].'
        try:
            return self.maps[0].pop(key, *args)
        except KeyError:
            raise KeyError('Key not found in the first mapping: {0!r}'.format(key))

    def clear(self):
        'Clear maps[0], leaving maps[1:] intact.'
        self.maps[0].clear()

# Re-use the same sentinel as in the Python stdlib socket module:
from socket import _GLOBAL_DEFAULT_TIMEOUT
# Was: _GLOBAL_DEFAULT_TIMEOUT = object()

def create_connection(address, timeout=_GLOBAL_DEFAULT_TIMEOUT,
                      source_address=None):
    """Backport of 3-argument create_connection() for Py2.6.

    Connect to *address* and return the socket object.

    Convenience function.  Connect to *address* (a 2-tuple ``(host,
    port)``) and return the socket object.  Passing the optional
    *timeout* parameter will set the timeout on the socket instance
    before attempting to connect.  If no *timeout* is supplied, the
    global default timeout setting returned by :func:`getdefaulttimeout`
    is used.  If *source_address* is set it must be a tuple of (host, port)
    for the socket to bind as a source address before making the connection.
    An host of '' or port 0 tells the OS to use the default.
    """

    host, port = address
    err = None
    for res in getaddrinfo(host, port, 0, SOCK_STREAM):
        af, socktype, proto, canonname, sa = res
        sock = None
        try:
            sock = socket(af, socktype, proto)
            if timeout is not _GLOBAL_DEFAULT_TIMEOUT:
                sock.settimeout(timeout)
            if source_address:
                sock.bind(source_address)
            sock.connect(sa)
            return sock

        except error as _:
            err = _
            if sock is not None:
                sock.close()

    if err is not None:
        raise err
    else:
        raise error("getaddrinfo returns an empty list")

# Backport from Py2.7 for Py2.6:
def cmp_to_key(mycmp):
    """Convert a cmp= function into a key= function"""
    class K(object):
        __slots__ = ['obj']
        def __init__(self, obj, *args):
            self.obj = obj
        def __lt__(self, other):
            return mycmp(self.obj, other.obj) < 0
        def __gt__(self, other):
            return mycmp(self.obj, other.obj) > 0
        def __eq__(self, other):
            return mycmp(self.obj, other.obj) == 0
        def __le__(self, other):
            return mycmp(self.obj, other.obj) <= 0
        def __ge__(self, other):
            return mycmp(self.obj, other.obj) >= 0
        def __ne__(self, other):
            return mycmp(self.obj, other.obj) != 0
        def __hash__(self):
            raise TypeError('hash not implemented')
    return K

# Back up our definitions above in case they're useful
_OrderedDict = OrderedDict
_Counter = Counter
_check_output = check_output
_count = count
_ceil = ceil
__count_elements = _count_elements
_recursive_repr = recursive_repr
_ChainMap = ChainMap
_create_connection = create_connection
_cmp_to_key = cmp_to_key

# Overwrite the definitions above with the usual ones
# from the standard library:
if sys.version_info >= (2, 7):
    from collections import OrderedDict, Counter
    from itertools import count
    from functools import cmp_to_key
    try:
        from subprocess import check_output
    except ImportError:
        # Not available. This happens with Google App Engine: see issue #231
        pass
    from socket import create_connection

if sys.version_info >= (3, 0):
    from math import ceil
    from collections import _count_elements

if sys.version_info >= (3, 3):
    from reprlib import recursive_repr
    from collections import ChainMap


text: from traitsui.qt4.list_editor import *

redpajama_set_name: RedPajamaGithub


text:
const gear = require("../../gearbox.js");
const paths = require("../../paths.json");
const locale = require('../../../utils/multilang_b');
const mm = locale.getT();

const cmd = 'set';

const init = async function (message, userDB, DB) {
//HELP TRIGGER
const P = {lngs:message.lang};
if(gear.autoHelper([mm("helpkey",P)],{cmd,message,opt:this.cat}))return;
if(gear.autoHelper(['noargs'],{cmd,message,opt:this.cat}));
//------------

  const On = gear.emoji("yep")
  const Off = gear.emoji("nope")

  const Server = message.guild;
  const Channel = message.channel;
  const Author = message.author;

  const Member = message.member;
  const Target = message.mentions.users.first() || Author;
  const MSG = message.content;

  const args = MSG.split(' ').slice(1)
  const LANG = message.lang;

    const modPass = await gear.hasPerms(Member,gear.serverDB);
      if (!modPass)return message.reply(mm('CMD.moderationNeeded',P)).catch(e=>console.warn);

  if(message.args[0]=="ignore"&&message.args[1]=="all"){
    channels = Server.channels.map(x=>x.id)
    //console.log(channels)
    await gear.channelDB.updateMany({id:{$in:channels}},{$set:{'ignored':true}});
    return message.reply(On+" Ignoring **all channels**. use `plx!set unignore` to revert");
  }
  if(message.args[0]=="ignore"){
    await gear.channelDB.set(Channel.id,{$set:{'ignored':true}});
    return message.reply(On+" Ignoring this channel. use `plx!set unignore` to revert");
  }
  if(message.args[0]=="unignore"&&message.args[1]=="all"){
   await gear.channelDB.updateMany({id:{$in:Server.channels.map(x=>x.id)}},{$set:{'ignored':false}});
    return message.reply(On+" Reading all channels. use `plx!set ignore` to revert");
  }
  if(message.args[0]=="unignore"){
   await  gear.channelDB.set(Channel.id,{$set:{'ignored':false}});
   return  message.reply(On+" Reading this channel. use `plx!set ignore` to revert");
  }
}
 module.exports = {pub:true,cmd: cmd, perms: 2, init: init, cat: 'mod'};


text:
{% extends base_template %}
{% load staticfiles %}

{% block pagecontent %}

Access Denied!

You are not authorized to view this page.

Please request admin, for getting access to this location

{% endblock %}


text:
app_dir="$(cd "$(dirname "$0")/../.."; pwd -P)"

# Mac app only startup shell - complete rewrite for starting from a GRASS.app
# in Mac OS X.  Sets defaults for unset env, adds some Mac-only config.

trap "echo 'User break!' ; exit" 2 3 9 15

# dummy for now - just saying we're starting GRASS.app on OSX
export GRASS_OS_STARTUP="Mac.app"

### change this to dirname/MacOS or dirname/Resources??
### set it this way instead of a direct path

export GISBASE=$app_dir/Contents/Resources
grass_ver=$(cut -d . -f 1-2 "$GISBASE/etc/VERSIONNUMBER")

export GISBASE_USER="$HOME/Library/GRASS/$grass_ver"
export GISBASE_SYSTEM="/Library/GRASS/$grass_ver"

# location of epsg database and other files needed by GDAL
export GDAL_DATA="$GISBASE/share/gdal"

# add some OS X style app support paths, and create user one if missing.
mkdir -p "$GISBASE_USER/Modules/bin"
mkdir -p "$GISBASE_USER/Modules/scripts"
if [ ! "$GRASS_ADDON_BASE" ] ; then
	GRASS_ADDON_BASE="$GISBASE_USER/Modules"
fi
export GRASS_ADDON_BASE

mkdir -p "$GISBASE_USER/Modules/etc"
addpath="$GISBASE_USER/Modules/etc:$GISBASE_SYSTEM/Modules/etc"
if [ "$GRASS_ADDON_ETC" ] ; then
	GRASS_ADDON_ETC="$GRASS_ADDON_ETC:$addpath"
else
	GRASS_ADDON_ETC="$addpath"
fi
export GRASS_ADDON_ETC

mkdir -p "$GISBASE_USER/Modules/lib"
mkdir -p "$GISBASE_USER/Modules/docs/html"

# rebuild addon html index and gui menus
"$app_dir/Contents/MacOS/build_html_user_index.sh" "$GISBASE"
"$app_dir/Contents/MacOS/build_gui_user_menu.sh"

# user fontcap files
if [ ! "$GRASS_FONT_CAP" ] ; then
	GRASS_FONT_CAP="$GISBASE_USER/Modules/etc/fontcap"
fi
export GRASS_FONT_CAP

### replaced all the prior code for finding Python and wxPython
export GRASS_PYTHON="$GISBASE/bin/pythonw"
export GRASS_PYTHONWX="$GISBASE/bin/pythonw"

# use the python wrapper to start grass
"$GRASS_PYTHON" "$GISBASE/bin/grass72" "-gui" "$@"


text:
{{title}}

<form role="form" name="frmListSponsors" class="form-horizontal" novalidate ng-submit="fetchData()">

        Year Submitted

            <select class="form-control col-sm-2" name="yearrequested" data-ng-model="formData.yearrequested" ng-change="fetchData()" ng-init="initialize()">
                <option data-ng-repeat="yearavailable in resultset.yearsavailable" value="{{yearavailable.year}}" ng-selected ="isSelected(yearavailable.year)">{{yearavailable.year}}</option>
            </select>

        Contest

            <select class="form-control col-sm-2" name="contest" data-ng-model="formData.contest" ng-change="fetchData()">
                <option selected disabled value="">-- Please Select --</option>
                <option value="ESSAY" >Childrens Essay Competition</option>
                <option value="ART">Childrens Art Competition</option>
                <option value="TALENT" >Childrens Talent Show</option>

                <option value="PHOTO" >Open Photography Contest</option>
                <option value="CONCH">Open Conch Shell Contest</option>
            </select>

        Contestant

            <input type="text" class="form-control" name="contestant" placeholder="Contestant"  data-ng-model="formData.contestant" change-on-blur="fetchData()" data-ng-minlength="3" data-ng-maxlength="100">

        Contact

            <input type="text" class="form-control" name="contact" placeholder="Contact"  data-ng-model="formData.contact" change-on-blur="fetchData()" data-ng-minlength="3" data-ng-maxlength="100">

        Phone

            <input type="text" class="form-control" name="phone" placeholder="Phone"  data-ng-model="formData.phone" change-on-blur="fetchData()" data-ng-minlength="3" data-ng-maxlength="100">

        Email

            <input type="text" class="form-control" name="email" placeholder="Email"  data-ng-model="formData.email" change-on-blur="fetchData()" data-ng-minlength="3" data-ng-maxlength="100">

            <button type="submit" class="btn btn-primary pull-right"  data-ng-click="fetchData()">Submit</button>

            <button type="button" class="btn btn-default"  data-ng-click="clear()">Clear</button>

</form>

                    Date

                    Contest

                    Contestant

                    Age

                    Contact

                    Phone

                    Email

            Submission Type
            File
            Message
            IP

            {{formatDate(sub.date)}}
            {{sub.competition}}
            {{sub.name}}
            {{sub.age}}
            {{sub.contact}}
            {{formatPhoneNumber(sub.phone)}}
            {{sub.email}}
            {{sub.file_type}}
            Link
            {{sub.message}}
            {{sub.ipaddress}}

    {{ msgs}}{{ errors}}

Add New Contest Entry

Return to Dashboard


text:
require 'value_graph_transformation'

module ValueGraphTransformation
  describe Context do
    let!(:context) { Context.new }

    it "is a Graph" do
      expect(context).to be_a(Graph::Graph)
    end

    describe "#function" do

      it "should fail unless the type is a class that inherits from Function" do
        expect {
          context.function(String, [],[])
        }.to raise_error(RuntimeError, "'String' is not a function.")
      end

      it "should fail unless all input objects are Value objects" do
        expect {
          context.function(Function, ["foo"], [])
        }.to raise_error(RuntimeError, "input not Value objects")
      end

      it "should fail unless all output objects are Value objects" do
        expect {
          context.function(Function, [], ["foo"])
        }.to raise_error(RuntimeError, "output not Value objects")
      end

      it "should return a Function" do
        expect(context.function(Function, [], [])).to be_a(Function)
      end

      it "should connect the input and output vertices" do
        in1 = context.value_for(nil)
        in2 = context.value_for(nil)
        out = context.value_for(nil)
        function = context.function(Function, [in1, in2], [out])

        expect(in1.targets.first.target).to eq(function)
        expect(in2.targets.first.target).to eq(function)
        expect(function.sources[0].source).to eq(in1)
        expect(function.sources[1].source).to eq(in2)

        expect(function.targets.first.target).to eq(out)
        expect(out.sources.first.source).to eq(function)
      end

      it "should add the function to the context's list of vertices" do
        function = context.function(Function, [], [])

        expect(context.vertices).to include(function)
      end
    end

    describe "#value_for" do

      it "should return a Value object" do
        expect(context.value_for(nil)).to be_a(Value)
        expect(context.value_for("foo")).to be_a(Value)
        expect(context.value_for(12)).to be_a(Value)
      end

      it "should return the same Value if identifier has been given earlier" do
        a = context.value_for("foo")
        b = context.value_for("foo")

        expect(a).to eq(b)
      end

      it "should always create new Value objects if nil is given as identifier" do
        a = context.value_for(nil)
        b = context.value_for(nil)

        expect(a).not_to eq(b)
      end
    end

  end
end


text:
/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.2
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

package org.opensim.modeling;

/**
 * An ExternalForce is a Force class specialized at applying an external force

 * and/or torque to a body as described by arrays (columns) of a Storage object.

 * The source of the Storage may be experimental sensor recording or user

 * generated data. The Storage must be able to supply (1) an array of time, (2)

 * arrays for the x,y,z, components of force and/or torque in time. Optionally,

 * (3) arrays for the point of force application in time. An ExternalForce

 * must specify the identifier (e.g. Force1.x Force1.y Force1.z) for the force

 * components (columns) listed in the Storage either by individual labels or

 * collectively (e.g. as "Force1"). Similarly, identifiers for the applied

 * torque and optionally the point of force application must be specified.

 *

 * If an identifier is supplied and it cannot uniquely identify the force data

 * (e.g. the force, torque, or point) in the Storage, then an Exception is

 * thrown.

 *

 * An ExternalForce must apply at least a force or a torque and therefore both

 * identifiers cannot be empty.

 *

 * @author Ajay Seth
 */
public class ExternalForce extends Force {
  private transient long swigCPtr;

  public ExternalForce(long cPtr, boolean cMemoryOwn) {
    super(opensimSimulationJNI.ExternalForce_SWIGUpcast(cPtr), cMemoryOwn);
    swigCPtr = cPtr;
  }

  public static long getCPtr(ExternalForce obj) {
    return (obj == null) ? 0 : obj.swigCPtr;
  }

  @SuppressWarnings("deprecation")
  protected void finalize() {
    delete();
  }

  public synchronized void delete() {
    if (swigCPtr != 0) {
      if (swigCMemOwn) {
        swigCMemOwn = false;
        opensimSimulationJNI.delete_ExternalForce(swigCPtr);
      }
      swigCPtr = 0;
    }
    super.delete();
  }

  public static ExternalForce safeDownCast(OpenSimObject obj) {
    long cPtr = opensimSimulationJNI.ExternalForce_safeDownCast(OpenSimObject.getCPtr(obj), obj);
    return (cPtr == 0) ? null : new ExternalForce(cPtr, false);
  }

  public void assign(OpenSimObject aObject) {
    opensimSimulationJNI.ExternalForce_assign(swigCPtr, this, OpenSimObject.getCPtr(aObject), aObject);
  }

  public static String getClassName() {
    return opensimSimulationJNI.ExternalForce_getClassName();
  }

  public OpenSimObject clone() {
    long cPtr = opensimSimulationJNI.ExternalForce_clone(swigCPtr, this);
    return (cPtr == 0) ? null : new ExternalForce(cPtr, true);
  }

  public String getConcreteClassName() {
    return opensimSimulationJNI.ExternalForce_getConcreteClassName(swigCPtr, this);
  }

  public void copyProperty_applied_to_body(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_applied_to_body(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_applied_to_body(int i) {
    return opensimSimulationJNI.ExternalForce_get_applied_to_body__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_applied_to_body(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_applied_to_body__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_applied_to_body(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_applied_to_body__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_applied_to_body(String value) {
    return opensimSimulationJNI.ExternalForce_append_applied_to_body(swigCPtr, this, value);
  }

  public void constructProperty_applied_to_body(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_applied_to_body(swigCPtr, this, initValue);
  }

  public String get_applied_to_body() {
    return opensimSimulationJNI.ExternalForce_get_applied_to_body__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_applied_to_body() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_applied_to_body__SWIG_1(swigCPtr, this), false);
  }

  public void set_applied_to_body(String value) {
    opensimSimulationJNI.ExternalForce_set_applied_to_body__SWIG_1(swigCPtr, this, value);
  }

  public void copyProperty_force_expressed_in_body(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_force_expressed_in_body(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_force_expressed_in_body(int i) {
    return opensimSimulationJNI.ExternalForce_get_force_expressed_in_body__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_force_expressed_in_body(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_force_expressed_in_body__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_force_expressed_in_body(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_force_expressed_in_body__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_force_expressed_in_body(String value) {
    return opensimSimulationJNI.ExternalForce_append_force_expressed_in_body(swigCPtr, this, value);
  }

  public void constructProperty_force_expressed_in_body(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_force_expressed_in_body(swigCPtr, this, initValue);
  }

  public String get_force_expressed_in_body() {
    return opensimSimulationJNI.ExternalForce_get_force_expressed_in_body__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_force_expressed_in_body() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_force_expressed_in_body__SWIG_1(swigCPtr, this), false);
  }

  public void set_force_expressed_in_body(String value) {
    opensimSimulationJNI.ExternalForce_set_force_expressed_in_body__SWIG_1(swigCPtr, this, value);
  }

  public void copyProperty_point_expressed_in_body(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_point_expressed_in_body(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_point_expressed_in_body(int i) {
    return opensimSimulationJNI.ExternalForce_get_point_expressed_in_body__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_point_expressed_in_body(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_point_expressed_in_body__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_point_expressed_in_body(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_point_expressed_in_body__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_point_expressed_in_body(String value) {
    return opensimSimulationJNI.ExternalForce_append_point_expressed_in_body(swigCPtr, this, value);
  }

  public void constructProperty_point_expressed_in_body(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_point_expressed_in_body(swigCPtr, this, initValue);
  }

  public String get_point_expressed_in_body() {
    return opensimSimulationJNI.ExternalForce_get_point_expressed_in_body__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_point_expressed_in_body() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_point_expressed_in_body__SWIG_1(swigCPtr, this), false);
  }

  public void set_point_expressed_in_body(String value) {
    opensimSimulationJNI.ExternalForce_set_point_expressed_in_body__SWIG_1(swigCPtr, this, value);
  }

  public void copyProperty_force_identifier(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_force_identifier(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_force_identifier(int i) {
    return opensimSimulationJNI.ExternalForce_get_force_identifier__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_force_identifier(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_force_identifier__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_force_identifier(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_force_identifier__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_force_identifier(String value) {
    return opensimSimulationJNI.ExternalForce_append_force_identifier(swigCPtr, this, value);
  }

  public void constructProperty_force_identifier() {
    opensimSimulationJNI.ExternalForce_constructProperty_force_identifier__SWIG_0(swigCPtr, this);
  }

  public void constructProperty_force_identifier(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_force_identifier__SWIG_1(swigCPtr, this, initValue);
  }

  public String get_force_identifier() {
    return opensimSimulationJNI.ExternalForce_get_force_identifier__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_force_identifier() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_force_identifier__SWIG_1(swigCPtr, this), false);
  }

  public void set_force_identifier(String value) {
    opensimSimulationJNI.ExternalForce_set_force_identifier__SWIG_1(swigCPtr, this, value);
  }

  public void copyProperty_point_identifier(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_point_identifier(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_point_identifier(int i) {
    return opensimSimulationJNI.ExternalForce_get_point_identifier__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_point_identifier(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_point_identifier__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_point_identifier(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_point_identifier__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_point_identifier(String value) {
    return opensimSimulationJNI.ExternalForce_append_point_identifier(swigCPtr, this, value);
  }

  public void constructProperty_point_identifier() {
    opensimSimulationJNI.ExternalForce_constructProperty_point_identifier__SWIG_0(swigCPtr, this);
  }

  public void constructProperty_point_identifier(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_point_identifier__SWIG_1(swigCPtr, this, initValue);
  }

  public String get_point_identifier() {
    return opensimSimulationJNI.ExternalForce_get_point_identifier__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_point_identifier() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_point_identifier__SWIG_1(swigCPtr, this), false);
  }

  public void set_point_identifier(String value) {
    opensimSimulationJNI.ExternalForce_set_point_identifier__SWIG_1(swigCPtr, this, value);
  }

  public void copyProperty_torque_identifier(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_torque_identifier(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_torque_identifier(int i) {
    return opensimSimulationJNI.ExternalForce_get_torque_identifier__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_torque_identifier(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_torque_identifier__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_torque_identifier(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_torque_identifier__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_torque_identifier(String value) {
    return opensimSimulationJNI.ExternalForce_append_torque_identifier(swigCPtr, this, value);
  }

  public void constructProperty_torque_identifier() {
    opensimSimulationJNI.ExternalForce_constructProperty_torque_identifier__SWIG_0(swigCPtr, this);
  }

  public void constructProperty_torque_identifier(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_torque_identifier__SWIG_1(swigCPtr, this, initValue);
  }

  public String get_torque_identifier() {
    return opensimSimulationJNI.ExternalForce_get_torque_identifier__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_torque_identifier() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_torque_identifier__SWIG_1(swigCPtr, this), false);
  }

  public void set_torque_identifier(String value) {
    opensimSimulationJNI.ExternalForce_set_torque_identifier__SWIG_1(swigCPtr, this, value);
  }

  public void copyProperty_data_source_name(ExternalForce source) {
    opensimSimulationJNI.ExternalForce_copyProperty_data_source_name(swigCPtr, this, ExternalForce.getCPtr(source), source);
  }

  public String get_data_source_name(int i) {
    return opensimSimulationJNI.ExternalForce_get_data_source_name__SWIG_0(swigCPtr, this, i);
  }

  public SWIGTYPE_p_std__string upd_data_source_name(int i) {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_data_source_name__SWIG_0(swigCPtr, this, i), false);
  }

  public void set_data_source_name(int i, String value) {
    opensimSimulationJNI.ExternalForce_set_data_source_name__SWIG_0(swigCPtr, this, i, value);
  }

  public int append_data_source_name(String value) {
    return opensimSimulationJNI.ExternalForce_append_data_source_name(swigCPtr, this, value);
  }

  public void constructProperty_data_source_name() {
    opensimSimulationJNI.ExternalForce_constructProperty_data_source_name__SWIG_0(swigCPtr, this);
  }

  public void constructProperty_data_source_name(String initValue) {
    opensimSimulationJNI.ExternalForce_constructProperty_data_source_name__SWIG_1(swigCPtr, this, initValue);
  }

  public String get_data_source_name() {
    return opensimSimulationJNI.ExternalForce_get_data_source_name__SWIG_1(swigCPtr, this);
  }

  public SWIGTYPE_p_std__string upd_data_source_name() {
    return new SWIGTYPE_p_std__string(opensimSimulationJNI.ExternalForce_upd_data_source_name__SWIG_1(swigCPtr, this), false);
  }

  public void set_data_source_name(String value) {
    opensimSimulationJNI.ExternalForce_set_data_source_name__SWIG_1(swigCPtr, this, value);
  }

  /**
   * Default Construct of an ExternalForce.

   * By default ExternalForce has data source identified by name.

   * By setup() time, Tool or modeler must setDataSource() on this Force for

   * it to be able to apply any force. Otherwise, an exception is thrown.
   */
  public ExternalForce() {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_0(), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   * @param forceIdentifier

   *      string used to access the force data in the dataSource

   * @param pointIdentifier

   *      string used to access the point of application of the force in

   *      dataSource

   * @param torqueIdentifier

   *      string used to access the force data in the dataSource

   * @param appliedToBodyName

   *      string used to specify the body to which the force is applied

   * @param forceExpressedInBodyName

   *      string used to define in which body the force is expressed

   * @param pointExpressedInBodyName

   *      string used to define the body in which the point is expressed
   */
  public ExternalForce(Storage dataSource, String forceIdentifier, String pointIdentifier, String torqueIdentifier, String appliedToBodyName, String forceExpressedInBodyName, String pointExpressedInBodyName) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_1(Storage.getCPtr(dataSource), dataSource, forceIdentifier, pointIdentifier, torqueIdentifier, appliedToBodyName, forceExpressedInBodyName, pointExpressedInBodyName), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   * @param forceIdentifier

   *      string used to access the force data in the dataSource

   * @param pointIdentifier

   *      string used to access the point of application of the force in

   *      dataSource

   * @param torqueIdentifier

   *      string used to access the force data in the dataSource

   * @param appliedToBodyName

   *      string used to specify the body to which the force is applied

   * @param forceExpressedInBodyName

   *      string used to define in which body the force is expressed

   *
   */
  public ExternalForce(Storage dataSource, String forceIdentifier, String pointIdentifier, String torqueIdentifier, String appliedToBodyName, String forceExpressedInBodyName) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_2(Storage.getCPtr(dataSource), dataSource, forceIdentifier, pointIdentifier, torqueIdentifier, appliedToBodyName, forceExpressedInBodyName), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   * @param forceIdentifier

   *      string used to access the force data in the dataSource

   * @param pointIdentifier

   *      string used to access the point of application of the force in

   *      dataSource

   * @param torqueIdentifier

   *      string used to access the force data in the dataSource

   * @param appliedToBodyName

   *      string used to specify the body to which the force is applied

   *

   *
   */
  public ExternalForce(Storage dataSource, String forceIdentifier, String pointIdentifier, String torqueIdentifier, String appliedToBodyName) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_3(Storage.getCPtr(dataSource), dataSource, forceIdentifier, pointIdentifier, torqueIdentifier, appliedToBodyName), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   * @param forceIdentifier

   *      string used to access the force data in the dataSource

   * @param pointIdentifier

   *      string used to access the point of application of the force in

   *      dataSource

   * @param torqueIdentifier

   *      string used to access the force data in the dataSource

   *

   *

   *
   */
  public ExternalForce(Storage dataSource, String forceIdentifier, String pointIdentifier, String torqueIdentifier) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_4(Storage.getCPtr(dataSource), dataSource, forceIdentifier, pointIdentifier, torqueIdentifier), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   * @param forceIdentifier

   *      string used to access the force data in the dataSource

   * @param pointIdentifier

   *      string used to access the point of application of the force in

   *      dataSource

   *

   *

   *

   *
   */
  public ExternalForce(Storage dataSource, String forceIdentifier, String pointIdentifier) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_5(Storage.getCPtr(dataSource), dataSource, forceIdentifier, pointIdentifier), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   * @param forceIdentifier

   *      string used to access the force data in the dataSource

   *

   *

   *

   *

   *
   */
  public ExternalForce(Storage dataSource, String forceIdentifier) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_6(Storage.getCPtr(dataSource), dataSource, forceIdentifier), true);
  }

  /**
   * Convenience Constructor of an ExternalForce.

   *

   * @param dataSource

   *      a storage containing the pertinent force data through time

   *

   *

   *

   *

   *

   *
   */
  public ExternalForce(Storage dataSource) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_7(Storage.getCPtr(dataSource), dataSource), true);
  }

  public ExternalForce(SWIGTYPE_p_SimTK__Xml__Element aNode) {
    this(opensimSimulationJNI.new_ExternalForce__SWIG_8(SWIGTYPE_p_SimTK__Xml__Element.getCPtr(aNode)), true);
  }

  /**
   *  Associate the data source from which the force, point and/or torque data

   *  is to be extracted.
   */
  public void setDataSource(Storage dataSource) {
    opensimSimulationJNI.ExternalForce_setDataSource(swigCPtr, this, Storage.getCPtr(dataSource), dataSource);
  }

  /**
   *  Get the name of the data source for the force data. *
   */
  public String getDataSourceName() {
    return opensimSimulationJNI.ExternalForce_getDataSourceName(swigCPtr, this);
  }

  /**
   *  Specify or obtain the body to which the force will be applied
   */
  public void setAppliedToBodyName(String applyToName) {
    opensimSimulationJNI.ExternalForce_setAppliedToBodyName(swigCPtr, this, applyToName);
  }

  public String getAppliedToBodyName() {
    return opensimSimulationJNI.ExternalForce_getAppliedToBodyName(swigCPtr, this);
  }

  /**
   *  Specify or obtain the body in which the point of application is expressed
   */
  public void setPointExpressedInBodyName(String pointInBodyName) {
    opensimSimulationJNI.ExternalForce_setPointExpressedInBodyName(swigCPtr, this, pointInBodyName);
  }

  public String getPointExpressedInBodyName() {
    return opensimSimulationJNI.ExternalForce_getPointExpressedInBodyName(swigCPtr, this);
  }

  /**
   *  Specify or obtain the body in which the force is expressed
   */
  public void setForceExpressedInBodyName(String forceInBodyName) {
    opensimSimulationJNI.ExternalForce_setForceExpressedInBodyName(swigCPtr, this, forceInBodyName);
  }

  public String getForceExpressedInBodyName() {
    return opensimSimulationJNI.ExternalForce_getForceExpressedInBodyName(swigCPtr, this);
  }

  /**
   * Identifiers
   */
  public void setForceIdentifier(String aForceIdentifier) {
    opensimSimulationJNI.ExternalForce_setForceIdentifier(swigCPtr, this, aForceIdentifier);
  }

  public void setPointIdentifier(String aPointIdentifier) {
    opensimSimulationJNI.ExternalForce_setPointIdentifier(swigCPtr, this, aPointIdentifier);
  }

  public void setTorqueIdentifier(String aTorqueIdentifier) {
    opensimSimulationJNI.ExternalForce_setTorqueIdentifier(swigCPtr, this, aTorqueIdentifier);
  }

  public String getForceIdentifier() {
    return opensimSimulationJNI.ExternalForce_getForceIdentifier(swigCPtr, this);
  }

  public String getPointIdentifier() {
    return opensimSimulationJNI.ExternalForce_getPointIdentifier(swigCPtr, this);
  }

  public String getTorqueIdentifier() {
    return opensimSimulationJNI.ExternalForce_getTorqueIdentifier(swigCPtr, this);
  }

  /**
   * Convenience methods to access external forces at a given time
   */
  public Vec3 getForceAtTime(double aTime) {
    return new Vec3(opensimSimulationJNI.ExternalForce_getForceAtTime(swigCPtr, this, aTime), true);
  }

  public Vec3 getPointAtTime(double aTime) {
    return new Vec3(opensimSimulationJNI.ExternalForce_getPointAtTime(swigCPtr, this, aTime), true);
  }

  public Vec3 getTorqueAtTime(double aTime) {
    return new Vec3(opensimSimulationJNI.ExternalForce_getTorqueAtTime(swigCPtr, this, aTime), true);
  }

  /**
   * Methods used for reporting.

   * First identify the labels for individual components
   */
  public ArrayStr getRecordLabels() {
    return new ArrayStr(opensimSimulationJNI.ExternalForce_getRecordLabels(swigCPtr, this), true);
  }

  /**
   * Given SimTK::State object extract all the values necessary to report

   * forces, application location frame, etc. used in conjunction with

   * getRecordLabels and should return same size Array.
   */
  public ArrayDouble getRecordValues(State state) {
    return new ArrayDouble(opensimSimulationJNI.ExternalForce_getRecordValues(swigCPtr, this, State.getCPtr(state), state), true);
  }

  /**
   * Methods to query the force properties to find out if it's a body vs.

   * point force and/or if it applies a torque.
   */
  public boolean appliesForce() {
    return opensimSimulationJNI.ExternalForce_appliesForce(swigCPtr, this);
  }

  public boolean specifiesPoint() {
    return opensimSimulationJNI.ExternalForce_specifiesPoint(swigCPtr, this);
  }

  public boolean appliesTorque() {
    return opensimSimulationJNI.ExternalForce_appliesTorque(swigCPtr, this);
  }

}


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const child_process = require("child_process");
const request = require("request");
class SolargraphServer {
    constructor() {
        this.child = null;
        this.port = null;
        this.pid = null;
        this.useBundler = false;
        this.commandPath = null;
        this.views = null;
        this.workspace = null;
        this.configure();
    }
    isRunning() {
        return (this.child != null && this.port != null && this.pid != null);
    }
    getPort() {
        return this.port;
    }
    configure(options = {}) {
        this.commandPath = options['commandPath'] || 'solargraph';
        this.useBundler = options['useBundler'] || false;
        this.views = options['views'] || null;
        this.workspace = options['workspace'] || null;
    }
    start() {
        return new Promise((resolve, reject) => {
            var started = false;
            if (this.child) {
                console.warn('There is already a process running for the Solargraph server.');
            }
            else {
                console.log('Starting the server');
                var args = ['server', '--port', '0'];
                if (this.views) {
                    args.push('--views', this.views);
                }
                this.child = this.solargraphCommand(args);
                this.child.stderr.on('data', (data) => {
                    var out = data.toString();
                    if (!this.port) {
                        var match = out.match(/port=([0-9]*)/);
                        if (match) {
                            this.port = match[1];
                        }
                        match = out.match(/pid=([0-9]*)/);
                        if (match) {
                            this.pid = parseInt(match[1]);
                        }
                    }
                    if (this.isRunning() && !started) {
                        started = true;
                        return resolve();
                    }
                });
                this.child.on('exit', () => {
                    this.port = null;
                    if (!started) {
                        return reject();
                    }
                });
            }
        });
    }
    stop() {
        if (!this.child) {
            console.warn('The server is not running.');
        }
        else {
            this.child.kill();
            if (this.pid) {
                process.kill(this.pid);
            }
            this.pid = null;
            this.port = null;
            this.child = null;
        }
    }
    restart() {
        this.stop();
        return this.start();
    }
    prepare(workspace) {
        return new Promise((resolve, reject) => {
            //let prepareStatus = vscode.window.setStatusBarMessage('Analyzing Ruby code in workspace ' + workspace);
            request.post({ url: 'http://localhost:' + this.port + '/prepare', form: {
                    workspace: workspace
                } }, function (err, response, body) {
                if (err) {
                    reject();
                }
                else {
                    resolve();
                }
            });
        });
    }
    suggest(text, line, column, filename, workspace, withSnippets) {
        return new Promise((resolve, reject) => {
            request.post({ url: 'http://localhost:' + this.port + '/suggest', form: {
                    text: text,
                    line: line,
                    column: column,
                    filename: filename || null,
                    workspace: workspace || null,
                    with_snippets: withSnippets || false
                }
            }, function (err, response, body) {
                if (err) {
                    reject(err);
                }
                else {
                    resolve(JSON.parse(body));
                }
            });
        });
    }
    solargraphCommand(args) {
        let cmd = [];
        if (this.useBundler && this.workspace) {
            // TODO: pathToBundler configuration
            cmd.push('bundle', 'exec', 'solargraph');
        }
        else {
            cmd.push(this.commandPath);
        }
        var env = { shell: true };
        if (this.workspace)
            env['cwd'] = this.workspace;
        return child_process.spawn(cmd.shift(), cmd.concat(args), env);
    }
}
exports.default = SolargraphServer;
//# sourceMappingURL=SolargraphServer.js.map


text:
package com.google.gerrit.extensions.common;

import java.sql.Timestamp;
import java.util.Collection;
import java.util.Map;

public class ChangeInfo {
  public String id;
  public String project;
  public String branch;
  public String topic;
  public String changeId;
  public String subject;
  public ChangeStatus status;
  public Timestamp created;
  public Timestamp updated;
  public Boolean starred;
  public Boolean reviewed;
  public Boolean mergeable;
  public Integer insertions;
  public Integer deletions;
  public AccountInfo owner;
  public String currentRevision;
  public Map<String, ActionInfo> actions;
  public Map<String, LabelInfo> labels;
  public Collection<ChangeMessageInfo> messages;
  public Map<String, RevisionInfo> revisions;
  public int _number;
}


text:
/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package src.model.constructs;

import src.Effect;
import src.SkillEnum;
import src.model.constructs.items.OneHandedSword;
import src.model.constructs.items.OneHandedWeapon;
import src.model.constructs.items.TwoHandedSword;
import src.model.constructs.items.TwoHandedWeapon;

/**
 * Smasher Occupation, Strength +1.
 */
public final class Smasher extends Occupation {

    private static final long serialVersionUID = 22L;
    @Override
    public int getID() { return (int)serialVersionUID; }

    public Smasher(Entity e) {
        super(e);
    }
    public Smasher(Occupation o) {
        super(o);
    }
    public Smasher getACopyOfMyself() {
        return new Smasher(this);
    }
    private TwoHandedSword two_handed_sword_ = null;
    private OneHandedSword one_handed_sword_ = null;
    private OneHandedWeapon bullshit_weapon_one_ = null;
    private TwoHandedWeapon bullshit_weapon_two_ = null;

    public enum ActiveWeapon {

        FISTS, TWO_HANDED_SWORD, ONE_HANDED_SWORD, TWO_HANDED_BULLSHIT, ONE_HANDED_BULLSHIT
    }
    private ActiveWeapon current_weapon = ActiveWeapon.FISTS;

    @Override
    public void changeStats(EntityStatsPack current_stats) {
        //for smasher
        current_stats.increaseStrengthLevelByOne();
    }

    @Override
    public int equipOneHandWeapon(OneHandedWeapon weapon) {
        try {
            one_handed_sword_ = (OneHandedSword) weapon;
            bullshit_weapon_one_ = null;
            current_weapon = ActiveWeapon.ONE_HANDED_SWORD;
            return 0;
        } catch (ClassCastException e1) {
            bullshit_weapon_one_ = weapon;
            one_handed_sword_ = null;
            current_weapon = ActiveWeapon.ONE_HANDED_BULLSHIT;
            return 0;
        }
    }

    public ActiveWeapon getActiveWeapon() { return current_weapon; }

    public void setActiveWeapon(ActiveWeapon value) { current_weapon = value; }

    public OneHandedSword getSwordOne() { return one_handed_sword_; }

    public TwoHandedSword getSwordTwo() { return two_handed_sword_; }

    public OneHandedWeapon getWeaponOne () { return bullshit_weapon_one_; }

    public TwoHandedWeapon getWeaponTwo() { return bullshit_weapon_two_; }

    @Override
    public int unEquipEverything() {
        two_handed_sword_ = null;
        one_handed_sword_ = null;
        bullshit_weapon_one_ = null;
        bullshit_weapon_two_ = null;
        current_weapon = ActiveWeapon.FISTS;
        return 0;
    }

    /**
     * Equips a two handed weapon to an occupation for occupation specific
     * bonuses.
     *
     * @author John-Michael Reed
     * @param weapon
     * @return
     */
    @Override
    public int equipTwoHandWeapon(TwoHandedWeapon weapon) {
        try {
            two_handed_sword_ = (TwoHandedSword) weapon;
            bullshit_weapon_two_ = null;
            current_weapon = ActiveWeapon.TWO_HANDED_SWORD;
            return 0;
        } catch (ClassCastException e1) {
            bullshit_weapon_two_ = weapon;
            one_handed_sword_ = null;
            current_weapon = ActiveWeapon.TWO_HANDED_BULLSHIT;
            return 0;
        }
    }

    /**
     * Increments an occupation specific skill. Caller should decrement number
     * of skillpoints.
     *
     * @param skill Which skill to increment
     * @return 0 on success, -1 if this occupation cannot increment this skill.
     */
    @Override
    public int incrementSkill(SkillEnum skill) {
        if (skill == SkillEnum.OCCUPATION_SKILL_1) {
            super.incrementSkill_1_();
            return 0;
        } else if (skill == SkillEnum.OCCUPATION_SKILL_2) {
            super.incrementSkill_2_();
            return 0;
        } else if (skill == SkillEnum.OCCUPATION_SKILL_3) {
            super.incrementSkill_3_();
            return 0;
        } else if (skill == SkillEnum.OCCUPATION_SKILL_4) {
            // Smasher does not have four skills.
            return -1; // error cannot increment skill.
        } else {
            System.exit(-1);
            return -99999; // F***ing impossible
        }
    }

    @Override
    public String getSkillNameFromNumber(int skill_number) {
        super.getSkillNameFromNumber(skill_number); // checks input
        switch (skill_number) {
            case 1:
                return "1-H";
            case 2:
                return "2-H";
            case 3:
                return "Fists";
            case 4:
                return "NA";
            default:
                System.err.println("Error");
                System.exit(-56);
                return "";
        }
    }

    /**
     * @author John-Michael Reed
     * @param number - 1 for occupation skill #1, 2 for occupation skill #2,
     * etc.
     * @return 0
     */
    @Override
    public int performOccupationSkill(int number) {
        final int cost = 1;
        Entity target = super.getEntity().getMapRelation().getEntityInFacingDirection();
        if (number == 1) {
            // one-handed weapon
            if (current_weapon == ActiveWeapon.ONE_HANDED_SWORD) {
                // Case that you have enough mana:
                if (getEntity().getStatsPack().deductCurrentManaBy(cost) == 0) {
                    if (target != null) {
                        target.receiveAttack(getSkill_1_(), null); // hurt enemy [no attack-back]
                    }
                    getEntity().getMapRelation().areaEffectFunctor.effectAreaWithinLine(3*getSkill_1_()+3, getSkill_1_(), Effect.HURT);
                } else {
                    System.out.println("Out of mana in Smasher1");
                }
            }
        } else if (number == 2) {
            // two-handed weapon
            System.out.println("Starting skill 2");
            if (current_weapon == ActiveWeapon.TWO_HANDED_SWORD) {
                // Case that you have enough mana:
                if (getEntity().getStatsPack().deductCurrentManaBy(cost) == 0) {
                    if (target != null) {
                        target.receiveAttack(getSkill_2_(), null); // hurt enemy [no attack-back]
                    }
                    getEntity().getMapRelation().areaEffectFunctor.effectAreaWithinArc(2*getSkill_2_()+1, getSkill_2_(), Effect.HURT);
                } else {
                    System.out.println("Out of mana in Smasher2");
                }
            }
        } else if (number == 3) {
            // brawling
            System.out.println("Starting skill 3");
            if (current_weapon == ActiveWeapon.FISTS) {
                System.out.println("Doing skill 3");
                // Case that you have enough mana:
                if (getEntity().getStatsPack().deductCurrentManaBy(cost) == 0) {
                    if (target != null) {
                        target.receiveAttack(getSkill_3_(), null); // hurt enemy [no attack-back]
                    }
                    getEntity().getMapRelation().areaEffectFunctor.effectAreaWithinRadius(1, getSkill_3_(), Effect.HEAL);
                    getEntity().getMapRelation().areaEffectFunctor.effectAreaWithinRadius(getSkill_3_()+1, 1, Effect.LEVEL);
                    getEntity().getMapRelation().areaEffectFunctor.effectAreaWithinRadius(1, getSkill_3_(), Effect.HEAL);
                } else {
                    System.out.println("Out of mana in Smasher3");
                }
            }
        } else if (number == 4) {
            //Do nothing
        } else {
            System.err.println("Error in Smasher.performOccupationSkill()");
            System.exit(-99);
        }
        return 0;
    }

    @Override
    public String toString() {
        return "Smasher";
    }

    @Override
    public void takeTurn(){

    }

	@Override
	public Smasher switchToNextSubOccupation() {
		//A smasher has no sub occupations atm.
		return this;
	}
	@Override
	public char getOccupationRepresentation() {
		return '⚔';
	}
}


text:
#include <sys/types.h> // pid_t, mode_t, uid_t, gid_t
#include <sys/ioctl.h> // ioctl
#include <sys/stat.h> // umask
#include <unistd.h> // fork, execve, dup2, chdir, close, environ
#include <fcntl.h> // open
#include <stdlib.h> // exit, posix_openpt, grantpt, unlockpt
#include <termios.h> // tcgetattr, tcsetattr
#include <flux/Format>
#include <flux/File>
#include <flux/exceptions>
#include <flux/ProcessFactory>

namespace flux {

ProcessFactory::ProcessFactory(int type):
    type_(type),
    ioPolicy_(0),
    fileCreationMask_(-1)
{}

void ProcessFactory::setExecPath(String path)
{
    if (path->contains('~')) {
        String home = Process::env("HOME");
        if (home != "") path = path->replace("~", home);
    }
    execPath_ = path;
}

void ProcessFactory::setArguments(StringList *list) { arguments_ = list; }
void ProcessFactory::setEnvMap(EnvMap *map) { envMap_ = map; }
void ProcessFactory::setWorkingDirectory(String path) { workingDirectory_ = path; }

void ProcessFactory::setIoPolicy(int flags) { ioPolicy_ = flags; }
void ProcessFactory::setIn(SystemStream *stream) { in_ = stream; }
void ProcessFactory::setOut(SystemStream *stream) { out_ = stream; }
void ProcessFactory::setErr(SystemStream *stream) { err_ = stream; }

void ProcessFactory::setSignalMask(SignalSet *mask) { signalMask_ = mask; }
void ProcessFactory::setFileCreationMask(int mask) { fileCreationMask_ = mask; }

String ProcessFactory::command() const { return arguments_->join(" "); }

void ProcessFactory::setCommand(String command)
{
    command_ = command->simplify()->trimInsitu();

    Ref<StringList> args = command_->split(' ');
    setArguments(args);
    String name = args->at(0);

    String path = File::lookup(name);
    if (path == "") path = name;
    setExecPath(path);
}

Ref<Process> ProcessFactory::produce()
{
    int inputPipe[2];
    int outputPipe[2];
    int errorPipe[2];

    int ptyMaster = -1, ptySlave = -1;

    if (ioPolicy_ & Process::ForwardByPseudoTerminal)
    {
        ptyMaster = ::posix_openpt(O_RDWR|O_NOCTTY);
        if (ptyMaster == -1) FLUX_SYSTEM_DEBUG_ERROR(errno);
        if (::grantpt(ptyMaster) == -1) FLUX_SYSTEM_DEBUG_ERROR(errno);
        if (::unlockpt(ptyMaster) == -1) FLUX_SYSTEM_DEBUG_ERROR(errno);
        ptySlave = ::open(ptsname(ptyMaster), O_RDWR|O_NOCTTY);
        if (ptySlave == -1) FLUX_SYSTEM_DEBUG_ERROR(errno);
    }
    else
    {
        if (ioPolicy_ & Process::ForwardInput)
            if (::pipe(inputPipe) == -1)
                FLUX_SYSTEM_DEBUG_ERROR(errno);

        if (ioPolicy_ & Process::ForwardOutput)
            if (::pipe(outputPipe) == -1)
                FLUX_SYSTEM_DEBUG_ERROR(errno);

        if (ioPolicy_ & Process::ForwardError)
            if (::pipe(errorPipe) == -1)
                FLUX_SYSTEM_DEBUG_ERROR(errno);
    }

    char **argv = 0, **envp = 0;

    if (execPath_ != "")
    {
        // prepare the argument list

        StringList *arguments = arguments_;
        if (arguments) if (arguments->count() == 0) arguments = 0;

        int argc = arguments ? arguments->count() : 1;
        argv = new char*[argc + 1];

        if (arguments) {
            for (int i = 0; i < arguments->count(); ++i)
                argv[i] = strdup(arguments->at(i)->chars());
        }
        else {
            argv[0] = strdup(execPath_->chars());
        }
        argv[argc] = 0;

        // prepare the environment map

        envp = 0;

        if (envMap_) {
            int n = envMap_->count();
            envp = new char*[n + 1];
            for (int i = 0; i < n; ++i)
                envp[i] = strdup(String(Format() << envMap_->keyAt(i) <<  "=" << envMap_->valueAt(i))->chars());
            envp[n] = 0;
        }
        else {
            envp = Process::environ();
        }
    }

    int ret = ::fork();

    if (ret == 0)
    {
        // child process

        if (type_ == Process::GroupLeader)
            ::setpgid(0, 0);
        else if (type_ == Process::SessionLeader)
            ::setsid();

        if (ioPolicy_ & Process::ForwardByPseudoTerminal)
        {
            if (::close(ptyMaster) == -1)
                FLUX_SYSTEM_DEBUG_ERROR(errno);

            if (type_ == Process::SessionLeader)
                ::ioctl(ptySlave, TIOCSCTTY, 0);

            {
                struct termios attr;
                ::tcgetattr(ptySlave, &attr);
                attr.c_iflag ^= IXON;
            #ifdef IUTF8
                attr.c_iflag |= IUTF8;
            #endif // IUTF8
                ::tcsetattr(ptySlave, TCSANOW, &attr);
            }
        }

        if (workingDirectory_ != "") {
            if (::chdir(workingDirectory_) == -1)
                FLUX_SYSTEM_DEBUG_ERROR(errno);
        }

        if (signalMask_) {
            if (::sigprocmask(SIG_SETMASK, signalMask_->rawSet(), 0) == -1)
                FLUX_SYSTEM_DEBUG_ERROR(errno);
        }

        if (fileCreationMask_ >= 0) ::umask(fileCreationMask_);

        if (ioPolicy_ & Process::CloseInput) ::close(0);
        if (ioPolicy_ & Process::CloseOutput) ::close(1);
        if (ioPolicy_ & Process::CloseError) ::close(2);

        if (in_) ::dup2(in_->fd(), 0);
        if (out_) ::dup2(out_->fd(), 1);
        if (err_) ::dup2(err_->fd(), 2);

        if (ioPolicy_ & Process::ForwardByPseudoTerminal)
        {
            if (ioPolicy_ & Process::ForwardInput) ::dup2(ptySlave, 0);
            if (ioPolicy_ & Process::ForwardOutput) ::dup2(ptySlave, 1);
            if (ioPolicy_ & Process::ForwardError) ::dup2(ptySlave, 2);
            ::close(ptySlave);
        }
        else
        {
            if (ioPolicy_ & Process::ForwardInput) {
                ::close(inputPipe[1]);
                ::dup2(inputPipe[0], 0);
            }
            if (ioPolicy_ & Process::ForwardOutput) {
                ::close(outputPipe[0]);
                ::dup2(outputPipe[1], 1);
            }
            if (ioPolicy_ & Process::ForwardError) {
                ::close(errorPipe[0]);
                ::dup2(errorPipe[1], 2);
            }
        }

        if (ioPolicy_ & Process::ErrorToOutput) ::dup2(1, 2);

        if (execPath_ != "")
        {
            // load new program

            ::execve(execPath_, argv, envp);

            FLUX_SYSTEM_DEBUG_ERROR(errno);
        }
        else
        {
            ::exit(incarnate());
        }
    }
    else if (ret > 0)
    {
        // parent process

        if (argv) {
            for (int i = 0; argv[i]; ++i)
                flux::free(argv[i]);
            delete[] argv;
        }
        if (envMap_) {
            for (int i = 0; envp[i]; ++i)
                flux::free(envp[i]);
            delete[] envp;
        }

        Ref<SystemStream> in = in_;
        Ref<SystemStream> out = out_;
        Ref<SystemStream> err = err_;

        if (ioPolicy_ & Process::ForwardByPseudoTerminal)
        {
            ::close(ptySlave);

            if (ioPolicy_ & Process::ForwardInput)
                in = SystemStream::create(ptyMaster);
            if ((ioPolicy_ & Process::ForwardOutput) || (ioPolicy_ & Process::ForwardError)) {
                if (in)
                    out = in;
                else
                    out = SystemStream::create(ptyMaster);
            }
        }
        else
        {
            if (ioPolicy_ & Process::ForwardInput) {
                ::close(inputPipe[0]);
                in = SystemStream::create(inputPipe[1]);
            }
            if (ioPolicy_ & Process::ForwardOutput) {
                ::close(outputPipe[1]);
                out = SystemStream::create(outputPipe[0]);
            }
            if (ioPolicy_ & Process::ForwardError) {
                ::close(errorPipe[1]);
                err = SystemStream::create(errorPipe[0]);
            }
        }

        return new Process(type_, ioPolicy_, in, out, err, ret, command_);
    }
    else if (ret < 0)
    {
        FLUX_SYSTEM_DEBUG_ERROR(errno);
    }

    FLUX_ASSERT(0 == 1);
    return 0;
}

int ProcessFactory::incarnate() { return 0; }

} // namespace flux


text:
package com.simbest.cores.app.service;

import com.simbest.cores.app.model.ProcessStatus;
import com.simbest.cores.service.ILogicService;

import java.util.List;

public interface IProcessStatusService extends ILogicService<ProcessStatus, Long> {

	ProcessStatus getOne(Integer processTypeId, Integer processHeaderId, Long receiptId);

    Integer getJoinCount(Integer createUserId);

    List<ProcessStatus> getJoin();

	boolean checkProcessRunning(Integer processTypeId, Integer processHeaderId, Integer processStepVersion);

    int updateOnCompleted(ProcessStatus status);
}


text:
using System;
using System.Collections.Generic;

namespace S3NoSql.Engine.Structures
{
    /// <summary>
    /// Represent a index information
    /// </summary>
    public class IndexInfo
    {
        internal IndexInfo(CollectionIndex index)
        {
            this.Slot = index.Slot;
            this.Field = index.Field;
            this.Unique = index.Unique;
        }

        /// <summary>
        /// Slot number of index
        /// </summary>
        public int Slot { get; private set; }

        /// <summary>
        /// Field index name
        /// </summary>
        public string Field { get; private set; }

        /// <summary>
        /// Index is Unique?
        /// </summary>
        public bool Unique { get; private set; }
    }
}


text:
class CreatePosts < ActiveRecord::Migration
  def change
    create_table :posts do |t|
      t.string :title
      t.text :content
      t.integer :language_problem_id
      t.integer :user_id

      t.timestamps null: false
    end

    add_index :posts, :user_id
    add_index :posts, :language_problem_id
  end
end


text:
@extends('admin.layouts.poly-log._template.master')

@section('content')

各平台日志

                    @foreach($headers as $key => $header)

                        @if ($key == 'channel')
                            {{ $header }}
                        @else

                                {!! log_styler()->icon($key) . ' ' . $header !!}

                        @endif

                    @endforeach
                    Actions

                @foreach($rows as $channel => $row)

                    @foreach($row as $key => $value)

                        @if ($key == 'channel')
                            {{ $value }}
                        @elseif ($value == 0)
                            {{ $value }}
                        @else

                                {{ $value }}

                        @endif

                    @endforeach

                        {{--

                        --}}

                @endforeach

    {!! $rows->render() !!}

    {{-- DELETE MODAL --}}

            <form id="delete-log-form" action="{{ route('admin.platform.logs.delete') }}" method="POST">
                <input type="hidden" name="_method" value="DELETE">
                <input type="hidden" name="_token" value="{{ csrf_token() }}">
                <input type="hidden" name="channel" value="">

                        <button type="button" class="close" data-dismiss="modal" aria-label="Close">
                            ×
                        </button>

删除渠道日志

                        <button type="button" class="btn btn-sm btn-default pull-left" data-dismiss="modal">取消</button>
                        <button type="submit" class="btn btn-sm btn-danger" data-loading-text="Loading…">删除</button>

            </form>

@stop

@section('scripts')

@stop


text:
/* © 2020 Ivan Pointer
MIT License: https://github.com/ivanpointer/NuLog/blob/master/LICENSE
Source on GitHub: https://github.com/ivanpointer/NuLog */

namespace NuLogSnippets {

    internal static class Program {

        private static void Main(string[] args) {
            // Nothing to do. Code is here for documentation purposes.
        }
    }
}


text:
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

using System.Collections.Generic;
using System.IO;
using System.Reflection;
using Newtonsoft.Json;

namespace LinqToAql.Tests.Common.Model.Data
{
    internal static class TinySocialData
    {
        static TinySocialData()
        {
            var assembly = typeof(TinySocialData).GetTypeInfo().Assembly;
            var prefix = $"{assembly.GetName().Name}.Resources.";
            var serializer = new JsonSerializer();
            using (var tr = new JsonTextReader(new StreamReader(assembly.GetManifestResourceStream($"{prefix}FacebookMessages.json"))))
                FacebookMessages = serializer.Deserialize<IEnumerable<FacebookMessage>>(tr);
            using (var tr = new JsonTextReader(new StreamReader(assembly.GetManifestResourceStream($"{prefix}FacebookUsers.json"))))
                FacebookUsers = serializer.Deserialize<IEnumerable<FacebookUser>>(tr);
            using (var tr = new JsonTextReader(new StreamReader(assembly.GetManifestResourceStream($"{prefix}TweetMessages.json"))))
                TweetMessages = serializer.Deserialize<IEnumerable<TweetMessage>>(tr);
        }

        public static IEnumerable<FacebookMessage> FacebookMessages { get; }

        public static IEnumerable<FacebookUser> FacebookUsers { get; }

        public static IEnumerable<TweetMessage> TweetMessages { get; }
    }
}


text:
package org.apereo.cas.metadata;

import org.apereo.cas.configuration.CasConfigurationProperties;

import lombok.Getter;
import lombok.SneakyThrows;
import lombok.val;
import org.apache.commons.lang3.StringUtils;
import org.jooq.lambda.Unchecked;
import org.springframework.boot.configurationmetadata.CasConfigurationMetadataRepositoryJsonBuilder;
import org.springframework.boot.configurationmetadata.ConfigurationMetadataProperty;
import org.springframework.boot.configurationmetadata.ConfigurationMetadataRepository;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * This is {@link CasConfigurationMetadataRepository}.
 *
 * @author Misagh Moayyed
 * @author Dmitriy Kopylenko
 * @since 5.2.0
 */
@Getter
public class CasConfigurationMetadataRepository {
    private final ConfigurationMetadataRepository repository;

    /**
     * Instantiates a new Cas configuration metadata repository.
     */
    public CasConfigurationMetadataRepository() {
        this("classpath*:META-INF/spring-configuration-metadata.json");
    }

    /**
     * Instantiates a new CAS configuration metadata repository.
     * Scans the context looking for spring configuration metadata
     * resources and then loads them all into a repository instance.
     *
     * @param resource the resource
     */
    @SneakyThrows
    public CasConfigurationMetadataRepository(final String resource) {
        val resources = new PathMatchingResourcePatternResolver().getResources(resource);
        val builder = CasConfigurationMetadataRepositoryJsonBuilder.create();
        Arrays.stream(resources).forEach(Unchecked.consumer(r -> {
            try (val in = r.getInputStream()) {
                builder.withJsonResource(in);
            }
        }));
        repository = builder.build();
    }

    /**
     * Instantiates a new Cas configuration metadata repository.
     *
     * @param resource the resource
     */
    @SneakyThrows
    public CasConfigurationMetadataRepository(final Resource resource) {
        val builder = CasConfigurationMetadataRepositoryJsonBuilder.create();
        try (val in = resource.getInputStream()) {
            builder.withJsonResource(in);
        }
        repository = builder.build();
    }

    /**
     * Gets property group id.
     *
     * @param prop the prop
     * @return the property group id
     */
    public static String getPropertyGroupId(final ConfigurationMetadataProperty prop) {
        if (isCasProperty(prop)) {
            return StringUtils.substringBeforeLast(prop.getName(), ".");
        }
        return StringUtils.substringBeforeLast(prop.getId(), ".");
    }

    /**
     * Is cas property ?.
     *
     * @param prop the prop
     * @return true /false
     */
    public static boolean isCasProperty(final ConfigurationMetadataProperty prop) {
        return prop.getName().startsWith(CasConfigurationProperties.PREFIX.concat("."));
    }

    /**
     * Gets properties by class type.
     *
     * @param clazz the clazz
     * @return the properties by class type
     */
    public Set<ConfigurationMetadataProperty> getPropertiesWithType(final Class clazz) {
        return repository.getAllProperties().values()
            .stream()
            .filter(prop -> StringUtils.isNotBlank(prop.getType()))
            .filter(prop -> prop.getType().contains(clazz.getName()))
            .collect(Collectors.toSet());
    }

    /**
     * Query cas configuration metadata catalog.
     *
     * @param query the query
     * @return the cas configuration metadata catalog
     */
    public CasConfigurationMetadataCatalog.CasPropertiesContainer query(final ConfigurationMetadataCatalogQuery query) {
        return CasConfigurationMetadataCatalog.catalog(query);
    }
}