text:
package io.pivotal.example.data;

import com.gemstone.gemfire.pdx.PdxReader;
import com.gemstone.gemfire.pdx.PdxSerializable;
import com.gemstone.gemfire.pdx.PdxWriter;

import java.util.List;

/**
 * POJO example to represent business object for example
 * @author wmarkito
 */
public class Transaction implements PdxSerializable {

    private String id;
    private long sequenceNumber;
    private String operation;
    private int pointOfSaleId;
    private List<TransactionItem> items;

    public Transaction()  {

    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public long getSequenceNumber() {
        return sequenceNumber;
    }

    public void setSequenceNumber(long sequenceNumber) {
        this.sequenceNumber = sequenceNumber;
    }

    public String getOperation() {
        return operation;
    }

    public void setOperation(String operation) {
        this.operation = operation;
    }

    public int getPointOfSaleId() {
        return pointOfSaleId;
    }

    public void setPointOfSaleId(int pointOfSaleId) {
        this.pointOfSaleId = pointOfSaleId;
    }

    public List<TransactionItem> getItems() {
        return items;
    }

    public void setItems(List<TransactionItem> items) {
        this.items = items;
    }

    @Override
    public void toData(PdxWriter pdxWriter) {
        pdxWriter.markIdentityField("id").markIdentityField("pointOfSaleId")
                .writeString("id", id)
                .writeLong("sequenceNumber", sequenceNumber)
                .writeInt("pointOfSaleId", pointOfSaleId)
                .writeString("operation", operation)
                .writeObject("items", items);
    }

    @Override
    public void fromData(PdxReader pdxReader) {

        id = pdxReader.readString("id");
        sequenceNumber = pdxReader.readLong("sequenceNumber");
        pointOfSaleId = pdxReader.readInt("pointOfSaleId");
        operation = pdxReader.readString("operation");
        items = (List<Transaction.TransactionItem>) pdxReader.readObject("items");

    }

    public static class TransactionItem implements PdxSerializable {
        private double amount;
        private String id;

        public TransactionItem() {}

        public TransactionItem(double amount, String id) {
            this.setAmount(amount);
            this.setId(id);
        }

        @Override
        public void toData(PdxWriter pdxWriter) {
            pdxWriter.writeString("id", getId())
                    .writeDouble("amount", getAmount());
        }

        @Override
        public void fromData(PdxReader pdxReader) {
             setId(pdxReader.readString("id"));
             setAmount(pdxReader.readDouble("amount"));
        }

        public double getAmount() {
            return amount;
        }

        public void setAmount(double amount) {
            this.amount = amount;
        }

        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

    }

    @Override
    public String toString() {
        final StringBuffer sb = new StringBuffer("Transaction{");
        sb.append("id='").append(id).append('\'');
        sb.append(", sequenceNumber=").append(sequenceNumber);
        sb.append(", operation='").append(operation).append('\'');
        sb.append(", pointOfSaleId=").append(pointOfSaleId);
        sb.append(", items=").append(items);
        sb.append('}');

        return sb.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Transaction that = (Transaction) o;

        if (pointOfSaleId != that.pointOfSaleId) return false;
        if (sequenceNumber != that.sequenceNumber) return false;
        if (!id.equals(that.id)) return false;
        if (items != null ? !items.equals(that.items) : that.items != null) return false;
        if (!operation.equals(that.operation)) return false;

        return true;
    }

    @Override
    public int hashCode() {
        int result = id.hashCode();
        result = 31 * result + (int) (sequenceNumber ^ (sequenceNumber >>> 32));
        result = 31 * result + operation.hashCode();
        result = 31 * result + pointOfSaleId;
        result = 31 * result + (items != null ? items.hashCode() : 0);
        return result;
    }
}


text:
struct OUT{
	float4 c:COLOR0;
//	float d:DEPTH;
};
struct IN{
	float3 light[NUM_DIRECTIONAL+1]:COLOR;
	float2 t0:TEXCOORD0;
};

sampler2D sDiffuse;
sampler2D sNormal;
sampler2D sSpecular;
float4 DiffuseMaterial;
float4 SpecularMaterial;
float3 DiffuseDirectional[NUM_DIRECTIONAL];
float3 SpecularDirectional[NUM_DIRECTIONAL];
float3 LightVectorDirectional[NUM_DIRECTIONAL];
float3 AmbientLight;
//int NumDirectional;
OUT Entry(IN _in){
	OUT _out;
	float3 n=normalize(tex2D(sNormal,_in.t0).xyz-float3(0.5,0.5,0.5));
	float4 DiffuseColor=tex2D(sDiffuse,_in.t0);
	float4 SpecularColor=tex2D(sSpecular,_in.t0);
	_out.c.xyz=AmbientLight*DiffuseColor.xyz;
	SpecularColor.w*=255;

//	SpecularColor.xyz=1;
//	SpecularColor.w=59;
//	SpecularColor=SpecularMaterial;

	for(int i=0 ;  i < NUM_DIRECTIONAL; ++i){
		//float3 HalfVector
		float4 light=lit(dot(normalize(_in.light[i]),n),dot(normalize(_in.light[i] + _in.light[NUM_DIRECTIONAL]),n),SpecularColor.w);
		_out.c.xyz+=DiffuseColor.xyz*(light.y*DiffuseDirectional[i])+SpecularColor.xyz*(light.z*SpecularDirectional[i]);
	}
	_out.c.w=DiffuseColor.w;
	return _out;
}

redpajama_set_name: RedPajamaGithub


text:
'use strict';

var _objectAssign = require('object-assign');

var _objectAssign2 = _interopRequireDefault(_objectAssign);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

var printableResults = function printableResults(results) {
	return results.map(function (res) {
		return JSON.stringify(res, null, 4);
	});
};

var withStacktrace = function withStacktrace(errors) {
	return errors.map(function (e) {
		return e.stack ? e.message + ': ' + e.stack : JSON.stringify(e, null, 4);
	});
};

function run(handler, event) {
	var opts = arguments.length <= 2 || arguments[2] === undefined ? {} : arguments[2];

	var defaults = {
		name: 'MockFunctionName',
		memoryLimitInMB: '128',
		timeoutInSec: 3,
		invokeid: '' + Date.now(),
		functionVersion: '$LATEST',
		invokedFunctionArn: null,
		logGroupName: null,
		logStreamName: 'mockLogStreamName'
	};

	opts = (0, _objectAssign2.default)({}, defaults, opts);

	if (!opts.invokedFunctionArn) {
		opts.invokedFunctionArn = 'arn:mock:lambda:abc:function:' + name;
	}

	if (!opts.logGroupName) {
		opts.logGroupName = '/aws/lambda/' + name;
	}

	var timeoutInSec = opts.timeoutInSec;
	var start = Date.now();
	function getRemainingTimeInMillis() {
		return start + timeoutInSec * 1000 - Date.now();
	}

	var context = (0, _objectAssign2.default)({
		succeed: function succeed() {
			var _console;

			for (var _len = arguments.length, results = Array(_len), _key = 0; _key < _len; _key++) {
				results[_key] = arguments[_key];
			}

			(_console = console).log.apply(_console, _toConsumableArray(['SUCCESS'].concat(printableResults(results))));
		},
		fail: function fail() {
			var _console2;

			for (var _len2 = arguments.length, results = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
				results[_key2] = arguments[_key2];
			}

			(_console2 = console).log.apply(_console2, _toConsumableArray(['FAILURE'].concat(withStacktrace(results))));
		},
		done: function done() {
			var _console3;

			for (var _len3 = arguments.length, results = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
				results[_key3] = arguments[_key3];
			}

			(_console3 = console).log.apply(_console3, _toConsumableArray(['DONE'].concat(printableResults(results))));
		}
	}, opts);

	// timeoutInSec is not available in Lambda and only used in getRemainingTimeInMillis
	delete context.timeoutInSec;

	handler(event, context);
}

module.exports = {
	run: run
};


text:
		<meta http-equiv=content-type content="text/html;charset=ISO-8859-1">		<TITLE>Dictionary of Botanical Epithets</TITLE>
Dictionary of Botanical Epithets

undatus - urceolatus

© 2019

Epithet
Definition

Derivation
Stem
Type/
                  Gender
Meaning

undatus
undata
undatum	wavy edged

unda	und	noun/f	a wave

atus	at	adj	adjectival suffix for nouns: possessive of or likeness of something (with, shaped, made)/ for verb participles: a completed action, -ed

Psychotria undata Jacq.
Cereus undatus Haw.

undulatifolius
undulatifolia
undulatifolium	wavy edged leaves

undulatus	undulat	adj	undulated

i	i	cnct	connective vowel used by botanical Latin

folius	foli	adj	folium
leaf

Tulipa undulatifolia Boiss.
Panicum undulatifolium Ard.
Oplismenus undulatifolius (Ard.) Roem. & Schult.

undulatus
undulata
undulatum	wavy edged

undulatus	undulat	adj	undulated

Allocarya undulata Piper
Trillium undulatum Willd.
Aster undulatus L.

unedo
unedones
 	the strawberry tree

unedo	unedon	noun/m	the strawberry tree (also called arbutus), Arbutus unedo

Arbutus unedo L.

unguicularis
unguicularis
unguiculare	with a claw

unguiculus	unguicul	adj	a fingernail

aris	ar	adj	alis
adjective suffix for nouns: of or pertaining to

Iris unguicularis Poir.

unguiculatus
unguiculata
unguiculatum	with a claw

unguiculus	unguicul	adj	a fingernail

atus	at	adj	adjectival suffix for nouns: possessive of or likeness of something (with, shaped, made)/ for verb participles: a completed action, -ed

Clarkia unguiculata Lindl.
Solanum unguiculatum A. Rich.
Dolichos unguiculatus L.

unguis-cati
ungues-catorum
 	cat's claw

unguis	ungu	noun/m	fingernail, toenail, claw, hoof

-	-	cnct
generative of catus	cat	noun/m	male cat (minor usage)

Macfadyena unguis-cati (L.) A.H.Gentry

uniflorifer
uniflorifera
unifloriferum	bearing one flower

unus	un	adj	one; single, sole; an

i	i	cnct	connective vowel used by botanical Latin

flos	flor	noun/m	L.
flower

i	i	cnct	connective vowel used by botanical Latin

fer	fer	apar	fero
to bear, carry, bring

Rubus uniflorifer Bailey

uniflorus
uniflora
uniflorum	one flowered

unus	un	adj	one; single, sole; an

i	i	cnct	connective vowel used by botanical Latin

florus	flor	ppar	floreo
to bloom, to flower

Calceolaria uniflora Ruiz & Pav.
Ipheion uniflorum (Graham) Raf.
Calochortus uniflorus Hook. & Arn.

unifoliatus
unifoliata
unifoliatum	one leaved

unus	un	adj	one; single, sole; an

i	i	cnct	connective vowel used by botanical Latin

foliatus	foliat	adj	provided with or having leaves

Tiarella unifoliata Hook.
Astragalus unifoliatus Bunge

unifolius
unifolia
unifolium	one leaved

unus	un	adj	one; single, sole; an

i	i	cnct	connective vowel used by botanical Latin

folius	foli	adj	folium
leaf

Malaxis unifolia Michx.
Allium unifolium Kellogg
Cyperus unifolius Boeckl.

uninervis
uninervis
uninerve	one veined

unus	un	adj	one; single, sole; an

i	i	cnct	connective vowel used by botanical Latin

nervus	nerv	noun/m	νευρον
a sinew, tendon, nerve

is		adj	adjectival suffix

Halodule uninervis Boiss.

uninervius
uninervia
uninervium	single veined

unus	un	adj	one; single, sole; an

i	i	cnct	connective vowel used by botanical Latin

nervus	nerv	noun/m	νευρον
a sinew, tendon, nerve

ius	i	adj	-ιοϛ
adjective suffix for nouns: characteristic of, connected to, resembling, when related to -eus: of..., ...like

Diplachne uninervia (J. Presl) Parodi

urbanus
urbana
urbanum	from the city

urbanus	urban	adj	of or in the city, town; in Rome

Geum urbanum L.

urbius
urbia
urbium	of towns

urbs	urb	noun/f	a walled town or city

ius	i	adj	-ιοϛ
adjective suffix for nouns: characteristic of, connected to, resembling, when related to -eus: of..., ...like

urceolatus
urceolata
urceolatum	pitcher shaped

urceolus	urceol	noun/m	a little pitcher

atus	at	adj	adjectival suffix for nouns: possessive of or likeness of something (with, shaped, made)/ for verb participles: a completed action, -ed

Galax urceolata (Poir.) Brummitt
Conotrema urceolatum (Ach.) Tuck.


text:
package com.github.stathvaille.marketimports.domain.staticdataexport;

import lombok.Value;

import java.util.Map;

@Value
public class Groups {
    private final Map<Long, Group> groups;

