text:
package org.jtwig.parser.parboiled.base;

import org.jtwig.parser.ParseException;
import org.jtwig.parser.parboiled.ParserContext;
import org.jtwig.util.ErrorMessageFormatter;
import org.parboiled.BaseParser;
import org.parboiled.MatcherContext;
import org.parboiled.Rule;
import org.parboiled.errors.BasicParseError;

import java.util.List;

public class BasicParser<T> extends BaseParser<T> {
    final ParserContext parserContext;

    public BasicParser (Class<? extends BasicParser> type, ParserContext context) {
        this.parserContext = context;
        this.parserContext.register(type, this);
    }

    public ParserContext parserContext() {
        return parserContext;
    }

    public void addError(String message) {
        MatcherContext matcherContext = (MatcherContext) getContext();
        matcherContext.markError();
        List parseErrors = matcherContext.getParseErrors();
        parseErrors.add(new BasicParseError(matcherContext.getInputBuffer(), parseErrors.size(), message));
    }

    public Rule Mandatory (Rule rule, String message) {
        return FirstOf(
            rule,
            throwException(message)
        );
    }

    public boolean throwException(String message) {
        throw new ParseException(ErrorMessageFormatter.errorMessage(parserContext.parser(PositionTrackerParser.class).currentPosition(), message));
    }
}


text:
package executor

import (
	"fmt"

	"sqlflow.org/sqlflow/go/codegen/pai"
	"sqlflow.org/sqlflow/go/ir"
	"sqlflow.org/sqlflow/go/model"
)

type paiLocalExecutor struct{ *pythonExecutor }

const setLocalFlagsCodeTmpl = `import os
from runtime.pai.pai_distributed import define_tf_flags
FLAGS = define_tf_flags()
FLAGS.sqlflow_oss_ak = os.getenv("SQLFLOW_OSS_AK")
FLAGS.sqlflow_oss_sk = os.getenv("SQLFLOW_OSS_SK")
FLAGS.sqlflow_oss_ep = os.getenv("SQLFLOW_OSS_MODEL_ENDPOINT")
FLAGS.sqlflow_oss_modeldir = "%[1]s"
FLAGS.checkpointDir = "."
`

func (s *paiLocalExecutor) ExecuteTrain(trainStmt *ir.TrainStmt) error {
	code, _, _, err := getPaiTrainCode(s.pythonExecutor, trainStmt)
	defer dropTmpTables([]string{trainStmt.TmpTrainTable, trainStmt.TmpValidateTable}, s.Session.DbConnStr)
	if err != nil {
		return err
	}
	ossModelPathToSave, e := model.GetOSSModelPath(trainStmt.Into, s.Session)
	if e != nil {
		return e
	}
	setLocalFlagsCode := fmt.Sprintf(setLocalFlagsCodeTmpl, pai.OSSModelURL(ossModelPathToSave))
	err = s.runProgram(setLocalFlagsCode+code, true)
	if err != nil {
		return err
	}
	// download model from OSS to local cwd and save to sqlfs
	// NOTE(typhoonzero): model in sqlfs will be used by sqlflow model zoo currently
	// should use the model in sqlfs when predicting.
	if e = downloadOSSModel(ossModelPathToSave + "/"); e != nil {
		return e
	}
	m := model.New(s.Cwd, trainStmt.OriginalSQL)
	return m.Save(trainStmt.Into, s.Session)
}

func (s *paiLocalExecutor) ExecutePredict(predStmt *ir.PredictStmt) error {
	code, _, _, _, err := getPaiPredictCode(s.pythonExecutor, predStmt)

	defer dropTmpTables([]string{predStmt.TmpPredictTable}, s.Session.DbConnStr)
	if err != nil {
		return err
	}
	ossModelPathToSave, e := model.GetOSSModelPath(predStmt.Using, s.Session)
	if e != nil {
		return e
	}
	setLocalFlagsCode := fmt.Sprintf(setLocalFlagsCodeTmpl, pai.OSSModelURL(ossModelPathToSave))
	return s.runProgram(setLocalFlagsCode+code, true)
}

func (s *paiLocalExecutor) ExecuteExplain(explainStmt *ir.ExplainStmt) error {
	expn, _, err := getPaiExplainCode(s.pythonExecutor, explainStmt)
	defer dropTmpTables([]string{explainStmt.TmpExplainTable}, s.Session.DbConnStr)
	if err != nil {
		return err
	}
	ossModelPathToSave, e := model.GetOSSModelPath(explainStmt.ModelName, s.Session)
	if e != nil {
		return e
	}
	setLocalFlagsCode := fmt.Sprintf(setLocalFlagsCodeTmpl, pai.OSSModelURL(ossModelPathToSave))
	return s.runProgram(setLocalFlagsCode+expn.Code, true)
}

func (s *paiLocalExecutor) ExecuteEvaluate(evalStmt *ir.EvaluateStmt) error {
	code, _, _, _, err := getPaiEvaluateCode(s.pythonExecutor, evalStmt)
	defer dropTmpTables([]string{evalStmt.TmpEvaluateTable}, s.Session.DbConnStr)
	if err != nil {
		return err
	}
	ossModelPathToSave, e := model.GetOSSModelPath(evalStmt.ModelName, s.Session)
	if e != nil {
		return e
	}
	setLocalFlagsCode := fmt.Sprintf(setLocalFlagsCodeTmpl, pai.OSSModelURL(ossModelPathToSave))
	return s.runProgram(setLocalFlagsCode+code, true)
}

redpajama_set_name: RedPajamaGithub


text:
<?php
namespace frontend\controllers;

use common\models\SitePages;
use Yii;

class PagesController extends AppController
{

    public function actionIndex()
    {
        $page = SitePages::find()
            ->where(['url' => trim(Yii::$app->request->getUrl(), '/')])->one();
        $this->pageId = $page['id'];
        Yii::$app->view->title = empty($page['title']) ? $page['name']
            : $page['title'];
        Yii::$app->view->registerMetaTag([
            'name'    => 'description',
            'content' => $page['description'],
        ]);
        Yii::$app->view->registerMetaTag([
            'name'    => 'keywords',
            'content' => $page['keywords'],
        ]);

        return $this->render($page['template'], ['page' => $page]);
    }

}


text: Copyright 2017 - WF3


text:
.class public Lcom/voxelbusters/nativeplugins/defines/UnityDefines$WebView;
.super Ljava/lang/Object;
.source "UnityDefines.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/voxelbusters/nativeplugins/defines/UnityDefines;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x1
    name = "WebView"
.end annotation

# static fields
.field public static final WEB_VIEW_DID_DESTROY:Ljava/lang/String; = "WebViewDidDestroy"

.field public static final WEB_VIEW_DID_FAIL_LOAD_WITH_ERROR:Ljava/lang/String; = "WebViewDidFailLoadWithError"

.field public static final WEB_VIEW_DID_FINISH_EVALUATING_JS:Ljava/lang/String; = "WebViewDidFinishEvaluatingJS"

.field public static final WEB_VIEW_DID_FINISH_LOAD:Ljava/lang/String; = "WebViewDidFinishLoad"

.field public static final WEB_VIEW_DID_HIDE:Ljava/lang/String; = "WebViewDidHide"

.field public static final WEB_VIEW_DID_RECEIVE_MESSAGE:Ljava/lang/String; = "WebViewDidReceiveMessage"

.field public static final WEB_VIEW_DID_SHOW:Ljava/lang/String; = "WebViewDidShow"

.field public static final WEB_VIEW_DID_START_LOAD:Ljava/lang/String; = "WebViewDidStartLoad"

# instance fields
.field final synthetic this$0:Lcom/voxelbusters/nativeplugins/defines/UnityDefines;

# direct methods
.method public constructor <init>(Lcom/voxelbusters/nativeplugins/defines/UnityDefines;)V
    .registers 2

    .prologue
    .line 49
    iput-object p1, p0, Lcom/voxelbusters/nativeplugins/defines/UnityDefines$WebView;->this$0:Lcom/voxelbusters/nativeplugins/defines/UnityDefines;

    invoke-direct {p0}, Ljava/lang/Object;-><init>()V

    return-void
.end method


text:
package liquibase.sqlgenerator.core;

import java.math.BigInteger;

import org.junit.Test;

import liquibase.database.Database;
import liquibase.database.core.DB2Database;
import liquibase.database.core.H2Database;
import liquibase.database.core.HsqlDatabase;
import liquibase.test.TestContext;

public class AddAutoIncrementGeneratorDB2Test extends AddAutoIncrementGeneratorTest {

    public AddAutoIncrementGeneratorDB2Test() throws Exception {
    	super(new AddAutoIncrementGeneratorDB2());
    }

     @Override
    protected boolean shouldBeImplementation(Database database) {
        return database instanceof DB2Database;
    }

     @Test
     public void testAddAutoIncrement() throws Exception {
     	for (Database database : TestContext.getInstance().getAllDatabases()) {
     		if (database instanceof DB2Database || database instanceof DB2Database) {
     			super.testAddAutoIncrementStatement(
     				database,
     				null,
     				null,
     				"ALTER TABLE SCHEMA_NAME.TABLE_NAME ALTER COLUMN COLUMN_NAME SET GENERATED BY DEFAULT AS IDENTITY");
     		}
     	}
     }

     @Test
     public void testAddAutoIncrementStartWith() throws Exception {
     	for (Database database : TestContext.getInstance().getAllDatabases()) {
     		if (database instanceof DB2Database || database instanceof DB2Database) {
     			super.testAddAutoIncrementStatement(
     				database,
     				BigInteger.valueOf(2),
     				null,
     				"ALTER TABLE SCHEMA_NAME.TABLE_NAME ALTER COLUMN COLUMN_NAME SET GENERATED BY DEFAULT AS IDENTITY (START WITH 2)");
     		}
     	}
     }

     @Test
     public void testAddAutoIncrementStartWithIncrementBy() throws Exception {
     	for (Database database : TestContext.getInstance().getAllDatabases()) {
     		if (database instanceof DB2Database || database instanceof DB2Database) {
     			super.testAddAutoIncrementStatement(
     				database,
     				BigInteger.valueOf(2),
     				BigInteger.TEN,
     				"ALTER TABLE SCHEMA_NAME.TABLE_NAME ALTER COLUMN COLUMN_NAME SET GENERATED BY DEFAULT AS IDENTITY (START WITH 2, INCREMENT BY 10)");
     		}
     	}
     }
}


text:
package org.data2semantics.mustard.kernels.graphkernels.rdfdata;

import java.util.List;
import java.util.Set;

import org.data2semantics.mustard.kernels.ComputationTimeTracker;
import org.data2semantics.mustard.kernels.KernelUtils;
import org.data2semantics.mustard.kernels.SparseVector;
import org.data2semantics.mustard.kernels.data.RDFData;
import org.data2semantics.mustard.kernels.data.SingleDTGraph;
import org.data2semantics.mustard.kernels.graphkernels.FeatureVectorKernel;
import org.data2semantics.mustard.kernels.graphkernels.GraphKernel;
import org.data2semantics.mustard.kernels.graphkernels.singledtgraph.DTGraphTreeWLSubTreeIDEQKernel;
import org.data2semantics.mustard.rdf.RDFDataSet;
import org.data2semantics.mustard.rdf.RDFUtils;
import org.openrdf.model.Resource;
import org.openrdf.model.Statement;

/**
 * Wrapper kernel for {@link org.data2semantics.mustard.kernels.graphkernels.singledtgraph.DTGraphTreeWLSubTreeIDEQKernel}.
 *
 * @author Gerben
 */
