text:
define(function () { 'use strict';

var observable = function(el) {

  /**
   * Extend the original object or create a new empty one
   * @type { Object }
   */

  el = el || {};

  /**
   * Private variables
   */
  var callbacks = {},
    slice = Array.prototype.slice;

  /**
   * Public Api
   */

  // extend the el object adding the observable methods
  Object.defineProperties(el, {
    /**
     * Listen to the given `event` ands
     * execute the `callback` each time an event is triggered.
     * @param  { String } event - event id
     * @param  { Function } fn - callback function
     * @returns { Object } el
     */
    on: {
      value: function(event, fn) {
        if (typeof fn == 'function')
          { (callbacks[event] = callbacks[event] || []).push(fn); }
        return el
      },
      enumerable: false,
      writable: false,
      configurable: false
    },

    /**
     * Removes the given `event` listeners
     * @param   { String } event - event id
     * @param   { Function } fn - callback function
     * @returns { Object } el
     */
    off: {
      value: function(event, fn) {
        if (event == '*' && !fn) { callbacks = {}; }
        else {
          if (fn) {
            var arr = callbacks[event];
            for (var i = 0, cb; cb = arr && arr[i]; ++i) {
              if (cb == fn) { arr.splice(i--, 1); }
            }
          } else { delete callbacks[event]; }
        }
        return el
      },
      enumerable: false,
      writable: false,
      configurable: false
    },

    /**
     * Listen to the given `event` and
     * execute the `callback` at most once
     * @param   { String } event - event id
     * @param   { Function } fn - callback function
     * @returns { Object } el
     */
    one: {
      value: function(event, fn) {
        function on() {
          el.off(event, on);
          fn.apply(el, arguments);
        }
        return el.on(event, on)
      },
      enumerable: false,
      writable: false,
      configurable: false
    },

    /**
     * Execute all callback functions that listen to
     * the given `event`
     * @param   { String } event - event id
     * @returns { Object } el
     */
    trigger: {
      value: function(event) {
        var arguments$1 = arguments;

        // getting the arguments
        var arglen = arguments.length - 1,
          args = new Array(arglen),
          fns,
          fn,
          i;

        for (i = 0; i < arglen; i++) {
          args[i] = arguments$1[i + 1]; // skip first argument
        }

        fns = slice.call(callbacks[event] || [], 0);

        for (i = 0; fn = fns[i]; ++i) {
          fn.apply(el, args);
        }

        if (callbacks['*'] && event != '*')
          { el.trigger.apply(el, ['*', event].concat(args)); }

        return el
      },
      enumerable: false,
      writable: false,
      configurable: false
    }
  });

  return el

};

/**
 * Simple client-side router
 * @module riot-route
 */

var RE_ORIGIN = /^.+?\/\/+[^\/]+/;
var EVENT_LISTENER = 'EventListener';
var REMOVE_EVENT_LISTENER = 'remove' + EVENT_LISTENER;
var ADD_EVENT_LISTENER = 'add' + EVENT_LISTENER;
var HAS_ATTRIBUTE = 'hasAttribute';
var POPSTATE = 'popstate';
var HASHCHANGE = 'hashchange';
var TRIGGER = 'trigger';
var MAX_EMIT_STACK_LEVEL = 3;
var win = typeof window != 'undefined' && window;
var doc = typeof document != 'undefined' && document;
var hist = win && history;
var loc = win && (hist.location || win.location);
var prot = Router.prototype;
var clickEvent = doc && doc.ontouchstart ? 'touchstart' : 'click';
var central = observable();

var started = false;
var routeFound = false;
var debouncedEmit;
var base;
var current;
var parser;
var secondParser;
var emitStack = [];
var emitStackLevel = 0;

/**
 * Default parser. You can replace it via router.parser method.
 * @param {string} path - current path (normalized)
 * @returns {array} array
 */
function DEFAULT_PARSER(path) {
  return path.split(/[/?#]/)
}

/**
 * Default parser (second). You can replace it via router.parser method.
 * @param {string} path - current path (normalized)
 * @param {string} filter - filter string (normalized)
 * @returns {array} array
 */
function DEFAULT_SECOND_PARSER(path, filter) {
  var f = filter
    .replace(/\?/g, '\\?')
    .replace(/\*/g, '([^/?#]+?)')
    .replace(/\.\./, '.*');
  var re = new RegExp(("^" + f + "$"));
  var args = path.match(re);

  if (args) { return args.slice(1) }
}

/**
 * Simple/cheap debounce implementation
 * @param   {function} fn - callback
 * @param   {number} delay - delay in seconds
 * @returns {function} debounced function
 */
function debounce(fn, delay) {
  var t;
  return function () {
    clearTimeout(t);
    t = setTimeout(fn, delay);
  }
}

/**
 * Set the window listeners to trigger the routes
 * @param {boolean} autoExec - see route.start
 */
function start(autoExec) {
  debouncedEmit = debounce(emit, 1);
  win[ADD_EVENT_LISTENER](POPSTATE, debouncedEmit);
  win[ADD_EVENT_LISTENER](HASHCHANGE, debouncedEmit);
  doc[ADD_EVENT_LISTENER](clickEvent, click);
  if (autoExec) { emit(true); }
}

/**
 * Router class
 */
function Router() {
  this.$ = [];
  observable(this); // make it observable
  central.on('stop', this.s.bind(this));
  central.on('emit', this.e.bind(this));
}

function normalize(path) {
  return path.replace(/^\/|\/$/, '')
}

function isString(str) {
  return typeof str == 'string'
}

/**
 * Get the part after domain name
 * @param {string} href - fullpath
 * @returns {string} path from root
 */
function getPathFromRoot(href) {
  return (href || loc.href).replace(RE_ORIGIN, '')
}

/**
 * Get the part after base
 * @param {string} href - fullpath
 * @returns {string} path from base
 */
function getPathFromBase(href) {
  return base[0] === '#'
    ? (href || loc.href || '').split(base)[1] || ''
    : (loc ? getPathFromRoot(href) : href || '').replace(base, '')
}

function emit(force) {
  // the stack is needed for redirections
  var isRoot = emitStackLevel === 0;
  if (MAX_EMIT_STACK_LEVEL <= emitStackLevel) { return }

  emitStackLevel++;
  emitStack.push(function() {
    var path = getPathFromBase();
    if (force || path !== current) {
      central[TRIGGER]('emit', path);
      current = path;
    }
  });
  if (isRoot) {
    var first;
    while (first = emitStack.shift()) { first(); } // stack increses within this call
    emitStackLevel = 0;
  }
}

function click(e) {
  if (
    e.which !== 1 // not left click
    || e.metaKey || e.ctrlKey || e.shiftKey // or meta keys
    || e.defaultPrevented // or default prevented
  ) { return }

  var el = e.target;
  while (el && el.nodeName !== 'A') { el = el.parentNode; }

  if (
    !el || el.nodeName !== 'A' // not A tag
    || el[HAS_ATTRIBUTE]('download') // has download attr
    || !el[HAS_ATTRIBUTE]('href') // has no href attr
    || el.target && el.target !== '_self' // another window or frame
    || el.href.indexOf(loc.href.match(RE_ORIGIN)[0]) === -1 // cross origin
  ) { return }

  if (el.href !== loc.href
    && (
      el.href.split('#')[0] === loc.href.split('#')[0] // internal jump
      || base[0] !== '#' && getPathFromRoot(el.href).indexOf(base) !== 0 // outside of base
      || base[0] === '#' && el.href.split(base)[0] !== loc.href.split(base)[0] // outside of #base
      || !go(getPathFromBase(el.href), el.title || doc.title) // route not found
    )) { return }

  e.preventDefault();
}

/**
 * Go to the path
 * @param {string} path - destination path
 * @param {string} title - page title
 * @param {boolean} shouldReplace - use replaceState or pushState
 * @returns {boolean} - route not found flag
 */
function go(path, title, shouldReplace) {
  // Server-side usage: directly execute handlers for the path
  if (!hist) { return central[TRIGGER]('emit', getPathFromBase(path)) }

  path = base + normalize(path);
  title = title || doc.title;
  // browsers ignores the second parameter `title`
  shouldReplace
    ? hist.replaceState(null, title, path)
    : hist.pushState(null, title, path);
  // so we need to set it manually
  doc.title = title;
  routeFound = false;
  emit();
  return routeFound
}

/**
 * Go to path or set action
 * a single string:                go there
 * two strings:                    go there with setting a title
 * two strings and boolean:        replace history with setting a title
 * a single function:              set an action on the default route
 * a string/RegExp and a function: set an action on the route
 * @param {(string|function)} first - path / action / filter
 * @param {(string|RegExp|function)} second - title / action
 * @param {boolean} third - replace flag
 */
prot.m = function(first, second, third) {
  if (isString(first) && (!second || isString(second))) { go(first, second, third || false); }
  else if (second) { this.r(first, second); }
  else { this.r('@', first); }
};

/**
 * Stop routing
 */
prot.s = function() {
  this.off('*');
  this.$ = [];
};

/**
 * Emit
 * @param {string} path - path
 */
prot.e = function(path) {
  this.$.concat('@').some(function(filter) {
    var args = (filter === '@' ? parser : secondParser)(normalize(path), normalize(filter));
    if (typeof args != 'undefined') {
      this[TRIGGER].apply(null, [filter].concat(args));
      return routeFound = true // exit from loop
    }
  }, this);
};

/**
 * Register route
 * @param {string} filter - filter for matching to url
 * @param {function} action - action to register
 */
prot.r = function(filter, action) {
  if (filter !== '@') {
    filter = '/' + normalize(filter);
    this.$.push(filter);
  }
  this.on(filter, action);
};

var mainRouter = new Router();
var route = mainRouter.m.bind(mainRouter);

/**
 * Create a sub router
 * @returns {function} the method of a new Router object
 */
route.create = function() {
  var newSubRouter = new Router();
  // assign sub-router's main method
  var router = newSubRouter.m.bind(newSubRouter);
  // stop only this sub-router
  router.stop = newSubRouter.s.bind(newSubRouter);
  return router
};

/**
 * Set the base of url
 * @param {(str|RegExp)} arg - a new base or '#' or '#!'
 */
route.base = function(arg) {
  base = arg || '#';
  current = getPathFromBase(); // recalculate current path
};

/** Exec routing right now **/
route.exec = function() {
  emit(true);
};

/**
 * Replace the default router to yours
 * @param {function} fn - your parser function
 * @param {function} fn2 - your secondParser function
 */
route.parser = function(fn, fn2) {
  if (!fn && !fn2) {
    // reset parser for testing...
    parser = DEFAULT_PARSER;
    secondParser = DEFAULT_SECOND_PARSER;
  }
  if (fn) { parser = fn; }
  if (fn2) { secondParser = fn2; }
};

/**
 * Helper function to get url query as an object
 * @returns {object} parsed query
 */
route.query = function() {
  var q = {};
  var href = loc.href || current;
  href.replace(/[?&](.+?)=([^&]*)/g, function(_, k, v) { q[k] = v; });
  return q
};

/** Stop routing **/
route.stop = function () {
  if (started) {
    if (win) {
      win[REMOVE_EVENT_LISTENER](POPSTATE, debouncedEmit);
      win[REMOVE_EVENT_LISTENER](HASHCHANGE, debouncedEmit);
      doc[REMOVE_EVENT_LISTENER](clickEvent, click);
    }
    central[TRIGGER]('stop');
    started = false;
  }
};

/**
 * Start routing
 * @param {boolean} autoExec - automatically exec after starting if true
 */
route.start = function (autoExec) {
  if (!started) {
    if (win) {
      if (document.readyState === 'interactive' || document.readyState === 'complete') {
        start(autoExec);
      }
      else {
        document.onreadystatechange = function () {
          if (document.readyState === 'interactive') {
            // the timeout is needed to solve
            // a weird safari bug https://github.com/riot/route/issues/33
            setTimeout(function() { start(autoExec); }, 1);
          }
        };
      }
    }
    started = true;
  }
};

/** Prepare the router **/
route.base();
route.parser();

return route;

});


text:
import * as R from 'ramda';
import * as React from 'react';

import { IArtifactWithPath } from 'shared/models/Artifact';
import { artifactErrorMessages } from 'shared/utils/customErrorMessages';
import { initialCommunication } from 'shared/utils/redux/communication';
import Button from 'shared/view/elements/Button/Button';
import InlineCommunicationError from 'shared/view/elements/Errors/InlineCommunicationError/InlineCommunicationError';
import { Icon } from 'shared/view/elements/Icon/Icon';
import Preloader from 'shared/view/elements/Preloader/Preloader';
import { EntityType } from 'features/artifactManager/store';
import useDownloadArtifact from 'features/artifactManager/store/hooks/useDownloadArtifact';

import styles from './DownloadArtifactButton.module.css';

interface ILocalProps {
  entityId: string;
  entityType: EntityType;
  artifact: IArtifactWithPath;
  isShowErrorIfExist: boolean;
}

type AllProps = ILocalProps;

const DownloadArtifactButton = (props: AllProps) => {
  const { artifact, entityId, entityType, isShowErrorIfExist } = props;
  const { downloadArtifact, downloadingArtifact } = useDownloadArtifact({
    artifact,
    entityId,
    entityType,
  });

  if (R.equals(downloadingArtifact, initialCommunication)) {
    return (

        <Button onClick={downloadArtifact}>Download Artifact</Button>

    );
  }
  if (downloadingArtifact.isRequesting) {
    return (

        <Preloader variant="dots" />

    );
  }
  if (downloadingArtifact.error) {
    return (

        <Button disabled={true} onClick={downloadArtifact}>
          Download Failed
        </Button>
        {isShowErrorIfExist && (

            <InlineCommunicationError
              error={downloadingArtifact.error}
              customMessage={artifactErrorMessages.artifact_download}
            />

        )}

    );
  }
  return (

      <Button disabled={true}>Downloaded</Button>

          Downloaded <Icon type="check-circle" />

  );
};

export default DownloadArtifactButton;

redpajama_set_name: RedPajamaGithub


text:
require "helper"
require "pathname"

describe Google::Cloud::Vision::Image, :document, :mock_vision do
  let(:filepath) { "acceptance/data/text.png" }
  let(:image)    { vision.image filepath }

  it "detects document text" do
    feature = Google::Cloud::Vision::V1::Feature.new(type: :DOCUMENT_TEXT_DETECTION, max_results: 1)
    req = [
      Google::Cloud::Vision::V1::AnnotateImageRequest.new(
        image: Google::Cloud::Vision::V1::Image.new(content: File.read(filepath, mode: "rb")),
        features: [feature]
      )
    ]
    mock = Minitest::Mock.new
    mock.expect :batch_annotate_images, text_response_grpc, [req, options: default_options]

    vision.service.mocked_service = mock

    text = image.document
    mock.verify

    text.wont_be :nil?
    text.text.must_include "Google Cloud Client for Ruby"
    text.locale.must_equal "en"
    # the `text_annotations` model
    text.words.count.must_equal 28
    text.words[0].text.must_equal "Google"
    text.words[0].bounds.map(&:to_a).must_equal [[13, 8], [53, 8], [53, 23], [13, 23]]
    text.words[27].text.must_equal "Storage."
    text.words[27].bounds.map(&:to_a).must_equal [[304, 59], [351, 59], [351, 74], [304, 74]]
    # the `full_text_annotation` model
    text.pages.count.must_equal 1
    text.pages[0].must_be_kind_of Google::Cloud::Vision::Annotation::Text::Page
    text.pages[0].languages.count.must_equal 1
    text.pages[0].languages[0].code.must_equal "en"
    text.pages[0].languages[0].confidence.must_equal 0.0
    text.pages[0].break_type.must_be :nil?
    text.pages[0].wont_be :prefix_break?
    text.pages[0].width.must_equal 400
    text.pages[0].height.must_equal 80
    text.pages[0].blocks[0].bounds.map(&:to_a).must_equal [[13, 8], [385, 8], [385, 23], [13, 23]]
    text.pages[0].blocks[0].paragraphs[0].bounds.map(&:to_a).must_equal [[13, 8], [385, 8], [385, 23], [13, 23]]
    text.pages[0].blocks[0].paragraphs[0].words[0].bounds.map(&:to_a).must_equal [[13, 8], [53, 8], [53, 23], [13, 23]]
    text.pages[0].blocks[0].paragraphs[0].words[0].symbols[0].bounds.map(&:to_a).must_equal [[13, 8], [21, 8], [21, 23], [13, 23]]
    text.pages[0].blocks[0].paragraphs[0].words[0].symbols[0].text.must_equal "G"

    text.pages.count.must_equal 1
  end
end


text:
import { matchesProperty } from "lodash";
export = matchesProperty;


text:
static void build_document_order(std::vector<pugi::xpath_node>& result, pugi::xml_node root)
{
	result.push_back(pugi::xpath_node());

	pugi::xml_node cur = root;

	for (;;)
	{
		result.push_back(cur);

		for (pugi::xml_attribute a = cur.first_attribute(); a; a = a.next_attribute())
			result.push_back(pugi::xpath_node(a, cur));

		if (cur.first_child())
			cur = cur.first_child();
		else if (cur.next_sibling())
			cur = cur.next_sibling();
		else
		{
			while (cur && !cur.next_sibling()) cur = cur.parent();
			cur = cur.next_sibling();

			if (!cur) break;
		}
	}
}
#endif

bool test_string_equal(const pugi::char_t* lhs, const pugi::char_t* rhs)
{
	return (!lhs || !rhs) ? lhs == rhs :
	#ifdef PUGIXML_WCHAR_MODE
		wcscmp(lhs, rhs) == 0;
	#else
		strcmp(lhs, rhs) == 0;
	#endif
}

bool test_node(const pugi::xml_node& node, const pugi::char_t* contents, const pugi::char_t* indent, unsigned int flags)
{
	xml_writer_string writer;

	node.print(writer, indent, flags, get_native_encoding());

	return writer.as_string() == contents;
}

bool test_double_nan(double value)
{
#if defined(_MSC_VER) || defined(__BORLANDC__)
	return _isnan(value) != 0;
#else
	return value != value;
#endif
}

#ifndef PUGIXML_NO_XPATH
static size_t strlength(const pugi::char_t* s)
{
#ifdef PUGIXML_WCHAR_MODE
	return wcslen(s);
#else
	return strlen(s);
#endif
}

bool test_xpath_string(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, const pugi::char_t* expected)
{
	pugi::xpath_query q(query, variables);
	if (!q) return false;

	const size_t capacity = 64;
	pugi::char_t result[capacity];

	size_t size = q.evaluate_string(result, capacity, node);

	if (size != strlength(expected) + 1)
		return false;

	if (size <= capacity)
		return test_string_equal(result, expected);

	std::basic_string<pugi::char_t> buffer(size, ' ');

	return q.evaluate_string(&buffer[0], size, node) == size && test_string_equal(buffer.c_str(), expected);
}

bool test_xpath_boolean(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, bool expected)
{
	pugi::xpath_query q(query, variables);
	if (!q) return false;

	return q.evaluate_boolean(node) == expected;
}

bool test_xpath_number(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables, double expected)
{
	pugi::xpath_query q(query, variables);
	if (!q) return false;

	double value = q.evaluate_number(node);
	double absolute_error = fabs(value - expected);

	const double tolerance = 1e-15;
	return absolute_error < tolerance || absolute_error < fabs(expected) * tolerance;
}

bool test_xpath_number_nan(const pugi::xpath_node& node, const pugi::char_t* query, pugi::xpath_variable_set* variables)
{
	pugi::xpath_query q(query, variables);
	if (!q) return false;

	return test_double_nan(q.evaluate_number(node));
}

bool test_xpath_fail_compile(const pugi::char_t* query, pugi::xpath_variable_set* variables)
{
#ifdef PUGIXML_NO_EXCEPTIONS
	return !pugi::xpath_query(query, variables);
#else
	try
	{
		pugi::xpath_query q(query, variables);
		return false;
	}
	catch (const pugi::xpath_exception&)
	{
		return true;
	}
#endif
}

void xpath_node_set_tester::check(bool condition)
{
	if (!condition)
	{
		test_runner::_failure_message = message;
		longjmp(test_runner::_failure_buffer, 1);
	}
}

xpath_node_set_tester::xpath_node_set_tester(const pugi::xpath_node_set& set, const char* message_): last(0), message(message_)
{
	result = set;

	// only sort unsorted sets so that we're able to verify reverse order for some axes
	if (result.type() == pugi::xpath_node_set::type_unsorted) result.sort();

	if (result.empty())
	{
		document_order = 0;
		document_size = 0;
	}
	else
	{
		std::vector<pugi::xpath_node> order;
		build_document_order(order, (result[0].attribute() ? result[0].parent() : result[0].node()).root());

		document_order = new pugi::xpath_node[order.size()];
		std::copy(order.begin(), order.end(), document_order);

		document_size = order.size();
	}
}

xpath_node_set_tester::~xpath_node_set_tester()
{
	// check that we processed everything
	check(last == result.size());

	delete[] document_order;
}

xpath_node_set_tester& xpath_node_set_tester::operator%(unsigned int expected)
{
	// check element count
	check(last < result.size());

	// check document order
	check(expected < document_size);
	check(result.begin()[last] == document_order[expected]);

	// continue to the next element
	last++;

	return *this;
}

#endif

bool is_little_endian()
{
	unsigned int ui = 1;
	return *reinterpret_cast<char*>(&ui) == 1;
}

pugi::xml_encoding get_native_encoding()
{
#ifdef PUGIXML_WCHAR_MODE
	return pugi::encoding_wchar;
#else
	return pugi::encoding_utf8;
#endif
}


text:
<LINK REL="stylesheet" href="../../static/styles.css">

<TITLE>What's New in 1.01</TITLE>

Firelight Technologies FMOD Studio API

What's New in 1.01

This section describes the major features introduced in the 1.01 release.  See the Detailed Revision History for information regarding each patch release.

Sends

Support has been added for Send DSP connections to send sound data to different areas of the mix graph.

Fade Points

Support has been added for setting sample-accurate fade ramp points.  The fade points allow Studio to schedule sound volume gradients to occur in future mixes.

Studio API

A number of additional Studio API functions have been added.  See the revision.txt for more details.


text:
#ifndef X264_FRAME_H
#define X264_FRAME_H

/* number of pixels past the edge of the frame, for motion estimation/compensation */
#define PADH 32
#define PADV 32

typedef struct x264_frame
{
    /* */
    uint8_t *base;       /* Base pointer for all malloced data in this frame. */
    int     i_poc;
    int     i_delta_poc[2];
    int     i_type;
    int     i_forced_type;
    int     i_qpplus1;
    int64_t i_pts;
    int64_t i_dts;
    int64_t i_reordered_pts;
    int64_t i_duration;  /* in SPS time_scale units (i.e 2 * timebase units) used for vfr */
    float   f_duration;  /* in seconds */
    int64_t i_cpb_duration;
    int64_t i_cpb_delay; /* in SPS time_scale units (i.e 2 * timebase units) */
    int64_t i_dpb_output_delay;
    x264_param_t *param;

    int     i_frame;     /* Presentation frame number */
    int     i_coded;     /* Coded frame number */
    int64_t i_field_cnt; /* Presentation field count */
    int     i_frame_num; /* 7.4.3 frame_num */
    int     b_kept_as_ref;
    int     i_pic_struct;
    int     b_keyframe;
    uint8_t b_fdec;
    uint8_t b_last_minigop_bframe; /* this frame is the last b in a sequence of bframes */
    uint8_t i_bframes;   /* number of bframes following this nonb in coded order */
    float   f_qp_avg_rc; /* QPs as decided by ratecontrol */
    float   f_qp_avg_aq; /* QPs as decided by AQ in addition to ratecontrol */
    float   f_crf_avg;   /* Average effective CRF for this frame */
    int     i_poc_l0ref0; /* poc of first refframe in L0, used to check if direct temporal is possible */

    /* YUV buffer */
    int     i_csp; /* Internal csp */
    int     i_plane;
    int     i_stride[3];
    int     i_width[3];
    int     i_lines[3];
    int     i_stride_lowres;
    int     i_width_lowres;
    int     i_lines_lowres;
    pixel *plane[3];
    pixel *plane_fld[3];
    pixel *filtered[3][4]; /* plane[0], H, V, HV */
    pixel *filtered_fld[3][4];
    pixel *lowres[4]; /* half-size copy of input frame: Orig, H, V, HV */
    uint16_t *integral;

    /* for unrestricted mv we allocate more data than needed
     * allocated data are stored in buffer */
    pixel *buffer[4];
    pixel *buffer_fld[4];
    pixel *buffer_lowres;

    x264_weight_t weight[X264_REF_MAX][3]; /* [ref_index][plane] */
    pixel *weighted[X264_REF_MAX]; /* plane[0] weighted of the reference frames */
    int b_duplicate;
    struct x264_frame *orig;

    /* motion data */
    int8_t  *mb_type;
    uint8_t *mb_partition;
    int16_t (*mv[2])[2];
    int16_t (*mv16x16)[2];
    int16_t (*lowres_mvs[2][X264_BFRAME_MAX+1])[2];
    uint8_t *field;
    uint8_t *effective_qp;

    /* Stored as (lists_used << LOWRES_COST_SHIFT) + (cost).
     * Doesn't need special addressing for intra cost because
     * lists_used is guaranteed to be zero in that cast. */
    uint16_t (*lowres_costs[X264_BFRAME_MAX+2][X264_BFRAME_MAX+2]);
    #define LOWRES_COST_MASK ((1<<14)-1)
    #define LOWRES_COST_SHIFT 14

    int     *lowres_mv_costs[2][X264_BFRAME_MAX+1];
    int8_t  *ref[2];
    int     i_ref[2];
    int     ref_poc[2][X264_REF_MAX];
    int16_t inv_ref_poc[2]; // inverse values of ref0 poc to avoid divisions in temporal MV prediction

    /* for adaptive B-frame decision.
     * contains the SATD cost of the lowres frame encoded in various modes
     * FIXME: how big an array do we need? */
    int     i_cost_est[X264_BFRAME_MAX+2][X264_BFRAME_MAX+2];
    int     i_cost_est_aq[X264_BFRAME_MAX+2][X264_BFRAME_MAX+2];
    int     i_satd; // the i_cost_est of the selected frametype
    int     i_intra_mbs[X264_BFRAME_MAX+2];
    int     *i_row_satds[X264_BFRAME_MAX+2][X264_BFRAME_MAX+2];
    int     *i_row_satd;
    int     *i_row_bits;
    float   *f_row_qp;
    float   *f_row_qscale;
    float   *f_qp_offset;
    float   *f_qp_offset_aq;
    int     b_intra_calculated;
    uint16_t *i_intra_cost;
    uint16_t *i_propagate_cost;
    uint16_t *i_inv_qscale_factor;
    int     b_scenecut; /* Set to zero if the frame cannot possibly be part of a real scenecut. */
    float   f_weighted_cost_delta[X264_BFRAME_MAX+2];
    uint32_t i_pixel_sum[3];
    uint64_t i_pixel_ssd[3];

    /* hrd */
    x264_hrd_t hrd_timing;

    /* vbv */
    uint8_t i_planned_type[X264_LOOKAHEAD_MAX+1];
    int i_planned_satd[X264_LOOKAHEAD_MAX+1];
    double f_planned_cpb_duration[X264_LOOKAHEAD_MAX+1];
    int64_t i_coded_fields_lookahead;
    int64_t i_cpb_delay_lookahead;

    /* threading */
    int     i_lines_completed; /* in pixels */
    int     i_lines_weighted; /* FIXME: this only supports weighting of one reference frame */
    int     i_reference_count; /* number of threads using this frame (not necessarily the number of pointers) */
    x264_pthread_mutex_t mutex;
    x264_pthread_cond_t  cv;
    int     i_slice_count; /* Atomically written to/read from with slice threads */

    /* periodic intra refresh */
    float   f_pir_position;
    int     i_pir_start_col;
    int     i_pir_end_col;
    int     i_frames_since_pir;

    /* interactive encoder control */
    int     b_corrupt;

    /* user sei */
    x264_sei_t extra_sei;

    /* user data */
    void *opaque;

    /* user frame properties */
    uint8_t *mb_info;
    void (*mb_info_free)( void* );

#if HAVE_OPENCL
    x264_frame_opencl_t opencl;
#endif
} x264_frame_t;

/* synchronized frame list */
typedef struct
{
   x264_frame_t **list;
   int i_max_size;
   int i_size;
   x264_pthread_mutex_t     mutex;
   x264_pthread_cond_t      cv_fill;  /* event signaling that the list became fuller */
   x264_pthread_cond_t      cv_empty; /* event signaling that the list became emptier */
} x264_sync_frame_list_t;

typedef void (*x264_deblock_inter_t)( pixel *pix, intptr_t stride, int alpha, int beta, int8_t *tc0 );
typedef void (*x264_deblock_intra_t)( pixel *pix, intptr_t stride, int alpha, int beta );
typedef struct
{
    x264_deblock_inter_t deblock_luma[2];
    x264_deblock_inter_t deblock_chroma[2];
    x264_deblock_inter_t deblock_h_chroma_420;
    x264_deblock_inter_t deblock_h_chroma_422;
    x264_deblock_intra_t deblock_luma_intra[2];
    x264_deblock_intra_t deblock_chroma_intra[2];
    x264_deblock_intra_t deblock_h_chroma_420_intra;
    x264_deblock_intra_t deblock_h_chroma_422_intra;
    x264_deblock_inter_t deblock_luma_mbaff;
    x264_deblock_inter_t deblock_chroma_mbaff;
    x264_deblock_inter_t deblock_chroma_420_mbaff;
    x264_deblock_inter_t deblock_chroma_422_mbaff;
    x264_deblock_intra_t deblock_luma_intra_mbaff;
    x264_deblock_intra_t deblock_chroma_intra_mbaff;
    x264_deblock_intra_t deblock_chroma_420_intra_mbaff;
    x264_deblock_intra_t deblock_chroma_422_intra_mbaff;
    void (*deblock_strength)( uint8_t nnz[X264_SCAN8_SIZE], int8_t ref[2][X264_SCAN8_LUMA_SIZE],
                              int16_t mv[2][X264_SCAN8_LUMA_SIZE][2], uint8_t bs[2][8][4], int mvy_limit,
                              int bframe );
} x264_deblock_function_t;

#define x264_frame_delete x264_template(frame_delete)
void          x264_frame_delete( x264_frame_t *frame );

#define x264_frame_copy_picture x264_template(frame_copy_picture)
int           x264_frame_copy_picture( x264_t *h, x264_frame_t *dst, x264_picture_t *src );

#define x264_frame_expand_border x264_template(frame_expand_border)
void          x264_frame_expand_border( x264_t *h, x264_frame_t *frame, int mb_y );
#define x264_frame_expand_border_filtered x264_template(frame_expand_border_filtered)
void          x264_frame_expand_border_filtered( x264_t *h, x264_frame_t *frame, int mb_y, int b_end );
#define x264_frame_expand_border_lowres x264_template(frame_expand_border_lowres)
void          x264_frame_expand_border_lowres( x264_frame_t *frame );
#define x264_frame_expand_border_chroma x264_template(frame_expand_border_chroma)
void          x264_frame_expand_border_chroma( x264_t *h, x264_frame_t *frame, int plane );
#define x264_frame_expand_border_mod16 x264_template(frame_expand_border_mod16)
void          x264_frame_expand_border_mod16( x264_t *h, x264_frame_t *frame );
#define x264_expand_border_mbpair x264_template(expand_border_mbpair)
void          x264_expand_border_mbpair( x264_t *h, int mb_x, int mb_y );

#define x264_frame_deblock_row x264_template(frame_deblock_row)
void          x264_frame_deblock_row( x264_t *h, int mb_y );
#define x264_macroblock_deblock x264_template(macroblock_deblock)
void          x264_macroblock_deblock( x264_t *h );

#define x264_frame_filter x264_template(frame_filter)
void          x264_frame_filter( x264_t *h, x264_frame_t *frame, int mb_y, int b_end );
#define x264_frame_init_lowres x264_template(frame_init_lowres)
void          x264_frame_init_lowres( x264_t *h, x264_frame_t *frame );

#define x264_deblock_init x264_template(deblock_init)
void          x264_deblock_init( int cpu, x264_deblock_function_t *pf, int b_mbaff );

#define x264_frame_cond_broadcast x264_template(frame_cond_broadcast)
void          x264_frame_cond_broadcast( x264_frame_t *frame, int i_lines_completed );
#define x264_frame_cond_wait x264_template(frame_cond_wait)
void          x264_frame_cond_wait( x264_frame_t *frame, int i_lines_completed );
#define x264_frame_new_slice x264_template(frame_new_slice)
int           x264_frame_new_slice( x264_t *h, x264_frame_t *frame );

#define x264_threadslice_cond_broadcast x264_template(threadslice_cond_broadcast)
void          x264_threadslice_cond_broadcast( x264_t *h, int pass );
#define x264_threadslice_cond_wait x264_template(threadslice_cond_wait)
void          x264_threadslice_cond_wait( x264_t *h, int pass );

#define x264_frame_push x264_template(frame_push)
void          x264_frame_push( x264_frame_t **list, x264_frame_t *frame );
#define x264_frame_pop x264_template(frame_pop)
x264_frame_t *x264_frame_pop( x264_frame_t **list );
#define x264_frame_unshift x264_template(frame_unshift)
void          x264_frame_unshift( x264_frame_t **list, x264_frame_t *frame );
#define x264_frame_shift x264_template(frame_shift)
x264_frame_t *x264_frame_shift( x264_frame_t **list );
#define x264_frame_push_unused x264_template(frame_push_unused)
void          x264_frame_push_unused( x264_t *h, x264_frame_t *frame );
#define x264_frame_push_blank_unused x264_template(frame_push_blank_unused)
void          x264_frame_push_blank_unused( x264_t *h, x264_frame_t *frame );
#define x264_frame_pop_blank_unused x264_template(frame_pop_blank_unused)
x264_frame_t *x264_frame_pop_blank_unused( x264_t *h );
#define x264_weight_scale_plane x264_template(weight_scale_plane)
void x264_weight_scale_plane( x264_t *h, pixel *dst, intptr_t i_dst_stride, pixel *src, intptr_t i_src_stride,
                              int i_width, int i_height, x264_weight_t *w );
#define x264_frame_pop_unused x264_template(frame_pop_unused)
x264_frame_t *x264_frame_pop_unused( x264_t *h, int b_fdec );
#define x264_frame_delete_list x264_template(frame_delete_list)
void          x264_frame_delete_list( x264_frame_t **list );

#define x264_sync_frame_list_init x264_template(sync_frame_list_init)
int           x264_sync_frame_list_init( x264_sync_frame_list_t *slist, int nelem );
#define x264_sync_frame_list_delete x264_template(sync_frame_list_delete)
void          x264_sync_frame_list_delete( x264_sync_frame_list_t *slist );
#define x264_sync_frame_list_push x264_template(sync_frame_list_push)
void          x264_sync_frame_list_push( x264_sync_frame_list_t *slist, x264_frame_t *frame );
#define x264_sync_frame_list_pop x264_template(sync_frame_list_pop)
x264_frame_t *x264_sync_frame_list_pop( x264_sync_frame_list_t *slist );

#endif


text:
<!-- REQUIRED JS SCRIPTS -->

<!-- jQuery 2.1.4 -->
<script src="{{ asset('/plugins/jQuery/jQuery-2.1.4.min.js') }}"></script>
<!-- Bootstrap 3.3.2 JS -->
<script src="{{ asset('/js/bootstrap.min.js') }}" type="text/javascript"></script>
<!-- AdminLTE App -->
<script src="{{ asset('/js/app.min.js') }}" type="text/javascript"></script>

<script src="{{asset('js/main.js')}}"></script>
<script src="{{asset('js/all.js')}}"></script>
<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/sweetalert/1.1.3/sweetalert.min.js"></script>
{{--<script src="{{'js/graph_vue.js'}}"></script>--}}

<!-- Optionally, you can add Slimscroll and FastClick plugins.
      Both of these plugins are recommended to enhance the
      user experience. Slimscroll is required when using the
      fixed layout. -->


text:
/**
 * Base Job Model Validator
 *
 */
define([
  'require',
  'backbone',
  'underscore',
  'models/base_job',
  'backbone/validations'
],
function(require,
         Backbone,
         _,
         BaseJob) {

  function getBaseJob() {
    return BaseJob || (BaseJob = require('models/base_job'));
  };

  var BaseValues;

  var ModelScope = function(model) {
    var attrIs, attrIsNot;

    attrIs = function(attr, val) {
      val || (val = model.get('attr'));
      return function(m) { return m.get(attr) === val; };
    };

    attrIsNot = function(attr, val) {
      val || (val = model.get('attr'));
      return function(m) { return m.get(attr) !== val; };
    };

    return {attrIs: attrIs, attrIsNot: attrIsNot};
  };

  var defaultValidations = {
    name: function(options, attributeName, model, valueToSet) {
      var defaults, conflictingModel;

      defaults = getBaseJob().prototype.defaults.call(null);

      if (defaults.name === model.get('name')) {
        return 'Job should have a name.';
      }

      conflictingModel = model.collection && model.collection.some(function(m) {
        return (model.get('name') === m.get('name')) && (model.id !== m.id);
      });

      if (!!conflictingModel) {
        return "Job should have a unique name.";
      }
    },
    command: function(options, attributeName, model, valueToSet) {
      var defaults = getBaseJob().prototype.defaults.call(null),
          isDefault = (defaults.command === valueToSet);

      if (isDefault || _.isEmpty(valueToSet)) {
        return 'Job should have a command.';
      }
    }
  };

  BaseValues = _.reduce(defaultValidations, function(memo, v, k) {
    var name = ['base_job', k].join(':');
    Backbone.Validations.addValidator(name, v);
    memo[k] || (memo[k] = {});
    memo[k][name] = "";

    return memo;
  }, {});

  return _.extend(BaseValues, {
    owner: {
      required: true,
      minlength: 3,
      // This pattern is based on the one described at http://www.regular-expressions.info/email.html.
      pattern: /[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?/
    }
  });
});


text:
farmaciaWeb
===========

Um aplicativo web para gerenciar uma farmacia


text:
using System;
using XperiCode.JpegMetadata;

namespace ExifInCSharp
{
    public class DemoMitJpegMetadata
    {
        public void ExtrahiereGPSInformationen(string filePath)
        {
            var adapter = new JpegMetadataAdapter(filePath);
            Console.WriteLine($"Title: {adapter.Metadata.Title}");
            Console.WriteLine($"Subject: {adapter.Metadata.Subject}");
            Console.WriteLine($"Rating: {adapter.Metadata.Rating}");
            Console.WriteLine($"Comments: {adapter.Metadata.Comments}");
            Console.WriteLine($"Keywords:");

            foreach (var keyword in adapter.Metadata.Keywords)
            {
                Console.WriteLine($"\t Keyword: {keyword}");
            }
        }
    }
}


text:
<!doctype html>
<title>members of WorkerLocation</title>


text:
<?php

class UserController extends MainController
{
    protected $model;

    public function __construct()
    {
        $this->model = new User();
    }

    public function index()
    {
        if (isset($_SESSION['logged_in']))
            $this->settings();
        else
            $this->login();
    }

    public function login()
    {
        if (isset($_SESSION['logged_in']))
            $this->error('You\'re already signed in.');

        if (isset($_POST['login'])) {
            $username = $_POST['username'];
            $password = $_POST['password'];

            try {
                $this->model->log_in($username, $password);
                header('Location: ' . URL . 'item');
            } catch (Exception $e) {
                $this->error_message = 'Log in failed: ' . $e->getMessage();
            }
        }

        $this->title = 'Reserver - Log in';
        $this->view('user', 'login');
    }

    public function settings()
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        $this->user  = $this->model->get_user($_SESSION['logged_in']);

        if (isset($_POST['change_settings'])) {
            $email                = $_POST['email'];
            $username             = $_POST['username'];
            $current_password     = $_POST['current_password'];
            $new_password         = $_POST['new_password'];
            $confirm_new_password = $_POST['confirm_new_password'];
            $send_reminders       = isset($_POST['send_reminders']) ? 1 : 0;
            $password             = $this->user->password;

            if (!empty($current_password) || !empty($new_password) || !empty($confirm_new_password)) {
                try {
                    $password = $this->model->new_password($this->user->id,
                                                           $current_password, $new_password,
                                                           $confirm_new_password);
                } catch (Exception $e) {
                    $this->error_message = 'Failed to change password: ' . $e->getMessage();
                    $this->view('user', 'settings');
                    return false;
                }
            }

            try {
                $this->model->edit_settings($this->user->id, $email,
                                            $username, $password, $send_reminders);
                $this->success_message = 'Settings successfully changed.';
                /* header('Location: ' . URL . 'user/settings'); */
            } catch (Exception $e) {
                $this->error_message = 'Failed to change settings: ' . $e->getMessage();
            }
        }

        $this->title = 'Reserver - Settings';
        $this->view('user', 'settings');
    }

    public function logout()
    {
        if (!isset($_SESSION['logged_in'])) {
            $this->login();
            return false;
        }

        $this->model->log_out();
        header('Location: ' . URL);
    }

    public function add()
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        if (!$this->model->get_permission('can_change_users')) {
            $this->index();
            return false;
        }

        if (isset($_POST['add_user'])) {
            $full_name    = $_POST['full_name'];
            $email        = $_POST['email'];
            $access_group = $_POST['access_group'];

            try {
                $this->model->add_user($full_name, $email, $access_group);
                // XXX: temporary disable redirecting until mailing works
                /* header('Location: ' . URL . 'user/all'); */
            } catch (Exception $e) {
                $this->error_message = 'Adding user failed: ' . $e->getMessage();
            }
        }

        $this->title = 'Reserver - Add user';
        $this->view('user', 'add');
    }

    public function all($order = 'ausername')
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        if (!$this->model->get_permission('can_change_users')) {
            $this->index();
            return false;
        }

        $this->order = $order;
        $this->users = $this->model->get_all_users($order);

        $this->title = 'Reserver - Edit users';
        $this->view('user', 'all');
    }

    public function edit($uid = null)
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        if (!$this->model->get_user($uid) || !$this->model->get_permission('can_change_users')) {
            $this->index();
            return false;
        }

        $this->user  = $this->model->get_user($uid);

        if (isset($_POST['edit_user'])) {
            $username     = $_POST['username'];
            $email        = $_POST['email'];
            $full_name    = $_POST['full_name'];
            $access_group = $_POST['access_group'];

            try {
                $this->model->edit_user($uid, $username, $email, $full_name, $access_group);
                $this->success_message = 'User ' . $this->model->get_user($uid)->username .
                                         ' succesfully changed.';
                $this->all();
                exit(1);
            } catch (Exception $e) {
                $this->error_message = 'Editing user failed: ' . $e->getMessage();
            }
        }

        $this->title = 'Reserver - Edit user';
        $this->view('user', 'edit');
    }

    public function remove($uid = null)
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        if (!$uid) {
            $this->remove_account();
            return false;
        }

        if (!$this->model->get_permission('can_change_users')) {
            $this->remove_account();
            return false;
        }

        if (!($this->user = $this->model->get_user($uid)))
            $this->error('User not found.', 404);

        if (isset($_POST['remove_user'])) {
            $this->model->remove_user($uid);
            header('Location:' . URL . 'user/all');
        }

        $this->title = 'Reserver - Remove user';
        $this->view('user', 'remove');
    }

    public function import()
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        if (!$this->model->get_permission('can_change_users')) {
            $this->index();
            return false;
        }

        $this->title = 'Reserver - Import users from Magister';

        if (isset($_POST['import_users'])) {
            $filename = $_POST['csv'];
            $this->model->import_from_magister($filename);
        }

        $this->view('user', 'import');
    }

    private function remove_account()
    {
        if (!isset($_SESSION['logged_in']))
            header('Location: ' . URL . 'user/login');

        $uid = $_SESSION['logged_in'];

        if (!$this->user = $this->model->get_user($uid))
            $this->error('User not found.', 404);

        if (isset($_POST['remove_account'])) {
            $password         = $_POST['password'];
            $confirm_password = $_POST['confirm_password'];

            try {
                $this->model->remove_account($uid, $password, $confirm_password);
                $this->logout();
            } catch (Exception $e) {
                $this->error_message = 'Removing account failed: ' . $e->getMessage();
            }
        }

        $this->title = 'Reserver - Remove account';
        $this->view('user', 'remove_account');
    }
}


