' . $content);
        }
      }

      if (!class_exists($cls, false)) {
        throw new Twig_SupTwgSgg_Error_Runtime(sprintf('Failed to load Twig template "%s", index "%s": cache is corrupted.', $name, $index), -1, $source);
      }
    }

    if (!$this->runtimeInitialized) {
      $this->initRuntime();
    }

    return $this->loadedTemplates[$cls] = new $cls($this);
  }

  /**
   * Creates a template from source.
   *
   * This method should not be used as a generic way to load templates.
   *
   * @param string $template The template name
   *
   * @return Twig_SupTwgSgg_Template A template instance representing the given template name
   *
   * @throws Twig_SupTwgSgg_Error_Loader When the template cannot be found
   * @throws Twig_SupTwgSgg_Error_Syntax When an error occurred during compilation
   */
  public function createTemplate($template)
  {
    $name = sprintf('__string_template__%s', hash('sha256', uniqid(mt_rand(), true), false));

    $loader = new Twig_SupTwgSgg_Loader_Chain([new Twig_SupTwgSgg_Loader_Array([$name => $template]), ($current = $this->getLoader())]);

    $this->setLoader($loader);
    try {
      $template = $this->loadTemplate($name);
    } catch (Exception $e) {
      $this->setLoader($current);

      throw $e;
    } catch (Throwable $e) {
      $this->setLoader($current);

      throw $e;
    }
    $this->setLoader($current);

    return $template;
  }

  /**
   * Returns true if the template is still fresh.
   *
   * Besides checking the loader for freshness information,
   * this method also checks if the enabled extensions have
   * not changed.
   *
   * @param string $name The template name
   * @param int    $time The last modification time of the cached template
   *
   * @return bool true if the template is fresh, false otherwise
   */
  public function isTemplateFresh($name, $time)
  {
    if (0 === $this->lastModifiedExtension) {
      foreach ($this->extensions as $extension) {
        $r = new ReflectionObject($extension);
        if (file_exists($r->getFileName()) && ($extensionTime = filemtime($r->getFileName())) > $this->lastModifiedExtension) {
          $this->lastModifiedExtension = $extensionTime;
        }
      }
    }

    return $this->lastModifiedExtension <= $time && $this->getLoader()->isFresh($name, $time);
  }

  /**
   * Tries to load a template consecutively from an array.
   *
   * Similar to loadTemplate() but it also accepts Twig_SupTwgSgg_TemplateInterface instances and an array
   * of templates where each is tried to be loaded.
   *
   * @param string|Twig_SupTwgSgg_Template|array $names A template or an array of templates to try consecutively
   *
   * @return Twig_SupTwgSgg_Template
   *
   * @throws Twig_SupTwgSgg_Error_Loader When none of the templates can be found
   * @throws Twig_SupTwgSgg_Error_Syntax When an error occurred during compilation
   */
  public function resolveTemplate($names)
  {
    if (!is_array($names)) {
      $names = [$names];
    }

    foreach ($names as $name) {
      if ($name instanceof Twig_SupTwgSgg_Template) {
        return $name;
      }

      try {
        return $this->loadTemplate($name);
      } catch (Twig_SupTwgSgg_Error_Loader $e) {
      }
    }

    if (1 === count($names)) {
      throw $e;
    }

    throw new Twig_SupTwgSgg_Error_Loader(sprintf('Unable to find one of the following templates: "%s".', implode('", "', $names)));
  }

  /**
   * Clears the internal template cache.
   *
   * @deprecated since 1.18.3 (to be removed in 2.0)
   */
  public function clearTemplateCache()
  {
    //@trigger_error(sprintf('The %s method is deprecated since version 1.18.3 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);

    $this->loadedTemplates = [];
  }

  /**
   * Clears the template cache files on the filesystem.
   *
   * @deprecated since 1.22 (to be removed in 2.0)
   */
  public function clearCacheFiles()
  {
    //@trigger_error(sprintf('The %s method is deprecated since version 1.22 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);

    if (is_string($this->originalCache)) {
      foreach (new RecursiveIteratorIterator(new RecursiveDirectoryIterator($this->originalCache), RecursiveIteratorIterator::LEAVES_ONLY) as $file) {
        if ($file->isFile()) {
          @unlink($file->getPathname());
        }
      }
    }
  }

  /**
   * Gets the Lexer instance.
   *
   * @return Twig_SupTwgSgg_LexerInterface
   *
   * @deprecated since 1.25 (to be removed in 2.0)
   */
  public function getLexer()
  {
    //@trigger_error(sprintf('The %s() method is deprecated since version 1.25 and will be removed in 2.0.', __FUNCTION__), E_USER_DEPRECATED);

    if (null === $this->lexer) {
      $this->lexer = new Twig_SupTwgSgg_Lexer($this);
    }

    return $this->lexer;
  }

  public function setLexer(Twig_SupTwgSgg_LexerInterface $lexer)
  {
    $this->lexer = $lexer;
  }

  /**
   * Tokenizes a source code.
   *
   * @param string|Twig_SupTwgSgg_Source $source The template source code
   * @param string             $name   The template name (deprecated)
   *
   * @return Twig_SupTwgSgg_TokenStream
   *
   * @throws Twig_SupTwgSgg_Error_Syntax When the code is syntactically wrong
   */
  public function tokenize($source, $name = null)
  {
    if (!$source instanceof Twig_SupTwgSgg_Source) {
      //@trigger_error(sprintf('Passing a string as the $source argument of %s() is deprecated since version 1.27. Pass a Twig_SupTwgSgg_Source instance instead.', __METHOD__), E_USER_DEPRECATED);
      $source = new Twig_SupTwgSgg_Source($source, $name);
    }

    if (null === $this->lexer) {
      $this->lexer = new Twig_SupTwgSgg_Lexer($this);
    }

    return $this->lexer->tokenize($source);
  }

  /**
   * Gets the Parser instance.
   *
   * @return Twig_SupTwgSgg_ParserInterface
   *
   * @deprecated since 1.25 (to be removed in 2.0)
   */
  public function getParser()
  {
    //@trigger_error(sprintf('The %s() method is deprecated since version 1.25 and will be removed in 2.0.', __FUNCTION__), E_USER_DEPRECATED);

    if (null === $this->parser) {
      $this->parser = new Twig_SupTwgSgg_Parser($this);
    }

    return $this->parser;
  }

  public function setParser(Twig_SupTwgSgg_ParserInterface $parser)
  {
    $this->parser = $parser;
  }

  /**
   * Converts a token stream to a node tree.
   *
   * @return Twig_SupTwgSgg_Node_Module
   *
   * @throws Twig_SupTwgSgg_Error_Syntax When the token stream is syntactically or semantically wrong
   */
  public function parse(Twig_SupTwgSgg_TokenStream $stream)
  {
    if (null === $this->parser) {
      $this->parser = new Twig_SupTwgSgg_Parser($this);
    }

    return $this->parser->parse($stream);
  }

  /**
   * Gets the Compiler instance.
   *
   * @return Twig_SupTwgSgg_CompilerInterface
   *
   * @deprecated since 1.25 (to be removed in 2.0)
   */
  public function getCompiler()
  {
    //@trigger_error(sprintf('The %s() method is deprecated since version 1.25 and will be removed in 2.0.', __FUNCTION__), E_USER_DEPRECATED);

    if (null === $this->compiler) {
      $this->compiler = new Twig_SupTwgSgg_Compiler($this);
    }

    return $this->compiler;
  }

  public function setCompiler(Twig_SupTwgSgg_CompilerInterface $compiler)
  {
    $this->compiler = $compiler;
  }

  /**
   * Compiles a node and returns the PHP code.
   *
   * @return string The compiled PHP source code
   */
  public function compile(Twig_SupTwgSgg_NodeInterface $node)
  {
    if (null === $this->compiler) {
      $this->compiler = new Twig_SupTwgSgg_Compiler($this);
    }

    return $this->compiler->compile($node)->getSource();
  }

  /**
   * Compiles a template source code.
   *
   * @param string|Twig_SupTwgSgg_Source $source The template source code
   * @param string             $name   The template name (deprecated)
   *
   * @return string The compiled PHP source code
   *
   * @throws Twig_SupTwgSgg_Error_Syntax When there was an error during tokenizing, parsing or compiling
   */
  public function compileSource($source, $name = null)
  {
    if (!$source instanceof Twig_SupTwgSgg_Source) {
      //@trigger_error(sprintf('Passing a string as the $source argument of %s() is deprecated since version 1.27. Pass a Twig_SupTwgSgg_Source instance instead.', __METHOD__), E_USER_DEPRECATED);
      $source = new Twig_SupTwgSgg_Source($source, $name);
    }

    try {
      return $this->compile($this->parse($this->tokenize($source)));
    } catch (Twig_SupTwgSgg_Error $e) {
      $e->setSourceContext($source);
      throw $e;
    } catch (Exception $e) {
      throw new Twig_SupTwgSgg_Error_Syntax(sprintf('An exception has been thrown during the compilation of a template ("%s").', $e->getMessage()), -1, $source, $e);
    }
  }

  public function setLoader(Twig_SupTwgSgg_LoaderInterface $loader)
  {
    if (!$loader instanceof Twig_SupTwgSgg_SourceContextLoaderInterface && 0 !== strpos(get_class($loader), 'Mock_Twig_SupTwgSgg_LoaderInterface')) {
      //@trigger_error(sprintf('Twig loader "%s" should implement Twig_SupTwgSgg_SourceContextLoaderInterface since version 1.27.', get_class($loader)), E_USER_DEPRECATED);
    }

    $this->loader = $loader;
  }

  /**
   * Gets the Loader instance.
   *
   * @return Twig_SupTwgSgg_LoaderInterface
   */
  public function getLoader()
  {
    if (null === $this->loader) {
      throw new LogicException('You must set a loader first.');
    }

    return $this->loader;
  }

  /**
   * Sets the default template charset.
   *
   * @param string $charset The default charset
   */
  public function setCharset($charset)
  {
    $this->charset = strtoupper($charset);
  }

  /**
   * Gets the default template charset.
   *
   * @return string The default charset
   */
  public function getCharset()
  {
    return $this->charset;
  }

  /**
   * Initializes the runtime environment.
   *
   * @deprecated since 1.23 (to be removed in 2.0)
   */
  public function initRuntime()
  {
    $this->runtimeInitialized = true;

    foreach ($this->getExtensions() as $name => $extension) {
      if (!$extension instanceof Twig_SupTwgSgg_Extension_InitRuntimeInterface) {
        $m = new ReflectionMethod($extension, 'initRuntime');

        if ('Twig_SupTwgSgg_Extension' !== $m->getDeclaringClass()->getName()) {
          //@trigger_error(sprintf('Defining the initRuntime() method in the "%s" extension is deprecated since version 1.23. Use the `needs_environment` option to get the Twig_SupTwgSgg_Environment instance in filters, functions, or tests; or explicitly implement Twig_SupTwgSgg_Extension_InitRuntimeInterface if needed (not recommended).', $name), E_USER_DEPRECATED);
        }
      }

      $extension->initRuntime($this);
    }
  }

  /**
   * Returns true if the given extension is registered.
   *
   * @param string $class The extension class name
   *
   * @return bool Whether the extension is registered or not
   */
  public function hasExtension($class)
  {
    $class = ltrim($class, '\\');
    if (isset($this->extensions[$class])) {
      if ($class !== get_class($this->extensions[$class])) {
        //@trigger_error(sprintf('Referencing the "%s" extension by its name (defined by getName()) is deprecated since 1.26 and will be removed in Twig 2.0. Use the Fully Qualified Extension Class Name instead.', $class), E_USER_DEPRECATED);
      }

      return true;
    }

    return isset($this->extensionsByClass[$class]);
  }

  /**
   * Adds a runtime loader.
   */
  public function addRuntimeLoader(Twig_SupTwgSgg_RuntimeLoaderInterface $loader)
  {
    $this->runtimeLoaders[] = $loader;
  }

  /**
   * Gets an extension by class name.
   *
   * @param string $class The extension class name
   *
   * @return Twig_SupTwgSgg_ExtensionInterface
   */
  public function getExtension($class)
  {
    $class = ltrim($class, '\\');

    if (isset($this->extensions[$class])) {
      if ($class !== get_class($this->extensions[$class])) {
        //@trigger_error(sprintf('Referencing the "%s" extension by its name (defined by getName()) is deprecated since 1.26 and will be removed in Twig 2.0. Use the Fully Qualified Extension Class Name instead.', $class), E_USER_DEPRECATED);
      }

      return $this->extensions[$class];
    }

    if (!isset($this->extensionsByClass[$class])) {
      throw new Twig_SupTwgSgg_Error_Runtime(sprintf('The "%s" extension is not enabled.', $class));
    }

    return $this->extensionsByClass[$class];
  }

  /**
   * Returns the runtime implementation of a Twig element (filter/function/test).
   *
   * @param string $class A runtime class name
   *
   * @return object The runtime implementation
   *
   * @throws Twig_SupTwgSgg_Error_Runtime When the template cannot be found
   */
  public function getRuntime($class)
  {
    if (isset($this->runtimes[$class])) {
      return $this->runtimes[$class];
    }

    foreach ($this->runtimeLoaders as $loader) {
      if (null !== ($runtime = $loader->load($class))) {
        return $this->runtimes[$class] = $runtime;
      }
    }

    throw new Twig_SupTwgSgg_Error_Runtime(sprintf('Unable to load the "%s" runtime.', $class));
  }

  public function addExtension(Twig_SupTwgSgg_ExtensionInterface $extension)
  {
    if ($this->extensionInitialized) {
      throw new LogicException(sprintf('Unable to register extension "%s" as extensions have already been initialized.', $extension->getName()));
    }

    $class = get_class($extension);
    if ($class !== $extension->getName()) {
      if (isset($this->extensions[$extension->getName()])) {
        unset($this->extensions[$extension->getName()], $this->extensionsByClass[$class]);
        //@trigger_error(sprintf('The possibility to register the same extension twice ("%s") is deprecated since version 1.23 and will be removed in Twig 2.0. Use proper PHP inheritance instead.', $extension->getName()), E_USER_DEPRECATED);
      }
    }

    $this->lastModifiedExtension = 0;
    $this->extensionsByClass[$class] = $extension;
    $this->extensions[$extension->getName()] = $extension;
    $this->updateOptionsHash();
  }

  /**
   * Removes an extension by name.
   *
   * This method is deprecated and you should not use it.
   *
   * @param string $name The extension name
   *
   * @deprecated since 1.12 (to be removed in 2.0)
   */
  public function removeExtension($name)
  {
    //@trigger_error(sprintf('The %s method is deprecated since version 1.12 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);

    if ($this->extensionInitialized) {
      throw new LogicException(sprintf('Unable to remove extension "%s" as extensions have already been initialized.', $name));
    }

    $class = ltrim($name, '\\');
    if (isset($this->extensions[$class])) {
      if ($class !== get_class($this->extensions[$class])) {
        //@trigger_error(sprintf('Referencing the "%s" extension by its name (defined by getName()) is deprecated since 1.26 and will be removed in Twig 2.0. Use the Fully Qualified Extension Class Name instead.', $class), E_USER_DEPRECATED);
      }

      unset($this->extensions[$class]);
    }

    unset($this->extensions[$class]);
    $this->updateOptionsHash();
  }

  /**
   * Registers an array of extensions.
   *
   * @param array $extensions An array of extensions
   */
  public function setExtensions(array $extensions)
  {
    foreach ($extensions as $extension) {
      $this->addExtension($extension);
    }
  }

  /**
   * Returns all registered extensions.
   *
   * @return Twig_SupTwgSgg_ExtensionInterface[] An array of extensions (keys are for internal usage only and should not be relied on)
   */
  public function getExtensions()
  {
    return $this->extensions;
  }

  public function addTokenParser(Twig_SupTwgSgg_TokenParserInterface $parser)
  {
    if ($this->extensionInitialized) {
      throw new LogicException('Unable to add a token parser as extensions have already been initialized.');
    }

    $this->staging->addTokenParser($parser);
  }

  /**
   * Gets the registered Token Parsers.
   *
   * @return Twig_SupTwgSgg_TokenParserBrokerInterface
   *
   * @internal
   */
  public function getTokenParsers()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->parsers;
  }

  /**
   * Gets registered tags.
   *
   * Be warned that this method cannot return tags defined by Twig_SupTwgSgg_TokenParserBrokerInterface classes.
   *
   * @return Twig_SupTwgSgg_TokenParserInterface[]
   *
   * @internal
   */
  public function getTags()
  {
    $tags = [];
    foreach ($this->getTokenParsers()->getParsers() as $parser) {
      if ($parser instanceof Twig_SupTwgSgg_TokenParserInterface) {
        $tags[$parser->getTag()] = $parser;
      }
    }

    return $tags;
  }

  public function addNodeVisitor(Twig_SupTwgSgg_NodeVisitorInterface $visitor)
  {
    if ($this->extensionInitialized) {
      throw new LogicException('Unable to add a node visitor as extensions have already been initialized.');
    }

    $this->staging->addNodeVisitor($visitor);
  }

  /**
   * Gets the registered Node Visitors.
   *
   * @return Twig_SupTwgSgg_NodeVisitorInterface[]
   *
   * @internal
   */
  public function getNodeVisitors()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->visitors;
  }

  /**
   * Registers a Filter.
   *
   * @param string|Twig_SupTwgSgg_SimpleFilter               $name   The filter name or a Twig_SupTwgSgg_SimpleFilter instance
   * @param Twig_SupTwgSgg_FilterInterface|Twig_SupTwgSgg_SimpleFilter $filter
   */
  public function addFilter($name, $filter = null)
  {
    if (!$name instanceof Twig_SupTwgSgg_SimpleFilter && !($filter instanceof Twig_SupTwgSgg_SimpleFilter || $filter instanceof Twig_SupTwgSgg_FilterInterface)) {
      throw new LogicException('A filter must be an instance of Twig_SupTwgSgg_FilterInterface or Twig_SupTwgSgg_SimpleFilter.');
    }

    if ($name instanceof Twig_SupTwgSgg_SimpleFilter) {
      $filter = $name;
      $name = $filter->getName();
    } else {
      //@trigger_error(sprintf('Passing a name as a first argument to the %s method is deprecated since version 1.21. Pass an instance of "Twig_SupTwgSgg_SimpleFilter" instead when defining filter "%s".', __METHOD__, $name), E_USER_DEPRECATED);
    }

    if ($this->extensionInitialized) {
      throw new LogicException(sprintf('Unable to add filter "%s" as extensions have already been initialized.', $name));
    }

    $this->staging->addFilter($name, $filter);
  }

  /**
   * Get a filter by name.
   *
   * Subclasses may override this method and load filters differently;
   * so no list of filters is available.
   *
   * @param string $name The filter name
   *
   * @return Twig_SupTwgSgg_Filter|false A Twig_SupTwgSgg_Filter instance or false if the filter does not exist
   *
   * @internal
   */
  public function getFilter($name)
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    if (isset($this->filters[$name])) {
      return $this->filters[$name];
    }

    foreach ($this->filters as $pattern => $filter) {
      $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);

      if ($count) {
        if (preg_match('#^' . $pattern . '$#', $name, $matches)) {
          array_shift($matches);
          $filter->setArguments($matches);

          return $filter;
        }
      }
    }

    foreach ($this->filterCallbacks as $callback) {
      if (false !== ($filter = call_user_func($callback, $name))) {
        return $filter;
      }
    }

    return false;
  }

  public function registerUndefinedFilterCallback($callable)
  {
    $this->filterCallbacks[] = $callable;
  }

  /**
   * Gets the registered Filters.
   *
   * Be warned that this method cannot return filters defined with registerUndefinedFilterCallback.
   *
   * @return Twig_SupTwgSgg_FilterInterface[]
   *
   * @see registerUndefinedFilterCallback
   *
   * @internal
   */
  public function getFilters()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->filters;
  }

  /**
   * Registers a Test.
   *
   * @param string|Twig_SupTwgSgg_SimpleTest             $name The test name or a Twig_SupTwgSgg_SimpleTest instance
   * @param Twig_SupTwgSgg_TestInterface|Twig_SupTwgSgg_SimpleTest $test A Twig_SupTwgSgg_TestInterface instance or a Twig_SupTwgSgg_SimpleTest instance
   */
  public function addTest($name, $test = null)
  {
    if (!$name instanceof Twig_SupTwgSgg_SimpleTest && !($test instanceof Twig_SupTwgSgg_SimpleTest || $test instanceof Twig_SupTwgSgg_TestInterface)) {
      throw new LogicException('A test must be an instance of Twig_SupTwgSgg_TestInterface or Twig_SupTwgSgg_SimpleTest.');
    }

    if ($name instanceof Twig_SupTwgSgg_SimpleTest) {
      $test = $name;
      $name = $test->getName();
    } else {
      //@trigger_error(sprintf('Passing a name as a first argument to the %s method is deprecated since version 1.21. Pass an instance of "Twig_SupTwgSgg_SimpleTest" instead when defining test "%s".', __METHOD__, $name), E_USER_DEPRECATED);
    }

    if ($this->extensionInitialized) {
      throw new LogicException(sprintf('Unable to add test "%s" as extensions have already been initialized.', $name));
    }

    $this->staging->addTest($name, $test);
  }

  /**
   * Gets the registered Tests.
   *
   * @return Twig_SupTwgSgg_TestInterface[]
   *
   * @internal
   */
  public function getTests()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->tests;
  }

  /**
   * Gets a test by name.
   *
   * @param string $name The test name
   *
   * @return Twig_SupTwgSgg_Test|false A Twig_SupTwgSgg_Test instance or false if the test does not exist
   *
   * @internal
   */
  public function getTest($name)
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    if (isset($this->tests[$name])) {
      return $this->tests[$name];
    }

    return false;
  }

  /**
   * Registers a Function.
   *
   * @param string|Twig_SupTwgSgg_SimpleFunction                 $name     The function name or a Twig_SupTwgSgg_SimpleFunction instance
   * @param Twig_SupTwgSgg_FunctionInterface|Twig_SupTwgSgg_SimpleFunction $function
   */
  public function addFunction($name, $function = null)
  {
    if (!$name instanceof Twig_SupTwgSgg_SimpleFunction && !($function instanceof Twig_SupTwgSgg_SimpleFunction || $function instanceof Twig_SupTwgSgg_FunctionInterface)) {
      throw new LogicException('A function must be an instance of Twig_SupTwgSgg_FunctionInterface or Twig_SupTwgSgg_SimpleFunction.');
    }

    if ($name instanceof Twig_SupTwgSgg_SimpleFunction) {
      $function = $name;
      $name = $function->getName();
    } else {
      //@trigger_error(sprintf('Passing a name as a first argument to the %s method is deprecated since version 1.21. Pass an instance of "Twig_SupTwgSgg_SimpleFunction" instead when defining function "%s".', __METHOD__, $name), E_USER_DEPRECATED);
    }

    if ($this->extensionInitialized) {
      throw new LogicException(sprintf('Unable to add function "%s" as extensions have already been initialized.', $name));
    }

    $this->staging->addFunction($name, $function);
  }

  /**
   * Get a function by name.
   *
   * Subclasses may override this method and load functions differently;
   * so no list of functions is available.
   *
   * @param string $name function name
   *
   * @return Twig_SupTwgSgg_Function|false A Twig_SupTwgSgg_Function instance or false if the function does not exist
   *
   * @internal
   */
  public function getFunction($name)
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    if (isset($this->functions[$name])) {
      return $this->functions[$name];
    }

    foreach ($this->functions as $pattern => $function) {
      $pattern = str_replace('\\*', '(.*?)', preg_quote($pattern, '#'), $count);

      if ($count) {
        if (preg_match('#^' . $pattern . '$#', $name, $matches)) {
          array_shift($matches);
          $function->setArguments($matches);

          return $function;
        }
      }
    }

    foreach ($this->functionCallbacks as $callback) {
      if (false !== ($function = call_user_func($callback, $name))) {
        return $function;
      }
    }

    return false;
  }

  public function registerUndefinedFunctionCallback($callable)
  {
    $this->functionCallbacks[] = $callable;
  }

  /**
   * Gets registered functions.
   *
   * Be warned that this method cannot return functions defined with registerUndefinedFunctionCallback.
   *
   * @return Twig_SupTwgSgg_FunctionInterface[]
   *
   * @see registerUndefinedFunctionCallback
   *
   * @internal
   */
  public function getFunctions()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->functions;
  }

  /**
   * Registers a Global.
   *
   * New globals can be added before compiling or rendering a template;
   * but after, you can only update existing globals.
   *
   * @param string $name  The global name
   * @param mixed  $value The global value
   */
  public function addGlobal($name, $value)
  {
    if ($this->extensionInitialized || $this->runtimeInitialized) {
      if (null === $this->globals) {
        $this->globals = $this->initGlobals();
      }

      if (!array_key_exists($name, $this->globals)) {
        // The deprecation notice must be turned into the following exception in Twig 2.0
        //@trigger_error(sprintf('Registering global variable "%s" at runtime or when the extensions have already been initialized is deprecated since version 1.21.', $name), E_USER_DEPRECATED);
        //throw new LogicException(sprintf('Unable to add global "%s" as the runtime or the extensions have already been initialized.', $name));
      }
    }

    if ($this->extensionInitialized || $this->runtimeInitialized) {
      // update the value
      $this->globals[$name] = $value;
    } else {
      $this->staging->addGlobal($name, $value);
    }
  }

  /**
   * Gets the registered Globals.
   *
   * @return array An array of globals
   *
   * @internal
   */
  public function getGlobals()
  {
    if (!$this->runtimeInitialized && !$this->extensionInitialized) {
      return $this->initGlobals();
    }

    if (null === $this->globals) {
      $this->globals = $this->initGlobals();
    }

    return $this->globals;
  }

  /**
   * Merges a context with the defined globals.
   *
   * @param array $context An array representing the context
   *
   * @return array The context merged with the globals
   */
  public function mergeGlobals(array $context)
  {
    // we don't use array_merge as the context being generally
    // bigger than globals, this code is faster.
    foreach ($this->getGlobals() as $key => $value) {
      if (!array_key_exists($key, $context)) {
        $context[$key] = $value;
      }
    }

    return $context;
  }

  /**
   * Gets the registered unary Operators.
   *
   * @return array An array of unary operators
   *
   * @internal
   */
  public function getUnaryOperators()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->unaryOperators;
  }

  /**
   * Gets the registered binary Operators.
   *
   * @return array An array of binary operators
   *
   * @internal
   */
  public function getBinaryOperators()
  {
    if (!$this->extensionInitialized) {
      $this->initExtensions();
    }

    return $this->binaryOperators;
  }

  /**
   * @deprecated since 1.23 (to be removed in 2.0)
   */
  public function computeAlternatives($name, $items)
  {
    //@trigger_error(sprintf('The %s method is deprecated since version 1.23 and will be removed in Twig 2.0.', __METHOD__), E_USER_DEPRECATED);

    return Twig_SupTwgSgg_Error_Syntax::computeAlternatives($name, $items);
  }

  /**
   * @internal
   */
  protected function initGlobals()
  {
    $globals = [];
    foreach ($this->extensions as $name => $extension) {
      if (!$extension instanceof Twig_SupTwgSgg_Extension_GlobalsInterface) {
        $m = new ReflectionMethod($extension, 'getGlobals');

        if ('Twig_SupTwgSgg_Extension' !== $m->getDeclaringClass()->getName()) {
          //@trigger_error(sprintf('Defining the getGlobals() method in the "%s" extension without explicitly implementing Twig_SupTwgSgg_Extension_GlobalsInterface is deprecated since version 1.23.', $name), E_USER_DEPRECATED);
        }
      }

      $extGlob = $extension->getGlobals();
      if (!is_array($extGlob)) {
        throw new UnexpectedValueException(sprintf('"%s::getGlobals()" must return an array of globals.', get_class($extension)));
      }

      $globals[] = $extGlob;
    }

    $globals[] = $this->staging->getGlobals();

    return call_user_func_array('array_merge', $globals);
  }

  /**
   * @internal
   */
  protected function initExtensions()
  {
    if ($this->extensionInitialized) {
      return;
    }

    $this->parsers = new Twig_SupTwgSgg_TokenParserBroker([], [], false);
    $this->filters = [];
    $this->functions = [];
    $this->tests = [];
    $this->visitors = [];
    $this->unaryOperators = [];
    $this->binaryOperators = [];

    foreach ($this->extensions as $extension) {
      $this->initExtension($extension);
    }
    $this->initExtension($this->staging);
    // Done at the end only, so that an exception during initialization does not mark the environment as initialized when catching the exception
    $this->extensionInitialized = true;
  }

  /**
   * @internal
   */
  protected function initExtension(Twig_SupTwgSgg_ExtensionInterface $extension)
  {
    // filters
    foreach ($extension->getFilters() as $name => $filter) {
      if ($filter instanceof Twig_SupTwgSgg_SimpleFilter) {
        $name = $filter->getName();
      } else {
        //@trigger_error(sprintf('Using an instance of "%s" for filter "%s" is deprecated since version 1.21. Use Twig_SupTwgSgg_SimpleFilter instead.', get_class($filter), $name), E_USER_DEPRECATED);
      }

      $this->filters[$name] = $filter;
    }

    // functions
    foreach ($extension->getFunctions() as $name => $function) {
      if ($function instanceof Twig_SupTwgSgg_SimpleFunction) {
        $name = $function->getName();
      } else {
        //@trigger_error(sprintf('Using an instance of "%s" for function "%s" is deprecated since version 1.21. Use Twig_SupTwgSgg_SimpleFunction instead.', get_class($function), $name), E_USER_DEPRECATED);
      }

      $this->functions[$name] = $function;
    }

    // tests
    foreach ($extension->getTests() as $name => $test) {
      if ($test instanceof Twig_SupTwgSgg_SimpleTest) {
        $name = $test->getName();
      } else {
        //@trigger_error(sprintf('Using an instance of "%s" for test "%s" is deprecated since version 1.21. Use Twig_SupTwgSgg_SimpleTest instead.', get_class($test), $name), E_USER_DEPRECATED);
      }

      $this->tests[$name] = $test;
    }

    // token parsers
    foreach ($extension->getTokenParsers() as $parser) {
      if ($parser instanceof Twig_SupTwgSgg_TokenParserInterface) {
        $this->parsers->addTokenParser($parser);
      } elseif ($parser instanceof Twig_SupTwgSgg_TokenParserBrokerInterface) {
        //@trigger_error('Registering a Twig_SupTwgSgg_TokenParserBrokerInterface instance is deprecated since version 1.21.', E_USER_DEPRECATED);

        $this->parsers->addTokenParserBroker($parser);
      } else {
        throw new LogicException('getTokenParsers() must return an array of Twig_SupTwgSgg_TokenParserInterface or Twig_SupTwgSgg_TokenParserBrokerInterface instances.');
      }
    }

    // node visitors
    foreach ($extension->getNodeVisitors() as $visitor) {
      $this->visitors[] = $visitor;
    }

    // operators
    if ($operators = $extension->getOperators()) {
      if (!is_array($operators)) {
        throw new InvalidArgumentException(sprintf('"%s::getOperators()" must return an array with operators, got "%s".', get_class($extension), is_object($operators) ? get_class($operators) : gettype($operators) . (is_resource($operators) ? '' : '#' . $operators)));
      }

      if (2 !== count($operators)) {
        throw new InvalidArgumentException(sprintf('"%s::getOperators()" must return an array of 2 elements, got %d.', get_class($extension), count($operators)));
      }

      $this->unaryOperators = array_merge($this->unaryOperators, $operators[0]);
      $this->binaryOperators = array_merge($this->binaryOperators, $operators[1]);
    }
  }

  /**
   * @deprecated since 1.22 (to be removed in 2.0)
   */
  protected function writeCacheFile($file, $content)
  {
    $this->cache->write($file, $content);
  }

  private function updateOptionsHash()
  {
    $hashParts = array_merge(array_keys($this->extensions), [(int) function_exists('Twig_SupTwgSgg_template_get_attributes'), PHP_MAJOR_VERSION, PHP_MINOR_VERSION, self::VERSION, (int) $this->debug, $this->baseTemplateClass, (int) $this->strictVariables]);
    $this->optionsHash = implode(':', $hashParts);
  }
}