public class RDFTreeWLSubTreeIDEQKernel implements GraphKernel<RDFData>, FeatureVectorKernel<RDFData>, ComputationTimeTracker {
	private int depth;
	private boolean inference;
	private DTGraphTreeWLSubTreeIDEQKernel kernel;
	private SingleDTGraph graph;

	public RDFTreeWLSubTreeIDEQKernel(int iterations, int depth, boolean inference, boolean reverse, boolean noDuplicateSubtrees, boolean normalize) {
		super();
		this.depth = depth;
		this.inference = inference;

		kernel = new DTGraphTreeWLSubTreeIDEQKernel(iterations, depth, reverse, noDuplicateSubtrees, normalize);
	}

	public String getLabel() {
		return KernelUtils.createLabel(this) + "_" + kernel.getLabel();
	}

	public void setNormalize(boolean normalize) {
		kernel.setNormalize(normalize);
	}

	public long getComputationTime() {
		return kernel.getComputationTime();
	}

	public SparseVector[] computeFeatureVectors(RDFData data) {
		init(data.getDataset(), data.getInstances(), data.getBlackList());
		return kernel.computeFeatureVectors(graph);
	}

	public double[][] compute(RDFData data) {
		init(data.getDataset(), data.getInstances(), data.getBlackList());
		return kernel.compute(graph);
	}

	private void init(RDFDataSet dataset, List<Resource> instances, List<Statement> blackList) {
		Set<Statement> stmts = RDFUtils.getStatements4Depth(dataset, instances, depth, inference);
		stmts.removeAll(blackList);
		graph = RDFUtils.statements2Graph(stmts, RDFUtils.REGULAR_LITERALS, instances, true);
	}
}


text:
package thereisnospon.acclient.data;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author thereisnospon
 * 提交状态Bean
 * Created by yzr on 16/6/8.
 */
public class SubmmitStatus
{
    String submmitId;
    String date;
    String status;
    String problemId;
    String usedTime;
    String usedMemory;
    String codeLen;
    String language;
    String userName;
    String userId;

    public SubmmitStatus(String submmitId, String date, String status,
                         String problemId, String usedTime, String usedMemory,
                         String codeLen, String language, String userName, String userId) {
        this.submmitId = submmitId;
        this.date = date;
        this.status = status;
        this.problemId = problemId;
        this.usedTime = usedTime;
        this.usedMemory = usedMemory;
        this.codeLen = codeLen;
        this.language = language;
        this.userName = userName;
        this.userId = userId;
    }

    public static class Builder
    {

        public static List<SubmmitStatus> parse(String html){
            Document document= Jsoup.parse(html);
            Element div=document.getElementById("fixed_table");
            Element table=div.getElementsByTag("table").first();
            Elements trs=table.getElementsByTag("tr");
            List<SubmmitStatus>list=new ArrayList<>();

            for(int i=1;i<trs.size();i++){
                SubmmitStatus status=get(trs.get(i).getElementsByTag("td"));
                if(status!=null)
                    list.add(status);
            }
            return list;

        }

        private  static SubmmitStatus get(Elements tds){

            if(tds.size()!=9)
                return null;
            String submmitedId=tds.get(0).text();
            String date=tds.get(1).text();
            String status=tds.get(2).text();
            String problemId=tds.get(3).text();
            String time=tds.get(4).text();
            String memory=tds.get(5).text();
            String codeLen=tds.get(6).text();
            String language=tds.get(7).text();
            String userName=tds.get(8).text();
            String userId=parseId(tds.get(8).html());

            SubmmitStatus submmitStatus=new SubmmitStatus(
                    submmitedId,date,status,problemId,
                    time,memory,codeLen,language
                    ,userName,userId
            );

            return submmitStatus;

        }

        private static final String ID_REGEX="\\?user=(\\S+)[\"']+?";

        private static String  parseId(String x){
            Pattern pattern=Pattern.compile(ID_REGEX);
            Matcher matcher=pattern.matcher(x);
            if(matcher.find()){
                return matcher.group(1);
            }else return "";
        }
    }

    public String getSubmmitId() {
        return submmitId;
    }

    public void setSubmmitId(String submmitId) {
        this.submmitId = submmitId;
    }

    public String getDate() {
        return date;
    }

    public void setDate(String date) {
        this.date = date;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getProblemId() {
        return problemId;
    }

    public void setProblemId(String problemId) {
        this.problemId = problemId;
    }

    public String getUsedTime() {
        return usedTime;
    }

    public void setUsedTime(String usedTime) {
        this.usedTime = usedTime;
    }

    public String getUsedMemory() {
        return usedMemory;
    }

    public void setUsedMemory(String usedMemory) {
        this.usedMemory = usedMemory;
    }

    public String getCodeLen() {
        return codeLen;
    }

    public void setCodeLen(String codeLen) {
        this.codeLen = codeLen;
    }

    public String getLanguage() {
        return language;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    private static String _tag(String key, String value){
        return key+":\t"+value+"\n";
    }

    @Override
    public String toString() {
        StringBuilder builder=new StringBuilder();
        builder.append(_tag("submmitId",submmitId));
        builder.append(_tag("date",date));
        builder.append(_tag("status",status));
        builder.append(_tag("problemId",problemId));
        builder.append(_tag("usedTime",usedTime));
        builder.append(_tag("usedMemory",usedMemory));
        builder.append(_tag("codelen",codeLen));
        builder.append(_tag("language",language));
        builder.append(_tag("userName",userName));
        builder.append(_tag("userId",userId));
        return builder.toString();
    }
}


text:
var vows = require('vows');
var assert = require('assert');
var util = require('util');
var allplayers = require('passport-dropbox');

vows.describe('passport-allplayers').addBatch({

  'module': {
    'should report a version': function (x) {
      assert.isString(allplayers.version);
    },
  },

}).export(module);


text:
using System;
using Microsoft.Extensions.Localization;

namespace Orchard
{
    public class OrchardException : Exception
    {
        private readonly LocalizedString _localizedMessage;

        public OrchardException(LocalizedString message)
            : base(message)
        {
            _localizedMessage = message;
        }

        public OrchardException(LocalizedString message, Exception innerException)
            : base(message, innerException)
        {
            _localizedMessage = message;
        }

        public LocalizedString LocalizedMessage { get { return _localizedMessage; } }
    }
}


text:
package com.portlet.sample.service.persistence;

import com.liferay.portal.kernel.dao.orm.BaseActionableDynamicQuery;
import com.liferay.portal.kernel.exception.SystemException;

import com.portlet.sample.model.EntryComment;
import com.portlet.sample.service.EntryCommentLocalServiceUtil;

/**
 * @author Scalsysu5
 * @generated
 */
public abstract class EntryCommentActionableDynamicQuery
	extends BaseActionableDynamicQuery {
	public EntryCommentActionableDynamicQuery() throws SystemException {
		setBaseLocalService(EntryCommentLocalServiceUtil.getService());
		setClass(EntryComment.class);

		setClassLoader(com.portlet.sample.service.ClpSerializer.class.getClassLoader());

		setPrimaryKeyPropertyName("commentId");
	}
}


text:
package com.sshtools.forker.client.impl;

import java.io.IOException;

import com.sshtools.forker.client.ForkerBuilder;
import com.sshtools.forker.client.ForkerProcess;
import com.sshtools.forker.client.ForkerProcessFactory;
import com.sshtools.forker.client.ForkerProcessListener;
import com.sshtools.forker.client.NonBlockingProcessListener;
import com.sshtools.forker.common.IO;

/**
 * Create a {@link LocalProcess} if requested to explicity do so.
 *
 */
public class DefaultProcessFactory implements ForkerProcessFactory {

	@Override
	public ForkerProcess createProcess(ForkerBuilder builder, ForkerProcessListener listener) throws IOException {
		if (builder.io() == IO.DEFAULT) {
			if(listener instanceof NonBlockingProcessListener) {
				throw new IllegalArgumentException(String.format("%s is not supported by %s, is your I/O mode set correctly (see %s.io(%s))", listener.getClass(), getClass(), ForkerBuilder.class, IO.class));
			}
			return new LocalProcess(builder);
		}
		return null;
	}

}


text:
// flow-typed signature: ce4134b0dec84fd45c8e8b631aa6d642
// flow-typed version: <<STUB>>/react-logger_v^1.1.0/flow_v0.54.0

/**
 * This is an autogenerated libdef stub for:
 *
 *   'react-logger'
 *
 * Fill this stub out by replacing all the `any` types.
 *
 * Once filled out, we encourage you to share your work with the
 * community by sending a pull request to:
 * https://github.com/flowtype/flow-typed
 */

declare module 'react-logger' {
  declare module.exports: any;
}

/**
 * We include stubs for each file inside this npm package in case you need to
 * require those files directly. Feel free to delete any files that aren't
 * needed.
 */
declare module 'react-logger/test/index' {
  declare module.exports: any;
}

// Filename aliases
declare module 'react-logger/index' {
  declare module.exports: $Exports<'react-logger'>;
}
declare module 'react-logger/index.js' {
  declare module.exports: $Exports<'react-logger'>;
}
declare module 'react-logger/test/index.js' {
  declare module.exports: $Exports<'react-logger/test/index'>;
}


text:
define([
  'jquery',
  './base',
  '../utils'
], function ($, BaseSelection, Utils) {
  function MultipleSelection ($element, options) {
    MultipleSelection.__super__.constructor.apply(this, arguments);
  }

  Utils.Extend(MultipleSelection, BaseSelection);

  MultipleSelection.prototype.render = function () {
    var $selection = MultipleSelection.__super__.render.call(this);

    $selection.addClass('select2-selection--multiple');

    $selection.html(
      '

'
    );

    return $selection;
  };

  MultipleSelection.prototype.bind = function (container, $container) {
    var self = this;

    MultipleSelection.__super__.bind.apply(this, arguments);

    this.$selection.on('click', function (evt) {
      self.trigger('toggle', {
        originalEvent: evt
      });
    });

    this.$selection.on('click', '.select2-selection__choice__remove',
      function (evt) {
      var $remove = $(this);
      var $selection = $remove.parent();

      var data = $selection.data('data');

      self.trigger('unselect', {
        originalEvent: evt,
        data: data
      });
    });
  };

  MultipleSelection.prototype.clear = function () {
    this.$selection.find('.select2-selection__rendered').empty();
  };

  MultipleSelection.prototype.display = function (data) {
    var template = this.options.get('templateSelection');
    var escapeMarkup = this.options.get('escapeMarkup');

    return escapeMarkup(template(data));
  };

  MultipleSelection.prototype.selectionContainer = function () {
    var $container = $(
      '
' +
        '' +
          '×' +
        '' +
      '
'
    );

    return $container;
  };

  MultipleSelection.prototype.update = function (data) {
    this.clear();

    if (data.length === 0) {
      return;
    }

    var $selections = [];

    for (var d = 0; d < data.length; d++) {
      var selection = data[d];

      var formatted = this.display(selection);
      var $selection = this.selectionContainer();

      $selection.append(formatted);
      $selection.data('data', selection);

      $selections.push($selection);
    }

    this.$selection.find('.select2-selection__rendered').append($selections);
  };

  return MultipleSelection;
});


text:
// Copyright (C) Pash Contributors. License: GPL/BSD. See https://github.com/Pash-Project/Pash/
using System;
using System.Collections.Generic;
using System.Management.Automation;

namespace System.Management.Automation.Language
{
    public class MemberExpressionAst : ExpressionAst
    {
        public MemberExpressionAst(IScriptExtent extent, ExpressionAst expression, CommandElementAst member, bool @static)
            : base(extent)
        {
            this.Expression = expression;
            this.Member = member;
            this.Static = @static;
        }

        public ExpressionAst Expression { get; private set; }
        public CommandElementAst Member { get; private set; }
        public bool Static { get; private set; }

        internal override IEnumerable<Ast> Children
        {
            get
            {
                yield return this.Expression;
                yield return this.Member;
                foreach (var item in base.Children) yield return item;
            }
        }

        public override string ToString()
        {
            return string.Format("{0}{1}{2}", this.Expression, this.Static ? "::" : ".", this.Member);
        }
    }
}


text: emrun --browser firefox ./bin/web/$1.html


text:
function [m1 x1a rhoi_star lpb] = gen_improper_modulator_function(fm,fc,rdi,phi,L,fs)
% *************************************************************************
% The MIT License (MIT)
%
% Copyright (c) 2015 Scott Wisdom and Greg Okopal
%
% Permission is hereby granted, free of charge, to any person obtaining a copy
% of this software and associated documentation files (the "Software"), to deal
% in the Software without restriction, including without limitation the rights
% to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
% copies of the Software, and to permit persons to whom the Software is
% furnished to do so, subject to the following conditions:
%
% The above copyright notice and this permission notice shall be included in
% all copies or substantial portions of the Software.
%
% THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
% AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
% OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
% THE SOFTWARE.
% *************************************************************************
n = (0:(L-1));
N  = 1024;   %order of LPF

if ~isnan(fm)
    lpb = fir1(N,fm/(fs/2));        %filter for signal
    lpb = lpb./sqrt(sum(lpb.^2));
else
    lpb = [];
end

rvar = rdi^2;
ivar = 1;

rhoi_star = (rvar-ivar)/(rvar+ivar)*exp(j*phi)*sign(rvar-ivar); %true noncircularity coeff

mn1 = gen_complex_gaussian(rvar,ivar,phi,L);
if ~isnan(fm)
    m1 = fftfilt(lpb,mn1);
else
    m1 = mn1;
end

fc_off = 0;     %range of support for phase jitter (+/- for uniform dist)
fc_jit_fc = 10;  %cutoff of LPF in Hertz; lower numbers give smoother jitter
lpb_jit = fir1(2*N,fc_jit_fc/(fs/2));        %filter for signal
fc_jito = fc_off.*2.*(rand(1,L)-0.5);
if fc_jit_fc>0
    fc_jit = fftfilt(lpb_jit,fc_jito);
else
    fc_jit = fc_jito;
end

cstar = exp(j*2*pi.*n.*(fc+fc_jit)/fs);
x1a = cstar.*m1;
x1 = real(x1a);

rho1 = (sum(x1a.^2))/sum(abs(x1a).^2);

end


text:
package org.wildfly.swarm.spi.runtime.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.enterprise.util.AnnotationLiteral;
import javax.enterprise.util.Nonbinding;
import javax.inject.Qualifier;

/** Provides for simple runtime configuration of a Fraction.
 *
 * @author Bob McWhirter
 */
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER, ElementType.TYPE})
public @interface ConfigurationValue {
    @Nonbinding String value();