    public Groups(Map<Long, Group> groups){
        this.groups = groups;
    }
}


text:
import nonportable

NORMAL_THREADS = str(500) # How many threads to report for Desktop systems
MINIMUM_THREADS = str(5)  # "" for Mobile Systems

# If we see more than this many processes, assume a desktop system
NON_MOBILE_THRES = 50

# Predetermine based on OS the suitability of using 500 threads
DESKTOP = ["Linux", "Darwin", "Windows"]
MOBILE = ["WindowsCE", "Unknown"]

ostype = nonportable.ostype

# If we are on linux, check if it is mobile, e.g. Nokia
if ostype == "Linux":
  try:
    # Try this command, see if we can determine the number of processes
    # ps ax should list all the processes running, and wc will tally them up
    cmd = "ps ax | wc -l"

    # Launch ps
    import subprocess
    proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)

    # Get the output
    cmddata = proc.stdout.read()
    p.stdout.close()

    count = int(cmddata.strip())

    if count >= NON_MOBILE_THRES:
      print NORMAL_THREADS
    else:
      print MINIMUM_THREADS
    exit()

  except:
    # It is probably better to assume we are on a Desktop for Linux systems
    print NORMAL_THREADS
    exit()

# Check if this is a Desktop category
if ostype in DESKTOP:
  print NORMAL_THREADS

# Fall back onto mobile
else:
  print MINIMUM_THREADS


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.HashZero = void 0;
exports.HashZero = "0x0000000000000000000000000000000000000000000000000000000000000000";
//# sourceMappingURL=hashes.js.map


text:
#ifndef FIO_THREAD_OPTIONS_H
#define FIO_THREAD_OPTIONS_H

#include "arch/arch.h"
#include "os/os.h"
#include "stat.h"
#include "gettime.h"
#include "lib/ieee754.h"
#include "td_error.h"

/*
 * What type of allocation to use for io buffers
 */
enum fio_memtype {
	MEM_MALLOC = 0,	/* ordinary malloc */
	MEM_SHM,	/* use shared memory segments */
	MEM_SHMHUGE,	/* use shared memory segments with huge pages */
	MEM_MMAP,	/* use anonynomous mmap */
	MEM_MMAPHUGE,	/* memory mapped huge file */
};

#define ERROR_STR_MAX	128

#define BSSPLIT_MAX	64

struct bssplit {
	uint32_t bs;
	uint32_t perc;
};

#define OPT_MAGIC	0x4f50544e

struct thread_options {
	int magic;
	char *description;
	char *name;
	char *directory;
	char *filename;
	char *filename_format;
	char *opendir;
	char *ioengine;
	char *mmapfile;
	enum td_ddir td_ddir;
	unsigned int rw_seq;
	unsigned int kb_base;
	unsigned int unit_base;
	unsigned int ddir_seq_nr;
	long long ddir_seq_add;
	unsigned int iodepth;
	unsigned int iodepth_low;
	unsigned int iodepth_batch;
	unsigned int iodepth_batch_complete;

	unsigned long long size;
	unsigned long long io_limit;
	unsigned int size_percent;
	unsigned int fill_device;
	unsigned int file_append;
	unsigned long long file_size_low;
	unsigned long long file_size_high;
	unsigned long long start_offset;

	unsigned int bs[DDIR_RWDIR_CNT];
	unsigned int ba[DDIR_RWDIR_CNT];
	unsigned int min_bs[DDIR_RWDIR_CNT];
	unsigned int max_bs[DDIR_RWDIR_CNT];
	struct bssplit *bssplit[DDIR_RWDIR_CNT];
	unsigned int bssplit_nr[DDIR_RWDIR_CNT];

	int *ignore_error[ERROR_TYPE_CNT];
	unsigned int ignore_error_nr[ERROR_TYPE_CNT];
	unsigned int error_dump;

	unsigned int nr_files;
	unsigned int open_files;
	enum file_lock_mode file_lock_mode;

	unsigned int odirect;
	unsigned int oatomic;
	unsigned int invalidate_cache;
	unsigned int create_serialize;
	unsigned int create_fsync;
	unsigned int create_on_open;
	unsigned int create_only;
	unsigned int end_fsync;
	unsigned int pre_read;
	unsigned int sync_io;
	unsigned int verify;
	unsigned int do_verify;
	unsigned int verifysort;
	unsigned int verifysort_nr;
	unsigned int verify_interval;
	unsigned int verify_offset;
	char verify_pattern[MAX_PATTERN_SIZE];
	unsigned int verify_pattern_bytes;
	unsigned int verify_fatal;
	unsigned int verify_dump;
	unsigned int verify_async;
	unsigned long long verify_backlog;
	unsigned int verify_batch;
	unsigned int experimental_verify;
	unsigned int use_thread;
	unsigned int unlink;
	unsigned int do_disk_util;
	unsigned int override_sync;
	unsigned int rand_repeatable;
	unsigned int allrand_repeatable;
	unsigned long long rand_seed;
	unsigned int use_os_rand;
	unsigned int log_avg_msec;
	unsigned int norandommap;
	unsigned int softrandommap;
	unsigned int bs_unaligned;
	unsigned int fsync_on_close;
	unsigned int bs_is_seq_rand;

	unsigned int verify_only;

	unsigned int random_distribution;

	fio_fp64_t zipf_theta;
	fio_fp64_t pareto_h;

	unsigned int random_generator;

	unsigned int perc_rand[DDIR_RWDIR_CNT];

	unsigned int hugepage_size;
	unsigned int rw_min_bs;
	unsigned int thinktime;
	unsigned int thinktime_spin;
	unsigned int thinktime_blocks;
	unsigned int fsync_blocks;
	unsigned int fdatasync_blocks;
	unsigned int barrier_blocks;
	unsigned long long start_delay;
	unsigned long long start_delay_high;
	unsigned long long timeout;
	unsigned long long ramp_time;
	unsigned int overwrite;
	unsigned int bw_avg_time;
	unsigned int iops_avg_time;
	unsigned int loops;
	unsigned long long zone_range;
	unsigned long long zone_size;
	unsigned long long zone_skip;
	unsigned long long lockmem;
	enum fio_memtype mem_type;
	unsigned int mem_align;

	unsigned int max_latency;

	unsigned int stonewall;
	unsigned int new_group;
	unsigned int numjobs;
	os_cpu_mask_t cpumask;
	unsigned int cpumask_set;
	os_cpu_mask_t verify_cpumask;
	unsigned int verify_cpumask_set;
	unsigned int cpus_allowed_policy;
	char *numa_cpunodes;
	unsigned int numa_cpumask_set;
	unsigned short numa_mem_mode;
	unsigned int numa_mem_prefer_node;
	char *numa_memnodes;
	unsigned int numa_memmask_set;
	unsigned int iolog;
	unsigned int rwmixcycle;
	unsigned int rwmix[DDIR_RWDIR_CNT];
	unsigned int nice;
	unsigned int ioprio;
	unsigned int ioprio_class;
	unsigned int file_service_type;
	unsigned int group_reporting;
	unsigned int fadvise_hint;
	enum fio_fallocate_mode fallocate_mode;
	unsigned int zero_buffers;
	unsigned int refill_buffers;
	unsigned int scramble_buffers;
	char buffer_pattern[MAX_PATTERN_SIZE];
	unsigned int buffer_pattern_bytes;
	unsigned int compress_percentage;
	unsigned int compress_chunk;
	unsigned int time_based;
	unsigned int disable_lat;
	unsigned int disable_clat;
	unsigned int disable_slat;
	unsigned int disable_bw;
	unsigned int unified_rw_rep;
	unsigned int gtod_reduce;
	unsigned int gtod_cpu;
	unsigned int gtod_offload;
	enum fio_cs clocksource;
	unsigned int no_stall;
	unsigned int trim_percentage;
	unsigned int trim_batch;
	unsigned int trim_zero;
	unsigned long long trim_backlog;
	unsigned int clat_percentiles;
	unsigned int percentile_precision;	/* digits after decimal for percentiles */
	fio_fp64_t percentile_list[FIO_IO_U_LIST_MAX_LEN];

