@param array $e

@return \chillerlan\QRCode\Helpers\Polynomial
339581
public function mod(array $e):Polynomial{
		$n = $this->num;

		if(\count($n) - \count($e) < 0){
			return $this;
		}

		$ratio = $this->glog($n[0]) - $this->glog($e[0]);

		foreach($e as $i => $v){
			$n[$i] ^= $this->gexp($this->glog($v) + $ratio);
		}

		$this->setNum($n)->mod($e);

		return $this;
	}
1326243
protected function _createFromThrowable($e)
    {
        $this->backtrace = $e->getTrace();
        if ($previous = $e->getPrevious()) {
            $backtrace = new self($previous);
            $this->backtrace = array_merge($backtrace->backtrace,
                                           $this->backtrace);
        }
    }
230259
public function reindex($e)
    {
        $i = 1;
        foreach (self::find()->where([
            'nav_container_id' => $this->nav_container_id,
            'parent_nav_id' => $this->parent_nav_id
        ])->orderBy('sort_index ASC')->asArray()->all() as $model) {
            Yii::$app->db->createCommand()->update(
                self::tableName(),
                ['sort_index' => $i],
                'id=:id',
                ['id' => $model['id']]
            )->execute();
            ++$i;
        }

        switch ($e->name) {
            case 'afterInsert':
                Log::add(1, ['tableName' => 'cms_nav', 'action' => 'insert', 'row' => $this->id], 'cms_nav', $this->id, $this->toArray());
                break;
            case 'afterUpdate':
                Log::add(2, ['tableName' => 'cms_nav', 'action' => 'update', 'row' => $this->id], 'cms_nav', $this->id, $this->toArray());
                break;
            case 'afterDelete':
                Log::add(3, ['tableName' => 'cms_nav', 'action' => 'delete', 'row' => $this->id], 'cms_nav', $this->id, $this->toArray());
                break;
        }
    }
1194583
public function populateAppIds($e)
    {
        $appsArray = $e->getParam('apps');

        $appService = $e->getTarget()
        ->getServiceManager()
        ->get('playgroundfacebook_app_service');
        $apps = $appService->getAvailableApps();

        foreach ($apps as $app) {
            $app_label = '';
            if ($app->getAppName()) {
                $app_label .= $app->getAppName();
            }
            if ($app->getAppId()) {
                $app_label .= ' ('.$app->getAppId().')';
            }
            $appsArray[$app->getAppId()] = $app_label;
        }

        return $appsArray;
    }
124491
public function interpolate( $x )
	{
		$keys	= array_keys( $this->data );
		$n	= count( $keys );
		$p	= $this->polynomial[$n-1];
		for( $i=$n-2; $i>=0; $i-- )
			$p	= $p * ( $x - $keys[$i] ) + $this->polynomial[$i];
		return $p;
	}
265782
private static function getErrorObject( $e ) : \stdClass
	{
		$config = config('system.errors');
		$error = new \stdClass;
		$error->message = $e->getMessage();
		if ($data = json_decode($error->message)) {
			$error->message = $data;
		}
		ob_start();
		$sentData = ob_get_clean();
		if ($sentData) {
			$error->data = $sentData;
		}
		if (!is_a($e,Message::class)) {
			$error->type = self::getType($e);
			$error->file = str_replace("\\", "\\\\", $e->getFile());
			$error->line = $e->getLine();
			if ($config['backtrace']) {
				$error->trace = explode("\n", str_replace("\\", "\\\\", trim($e->getTraceAsString())));
			}
		}
		return $error;
	}
779521
public function onEventError(Exception $e)
    {
        if(($this->xErrorCallback))
        {
            call_user_func_array($this->xErrorCallback, array($this->xResponse, $e));
        }
        else
        {
            throw $e;
        }
        return $this->xResponse;
    }
320451
private function requestBodyOrUrlAreRegexp(Expectation $expectation)
    {
        return $expectation->getRequest()->getBody()
            && Matchers::MATCHES === $expectation->getRequest()->getBody()->getMatcher()
            || $expectation->getRequest()->getUrl()
            && Matchers::MATCHES === $expectation->getRequest()->getUrl()->getMatcher();
    }