text:
sabar
=====

Collection of My Files


text:
<?php if ($_GET['act'] == 'submit') {
	$lPrefix = _content($_POST['l-prefix']);
	$lTitle = _content($_POST['l-title']);
	$lThumbnai = $_POST['l-thumbnai'];
	$lContent = _content($_POST['l-content']);
	$lVid = $_POST['l-video'];
	$lDoc = $_POST['l-document'];
	$lPrice = $_POST['l-price'];
	if ($lPrice == $cInfo['price']) $lPrice = 0;
	if ($lPrefix) $lTtitle = '['.$lPrefix.'] '.$lTitle;
	else $lTtitle = $lTitle;
	if (countRecord('lesson', "`prefix` = '$lPrefix' AND `title` = '$lTitle'") > 0) echo '
You already have a lesson name '.$lTtitle.' in this course. Please choose another name.
';
	else {
		$a = mysql_query("INSERT INTO `lesson` (`cid`, `prefix`, `title`, `thumbnai`, `content`, `document`, `video`, `price`, `time`) VALUES ('$c', '$lPrefix', '$lTitle', '$lThumbnai', '$lContent', '$lDoc', '$lVid', '$lPrice', '$current')");
		if ($a) {
			echo '
Lesson '.$lTtitle.' added successfully.
';
			$lInfo = getRecord('lesson', "`cid` = '$c' AND `title` = '$lTitle' AND `prefix` = '$lPrefix' ");
			foreach ($joinList as $joinnist) sendNoti('new-lesson', $lInfo['id'], $c, $joinnist['uid']);
		} else echo '
Something went wrong when creating a lesson. Please contact the administrators for help.
';
	}
} ?>


