public function __call($name, $arguments)
    {
        $callable = array($this->run, $name);
        if (method_exists($this, $name)) {
            $callable = array($this, $name);
        }
 
        return call_user_func_array($callable, $arguments);
    }
 

 
        if ( ! is_writable($parentDirectory)) {
            throw UnexpectedValueException::proxyDirectoryNotWritable($this->proxyDirectory);
        }
 
        $tmpFileName = $fileName . '.' . uniqid('', true);
 
        file_put_contents($tmpFileName, $proxyCode);
        chmod($tmpFileName, 0664);
        rename($tmpFileName, $fileName);

                    if ( ! file_exists($fileName)) {
                        $this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
                    }
                    require $fileName;
                    break;
 
                case self::AUTOGENERATE_ALWAYS:
                    $this->proxyGenerator->generateProxyClass($classMetadata, $fileName);
                    require $fileName;
                    break;

     *
     * @throws \Doctrine\Common\Proxy\Exception\OutOfBoundsException
     */
    public function getProxy($className, array $identifier)
    {
        $definition = isset($this->definitions[$className])
            ? $this->definitions[$className]
            : $this->getProxyDefinition($className);
        $fqcn       = $definition->proxyClassName;
        $proxy      = new $fqcn($definition->initializer, $definition->cloner);

                            $newValue = $this->getEntityPersister($assoc['targetEntity'])->loadOneToOneEntity($assoc, $entity, $associatedId);
                            break;
 
                        default:
                            switch (true) {
                                // We are negating the condition here. Other cases will assume it is valid!
                                case ($hints['fetchMode'][$class->name][$field] !== ClassMetadata::FETCH_EAGER):
                                    $newValue = $this->em->getProxyFactory()->getProxy($assoc['targetEntity'], $associatedId);
                                    break;
 

        }
 
        if (isset($this->_hints[Query::HINT_REFRESH_ENTITY])) {
            $this->registerManaged($this->class, $this->_hints[Query::HINT_REFRESH_ENTITY], $data);
        }
 
        $uow    = $this->_em->getUnitOfWork();
        $entity = $uow->createEntity($entityName, $data, $this->_hints);
 
        $result[] = $entity;

     */
    protected function hydrateAllData()
    {
        $result = array();
        $cache = array();
 
        while ($row = $this->_stmt->fetch(PDO::FETCH_ASSOC)) {
            $this->hydrateRowData($row, $cache, $result);
        }
 

    {
        $this->_stmt  = $stmt;
        $this->_rsm   = $resultSetMapping;
        $this->_hints = $hints;
 
        $this->prepare();
 
        $result = $this->hydrateAllData();
 
        $this->cleanup();

 
        if ($entity !== null) {
            $hints[Query::HINT_REFRESH]         = true;
            $hints[Query::HINT_REFRESH_ENTITY]  = $entity;
        }
 
        $hydrator = $this->em->newHydrator($this->selectJoinSql ? Query::HYDRATE_OBJECT : Query::HYDRATE_SIMPLEOBJECT);
        $entities = $hydrator->hydrateAll($stmt, $this->rsm, $hints);
 
        return $entities ? $entities[0] : null;

            return $entity; // Hit!
        }
 
        $persister = $unitOfWork->getEntityPersister($class->name);
 
        switch ($lockMode) {
            case LockMode::NONE:
                return $persister->load($sortedId);
 
            case LockMode::OPTIMISTIC:

     * returns a file object for the given file ID
     * @param int $fID
     * @return File
     */
    public static function getByID($fID)
    {
        $em = \ORM::entityManager('core');
        return $em->find('\Concrete\Core\File\File', $fID);
    }
 

        if (is_object($this->getFileOnstateObject())) {
            $this->requireAsset('javascript', 'jquery');
        }
    }
 
    public function view()
    {
        $f = File::getByID($this->fID);
        if (!is_object($f) || !$f->getFileID()) {
            return false;

 
    public function runAction($action, $parameters = array())
    {
        $this->action = $action;
        $this->parameters = $parameters;
        if (is_callable(array($this, $action))) {
            if ($this->shouldRunControllerTask()) {
                return call_user_func_array(array($this, $action), $parameters);
            }
        }

                        $this->controller = $controller;
                    }
                }
            }
 
            $parameters = array();
            if (!$passthru) {
                $this->controller->runAction($method, $parameters);
            }
            $this->controller->on_before_render();

 
    public function startRender()
    {
    }
 
    public function setupRender()
    {
        $this->runControllerTask();
 
        $view = $this->viewToRender;

 
    public function render($state = false)
    {
        if ($this instanceof View) {
            $this->setRequestInstance($this);
        }
        $this->start($state);
        $this->setupRender();
        $this->startRender();
        $scopeItems = $this->getScopeItems();

            $bv = new BlockView($b);
            $bv->setAreaObject($this);
            $p = new Permissions($b);
            if ($p->canViewBlock()) {
                if (!$c->isEditMode()) {
                    echo $this->enclosingStart;
                }
                $bv->render('view');
                if (!$c->isEditMode()) {
                    echo $this->enclosingEnd;

 
        unset($blocksTmp);
        return $blocks;
    }
 
    public function display($c = false, $fake = null)
    {
        parent::display($c, null);
    }
 

	?>
	<?php  if($abltb > 0 || $abrtb > 0 || $c->isEditMode()) {?>
	<div class="row">
	<?php  }?>
		<?php 
		if($abltb > 0 || $c->isEditMode()) {
			echo '<div class="small-12 large-6 columns">';
					$abl->display();
			echo '</div>';
		}

        unset($path);
        if (!empty($__data__['scopedItems'])) {
            if (array_key_exists('__data__', $__data__['scopedItems'])) {
                throw new \Exception(t(/*i18n: %1$s is a variable name, %2$s is a function name*/'Illegal variable name \'%1$s\' in %2$s args.', '__data__', __CLASS__.'::'.__METHOD__));
            }
            extract($__data__['scopedItems']);
        }
        include $__data__['path'];
    }
 

<?php  defined('C5_EXECUTE') or die("Access Denied.");?>
 
<?php  $this->inc('elements/head.php');?>
<?php  $this->inc('elements/header.php');?>
<?php 
$u = new User();
if(Config::get('c5hub.fundamental.general.sticky_footer') == true && !$u->isRegistered()) {
	$stickyFooter = ' c5h-sticky-footer-content';
}
?>

            $innerContent = ob_get_contents();
            ob_end_clean();
        }
 
        if (file_exists($this->template)) {
            ob_start();
            $this->onBeforeGetContents();
            include $this->template;
            $contents = ob_get_contents();
            $this->onAfterGetContents();

        if ($this instanceof View) {
            $this->setRequestInstance($this);
        }
        $this->start($state);
        $this->setupRender();
        $this->startRender();
        $scopeItems = $this->getScopeItems();
        $contents = $this->renderViewContents($scopeItems);
        $contents = $this->postProcessViewContents($contents);
        $response = $this->finishRender($contents);

use Core;
use Session;
 
class DispatcherRouteCallback extends RouteCallback
{
    protected function sendResponse(View $v, $code = 200)
    {
        $contents = $v->render();
        $response = new Response($contents, $code);
 

                }
            }
        }
 
        // we update the current page with the one bound to this controller.
        $request->setCurrentPage($c);
 
        return $this->sendResponse($view);
    }
 

                $request->attributes->add($matcher->match($path));
                $matched = $matcher->match($path);
                $route = $collection->get($matched['_route']);
                Route::setRequest($request);
                $response = Route::execute($route, $matched);
            } catch (ResourceNotFoundException $e) {
                $callback = new DispatcherRouteCallback('dispatcher');
                $response = $callback->execute($request);
            }
        }

\Events::dispatch('on_before_dispatch');
 
/**
 * ----------------------------------------------------------------------------
 * Get the response to the current request
 * ----------------------------------------------------------------------------
 */
$response = $cms->dispatch($request);
/**
 * ----------------------------------------------------------------------------

 
 
/**
 * ----------------------------------------------------------------------------
 * Begin concrete5 startup.
 * ----------------------------------------------------------------------------
 */
$cms = require $__DIR__ . '/bootstrap/start.php';
 
 

<?php
require('concrete/dispatcher.php');
 

    public function __call($name, $arguments)
    {
        $callable = array($this->run, $name);
        if (method_exists($this, $name)) {
            $callable = array($this, $name);
        }
 
        return call_user_func_array($callable, $arguments);
    }
 

    }
 
    /**
     * {@inheritdoc}
     */
    public function write($sessionId, $data)
    {
        return (bool) $this->handler->write($sessionId, $data);
    }