text:
import json
def p(s): print(s)
from pymeta.bootbase import BootBase as GrammarBase
import string
class GeneratedTranslator(GrammarBase):
    globals = globals()
    def rule_grammar(self):
        _locals = {'self': self}
        self.locals['grammar'] = _locals
        def _G_many_1():
            _G_apply_1, lastError = self._apply(self.rule_stmt, "stmt", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        _G_many_2, lastError = self.many(_G_many_1)
        self.considerError(lastError)
        _locals['s'] = _G_many_2
        _G_python_3, lastError = eval("'%s\\n' % '\\n'.join(s)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_3, self.currentError)

    def rule_block(self):
        _locals = {'self': self}
        self.locals['block'] = _locals
        def _G_lookahead_1():
            def _G_listpattern_1():
                def _G_many_1():
                    _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                _G_many_2, lastError = self.many(_G_many_1)
                self.considerError(lastError)
                return (_G_many_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            return (_G_listpattern_2, self.currentError)
        _G_lookahead_2, lastError = self.lookahead(_G_lookahead_1)
        self.considerError(lastError)
        _G_python_3, lastError = eval('self.indent()', self.globals, _locals), None
        self.considerError(lastError)
        _locals['i'] = _G_python_3
        def _G_listpattern_4():
            def _G_many_1():
                _G_apply_1, lastError = self._apply(self.rule_stmt, "stmt", [])
                self.considerError(lastError)
                return (_G_apply_1, self.currentError)
            _G_many_2, lastError = self.many(_G_many_1)
            self.considerError(lastError)
            _locals['s'] = _G_many_2
            return (_locals['s'], self.currentError)
        _G_listpattern_5, lastError = self.listpattern(_G_listpattern_4)
        self.considerError(lastError)
        _G_python_6, lastError = eval('self.dedent()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_7, lastError = eval('self.make_block(s, i)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_7, self.currentError)

    def rule_funcblock(self):
        _locals = {'self': self}
        self.locals['funcblock'] = _locals
        def _G_lookahead_1():
            def _G_listpattern_1():
                def _G_many_1():
                    _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                _G_many_2, lastError = self.many(_G_many_1)
                self.considerError(lastError)
                return (_G_many_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            return (_G_listpattern_2, self.currentError)
        _G_lookahead_2, lastError = self.lookahead(_G_lookahead_1)
        self.considerError(lastError)
        _G_python_3, lastError = eval('self.indent()', self.globals, _locals), None
        self.considerError(lastError)
        _locals['i'] = _G_python_3
        def _G_listpattern_4():
            def _G_many_1():
                _G_apply_1, lastError = self._apply(self.rule_stmt, "stmt", [])
                self.considerError(lastError)
                return (_G_apply_1, self.currentError)
            _G_many_2, lastError = self.many(_G_many_1)
            self.considerError(lastError)
            _locals['s'] = _G_many_2
            return (_locals['s'], self.currentError)
        _G_listpattern_5, lastError = self.listpattern(_G_listpattern_4)
        self.considerError(lastError)
        _G_python_6, lastError = eval('self.dedent()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_7, lastError = eval('self.make_func_block(s, i)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_7, self.currentError)

    def rule_stmt(self):
        _locals = {'self': self}
        self.locals['stmt'] = _locals
        def _G_or_1():
            def _G_or_1():
                def _G_listpattern_1():
                    _G_exactly_1, lastError = self.exactly('while')
                    self.considerError(lastError)
                    _G_apply_2, lastError = self._apply(self.rule_while, "while", [])
                    self.considerError(lastError)
                    _locals['e'] = _G_apply_2
                    return (_locals['e'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                return (_G_listpattern_2, self.currentError)
            def _G_or_2():
                def _G_listpattern_1():
                    _G_exactly_1, lastError = self.exactly('if')
                    self.considerError(lastError)
                    _G_apply_2, lastError = self._apply(self.rule_if, "if", [])
                    self.considerError(lastError)
                    _locals['e'] = _G_apply_2
                    return (_locals['e'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                return (_G_listpattern_2, self.currentError)
            def _G_or_3():
                def _G_listpattern_1():
                    _G_exactly_1, lastError = self.exactly('for')
                    self.considerError(lastError)
                    _G_apply_2, lastError = self._apply(self.rule_for, "for", [])
                    self.considerError(lastError)
                    _locals['e'] = _G_apply_2
                    return (_locals['e'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                return (_G_listpattern_2, self.currentError)
            def _G_or_4():
                def _G_listpattern_1():
                    _G_exactly_1, lastError = self.exactly('try')
                    self.considerError(lastError)
                    _G_apply_2, lastError = self._apply(self.rule_try, "try", [])
                    self.considerError(lastError)
                    _locals['e'] = _G_apply_2
                    return (_locals['e'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                return (_G_listpattern_2, self.currentError)
            def _G_or_5():
                def _G_listpattern_1():
                    _G_exactly_1, lastError = self.exactly('func')
                    self.considerError(lastError)
                    _G_apply_2, lastError = self._apply(self.rule_funcstmt, "funcstmt", [])
                    self.considerError(lastError)
                    _locals['e'] = _G_apply_2
                    return (_locals['e'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                return (_G_listpattern_2, self.currentError)
            _G_or_6, lastError = self._or([_G_or_1, _G_or_2, _G_or_3, _G_or_4, _G_or_5])
            self.considerError(lastError)
            _G_python_7, lastError = eval("'%s\\n' % e", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_7, self.currentError)
        def _G_or_2():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('global')
                self.considerError(lastError)
                def _G_listpattern_2():
                    def _G_many_1():
                        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                        self.considerError(lastError)
                        return (_G_apply_1, self.currentError)
                    _G_many_2, lastError = self.many(_G_many_1)
                    self.considerError(lastError)
                    _locals['names'] = _G_many_2
                    return (_locals['names'], self.currentError)
                _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
                self.considerError(lastError)
                return (_G_listpattern_3, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_python_3, lastError = eval('self.register_globals(names)', self.globals, _locals), None
            self.considerError(lastError)
            _G_python_4, lastError = eval("''", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        def _G_or_3():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('pass')
                self.considerError(lastError)
                return (_G_exactly_1, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_python_3, lastError = eval("''", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        def _G_or_4():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('call')
                self.considerError(lastError)
                def _G_lookahead_2():
                    def _G_listpattern_1():
                        _G_exactly_1, lastError = self.exactly('name')
                        self.considerError(lastError)
                        _G_exactly_2, lastError = self.exactly('JS')
                        self.considerError(lastError)
                        return (_G_exactly_2, self.currentError)
                    _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                    self.considerError(lastError)
                    def _G_many_3():
                        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
                        self.considerError(lastError)
                        return (_G_apply_1, self.currentError)
                    _G_many_4, lastError = self.many(_G_many_3)
                    self.considerError(lastError)
                    return (_G_many_4, self.currentError)
                _G_lookahead_3, lastError = self.lookahead(_G_lookahead_2)
                self.considerError(lastError)
                _G_apply_4, lastError = self._apply(self.rule_call, "call", [])
                self.considerError(lastError)
                _locals['e'] = _G_apply_4
                return (_locals['e'], self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_python_3, lastError = eval('e', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        def _G_or_5():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['e'] = _G_apply_1
            _G_python_2, lastError = eval("'%s;' % e", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_2, self.currentError)
        _G_or_6, lastError = self._or([_G_or_1, _G_or_2, _G_or_3, _G_or_4, _G_or_5])
        self.considerError(lastError)
        return (_G_or_6, self.currentError)

    def rule_expr(self):
        _locals = {'self': self}
        self.locals['expr'] = _locals
        def _G_listpattern_1():
            _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError)
            _locals['t'] = _G_apply_1
            _G_python_2, lastError = eval('t', self.globals, _locals), None
            self.considerError(lastError)
            _G_apply_3, lastError = self._apply(self.rule_apply, "apply", [_G_python_2])
            self.considerError(lastError)
            _locals['ans'] = _G_apply_3
            return (_locals['ans'], self.currentError)
        _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
        self.considerError(lastError)
        _G_python_3, lastError = eval('ans', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_3, self.currentError)

    def rule_augassign(self):
        _locals = {'self': self}
        self.locals['augassign'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['op'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['l'] = _G_apply_2
        _G_apply_3, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['r'] = _G_apply_3
        _G_python_4, lastError = eval('self.register_var(l)', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_5, lastError = eval("'%s %s %s' % (l, op, r)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_5, self.currentError)

    def rule_assign(self):
        _locals = {'self': self}
        self.locals['assign'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['l'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['r'] = _G_apply_2
        _G_python_3, lastError = eval('self.register_var(l)', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_4, lastError = eval("'%s = %s' % (l, r)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_4, self.currentError)

    def rule_get(self):
        _locals = {'self': self}
        self.locals['get'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['x'] = _G_apply_1
        _G_python_2, lastError = eval('x', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_getattr(self):
        _locals = {'self': self}
        self.locals['getattr'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['x'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['y'] = _G_apply_2
        _G_python_3, lastError = eval("'%s.%s' % (x, y)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_3, self.currentError)

    def rule_getitem(self):
        _locals = {'self': self}
        self.locals['getitem'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['x'] = _G_apply_1
        def _G_or_2():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('slice')
                self.considerError(lastError)
                def _G_or_2():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                def _G_or_3():
                    _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                _G_or_4, lastError = self._or([_G_or_2, _G_or_3])
                self.considerError(lastError)
                _locals['start'] = _G_or_4
                def _G_or_5():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                def _G_or_6():
                    _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                _G_or_7, lastError = self._or([_G_or_5, _G_or_6])
                self.considerError(lastError)
                _locals['end'] = _G_or_7
                return (_locals['end'], self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_python_3, lastError = eval("'%s.slice(%s)' % (x, (start if start is not None else '0') + (', ' + end if end is not None else ''))", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        def _G_or_3():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('unop')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('-')
                self.considerError(lastError)
                def _G_listpattern_3():
                    def _G_or_1():
                        _G_exactly_1, lastError = self.exactly('number')
                        self.considerError(lastError)
                        return (_G_exactly_1, self.currentError)
                    def _G_or_2():
                        _G_exactly_1, lastError = self.exactly('hexnumber')
                        self.considerError(lastError)
                        return (_G_exactly_1, self.currentError)
                    _G_or_3, lastError = self._or([_G_or_1, _G_or_2])
                    self.considerError(lastError)
                    _G_apply_4, lastError = self._apply(self.rule_anything, "anything", [])
                    self.considerError(lastError)
                    _locals['i'] = _G_apply_4
                    def _G_pred_5():
                        _G_python_1, lastError = eval('i > 0', self.globals, _locals), None
                        self.considerError(lastError)
                        return (_G_python_1, self.currentError)
                    _G_pred_6, lastError = self.pred(_G_pred_5)
                    self.considerError(lastError)
                    return (_G_pred_6, self.currentError)
                _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
                self.considerError(lastError)
                return (_G_listpattern_4, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_python_3, lastError = eval("'%s.slice(%s)[0]' % (x, -i if i == 1 else '%s, %s' % (-i, -i+1))", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        def _G_or_4():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['y'] = _G_apply_1
            _G_python_2, lastError = eval("'%s[%s]' % (x, y)", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_2, self.currentError)
        _G_or_5, lastError = self._or([_G_or_2, _G_or_3, _G_or_4])
        self.considerError(lastError)
        return (_G_or_5, self.currentError)

    def rule_del(self):
        _locals = {'self': self}
        self.locals['del'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['x'] = _G_apply_1
        _G_python_2, lastError = eval("'delete %s' % x", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_unop(self):
        _locals = {'self': self}
        self.locals['unop'] = _locals
        def _G_or_1():
            _G_exactly_1, lastError = self.exactly('not')
            self.considerError(lastError)
            def _G_listpattern_2():
                _G_exactly_1, lastError = self.exactly('call')
                self.considerError(lastError)
                def _G_listpattern_2():
                    _G_exactly_1, lastError = self.exactly('name')
                    self.considerError(lastError)
                    _G_exactly_2, lastError = self.exactly('hasattr')
                    self.considerError(lastError)
                    return (_G_exactly_2, self.currentError)
                _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
                self.considerError(lastError)
                def _G_listpattern_4():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    _locals['obj'] = _G_apply_1
                    _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    _locals['attr'] = _G_apply_2
                    return (_locals['attr'], self.currentError)
                _G_listpattern_5, lastError = self.listpattern(_G_listpattern_4)
                self.considerError(lastError)
                return (_G_listpattern_5, self.currentError)
            _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
            self.considerError(lastError)
            _G_python_4, lastError = eval('\'(typeof %s[%s] == "undefined")\' % (obj, attr)', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        def _G_or_2():
            _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError)
            _locals['op'] = _G_apply_1
            _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['x'] = _G_apply_2
            _G_python_3, lastError = eval("'(%s%s)' % (self.op_map.get(op, op), x)", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        _G_or_3, lastError = self._or([_G_or_1, _G_or_2])
        self.considerError(lastError)
        return (_G_or_3, self.currentError)

    def rule_binop(self):
        _locals = {'self': self}
        self.locals['binop'] = _locals
        def _G_or_1():
            _G_exactly_1, lastError = self.exactly('not in')
            self.considerError(lastError)
            _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['x'] = _G_apply_2
            _G_apply_3, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['y'] = _G_apply_3
            _G_python_4, lastError = eval("'!(%s in %s)' % (x, y)", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        def _G_or_2():
            _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError)
            _locals['op'] = _G_apply_1
            _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['x'] = _G_apply_2
            _G_apply_3, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['y'] = _G_apply_3
            _G_python_4, lastError = eval("'(%s %s %s)' % (x, self.binop_map.get(op, op), y)", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        _G_or_3, lastError = self._or([_G_or_1, _G_or_2])
        self.considerError(lastError)
        return (_G_or_3, self.currentError)

    def rule_name(self):
        _locals = {'self': self}
        self.locals['name'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['n'] = _G_apply_1
        _G_python_2, lastError = eval('self.get_name(n)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_number(self):
        _locals = {'self': self}
        self.locals['number'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['n'] = _G_apply_1
        _G_python_2, lastError = eval('str(n)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_hexnumber(self):
        _locals = {'self': self}
        self.locals['hexnumber'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['n'] = _G_apply_1
        _G_python_2, lastError = eval('hex(n)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_string(self):
        _locals = {'self': self}
        self.locals['string'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['s'] = _G_apply_1
        _G_python_2, lastError = eval('json.dumps(s)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_call(self):
        _locals = {'self': self}
        self.locals['call'] = _locals
        def _G_or_1():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('name')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('jsnew')
                self.considerError(lastError)
                return (_G_exactly_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            def _G_listpattern_3():
                _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['obj'] = _G_apply_1
                return (_locals['obj'], self.currentError)
            _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
            self.considerError(lastError)
            _G_python_5, lastError = eval("'(new %s)' % obj", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_5, self.currentError)
        def _G_or_2():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('name')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('len')
                self.considerError(lastError)
                return (_G_exactly_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            def _G_listpattern_3():
                _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['obj'] = _G_apply_1
                return (_locals['obj'], self.currentError)
            _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
            self.considerError(lastError)
            _G_python_5, lastError = eval("'%s.length' % obj", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_5, self.currentError)
        def _G_or_3():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('name')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('hasattr')
                self.considerError(lastError)
                return (_G_exactly_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            def _G_listpattern_3():
                _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['obj'] = _G_apply_1
                _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['attr'] = _G_apply_2
                return (_locals['attr'], self.currentError)
            _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
            self.considerError(lastError)
            _G_python_5, lastError = eval('\'(typeof %s[%s] != "undefined")\' % (obj, attr)', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_5, self.currentError)
        def _G_or_4():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('name')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('getattr')
                self.considerError(lastError)
                return (_G_exactly_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            def _G_listpattern_3():
                _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['obj'] = _G_apply_1
                _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['attr'] = _G_apply_2
                return (_locals['attr'], self.currentError)
            _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
            self.considerError(lastError)
            _G_python_5, lastError = eval("'%s[%s]' % (obj, attr)", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_5, self.currentError)
        def _G_or_5():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('name')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('setattr')
                self.considerError(lastError)
                return (_G_exactly_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            def _G_listpattern_3():
                _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['obj'] = _G_apply_1
                _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['attr'] = _G_apply_2
                _G_apply_3, lastError = self._apply(self.rule_expr, "expr", [])
                self.considerError(lastError)
                _locals['value'] = _G_apply_3
                return (_locals['value'], self.currentError)
            _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
            self.considerError(lastError)
            _G_python_5, lastError = eval("'%s[%s] = %s' % (obj, attr, value)", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_5, self.currentError)
        def _G_or_6():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('name')
                self.considerError(lastError)
                _G_exactly_2, lastError = self.exactly('JS')
                self.considerError(lastError)
                return (_G_exactly_2, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            def _G_or_3():
                def _G_listpattern_1():
                    def _G_listpattern_1():
                        _G_exactly_1, lastError = self.exactly('string')
                        self.considerError(lastError)
                        _G_apply_2, lastError = self._apply(self.rule_anything, "anything", [])
                        self.considerError(lastError)
                        _locals['js'] = _G_apply_2
                        return (_locals['js'], self.currentError)
                    _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                    self.considerError(lastError)
                    return (_G_listpattern_2, self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                _G_python_3, lastError = eval("'%s' % js", self.globals, _locals), None
                self.considerError(lastError)
                return (_G_python_3, self.currentError)
            def _G_or_4():
                def _G_listpattern_1():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    _locals['js'] = _G_apply_1
                    return (_locals['js'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                _G_python_3, lastError = eval("'eval(%s)' % js", self.globals, _locals), None
                self.considerError(lastError)
                return (_G_python_3, self.currentError)
            _G_or_5, lastError = self._or([_G_or_3, _G_or_4])
            self.considerError(lastError)
            return (_G_or_5, self.currentError)
        def _G_or_7():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['fn'] = _G_apply_1
            def _G_listpattern_2():
                def _G_many_1():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                _G_many_2, lastError = self.many(_G_many_1)
                self.considerError(lastError)
                _locals['args'] = _G_many_2
                return (_locals['args'], self.currentError)
            _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
            self.considerError(lastError)
            _G_python_4, lastError = eval("'%s(%s)' % (fn, ', '.join(args))", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        _G_or_8, lastError = self._or([_G_or_1, _G_or_2, _G_or_3, _G_or_4, _G_or_5, _G_or_6, _G_or_7])
        self.considerError(lastError)
        return (_G_or_8, self.currentError)

    def rule_list(self):
        _locals = {'self': self}
        self.locals['list'] = _locals
        _G_python_1, lastError = eval('self.indent()', self.globals, _locals), None
        self.considerError(lastError)
        def _G_many_2():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        _G_many_3, lastError = self.many(_G_many_2)
        self.considerError(lastError)
        _locals['xs'] = _G_many_3
        _G_python_4, lastError = eval('self.dedent()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_5, lastError = eval("'[%s]' % ', '.join(xs)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_5, self.currentError)

    def rule_tuple(self):
        _locals = {'self': self}
        self.locals['tuple'] = _locals
        _G_python_1, lastError = eval('self.indent()', self.globals, _locals), None
        self.considerError(lastError)
        def _G_many_2():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        _G_many_3, lastError = self.many(_G_many_2)
        self.considerError(lastError)
        _locals['xs'] = _G_many_3
        _G_python_4, lastError = eval('self.dedent()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_5, lastError = eval("'[%s]' % ', '.join(xs)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_5, self.currentError)

    def rule_set(self):
        _locals = {'self': self}
        self.locals['set'] = _locals
        _G_python_1, lastError = eval('self.indent()', self.globals, _locals), None
        self.considerError(lastError)
        def _G_many_2():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        _G_many_3, lastError = self.many(_G_many_2)
        self.considerError(lastError)
        _locals['xs'] = _G_many_3
        _G_python_4, lastError = eval('self.dedent()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_5, lastError = eval("'set([%s])' % ', '.join(xs)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_5, self.currentError)

    def rule_dict(self):
        _locals = {'self': self}
        self.locals['dict'] = _locals
        _G_python_1, lastError = eval('self.indent()', self.globals, _locals), None
        self.considerError(lastError)
        _locals['i'] = _G_python_1
        def _G_many_2():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        _G_many_3, lastError = self.many(_G_many_2)
        self.considerError(lastError)
        _locals['xs'] = _G_many_3
        _G_python_4, lastError = eval('self.dedent()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_5, lastError = eval('self.make_dict(xs, i)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_5, self.currentError)

    def rule_dictkv(self):
        _locals = {'self': self}
        self.locals['dictkv'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['k'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['v'] = _G_apply_2
        _G_python_3, lastError = eval("'%s: %s' % (k, v)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_3, self.currentError)

    def rule_self(self):
        _locals = {'self': self}
        self.locals['self'] = _locals
        _G_python_1, lastError = eval("'this'", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_1, self.currentError)

    def rule_break(self):
        _locals = {'self': self}
        self.locals['break'] = _locals
        _G_python_1, lastError = eval("'break'", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_1, self.currentError)

    def rule_continue(self):
        _locals = {'self': self}
        self.locals['continue'] = _locals
        _G_python_1, lastError = eval("'continue'", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_1, self.currentError)

    def rule_return(self):
        _locals = {'self': self}
        self.locals['return'] = _locals
        def _G_or_1():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['x'] = _G_apply_1
            _G_python_2, lastError = eval("'return %s' % x", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_2, self.currentError)
        def _G_or_2():
            _G_python_1, lastError = eval("'return'", self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_1, self.currentError)
        _G_or_3, lastError = self._or([_G_or_1, _G_or_2])
        self.considerError(lastError)
        return (_G_or_3, self.currentError)

    def rule_raise(self):
        _locals = {'self': self}
        self.locals['raise'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['x'] = _G_apply_1
        _G_python_2, lastError = eval("'throw %s' % x", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_while(self):
        _locals = {'self': self}
        self.locals['while'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['cond'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_block, "block", [])
        self.considerError(lastError)
        _locals['body'] = _G_apply_2
        _G_python_3, lastError = eval("'while (%s) %s' % (cond, ''.join(body))", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_3, self.currentError)

    def rule_if(self):
        _locals = {'self': self}
        self.locals['if'] = _locals
        def _G_listpattern_1():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['cond'] = _G_apply_1
            _G_apply_2, lastError = self._apply(self.rule_block, "block", [])
            self.considerError(lastError)
            _locals['t'] = _G_apply_2
            return (_locals['t'], self.currentError)
        _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
        self.considerError(lastError)
        def _G_listpattern_3():
            def _G_many_1():
                def _G_listpattern_1():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    _locals['c'] = _G_apply_1
                    _G_apply_2, lastError = self._apply(self.rule_block, "block", [])
                    self.considerError(lastError)
                    _locals['b'] = _G_apply_2
                    return (_locals['b'], self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                _G_python_3, lastError = eval('(c, b)', self.globals, _locals), None
                self.considerError(lastError)
                return (_G_python_3, self.currentError)
            _G_many_2, lastError = self.many(_G_many_1)
            self.considerError(lastError)
            _locals['ei'] = _G_many_2
            return (_locals['ei'], self.currentError)
        _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
        self.considerError(lastError)
        def _G_optional_5():
            _G_apply_1, lastError = self._apply(self.rule_block, "block", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        def _G_optional_6():
            return (None, self.input.nullError())
        _G_or_7, lastError = self._or([_G_optional_5, _G_optional_6])
        self.considerError(lastError)
        _locals['e'] = _G_or_7
        _G_python_8, lastError = eval('self.make_if(cond, t, ei, e)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_8, self.currentError)

    def rule_ifexpr(self):
        _locals = {'self': self}
        self.locals['ifexpr'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['cond'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['t'] = _G_apply_2
        _G_apply_3, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['f'] = _G_apply_3
        _G_python_4, lastError = eval("'(%s ? %s : %s)' % (cond, t, f)", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_4, self.currentError)

    def rule_isliteral(self):
        _locals = {'self': self}
        self.locals['isliteral'] = _locals
        def _G_or_1():
            def _G_lookahead_1():
                def _G_listpattern_1():
                    def _G_or_1():
                        _G_exactly_1, lastError = self.exactly('name')
                        self.considerError(lastError)
                        return (_G_exactly_1, self.currentError)
                    def _G_or_2():
                        _G_exactly_1, lastError = self.exactly('number')
                        self.considerError(lastError)
                        return (_G_exactly_1, self.currentError)
                    def _G_or_3():
                        _G_exactly_1, lastError = self.exactly('hexnumber')
                        self.considerError(lastError)
                        return (_G_exactly_1, self.currentError)
                    def _G_or_4():
                        _G_exactly_1, lastError = self.exactly('string')
                        self.considerError(lastError)
                        return (_G_exactly_1, self.currentError)
                    _G_or_5, lastError = self._or([_G_or_1, _G_or_2, _G_or_3, _G_or_4])
                    self.considerError(lastError)
                    def _G_many_6():
                        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
                        self.considerError(lastError)
                        return (_G_apply_1, self.currentError)
                    _G_many_7, lastError = self.many(_G_many_6)
                    self.considerError(lastError)
                    return (_G_many_7, self.currentError)
                _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                self.considerError(lastError)
                return (_G_listpattern_2, self.currentError)
            _G_lookahead_2, lastError = self.lookahead(_G_lookahead_1)
            self.considerError(lastError)
            _G_python_3, lastError = eval('True', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        def _G_or_2():
            _G_python_1, lastError = eval('False', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_1, self.currentError)
        _G_or_3, lastError = self._or([_G_or_1, _G_or_2])
        self.considerError(lastError)
        return (_G_or_3, self.currentError)

    def rule_for(self):
        _locals = {'self': self}
        self.locals['for'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['var'] = _G_apply_1
        _G_python_2, lastError = eval('self.register_var(var)', self.globals, _locals), None
        self.considerError(lastError)
        def _G_or_3():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('call')
                self.considerError(lastError)
                def _G_listpattern_2():
                    _G_exactly_1, lastError = self.exactly('name')
                    self.considerError(lastError)
                    _G_exactly_2, lastError = self.exactly('range')
                    self.considerError(lastError)
                    return (_G_exactly_2, self.currentError)
                _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
                self.considerError(lastError)
                def _G_listpattern_4():
                    def _G_many1_1():
                        _G_apply_1, lastError = self._apply(self.rule_isliteral, "isliteral", [])
                        self.considerError(lastError)
                        _locals['lit'] = _G_apply_1
                        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
                        self.considerError(lastError)
                        _locals['e'] = _G_apply_2
                        _G_python_3, lastError = eval('(lit, e)', self.globals, _locals), None
                        self.considerError(lastError)
                        return (_G_python_3, self.currentError)
                    _G_many1_2, lastError = self.many(_G_many1_1, _G_many1_1())
                    self.considerError(lastError)
                    _locals['r'] = _G_many1_2
                    def _G_pred_3():
                        _G_python_1, lastError = eval('len(r) <= 3', self.globals, _locals), None
                        self.considerError(lastError)
                        return (_G_python_1, self.currentError)
                    _G_pred_4, lastError = self.pred(_G_pred_3)
                    self.considerError(lastError)
                    return (_G_pred_4, self.currentError)
                _G_listpattern_5, lastError = self.listpattern(_G_listpattern_4)
                self.considerError(lastError)
                return (_G_listpattern_5, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_apply_3, lastError = self._apply(self.rule_block, "block", [])
            self.considerError(lastError)
            _locals['body'] = _G_apply_3
            _G_python_4, lastError = eval('self.make_for_range(var, r, body)', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        def _G_or_4():
            def _G_listpattern_1():
                _G_exactly_1, lastError = self.exactly('call')
                self.considerError(lastError)
                def _G_listpattern_2():
                    _G_exactly_1, lastError = self.exactly('name')
                    self.considerError(lastError)
                    _G_exactly_2, lastError = self.exactly('reversed')
                    self.considerError(lastError)
                    return (_G_exactly_2, self.currentError)
                _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
                self.considerError(lastError)
                def _G_listpattern_4():
                    def _G_listpattern_1():
                        _G_exactly_1, lastError = self.exactly('call')
                        self.considerError(lastError)
                        def _G_listpattern_2():
                            _G_exactly_1, lastError = self.exactly('name')
                            self.considerError(lastError)
                            _G_exactly_2, lastError = self.exactly('range')
                            self.considerError(lastError)
                            return (_G_exactly_2, self.currentError)
                        _G_listpattern_3, lastError = self.listpattern(_G_listpattern_2)
                        self.considerError(lastError)
                        def _G_listpattern_4():
                            def _G_many1_1():
                                _G_apply_1, lastError = self._apply(self.rule_isliteral, "isliteral", [])
                                self.considerError(lastError)
                                _locals['lit'] = _G_apply_1
                                _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
                                self.considerError(lastError)
                                _locals['e'] = _G_apply_2
                                _G_python_3, lastError = eval('(lit, e)', self.globals, _locals), None
                                self.considerError(lastError)
                                return (_G_python_3, self.currentError)
                            _G_many1_2, lastError = self.many(_G_many1_1, _G_many1_1())
                            self.considerError(lastError)
                            _locals['r'] = _G_many1_2
                            def _G_pred_3():
                                _G_python_1, lastError = eval('len(r) <= 3', self.globals, _locals), None
                                self.considerError(lastError)
                                return (_G_python_1, self.currentError)
                            _G_pred_4, lastError = self.pred(_G_pred_3)
                            self.considerError(lastError)
                            return (_G_pred_4, self.currentError)
                        _G_listpattern_5, lastError = self.listpattern(_G_listpattern_4)
                        self.considerError(lastError)
                        return (_G_listpattern_5, self.currentError)
                    _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
                    self.considerError(lastError)
                    return (_G_listpattern_2, self.currentError)
                _G_listpattern_5, lastError = self.listpattern(_G_listpattern_4)
                self.considerError(lastError)
                return (_G_listpattern_5, self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_apply_3, lastError = self._apply(self.rule_block, "block", [])
            self.considerError(lastError)
            _locals['body'] = _G_apply_3
            _G_python_4, lastError = eval('self.make_for_reversed_range(var, r, body)', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_4, self.currentError)
        def _G_or_5():
            _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
            self.considerError(lastError)
            _locals['data'] = _G_apply_1
            _G_apply_2, lastError = self._apply(self.rule_block, "block", [])
            self.considerError(lastError)
            _locals['body'] = _G_apply_2
            _G_python_3, lastError = eval('self.make_for(var, data, body)', self.globals, _locals), None
            self.considerError(lastError)
            return (_G_python_3, self.currentError)
        _G_or_6, lastError = self._or([_G_or_3, _G_or_4, _G_or_5])
        self.considerError(lastError)
        return (_G_or_6, self.currentError)

    def rule_defaultarg(self):
        _locals = {'self': self}
        self.locals['defaultarg'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['name'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['default'] = _G_apply_2
        _G_python_3, lastError = eval('(name, default)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_3, self.currentError)

    def rule_stararg(self):
        _locals = {'self': self}
        self.locals['stararg'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['name'] = _G_apply_1
        _G_python_2, lastError = eval('(name,)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_func(self):
        _locals = {'self': self}
        self.locals['func'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_funcstmt, "funcstmt", [])
        self.considerError(lastError)
        _locals['f'] = _G_apply_1
        _G_python_2, lastError = eval("'(%s)' % f", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_2, self.currentError)

    def rule_funcstmt(self):
        _locals = {'self': self}
        self.locals['funcstmt'] = _locals
        _G_python_1, lastError = eval('self.push_vars()', self.globals, _locals), None
        self.considerError(lastError)
        _G_apply_2, lastError = self._apply(self.rule_anything, "anything", [])
        self.considerError(lastError)
        _locals['name'] = _G_apply_2
        def _G_listpattern_3():
            def _G_listpattern_1():
                def _G_many_1():
                    _G_apply_1, lastError = self._apply(self.rule_expr, "expr", [])
                    self.considerError(lastError)
                    return (_G_apply_1, self.currentError)
                _G_many_2, lastError = self.many(_G_many_1)
                self.considerError(lastError)
                _locals['args'] = _G_many_2
                return (_locals['args'], self.currentError)
            _G_listpattern_2, lastError = self.listpattern(_G_listpattern_1)
            self.considerError(lastError)
            _G_apply_3, lastError = self._apply(self.rule_anything, "anything", [])
            self.considerError(lastError)
            _locals['stararg'] = _G_apply_3
            return (_locals['stararg'], self.currentError)
        _G_listpattern_4, lastError = self.listpattern(_G_listpattern_3)
        self.considerError(lastError)
        _G_python_5, lastError = eval('self.register_globals(args)', self.globals, _locals), None
        self.considerError(lastError)
        _G_apply_6, lastError = self._apply(self.rule_funcblock, "funcblock", [])
        self.considerError(lastError)
        _locals['body'] = _G_apply_6
        _G_python_7, lastError = eval('self.pop_vars()', self.globals, _locals), None
        self.considerError(lastError)
        _G_python_8, lastError = eval('self.make_func(name, args, stararg, body)', self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_8, self.currentError)

    def rule_try(self):
        _locals = {'self': self}
        self.locals['try'] = _locals
        _G_apply_1, lastError = self._apply(self.rule_block, "block", [])
        self.considerError(lastError)
        _locals['body'] = _G_apply_1
        _G_apply_2, lastError = self._apply(self.rule_expr, "expr", [])
        self.considerError(lastError)
        _locals['err'] = _G_apply_2
        _G_apply_3, lastError = self._apply(self.rule_block, "block", [])
        self.considerError(lastError)
        _locals['errbody'] = _G_apply_3
        def _G_optional_4():
            _G_apply_1, lastError = self._apply(self.rule_block, "block", [])
            self.considerError(lastError)
            return (_G_apply_1, self.currentError)
        def _G_optional_5():
            return (None, self.input.nullError())
        _G_or_6, lastError = self._or([_G_optional_4, _G_optional_5])
        self.considerError(lastError)
        _locals['finbody'] = _G_or_6
        _G_python_7, lastError = eval("'try %s catch(%s) %s' % (body, err, errbody) + (' finally %s' % finbody if finbody else '')", self.globals, _locals), None
        self.considerError(lastError)
        return (_G_python_7, self.currentError)


text:
function GetWavDataMultipleSpreadsheets_matt(sfolder, direrror, ...
    nameerror, wavnamout, getwavlog)
    if nargin < 5
        getwavlog = fullfile(sfolder,'GetWavDataLog.txt');
        if nargin < 4
            wavnamout = fullfile(sfolder,'wavNamingLog.txt');
            if nargin < 3
                nameerror = fullfile(sfolder,'NamingErrors.txt');
                if nargin < 2
                    direrror = fullfile(sfolder,'DirectoryErrors.txt');
                end
            end
        end
    end
    fprintf('Running GetWavData for %s at %s.\n',sfolder,datestr(now));
    addpath('D:\BackupFromDesktop072815\MATLABCode\MatlabSeminarDemos',...
        'D:\BackupFromDesktop072815\MATLABCode\MATLAB') %directories for wavNaming and bin2wav
    recdir = 'D:/SoundData'; %directory where 'Recordings' folders are
    direrrorout = fopen(direrror,'at'); %file to write errors in directory naming
    getwavout = fopen(getwavlog,'at');
    %Get a list of all worksheets in the folder.
    listing = dir(fullfile(sfolder,'*.xlsx'));
    %For each worksheet in the folder,
    for file = listing' %listing appears to be a row array.
        %tic;
        %Map the name of the worksheet to the directory where the .wav file
        %should be.
        fn = file.name;
        fprintf(getwavout,'Parsing %s at %s.\n',fn,datestr(now));
        nosuff = strrep(fn,'.xlsx',''); %eliminate file suffix
        dings = strfind(nosuff,'dings');
        if isempty(dings)
            wplural = strrep(nosuff,'ding','dings');
        else
            wplural = nosuff;
        end
        if exist(fullfile(recdir,wplural),'dir') == 0
            %try adding a '20' to the name
            finaldir = strcat(wplural(1:(length(wplural)-2)),'20',...
                wplural((length(wplural)-1):length(wplural)));
        elseif exist(fullfile(recdir,wplural),'dir') == 7
            finaldir = wplural;
        else
            fprintf(direrrorout,'%s is not a directory.\n', wplural);
            continue
        end
        %find the associated .bin file (if there is one),
        binfiles = dir(fullfile(recdir,finaldir,'*.bin'));
        if isempty(binfiles)
            fprintf(direrrorout,'No .bin files in %s.\n',finaldir);
            continue
        elseif length(binfiles) > 1
            fprintf(direrrorout,'Multiple .bin files in %s.\n',finaldir);
            continue
        else
            wavfiles = dir(fullfile(recdir,finaldir,'*.wav'));
            if length(wavfiles) > 1
                fprintf(direrrorout,'Multiple .wav files in %s.\n',finaldir);
                continue
            elseif isempty(wavfiles)
                %Run bin2wav
                bfname = binfiles(1).name;
                binbase = strrep(bfname,'.bin','');
                bin2wav(fullfile(recdir,finaldir,binbase));
                wavfiles = dir(fullfile(recdir,finaldir,'*.wav'));
            end
            %and run wavNaming.
            wname = wavfiles(1).name;
            fixname = wavNaming_matt(fullfile(sfolder,fn),...
                fullfile(recdir,finaldir,wname),...
                nameerror,wavnamout);
            if fixname == 1
                fprintf(getwavout,'Naming issue for %s; fix and re-run.\n',fn);
            elseif fixname == 2
                fprintf(getwavout,'No more channels for %s; continuing.\n',fn);
                continue
            end
        end
        fprintf(getwavout,'Finished getting files from %s at %s.\n',fn,datestr(now));
        %etime = toc;
        %fprintf(getwavout,'Elapsed time is %s seconds.\n',num2str(etime));
    end
    fclose(direrrorout);
    fclose(getwavout);
    fprintf('Finished running GetWavData for %s at %s.\n',...
        sfolder,datestr(now));
end

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

	<title>

            Paradise Events -

    Complete profile - Canadian Company Capabilities - Industries and Business - Industry Canada
  </title>

<meta charset="utf-8" />
<meta name="dcterms.language" title="ISO639-2" content="eng" />
<meta name="dcterms.title" content="" />
<meta name="description" content="" />
<meta name="dcterms.description" content="" />
<meta name="dcterms.type" content="report, data set" />
<meta name="dcterms.subject" content="businesses, industry" />
<meta name="dcterms.subject" content="businesses, industry" />
<meta name="dcterms.issued" title="W3CDTF" content="" />
<meta name="dcterms.modified" title="W3CDTF" content="" />
<meta name="keywords" content="" />

<meta name="dcterms.creator" content="" />
<meta name="author" content="" />
<meta name="dcterms.created" title="W3CDTF" content="" />
<meta name="dcterms.publisher" content="" />
<meta name="dcterms.audience" title="icaudience" content="" />
<meta name="dcterms.spatial" title="ISO3166-1" content="" />
<meta name="dcterms.spatial" title="gcgeonames" content="" />
<meta name="dcterms.format" content="HTML" />
<meta name="dcterms.identifier" title="ICsiteProduct" content="536" />

<meta http-equiv="X-UA-Compatible" content="IE=edge">

<meta content="width=device-width,initial-scale=1" name="viewport">

<meta name = "format-detection" content = "telephone=no">

<meta name="robots" content="noarchive">

<link href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/assets/favicon.ico" rel="icon" type="image/x-icon">
<link rel="stylesheet" href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/css/wet-boew.min.css">

<link rel="stylesheet" href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/css/theme.min.css">

<link rel="stylesheet" href="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/css/noscript.min.css" />

<link rel="stylesheet" href="/eic/home.nsf/css/add_WET_4-0_Canada_Apps.css">

  	<link href="//netdna.bootstrapcdn.com/font-awesome/4.0.3/css/font-awesome.css" rel="stylesheet">
  	<link href="/app/ccc/srch/css/print.css" media="print" rel="stylesheet" type="text/css" />

<meta property="legalName" content="Department_of_Industry">

Skip to main content

Skip to "About this site"

Language selection

Français

<object type="image/svg+xml" tabindex="-1" data="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/assets/sig-blk-en.svg"></object> Government of Canada

Search and menus

Search and menus

Topics menu

Jobs

Immigration

Travel

Business

Benefits

Health

Taxes

More services

You are here:

Home

Industries and Business

Canadian Company Capabilities

<input id="showMore" type="hidden" value='more'/>
<input id="showLess" type="hidden" value='less'/>

 Company profile - Canadian Company Capabilities

New Search |

<form name="searchForm" method="post" action="/app/ccc/srch/bscSrch.do">

          <input type="hidden" name="lang" value="eng" />
          <input type="hidden" name="profileId" value="" />
          <input type="hidden" name="prtl" value="1" />
          <input type="hidden" name="searchPage" value="%2Fapp%2Fccc%2Fsrch%2FcccBscSrch.do%3Flang%3Deng%26amp%3Bprtl%3D1%26amp%3Btagid%3D"  />

          <input type="hidden" name="V_SEARCH.scopeCategory" value="CCC.Root" />

          <input type="hidden" name="V_SEARCH.depth" value="1" />
          <input type="hidden" name="V_SEARCH.showStricts" value="false" />
          <input id="repeatSearchBtn" class="btn btn-link" type="submit" value="Return to search results" />

  </form>

| Previous Company

| Next Company

      Third-Party Information Liability Disclaimer

Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.

      Paradise Events

Legal/Operating Name:

Paradise Events

http://www.ParadiseEvents.com

info@paradiseevents.com

Mailing Address:

              	<address class="mrgn-bttm-md">

                   750 Pacific Blvd

                    VANCOUVER,

                    British Columbia

                  V6B 5E7

                </address>

Location Address:

              	         <address class="mrgn-bttm-md">

                   750 Pacific Blvd

                    VANCOUVER,

                    British Columbia

                  V6B 5E7

                         </address>

Tel.:
		      (604) 687-6200

Fax:
		      (604) 638-5157

Company Profile

            Vancouver DJ (Wedding DJ), mobile Disco Jockey for Christmas Party, High School Dance Deejay, DJ for prom nights, graduations, corporate events, private parties and special events since 1998, in the Lower Mainland, BC.  Other party rentals services and event services include&#65306; Photobooth Vancouver, Uplighting (wireless uplights), Gobo Light, Wedding Ambient Light, Laser Lights, Party Lights; Dance Floor Rental; Audio Video Projector + Projector Screen Rental; Step and Repeat Red Carpet Backdrop; Trade Show Displays Banner Printing.

				Full profile

				Full profile

				Contact information

                Swan
                Chan

                  Telephone:

                (604) 687-6200

                    Email:

                  info@paradiseevents.com

  top of page

				Company description

            Country of Ownership:

              Canada

              Year Established:

            1998

            Exporting:

              No

                Primary Industry (NAICS):

				711512 - Independent Actors, Comedians and Performers

            Alternate Industries (NAICS):

            532210 - Consumer Electronics and Appliance Rental

            532290 - Other Consumer Goods Rental

            Primary Business Activity:

            Services

				Product / Service / Licensing

                              Service Name:

                            DJ, Photobooth Rentals, Lighting Rentals, Party Rentals, Step and Repeat, Trade Show Displays Printing

                            Mobile Disco Jockey for Vancouver weddings, Christmas Party, High School Dances, Graduations, Corporate Events, Private Parties and Special Events in the Lower Mainland, BC since 1998.

Our full time and full production services and events rentals include: lighting, sound, photobooth rental, audio video projector scree rentals, photo station, green screen studio, dance floor rental, party lights (laser light, black light, disco lights) + ambient light (uplighting & gobo lights).

We also provide banner printing for step and repeat, red carpet backdrop and trade show displays.

  top of page

					Sector information

                Key / Major clients:

              10 years on site production company for Plaza of Nation, TD Canada Trust, Red Cross Canada, Van City, Costco, The Vancouver Sun, Variety the Children Foundation, Fair Child Television, Telus Mobility, Max Mara, Marine Drive Golf Club, Snowball Classic, UBC Ballroom Competition, Du Marier International Jazz Festival , Festival Latino, Great Canadian Pet Fair, TD Mid-Autumn Festival , Chinese New Year Festivals, Leone Fashion Show, Bear Wear (Vancouver Grizzlies), Cultural Wealth Young Designers of Vancouver, Face West Modeling Scout Show, Brentwood Mall,

                Success stories:

               We just had our office Christmas party and booked a photo booth with Paradise Events. They were great, and the photographer was awesome, making sure everyone had had a chance to get a photo before packing up at the end of the night. More importantly, the booth served as entertainment for the evening, broke the ice, and got everyone laughing which is the whole point of getting the office together for the holidays! People were loving that they got printed souvenirs right away, and everyone is already asking about where to get their digital copies. Big thanks to Paradise Events for making our party so memorable!

                Testimonial:

              Swan and the team at paradise events completely blew my mind. I had the pleasure of planning TD's Christmas party and I couldn't be happier when I found a company that could provide me a one-stop shop for the lighting, dj and photo-booth at a fantastic price. They took all my stress away and I left everything in their hands. Anything I asked for, they made it work and delivered. The night itself was amazing. The lighting was beautiful- the DJ was awesome and the photo-booth was a huge hit. The quality of the pictures was nothing like I've seen before. The thing I am most impressed is with the service I received. From the moment I first spoke with them, they were so helpful and knowledgeable. The party would not have been such a success if it wasn't for the team at Paradise Events. I am forever a customer and will definitely call them for any of my future events. I highly, highly recommend. You won't be disappointed! Thanks for the great memory :)

					Third-Party Information Liability Disclaimer

					Some of the information on this Web page has been provided by external sources. The Government of Canada is not responsible for the accuracy, reliability or currency of the information supplied by external sources. Users wishing to rely upon this information should consult directly with the source of the information. Content provided by external sources is not subject to official languages, privacy and accessibility requirements.

				Contacts

				Contact information

                Swan
                Chan

                  Telephone:

                (604) 687-6200

                    Email:

                  info@paradiseevents.com

				Description

				Company description

            Country of Ownership:

              Canada

              Year Established:

            1998

            Exporting:

              No

                Primary Industry (NAICS):

				711512 - Independent Actors, Comedians and Performers

            Alternate Industries (NAICS):

            532210 - Consumer Electronics and Appliance Rental

            532290 - Other Consumer Goods Rental

            Primary Business Activity:

            Services

				Products, services and licensing

				Product / Service / Licensing

                              Service Name:

                            DJ, Photobooth Rentals, Lighting Rentals, Party Rentals, Step and Repeat, Trade Show Displays Printing

                            Mobile Disco Jockey for Vancouver weddings, Christmas Party, High School Dances, Graduations, Corporate Events, Private Parties and Special Events in the Lower Mainland, BC since 1998.

Our full time and full production services and events rentals include: lighting, sound, photobooth rental, audio video projector scree rentals, photo station, green screen studio, dance floor rental, party lights (laser light, black light, disco lights) + ambient light (uplighting & gobo lights).

We also provide banner printing for step and repeat, red carpet backdrop and trade show displays.

					Sector

					Sector information

                Key / Major clients:

              10 years on site production company for Plaza of Nation, TD Canada Trust, Red Cross Canada, Van City, Costco, The Vancouver Sun, Variety the Children Foundation, Fair Child Television, Telus Mobility, Max Mara, Marine Drive Golf Club, Snowball Classic, UBC Ballroom Competition, Du Marier International Jazz Festival , Festival Latino, Great Canadian Pet Fair, TD Mid-Autumn Festival , Chinese New Year Festivals, Leone Fashion Show, Bear Wear (Vancouver Grizzlies), Cultural Wealth Young Designers of Vancouver, Face West Modeling Scout Show, Brentwood Mall,

                Success stories:

               We just had our office Christmas party and booked a photo booth with Paradise Events. They were great, and the photographer was awesome, making sure everyone had had a chance to get a photo before packing up at the end of the night. More importantly, the booth served as entertainment for the evening, broke the ice, and got everyone laughing which is the whole point of getting the office together for the holidays! People were loving that they got printed souvenirs right away, and everyone is already asking about where to get their digital copies. Big thanks to Paradise Events for making our party so memorable!

                Testimonial:

              Swan and the team at paradise events completely blew my mind. I had the pleasure of planning TD's Christmas party and I couldn't be happier when I found a company that could provide me a one-stop shop for the lighting, dj and photo-booth at a fantastic price. They took all my stress away and I left everything in their hands. Anything I asked for, they made it work and delivered. The night itself was amazing. The lighting was beautiful- the DJ was awesome and the photo-booth was a huge hit. The quality of the pictures was nothing like I've seen before. The thing I am most impressed is with the service I received. From the moment I first spoke with them, they were so helpful and knowledgeable. The party would not have been such a success if it wasn't for the team at Paradise Events. I am forever a customer and will definitely call them for any of my future events. I highly, highly recommend. You won't be disappointed! Thanks for the great memory :)

    Last Update Date 2015-01-09

Date Modified:

      <time>2017-03-02</time>

About government

Contact us

Departments and agencies

Public service and military

News

Treaties, laws and regulations

Government-wide reporting

Prime Minister

How government works

Open government

About this site

Social media

Mobile applications

About Canada.ca

Terms and conditions

Privacy

Top of Page

<object type="image/svg+xml" tabindex="-1" role="img" data="/utils/scripts/_WET_4-0/apps/themes-dist/gcweb/assets/wmms-blk.svg" aria-label="Symbol of the Government of Canada"></object>


text:
import { ComponentFactoryResolver, SimpleChanges, OnChanges } from '@angular/core';
import { EditCellDefault } from './edit-cell-default';
export declare class CustomEditComponent extends EditCellDefault implements OnChanges {
    private resolver;
    customComponent: any;
    dynamicTarget: any;
    constructor(resolver: ComponentFactoryResolver);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
}


text:
<?php
namespace persiang\Grids\Components\Base;

/**
 * Interface RegistryInterface
 *
 * Interface of Grid components registry
 *
 * @package persiang\Grids\Components\Base
 */
interface RegistryInterface
{
    /**
     * Returns collection of attached components.
     *
     * @return \Illuminate\Support\Collection|ComponentInterface[]|array
     */
    public function getComponents();

    /**
     * Returns child component
     * with specified name or null if component not found.
     *
     * @param string $name
     * @return ComponentInterface|null
     */
    public function getComponentByName($name);

    /**
     * Adds component to collection.
     *
     * @param ComponentInterface $component
     * @return $this
     */
    public function addComponent(ComponentInterface $component);

    /**
     * Sets children components collection.
     *
     * @param \Illuminate\Support\Collection|ComponentInterface[]|array $components
     * @return $this
     */
    public function setComponents($components);

    /**
     * Adds components to collection.
     *
     * @param \Illuminate\Support\Collection|ComponentInterface[]|array $components
     * @return $this
     */
    public function addComponents($components);

    /**
     * Creates component be class name,
     * attaches it to children collection
     * and returns this component as result.
     *
     * @param string $class
     * @return ComponentInterface
     */
    public function makeComponent($class);
}


text:
omc-server
==========

Oh my chat - Server


text:
key: 5
user: Augusto Santos
userAvatar: /img/user.jpg
title: Testando ReactJS Component Post
atCreated: 25/05/2017
viewrs: 15
comment: 25
tags: [ReactJS, ES2015, JavaScript, LoopBack, MarkDown]
---

## Introdução

 A pagina de **Post** e constituida de varios Components feito sobe medida para ela.

 Em busca de torna a pagina mais comfortavel e atraente, cada componente foi desenvolvido
cuidadosamente, para manter um perfeito equilibrio e armonia, entre a pagina e seus creador.

Feito em conjunto a uma API, para atender as suas *querys*, para as mais diversas plataformas.

## Tomada de Decição para API

 As varias opções de **frameworks** no mercado, que facilitam no desenvolvimento de *API*s, são diversificada.
Para melhor integra a aplicação foi decidido que:

- **RDBMS**: *PostgreSQL*
- **Servidor**: *NodeJS* usando *ExpressJS*

Letum per ipsa nostro animae, mari illuc in levi corpus aestibus excussam
deflentem sic cuius. Venere dedit illa cui in quo senecta artus bella inficit,
Achaica. Videbatur crinem resonantia alto dea umida dicitur igne; meus signa
habet; est. Cognovit coepta: similes fugis: habuissem votivi liquida: ictus visi
nostra me Adoni.

## Laedar cum margine quoque

Quam dato ullis, acer venturi volantes! Tuam non non cursu acta hic, novem
nutrit, in sidera viscera iam fontes tempora, omnes. Saturnius artus inquit,
conatoque erectos lenius, carinae, ora est infamia elige per Medusaei induitur.
Quem quem ab postquam tunc frondescere nodis capiam labique. Voluere luce
Semeles.

```
    if (delete(digital, hibernateSoft, dynamicExcelVpn) > io_secondary_led /
            84) {
        disk = load;
        orientationPci.matrix_laptop(modelSsdTweet);
    } else {
        kdeEmoticonLed.mebibyte_algorithm_domain(2,
                hackerCtr.rom_iso_desktop.scarewarePrimaryBankruptcy(station,
                disk_mask_matrix, restore_crt));
        cameraSpyware(4, multitasking(-3, log_dfs_controller));
        menuCisc.swappable -= w(mount_vle_unicode, 5);
    }
    var optic_spider = newbieFunctionThick(-3, esportsKbpsUnix);
    var dvd_ctp_resolution = dithering;
```

## Usus fixurus illi petunt

Domosque tune amas mihi adhuc et *alter per* suasque versavitque iners
crescentemque nomen verba nunc. Acervos hinc natus si habet. Et cervix imago
quod! Arduus dolet!

```
    git clone https://github.com/augusto-santos/webapp
```

Aliquid mansura arida altismunera **in illi**. Dignus vir pontum *crimen
versabat* carpunt omnes rotis Canentem erant in Oebalio, et manu senecta
iungere. Prima diurnis!


text:
using System.ComponentModel.Composition;
using Cortex.Studio.Modules.ProjectExplorer.Commands;
using Gemini.Framework.Menus;

namespace Cortex.Studio.Modules.ProjectExplorer
{
    class MenuDefenitions
    {
        [Export]
        public static MenuItemDefinition OpenProjectExplorerMenuItem = new CommandMenuItemDefinition<OpenProjectExplorerDefinition>(
            Gemini.Modules.MainMenu.MenuDefinitions.ViewToolsMenuGroup, 0);

        [Export]
        public static MenuItemDefinition OpenFolderMenuItem = new CommandMenuItemDefinition<OpenProjectDefenition>(
            Gemini.Modules.MainMenu.MenuDefinitions.FileNewOpenMenuGroup, 1);

        [Export]
        public static MenuItemDefinition RecentMenuItem = new TextMenuItemDefinition(
            Gemini.Modules.MainMenu.MenuDefinitions.FileNewOpenMenuGroup, 3, "_Recent");

        [Export]
        public static MenuItemGroupDefinition RecentCascadeGroup = new MenuItemGroupDefinition(RecentMenuItem, 0);

        [Export]
        public static MenuItemDefinition RecentMenuItemList = new CommandMenuItemDefinition<OpenExactProjectListDefenition>(RecentCascadeGroup, 0);
    }
}


text:
using System.Collections.Generic;
using System.Linq;
using taller.Model;
using taller.Data;

namespace taller.Services
{
    public class StarWarsEFService : IStarWarsService
    {
        IEnumerable<Films> FilmsCollection;
        IEnumerable<Characters> CharactersCollection;

        private EFCoreWebDemoContext _context;

        public StarWarsEFService(EFCoreWebDemoContext context)
        {
            _context = context;
        }

        IEnumerable<Characters> IStarWarsService.GetCharacters()
        {
          return _context.Characters.ToList();
        }

        IEnumerable<Characters> IStarWarsService.GetCharactersByName(string name)
        {
         return _context.Characters.Where(c=> c.Name == name).ToList();
        }

        IEnumerable<Films> IStarWarsService.GetFilms()
        {
             return _context.Films.ToList();
        }

        IEnumerable<Films> IStarWarsService.GetFilmsByName(string name)
        {
          return _context.Films.Where(c=> c.Name == name).ToList();
        }
    }
}


text:
angular.module('security', [
  'security.service',
  'security.interceptor',
  'security.login',
  'security.authorization']);


text:
title:  Le déluge
date:   16/04/2022
---

### Lecture de la semaine
Genèse 6:13-7:10, 2 Pierre 2:5-9, Genèse 7, Romains 6:1-6, Ps. 106:4, Genèse 8, Genèse 9:1-17.

>
Verset à mémoriser

> « Ce qui arriva du temps de Noé arrivera de même à l'avènement du Fils de l'homme » (Matthieu 24:37, LSG).

L'Éternel vit que la méchanceté des hommes était grande sur la terre, et que toutes les pensées de leur cœur se portaient chaque jour uniquement vers le mal » (Genèse 6:5, LSG). Le verbe « vit » (Genèse 6:5) ramène le lecteur à chaque étape de la création initiale de Dieu. Mais ce que Dieu voit maintenant, au lieu d'être tov, « bon », est ra', « mal » (Genèse 6:5). C'est comme si Dieu avait regretté d'avoir créé le monde, qui est maintenant plein de ra' (Genèse 6:5).

Toutefois, le regret de Dieu contient aussi des éléments de salut. Le mot hébreu pour « désolé » (nakham) est repris dans le nom de Noé (Noakh), qui signifie « réconfort » (Genèse 5:29). Ainsi, la réponse de Dieu à cette méchanceté a deux côtés. Elle contient la menace de la justice, conduisant à la destruction pour certains; et pourtant, Sa réponse promet réconfort et miséricorde, conduisant aussi au salut pour les autres.

Cette « double voix » était déjà entendue dans le cas de Caïn et Abel/Seth, et elle se répétait à travers le contraste entre les deux lignées de Seth (les « fils de Dieu ») et Caïn (les « fils des hommes »). Maintenant, nous l'entendons à nouveau alors que Dieu fait la différence entre Noé et le reste de l'humanité.

*** Étudiez cette leçon pour le sabbat 23 avril.**


text:
//
//  SecondViewController.m
//  HelpUkraine
//
//  Created by Admin on 8/10/14.
//  Copyright (c) 2014 Igor Zhariy. All rights reserved.
//

#import "MainViewController.h"
#import "DetailsViewController.h"
#import "AppDelegate.h"
#import "Constants.h"
#import "ListTableViewCell.h"

@class ListTableViewCell;

@interface ListViewController ()

@end

@implementation ListViewController

- (id)initWithNibName:(NSString *)nibNameOrNil bundle:(NSBundle *)nibBundleOrNil
{
    self = [super initWithNibName:nibNameOrNil bundle:nibBundleOrNil];
    if (self) {
        // Custom initialization

        // White background of the View Controller
        self.view.backgroundColor = [UIColor whiteColor];

        // Initializing main TableView
        _listViewTable = [[UITableView alloc] initWithFrame:_bounds style:UITableViewStylePlain];
        _listViewTable.tableFooterView = [[UIView alloc] initWithFrame:CGRectZero];
        _listViewTable.dataSource = self;
        _listViewTable.delegate = self;
        [self.view addSubview:_listViewTable];

    }
    return self;
}

// Return one section in TableView
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    return 1;
}

// Return sorted list of contacts
- (NSInteger)tableView: (UITableView *)tableView numberOfRowsInSection: (NSInteger)section
{
    return [_shortDictSorted count];
}

// Initialize cell content
- (UITableViewCell *)tableView: (UITableView *)tableView cellForRowAtIndexPath: (NSIndexPath *)indexPath
{
    static NSString *_cellindentifier = @"ListViewCellIdentifier";
    NSDictionary *_dictionary = [_shortDictSorted objectAtIndex:[indexPath row]];
    ListTableViewCell *_cell = [tableView dequeueReusableCellWithIdentifier:_cellindentifier];
    if (_cell == nil)
    {
        _cell = [[ListTableViewCell alloc] initWithStyle:UITableViewCellStyleSubtitle reuseIdentifier:_cellindentifier];
    }

    _cell.accessoryType = UITableViewCellAccessoryDisclosureIndicator;
    _cell._cellName.text = [_dictionary objectForKey:@"name"];

    // Color cell if there's a color for it in dict
    if ([[_dictionary objectForKey:@"color"] length] != 0)
    {
        NSString *_cellColorFromDict= [NSString stringWithFormat:@"0x%@", [_dictionary objectForKey:@"color"]];
        unsigned colorInt = 0;
        [[NSScanner scannerWithString:_cellColorFromDict] scanHexInt:&colorInt];
        _cell.backgroundColor = UIColorFromRGB(colorInt);
    }

    return _cell;
}

// Open Details View Controller for selected cell
- (void)tableView: (UITableView *)tableView didSelectRowAtIndexPath: (NSIndexPath *)indexPath
{
    [tableView deselectRowAtIndexPath:indexPath animated:YES];
    [self.navigationController pushViewController:_detailsViewController animated:YES];
    NSDictionary *_choiceFromListView = [_shortDictSorted objectAtIndex:[indexPath row]];
    [[NSNotificationCenter defaultCenter] postNotificationName: @"_choiceFromListView" object:nil userInfo:_choiceFromListView];
}

// Get contacts for the specific language and sort them before displaying
- (void)shortenDictToOneGroupAndSort:(NSNotification *) notif
{
    NSDictionary  *_choiceFromSendHelpView = notif.userInfo;
    NSString *_choiceOnSendHelpView = [_choiceFromSendHelpView objectForKey:@"_groupSelected"];
    self.title = [_choiceFromSendHelpView objectForKey:@"_groupSelectedName"];

    _shortDictSorted = [[NSMutableArray alloc] init];
    for (NSDictionary *_dictionary in _dictInOneLanguage)
    {
        NSString *_groupName = [_dictionary objectForKey:@"group"];
        NSString *_contactName = [_dictionary objectForKey:@"name"];

        if ([_groupName isEqualToString:_choiceOnSendHelpView] && ![_contactName  isEqualToString: @""])
        {
            [_shortDictSorted addObject:_dictionary];
        }
    }

    // Sort it
    [_shortDictSorted sortUsingDescriptors:[NSArray arrayWithObjects:[[NSSortDescriptor alloc] initWithKey:@"order" ascending:YES], [[NSSortDescriptor alloc] initWithKey:@"name" ascending:YES selector:@selector(localizedCaseInsensitiveCompare:)], nil]];
}

- (void)viewDidLoad
{
    // Receive group name from the Send Help View Controller to know contacts from which group to display
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(shortenDictToOneGroupAndSort:) name:@"_choiceFromSendHelpView" object:nil];
    [super viewDidLoad];

    // Do any additional setup after loading the view.
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

/*
 #pragma mark - Navigation

 // In a storyboard-based application, you will often want to do a little preparation before navigation
 - (void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender
 {
 // Get the new view controller using [segue destinationViewController].
 // Pass the selected object to the new view controller.
 }
 */

@end


text:
<web-app version="3.0" id="imoweb_v1"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         metadata-complete="true">

    <display-name>Homerenting</display-name>

    <!-- Spring root -->
    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/spring-mvc-context.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>
            classpath:/META-INF/spring/applicationContext.xml,
            classpath:/META-INF/spring/infrastructure.xml,
            /WEB-INF/spring-security.xml
        </param-value>
    </context-param>

    <!-- Spring Security -->
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>

    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <!--force http to https, disabled locally because it misses jboss certificate import
    <security-constraint>
        <web-resource-collection>
            <web-resource-name>HTTPs Test</web-resource-name>
            <url-pattern>/*</url-pattern>
        </web-resource-collection>
        <user-data-constraint>
            <transport-guarantee>CONFIDENTIAL</transport-guarantee>
        </user-data-constraint>
    </security-constraint>-->

    <!--<listener>
        <listener-class>com.homerenting.domain.helpers.ContextLoadListener</listener-class>
    </listener>-->

    <!--
    <filter>
        <filter-name>WebResourceOptimizer</filter-name>
        <filter-class>ro.isdc.wro.http.WroFilter</filter-class>
    </filter>-->

    <!-- Start Filters: Order is important
    <filter>
        <filter-name>CharacterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
        <init-param>
            <param-name>forceEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>

    <filter-mapping>
        <filter-name>CharacterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <filter-mapping>
        <filter-name>WebResourceOptimizer</filter-name>
        <url-pattern>/wro/*</url-pattern>
    </filter-mapping>-->
</web-app>


text:
package main

import (
	"fmt"
	"koding/artifact"
	"koding/kites/kontrol/kontrol"

	"net/http"
	_ "net/http/pprof"

	"github.com/koding/kite"
	"github.com/koding/multiconfig"
)

var Name = "kontrol"

func main() {
	loader := multiconfig.MultiLoader(
		&multiconfig.TagLoader{},
		&multiconfig.EnvironmentLoader{Prefix: "kontrol"},
		&multiconfig.EnvironmentLoader{Prefix: "KONFIG_KONTROL"},
		&multiconfig.FlagLoader{EnvPrefix: "kontrol"},
	)

	conf := new(kontrol.Config)

	// Load the config, it's reads from the file, environment variables and
	// lastly from flags in order
	if err := loader.Load(conf); err != nil {
		panic(err)
	}

	if err := multiconfig.MultiValidator(&multiconfig.RequiredValidator{}).Validate(conf); err != nil {
		panic(err)
	}

	fmt.Printf("Kontrol loaded with following variables: %+v\n", conf)

	k := kontrol.New(conf)

	k.Kite.HandleHTTPFunc("/healthCheck", artifact.HealthCheckHandler(Name))
	k.Kite.HandleHTTPFunc("/version", artifact.VersionHandler())

	if conf.Debug {
		k.Kite.SetLogLevel(kite.DEBUG)
	}

	go func() {
		// Kloud runs on 6060, so we choose 6061 for kontrol
		err := http.ListenAndServe("0.0.0.0:6061", nil)
		k.Kite.Log.Error(err.Error())
	}()

	k.Run()
}


text:
<bill session="115" type="hc" number="42" updated="2017-09-19T20:00:13Z">
  <state datetime="2017-03-29">REFERRED</state>
  <status>
    <introduced datetime="2017-03-29"/>
  </status>
  <introduced datetime="2017-03-29"/>
  <titles>
    <title type="official" as="introduced">Expressing the sense of Congress that the Supreme Court misinterpreted the First Amendment to the Constitution in the case of Buckley v. Valeo.</title>
    <title type="display">Expressing the sense of Congress that the Supreme Court misinterpreted the First Amendment to the Constitution in the case of Buckley v. Valeo.</title>
  </titles>
  <sponsor bioguide_id="K000009"/>
  <cosponsors>
    <cosponsor bioguide_id="B000574" joined="2017-03-29"/>
    <cosponsor bioguide_id="C000714" joined="2017-03-29"/>
    <cosponsor bioguide_id="D000191" joined="2017-03-29"/>
    <cosponsor bioguide_id="G000410" joined="2017-03-29"/>
    <cosponsor bioguide_id="H001038" joined="2017-03-29"/>
    <cosponsor bioguide_id="M001185" joined="2017-03-29"/>
    <cosponsor bioguide_id="N000147" joined="2017-03-29"/>
    <cosponsor bioguide_id="R000606" joined="2017-03-29"/>
    <cosponsor bioguide_id="S001145" joined="2017-03-29"/>
    <cosponsor bioguide_id="S000480" joined="2017-03-29"/>
    <cosponsor bioguide_id="S001200" joined="2017-03-29"/>
  </cosponsors>
  <actions>
    <action datetime="2017-03-29">
      <text>Introduced in House</text>
    </action>
    <action datetime="2017-03-29">
      <text>Sponsor introductory remarks on measure.</text>
      <reference ref="CR H2550, E411"/>
    </action>
    <action datetime="2017-03-29" state="REFERRED">
      <text>Referred to the House Committee on the Judiciary.</text>
    </action>
    <action datetime="2017-03-29">
      <text>Referred to the Subcommittee on the Constitution and Civil Justice.</text>
    </action>
  </actions>
  <committees>
    <committee subcommittee="" code="HSJU" name="House Judiciary" activity="Referral"/>
    <committee subcommittee="Constitution and Civil Justice" code="HSJU10" name="House Judiciary" activity="Referral"/>
  </committees>
  <relatedbills/>
  <subjects>
    <term name="Government operations and politics"/>
    <term name="Constitution and constitutional amendments"/>
    <term name="Elections, voting, political campaign regulation"/>
    <term name="First Amendment rights"/>
    <term name="Supreme Court"/>
  </subjects>
  <amendments/>
  <summary date="2017-03-29T04:00:00Z" status="Introduced in House">Expresses the sense of Congress that the Supreme Court misinterpreted the First Amendment in the case of Buckley v. Valeo because the decision failed to recognize: (1) that the unlimited spending of large amounts of money on elections has a corrosive effect on the electoral process not simply because of direct transactions between those who give large amounts of money and candidates and elected officials but because the presence of unlimited amounts of money corrupts the process on a more fundamental level; and (2) other legitimate state interests which justify limiting money in campaigns, including the need to preserve the integrity of our republican form of government, restore public confidence in government, and ensure all citizens a more equal opportunity to participate in the political process.</summary>
  <committee-reports/>
</bill>


text:
package com.dounine.clouddisk360.enums;

public enum Order {

	ASC("asc"),
	DESC("desc");

	private String value;

	private Order(String value){
		this.value = value;
	}

	public String getValue() {
		return value;
	}
}