text:
package com.lemmingapex.projecteuler.pokerhands;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;

/**
 * 12/19/2016
 * PokerHands.java
 * Poker hands
 *
 * @author Scott Wiedemann
 *
 */
public class PokerHands {
	public static void main(String[] args) {
		if (args.length != 1) {
			System.err.println("Incorrect number of arguments.");
			System.err.println("Usage: ./pokerhands.jar p054_poker.txt");
			System.exit(1);
		}

		String inputFileString = args[0];
		if (inputFileString == null || inputFileString.trim().isEmpty()) {
			System.err.println("Bad file name: " + String.valueOf(inputFileString));
			System.exit(1);
		}

		File inputFile = new File(inputFileString);
		if (!inputFile.exists()) {
			System.err.println(inputFile.getAbsolutePath() + " does not exist.");
			System.exit(1);
		}

		if (!inputFile.canRead()) {
			System.err.println("Can not read " + inputFile.getAbsolutePath() + ".");
			System.exit(1);
		}

		int numberOfhandsPlayerOneWins = 0;
		BufferedReader br = null;
		try {
			br = new BufferedReader(new FileReader(inputFile));
			String line = br.readLine();
			while (line != null && !line.trim().isEmpty()) {
				String[] cards = line.split("\\s+");
				Hand player1Hand = new Hand();
				for(int i=0; i<5; i++) {
					String card = cards[i];
					player1Hand.cards.add(Card.valueOf(card));
				}
				Hand player2Hand = new Hand();
				for(int i=5; i<10; i++) {
					String card = cards[i];
					player2Hand.cards.add(Card.valueOf(card));
				}
				if(player1Hand.getHandValue() > player2Hand.getHandValue()) {
					numberOfhandsPlayerOneWins++;
					//System.out.println("player 1 wins!");
				} else if(player1Hand.getHandValue() < player2Hand.getHandValue()) {
					//System.out.println("player 2 wins!");
				} else {
					//System.out.println("tie!");
				}

				line = br.readLine();
			}
		} catch (Exception e) {
			System.err.println("Problem reading file: " + inputFile.getAbsolutePath() + ".");
			e.printStackTrace();
		} finally {
			if (br != null) {
				try {
					br.close();
				} catch (IOException e) {
					// bummer
				}
			}
		}

		System.out.println(numberOfhandsPlayerOneWins);
	}
}


text:
<!DOCTYPE html>

<TITLE>Manpage of QUERY_MODULE</TITLE>
<meta charset="utf-8">
<link rel="stylesheet" href="/css/main.css" type="text/css">

linux manpages

{"type":"documentation"}

QUERY_MODULE

Section: Linux Programmer's Manual (2)
Updated: 2007-06-03
Index
Return to Main Contents

NAME

query_module - query the kernel for various bits pertaining to modules

SYNOPSIS

#include <linux/module.h>

int query_module(const char *name, int which, void *buf,
                 size_t bufsize, size_t *ret);

DESCRIPTION

query_module()

requests information from the kernel about loadable modules.
The returned information is placed in the buffer pointed to by
buf.

The caller must specify the size of
buf

in
bufsize.

The precise nature and format of the returned information
depend on the operation specified by
which.

Some operations require
name

to identify a currently loaded module, some allow
name

to be NULL, indicating the kernel proper.

The following values can be specified for
which:

0

Returns success, if the kernel supports
query_module().

Used to probe for availability of the system call.

QM_MODULES

Returns the names of all loaded modules.
The returned buffer consists of a sequence of null-terminated strings;
ret

is set to the number of
modules.

QM_DEPS

Returns the names of all modules used by the indicated module.
The returned buffer consists of a sequence of null-terminated strings;
ret

is set to the number of modules.

QM_REFS

Returns the names of all modules using the indicated module.
This is the inverse of
QM_DEPS.

The returned buffer consists of a sequence of null-terminated strings;
ret

is set to the number of modules.

QM_SYMBOLS

Returns the symbols and values exported by the kernel or the indicated
module.
The returned buffer is an array of structures of the following form

struct module_symbol {
    unsigned long value;
    unsigned long name;
};

followed by null-terminated strings.
The value of
name

is the character offset of the string relative to the start of
buf;

ret

is set to the number of symbols.

QM_INFO

Returns miscellaneous information about the indicated module.
The output buffer format is:

struct module_info {
    unsigned long address;
    unsigned long size;
    unsigned long flags;
};

where
address

is the kernel address at which the module resides,
size

is the size of the module in bytes, and
flags

is a mask of
MOD_RUNNING,

MOD_AUTOCLEAN,

etc. that indicates the current status of the module
(see the kernel source file
include/linux/module.h).

ret

is set to the size of the
module_info

structure.

RETURN VALUE

On success, zero is returned.
On error, -1 is returned and
errno

is set appropriately.

ERRORS

EFAULT

At least one of
name,

buf,

or
ret

was outside the program's accessible address space.

EINVAL

Invalid
which;

or
name

is NULL (indicating "the kernel"),
but this is not permitted with the specified value of
which.

ENOENT

No module by that
name

exists.

ENOSPC

The buffer size provided was too small.
ret

is set to the minimum size needed.

ENOSYS

query_module()

is not supported in this version of the kernel.

CONFORMING TO

query_module()

is Linux-specific.

NOTES

This system call is only present on Linux up until kernel 2.4;
it was removed in Linux 2.6.

Some of the information that was available via
query_module()

can be obtained from
/proc/modules,

/proc/kallsyms,

and
/sys/modules.

SEE ALSO

create_module(2),

delete_module(2),

get_kernel_syms(2),

init_module(2)

COLOPHON

This page is part of release 3.22 of the Linux
man-pages

project.
A description of the project,
and information about reporting bugs,
can be found at
http://www.kernel.org/doc/man-pages/.

Index

NAME

SYNOPSIS

DESCRIPTION

RETURN VALUE

ERRORS

CONFORMING TO

NOTES

SEE ALSO

COLOPHON

This document was created by
man2html,
using the manual pages.

Time: 05:33:04 GMT, December 24, 2015

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

		<meta charset="utf-8" />
		<base href="../../" />

		<link type="text/css" rel="stylesheet" href="page.css" />

[name]

			Represents a section bounded by a specific amount of half-edges. The current implmentation assumes that a face always consist of three edges.

Constructor

[name]()

Properties

[property:Vector3 normal]

			The normal vector of the face. Default is a [page:Vector3] at (0, 0, 0).

[property:Vector3 midpoint]

			The midpoint or centroid of the face. Default is a [page:Vector3] at (0, 0, 0).

[property:Float area]

			The area of the face. Default is 0.

[property:Float constant]

			Signed distance from face to the origin. Default is 0.

[property:VertexNode outside]

			Reference to a vertex in a vertex list this face can see. Default is null.

[property:Integer mark]

			Marks if a face is visible or deleted. Default is 'Visible'.

[property:HalfEdge edge]

			Reference to the base edge of a face. To retrieve all edges, you can use the 'next' reference of the current edge. Default is null.

Methods

[method:Face create]( [param:VertexNode a], [param:VertexNode b], [param:VertexNode c] )

		[page:VertexNode a] - First vertex of the face.

		[page:VertexNode b] - Second vertex of the face.

		[page:VertexNode c] - Third vertex of the face.

Creates a face.

[method:HalfEdge getEdge]( [param:Integer i] )

		[page:Integer i] - The index of the edge.

Returns an edge by the given index.

[method:Face compute] ()

Computes all properties of the face.

[method:Float distanceToPoint]( [param:Vector3 point] )

		[page:Vector3 point] - Any point in 3D space.

Returns the signed distance from a given point to the plane representation of this face.