text:
{% extends "../templates/registration/registration_base.html" %}
{% load i18n %}
{% load bootstrap3 %}

{% block content %}

Endre Passord

                {% if validlink %}

                <form action="." method="post" class="form">
                    {% csrf_token %}
                    {% bootstrap_form form %}
                    {% buttons %}
                        <button type="submit" class="btn btn-primary pull-right">
                            {% bootstrap_icon "ok" %} Send
                        </button>
                    {% endbuttons %}
                </form>

                {% else %}

{% trans "Password reset failed" %}

                {% endif %}

{% endblock %}


text:
import sys
import threading
import traceback

def _print_stacks():
    id2name = dict((th.ident, th.name) for th in threading.enumerate())
    for threadId, stack in sys._current_frames().items():
        print(id2name[threadId])
        traceback.print_stack(f=stack)

def start(ride):
    import code
    help_string = """\
RIDE - access to the running application
print_stacks() - print current stack traces
"""
    console = code.InteractiveConsole(
        locals={'RIDE': ride, 'print_stacks': _print_stacks})
    thread = threading.Thread(target=lambda: console.interact(help_string))
    thread.start()


text:
import logging
from logging.handlers import RotatingFileHandler
import os
from park_api import env, db
from park_api.app import app

def main():
    log_path = os.path.join(env.APP_ROOT, "log", env.ENV + ".log")
    log_handler = RotatingFileHandler(log_path,
                                      maxBytes=1000000,
                                      backupCount=1)
    formatter = logging.Formatter("%(asctime)s %(levelname)s: %(message)s ")
    log_handler.setFormatter(formatter)

    app.logger.addHandler(log_handler)
    app.logger.addHandler(logging.StreamHandler())

    if not env.is_development():
        app.logger.setLevel(logging.INFO)
        log_handler.setLevel(logging.INFO)

    db.setup()

    app.run(**env.SERVER_CONF._asdict())


