text:
mkdir -p ../generated
# The full chart with all information.
./gen_html.py > ../generated/full.html
# All information, but only with the symbols that are in the proposal.
./gen_html.py --only_in_proposal > ../generated/utc.html
# All symbols, but shorter format. Omits carrier character codes.
./gen_html.py --no_codes > ../generated/short.html
# Special chart for the font and glyph design.
# ./gen_html.py --design > ../generated/design.html
# Special chart with only the symbols proposed for new encoding,
# sorted by Unicode code points.
./gen_html.py --proposed_by_unicode --show_only_font_chars > ../generated/proposed.html
# All information, but only with the symbols that are in the proposal.
# Same as utc.html but uses the fonts rather than the images.
./gen_html.py --only_in_proposal --show_only_font_chars > ../generated/utc_pdf.html
# All information, except category names, temporary and design notes;
# sorted by Unicode code points.
./gen_html.py --emoji_data > ../generated/emojidata.html


text:
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html>
<head>
<script src="../resources/gc.js"></script>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="resources/testharness-adapter.js"></script>
</head>
<body>
<script>
description("Tests that we do not crash when a Geolocation request is made from a remote frame, which is then removed from the DOM in the error callback.");

function onIframeReady() {
    // Make request from remote frame
    iframe.contentWindow.navigator.geolocation.getCurrentPosition(function() {
        testFailed('Success callback invoked unexpectedly');
        finishJSTest();
    }, function() {
        testPassed('Error callback invoked.');
        document.body.removeChild(iframe);
        gc();
        finishJSTest();
    });
}

var iframe = document.createElement('iframe');
iframe.src = 'resources/remove-remote-context-in-error-callback-crash-inner.html';
document.body.appendChild(iframe);
</script>
</body>
</html>

redpajama_set_name: RedPajamaGithub


text:
@interface SimulatorLauncher : NSObject <DTiPhoneSimulatorSessionDelegate>

@property (nonatomic, strong, readonly) NSError *launchError;
@property (nonatomic, copy) NSNumber *launchTimeout;

+ (void)loadAllPlatforms;
- (instancetype)initWithSessionConfig:(DTiPhoneSimulatorSessionConfig *)sessionConfig
                 deviceName:(NSString *)deviceName;
- (BOOL)launchAndWaitForExit;
- (BOOL)launchAndWaitForStart;

@end


text:
package com.dz.store.es;

import com.dz.dsl.GetByKeyRequest;
import com.dz.dsl.PagedRequest;
import com.dz.dsl.extension.GetByUrlRequest;
import org.elasticsearch.index.query.FilterBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.search.sort.SortBuilder;

/**
 * @author mamad
 * @since 15/11/14.
 */
public interface EsQueryBuilderFactory {
    QueryBuilder create(PagedRequest request);

    FilterBuilder create(GetByUrlRequest request);

    FilterBuilder create(GetByKeyRequest request);

    SortBuilder sortBySaveDate();
}


text:
编辑历史事件

			事件名称:<input value = "{{event_name}}" type="text" id="event_name" class="txtInput" style="width:100%;"></input>

			发生地点:<input type="text" id="tem" class="txtInput" style="width:100%;"  readonly="readonly" value="请先选择朝代"></input>

			时间范围:

			<input value = "{{start_date}}" type="text" id="place_start" class="txtInput" value="开始时间" onfocus="onTimeStartfocus('place_start')" onblur="onTimeStartBlur('place_start')" style="float:left; width:49%;"></input>
			&nbsp-&nbsp
			<input value = "{{end_date}}" type="text" id="place_end" class="txtInput" value="结束时间" onfocus="onTimeEndfocus('place_end')" onblur="onTimeEndBlur('place_end')" style="float:left; width:49%;"></input>

			参与人物:
			<input value = "{{people}}" type="text" id="event_people" class="txtInput" style="width:100%;"></input>

			事件影响:
			<input value = "{{influ}}" type="text" id="event_infu" class="txtInput" style="width:100%;"></input>

			基本信息:
			<input value = "{{summary}}" type="text" id="event_summary" class="txtInput" style="width:100%;"></input>

			详细介绍:
			<input value = "{{detail_url}}" type="text" id="event_detail" class="txtInput" style="width:100%;"></input>

			相关视频:
			<input value = "{{event_video}}" type="text" id="event_video" class="txtInput" style="width:100%;"></input>

		<input type="button" id="event_submit" class="buttonInput" style="margin-top:10px; width:100%;" value="提交"></input>
		<input type="button" id="event_cancel" class="buttonInput" style="margin-top:10px; width:100%;" value="取消"></input>


text:
define(
	[
		'whynot/Generation',
		'whynot/Thread'
	],
	function(
		Generation,
		Thread
		) {
		'use strict';

		describe('Generation', function() {
			var generation;
			beforeEach(function() {
				generation = new Generation(10, [], 0);
			});

			describe('.reset()', function() {
				it('empties the Generation', function() {
					generation.reset();
					chai.expect(generation.getNextThread()).to.equal(null);
				});
			});

			describe('.addThread()', function() {
				describe('non-duplicate', function() {
					var addedThread;
					beforeEach(function() {
						addedThread = generation.addThread(0);
					});

					it('returns the thread', function() {
						chai.expect(addedThread).to.be.an.instanceOf(Thread);
					});

					it('returns the thread when scheduled', function() {
						var nextThread = generation.getNextThread();
						chai.expect(nextThread).to.equal(addedThread);
					});
				});

				describe('duplicate', function() {
					var rootThread,
						forkLeft,
						forkRight;
					beforeEach(function() {
						rootThread = generation.addThread(0);
						forkLeft = generation.addThread(1, rootThread);
						forkRight = generation.addThread(2, rootThread);
					});

					it('joins non-repeating threads', function() {
						var joiningThread = generation.addThread(2, forkLeft);
						chai.expect(joiningThread).to.equal(null);
						chai.expect(forkRight.trace.prefixes.length).to.equal(2);
					});

					it('discards repeating threads', function() {
						var repeatingThread = generation.addThread(0, forkLeft);
						chai.expect(repeatingThread).to.equal(null);
						chai.expect(rootThread.trace.prefixes.length).to.equal(0);
					});
				});
			});

			describe('.getNextThread()', function() {
				function schedule(generation, threadSpecs) {
					var threads = [];
					for (var i = 0, l = threadSpecs.length; i < l; ++i) {
						var pc = threadSpecs[i].pc,
							parentThread = threads[threadSpecs[i].parent],
							badness = threadSpecs[i].badness;
						threads.push(generation.addThread(pc, parentThread, badness));
					}
				}

				function expectOrder(generation, threadSpecs) {
					for (var i = 0, l = threadSpecs.length; i < l; ++i) {
						var expectedPC = threadSpecs[i].pc,
							expectedBadness = threadSpecs[i].badness;

						var nextThread = generation.getNextThread();
						chai.expect(nextThread.pc).to.equal(expectedPC);
						chai.expect(nextThread.badness).to.equal(expectedBadness);
					}
				}

				it('should return threads with lower badness before higher ones', function() {
					schedule(generation, [
						{pc: 0, parent: null, badness: 0},
						{pc: 1, parent: 0, badness: 1},
						{pc: 2, parent: 0, badness: 0}
					]);
					expectOrder(generation, [
						{pc: 0, badness: 0},
						{pc: 2, badness: 0},
						{pc: 1, badness: 1}
					]);
				});

				it('should eventually yield all scheduled threads', function() {
					schedule(generation, [
						{pc: 0, parent: null, badness: 1},
						{pc: 1, parent: 0, badness: 2},
						{pc: 2, parent: 0, badness: 1}
					]);
					expectOrder(generation, [
						{pc: 0, badness: 1}
					]);
					schedule(generation, [
						{pc: 3, parent: null, badness: 0},
						{pc: 4, parent: 0, badness: 2},
						{pc: 5, parent: 0, badness: 1}
					]);
					expectOrder(generation, [
						{pc: 3, badness: 0},
						{pc: 2, badness: 1},
						{pc: 5, badness: 1},
						{pc: 1, badness: 2},
						{pc: 4, badness: 2}
					]);
				});
			});
		});
	}
);


text:
<?php

namespace Fidry\LaravelYaml\FileLoader;

use Fidry\LaravelYaml\Exception\Exception;

/**
 * @author Théo FIDRY <theo.fidry@gmail.com>
 */
interface FileLoaderInterface
{
    /**
     * @param string $resource File name or path
     *
     * @return $this
     * @throws Exception
     */
    public function load($resource);
}


text:
forfiles /m Citrus.Interactions.*.nupkg /c "cmd /c del @file"
..\Citrus.Interactions\.nuget\NuGet.exe pack Citrus.Interactions.nuspec
forfiles /m Citrus.Interactions.*.nupkg /c "cmd /c explorer /select,@file"


text:
package org.agorava.linkedin.jackson;

import com.fasterxml.jackson.annotation.JsonProperty;

/**
 * @author Antoine Sabot-Durand
 */
abstract class ConnectionAuthorizationMixin extends LinkedInObjectMixin {

    ConnectionAuthorizationMixin(@JsonProperty("name") String name, @JsonProperty("value") String value) {
    }

}


text:
<!DOCTYPE html>

    <meta http-equiv="refresh" content="0;URL=type.U75.html">

Redirecting to type.U75.html...


text:
//=============================================================================
// File Name: infra_vm_funcs.h
// Written by: Ofer Dekel (oferd@cs.huji.ac.il)
//
// Distributed as part of the infra C++ library for linear algebra
// Copyright (C) 2004 Ofer Dekel
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//=============================================================================
#ifndef _OFERD_VM_FUNCS_H_
#define _OFERD_VM_FUNCS_H_

//*****************************************************************************
// Included Files
//*****************************************************************************
#include "infra_vector.h"
#include "infra_matrix.h"