	char *read_iolog_file;
	char *write_iolog_file;
	char *bw_log_file;
	char *lat_log_file;
	char *iops_log_file;
	char *replay_redirect;

	/*
	 * Pre-run and post-run shell
	 */
	char *exec_prerun;
	char *exec_postrun;

	unsigned int rate[DDIR_RWDIR_CNT];
	unsigned int ratemin[DDIR_RWDIR_CNT];
	unsigned int ratecycle;
	unsigned int rate_iops[DDIR_RWDIR_CNT];
	unsigned int rate_iops_min[DDIR_RWDIR_CNT];

	char *ioscheduler;

	/*
	 * I/O Error handling
	 */
	enum error_type continue_on_error;

	/*
	 * Benchmark profile type
	 */
	char *profile;

	/*
	 * blkio cgroup support
	 */
	char *cgroup;
	unsigned int cgroup_weight;
	unsigned int cgroup_nodelete;

	unsigned int uid;
	unsigned int gid;

	int flow_id;
	int flow;
	int flow_watermark;
	unsigned int flow_sleep;

	unsigned long long offset_increment;
	unsigned long long number_ios;

	unsigned int sync_file_range;

	unsigned long long latency_target;
	unsigned long long latency_window;
	fio_fp64_t latency_percentile;
};

#define FIO_TOP_STR_MAX		256

struct thread_options_pack {
	uint8_t description[FIO_TOP_STR_MAX];
	uint8_t name[FIO_TOP_STR_MAX];
	uint8_t directory[FIO_TOP_STR_MAX];
	uint8_t filename[FIO_TOP_STR_MAX];
	uint8_t filename_format[FIO_TOP_STR_MAX];
	uint8_t opendir[FIO_TOP_STR_MAX];
	uint8_t ioengine[FIO_TOP_STR_MAX];
	uint8_t mmapfile[FIO_TOP_STR_MAX];
	uint32_t td_ddir;
	uint32_t rw_seq;
	uint32_t kb_base;
	uint32_t unit_base;
	uint32_t ddir_seq_nr;
	uint64_t ddir_seq_add;
	uint32_t iodepth;
	uint32_t iodepth_low;
	uint32_t iodepth_batch;
	uint32_t iodepth_batch_complete;

	uint64_t size;
	uint64_t io_limit;
	uint32_t size_percent;
	uint32_t fill_device;
	uint32_t file_append;
	uint64_t file_size_low;
	uint64_t file_size_high;
	uint64_t start_offset;

	uint32_t bs[DDIR_RWDIR_CNT];
	uint32_t ba[DDIR_RWDIR_CNT];
	uint32_t min_bs[DDIR_RWDIR_CNT];
	uint32_t max_bs[DDIR_RWDIR_CNT];
	struct bssplit bssplit[DDIR_RWDIR_CNT][BSSPLIT_MAX];
	uint32_t bssplit_nr[DDIR_RWDIR_CNT];

	uint32_t ignore_error[ERROR_TYPE_CNT][ERROR_STR_MAX];
	uint32_t ignore_error_nr[ERROR_TYPE_CNT];
	uint32_t error_dump;

	uint32_t nr_files;
	uint32_t open_files;
	uint32_t file_lock_mode;

	uint32_t odirect;
	uint32_t oatomic;
	uint32_t invalidate_cache;
	uint32_t create_serialize;
	uint32_t create_fsync;
	uint32_t create_on_open;
	uint32_t create_only;
	uint32_t end_fsync;
	uint32_t pre_read;
	uint32_t sync_io;
	uint32_t verify;
	uint32_t do_verify;
	uint32_t verifysort;
	uint32_t verifysort_nr;
	uint32_t verify_interval;
	uint32_t verify_offset;
	uint8_t verify_pattern[MAX_PATTERN_SIZE];
	uint32_t verify_pattern_bytes;
	uint32_t verify_fatal;
	uint32_t verify_dump;
	uint32_t verify_async;
	uint64_t verify_backlog;
	uint32_t verify_batch;
	uint32_t experimental_verify;
	uint32_t use_thread;
	uint32_t unlink;
	uint32_t do_disk_util;
	uint32_t override_sync;
	uint32_t rand_repeatable;
	uint32_t allrand_repeatable;
	uint64_t rand_seed;
	uint32_t use_os_rand;
	uint32_t log_avg_msec;
	uint32_t norandommap;
	uint32_t softrandommap;
	uint32_t bs_unaligned;
	uint32_t fsync_on_close;
	uint32_t bs_is_seq_rand;

	uint32_t random_distribution;
	fio_fp64_t zipf_theta;
	fio_fp64_t pareto_h;

	uint32_t random_generator;

	uint32_t perc_rand[DDIR_RWDIR_CNT];

	uint32_t hugepage_size;
	uint32_t rw_min_bs;
	uint32_t thinktime;
	uint32_t thinktime_spin;
	uint32_t thinktime_blocks;
	uint32_t fsync_blocks;
	uint32_t fdatasync_blocks;
	uint32_t barrier_blocks;
	uint64_t start_delay;
	uint64_t start_delay_high;
	uint64_t timeout;
	uint64_t ramp_time;
	uint32_t overwrite;
	uint32_t bw_avg_time;
	uint32_t iops_avg_time;
	uint32_t loops;
	uint64_t zone_range;
	uint64_t zone_size;
	uint64_t zone_skip;
	uint64_t lockmem;
	uint32_t mem_type;
	uint32_t mem_align;

	uint32_t max_latency;

	uint32_t stonewall;
	uint32_t new_group;
	uint32_t numjobs;
	uint8_t cpumask[FIO_TOP_STR_MAX];
	uint32_t cpumask_set;
	uint8_t verify_cpumask[FIO_TOP_STR_MAX];
	uint32_t verify_cpumask_set;
	uint32_t cpus_allowed_policy;
	uint32_t iolog;
	uint32_t rwmixcycle;
	uint32_t rwmix[DDIR_RWDIR_CNT];
	uint32_t nice;
	uint32_t ioprio;
	uint32_t ioprio_class;
	uint32_t file_service_type;
	uint32_t group_reporting;
	uint32_t fadvise_hint;
	uint32_t fallocate_mode;
	uint32_t zero_buffers;
	uint32_t refill_buffers;
	uint32_t scramble_buffers;
	uint8_t buffer_pattern[MAX_PATTERN_SIZE];
	uint32_t buffer_pattern_bytes;
	unsigned int compress_percentage;
	unsigned int compress_chunk;
	uint32_t time_based;
	uint32_t disable_lat;
	uint32_t disable_clat;
	uint32_t disable_slat;
	uint32_t disable_bw;
	uint32_t unified_rw_rep;
	uint32_t gtod_reduce;
	uint32_t gtod_cpu;
	uint32_t gtod_offload;
	uint32_t clocksource;
	uint32_t no_stall;
	uint32_t trim_percentage;
	uint32_t trim_batch;
	uint32_t trim_zero;
	uint64_t trim_backlog;
	uint32_t clat_percentiles;
	uint32_t percentile_precision;
	fio_fp64_t percentile_list[FIO_IO_U_LIST_MAX_LEN];

	uint8_t read_iolog_file[FIO_TOP_STR_MAX];
	uint8_t write_iolog_file[FIO_TOP_STR_MAX];
	uint8_t bw_log_file[FIO_TOP_STR_MAX];
	uint8_t lat_log_file[FIO_TOP_STR_MAX];
	uint8_t iops_log_file[FIO_TOP_STR_MAX];
	uint8_t replay_redirect[FIO_TOP_STR_MAX];

	/*
	 * Pre-run and post-run shell
	 */
	uint8_t exec_prerun[FIO_TOP_STR_MAX];
	uint8_t exec_postrun[FIO_TOP_STR_MAX];

	uint32_t rate[DDIR_RWDIR_CNT];
	uint32_t ratemin[DDIR_RWDIR_CNT];
	uint32_t ratecycle;
	uint32_t rate_iops[DDIR_RWDIR_CNT];
	uint32_t rate_iops_min[DDIR_RWDIR_CNT];

	uint8_t ioscheduler[FIO_TOP_STR_MAX];

	/*
	 * I/O Error handling
	 */
	uint32_t continue_on_error;

	/*
	 * Benchmark profile type
	 */
	uint8_t profile[FIO_TOP_STR_MAX];

	/*
	 * blkio cgroup support
	 */
	uint8_t cgroup[FIO_TOP_STR_MAX];
	uint32_t cgroup_weight;
	uint32_t cgroup_nodelete;

	uint32_t uid;
	uint32_t gid;

	int32_t flow_id;
	int32_t flow;
	int32_t flow_watermark;
	uint32_t flow_sleep;

	uint64_t offset_increment;
	uint64_t number_ios;

	uint32_t sync_file_range;

	uint64_t latency_target;
	uint64_t latency_window;
	fio_fp64_t latency_percentile;
} __attribute__((packed));

extern void convert_thread_options_to_cpu(struct thread_options *o, struct thread_options_pack *top);
extern void convert_thread_options_to_net(struct thread_options_pack *top, struct thread_options *);
extern int fio_test_cconv(struct thread_options *);
extern void options_default_fill(struct thread_options *o);

#endif


text:
.titlebar
{
	background:#404040;
	height:17px;
	padding:5px 0px 6px 9px;
	font:bold 14px verdana;
	color:#FFFFFF;
	-moz-border-radius: 8px 8px 0px 0px;
	-webkit-border-radius: 8px 8px 0px 0px;
	overflow:auto;
	margin-top:14px;
}

.contentsection
{
	background:#f0f0f0;
	padding:10px;
	border:1px solid #808080;
	font:12px verdana;
	color:#000000;
	-moz-border-radius: 0px 0px 8px 8px;
	-webkit-border-radius: 0px 0px 8px 8px;
	overflow:auto;
	margin-bottom:14px;
}

.standalonecontentsection
{
	background:#f0f0f0;
	padding:10px;
	border:1px solid #808080;
	font:12px verdana;
	color:#000000;
	-moz-border-radius: 8px 8px 8px 8px;
	-webkit-border-radius: 8px 8px 8px 8px;
	overflow:auto;
	margin-top:14px;
	margin-bottom:14px;
}