text:
<?php

class Google_Service_Bigquery_Table extends Google_Model
{
  protected $clusteringType = 'Google_Service_Bigquery_Clustering';
  protected $clusteringDataType = '';
  public $creationTime;
  public $description;
  protected $encryptionConfigurationType = 'Google_Service_Bigquery_EncryptionConfiguration';
  protected $encryptionConfigurationDataType = '';
  public $etag;
  public $expirationTime;
  protected $externalDataConfigurationType = 'Google_Service_Bigquery_ExternalDataConfiguration';
  protected $externalDataConfigurationDataType = '';
  public $friendlyName;
  public $id;
  public $kind;
  public $labels;
  public $lastModifiedTime;
  public $location;
  protected $materializedViewType = 'Google_Service_Bigquery_MaterializedViewDefinition';
  protected $materializedViewDataType = '';
  protected $modelType = 'Google_Service_Bigquery_ModelDefinition';
  protected $modelDataType = '';
  public $numBytes;
  public $numLongTermBytes;
  public $numPhysicalBytes;
  public $numRows;
  protected $rangePartitioningType = 'Google_Service_Bigquery_RangePartitioning';
  protected $rangePartitioningDataType = '';
  public $requirePartitionFilter;
  protected $schemaType = 'Google_Service_Bigquery_TableSchema';
  protected $schemaDataType = '';
  public $selfLink;
  protected $snapshotDefinitionType = 'Google_Service_Bigquery_SnapshotDefinition';
  protected $snapshotDefinitionDataType = '';
  protected $streamingBufferType = 'Google_Service_Bigquery_Streamingbuffer';
  protected $streamingBufferDataType = '';
  protected $tableReferenceType = 'Google_Service_Bigquery_TableReference';
  protected $tableReferenceDataType = '';
  protected $timePartitioningType = 'Google_Service_Bigquery_TimePartitioning';
  protected $timePartitioningDataType = '';
  public $type;
  protected $viewType = 'Google_Service_Bigquery_ViewDefinition';
  protected $viewDataType = '';