namespace infra {
//-----------------------------------------------------------------------------
/** Performs matrix-vector_base multiplication: outcome = M * v
    @param M A constant reference to a matrix
    @param v A constant reference to a vector_base
    @param outcome A reference to where the outcome will be stored
*/
void prod(const infra::matrix_base& M, const infra::vector_base& v,
	  infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Operator * for matrix-vector multiplication: M * v
    @param M A constant reference to a matrix
    @param v A constant reference to a vector_base
    @return The outcome vector
*/
infra::vector_base operator* (const infra::matrix_base& M,
                              const infra::vector_base& v);

//-----------------------------------------------------------------------------
/** Performs vector_base-matrix multiplication: outcome = v * M
    @param v A constant reference to a vector_base
    @param M A constant reference to a matrix
    @param outcome A reference to where the outcome will be stored
*/
void prod(const infra::vector_base& v, const infra::matrix_base& M,
	  infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Operator * for vector-matrix multiplication: v * M
    @param v A constant reference to a vector_base
    @param M A constant reference to a matrix
    @return The outcome vector
*/
infra::vector_base operator* (const infra::vector_base& v,
                              const infra::matrix_base& M);

//-----------------------------------------------------------------------------
/** Adds a matrix-vector_base multiplication to the vector_base :
    outcome += M * v
    @param M A constant reference to a matrix
    @param v A constant reference to a vector_base
    @param outcome A reference to where the outcome will be stored
*/
void add_prod(const infra::matrix_base& M, const infra::vector_base& v,
	      infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Adds a vector_base-matrix multiplication to the vector_base :
    outcome += v * M
    @param v A constant reference to a vector_base
    @param M A constant reference to a matrix
    @param outcome A reference to where the outcome will be stored
*/
void add_prod(const infra::vector_base& v, const infra::matrix_base& M,
	      infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Subtracts a matrix-vector_base multiplication from the vector_base :
    outcome -= M * v
    @param M A constant reference to a matrix
    @param v A constant reference to a vector_base
    @param outcome A reference to where the outcome will be stored
*/
void subtract_prod(const infra::matrix_base& M, const infra::vector_base& v,
		   infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Subtracts a vector_base-matrix multiplication from the vector_base :
    outcome -= v * M
    @param v A constant reference to a vector_base
    @param M A constant reference to a matrix
    @param outcome A reference to where the outcome will be stored
*/
void subtract_prod(const infra::vector_base& v, const infra::matrix_base& M,
		   infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Row-wise minimum of the matrix. Finds the minimal value in every
    row and writes it in the corresponding position in the outcome vector_base.
    @param M A constant matrix
    @param outcome A reference to where the outcome will be stored
*/
void row_min(const infra::matrix_base& M, infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Row-wise maximum of the matrix. Finds the maximal value in every
    row and writes it in the corresponding position in the outcome vector_base.
    @param M A constant matrix
    @param outcome A reference to where the outcome will be stored
*/
void row_max(const infra::matrix_base& M, infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Row-wise sum of the matrix. For every row, the sum of its entries is
    calculated and writen in the corresponding position in the outcome
    vector_base.
    @param M A constant matrix
    @param outcome A reference to where the outcome will be stored
*/
void row_sum(const infra::matrix_base& M, infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Column-wise minimum of the matrix. Finds the minimal value in every column
    and writes it in the corresponding position in the outcome vector_base.
    @param M A constant matrix
    @param outcome A reference to where the outcome will be stored
*/
void column_min(const infra::matrix_base& M, infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Column-wise maximum of the matrix. Finds the maximal value in every column
    and writes it in the corresponding position in the outcome vector_base.
    @param M A constant matrix
    @param outcome A reference to where the outcome will be stored
*/
void column_max(const infra::matrix_base& M, infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Column-wise sum of the matrix. For every column, the sum of its entries is
    calculated and writen in the corresponding position in the outcome
    vector_base.
    @param M A constant matrix
    @param outcome A reference to where the outcome will be stored
*/
void column_sum(const infra::matrix_base& M, infra::vector_base& outcome);

//-----------------------------------------------------------------------------
/** Adds a constant row vector_base to all of the rows in a matrix
    @param M The matrix
    @param v The constant vector being added
*/
void add_row_vector(infra::matrix_base& M, const infra::vector_base& v);

//-----------------------------------------------------------------------------
/** Subtracts a constant row vector from all of the rows in a matrix
    @param M The matrix
    @param v The constant vector being subtracted
*/
void subtract_row_vector(infra::matrix_base& M, const infra::vector_base& v);

//-----------------------------------------------------------------------------
/** Adds a constant column vector to all of the columns in a matrix
    @param M The matrix
    @param v The constant vector being added
*/
void add_column_vector(infra::matrix_base& M, const infra::vector_base& v);

//-----------------------------------------------------------------------------
/** Subtracts a constant column vector from all of the columns in a matrix
    @param M The matrix
    @param v The constant vector being subtracted
*/
void subtract_column_vector(infra::matrix_base& M,const infra::vector_base& v);
};
#endif
//*****************************************************************************
//                                     E O F
//*****************************************************************************


text:
using System;
using System.Threading.Tasks;

namespace RDS.CaraBus.AsyncEx.Nito.AsyncEx.Tasks
{
    /// <summary>
    /// Provides extension methods for task factories.
    /// </summary>
    internal static class TaskFactoryExtensions
    {
        /// <summary>
        /// Queues work to the task factory and returns a <see cref="Task"/> representing that work. If the task factory does not specify a task scheduler, the thread pool task scheduler is used.
        /// </summary>
        /// <param name="this">The <see cref="TaskFactory"/>. May not be <c>null</c>.</param>
        /// <param name="action">The action delegate to execute. May not be <c>null</c>.</param>
        /// <returns>The started task.</returns>
        public static Task Run(this TaskFactory @this, Action action)
        {
            if (@this == null)
                throw new ArgumentNullException(nameof(@this));
            if (action == null)
                throw new ArgumentNullException(nameof(action));

            return @this.StartNew(action, @this.CancellationToken, @this.CreationOptions | TaskCreationOptions.DenyChildAttach, @this.Scheduler ?? TaskScheduler.Default);
        }

        /// <summary>
        /// Queues work to the task factory and returns a <see cref="Task{TResult}"/> representing that work. If the task factory does not specify a task scheduler, the thread pool task scheduler is used.
        /// </summary>
        /// <param name="this">The <see cref="TaskFactory"/>. May not be <c>null</c>.</param>
        /// <param name="action">The action delegate to execute. May not be <c>null</c>.</param>
        /// <returns>The started task.</returns>
        public static Task<TResult> Run<TResult>(this TaskFactory @this, Func<TResult> action)
        {
            if (@this == null)
                throw new ArgumentNullException(nameof(@this));
            if (action == null)
                throw new ArgumentNullException(nameof(action));

            return @this.StartNew(action, @this.CancellationToken, @this.CreationOptions | TaskCreationOptions.DenyChildAttach, @this.Scheduler ?? TaskScheduler.Default);
        }

        /// <summary>
        /// Queues work to the task factory and returns a proxy <see cref="Task"/> representing that work. If the task factory does not specify a task scheduler, the thread pool task scheduler is used.
        /// </summary>
        /// <param name="this">The <see cref="TaskFactory"/>. May not be <c>null</c>.</param>
        /// <param name="action">The action delegate to execute. May not be <c>null</c>.</param>
        /// <returns>The started task.</returns>
        public static Task Run(this TaskFactory @this, Func<Task> action)
        {
            if (@this == null)
                throw new ArgumentNullException(nameof(@this));
            if (action == null)
                throw new ArgumentNullException(nameof(action));

            return @this.StartNew(action, @this.CancellationToken, @this.CreationOptions | TaskCreationOptions.DenyChildAttach, @this.Scheduler ?? TaskScheduler.Default).Unwrap();
        }

        /// <summary>
        /// Queues work to the task factory and returns a proxy <see cref="Task{TResult}"/> representing that work. If the task factory does not specify a task scheduler, the thread pool task scheduler is used.
        /// </summary>
        /// <param name="this">The <see cref="TaskFactory"/>. May not be <c>null</c>.</param>
        /// <param name="action">The action delegate to execute. May not be <c>null</c>.</param>
        /// <returns>The started task.</returns>
        public static Task<TResult> Run<TResult>(this TaskFactory @this, Func<Task<TResult>> action)
        {
            if (@this == null)
                throw new ArgumentNullException(nameof(@this));
            if (action == null)
                throw new ArgumentNullException(nameof(action));

            return @this.StartNew(action, @this.CancellationToken, @this.CreationOptions | TaskCreationOptions.DenyChildAttach, @this.Scheduler ?? TaskScheduler.Default).Unwrap();
        }
    }
}


text:
<?php
namespace W3TC;

/**
 * W3 Object Cache object
 */
class ObjectCache_WpObjectCache_Regular {
	/**
	 * Internal cache array
	 *
	 * @var array
	 */
	var $cache = array();

	/**
	 * Array of global groups
	 *
	 * @var array
	 */
	var $global_groups = array();

	/**
	 * List of non-persistent groups
	 *
	 * @var array
	 */
	var $nonpersistent_groups = array();

	/**
	 * Total count of calls
	 *
	 * @var integer
	 */
	var $cache_total = 0;

	/**
	 * Cache hits count
	 *
	 * @var integer
	 */
	var $cache_hits = 0;

	/**
	 * Cache misses count
	 *
	 * @var integer
	 */
	var $cache_misses = 0;

	/**
	 * Total time
	 *
	 * @var integer
	 */
	var $time_total = 0;

	/**
	 * Store debug information of w3tc using
	 *
	 * @var array
	 */
	var $debug_info = array();

	/**
	 * Blog id of cache
	 *
	 * @var integer
	 */
	private $_blog_id;

	/**
	 * Key cache
	 *
	 * @var array
	 */
	var $_key_cache = array();

	/**
	 * Config
	 */
	var $_config = null;

	/**
	 * Caching flag
	 *
	 * @var boolean
	 */
	var $_caching = false;

	/**
	 * Dynamic Caching flag
	 *
	 * @var boolean
	 */
	var $_can_cache_dynamic = null;
	/**
	 * Cache reject reason
	 *
	 * @var string
	 */
	private $cache_reject_reason = '';

	/**
	 * Lifetime
	 *
	 * @var integer
	 */
	var $_lifetime = null;

	/**
	 * Debug flag
	 *
	 * @var boolean
	 */
	var $_debug = false;

	/**
	 * PHP5 style constructor
	 */
	function __construct() {
		global $_wp_using_ext_object_cache;

		$this->_config = Dispatcher::config();
		$this->_lifetime = $this->_config->get_integer( 'objectcache.lifetime' );
		$this->_debug = $this->_config->get_boolean( 'objectcache.debug' );
		$this->_caching = $_wp_using_ext_object_cache = $this->_can_cache();
		$this->global_groups = $this->_config->get_array( 'objectcache.groups.global' );
		$this->nonpersistent_groups = $this->_config->get_array( 'objectcache.groups.nonpersistent' );

		$this->_blog_id = Util_Environment::blog_id();
	}

	/**
	 * Get from the cache
	 *
	 * @param string  $id
	 * @param string  $group
	 * @return mixed
	 */
	function get( $id, $group = 'default', $force = false, &$found = null ) {
		if ( $this->_debug ) {
			$time_start = Util_Debug::microtime();
		}

		$key = $this->_get_cache_key( $id, $group );
		$internal = isset( $this->cache[$key] );

		if ( $internal && !$force ) {
			$found = true;
			$value = $this->cache[$key];
		} elseif ( $this->_caching &&
			!in_array( $group, $this->nonpersistent_groups ) &&
			$this->_check_can_cache_runtime( $group ) ) {
			$cache = $this->_get_cache( null, $group );
			$v = $cache->get( $key );
			if ( is_array( $v ) && $v['content'] != null ) {
				$found = true;
				$value = $v['content'];
			} else
				$value = false;
		} else {
			$value = false;
		}

		if ( $value === null ) {
			$value = false;
		}

		if ( is_object( $value ) ) {
			$value = clone $value;
		}

		$this->cache[$key] = $value;
		$this->cache_total++;

		if ( $value !== false ) {
			$cached = true;
			$this->cache_hits++;
		} else {
			$cached = false;
			$this->cache_misses++;
		}

		/**
		 * Add debug info
		 */
		if ( $this->_debug ) {
			$time = Util_Debug::microtime() - $time_start;
			$this->time_total += $time;

			if ( !$group ) {
				$group = 'default';
			}

			$this->debug_info[] = array(
				'id' => $id,
				'group' => $group,
				'cached' => $cached,
				'internal' => $internal,
				'data_size' => ( $value ? strlen( serialize( $value ) ) : '' ),
				'time' => $time
			);
		}

		return $value;
	}

	/**
	 * Set to the cache
	 *
	 * @param string  $id
	 * @param mixed   $data
	 * @param string  $group
	 * @param integer $expire
	 * @return boolean
	 */
	function set( $id, $data, $group = 'default', $expire = 0 ) {
		$key = $this->_get_cache_key( $id, $group );

		if ( is_object( $data ) ) {
			$data = clone $data;
		}

		$this->cache[$key] = $data;

		if ( $this->_caching &&
			!in_array( $group, $this->nonpersistent_groups ) &&
			$this->_check_can_cache_runtime( $group ) ) {
			$cache = $this->_get_cache( null, $group );

			if ( $id == 'alloptions' && $group == 'options' ) {
				// alloptions are deserialized on the start when some classes are not loaded yet
				// so postpone it until requested
				foreach ( $data as $k => $v ) {
					if ( is_object( $v ) ) {
						$data[$k] = serialize( $v );
					}
				}
			}

			$v = array( 'content' => $data );
			return $cache->set( $key, $v,
				( $expire ? $expire : $this->_lifetime ) );
		}

		return true;
	}

	/**
	 * Delete from the cache
	 *
	 * @param string  $id
	 * @param string  $group
	 * @param bool    $force
	 * @return boolean
	 */
	function delete( $id, $group = 'default', $force = false ) {
		if ( !$force && $this->get( $id, $group ) === false ) {
			return false;
		}

		$key = $this->_get_cache_key( $id, $group );

		unset( $this->cache[$key] );

		if ( $this->_caching && !in_array( $group, $this->nonpersistent_groups ) ) {
			$cache = $this->_get_cache( null, $group );

			return $cache->delete( $key );
		}

		return true;
	}

	/**
	 * Add to the cache
	 *
	 * @param string  $id
	 * @param mixed   $data
	 * @param string  $group
	 * @param integer $expire
	 * @return boolean
	 */
	function add( $id, $data, $group = 'default', $expire = 0 ) {
		if ( $this->get( $id, $group ) !== false ) {
			return false;
		}

		return $this->set( $id, $data, $group, $expire );
	}

	/**
	 * Replace in the cache
	 *
	 * @param string  $id
	 * @param mixed   $data
	 * @param string  $group
	 * @param integer $expire
	 * @return boolean
	 */
	function replace( $id, $data, $group = 'default', $expire = 0 ) {
		if ( $this->get( $id, $group ) === false ) {
			return false;
		}

		return $this->set( $id, $data, $group, $expire );
	}

	/**
	 * Reset keys
	 *
	 * @return boolean
	 */
	function reset() {
		global $_wp_using_ext_object_cache;

		$_wp_using_ext_object_cache = $this->_caching;

		return true;
	}

	/**
	 * Flush cache
	 *
	 * @return boolean
	 */
	function flush() {
		$this->cache = array();

		global $w3_multisite_blogs;
		if ( isset( $w3_multisite_blogs ) ) {
			foreach ( $w3_multisite_blogs as $blog ) {
				$cache = $this->_get_cache( $blog->userblog_id );
				$cache->flush();
			}
		} else {
			$cache = $this->_get_cache( 0 );
			$cache->flush();

			$cache = $this->_get_cache();
			$cache->flush();
		}

		return true;
	}

	/**
	 * Add global groups
	 *
	 * @param array   $groups
	 * @return void
	 */
	function add_global_groups( $groups ) {
		if ( !is_array( $groups ) ) {
			$groups = (array) $groups;
		}

		$this->global_groups = array_merge( $this->global_groups, $groups );
		$this->global_groups = array_unique( $this->global_groups );
	}

	/**
	 * Add non-persistent groups
	 *
	 * @param array   $groups
	 * @return void
	 */
	function add_nonpersistent_groups( $groups ) {
		if ( !is_array( $groups ) ) {
			$groups = (array) $groups;
		}

		$this->nonpersistent_groups = array_merge( $this->nonpersistent_groups, $groups );
		$this->nonpersistent_groups = array_unique( $this->nonpersistent_groups );
	}

	/**
	 * Increment numeric cache item's value
	 *
	 * @param int|string $key    The cache key to increment
	 * @param int     $offset The amount by which to increment the item's value. Default is 1.
	 * @param string  $group  The group the key is in.
	 * @return bool|int False on failure, the item's new value on success.
	 */
	function incr( $key, $offset = 1, $group = 'default' ) {
		$value = $this->get( $key, $group );
		if ( $value === false )
			return false;

		if ( !is_numeric( $value ) )
			$value = 0;

		$offset = (int) $offset;
		$value += $offset;

		if ( $value < 0 )
			$value = 0;
		$this->replace( $key, $value, $group );
		return $value;
	}

	/**
	 * Decrement numeric cache item's value
	 *
	 * @param int|string $key    The cache key to increment
	 * @param int     $offset The amount by which to decrement the item's value. Default is 1.
	 * @param string  $group  The group the key is in.
	 * @return bool|int False on failure, the item's new value on success.
	 */
	function decr( $key, $offset = 1, $group = 'default' ) {
		$value = $this->get( $key, $group );
		if ( $value === false )
			return false;

		if ( !is_numeric( $value ) )
			$value = 0;

		$offset = (int) $offset;
		$value -= $offset;

		if ( $value < 0 )
			$value = 0;
		$this->replace( $key, $value, $group );
		return $value;
	}

	/**
	 * Print Object Cache stats
	 *
	 * @return void
	 */
	function stats() {
		echo '
Summary
';
		echo '
';
		echo 'Engine: ' . Cache::engine_name( $this->_config->get_string( 'objectcache.engine' ) ) . '
';
		echo 'Caching: ' . ( $this->_caching ? 'enabled' : 'disabled' ) . '
';

		if ( !$this->_caching ) {
			echo 'Reject reason: ' . $this->get_reject_reason() . '
';
		}

		echo 'Total calls: ' . $this->cache_total . '
';
		echo 'Cache hits: ' . $this->cache_hits . '
';
		echo 'Cache misses: ' . $this->cache_misses . '
';
		echo 'Total time: '. round( $this->time_total, 4 ) . 's';
		echo '
';

		echo '
Cache info
';

		if ( $this->_debug ) {
			echo '
';
			echo '
#	Status	Source	Data size (b)	Query time (s)	ID:Group
';

			foreach ( $this->debug_info as $index => $debug ) {
				echo '
';
				echo '' . ( $index + 1 ) . '	';
				echo '' . ( $debug['cached'] ? 'cached' : 'not cached' ) . '	';
				echo '' . ( $debug['internal'] ? 'internal' : 'persistent' ) . '	';
				echo '' . $debug['data_size'] . '	';
				echo '' . round( $debug['time'], 4 ) . '	';
				echo '' . sprintf( '%s:%s', $debug['id'], $debug['group'] ) . '	';
				echo '
';
			}

			echo '
';
		} else {
			echo '
Enable debug mode.
';
		}
	}

	/**
	 * Switches context to another blog
	 *
	 * @param integer $blog_id
	 */
	function switch_blog( $blog_id ) {
		$this->reset();
		$this->_blog_id = $blog_id;
	}

	/**
	 * Returns cache key
	 *
	 * @param string  $id
	 * @param string  $group
	 * @return string
	 */
	function _get_cache_key( $id, $group = 'default' ) {
		if ( !$group ) {
			$group = 'default';
		}

		$blog_id = $this->_blog_id;
		if ( in_array( $group, $this->global_groups ) )
			$blog_id = 0;

		$key_cache_id = $blog_id . $group . $id;

		if ( isset( $this->_key_cache[$key_cache_id] ) ) {
			$key = $this->_key_cache[$key_cache_id];
		} else {
			$key = md5( $blog_id . $group . $id );
			$this->_key_cache[$key_cache_id] = $key;
		}

		return $key;
	}

	public function get_usage_statistics_cache_config() {
		$engine = $this->_config->get_string( 'objectcache.engine' );

		switch ( $engine ) {
		case 'memcached':
			$engineConfig = array(
				'servers' => $this->_config->get_array( 'objectcache.memcached.servers' ),
				'persistent' => $this->_config->get_boolean( 'objectcache.memcached.persistent' ),
				'aws_autodiscovery' => $this->_config->get_boolean( 'objectcache.memcached.aws_autodiscovery' ),
				'username' => $this->_config->get_boolean( 'objectcache.memcached.username' ),
				'password' => $this->_config->get_boolean( 'objectcache.memcached.password' )
			);
			break;

		case 'redis':
			$engineConfig = array(
				'servers' => $this->_config->get_array( 'objectcache.redis.servers' ),
				'persistent' => $this->_config->get_boolean( 'objectcache.redis.persistent' ),
				'dbid' => $this->_config->get_boolean( 'objectcache.redis.dbid' ),
				'password' => $this->_config->get_boolean( 'objectcache.redis.password' )
			);
			break;

		default:
			$engineConfig = array();
		}

		$engineConfig['engine'] = $engine;
		return $engineConfig;
	}

	/**
	 * Returns cache object
	 *
	 * @param int|null $blog_id
	 * @param string  $group
	 * @return W3_Cache_Base
	 */
	function _get_cache( $blog_id = null, $group = '' ) {
		static $cache = array();

		if ( is_null( $blog_id ) && !in_array( $group, $this->global_groups ) )
			$blog_id = $this->_blog_id;
		elseif ( is_null( $blog_id ) )
			$blog_id = 0;

		if ( !isset( $cache[$blog_id] ) ) {
			$engine = $this->_config->get_string( 'objectcache.engine' );

			switch ( $engine ) {
			case 'memcached':
				$engineConfig = array(
					'servers' => $this->_config->get_array( 'objectcache.memcached.servers' ),
					'persistent' => $this->_config->get_boolean( 'objectcache.memcached.persistent' ),
					'aws_autodiscovery' => $this->_config->get_boolean( 'objectcache.memcached.aws_autodiscovery' ),
					'username' => $this->_config->get_boolean( 'objectcache.memcached.username' ),
					'password' => $this->_config->get_boolean( 'objectcache.memcached.password' )
				);
				break;

			case 'redis':
				$engineConfig = array(
					'servers' => $this->_config->get_array( 'objectcache.redis.servers' ),
					'persistent' => $this->_config->get_boolean( 'objectcache.redis.persistent' ),
					'dbid' => $this->_config->get_boolean( 'objectcache.redis.dbid' ),
					'password' => $this->_config->get_boolean( 'objectcache.redis.password' )
				);
				break;

			case 'file':
				$engineConfig = array(
					'section' => 'object',
					'locking' => $this->_config->get_boolean( 'objectcache.file.locking' ),
					'flush_timelimit' => $this->_config->get_integer( 'timelimit.cache_flush' )
				);
				break;

			default:
				$engineConfig = array();
			}
			$engineConfig['blog_id'] = $blog_id;
			$engineConfig['module'] = 'object';
			$engineConfig['host'] = Util_Environment::host();
			$engineConfig['instance_id'] = Util_Environment::instance_id();

			$cache[$blog_id] = Cache::instance( $engine, $engineConfig );
		}

		return $cache[$blog_id];
	}

	/**
	 * Check if caching allowed on init
	 *
	 * @return boolean
	 */
	function _can_cache() {
		/**
		 * Skip if disabled
		 */
		if ( !$this->_config->get_boolean( 'objectcache.enabled' ) ) {
			$this->cache_reject_reason = 'objectcache.disabled';

			return false;
		}

		/**
		 * Check for DONOTCACHEOBJECT constant
		 */
		if ( defined( 'DONOTCACHEOBJECT' ) && DONOTCACHEOBJECT ) {
			$this->cache_reject_reason = 'DONOTCACHEOBJECT';

			return false;
		}

		return true;
	}

	/**
	 * Returns if we can cache, that condition can change in runtime
	 *
	 * @param unknown $group
	 * @return boolean
	 */
	function _check_can_cache_runtime( $group ) {
		//Need to be handled in wp admin as well as frontend
		if ( in_array( $group, array( 'transient', 'site-transient' ) ) )
			return true;

		if ( $this->_can_cache_dynamic != null )
			return $this->_can_cache_dynamic;

		if ( $this->_caching ) {
			if ( defined( 'WP_ADMIN' ) ) {
				$this->_can_cache_dynamic = false;
				$this->cache_reject_reason = 'WP_ADMIN defined';
				return $this->_can_cache_dynamic;
			}
		}

		return $this->_caching;
	}

	public function w3tc_footer_comment( $strings ) {
		if ( $this->_config->get_boolean( 'objectcache.debug' ) ) {
			$strings[] = "Object Cache debug info:";
			$strings[] = sprintf( "%s%s", str_pad( 'Engine: ', 20 ), Cache::engine_name( $this->_config->get_string( 'objectcache.engine' ) ) );
			$strings[] = sprintf( "%s%s", str_pad( 'Caching: ', 20 ), ( $this->_caching ? 'enabled' : 'disabled' ) );

			if ( !$this->_caching ) {
				$strings[] = sprintf( "%s%s", str_pad( 'Reject reason: ', 20 ), $this->cache_reject_reason );
			}

			$strings[] = sprintf( "%s%d", str_pad( 'Total calls: ', 20 ), $this->cache_total );
			$strings[] = sprintf( "%s%d", str_pad( 'Cache hits: ', 20 ), $this->cache_hits );
			$strings[] = sprintf( "%s%d", str_pad( 'Cache misses: ', 20 ), $this->cache_misses );
			$strings[] = sprintf( "%s%.4f", str_pad( 'Total time: ', 20 ), $this->time_total );

			$strings[] = "W3TC Object Cache info:";
			$strings[] = sprintf( "%s | %s | %s | %s | %s | %s",
				str_pad( '#', 5, ' ', STR_PAD_LEFT ),
				str_pad( 'Status', 15, ' ', STR_PAD_BOTH ),
				str_pad( 'Source', 15, ' ', STR_PAD_BOTH ),
				str_pad( 'Data size (b)', 13, ' ', STR_PAD_LEFT ),
				str_pad( 'Query time (s)', 14, ' ', STR_PAD_LEFT ),
				'ID:Group' );

			foreach ( $this->debug_info as $index => $debug ) {
				$strings[] = sprintf( "%s | %s | %s | %s | %s | %s",
					str_pad( $index + 1, 5, ' ', STR_PAD_LEFT ),
					str_pad( ( $debug['cached'] ? 'cached' : 'not cached' ), 15, ' ', STR_PAD_BOTH ),
					str_pad( ( $debug['internal'] ? 'internal' : 'persistent' ), 15, ' ', STR_PAD_BOTH ),
					str_pad( $debug['data_size'], 13, ' ', STR_PAD_LEFT ),
					str_pad( round( $debug['time'], 4 ), 14, ' ', STR_PAD_LEFT ),
					sprintf( '%s:%s', $debug['id'], $debug['group'] ) );
			}
		} else {
			$reason = $this->get_reject_reason();
			$append = ( $reason != '' ? sprintf( ' (%s)', $reason ) : '' );

			$strings[] = sprintf(
				__( 'Object Caching %d/%d objects using %s%s', 'w3-total-cache' ),
				$this->cache_hits, $this->cache_total,
				Cache::engine_name( $this->_config->get_string( 'objectcache.engine' ) ),
				$append );
		}

		return $strings;
	}

	public function w3tc_usage_statistics_of_request( $storage ) {
		$storage->counter_add( 'objectcache_calls_total', $this->cache_total );
		$storage->counter_add( 'objectcache_calls_hits', $this->cache_hits );
	}

	public function get_reject_reason() {
		if ( is_null( $this->cache_reject_reason ) )
			return '';
		return $this->_get_reject_reason_message( $this->cache_reject_reason );
	}

	/**
	 *
	 *
	 * @param unknown $key
	 * @return string|void
	 */
	private function _get_reject_reason_message( $key ) {
		if ( !function_exists( '__' ) )
			return $key;

		switch ( $key ) {
		case 'objectcache.disabled':
			return __( 'Object caching is disabled', 'w3-total-cache' );
		case 'DONOTCACHEOBJECT':
			return __( 'DONOTCACHEOBJECT constant is defined', 'w3-total-cache' );
		default:
			return '';
		}
	}
}


text:
package collins.controllers.actors

import java.util.concurrent.TimeUnit

import scala.concurrent.Await
import scala.concurrent.duration.Duration
import scala.concurrent.duration.FiniteDuration

import play.api.mvc.AnyContent
import play.api.mvc.Request

import collins.softlayer.SoftLayer
import collins.softlayer.SoftLayerConfig
import collins.util.concurrent.BackgroundProcess

case class ActivationProcessor(slId: Long, userTimeout: Option[FiniteDuration] = None)(implicit req: Request[AnyContent]) extends BackgroundProcess[Boolean] {
  val timeout = userTimeout.getOrElse(Duration(SoftLayerConfig.activationRequestTimeoutMs, TimeUnit.MILLISECONDS))

  def run(): Boolean = {
    Await.result(SoftLayer.activateServer(slId), timeout)
  }
}


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

        <meta http-equiv="X-UA-Compatible" content="IE=edge">

        <meta name="viewport" content="width=device-width, initial-scale=1">
        <meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
        <meta name="generator" content="Doxygen 1.8.13"/>

        <title>CubbyFlow: CubbyFlow::PointParallelHashGridSearcher< N >::Builder Class Reference</title>

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

        <link href="doxygen.css" rel="stylesheet" type="text/css" />
        <link href="customdoxygen.css" rel="stylesheet" type="text/css"/>
        <link href='https://fonts.googleapis.com/css?family=Roboto+Slab' rel='stylesheet' type='text/css'>
        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">

        <link href="jquery.smartmenus.bootstrap.css" rel="stylesheet">

                    CubbyFlow v0.71

CubbyFlow

PointParallelHashGridSearcher

Builder

Public Member Functions |
List of all members

CubbyFlow::PointParallelHashGridSearcher< N >::Builder Class Referencefinal

Front-end to create PointParallelHashGridSearcher objects step by step.
 More...

#include <Core/Searcher/PointParallelHashGridSearcher.hpp>

Inheritance diagram for CubbyFlow::PointParallelHashGridSearcher< N >::Builder:

  <map id="CubbyFlow::PointParallelHashGridSearcher_3C_20N_20_3E::Builder_map" name="CubbyFlow::PointParallelHashGridSearcher_3C_20N_20_3E::Builder_map">
<area href="class_cubby_flow_1_1_point_neighbor_searcher_builder.html" title="Abstract base class for N-D point neighbor searcher builders. " alt="CubbyFlow::PointNeighborSearcherBuilder< N >" shape="rect" coords="0,0,338,24"/>
</map>

Public Member Functions

 	Builder ()=default

 	Default constructor.  More...

 	~Builder () override=default

 	Default virtual destructor.  More...

 	Builder (const Builder &other)=delete

 	Deleted copy constructor.  More...

 	Builder (Builder &&other) noexcept=delete

 	Deleted move constructor.  More...

Builder & 	operator= (const Builder &other)=delete

 	Deleted copy assignment operator.  More...

Builder & 	operator= (Builder &&other) noexcept=delete

 	Deleted move assignment operator.  More...

Builder & 	WithResolution (const Vector< size_t, N > &resolution)

 	Returns builder with resolution.  More...

Builder & 	WithGridSpacing (double gridSpacing)

 	Returns builder with grid spacing.  More...

PointParallelHashGridSearcher< N > 	Build () const

 	Builds PointParallelHashGridSearcher instance.  More...

std::shared_ptr< PointParallelHashGridSearcher< N > > 	MakeShared () const

 	Builds shared pointer of PointParallelHashGridSearcher instance.  More...

std::shared_ptr< PointNeighborSearcher< N > > 	BuildPointNeighborSearcher () const override

 	Returns shared pointer of PointNeighborSearcher type.  More...

 Public Member Functions inherited from CubbyFlow::PointNeighborSearcherBuilder< N >

 	PointNeighborSearcherBuilder ()=default

 	Default constructor.  More...

virtual 	~PointNeighborSearcherBuilder ()=default

 	Default virtual destructor.  More...

 	PointNeighborSearcherBuilder (const PointNeighborSearcherBuilder &other)=delete

 	Deleted copy constructor.  More...

 	PointNeighborSearcherBuilder (PointNeighborSearcherBuilder &&other) noexcept=delete

 	Deleted move constructor.  More...

PointNeighborSearcherBuilder & 	operator= (const PointNeighborSearcherBuilder &other)=delete

 	Deleted copy assignment operator.  More...

PointNeighborSearcherBuilder & 	operator= (PointNeighborSearcherBuilder &&other) noexcept=delete

 	Deleted move assignment operator.  More...

Detailed Description

template<size_t N>

class CubbyFlow::PointParallelHashGridSearcher< N >::Builder

Front-end to create PointParallelHashGridSearcher objects step by step.

Constructor & Destructor Documentation

◆ Builder() [1/3]

template<size_t N>

          CubbyFlow::PointParallelHashGridSearcher< N >::Builder::Builder
          (
          	)

default

Default constructor.

◆ ~Builder()

template<size_t N>

          CubbyFlow::PointParallelHashGridSearcher< N >::Builder::~Builder
          (
          	)

overridedefault

Default virtual destructor.

◆ Builder() [2/3]

template<size_t N>

          CubbyFlow::PointParallelHashGridSearcher< N >::Builder::Builder
          (
          const Builder &
          other	)

delete

Deleted copy constructor.

◆ Builder() [3/3]

template<size_t N>

          CubbyFlow::PointParallelHashGridSearcher< N >::Builder::Builder
          (
          Builder &&
          other	)

deletenoexcept

Deleted move constructor.

Member Function Documentation

◆ Build()

template<size_t N>

          PointParallelHashGridSearcher<N> CubbyFlow::PointParallelHashGridSearcher< N >::Builder::Build
          (
          	)
           const

Builds PointParallelHashGridSearcher instance.

◆ BuildPointNeighborSearcher()

template<size_t N>

          std::shared_ptr<PointNeighborSearcher<N> > CubbyFlow::PointParallelHashGridSearcher< N >::Builder::BuildPointNeighborSearcher
          (
          	)
           const

overridevirtual

Returns shared pointer of PointNeighborSearcher type.

Implements CubbyFlow::PointNeighborSearcherBuilder< N >.

◆ MakeShared()

template<size_t N>

          std::shared_ptr<PointParallelHashGridSearcher<N> > CubbyFlow::PointParallelHashGridSearcher< N >::Builder::MakeShared
          (
          	)
           const

Builds shared pointer of PointParallelHashGridSearcher instance.

◆ operator=() [1/2]

template<size_t N>

          Builder& CubbyFlow::PointParallelHashGridSearcher< N >::Builder::operator=
          (
          const Builder &
          other	)

delete

Deleted copy assignment operator.

◆ operator=() [2/2]

template<size_t N>

          Builder& CubbyFlow::PointParallelHashGridSearcher< N >::Builder::operator=
          (
          Builder &&
          other	)

deletenoexcept

Deleted move assignment operator.

◆ WithGridSpacing()

template<size_t N>

          Builder& CubbyFlow::PointParallelHashGridSearcher< N >::Builder::WithGridSpacing
          (
          double
          gridSpacing	)

Returns builder with grid spacing.

◆ WithResolution()

template<size_t N>

          Builder& CubbyFlow::PointParallelHashGridSearcher< N >::Builder::WithResolution
          (
          const Vector< size_t, N > &
          resolution	)

Returns builder with resolution.

The documentation for this class was generated from the following file:

Core/Searcher/PointParallelHashGridSearcher.hpp

<address class="footer">
Generated on Thu Jul 15 2021 02:18:16 for CubbyFlow by

 1.8.13
</address>


text:
<?php
/**
 * Box packing (3D bin packing, knapsack problem).
 *
 * @author Doug Wright
 */
declare(strict_types=1);

namespace DVDoug\BoxPacker;

/**
 * A "box" (or envelope?) to pack items into.
 */
interface Box
{
    /**
     * Reference for box type (e.g. SKU or description).
     */
    public function getReference(): string;

    /**
     * Outer width in mm.
     */
    public function getOuterWidth(): int;

    /**
     * Outer length in mm.
     */
    public function getOuterLength(): int;

    /**
     * Outer depth in mm.
     */
    public function getOuterDepth(): int;

    /**
     * Empty weight in g.
     */
    public function getEmptyWeight(): int;

    /**
     * Inner width in mm.
     */
    public function getInnerWidth(): int;

    /**
     * Inner length in mm.
     */
    public function getInnerLength(): int;

    /**
     * Inner depth in mm.
     */
    public function getInnerDepth(): int;

    /**
     * Max weight the packaging can hold in g.
     */
    public function getMaxWeight(): int;
}


text:
import csv
import argparse

FLAG = None

def write_file(feats,lab_list, fn):
    with open(fn,'w') as f:
        for num, i in enumerate(feats):
            for j in range(len(i)):
                f.write(str(i[j]) + ',')
            f.write(str([len(i)-1]) + '\n')

    return

def transform(feats, lens):
    dim = FLAG.feat_dim
    trans_feats = []

    for i in range(len(feats)):
        trans_feats.append(feats[i][:single_len[lens[i]*dim]])

    return trans_feats

def read_feat(fn):
    feats = []
    labs = []
    with open(fn,'r') as f:
        reader = csv.reader(f)
        for row in reader:
            feats.append(list(map(float,row[:-1])))
            labs.append(float(row[-1]))

    return feats, labs

def read_len(fn):
    len_list = []
    with open(fn,'r') as f:
        for line in f:
            len_list.append(int(line.rstrip()))

    return len_list

def main():
    len_list = read_len(FLAG.len_file)
    ark_list, lab_list = read_feat(FLAG.ark_file)

    return

if __name__ == '__main__':
    parser = argparse.ArgumentParser(
        description='Transfrom the fulfilled zeros to no')
    parser.add_argument('--feat_dim',type=int, default=39,
        help='each frame feat dimension')
    parser.add_argument('ark_file',
        help='the transforming ark file')
    parser.add_argument('len_file',
        help='meaning the length of each utterance')
    parser.add_argument('out_ark',
        help='the output file')
    FLAG = parser.parse_args()

    main()


text: from blaze_loader import *


text:
layout: category
section-type: category
title: sql
---
## Category


text:
#ifndef BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED
#define BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED

#include <boost/numeric/odeint/util/is_resizeable.hpp>
#include <boost/numeric/odeint/util/resize.hpp>
#include <boost/numeric/odeint/util/same_size.hpp>

#include <boost/mpl/and.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/multi_array.hpp>

namespace boost {
namespace numeric {
namespace odeint {

template< typename T >
struct is_multi_array
{
    typedef boost::false_type type;
    const static bool value = type::value;
};

template< typename T >
struct is_resizeable_multi_array
{
    typedef boost::false_type type;
    const static bool value = type::value;
};

template< typename V , size_t Dim , typename A >
struct is_multi_array< boost::multi_array< V , Dim , A > >
{
    typedef boost::true_type type;
    const static bool value = type::value;
};

template< typename V , size_t Dim , typename A >
struct is_resizeable_multi_array< boost::multi_array< V , Dim , A > >
{
    typedef boost::true_type type;
    const static bool value = type::value;
};

template< typename T  >
struct is_resizeable< T , typename boost::enable_if< typename is_resizeable_multi_array< T >::type >::type >
{
    typedef boost::true_type type;
    const static bool value = type::value;
};

template< typename T1 , typename T2  >
struct same_size_impl< T1 , T2 ,
                       typename boost::enable_if<
                           typename boost::mpl::and_<
                               is_multi_array< T1 > ,
                               is_multi_array< T2 > ,
                               boost::mpl::bool_< T1::dimensionality == T2::dimensionality >
                           >::type
                       >::type >
{
    static bool same_size( T1 const &x1 , T2 const &x2 )
    {
        for( size_t i=0 ; i<T1::dimensionality ; ++i )
        {
            if( x1.shape()[i] != x2.shape()[i] ) return false;
            if( x1.index_bases()[i] != x2.index_bases()[i] ) return false;
        }
        return true;
    }
};

template< typename T1 , typename T2 >
struct resize_impl< T1 , T2 ,
                    typename boost::enable_if<
                        typename boost::mpl::and_<
                            is_resizeable_multi_array< T1 > ,
                            is_multi_array< T2 > ,
                            boost::mpl::bool_< T1::dimensionality == T2::dimensionality >
                        >::type
                    >::type >
{
    static void resize( T1 &x1 , const T2 &x2 )
    {
        boost::array< int , T1::dimensionality > extents;
        for( size_t i=0 ; i<T1::dimensionality ; ++i ) extents[i] = x2.shape()[i];
        x1.resize( extents );
        boost::array< int , T1::dimensionality > origins;
        for( size_t i=0 ; i<T1::dimensionality ; ++i ) origins[i] = x2.index_bases()[i];
        x1.reindex( origins );
    }
};

} // namespace odeint
} // namespace numeric
} // namespace boost

#endif // BOOST_NUMERIC_ODEINT_UTIL_MULTI_ARRAY_ADAPTION_HPP_DEFINED


text:
using System;
using System.Collections.Generic;
using System.Linq;

namespace AOLadderer.Blazor.Models
{
    public enum CompositesBuff
    {
        None, Standard, Pay2Win
    }

    public enum StrengthAndStaminaBuff
    {
        None, IronCircle, ProdigiousStrength, IronCircleOrProdigiousStrength
    }

    public class BuffsModel : IUrlTokenSerializable
    {
        public CompositesBuff Composites { get; set; }
        public bool UseSurgeryClinicEffect { get; set; }
        public bool UseSuperiorFirstAid { get; set; }
        public bool UseEnhancedSenses { get; set; }
        public bool UseFelineGrace { get; set; }
        public bool UseEssenceOfBehemoth { get; set; }
        public bool UseGauntlet { get; set; }
        public bool UseExtruderBar { get; set; }
        public bool UseExplosifs { get; set; }
        public StrengthAndStaminaBuff StrengthAndStamina { get; set; }
        public bool UseNeuronalStimulator { get; set; }

        protected IEnumerable<Buff> Buffs
        {
            get
            {
                if (Composites == CompositesBuff.Standard) yield return Buff.Composites;
                if (Composites == CompositesBuff.Pay2Win) yield return Buff.Composites_Pay2Win;
                if (UseSurgeryClinicEffect) yield return Buff.SurgeryClinicEffect;
                if (UseSuperiorFirstAid) yield return Buff.SuperiorFirstAid;
                if (UseEnhancedSenses) yield return Buff.EnhancedSenses;
                if (UseFelineGrace) yield return Buff.FelineGrace;
                if (UseEssenceOfBehemoth) yield return Buff.EssenceOfBehemoth;
                if (UseGauntlet) yield return Buff.Gauntlet;
                if (UseExtruderBar) yield return Buff.ExtruderBar;
                if (UseExplosifs) yield return Buff.Explosifs;
                if (StrengthAndStamina == StrengthAndStaminaBuff.IronCircle) yield return Buff.IronCircle;
                if (StrengthAndStamina == StrengthAndStaminaBuff.ProdigiousStrength) yield return Buff.ProdigiousStrength;
                if (StrengthAndStamina == StrengthAndStaminaBuff.IronCircleOrProdigiousStrength) yield return Buff.IronCircleOrProdigiousStrength;
                if (UseNeuronalStimulator) yield return Buff.NeuronalStimulator;
            }
        }

        public int Strength => Buffs.Sum(b => b.Strength);
        public int Agility => Buffs.Sum(b => b.Agility);
        public int Stamina => Buffs.Sum(b => b.Stamina);
        public int Intelligence => Buffs.Sum(b => b.Intelligence);
        public int Sense => Buffs.Sum(b => b.Sense);
        public int Psychic => Buffs.Sum(b => b.Psychic);
        public double Treatment => Buffs.Sum(b => b.Treatment);

        public void UrlTokenDeserialize(Queue<object> data)
        {
            Composites = (CompositesBuff)Convert.ToInt32(data.Dequeue());
            UseSurgeryClinicEffect = Convert.ToInt32(data.Dequeue()) == 1;
            UseSuperiorFirstAid = Convert.ToInt32(data.Dequeue()) == 1;
            UseEnhancedSenses = Convert.ToInt32(data.Dequeue()) == 1;
            UseFelineGrace = Convert.ToInt32(data.Dequeue()) == 1;
            UseEssenceOfBehemoth = Convert.ToInt32(data.Dequeue()) == 1;
            UseGauntlet = Convert.ToInt32(data.Dequeue()) == 1;
            UseExtruderBar = Convert.ToInt32(data.Dequeue()) == 1;
            UseExplosifs = Convert.ToInt32(data.Dequeue()) == 1;
            StrengthAndStamina = (StrengthAndStaminaBuff)Convert.ToInt32(data.Dequeue());
            UseNeuronalStimulator = Convert.ToInt32(data.Dequeue()) == 1;
        }

        public void UrlTokenSerialize(Queue<object> data)
        {
            data.Enqueue(Composites);
            data.Enqueue(UseSurgeryClinicEffect ? 1 : 0);
            data.Enqueue(UseSuperiorFirstAid ? 1 : 0);
            data.Enqueue(UseEnhancedSenses ? 1 : 0);
            data.Enqueue(UseFelineGrace ? 1 : 0);
            data.Enqueue(UseEssenceOfBehemoth ? 1 : 0);
            data.Enqueue(UseGauntlet ? 1 : 0);
            data.Enqueue(UseExtruderBar ? 1 : 0);
            data.Enqueue(UseExplosifs ? 1 : 0);
            data.Enqueue(StrengthAndStamina);
            data.Enqueue(UseNeuronalStimulator ? 1 : 0);
        }
    }
}


text:
// Copyright 2011 Traceur Authors.
//
// 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.

var classifyTraceurTokens = function() {};

(function() {
  'use strict';

  var Scanner = traceur.syntax.Scanner;
  var SourceRange = traceur.util.SourceRange;
  var TokenType = traceur.syntax.TokenType;
  var PredefinedName = traceur.syntax.PredefinedName;
  var ErrorReporter = traceur.util.ErrorReporter;
  var SourceFile = traceur.syntax.SourceFile;
  var Keywords = traceur.syntax.Keywords;

  var Classification = {
    ERROR: 'error',
    COMMENT: 'comment',
    IDENTIFIER: 'identifier',
    KEYWORD: 'keyword',
    PUNCTUATOR: 'punctuator',
    STRING: 'string',
    NUMBER: 'number',
    REGEX: 'regex',
    CONTEXTUAL: 'contextual'
  };

  /**
   * Represents the classification of a region of text
   * @param {Classification} category
   * @param {string} text
   * @constructor
   */
  function ClassifiedText(category, text) {
    this.category = category;
    this.text = text;
  }

  /**
   * Classifies javascript tokens into their token category. This can be used
   * for colorization.
   *
   * TODO(jmesserly): regex and contextual keywords need a parse to be colorized
   * correctly.
   *
   * @param {ErrorReport} errorReporter
   * @param {SourceFile} file
   * @param {number=} opt_offset
   * @constructor
   * @extends {Scanner}
   */
  function Classifier(errorReporter, file, opt_offset) {
    Scanner.call(this, errorReporter, file, opt_offset);
    this.classifications_ = [];
  }

  var proto = Scanner.prototype;
  Classifier.prototype = {
    __proto__: proto,

    /** @type {number} */
    lastClassifierLocation_: 0,

    /**
     * @param {Classification} category
     * @param {SourceRange} location
     */
    pushResult_: function(category, location) {
      var start = location.start.offset;
      var end = location.end.offset;
      var contents = this.source_.contents;

      var code;
      if (this.lastClassifierLocation_ < start) {
        code = contents.substring(this.lastClassifierLocation_, start);

        this.classifications_.push(new ClassifiedText(null, code));
      }

      code = contents.substring(start, end);
      this.classifications_.push(new ClassifiedText(category, code));
      this.lastClassifierLocation_ = end;
    },

    // Comments don't come back as tokens, so we need to override them to
    // capture the spans.
    skipSingleLineComment_: function() {
      var beginToken = this.index_;
      proto.skipSingleLineComment_.call(this);
      this.pushResult_(Classification.COMMENT, this.getTokenRange_(beginToken));
    },

    skipMultiLineComment_: function() {
      var beginToken = this.index_;
      proto.skipMultiLineComment_.call(this);
      this.pushResult_(Classification.COMMENT, this.getTokenRange_(beginToken));
    },

    scanToken_: function() {
      var token = proto.scanToken_.call(this);
      var c;
      switch (token.type) {
        case TokenType.ERROR:
          c = Classification.ERROR;
          break;

        case TokenType.IDENTIFIER:
          // contextual keywords
          switch (token.value) {
            case PredefinedName.GET:
            case PredefinedName.MODULE:
            case PredefinedName.SET:
              c = Classification.CONTEXTUAL;
              break;
            default: // otherwise, identifier
              c = Classification.IDENTIFIER;
          }
          break;

        case TokenType.OPEN_CURLY:
        case TokenType.CLOSE_CURLY:
        case TokenType.OPEN_PAREN:
        case TokenType.CLOSE_PAREN:
        case TokenType.OPEN_SQUARE:
        case TokenType.CLOSE_SQUARE:
        case TokenType.PERIOD:
        case TokenType.SEMI_COLON:
        case TokenType.COMMA:
        case TokenType.OPEN_ANGLE:
        case TokenType.CLOSE_ANGLE:
        case TokenType.LESS_EQUAL:
        case TokenType.GREATER_EQUAL:
        case TokenType.EQUAL_EQUAL:
        case TokenType.NOT_EQUAL:
        case TokenType.EQUAL_EQUAL_EQUAL:
        case TokenType.NOT_EQUAL_EQUAL:
        case TokenType.PLUS:
        case TokenType.MINUS:
        case TokenType.STAR:
        case TokenType.PERCENT:
        case TokenType.PLUS_PLUS:
        case TokenType.MINUS_MINUS:
        case TokenType.LEFT_SHIFT:
        case TokenType.RIGHT_SHIFT:
        case TokenType.UNSIGNED_RIGHT_SHIFT:
        case TokenType.AMPERSAND:
        case TokenType.BAR:
        case TokenType.CARET:
        case TokenType.BANG:
        case TokenType.TILDE:
        case TokenType.AND:
        case TokenType.OR:
        case TokenType.QUESTION:
        case TokenType.COLON:
        case TokenType.EQUAL:
        case TokenType.PLUS_EQUAL:
        case TokenType.MINUS_EQUAL:
        case TokenType.STAR_EQUAL:
        case TokenType.PERCENT_EQUAL:
        case TokenType.LEFT_SHIFT_EQUAL:
        case TokenType.RIGHT_SHIFT_EQUAL:
        case TokenType.UNSIGNED_RIGHT_SHIFT_EQUAL:
        case TokenType.AMPERSAND_EQUAL:
        case TokenType.BAR_EQUAL:
        case TokenType.CARET_EQUAL:
        case TokenType.SLASH:
        case TokenType.SLASH_EQUAL:
        case TokenType.DOT_DOT_DOT:
          c = Classification.OPERATOR;
          break;

        // 7.8 Literals
        case TokenType.NUMBER:
          c = Classification.NUMBER;
          break;

        case TokenType.STRING:
          c = Classification.STRING;
          break;

        case TokenType.REGULAR_EXPRESSION:
          c = Classification.REGEX;
          break;

        // These are treated as keywords in other colorizers
        case TokenType.NULL:
        case TokenType.TRUE:
        case TokenType.FALSE:

        // Seems like this should be colorized as a keyword, since it's a
        // short form of "function"
        case TokenType.POUND:
          c = Classification.KEYWORD;
          break;

        case TokenType.END_OF_FILE:
        default:
          if (Keywords.isKeyword(token.type)) {
            c = Classification.KEYWORD;
            break;
          }
          // EOF, or we didn't understand something. Exit.
          return token;
      }
      this.pushResult_(c, token.location);
      return token;
    }
  };

  /**
   * @param {string} source
   * @return {Array.<Classification>}
   */
  function getClassifiedTokens(source) {
    var sourceFile = new SourceFile('inline-script', source);
    var classifier = new Classifier(new ErrorReporter(), sourceFile);

    while (classifier.nextToken().type !== TokenType.END_OF_FILE) {
    }

    return classifier.classifications_;
  }

  /**
   * @param {string} source
   * @return {string} source the source with classification  tags added.
   */
  function classifySource(source) {
    var result = [];
    getClassifiedTokens(source).forEach(function(c) {
      if (c.category) {
        result.push('', c.text, '');
      } else {
        result.push(c.text);
      }
    });
    return result.join('');
  }

  classifyTraceurTokens = classifySource;

  function classifyAllScripts() {
    var scripts = document.querySelectorAll('pre');
    Array.prototype.forEach.call(scripts, function(preElement) {
      // get textContent to strip out existing tags
      var source = preElement.textContent;
      var classifiedSource = classifySource(source);

      // write it back as innerHTML to preserve  tags
      preElement.innerHTML = classifiedSource;
    });
  }

  classifyAllScripts();

})();


text:
<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="@color/textColorPrimary"/>
    <size android:height="1dp" android:width="1dp"/>
    <corners android:radius="1dp"/>
</shape>


text:
export const CHAT_ALREADY_EXISTS = 'CHAT_ALREADY_EXISTS';
export const CHAT_NEW = 'CHAT_NEW';
export const DISPLAY_CHAT_ON_RECIPIENT_SIDE = 'DISPLAY_CHAT_ON_RECIPIENT_SIDE';

export const READ_MESSAGE = 'READ_MESSAGE';
export const IS_USER_TYPING = 'IS_USER_TYPING';
export const SEND_MESSAGE = 'SEND_MESSAGE';


text:
using Nancy;
using Nancy.Conventions;

namespace NetDevPLWeb
{
    public class CustomConventionsBootstrapper : DefaultNancyBootstrapper
    {
        protected override void ConfigureConventions(NancyConventions nancyConventions)
        {
            base.ConfigureConventions(nancyConventions);

            nancyConventions.ViewLocationConventions.Clear();

            nancyConventions.ViewLocationConventions.Add(
                (viewName, model, viewLocationContext) =>
                    "features/" + viewLocationContext.ModuleName + "/Views/" + viewName);

            nancyConventions.ViewLocationConventions.Add(
                (viewName, model, viewLocationContext) =>
                    "features/Shared/Views/" + viewName);
        }
    }
}


text:
<?php
namespace Brainteaser\Domain\Exercise;

class ExerciseDoesNotExistException extends \Exception
{

}


text:
namespace Quickpay.Models.Account.Settings
{
    public class ViaBill
    {
        public bool active { get; set; }
        public string api_key { get; set; }
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

  <bean id="tags.personViewService" class="vtk.web.service.ServiceImpl">
    <property name="parent" ref="tags.viewService" />
    <property name="order" value="-10" />
    <property name="assertions">
      <list>
        <bean class="vtk.web.service.RequestParameterAssertion">
          <property name="parameterName" value="resource-type" />
          <property name="parameterValue" value="person" />
        </bean>
        <bean class="vtk.web.service.RequestParameterExistsAssertion">
          <property name="parameterName" value="tag" />
        </bean>
      </list>
    </property>
    <property name="handler" ref="tags.personHandler" />
  </bean>

  <bean id="tags.personHandler" parent="tags.handler">
    <property name="searchComponent" ref="tags.personSearchComponent" />
    <property name="alternativeRepresentations">
      <map>
        <entry key="application/atom+xml" value-ref="tags.personFeedService" />
      </map>
    </property>
  </bean>

  <bean id="tags.personFeedService" class="vtk.web.service.ServiceImpl">
    <property name="parent" ref="tags.personViewService" />
    <property name="assertions">
      <list>
        <ref bean="feedViewParameterAssertion" />
      </list>
    </property>
    <property name="handler" ref="tags.personFeedHandler" />
    <property name="serviceNameProvider" ref="tags.viewService.serviceNameProvider" />
  </bean>

  <bean id="tags.personFeedHandler" parent="tags.feedHandler">
    <property name="searchComponent" ref="tags.personSearchComponent" />
    <property name="viewName" value="personTags.feedView" />
  </bean>

  <bean id="personTags.feedView" parent="tags.feedView">
    <property name="feedMetadata">
      <map>
        <entry key="feed-type" value="person-tags" />
      </map>
    </property>
  </bean>

  <bean id="tags.personSearchComponent" parent="tags.searchComponent">
    <property name="name" value="tags.personSearchComponent" />
    <property name="queryBuilders">
      <list>
        <ref bean="tags.scopeQueryBuilder" />
        <bean class="vtk.web.search.PropertyValueQueryBuilder">
          <property name="parameterName" value="tag" />
          <property name="propertyTypeDefinition" ref="tagsPropDef" />
        </bean>
        <bean parent="queryStringParser">
          <property name="queryString" value="(type IN person AND resource:surname exists AND resource:firstName exists)" />
        </bean>
      </list>
    </property>
    <property name="searchSorting" ref="tags.personSearchSorting" />
  </bean>

  <bean id="tags.personSearchSorting" class="vtk.web.search.SearchSorting">
    <property name="sortOrderPropDefPointers">
      <list>
        <value>resource:surname</value>
        <value>resource:firstName</value>
      </list>
    </property>
    <property name="resourceTypeTree" ref="resourceTypeTree" />
    <property name="defaultSortOrder" ref="SORT_ORDER.ASC" />
  </bean>

</beans>


text:
package com.yifeistudio.guard.action;

import org.springframework.http.HttpRequest;

public abstract class AbstractAction {

    protected HttpRequest request;

    protected String token;

    protected String userId;

    public HttpRequest getRequest() {
        return request;
    }

    public void setRequest(HttpRequest request) {
        this.request = request;
    }

    public String getToken() {
        return token;
    }

    public void setToken(String token) {
        this.token = token;
    }

    public String getUserId() {
        return userId;
    }

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


text:
std::ostream& hello::greet(std::ostream& stream)
{
    return stream << "Hello World!";
}


text:
package org.nd4j.parameterserver.updater.storage;

import org.junit.Test;
import org.nd4j.BaseND4JTest;
import org.nd4j.aeron.ipc.NDArrayMessage;
import org.nd4j.linalg.factory.Nd4j;

import static junit.framework.TestCase.assertEquals;

/**
 * Created by agibsonccc on 12/2/16.
 */
public class UpdaterStorageTests extends BaseND4JTest {

    @Test(timeout = 30000L)
    public void testInMemory() {
        UpdateStorage updateStorage = new RocksDbStorage("/tmp/rocksdb");
        NDArrayMessage message = NDArrayMessage.wholeArrayUpdate(Nd4j.scalar(1.0));
        updateStorage.addUpdate(message);
        assertEquals(1, updateStorage.numUpdates());
        assertEquals(message, updateStorage.getUpdate(0));
        updateStorage.clear();
        assertEquals(0, updateStorage.numUpdates());
        updateStorage.close();
    }
}


text:
<?php
   session_start();
   include('includes/connection.php');
   include('functions/function.php');
   if(!isset($_SESSION['user_email']))
   {
      header("location: index.php");
   }
   else
   {
   ?>
<!DOCTYPE html>

   <link href="vendor/bootstrap/css/bootstrap.min.css" rel="stylesheet">

   <link href="css/freelancer.css" rel="stylesheet">

   <link href="vendor/font-awesome/css/font-awesome.min.css" rel="stylesheet" type="text/css">
   <link href="https://fonts.googleapis.com/css?family=Montserrat:400,700" rel="stylesheet" type="text/css">
   <link href="https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic" rel="stylesheet" type="text/css">

      <title>Welcome <?php echo $_SESSION['user_email'] ;?></title>

      <?php include('home_header.php'); ?>

                  <?php
                     $user=$_SESSION['user_email'];

                     $get_user="select * from users where user_email='$user'";
                     $run_user=mysqli_query($con,$get_user) or die(mysql_error());
                     $row=mysqli_fetch_array($run_user) or die(mysql_error());
                     $user_id=$row['user_id'];
                     $user_name=$row['user_name'];
                     $user_email=$row['user_email'];
                     $user_gender=$row['user_gender'];
                     $user_b_day=$row['user_b_day'];
                     $user_image=$row['user_image'];
                     $user_register=$row['register_date'];
                     $user_last=$row['last_login'];
                     $get_user_post="select * from post where user_id='$user_id'";
                     $run_user_post=mysqli_query($con,$get_user_post);
                     $count=mysqli_num_rows($run_user_post);
                $sel_msg="select * from messages where receiver='$user_id' AND status='unread' ORDER BY 1 DESC";
            $run=mysqli_query($con,$sel_msg) OR die("ERROR :".mysqli_error($con));
            $count_msg=mysqli_num_rows($run);
                     echo"

Name :$user_name

Member Since:$user_register

Last Login :$user_last

Messages ($count_msg):

                     Posts ($count):

                     Edit my Account :

                     Logout

                     "

                     ;
                     ?>

               <?php single_post() ;?>

              <?php } ?>


text:
begin
  require 'net/http'
  require 'open-uri'
  require 'json'
  require 'htmlentities'
  require 'uri'
rescue
  require 'rubygems'
  retry
end

module Twitter
  class ExcessRequestsException < StandardError; end
  class MalformedDataException  < StandardError; end

  class Client
    BASEURL = 'twitter.com'.freeze
    FORMAT  = '.json'

    def initialize(user, password)
      @user  = user
      @password = password
      @users = {}
      @me    = nil
    end

    def show(who)
      request = "/users/show/#{who}#{FORMAT}"
      make_user fetch(request)
    end

    def me
      @me ||= show @user
    end

    def public_timeline(since_id=nil)
      request = "/statuses/public_timeline#{FORMAT}"
      request << "?since_id=#{since_id}" if since_id
      build_message_list fetch(request, :get, :auth => false)
    end

    def friends_timeline(opts={})
      request = "/statuses/friends_timeline#{FORMAT}"
      build_message_list fetch(request, :get, opts)
    end

    def replies
      request = "/statuses/replies#{FORMAT}"
      build_message_list fetch(request)
    end

    def post(text)
      text = text[0...160]
      request = "/statuses/update#{FORMAT}"
      output = fetch request, :post, :fields => { :status => text, :source => "hechtetwitter" }
      make_message output
    end

    def friends(user, opts=nil)
      request = "/statuses/friends/#{user}#{FORMAT}"
      opts.each { |o, v| opts[o] = URI.encode v } if opts
      data = fetch(request, :get, opts)
      data.map { |u| make_user u }
    end

    def block_user(user)
      request = "/blocks/create/#{user.id}#{FORMAT}"
      fetch request
      nil
    end

    def user_timeline
      request = "/statuses/user_timeline#{FORMAT}"
      build_message_list fetch(request)
    end

    def remove_status(status)
      request = "/statuses/destroy/#{status.id}#{FORMAT}"
      fetch request
    end

    def show_status(status_id)
      request = "/statuses/show/#{status_id}#{FORMAT}"
      build_message_list fetch(request)
    end

    def favorites
      request = "/favorites#{FORMAT}"
      build_message_list fetch(request)
    end

    def make_favorite(message)
      request = "/favorites/create/#{message.id}#{FORMAT}"
      make_message fetch(request)
    end

    def remove_favorite(message)
      request = "/favorites/destroy/#{message.id}#{FORMAT}"
      make_message fetch(request)
    end

    private
    def fetch(what, method=:get, opts={})
      begin
        auth = opts[:auth] || true
        data = Net::HTTP.start(BASEURL) do |http|
                 req = if method == :get
                         if opts[:fields]
                           params = '?'
                           opts[:fields].map { |f, v| "#{f}=#{URI.encode v.to_s}" }
                           params << opts.join('&')
                           what << params
                         end
                         Net::HTTP::Get.new(what, { 'User-Agent' => 'HechteTwitter' })
                       else
                         r = Net::HTTP::Post.new(what, { 'User-Agent' => 'HechteTwitter' })
                         if opts[:fields]
                           fields = {}
                           opts[:fields].each { |o, v| fields[o.to_s] = v }
                           r.set_form_data fields if opts
                         end
                         r
                       end
                 req.basic_auth @user, @password if auth
                 http.request(req).body
               end
        check_data data
      rescue JSON::ParserError => jse
        raise MalformedDataException, "Malformed output from Twitter's servers."
      rescue ExcessRequestsException => ere
        raise ere
      rescue
        raise StandardError, "Problem retrieving information from Twitter's servers. Please contact Twitter for more information."
      end
    end

    def check_data(data)
      data = JSON.parse data
      raise ExcessRequestsException, data['error'] if data.is_a?(Hash) && data['error']
      data
    end

    def build_message_list(input)
      input.map { |m| make_message m }
    end

    def make_user(data)
      @users[data['id']] ||= User.new(data['id'], data['name'],
                                      data['screen_name'], data['location'],
                                      data['description'],
                                      data['profile_image_url'],
                                      data['url'], data['is_protected'], self)
    end

    def make_message(m)
      user = make_user m['user']
      text = HTMLEntities.decode_entities(m['text']).gsub('&', '&').
                                                     gsub('<', '<').
                                                     gsub('>', '>')
      Status.new(m['id'], Time.parse(m['created_at']), text, user,
                 m['favorited'], m['source'], self)
    end
  end

  class User
    attr_reader :id, :name, :screen_name, :location,
                :description, :profile_image_url, :url

    def initialize(id, name, screen_name, location, description,
                   profile_image_url, url, is_protected, client)
      @id = id
      @name = name
      @screen_name = screen_name
      @location = location
      @description = description
      @profile_image_url = profile_image_url
      @url = url
      @is_protected = is_protected
      @image = nil
      @friends = nil
      @followers = nil
      @client = client
    end

    def is_protected?
      @is_protected
    end

    def image
      begin
        @image ||= open(URI.encode(@profile_image_url)).read
      rescue
        @image = nil
      end
    end

    def friends
      @friends ||= @client.friends @screen_name
    end

    def to_s
      "#@id\n#@name\n#@screen_name\n#@location\n#@description\n"
    end

    def block!
      @client.block_user(self) if self != @client.me
    end
  end

  class Status
    attr_reader :id, :created_at, :text, :user
    def initialize(id, created_at, text, user, favorited,
                   source, client)
      @id = id
      @created_at = created_at
      @text = text
      @user = user
      @favorited = favorited
      @source = source
      @client = client
    end

    def ==(other)
      @id == other.id
    end

    def mentions?(user)
      !(@text =~ /#{user.screen_name}/i).nil?
    end

    def belongs_to?(user)
      @user == user
    end

    def favorite!
      @client.make_favorite self
      @favorited = true
    end

    def unfavorite
      @client.remove_favorite self
      @favorited = false
    end

    def favorite?
      @favorited
    end

    def destroy!
      @client.remove_status self
    end

    def to_s
      "#{@user.to_s}\n\n#{@created_at.to_s}\n#{@text}\n#{@user}"
    end
  end
end


text:
<?php

namespace AppBundle\Manager\Payment\PriceSummand;

use AppBundle\Entity\AcquisitionAttribute\Attribute;
use AppBundle\Entity\AcquisitionAttribute\Fillout;
use AppBundle\Entity\Participant;

class FilloutSummand extends BaseSummand implements SummandInterface, AttributeAwareInterface
{

    /**
     * Fillout
     *
     * @var Fillout
     */
    protected $fillout;

    /**
     * Get price in euro
     *
     * @var float|int
     */
    protected $value;

    /**
     * FilloutSummand constructor.
     *
     * @param SummandImpactedInterface $impacted
     * @param Fillout $fillout
     * @param float|int $value Numeric summand value in euro
     */
    public function __construct(SummandImpactedInterface $impacted, Fillout $fillout, $value)
    {
        $this->fillout = $fillout;
        $this->value   = $value;

        if ($this->fillout->getParticipation()) {
            $cause = $this->fillout->getParticipation();
        } elseif ($this->fillout->getParticipant()) {
            $cause = $this->fillout->getParticipant();
        } elseif ($this->fillout->getEmployee()) {
            $cause = $this->fillout->getEmployee();
        } else {
            throw new \InvalidArgumentException('Unknown cause for summand');
        }

        parent::__construct($impacted, $cause);
    }

    /**
     * {@inheritdoc}
     */
    public function getType(): string
    {
        return 'Feld';
    }

    /**
     * {@inheritdoc}
     */
    public function getValue($inEuro = false)
    {
        $value = $inEuro ? $this->value : (100*$this->value);
        if (is_float($value) && round($value, 0) === round($value, 2)) {
            return (int)round($value, 0);
        }
        return $value;
    }

    /**
     * Get related attribute
     *
     * @return Attribute
     */
    public function getAttribute(): Attribute
    {
        return $this->fillout->getAttribute();
    }

    /**
     * Get related fillout
     *
     * @return Fillout
     */
    public function getFillout(): Fillout
    {
        return $this->fillout;
    }

}


text:
package io.github.leonhover.videorecorder.camera;

import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.SurfaceTexture;
import android.opengl.GLSurfaceView;
import android.opengl.Matrix;
import android.util.AttributeSet;
import android.util.Log;
import android.view.SurfaceHolder;

import java.lang.ref.WeakReference;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import io.github.leonhover.videorecorder.R;
import io.github.leonhover.videorecorder.opengl.filter.GLSurfaceFilter;

/**
 * 相机预览控件
 * Created by wangzongliang on 17-3-29.
 */

public class CameraView extends GLSurfaceView implements SurfaceTexture.OnFrameAvailableListener {

    private static final String TAG = "CameraView";

    private final static float LAYOUT_RATIO_NONE = 0.0f;

    private final static int PREVIEW_ROTATION_0 = 0;
    private final static int PREVIEW_ROTATION_90 = 90;
    private final static int PREVIEW_ROTATION_180 = 180;
    private final static int PREVIEW_ROTATION_270 = 270;

    private CameraRenderer mRenderer;
    protected SurfaceTexture mSurfaceTexture;
    private CameraSurfaceListener mCameraSurfaceListener;
    //预览大小
    private int mPreviewWidth = 0;
    private int mPreviewHeight = 0;
    private int mPreviewRotation = 0;
    private GLSurfaceFilter mGLSurfaceFilter;
    private float mLayoutRatio = LAYOUT_RATIO_NONE;

    public CameraView(Context context) {
        this(context, null);
    }

    public CameraView(Context context, AttributeSet attrs) {
        super(context, attrs);

        TypedArray typedArray = null;

        try {
            typedArray = context.obtainStyledAttributes(attrs, R.styleable.CameraView);
            mLayoutRatio = typedArray.getFloat(R.styleable.CameraView_layout_ratio, LAYOUT_RATIO_NONE);
        } finally {
            if (typedArray != null) {
                typedArray.recycle();
            }
        }

        mRenderer = new CameraRenderer(this);
        setEGLContextClientVersion(2);
        setRenderer(mRenderer);
        setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
    }

    public void setCameraSurfaceListener(CameraSurfaceListener cameraSurfaceListener) {
        this.mCameraSurfaceListener = cameraSurfaceListener;
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        super.surfaceCreated(holder);
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        super.surfaceDestroyed(holder);
        this.mPreviewHeight = 0;
        this.mPreviewWidth = 0;
        mSurfaceTexture.setOnFrameAvailableListener(null);
        if (this.mCameraSurfaceListener != null) {
            this.mCameraSurfaceListener.onCameraSurfaceDestroy(mSurfaceTexture);
        }
        mSurfaceTexture.release();
    }

    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
        requestRender();
    }

    private static class CameraRenderer implements Renderer {

        private static final String TAG = "CameraRenderer";
        //纹理ID
        private int mTextureId;
        //纹理坐标矩阵
        private final float[] mSTMatrix = new float[16];
        //坐标转换矩阵
        private final float[] mMvpMatrix = new float[16];

        private WeakReference<CameraView> mCameraViewRef;

        public CameraRenderer(CameraView cameraView) {
            this.mCameraViewRef = new WeakReference<CameraView>(cameraView);
        }

        @Override
        public void onSurfaceCreated(GL10 gl, EGLConfig config) {
            Log.d(TAG, "onSurfaceCreated");

            final CameraView cameraView = mCameraViewRef.get();
            if (cameraView != null) {
                cameraView.mGLSurfaceFilter = new GLSurfaceFilter();

                Matrix.setIdentityM(mMvpMatrix, 0);
                mTextureId = cameraView.mGLSurfaceFilter.createTexture();
                cameraView.mSurfaceTexture = new SurfaceTexture(mTextureId);
                cameraView.mSurfaceTexture.setOnFrameAvailableListener(cameraView);
                if (cameraView.mCameraSurfaceListener != null) {
                    cameraView.mCameraSurfaceListener.onCameraSurfaceCreate(cameraView.mSurfaceTexture);
                }
            }
        }

        @Override
        public void onSurfaceChanged(GL10 gl, int width, int height) {
            Log.d(TAG, "onSurfaceChanged " + "width:" + width + ",height:" + height);
            updateViewPort();
            final CameraView cameraView = mCameraViewRef.get();
            if (cameraView != null) {
                if (cameraView.mCameraSurfaceListener != null) {
                    cameraView.mCameraSurfaceListener.onCameraSurfaceChanged(cameraView.mSurfaceTexture, width, height);
                }
            }
        }

        @Override
        public void onDrawFrame(GL10 gl) {
            final CameraView cameraView = mCameraViewRef.get();
            if (cameraView != null) {
                cameraView.mSurfaceTexture.updateTexImage();
                if (cameraView.mCameraSurfaceListener != null) {
                    cameraView.mCameraSurfaceListener.onCameraSurfaceUpdate(cameraView.mSurfaceTexture, mTextureId);
                }

                cameraView.mSurfaceTexture.getTransformMatrix(mSTMatrix);

                cameraView.mGLSurfaceFilter.draw(mTextureId, mSTMatrix);
            }

        }

        public void updateViewPort() {
            final CameraView cameraView = mCameraViewRef.get();
            if (cameraView != null) {
                final int viewWidth = cameraView.getWidth();
                final int viewHeight = cameraView.getHeight();
                final int previewWidth = cameraView.mPreviewWidth;
                final int previewHeight = cameraView.mPreviewHeight;

                //CenterCrop
                float scaleX = 1.0f;
                float scaleY = 1.0f;
                final double previewRatio = previewWidth * 1.0f / previewHeight;
                final double viewRatio = viewWidth * 1.0f / viewHeight;

                if (previewRatio < viewRatio) {
                    scaleY = (float) (previewHeight * 1.0f / (previewWidth / viewRatio));
                } else {
                    scaleX = (float) (previewWidth * 1.0f / (previewHeight * viewRatio));
                }

                Log.d(TAG, "scaleX:" + scaleX + ",scaleY:" + scaleY + ",previewRatio:" + previewRatio + ",viewRatio:" + viewRatio);
                Matrix.setIdentityM(mMvpMatrix, 0);
                Matrix.scaleM(mMvpMatrix, 0, scaleX, scaleY, 1.0f);

                if (cameraView.mGLSurfaceFilter != null) {
                    cameraView.mGLSurfaceFilter.setMvpMatrix(mMvpMatrix);
                }

            }
        }

    }

    /**
     * 设置预览的旋转角度,请在调用{link setPreviewSize}前调用,否则会抛出IllegalStateException.
     *
     * @param rotation 旋转角度
     */
    void setPreviewRotation(int rotation) {
        this.mPreviewRotation = rotation;
        if (this.mPreviewWidth * this.mPreviewHeight != 0) {
            throw new IllegalStateException("please invoke setPreviewRotation before setPreviewSize");
        }
    }

    /**
     * 设置预览大小
     * @param width 宽度
     * @param height 高度
     */
    public void setPreviewSize(int width, int height) {
        this.mPreviewWidth = width;
        this.mPreviewHeight = height;

        queueEvent(new Runnable() {
            @Override
            public void run() {
                mRenderer.updateViewPort();
            }
        });
    }

    public void setRatio(float ratio) {
        this.mLayoutRatio = ratio;
        requestLayout();
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mLayoutRatio > 0) {
            int widthSpec = MeasureSpec.getSize(widthMeasureSpec);
            int newHeightMeasureSpec = MeasureSpec.makeMeasureSpec((int) (widthSpec / mLayoutRatio), MeasureSpec.EXACTLY);
            super.onMeasure(widthMeasureSpec, newHeightMeasureSpec);
        } else {
            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        }
    }

    public interface CameraSurfaceListener {
        void onCameraSurfaceCreate(SurfaceTexture surfaceTexture);

        void onCameraSurfaceChanged(SurfaceTexture surfaceTexture, int width, int height);

        void onCameraSurfaceDestroy(SurfaceTexture surfaceTexture);

        void onCameraSurfaceUpdate(SurfaceTexture surfaceTexture, int textureId);
    }
}


text:
//
//  GMSPolylineOptions.h
//  Google Maps SDK for iOS
//
//  Copyright 2012 Google Inc.
//
//  Usage of this SDK is subject to the Google Maps/Google Earth APIs Terms of
//  Service: https://developers.google.com/maps/terms
//

@class GMSPath;

/**
 * Contains options used to configure a polyline.
 */
@interface GMSPolylineOptions : NSObject<NSCopying>

/** The path that describes this polyline. */
@property (nonatomic, copy) GMSPath *path;

/** The UIColor used to render the polyline. Defaults to blueColor. */
@property (nonatomic, strong) UIColor *color;

/** The width of the line in screen points. Defaults to 1. */
@property (nonatomic, assign) float width;

/** If this line should be rendered with geodesic correction. */
@property (nonatomic, assign) BOOL geodesic;

/**
 * The accessibility label of this polyline, as per the UIAccessibility
 * protocol.
 */
@property (nonatomic, copy) NSString *accessibilityLabel;

/** Convenience constructor for default initialized options. */
+ (GMSPolylineOptions *)options;

@end


text:
<?php

namespace Agile\NimbleBoardBundle\Entity;

use Doctrine\ORM\EntityRepository;

/**
 * StoryRepository
 *
 * This class was generated by the Doctrine ORM. Add your own custom
 * repository methods below.
 */
class StoryRepository extends EntityRepository
{
  public function findOneByIdJoinedToProject($id)
  {
    $query = $this->getEntityManager()->createQuery('
      select s, p from NimbleBoardBundle:Story s
      join s.project p
      where s.id = :id
    ')->setParameter(':id', $id);
    try {
      return $query->getSingleResult();
    } catch(\Doctrine\ORM\NoResultException $e) {
      return null;
    }
  }

  /**
   * User for product backlog : all stories in project which are not in a sprint
   */
  public function findByProjectWithoutSprint($projectId)
  {
    $query = $this->getEntityManager()->createQuery('
      select s, p from NimbleBoardBundle:Story s
      join s.project p
      where p.id = :projectId and s.sprint is null
    ')->setParameter(':projectId', $projectId);
    return $query->getResult();
  }
}


text:
package org.jboss.hal.client.configuration.subsystem.elytron;

import java.util.List;
import java.util.function.Supplier;

import javax.inject.Inject;

import org.jboss.hal.core.CrudOperations;
import org.jboss.hal.core.finder.Finder;
import org.jboss.hal.core.finder.FinderColumn;
import org.jboss.hal.core.finder.ItemActionFactory;
import org.jboss.hal.core.finder.PreviewContent;
import org.jboss.hal.core.finder.StaticItem;
import org.jboss.hal.core.finder.StaticItemColumn;
import org.jboss.hal.core.mvp.Places;
import org.jboss.hal.meta.token.NameTokens;
import org.jboss.hal.resources.Ids;
import org.jboss.hal.resources.Names;
import org.jboss.hal.resources.Resources;
import org.jboss.hal.spi.AsyncColumn;

import static java.util.Arrays.asList;
import static java.util.stream.Collectors.toList;

/**
 * Holds the top level items to configure the elytron subsystem.
 */
@AsyncColumn(Ids.ELYTRON)
public class ElytronColumn
        extends FinderColumn<StaticItem> { // doesn't extend from StaticItemColumn because we need more flexibility

    @Inject
    public ElytronColumn(Finder finder,
            ItemActionFactory itemActionFactory,
            CrudOperations crud,
            Places places,
            Resources resources) {

        super(new Builder<StaticItem>(finder, Ids.ELYTRON, resources.constants().settings())
                .itemRenderer(StaticItemColumn.StaticItemDisplay::new)
                .onPreview(StaticItem::getPreviewContent)
                .useFirstActionAsBreadcrumbHandler()
                .withFilter());

        Supplier<List<StaticItem>> itemsSupplier = () -> asList(
                new StaticItem.Builder(resources.constants().globalSettings())
                        .id(Ids.ELYTRON)
                        .action(itemActionFactory.viewAndMonitor(Ids.ELYTRON,
                                places.selectedProfile(NameTokens.ELYTRON).build()))
                        .onPreview(new ElytronSubsystemPreview(crud, resources))
                        .keywords("global", "settings")
                        .build(),

                new StaticItem.Builder(Names.FACTORIES_TRANSFORMERS)
                        .id(Ids.ELYTRON_FACTORIES_TRANSFORMERS)
                        .action(itemActionFactory.viewAndMonitor(Ids.ELYTRON_FACTORIES_TRANSFORMERS,
                                places.selectedProfile(NameTokens.ELYTRON_FACTORIES_TRANSFORMERS).build()))
                        .onPreview(new PreviewContent<>(Names.FACTORIES_TRANSFORMERS,
                                resources.previews().configurationElytronFactories()))
                        .keywords("factory", "transformer", "http", "sasl", "kerberos", "principal")
                        .build(),

                new StaticItem.Builder(Names.MAPPERS_DECODERS)
                        .id(Ids.ELYTRON_MAPPERS_DECODERS)
                        .action(itemActionFactory.viewAndMonitor(Ids.ELYTRON_MAPPERS_DECODERS,
                                places.selectedProfile(NameTokens.ELYTRON_MAPPERS_DECODERS).build()))
                        .onPreview(new PreviewContent<>(Names.MAPPERS_DECODERS,
                                resources.previews().configurationElytronMappersDecoders()))
                        .keywords("mapper", "decoder", "role", "permission", "principal")
                        .build(),

                new StaticItem.Builder(Names.OTHER_SETTINGS)
                        .action(itemActionFactory.viewAndMonitor(Ids.asId(Names.OTHER_SETTINGS),
                                places.selectedProfile(NameTokens.ELYTRON_OTHER).build()))
                        .onPreview(new PreviewContent<>(Names.OTHER_SETTINGS,
                                resources.previews().configurationElytronOtherSettings()))
                        .keywords("store", "ssl", "authentication", "ldap")
                        .build(),

                new StaticItem.Builder(Names.SECURITY_REALMS)
                        .action(itemActionFactory.viewAndMonitor(Ids.asId(Names.SECURITY_REALMS),
                                places.selectedProfile(NameTokens.ELYTRON_SECURITY_REALMS).build()))
                        .onPreview(new PreviewContent<>(Names.SECURITY_REALMS,
                                resources.previews().configurationElytronSecurityRealms()))
                        .keywords("realm")
                        .build()
        );

        setItemsProvider((context, callback) -> callback.onSuccess(itemsSupplier.get()));
        setBreadcrumbItemsProvider(
                (context, callback) -> callback.onSuccess(
                        itemsSupplier.get().stream().filter(item -> item.getNextColumn() == null).collect(toList())));
    }
}


text:
package com.nscg.app.model.domain;

import java.io.Serializable;

/**
 * Created by liuyongfeng on 2018/3/20.
 */

public class Log implements Serializable {
    private String title;
    private String date;
    private String content;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getDate() {
        return date;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}


text:
// Generated by xsd compiler for ios/objective-c
// DO NOT CHANGE!

#import <Foundation/Foundation.h>
#import "PicoClassSchema.h"
#import "PicoPropertySchema.h"
#import "PicoConstants.h"
#import "PicoBindable.h"
#import "Shopping_AbstractRequestType.h"

/**

 This call will give you the ability to retrieve high level
 Category information, relevant for a buy-side application.

 @ingroup ShoppingInterface
*/
@interface Shopping_GetCategoryInfoRequestType : Shopping_AbstractRequestType {

@private
    NSString *_categoryID;
    NSString *_includeSelector;

}

/**

 Use an ID of -1 to retrieve the root category and the top-level (level
 1) meta categories. You can determine other CategoryIDs from the
 response from this call, or from a specific item (retrieved from
 another call like GetSingleItem), or from the eBay
 website.

 type : NSString, wrapper for primitive string
*/
@property (nonatomic, strong) NSString *categoryID;

/**

 Defines standard subsets of fields to return within the
 response. If you don't specify this field, the call returns
 a default set of fields. If you specify this field, the
 additional fields (child categories) you retrieve can affect
 the call's response time (decrease performance).
 Applicable values:

•   ChildCategories

Include the first level of child categories for
 the specified parent.

 type : NSString, wrapper for primitive string
*/
@property (nonatomic, strong) NSString *includeSelector;

@end