.contentsection ul
{
	margin:5px 10px;
	padding:0px;
}

.contentsection ul li
{
	margin:5px 10px;
	padding:0px;
}

.feature_list
{
	list-style:none;
	margin:0px;
	padding:0px;
	margin-right:235px;
}

.feature_list li
{
	margin:0px;
	padding:4px 4px;
	float:left;
	max-width:662px;
}

.feature_horiz
{
	width:100%;
	height:110px;
	background:#f0f0f0;
	border:1px solid #808080;
	-moz-border-radius: 8px 8px 8px 8px;
	-webkit-border-radius: 8px 8px 8px 8px;
}

.feature_horiz a img
{
	float:left;
	margin:6px 22px;
	width:98px;
	height:98px;
	border:0px solid #000000;
}

.feature_horiz img
{
	float:left;
	margin:6px 22px;
	width:98px;
	height:98px;
	border:0px solid #000000;
}

.feature_title
{
	margin:8px 0px 8px 0px;
	font:bold 16px Helvetica, Arial, sans-serif;
	color:#a80403;
}

.feature_title a
{
	font:bold 16px Helvetica, Arial, sans-serif;
	color:#a80403;
	text-decoration:none;
	border-bottom:0px solid #000000;
}

.feature_content
{
	margin:10px 0px 10px 0px;
	color:#000000;
	font:13px Helvetica, Arial, sans-serif;
	line-height:1.5em;
}

.header_img
{
	margin-right:235px;
	max-width:670px;
}

.header_img img
{
	width:100%;
}

div.codetitlebar
{
	background:#404040;
	height:17px;
	margin:0px 10px;
	padding:5px 0px 6px 9px;
	font:bold 14px verdana;
	color:#FFFFFF;
	overflow:auto;
	-moz-border-radius: 8px 8px 0px 0px;
	-webkit-border-radius: 8px 8px 0px 0px;
}

div.codesnippet
{
	margin:0px 10px;
	padding:0px 10px;
	background:#f0f0f0;
	font:12px Courier;
	max-height:500px;
	overflow:auto;
	border:2px inset #989898;
	color:#000000;
	-moz-border-radius: 0px 0px 8px 8px;
	-webkit-border-radius: 0px 0px 8px 8px;
}

.section_wrapper
{
	width:672px;
	height:200px;
	position:relative;
}

.link_list_wrapper
{
	position:absolute;
	top:172px;
	width:672px;
	height:28px;
}

.link_list
{
	list-style:none;
	padding:0px;
	margin:0px;
}

.link_item
{
	color:#f0f0f0;
	font-weight:bold;
	float:left;
	height:16px;
	padding:2px 21px 10px;
}

.link_item_bus
{
	color:#f0f0f0;
	font-weight:bold;
	float:left;
	height:16px;
	padding:2px 10px 10px;
}

.link_item a
{
	color:#f0f0f0;
	font-weight:bold;
	text-decoration:none;
	border-bottom:0px;
}

.link_item_bus a
{
	color:#f0f0f0;
	font-weight:bold;
	text-decoration:none;
	border-bottom:0px;
}

.link_divider
{
	float:left;
	height:28px;
	width:1px;
	padding:0px 0px;
	background:#888888;
}

.link_list
{
	list-style:none;
	padding:0px;
	margin:0px auto;
}

.arrow
{
	cursor:pointer;
}

.newsitem
{
	position:absolute;
	top:0px;
	left:0px;
	display:none;
}

.news_image
{
	float:left;
	width:287px;
	height:170px;
}

.news_image a
{
	text-decoration:none;
	border-bottom:0px;
}

.news_content
{
	float:left;
	width:382px;
	height:170px;
}

.news_date
{
	color:#808080;
	font-size:10px;
	font-style:italic;
	margin:2px 10px;
}

.news_list
{
	list-style:none;
	padding:0px;
	margin:2px auto 4px auto;
	height:20px;
}

.news_list li
{
	float:left;
	height:13px;
	width:13px;
	padding:3px 4px;
	cursor:pointer;
}
div.codetitlebar {
    -moz-font-feature-settings: normal;
    -moz-font-language-override: normal;
    -x-system-font: none;
    background-attachment: scroll;
    background-clip: border-box;
    background-color: #404040;
    background-image: none;
    background-origin: padding-box;
    background-position: 0 0;
    background-repeat: repeat;
    background-size: auto auto;
    border-bottom-left-radius: 0;
    border-bottom-right-radius: 0;
    border-top-left-radius: 8px;
    border-top-right-radius: 8px;
    color: #FFFFFF;
    font-family: verdana;
    font-size: 14px;
    font-size-adjust: none;
    font-stretch: normal;
    font-style: normal;
    font-variant: normal;
    font-weight: bold;
    height: 16px;
    line-height: normal;
    margin-bottom: 0;
    margin-left: 10px;
    margin-right: 10px;
    margin-top: 0;
    overflow-x: auto;
    overflow-y: auto;
    padding-bottom: 9px;
    padding-left: 9px;
    padding-right: 0;
    padding-top: 5px;
}
div.codesnippet {
    -moz-border-bottom-colors: none;
    -moz-border-image: none;
    -moz-border-left-colors: none;
    -moz-border-right-colors: none;
    -moz-border-top-colors: none;
    -moz-font-feature-settings: normal;
    -moz-font-language-override: normal;
    -x-system-font: none;
    background-attachment: scroll;
    background-clip: border-box;
    background-color: #F0F0F0;
    background-image: none;
    background-origin: padding-box;
    background-position: 0 0;
    background-repeat: repeat;
    background-size: auto auto;
    border-bottom-color: #989898;
    border-bottom-left-radius: 8px;
    border-bottom-right-radius: 8px;
    border-bottom-style: inset;
    border-bottom-width: 2px;
    border-left-color-ltr-source: physical;
    border-left-color-rtl-source: physical;
    border-left-color-value: #989898;
    border-left-style-ltr-source: physical;
    border-left-style-rtl-source: physical;
    border-left-style-value: inset;
    border-left-width-ltr-source: physical;
    border-left-width-rtl-source: physical;
    border-left-width-value: 2px;
    border-right-color-ltr-source: physical;
    border-right-color-rtl-source: physical;
    border-right-color-value: #989898;
    border-right-style-ltr-source: physical;
    border-right-style-rtl-source: physical;
    border-right-style-value: inset;
    border-right-width-ltr-source: physical;
    border-right-width-rtl-source: physical;
    border-right-width-value: 2px;
    border-top-color: #989898;
    border-top-left-radius: 0;
    border-top-right-radius: 0;
    border-top-style: inset;
    border-top-width: 2px;
    color: #000000;
    font-family: Courier;
    font-size: 12px;
    font-size-adjust: none;
    font-stretch: normal;
    font-style: normal;
    font-variant: normal;
    font-weight: normal;
    line-height: normal;
    margin-bottom: 0;
    margin-left: 10px;
    margin-right: 10px;
    margin-top: 0;
    max-height: 500px;
    overflow-x: auto;
    overflow-y: auto;
    padding-bottom: 0;
    padding-left: 10px;
    padding-right: 10px;
    padding-top: 0;
}


text:
import React from 'react'
import { Link } from 'react-router'
import EditableText from '../form/editableText.js'
import TextField from '../form/textField.js'
import TextFieldMultiLine from '../form/textFieldMultiLine.js'

const mergedStyle = (currentStyles, newStyles) => ({style: Object.assign({}, currentStyles, newStyles) })//shortcut
const EditChannel = React.createClass({
	propTypes:{
		channel: React.PropTypes.string.isRequired,
		channelDetails: React.PropTypes.object.isRequired,
		saveChannelDetails: React.PropTypes.func.isRequired,
	},
	getInitialState() {
		return {
			title: this.props.channelDetails.title,
			description: this.props.channelDetails.description
		}
	},
	componentWillReceiveProps(props) {
		console.log("editChannel.js: componentWillReceiveProps ", props);

		this.setState({title:props.channelDetails.title || this.props.channel || ''})
		this.setState({description:props.channelDetails.description || ''})
	},
	saveTitle() {
		this.props.saveChannelDetails(this.props.channel, {
			title:this.state.title
		})
	},
	saveDescription() {
		this.props.saveChannelDetails(this.props.channel, {
			description:this.state.description
		})
	},
	setStateProp(stateProp) {
		const comp = this
		return (val) => {
			let newState = {}
			newState[stateProp] = val
			comp.setState(newState)
		}
	},
	render() {
		return (

					<fieldset>
						<EditableText
							size="15"
							name="editChannelName"
							presetValue={ this.state.title }
							binder={this.setStateProp('title')}
							onEnter={this.saveTitle}
						/>
					</fieldset>
					<fieldset>
						<EditableText
							size="15"
							isTextArea={true}
							name="editChannelDescr"
							placeholder="Click to edit Description"
							presetValue={this.state.description || ''}
							binder={this.setStateProp('description')}
							onEnter={this.saveDescription}
						/>
					</fieldset>

		)
	}
})

export default EditChannel


text:
require 'activesms/sms'
require 'activesms/sms2email'
require 'net/https'