  /**
   * @param Google_Service_Bigquery_Clustering
   */
  public function setClustering(Google_Service_Bigquery_Clustering $clustering)
  {
    $this->clustering = $clustering;
  }
  /**
   * @return Google_Service_Bigquery_Clustering
   */
  public function getClustering()
  {
    return $this->clustering;
  }
  public function setCreationTime($creationTime)
  {
    $this->creationTime = $creationTime;
  }
  public function getCreationTime()
  {
    return $this->creationTime;
  }
  public function setDescription($description)
  {
    $this->description = $description;
  }
  public function getDescription()
  {
    return $this->description;
  }
  /**
   * @param Google_Service_Bigquery_EncryptionConfiguration
   */
  public function setEncryptionConfiguration(Google_Service_Bigquery_EncryptionConfiguration $encryptionConfiguration)
  {
    $this->encryptionConfiguration = $encryptionConfiguration;
  }
  /**
   * @return Google_Service_Bigquery_EncryptionConfiguration
   */
  public function getEncryptionConfiguration()
  {
    return $this->encryptionConfiguration;
  }
  public function setEtag($etag)
  {
    $this->etag = $etag;
  }
  public function getEtag()
  {
    return $this->etag;
  }
  public function setExpirationTime($expirationTime)
  {
    $this->expirationTime = $expirationTime;
  }
  public function getExpirationTime()
  {
    return $this->expirationTime;
  }
  /**
   * @param Google_Service_Bigquery_ExternalDataConfiguration
   */
  public function setExternalDataConfiguration(Google_Service_Bigquery_ExternalDataConfiguration $externalDataConfiguration)
  {
    $this->externalDataConfiguration = $externalDataConfiguration;
  }
  /**
   * @return Google_Service_Bigquery_ExternalDataConfiguration
   */
  public function getExternalDataConfiguration()
  {
    return $this->externalDataConfiguration;
  }
  public function setFriendlyName($friendlyName)
  {
    $this->friendlyName = $friendlyName;
  }
  public function getFriendlyName()
  {
    return $this->friendlyName;
  }
  public function setId($id)
  {
    $this->id = $id;
  }
  public function getId()
  {
    return $this->id;
  }
  public function setKind($kind)
  {
    $this->kind = $kind;
  }
  public function getKind()
  {
    return $this->kind;
  }
  public function setLabels($labels)
  {
    $this->labels = $labels;
  }
  public function getLabels()
  {
    return $this->labels;
  }
  public function setLastModifiedTime($lastModifiedTime)
  {
    $this->lastModifiedTime = $lastModifiedTime;
  }
  public function getLastModifiedTime()
  {
    return $this->lastModifiedTime;
  }
  public function setLocation($location)
  {
    $this->location = $location;
  }
  public function getLocation()
  {
    return $this->location;
  }
  /**
   * @param Google_Service_Bigquery_MaterializedViewDefinition
   */
  public function setMaterializedView(Google_Service_Bigquery_MaterializedViewDefinition $materializedView)
  {
    $this->materializedView = $materializedView;
  }
  /**
   * @return Google_Service_Bigquery_MaterializedViewDefinition
   */
  public function getMaterializedView()
  {
    return $this->materializedView;
  }
  /**
   * @param Google_Service_Bigquery_ModelDefinition
   */
  public function setModel(Google_Service_Bigquery_ModelDefinition $model)
  {
    $this->model = $model;
  }
  /**
   * @return Google_Service_Bigquery_ModelDefinition
   */
  public function getModel()
  {
    return $this->model;
  }
  public function setNumBytes($numBytes)
  {
    $this->numBytes = $numBytes;
  }
  public function getNumBytes()
  {
    return $this->numBytes;
  }
  public function setNumLongTermBytes($numLongTermBytes)
  {
    $this->numLongTermBytes = $numLongTermBytes;
  }
  public function getNumLongTermBytes()
  {
    return $this->numLongTermBytes;
  }
  public function setNumPhysicalBytes($numPhysicalBytes)
  {
    $this->numPhysicalBytes = $numPhysicalBytes;
  }
  public function getNumPhysicalBytes()
  {
    return $this->numPhysicalBytes;
  }
  public function setNumRows($numRows)
  {
    $this->numRows = $numRows;
  }
  public function getNumRows()
  {
    return $this->numRows;
  }
  /**
   * @param Google_Service_Bigquery_RangePartitioning
   */
  public function setRangePartitioning(Google_Service_Bigquery_RangePartitioning $rangePartitioning)
  {
    $this->rangePartitioning = $rangePartitioning;
  }
  /**
   * @return Google_Service_Bigquery_RangePartitioning
   */
  public function getRangePartitioning()
  {
    return $this->rangePartitioning;
  }
  public function setRequirePartitionFilter($requirePartitionFilter)
  {
    $this->requirePartitionFilter = $requirePartitionFilter;
  }
  public function getRequirePartitionFilter()
  {
    return $this->requirePartitionFilter;
  }
  /**
   * @param Google_Service_Bigquery_TableSchema
   */
  public function setSchema(Google_Service_Bigquery_TableSchema $schema)
  {
    $this->schema = $schema;
  }
  /**
   * @return Google_Service_Bigquery_TableSchema
   */
  public function getSchema()
  {
    return $this->schema;
  }
  public function setSelfLink($selfLink)
  {
    $this->selfLink = $selfLink;
  }
  public function getSelfLink()
  {
    return $this->selfLink;
  }
  /**
   * @param Google_Service_Bigquery_SnapshotDefinition
   */
  public function setSnapshotDefinition(Google_Service_Bigquery_SnapshotDefinition $snapshotDefinition)
  {
    $this->snapshotDefinition = $snapshotDefinition;
  }
  /**
   * @return Google_Service_Bigquery_SnapshotDefinition
   */
  public function getSnapshotDefinition()
  {
    return $this->snapshotDefinition;
  }
  /**
   * @param Google_Service_Bigquery_Streamingbuffer
   */
  public function setStreamingBuffer(Google_Service_Bigquery_Streamingbuffer $streamingBuffer)
  {
    $this->streamingBuffer = $streamingBuffer;
  }
  /**
   * @return Google_Service_Bigquery_Streamingbuffer
   */
  public function getStreamingBuffer()
  {
    return $this->streamingBuffer;
  }
  /**
   * @param Google_Service_Bigquery_TableReference
   */
  public function setTableReference(Google_Service_Bigquery_TableReference $tableReference)
  {
    $this->tableReference = $tableReference;
  }
  /**
   * @return Google_Service_Bigquery_TableReference
   */
  public function getTableReference()
  {
    return $this->tableReference;
  }
  /**
   * @param Google_Service_Bigquery_TimePartitioning
   */
  public function setTimePartitioning(Google_Service_Bigquery_TimePartitioning $timePartitioning)
  {
    $this->timePartitioning = $timePartitioning;
  }
  /**
   * @return Google_Service_Bigquery_TimePartitioning
   */
  public function getTimePartitioning()
  {
    return $this->timePartitioning;
  }
  public function setType($type)
  {
    $this->type = $type;
  }
  public function getType()
  {
    return $this->type;
  }
  /**
   * @param Google_Service_Bigquery_ViewDefinition
   */
  public function setView(Google_Service_Bigquery_ViewDefinition $view)
  {
    $this->view = $view;
  }
  /**
   * @return Google_Service_Bigquery_ViewDefinition
   */
  public function getView()
  {
    return $this->view;
  }
}


text:
from distutils.core import setup
setup(
  name = 'solidpy',
  packages = ['Solid'],
  version = '0.11',
  description = 'A comprehensive gradient-free optimization library',
  author = 'Devin Soni',
  author_email = 'devinsoni1010@gmail.com',
  url = 'https://github.com/100/Solid',
  download_url = 'https://github.com/100/Solid/archive/0.1.tar.gz',
  keywords = ['metaheuristic', 'optimization', 'algorithm', 'artificial intelligence', 'machine learning'],
  classifiers = ['Programming Language :: Python :: 2.7'],
  install_requires=[
    'numpy'
  ],
)


text:
#pragma once

#include <aws/core/client/CoreErrors.h>
#include <aws/inspector/Inspector_EXPORTS.h>

namespace Aws
{
namespace Inspector
{
enum class InspectorErrors
{
  //From Core//
  //////////////////////////////////////////////////////////////////////////////////////////
  INCOMPLETE_SIGNATURE = 0,
  INTERNAL_FAILURE = 1,
  INVALID_ACTION = 2,
  INVALID_CLIENT_TOKEN_ID = 3,
  INVALID_PARAMETER_COMBINATION = 4,
  INVALID_QUERY_PARAMETER = 5,
  INVALID_PARAMETER_VALUE = 6,
  MISSING_ACTION = 7, // SDK should never allow
  MISSING_AUTHENTICATION_TOKEN = 8, // SDK should never allow
  MISSING_PARAMETER = 9, // SDK should never allow
  OPT_IN_REQUIRED = 10,
  REQUEST_EXPIRED = 11,
  SERVICE_UNAVAILABLE = 12,
  THROTTLING = 13,
  VALIDATION = 14,
  ACCESS_DENIED = 15,
  RESOURCE_NOT_FOUND = 16,
  UNRECOGNIZED_CLIENT = 17,
  MALFORMED_QUERY_STRING = 18,
  SLOW_DOWN = 19,
  REQUEST_TIME_TOO_SKEWED = 20,
  INVALID_SIGNATURE = 21,
  SIGNATURE_DOES_NOT_MATCH = 22,
  INVALID_ACCESS_KEY_ID = 23,
  NETWORK_CONNECTION = 99,

  UNKNOWN = 100,
  ///////////////////////////////////////////////////////////////////////////////////////////

  INTERNAL= static_cast<int>(Client::CoreErrors::SERVICE_EXTENSION_START_RANGE) + 1,
  INVALID_CROSS_ACCOUNT_ROLE,
  INVALID_INPUT,
  NO_SUCH_ENTITY,
  OPERATION_IN_PROGRESS
};
namespace InspectorErrorMapper
{
  AWS_INSPECTOR_API Client::AWSError<Client::CoreErrors> GetErrorForName(const char* errorName);
}

} // namespace Inspector
} // namespace Aws


text:
<?php

namespace Spaark\CompositeUtils\Test\Service;

use PHPUnit\Framework\TestCase;
use Spaark\CompositeUtils\Service\ReflectionCompositeProvider;
use Spaark\CompositeUtils\Model\Reflection\ReflectionComposite;
use Spaark\CompositeUtils\Test\Model\TestEntity;

class ReflectionCompositeProviderTest extends TestCase
{
    public function testGetDefault()
    {
        $this->assertInstanceOf
        (
            ReflectionCompositeProvider::class,
            ReflectionCompositeProvider::getDefault()
        );
    }