Source

		[link:https://github.com/mrdoob/three.js/blob/master/examples/js/QuickHull.js examples/js/QuickHull.js]


text:
const _ = require('lodash');
const localUtils = require('../../../index');

const tag = (attrs, frame) => {
    if (localUtils.isContentAPI(frame)) {
        delete attrs.created_at;
        delete attrs.updated_at;

        // We are standardising on returning null from the Content API for any empty values
        if (attrs.meta_title === '') {
            attrs.meta_title = null;
        }
        if (attrs.meta_description === '') {
            attrs.meta_description = null;
        }
        if (attrs.description === '') {
            attrs.description = null;
        }
    }

    delete attrs.parent_id;
    delete attrs.parent;

    return attrs;
};

const author = (attrs, frame) => {
    if (localUtils.isContentAPI(frame)) {
        delete attrs.created_at;
        delete attrs.updated_at;
        delete attrs.last_seen;
        delete attrs.status;
        delete attrs.email;

        // @NOTE: used for night shift
        delete attrs.accessibility;

        // Extra properties removed from canary
        delete attrs.tour;

        // We are standardising on returning null from the Content API for any empty values
        if (attrs.twitter === '') {
            attrs.twitter = null;
        }
        if (attrs.bio === '') {
            attrs.bio = null;
        }
        if (attrs.website === '') {
            attrs.website = null;
        }
        if (attrs.facebook === '') {
            attrs.facebook = null;
        }
        if (attrs.meta_title === '') {
            attrs.meta_title = null;
        }
        if (attrs.meta_description === '') {
            attrs.meta_description = null;
        }
        if (attrs.location === '') {
            attrs.location = null;
        }
    }

    // @NOTE: unused fields
    delete attrs.visibility;
    delete attrs.locale;

    return attrs;
};

const post = (attrs, frame) => {
    if (localUtils.isContentAPI(frame)) {
        // @TODO: https://github.com/TryGhost/Ghost/issues/10335
        // delete attrs.page;
        delete attrs.status;

        // We are standardising on returning null from the Content API for any empty values
        if (attrs.twitter_title === '') {
            attrs.twitter_title = null;
        }
        if (attrs.twitter_description === '') {
            attrs.twitter_description = null;
        }
        if (attrs.meta_title === '') {
            attrs.meta_title = null;
        }
        if (attrs.meta_description === '') {
            attrs.meta_description = null;
        }
        if (attrs.og_title === '') {
            attrs.og_title = null;
        }
        if (attrs.og_description === '') {
            attrs.og_description = null;
        }
        // NOTE: the visibility column has to be always present in Content API response to perform content gating
        if (frame.options.columns && frame.options.columns.includes('visibility') && !frame.original.query.fields.includes('visibility')) {
            delete attrs.visibility;
        }
    } else {
        delete attrs.page;
    }

    if (!attrs.tags) {
        delete attrs.primary_tag;
    }

    if (!attrs.authors) {
        delete attrs.primary_author;
    }

    delete attrs.locale;
    delete attrs.author;
    delete attrs.type;

    return attrs;
};

const action = (attrs) => {
    if (attrs.actor) {
        delete attrs.actor_id;
        delete attrs.resource_id;

        if (attrs.actor_type === 'user') {
            attrs.actor = _.pick(attrs.actor, ['id', 'name', 'slug', 'profile_image']);
            attrs.actor.image = attrs.actor.profile_image;
            delete attrs.actor.profile_image;
        } else {
            attrs.actor = _.pick(attrs.actor, ['id', 'name', 'slug', 'icon_image']);
            attrs.actor.image = attrs.actor.icon_image;
            delete attrs.actor.icon_image;
        }
    } else if (attrs.resource) {
        delete attrs.actor_id;
        delete attrs.resource_id;

        // @NOTE: we only support posts right now
        attrs.resource = _.pick(attrs.resource, ['id', 'title', 'slug', 'feature_image']);
        attrs.resource.image = attrs.resource.feature_image;
        delete attrs.resource.feature_image;
    }
};

module.exports.post = post;
module.exports.tag = tag;
module.exports.author = author;
module.exports.action = action;


text:
Title: Sponsoring EuroSciPy 2019
URL: 2019/sponsors.html
save_as: 2019/sponsors.html
section: euroscipy_2019
slug: sponsors2019

Information about sponsorship is available at the [sponsorship information page](sponsors_info.html).

### Organising institutions

        El ámbito de trabajo del grupo de Inteligencia Computacional
        es la aplicación de técnicas de Inteligencia Artificial, basadas en técnicas estadísticas,
        a diversos aspectos de la percepción y control en sistemas.

        Las técnicas que se conocen van desde algoritmos de clustering y cuantización vectorial,
        redes neuronales, Hidden Markov Models, algoritmos supervisados de clasificación, hasta el procesado de imagen
        y la visión por computador.

        Las aplicaciones van desde los sistemas de interacción hombre máquina avanzados, control de robots móviles,
        diagnosis basada en imágenes médicas, sistemas de seguridad en el trabajo basados en inteligencia ambiental,
        comunicación gestual con personas sordas, hasta la inspección de procesos y productos y la psicología experimental.

        In a prosperous region stretching along the Atlantic coast of northern Spain,
        the people of the Basque Country are the custodians of one of Europe's most ancient languages and cultures.
        Yet, they not only have a high esteem for tradition, but are also remarkably forward-looking and
        have established a highly regarded industrial sector.

        The region's success and scientific and technological progress are underpinned by the
        University of the Basque Country,
        a vibrant 30-year-old institution with 45,000 students, 5,000 world-class academic staff and state-of-the-art facilities.

### Platinum sponsors

        Intrepid Control Systems provides measurement and data
        logging hardware solutions for Python developers.
        Our tools capture industrial and laboratory type measurements such as temperature, pressure, voltage,
        and other process measurements. Intrepid hardware can store data in the cloud (IoT) backed by
        integrated analysis using Python on the server.

        Recognized worldwide for our innovative engineering tools, we have offices in the USA, China, Japan,
        England, Germany, India, Korea, and Australia for direct sales and support.

        Find out more at www.intrepidcs.com.

### Gold sponsors

        Intel®, a world leader in computing innovation, delivers highly optimized Python Packages to developers.
        Achieve faster Python* application performance—right out of the box—with minimal or no changes to your code.
        Accelerated NumPy*, SciPy*, and scikit-learn* via integrated Intel® Performance Libraries such as
        Intel® Math Kernel Library and Intel® Data Analytics Acceleration Library.
        Access the latest vectorization and multithreading instructions via Numba* and Cython*,
        composable parallelism with Threading Building Blocks.

        Download Intel Distribution for Python today.

        TensorFlow is an end-to-end open source platform for machine learning.
        TensorFlow makes it easy for beginners and experts to help develop and train ML models.
        Get started quickly by running Colab notebooks directly in your browser.

        Learn more at https://www.tensorflow.org/

### Silver sponsors

      Founded in 2001, Enthought helped establish Python's scientific community
      and became an early leader in scientific digital transformation. Our team of "scientists who code" pairs in-depth
      science expertise with data strategy, modeling, simulation, AI and more to transform businesses that depend on science.

      We solve complex problems for some of the most innovative and respected organizations across the oil and gas,
      life sciences, chemical, and semiconductor industries. Enthought is a highly collaborative, low-hierarchy workplace.
      "Enthoughters" are passionate about life, intellectually curious, dedicated to doing quality work, friendly, and fun.

      Enthought is headquartered in Austin, Texas, with offices in Houston, Texas, Cambridge, United Kingdom, Zürich, Switzerland, and Tokyo, Japan.

### Bronze sponsors

        Python Academy is a specialized Python training company.
        We offer open courses for individuals as well as customized on-site courses for companies and
        institutes. We cover a wide range of Python topics from introductory to
        advanced, Python for scientists and engineers, big data, machine learning, web
        development, code optimization, and many more.

        In addition to training, we consult companies that migrate to Python and
        develop high-quality Python software often in combination with training. Our
        special expertise is scientific and technical software development with Python.

        At Microsoft, our mission is to
        empower every person and every organization on the planet to achieve more.
        With Microsoft Azure you can build,deploy, and manage applications with
        a comprehensive set of cloud services designed for you.

        Learn more about Microsoft and the endless possibilities with Microsoft Azure on Monday,
        September 2 with Dr. Tania Allard during her session, Building data pipelines
        in Python: Airflow vs scripts soup. We are excited to see you at EuroSciPy 2019!

### Financial Aid sponsors

        The mission of NumFOCUS is to promote open practices in research, data, and scientific computing
        by serving as a fiscal sponsor for open source projects and organizing community-driven educational programs.

        NumFOCUS envisions an inclusive scientific and research community that utilizes actively supported
        open source software to make impactful discoveries for a better world.

        NumFOCUS is a 501(c)3 public charity in the United States.

        The mission of the Python Software Foundation is to promote,
        protect, and advance the Python programming language, and to support and facilitate the growth of a
        diverse and international community of Python programmers. The majority of the PSF's work is focused
        on empowering and supporting people within the Python community. The PSF has active grant programs
        that support sprints, conferences, meet ups, user groups, and Python development efforts all over the world.
        In addition, the PSF underwrites and runs PyCon US, the primary Python community conference.
        Being part of the PSF means being part of the Python community. Recently we changed the PSF
        to an open membership organization, so that everyone who uses and supports Python can join.
        To learn more, visit https://www.python.org/psf/membership.

        The EuroPython Society (EPS) is a Swedish non-profit organization
        which organizes EuroPython conferences, supports the Python community in Europe and holds the rights to the
        EuroPython conference series and trademarks.

        The EPS was formed in 2004, with the mission to turn EuroPython into a successful Python conference series
        for the years to come. In 2016, we have extended our mission to further the use of the programming language
        Python in Europe and organize events centered around the programming language Python to support this.

### Community sponsors

        O'Reilly is a learning company that helps individuals,
        teams, and enterprises build skills to succeed in a world defined by technology-driven transformation.
        From in-person conferences and live online training courses to self-directed learning
        and immediate access to problem solving online, O'Reilly has you and your team covered.

        Sticker Mule
        is the fastest and easiest way to buy custom printed
        products. Thousands of people trust us to make kick ass stickers, labels,
        magnets, badges & more. Order in seconds and get free online proofs, free
        shipping and super fast turnaround.

        At JetBrains, code is our passion.
        For over 15 years we have strived to make the strongest,
        most effective developer tools on earth. By automating routine checks and corrections,
        our tools speed up production, freeing developers to grow, discover and create.


text:
			function save(id, text)
			{
				jQuery('#text').val(text);
				jQuery('#save_as_request').val('0');
				jQuery('#name').val(currentName);
				jQuery('#folder').val(currentFolder);
				do_save(false);
			};
			function do_save(saveAsRequest)
			{
				jQuery('#windowProcessing').jqmShow();

			var options =
			{
				dataType: 'json',
				error: function (data, status, e)
				{
					alert(e);
				},
				success: function(data)
				{
										if(typeof(data.error) == 'undefined')
										{
											alert('Unexpected information ');

											if(typeof(saveAsRequest) == 'boolean' && saveAsRequest)
											{
												jQuery('#windowSaveAs').jqmShow();
											}
										}
										else if(data.error != '')
										{
											alert(data.error);
											jQuery('#windowProcessing').jqmHide();
											if(typeof(saveAsRequest) == 'boolean' && saveAsRequest)
											{
												jQuery('#windowSaveAs').jqmShow();
											}
										}else
										{
											jQuery('#windowProcessing').jqmHide();
											jQuery('#windowSaveAs').jqmHide();
											currentFolder = data.folder;
											currentName = data.name;
										}
				}
			};
			jQuery('#frmProcessing').ajaxSubmit(options);
			};
			function save_as(id, text)
			{

				jQuery('#text').val(text);
				jQuery('#windowSaveAs').jqmShow();
				var saveTo = jQuery('#save_to');
				jQuery(saveTo).removeOption(/./);
				jQuery(saveTo).ajaxAddOption(urlGetFolderList, {}, false,
																	function()
																	{
																			jQuery(saveTo).selectOptions(currentFolder);
																		});

			};
			function do_save_as()
			{
				var pattern=/^[A-Za-z0-9_ \-]+$/i;
				var newName = jQuery('#new_name');
				var saveAs = jQuery('#save_to').get(0);
				var ext = jQuery('#ext').get(0);
				if(!pattern.test(jQuery(newName).val()))
				{
					alert(warningInvalidName);
				}else if(saveAs.selectedIndex < 0)
				{
					alert(waringFolderNotSelected);
				}else if(ext.selectedIndex < 0)
				{
					alert(warningExtNotSelected);
				}
				else
				{

					jQuery('#name').val(jQuery(newName).val() + "." + ext.options[ext.selectedIndex].value);
					jQuery('#folder').val(saveAs.options[saveAs.selectedIndex].value);
					jQuery('#save_as_request').val('1');
					jQuery('#windowSaveAs').jqmHide();
					do_save(true);
				}
				return false;
			};


text:
int main(int argc, char * argv[])
{
    @autoreleasepool {
        return UIApplicationMain(argc, argv, nil, NSStringFromClass([INFAppDelegate class]));
    }
}


text:
BEGIN {
	require 'pathname'
	basedir = Pathname.new( __FILE__ ).dirname.parent.parent

	libdir = basedir + "lib"

	$LOAD_PATH.unshift( libdir ) unless $LOAD_PATH.include?( libdir )
}

begin
	require 'spec'
	require 'apache/fakerequest'
	require 'arrow'
	require 'arrow/applet'
	require 'arrow/appletregistry'
	require 'arrow/config'
	require 'spec/lib/helpers'
rescue LoadError
	unless Object.const_defined?( :Gem )
				retry
	end
	raise
end

#####################################################################
###	C O N T E X T S
#####################################################################

describe Arrow::AppletRegistry do
	include Arrow::SpecHelpers

	APPLETREGISTRY_TEST_CONFIG = {
		:applets => {
			:path			=> Arrow::Path.new( "applets:specs/data/applets" ),
			:pattern		=> '*.rb',
			:pollInterval	=> 5,
			:missingApplet	=> '/missing',
			:errorApplet	=> '/error',

			:layout			=> {
				"/"					=> "Setup",
				"/missing"			=> "NoSuchAppletHandler",
				"/error"			=> "ErrorHandler",
				"/status"			=> "ServerStatus",
				"/hello"			=> "Hello",
				"/args"				=> "ArgumentTester",
				"/protected"		=> "ProtectedDelegator",
				"/protected/hello"	=> "Hello",
				"/counted"			=> "AccessCounter",
				"/counted/hello"	=> "Hello",

				"/test"				=> "TestApplet",
				"/foo"				=> "BargleApplet",
			},
			:config			=> {},
		},
	}

	GEM_CONFIG = APPLETREGISTRY_TEST_CONFIG.merge({
		:gems => {
			:require_signed => false,
			:autoinstall    => false,
			:path           => Arrow::Path.new([ "gems", *Gem.path ]),
			:applets => {
				'arrow-demo-apps'       => '>= 0.0.3',
				'arrow-management-apps' => '= 0.9.4',
				'arrow-laikapedia'      => nil,
			},
		},
	})

	### Set up a stubbed applet instance that can be loaded via
	### Arrow::Applet.load.
	def fixture_appletclass( path, name, classname )
		applet = stub( "#{classname} instance (path)" )
		appletclass = stub( "#{classname} class",
			:name => name,
			:normalized_name => classname,
			:new => applet
		  )

		Arrow::Applet.should_receive( :load ).with( path ).once.
			and_return([ appletclass ])
		File.should_receive( :mtime ).with( path ).and_return( Time.now )

		return applet, appletclass
	end

	before( :all ) do
		setup_logging( :crit )
	end

	after( :all ) do
		reset_logging()
	end

	before( :each ) do
		Arrow::Applet.stub!( :load ).and_return( [] )
	end

	it "ignores the gem home if it isn't a directory" do
		homepath = mock( 'Pathname object for gem home' )

		Gem.should_receive( :user_home ).and_return( :user_home )
		Pathname.should_receive( :new ).with( :user_home ).and_return( homepath )
		homepath.should_receive( :+ ).with( 'gems' ).and_return( homepath )
		homepath.should_receive( :directory? ).and_return( false )

		Arrow::AppletRegistry.get_safe_gemhome.should be_nil()
	end

	it "ignores the gem home if it's world-writable" do
		homepath = mock( 'Pathname object for gem home' )
		homepath_stat = mock( 'Stat data for the gem home' )

		Gem.should_receive( :user_home ).and_return( :user_home )
		Pathname.should_receive( :new ).with( :user_home ).and_return( homepath )
		homepath.should_receive( :+ ).with( 'gems' ).and_return( homepath )
		homepath.should_receive( :directory? ).and_return( true )
		homepath.should_receive( :stat ).and_return( homepath_stat )

		homepath_stat.should_receive( :mode ).and_return( 0777 )

		Arrow::AppletRegistry.get_safe_gemhome.should be_nil()
	end

	it "returns an untainted Pathname for the gem home if it's sane" do
		homepath = mock( 'Pathname object for gem home' )
		homepath.taint
		homepath_stat = mock( 'Stat data for the gem home' )

		Gem.should_receive( :user_home ).and_return( :user_home )
		Pathname.should_receive( :new ).with( :user_home ).and_return( homepath )
		homepath.should_receive( :+ ).with( 'gems' ).and_return( homepath )
		homepath.should_receive( :directory? ).and_return( true )
		homepath.should_receive( :stat ).and_return( homepath_stat )

		homepath_stat.should_receive( :mode ).and_return( 0755 )

		rval = Arrow::AppletRegistry.get_safe_gemhome

		rval.should == homepath
		rval.should_not be_tainted()
	end

	it "loads any configured gems when it is created, and adds their template/ and applet/ " +
	   "directories to the template factory and path" do
		Gem.should_receive( :activate ).with( 'arrow-demo-apps', '>= 0.0.3' ).
			and_return( true )
		Gem.should_receive( :datadir ).with( 'arrow-demo-apps' ).
			and_return( '/some/path/arrow-demo-apps/data' )
		Gem.should_receive( :activate ).with( 'arrow-management-apps', '= 0.9.4' ).
			and_return( true )
		Gem.should_receive( :datadir ).with( 'arrow-management-apps' ).
			and_return( '/some/path/arrow-management-apps/data' )
		Gem.should_receive( :activate ).with( 'arrow-laikapedia', Gem::Requirement.default ).
			and_return( true )
		Gem.should_receive( :datadir ).with( 'arrow-laikapedia' ).
			and_return( '/some/path/arrow-laikapedia/data' )

		config = Arrow::Config.new( GEM_CONFIG )
		registry = Arrow::AppletRegistry.new( config )

		registry.template_factory.path.should have(5).members
		registry.template_factory.path.dirs.should include(
			'/some/path/arrow-demo-apps/data/templates',
			'/some/path/arrow-management-apps/data/templates',
			'/some/path/arrow-laikapedia/data/templates'
		)

		registry.path.should have(5).members
		registry.path.dirs.should include(
			'/some/path/arrow-demo-apps/data/applets',
			'/some/path/arrow-management-apps/data/applets',
			'/some/path/arrow-laikapedia/data/applets'
		)
	end

	it "searches for applets in its list of paths, and loads all of them" do
		test_applet, test_appletclass = fixture_appletclass( 'test.rb', 'test', 'TestApplet' )
		bargle_applet, bargle_appletclass = fixture_appletclass( 'bargle.rb', 'bargle', 'BargleApplet' )

		File.stub!( :exist? ).and_return( true )

		Dir.should_receive( :[] ).with( 'applets/*.rb' ).and_return([ 'test.rb', 'bargle.rb' ])

		applets_path = stub( 'applets path object', :dirs => ['applets'] )
		applets_path.stub!( :each ).and_yield( 'applets' )
		config = Arrow::Config.new( APPLETREGISTRY_TEST_CONFIG )
		config.applets.path = applets_path
		registry = Arrow::AppletRegistry.new( config )

		registry.urispace.should have(2).members
		registry.urispace.values.should include( bargle_applet, test_applet )
	end

	describe "instance" do

		before( :all ) do
			setup_logging( :crit )
		end

	    TEST_URISPACE = {
			""                => "Setup",
			"hello"           => "Hello",
			"args"            => "ArgumentTester",
			"protected"       => "ProtectedDelegator",
			"protected/hello" => "Hello",
			"counted"         => "AccessCounter",
			"counted/hello"   => "Hello",
	    }

		before( :each ) do
			@config = Arrow::Config.new( APPLETREGISTRY_TEST_CONFIG )
			@registry = Arrow::AppletRegistry.new( @config )
			@registry.instance_variable_set( :@urispace, TEST_URISPACE )
		end

		it "can create an applet chain for a uri" do
			@registry.find_applet_chain( '/protected/hello' ).should have(3).members
			@registry.find_applet_chain( '/protected/hello' ).
				collect {|cl| cl.path }.should == [ '', 'protected', 'protected/hello' ]
			@registry.find_applet_chain( '/protected/hello' ).
				collect {|cl| cl.applet }.should == [ 'Setup', 'ProtectedDelegator', 'Hello' ]

			@registry.find_applet_chain( '/protected' ).should have(2).members
			@registry.find_applet_chain( '/protected' ).
				collect {|cl| cl.path }.should == [ '', 'protected' ]
			@registry.find_applet_chain( '/protected' ).
				collect {|cl| cl.applet }.should == [ 'Setup', 'ProtectedDelegator' ]

			@registry.find_applet_chain( '/' ).should have(1).members
			@registry.find_applet_chain( '/' ).
				collect {|cl| cl.path }.should == [ '' ]
			@registry.find_applet_chain( '/' ).
				collect {|cl| cl.applet }.should == [ 'Setup' ]

			@registry.find_applet_chain( '/args' ).should have(2).members
			@registry.find_applet_chain( '/args' ).
				collect {|cl| cl.path }.should == [ '', 'args' ]
			@registry.find_applet_chain( '/args' ).
				collect {|cl| cl.applet }.should == [ 'Setup', 'ArgumentTester' ]
		end

		it "reloads its applets if the configured interval has passed since applets " +
		   "were loaded" do
			# Make sure the load time is far enough in the past
			@registry.load_time = Time.now - 2000
			@registry.should_receive( :reload_applets ).once
			@registry.check_for_updates
		end

		it "doesn't reload its applets if the configured interval hasn't passed since " +
		   "applets were loaded" do
			# Make sure the load time is far enough in the past
			@registry.load_time = Time.now
			@registry.should_not_receive( :reload_applets )
			@registry.check_for_updates
		end

		it "doesn't reload its applets if reloading is turned off (interval is zero)" do
			# Make sure the load time is far enough in the past
			@config.applets.pollInterval = 0
			@registry.load_time = Time.now - 2000
			@registry.should_not_receive( :reload_applets )
			@registry.check_for_updates
		end

	end

end


text:
package com.ispikemon.DemonicEmpowerment.init;

import com.ispikemon.DemonicEmpowerment.item.DEitem;
import com.ispikemon.DemonicEmpowerment.item.felSword;
import net.minecraft.client.Minecraft;
import net.minecraft.client.renderer.RenderItem;
import net.minecraft.client.renderer.block.model.ModelResourceLocation;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.registry.GameRegistry;

import java.util.ArrayList;
import java.util.List;

public class DEitems extends Items{

    public static List<Item> items = new ArrayList();
    public static Item FelRock = new DEitem("FelRock", 64);

    public static List<Item> itemList() {
        return items;
    }

    public static void register(FMLPreInitializationEvent preEvent) {
        for (Item item : itemList()){
            GameRegistry.register(item);
        }
    }

    public static void registerRender(FMLInitializationEvent event) {
        RenderItem renderItem = Minecraft.getMinecraft().getRenderItem();
        for (Item item : itemList()){
            renderItem.getItemModelMesher().register(item, 0, new ModelResourceLocation(item.getRegistryName().toString(), "inventory"));
        }
    }
}


text:
import {Activator} from './activator'
import {collectActivatables} from 'widget/activation/activation'
import {compose} from 'compose'
import {connect} from 'store'
import {shouldDeactivate} from 'widget/activation/activationPolicy'
import {withActivationContext} from 'widget/activation/activationContext'
import PropTypes from 'prop-types'
import React from 'react'
import _ from 'lodash'
import actionBuilder from 'action-builder'

const mapStateToProps = (state, ownProps) => {
    const {activationContext: {pathList}} = ownProps
    return {activatables: collectActivatables(state, pathList)}
}

class _Activatable extends React.Component {
    render() {
        const {id, activatables, children} = this.props
        const currentActivatable = activatables[id] || {}
        return currentActivatable.active
            ? <Activator
                id={id}>{activatorProps => children({...this.props, ...activatorProps, ...currentActivatable.activationProps})}</Activator>
            : null
    }

    componentDidMount() {
        this.updateReduxStateIfChanged()
    }

    componentDidUpdate() {
        this.updateReduxStateIfChanged()
    }

    componentWillUnmount() {
        const {id, activationContext: {pathList}} = this.props
        actionBuilder('REMOVE_ACTIVATABLE')
            .del([pathList, 'activatables', id])
            .dispatch()
    }

    updateReduxStateIfChanged() {
        const {id, policy, activatables, otherProps} = this.props
        const currentActivatable = activatables[id] || {}
        const currentActive = currentActivatable.active
        const currentPolicy = currentActivatable.policy
        const justActivated = currentActivatable.justActivated
        const nextPolicy = policy ? policy(otherProps) : undefined
        const nextActive = currentActive && (justActivated || !shouldDeactivate(id, activatables, nextPolicy))
        const shouldUpdatePolicy = currentActive !== nextActive
            || !_.isEqual(currentPolicy, nextPolicy)
            || justActivated
        if (shouldUpdatePolicy) {
            this.updateReduxState(nextPolicy, nextActive)
        }
    }

    updateReduxState(nextPolicy, active) {
        const {id, activationContext: {pathList}, alwaysAllow} = this.props
        const activatable = {
            id,
            path: [...pathList, 'activatables', id],
            active: !!active,
            justActivated: false,
            policy: nextPolicy,
            alwaysAllow
        }

        actionBuilder('UPDATE_ACTIVATABLE', activatable)
            .merge([pathList, 'activatables', id], activatable)
            .dispatch()
    }
}

export const Activatable = compose(
    _Activatable,
    connect(mapStateToProps),
    withActivationContext()
)

Activatable.propTypes = {
    children: PropTypes.func.isRequired,
    id: PropTypes.string.isRequired,
    policy: PropTypes.func
}

export const activatable = ({id, policy, alwaysAllow}) =>
    WrappedComponent =>
        class HigherOrderComponent extends React.Component {
            render() {
                const activatableId = _.isFunction(id) ? id(this.props) : id
                return (
                    <Activatable id={activatableId} policy={policy} alwaysAllow={alwaysAllow} otherProps={this.props}>
                        {activatable =>
                            React.createElement(
                                WrappedComponent,
                                {activatable, ...this.props}
                            )
                        }
                    </Activatable>
                )
            }
        }


text:
layout: page
title: Saunders Music Award Ceremony
date: 2016-05-24
author: Emma Hodges
tags: weekly links, java
status: published
summary: Vestibulum augue felis, consectetur ut scelerisque a, maximus sit amet.
banner: images/banner/leisure-03.jpg
booking:
  startDate: 06/25/2019
  endDate: 06/30/2019
  ctyhocn: LBFNEHX
  groupCode: SMAC
published: true
---
Proin at erat finibus diam feugiat bibendum. Fusce lectus mauris, mollis eget ante fringilla, accumsan pharetra justo. Nulla placerat dolor vitae ligula egestas, et elementum metus tristique. Suspendisse sodales venenatis mauris molestie facilisis. Phasellus at imperdiet turpis. Donec non velit a lacus eleifend placerat nec quis arcu. Cras ornare nunc leo. Maecenas sit amet viverra mauris. Donec nulla orci, mattis a iaculis sit amet, semper non magna. Praesent blandit nisi et lacus lacinia, vel feugiat turpis lacinia. Nunc ante massa, gravida in odio vitae, suscipit ornare libero. Nulla dignissim nulla vel urna suscipit bibendum.

* Donec at tortor et dui venenatis dapibus.

Nulla faucibus nibh scelerisque nibh consequat consectetur. Quisque et urna metus. Sed auctor, enim id ultricies scelerisque, magna mauris malesuada dui, sed placerat magna eros in odio. Suspendisse vehicula, purus in pellentesque laoreet, ante mi congue odio, vel fermentum tellus mauris vel orci. Sed semper faucibus massa eget venenatis. Nunc vel bibendum felis, tincidunt rutrum nisl. Proin sed congue libero, a porta leo.
Aenean elementum tortor quis erat egestas condimentum. Ut ac tempus arcu. Proin tincidunt accumsan vestibulum. Vestibulum in rutrum sem, vel ullamcorper lectus. Duis nec condimentum eros. Ut hendrerit, odio id varius ullamcorper, elit libero bibendum metus, non finibus nulla neque non turpis. Aenean aliquam et ligula et tristique. Maecenas tincidunt ut nisi at lobortis. Etiam fermentum nisi sem, eget tempus diam lacinia ac. Donec a pellentesque turpis.


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Monoscape.Common.Sockets.FileServer;
using System.Net;

namespace Monoscape.ApplicationGridController.Sockets
{
    public class ApFileTransferSocket : AbstractFileTransferSocket
    {
        public ApFileTransferSocket(IPAddress ipAddress, int port)
            : base(ipAddress, port)
        {
        }
    }
}


text:
import TestingBotLauncher from './launcher'

export default class TestingBotService {}
export const launcher = TestingBotLauncher


text:
<?php

// BONO
return array(
    // The providers
    'bono.providers' => array(
        // The version provider
        'BComp\\Provider\\VersionProvider' => array(
            // Enter the team hostnames computer here
            'local' => array(

            ),

            // Enter the remote hostnames computer here
            'remote' => array(

            ),
        ),

        // For logging purpose
        'BComp\\Provider\\LogProvider' => array(
            // Your log name
            'log.name' => 'ViperLog',

            // Path where log will be written
            'log.path' => 'logs',

            // The file format of logfile
            'log.format' => 'Y-m-d',

            // The used timezone for your logfile timestamp
            'log.timezone' => 'Asia/Jakarta'
        ),

        // The Norm Provider
        'Norm\\Provider\\NormProvider',

        // Kraken Provider
        'KrisanAlfa\\Kraken\\Provider\\KrakenProvider',

        // Facade Provider, also good for bind some dependencies in Resource Sharer Container
        'KrisanAlfa\\Kraken\\Provider\\FacadesProvider' => array(
            // The dependencies that will be bind to Kraken Container
            'dependencies' => array(
            ),
        ),

        // The Auth Provider
        // 'App\\Provider\\Auth' => array(
        //     'allowed' => array(
        //         '/'           => function() {},
        //         '/about'      => function() {},
        //         '/disclaimer' => function() {},
        //     ),
        // ),
    ),
);


text:
## SYNOPSIS
Returns a list of all fault-tolerant distributed file systems
for the current (or specified) domain.

Author: Ben Campbell (@meatballs__)
License: BSD 3-Clause
Required Dependencies: Get-DomainSearcher

## SYNTAX

```
Get-DomainDFSShare [[-Domain] <String[]>] [[-SearchBase] <String>] [[-Server] <String>]
 [[-SearchScope] <String>] [[-ResultPageSize] <Int32>] [[-ServerTimeLimit] <Int32>] [-Tombstone]
 [[-Credential] <PSCredential>] [[-Version] <String>]
```

## DESCRIPTION
This function searches for all distributed file systems (either version
1, 2, or both depending on -Version X) by searching for domain objects
matching (objectClass=fTDfs) or (objectClass=msDFS-Linkv2), respectively
The server data is parsed appropriately and returned.

## EXAMPLES

### -------------------------- EXAMPLE 1 --------------------------
```
Get-DomainDFSShare
```

Returns all distributed file system shares for the current domain.

### -------------------------- EXAMPLE 2 --------------------------
```
Get-DomainDFSShare -Domain testlab.local
```

Returns all distributed file system shares for the 'testlab.local' domain.

### -------------------------- EXAMPLE 3 --------------------------
```
$SecPassword = ConvertTo-SecureString 'Password123!' -AsPlainText -Force
```

$Cred = New-Object System.Management.Automation.PSCredential('TESTLAB\dfm.a', $SecPassword)
Get-DomainDFSShare -Credential $Cred

## PARAMETERS

### -Domain
Specifies the domain to use for the query, defaults to the current domain.

```yaml
Type: String[]
Parameter Sets: (All)
Aliases: DomainName, Name

Required: False
Position: 1
Default value: None
Accept pipeline input: True (ByPropertyName, ByValue)
Accept wildcard characters: False
```

### -SearchBase
The LDAP source to search through, e.g.
"LDAP://OU=secret,DC=testlab,DC=local"
Useful for OU queries.

```yaml
Type: String
Parameter Sets: (All)
Aliases: ADSPath

Required: False
Position: 2
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -Server
Specifies an Active Directory server (domain controller) to bind to.

```yaml
Type: String
Parameter Sets: (All)
Aliases: DomainController

Required: False
Position: 3
Default value: None
Accept pipeline input: False
Accept wildcard characters: False
```

### -SearchScope
Specifies the scope to search under, Base/OneLevel/Subtree (default of Subtree).

```yaml
Type: String
Parameter Sets: (All)
Aliases:

Required: False
Position: 4
Default value: Subtree
Accept pipeline input: False
Accept wildcard characters: False
```

### -ResultPageSize
Specifies the PageSize to set for the LDAP searcher object.

```yaml
Type: Int32
Parameter Sets: (All)
Aliases:

Required: False
Position: 5
Default value: 200
Accept pipeline input: False
Accept wildcard characters: False
```

### -ServerTimeLimit
Specifies the maximum amount of time the server spends searching.
Default of 120 seconds.

```yaml
Type: Int32
Parameter Sets: (All)
Aliases:

Required: False
Position: 6
Default value: 0
Accept pipeline input: False
Accept wildcard characters: False
```

### -Tombstone
Switch.
Specifies that the searcher should also return deleted/tombstoned objects.

```yaml
Type: SwitchParameter
Parameter Sets: (All)
Aliases:

Required: False
Position: Named
Default value: False
Accept pipeline input: False
Accept wildcard characters: False
```

### -Credential
A \[Management.Automation.PSCredential\] object of alternate credentials
for connection to the target domain.

```yaml
Type: PSCredential
Parameter Sets: (All)
Aliases:

Required: False
Position: 7
Default value: [Management.Automation.PSCredential]::Empty
Accept pipeline input: False
Accept wildcard characters: False
```

### -Version
{{Fill Version Description}}

```yaml
Type: String
Parameter Sets: (All)
Aliases:

Required: False
Position: 8
Default value: All
Accept pipeline input: False
Accept wildcard characters: False
```

## INPUTS

## OUTPUTS

### System.Management.Automation.PSCustomObject

A custom PSObject describing the distributed file systems.

## NOTES

## RELATED LINKS


text:
DEBUG = True
SQLALCHEMY_DATABASE_URI = 'sqlite:///db.db'
CACHE_TYPE = "null"


text:
package org.carlspring.strongbox.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;

@Configuration
public class DataServicePropertiesConfig
{

    @Bean
    public static PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer()
    {
        return new PropertySourcesPlaceholderConfigurer();
    }

}


text:
void MyMenu::registerWithTouchDispatcher(){
    CCDirector *dir=CCDirector::sharedDirector();
    dir->getTouchDispatcher()->addTargetedDelegate(this, 1, true);

}
bool MyMenu::ccTouchBegan(CCTouch* touch, CCEvent* event)
{

    moved = false;
    return CCMenu::ccTouchBegan(touch, event);

}
void MyMenu::ccTouchEnded(CCTouch* touch, CCEvent* event)
{
    if(!moved)
    {
        CCMenu::ccTouchEnded(touch, event);
    }

    if (m_pSelectedItem)
    {
        m_pSelectedItem->unselected();
    }

    m_eState = kCCMenuStateWaiting;

}
void MyMenu::ccTouchMoved(CCTouch* touch, CCEvent* event)
{
    moved = true;
    CCMenu::ccTouchMoved(touch, event);
}


text:
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.

using Azure.Core.TestFramework;
using NUnit.Framework;

namespace Azure.Core.Tests
{
    public class ResponseTests
    {
        [Test]
        public void ValueIsAccessible()
        {
            var response = Response.FromValue(new TestPayload("test_name"), response: null);
            TestPayload value = response.Value;

            Assert.IsNotNull(value);
            Assert.AreEqual("test_name", value.Name);
        }

        [Test]
        public void ValueObtainedFromCast()
        {
            var response = Response.FromValue(new TestPayload("test_name"), response: null);
            TestPayload value = response;

            Assert.IsNotNull(value);
            Assert.AreEqual("test_name", value.Name);
        }

        [Test]
        public void ToStringsFormatsStatusAndValue()
        {
            var response = Response.FromValue(new TestPayload("test_name"), response: new MockResponse(200));

            Assert.AreEqual("Status: 200, Value: Name: test_name", response.ToString());
        }

        [Test]
        public void ToStringsFormatsStatusAndResponsePhrase()
        {
            var response = new MockResponse(200, "Phrase");

            Assert.AreEqual("Status: 200, ReasonPhrase: Phrase", response.ToString());
        }

        [Test]
        public void ValueThrowsIfUnspecified()
        {
            var response = new NoBodyResponse<TestPayload>(new MockResponse(304));
            bool throws = false;
            try
            {
                TestPayload value = response.Value;
            }
            catch
            {
                throws = true;
            }

            Assert.True(throws);
        }

        [Test]
        public void ValueThrowsFromCastIfUnspecified()
        {
            var response = new NoBodyResponse<TestPayload>(new MockResponse(304));

            bool throws = false;
            try
            {
                TestPayload value = response;
            }
            catch
            {
                throws = true;
            }

            Assert.True(throws);
        }

        [Test]
        public void ToStringsFormatsStatusAndMessageForNoBodyResponse()
        {
            var response = new NoBodyResponse<TestPayload>(new MockResponse(200));

            Assert.AreEqual("Status: 200, Service returned no content", response.ToString());
        }

        internal class TestPayload
        {
            public string Name { get; }

            public TestPayload(string name)
            {
                Name = name;
            }

            public override string ToString()
            {
                return $"Name: {Name}";
            }
        }
    }

}


text:
#ifndef __CABLASTP_SEEDS_H__
#define __CABLASTP_SEEDS_H__

/* Apparently this is required to make pthread_rwlock* stuff available. */
#define __USE_UNIX98

#include <pthread.h>
#include <stdint.h>

#define CABLASTP_SEEDS_ALPHA_SIZE 23

const int8_t cbp_seeds_alpha_size[26];

struct cbp_seed_loc {
    uint32_t coarse_seq_id;
    uint16_t residue_index;
    struct cbp_seed_loc *next;
};

struct cbp_seed_loc *
cbp_seed_loc_init(uint32_t coarse_seq_id, uint16_t residue_index);

void
cbp_seed_loc_free(struct cbp_seed_loc *seedLoc);

struct cbp_seeds {
    int32_t seed_size;
    struct cbp_seed_loc **locs;
    int32_t locs_length;
    int32_t *powers;
    int32_t powers_length;
    pthread_rwlock_t lock;
};

struct cbp_seeds *
cbp_seeds_init(int32_t seed_size);

void
cbp_seeds_free(struct cbp_seeds *seeds);

struct cbp_coarse_seq;

void
cbp_seeds_add(struct cbp_seeds *seeds, struct cbp_coarse_seq *seq);

/* Produces a copy of the list of seeds for 'kmer', and therefore the
 * result needs to be freed with `cbp_seed_loc_free` when finished. */
struct cbp_seed_loc *
cbp_seeds_lookup(struct cbp_seeds *seeds, char *kmer);

#endif


text:
LEVEL = ../../../..

PROG     = Symbolics-dbl
LDFLAGS  = -lm
CFLAGS += -std=gnu99
RUN_OPTIONS = 9090 14
include $(LEVEL)/MultiSource/Makefile.multisrc


text:
namespace metrics {

// static
scoped_ptr<TrackingSynchronizerDelegate>
IOSTrackingSynchronizerDelegate::Create(TrackingSynchronizer* synchronizer) {
  return make_scoped_ptr(new IOSTrackingSynchronizerDelegate(synchronizer));
}

IOSTrackingSynchronizerDelegate::IOSTrackingSynchronizerDelegate(
    TrackingSynchronizer* synchronizer)
    : synchronizer_(synchronizer) {
  DCHECK(synchronizer_);
}

IOSTrackingSynchronizerDelegate::~IOSTrackingSynchronizerDelegate() {}

void IOSTrackingSynchronizerDelegate::GetProfilerDataForChildProcesses(
    int sequence_number,
    int current_profiling_phase) {
  // Notify |synchronizer_| that there are no processes pending (on iOS, there
  // is only the browser process).
  synchronizer_->OnPendingProcesses(sequence_number, 0, true);
}

void IOSTrackingSynchronizerDelegate::OnProfilingPhaseCompleted(
    int profiling_phase) {}

}  // namespace metrics


text:
    <isolation bench="tatp">|ISOLATION|</isolation>

    <!-- Scalefactor increases the number of subscribers -->
    <scalefactor bench="tatp">|SCALE|</scalefactor>

	<!-- Twitter Procedures declaration -->
    <transactiontypes bench="tatp">
        <transactiontype>
                <name>DeleteCallForwarding</name>
        </transactiontype>
        <transactiontype>
                <name>GetAccessData</name>
        </transactiontype>
        <transactiontype>
                <name>GetNewDestination</name>
        </transactiontype>
        <transactiontype>
                <name>GetSubscriberData</name>
        </transactiontype>
        <transactiontype>
                <name>InsertCallForwarding</name>
        </transactiontype>
        <transactiontype>
                <name>UpdateLocation</name>
        </transactiontype>
        <transactiontype>
                <name>UpdateSubscriberData</name>
        </transactiontype>
    </transactiontypes>


text:
function every(array, predicate) {
    for (var i = 0; i < array.length; ++i) {
        if (!(predicate(array[i]))) {
            return false;
        }
    }
    return true;
}

function some(array, predicate) {
    for (var i = 0; i< array.length; ++i) {
        if (predicate(array[i])) {
            return true;
        }
    }
    return false;
}

console.log('should be true: ' + every([NaN, NaN, NaN], isNaN));
console.log('should be false: ' + every([NaN, NaN, 4], isNaN));
console.log('should be true: ' + some([NaN, 3, 4], isNaN));
console.log('should be false: ' + some([2, 3, 4], isNaN));


text:
descr = """PySurfer: Python / FreeSurfer / Mayavi2 for brain imaging"""

import os
# deal with MPL sandbox violations during easy_install
os.environ['MPLCONFIGDIR'] = '.'

# get the version, don't import surfer here so setup works on headless systems
version = None
with open(os.path.join('surfer', '__init__.py'), 'r') as fid:
    for line in (line.strip() for line in fid):
        if line.startswith('__version__'):
            version = line.split('=')[1].strip().strip('"')
            break
if version is None:
    raise RuntimeError('Could not determine version')

DISTNAME = 'pysurfer'
DESCRIPTION = descr
LONG_DESCRIPTION = descr
MAINTAINER = 'Michael Waskom'
MAINTAINER_EMAIL = 'mwaskom@stanford.edu'
URL = 'http://pysurfer.github.com'
LICENSE = 'BSD (3-clause)'
DOWNLOAD_URL = 'https://github.com/nipy/PySurfer'
VERSION = version

from setuptools import setup

if __name__ == "__main__":
    if os.path.exists('MANIFEST'):
        os.remove('MANIFEST')

    setup(name=DISTNAME,
        maintainer=MAINTAINER,
        include_package_data=True,
        maintainer_email=MAINTAINER_EMAIL,
        description=DESCRIPTION,
        license=LICENSE,
        url=URL,
        version=VERSION,
        download_url=DOWNLOAD_URL,
        long_description=LONG_DESCRIPTION,
        zip_safe=False,  # the package can run out of an .egg file
        classifiers=['Intended Audience :: Science/Research',
                     'Intended Audience :: Developers',
                     'License :: OSI Approved',
                     'Programming Language :: Python',
                     'Topic :: Software Development',
                     'Topic :: Scientific/Engineering',
                     'Operating System :: Microsoft :: Windows',
                     'Operating System :: POSIX',
                     'Operating System :: Unix',
                     'Operating System :: MacOS'
                     ],
         platforms='any',
         packages=['surfer', 'surfer.tests'],
         scripts=['bin/pysurfer'],
    )


text:
import {Element as PolymerElement} from '../node_modules/@polymer/polymer/polymer-element.js';
import {MyApp} from './my-app/my-app-module.js';


text:
var util = ProjRequire('lib/util.js');
module.exports = {
	spec : function() {
		return {
			name : 'replaceAll',
			desc : 'To replace all occurrences of certain keyword (from) into another string (to) with a source string, and store result into a variable',
			fields : [
			{type:'string',name:'var',description:'The variable name to store the result',required:true},
			{type:'string',name:'source',description:'The source string to replace',required:true},
			{type:'string',name:'from',description:'The from keyword to replace',required:true},
			{type:'string',name:'to',description:'The target keyword to replace to',required:true}
			]
		}
	}
	,
	process : function(ctx, step, checkNext) {
		ctx.vars[step.var] = util.replaceAll(step.source, step.from, step.to);
		process.nextTick(checkNext);
	}
}


text:
package com.intellij.openapi.diff.impl.settings;

import com.intellij.application.options.colors.ColorAndFontDescription;
import com.intellij.application.options.colors.ColorAndFontOptions;
import com.intellij.application.options.colors.EditorSchemeAttributeDescriptor;
import com.intellij.application.options.colors.OptionsPanelImpl;
import com.intellij.diff.util.TextDiffTypeFactory;
import com.intellij.openapi.diff.DiffBundle;
import com.intellij.openapi.editor.colors.EditorColorsScheme;
import com.intellij.openapi.editor.markup.TextAttributes;
import com.intellij.util.EventDispatcher;
import consulo.awt.TargetAWT;
import consulo.ui.CheckBox;
import consulo.ui.ColorBox;
import consulo.ui.Label;
import consulo.ui.annotation.RequiredUIAccess;
import consulo.ui.color.ColorValue;
import consulo.ui.layout.VerticalLayout;
import consulo.ui.style.StandardColors;
import consulo.ui.util.FormBuilder;
import consulo.util.lang.ObjectUtil;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.swing.*;

class DiffColorDescriptionPanel implements OptionsPanelImpl.ColorDescriptionPanel {
  private final EventDispatcher<Listener> myDispatcher = EventDispatcher.create(Listener.class);

  private final VerticalLayout myPanel;

  private ColorBox myBackgroundColorPanel;
  private ColorBox myIgnoredColorPanel;
  private ColorBox myStripeMarkColorPanel;
  private CheckBox myInheritIgnoredCheckBox;

  @Nonnull
  private final ColorAndFontOptions myOptions;

  @RequiredUIAccess
  DiffColorDescriptionPanel(@Nonnull ColorAndFontOptions options) {
    myOptions = options;

    myPanel = VerticalLayout.create();

    FormBuilder builder = FormBuilder.create();
    builder.addLabeled(Label.create(DiffBundle.message("merge.color.options.background.color.label")), myBackgroundColorPanel = ColorBox.create());
    builder.addLabeled(Label.create(DiffBundle.message("merge.color.options.ignored.color.label")), myIgnoredColorPanel = ColorBox.create());
    builder.addLabeled(Label.create(DiffBundle.message("merge.color.options.stripe.mark.color.label")), myStripeMarkColorPanel = ColorBox.create());

    myPanel.add(builder.build());

    myInheritIgnoredCheckBox = CheckBox.create(DiffBundle.message("option.inherit.ignored.color"));
    myPanel.add(myInheritIgnoredCheckBox);

    myBackgroundColorPanel.addValueListener(event -> onSettingsChanged());
    myIgnoredColorPanel.addValueListener(event -> onSettingsChanged());
    myStripeMarkColorPanel.addValueListener(event -> onSettingsChanged());

    myInheritIgnoredCheckBox.addValueListener(e -> {
      myIgnoredColorPanel.setEnabled(!myInheritIgnoredCheckBox.getValueOrError());

      if (myInheritIgnoredCheckBox.getValueOrError()) {
        myIgnoredColorPanel.setValue(null);
      }
      else {
        ColorValue background = ObjectUtil.notNull(myBackgroundColorPanel.getValue(), StandardColors.WHITE);
        ColorValue gutterBackground = myOptions.getSelectedScheme().getDefaultBackground();
        myIgnoredColorPanel.setValue(TextDiffTypeFactory.getMiddleColor(background, gutterBackground));
      }

      onSettingsChanged();
    });
  }

  @Nonnull
  @Override
  public JComponent getPanel() {
    return (JComponent)TargetAWT.to(myPanel);
  }

  private void onSettingsChanged() {
    myDispatcher.getMulticaster().onSettingsChanged();
  }

  @Override
  @RequiredUIAccess
  public void resetDefault() {
    myBackgroundColorPanel.setEnabled(false);
    myIgnoredColorPanel.setEnabled(false);
    myStripeMarkColorPanel.setEnabled(false);
    myInheritIgnoredCheckBox.setEnabled(false);
    myInheritIgnoredCheckBox.setValue(false);
  }

  @Override
  @RequiredUIAccess
  public void reset(@Nonnull EditorSchemeAttributeDescriptor attrDescription) {
    if (!(attrDescription instanceof ColorAndFontDescription)) return;
    ColorAndFontDescription description = (ColorAndFontDescription)attrDescription;

    ColorValue backgroundColor = getBackgroundColor(description);
    ColorValue ignoredColor = getIgnoredColor(description);
    ColorValue stripeMarkColor = getStripeMarkColor(description);
    boolean inheritIgnored = ignoredColor == null;

    myBackgroundColorPanel.setEnabled(true);
    myIgnoredColorPanel.setEnabled(!inheritIgnored);
    myStripeMarkColorPanel.setEnabled(true);
    myInheritIgnoredCheckBox.setEnabled(true);

    myBackgroundColorPanel.setValue(backgroundColor, false);
    myIgnoredColorPanel.setValue(ignoredColor, false);
    myStripeMarkColorPanel.setValue(stripeMarkColor, false);
    myInheritIgnoredCheckBox.setValue(inheritIgnored);
  }

  @Override
  public void apply(@Nonnull EditorSchemeAttributeDescriptor attrDescription, EditorColorsScheme scheme) {
    if (!(attrDescription instanceof ColorAndFontDescription)) return;
    ColorAndFontDescription description = (ColorAndFontDescription)attrDescription;

    description.setBackgroundChecked(true);
    description.setForegroundChecked(true);
    description.setErrorStripeChecked(true);

    setBackgroundColor(description);
    setIgnoredColor(description);
    setStripeMarkColor(description);

    description.apply(scheme);
  }

  @Override
  public void addListener(@Nonnull Listener listener) {
    myDispatcher.addListener(listener);
  }

  @Nullable
  private static ColorValue getBackgroundColor(@Nonnull TextAttributes attributes) {
    return attributes.getBackgroundColor();
  }

  @Nullable
  private static ColorValue getIgnoredColor(@Nonnull TextAttributes attributes) {
    return attributes.getForegroundColor();
  }

  @Nullable
  private static ColorValue getStripeMarkColor(@Nonnull TextAttributes attributes) {
    return attributes.getErrorStripeColor();
  }

  private void setBackgroundColor(@Nonnull TextAttributes attributes) {
    attributes.setBackgroundColor(myBackgroundColorPanel.getValue());
  }

  private void setIgnoredColor(@Nonnull TextAttributes attributes) {
    attributes.setForegroundColor(myInheritIgnoredCheckBox.getValueOrError() ? null : myIgnoredColorPanel.getValue());
  }

  private void setStripeMarkColor(@Nonnull TextAttributes attributes) {
    attributes.setErrorStripeColor(myStripeMarkColorPanel.getValue());
  }
}


text:
declare module Handlebars {
    function registerHelper(name: string, fn: Function, inverse?: boolean): void;
    function registerPartial(name: string, str: any): void;
    function K(): void;
    function createFrame(object: any): any;
    function Exception(message: string): void;
    class SafeString {
        constructor(str: string);
        static toString(): string;
    }
    function parse(input: string): boolean;
    var logger: Logger;
    function log(level: number, obj: any): void;
    function compile(input: any, options?: any): (context: any, options?: any) => string;

    interface Logger {
        DEBUG: number;
        INFO: number;
        WARN: number;
        ERROR: number;
        level: number;

        methodMap: { [level: number]: string };

        log(level: number, obj: string): void;
    }
}


text:
package org.apache.nifi.web.api.entity;

import com.wordnik.swagger.annotations.ApiModelProperty;
import org.apache.nifi.web.api.dto.FlowConfigurationDTO;

import javax.xml.bind.annotation.XmlRootElement;

/**
 * A serialized representation of this class can be placed in the entity body of a request or response to or from the API. This particular entity holds a reference to a FlowConfigurationDTO.
 */
@XmlRootElement(name = "flowConfigurationEntity")
public class FlowConfigurationEntity extends Entity {

    private FlowConfigurationDTO flowConfiguration;

    /**
     * The FlowConfigurationDTO that is being serialized.
     *
     * @return The FlowConfigurationDTO object
     */
    @ApiModelProperty(
        value = "The controller configuration."
    )
    public FlowConfigurationDTO getFlowConfiguration() {
        return flowConfiguration;
    }

    public void setFlowConfiguration(FlowConfigurationDTO flowConfiguration) {
        this.flowConfiguration = flowConfiguration;
    }

}


text:
using System;
using System.Runtime.Serialization;

namespace Alachisoft.NCache.Parser
{
    [Serializable]
    public class TypeIndexNotDefined : Exception, ISerializable
    {
        public TypeIndexNotDefined(String error) : base(error)
        {
        }

        public TypeIndexNotDefined(String error, Exception exception) : base(error, exception)
        {
        }

        public TypeIndexNotDefined(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
    }
}


text:
#include "core/dom/custom/CustomElementAsyncImportMicrotaskQueue.h"

#include "core/dom/custom/CustomElementMicrotaskImportStep.h"

namespace blink {

void CustomElementAsyncImportMicrotaskQueue::enqueue(RawPtr<CustomElementMicrotaskStep> step)
{
    m_queue.append(step);
}

void CustomElementAsyncImportMicrotaskQueue::doDispatch()
{
    HeapVector<Member<CustomElementMicrotaskStep>> remaining;

    for (unsigned i = 0; i < m_queue.size(); ++i) {
        if (CustomElementMicrotaskStep::Processing == m_queue[i]->process())
            remaining.append(m_queue[i].release());
    }

    m_queue.swap(remaining);
}

} // namespace blink


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (c) 2005-2014, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
  ~
  ~   WSO2 Inc. licenses this file to you under the Apache License,
  ~   Version 2.0 (the "License"); you may not use this file except
  ~   in compliance with the License.
  ~   You may obtain a copy of the License at
  ~
  ~      http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~   Unless required by applicable law or agreed to in writing,
  ~   software distributed under the License is distributed on an
  ~   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  ~   KIND, either express or implied.  See the License for the
  ~   specific language governing permissions and limitations
  ~   under the License.
  -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">

    <parent>
        <groupId>org.wso2.carbon.messaging</groupId>
        <artifactId>andes</artifactId>
        <version>3.5.0-SNAPSHOT</version>
        <relativePath>../pom.xml</relativePath>
    </parent>

    <modelVersion>4.0.0</modelVersion>
    <version>3.5.0-SNAPSHOT</version>
    <artifactId>org.wso2.carbon.andes.cluster.mgt</artifactId>
    <packaging>bundle</packaging>
    <name>WSO2 Carbon - Component - MB Cluster Management - BE</name>
    <description>org.wso2.carbon.andes.cluster.mgt provides the back-end functionalities for cluster
        management of MB
    </description>
    <url>http://wso2.org</url>

    <dependencies>
        <dependency>
            <groupId>org.apache.axis2.wso2</groupId>
            <artifactId>axis2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.wso2.carbon</groupId>
            <artifactId>org.wso2.carbon.core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.wso2.carbon</groupId>
            <artifactId>org.wso2.carbon.utils</artifactId>
        </dependency>
        <dependency>
            <groupId>org.wso2.carbon.messaging</groupId>
            <artifactId>org.wso2.carbon.andes</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-scr-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>
                <extensions>true</extensions>
                <configuration>
                    <instructions>
                        <Bundle-SymbolicName>${project.artifactId}</Bundle-SymbolicName>
                        <Bundle-Name>${project.artifactId}</Bundle-Name>
                        <Private-Package>org.wso2.carbon.andes.cluster.mgt.internal.*
                        </Private-Package>
                        <Export-Package>!org.wso2.carbon.andes.cluster.mgt.internal,
                            org.wso2.carbon.andes.cluster.mgt.*
                        </Export-Package>
                        <Import-Package>org.osgi.framework, *;resolution:=optional</Import-Package>
                    </instructions>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>


text:
// @flow

import { JitsiRecordingConstants } from '../../../base/lib-jitsi-meet';
import { RecordingExpandedLabel } from '../../../recording';
import { TranscribingExpandedLabel } from '../../../transcribing';
import { VideoQualityExpandedLabel } from '../../../video-quality';

import InsecureRoomNameExpandedLabel from './InsecureRoomNameExpandedLabel';
import RaisedHandsCountExpandedLabel from './RaisedHandsCountExpandedLabel';

export const LabelHitSlop = {
    top: 10,
    bottom: 10,
    left: 0,
    right: 0
};

/**
 * Timeout to hide the {@ExpandedLabel}.
 */
export const EXPANDED_LABEL_TIMEOUT = 5000;

export const LABEL_ID_QUALITY = 'quality';
export const LABEL_ID_RECORDING = 'recording';
export const LABEL_ID_STREAMING = 'streaming';
export const LABEL_ID_TRANSCRIBING = 'transcribing';
export const LABEL_ID_INSECURE_ROOM_NAME = 'insecure-room-name';
export const LABEL_ID_RAISED_HANDS_COUNT = 'raised-hands-count';

/**
 * The {@code ExpandedLabel} components to be rendered for the individual
 * {@code Label}s.
 */
export const EXPANDED_LABELS = {
    [LABEL_ID_QUALITY]: VideoQualityExpandedLabel,
    [LABEL_ID_RECORDING]: {
        component: RecordingExpandedLabel,
        props: {
            mode: JitsiRecordingConstants.mode.FILE
        },
        alwaysOn: true
    },
    [LABEL_ID_STREAMING]: {
        component: RecordingExpandedLabel,
        props: {
            mode: JitsiRecordingConstants.mode.STREAM
        },
        alwaysOn: true
    },
    [LABEL_ID_TRANSCRIBING]: TranscribingExpandedLabel,
    [LABEL_ID_INSECURE_ROOM_NAME]: InsecureRoomNameExpandedLabel,
    [LABEL_ID_RAISED_HANDS_COUNT]: {
        component: RaisedHandsCountExpandedLabel,
        alwaysOn: true
    }
};


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycotaxon 3(2): 204 (1976)

#### Original name
Misgomyces ptenidii Scheloske, 1969

### Remarks
null


text:
CKEDITOR.plugins.setLang( 'a11yhelp', 'cs',
{
	accessibilityHelp :
	{
		title : 'Instrukce pro přístupnost',
		contents : 'Obsah nápovědy. Pro uzavření tohoto dialogu stiskněte klávesu ESC.',
		legend :
		[
			{
				name : 'Obecné',
				items :
						[
							{
								name : 'Panel nástrojů editoru',
								legend:
									'Stiskněte${toolbarFocus} k procházení panelu nástrojů. Přejděte na další a předchozí skupiny pomocí TAB a SHIFT-TAB. Přechod na další a předchozí tlačítko panelu nástrojů je pomocí ŠIPKA VPRAVO nebo ŠIPKA VLEVO. Stisknutím mezerníku nebo klávesy ENTER tlačítko aktivujete.'
							},

							{
								name : 'Dialogové okno editoru',
								legend :
									'Uvnitř dialogového okna stiskněte TAB pro přesunutí na další pole, stiskněte SHIFT + TAB pro přesun na předchozí pole, stiskněte ENTER pro odeslání dialogu, stiskněte ESC pro jeho zrušení. Pro dialogová okna, která mají mnoho karet stiskněte ALT + F10 pr oprocházení seznamu karet. Pak se přesuňte na další kartu pomocí TAB nebo ŠIPKA VPRAVO. Pro přesun na předchozí stiskněte SHIFT + TAB nebo ŠIPKA VLEVO. Stiskněte MEZERNÍK nebo ENTER pro vybrání stránky karet.'
							},

							{
								name : 'Kontextové menu editoru',
								legend :
									'Stiskněte ${contextMenu} nebo klávesu APPLICATION k otevření kontextového menu. Pak se přesuňte na další možnost menu pomocí TAB nebo ŠIPKY DOLŮ. Přesuňte se na předchozí možnost pomocí  SHIFT+TAB nebo ŠIPKY NAHORU. Stiskněte MEZERNÍK nebo ENTER pro zvolení možnosti menu. Podmenu současné možnosti otevřete pomocí MEZERNÍKU nebo ENTER či ŠIPKY DOLEVA. Kontextové menu uzavřete stiskem ESC.'
							},

							{
								name : 'Rámeček seznamu editoru',
								legend :
									'Inside a list-box, move to next list item with TAB OR DOWN ARROW. Move to previous list item with SHIFT + TAB or UP ARROW. Press SPACE or ENTER to select the list option. Press ESC to close the list-box.'  // MISSING
							},

							{
								name : 'Lišta cesty prvku v editoru',
								legend :
									'Press ${elementsPathFocus} to navigate to the elements path bar. Move to next element button with TAB or RIGHT ARROW. Move to previous button with  SHIFT+TAB or LEFT ARROW. Press SPACE or ENTER to select the element in editor.'  // MISSING
							}
						]
			},
			{
				name : 'Příkazy',
				items :
						[
							{
								name : ' Příkaz Zpět',
								legend : 'Stiskněte ${undo}'
							},
							{
								name : ' Příkaz Znovu',
								legend : 'Stiskněte ${redo}'
							},
							{
								name : ' Příkaz Tučné',
								legend : 'Stiskněte ${bold}'
							},
							{
								name : ' Příkaz Kurzíva',
								legend : 'Stiskněte ${italic}'
							},
							{
								name : ' Příkaz Podtržení',
								legend : 'Stiskněte ${underline}'
							},
							{
								name : ' Příkaz Odkaz',
								legend : 'Stiskněte ${link}'
							},
							{
								name : ' Příkaz Skrýt panel nástrojů',
								legend : 'Stiskněte ${toolbarCollapse}'
							},
							{
								name : ' Nápověda přístupnosti',
								legend : 'Stiskněte ${a11yHelp}'
							}
						]
			}
		]
	}
});


text:
<?php

/**
 * @xmlNamespace http://schema.intuit.com/finance/v3
 * @xmlType
 * @xmlName IPPSyncErrorResponse
 * @var IPPSyncErrorResponse
 * @xmlDefinition
                Product: QBW
                Description: Provides a wrapper for SyncError for Conflict API Response
                Consists of list of SyncError objects

 */
class IPPSyncErrorResponse
	{

		/**
		* Initializes this object, optionally with pre-defined property values
		*
		* Initializes this object and it's property members, using the dictionary
		* of key/value pairs passed as an optional argument.
		*
		* @param dictionary $keyValInitializers key/value pairs to be populated into object's properties
		* @param boolean $verbose specifies whether object should echo warnings
		*/
		public function __construct($keyValInitializers=array(), $verbose=FALSE)
		{
			foreach($keyValInitializers as $initPropName => $initPropVal)
			{
				if (property_exists('IPPSyncErrorResponse',$initPropName))
				{
					$this->{$initPropName} = $initPropVal;
				}
				else
				{
					if ($verbose)
						echo "Property does not exist ($initPropName) in class (".get_class($this).")";
				}
			}
		}

	/**
	 * @Definition
                        Product:QBW
                        Description: Wrapper of both types of Objects CloudVersion and QBVersion of objects
                        If there are multiple errored objects you will get a list of errored objects

	 * @xmlType element
	 * @xmlNamespace http://schema.intuit.com/finance/v3
	 * @xmlMinOccurs 0
	 * @xmlMaxOccurs unbounded
	 * @xmlName SyncError
	 * @var com\intuit\schema\finance\v3\IPPSyncError
	 */
	public $SyncError;
	/**
	 * @Definition
		           		Product: QBW
		           		Description: Specifies the latest time when Upload happened.

	 * @xmlType attribute
	 * @xmlName latestUploadTime
	 * @var string
	 */
	public $latestUploadTime;
	/**
	 * @Definition Specifies the starting row number in this result
	 * @xmlType attribute
	 * @xmlName startPosition
	 * @var integer
	 */
	public $startPosition;
	/**
	 * @Definition Specifies the number of records in this result
	 * @xmlType attribute
	 * @xmlName maxResults
	 * @var integer
	 */
	public $maxResults;
	/**
	 * @Definition Specifies the total count of records that satisfy the filter condition
	 * @xmlType attribute
	 * @xmlName totalCount
	 * @var integer
	 */
	public $totalCount;

} // end class IPPSyncErrorResponse


text:
/*
 * 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.
 */
package io.trino.operator.unnest;

import io.trino.spi.block.Block;
import io.trino.spi.block.ColumnarArray;
import io.trino.spi.block.ColumnarRow;
import org.openjdk.jol.info.ClassLayout;

import static io.airlift.slice.SizeOf.sizeOf;
import static io.trino.operator.unnest.UnnestOperator.ensureCapacity;
import static io.trino.spi.block.ColumnarArray.toColumnarArray;
import static io.trino.spi.block.ColumnarRow.toColumnarRow;
import static java.util.Objects.requireNonNull;

public class ArrayOfRowsUnnester
        implements Unnester
{
    private static final int INSTANCE_SIZE = ClassLayout.parseClass(ArrayOfRowsUnnester.class).instanceSize();

    private final int fieldCount;
    private final UnnestBlockBuilder[] blockBuilders;

    private int[] arrayLengths = new int[0];
    private ColumnarArray columnarArray;
    private ColumnarRow columnarRow;

    public ArrayOfRowsUnnester(int fieldCount)
    {
        blockBuilders = createUnnestBlockBuilders(fieldCount);
        this.fieldCount = fieldCount;
    }

    private static UnnestBlockBuilder[] createUnnestBlockBuilders(int fieldCount)
    {
        UnnestBlockBuilder[] builders = new UnnestBlockBuilder[fieldCount];
        for (int i = 0; i < fieldCount; i++) {
            builders[i] = new UnnestBlockBuilder();
        }
        return builders;
    }

    @Override
    public int getChannelCount()
    {
        return fieldCount;
    }

    @Override
    public void resetInput(Block block)
    {
        requireNonNull(block, "block is null");
        columnarArray = toColumnarArray(block);
        columnarRow = toColumnarRow(columnarArray.getElementsBlock());

        for (int i = 0; i < fieldCount; i++) {
            blockBuilders[i].resetInputBlock(columnarRow.getField(i), columnarRow.getNullCheckBlock());
        }

        int positionCount = block.getPositionCount();
        arrayLengths = ensureCapacity(arrayLengths, positionCount, false);
        for (int j = 0; j < positionCount; j++) {
            arrayLengths[j] = columnarArray.getLength(j);
        }
    }

    @Override
    public int[] getOutputEntriesPerPosition()
    {
        return arrayLengths;
    }

    @Override
    public Block[] buildOutputBlocks(int[] outputEntriesPerPosition, int startPosition, int batchSize, int outputRowCount)
    {
        boolean nullRequired = needToInsertNulls(startPosition, batchSize, outputRowCount);

        Block[] outputBlocks = new Block[fieldCount];
        for (int i = 0; i < fieldCount; i++) {
            if (nullRequired) {
                outputBlocks[i] = blockBuilders[i].buildWithNulls(outputEntriesPerPosition, startPosition, batchSize, outputRowCount, arrayLengths);
            }
            else {
                outputBlocks[i] = blockBuilders[i].buildWithoutNulls(outputRowCount);
            }
        }

        return outputBlocks;
    }

    private boolean needToInsertNulls(int offset, int inputBatchSize, int outputRowCount)
    {
        int start = columnarArray.getOffset(offset);
        int end = columnarArray.getOffset(offset + inputBatchSize);
        int totalLength = end - start;

        if (totalLength < outputRowCount) {
            return true;
        }

        if (columnarRow.mayHaveNull()) {
            for (int i = start; i < end; i++) {
                if (columnarRow.isNull(i)) {
                    return true;
                }
            }
        }

        return false;
    }

    @Override
    public long getRetainedSizeInBytes()
    {
        // The lengths array in blockBuilders is the same object as in the unnester and doesn't need to be counted again.
        return INSTANCE_SIZE + sizeOf(arrayLengths);
    }
}


text:
package common.preparation;

import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertThat;

import java.io.IOException;

import org.junit.Test;

public class BufferedFileReaderTest {

	private static final String FILE_PATH = "src/test/resources/resources/bufferedFileReaderTest.txt";

	@Test
	public void readLineFromFile() throws IOException {
		String result;
		try (BufferedFileReader bufferedFileReader = new BufferedFileReader(FILE_PATH)) {
			result = bufferedFileReader.readLine();
		}

		assertThat(result, is("works!"));
	}
}


text:
package builds

import (
	"fmt"

	g "github.com/onsi/ginkgo/v2"
	o "github.com/onsi/gomega"

	admissionapi "k8s.io/pod-security-admission/api"

	exutil "github.com/openshift/origin/test/extended/util"
)

var _ = g.Describe("[sig-builds][Feature:Builds][pullsecret] docker build using a pull secret", func() {
	defer g.GinkgoRecover()
	const (
		buildTestPod     = "build-test-pod"
		buildTestService = "build-test-svc"
	)

	var (
		buildFixture = exutil.FixturePath("testdata", "builds", "test-docker-build-pullsecret.json")
		oc           = exutil.NewCLIWithPodSecurityLevel("docker-build-pullsecret", admissionapi.LevelBaseline)
	)

	g.Context("", func() {

		g.BeforeEach(func() {
			exutil.PreTestDump()
		})

		g.AfterEach(func() {
			if g.CurrentSpecReport().Failed() {
				exutil.DumpPodStates(oc)
				exutil.DumpConfigMapStates(oc)
				exutil.DumpPodLogsStartingWith("", oc)
			}
		})

		g.Describe("Building from a template", func() {
			g.It("should create a docker build that pulls using a secret run it [apigroup:build.openshift.io]", func() {

				g.By(fmt.Sprintf("calling oc create -f %q", buildFixture))
				err := oc.Run("create").Args("-f", buildFixture).Execute()
				o.Expect(err).NotTo(o.HaveOccurred())

				g.By("starting a build")
				br, err := exutil.StartBuildAndWait(oc, "docker-build")
				o.Expect(err).NotTo(o.HaveOccurred())
				br.AssertSuccess()

				g.By("starting a second build that pulls the image from the first build")
				br, err = exutil.StartBuildAndWait(oc, "docker-build-pull")
				o.Expect(err).NotTo(o.HaveOccurred())
				br.AssertSuccess()

			})
		})
	})
})


text:
{
    'name': 'Events Sales',
    'version': '1.1',
    'category': 'Marketing',
    'website': 'https://www.odoo.com/page/events',
    'description': """
Creating registration with sale orders.
=======================================

This module allows you to automate and connect your registration creation with
your main sale flow and therefore, to enable the invoicing feature of registrations.

It defines a new kind of service products that offers you the possibility to
choose an event category associated with it. When you encode a sale order for
that product, you will be able to choose an existing event of that category and
when you confirm your sale order it will automatically create a registration for
this event.
""",
    'depends': ['event', 'sale'],
    'data': [
        'views/event.xml',
        'views/product.xml',
        'views/sale_order.xml',
        'event_sale_data.xml',
        'report/event_event_templates.xml',
        'security/ir.model.access.csv',
        'wizard/event_edit_registration.xml',
    ],
    'demo': ['event_demo.xml'],
    'test': ['test/confirm.yml'],
    'installable': True,
    'auto_install': True
}


text:
<!-- markdown-toc start - Don't edit this section. Run M-x markdown-toc-refresh-toc -->
**Table of Contents**

- [Limitations](#limitations)
    - [Overview](#overview)
    - [Finite Loops](#finite-loops)
    - [Identifying and Resolving Non-Termination](#identifying-and-resolving-non-termination)
    - [Fixed-size Inputs and Outputs](#fixed-size-inputs-and-outputs)
    - [Other Generic Limitations](#other-generic-limitations)
    - [Other Java Limitations](#other-java-limitations)
    - [Other LLVM Limitations](#other-llvm-limitations)
    - [Crucible LLVM Limitations](#crucible-llvm-limitations)

<!-- markdown-toc end -->

## Overview

There are a few limitations on the types of code that SAW can process.
Some of these limitations arise from the impossibility of automatically
deciding certain theoretical problems, and some arise more narrowly from
the specific analysis algorithms that we have chosen to use.

Ultimately, due to several closely related theoretical results (known as
the halting problem, Rice's theorem, Gödel's completeness theorem, among
others), there will always be *some* combination of a program and a
property that a given automated analysis system cannot prove. But we
have some flexibility to decide which sorts of programs and properties
we can prove and which we cannot.

SAW builds on two fundamental technologies at the moment, and inherits
the benefits and limitations of both. These two technologies are 1)
symbolic execution with path merging, and 2) SAT and SMT solvers.

The use of symbolic execution limits the style of *loops* SAW can
handle. And the use of SAT and SMT limits the sorts of data structures
SAW can handle in initial and final states of a program. In addition to
these broader limitations, there are some specific details of the Java
and LLVM languages that are not currently supported, but that could be
supported in the future.

At the most abstract level, the two key restrictions are these:

  * All loops must iterate only a finite, fixed number of times during
    execution of the program, based on the specific inputs to the
    symbolic execution process (some of which may be constant values
    rather than symbolic variables).

  * All programs must have initial states and final states that consist
    of a finite, fixed number of bits. Linked lists and dynamic memory
    allocation, for example, are supported, but only in a limited way.
    For instance, a program can take a linked list as input but only if
    the number of elements in that list and the arrangement of pointers
    is known and specified in advance.

The rest of this document describes these limitations in more detail.

## Finite Loops

The standard approach to symbolic execution involves forward execution
of a program with symbolic values. At each branch, the symbolic
execution engine executes *both* alternatives. And, in our
implementation, when reaching a point that both branches must ultimately
lead to (a *post-dominator* of the branch), we merge the symbolic states
created for each branch. Because SAW operates on programs in the JVM or
LLVM languages, which are unstructured control-flow graphs, loops are
just a specific case of branches.

In the most straightforward implementation, this would mean that
symbolic execution of a program containing loops would never terminate.
In SAW, there are two mechanisms, one always enabled and one optional,
that allow some loops to terminate.

The first mechanism is automated simplification of expressions during
symbolic execution. If the value of a variable is constant and it is
updated according to an operation entirely of constants, the result will
still be constant. And comparison between constants will yield a
constant result. And, when SAW executes a conditional branch, it first
checks to see whether the condition is equal to the constant `true` or
`false`. If it is, SAW will execute only one of the branches. So, for
example, a loop that counts from the constant 1 to the constant 10 will
terminate.

The second mechanism, which can be enabled or disabled, is the use of a
SAT solver to determine whether branch conditions are semantically
equivalent to `true` or `false`, even if they are not syntactically
equivalent. For example, consider a loop that counts from `x` to `y`,
where both are input variables, but inside a conditional that guarantees
that `y - x` is less than 10. This loop is also guaranteed to terminate
after 10 iterations, but it requires deeper reasoning to determine that
it will. Enabling path satisfiability checking will allow SAW to
terminate when analyzing this program.

So, as a general rule, if symbolic execution does not seem to be
terminating on the program under analysis, consider enabling branch
satisfiability checking.

## Identifying and Resolving Non-Termination

To determine whether path satisfiability checking will be helpful when
verification is taking a long time, several debugging flags can help
determine where execution is getting stuck. In general, most cases of
slow verification come from one of three sources: slow execution of
individual instructions, usually due to memory loads or stores at
symbolic addresses; slow execution of an external theorem prover; or
re-executing the body of a loop a large or unbounded number of times.
Path satisfiability checking only affects the last of these three.

The first step in determining what might be causing performance problems
is to trace execution of individual instructions, enabled with the `-d`
flag followed by a specific verbosity level to enable. For the older
LLVM-based interface (`llvm_extract`, `llvm_symexec` and `llvm_verify`)
use `-d2`. For Java analysis, or Crucible-based LLVM analysis, use
`-d4`.

If you see the output pause after execution of a load or store
instruction, then complex symbolic addresses are probably to blame. If
you see the output pause after a return instruction, then a slow
external prover is probably to blame (and it may be worth trying a
different prover). If you see a steady stream of instructions being
executed, however, then either the code being analyzed is large and it
simply hasn't reached the end yet (which could mean that loops have
constant but large iteration bounds), or it could mean that symbolic
execution is getting stuck in an infinite loop. In this case, path
satisfiability checking may allow it to terminate.

## Fixed-size Inputs and Outputs

The second major limitation in SAW is that the inputs and outputs of
symbolic execution need to have fixed size. In a more concrete technical
sense, this means that each pointer used in a program must either be
considered to be pre-allocated to point to a constant-sized object
before symbolic execution, or point to a constant-sized object allocated
during execution. In practice, this primarily means that arrays must
have constant sizes and that internal pointers (pointer or object fields
of structs or classes) must point to something specific. The only values
allowed to be symbolic during execution are those of scalar variables,
arrays, or scalar fields of aggregate types. The one exception is that,
in LLVM, a pointer may be symbolic if it will never be dereferenced
during the execution of the code being analyzed.

It is worth noting that the restriction to fixed-size inputs and outputs
is actually a necessary consequence of the treatment of loops within
SAW. If a loop must terminate after a fixed number of iterations, it can
access only a finite portion of a heap data structure (even if, in
theory, that data structure extends beyond the portion accessed).

## Other Generic Limitations

Neither the Java or the LLVM simulation support handling of exceptions.
Java programs can throw exceptions, but they are treated as simulation
failures. Verification of a method that throws an exception includes
proving that the path resulting in the exception is infeasible.

Floating point calculations are only supported on concrete values in
Java. Symbolic execution will fail if it encounters floating point
operations on symbolic values. For LLVM, floating point is not supported
at all.

In general, I/O is not supported. Simple printing (`printf` or
`System.out.println`) does work, but other I/O operations will generally
lead to failure of symbolic execution. To analyze code that performs I/O
in some way, it is sometimes possible to create overrides for the I/O
functions or methods. These overrides might assume, for instance, that a
`read` call always reads 10 bytes and that the values of these bytes are
completely arbitrary.

Similarly, code that performs system calls is generally not supported.

## Other Java Limitations

In Java, there is no way to specify the contents of arrays of
references. Such arrays can be used internally in computations, but
there's no way to write a specification for a method that takes them as
input or produces them as output.

Multi-dimensional arrays are not supported.

Native methods are generally not supported, unless there's a special
case in the simulator to provide alternative semantics for them. The
methods currently supported by the simulator include:

* `System.out.print`
* `System.out.println`
* `java.lang.Boolean.valueOf`
* `java.lang.Byte.valueOf`
* `java.lang.Short.valueOf`
* `java.lang.Integer.valueOf`
* `java.lang.Long.valueOf`
* `java.lang.Class.desiredAssertionStatus0`
* `java.lang.Class.getClassLoader`
* `java.lang.Class.getComponentType`
* `java.lang.Class.getPrimitiveClass`
* `java.lang.Class.isArray`
* `java.lang.Class.isPrimitive`
* `java.lang.Class.registerNatives`
* `java.lang.ClassLoader.registerNatives`
* `java.lang.Double.doubleToRawLongBits`
* `java.lang.Float.floatToRawIntBits`
* `java.lang.Runtime.gc`
* `java.lang.String.intern`
* `java.lang.StringBuilder.append`
* `java.lang.System.arraycopy`
* `java.lang.System.exit`
* `java.lang.System.nanoTime`
* `java.lang.System.currentTimeMillis`
* `java.lang.System.identityHashCode`
* `java.lang.Thread.registerNatives`
* `java.lang.Throwable.fillInStackTrace`
* `java.io.BufferedOutputStream.flush`
* `java.io.FileInputStream.initIDs`
* `java.io.FileOutputStream.initIDs`
* `java.io.ObjectStreamClass.initIDs`
* `java.io.RandomAccessFile.initIDs`
* `java.security.AccessController.doPrivileged`
* `java.util.Arrays.fill`

## Other LLVM Limitations

Only a subset of the LLVM intrinsic functions are supported. These
include:

* `llvm.bswap.i16`
* `llvm.bswap.i32`
* `llvm.bswap.i48`
* `llvm.bswap.i64`
* `llvm.expect.i32`
* `llvm.expect.i64`
* `llvm.lifetime.start`
* `llvm.lifetime.end`
* `llvm.memcpy.p0i8.p0i8.i32`
* `llvm.memcpy.p0i8.p0i8.i64`
* `llvm.memset.p0i8.i32`
* `llvm.memset.p0i8.i64`
* `llvm.objectsize.i32.p0i8`
* `llvm.objectsize.i64.p0i8`
* `llvm.sadd.with.overflow`
* `llvm.uadd.with.overflow`

And a subset of the C standard library is supported:

* `__assert_fail`
* `__assert_rtn`
* `__memset_chk`
* `__memcpy_chk`
* `alloca`
* `calloc`
* `free`
* `malloc`
* `printf`

Casts between pointers and integers are limited. The constant 0 is
allowed to be a value of pointer type, and it is never equal to any
normal pointer. Pointers can be cast to integers only for temporary
storage and subsequent conversion back to pointer type without
modification.

## Crucible LLVM Limitations

As with the legacy LLVM backend, only certain intrinsics are implemented.
These include:

<!-- This list is generated from the Crucible source code:
     curl https://raw.githubusercontent.com/GaloisInc/crucible/master/crucible-llvm/src/Lang/Crucible/LLVM/Intrinsics.hs | grep "let nm = " | perl -p -i -e 's/let nm = "(.+)" in/\1/' | sort
-->

* `llvm.ctlz.i32`
* `llvm.lifetime.end`
* `llvm.lifetime.start`
* `llvm.memcpy.p0i8.p0i8.i32`
* `llvm.memcpy.p0i8.p0i8.i64`
* `llvm.memmove.p0i8.p0i8.i32`
* `llvm.memmove.p0i8.p0i8.i64`
* `llvm.memset.p0i8.i32`
* `llvm.memset.p0i8.i64`
* `llvm.objectsize.i32.p0i8`
* `llvm.objectsize.i64.p0i8`

And the subset of the C standard library:

* `__assert_rtn`
* `__memcpy_chk`
* `__memset_chk`
* `calloc`
* `free`
* `malloc`
* `memcpy`
* `memmove`
* `memset`
* `printf`
* `putchar`
* `puts`


text:
package gw.lang;

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

@Retention(RetentionPolicy.RUNTIME)
@Target( { } )
@Inherited
@java.lang.Deprecated
@Deprecated("This annotation is deprecated and will be ignored if you add it to a new file. Do NOT use.")
public @interface PublishedType
{
  String fromType();
  String toType();
}


text:
using System;
using System.Linq;

namespace Core {
    using System.Collections.Generic;
    using System.Drawing;
    using System.IO;

    using SlimDX;
    using SlimDX.Direct3D11;

    using Device = SlimDX.Direct3D11.Device;

    public class TextureAtlas : DisposableClass {
        private bool _disposed;
        private readonly Matrix[] _texTransforms;
        private ShaderResourceView _textureView;

        public int Rows { get; private set; }
        public int Columns { get; private set; }
        public int NumCells { get; private set; }

        public ShaderResourceView TextureView {
            get { return _textureView; }
            private set { _textureView = value; }
        }

        public Matrix GetTexTransform(int i) {
            System.Diagnostics.Debug.Assert(i >= 0 && i < NumCells);
            return _texTransforms[i];
        }

        public TextureAtlas(Device device, ICollection<string> filenames) {
            NumCells = filenames.Count;

            // Note: all textures need to be the same size
            var tex = Texture2D.FromFile(device, filenames.First());
            var w = tex.Description.Width;
            var h = tex.Description.Height;
            tex.Dispose();

            Columns = Math.Min(8192 / w, (int)Math.Ceiling(Math.Sqrt(NumCells)));
            Rows = Math.Min(8192 / h, (int)Math.Ceiling((float)NumCells/Columns));

            System.Diagnostics.Debug.Assert(Columns * Rows >= NumCells);

            var bitmap = new Bitmap(Columns * w, Rows * h);
            _texTransforms = new Matrix[NumCells];

            using (var g = Graphics.FromImage(bitmap)) {
                g.Clear(Color.Black);
                var r = 0;
                var c = 0;
                foreach (var filename in filenames) {
                    g.DrawImage(new Bitmap(filename), new Point(c*w, r*h) );

                    _texTransforms[r * Columns + c] =
                        Matrix.Scaling(1.0f/(Columns*2), 1.0f / (2*Rows), 0) *
                        Matrix.Translation(c * w / (float)bitmap.Width, r * h / (float)bitmap.Width, 0);

                    c++;
                    if (c >= Columns) {
                        c = 0;
                        r++;
                    }

                }
            }
            var tmpFile = Path.GetTempFileName() + ".bmp";
            bitmap.Save(tmpFile);

            TextureView = ShaderResourceView.FromFile(device, tmpFile);
            TextureView.Resource.DebugName = "texture atlas: " +filenames.Aggregate((i, j) => i + ", " + j);
        }

        protected override void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    Util.ReleaseCom(ref _textureView);
                }
                _disposed = true;
            }
            base.Dispose(disposing);
        }
    }
}


text:
appengine-try-java
==================

Google App Engine Java sample


text:
package org.ister.nerlo;

import java.util.concurrent.*;

/**
 *
 * @author ingo
 *
 * @param <V>
 */
public interface Fiber<V> extends Callable<V> {

}