896617
public function compile(array $expression, CompilationContext $compilationContext)
    {
        $isPhpConstant = false;
        $isZephirConstant = false;

        $constantName = $expression['value'];

        $mergedConstants = array_merge($this->envConstants, $this->magicConstants, $this->resources);
        if (!\defined($expression['value']) && !\in_array($constantName, $mergedConstants)) {
            if (!$compilationContext->compiler->isConstant($constantName)) {
                $compilationContext->logger->warning(
                    "Constant '".$constantName."' does not exist at compile time",
                    ['nonexistent-constant', $expression]
                );
            } else {
                $isZephirConstant = true;
            }
        } else {
            if (false !== strpos($constantName, 'VERSION')) {
                $isPhpConstant = false;
            } else {
                $isPhpConstant = true;
            }
        }

        if ($isZephirConstant && !\in_array($constantName, $this->resources)) {
            $constant = $compilationContext->compiler->getConstant($constantName);

            return new LiteralCompiledExpression($constant[0], $constant[1], $expression);
        }

        if ($isPhpConstant && !\in_array($constantName, $mergedConstants)) {
            $constantName = \constant($constantName);
            $type = strtolower(\gettype($constantName));

            switch ($type) {
                case 'integer':
                    return new LiteralCompiledExpression('int', $constantName, $expression);

                case 'double':
                    return new LiteralCompiledExpression('double', $constantName, $expression);

                case 'string':
                    return new LiteralCompiledExpression('string', add_slashes($constantName), $expression);

                case 'object':
                    throw new CompilerException('?');
                default:
                    return new LiteralCompiledExpression($type, $constantName, $expression);
            }
        }

        if (\in_array($constantName, $this->magicConstants)) {
            switch ($constantName) {
                case '__CLASS__':
                    return new CompiledExpression(
                        'string',
                        add_slashes($compilationContext->classDefinition->getCompleteName()),
                        $expression
                    );
                case '__NAMESPACE__':
                    return new CompiledExpression(
                        'string',
                        add_slashes($compilationContext->classDefinition->getNamespace()),
                        $expression
                    );
                case '__METHOD__':
                    return new CompiledExpression(
                        'string',
                        $compilationContext->classDefinition->getName().':'.$compilationContext->currentMethod->getName(),
                        $expression
                    );
                case '__FUNCTION__':
                    return new CompiledExpression(
                        'string',
                        $compilationContext->currentMethod->getName(),
                        $expression
                    );
            }

            $compilationContext->logger->warning(
                "Magic constant '".$constantName."' is not supported",
                ['not-supported-magic-constant', $expression]
            );

            return new LiteralCompiledExpression('null', null, $expression);
        }

        if ($this->expecting && $this->expectingVariable) {
            $symbolVariable = $this->expectingVariable;

            $symbolVariable->setLocalOnly(false);
            $symbolVariable->setMustInitNull(true);
            $symbolVariable->initVariant($compilationContext);
        } else {
            $symbolVariable = $compilationContext->symbolTable->getTempVariableForWrite('variable', $compilationContext, $expression);
        }

        if (!$symbolVariable->isVariable()) {
            throw new CompilerException('Cannot use variable: '.$symbolVariable->getType().' to assign property value', $expression);
        }

        $compilationContext->codePrinter->output('ZEPHIR_GET_CONSTANT('.$compilationContext->backend->getVariableCode($symbolVariable).', "'.$expression['value'].'");');

        return new CompiledExpression('variable', $symbolVariable->getName(), $expression);
    }
537111
public function glog(int $n):int{

		if($n < 1){
			throw new QRCodeException('log('.$n.')');
		}

		return Polynomial::table[$n][1];
	}
25028
protected function returnException(Exception $e)
    {
        $key = snake_case(class_basename($e));
        $message = $this->translate($key, $e->getMessage());

        return new ExceptionReply($message, [], $e);
    }
900655
protected function normalizeException($e)
    {
        // TODO 2.0 only check for Throwable
        if (!$e instanceof Exception && !$e instanceof \Throwable) {
            throw new \InvalidArgumentException('Exception/Throwable expected, got '.gettype($e).' / '.get_class($e));
        }

        $data = array(
            'class' => get_class($e),
            'message' => $e->getMessage(),
            'code' => $e->getCode(),
            'file' => $e->getFile().':'.$e->getLine(),
        );

        if ($this->includeStacktraces) {
            $trace = $e->getTrace();
            foreach ($trace as $frame) {
                if (isset($frame['file'])) {
                    $data['trace'][] = $frame['file'].':'.$frame['line'];
                } elseif (isset($frame['function']) && $frame['function'] === '{closure}') {
                    // We should again normalize the frames, because it might contain invalid items
                    $data['trace'][] = $frame['function'];
                } else {
                    // We should again normalize the frames, because it might contain invalid items
                    $data['trace'][] = $this->normalize($frame);
                }
            }
        }

        if ($previous = $e->getPrevious()) {
            $data['previous'] = $this->normalizeException($previous);
        }

        return $data;
    }
77645
public function setEvent(Event $e)
    {
        if (!$e instanceof AdapterChainEvent) {
            $eventParams = $e->getParams();
            $e = new AdapterChainEvent();
            $e->setParams($eventParams);
        }

        $this->event = $e;

        return $this;
    }
1331919
public static function normalize($expression)
    {
        if (is_callable($expression)) {
            $expressionConfigurator = $expression;
            $expression = new Expression;
            call_user_func($expressionConfigurator, $expression);
        }

        if ($expression instanceof Expression) {
            $expression = $expression->toArray();
        } elseif (is_array($expression)) {
            foreach ($expression as $fieldName => $value) {
                $expression[$fieldName] = self::normalize($value);
            }
        }

        return $expression;
    }
675032
protected function fromArray($array)
    {
        if (empty($array)) {
            return $this;
        }

        $this->query = new QueryString();

        if (!empty($array['query'])) {
            $this->query->import($array['query']);
        }

        $keys = array(
            'scheme',
            'host',
            'port',
            'user',
            'pass',
            'path',
            'fragment',
            'dirname',
            'basename',
            'extension',
            'filename',
        );

        foreach ($keys as $key) {
            if (!isset($array[$key])) {
                continue;
            }

            $this->$key = $array[$key];

            if ($key === 'path') {
                $this->parsePath($this->path);
            }
        }

        $this->buildPath();

        return $this;
    }
765830
public function reject($e)
    {
        foreach ($this->rejectCallables as $reject) {
            $e = $reject($e);
        }

        return $e;
    }
79278
protected function recursiveImplode(string $glue, array $array): string
    {
        $return = '';
        $index = 0;
        $count = count($array);
        foreach ($array as $row) {
            if (is_array($row)) {
                $return .= $this->recursiveImplode($glue, $row);
            } else {
                $return .= (is_object($row)) ? get_class($row) : $row;
            }
            if ($index < $count - 1) {
                $return .= $glue;
            }
            ++$index;
        }

        return $return;
    }