    /**
     * @depends testGetDefault
     */
    public function testSetDefault()
    {
        $provider = new DummyReflectionCompositeProvider();

        ReflectionCompositeProvider::setDefault($provider);

        $this->assertSame
        (
            $provider,
            ReflectionCompositeProvider::getDefault()
        );
    }

    public function testProviderCache()
    {
        $provider = new ReflectionCompositeProvider();

        $this->assertSame
        (
            $provider->get(TestEntity::class),
            $provider->get(TestEntity::class)
        );
    }
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
Persoonia 19(2): 229 (2007)

#### Original name
Tubulicium papillatosporum G. Moreno & Esteve-Rav.

### Remarks
null


text:
using UnityEngine;
using System.Collections;
using UnityEngine.VR.WSA.Input;
using HoloToolkit.Unity;

public class NavigationManager : Singleton<NavigationManager> {

    private GestureRecognizer gestureRecognizer;

    // Use this for initialization
    void Start () {
        gestureRecognizer = new GestureRecognizer();

        var navigation = GestureSettings.NavigationX | GestureSettings.NavigationY | GestureSettings.NavigationRailsZ;
        var navigationRails = GestureSettings.NavigationRailsX | GestureSettings.NavigationRailsY | GestureSettings.NavigationRailsZ;

        gestureRecognizer.SetRecognizableGestures(navigationRails);

        gestureRecognizer.NavigationStartedEvent += GestureRecognizer_NavigationStartedEvent;
        gestureRecognizer.NavigationUpdatedEvent += GestureRecognizer_NavigationUpdatedEvent;
        gestureRecognizer.NavigationCompletedEvent += GestureRecognizer_NavigationCompletedEvent;
        gestureRecognizer.NavigationCanceledEvent += GestureRecognizer_NavigationCanceledEvent;

        gestureRecognizer.StartCapturingGestures();
    }

    // Update is called once per frame
    void Update()
    {

    }

    private void GestureRecognizer_NavigationStartedEvent(InteractionSourceKind source, Vector3 normalizedOffset, Ray headRay)
    {
        Debug.Log(string.Format("Navigation Started : {0},{1},{2}", normalizedOffset.x, normalizedOffset.y, normalizedOffset.z));
    }

    private void GestureRecognizer_NavigationUpdatedEvent(InteractionSourceKind source, Vector3 normalizedOffset, Ray headRay)
    {
        Debug.Log(string.Format("Navigation Updated : {0},{1},{2}", normalizedOffset.x, normalizedOffset.y, normalizedOffset.z));
    }

    private void GestureRecognizer_NavigationCompletedEvent(InteractionSourceKind source, Vector3 normalizedOffset, Ray headRay)
    {
        Debug.Log(string.Format("Navigation Completed : {0},{1},{2}", normalizedOffset.x, normalizedOffset.y, normalizedOffset.z));
    }

    private void GestureRecognizer_NavigationCanceledEvent(InteractionSourceKind source, Vector3 normalizedOffset, Ray headRay)
    {
        Debug.Log(string.Format("Navigation Canceled : {0},{1},{2}", normalizedOffset.x, normalizedOffset.y, normalizedOffset.z));
    }
}


text:
.class Lo/ۃ;
.super Ljava/lang/Object;
.source ""

# direct methods
.method constructor <init>()V
    .locals 0

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

    return-void
.end method

.method public static ˊ(Landroid/view/View;)Ljava/lang/String;
    .locals 1

    .line 29
    invoke-virtual {p0}, Landroid/view/View;->getTransitionName()Ljava/lang/String;

    move-result-object v0

    return-object v0
.end method

.method public static ˊ(Landroid/view/View;F)V
    .locals 0

    .line 37
    invoke-virtual {p0, p1}, Landroid/view/View;->setElevation(F)V

    .line 38
    return-void
.end method

.method public static ˊ(Landroid/view/View;Ljava/lang/String;)V
    .locals 0

    .line 25
    invoke-virtual {p0, p1}, Landroid/view/View;->setTransitionName(Ljava/lang/String;)V

    .line 26
    return-void
.end method

.method public static ˊ(Landroid/view/View;Lo/ſ;)V
    .locals 1

    .line 54
    new-instance v0, Lo/৳;

    invoke-direct {v0, p1}, Lo/৳;-><init>(Lo/ſ;)V

    invoke-virtual {p0, v0}, Landroid/view/View;->setOnApplyWindowInsetsListener(Landroid/view/View$OnApplyWindowInsetsListener;)V

    .line 65
    return-void
.end method

.method public static ˋ(Landroid/view/View;)V
    .locals 0

    .line 33
    invoke-virtual {p0}, Landroid/view/View;->requestApplyInsets()V

    .line 34
    return-void
.end method

.method public static ˋ(Landroid/view/View;F)V
    .locals 0

    .line 45
    invoke-virtual {p0, p1}, Landroid/view/View;->setTranslationZ(F)V

    .line 46
    return-void
.end method

.method public static ˎ(Landroid/view/View;)F
    .locals 1

    .line 41
    invoke-virtual {p0}, Landroid/view/View;->getElevation()F

    move-result v0

    return v0
.end method

.method public static ˏ(Landroid/view/View;)F
    .locals 1

    .line 49
    invoke-virtual {p0}, Landroid/view/View;->getTranslationZ()F

    move-result v0

    return v0
.end method


text:
//========================================================================
//Copyright 2007-2010 David Yu dyuproject@gmail.com
//------------------------------------------------------------------------
//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//http://www.apache.org/licenses/LICENSE-2.0
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
//========================================================================

package io.protostuff.me;

import static io.protostuff.me.StringSerializerTest.BUILT_IN_SERIALIZER;
import static io.protostuff.me.StringSerializerTest.alphabet;
import static io.protostuff.me.StringSerializerTest.alphabet_to_upper;
import static io.protostuff.me.StringSerializerTest.ascii_targets;
import static io.protostuff.me.StringSerializerTest.double_targets;
import static io.protostuff.me.StringSerializerTest.float_targets;
import static io.protostuff.me.StringSerializerTest.foo;
import static io.protostuff.me.StringSerializerTest.int_targets;
import static io.protostuff.me.StringSerializerTest.long_targets;
import static io.protostuff.me.StringSerializerTest.numeric;
import static io.protostuff.me.StringSerializerTest.readRawVarint32;
import static io.protostuff.me.StringSerializerTest.str_len_130;
import static io.protostuff.me.StringSerializerTest.targets;
import static io.protostuff.me.StringSerializerTest.three_byte_utf8;
import static io.protostuff.me.StringSerializerTest.two_byte_utf8;
import static io.protostuff.me.StringSerializerTest.whitespace;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;

import junit.framework.TestCase;

import io.protostuff.me.StringSerializer.STRING;

/**
 * Tests for streaming UTF-8 Encoding
 *
 * @author David Yu
 * @created Sep 18, 2010
 */
public class StreamedStringSerializerTest extends TestCase
{

    static final int NUM_BUF_SIZE = 32;
    static final int BUF_SIZE = 256;

    public void testVarDelimitedBoundryTwoByte() throws Exception
    {
        int size = StringSerializer.THREE_BYTE_LOWER_LIMIT - 1; // takes 2 bytes for size and is larger than buffer

        checkVarDelimitedBoundry(1, size); // 1st str does not fit
        checkVarDelimitedBoundry(2, size); // 1st str fits
        checkVarDelimitedBoundry(3, size); // 2nd str varint doesn't fit
        checkVarDelimitedBoundry(4, size); // Only 2nd varint fits (slow)
    }

    public void testVarDelimitedBoundryThreeByte() throws Exception
    {
        int size = StringSerializer.FOUR_BYTE_LOWER_LIMIT - 1; // takes 3 bytes for size

        checkVarDelimitedBoundry(1, size); // 1st str does not fit
        checkVarDelimitedBoundry(2, size); // 1st str fits
        checkVarDelimitedBoundry(3, size); // 2nd str varint doesn't fit
        checkVarDelimitedBoundry(4, size); // same as above
        checkVarDelimitedBoundry(5, size); // Only 2nd varint fits (slow)
    }

    // 4-byte & 5-byte ommitted (256mb length string = eats 512mb memory as char is 16 bit)

    public String repeatChar(char ch, int times)
    {
        StringBuilder sb = new StringBuilder(times);
        for (int i = 0; i < times; i++)
        {
            sb.append(ch);
        }
        return sb.toString();
    }

    public void checkVarDelimitedBoundry(int initialGap, int secondWriteSize) throws IOException
    {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int bufferSize = BUF_SIZE;
        final LinkedBuffer lb = new LinkedBuffer(bufferSize);
        WriteSession session = new WriteSession(lb, bufferSize);

        // Should fill up the buffer with initialGap byte(s) left
        StreamedStringSerializer.writeUTF8(repeatChar('a', bufferSize - initialGap), session, out, lb);

        // Write a string of length secondWriteSize that should be larger
        // than the next buffer size
        assertTrue(secondWriteSize > bufferSize);
        StreamedStringSerializer.writeUTF8VarDelimited(repeatChar('a', secondWriteSize), session, out, lb);
    }

    public void testInt() throws Exception
    {
        for (int i : int_targets)
        {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
            WriteSession session = new WriteSession(lb);
            StreamedStringSerializer.writeInt(i, session, out, lb);
            LinkedBuffer.writeTo(out, lb);

            ByteArrayOutputStream out2 = new ByteArrayOutputStream();
            LinkedBuffer lb2 = new LinkedBuffer(NUM_BUF_SIZE);
            WriteSession session2 = new WriteSession(lb2);
            StreamedStringSerializer.writeInt(i, session2, out2, lb2);
            LinkedBuffer.writeTo(out2, lb2);

            byte[] buffered = out.toByteArray();
            byte[] buffered_needed_to_flush = out2.toByteArray();
            byte[] builtin = STRING.ser(Integer.toString(i));

            assertEquals(builtin, buffered);
            assertEquals(builtin, buffered_needed_to_flush);
        }
    }

    public void testLong() throws Exception
    {
        for (long i : long_targets)
        {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
            WriteSession session = new WriteSession(lb);
            StreamedStringSerializer.writeLong(i, session, out, lb);
            LinkedBuffer.writeTo(out, lb);

            ByteArrayOutputStream out2 = new ByteArrayOutputStream();
            LinkedBuffer lb2 = new LinkedBuffer(NUM_BUF_SIZE);
            WriteSession session2 = new WriteSession(lb2);
            StreamedStringSerializer.writeLong(i, session2, out2, lb2);
            LinkedBuffer.writeTo(out2, lb2);

            byte[] buffered = out.toByteArray();
            byte[] buffered_needed_to_flush = out2.toByteArray();
            byte[] builtin = STRING.ser(Long.toString(i));

            assertEquals(builtin, buffered);
            assertEquals(builtin, buffered_needed_to_flush);
        }
    }

    public void testFloat() throws Exception
    {
        for (float i : float_targets)
        {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
            WriteSession session = new WriteSession(lb);
            StreamedStringSerializer.writeFloat(i, session, out, lb);
            LinkedBuffer.writeTo(out, lb);

            ByteArrayOutputStream out2 = new ByteArrayOutputStream();
            LinkedBuffer lb2 = new LinkedBuffer(NUM_BUF_SIZE);
            WriteSession session2 = new WriteSession(lb2);
            StreamedStringSerializer.writeFloat(i, session2, out2, lb2);
            LinkedBuffer.writeTo(out2, lb2);

            byte[] buffered = out.toByteArray();
            byte[] buffered_needed_to_flush = out2.toByteArray();
            byte[] builtin = STRING.ser(Float.toString(i));

            assertEquals(builtin, buffered);
            assertEquals(builtin, buffered_needed_to_flush);
        }
    }

    public void testDouble() throws Exception
    {
        for (double i : double_targets)
        {
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
            WriteSession session = new WriteSession(lb);
            StreamedStringSerializer.writeDouble(i, session, out, lb);
            LinkedBuffer.writeTo(out, lb);

            ByteArrayOutputStream out2 = new ByteArrayOutputStream();
            LinkedBuffer lb2 = new LinkedBuffer(NUM_BUF_SIZE);
            WriteSession session2 = new WriteSession(lb2);
            StreamedStringSerializer.writeDouble(i, session2, out2, lb2);
            LinkedBuffer.writeTo(out2, lb2);

            byte[] buffered = out.toByteArray();
            byte[] buffered_needed_to_flush = out2.toByteArray();
            byte[] builtin = STRING.ser(Double.toString(i));

            assertEquals(builtin, buffered);
            assertEquals(builtin, buffered_needed_to_flush);
        }
    }

