{
ob_start();
extract($__data);
// We'll evaluate the contents of the view inside a try/catch block so we can
// flush out any stray output that might get out before an error occurs or
// an exception is thrown. This prevents any partial views from leaking.
try {
include $__path;
} catch (\Exception $e) {
$this->handleViewException($e);

{
$env = $this->environment;
// We will keep track of the amount of views being rendered so we can flush
// the section after the complete rendering operation is done. This will
// clear out the sections for any separate views that may be rendered.
$env->incrementRender();
$env->callComposer($this);
$contents = trim($this->getContents());
// Once we've finished rendering the view, we'll decrement the render count
// then if we are at the bottom of the stack we'll flush out sections as

{
ob_start();
extract($__data);
// We'll evaluate the contents of the view inside a try/catch block so we can
// flush out any stray output that might get out before an error occurs or
// an exception is thrown. This prevents any partial views from leaking.
try {
include $__path;
} catch (\Exception $e) {
$this->handleViewException($e);

{
$env = $this->environment;
// We will keep track of the amount of views being rendered so we can flush
// the section after the complete rendering operation is done. This will
// clear out the sections for any separate views that may be rendered.
$env->incrementRender();
$env->callComposer($this);
$contents = trim($this->getContents());
// Once we've finished rendering the view, we'll decrement the render count
// then if we are at the bottom of the stack we'll flush out sections as

// If the content is "JSONable" we will set the appropriate header and convert
// the content to JSON. This is useful when returning something like models
// from routes that will be automatically transformed to their JSON form.
if ($this->shouldBeJson($content)) {
$this->headers->set('Content-Type', 'application/json');
$content = $this->morphToJson($content);
} elseif ($content instanceof RenderableInterface) {
$content = $content->render();
}
return parent::setContent($content);

protected function processResponse($router, $method, $response)
{
$request = $router->getRequest();
// The after filters give the developers one last chance to do any last minute
// processing on the response. The response has already been converted to a
// full Response object and will also be handed off to the after filters.
$response = $router->prepare($response, $request);
$this->callAfterFilters($router, $method, $response);

// used we will assume we want to just return the layout view as any nested
// views were probably bound on this view during this controller actions.
if (is_null($response) and ! is_null($this->layout))
{
$response = $this->layout;
}
return $this->processResponse($router, $method, $response);
}

list($controller, $method) = explode('@', $attribute);
$route = $me->getCurrentRoute();
// We will extract the passed in parameters off of the route object so we will
// pass them off to the controller method as arguments. We will not get the
// defaults so that the controllers will be able to use its own defaults.
$args = array_values($route->getParametersWithoutDefaults());
$instance = $ioc->make($controller);
return $instance->callAction($ioc, $me, $method, $args);
};
}

{
$this->parsedParameters = null;
// We will only call the router callable if no "before" middlewares returned
// a response. If they do, we will consider that the response to requests
// so that the request "lifecycle" will be easily halted for filtering.
$response = $this->callBeforeFilters($request);
if (!isset($response)) {
$response = $this->callCallable();
} else {
$fromFilter = true;

// to override the normal requests process when a response is returned by a
// middleware. Otherwise we'll call the route just like a normal request.
$response = $this->callGlobalFilter($request, 'before');
if (!is_null($response)) {
$response = $this->prepare($response, $request);
} else {
$this->currentRoute = $route = $this->findRoute($request);
$response = $route->run($request);
}
// Finally after the route has been run we can call the after and close global

| Once we have the application, we can simply call the run method,
| which will execute the request and send the response back to
| the client's browser allowing them to enjoy the creative
| and wonderful applications we have created for them.
|
*/
$app->run();
/*