    final class Literal extends AnnotationLiteral<ConfigurationValue> implements ConfigurationValue {

        public static final Literal INSTANCE = new Literal();

        private static final long serialVersionUID = 1L;

        @Nonbinding
        @Override
        public String value() {
            return null;
        }
    }
}


text:
"""
EasyBuild support for foss compiler toolchain (includes GCC, OpenMPI, OpenBLAS, LAPACK, ScaLAPACK and FFTW).

@author: Kenneth Hoste (Ghent University)
"""

from easybuild.toolchains.compiler.gcc import Gcc
from easybuild.toolchains.fft.fftw import Fftw
from easybuild.toolchains.linalg.openblas import OpenBLAS
from easybuild.toolchains.linalg.scalapack import ScaLAPACK
from easybuild.toolchains.mpi.openmpi import OpenMPI

class Foss(Gcc, OpenMPI, OpenBLAS, ScaLAPACK, Fftw):
    """Compiler toolchain with GCC, OpenMPI, OpenBLAS, ScaLAPACK and FFTW."""
    NAME = 'foss'


text:
<?php

declare(strict_types=1);

namespace Tests\Unit\Classes;

use Nette\Application\UI\Presenter;

/**
 * @author Jáchym Toušek <enumag@gmail.com>
 */
class TestPresenter extends Presenter
{
    /**
     * @persistent
     *
     * @var Class1
     */
    public $persistent1;

    /**
     * @persistent
     *
     * @var string
     */
    public $persistent2;

    public function actionTestAction(Class2 $actionEntity): void
    {
    }

    public function renderTestRender(Class3 $renderEntity): void
    {
    }

    public function handleTestHandle(Class4 $handleEntity): void
    {
    }

    public function handleNoTypehintHandle($handleEntity): void
    {
    }

    public function actionNonexistentParameter($entity): void
    {
    }

    protected function createComponentComponent(): TestComponent
    {
    }

    protected function createComponentNonexistentComponent(): NonexistentComponent
    {
    }

    protected function createComponentMissingTypehint()
    {
    }

    protected function createComponentBuiltinTypehint(): int
    {
    }
}


text:
var _ = require('lib/underscore'),
    theme = require('helpers/theme'),
    accounting = require('lib/accounting'),
    APP_CONST = require('business/constants');

function NotificationRow (_args) {
    var item = _args.data,
        self = Ti.UI.createTableViewRow({
            _id: item.id,
            _source_type: item.source_type,
            _source_id: item.source_id,
            height: Ti.UI.SIZE,
            className: 'notificationDetail',
            backgroundColor: item.unread ? '#504086FF' : '#fff'
        });

    var content = '',
        type = null;
    (function () {
        type = _(APP_CONST.DATA.NOTIFICATION_ARRAY).find(function (n) {
            return n.code == item.type;
        });
        var contents = [];
        switch (item.type) {
            case APP_CONST.DATA.NOTIFICATION_TYPE.PROMOTION:
                contents.push(L('promotion_notification'));
                break;
            case APP_CONST.DATA.NOTIFICATION_TYPE.NEW_PRODUCT:
                contents.push(L('new_product_notification'));
                break;
            case APP_CONST.DATA.NOTIFICATION_TYPE.PRICE_CHANGE:
                contents.push(L('price_change_notification'));
                break;
            case APP_CONST.DATA.NOTIFICATION_TYPE.ORDER_CANCEL:
                contents.push(L('order_cancel_notification'));
                break;
            case APP_CONST.DATA.NOTIFICATION_TYPE.ORDER_CONFIRM:
                contents.push(L('order_confirm_notification'));
                break;
        }
        item.full_content.forEach(function (c) {
            if (c.type == 'Money') {
                contents.push('' + accounting.formatMoney(c.value, {symbol: 'VND', format:"%v %s"}) + '');
            } else {
                contents.push('' + c.value + '');
            }
        });
        content = String.format.apply(String, contents);
    })();

    var contentView = Ti.UI.createView({
        touchEnabled: false,
        top: 10,
        bottom: 10,
        width: Ti.UI.FILL,
        height: Ti.UI.SIZE,
        layout: 'horizontal'
    }),
    typeLabel = Ti.UI.createLabel({
        touchEnabled: false,
        text: (type && type.value) ? ('- ' + type.value + ' - ') : '',
        font: {fontWeight: 'bold', fontSize: 28},
        color: '#000'
    }),
    contentLabel = Ti.UI.createLabel({
        touchEnabled: false,
        html: content,
        font: {fontSize: 28},
        color: '#000'
    });

    contentView.add(typeLabel);
    contentView.add(contentLabel);

    self.add(contentView);

    return self;
}

module.exports = NotificationRow;


text:
// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

using Org.Apache.REEF.Network.Group.Pipelining;
using Org.Apache.REEF.Tang.Formats;
using Org.Apache.REEF.Tang.Util;

namespace Org.Apache.REEF.IMRU.API
{
    /// <summary>
    /// A configuration module for The PipelineDataConverter used for chunking
    /// and dechunking TMapInput and TMapOutput
    /// </summary>
    /// <typeparam name="T">Generic type</typeparam>
    public sealed class IMRUPipelineDataConverterConfiguration<T> : ConfigurationModuleBuilder
    {
        /// <summary>
        /// The PipelineDataConverter used for chunking and
        ///  dechunking TMapInput and TMapOutput
        /// </summary>
        public static readonly
            RequiredImpl<IPipelineDataConverter<T>> MapInputPiplelineDataConverter =
                new RequiredImpl<IPipelineDataConverter<T>>();

        /// <summary>
        /// Configuration module
        /// </summary>
        public static ConfigurationModule ConfigurationModule =
            new IMRUPipelineDataConverterConfiguration<T>()
                .BindImplementation(GenericType<IPipelineDataConverter<T>>.Class, MapInputPiplelineDataConverter)
                .Build();
    }
}