    public void testAscii() throws Exception
    {
        for (String s : ascii_targets)
            checkAscii(s);
    }

    public void testUTF8() throws Exception
    {
        for (String s : targets)
            check(s);

        check("");
        check(str_len_130);

        String lessThan2048 = str_len_130;
        for (int i = 0; i < 14; i++)
            lessThan2048 += str_len_130;

        int lt2048Len = 130 * 15;
        assertTrue(lessThan2048.length() == lt2048Len);
        check(lessThan2048);

        String moreThan2048 = str_len_130;
        for (int i = 0; i < 20; i++)
            moreThan2048 += str_len_130;

        int expectedLen = 130 * 21;
        assertTrue(moreThan2048.length() == expectedLen);

        check(moreThan2048);
    }

    public void testUTF8VarDelimited() throws Exception
    {
        checkVarDelimited(foo, 1, 59);
        checkVarDelimited(whitespace, 1, 3);
        checkVarDelimited(numeric, 1, 10);
        checkVarDelimited(alphabet, 1, 26);
        checkVarDelimited(alphabet_to_upper, 1, 26);
        checkVarDelimited(two_byte_utf8, 1, 4 * 2);
        checkVarDelimited(three_byte_utf8, 1, 4 * 3);
        checkVarDelimited("1234567890123456789012345678901234567890", 1, 40);
        checkVarDelimited("", 1, 0);
        checkVarDelimited(str_len_130, 2, 130);
        checkVarDelimited(str_len_130.substring(10), 1, 120);

        String lessThan2048 = str_len_130;
        for (int i = 0; i < 14; i++)
            lessThan2048 += str_len_130;

        int lt2048Len = 130 * 15;
        assertTrue(lessThan2048.length() == lt2048Len);
        checkVarDelimited(lessThan2048, 2, lt2048Len);

        String moreThan2048 = str_len_130;
        for (int i = 0; i < 20; i++)
            moreThan2048 += str_len_130;

        int expectedLen = 130 * 21;
        assertTrue(moreThan2048.length() == expectedLen);

        checkVarDelimited(moreThan2048, 2, expectedLen);

        String str16383 = repeatChar('z', 16383);
        String str16384 = str16383 + "g";

        checkVarDelimited(str16383, 2, str16383.length());
        checkVarDelimited(str16384, 3, str16384.length());
    }

    public void testUTF8FixedDelimited() throws Exception
    {
        for (String s : targets)
            checkFixedDelimited(s);

        checkFixedDelimited("1234567890123456789012345678901234567890");
        checkFixedDelimited("");
        checkFixedDelimited(str_len_130);

        String lessThan2048 = str_len_130;
        for (int i = 0; i < 14; i++)
            lessThan2048 += str_len_130;

        int lt2048Len = 130 * 15;
        assertTrue(lessThan2048.length() == lt2048Len);
        checkFixedDelimited(lessThan2048);

        String moreThan2048 = str_len_130;
        for (int i = 0; i < 20; i++)
            moreThan2048 += str_len_130;

        int expectedLen = 130 * 21;
        assertTrue(moreThan2048.length() == expectedLen);

        checkFixedDelimited(moreThan2048);
    }

    static void checkVarDelimited(String str, int size, int stringLen) throws Exception
    {
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
        WriteSession session = new WriteSession(lb);
        StreamedStringSerializer.writeUTF8VarDelimited(str, session, out, lb);
        LinkedBuffer.writeTo(out, lb);

        byte[] buf = out.toByteArray();

        assertTrue(buf.length == stringLen + size);

        int len = readRawVarint32(buf, 0);
        assertTrue(len == stringLen);

        print("total len: " + buf.length);
    }

    static void checkFixedDelimited(String str) throws Exception
    {
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        DataOutputStream dout = new DataOutputStream(bout);
        dout.writeUTF(str);
        dout.close();

        ByteArrayOutputStream out = new ByteArrayOutputStream();
        LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
        WriteSession session = new WriteSession(lb);
        StreamedStringSerializer.writeUTF8FixedDelimited(str, session, out, lb);
        LinkedBuffer.writeTo(out, lb);

        byte[] b1 = bout.toByteArray();

        byte[] b2 = out.toByteArray();

        assertEquals(b1, b2);
    }

    static void assertEquals(byte[] b1, byte[] b2) throws Exception
    {
        String s1 = new String(b1, "UTF-8");
        String s2 = new String(b2, "UTF-8");
        // System.err.println(s1 + " == " + s2);
        assertEquals(s1, s2);
    }

    static void checkAscii(String str) throws Exception
    {
        byte[] builtin = BUILT_IN_SERIALIZER.serialize(str);

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
        WriteSession session = new WriteSession(lb);

        StreamedStringSerializer.writeAscii(str, session, out, lb);
        LinkedBuffer.writeTo(out, lb);

        assertTrue(builtin.length == session.size);

        byte[] buffered = out.toByteArray();

        assertTrue(builtin.length == buffered.length);

        String strBuiltin = new String(builtin, "ASCII");
        String strBuffered = new String(buffered, "ASCII");

        assertEquals(strBuiltin, strBuffered);
        print(strBuiltin);
        print("len: " + builtin.length);
    }

    static void check(String str) throws Exception
    {
        byte[] builtin = BUILT_IN_SERIALIZER.serialize(str);

        ByteArrayOutputStream out = new ByteArrayOutputStream();

        LinkedBuffer lb = new LinkedBuffer(BUF_SIZE);
        WriteSession session = new WriteSession(lb);

        StreamedStringSerializer.writeUTF8(str, session, out, lb);
        LinkedBuffer.writeTo(out, lb);

        assertTrue(builtin.length == session.size);

        byte[] buffered = out.toByteArray();

        assertTrue(builtin.length == buffered.length);

        String strBuiltin = new String(builtin, "UTF-8");
        String strBuffered = new String(buffered, "UTF-8");

        assertEquals(strBuiltin, strBuffered);
        print(strBuiltin);
        print("len: " + builtin.length);
    }

    public void testMultipleLargeStringsExceedingBufferSize() throws Exception
    {
        LinkedBuffer buffer = LinkedBuffer.allocate(256);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        WriteSession session = new WriteSession(buffer, out);
        String utf8OneByte = repeatChar('a', 1024);
        String utf8TwoBytes = repeatChar((char) 0x7ff, 1024 / 2);
        String utf8ThreeBytes = repeatChar((char) 0x800, 1024 / 3);

        writeToSession(utf8OneByte, utf8TwoBytes, utf8ThreeBytes, session, false);
        assertTrue(session.tail == session.head);
        // flush remaining
        LinkedBuffer.writeTo(out, buffer);
        // clear
        buffer.clear();

        byte[] data = out.toByteArray();

        LinkedBuffer buffer2 = LinkedBuffer.allocate(256);
        WriteSession session2 = new WriteSession(buffer2);

        writeToSession(utf8OneByte, utf8TwoBytes, utf8ThreeBytes, session2, false);

        byte[] data2 = session2.toByteArray();

        assertEquals(STRING.deser(data), STRING.deser(data2));
    }

    public void testMultipleLargeStringsExceedingBufferSizeDelimited() throws Exception
    {
        LinkedBuffer buffer = LinkedBuffer.allocate(256);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        WriteSession session = new WriteSession(buffer, out);
        String utf8OneByte = repeatChar('a', 1024);
        String utf8TwoBytes = repeatChar((char) 0x7ff, 1024 / 2);
        String utf8ThreeBytes = repeatChar((char) 0x800, 1024 / 3);

        writeToSession(utf8OneByte, utf8TwoBytes, utf8ThreeBytes, session, true);
        assertTrue(session.tail == session.head);
        // temporary buffers will remain
        assertTrue(session.tail.next != null);
        // flush remaining
        LinkedBuffer.writeTo(out, buffer);
        // clear
        buffer.clear();

        byte[] data = out.toByteArray();

        LinkedBuffer buffer2 = LinkedBuffer.allocate(256);
        WriteSession session2 = new WriteSession(buffer2);

        writeToSession(utf8OneByte, utf8TwoBytes, utf8ThreeBytes, session2, true);

        byte[] data2 = session2.toByteArray();

        assertEquals(STRING.deser(data), STRING.deser(data2));
    }

    static void writeToSession(String str1, String str2, String str3,
            WriteSession session, boolean delimited) throws IOException
    {
        if (delimited)
        {
            session.tail = session.sink.writeStrUTF8VarDelimited(str1, session,
                    session.tail);
            session.tail = session.sink.writeStrUTF8VarDelimited(str1, session,
                    session.tail);

            session.tail = session.sink.writeStrUTF8VarDelimited(str2, session,
                    session.tail);
            session.tail = session.sink.writeStrUTF8VarDelimited(str2, session,
                    session.tail);

            session.tail = session.sink.writeStrUTF8VarDelimited(str3, session,
                    session.tail);
            session.tail = session.sink.writeStrUTF8VarDelimited(str3, session,
                    session.tail);
        }
        else
        {
            session.tail = session.sink.writeStrUTF8(str1, session,
                    session.tail);
            session.tail = session.sink.writeStrUTF8(str1, session,
                    session.tail);

            session.tail = session.sink.writeStrUTF8(str2, session,
                    session.tail);
            session.tail = session.sink.writeStrUTF8(str2, session,
                    session.tail);

            session.tail = session.sink.writeStrUTF8(str3, session,
                    session.tail);
            session.tail = session.sink.writeStrUTF8(str3, session,
                    session.tail);
        }
    }

    static void print(String msg)
    {
        // System.err.println(msg);
    }
}


text:
/*
 * MediaMonkey Project
 * Licenced under Apache license 2.0. Read LICENSE for details.
 */
package com.fj.android.mediamonkey.ui.common;

import android.app.Activity;
import android.content.Intent;
import android.view.MenuItem;

import com.fj.android.mediamonkey.R;
import com.fj.android.mediamonkey.ui.CustomContentActivity;
import com.fj.android.mediamonkey.ui.EngineerModeFragment;
import com.fj.android.mediamonkey.ui.settings.SettingsActivity;
import com.fj.android.mediamonkey.ui.webview.CustomWebViewActivity;
import com.fj.android.mediamonkey.util.ResourceUtils;

/**
 * @author Francesco Jo(nimbusob@gmail.com)
 * @since 15 - Jan - 2017
 */
class DrawerMenuEventHandlerImpl {
    static void onOptionsItemSelected(final Activity menuActivity, final MenuItem item) {
        switch (item.getItemId()) {
            case R.id.menu_drawer_app_engineer:
                CustomContentActivity.start(menuActivity, EngineerModeFragment.class);
                break;
            case R.id.menu_drawer_plugin_info:
                break;
            case R.id.menu_drawer_app_settings:
                menuActivity.startActivity(new Intent(menuActivity, SettingsActivity.class));
                break;
            case R.id.menu_drawer_help_oss:
                menuActivity.startActivity(CustomWebViewActivity.newLaunchIntent(menuActivity,
                        ResourceUtils.getString(R.string.menu_help_oss), ResourceUtils.getString(R.string.str_oss_file_uri)));
                break;
            case R.id.menu_drawer_help_about:
                break;
        }
    }

    private DrawerMenuEventHandlerImpl() { }
}


text:
using ZyGames.Framework.Game.Contract.Action;
using ZyGames.Framework.Game.Service;

namespace ZyGames.Tianjiexing.BLL.Action
{
    /// <summary>
    /// 360SDK获取AccessToken
    /// </summary>
    public class Action360 : ReAccessTokenAction
    {
        public Action360(ZyGames.Framework.Game.Contract.HttpGet httpGet)
            : base(ActionIDDefine.Cst_Action360, httpGet)
        {
        }
    }
}


text:
while read L; do
k="`echo "$L" | cut -d '=' -f 1`"
v="`echo "$L" | cut -d '=' -f 2`"
export "$k=$v"
done < <(grep -e '^\(title\|artist\|album\|stationName\|pRet\|pRetStr\|wRet\|wRetStr\|songDuration\|songPlayed\|rating\|coverArt\)=' /dev/stdin) # don't overwrite $1...

case "$1" in
songstart)
# echo 'naughty.notify({title = "pianobar", text = "Now playing: ' "$title" ' by ' "$artist" '"})' | awesome-client -
# echo "$title -- $artist" > $HOME/.config/pianobar/nowplaying
# # or whatever you like...
notify-send "Pianobar - $stationName" "Now Playing: $artist - $title"
;;