module ActiveSms #:nodoc:

  # Active SMS allows you to send SMS messages from your application using
  # an SMS model.
  #
  # = SMS models
  #
  # To use Action SMS, you need to create an SMS model.
  #
  #   $ script/generate sms Notifier signup
  #
  # The generated model inherits from ActiveSms::Base.  SMS messages are
  # defined by creating methods on the model which are then used to set
  # variables to be used in the message or to change options on the message.
  #
  # Examples:
  #
  #   class Notifier < ActiveSms::Base
  #     def signup
  #       delivery   = :gateway
  #       recipients = "447987654321"
  #       from       = "447123456789"
  #       body       = "Your account has been created"
  #     end
  #   end
  #
  # Sender methods have the following configuration methods available.
  #
  # * <tt>delivery</tt> - Method to use to delivery the SMS.
  #   Accept two paramenters: :gateway or :email
  #
  # * <tt>recipients</tt> - Takes one or more destination numbers.  These
  #   numbers should be formatted in standard international number format.
  #
  # * <tt>from</tt> - Who the SMS message you are sending is from.  This
  #   may be either a number formatted in standard internation number format,
  #   or, if the gateway supports it, an alphanumeric origination.
  #
  # * <tt>body</tt> - The content of the message.  This must fit within the
  #   length limitation of SMS messages.
  #
  # = Sending SMS messages
  #
  # Once an SMS action is defined, you can deliver you message or create it
  # and save it for delivery later.
  #
  #   Notifier.deliver_signup_noification(david) # sends the SMS message
  #
  #   sms = Notifier.create_signup_notification(david) # an SMS object
  #   Notifier.deliver(sms)
  #
  # You never instantiate your model class.  Rather, your delivery instance
  # methods are automatically wrapped in class methods that start with the
  # word <tt>deliver</tt> followed by the name of the SMS method that you
  # would like to deliver.  The <tt>signup_notification</tt> method defined
  # above is delivered by invoking <tt>Notifier.deliver_signup_notification</tt>.
  #
  # = Configuration options
  #
  # These options are specified on the class level.
  #
  # * <tt>logger</tt> - The logger is used for generating information about
  #   the sending run if available.  This can be set to nil for no logging.
  #   It is compatible with Ruby's own Logger and Log4r loggers.
  #
  # * <tt>gateway_settings</tt> - Allows detailed configuration of the SMS
  #   gateway used to deliver the messages.  Some gateways may require
  #   additional configuration settings.
  #
  # * <tt>raise_delivery_errors</tt> - Determines whether or not errors should
  #   be raised if the SMS fails to be delivered.
  #
  # * <tt>delivery_method</tt> - Defines a delivery method.  Possible values
  #   are :gateway (default) or :test.
  #
  # * <tt>perform_deliveries</tt> - Determines whether or not deliver_*
  #   methods are actually carried out.  By default they are, but this can be
  #   turned off to help functional testing.
  #
  # * <tt>deliveries</tt> - Keeps an array of all the messages sent out through
  #   Active SMS with deliver_method :test.  Most useful for unit and functional
  #   testing.
  class Base
    include ActionMailer::AdvAttrAccessor
    include ActionController::UrlWriter
    include Email

    @@logger = nil
    cattr_accessor :logger

    private_class_method :new #:nodoc:

    @@raise_delivery_errors = true
    cattr_accessor :raise_delivery_errors

    @@delivery_method = :gateway
    cattr_accessor :delivery_method

    @@perform_deliveries = true
    cattr_accessor :perform_deliveries

    @@deliveries = []
    cattr_accessor :deliveries

    # Method to deliver :gateway or :email
    adv_attr_accessor :delivery

    # If email we should have a carrier
    adv_attr_accessor :carrier

    # The recipient numbers for the message, either as a string (for a single
    # recipient) or an array (for multiple recipientipients).
    adv_attr_accessor :recipients

    # Specify the from number or identifier for the message.
    adv_attr_accessor :from

    # Specify the subject of the message.
    adv_attr_accessor :subject

    # The content of the message.
    adv_attr_accessor :body

    # The ID of the message.
    adv_attr_accessor :id

    # Schedule for delivery
    adv_attr_accessor :schedule

    # The Sms message object instance referenced by this model.
    attr_reader :sms

    class << self
      def method_missing(method_symbol, *parameters) #:nodoc:
        case method_symbol.id2name
          when /^create_([_a-z]\w+)/ then new($1, *parameters).sms
          when /^deliver_([_a-z]\w+)/ then new($1, *parameters).deliver!
          when "new" then nil
          else super
        end
      end

      # Receives an SMS message, parses it into an SMS object, instantiates
      # a new model, and passes the message object to the model object's
      # #receive method.  If you want your model to be able to process
      # incoming messages, you'll need to implement a #receive method
      # that accepts the SMS object as a parameter.
      #
      #   class Notifier < ActionSms::Base
      #     def receive(sms)
      #       ...
      #     end
      #   end
      def receive(sms)
        sms = connection.parse(sms)
        new.receive(sms)
      end

      # Deliver the given Sms message object directly.  This can be used to
      # deliver a preconstructed message, like:
      #
      #   sms = Notifier.create_signup_notification(parameters)
      #   Notifier.deliver(sms)
      def deliver(sms)
        new.deliver!(sms)
      end

    end

    # Instantiate a new Active SMS model object.  If +method_name+ is not
    # +nil+, the model will be initialized according to the named method.
    # If not, the model will remain uninitialized (useful when you need to
    # invoke the "receive" method, for instance).
    def initialize(method_name = nil, *parameters) #:nodoc:
      create!(method_name, *parameters) if method_name
    end

    # Initialize the model via the given +method_name+.  The body will be
    # rendered and a new Sms object created.
    def create!(method_name, *parameters) #:nodoc:
      initialize_defaults(method_name)
      send(method_name, *parameters)

      # Build the SMS object itself.
      @sms = create_sms
    end

    # Delivers an Sms message object.  By default, it deliver the cached object
    # (from the #create! method).  If no cached object exists, and no
    # alternate has been give as the prameter, this will fail.
    #
    # Mod to enable the user to choose between sending via gateway or email.
    #
    def deliver!(sms = @sms) #:nodoc:
      raise "no SMS object available for delivery!" unless sms
      logger.info "Sending SMS: #{sms} via #{sms.delivery}" unless logger.nil?

      begin
        send("perform_delivery_#{sms.delivery}", sms) if perform_deliveries
      rescue Exception => e
        raise e if raise_delivery_errors
      end

      logger.info "SMS Sent!" unless logger.nil?
      return sms
    end

    private

      # Set up the default values for the various instance variables of this
      # model.  Subclasses may override this method to provide different
      # defaults.
      def initialize_defaults(method_name)
      end

      def create_sms
        raise SmsException unless body && recipients
        sms = Sms.new
        sms.delivery = delivery
        sms.recipients = recipients
        sms.from = from
        sms.body = body
        sms.id = id if id
        sms.carrier = carrier if carrier
        sms.schedule = schedule if schedule
        @sms = sms
      end

      def perform_delivery_gateway(sms)
        raise ConnectionNotEstablished unless connection
        connection.deliver(sms)
      end

      def perform_delivery_email(sms)
        #raise ConnectionNotEstablished unless email
        email_deliver(sms)
      end

      def perform_delivery_test(sms)
        deliveries << sms
      end

  end
end


text:
module Toyrobot
  module CommandHandlers
    class PlaceHandler < BaseHandler
      def call(command)
        vector = Engine::Vector2D.new(command.x, command.y)
        return unless game.table.includes?(vector)
        return unless valid_direction?(command.direction)

        game.robot = Robot.new(vector, Engine::Direction.new(command.direction), game.table)
      end

      private

      def valid_direction?(direction)
        Engine::Direction::DIRECTIONS.include?(direction)
      end
    end
  end
end


text:
/*
Demo: AJAX Search Suggest (WeAreHunted.com Style)
Version 1.0
Author: Ian Lunn
Author URL: http://www.ianlunn.co.uk/
Demo URL: http://www.ianlunn.co.uk/demos/ajax-search-suggest-wearehunted/
Tutorial URL: http://www.ianlunn.co.uk/blog/code-tutorials/ajax-search-suggest-wearehunted/
GitHub: https://github.com/IanLunn/AJAX-Search-Suggest--WeAreHunted.com-Style-/

Dual licensed under the MIT and GPL licenses:
http://www.opensource.org/licenses/mit-license.php
http://www.gnu.org/licenses/gpl.html
*/