text:
(function(api, engine) {
    var pendingAutoSave = false;
    function doAutoSave(result, value) {
        if (!self.autoSave()) {
            result.resolve(value);
            return;
        }

        // This accumulates a first batch of tally calls when more than one stat
        // is getting updated.
        if (!pendingAutoSave) {
            pendingAutoSave = [];
            pendingAutoSave.push([result, value]);
            _.delay(function() {
                var results = pendingAutoSave;
                pendingAutoSave = false;
                self.save()
                    .done(function() {
                        _.forEach(results, function(pair) {
                            pair[0].resolve(pair[1]);
                        });
                    })
                    .fail(function() {
                        _.forEach(results, function(pair) {
                            pair[0].reject();
                        });
                    });
            });
        }
        else
            pendingAutoSave.push([result, value]);
    }

    var self = {
        autoSave: ko.observable(true),
        refresh: function() {
            var result = $.Deferred();
            engine.asyncCall('tally.refresh')
                .fail(function(value) {
                    result.reject(value);
                })
                .done(function() {
                    result.resolve();
                });
            return result.promise();
        },

        save: function() {
            var result = $.Deferred();
            engine.asyncCall('tally.save')
                .fail(function(value) {
                    result.reject(value);
                })
                .done(function() {
                    result.resolve();
                });
            return result.promise();
        },

        getStatInt: function(name) {
            var result = $.Deferred();
            engine.call('tally.getStatInt', name)
                .then(function(value) {
                    if (value !== '')
                        result.resolve(Number(value));
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },
        setStatInt: function(name, value) {
            var result = $.Deferred();
            engine.call('tally.setStatInt', name, value)
                .then(function(succeeded) {
                    if (succeeded)
                        doAutoSave(result, value);
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },
        incStatInt: function(name, adj) {
            var result = $.Deferred();
            if (_.isUndefined(adj))
                adj = 1;
            engine.call('tally.incStatInt', name, adj)
                .then(function(value) {
                    if (value !== '')
                        doAutoSave(result, Number(value));
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },
        getStatFloat: function(name) {
            var result = $.Deferred();
            engine.call('tally.getStatFloat', name)
                .then(function(value) {
                    if (value !== '')
                        doAutoSave(result, Number(value));
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },
        setStatFloat: function(name, value) {
            var result = $.Deferred();
            engine.call('tally.setStatFloat', name, value)
                .then(function(succeeded) {
                    if (succeeded)
                        doAutoSave(result, value);
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },
        incStatFloat: function(name, adj) {
            var result = $.Deferred();
            if (_.isUndefined(adj))
                adj = 1;
            engine.call('tally.incStatFloat', name, adj)
                .then(function(value) {
                    if (value !== '')
                        doAutoSave(result, Number(value));
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },

        updateStatAvg: function(name, value, period) {
            var result = $.Deferred();
            engine.call('tally.updateStatAvg', name, value, period)
                .then(function(succeeded) {
                    if (succeeded)
                        doAutoSave(result);
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        },

        setAchievement: function(name) {
            var result = $.Deferred();
            engine.call('tally.setAchievement', name)
                .then(function(succeeded) {
                    if (succeeded)
                        doAutoSave(result);
                    else
                        result.reject();
                }, function() { result.reject(); });
            return result.promise();
        }
    };

    api.tally = self;
})(window.api, engine);


text:
/*
 * Originally taken from https://github.com/decker405/figwheel-react-native
 *
 * @providesModule figwheel-bridge
 */

var CLOSURE_UNCOMPILED_DEFINES = null;
var debugEnabled = false;

var config = {
    basePath: "target/",
    googBasePath: 'goog/',
    serverPort: 8081
};

var React = require('react');
var ReactNative = require('react-native');
var WebSocket = require('WebSocket');
var self;
var scriptQueue = [];
var serverHost = null; // will be set dynamically
var fileBasePath = null; // will be set dynamically
var evaluate = eval; // This is needed, direct calls to eval does not work (RN packager???)
var externalModules = {};
var evalListeners = [ // Functions to be called after each js file is loaded and evaluated
    function (url) {
        if (url.indexOf('jsloader') > -1) {
            shimJsLoader();
        }
    },
    function (url) {
        if (url.indexOf('/figwheel/client/socket') > -1) {
            setCorrectWebSocketImpl();
        }
    }];

var figwheelApp = function (platform, devHost) {
    return React.createClass({
        getInitialState: function () {
            return {loaded: false}
        },
        render: function () {
            if (!this.state.loaded) {
                var plainStyle = {flex: 1, alignItems: 'center', justifyContent: 'center'};
                return (
                    <ReactNative.View style={plainStyle}>
                        <ReactNative.Text>Waiting for Figwheel to load files.</ReactNative.Text>
                    </ReactNative.View>
                );
            }
            return this.state.root;
        },
        componentDidMount: function () {
            var app = this;
            if (typeof goog === "undefined") {
                loadApp(platform, devHost, function (appRoot) {
                    app.setState({root: appRoot, loaded: true})
                });
            }
        }
    })
};

function logDebug(msg) {
    if (debugEnabled) {
        console.log(msg);
    }
}

// evaluates js code ensuring proper ordering
function customEval(url, javascript, success, error) {
    if (scriptQueue.length > 0) {
        if (scriptQueue[0] === url) {
            try {
                evaluate(javascript);
                logDebug('Evaluated: ' + url);
                scriptQueue.shift();
                evalListeners.forEach(function (listener) {
                    listener(url)
                });
                success();
            } catch (e) {
                console.error(e);
                error();
            }
        } else {
            setTimeout(function () {
                customEval(url, javascript, success, error)
            }, 5);
        }
    } else {
        console.error('Something bad happened...');
        error()
    }
}

var isChrome = function () {
    return typeof importScripts === "function"
};

function asyncImportScripts(url, success, error) {
    logDebug('(asyncImportScripts) Importing: ' + url);
    scriptQueue.push(url);
    fetch(url)
        .then(function (response) {
            return response.text()
        })
        .then(function (responseText) {
            return customEval(url, responseText, success, error);
        })
        .catch(function (error) {
            console.error(error);
            return error();
        });
}

function syncImportScripts(url, success, error) {
    try {
        importScripts(url);
        logDebug('Evaluated: ' + url);
        evalListeners.forEach(function (listener) {
            listener(url)
        });
        success();
    } catch (e) {
        console.error(e);
        error()
    }
}

// Loads js file sync if possible or async.
function importJs(src, success, error) {
    if (typeof success !== 'function') {
        success = function () {
        };
    }
    if (typeof error !== 'function') {
        error = function () {
        };
    }

    var file = fileBasePath + '/' + src;

    logDebug('(importJs) Importing: ' + file);
    if (isChrome()) {
        syncImportScripts(serverBaseUrl("localhost") + '/' + file, success, error);
    } else {
        asyncImportScripts(serverBaseUrl(serverHost) + '/' + file, success, error);
    }
}

function interceptRequire() {
    var oldRequire = window.require;
    console.info("Shimming require");
    window.require = function (id) {
        console.info("Requiring: " + id);
        if (externalModules[id]) {
            return externalModules[id];
        }
        return oldRequire(id);
    };
}

function compileWarningsToYellowBox() {
    var log = window.console.log;
    var compileWarningRx = /Figwheel: Compile/;
    window.console.log = function (msg) {
        if (compileWarningRx.test(msg)) {
            console.warn(msg);
        } else {
            log.apply(window.console, arguments);
        }
    };
}

function serverBaseUrl(host) {
    return "http://" + host + ":" + config.serverPort
}

function setCorrectWebSocketImpl() {
    figwheel.client.socket.get_websocket_imp = function () {
        return WebSocket;
    };
}

function loadApp(platform, devHost, onLoadCb) {
    serverHost = devHost;
    fileBasePath = config.basePath + platform;

    // callback when app is ready to get the reloadable component
    var mainJs = '/env/' + platform + '/main.js';
    evalListeners.push(function (url) {
        if (url.indexOf(mainJs) > -1) {
            onLoadCb(env[platform].main.root_el);
            console.info('Done loading Clojure app');
        }
    });

    if (typeof goog === "undefined") {
        console.info('Loading Closure base.');
        interceptRequire();
        compileWarningsToYellowBox();
        importJs('goog/base.js', function () {
            shimBaseGoog();
            importJs('cljs_deps.js');
            importJs('goog/deps.js', function () {
                // This is needed because of RN packager
                // seriously React packager? why.
                var googreq = goog.require;

                googreq('figwheel.connect');
            });
        });
    }
}

function startApp(appName, platform, devHost) {
    ReactNative.AppRegistry.registerComponent(
        appName, () => figwheelApp(platform, devHost));
}

function withModules(moduleById) {
    externalModules = moduleById;
    return self;
}

// Goog fixes
function shimBaseGoog() {
    console.info('Shimming goog functions.');
    goog.basePath = 'goog/';
    goog.writeScriptSrcNode = importJs;
    goog.writeScriptTag_ = function (src, optSourceText) {
        importJs(src);
        return true;
    };
}

// Figwheel fixes
// Used by figwheel - uses importScript to load JS rather than <script>'s
function shimJsLoader() {
    console.info('==== Shimming jsloader ====');
    goog.net.jsloader.load = function (uri, options) {
        var deferred = {
            callbacks: [],
            errbacks: [],
            addCallback: function (cb) {
                deferred.callbacks.push(cb);
            },
            addErrback: function (cb) {
                deferred.errbacks.push(cb);
            },
            callAllCallbacks: function () {
                while (deferred.callbacks.length > 0) {
                    deferred.callbacks.shift()();
                }
            },
            callAllErrbacks: function () {
                while (deferred.errbacks.length > 0) {
                    deferred.errbacks.shift()();
                }
            }
        };

        // Figwheel needs this to be an async call,
        //    so that it can add callbacks to deferred
        setTimeout(function () {
            importJs(uri.getPath(),
                deferred.callAllCallbacks,
                deferred.callAllErrbacks);
        }, 1);

        return deferred;
    };
}

self = {
    withModules: withModules,
    start: startApp
};

module.exports = self;


text:
<?php defined('BASEPATH') OR exit('No direct script access allowed');
###################################################################
##
##	Dashboard Module
##	Version: 1.23
##
##	Last Edit:
##	July 12 2015
##
##	Description:
##	Provide Various Quick Controls - Widgets
##
##	Author:
##	By Shawn Purdy
##
##	Comments:
##
##
##################################################################
class Dashboard extends ADMIN_Controller {

	function __construct()
		{
		parent::__construct();
		#Helpers
		$this->load->helper('form');
		$this->load->helper('file');
		$this->load->library('image_moo');

		#Models
		$this->load->model('dashboard_model');
		$this->load->model('blog_admin/blog_admin_model');
		$this->load->model('page_admin/page_admin_model');
		$this->load->model('widget_admin/widget_admin_model');
		$this->load->model('log_admin/log_admin_model');
		$this->load->model('menu_admin/menu_admin_model');

		#Helpers
		$this->load->helper('date');
		$this->load->helper('directory');

		#Configuration
		$this->load->config('blog_config');
		$this->load->config('analytics');

		#Load Module User Protection
		$check_perm = $this->backend_model->protect_module();
		$this->data['module_read'] = 'N';
		$this->data['module_write'] = 'N';
		$this->data['module_delete'] = 'N';
		$check_perm = $this->backend_model->get_module_permissions();
		if($check_perm->result())
			{
			foreach($check_perm->result() as $pm)
				{
				$this->data['module_read'] = $pm->read;
				$this->data['module_write'] = $pm->write;
				$this->data['module_delete'] = $pm->delete;
				}
			}
		else
			{
			$this->data['module_read'] = 'N';
			$this->data['module_write'] = 'N';
			$this->data['module_delete'] = 'N';
			}
		}

	function index()
		{
		if($this->data['module_read'] == 'Y' OR $this->ion_auth->is_admin())
			{
			$this->data['heading'] = $this->lang->line('label_dashboard');
			$this->data['template_path'] = $this->config->item('template_admin_page');
			$this->data['protect_module'] = $this->backend_model->protect_module();
			$this->data['page'] = $this->data['template_path'] . '/dashboard/dashboard_view';
			$this->data['flashmsg'] = $this->session->flashdata('flashmsg');
			$this->load->vars($this->data);
			$this->load->view($this->_container);
			}
		else
			{
			echo "access denied";
			}
		}

	function analytics()
		{
		if($this->data['module_read'] == 'Y' OR $this->ion_auth->is_admin())
			{
			//User Information
			$ga_email = $this->config->item('username');
			$ga_password = $this->config->item('password');
			$ga_profile_id = $this->config->item('profile_id'); //'50151742';

			//Library
			$this->load->library('gapi');

			//Login
			$ga = $this->gapi->login($ga_email,$ga_password);

			//metrics
			$dimensions = array('date');
			$metrics = array('pageviews','visits','visitors','visitBounceRate');
			$sort_metric = array('date');
			$filter = null;
			$start_date = $this->config->item('start_date');//'2005-01-01';
			$end_date = date('Y-m-d');
			$start_index = 1;
			$max_results = 10000000;

			//Request Data
			$this->gapi->requestReportData($ga_profile_id,$dimensions,$metrics,$sort_metric,$filter,$start_date,$end_date,$start_index,$max_results);

			$data['heading'] = 'Analytics';
			$data['result'] = $this->gapi->getResults();
			$template_path = $this->config->item('template_admin_page');
			$this->load->view($template_path . '/dashboard/stats', $data);
			}
		else
			{
			echo "access denied";
			}
		}

	function stat_by_month_year()
		{
		if($this->data['module_read'] == 'Y' OR $this->ion_auth->is_admin())
			{
			$month_year = $this->uri->segment(3);

			//User Information
			$ga_email = $this->config->item('username');
			$ga_password = $this->config->item('password');
			$ga_profile_id = $this->config->item('profile_id'); //'50151742';

			//Library
			$this->load->library('gapi');

			//Login
			$ga = $this->gapi->login($ga_email,$ga_password);

			//metrics
			$dimensions = array('date');
			$metrics = array('pageviews','visits','visitors','visitBounceRate');
			$sort_metric = array('date');
			$filter = null;
			$start_date = $month_year;//'2005-01-01';
			$end_date = date("Y-m-t", strtotime($start_date));
			$start_index = 1;
			$max_results = 10000000;

			//Request Data
			$this->gapi->requestReportData($ga_profile_id,$dimensions,$metrics,$sort_metric,$filter,$start_date,$end_date,$start_index,$max_results);
			$data['heading'] = 'Analytics';
			$data['result'] = $this->gapi->getResults();
			$template_path = $this->config->item('template_admin_page');
			$this->load->view($template_path . '/dashboard/stats_by_month', $data);
			}
		else
			{
			echo "access denied";
			}
		}

	function add_page()
		{
		if($this->data['module_write'] == 'Y' OR $this->ion_auth->is_admin())
			{
			$this->form_validation->set_message('required', 'The Field %s is Required');
			$this->form_validation->set_rules('name', 'name', 'xss_clean|required');
			$this->form_validation->set_rules('text2', 'text2', 'required');
			$this->form_validation->set_rules('container_name', 'container_name', 'xss_clean');
			$this->form_validation->set_rules('meta_desc', 'meta_desc', 'xss_clean');
			$this->form_validation->set_rules('meta_keywords', 'meta_keywords', 'xss_clean');
			$this->form_validation->set_rules('slide_id', 'slide_id', 'xss_clean');
			$this->form_validation->set_rules('side_top', 'side_top', 'xss_clean');
			$this->form_validation->set_rules('side_bottom', 'side_bottom', 'xss_clean');
			$this->form_validation->set_rules('content_top', 'content_top', 'xss_clean');
			$this->form_validation->set_rules('content_bottom', 'content_bottom', 'xss_clean');
			$this->form_validation->set_rules('lang', 'lang', 'xss_clean');
			$this->form_validation->set_rules('hide', 'hide', 'xss_clean');
			$this->form_validation->set_rules('draft', 'draft', 'xss_clean');
			$this->form_validation->set_error_delimiters('
', '
');
			if($this->form_validation->run() == FALSE)
				{
				$data['heading'] = 'Add Page';
				$template_path = $this->config->item('template_admin_page');
				$data['containers'] = $this->page_admin_model->get_containers();
				$data['get_slideshow'] = $this->page_admin_model->get_slideshow();
				$data['w_locations'] = $this->widget_admin_model->get_widget_locations();
				$data['groups'] = $this->page_admin_model->get_groups();
				$data['langs'] = $this->page_admin_model->get_langs();
				if(!isset($_POST['name']))
					{
					$this->load->view($template_path . '/dashboard/addpage', $data);
					}
				else
					{
					$data['page'] = $template_path . '/dashboard/addpage';
					$this->load->vars($data);
					$this->load->view($this->_container);
					}
				}
			else
				{
				#Check if the page will be saved as a draft or not
				if($this->input->post('draft') == 'Y')
					{
					#hidden page draft.
					$this->page_admin_model->page_insert_draft();
					$msg = $this->lang->line('added');
					$this->session->set_flashdata('flashmsg', $msg);
					redirect('dashboard');
					}
				else
					{
					#Live Publicly viewable
					$this->dashboard_model->page_insert();
					$page_id = $this->db->insert_id();
					$w_locations = $this->widget_admin_model->get_widget_locations();
					foreach($w_locations->result() as $wl)
						{
						$loc = $wl->id;

						if($this->input->post($wl->name) == '0')
							{
							$this->widget_admin_model->delete_page_exist($loc, $page_id);
							}
						else
							{
							$group_id = $_POST[$wl->name];
							$this->widget_admin_model->delete_page_exist($loc, $page_id);
							$this->widget_admin_model->insert_page_widgets($loc, $page_id, $group_id);
							}
						}
					$msg = $this->lang->line('added');
					$this->session->set_flashdata('flashmsg', $msg);
					redirect('dashboard');
					}
				}
			}
		else
			{
			echo "access denied";
			}
		}

	function add_news()
		{
		if($this->data['module_write'] == 'Y' OR $this->ion_auth->is_admin())
			{
			$this->form_validation->set_message('required', 'The Field %s is Required');
			$this->form_validation->set_rules('name', 'name', 'xss_clean|required');
			$this->form_validation->set_rules('text', 'text', 'required');
			$this->form_validation->set_rules('add_image', 'add_image', 'xss_clean');
			$this->form_validation->set_rules('userfile', 'userfile', 'xss_clean');
			$this->form_validation->set_rules('lang', 'lang', 'xss_clean');
			$this->form_validation->set_rules('gallery_display', 'gallery_display', 'xss_clean');
			$this->form_validation->set_rules('gallery_id', 'gallery_id', 'xss_clean');
			$this->form_validation->set_rules('active', 'active', 'xss_clean');
			$this->form_validation->set_error_delimiters('
', '
');
			if($this->form_validation->run($this) == FALSE)
				{
				$data['heading'] = $this->lang->line('new_blog_post');
				$template_path = $this->config->item('template_admin_page');
				$data['get_galleries'] = $this->blog_admin_model->get_galleries();
				$data['tags'] = $this->blog_admin_model->get_tags();
				$data['langs'] = $this->blog_admin_model->get_langs();

				if(!isset($_POST['add_image']))
					{
					$this->load->view($template_path . '/dashboard/blog_new_post', $data);
					}
				else
					{
					$data['page'] = $template_path . '/dashboard/blog_new_post';
					$this->load->vars($data);
					$this->load->view($this->_container);
					}
				}
			else
				{
				if($this->input->post('add_image') == 'Y')
					{
					#Upload file
					$config['upload_path'] = './assets/news/';
					$config['allowed_types'] = $this->config->item('global_filetypes');
					$config['max_size']	= $this->config->item('global_upload_limit');
					$config['max_width']  = $this->config->item('global_upload_maxwidth');
					$config['max_height']  = $this->config->item('global_upload_maxheight');
					$this->load->library('upload', $config);
					if(!$this->upload->do_upload())
						{
						redirect('dashboard/#tabs-2');
						}
					else
						{
						$data = array('upload_data' => $this->upload->data());
						$updatea = $this->upload->data();

						$thumb_path = 'assets/news/thumbs/' . $data['upload_data']['file_name'];
						$small_path = 'assets/news/small/' . $data['upload_data']['file_name'];
						$medium_path = 'assets/news/medium/' . $data['upload_data']['file_name'];
						$normal_path = 'assets/news/normal/' . $data['upload_data']['file_name'];

						//Create Thumbnail
						$this->image_moo
							->load($updatea['full_path'])
							->set_jpeg_quality($this->config->item('blog_thumbnail_quality'))
							->resize_crop($this->config->item('blog_thumbnail_maxwidth'),$this->config->item('blog_thumbnail_maxheight'))
							->save($thumb_path, TRUE);

						//Create Normal Size
						$this->image_moo
							->load($updatea['full_path'])
							->set_jpeg_quality($this->config->item('blog_normal_quality'))
							->resize_crop($this->config->item('blog_normal_maxwidth'),$this->config->item('blog_normal_maxheight'))
							->save($normal_path, TRUE);

						//Create Medium Size
						$this->image_moo
							->load($updatea['full_path'])
							->set_jpeg_quality($this->config->item('blog_medium_quality'))
							->resize_crop($this->config->item('blog_medium_maxwidth'),$this->config->item('blog_medium_maxheight'))
							->save($medium_path, TRUE);

						//Create Small Size
						$this->image_moo
							->load($updatea['full_path'])
							->set_jpeg_quality($this->config->item('blog_small_quality'))
							->resize_crop($this->config->item('blog_small_maxwidth'),$this->config->item('blog_small_maxheight'))
							->save($small_path, TRUE);

						$userfile = $data['upload_data']['file_name'];
						$this->blog_admin_model->blog_insert($userfile);
						$post_id = $this->db->insert_id();
						if($this->input->post('tags') == '')
							{
							}
							else
							{
							for($i = 0; $i < count($_POST['tags']); $i++)
								{
								$new_tag = $_POST['tags'][$i];
								$this->blog_admin_model->import_category($new_tag, $post_id);
								}
							}
						$this->load->dbutil();
						$this->dbutil->optimize_table('blog');
						$msg = $this->lang->line('added');
						$this->session->set_flashdata('flashmsg', $msg);
						redirect('dashboard');
						}
					}
				else
					{
					$userfile = '';
					$this->blog_admin_model->blog_insert($userfile);
					$post_id = $this->db->insert_id();
					if($this->input->post('tags') == '')
						{
						}
						else
						{
						for($i = 0; $i < count($_POST['tags']); $i++)
							{
							$new_tag = $_POST['tags'][$i];
							$this->blog_admin_model->import_category($new_tag, $post_id);
							}
						}
					$this->load->dbutil();
					$this->dbutil->optimize_table('blog');
					$msg = $this->lang->line('added');
					$this->session->set_flashdata('flashmsg', $msg);
					redirect('dashboard');
					}
				}
			}
		else
			{
			echo "access denied";
			}
		}

	function latest_comments()
		{
		if($this->data['module_read'] == 'Y' OR $this->ion_auth->is_admin())
			{
			$data['show_comments'] = $this->dashboard_model->show_comments();
			$data['heading'] = $this->lang->line('manage_blog_comments');
			$data['template_path'] = $this->config->item('template_admin_page');
			$this->load->view($data['template_path'] . '/dashboard/comment_list', $data);
			}
		else
			{
			echo "access denied";
			}
		}

	function spam_log()
		{
		if($this->data['module_read'] == 'Y' OR $this->ion_auth->is_admin())
			{
			$data['template_path'] = $this->config->item('template_admin_page');
			$data['query'] = $this->log_admin_model->spam_log();
			$data['flashmsg'] = $this->session->flashdata('flashmsg');
			$this->load->view($data['template_path'] . '/dashboard/spam_log', $data);
			}
		else
			{
			echo "access denied";
			}
		}

	function widget_locations()
		{
		}

	function updates()
		{
		$this->data['heading'] = 'Change Log';
		$this->data['template_path'] = $this->config->item('template_admin_page');
		$this->data['page'] = $this->data['template_path'] . '/dashboard/updates';
		$this->load->vars($this->data);
		$this->load->view($this->_container);
		}
}


text:
<?php

/**
 *	\file       htdocs/admin/stock.php
 *	\ingroup    stock
 *	\brief      Page d'administration/configuration du module gestion de stock
 *	\version    $Id: stock.php,v 1.23 2010/07/11 19:29:18 eldy Exp $
 */
require("../main.inc.php");
require_once(DOL_DOCUMENT_ROOT."/lib/admin.lib.php");

$langs->load("admin");
$langs->load("stocks");

// Securit check
if (!$user->admin)
accessforbidden();

/*
 * Actions
 */

if ($_POST["action"] == 'STOCK_USERSTOCK_AUTOCREATE')
{
	dolibarr_set_const($db, "STOCK_USERSTOCK_AUTOCREATE", $_POST["STOCK_USERSTOCK_AUTOCREATE"],'chaine',0,'',$conf->entity);
	Header("Location: stock.php");
	exit;
}
// Mode of stock decrease
if ($_POST["action"] == 'STOCK_CALCULATE_ON_BILL'
|| $_POST["action"] == 'STOCK_CALCULATE_ON_VALIDATE_ORDER'
|| $_POST["action"] == 'STOCK_CALCULATE_ON_SHIPMENT')
{
	$count=0;
	$db->begin();
	$count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_BILL", '','chaine',0,'',$conf->entity);
	$count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_VALIDATE_ORDER", '','chaine',0,'',$conf->entity);
	$count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SHIPMENT", '','chaine',0,'',$conf->entity);
	if ($_POST["action"] == 'STOCK_CALCULATE_ON_BILL')           $count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_BILL", $_POST["STOCK_CALCULATE_ON_BILL"],'chaine',0,'',$conf->entity);
	if ($_POST["action"] == 'STOCK_CALCULATE_ON_VALIDATE_ORDER') $count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_VALIDATE_ORDER", $_POST["STOCK_CALCULATE_ON_VALIDATE_ORDER"],'chaine',0,'',$conf->entity);
	if ($_POST["action"] == 'STOCK_CALCULATE_ON_SHIPMENT')       $count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SHIPMENT", $_POST["STOCK_CALCULATE_ON_SHIPMENT"],'chaine',0,'',$conf->entity);
	if ($count == 4)
	{
		$db->commit();
		Header("Location: stock.php");
		exit;
	}
	else
	{
		$db->rollback();
		dol_print_error("Error in some requests", LOG_ERR);
	}
}
// Mode of stock increase
if ($_POST["action"] == 'STOCK_CALCULATE_ON_SUPPLIER_BILL'
|| $_POST["action"] == 'STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER'
|| $_POST["action"] == 'STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER')
{
	$count=0;
	$db->begin();
	$count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SUPPLIER_BILL", '','chaine',0,'',$conf->entity);
	$count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER", '','chaine',0,'',$conf->entity);
	$count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER", '','chaine',0,'',$conf->entity);
	if ($_POST["action"] == 'STOCK_CALCULATE_ON_SUPPLIER_BILL')           $count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SUPPLIER_BILL", $_POST["STOCK_CALCULATE_ON_SUPPLIER_BILL"],'chaine',0,'',$conf->entity);
	if ($_POST["action"] == 'STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER') $count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER", $_POST["STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER"],'chaine',0,'',$conf->entity);
	if ($_POST["action"] == 'STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER') $count+=dolibarr_set_const($db, "STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER", $_POST["STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER"],'chaine',0,'',$conf->entity);
	if ($count == 4)
	{
		$db->commit();
		Header("Location: stock.php");
		exit;
	}
	else
	{
		$db->rollback();
		dol_print_error("Error in some requests", LOG_ERR);
	}
}

/*
 * View
 */

llxHeader('',$langs->trans("StockSetup"));

$linkback=''.$langs->trans("BackToModuleList").'';
print_fiche_titre($langs->trans("StockSetup"),$linkback,'setup');
print '
';

$html=new Form($db);
$var=true;
print '
';

print '
';
print "  ".$langs->trans("Parameters")."	\n";
print "  ".$langs->trans("Value")."	\n";
print '
'."\n";

/*
 * Formulaire parametres divers
 */

$var=!$var;

print "
";
print ''.$langs->trans("UserWarehouseAutoCreate").'	';

print '';
print "<form method=\"post\" action=\"stock.php\">";
print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
print "<input type=\"hidden\" name=\"action\" value=\"STOCK_USERSTOCK_AUTOCREATE\">";
print $html->selectyesno("STOCK_USERSTOCK_AUTOCREATE",$conf->global->STOCK_USERSTOCK_AUTOCREATE,1);
print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
print '</form>';
print "	\n";
print "
\n";

// Title rule for stock decrease
print '
';
print "  ".$langs->trans("RuleForStockManagementDecrease")."	\n";
print "  ".$langs->trans("Value")."	\n";
print '
'."\n";
$var=true;

if ($conf->facture->enabled)
{
	$var=!$var;
	print "
";
	print ''.$langs->trans("DeStockOnBill").'	';
	print '';
	print "<form method=\"post\" action=\"stock.php\">";
	print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
	print "<input type=\"hidden\" name=\"action\" value=\"STOCK_CALCULATE_ON_BILL\">";
	print $html->selectyesno("STOCK_CALCULATE_ON_BILL",$conf->global->STOCK_CALCULATE_ON_BILL,1);
	print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
	print "</form>\n	\n
\n";
}

if ($conf->commande->enabled)
{
	$var=!$var;
	print "
";
	print ''.$langs->trans("DeStockOnValidateOrder").'	';
	print '';
	print "<form method=\"post\" action=\"stock.php\">";
	print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
	print "<input type=\"hidden\" name=\"action\" value=\"STOCK_CALCULATE_ON_VALIDATE_ORDER\">";
	print $html->selectyesno("STOCK_CALCULATE_ON_VALIDATE_ORDER",$conf->global->STOCK_CALCULATE_ON_VALIDATE_ORDER,1);
	print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
	print "</form>\n	\n
\n";
}

if ($conf->expedition->enabled)
{
	$var=!$var;
	print "
";
	print ''.$langs->trans("DeStockOnShipment").'	';
	print '';
	print "<form method=\"post\" action=\"stock.php\">";
	print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
	print "<input type=\"hidden\" name=\"action\" value=\"STOCK_CALCULATE_ON_SHIPMENT\">";
	print $html->selectyesno("STOCK_CALCULATE_ON_SHIPMENT",$conf->global->STOCK_CALCULATE_ON_SHIPMENT,1);
	print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
	print "</form>\n	\n
\n";
}

// Title rule for stock increase
print '
';
print "  ".$langs->trans("RuleForStockManagementIncrease")."	\n";
print "  ".$langs->trans("Value")."	\n";
print '
'."\n";
$var=true;

if ($conf->fournisseur->enabled)
{
	$var=!$var;
	print "
";
	print ''.$langs->trans("ReStockOnBill").'	';
	print '';
	print "<form method=\"post\" action=\"stock.php\">";
	print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
	print "<input type=\"hidden\" name=\"action\" value=\"STOCK_CALCULATE_ON_SUPPLIER_BILL\">";
	print $html->selectyesno("STOCK_CALCULATE_ON_SUPPLIER_BILL",$conf->global->STOCK_CALCULATE_ON_SUPPLIER_BILL,1);
	print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
	print "</form>\n	\n
\n";
}

if ($conf->fournisseur->enabled)
{
	$var=!$var;
	print "
";
	print ''.$langs->trans("ReStockOnValidateOrder").'	';
	print '';
	print "<form method=\"post\" action=\"stock.php\">";
	print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
	print "<input type=\"hidden\" name=\"action\" value=\"STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER\">";
	print $html->selectyesno("STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER",$conf->global->STOCK_CALCULATE_ON_SUPPLIER_VALIDATE_ORDER,1);
	print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
	print "</form>\n	\n
\n";
}
if ($conf->fournisseur->enabled)
{
	$var=!$var;
	print "
";
	print ''.$langs->trans("ReStockOnDispatchOrder").'	';
	print '';
	print "<form method=\"post\" action=\"stock.php\">";
	print '<input type="hidden" name="token" value="'.$_SESSION['newtoken'].'">';
	print "<input type=\"hidden\" name=\"action\" value=\"STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER\">";
	print $html->selectyesno("STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER",$conf->global->STOCK_CALCULATE_ON_SUPPLIER_DISPATCH_ORDER,1);
	print '<input type="submit" class="button" value="'.$langs->trans("Modify").'">';
	print "</form>\n	\n
\n";
}

print '
';
$db->close();

llxFooter('$Date: 2010/07/11 19:29:18 $ - $Revision: 1.23 $');
?>


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

     Copyright 2005-2016 Red Hat, Inc.

     Red Hat licenses this file to you under the Apache License, version
     2.0 (the "License"); you may not use this file except in compliance
     with the License.  You may obtain a copy of the License at

        http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
     implied.  See the License for the specific language governing
     permissions and limitations under the License.

-->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>io.fabric8</groupId>
    <artifactId>components</artifactId>
    <version>2.2-SNAPSHOT</version>
  </parent>

  <groupId>io.fabric8</groupId>
  <artifactId>jolokia-assertions</artifactId>
  <packaging>bundle</packaging>

  <name>Fabric8 :: Jolokia :: Assertions</name>

  <properties>
  </properties>

  <dependencies>
    <dependency>
      <groupId>org.jolokia</groupId>
      <artifactId>jolokia-client-java</artifactId>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
    </dependency>
    <dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
    </dependency>
    <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
    </dependency>

    <!-- testing -->
    <dependency>
      <groupId>org.jolokia</groupId>
      <artifactId>jolokia-jvm</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>io.fabric8</groupId>
      <artifactId>kubernetes-jolokia</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.codehaus.mojo</groupId>
        <artifactId>exec-maven-plugin</artifactId>
        <version>${exec-maven-plugin.version}</version>
        <executions>
          <execution>
            <goals>
              <goal>java</goal>
            </goals>
          </execution>
        </executions>
        <configuration>
          <mainClass>io.fabric8.jolokia.assertions.Example</mainClass>
          <classpathScope>test</classpathScope>
        </configuration>
      </plugin>

    </plugins>
  </build>

</project>


text:
package dev.niekirk.com.instagram4android.requests.payload;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.RequiredArgsConstructor;
import lombok.Setter;

/**
 * Created by root on 24/09/17.
 */

@Getter
@Setter
@AllArgsConstructor
@RequiredArgsConstructor
public class InstagramUserStoryFeedResult {

    public InstagramBroadcast broadcast;
    public InstagramReel reel;
    public InstagramPostLiveItem post_live_item;

}


text:
function [ISD QR] = mainHourly(yearStart, yearEnd, months, percentiles, varname, stationList, ...
	timesToSample, timeForQR, runNumber, nIntervals, njitter, nboot)

% Sample hourly data at different measurement times and determine effect on QR slopes,
% as compared to the warming / variability signal

% user needs to fill these in
csvDir = ''; % location of csv files with ISD data
cacheDir = '';
figDir = '';

fid = fopen(stationList);
headers = textscan(fid, '%q', 11, 'delimiter', ',');
vals = textscan(fid, '%d %d %s %s %s %s %f %f %f %d %d', 'delimiter', ',');
fclose(fid);
allUSAF = reshape(sprintf('%06d', vals{1}),[6 length(vals{1})])';
allWBAN = reshape(sprintf('%05d', vals{2}),[5 length(vals{2})])';

startInd = 1;

opts.yearStart = yearStart;
opts.yearEnd = yearEnd;
opts.csvDir = csvDir;
opts.cacheDir = cacheDir;
opts.startInd = startInd;
opts.months = months;

% sample hourly data at two different times
% (will take a long time if not previously calculated)

[ISD] = sampleHourlyWrapper(allUSAF, allWBAN, timesToSample, runNumber, nIntervals, opts);

ISD0 = ISD;

% subselect one obs time for the rest of the analysis
ISD.TMAX = squeeze(ISD0.TMAX(:, timesToSample == timeForQR, :));
ISD.TMIN = squeeze(ISD0.TMIN(:, timesToSample == timeForQR, :));

ISD = doQC(ISD, months, varname);

% Do QR
QR = QRwrapper(ISD, varname, nIntervals, months, runNumber, percentiles, ...
	njitter, cacheDir, nboot);

return


text:
{% load flatcontent_tags markup_tags %}

{% flatcontent test-content-all-elements with var1='extra' var2='ctx1' for-site 1 as ctx1 %}
{{ ctx1|apply_markup:"textile" }}
{% flatcontent test-content-all-elements for-site 1 with var1='extra' var2='ctx2' as ctx2 %}
{{ ctx2|apply_markup:"textile" }}
{% flatcontent test-content-all-elements for-site 1 as ctx3 with var1='extra' var2='ctx3' %}
{{ ctx3|apply_markup:"textile" }}


text:
({

    doInit : function( component, event, helper ) {

        helper.getIdeaList( component, {}, function() {

        });

    },

    getIdeaList : function( component, event, helper ) {

        var ideaListOptions = {
            filter : event.getParam( "filter" ),
            sort : event.getParam( "sort" )
        };

        component.set( "v.filter", ideaListOptions.filter );

        helper.getIdeaList( component, ideaListOptions, function() {

        });

    }

})


text:
layout: default-app
---

{% include themes/index.html %}


text:
/*PLEASE DO NOT EDIT THIS CODE*/
/*This code was generated using the UMPLE 1.21.0.4666 modeling language!*/

// line 41 "PingPong.ump"
public class Atomic
{

  //------------------------
  // MEMBER VARIABLES
  //------------------------

  //Atomic Attributes
  private Component1 cmp1;
  private Component2 cmp2;
  private int startValue;

  //------------------------
  // CONSTRUCTOR
  //------------------------

  public Atomic(Component1 aCmp1, Component2 aCmp2, int aStartValue)
  {
    cmp1 = aCmp1;
    cmp2 = aCmp2;
    startValue = aStartValue;
    // line 46 "PingPong.ump"
    cmp1->pIn1(startValue);
  }

  //------------------------
  // INTERFACE
  //------------------------

  public boolean setCmp1(Component1 aCmp1)
  {
    boolean wasSet = false;
    cmp1 = aCmp1;
    wasSet = true;
    return wasSet;
  }

  public boolean setCmp2(Component2 aCmp2)
  {
    boolean wasSet = false;
    cmp2 = aCmp2;
    wasSet = true;
    return wasSet;
  }

  public boolean setStartValue(int aStartValue)
  {
    boolean wasSet = false;
    startValue = aStartValue;
    wasSet = true;
    return wasSet;
  }

  public Component1 getCmp1()
  {
    return cmp1;
  }

  public Component2 getCmp2()
  {
    return cmp2;
  }

  public int getStartValue()
  {
    return startValue;
  }

  public void delete()
  {}

  public String toString()
  {
	  String outputString = "";
    return super.toString() + "["+
            "startValue" + ":" + getStartValue()+ "]" + System.getProperties().getProperty("line.separator") +
            "  " + "cmp1" + "=" + (getCmp1() != null ? !getCmp1().equals(this)  ? getCmp1().toString().replaceAll("  ","    ") : "this" : "null") + System.getProperties().getProperty("line.separator") +
            "  " + "cmp2" + "=" + (getCmp2() != null ? !getCmp2().equals(this)  ? getCmp2().toString().replaceAll("  ","    ") : "this" : "null")
     + outputString;
  }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Bull. Soc. mycol. Fr. 30: 217 (1914)

#### Original name
Clavariella cedretorum Maire

### Remarks
null


text:
import { equalizeWhitespace, escapeRegExp, id } from 'src/utils';

import * as regexFactory from './regexFactory';
import { type Token, TokenType } from './token';

export const WHITESPACE_REGEX = /^(\s+)/u;
const NULL_REGEX = /(?!)/; // zero-width negative lookahead, matches nothing

const toCanonicalKeyword = (text: string) => equalizeWhitespace(text.toUpperCase());

/** Struct that defines how a SQL language can be broken into tokens */
interface TokenizerOptions {
  reservedKeywords: string[];
  reservedCommands: string[];
  reservedLogicalOperators?: string[];
  reservedDependentClauses: string[];
  reservedBinaryCommands: string[];
  reservedJoinConditions?: string[];
  stringTypes: regexFactory.StringPatternType[];
  blockStart?: string[];
  blockEnd?: string[];
  indexedPlaceholderTypes?: string[];
  namedPlaceholderTypes?: string[];
  lineCommentTypes?: string[];
  specialWordChars?: { prefix?: string; any?: string; suffix?: string };
  operators?: string[];
  preprocess?: (tokens: Token[]) => Token[];
}

/** Converts SQL language string into a token stream */
export default class Tokenizer {
  REGEX_MAP: { [tokenType in TokenType]: RegExp };

  INDEXED_PLACEHOLDER_REGEX?: RegExp;
  IDENT_NAMED_PLACEHOLDER_REGEX?: RegExp;
  STRING_NAMED_PLACEHOLDER_REGEX?: RegExp;

  private preprocess = (tokens: Token[]) => tokens;

  /**
   * @param {TokenizerOptions} cfg
   *  @param {string[]} cfg.reservedKeywords - Reserved words in SQL
   *  @param {string[]} cfg.reservedDependentClauses - Words that following a specific Statement and must have data attached
   *  @param {string[]} cfg.reservedLogicalOperators - Words that are set to newline
   *  @param {string[]} cfg.reservedCommands - Words that are set to new line separately
   *  @param {string[]} cfg.reservedBinaryCommands - Words that are top level but have no indentation
   *  @param {string[]} cfg.reservedJoinConditions - ON and USING
   *  @param {string[]} cfg.stringTypes - string types to enable - "", '', ``, [], N''
   *  @param {string[]} cfg.blockStart - Opening parentheses to enable, like (, [
   *  @param {string[]} cfg.blockEnd - Closing parentheses to enable, like ), ]
   *  @param {string[]} cfg.indexedPlaceholderTypes - Prefixes for indexed placeholders, like ?
   *  @param {string[]} cfg.namedPlaceholderTypes - Prefixes for named placeholders, like @ and :
   *  @param {string[]} cfg.lineCommentTypes - Line comments to enable, like # and --
   *  @param {string[]} cfg.specialWordChars - Special chars that can be found inside of words, like @ and #
   *  @param {string[]} cfg.operators - Additional operators to recognize
   *  @param {Function} cfg.preprocess - Optional function to process tokens before emitting
   */
  constructor(cfg: TokenizerOptions) {
    if (cfg.preprocess) {
      this.preprocess = cfg.preprocess;
    }

    const specialWordCharsAll = Object.values(cfg.specialWordChars ?? {}).join('');
    this.REGEX_MAP = {
      [TokenType.WORD]: regexFactory.createWordRegex(cfg.specialWordChars),
      [TokenType.STRING]: regexFactory.createStringRegex(cfg.stringTypes),
      [TokenType.RESERVED_KEYWORD]: regexFactory.createReservedWordRegex(
        cfg.reservedKeywords,
        specialWordCharsAll
      ),
      [TokenType.RESERVED_DEPENDENT_CLAUSE]: regexFactory.createReservedWordRegex(
        cfg.reservedDependentClauses ?? [],
        specialWordCharsAll
      ),
      [TokenType.RESERVED_LOGICAL_OPERATOR]: regexFactory.createReservedWordRegex(
        cfg.reservedLogicalOperators ?? ['AND', 'OR'],
        specialWordCharsAll
      ),
      [TokenType.RESERVED_COMMAND]: regexFactory.createReservedWordRegex(
        cfg.reservedCommands,
        specialWordCharsAll
      ),
      [TokenType.RESERVED_BINARY_COMMAND]: regexFactory.createReservedWordRegex(
        cfg.reservedBinaryCommands,
        specialWordCharsAll
      ),
      [TokenType.RESERVED_JOIN_CONDITION]: regexFactory.createReservedWordRegex(
        cfg.reservedJoinConditions ?? ['ON', 'USING'],
        specialWordCharsAll
      ),
      [TokenType.OPERATOR]: regexFactory.createOperatorRegex('+-/*%&|^><=.,;[]{}`:$@', [
        '<>',
        '<=',
        '>=',
        '!=',
        ...(cfg.operators ?? []),
      ]),
      [TokenType.BLOCK_START]: regexFactory.createParenRegex(cfg.blockStart ?? ['(']),
      [TokenType.BLOCK_END]: regexFactory.createParenRegex(cfg.blockEnd ?? [')']),
      [TokenType.RESERVED_CASE_START]: /^(CASE)\b/iu,
      [TokenType.RESERVED_CASE_END]: /^(END)\b/iu,
      [TokenType.LINE_COMMENT]: regexFactory.createLineCommentRegex(cfg.lineCommentTypes ?? ['--']),
      [TokenType.BLOCK_COMMENT]: /^(\/\*[^]*?(?:\*\/|$))/u,
      [TokenType.NUMBER]:
        /^(0x[0-9a-fA-F]+|0b[01]+|(-\s*)?[0-9]+(\.[0-9]*)?([eE][-+]?[0-9]+(\.[0-9]+)?)?)/u,
      [TokenType.PLACEHOLDER]: NULL_REGEX, // matches nothing
      [TokenType.EOF]: NULL_REGEX, // matches nothing
    };

    this.INDEXED_PLACEHOLDER_REGEX = regexFactory.createPlaceholderRegex(
      cfg.indexedPlaceholderTypes ?? [],
      '[0-9]*'
    );
    this.IDENT_NAMED_PLACEHOLDER_REGEX = regexFactory.createPlaceholderRegex(
      cfg.namedPlaceholderTypes ?? [],
      '[a-zA-Z0-9._$]+'
    );
    this.STRING_NAMED_PLACEHOLDER_REGEX = regexFactory.createPlaceholderRegex(
      cfg.namedPlaceholderTypes ?? [],
      regexFactory.createStringPattern(cfg.stringTypes)
    );
  }

  /**
   * Takes a SQL string and breaks it into tokens.
   * Each token is an object with type and value.
   *
   * @param {string} input - The SQL string
   * @returns {Token[]} output token stream
   */
  tokenize(input: string): Token[] {
    const tokens: Token[] = [];
    let token: Token | undefined;

    // Keep processing the string until it is empty
    while (input.length) {
      // grab any preceding whitespace
      const whitespaceBefore = this.getWhitespace(input);
      input = input.substring(whitespaceBefore.length);

      if (input.length) {
        // Get the next token and the token type
        token = this.getNextToken(input, token);
        if (!token) {
          throw new Error(`Parse error: Unexpected "${input.slice(0, 100)}"`);
        }
        // Advance the string
        input = input.substring(token.text.length);

        tokens.push({ ...token, whitespaceBefore });
      }
    }
    return this.preprocess(tokens);
  }

  /** Matches preceding whitespace if present */
  getWhitespace(input: string): string {
    const matches = input.match(WHITESPACE_REGEX);
    return matches ? matches[1] : '';
  }

  /** Curried function of `getTokenOnFirstMatch` that allows token type to be passed first */
  matchToken =
    (tokenType: TokenType) =>
    (input: string): Token | undefined =>
      this.getTokenOnFirstMatch({
        input,
        type: tokenType,
        regex: this.REGEX_MAP[tokenType],
        transform: id,
      });

  /** Attempts to match next token from input string, tests RegExp patterns in decreasing priority */
  getNextToken(input: string, previousToken?: Token): Token | undefined {
    return (
      this.matchToken(TokenType.LINE_COMMENT)(input) ||
      this.matchToken(TokenType.BLOCK_COMMENT)(input) ||
      this.matchToken(TokenType.STRING)(input) ||
      this.matchToken(TokenType.BLOCK_START)(input) ||
      this.matchToken(TokenType.BLOCK_END)(input) ||
      this.getPlaceholderToken(input) ||
      this.matchToken(TokenType.NUMBER)(input) ||
      this.getReservedWordToken(input, previousToken) ||
      this.matchToken(TokenType.WORD)(input) ||
      this.matchToken(TokenType.OPERATOR)(input)
    );
  }

  /**
   * Attempts to match a placeholder token pattern
   * @return {Token | undefined} - The placeholder token if found, otherwise undefined
   */
  getPlaceholderToken(input: string): Token | undefined {
    const placeholderTokenRegexMap: { regex: RegExp; parseKey: (s: string) => string }[] = [
      // pattern for placeholder with identifier name
      {
        regex: this.IDENT_NAMED_PLACEHOLDER_REGEX ?? NULL_REGEX,
        parseKey: v => v.slice(1),
      },
      // pattern for placeholder with string name
      {
        regex: this.STRING_NAMED_PLACEHOLDER_REGEX ?? NULL_REGEX,
        parseKey: v =>
          this.getEscapedPlaceholderKey({ key: v.slice(2, -1), quoteChar: v.slice(-1) }),
      },
      // pattern for placeholder with numeric index
      {
        regex: this.INDEXED_PLACEHOLDER_REGEX ?? NULL_REGEX,
        parseKey: v => v.slice(1),
      },
    ];

    return placeholderTokenRegexMap.reduce((acc, { regex, parseKey }) => {
      const token = this.getTokenOnFirstMatch({
        input,
        regex,
        type: TokenType.PLACEHOLDER,
        transform: id,
      });
      return token ? { ...token, key: parseKey(token.value) } : acc;
    }, undefined as Token | undefined);
  }

  getEscapedPlaceholderKey({ key, quoteChar }: { key: string; quoteChar: string }): string {
    return key.replace(new RegExp(escapeRegExp('\\' + quoteChar), 'gu'), quoteChar);
  }

  /**
   * Attempts to match a Reserved word token pattern, avoiding edge cases of Reserved words within string tokens
   * @return {Token | undefined} - The Reserved word token if found, otherwise undefined
   */
  getReservedWordToken(input: string, previousToken?: Token): Token | undefined {
    // A reserved word cannot be preceded by a '.'
    // this makes it so in "mytable.from", "from" is not considered a reserved word
    if (previousToken?.value === '.') {
      return undefined;
    }

    // prioritised list of Reserved token types
    const reservedTokenList = [
      TokenType.RESERVED_CASE_START,
      TokenType.RESERVED_CASE_END,
      TokenType.RESERVED_COMMAND,
      TokenType.RESERVED_BINARY_COMMAND,
      TokenType.RESERVED_DEPENDENT_CLAUSE,
      TokenType.RESERVED_LOGICAL_OPERATOR,
      TokenType.RESERVED_KEYWORD,
      TokenType.RESERVED_JOIN_CONDITION,
    ];

    return reservedTokenList.reduce(
      (matchedToken: Token | undefined, tokenType) =>
        matchedToken ||
        this.getTokenOnFirstMatch({
          input,
          type: tokenType,
          regex: this.REGEX_MAP[tokenType],
          transform: toCanonicalKeyword,
        }),
      undefined
    );
  }

  /**
   * Attempts to match RegExp from head of input, returning undefined if not found
   * @param {string} _.input - The string to match
   * @param {TokenType} _.type - The type of token to match against
   * @param {RegExp} _.regex - The regex to match
   * @return {Token | undefined} - The matched token if found, otherwise undefined
   */
  getTokenOnFirstMatch({
    input,
    type,
    regex,
    transform,
  }: {
    input: string;
    type: TokenType;
    regex: RegExp;
    transform: (s: string) => string;
  }): Token | undefined {
    const matches = input.match(regex);
    if (matches) {
      return {
        type,
        text: matches[1],
        value: transform(matches[1]),
      };
    }
    return undefined;
  }
}


text:
using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Cci;

namespace VBSourceEmitter {
  public partial class SourceEmitter : CodeTraverser, IVBSourceEmitter {
    public new void Traverse(IEnumerable<IGenericTypeParameter> genericParameters) {
      PrintToken(VBToken.LeftAngleBracket);

      bool fFirstParameter = true;
      foreach (IGenericTypeParameter genericTypeParameter in genericParameters) {
        if (!fFirstParameter)
          PrintGenericTypeParametersListDelimiter();

        this.Traverse(genericTypeParameter);

        fFirstParameter = false;
      }

      PrintToken(VBToken.RightAngleBracket);
    }

    public new void Traverse(IEnumerable<IGenericMethodParameter> genericParameters) {
      PrintToken(VBToken.LeftAngleBracket);

      bool fFirstParameter = true;
      foreach (IGenericMethodParameter genericMethodParameter in genericParameters) {
        if (!fFirstParameter)
          PrintGenericTypeParametersListDelimiter();

        this.Traverse(genericMethodParameter);

        fFirstParameter = false;
      }

      PrintToken(VBToken.RightAngleBracket);
    }

    public virtual void PrintGenericTypeParametersListDelimiter() {
      PrintToken(VBToken.Comma);
      PrintToken(VBToken.Space);
    }

  }
}


text:
/*
 * @file	generic/zynqmp_r5/sys.c
 * @brief	machine specific system primitives implementation.
 */

#include <metal/compiler.h>
#include <metal/io.h>
#include <metal/sys.h>
#include <stdint.h>
#include "xil_cache.h"
#include "xil_exception.h"
#include "xil_mmu.h"
#include "xil_mpu.h"
#include "xreg_cortexr5.h"
#include "xscugic.h"

#define MPU_REGION_SIZE_MIN 0x20

void sys_irq_restore_enable(unsigned int flags)
{
	Xil_ExceptionEnableMask(~flags);
}

unsigned int sys_irq_save_disable(void)
{
	unsigned int state = mfcpsr() & XIL_EXCEPTION_ALL;

	if (XIL_EXCEPTION_ALL != state) {
		Xil_ExceptionDisableMask(XIL_EXCEPTION_ALL);
	}
	return state;
}

void metal_machine_cache_flush(void *addr, unsigned int len)
{
	if (!addr && !len)
		Xil_DCacheFlush();
	else
		Xil_DCacheFlushRange((intptr_t)addr, len);
}

void metal_machine_cache_invalidate(void *addr, unsigned int len)
{
	if (!addr && !len)
		Xil_DCacheInvalidate();
	else
		Xil_DCacheInvalidateRange((intptr_t)addr, len);
}

/**
 * @brief poll function until some event happens
 */
void metal_weak metal_generic_default_poll(void)
{
	asm volatile("wfi");
}

void *metal_machine_io_mem_map(void *va, metal_phys_addr_t pa,
			       size_t size, unsigned int flags)
{
	size_t rsize = MPU_REGION_SIZE_MIN;
	metal_phys_addr_t base_pa;

	if (!flags)
		return va;
	while(1) {
		if (rsize < size) {
			rsize <<= 1;
			continue;
		} else {
			base_pa = pa & ~(rsize - 1);
			if ((base_pa + rsize) < (pa + size)) {
				rsize <<= 1;
				continue;
			}
			break;
		}
	}
	Xil_SetMPURegion(base_pa, rsize, flags);
	return va;
}


text:
{{ csrf_field() }}

    {{ trans('alpaca::redirect.from') }}*
    <input type="text" class="form-control" id="from" name="from" placeholder="/old/path"
           value="{{ old('from', isset($redirect) ? $redirect->from : '') }}" required>

    {{ trans('alpaca::redirect.to') }}*
    <input type="text" class="form-control" id="to" name="to" placeholder="/new/path"
           value="{{ old('to', isset($redirect) ? $redirect->to : '') }}" required>

    {{ trans('alpaca::redirect.code') }}*
    <input type="text" class="form-control" id="code" name="code"
           value="{{ old('code', isset($redirect) ? $redirect->code : '301') }}" required>
    301, "Moved Permanently"—recommended for SEO

        302, "Found" or "Moved Temporarily"

<button type="submit" class="btn btn-info btn-block">{{ trans('alpaca::alpaca.save') }}</button>


text:
class DropVersions < ActiveRecord::Migration
  def up
    remove_index :versions, [:item_type, :item_id]
    drop_table :versions
  end

  def down
    create_table :versions do |t|
      t.string   :item_type, :null => false
      t.integer  :item_id,   :null => false
      t.string   :event,     :null => false
      t.string   :whodunnit
      t.text     :object
      t.datetime :created_at
    end
    add_index :versions, [:item_type, :item_id]
  end
end


text:
<?php
require_once("models/config.php");
$query = $_GET['id'];
if ($query) {
    $context  = stream_context_create(array('http' => array('header' => 'Accept: application/xml')));
    $api = '/rest/v1/device/';
    $url = $dc_base_url . $api . $query;

    $device = file_get_contents($url, false, $context);
    $device = simplexml_load_string($device);

    if (IsNullOrEmptyString($device->device_id)) {
        header("Location: error.php");
        die();
    }

    // Convert created_on timestamp to a date
    if (!IsNullOrEmptyString($device->created_on)) {
        $timeCreatedOn = strtotime($device->created_on);
        $dateCreatedOn = date('F jS Y \a\t g:ia', $timeCreatedOn);
    }

    // Convert checked_out_date timestamp to a date
    if (!IsNullOrEmptyString($device->checked_out_date)) {
        $timeCheckedOut = strtotime($device->checked_out_date);
        $dateCheckedOut = date('F jS Y \a\t g:ia', $timeCheckedOut);
    }

    // Create a path to an image asset
    if (!IsNullOrEmptyString($device->image_path)) {
        $imgPath = "images/uploads/" . $device->image_path;
    }
} else {
    header("Location: error.php");
    die();
}
function IsNullOrEmptyString($str){
    return (!isset($str) || trim($str)==='');
}
?>

<!DOCTYPE html>

    <title>DeviceGenie - <?=($device->device_id)?></title>
    <link rel="stylesheet" type="text/css" href="genie.css">

    </style>

    <?php include 'navbar-search.php'; ?>

<?=($device->device_id)?($device->device_id):'N/A';?>

                    <?php if ($imgPath && file_exists($imgPath)): ?>
                        <img src="<?=$imgPath;?>" class="section-body-image" alt="<?=$device->device_id;?>"/>
                    <?php else: ?>
                        <img src="images/default.png" class="section-body-image" alt="<?=$device->device_id;?>"/>
                    <?php endif; ?>

Status: <?=($device->available == 'true')?'Available':'Not Available';?>

Device: <?=$device->manufacturer;?> <?=$device->model;?> <?=$device->model_version;?>

OS Version: <?=$device->os_type;?> <?=$device->os_version;?>

Type: <?=$device->type;?>

Location: <?=$device->location;?>

Managed By: <?=$device->manager_dept;?>

Dev Provisioned: <?=($device->dev_provisioned == 'true')?'Yes':'No';?>

                    <?php if ($device->available == 'true'): ?>
                        <a class="green-button" href="checkout.php?id=<?=$device->device_id;?>">Checkout
                        Available
                    <?php else: ?>
                        <?php if (isUserLoggedIn() && $loggedInUser->username == $device->checked_out_to): ?>
                            <a class="red-button-short" href="checkin.php?id=<?=$device->device_id;?>">Checkinv
                            Device is checked out to you

Add a note to this checkin:

                                <form action="checkin.php" method="get">
                                    <input type="hidden" name="id" value="<?=$device->device_id;?>">

<input class="search" type="text" name="note" placeholder="wifi problem, etc"><input class="green-button-small" type="submit" value="Checkin">

                                </form>

                        <?php else: ?>
                            Unavailable
                            Loaned To: <?=$device->checked_out_to;?>
                        <?php endif; ?>
                    <?php endif; ?>

Details

History

UDID: <?=($device->udid && strlen(trim($device->udid)) > 0)?($device->udid):'N/A';?>

Carrier: <?=($device->carrier && strlen(trim($device->carrier)) > 0)?($device->carrier):'N/A';?>

Phone Number: <?=($device->phone_number && strlen(trim($device->phone_number)) > 0)?($device->phone_number):'N/A';?>

Jailbroken: <?=($device->jailbroken == 'true')?'Yes':'No';?>

Notes: <?=($device->note && strlen(trim($device->note)) > 0)?($device->note):'N/A';?>

Last Checked Out: <?=($dateCheckedOut)?($dateCheckedOut):'N/A';?>

Checked Out Count: <?=$device->checked_out_count;?>

Device Added: <?=($dateCreatedOn)?($dateCreatedOn):'N/A';?>

                    Recent History:

                        <?php foreach($device->recent_activity[0] as $activity): ?>
                        <?php
                        if (!IsNullOrEmptyString($activity['created_on'])) {
                            $activityCreatedOn = strtotime($activity['created_on']);
                            $activityDate = date('F jS Y g:ia', $activityCreatedOn);
                        }
                        ?>

                                <?= $activityDate; ?> - <?= $activity['type']; ?> by <?= $activity['user']; ?>
                                <?php if (!IsNullOrEmptyString($activity['note'])): ?>
                                    with note '<?= $activity['note']; ?>'
                                <?php endif; ?>

                        <?php endforeach; ?>

    <?php include 'footer.php'; ?>