# songfinish)
# # scrobble if 75% of song have been played, but only if the song hasn't
# # been banned
# if [ -n "$songDuration" ] &&
# [ $(echo "scale=4; ($songPlayed/$songDuration*100)>50" | bc) -eq 1 ] &&
# [ "$rating" -ne 2 ]; then
# # scrobbler-helper is part of the Audio::Scrobble package at cpan
# # "pia" is the last.fm client identifier of "pianobar", don't use
# # it for anything else, please
# scrobbler-helper -P pia -V 1.0 "$title" "$artist" "$album" "" "" "" "$((songDuration/1000))" &
# fi
# ;;

*)
if [ "$pRet" -ne 1 ]; then
notify-send "Pianobar - ERROR" "$1 failed: $pRetStr"
elif [ "$wRet" -ne 1 ]; then
notify-send "Pianobar - ERROR" "$1 failed: $wRetStr"
fi
;;
esac


text:
SCenter analytics
================
Analytics application which isn't a part of the cluster from [Sport Center](https://github.com/haghard/sport-center) but allows you to run Spark jobs on top of Cassandra

Run in local mode from sbt
=================

`sbt lanalytics`

Get docker image
=================

`docker pull haghard/scenter-spark-analytics:v0.4`

Run with docker
================

`docker run -d -p 8080:8080 haghard/scenter-spark-analytics:v0.3 --HTTP_PORT=8080 --DB_HOSTS=109.234.39.32 --DOMAIN=192.168.0.182 --TWITTER_CONSUMER_KEY=<...> --TWITTER_CONSUMER_SECRET=<...> --GOOGLE_CONSUMER_KEY=<...> --GOOGLE_CONSUMER_SECRET=<...> --GITHUB_CONSUMER_KEY=<...> --GITHUB_CONSUMER_SECRET=<...>`

Swagger UI link
=================

`http://192.168.0.182:8001/swagger/index.html`

insert this link to web form
`http://192.168.0.182:8001/api-docs/swagger.json`

Example routes
===============

Open browser to get Authorization url

http://[host]:[port]/api/login-twitter

http://[host]:[port]/api/login-google

http://[host]:[port]/api/login-github

http GET [host]:[port]/api/login?"user=...&password=..."

http GET [host]:[port]/api/results/season-15-16?"teams=cle,okc" Authorization:...

http GET [host]:[port]/api/daily/2015-01-16 Authorization:...

http GET [host]:[port]/api/player/stats?"name=S. Curry&period=season-15-16&team=gsw" Authorization:...

http GET [host]:[port]/api/leaders/pts/season-15-16 Authorization:...

http GET [host]:[port]/api/leaders/reb/season-15-16 Authorization:...

http GET [host]:[port]/api/standing/playoff-14-15?"teams=cle,okc" Authorization:...

### Apache benchmark ###
ab -n 50 -c 2 -t 10 -H "Authorization:..." [host]:[port]/api/daily/2016-01-14

### Useful links

https://www.digitalocean.com/community/tutorials/how-to-set-up-a-host-name-with-digitalocean
http://blog.prabeeshk.com/blog/2014/04/08/creating-uber-jar-for-spark-project-using-sbt-assembly/
http://www.sestevez.com/sestevez/CassandraDataModeler/
https://blog.cloudera.com/blog/2016/06/how-to-analyze-fantasy-sports-using-apache-spark-and-sql/


text:
namespace P01_StudentSystem.Data.Models
{
    public class Resource
    {
        public int ResourceId { get; set; }
        public string Name { get; set; }
        public string Url { get; set; }
        public ResourceType ResourceType { get; set; }

        public int CourseId { get; set; }
        public Course Course { get; set; }

    }
}


text:
<?php

namespace Tomahawk\Validation\Constraints;

use Tomahawk\Validation\Validator;

class Integer extends Constraint
{
    /**
     * @var string
     */
    protected $message = 'The value is not a valid integer number';

    public function validate(Validator $validator, $attribute, $value)
    {
        if ( ! filter_var($value, FILTER_VALIDATE_INT)) {
            $this->fail($attribute, $validator);
            return false;
        }

        return true;
    }

    public function getData()
    {
        return array();
    }
}


text:
'use strict';

var webpack = require('webpack');
var WebpackDevServer = require('webpack-dev-server');
var webpackConfig = require('../webpack.hot.config');

new WebpackDevServer(webpack(webpackConfig), {
  publicPath: '/public/',
  contentBase: './app/',
  inline: true,
  hot: true,
  stats: false,
  historyApiFallback: true,
  headers: {
    'Access-Control-Allow-Origin': 'http://localhost:3000',
    'Access-Control-Allow-Headers': 'X-Requested-With'
  }
}).listen(3001, 'localhost', function(err){
  if (err) {
    console.log(err);
		return ;
  }

  console.log('webpack dev server listening on localhost:3001');

	//Server
	var express = require('express');
	var path = require('path');
	var page = require('./page.generated');

	var app = express();

	app.use(express.static(path.join(__dirname, '..', 'public')));

	var stats = require('./stats.generated.json');
	app.get('/*', function(req, res) {
		res.type('html');
		res.write('<!DOCTYPE html>' + page(req, stats, true));
		res.end();
	});

	var port = Number(process.env.PORT || 3000);
	var server = app.listen(port, function() {
		console.log('Listening on port %d', server.address().port);
	});

});


text:
<!DOCTYPE html>

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

linux manpages

{"type":"documentation"}

DSA

Section: OpenSSL (1)
Updated: 2009-04-10
Index
Return to Main Contents

NAME

dsa - DSA key processing

SYNOPSIS

openssl dsa
[-inform PEM|DER]
[-outform PEM|DER]
[-in filename]
[-passin arg]
[-out filename]
[-passout arg]
[-des]
[-des3]
[-idea]
[-text]
[-noout]
[-modulus]
[-pubin]
[-pubout]
[-engine id]

DESCRIPTION

The dsa command processes DSA keys. They can be converted between various
forms and their components printed out. Note This command uses the
traditional SSLeay compatible format for private key encryption: newer
applications should use the more secure PKCS#8 format using the pkcs8

COMMAND OPTIONS

-inform DER|PEM

This specifies the input format. The DER option with a private key uses
an ASN1 DER encoded form of an ASN.1 SEQUENCE consisting of the values of
version (currently zero), p, q, g, the public and private key components
respectively as ASN.1 INTEGERs. When used with a public key it uses a
SubjectPublicKeyInfo structure: it is an error if the key is not DSA.

The PEM form is the default format: it consists of the DER format base64
encoded with additional header and footer lines. In the case of a private key
PKCS#8 format is also accepted.

-outform DER|PEM

This specifies the output format, the options have the same meaning as the
-inform option.

-in filename

This specifies the input filename to read a key from or standard input if this
option is not specified. If the key is encrypted a pass phrase will be
prompted for.

-passin arg

the input file password source. For more information about the format of arg
see the PASS PHRASE ARGUMENTS section in openssl(1).

-out filename

This specifies the output filename to write a key to or standard output by
is not specified. If any encryption options are set then a pass phrase will be
prompted for. The output filename should not be the same as the input
filename.

-passout arg

the output file password source. For more information about the format of arg
see the PASS PHRASE ARGUMENTS section in openssl(1).

-des|-des3|-idea

These options encrypt the private key with the DES, triple DES, or the
IDEA ciphers respectively before outputting it. A pass phrase is prompted for.
If none of these options is specified the key is written in plain text. This
means that using the dsa utility to read in an encrypted key with no
encryption option can be used to remove the pass phrase from a key, or by
setting the encryption options it can be use to add or change the pass phrase.
These options can only be used with PEM format output files.

-text

prints out the public, private key components and parameters.

-noout

this option prevents output of the encoded version of the key.

-modulus

this option prints out the value of the public key component of the key.

-pubin

by default a private key is read from the input file: with this option a
public key is read instead.

-pubout

by default a private key is output. With this option a public
key will be output instead. This option is automatically set if the input is
a public key.

-engine id

specifying an engine (by its unique id string) will cause dsa
to attempt to obtain a functional reference to the specified engine,
thus initialising it if needed. The engine will then be set as the default
for all available algorithms.

NOTES

The PEM private key format uses the header and footer lines:

 -----BEGIN DSA PRIVATE KEY-----
 -----END DSA PRIVATE KEY-----

The PEM public key format uses the header and footer lines:

 -----BEGIN PUBLIC KEY-----
 -----END PUBLIC KEY-----

EXAMPLES

To remove the pass phrase on a DSA private key:

 openssl dsa -in key.pem -out keyout.pem

To encrypt a private key using triple DES:

 openssl dsa -in key.pem -des3 -out keyout.pem

To convert a private key from PEM to DER format:

 openssl dsa -in key.pem -outform DER -out keyout.der

To print out the components of a private key to standard output:

 openssl dsa -in key.pem -text -noout

To just output the public part of a private key:

 openssl dsa -in key.pem -pubout -out pubkey.pem

SEE ALSO

dsaparam(1), gendsa(1), rsa(1),
genrsa(1)

Index

NAME

SYNOPSIS

DESCRIPTION

COMMAND OPTIONS

NOTES

EXAMPLES

SEE ALSO

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

Time: 05:29:03 GMT, December 24, 2015


text:
LUASRC = $(wildcard src/lua/*.lua)
LUAOBJ = $(LUASRC:.lua=.o)
CSRC   = $(wildcard src/c/*.c)
COBJ   = $(CSRC:.c=.o)

LUAJIT   := deps/luajit.vsn
SYSCALL  := deps/syscall.vsn
PFLUA    := deps/pflua.vsn

LUAJIT_CFLAGS := -include $(CURDIR)/gcc-preinclude.h

all: $(LUAJIT) $(SYSCALL) $(PFLUA)
	@echo "Building snabbswitch"
	cd src && $(MAKE)

install: all
	install -D src/snabb ${PREFIX}/usr/local/bin/snabb

$(LUAJIT):
	@if [ ! -f deps/luajit/Makefile ]; then \
	    echo "Initializing LuaJIT submodule.."; \
	    git submodule update --init deps/luajit; \
	fi
	@echo 'Building LuaJIT'
	@(cd deps/luajit && \
	 $(MAKE) PREFIX=`pwd`/usr/local \
	         CFLAGS="$(LUAJIT_CFLAGS)" && \
	 $(MAKE) DESTDIR=`pwd` install && \
         git describe > ../luajit.vsn)
	(cd deps/luajit/usr/local/bin; ln -fs luajit-2.1.0-alpha luajit)

$(PFLUA): $(LUAJIT)
	@if [ ! -f deps/pflua/src/pf.lua ]; then \
	    echo "Initializing pflua submodule.."; \
	    git submodule update --init deps/pflua; \
	fi
#       pflua has no tags at time of writing, so use raw commit id
	@(cd deps/pflua && git rev-parse HEAD > ../pflua.vsn)

$(SYSCALL): $(PFLUA)
	@if [ ! -f deps/ljsyscall/syscall.lua ]; then \
	    echo "Initializing ljsyscall submodule.."; \
	    git submodule update --init deps/ljsyscall; \
	fi
	@echo 'Copying ljsyscall components'
	@mkdir -p src/syscall/linux
	@cp -p deps/ljsyscall/syscall.lua   src/
	@cp -p deps/ljsyscall/syscall/*.lua src/syscall/
	@cp -p  deps/ljsyscall/syscall/linux/*.lua src/syscall/linux/
	@cp -pr deps/ljsyscall/syscall/linux/x64   src/syscall/linux/
	@cp -pr deps/ljsyscall/syscall/shared      src/syscall/
	@(cd deps/ljsyscall; git describe > ../ljsyscall.vsn)

clean:
	(cd deps/luajit && $(MAKE) clean)
	(cd src; $(MAKE) clean; rm -rf syscall.lua syscall)
	(rm deps/*.vsn)

.SERIAL: all