$(document).ready(function(){ //when the browser has rendered the page...

	//save selectors we'll be using more than once into variables for better performance
	var $hiddenSearch = $("#hidden-search"),
		$displaySearch = $("#display-search"),
		$searchOverlay = $("#search-overlay"),
		$artistsList = $("#artists");

	$("#search").click(function(){ //when the search link is clicked...
		$searchOverlay.show(); //show the search overlay
		$hiddenSearch.focus(); //give the hidden input box focus
	});

	$searchOverlay.click(function(event){ //when the search overlay is clicked...
		$hiddenSearch.focus(); //give the hidden input box focus
		if(event.target.id == "search-overlay" || event.target.id == "close"){ //...only if the user is clicking the empty areas of the overlay (and not child elements)...
			$hiddenSearch.blur(); //remove focus from the hidden input
			$(this).animate({"opacity": 0}, 500, function(){ //...animate it's opacity to 0...
				$(this).hide().css("opacity", 1); //...hide it (so the user can click the elements behind it again) and reset its opacity
			});
		}
	});

	//when the user pushes a key whilst the input box has focus...
	$hiddenSearch.keydown(function(e){
		currentQuery = $displaySearch.val(); //get the current value of the search input
		if(e.keyCode == 8){ //if the user hits backspace...

			latestQuery = currentQuery.substring(0, currentQuery.length - 1); //...remove the last character
			$displaySearch.val(latestQuery); //...update the search input box
			updateResults(latestQuery); //...update the results

		}else if(e.keyCode == 32 || (e.keyCode >= 65 && e.keyCode <= 90) || (e.keyCode >= 48 && e.keyCode <= 57)){ //if the user hits spacebar (32), characters a - z (65 - 90) or numeric keys(0 - 9)...
			latestQuery = currentQuery + String.fromCharCode(e.keyCode); //...add the newly entered key onto the current query
			$displaySearch.val(latestQuery); //...update the search input value with the latest query
			updateResults(latestQuery); //...update the results
		}
	});

	function updateResults(latestQuery){
		if(latestQuery.length > 0){ //if there is a query to process...
			$.post("controllers/auto-suggest.php", {latestQuery: latestQuery}, function(data){ //..send that query to the php script "auto-suggest.php" via ajax

			    if(data.length > 0){ //if the php script returns a result...
			    	data = $.parseJSON(data); //turn the string from the PHP script into a JavaScript object
					$("#artists li").remove(":contains('No results')"); //remove the "No results" text if it's being displayed
					$("#results").show(); //show the results container

					previousTerms = new Array(); //set up an array that will hold the terms currently being displayed
					$("#artists li").each(function(){ //for each result currently being displayed...
						previousTerms.push($(this).text()); //add it to the previousTerms array
					});

					keepTerms = new Array();

					for(term in data){ //for each matched term in the returned data...
						url = data[term]; //get the url for the matched term;
						if($.inArray(term, previousTerms) === -1){ //if this term isn't in the previous list of terms (and isn't already being displayed)...
							$artistsList.prepend('
'+term+'
');
						}else{ //if it is in the previous list...
							keepTerms.push(term); //add the term we want to keep to an array
						}
					}

					if(data == "" || (keepTerms.length == 0 && (previousTerms.length != 0 || $displaySearch.val() == ""))){
						$artistsList.html("
No results
");
					}else{
						for(term in previousTerms){ //for each term in the displayed list...
							if($.inArray(previousTerms[term], keepTerms) === -1){
								$("#artists li").filter(function(){
									return $(this).text() == previousTerms[term]
								}).remove();
							}
						}
					}
			    }
			});
		}else{
			$artistsList.html("
No results
");
		}
	}
});


text:
require "rails_helper"

RSpec.describe SaveCollection, type: :model do
  subject { described_class.call(collection, params) }
  let(:collection) do
    instance_double(Collection,
                    id: 9,
                    "attributes=" => true,
                    save: true,
                    url: nil,
                    url_slug: nil,
                    collection_configuration: double,
                    "image=" => true)
  end
  let(:params) { { name_line_1: "name_line_1", url_slug: "Test Slug" } }
  let(:upload_image) { Rack::Test::UploadedFile.new(Rails.root.join("spec/fixtures/test.jpg"), "image/jpeg") }

  before(:each) do
    allow(CreateUniqueId).to receive(:call).and_return(true)
    allow(collection).to receive(:url_slug=).with("test-slug")
  end

  it "returns when the collection save is successful" do
    expect(collection).to receive(:save).and_return(true)
    expect(subject).to be true
  end

  it "returns when the collection save is not successful" do
    expect(collection).to receive(:save).and_return(false)
    expect(subject).to be false
  end

  it "sets the attributes of the collection to be the passed in attributes " do
    expect(collection).to receive(:attributes=).with(params)
    subject
  end

  it "sets the url_slug to appropriate value if param is supplied" do
    expect(collection).to receive(:url_slug=).with("test-slug")
    subject
  end

  describe "unique_id" do
    it "uses the class to generate the id" do
      expect(CreateUniqueId).to receive(:call).with(collection)
      subject
    end
  end

  describe "image processing" do
    it "returns the true if the image was updated" do
      params[:uploaded_image] = upload_image
      allow(collection).to receive(:save).and_return(true)
      expect(subject).to eq(true)
    end

    it "calls FindOrCreateImage if the image is changed" do
      params[:uploaded_image] = upload_image
      expect(FindOrCreateImage).to receive(:call).and_return(nil)
      allow(collection).to receive(:save).and_return(true)
      allow(QueueJob).to receive(:call).with(SaveHoneypotImage, object: collection).and_return(true)
      subject
    end

    it "FindOrCreateImage is not called if the image is not changed" do
      params[:uploaded_image] = nil
      expect(FindOrCreateImage).not_to receive(:call)
      subject
    end
  end

  describe "url" do
    it "adds http if not given" do
      params[:url] = "www.nowhere.nil"
      expect(collection).to receive(:attributes=).with(include(url: "http://www.nowhere.nil"))
      subject
    end

    it "doesn't add another http if http is given" do
      params[:url] = "http://www.nowhere.nil"
      expect(collection).to receive(:attributes=).with(include(url: "http://www.nowhere.nil"))
      subject
    end

    it "doesn't add another http if https is given" do
      params[:url] = "https://www.nowhere.nil"
      expect(collection).to receive(:attributes=).with(include(url: "https://www.nowhere.nil"))
      subject
    end

    it "doesn't try to correct problems if http is given" do
      params[:url] = "http//www.nowhere.nil"
      expect(collection).to receive(:attributes=).with(include(url: "http//www.nowhere.nil"))
      subject
    end

    it "doesn't try to correct problems if http is given" do
      params[:url] = "https//www.nowhere.nil"
      expect(collection).to receive(:attributes=).with(include(url: "https//www.nowhere.nil"))
      subject
    end

    # It can't fix everything...
    it "does add http if http is given but misspelled" do
      params[:url] = "htp://www.nowhere.nil"
      expect(collection).to receive(:attributes=).with(include(url: "http://htp://www.nowhere.nil"))
      subject
    end
  end

  describe "collection_configuration" do
    it "calls CreateCollectionConfiguration after a success save" do
      expect(CreateCollectionConfiguration).to receive(:call)
      subject
    end

    it "does not call CreateCollectionConfiguration after a failure" do
      allow(collection).to receive(:save).and_return(false)
      expect(CreateCollectionConfiguration).to_not receive(:call)
      subject
    end
  end
end


text:
namespace IRunes.Models
{
    public class User : BaseEntity<string>
    {
        public string Username { get; set; }

        public string Password { get; set; }

        public string Email { get; set; }
    }
}


text:
layout: organization
category: local

title: Herbert G. Birch Services
impact_area: Children
keywords:
location_services:
location_offices:
website: http://www.hgbirch.org/

description:
mission: |
  Founded in 1975, our agency has grown from one small school into a large network of programs serving a wide range of New Yorkers who face significant challenges. Through a wide range of educational services, residential and family support programs, we enable these adults and children to achieve their full potential — while also transforming their lives.

cash_grants:
grants:
service_opp:
services:

learn:
cont_relationship:

salutation:
first_name:
last_name:
title_contact_person:

city: New York
state: NY
address: |
  104 West 29th Street Third Floor
  New York NY 10001
lat: 40.746656
lng: -73.990792
phone: 212-616-1800
ext:
fax: 212-741-6739
email:
preferred_contact:
contact_person_intro:
---


text:
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const util = require("util");
const path = require("path");
const ci_info_1 = require("ci-info");
const chalk = require("chalk");
const minimist = require("minimist");
const guards_1 = require("./guards");
const backends_1 = require("./lib/backends");
const config_1 = require("./lib/config");
const daemon_1 = require("./lib/daemon");
const http_1 = require("./lib/http");
const events_1 = require("./lib/events");
const environment_1 = require("./lib/environment");
const hooks_1 = require("./lib/hooks");
const project_1 = require("./lib/project");
const logger_1 = require("./lib/utils/logger");
const fs_1 = require("./lib/utils/fs");
const task_1 = require("./lib/utils/task");
const npm_1 = require("./lib/utils/npm");
const telemetry_1 = require("./lib/telemetry");
const session_1 = require("./lib/session");
const shell_1 = require("./lib/shell");
const prompts_1 = require("./lib/prompts");
var backends_2 = require("./lib/backends");
exports.BACKEND_LEGACY = backends_2.BACKEND_LEGACY;
exports.BACKEND_PRO = backends_2.BACKEND_PRO;
exports.KNOWN_BACKENDS = backends_2.KNOWN_BACKENDS;
const name = '@ionic/cli-utils';
function registerHooks(hooks) {
    hooks.register(name, 'info', () => tslib_1.__awaiter(this, void 0, void 0, function* () {
        const packageJson = yield npm_1.readPackageJsonFileOfResolvedModule(__filename);
        const version = packageJson.version || '';
        return [
            { type: 'cli-packages', key: name, value: version, path: path.dirname(__filename) },
        ];
    }));
    hooks.register(name, 'backend:changed', ({ env }) => tslib_1.__awaiter(this, void 0, void 0, function* () {
        const wasLoggedIn = yield env.session.isLoggedIn();
        yield env.session.logout();
        env.session = yield getSession(env.config, env.project, env.client);
        if (wasLoggedIn) {
            env.log.info('You have been logged out.');
        }
    }));
}
exports.registerHooks = registerHooks;
function getSession(config, project, client) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        const configData = yield config.load();
        return configData.backend === backends_1.BACKEND_LEGACY ? new session_1.CloudSession(config, project, client) : new session_1.ProSession(config, project, client);
    });
}
function generateIonicEnvironment(plugin, pargv, env) {
    return tslib_1.__awaiter(this, void 0, void 0, function* () {
        const cwd = process.cwd();
        const argv = minimist(pargv, { boolean: true, string: '_' });
        const config = new config_1.Config(env['IONIC_CONFIG_DIRECTORY'] || config_1.DEFAULT_CONFIG_DIRECTORY, config_1.CONFIG_FILE);
        const configData = yield config.load();
        const flags = config_1.gatherFlags(argv);
        let stream;
        let tasks;
        let bottomBar;
        let log;
        let level = 'info';
        let levelInvalid = false;
        let prefix = '';
        if (ci_info_1.isCI || configData.interactive === false) {
            flags.interactive = false;
        }
        if (argv['log-level']) {
            if (guards_1.isLogLevel(argv['log-level'])) {
                level = argv['log-level'];
            }
            else {
                levelInvalid = true;
            }
        }
        if (argv['log-timestamps']) {
            prefix = () => `${chalk.dim('[' + new Date().toISOString() + ']')}`;
        }
        if (flags.interactive) {
            const inquirer = yield Promise.resolve().then(function () { return require('inquirer'); });
            bottomBar = new inquirer.ui.BottomBar();
            stream = bottomBar.log;
            log = new logger_1.Logger({ level, prefix, stream });
            tasks = new task_1.InteractiveTaskChain({ log, bottomBar });
        }
        else {
            stream = process.stdout;
            log = new logger_1.Logger({ level, prefix, stream });
            tasks = new task_1.TaskChain({ log });
        }
        const projectDir = yield fs_1.findBaseDirectory(cwd, project_1.PROJECT_FILE);
        env['IONIC_PROJECT_DIR'] = projectDir || '';
        env['IONIC_PROJECT_FILE'] = project_1.PROJECT_FILE;
        configData.version = plugin.meta.version;
        const project = new project_1.Project(env['IONIC_PROJECT_DIR'], project_1.PROJECT_FILE);
        const client = new http_1.Client(config);
        const session = yield getSession(config, project, client);
        const hooks = new hooks_1.HookEngine();
        const daemon = new daemon_1.Daemon(env['IONIC_DAEMON_DIRECTORY'] || config_1.DEFAULT_CONFIG_DIRECTORY, daemon_1.DAEMON_JSON_FILE);
        const telemetry = new telemetry_1.Telemetry();
        const shell = new shell_1.Shell({ tasks, log, project });
        registerHooks(hooks);
        const ienv = new environment_1.Environment({
            bottomBar,
            client,
            config,
            daemon,
            events: new events_1.CLIEventEmitter(),
            flags,
            hooks,
            log,
            meta: {
                cwd,
                local: env['IONIC_CLI_LOCAL'] ? true : false,
                binPath: env['IONIC_CLI_BIN'],
                libPath: env['IONIC_CLI_LIB'],
            },
            namespace: plugin.namespace,
            plugins: {
                ionic: plugin,
            },
            prompt: yield prompts_1.createPromptModule({ confirm: flags.confirm, interactive: flags.interactive, log, config }),
            project,
            session,
            shell,
            tasks,
            telemetry,
        });
        telemetry.env = ienv; // TODO: proper DI
        yield ienv.open();
        if (levelInvalid) {
            log.warn(`${chalk.green(argv['log-level'])} is an invalid log level--defaulting back to ${chalk.bold(level)}.\n` +
                `You can choose from the following log levels: ${guards_1.LOG_LEVELS.map(l => chalk.green(l)).join(', ')}.\n`);
        }
        log.debug(() => `CLI flags: ${util.inspect(flags, { breakLength: Infinity, colors: chalk.enabled })}`);
        if (typeof argv['yarn'] === 'boolean') {
            log.warn(`${chalk.green('--yarn')} / ${chalk.green('--no-yarn')} switch is deprecated. Use ${chalk.green('ionic config set -g yarn ' + String(argv['yarn']))}.`);
            configData.yarn = argv['yarn'];
        }
        if (!projectDir) {
            const foundDir = yield fs_1.findBaseDirectory(cwd, project_1.PROJECT_FILE_LEGACY);
            if (foundDir) {
                log.warn(`${chalk.bold(project_1.PROJECT_FILE_LEGACY)} file found in ${chalk.bold(foundDir)}--please rename it to ${chalk.bold(project_1.PROJECT_FILE)}, or your project directory will not be detected!`);
            }
        }
        return ienv;
    });
}
exports.generateIonicEnvironment = generateIonicEnvironment;


