text:
var hoverZoomPlugins = hoverZoomPlugins || [];
hoverZoomPlugins.push({
    name:'artstation.com',
    version:'0.1',

    prepareImgLinks: function (callback) {
        const res = [];

        hoverZoom.urlReplace(res,
            'img[src*="artstation"]',
            /(\/[^0-9]*\/\d+\/\d+\/\d+\/)(\d+\/)?(small|smaller_square|small_square|micro_square|medium|medium_wide|default)\//,
            '$1large/',
            'a.project-image'
        );

        callback($(res));
    }
});


text:
@interface NRingProgressControlViewController ()
@property (weak, nonatomic) IBOutlet NRingProgressControl *NRPCtrl;

@end

@implementation NRingProgressControlViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
	// Do any additional setup after loading the view, typically from a nib.

    _NRPCtrl.progress = .65f;
}

- (IBAction)runProgress:(id)sender {
    [_NRPCtrl animateProgress:_NRPCtrl.progress];
}

- (void)didReceiveMemoryWarning
{
    [super didReceiveMemoryWarning];
    // Dispose of any resources that can be recreated.
}

@end

redpajama_set_name: RedPajamaGithub


text:
from unittest import mock

from mitmproxy.addons import browser
from mitmproxy.test import taddons

def test_browser(caplog):
    caplog.set_level("INFO")
    with mock.patch("subprocess.Popen") as po, mock.patch("shutil.which") as which, taddons.context():
        which.return_value = "chrome"
        b = browser.Browser()
        b.start()
        assert po.called

        b.start()
        assert "Starting additional browser" in caplog.text
        assert len(b.browser) == 2
        b.done()
        assert not b.browser

async def test_no_browser(caplog):
    caplog.set_level("INFO")
    with mock.patch("shutil.which") as which:
        which.return_value = False

        b = browser.Browser()
        b.start()
        assert "platform is not supported" in caplog.text

async def test_get_browser_cmd_executable():
    with mock.patch("shutil.which") as which:
        which.side_effect = lambda cmd: cmd == "chrome"
        assert browser.get_browser_cmd() == ["chrome"]

async def test_get_browser_cmd_no_executable():
    with mock.patch("shutil.which") as which:
        which.return_value = False
        assert browser.get_browser_cmd() is None

async def test_get_browser_cmd_flatpak():
    def subprocess_run_mock(cmd, **kwargs):
        returncode = 0 if cmd == ["flatpak", "info", "com.google.Chrome"] else 1
        return mock.Mock(returncode=returncode)

    with mock.patch("shutil.which") as which, mock.patch(
        "subprocess.run"
    ) as subprocess_run:
        which.side_effect = lambda cmd: cmd == "flatpak"
        subprocess_run.side_effect = subprocess_run_mock
        assert browser.get_browser_cmd() == [
            "flatpak",
            "run",
            "-p",
            "com.google.Chrome",
        ]

async def test_get_browser_cmd_no_flatpak():
    with mock.patch("shutil.which") as which, mock.patch(
        "subprocess.run"
    ) as subprocess_run:
        which.side_effect = lambda cmd: cmd == "flatpak"
        subprocess_run.return_value = mock.Mock(returncode=1)
        assert browser.get_browser_cmd() is None


text:
"""Example: scikits.statsmodels.OLS
"""

from scikits.statsmodels.datasets.longley import load
import scikits.statsmodels.api as sm
from scikits.statsmodels.iolib.table import (SimpleTable, default_txt_fmt,
                        default_latex_fmt, default_html_fmt)
import numpy as np

data = load()

data_orig = (data.endog.copy(), data.exog.copy())

#Note: In this example using zscored/standardized variables has no effect on
#   regression estimates. Are there no numerical problems?

rescale = 0
#0: no rescaling, 1:demean, 2:standardize, 3:standardize and transform back
rescale_ratio = data.endog.std()/data.exog.std(0)
if rescale > 0:
    # rescaling
    data.endog -= data.endog.mean()
    data.exog -= data.exog.mean(0)
if rescale > 1:
    data.endog *= 1./data.endog.std()
    #data.exog *= 1000./data.exog.var(0)
    data.exog /= data.exog.std(0)
    #rescale_ratio = data.exog.var(0)/data.endog.var()

#skip because mean has been removed, but dimension is hardcoded in table
data.exog = sm.tools.add_constant(data.exog)

ols_model = sm.OLS(data.endog, data.exog)
ols_results = ols_model.fit()

# the Longley dataset is well known to have high multicollinearity
# one way to find the condition number is as follows

#Find OLS parameters for model with one explanatory variable dropped

resparams = np.nan * np.ones((7,7))
res =  sm.OLS(data.endog, data.exog).fit()
resparams[:,0] = res.params

indall = range(7)
for i in range(6):
    ind = indall[:]
    del ind[i]
    res =  sm.OLS(data.endog, data.exog[:,ind]).fit()
    resparams[ind,i+1] = res.params

if rescale == 1:
    pass
if rescale == 3:
    resparams[:-1,:] *= rescale_ratio[:,None]

txt_fmt1 = default_txt_fmt
numformat = '%10.4f'
txt_fmt1 = dict(data_fmts = [numformat])
rowstubs = data.names[1:] + ['const']
headers = ['all'] + ['drop %s' % name for name in data.names[1:]]
tabl = SimpleTable(resparams, headers, rowstubs, txt_fmt=txt_fmt1)

nanstring = numformat%np.nan
nn = len(nanstring)
nanrep = ' '*(nn-1)
nanrep = nanrep[:nn//2] + '-' + nanrep[nn//2:]

print 'Longley data - sensitivity to dropping an explanatory variable'
#print tabl
print str(tabl).replace(nanstring, nanrep)


text:
<?php

/* PgGsbFraisBundle:SuivieFrais:suivreFrais.html.twig */
class __TwigTemplate_939ac57db95068365a1bd28797fa6b4158412c92b6b968f4064390f80e0e368e extends Twig_Template
{
    public function __construct(Twig_Environment $env)
    {
        parent::__construct($env);

        $this->parent = $this->env->loadTemplate("PgGsbFraisBundle::accueilCompta.html.twig");

        $this->blocks = array(
            'section' => array($this, 'block_section'),
        );
    }

    protected function doGetParent(array $context)
    {
        return "PgGsbFraisBundle::accueilCompta.html.twig";
    }

    protected function doDisplay(array $context, array $blocks = array())
    {
        $this->parent->display($context, array_merge($this->blocks, $blocks));
    }

    // line 2
    public function block_section($context, array $blocks = array())
    {
        // line 3
        echo "
Suivi des frais des utilisateurs

 Mes fiches à traiter

 Mois à sélectionner :

    <form method =\"POST\">

                 Utilisateur :
                <select id=\"lstUtilisateur\" name =\"lstUtilisateur\">
                ";
        // line 13
        $context['_parent'] = (array) $context;
        $context['_seq'] = twig_ensure_traversable((isset($context["lesVisiteurs"]) ? $context["lesVisiteurs"] : $this->getContext($context, "lesVisiteurs")));
        foreach ($context['_seq'] as $context["_key"] => $context["unVisiteur"]) {
            // line 14
            echo "                    <option value =";
            echo twig_escape_filter($this->env, $this->getAttribute((isset($context["unVisiteur"]) ? $context["unVisiteur"] : $this->getContext($context, "unVisiteur")), "id"), "html", null, true);
            echo ">";
            echo twig_escape_filter($this->env, $this->getAttribute((isset($context["unVisiteur"]) ? $context["unVisiteur"] : $this->getContext($context, "unVisiteur")), "nom"), "html", null, true);
            echo " ";
            echo twig_escape_filter($this->env, $this->getAttribute((isset($context["unVisiteur"]) ? $context["unVisiteur"] : $this->getContext($context, "unVisiteur")), "prenom"), "html", null, true);
            echo "</option>
                ";
        }
        $_parent = $context['_parent'];
        unset($context['_seq'], $context['_iterated'], $context['_key'], $context['unVisiteur'], $context['_parent'], $context['loop']);
        $context = array_intersect_key($context, $_parent) + $_parent;
        // line 16
        echo "                </select>

            <input id = \"ok\" class=\"btn btn-success btn-large\" type=\"submit\" value=\"Valider\" name=\"valider\" size = \"20\">
            <input id = \"annuler\" class=\"btn btn-danger btn-large\" type=\"reset\" value=\"Annuler\" name=\"annuler\" size = \"20\">

    </form>

";
    }

    public function getTemplateName()
    {
        return "PgGsbFraisBundle:SuivieFrais:suivreFrais.html.twig";
    }

    public function isTraitable()
    {
        return false;
    }

    public function getDebugInfo()
    {
        return array (  60 => 16,  47 => 14,  43 => 13,  31 => 3,  28 => 2,);
    }
}


text:
require 'test_helper'

class ProjectTest < ActiveSupport::TestCase
  fixtures :projects, :contexts, :todos, :recurring_todos, :users, :preferences

  def setup
    @timemachine = projects(:timemachine)
    @moremoney = projects(:moremoney)
  end

  # associations

  def test_has_default_context
    assert !@timemachine.default_context.nil?
    assert @timemachine.default_context.name == contexts(:lab).name

    p = Project.new
    assert_equal '', p.default_context.name
    p.default_context = contexts(:agenda)
    assert_equal 'agenda', p.default_context.name
  end

  # validations

  def test_validate_presence_of_name
    @timemachine.name = ""
    assert !@timemachine.save
    assert_equal 1, @timemachine.errors.count
    assert_equal "project must have a name", @timemachine.errors[:name][0]
  end

  def test_validate_name_is_less_than_256
    @timemachine.name = generate_random_string(256)
    assert !@timemachine.save
    assert_equal 1, @timemachine.errors.count
    assert_equal "project name must be less than 256 characters", @timemachine.errors[:name][0]
  end

  def test_validate_name_is_unique
    newproj = Project.new
    newproj.name = projects(:timemachine).name
    newproj.user_id = projects(:timemachine).user_id
    assert !newproj.save
    assert_equal 1, newproj.errors.count
    assert_equal "already exists", newproj.errors[:name][0]
  end

  # state machine

  def test_project_initial_state_is_active
    assert_equal :active, @timemachine.aasm.current_state
    assert @timemachine.active?
  end

  def test_hide_project
    @timemachine.hide!
    assert_equal :hidden, @timemachine.aasm.current_state
    assert @timemachine.hidden?
  end

  def test_activate_project
    @timemachine.activate!
    assert_equal :active, @timemachine.aasm.current_state
    assert @timemachine.active?
  end

  def test_transition_to_another_state
    assert_equal :active, @timemachine.aasm.current_state
    @timemachine.transition_to(:hidden)
    assert_equal :hidden, @timemachine.aasm.current_state
    @timemachine.transition_to(:completed)
    assert_equal :completed, @timemachine.aasm.current_state
    @timemachine.transition_to(:active)
    assert_equal :active, @timemachine.aasm.current_state
  end

  def test_transition_to_same_state
    assert_equal :active, @timemachine.aasm.current_state
    @timemachine.transition_to(:active)
    assert_equal :active, @timemachine.aasm.current_state
  end

  # other tests

  def test_review_project
    assert_nil @timemachine.last_reviewed
    assert @timemachine.needs_review?(users(:admin_user))
  end

  def test_review_completedprojects
    @timemachine.complete!
    refute @timemachine.needs_review?(users(:admin_user))
  end

  def test_new_project_is_reviewed
    project = users(:admin_user).projects.create!(:name => "test1")
    refute project.needs_review?(users(:admin_user))
  end

  def test_complete_project
    assert_nil @timemachine.completed_at
    @timemachine.complete!
    assert_equal :completed, @timemachine.aasm.current_state
    assert @timemachine.completed?
    assert_not_nil @timemachine.completed_at, "completed_at not expected to be nil"
    assert_in_delta Time.zone.now, @timemachine.completed_at, 1
  end

  def test_delete_project_deletes_todos_within_it
    assert_equal 3, @timemachine.todos.count
    timemachine_todo_ids = @timemachine.todos.map{ |t| t.id }
    @timemachine.destroy
    timemachine_todo_ids.each do |t_id|
      assert !Todo.exists?(t_id)
    end
  end

  def test_deferred_todos
    assert_equal 1, @timemachine.todos.deferred.size
    t = @timemachine.todos.not_completed[0]
    t.show_from = 1.days.from_now.utc
    t.save!
    assert_equal 2, Project.find(@timemachine.id).todos.deferred.size
  end

  def test_to_param_returns_id
    assert_equal '1', @timemachine.to_param
  end

  def test_null_object
    p = Project.null_object
    assert !p.hidden?
    assert p.nil?
    assert_nil p.id
    assert_equal "", p.name
  end

  def test_name_removes_extra_spaces
    newproj = Project.new
    newproj.name = "These   Words    Have   Proximity        Issues   "
    assert newproj.save
    assert_equal 0, newproj.errors.count
    assert_equal "These Words Have Proximity Issues", newproj.name

    # and on update...
    @timemachine.name = "   a     time machine    needs lots   of      spaaaaaaace         "
    assert @timemachine.save
    assert_equal "a time machine needs lots of spaaaaaaace", @timemachine.name
  end

  def test_deferred_todo_count
    assert_equal 1, @timemachine.todos.deferred.count
    assert_equal 0, @moremoney.todos.deferred.count

    first_todo = @moremoney.todos[0]
    first_todo.show_from = Time.zone.now + 1.week
    first_todo.save!
    assert_equal :deferred, @moremoney.todos[0].aasm.current_state

    assert_equal 1, @moremoney.todos.deferred.count
  end

  def test_done_todo_count
    assert_equal 0, @timemachine.todos.completed.count
    assert_equal 0, @moremoney.todos.completed.count
    @moremoney.todos[0].complete!
    assert_equal 1, @moremoney.todos.completed.count
  end

  def test_not_done_todo_count
    assert_equal 3, @timemachine.todos.not_completed.count
    assert_equal 4, @moremoney.todos.not_completed.count
    @moremoney.todos[0].complete!
    assert_equal 3, @moremoney.todos.not_completed.count
  end

  def test_new_record_before_save
    assert !@timemachine.new_record_before_save?, "existing records should not be new_record"
    p = Project.where(:name => "I do not exist").first_or_create
    assert p.new_record_before_save?, "newly created record should be new_record"
  end

  def test_shortened_name
    s = "project"*7 # len=49
    p = users(:admin_user).projects.create(:name => s)
    assert_equal 49, p.name.length
    assert_equal 40, p.shortened_name.length
    assert_equal "project"*5+"pr...", p.shortened_name

    assert p.shortened_name.html_safe?
  end

  def test_note_count
    p = users(:admin_user).projects.first
    assert_not_nil p

    assert_equal 2, p.note_count

    p.notes.create(:user_id => p.user_id, :body => "new note")

    assert_equal 3, p.note_count
  end

  def test_project_blocked
    p = users(:admin_user).projects.first

    assert !p.blocked?, "first project should not be blocked"

    p.complete!
    assert !p.blocked?, "completed projects should not be blocked"

    p.activate!
    p.todos.each{|t| t.show_from = 2.weeks.from_now; t.save! }
    assert p.blocked?, "projects with deferred todos should be blocked"

    p.todos.first.complete!
    assert p.blocked?, "projects with deferred todo should be blocked even if a completed todo exists"
  end

  def test_project_stalled
    p = users(:admin_user).projects.first

    p.hide!
    assert !p.stalled?, "hidden projects are not stalled"

    p.complete!
    assert !p.stalled?, "completed projects are not stalled"

    p.activate!
    p.todos.each(&:complete!)
    assert p.todos.reload.active.empty?, "project should not have active todos"
    assert p.todos.reload.deferred_or_blocked.empty?, "there should not be deferred or blocked todos"
    assert p.reload.stalled?, "project should be stalled"
  end

  def test_age_in_days
    p1 = users(:admin_user).projects.create!(:name => "test1")
    assert_equal 1, p1.age_in_days, "newly created project has age or one day"

    p2 = users(:admin_user).projects.create!(:name => "test7")
    p2.created_at = 1.week.ago
    p2.save!

    p2.reload
    assert_equal 8, p2.age_in_days
  end

  def test_running_time
    p = users(:admin_user).projects.create!(:name => "test8")
    p.created_at = 1.week.ago
    p.save!

    p.reload
    assert_equal 8, p.running_time

    p.completed_at = 4.days.ago
    p.save!

    p.reload
    assert_equal 4, p.running_time
  end
end


text:
namespace CoQt {
    class FiberPrivatePlatform {
    public:
        boost::coroutines::asymmetric_coroutine<void>::pull_type coroutine;
        boost::coroutines::asymmetric_coroutine<void>::push_type* yield;
    };
}

using namespace CoQt;

void FiberPrivate::init()
{
    platform = new FiberPrivatePlatform();

    quint32 uiStackSize = uiDefaultStackSize;
    if(uiDefaultStackSize == 0)
        uiStackSize = boost::coroutines::stack_traits::default_size();

    platform->yield = NULL;
    platform->coroutine = boost::coroutines::asymmetric_coroutine<void>::pull_type(
                [&](boost::coroutines::asymmetric_coroutine<void>::push_type& sink)
    {
       platform->yield = &sink;
       sink();

       function();

       //set the state to finished, and unregister fiber
       finishFiber();
    }, boost::coroutines::attributes(uiStackSize));
}

void FiberPrivate::cleanup()
{
    delete platform;
    platform = NULL;
}

//Actually yeild the fiber
void FiberPrivate::pauseFiber()
{
    //yield control back to the context that woke us
    (*context()->curFiber()->qxt_d().platform->yield)();
}

void FiberPrivate::wake()
{
    //switch to the fiber
    platform->coroutine();
}


text:
package com.in28minutes.java.oops.inheritance.reuse;

public class TestReuse {
	public static void main(String[] args) {
		Hero hero = new Hero();
		// act method inherited from Actor
		hero.act();// Act
		hero.fight();// fight

		Comedian comedian = new Comedian();
		// act method inherited from Actor
		comedian.act();// Act
		comedian.performComedy();// Comedy

		// Super class reference variable can hold
		// an object of sub class
		Actor actor1 = new Comedian();
		Actor actor2 = new Hero();

		// Object is super class of all java classes
		Object object = new Hero();
	}
}


text:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using NPEG;
using NPEG.Extensions;
using NPEG.GrammarInterpreter;

namespace Shields.Erm
{
    public class ErmParser
    {
        private static readonly Lazy<AExpression> grammar = new Lazy<AExpression>(LoadGrammar);

        private static AExpression Grammar
        {
            get { return grammar.Value; }
        }

        private static AExpression LoadGrammar()
        {
            var assembly = Assembly.GetExecutingAssembly();
            var resourceName = "Shields.Erm.Grammar.txt";
            using (var stream = assembly.GetManifestResourceStream(resourceName))
            using (var reader = new StreamReader(stream))
            {
                string rules = reader.ReadToEnd();
                return PEGrammar.Load(rules);
            }
        }

        public EntityRelationshipModel ParseFile(string ermPath)
        {
            using (var inputStream = File.OpenRead(ermPath))
            {
                var input = File.ReadAllText(ermPath);
                return ParseText(input);
            }
        }

        public EntityRelationshipModel ParseStream(Stream ermStream)
        {
            using (var reader = new StreamReader(ermStream))
            {
                var input = reader.ReadToEnd();
                return ParseText(input);
            }
        }

        public EntityRelationshipModel ParseText(string erm)
        {
            var iterator = new StringInputIterator(erm);
            var visitor = new NpegParserVisitor(iterator);
            Grammar.Accept(visitor);
            if (!visitor.IsMatch
                || visitor.AST.Token.End - visitor.AST.Token.Start + 1 < erm.Length)
            {
                throw new Exception("Failed to parse input file.");
            }
            return EntityRelationshipModel.From(visitor.AST, node => node.Token.ValueAsString(iterator));
        }
    }
}


text:
package org.apache.camel.component.etcd;

import mousio.etcd4j.EtcdClient;
import org.apache.camel.Processor;
import org.apache.camel.support.ScheduledPollConsumer;

/**
 * The etcd consumer.
 */
public abstract class AbstractEtcdPollingConsumer extends ScheduledPollConsumer {
    private EtcdClient client;

    protected AbstractEtcdPollingConsumer(AbstractEtcdPollingEndpoint endpoint, Processor processor) {
        super(endpoint, processor);
        this.client = null;
    }

    @Override
    protected void doStop() throws Exception {
        if (client != null) {
            client.close();
        }

        super.doStop();
    }

    protected EtcdClient getClient() throws Exception {
        if (client == null) {
            client = ((EtcdEndpoint)getEndpoint()).createClient();
        }

        return client;
    }
}


text:
package water.hive;

import org.apache.hadoop.conf.Configuration;
import water.H2O;
import water.init.StandaloneKerberosComponent;

public class HiveComponent implements StandaloneKerberosComponent {

    @Override
    public String name() {
        return "SecuredHive";
    }

    @Override
    public int priority() {
        return 1000;
    }

    @Override
    public boolean initComponent(Object conf, H2O.OptArgs args) {
        return DelegationTokenRefresher.startRefresher((Configuration) conf, args);
    }

}


text:
<!DOCTYPE html>

    <meta charset="UTF-8" />
    <meta name="robots" content="index, follow, all" />
    <title>EventManager\StdEventInterface | Event Manager</title>

            <link rel="stylesheet" type="text/css" href="../css/bootstrap.min.css">
        <link rel="stylesheet" type="text/css" href="../css/bootstrap-theme.min.css">
        <link rel="stylesheet" type="text/css" href="../css/sami.css">

        <meta name="MobileOptimized" content="width">
        <meta name="HandheldFriendly" content="true">
        <meta name="viewport" content="width=device-width,initial-scale=1,maximum-scale=1">

                <form id="search-form" action="../search.html" method="GET">

            <input name="search"
                   class="typeahead form-control"
                   type="search"
                   placeholder="Search">
        </form>

                <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar-elements">
                    Toggle navigation

                </button>
                Event Manager

Classes

Namespaces

Interfaces

Traits

Index

Search

interface

EventManager

StdEventInterface

StdEventInterface

    interface
    StdEventInterface

Interface StdEventInterface

Methods

    void

                    stopPropagation()

No description

    bool

                    isPropagationStopped()

No description

Details

at line 36

    void
    stopPropagation()

Return Value

    void

at line 41

    bool
    isPropagationStopped()

Return Value

    bool

        Generated by Sami, the API Documentation Generator.


text:
This application enables us to create 3D models  from ordinary
archaeological line drawings of vessel profiles. In particular,  it
creates 2D outlines of amphoras (two-handled clay jars used for maritime
transport all across the Mediterranean for thousands of years)  in a step-by-step way that allows them to be automatically converted into 3D models. The results can be used for various kinds of typological modelling, as well as for calculating useful data about an amphora's capacity (how much it could hold), its centre of gravity (when empty or full), points at which it was more likely to break given its shape, and likely behaviour when loaded into the hold of a ship.

This particular application considers Roman amphoras (especially those circulating
in the western Mediterranean during the Roman imperial period) and takes advantage
of an excellent typological resource of line drawings by Penny
Copeland that was created by the University of Southampton
and [archived with the UK Archaeology Data Service](http://archaeologydataservice.ac.uk/archives/view/amphora_ahrb_2005/).

For each scanned drawing of an amphora, we would like people to calibrate the drawing
to establish its correct dimensions, and draw a couple of very simple
lines to assist us with further automatic processing of the scanned line
drawings.

These steps should take no more than a couple of minutes per amphora
in total.

### This project is on behalf of:

[![UCL Institute of Archaeology logo](http://micropasts.org/wp-content/uploads/2014/09/UCL_logo_sm_blk.png)](http://ucl.ac.uk/archaeology)

### Find the code on GitHub

[![](http://micropasts-other.s3.amazonaws.com/other/github_logo.png)](https://github.com/ahb108/HyperAmphsH)


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

<sect1 id="zend.tag.cloud">
    <title>Zend_Tag_Cloud</title>

    <para>
        <classname>Zend_Tag_Cloud</classname> is the rendering part of
        <classname>Zend_Tag</classname>. By default it comes with a set of <acronym>HTML</acronym>
        decorators, which allow you to create tag clouds for a website, but
        also supplies you with two abstract classes to create your own
        decorators, to create tag clouds in <acronym>PDF</acronym> documents for example.
    </para>

    <para>
        You can instantiate and configure <classname>Zend_Tag_Cloud</classname> either
        programatically or completely via an array or an instance of
        <classname>Zend_Config</classname>. The available options are:
    </para>

    <itemizedlist>
        <listitem>
            <para>
                cloudDecorator: defines the decorator for the
                cloud. Can either be the name of the class which should be
                loaded by the pluginloader, an instance of
                <classname>Zend_Tag_Cloud_Decorator_Cloud</classname> or an array
                containing the string decorator and optionally
                an array options, which will be passed to the
                decorators constructor.
            </para>
        </listitem>

        <listitem>
            <para>
                tagDecorator: defines the decorator for individual
                tags. This can either be the name of the class which should be
                loaded by the pluginloader, an instance of
                <classname>Zend_Tag_Cloud_Decorator_Tag</classname> or an array
                containing the string decorator and optionally
                an array options, which will be passed to the
                decorators constructor.
            </para>
        </listitem>

        <listitem>
            <para>
                pluginLoader: a different plugin loader to use.
                Must be an instance of
                <classname>Zend_Loader_PluginLoader_Interface</classname>.
            </para>
        </listitem>

        <listitem>
            <para>
                prefixPath: prefix paths to add to the plugin
                loader. Must be an array containing the keys prefix and path or
                multiple arrays containing the keys prefix and path. Invalid
                elements will be skipped.
            </para>
        </listitem>

        <listitem>
            <para>
                itemList: a different item list to use. Must be an
                instance of <classname>Zend_Tag_ItemList</classname>.
            </para>
        </listitem>

        <listitem>
            <para>
                tags: a list of tags to assign to the cloud. Each
                tag must either implement <classname>Zend_Tag_Taggable</classname> or be
                an array which can be used to instantiate
                <classname>Zend_Tag_Item</classname>.
            </para>
        </listitem>
    </itemizedlist>

    <example id="zend.tag.cloud.example.using">
        <title>Using Zend_Tag_Cloud</title>

        <para>
            This example illustrates a basic example of how to create a tag
            cloud, add multiple tags to it and finally render it.
        </para>

        <programlisting language="php"><![CDATA[
// Create the cloud and assign static tags to it
$cloud = new Zend_Tag_Cloud(array(
    'tags' => array(
        array('title' => 'Code', 'weight' => 50,
              'params' => array('url' => '/tag/code')),
        array('title' => 'Zend Framework', 'weight' => 1,
              'params' => array('url' => '/tag/zend-framework')),
        array('title' => 'PHP', 'weight' => 5,
              'params' => array('url' => '/tag/php')),
    )
));

// Render the cloud
echo $cloud;
]]></programlisting>

        <para>
            This will output the tag cloud with the three tags, spread with
            the default font-sizes.
        </para>
    </example>

    <sect2 id="zend.tag.cloud.decorators">
        <title>Decorators</title>

        <para>
            <classname>Zend_Tag_Cloud</classname> requires two types of decorators to be
            able to render a tag cloud. This includes a decorator which renders
            the single tags as well as a decorator which renders the surounding
            cloud. <classname>Zend_Tag_Cloud</classname> ships a default decorator set for
            formatting a tag cloud in <acronym>HTML</acronym>. This set will by default create a
            tag cloud as ul/li-list, spread with different font-sizes according
            to the weight values of the tags assigned to them.
        </para>

        <sect3 id="zend.tag.cloud.decorators.htmltag">
            <title>HTML Tag decorator</title>

            <para>
                The <acronym>HTML</acronym> tag decorator will by default render every tag in an
                anchor element, surounded by a li element. The anchor itself is
                fixed and cannot be changed, but the surounding element(s) can.
            </para>

            <note>
                <title>URL parameter</title>

                <para>
                    As the <acronym>HTML</acronym> tag decorator always surounds the tag title with
                    an anchor, you should define an <acronym>URL</acronym> parameter for every
                    tag used in it.
                </para>
            </note>

            <para>
                The tag decorator can either spread different font-sizes over
                the anchors or a defined list of classnames. When setting
                options for one of those possibilities, the corespondening one
                will automatically be enabled. The following configuration
                options are available:
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        fontSizeUnit: defines the font-size unit
                        used for all font-sizes. The possible values are:
                        em, ex, px, in, cm, mm, pt, pc and %.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        minFontSize: the minimum font-size
                        distributed through the tags (must be an integer).
                    </para>
                </listitem>

                <listitem>
                    <para>
                        maxFontSize: the maximum font-size
                        distributed through the tags (must be an integer).
                    </para>
                </listitem>

                <listitem>
                    <para>
                        classList: an arry of classes distributed
                        through the tags.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        htmlTags: an array of <acronym>HTML</acronym> tags surounding
                        the anchor. Each element can either be a string, which
                        is used as element type then, or an array containing
                        an attribute list for the element, defined as key/value
                        pair. In this case, the array key is used as element
                        type.
                    </para>
                </listitem>
            </itemizedlist>
        </sect3>

        <sect3 id="zend.tag.cloud.decorators.htmlcloud">
            <title>HTML Cloud decorator</title>

            <para>
                The <acronym>HTML</acronym> cloud decorator will suround the <acronym>HTML</acronym>
                tags with an ul-element by default and add no separation. Like in the tag
                decorator, you can define multiple surounding <acronym>HTML</acronym> tags and
                additionally define a separator. The available options are:
            </para>

            <itemizedlist>
                <listitem>
                    <para>
                        separator: defines the separator which
                        is placed between all tags.
                    </para>
                </listitem>

                <listitem>
                    <para>
                        htmlTags: an array of <acronym>HTML</acronym> tags surounding
                        all tags. Each element can either be a string, which
                        is used as element type then, or an array containing
                        an attribute list for the element, defined as key/value
                        pair. In this case, the array key is used as element type.
                    </para>
                </listitem>
            </itemizedlist>
        </sect3>
    </sect2>
</sect1>


text:
function [waveform, timestep, waveformDuration] = OLWaveformFromName(waveformName,varargin)
% Generate a parameterized waveform from the parameter name
%
% Syntax:
%   waveform = OLWaveformFromName(waveformName)
%   [waveform, timestep, waveformDuration] = OLWaveformFromName(waveformName)
%
% Description:
%    For parameterized waveforms that are stored in
%    OLWaveformParamsDictionary, this function will pull out the parameters
%    and return the actual waveform.
%
% Inputs:
%    waveformName     - String name of a set of parameters for a waveform
%                       stored in OLWaveformParamsDictionary.
%
% Outputs:
%    waveform         - a 1xt rowvector of differentialScalar in range [0,1] at each
%                       timepoint.
%    timestep         - Timestep used to generate waveform
%    waveformDuration - Duration of the total waveform in seconds, at the
%                       given timestep (see above)
%
% Optional key/value pairs:
%    'alternateDictionaryFunc' - String with name of alternate dictionary
%                       function to call. This must be a function on the
%                       path. Default of empty string results in using the
%                       OneLightToolbox dictionary.
%
% Notes:
%    None.
%
% See also:
%    OLWaveformParamsDictionary, OLWaveformFromParams,
%    OLWaveformParamsDefaults, OLWaveformFromParams.

% History:
%    01/30/18  jv  Created as wrapper around OLWaveformFromParams and
%                  OLWaveformParamsDictionary.
%    03/31/18  dhb  Add alternateDictionaryFunc key/value pair.

waveformParams = OLWaveformParamsFromName(waveformName,varargin{:});
[waveform, timestep, waveformDuration] = OLWaveformFromParams(waveformParams);
end


text:
%\documentclass{article}
\documentclass[orivec,dvips,10pt]{llncs}

\usepackage{epsfig}
\usepackage{path}
\usepackage{url}
\usepackage{amsmath,amssymb}

\newenvironment{template}{\sffamily}

\usepackage{graphics,epsfig}
\usepackage{stmaryrd}

\input{macros.ltx}
\input{library.ltx}

\NatPackage

\newcommand{\Ivor}{\textsc{Ivor}}
\newcommand{\Funl}{\textsc{Funl}}
\newcommand{\Agda}{\textsc{Agda}}

\newcommand{\mysubsubsection}[1]{
\noindent
\textbf{#1}
}
\newcommand{\hdecl}[1]{\texttt{#1}}

\begin{document}

\title{\Ivor{}, a Proof Engine}
\author{Edwin Brady}

\institute{School of Computer Science, \\
 University of St Andrews, St Andrews, Scotland. \\ \texttt{Email: eb@cs.st-andrews.ac.uk}.\\
\texttt{Tel: +44-1334-463253}, \texttt{Fax: +44-1334-463278} \vspace{0.1in}
}

\maketitle

\begin{abstract}
Dependent type theory has several practical applications in the fields
of theorem proving, program verification and programming language
design. \Ivor{} is a Haskell library designed to allow easy extending
and embedding of a type theory based theorem prover in a Haskell
application. In this paper, I give an overview of the library and show
how it can be used to embed theorem proving technology in an
implementation of a simple functional programming language; by using
type theory as a core representation, we can construct and evaluate
terms and prove correctness properties of those terms within the
\remph{same} framework, ensuring consistency of the implementation and
the theorem prover.

\end{abstract}

\input{intro}

\input{corett}

%\input{usage}

\input{tactics}

\input{examples}

\input{conclusions}

\section*{Acknowledgements}

My thanks to Kevin Hammond and James McKinna for their comments on an
earlier draft of this paper, and to the anonymous reviewers for their
helpful comments.
This work is generously supported by EPSRC grant EP/C001346/1.

\bibliographystyle{abbrv}
\begin{small}
\bibliography{../bib/literature.bib}

%\appendix

%\input{code}

\end{small}
\end{document}


text:
package org.mates.osb.resources.services;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.mates.osb.export.IExportDirectory;
import org.mates.osb.export.IExportProvider;
import org.mates.osb.reference.IReference;
import org.mates.osb.resources.ExportItem;
import org.mates.osb.resources.ExportProvider;
import org.mates.osb.resources.IResource;
import org.mates.osb.utils.FileUtils;

public abstract class ServiceProvider extends ExportProvider implements IExportProvider {

	public ServiceProvider(IResource resource) {
		super(resource);
	}

	protected abstract String getFilename();

	protected File getTargetFile(IExportDirectory dir) {
		String pathWithoutExtension = getResource().getPath().buildPath("/");
		String stringFilePath = pathWithoutExtension + "." + getReferenceType().name();
		return new File(dir.getExportDir(), stringFilePath);
	}

	protected void createdDirForFile(File file) {
		file.getParentFile().mkdirs();
	}

	@Override
	public void exportTo(IExportDirectory dir) throws IOException {
		File destFile = getTargetFile(dir);
		createdDirForFile(destFile);

		writeSpecificData(destFile);
	}

	protected void writeSpecificData(File destFile) throws IOException {
		FileOutputStream fous = null;
		InputStream source = null;
		try {
			fous = new FileOutputStream(destFile);
			source = getResource().getSource().getInputStream();

			IOUtils.copy(source, fous);
		} finally {
			FileUtils.closeQuietly(fous);
			FileUtils.closeQuietly(source);
		}
	}

	@Override
	public ExportItem getExportItem() {
		ExportItem exportItem = super.getExportItem();
		List<IReference> references = ((Service) getResource()).getReferences();
		for (IReference iReference : references) {
			String value = iReference.getType().toString() + "$" + iReference.getPath().replace('/', '$');
			exportItem.addExtRefs(value);
		}
		return exportItem;
	}
}


text:
<?php
namespace frontend\widgets;

use Yii;
use yii\base\Widget;
use yii\helpers\Html;

class ShippingForm extends Widget
{

    public function run()
    {

        return $this->render('shipping-form');
    }
}


text:
Rails.application.routes.draw do
  root to: "welcome#index"

  mount ExceptionTrack::Engine => "/exception-track"

  get "/:id", to: "welcome#index"
end


text:
package org.sagebionetworks.web.unitclient.widget.entity.tabs;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.util.function.Consumer;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;
import org.sagebionetworks.repo.model.entitybundle.v2.EntityBundle;
import org.sagebionetworks.web.client.GlobalApplicationState;
import org.sagebionetworks.web.client.PortalGinInjector;
import org.sagebionetworks.web.client.cookie.CookieProvider;
import org.sagebionetworks.web.client.jsinterop.EvaluationEditorPageProps;
import org.sagebionetworks.web.client.place.Synapse;
import org.sagebionetworks.web.client.place.Synapse.EntityArea;
import org.sagebionetworks.web.client.security.AuthenticationController;
import org.sagebionetworks.web.client.utils.CallbackP;
import org.sagebionetworks.web.client.widget.entity.menu.v2.ActionMenuWidget;
import org.sagebionetworks.web.client.widget.entity.tabs.ChallengeTab;
import org.sagebionetworks.web.client.widget.entity.tabs.ChallengeTabView;
import org.sagebionetworks.web.client.widget.entity.tabs.Tab;
import org.sagebionetworks.web.client.widget.evaluation.AdministerEvaluationsList;
import org.sagebionetworks.web.client.widget.evaluation.ChallengeWidget;
import org.sagebionetworks.web.client.widget.evaluation.EvaluationEditorReactComponentPage;

import com.google.gwt.junit.GWTMockUtilities;
import com.google.gwt.user.client.ui.Widget;

public class ChallengeTabTest {
	@Mock
	Tab mockTab;
	@Mock
	ChallengeTabView mockView;
	@Mock
	CallbackP<Tab> mockOnClickCallback;
	@Mock
	AdministerEvaluationsList mockAdministerEvaluationsList;
	@Mock
	ChallengeWidget mockChallengeWidget;
	@Mock
	PortalGinInjector mockPortalGinInjector;
	@Mock
	EntityBundle mockProjectEntityBundle;
	@Mock
	ActionMenuWidget mockActionMenuWidget;
	@Mock
	CookieProvider mockCookieProvider;
	ChallengeTab tab;
	@Mock
	AuthenticationController mockAuthenticationController;
	@Mock
	GlobalApplicationState mockGlobalApplicationState;
	@Mock
	EvaluationEditorReactComponentPage mockEvaluationEditorReactComponentPage;
	@Captor
	ArgumentCaptor<Consumer<String>> consumerCaptor;
	@Captor
	ArgumentCaptor<EvaluationEditorPageProps.Callback> callbackCaptor;

	@Before
	public void setUp() {
		// The evaluation editor page does not have abstraction for all UIObjects, so we must disarm (to avoid GWT.create()) until this is fixed
		GWTMockUtilities.disarm();
		MockitoAnnotations.initMocks(this);
		tab = new ChallengeTab(mockTab, mockPortalGinInjector , mockAuthenticationController, mockGlobalApplicationState, mockCookieProvider);
		when(mockTab.getEntityActionMenu()).thenReturn(mockActionMenuWidget);
		when(mockPortalGinInjector.getChallengeTabView()).thenReturn(mockView);
		when(mockPortalGinInjector.getAdministerEvaluationsList()).thenReturn(mockAdministerEvaluationsList);
		when(mockPortalGinInjector.getChallengeWidget()).thenReturn(mockChallengeWidget);
		when(mockPortalGinInjector.createEvaluationEditorReactComponentPage()).thenReturn(mockEvaluationEditorReactComponentPage);
		tab.lazyInject();
	}

	@After
	public void after() {
		GWTMockUtilities.restore();
	}

	@Test
	public void testConstruction() {
		verify(mockView).setEvaluationList(any(Widget.class));
		verify(mockView).setChallengeWidget(any(Widget.class));
	}

	@Test
	public void testSetTabClickedCallback() {
		tab.setTabClickedCallback(mockOnClickCallback);
		verify(mockTab).addTabClickedCallback(mockOnClickCallback);
	}

	@Test
	public void testConfigure() {
		String entityId = "syn1";
		String entityName = "challenge project test";
		tab.configure(entityId, entityName, mockProjectEntityBundle);

		verify(mockAdministerEvaluationsList).configure(eq(entityId), consumerCaptor.capture());
		verify(mockChallengeWidget).configure(entityId, entityName);

		ArgumentCaptor<Synapse> captor = ArgumentCaptor.forClass(Synapse.class);
		verify(mockTab).setEntityNameAndPlace(eq(entityName), captor.capture());
		Synapse place = captor.getValue();
		assertEquals(entityId, place.getEntityId());
		assertNull(place.getVersionNumber());
		assertEquals(EntityArea.CHALLENGE, place.getArea());
		assertNull(place.getAreaToken());
		//verify evaluation editor
		String evaluationId = "88288282";

		consumerCaptor.getValue().accept(evaluationId);

		verify(mockGlobalApplicationState).setIsEditing(true);
		verify(mockEvaluationEditorReactComponentPage).configure(eq(evaluationId), anyString(), anyString(), anyBoolean(), callbackCaptor.capture());

		callbackCaptor.getValue().run();
		verify(mockEvaluationEditorReactComponentPage).removeFromParent();
		verify(mockGlobalApplicationState).setIsEditing(false);
	}

	@Test
	public void testAsTab() {
		assertEquals(mockTab, tab.asTab());
	}

}


text:
package de.unibamberg.minf.dme.service;

import java.util.List;

import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import de.unibamberg.minf.dme.dao.interfaces.PersistedVocabularyDao;
import de.unibamberg.minf.dme.model.PersistedVocabulary;
import de.unibamberg.minf.dme.service.interfaces.PersistedVocabularyService;
import de.unibamberg.minf.gtf.vocabulary.VocabularyEngine;

@Service
public class PersistedVocabularyServiceImpl implements InitializingBean, PersistedVocabularyService {
	@Autowired private PersistedVocabularyDao vocabularyDao;
	@Autowired private VocabularyEngine vocabularyEngine;

	@Override
	public void afterPropertiesSet() throws Exception {
		vocabularyEngine.setVocabularies(vocabularyDao.findAll());
	}

	@Override
	public PersistedVocabulary findById(String id) {
		return vocabularyDao.findById(id);
	}

	@Override
	public PersistedVocabulary save(PersistedVocabulary saveVocabulary) {
		saveVocabulary = vocabularyDao.save(saveVocabulary);
		vocabularyEngine.setVocabularies(vocabularyDao.findAll());

		return saveVocabulary;
	}

	@Override
	public List<PersistedVocabulary> findAll() {
		return vocabularyDao.findAll();
	}
}


text:
/**
 * Random truth by Kevin Siwoff,
 *
 */
var rectPosX, rectPosY;

function setup() {
  createCanvas(windowWidth, windowHeight);
  textAlign(CENTER);
  frameRate(1);
  rectPosX = 0;
  rectPosY = height/2;
}

function draw() {
  if(randomBool() === true){
    rectPosX +=12;
    rectPosY +=12;
  } else {
    rectPosY -=12;
  }
  fill(0);
  rect(rectPosX,rectPosY,12,12);
}

/**
 * randomBool function
 * returns: true | false
 */
function randomBool(){
  // forces value to be either 0 or 1
  var randomNum = Math.round(random(1));
  var isTrue = true;
  if(randomNum === 1){
    isTrue = true;
  }
  else {
    isTrue = false;
  }
  return isTrue;
}


text:
<?php

use yii\db\Schema;
use yii\db\Migration;

class m151219_094713_categories extends Migration
{
    public function up()
    {
     $this->createTable('categories', [
         'id' => $this->primaryKey(),
         'title' => $this->string(50)
     ]);
    }

    public function down()
    {
        echo "m151219_094713_categories cannot be reverted.\n";

        return false;
    }

    /*
    // Use safeUp/safeDown to run migration code within a transaction
    public function safeUp()
    {
    }

    public function safeDown()
    {
    }
    */
}


text:
from __future__ import absolute_import, unicode_literals
from google.appengine.ext import ndb
from gaebusiness.business import Command, CommandParallel
from gaebusiness.gaeutil import ModelSearchCommand, SaveCommand
from gaecookie import facade
from gaeforms.ndb.form import ModelForm
from gaegraph.business_base import NodeSearch, SingleDestinationSearch
from gaepermission.model import MainUser, ExternalToMainUser, PendingExternalToMainUser

def log_main_user_in(main_user, response, user_cookie):
    facade.write_cookie(response, user_cookie, {'id': main_user.key.id()}).execute()

class GetMainUserByEmail(ModelSearchCommand):
    def __init__(self, email):
        super(GetMainUserByEmail, self).__init__(MainUser.query_email(email), 1)

    def do_business(self):
        super(GetMainUserByEmail, self).do_business()
        self.result = self.result[0] if self.result else None

class MainUserForm(ModelForm):
    _model_class = MainUser
    _include = [MainUser.email, MainUser.name, MainUser.groups, MainUser.locale, MainUser.timezone]

class SaveUserCmd(SaveCommand):
    _model_form_class = MainUserForm

    def handle_previous(self, command):
        self.result = command.result

    def __init__(self, **form_parameters):
        super(SaveUserCmd, self).__init__(**form_parameters)

    def do_business(self):
        if self.result is None:
            super(SaveUserCmd, self).do_business()

class UpdateUserGroups(NodeSearch):
    def __init__(self, user_id, groups):
        super(UpdateUserGroups, self).__init__(user_id)
        self.groups = groups

    def do_business(self):
        super(UpdateUserGroups, self).do_business()
        self.result.groups = self.groups

    def commit(self):
        return self.result

class FindMainUserFromExternalUserId(ModelSearchCommand):
    def __init__(self, external_user_class, external_id):
        super(FindMainUserFromExternalUserId,
              self).__init__(external_user_class.query_by_external_id(external_id), 1)
        self.external_user = None

    def do_business(self):
        super(FindMainUserFromExternalUserId, self).do_business()
        external_user = self.result[0] if self.result else None
        if external_user:
            self.result = SingleDestinationSearch(ExternalToMainUser, external_user.key).execute().result
            self.external_user = external_user
        else:
            self.result = None

class CheckMainUserEmailConflict(CommandParallel):
    def __init__(self, external_user_class, external_id, email):
        super(CheckMainUserEmailConflict, self).__init__(GetMainUserByEmail(email),
                                                         FindMainUserFromExternalUserId(external_user_class,
                                                                                external_id))
        self.external_user = None
        self.main_user_from_external = None
        self.main_user_from_email = None

    def do_business(self):
        super(CheckMainUserEmailConflict, self).do_business()
        self.result = True
        self.external_user = self[1].external_user
        self.main_user_from_external = self[1].result
        self.main_user_from_email = self[0].result

        if self.main_user_from_email and not self.main_user_from_external:
            self.result = False

class Login(CheckMainUserEmailConflict):
    def __init__(self, external_user_class, external_id, email, user_name, response, user_cookie):
        super(Login, self).__init__(external_user_class, external_id, email)
        self.user_name = user_name
        self.user_cookie = user_cookie
        self.response = response
        self._arc = None
        self.pending_link = None
        self.external_user_class = external_user_class
        self.external_id = external_id
        self.email = email

    def do_business(self):
        super(Login, self).do_business()

        # if no conflict
        if self.result:
            if self.external_user is None and self.main_user_from_external is None:
                self.external_user = self.external_user_class(external_id=self.external_id)
                self.main_user_from_external = MainUser(name=self.user_name,
                                                        email=self.email)
                external_user_key, main_user_key = ndb.put_multi([self.external_user, self.main_user_from_external])
                self._arc = ExternalToMainUser(origin=external_user_key, destination=main_user_key)
            log_main_user_in(self.main_user_from_external, self.response, self.user_cookie)
        else:
            if self.external_user is None:
                self.external_user = self.external_user_class(external_id=self.external_id)
                self.external_user.put()
            self.pending_link = PendingExternalToMainUser(external_user=self.external_user.key,
                                                          main_user=self.main_user_from_email.key)

    def commit(self):
        return [m for m in [self._arc, self.pending_link] if m]


text:
.class public Lorg/apache/http/conn/ssl/TrustSelfSignedStrategy;
.super Ljava/lang/Object;
.source "TrustSelfSignedStrategy.java"

# interfaces
.implements Lorg/apache/http/conn/ssl/TrustStrategy;

# static fields
.field public static final INSTANCE:Lorg/apache/http/conn/ssl/TrustSelfSignedStrategy;

# direct methods
.method static constructor <clinit>()V
    .locals 1

    new-instance v0, Lorg/apache/http/conn/ssl/TrustSelfSignedStrategy;

    invoke-direct {v0}, Lorg/apache/http/conn/ssl/TrustSelfSignedStrategy;-><init>()V

    sput-object v0, Lorg/apache/http/conn/ssl/TrustSelfSignedStrategy;->INSTANCE:Lorg/apache/http/conn/ssl/TrustSelfSignedStrategy;

    return-void
.end method

.method public constructor <init>()V
    .locals 0

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

    return-void
.end method

# virtual methods
.method public isTrusted([Ljava/security/cert/X509Certificate;Ljava/lang/String;)Z
    .locals 2
    .annotation system Ldalvik/annotation/Throws;
        value = {
            Ljava/security/cert/CertificateException;
        }
    .end annotation

    const/4 v0, 0x1

    array-length v1, p1

    if-eq v1, v0, :cond_0

    const/4 v0, 0x0

    :cond_0
    return v0
.end method


text:
create procedure "Employee Sales by Country"
@Beginning_Date DateTime, @Ending_Date DateTime AS
SELECT Employees.Country, Employees.LastName, Employees.FirstName, Orders.ShippedDate, Orders.OrderID, "Order Subtotals".Subtotal AS SaleAmount
FROM Employees INNER JOIN
	(Orders INNER JOIN "Order Subtotals" ON Orders.OrderID = "Order Subtotals".OrderID)
	ON Employees.EmployeeID = Orders.EmployeeID
WHERE Orders.ShippedDate Between @Beginning_Date And @Ending_Date


text:
'use strict';
var grpc = require('grpc');
var tensorflow_core_protobuf_worker_pb = require('../../../tensorflow/core/protobuf/worker_pb.js');

function serialize_tensorflow_CleanupAllRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.CleanupAllRequest)) {
    throw new Error('Expected argument of type tensorflow.CleanupAllRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_CleanupAllRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.CleanupAllRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_CleanupAllResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.CleanupAllResponse)) {
    throw new Error('Expected argument of type tensorflow.CleanupAllResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_CleanupAllResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.CleanupAllResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_CleanupGraphRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.CleanupGraphRequest)) {
    throw new Error('Expected argument of type tensorflow.CleanupGraphRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_CleanupGraphRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.CleanupGraphRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_CleanupGraphResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.CleanupGraphResponse)) {
    throw new Error('Expected argument of type tensorflow.CleanupGraphResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_CleanupGraphResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.CleanupGraphResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_CreateWorkerSessionRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.CreateWorkerSessionRequest)) {
    throw new Error('Expected argument of type tensorflow.CreateWorkerSessionRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_CreateWorkerSessionRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.CreateWorkerSessionRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_CreateWorkerSessionResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.CreateWorkerSessionResponse)) {
    throw new Error('Expected argument of type tensorflow.CreateWorkerSessionResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_CreateWorkerSessionResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.CreateWorkerSessionResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_DeregisterGraphRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.DeregisterGraphRequest)) {
    throw new Error('Expected argument of type tensorflow.DeregisterGraphRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_DeregisterGraphRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.DeregisterGraphRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_DeregisterGraphResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.DeregisterGraphResponse)) {
    throw new Error('Expected argument of type tensorflow.DeregisterGraphResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_DeregisterGraphResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.DeregisterGraphResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_GetStatusRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.GetStatusRequest)) {
    throw new Error('Expected argument of type tensorflow.GetStatusRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_GetStatusRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.GetStatusRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_GetStatusResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.GetStatusResponse)) {
    throw new Error('Expected argument of type tensorflow.GetStatusResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_GetStatusResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.GetStatusResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_LoggingRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.LoggingRequest)) {
    throw new Error('Expected argument of type tensorflow.LoggingRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_LoggingRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.LoggingRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_LoggingResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.LoggingResponse)) {
    throw new Error('Expected argument of type tensorflow.LoggingResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_LoggingResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.LoggingResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_RecvTensorRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.RecvTensorRequest)) {
    throw new Error('Expected argument of type tensorflow.RecvTensorRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_RecvTensorRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.RecvTensorRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_RecvTensorResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.RecvTensorResponse)) {
    throw new Error('Expected argument of type tensorflow.RecvTensorResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_RecvTensorResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.RecvTensorResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_RegisterGraphRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.RegisterGraphRequest)) {
    throw new Error('Expected argument of type tensorflow.RegisterGraphRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_RegisterGraphRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.RegisterGraphRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_RegisterGraphResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.RegisterGraphResponse)) {
    throw new Error('Expected argument of type tensorflow.RegisterGraphResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_RegisterGraphResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.RegisterGraphResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_RunGraphRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.RunGraphRequest)) {
    throw new Error('Expected argument of type tensorflow.RunGraphRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_RunGraphRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.RunGraphRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_RunGraphResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.RunGraphResponse)) {
    throw new Error('Expected argument of type tensorflow.RunGraphResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_RunGraphResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.RunGraphResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_TracingRequest(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.TracingRequest)) {
    throw new Error('Expected argument of type tensorflow.TracingRequest');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_TracingRequest(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.TracingRequest.deserializeBinary(new Uint8Array(buffer_arg));
}

function serialize_tensorflow_TracingResponse(arg) {
  if (!(arg instanceof tensorflow_core_protobuf_worker_pb.TracingResponse)) {
    throw new Error('Expected argument of type tensorflow.TracingResponse');
  }
  return new Buffer(arg.serializeBinary());
}

function deserialize_tensorflow_TracingResponse(buffer_arg) {
  return tensorflow_core_protobuf_worker_pb.TracingResponse.deserializeBinary(new Uint8Array(buffer_arg));
}

// //////////////////////////////////////////////////////////////////////////////
//
// WorkerService defines a TensorFlow service that executes dataflow
// graphs on a set of local devices, on behalf of a MasterService.
//
// A worker service keeps track of multiple "registered graphs". Each
// registered graph is a subgraph of a client's graph, corresponding to
// only the nodes that should execute on this worker (and any
// additional nodes necessary for inter-process communication using
// the `RecvTensor` method).
//
// //////////////////////////////////////////////////////////////////////////////
//
var WorkerServiceService = exports.WorkerServiceService = {
  // See worker.proto for details.
  getStatus: {
    path: '/tensorflow.grpc.WorkerService/GetStatus',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.GetStatusRequest,
    responseType: tensorflow_core_protobuf_worker_pb.GetStatusResponse,
    requestSerialize: serialize_tensorflow_GetStatusRequest,
    requestDeserialize: deserialize_tensorflow_GetStatusRequest,
    responseSerialize: serialize_tensorflow_GetStatusResponse,
    responseDeserialize: deserialize_tensorflow_GetStatusResponse,
  },
  // See worker.proto for details.
  createWorkerSession: {
    path: '/tensorflow.grpc.WorkerService/CreateWorkerSession',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.CreateWorkerSessionRequest,
    responseType: tensorflow_core_protobuf_worker_pb.CreateWorkerSessionResponse,
    requestSerialize: serialize_tensorflow_CreateWorkerSessionRequest,
    requestDeserialize: deserialize_tensorflow_CreateWorkerSessionRequest,
    responseSerialize: serialize_tensorflow_CreateWorkerSessionResponse,
    responseDeserialize: deserialize_tensorflow_CreateWorkerSessionResponse,
  },
  // See worker.proto for details.
  registerGraph: {
    path: '/tensorflow.grpc.WorkerService/RegisterGraph',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.RegisterGraphRequest,
    responseType: tensorflow_core_protobuf_worker_pb.RegisterGraphResponse,
    requestSerialize: serialize_tensorflow_RegisterGraphRequest,
    requestDeserialize: deserialize_tensorflow_RegisterGraphRequest,
    responseSerialize: serialize_tensorflow_RegisterGraphResponse,
    responseDeserialize: deserialize_tensorflow_RegisterGraphResponse,
  },
  // See worker.proto for details.
  deregisterGraph: {
    path: '/tensorflow.grpc.WorkerService/DeregisterGraph',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.DeregisterGraphRequest,
    responseType: tensorflow_core_protobuf_worker_pb.DeregisterGraphResponse,
    requestSerialize: serialize_tensorflow_DeregisterGraphRequest,
    requestDeserialize: deserialize_tensorflow_DeregisterGraphRequest,
    responseSerialize: serialize_tensorflow_DeregisterGraphResponse,
    responseDeserialize: deserialize_tensorflow_DeregisterGraphResponse,
  },
  // See worker.proto for details.
  runGraph: {
    path: '/tensorflow.grpc.WorkerService/RunGraph',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.RunGraphRequest,
    responseType: tensorflow_core_protobuf_worker_pb.RunGraphResponse,
    requestSerialize: serialize_tensorflow_RunGraphRequest,
    requestDeserialize: deserialize_tensorflow_RunGraphRequest,
    responseSerialize: serialize_tensorflow_RunGraphResponse,
    responseDeserialize: deserialize_tensorflow_RunGraphResponse,
  },
  // See worker.proto for details.
  cleanupGraph: {
    path: '/tensorflow.grpc.WorkerService/CleanupGraph',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.CleanupGraphRequest,
    responseType: tensorflow_core_protobuf_worker_pb.CleanupGraphResponse,
    requestSerialize: serialize_tensorflow_CleanupGraphRequest,
    requestDeserialize: deserialize_tensorflow_CleanupGraphRequest,
    responseSerialize: serialize_tensorflow_CleanupGraphResponse,
    responseDeserialize: deserialize_tensorflow_CleanupGraphResponse,
  },
  // See worker.proto for details.
  cleanupAll: {
    path: '/tensorflow.grpc.WorkerService/CleanupAll',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.CleanupAllRequest,
    responseType: tensorflow_core_protobuf_worker_pb.CleanupAllResponse,
    requestSerialize: serialize_tensorflow_CleanupAllRequest,
    requestDeserialize: deserialize_tensorflow_CleanupAllRequest,
    responseSerialize: serialize_tensorflow_CleanupAllResponse,
    responseDeserialize: deserialize_tensorflow_CleanupAllResponse,
  },
  // See worker.proto for details.
  recvTensor: {
    path: '/tensorflow.grpc.WorkerService/RecvTensor',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.RecvTensorRequest,
    responseType: tensorflow_core_protobuf_worker_pb.RecvTensorResponse,
    requestSerialize: serialize_tensorflow_RecvTensorRequest,
    requestDeserialize: deserialize_tensorflow_RecvTensorRequest,
    responseSerialize: serialize_tensorflow_RecvTensorResponse,
    responseDeserialize: deserialize_tensorflow_RecvTensorResponse,
  },
  // RecvTensor Method
  // See worker.proto for details.
  logging: {
    path: '/tensorflow.grpc.WorkerService/Logging',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.LoggingRequest,
    responseType: tensorflow_core_protobuf_worker_pb.LoggingResponse,
    requestSerialize: serialize_tensorflow_LoggingRequest,
    requestDeserialize: deserialize_tensorflow_LoggingRequest,
    responseSerialize: serialize_tensorflow_LoggingResponse,
    responseDeserialize: deserialize_tensorflow_LoggingResponse,
  },
  // See worker.proto for details.
  tracing: {
    path: '/tensorflow.grpc.WorkerService/Tracing',
    requestStream: false,
    responseStream: false,
    requestType: tensorflow_core_protobuf_worker_pb.TracingRequest,
    responseType: tensorflow_core_protobuf_worker_pb.TracingResponse,
    requestSerialize: serialize_tensorflow_TracingRequest,
    requestDeserialize: deserialize_tensorflow_TracingRequest,
    responseSerialize: serialize_tensorflow_TracingResponse,
    responseDeserialize: deserialize_tensorflow_TracingResponse,
  },
};

exports.WorkerServiceClient = grpc.makeGenericClientConstructor(WorkerServiceService);


text:
using hw.UnitTest;
using Reni.FeatureTest.Helper;

namespace Reni.FeatureTest.Reference
{
    [UnitTest]
    [AllScopeHandling]
    [Target(@"
o:
@
(
    data: ^ ;
    dump_print1:
    @!
    {
        data (0) dump_print;
        data (1) dump_print;
        data (2) dump_print;
        data (3) dump_print;
        data (4) dump_print;
        data (5) dump_print
    }
);

o('abcdef') dump_print1
")]
    [Output("abcdef")]
    public sealed class FunctionalDumpSimple : CompilerTest { }

    [UnitTest]
    [FunctionalDumpSimple]
    [Target(@"
o:
@
(
    data: ^ array_reference ;
    dump_print1:
    @!
    {
        data (0) dump_print;
        data (3) dump_print;
        data (5) dump_print
    }
);

o('abcdef') dump_print1
")]
    [Output("adf")]
    public sealed class ArrayReferenceDumpSimple : CompilerTest { }
}


text:
<?xml version="1.0"?>
<!--
  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.
-->
<!DOCTYPE module PUBLIC
    "-//Puppy Crawl//DTD Check Configuration 1.1//EN"
    "http://www.puppycrawl.com/dtds/configuration_1_1.dtd">

<!--

  Checkstyle configuration that checks the sun coding conventions from:

    - the Java Language Specification at
      http://java.sun.com/docs/books/jls/second_edition/html/index.html

    - the Sun Code Conventions at http://java.sun.com/docs/codeconv/

    - the Javadoc guidelines at
      http://java.sun.com/j2se/javadoc/writingdoccomments/index.html

    - the JDK Api documentation http://java.sun.com/j2se/docs/api/index.html

    - some best practices

  Checkstyle is very configurable. Be sure to read the documentation at
  http://checkstyle.sf.net (or in your downloaded distribution).

  Most Checks are configurable, be sure to consult the documentation.

  To completely disable a check, just comment it out or delete it from the file.

  Finally, it is worth reading the documentation.

-->

<module name="Checker">

    <!-- Checks that a package.html file exists for each package.     -->
    <!-- See http://checkstyle.sf.net/config_javadoc.html${symbol_pound}PackageHtml -->
    <module name="JavadocPackage"/>
    <!--
    -->

    <!-- Checks whether files end with a new line.                        -->
    <!-- See http://checkstyle.sf.net/config_misc.html${symbol_pound}NewlineAtEndOfFile -->
        <!--
    <module name="NewlineAtEndOfFile"/>
         -->

    <!-- Checks that property files contain the same keys.         -->
    <!-- See http://checkstyle.sf.net/config_misc.html${symbol_pound}Translation -->
    <module name="Translation"/>

    <!--
    eg:
    //CHECKSTYLE.OFF: IllegalCatch - Much more readable than catching 7 exceptions
    catch (Exception e)
    //CHECKSTYLE.ON: IllegalCatch
     -->
    <module name="SuppressionCommentFilter">
        <property name="offCommentFormat" value="CHECKSTYLE.OFF${symbol_escape}: ([${symbol_escape}w${symbol_escape}|]+)"/>
        <property name="onCommentFormat" value="CHECKSTYLE.ON${symbol_escape}: ([${symbol_escape}w${symbol_escape}|]+)"/>
        <property name="checkFormat" value="${symbol_dollar}1"/>
    </module>

    <!--
    eg:
    // CHECKSTYLE IGNORE check FOR NEXT 1 LINES
    public void onClick(View view) { ... }     -->
    <module name="SuppressWithNearbyCommentFilter">
        <property name="commentFormat" value="CHECKSTYLE.IGNORE (${symbol_escape}w+) FOR NEXT (${symbol_escape}d+) LINES"/>
        <property name="checkFormat" value="${symbol_dollar}1"/>
        <property name="influenceFormat" value="${symbol_dollar}2"/>
    </module>

    <module name="TreeWalker">

        <property name="cacheFile" value="${symbol_dollar}{checkstyle.cache.file}"/>

        <!-- not available in eclipse-cs
        <module name="JavadocDeprecated"/>
        -->
        <module name="MissingOverride"/>

        <!-- ************************************************************** -->
        <!-- Checks that are different from the sun coding conventions ones -->
        <!-- ************************************************************** -->
        <property name="tabWidth" value="4"/>
        <module name="LeftCurly">
          <property name="option" value="eol"/>
        </module>
        <module name="RightCurly">
          <property name="option" value="same"/>
        </module>
        <module name="MemberName">
          <property name="format" value="^[a-z]([a-zA-Z0-9])*${symbol_dollar}"/>
        </module>
        <module name="StaticVariableName">
          <property name="format" value="^[A-Z](_?[A-Z0-9])*${symbol_dollar}"/>
        </module>
        <module name="MethodName">
          <property name="format" value="[a-z](_?[a-zA-Z0-9]+)*${symbol_dollar}"/>
        </module>
        <module name="ParameterName">
          <property name="format" value="[a-z]([a-zA-Z0-9]+)*${symbol_dollar}"/>
        </module>
        <module name="LocalVariableName">
          <property name="format" value="[a-z]([a-zA-Z0-9]+)*${symbol_dollar}"/>
        </module>

        <!-- ************************************************************** -->
        <!-- Default Sun coding conventions checks                          -->
        <!-- ************************************************************** -->

        <!-- Checks for Javadoc comments.                     -->
        <!-- See http://checkstyle.sf.net/config_javadoc.html -->

        <!-- TODO: instate at some point (though only for public methods
        <module name="JavadocType"/>
        -->
        <!--
        <module name="JavadocMethod"/>
        <module name="JavadocVariable"/>
         -->

        <!-- Checks for Naming Conventions.                  -->
        <!-- See http://checkstyle.sf.net/config_naming.html -->
        <module name="ConstantName"/>
        <module name="PackageName"/>
        <module name="TypeName"/>
        <module name="LocalFinalVariableName"/>

        <!-- Checks for Headers                              -->
        <!-- See http://checkstyle.sf.net/config_header.html -->
                <!--
        <module name="Header">
         -->
            <!-- The follow property value demonstrates the ability     -->
            <!-- to have access to ANT properties. In this case it uses -->
            <!-- the ${symbol_dollar}{basedir} property to allow Checkstyle to be run  -->
            <!-- from any directory within a project.                   -->
                    <!--
            <property name="headerFile" value="${symbol_dollar}{checkstyle.header.file}"/>
        </module>
         -->

        <!-- Following interprets the header file as regular expressions. -->
        <!-- <module name="RegexpHeader"/>                                -->

        <!-- Checks for imports                              -->
        <!-- See http://checkstyle.sf.net/config_import.html -->
        <module name="AvoidStarImport"/>
        <module name="IllegalImport"/>
        <module name="RedundantImport"/>
        <module name="UnusedImports"/>

        <!-- Checks for blocks. You know, those {}'s         -->
        <!-- See http://checkstyle.sf.net/config_blocks.html -->
        <module name="EmptyBlock"/>
        <module name="NeedBraces"/>
        <!--
        <module name="AvoidNestedBlocks"/>
         -->

        <!-- Checks for common coding problems               -->
        <!-- See http://checkstyle.sf.net/config_coding.html -->
        <module name="EmptyStatement"/>
        <module name="MagicNumber"/>
        <module name="MissingSwitchDefault"/>
        <module name="RedundantThrows"/>
        <module name="SimplifyBooleanExpression"/>
        <module name="SimplifyBooleanReturn"/>

        <!-- not supported in maven
        <module name="DoubleCheckedLocking"/>
         -->
        <!--
        <module name="AvoidInlineConditionals"/>
        <module name="EqualsHashCode"/>
        <module name="HiddenField"/>
        <module name="IllegalInstantiation"/>
        <module name="InnerAssignment"/>
         -->

        <!-- Checks for class design                         -->
        <!-- See http://checkstyle.sf.net/config_design.html -->
        <!--

        <module name="VisibilityModifier"/>
         -->
         <!-- too many violations...
         <module name="DesignForExtension"/>
          -->
         <module name="FinalClass"/>
         <module name="HideUtilityClassConstructor"/>
         <module name="InterfaceIsType"/>

         <module name="CyclomaticComplexity">
            <property name="max" value="12"/>
         </module>
         <module name="NPathComplexity">
            <property name="max" value="160"/>
        </module>

        <!-- Miscellaneous other checks.                   -->
        <!-- See http://checkstyle.sf.net/config_misc.html -->
        <!--
        <module name="ArrayTypeStyle"/>
        <module name="GenericIllegalRegexp">
            <property name="format" value="${symbol_escape}s+${symbol_dollar}"/>
            <property name="message" value="Line has trailing spaces."/>
        </module>
         -->
         <!-- removed; we detect these in other ways.
        <module name="TodoComment"/>
          -->
        <module name="UpperEll"/>
        <module name="FinalParameters"/>

        <!-- Checks for whitespace                               -->
        <!-- See http://checkstyle.sf.net/config_whitespace.html -->
        <!--
        <module name="NoWhitespaceAfter"/>
        <module name="NoWhitespaceBefore"/>
        <module name="OperatorWrap"/>
        <module name="ParenPad"/>
        <module name="WhitespaceAfter"/>
        <module name="WhitespaceAround"/>
        <module name="TabCharacter"/>
         -->
        <module name="EmptyForIteratorPad"/>

        <!-- Modifier Checks                                    -->
        <!-- See http://checkstyle.sf.net/config_modifiers.html -->
        <!--
        <module name="ModifierOrder"/>
        <module name="RedundantModifier"/>
         -->

        <!-- Checks for Size Violations.                    -->
        <!-- See http://checkstyle.sf.net/config_sizes.html -->
         <module name="LineLength">
            <property name="max" value="120"/>
        </module>
        <module name="MethodLength">
            <property name="max" value="30"/>
        </module>
        <module name="ParameterNumber">
            <property name="max" value="6"/>
        </module>

    </module>

    <module name="FileLength">
        <property name="max" value="1500"/>
    </module>

    <module name="FileTabCharacter">
        <property name="eachLine" value="true"/>
        <property name="fileExtensions" value="java,xml"/>
    </module>

</module>


text:
package org.coderswithoutborders.deglancer.func_debug.stage3;

import org.coderswithoutborders.deglancer.model.Stage;

/**
 * Created by Renier on 2016/05/06.
 */
public interface IDebugStage3View {
    void finishActivity();
    void moveToStage4View();
    void moveToStage2View();
    void setStage(Stage stage);
    void setTitleStage(String stage);
}


text:
require "rubygems"
require "bundler"
Bundler.setup
require File.expand_path("../../init.rb", __FILE__)
puts Spanish.get_syllables_ipa(ARGV.shift, *ARGV.map(&:to_sym))


text:
$(document).ready(function() {
  AOS.init( {
    // uncomment below for on-scroll animations to played only once
    // once: true
  }); // initialize animate on scroll library
});

// Smooth scroll for links with hashes
$('a.smooth-scroll')
.click(function(event) {
  // On-page links
  if (
    location.pathname.replace(/^\//, '') == this.pathname.replace(/^\//, '')
    &&
    location.hostname == this.hostname
  ) {
    // Figure out element to scroll to
    var target = $(this.hash);
    target = target.length ? target : $('[name=' + this.hash.slice(1) + ']');
    // Does a scroll target exist?
    if (target.length) {
      // Only prevent default if animation is actually gonna happen
      event.preventDefault();
      $('html, body').animate({
        scrollTop: target.offset().top
      }, 1000, function() {
        // Callback after animation
        // Must change focus!
        var $target = $(target);
        $target.focus();
        if ($target.is(":focus")) { // Checking if the target was focused
          return false;
        } else {
          $target.attr('tabindex','-1'); // Adding tabindex for elements not focusable
          $target.focus(); // Set focus again
        };
      });
    }
  }
});


text:
//------------------------------------------------------------------------------
// <автоматически создаваемое>
//     Этот код создан программой.
//
//     Изменения в этом файле могут привести к неправильной работе и будут потеряны в случае
//     повторной генерации кода.
// </автоматически создаваемое>
//------------------------------------------------------------------------------

namespace IIS.Авиакомпания {

    public partial class Компания {

        /// <summary>
        /// Num2 элемент управления.
        /// </summary>
        /// <remarks>
        /// Автоматически создаваемое поле.
        /// Для изменения переместите объявление поля из файла конструктора в файл кода программной части.
        /// </remarks>
        protected global::ICSSoft.STORMNET.Web.AjaxControls.AlphaNumericTextBox Num2;

        /// <summary>
        /// Button элемент управления.
        /// </summary>
        /// <remarks>
        /// Автоматически создаваемое поле.
        /// Для изменения переместите объявление поля из файла конструктора в файл кода программной части.
        /// </remarks>
        protected global::System.Web.UI.WebControls.Button Button;

        /// <summary>
        /// Mom элемент управления.
        /// </summary>
        /// <remarks>
        /// Автоматически создаваемое поле.
        /// Для изменения переместите объявление поля из файла конструктора в файл кода программной части.
        /// </remarks>
        protected global::ICSSoft.STORMNET.Web.AjaxControls.WebObjectListView Mom;
    }
}


text:
namespace impala {

class Tuple;
class TupleRow;

/// Node that evaluates conjuncts and enforces a limit but otherwise passes along
/// the rows pulled from its child unchanged.
class SelectNode : public ExecNode {
 public:
  SelectNode(ObjectPool* pool, const TPlanNode& tnode, const DescriptorTbl& descs);

  virtual Status Prepare(RuntimeState* state) override;
  virtual void Codegen(RuntimeState* state) override;
  virtual Status Open(RuntimeState* state) override;
  virtual Status GetNext(RuntimeState* state, RowBatch* row_batch, bool* eos) override;
  virtual Status Reset(RuntimeState* state, RowBatch* row_batch) override;
  virtual void Close(RuntimeState* state) override;

 private:
  /////////////////////////////////////////
  /// BEGIN: Members that must be Reset()

  /// current row batch of child
  boost::scoped_ptr<RowBatch> child_row_batch_;

  /// index of current row in child_row_batch_
  int child_row_idx_;

  /// true if last GetNext() call on child signalled eos
  bool child_eos_;

  /// END: Members that must be Reset()
  /////////////////////////////////////////

  typedef void (*CopyRowsFn)(SelectNode*, RowBatch*);
  CopyRowsFn codegend_copy_rows_fn_;

  /// Copy rows from child_row_batch_ for which conjuncts_ evaluate to true to
  /// output_batch, up to limit_ or till the output row batch reaches capacity.
  void CopyRows(RowBatch* output_batch);

  /// Codegen CopyRows(). Used for mostly codegen'ing the conjuncts evaluation logic.
  Status CodegenCopyRows(RuntimeState* state);
};

}

#endif


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

  Copyright 2003 - 2014 The eFaps Team

  Licensed 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.

  Author:          The eFaps Team

-->
<ui-form xmlns="http://www.efaps.org/xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.efaps.org/xsd http://www.efaps.org/xsd/eFaps_1.0.xsd">
    <uuid>4186c201-d302-4985-92f8-323273b1c909</uuid>
    <file-application>eFapsApp-Payroll</file-application>
    <definition>
        <version-expression>(version==latest)</version-expression>
        <name>Payroll_LaborTimeReportFilterForm</name>
        <field name="dateFrom">
            <property name="ModeEdit">EDITABLE</property>
            <property name="UIProvider">org.efaps.admin.datamodel.ui.DateUI</property>
            <property name="Label">ERP_ReportFilterForm4DateFromTo.dateFrom.Label</property>
            <trigger event="UI_FIELD_VALUE" method="getDateFromFieldValue"
                name="Payroll_LaborTimeReportFilterForm.dateFrom.UI_FIELD_VALUE"
                program="org.efaps.esjp.erp.FilteredReport" />
        </field>
        <field name="dateTo">
            <property name="ModeEdit">EDITABLE</property>
            <property name="UIProvider">org.efaps.admin.datamodel.ui.DateUI</property>
            <property name="Label">ERP_ReportFilterForm4DateFromTo.dateTo.Label</property>
            <trigger event="UI_FIELD_VALUE" method="getDateToFieldValue"
                name="Payroll_LaborTimeReportFilterForm.dateTo.UI_FIELD_VALUE"
                program="org.efaps.esjp.erp.FilteredReport" />
        </field>
        <field name="employee">
            <property name="ModeEdit">EDITABLE</property>
            <property name="UIProvider">org.efaps.admin.datamodel.ui.StringUI</property>
            <property name="Label">org.efaps.esjp.payroll.reports.LaborTimeReport.employee</property>
            <trigger event="UI_FIELD_VALUE" method="getInstanceFieldValue"
                name="Payroll_LaborTimeReportFilterForm.employee.UI_FIELD_VALUE"
                program="org.efaps.esjp.erp.FilteredReport">
                <property name="HumanResource_Employee_MsgPhrase">HumanResource_EmployeeWithNumberMsgPhrase</property>
            </trigger>
            <trigger event="UI_FIELD_AUTOCOMPLETE" method="autoComplete4Employee"
                name="Payroll_LaborTimeReportFilterForm.employee.UI_FIELD_AUTOCOMPLETE"
                program="org.efaps.esjp.humanresource.Employee" />
        </field>
        <field name="settlement">
            <property name="ModeEdit">EDITABLE</property>
            <property name="UIProvider">org.efaps.admin.datamodel.ui.BooleanUI</property>
            <property name="Label">org.efaps.esjp.payroll.reports.LaborTimeReport.settlement</property>
            <trigger event="UI_FIELD_VALUE" method="getBooleanFieldValue"
                name="Payroll_LaborTimeReportFilterForm.settlement.UI_FIELD_VALUE"
                program="org.efaps.esjp.payroll.reports.LaborTimeReport" />
        </field>
        <field name="monthly">
            <property name="ModeEdit">EDITABLE</property>
            <property name="UIProvider">org.efaps.admin.datamodel.ui.BooleanUI</property>
            <property name="Label">org.efaps.esjp.payroll.reports.LaborTimeReport.monthly</property>
            <trigger event="UI_FIELD_VALUE" method="getBooleanFieldValue"
                name="Payroll_LaborTimeReportFilterForm.monthly.UI_FIELD_VALUE"
                program="org.efaps.esjp.payroll.reports.LaborTimeReport" />
        </field>
    </definition>
</ui-form>


text:
'use strict';
/**
 *  Thanks to: http://browniefed.com/blog/2015/06/07/react-native-layout-examples/
 *
 */
import { bindActionCreators } from 'redux';
import { connect } from 'react-redux/native';
import * as profileActions from '../reducers/profile/profileActions';
import {Map} from 'immutable';
import ErrorAlert from '../components/ErrorAlert';
import FormButton from '../components/FormButton';
import Header from '../components/Header';
import React,
{
  Component,
  StyleSheet,
  View
}
from 'react-native';

import ItemCheckbox from '../components/ItemCheckbox';

import t from 'tcomb-form-native';

let Form = t.form.Form;

import {
} from '../lib/constants';

var styles = StyleSheet.create({
  container: {
    flexDirection: 'column',
    flex: 1,
    backgroundColor: 'transparent'
  },
  inputs: {
    marginTop: 10,
    marginBottom: 10,
    marginLeft: 10,
    marginRight: 10
  }
});

const actions = [
  profileActions
];

function mapStateToProps(state) {
  return {
      ...state
  };
}

function mapDispatchToProps(dispatch) {
  const creators = Map()
          .merge(...actions)
          .filter(value => typeof value === 'function')
          .toObject();

  return {
    actions: bindActionCreators(creators, dispatch),
    dispatch
  };
}

@connect(mapStateToProps, mapDispatchToProps)
export default class Profile extends Component {
  constructor(props) {
    super(props);
    this.errorAlert = new ErrorAlert();
    this.state = {
      formValues: {
        username: '',
        email: ''
      }
    };
  }
  onChange(value) {
    this.props.actions.onProfileFormFieldChange(value);
    this.setState({value});
  }

  componentDidMount() {
    this.props.actions.getProfile();
  }
  componentWillReceiveProps(props) {
    this.setState({
      formValues: {
        username: props.profile.form.fields.username,
        email: props.profile.form.fields.email
      }
    });
  }

  render() {

    this.errorAlert.checkError(this.props.profile.form.error);

    let self = this;

    let ProfileForm = t.struct({
      username: t.String,
      email: t.String
    });

    let options = {
      auto: 'placeholders',
      fields: {
        username: {
          label: 'Username',
          maxLength: 12,
          editable: !this.props.profile.form.isFetching,
          hasError: this.props.profile.form.fields.usernameHasError,
          error: 'Must have 6-12 characters and/or numbers'
        },
        email: {
          label: 'Email',
          keyboardType: 'email-address',
          editable: !this.props.profile.form.isFetching,
          hasError: this.props.profile.form.fields.emailHasError,
          error: 'Please enter valid email'
        }
      }
    };

    let profileButtonText = 'Update Profile';
    let onButtonPress = () => {
      this.props.actions.updateProfile(
        this.props.profile.form.originalProfile.objectId,
        this.props.profile.form.fields.username,
        this.props.profile.form.fields.email);
    };

    return (
      <View style={styles.container}>
      <Header isFetching={this.props.profile.form.isFetching}/>
        <View style={styles.inputs}>
          <Form
              ref="form"
              type={ProfileForm}
              options={options}
              value={this.state.formValues}
              onChange={this.onChange.bind(self)}
          />
          <ItemCheckbox text="Email verified (display only)"
                        disabled={true}
                        checked={this.props.profile.form.fields.emailVerified}
          />
        </View>

        <FormButton
            isDisabled={!this.props.profile.form.isValid || this.props.profile.form.isFetching}
            onPress={onButtonPress.bind(self)}
            buttonText={profileButtonText}/>

      </View>
    );
  }
}


text:
package centrality;

import graph.IGraph;
import graphcomputer.VertexFunction;
import it.unimi.dsi.fastutil.ints.Int2DoubleMap;
import it.unimi.dsi.fastutil.ints.Int2DoubleOpenHashMap;

public class PageRank extends VertexFunction {
	protected Int2DoubleMap result;
	protected final int totNodes;
	protected final double dumpingFactor;
	protected final double dumper;

	public PageRank(IGraph g) {
		totNodes = g.getNodeCount();
		dumpingFactor = 0.85;
		dumper = (1-dumpingFactor) / totNodes;

		this.result = new Int2DoubleOpenHashMap(totNodes);
		for(int n : g.getNodeSet())
			this.result.put(n, 1.0 / totNodes);
	}

	@Override
	public void apply(IGraph graph, int n) {
		double pr = 0.0;
		for( int pj : graph.getInNeighbours(n) )
			pr += result.get(pj) / graph.wOutDegree(pj);
		double rank = this.dumper + this.dumpingFactor * pr;
		result.put( n, rank );
	}

	@Override
	public Int2DoubleMap getResult() {
		return result;
	}

}