text:
layout   : blocks/outcome
title    : AppSec Review and Pentest Playbook
---

## Outcomes

* Created outline for a AppSec Pen Test Playbook
  * Initial [draft](http://sl.owasp.org/kzvgn) of outline sent to participants for consensus

### Synopsis and Takeaways

* Eleven participants collaborated on what defines an Application Security Pen Test
  * Driven by specific concerns
  * Driven by humans
  * Driven by depth
  * Driven by functionality


text:
<?php

namespace App\Models;

use Jenssegers\Mongodb\Eloquent\Model as Eloquent;

class TCLDevice extends Eloquent
{
    protected $collection = 'tclDevices';
    protected $fillable = ['deviceid','mac'];
}


text:
    <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target=".navbar-collapse">
      Toggle navigation

    </button>
    PM Rules!


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

<sql-cases>
    <sql-case id="cache_index_single_table" value="CACHE INDEX t_order IN hot_cache_index" db-types="MySQL" />
    <sql-case id="cache_index_multiple_table" value="CACHE INDEX t_order, t_user IN hot_cache_index" db-types="MySQL" />
    <sql-case id="cache_index_single_table_multiple_index" value="CACHE INDEX t_order INDEX (idx_a, idx_b) IN hot_cache_index" db-types="MySQL" />
    <sql-case id="cache_index_multiple_table_multiple_index" value="CACHE INDEX t_order INDEX (idx_order), t_user INDEX (idx_user) IN hot_cache_index" db-types="MySQL" />
    <sql-case id="cache_index_all_partition" value="CACHE INDEX t_order PARTITION (ALL) IN hot_cache_index" db-types="MySQL" />
    <sql-case id="cache_index_multiple_partition" value="CACHE INDEX t_order PARTITION (p0, p1) IN hot_cache_index" db-types="MySQL" />
</sql-cases>


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Platygrapha occulta f. decolerascens Nyl.

### Remarks
null


text:
RED.tray = (function() {

    var stack = [];
    var editorStack;
    var openingTray = false;
    var stackHidden = false;

    function resize() {

    }
    function showTray(options) {
        var el = $('

');
        // `editor-tray-header` is deprecated - use red-ui-tray-body instead
        var header = $('

').appendTo(el);
        var bodyWrapper = $('

').appendTo(el);
        // `editor-tray-body` is deprecated - use red-ui-tray-body instead
        var body = $('

').appendTo(bodyWrapper);
        // `editor-tray-footer` is deprecated - use red-ui-tray-footer instead
        var footer = $('

').appendTo(el);
        var resizer = $('

').appendTo(el);
        // var growButton = $('').appendTo(resizer);
        // var shrinkButton = $('').appendTo(resizer);
        if (options.title) {
            var titles = stack.map(function(e) { return e.options.title });
            titles.push(options.title);
            var title = '

'+titles.join("

")+'

';

            $('
'+title+'
').appendTo(header);
        }
        if (options.width === Infinity) {
            options.maximized = true;
            resizer.addClass('red-ui-tray-resize-maximised');
        }
        var buttonBar = $('

').appendTo(header);
        var primaryButton;
        if (options.buttons) {
            for (var i=0;i<options.buttons.length;i++) {
                var button = options.buttons[i];
                var b = $('<button>').button().appendTo(buttonBar);
                if (button.id) {
                    b.attr('id',button.id);
                }
                if (button.text) {
                    b.text(button.text);
                }
                if (button.click) {
                    b.on("click", (function(action) {
                        return function(evt) {
                            if (!$(this).hasClass('disabled')) {
                                action(evt);
                            }
                        };
                    })(button.click));
                }
                if (button.class) {
                    b.addClass(button.class);
                    if (button.class === "primary") {
                        primaryButton = button;
                    }
                }
            }
        }
        el.appendTo(editorStack);
        var tray = {
            tray: el,
            header: header,
            body: body,
            footer: footer,
            options: options,
            primaryButton: primaryButton
        };
        stack.push(tray);

        if (!options.maximized) {
            el.draggable({
                handle: resizer,
                axis: "x",
                start:function(event,ui) {
                    el.width('auto');
                },
                drag: function(event,ui) {
                    var absolutePosition = editorStack.position().left+ui.position.left
                    if (absolutePosition < 7) {
                        ui.position.left += 7-absolutePosition;
                    } else if (ui.position.left > -tray.preferredWidth-1) {
                        ui.position.left = -Math.min(editorStack.position().left-7,tray.preferredWidth-1);
                    }
                    if (tray.options.resize) {
                        setTimeout(function() {
                            tray.options.resize({width: -ui.position.left});
                        },0);
                    }
                    tray.width = -ui.position.left;
                },
                stop:function(event,ui) {
                    el.width(-ui.position.left);
                    el.css({left:''});
                    if (tray.options.resize) {
                        tray.options.resize({width: -ui.position.left});
                    }
                    tray.width = -ui.position.left;
                }
            });
        }

        function finishBuild() {
            $("#red-ui-header-shade").show();
            $("#red-ui-editor-shade").show();
            $("#red-ui-palette-shade").show();
            $(".red-ui-sidebar-shade").show();
            tray.preferredWidth = Math.max(el.width(),500);
            if (!options.maximized) {
                body.css({"minWidth":tray.preferredWidth-40});
            }
            if (options.width) {
                if (options.width > $("#red-ui-editor-stack").position().left-8) {
                    options.width = $("#red-ui-editor-stack").position().left-8;
                }
                el.width(options.width);
            } else {
                el.width(tray.preferredWidth);
            }

            tray.width = el.width();
            if (tray.width > $("#red-ui-editor-stack").position().left-8) {
                tray.width = Math.max(0/*tray.preferredWidth*/,$("#red-ui-editor-stack").position().left-8);
                el.width(tray.width);
            }

            // tray.body.parent().width(Math.min($("#red-ui-editor-stack").position().left-8,tray.width));

            $("#red-ui-main-container").scrollLeft(0);
            el.css({
                right: -(el.width()+10)+"px",
                transition: "right 0.25s ease"
            });
            handleWindowResize();
            openingTray = true;
            setTimeout(function() {
                setTimeout(function() {
                    if (!options.width) {
                        el.width(Math.min(tray.preferredWidth,$("#red-ui-editor-stack").position().left-8));
                    }
                    if (options.resize) {
                        options.resize({width:el.width()});
                    }
                    if (options.show) {
                        options.show();
                    }
                    setTimeout(function() {
                        // Delay resetting the flag, so we don't close prematurely
                        openingTray = false;
                    },200);
                    body.find(":focusable:first").trigger("focus");

                },150);
                el.css({right:0});
            },0);
        }
        if (options.open) {
            if (options.open.length === 1) {
                options.open(el);
                finishBuild();
            } else {
                options.open(el,finishBuild);
            }
        } else {
            finishBuild();
        }
    }

    function handleWindowResize() {
        if (stack.length > 0) {
            var tray = stack[stack.length-1];
            if (tray.options.maximized || tray.width > $("#red-ui-editor-stack").position().left-8) {
                tray.width = $("#red-ui-editor-stack").position().left-8;
                tray.tray.width(tray.width);
                // tray.body.parent().width(tray.width);
            } else if (tray.width < tray.preferredWidth) {
                tray.width = Math.min($("#red-ui-editor-stack").position().left-8,tray.preferredWidth);
                tray.tray.width(tray.width);
                // tray.body.parent().width(tray.width);
            }
            var trayHeight = tray.tray.height()-tray.header.outerHeight()-tray.footer.outerHeight();
            tray.body.height(trayHeight);
            if (tray.options.resize) {
                tray.options.resize({width:tray.width, height:trayHeight});
            }

        }
    }

    return {
        init: function init() {
            editorStack = $("#red-ui-editor-stack");
            $(window).on("resize", handleWindowResize);
            RED.events.on("sidebar:resize",handleWindowResize);
            $("#red-ui-editor-shade").on("click", function() {
                if (!openingTray) {
                    var tray = stack[stack.length-1];
                    if (tray && tray.primaryButton) {
                        tray.primaryButton.click();
                    }
                }
            });
        },
        show: function show(options) {
            if (!options) {
                if (stack.length > 0) {
                    var tray = stack[stack.length-1];
                    tray.tray.css({right:0});
                    $("#red-ui-header-shade").show();
                    $("#red-ui-editor-shade").show();
                    $("#red-ui-palette-shade").show();
                    $(".red-ui-sidebar-shade").show();
                    stackHidden = false;
                }
            } else if (stackHidden) {
                throw new Error("Cannot add to stack whilst hidden");
            } else if (stack.length > 0 && !options.overlay) {
                var oldTray = stack[stack.length-1];
                if (options.width === "inherit") {
                    options.width = oldTray.tray.width();
                }
                oldTray.tray.css({
                    right: -(oldTray.tray.width()+10)+"px"
                });
                setTimeout(function() {
                    oldTray.tray.detach();
                    showTray(options);
                },250)
            } else {
                RED.events.emit("editor:open");
                showTray(options);
            }

        },
        hide: function hide() {
            if (stack.length > 0) {
                var tray = stack[stack.length-1];
                tray.tray.css({
                    right: -(tray.tray.width()+10)+"px"
                });
                $("#red-ui-header-shade").hide();
                $("#red-ui-editor-shade").hide();
                $("#red-ui-palette-shade").hide();
                $(".red-ui-sidebar-shade").hide();
                stackHidden = true;
            }
        },
        resize: handleWindowResize,
        close: function close(done) {
            if (stack.length > 0) {
                var tray = stack.pop();
                tray.tray.css({
                    right: -(tray.tray.width()+10)+"px"
                });
                setTimeout(function() {
                    if (tray.options.close) {
                        tray.options.close();
                    }
                    tray.tray.remove();
                    if (stack.length > 0) {
                        var oldTray = stack[stack.length-1];
                        if (!oldTray.options.overlay) {
                            oldTray.tray.appendTo("#red-ui-editor-stack");
                            setTimeout(function() {
                                handleWindowResize();
                                oldTray.tray.css({right:0});
                                if (oldTray.options.show) {
                                    oldTray.options.show();
                                }
                            },0);
                        } else {
                            handleWindowResize();
                            if (oldTray.options.show) {
                                oldTray.options.show();
                            }
                        }
                    }
                    if (done) {
                        done();
                    }
                    if (stack.length === 0) {
                        $("#red-ui-header-shade").hide();
                        $("#red-ui-editor-shade").hide();
                        $("#red-ui-palette-shade").hide();
                        $(".red-ui-sidebar-shade").hide();
                        RED.events.emit("editor:close");
                        RED.view.focus();
                    }
                },250)
            }
        }
    }
})();


text:
# 1.0.0 (2017-11-06)
Move markForCheck inside directives.

# 1.0.0-alpha.8 (2017-09-19)
Bug fix when props exist in both ng4 and ng5 prop meta storage.

# 1.0.0-alpha.7 (2017-09-19)
Minor fix, plus moved commonjs factory loader to specs for now to get rid of static analysis warnings.  Can re-add in separate library later if needed.

# 1.0.0-alpha.6 (2017-09-19)
Get stuff working with 'static' dynamic (ie. ng cli with AOT).
In this mode, there is no need to register any specific NgModuleFactoryLoader.
Ng-cli basically transforms your typescript to plug its factories in during AOT.
It discovers components by using the router, so you'll have to add fake (or possibly real) routes.
In the root module, add routes like: { path: 'makeupsomething', loadChildren: '../../relative-path-to/some.module#SomeModule', component: SomeModule }.
Obviously this goes against the grain of what this library is trying to do, but sometimes you want it to run in an ng-cli devops environment, perhaps in anticipation of a better way later that wont cause you to change library code.
- Don't use a @scopename absolute reference in loadChildren, its not supported by ng cli yet.
- The component type is required, so if there are multiple types add multiple paths.  Remember, this is just a hack to make it work in the static analysis culture without changing library code.
- It adds an unfortunate private member access to get the component type, but only when the NgModule attribute is gone (ie. webpack output from the cli).

# 1.0.0-alpha.5 (2017-08-30)
Angular 5

# 1.0.0-alpha.4 (2017-06-15)
Added more NgModuleFactoryLoaders.
- Existing: Simply wraps getModuleFactory from @angular/core
- Explicit: Use this to register types directly as 'dynamic' (even though you have them statically resolved).  Useful for running tests and samples with webpack/ng-cli.

# 1.0.0-alpha.3 (2017-06-14)
State is now supplied in StateChange.

# 1.0.0-alpha.2 (2017-06-13)
Export @Control, @State, and @Stateful.

# 1.0.0-alpha.1 (2017-06-13)
Removed dependency on angular internal Reflector.

# 1.0.0-alpha.0 (2017-04-13)


text:
<md-input-container md-no-float ng-if="!options.hideFilters" layout-fill>
    <md-chips ng-model="filters">
        <md-autocomplete placeholder="filter"
                         ng-init="choices = getFilterChoices(searchText)"
                         md-min-length="0"
                         md-autoselect="true"
                         md-items="choice in choices"
                         md-item-text="choice"
                         md-search-text="searchText"
                         md-search-text-change="choices = getFilterChoices(searchText)"
                         >
            <md-item-template>
                {{choice}}
            </md-item-template>
        </md-autocomplete>
    </md-chips>
</md-input-container>

<md-data-table-container>

                <md-menu md-offset="-5 -5">
                    more_vert
                    <md-menu-content width="4">
                        <md-menu-item>
                            <md-button ng-click="showEntityModal($event, e, 'view')">
                                <md-icon>zoom_in</md-icon> view details
                            </md-button>
                        </md-menu-item>
                        <md-menu-item>
                            <md-button ng-click="showEntityModal($event, e, 'edit')">
                                <md-icon>mode_edit</md-icon> edit
                            </md-button>
                        </md-menu-item>
                        <md-menu-item>
                            <md-button ng-click="showEntityModal($event, e, 'duplicate')">
                                <md-icon>content_copy</md-icon> duplicate
                            </md-button>
                        </md-menu-item>
                        <md-menu-item>
                            <md-button ng-click="manuallyRunWorkflow(e)">
                                <md-icon>directions_run</md-icon> run
                            </md-button>
                        </md-menu-item>
                        <md-menu-item>
                            <md-button ng-click="$state.go('app.tools.graph', {t:'workflow', id:e.id})">
                                <md-icon>share</md-icon> graph
                            </md-button>
                        </md-menu-item>
                    </md-menu-content>
                </md-menu>

            {{e.id}}
            {{e.data.datastore_id}}
            {{e.data.name}}
            {{e.data.state}}
            {{e.data.concurrency}}

</md-data-table-container>

<md-data-table-pagination ng-if="!options.hideControls"
                          md-limit="query.limit"
                          md-page="query.page"
                          md-total="{{response.total}}"
                          md-trigger="onPaginationChange"></md-data-table-pagination>


text:
void RegisterDummyObjects(lua_State* L)
{
	using namespace luabridge;

	getGlobalNamespace(L)
		.beginClass<Vector2>("Vector2")
		.addConstructor<void(*)(float, float)>()
		.addData("x", &Vector2::x)
		.addData("y", &Vector2::y)
		.addFunction("length", &Vector2::length)
		.endClass()
		.beginClass<Vector3>("Vector3")
		.addConstructor<void(*)(float, float, float)>()
		.addData("x", &Vector3::x)
		.addData("y", &Vector3::y)
		.addData("z", &Vector3::z)
		.addFunction("length", &Vector3::length)
		.endClass()
		.beginClass<Quaternion>("Quaternion")
		.addConstructor<void(*)(float, float, float, float)>()
		.addData("x", &Quaternion::x)
		.addData("y", &Quaternion::y)
		.addData("z", &Quaternion::z)
		.addData("w", &Quaternion::w)
		.addFunction("length", &Quaternion::length)
		.endClass();
}


text:
Tinytest.add(
  'integration - sending some data',
  function(test) {
    var path = "/" + Random.id();
    Picker.route(path, function(params, req, res, next) {
      InjectData.pushData(res, "aa", {bb: 10});
      next();
    });

    var data = getInjectedData(path);
    var expected = {aa: {bb: 10}};
    test.equal(data, expected);
  }
);

Tinytest.add(
  'integration - get data on the client',
  function(test) {
    var expected = {bb: 10};
    var path = "/" + Random.id();
    Picker.route(path, function(params, req, res, next) {
      InjectData.pushData(res, "aa", {bb: 10});
      test.equal(InjectData.getData(res, "aa"), expected);
      next();
    });

    getInjectedData(path);
  }
);

Tinytest.add(
  'integration - different types of data',
  function(test) {
    var path = "/" + Random.id();
    var sendingData = {
      kk: {bb: 10},
      c: true,
      d: "string"
    };

    Picker.route(path, function(params, req, res, next) {
      _.each(sendingData, function(val, key) {
        InjectData.pushData(res, key, val);
      });
      next();
    });

    var data = getInjectedData(path);
    test.equal(data, sendingData);
  }
);

Tinytest.add(
  'integration - sending some bad chars where HTML does not like well',
  function(test) {
    var path = "/" + Random.id();
    var text = "<s> sdsd //\\ </script>alert('hello');</script>"
    Picker.route(path, function(params, req, res, next) {
      InjectData.pushData(res, "aa", text);
      next();
    });

    var data = getInjectedData(path);
    var expected = {aa: text};
    test.equal(data, expected);
  }
);

Tinytest.add(
  'integration - no data sending',
  function(test, done) {
    var path = "/" + Random.id();
    var data = getInjectedData(path);
    test.equal(data, null);
  }
);

Tinytest.add(
  'integration - send with CORS',
  function(test, done) {
    var path = "/" + Random.id();
    Picker.route(path, function(params, req, res, next) {
      InjectData.pushData(res, "aa", {bb: 10});
      res.writeHead(200, {
        'access-control-allow-origin': '*'
      });
      res.write('<!DOCTYPE html>');
      res.end();
    });

    var data = getInjectedData(path);
    test.equal(data, null);
  }
);

Tinytest.add(
  'integration - send as a buffer',
  function(test, done) {
    var path = "/" + Random.id();
    Picker.route(path, function(params, req, res, next) {
      InjectData.pushData(res, "aa", {bb: 10});
      var str = '<!DOCTYPE html>';
      res.write(new Buffer(str));
      res.end();
    });

    var data = getInjectedData(path);
    test.equal(data, {aa: {bb: 10}});
  }
);

Tinytest.add(
  'integration - send with other than HTML',
  function(test, done) {
    var path = "/" + Random.id();
    Picker.route(path, function(params, req, res, next) {
      InjectData.pushData(res, "aa", {bb: 10});
      res.write('some other data');
      res.end();
    });

    var data = getInjectedData(path);
    test.equal(data, null);
  }
);

var urlResolve = Npm.require('url').resolve;
function getInjectedData(path) {
  var url = urlResolve(process.env.ROOT_URL, path);
  var res = HTTP.get(url);

  var matched = res.content.match(/data">(.*)<\/script/);
  if(matched) {
    var encodedData = matched[1];
    return InjectData._decode(encodedData);
  } else {
    return null;
  }
}