text:
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf import symbol_database as _symbol_database
from google.protobuf import descriptor_pb2
# @@protoc_insertion_point(imports)

_sym_db = _symbol_database.Default()

from pogoprotos.data.badge import awarded_gym_badge_pb2 as pogoprotos_dot_data_dot_badge_dot_awarded__gym__badge__pb2
from pogoprotos.data.gym import gym_defender_pb2 as pogoprotos_dot_data_dot_gym_dot_gym__defender__pb2

DESCRIPTOR = _descriptor.FileDescriptor(
  name='pogoprotos/networking/responses/get_gym_badge_details_response.proto',
  package='pogoprotos.networking.responses',
  syntax='proto3',
  serialized_pb=_b('\nDpogoprotos/networking/responses/get_gym_badge_details_response.proto\x12\x1fpogoprotos.networking.responses\x1a-pogoprotos/data/badge/awarded_gym_badge.proto\x1a&pogoprotos/data/gym/gym_defender.proto\"\xa0\x01\n\x1aGetGymBadgeDetailsResponse\x12\x39\n\tgym_badge\x18\x01 \x01(\x0b\x32&.pogoprotos.data.badge.AwardedGymBadge\x12\x36\n\x0cgym_defender\x18\x02 \x01(\x0b\x32 .pogoprotos.data.gym.GymDefender\x12\x0f\n\x07success\x18\x03 \x01(\x08\x62\x06proto3')
  ,
  dependencies=[pogoprotos_dot_data_dot_badge_dot_awarded__gym__badge__pb2.DESCRIPTOR,pogoprotos_dot_data_dot_gym_dot_gym__defender__pb2.DESCRIPTOR,])
_sym_db.RegisterFileDescriptor(DESCRIPTOR)

_GETGYMBADGEDETAILSRESPONSE = _descriptor.Descriptor(
  name='GetGymBadgeDetailsResponse',
  full_name='pogoprotos.networking.responses.GetGymBadgeDetailsResponse',
  filename=None,
  file=DESCRIPTOR,
  containing_type=None,
  fields=[
    _descriptor.FieldDescriptor(
      name='gym_badge', full_name='pogoprotos.networking.responses.GetGymBadgeDetailsResponse.gym_badge', index=0,
      number=1, type=11, cpp_type=10, label=1,
      has_default_value=False, default_value=None,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
      name='gym_defender', full_name='pogoprotos.networking.responses.GetGymBadgeDetailsResponse.gym_defender', index=1,
      number=2, type=11, cpp_type=10, label=1,
      has_default_value=False, default_value=None,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
    _descriptor.FieldDescriptor(
      name='success', full_name='pogoprotos.networking.responses.GetGymBadgeDetailsResponse.success', index=2,
      number=3, type=8, cpp_type=7, label=1,
      has_default_value=False, default_value=False,
      message_type=None, enum_type=None, containing_type=None,
      is_extension=False, extension_scope=None,
      options=None),
  ],
  extensions=[
  ],
  nested_types=[],
  enum_types=[
  ],
  options=None,
  is_extendable=False,
  syntax='proto3',
  extension_ranges=[],
  oneofs=[
  ],
  serialized_start=193,
  serialized_end=353,
)

_GETGYMBADGEDETAILSRESPONSE.fields_by_name['gym_badge'].message_type = pogoprotos_dot_data_dot_badge_dot_awarded__gym__badge__pb2._AWARDEDGYMBADGE
_GETGYMBADGEDETAILSRESPONSE.fields_by_name['gym_defender'].message_type = pogoprotos_dot_data_dot_gym_dot_gym__defender__pb2._GYMDEFENDER
DESCRIPTOR.message_types_by_name['GetGymBadgeDetailsResponse'] = _GETGYMBADGEDETAILSRESPONSE

GetGymBadgeDetailsResponse = _reflection.GeneratedProtocolMessageType('GetGymBadgeDetailsResponse', (_message.Message,), dict(
  DESCRIPTOR = _GETGYMBADGEDETAILSRESPONSE,
  __module__ = 'pogoprotos.networking.responses.get_gym_badge_details_response_pb2'
  # @@protoc_insertion_point(class_scope:pogoprotos.networking.responses.GetGymBadgeDetailsResponse)
  ))
_sym_db.RegisterMessage(GetGymBadgeDetailsResponse)

# @@protoc_insertion_point(module_scope)


text:
require 'ostruct'

describe "OpenStruct#initialize" do
  it "is private" do
    OpenStruct.should have_private_instance_method(:initialize)
  end
end

redpajama_set_name: RedPajamaGithub


text:
(function ($, pubsub, data, elements) {
    var download = function () {
        var d = window.glimpse.data.currentData();
        //var j = JSON.stringify(d);
        var dt = new Date();
        var dts = dt.toJSON().replace('.', '_').replace(/-/g,'').replace(/:/g,'');
        var name = "glimpsedata_"+dts+".json";
        console.log("Store data on server to file "+name);
        var htmlUrl = window.glimpse.data.currentMetadata().resources.glimpse_telerikdataaccess_plugin_resource_htmlresource;
        $.ajax({
            // the URL for the request
            url: htmlUrl,

            // the data to send (will be converted to a query string)
            data: {
                sub: 'store',
                requestId: d.requestId,
                name: name
            },

            // whether this is a POST or GET request
            type: "GET",

            // the type of data we expect back
            dataType: "text",

            // code to run if the request succeeds;
            // the response is passed to the function
            success: function (text) {
                text = text.replace("{name}", name);
                alert(text);
            },

            // code to run if the request fails; the raw request and
            // status codes are passed to the function
            error: function (xhr, status, errorThrown) {
                alert("There was a problem storing the data: "+errorThrown+" Status="+status);
            },

            // code to run regardless of success or failure
            complete: function (xhr, status) {
                pubsub.publish("trigger.tab.select.glimpse_dataaccess", { key: 'glimpse_dataaccess' });
            }
        });
    };
    pubsub.subscribe("trigger.tab.select.download", download);
    var requestData = data.currentData();

    var old = elements.tabHolder().find('.glimpse-tabitem-ajax').first().parent();
    var myNewElement = $('
Download
');
    myNewElement.appendTo(old);

})(jQueryGlimpse, glimpse.pubsub, glimpse.data, glimpse.elements);


text:
var TR = {
  // background
  backgroundTitle: 'バックグラウンド',
  backgroundReset: 'リセット',
  backgroundImport: 'インポート  (jpg, png...)',
  backgroundFill: null,

  // camera
  cameraTitle: 'カメラ',
  cameraReset: 'View',
  cameraCenter: null,
  cameraFront: null,
  cameraLeft: null,
  cameraTop: null,
  cameraMode: 'モード',
  cameraOrbit: null,
  cameraSpherical: '球体 (Trackball)',
  cameraPlane: '平面 (Trackball)',
  cameraProjection: 'タイプ',
  cameraPerspective: '透視投影',
  cameraOrthographic: '平行投影',
  cameraFov: '視野',
  cameraPivot: 'ピボット選択',

  // file
  fileTitle: 'ファイル (インポート/エクスポート)',
  fileImportTitle: null,
  fileAdd: 'Add (obj, sgl, ply, stl)',
  fileAutoMatrix: null,
  fileVertexSRGB: null,
  fileExportSceneTitle: null,
  fileExportAll: null,
  fileExportSGL: null,
  fileExportOBJ: null,
  fileExportPLY: null,
  fileExportSTL: null,

  fileExportTextureTitle: null,
  fileExportTextureSize: null,
  fileExportColor: null,
  fileExportRoughness: null,
  fileExportMetalness: null,

  // scene
  sceneTitle: null,
  sceneReset: null,
  sceneAddSphere: null,
  sceneAddCube: null,
  sceneAddCylinder: null,
  sceneAddTorus: null,
  sceneSelection: null,
  sceneMerge: null,
  sceneDuplicate: null,

  // mesh
  meshTitle: 'メッシュ',
  meshNbVertices: null,
  meshNbFaces: null,

  // topology
  topologyTitle: null,

  // multires
  multiresTitle: null,
  multiresSubdivide: null,
  multiresReverse: null,
  multiresResolution: null,
  multiresNoLower: null,
  multiresNoHigher: null,
  multiresDelHigher: null,
  multiresDelLower: null,
  multiresSelectLowest: null,
  multiresSelectHighest: null,
  multiresWarnBigMesh: null,
  //
  //
  //
  multiresNotReversible: null,
  //

  // remesh
  remeshTitle: null,
  remeshRemesh: null,
  remeshResolution: null,
  remeshBlock: null,

  // dynamic
  dynamicTitle: null,
  dynamicActivated: null,
  dynamicSubdivision: null,
  dynamicDecimation: null,
  dynamicLinear: null,

  // sculpt
  sculptTitle: null,
  sculptBrush: 'ブラシ',
  sculptInflate: '膨張',
  sculptTwist: '回転',
  sculptSmooth: 'スムーズ化 (-Shift)',
  sculptFlatten: 'フラット化',
  sculptPinch: 'つまむ',
  sculptCrease: 'しわ',
  sculptDrag: 'ドラッグ',
  sculptPaint: 'ペイント',
  sculptMasking: null,
  sculptMove: null,
  sculptLocalScale: null,
  sculptTransform: null,

  sculptCommon: null,
  sculptTool: 'ツール',
  sculptSymmetry: '対称加工',
  sculptContinuous: '連続加工',
  sculptRadius: '半径 (-X)',
  sculptIntensity: '明るさ (-C)',
  sculptHardness: null,
  sculptCulling: null,
  sculptAlphaTitle: null,
  sculptLockPositon: null,
  sculptAlphaTex: null,
  sculptImportAlpha: null,
  sculptNegative: 'ネガティブ (N or -Alt)',
  sculptColor: null,
  sculptRoughness: null,
  sculptMetallic: null,
  sculptClay: 'クレイ',
  sculptAccumulate: null,
  sculptColorGlobal: null,
  sculptPickColor: null,
  sculptTangentialSmoothing: null,
  sculptTopologicalCheck: null,
  sculptMoveAlongNormal: null,
  sculptMaskingClear: null,
  sculptMaskingInvert: null,
  sculptMaskingBlur: null,
  sculptMaskingSharpen: null,
  sculptPBRTitle: null,
  sculptPaintAll: null,
  sculptExtractTitle: null,
  sculptExtractThickness: null,
  sculptExtractAction: null,

  // states
  stateTitle: '履歴',
  stateUndo: 'アンドゥ',
  stateRedo: 'リドゥ',
  stateMaxStack: null,

  // pressure
  pressureTitle: 'ワコムタブレット',
  pressureRadius: '圧力半径?',
  pressureIntensity: '圧力の強さ?',

  // rendering
  renderingTitle: null,
  renderingGrid: null,
  renderingSymmetryLine: null,
  renderingMatcap: null,
  renderingCurvature: null,
  renderingPBR: null,
  renderingTransparency: '透過',
  renderingNormal: 'ノーマル',
  renderingUV: null,
  renderingShader: 'シェーダー',
  renderingMaterial: null,
  renderingImportUV: null,
  renderingImportMatcap: null,
  renderingExtra: null,
  renderingFlat: 'フラットシェーディング',
  renderingWireframe: 'ワイヤーフレーム (W)',
  renderingExposure: null,
  renderingEnvironment: null,
  renderingIsolate: null,
  renderingFilmic: null,

  // contour
  contour: null,
  contourShow: null,
  contourColor: null,
  darkenUnselected: null,

  // pixel ratio
  resolution: null,

  // matcaps
  matcapPearl: null,
  matcapClay: 'クレイ',
  matcapSkin: 'スキン',
  matcapGreen: null,
  matcapWhite: null,

  // sketchfab
  sketchfabTitle: 'Sketchfabへ移動',
  sketchfabUpload: 'アップロード',
  sketchfabUploadMessage: null,
  //

  sketchfabUploadError: null,
  //

  sketchfabUploadSuccess: null,
  sketchfabAbort: null,
  sketchfabUploadProcessing: null,

  about: null,

  alphaNone: null,
  alphaSquare: null,
  alphaSkin: null
};

export default TR;


text:
using System;
using System.Dynamic;
using System.Collections.Generic;
using System.IO;

namespace JsonConfig
{
	public class ConfigObject : DynamicObject, IDictionary<string, object>
	{
		internal Dictionary<string, object> members = new Dictionary<string, object> ();
		public static ConfigObject FromExpando (object e)
		{
			var edict = e as IDictionary<string, object>;
			var c = new ConfigObject ();
			var cdict = (IDictionary<string, object>) c;

			// this is not complete. It will, however work for JsonFX ExpandoObjects
			// which consits only of primitive types, ExpandoObject or ExpandoObject []
			// but won't work for generic ExpandoObjects which might include collections etc.
			foreach (var kvp in edict) {
				// recursively convert and add ExpandoObjects
				if (kvp.Value is ExpandoObject) {
					cdict.Add (kvp.Key, FromExpando ((ExpandoObject) kvp.Value));
				}
				else if (kvp.Value is ExpandoObject[]) {
					var config_objects = new List<ConfigObject> ();
					foreach (var ex in ((ExpandoObject[]) kvp.Value)) {
						config_objects.Add (FromExpando (ex));
					}
					cdict.Add (kvp.Key, config_objects.ToArray ());
				}
				else
					cdict.Add (kvp.Key, kvp.Value);
			}
			return c;
		}
		public override bool TryGetMember (GetMemberBinder binder, out object result)
		{
			if (members.ContainsKey (binder.Name))
				result = members[binder.Name];
			else
				result = new NullExceptionPreventer ();

			return true;
		}
		public override bool TrySetMember (SetMemberBinder binder, object value)
		{
			if (this.members.ContainsKey (binder.Name))
				this.members[binder.Name] = value;
			else
				this.members.Add (binder.Name, value);
			return true;
		}
		public override bool TryInvokeMember (InvokeMemberBinder binder, object[] args, out object result)
		{
			// some special methods that should be in our dynamic object
			if (binder.Name == "ApplyJsonFromFile" && args.Length == 1 && args[0] is string) {
				result = Config.ApplyJsonFromFileInfo (new FileInfo ((string) args[0]), this);
				return true;
			}
			if (binder.Name == "ApplyJsonFromFile" && args.Length == 1 && args[0] is FileInfo) {
				result = Config.ApplyJsonFromFileInfo ((FileInfo) args[0], this);
				return true;
			}
			if (binder.Name == "Clone") {
				result = this.Clone ();
				return true;
			}
			if (binder.Name == "Exists" && args.Length == 1 && args[0] is string) {
				result = members.ContainsKey ((string) args[0]);
				return true;
			}

			// no other methods availabe, error
			result = null;
			return false;

		}
		public override string ToString ()
		{
			//var w = new JsonFx.Json.JsonWriter ();
			//return w.Write (this.members);
            return JsonFx.Json.JsonWriter.Serialize(this.members);
		}
		public void ApplyJson (string json)
		{
			ConfigObject result = Config.ApplyJson (json, this);
			// replace myself's members with the new ones
			this.members = result.members;
		}
		public static implicit operator ConfigObject (ExpandoObject exp)
		{
			return ConfigObject.FromExpando (exp);
		}
		#region IEnumerable implementation
		public System.Collections.IEnumerator GetEnumerator ()
		{
			return members.GetEnumerator();
		}
		#endregion

		#region IEnumerable implementation
		IEnumerator<KeyValuePair<string, object>> IEnumerable<KeyValuePair<string, object>>.GetEnumerator ()
		{
			return members.GetEnumerator ();
		}
		#endregion

		#region ICollection implementation
		public void Add (KeyValuePair<string, object> item)
		{
			members.Add (item.Key, item.Value);
		}

		public void Clear ()
		{
			members.Clear ();
		}

		public bool Contains (KeyValuePair<string, object> item)
		{
			return members.ContainsKey (item.Key) && members[item.Key] == item.Value;
		}

		public void CopyTo (KeyValuePair<string, object>[] array, int arrayIndex)
		{
			throw new NotImplementedException ();
		}

		public bool Remove (KeyValuePair<string, object> item)
		{
			throw new System.NotImplementedException ();
		}

		public int Count {
			get {
				return members.Count;
			}
		}

		public bool IsReadOnly {
			get {
				throw new System.NotImplementedException ();
			}
		}
		#endregion

		#region IDictionary implementation
		public void Add (string key, object value)
		{
			members.Add (key, value);
		}

		public bool ContainsKey (string key)
		{
			return members.ContainsKey (key);
		}

		public bool Remove (string key)
		{
			return members.Remove (key);
		}

		public object this[string key] {
			get {
				return members[key];
			}
			set {
				members[key] = value;
			}
		}

		public ICollection<string> Keys {
			get {
				return members.Keys;
			}
		}

		public ICollection<object> Values {
			get {
				return members.Values;
			}
		}
		public bool TryGetValue (string key, out object value)
		{
			return members.TryGetValue (key, out value);
		}

		#region ICloneable implementation

		object Clone ()
		{
			return Merger.Merge (new ConfigObject (), this);
		}

		#endregion
		#endregion

		#region casts
		public static implicit operator bool (ConfigObject c)
		{
			// we want to test for a member:
			// if (config.SomeMember) { ... }
			//
			// instead of:
			// if (config.SomeMember != null) { ... }

			// we return always true, because a NullExceptionPreventer is returned when member
			// does not exist
			return true;
		}
		#endregion
	}

	/// <summary>
	/// Null exception preventer. This allows for hassle-free usage of configuration values that are not
	/// defined in the config file. I.e. we can do Config.Scope.This.Field.Does.Not.Exist.Ever, and it will
	/// not throw an NullPointer exception, but return te NullExceptionPreventer object instead.
	///
	/// The NullExceptionPreventer can be cast to everything, and will then return default/empty value of
	/// that datatype.
	/// </summary>
	public class NullExceptionPreventer : DynamicObject
	{
		// all member access to a NullExceptionPreventer will return a new NullExceptionPreventer
		// this allows for infinite nesting levels: var s = Obj1.foo.bar.bla.blubb; is perfectly valid
		public override bool TryGetMember (GetMemberBinder binder, out object result)
		{
			result = new NullExceptionPreventer ();
			return true;
		}
		// Add all kinds of datatypes we can cast it to, and return default values
		// cast to string will be null
		public static implicit operator string (NullExceptionPreventer nep)
		{
			return null;
		}
		public override string ToString ()
		{
			return null;
		}
		public static implicit operator string[] (NullExceptionPreventer nep)
		{
			return new string[] { };
		}
		// cast to bool will always be false
		public static implicit operator bool (NullExceptionPreventer nep)
		{
			return false;
		}
		public static implicit operator bool[] (NullExceptionPreventer nep)
		{
			return new bool[] { };
		}
		public static implicit operator int[] (NullExceptionPreventer nep)
		{
			return new int[] { };
		}
		public static implicit operator long[] (NullExceptionPreventer nep)
		{
			return new long[] { };
		}
		public static implicit operator int (NullExceptionPreventer nep)
		{
			return 0;
		}
		public static implicit operator long (NullExceptionPreventer nep)
		{
			return 0;
		}
		// nullable types always return null
		public static implicit operator bool? (NullExceptionPreventer nep)
		{
			return null;
		}
		public static implicit operator int? (NullExceptionPreventer nep)
		{
			return null;
		}
		public static implicit operator long? (NullExceptionPreventer nep)
		{
			return null;
		}
	}
}


text:
Storage.prototype.setObject = function (key, value) {
    this.setItem(key, JSON.stringify(value));
};

Storage.prototype.getObject = function (key) {
    var value = this.getItem(key);
    return value && JSON.parse(value);
};

(function (w, d) {
    'use strict';
    function $(s) {
        return d.querySelector(s);
    }

    var select = w.select = function () {
        this.focus();
        this.select();
    };

    if (!localStorage && document.cookie.length == 0) {
        document.cookie = "x={}";
    }

    var c = function () {
        return JSON.parse(document.cookie.toString().substr(2));
    };

    function renderShortened(url, origUrl) {
        var div = d.createElement("div");
        div.className = "success";
        div.innerHTML = "<input type=\"text\" readonly class=\"short-url\" title=\"" + url + "\" value=\"" + url + "\" onclick=\"select()\" /> - sends to - <input type=\"text\" class=\"short-url\" readonly title=\"" + origUrl + "\" value=\"" + origUrl + "\" onclick=\"select()\" /> ";
        return div;
    }

    var storage = {
        put: function (key, value) {
            if (localStorage) {
                return localStorage.setObject(key, value);
            }
            var x = c();
            x[key] = value;
            document.cookie = "x=" + JSON.stringify(x);
        },
        get: function (key) {
            return localStorage ? localStorage.getObject(key) : c()[key];
        }
    };

    var shortened = $("#shortened")
        , url = $("#input-url")
        , oneTime = $("#check-one-time")
        , anon = $("#check-remove-referrer")
        , gobtn = $("#btn-shorten")
        , form = $("#form-shorten")
        , arr = storage.get("shortened")
        , xhr = Xhr;

    if (arr) {
        for (var i = arr.length - 1; i >= 0; i--) {
            shortened.appendChild(renderShortened(arr[i][0], arr[i][1]));
        }
    } else arr = [];

    gobtn.innerHTML = gobtn.getAttribute("data-default");

    $(".btn-clear").onclick = function () {
        arr.length = 0;
        storage.put("shortened", arr);
        while (shortened.firstChild) {
            shortened.removeChild(shortened.firstChild);
        }
    };

    gobtn.onclick = form.onsubmit = function (e) {
        e.preventDefault();
        var req = xhr();
        req.open("POST", "/api/create/", true);
        req.responseType = "json";
        req.onreadystatechange = function () {
            if (req.readyState != 4) return;
            if (req.status != 200 && req.status != 304) {
                return;
            }
            gobtn.removeAttribute("disabled");
            gobtn.className = "";
            gobtn.innerHTML = gobtn.getAttribute("data-default");
            url.value = "";
            var data = req.response;
            if (!data.error) {
                arr.push([data.url, data.originalUrl]);
                storage.put("shortened", arr);
                shortened.insertBefore(renderShortened(data.url, data.originalUrl), shortened.firstChild);
            } else {
                alert("Error! Original url is %1. Error code - %2"
                    .replace("%1", data.originalUrl)
                    .replace("%2", data.error))
            }
        };
        if (req.readyState == 4) return;
        if (url.value.indexOf("://") < 0) {
            url.value = "http://" + url.value;
        }
        gobtn.className = "loading";
        gobtn.setAttribute("disabled", "");
        gobtn.innerHTML = gobtn.getAttribute("data-loading");
        req.send(JSON.stringify({
            url: url.value.trim(),
            expiry: oneTime.checked ? Date.now() : undefined,
            anonymize: anon.checked
        }));
    };
})(window, document);


text:
cask "font-im-fell-double-pica-sc" do
  version :latest
  sha256 :no_check

  url "https://github.com/google/fonts/raw/main/ofl/imfelldoublepicasc/IMFeDPsc28P.ttf",
      verified: "github.com/google/fonts/"
  name "IM Fell Double Pica SC"
  homepage "https://fonts.google.com/specimen/IM+Fell+Double+Pica+SC"

  font "IMFeDPsc28P.ttf"
end


text:
#include "main/core.h"
#include "glsl_symbol_table.h"
#include "glsl_parser_extras.h"
#include "ir.h"
#include "program.h"
#include "program/hash_table.h"
#include "linker.h"

static ir_function_signature *
find_matching_signature(const char *name, const exec_list *actual_parameters,
			gl_shader **shader_list, unsigned num_shaders,
			bool use_builtin);

namespace {

class call_link_visitor : public ir_hierarchical_visitor {
public:
   call_link_visitor(gl_shader_program *prog, gl_shader *linked,
		     gl_shader **shader_list, unsigned num_shaders)
   {
      this->prog = prog;
      this->shader_list = shader_list;
      this->num_shaders = num_shaders;
      this->success = true;
      this->linked = linked;

      this->locals = hash_table_ctor(0, hash_table_pointer_hash,
				     hash_table_pointer_compare);
   }

   ~call_link_visitor()
   {
      hash_table_dtor(this->locals);
   }

   virtual ir_visitor_status visit(ir_variable *ir)
   {
      hash_table_insert(locals, ir, ir);
      return visit_continue;
   }

   virtual ir_visitor_status visit_enter(ir_call *ir)
   {
      /* If ir is an ir_call from a function that was imported from another
       * shader callee will point to an ir_function_signature in the original
       * shader.  In this case the function signature MUST NOT BE MODIFIED.
       * Doing so will modify the original shader.  This may prevent that
       * shader from being linkable in other programs.
       */
      const ir_function_signature *const callee = ir->callee;
      assert(callee != NULL);
      const char *const name = callee->function_name();

      /* Determine if the requested function signature already exists in the
       * final linked shader.  If it does, use it as the target of the call.
       */
      ir_function_signature *sig =
	 find_matching_signature(name, &callee->parameters, &linked, 1,
				 ir->use_builtin);
      if (sig != NULL) {
	 ir->callee = sig;
	 return visit_continue;
      }

      /* Try to find the signature in one of the other shaders that is being
       * linked.  If it's not found there, return an error.
       */
      sig = find_matching_signature(name, &ir->actual_parameters, shader_list,
				    num_shaders, ir->use_builtin);
      if (sig == NULL) {
	 /* FINISHME: Log the full signature of unresolved function.
	  */
	 linker_error(this->prog, "unresolved reference to function `%s'\n",
		      name);
	 this->success = false;
	 return visit_stop;
      }

      /* Find the prototype information in the linked shader.  Generate any
       * details that may be missing.
       */
      ir_function *f = linked->symbols->get_function(name);
      if (f == NULL) {
	 f = new(linked) ir_function(name);

	 /* Add the new function to the linked IR.  Put it at the end
          * so that it comes after any global variable declarations
          * that it refers to.
	  */
	 linked->symbols->add_function(f);
	 linked->ir->push_tail(f);
      }

      ir_function_signature *linked_sig =
	 f->exact_matching_signature(NULL, &callee->parameters);
      if ((linked_sig == NULL)
	  || ((linked_sig != NULL)
	      && (linked_sig->is_builtin() != ir->use_builtin))) {
	 linked_sig = new(linked) ir_function_signature(callee->return_type, callee->precision);
	 f->add_signature(linked_sig);
      }

      /* At this point linked_sig and called may be the same.  If ir is an
       * ir_call from linked then linked_sig and callee will be
       * ir_function_signatures that have no definitions (is_defined is false).
       */
      assert(!linked_sig->is_defined);
      assert(linked_sig->body.is_empty());

      /* Create an in-place clone of the function definition.  This multistep
       * process introduces some complexity here, but it has some advantages.
       * The parameter list and the and function body are cloned separately.
       * The clone of the parameter list is used to prime the hashtable used
       * to replace variable references in the cloned body.
       *
       * The big advantage is that the ir_function_signature does not change.
       * This means that we don't have to process the rest of the IR tree to
       * patch ir_call nodes.  In addition, there is no way to remove or
       * replace signature stored in a function.  One could easily be added,
       * but this avoids the need.
       */
      struct hash_table *ht = hash_table_ctor(0, hash_table_pointer_hash,
					      hash_table_pointer_compare);
      exec_list formal_parameters;
      foreach_in_list(const ir_instruction, original, &sig->parameters) {
	 assert(const_cast<ir_instruction *>(original)->as_variable());

	 ir_instruction *copy = original->clone(linked, ht);
	 formal_parameters.push_tail(copy);
      }

      linked_sig->replace_parameters(&formal_parameters);

      linked_sig->is_intrinsic = sig->is_intrinsic;

      if (sig->is_defined) {
         foreach_in_list(const ir_instruction, original, &sig->body) {
            ir_instruction *copy = original->clone(linked, ht);
            linked_sig->body.push_tail(copy);
         }

         linked_sig->is_defined = true;
      }

      hash_table_dtor(ht);

      /* Patch references inside the function to things outside the function
       * (i.e., function calls and global variables).
       */
      linked_sig->accept(this);

      ir->callee = linked_sig;

      return visit_continue;
   }

   virtual ir_visitor_status visit_leave(ir_call *ir)
   {
      /* Traverse list of function parameters, and for array parameters
       * propagate max_array_access. Otherwise arrays that are only referenced
       * from inside functions via function parameters will be incorrectly
       * optimized. This will lead to incorrect code being generated (or worse).
       * Do it when leaving the node so the children would propagate their
       * array accesses first.
       */

      const exec_node *formal_param_node = ir->callee->parameters.get_head();
      if (formal_param_node) {
         const exec_node *actual_param_node = ir->actual_parameters.get_head();
         while (!actual_param_node->is_tail_sentinel()) {
            ir_variable *formal_param = (ir_variable *) formal_param_node;
            ir_rvalue *actual_param = (ir_rvalue *) actual_param_node;

            formal_param_node = formal_param_node->get_next();
            actual_param_node = actual_param_node->get_next();

            if (formal_param->type->is_array()) {
               ir_dereference_variable *deref = actual_param->as_dereference_variable();
               if (deref && deref->var && deref->var->type->is_array()) {
                  deref->var->data.max_array_access =
                     MAX2(formal_param->data.max_array_access,
                         deref->var->data.max_array_access);
               }
            }
         }
      }
      return visit_continue;
   }

   virtual ir_visitor_status visit(ir_dereference_variable *ir)
   {
      if (hash_table_find(locals, ir->var) == NULL) {
	 /* The non-function variable must be a global, so try to find the
	  * variable in the shader's symbol table.  If the variable is not
	  * found, then it's a global that *MUST* be defined in the original
	  * shader.
	  */
	 ir_variable *var = linked->symbols->get_variable(ir->var->name);
	 if (var == NULL) {
	    /* Clone the ir_variable that the dereference already has and add
	     * it to the linked shader.
	     */
	    var = ir->var->clone(linked, NULL);
	    linked->symbols->add_variable(var);
	    linked->ir->push_head(var);
	 } else {
            if (var->type->is_array()) {
               /* It is possible to have a global array declared in multiple
                * shaders without a size.  The array is implicitly sized by
                * the maximal access to it in *any* shader.  Because of this,
                * we need to track the maximal access to the array as linking
                * pulls more functions in that access the array.
                */
               var->data.max_array_access =
                  MAX2(var->data.max_array_access,
                       ir->var->data.max_array_access);

               if (var->type->length == 0 && ir->var->type->length != 0)
                  var->type = ir->var->type;
            }
            if (var->is_interface_instance()) {
               /* Similarly, we need implicit sizes of arrays within interface
                * blocks to be sized by the maximal access in *any* shader.
                */
               unsigned *const linked_max_ifc_array_access =
                  var->get_max_ifc_array_access();
               unsigned *const ir_max_ifc_array_access =
                  ir->var->get_max_ifc_array_access();

               assert(linked_max_ifc_array_access != NULL);
               assert(ir_max_ifc_array_access != NULL);

               for (unsigned i = 0; i < var->get_interface_type()->length;
                    i++) {
                  linked_max_ifc_array_access[i] =
                     MAX2(linked_max_ifc_array_access[i],
                          ir_max_ifc_array_access[i]);
               }
            }
	 }

	 ir->var = var;
      }

      return visit_continue;
   }

   /** Was function linking successful? */
   bool success;

private:
   /**
    * Shader program being linked
    *
    * This is only used for logging error messages.
    */
   gl_shader_program *prog;

   /** List of shaders available for linking. */
   gl_shader **shader_list;

   /** Number of shaders available for linking. */
   unsigned num_shaders;

   /**
    * Final linked shader
    *
    * This is used two ways.  It is used to find global variables in the
    * linked shader that are accessed by the function.  It is also used to add
    * global variables from the shader where the function originated.
    */
   gl_shader *linked;

   /**
    * Table of variables local to the function.
    */
   hash_table *locals;
};

} /* anonymous namespace */

/**
 * Searches a list of shaders for a particular function definition
 */
ir_function_signature *
find_matching_signature(const char *name, const exec_list *actual_parameters,
			gl_shader **shader_list, unsigned num_shaders,
			bool use_builtin)
{
   for (unsigned i = 0; i < num_shaders; i++) {
      ir_function *const f = shader_list[i]->symbols->get_function(name);

      if (f == NULL)
	 continue;

      ir_function_signature *sig =
         f->matching_signature(NULL, actual_parameters, use_builtin);

      if ((sig == NULL) ||
          (!sig->is_defined && !sig->is_intrinsic))
	 continue;

      /* If this function expects to bind to a built-in function and the
       * signature that we found isn't a built-in, keep looking.  Also keep
       * looking if we expect a non-built-in but found a built-in.
       */
      if (use_builtin != sig->is_builtin())
	    continue;

      return sig;
   }

   return NULL;
}

bool
link_function_calls(gl_shader_program *prog, gl_shader *main,
		    gl_shader **shader_list, unsigned num_shaders)
{
   call_link_visitor v(prog, main, shader_list, num_shaders);

   v.run(main->ir);
   return v.success;
}


text:
package skabele.screenshare.actors

import WsId._
import WsData._
import InternalMessage._

trait ChatActor extends WsActor {

  override def preStart(): Unit = {
    context.system.eventStream.subscribe(self, classOf[ChatPublished])
    super.preStart()
  }

  def receiveChat: Receive = {
    case WsMessage(SEND_CHAT, SendChat(text)) =>
      context.system.eventStream.publish(ChatPublished(self, name, text))

    case ChatPublished(_, _name, text) =>
      socket ! WsMessage(CHAT_MSG, ChatMsg(_name, text))
  }
}


text:
import Constants from '../constants/constants';

const GoalSource = {
  post: function (data) {
    return $.ajax({
        method: "POST",
        url: Constants["SERVER_URL"] + "/goal",
        data: { goal: data.goal },
        'beforeSend': function(xhr) {
            if (localStorage.getItem('userToken')) {
              xhr.setRequestHeader('Authorization',
                    'Bearer ' + localStorage.getItem('userToken'));
            }
        },
        crossDomain: true
    })
  }
};

export default GoalSource;


text:
<security-domain name="ModuloBaseRealm" cache-type="default">
					<authentication>
						<login-module code="Database" flag="required">
							<module-option name="dsJndiName"
								value="java:jboss/datasources/modBaseDS" />
							<module-option name="principalsQuery"
								value="select jaas_password from segu_vta_jaas where jaas_user=?" />
							<module-option name="rolesQuery"
								value="select jaas_rol,'Roles' from segu_vta_jaas where jaas_user=?" />
						</login-module>
					</authentication>
				</security-domain>


text:
import sys
sys.path.insert(0, ".")
import atomium

pdb = atomium.open("tests/integration/files/{}")

#model = pdb.generate_assembly(1)


text:
(function( $ ) {
	$.widget( "ui.ajaxform", {

		// Default options
		options: {
			validate: null,
			done: null,
			fail: null,
			always: null
		},

		// Set up the widget
		_create: function() {
			var self = this,
				options = self.options,
				element = self.element

			self.submit = self.element.find('input[type=submit],button[type=submit]');

			if ( self.options.validate === null ) {
				element.on('submit.ajaxform', $.proxy( self._submit, self ));
			} else {
				$.extend( self.options.validate, { submitHandler: $.proxy( self._submit, self ) } );
				$( element ).validate( self.options.validate );
			}
		},

		// Function to handle the for submission
		_submit: function( event ) {
			this.submit.button('loading');

			var request = $.ajax({
				type: 'POST',
				url: this.element.attr('action'),
				data: this.element.serialize()
			});

			request.done( $.proxy( this._done, this ) );
			request.fail( $.proxy( this._fail, this ) );
			request.always( $.proxy( this._always, this ) );

			return false;
		},

		_done: function( data, textStatus, jqXHR ) {
			if ( $.isFunction( this.options.done ) ) {
				this.options.done.apply( this.element, arguments );
			}
		},

		_fail: function( jqXHR, textStatus, errorThrown ) {
			if ( $.isFunction( this.options.fail ) ) {
				this.options.fail.apply( this.element, arguments );
			}
		},

		_always: function() {
			this.submit.button('reset');
			if ( $.isFunction( this.options.always ) ) {
				this.options.always.apply( this.element, arguments );
			}
		},

		// Change option values
		_setOption: function( key, value ) {
			switch( key ) {
			}

			$.Widget.prototype._setOption.apply( this, arguments );
		},

		// Cleanup
		destroy: function() {
			element.off('submit.ajaxform');
			$.Widget.prototype.destroy.call( this );
		}
	});
}( jQuery ) );


text:
require 'spec_helper'

describe BetfairNg::API::Operations::Auth::Certlogin::Operation do
  include SharedHelper::Config
  include SharedHelper::Stubs

  before do
    stub :certlogin
  end

  subject { BetfairNg::API::Operations::Auth::Certlogin::Operation.new( config: config ) }

  describe '#endpoint' do
    it 'should not raise' do
      expect{ subject.endpoint }.to_not raise_error
    end

    it 'equals to https://identitysso.betfair.com/api/certlogin' do
      expect( subject.endpoint ).to eq('https://identitysso.betfair.com/api/certlogin')
    end

    it 'is possible to override' do
      subject.endpoint = 'example'

      expect( subject.endpoint ).to eq('example')
    end
  end

  describe "#headers" do
    it 'returns a Hash with X-Application' do
      expect( subject.http_headers['X-Application'] ).to eq('j88ytx4Agw6DFX5k')
    end
  end

  describe "#request" do
    it 'returns Hash with key :username' do
      expect( subject.request ).to be_has_key(:username)
    end

    it 'returns Hash with key :password' do
      expect( subject.request ).to be_has_key(:password)
    end
  end

  describe "#perform" do
    it 'not raises' do
      expect{ subject.perform }.to_not raise_error
    end

    it 'returns valid response' do
      subject.perform

      expect(subject.http_code).to eq("200")
      expect(subject.http_data["loginStatus"]).to eq("SUCCESS")
      expect(subject.http_data["sessionToken"]).not_to be_nil
      expect(subject.token).to eq(subject.http_data["sessionToken"])
      expect(subject.success?).to be true
    end
  end

end


text:
When /^worker (\d+) opens a url$/ do |id|
  @worker_by_id[id] = Breakout::Socket.new(Breakout.worker_url)
end

When /^browser (\d+) opens a url for "([^"]*)"$/ do |id, route|
  @browser_by_id[id] = Breakout::Socket.new(Breakout.browser_url(route, :bid => id))
end

When /^browser (\d+) opens a url with bid "([^"]*)"$/ do |id, bid|
  @browser_by_id[id] = Breakout::Socket.new(Breakout.browser_url("test", :bid => bid))
end

When /^browser (\d+) opens a url with notify$/ do |id|
  @browser_by_id[id] = Breakout::Socket.new(Breakout.browser_url("test", :bid => id, :notify => true))
end

When /^browser (\d+) opens a url with bid "([^"]*)" and notify$/ do |id, bid|
  @browser_by_id[id] = Breakout::Socket.new(Breakout.browser_url("test", :bid => bid, :notify => true))
end

When /^worker (\d+) opens a url for work$/ do |id|
  @worker_by_id[id] = Breakout::Socket.new(Breakout.worker_url)
  @worker_by_id[id].send :done_work => true
end

When /^browser (\d+) opens a url$/ do |id|
  step %|browser #{id} opens a url for "test"|
end

When /^browser (\d+) sends "([^"]*)"$/ do |id, msg|
  @browser_by_id[id].send(msg)
end

When /^worker (\d+) receives a payload$/ do |id|
  Timeout::timeout(0.1) { @worker_payload_by_id[id] = @worker_by_id[id].receive }
end

Then /^worker (\d+) should not have a payload$/ do |id|
  ->() do
    step %|worker #{id} receives a payload|
  end.should raise_error(Timeout::Error)
end

Then /^worker (\d+)'s payload route should be "([^"]*)"$/ do |id, route|
  @worker_payload_by_id[id].split("\n", 3)[0].should == route
end

Then /^worker (\d+)'s payload message should be "([^"]*)"$/ do |id, msg|
  @worker_payload_by_id[id].split("\n", 3)[2].should == msg
end

Then /^worker (\d+)'s payload bid should be "([^"]*)"$/ do |id, msg|
  @worker_payload_by_id[id].split("\n", 3)[1].should == msg
end

Then /^worker (\d+)'s payload should be "([^"]*)"$/ do |id, msg|
  @worker_payload_by_id[id].should == msg
end

When /^worker (\d+) sends done_work$/ do |id|
  @worker_by_id[id].send :done_work => true
end

When /^worker (\d+) sends done_work no requeue$/ do |id|
  @worker_by_id[id].send :done_work => false
end

When /^worker (\d+) sends disconnect for browser (\d+)$/ do |id, bid|
  @worker_by_id[id].send :disconnect => bid
end

When /^worker (\d+) sends message "([^"]*)" to browser (\d+)$/ do |id, msg, bid|
  @worker_by_id[id].send :send_messages => { msg => [ bid ] }
end

When /^browser (\d+) receives a payload$/ do |id|
  Timeout::timeout(1) { @browser_payload_by_id[id] = @browser_by_id[id].receive }
end

Then /^browser (\d+)'s payload should be "([^"]*)"$/ do |id, msg|
  @browser_payload_by_id[id].should == msg
end

Then /^worker (\d+) should be connected$/ do |id|
  ->() do
    Timeout::timeout(0.1) { @worker_by_id[id].receive }
  end.should raise_error(Timeout::Error)
end

Then /^browser (\d+) should be connected$/ do |id|
  ->() do
    Timeout::timeout(0.1) { @browser_by_id[id].receive }
  end.should raise_error(Timeout::Error)
end

Then /^browser (\d+) should not be connected$/ do |id|
  ->() do
    Timeout::timeout(0.1) { @browser_by_id[id].receive }
  end.should_not raise_error(Timeout::Error)
end

Then /^worker (\d+) should not be connected$/ do |arg1|
  ->() do
    Timeout::timeout(0.1) { @worker_by_id[id].receive }
  end.should_not raise_error(Timeout::Error)
end

When /^browser (\d+) disconnects$/ do |id|
  @browser_by_id[id].close
  sleep(0.01)
end

When /^worker (\d+) disconnects$/ do |id|
  @worker_by_id[id].close
  sleep(0.01)
end

Then /^browser (\d+) should be disconnected$/ do |id|
  step "browser #{id} should not be connected"
end

Then /^worker (\d+) should be disconnected$/ do |id|
  step "worker #{id} should not be connected"
end

When /^browser (\d+) opens an expired url$/ do |id|
  url = Breakout.browser_url('test', :e => (Time.now - 1).to_i)
  @browser_by_id[id] = Breakout::Socket.new(url)
end

When /^browser (\d+) opens a tampered url$/ do |id|
  url = Breakout.browser_url('REALROUTE').gsub(/REALROUTE/, 'TAMPEREDROUTE')
  @browser_by_id[id] = Breakout::Socket.new(url)
end

When /^worker (\d+) opens a url without grid$/ do |id|
  url = "ws://#{Breakout::CONFIG[:breakout_host]}:#{Breakout::CONFIG[:worker_port]}/?grid_key=#{Breakout::CONFIG[:grid_key]}"
  @worker_by_id[id] = Breakout::Socket.new(url)
end

When /^worker (\d+) sends_eval "([^"]*)"$/ do |id, rb|
  @worker_by_id[id].send eval(rb)
end

When /^worker (\d+) sends not json$/ do |id|
  @worker_by_id[id].send nil
end

When /^worker (\d+) sends not dictionary$/ do |id|
  @worker_by_id[id].send Array.new
end

When /^the ([\w]*) config is changed$/ do |option|
  option = option.to_sym
  raise option unless Breakout::CONFIG.has_key? option
  Breakout.config(option => Breakout.random_config[option])
end

Given /^the server is restarted$/ do
  restart_server
end

When /^there is a pause$/ do
  sleep(0.1)
end


text:
var configuration = require('../../config/configuration.json')
var utility = require('../../public/utility')

module.exports = {
  renewSessionForAccount: function (redisClient, accountHashID, callback) {
    var sessionTable = configuration.TableMAAccountModelUserToken + accountHashID
    var sessionHashID = utility.generateUniqueHashID()
    redisClient.set(sessionTable, sessionHashID, 'EX', configuration.maximumSessionLength, 'NX', function (err, replies) {
      if (err) {
        callback(err, null)
        return
      }
      callback(null, configuration.message.session.renew)
    })
  },

  terminateSessionForAccount: function (redisClient, accountHashID, callback) {
    var sessionTable = configuration.TableMAAccountModelUserToken + accountHashID
    redisClient.pexpire(sessionTable, 10, function (err, replies) {
      if (err) {
        callback(err, null)
        return
      }
      callback(null, configuration.message.session.terminate)
    })
  }
}


text:
 Authentication requires a valid OAuth application to be registered with http://www.assembla.com.

 Using your Assembla account you can create a new application registration using this link:
  https://www.assembla.com/user/edit/manage_clients

Registered oAuth application ID/Secret will be visible only for user who created it.

The entry should look like this:

Name	You can set any name you want.

Website	http://127.0.0.1:8080

Redirect URI	http://127.0.0.1:8080/securityRealm/finishLogin

With 127.0.0.1:8080 replaced with the public hostname and port of your Jenkins instance.

 The /securityRealm/finishLogin is required as this is where Assembla will redirect the user for the second part of the authorization process.


text:
* Please tag your issue with `bug`, `feature request`, or `question` to help us
  effectively respond.
* Please include the version of Dopamine you are running
  (run `pip list | grep dopamine`)
* Please provide the command line you ran as well as the log output.

# Pull Requests

We'd love to accept your patches and contributions to this project. There are
just a few small guidelines you need to follow.

## Contributor License Agreement

Contributions to this project must be accompanied by a Contributor License
Agreement. You (or your employer) retain the copyright to your contribution,
this simply gives us permission to use and redistribute your contributions as
part of the project. Head over to <https://cla.developers.google.com/> to see
your current agreements on file or to sign a new one.

You generally only need to submit a CLA once, so if you've already submitted one
(even if it was for a different project), you probably don't need to do it
again.

## Code reviews

All submissions, including submissions by project members, require review. We
use GitHub pull requests for this purpose. Consult
[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
information on using pull requests.


text:
<!-- Do not edit this file. It is automatically generated by API Documenter. -->

[Home](./index.md) > [sip.js](./sip.js.md)

## sip.js package

A core library implementing low level SIP protocol elements.

## Classes

|  Class | Description |
|  --- | --- |
|  [ByeUserAgentClient](./sip.js.byeuseragentclient.md) | BYE UAC. |
|  [ByeUserAgentServer](./sip.js.byeuseragentserver.md) | BYE UAS. |
|  [CancelUserAgentClient](./sip.js.canceluseragentclient.md) | CANCEL UAC. |
|  [ClientTransaction](./sip.js.clienttransaction.md) | Client Transaction. |
|  [Dialog](./sip.js.dialog.md) | Dialog. |
|  [Exception](./sip.js.exception.md) | An Exception is considered a condition that a reasonable application may wish to catch. An Error indicates serious problems that a reasonable application should not try to catch. |
|  [IncomingMessage](./sip.js.incomingmessage.md) | Incoming message. |
|  [IncomingRequestMessage](./sip.js.incomingrequestmessage.md) | Incoming request message. |
|  [IncomingResponseMessage](./sip.js.incomingresponsemessage.md) | Incoming response message. |
|  [InfoUserAgentClient](./sip.js.infouseragentclient.md) | INFO UAC. |
|  [InfoUserAgentServer](./sip.js.infouseragentserver.md) | INFO UAS. |
|  [InviteClientTransaction](./sip.js.inviteclienttransaction.md) | INVITE Client Transaction. |
|  [InviteServerTransaction](./sip.js.inviteservertransaction.md) | INVITE Server Transaction. |
|  [InviteUserAgentClient](./sip.js.inviteuseragentclient.md) | INVITE UAC. |
|  [InviteUserAgentServer](./sip.js.inviteuseragentserver.md) | INVITE UAS. |
|  [Logger](./sip.js.logger.md) | Logger. |
|  [LoggerFactory](./sip.js.loggerfactory.md) | Logger. |
|  [MessageUserAgentClient](./sip.js.messageuseragentclient.md) | MESSAGE UAC. |
|  [MessageUserAgentServer](./sip.js.messageuseragentserver.md) | MESSAGE UAS. |
|  [NameAddrHeader](./sip.js.nameaddrheader.md) | Name Address SIP header. |
|  [NonInviteClientTransaction](./sip.js.noninviteclienttransaction.md) | Non-INVITE Client Transaction. |
|  [NonInviteServerTransaction](./sip.js.noninviteservertransaction.md) | Non-INVITE Server Transaction. |
|  [NotifyUserAgentClient](./sip.js.notifyuseragentclient.md) | NOTIFY UAS. |
|  [NotifyUserAgentServer](./sip.js.notifyuseragentserver.md) | NOTIFY UAS. |
|  [OutgoingRequestMessage](./sip.js.outgoingrequestmessage.md) | Outgoing SIP request message. |
|  [PrackUserAgentClient](./sip.js.prackuseragentclient.md) | PRACK UAC. |
|  [PrackUserAgentServer](./sip.js.prackuseragentserver.md) | PRACK UAS. |
|  [PublishUserAgentClient](./sip.js.publishuseragentclient.md) | PUBLISH UAC. |
|  [ReferUserAgentClient](./sip.js.referuseragentclient.md) | REFER UAC. |
|  [ReferUserAgentServer](./sip.js.referuseragentserver.md) | REFER UAS. |
|  [RegisterUserAgentClient](./sip.js.registeruseragentclient.md) | REGISTER UAC. |
|  [RegisterUserAgentServer](./sip.js.registeruseragentserver.md) | REGISTER UAS. |
|  [ReInviteUserAgentClient](./sip.js.reinviteuseragentclient.md) | Re-INVITE UAC. |
|  [ReInviteUserAgentServer](./sip.js.reinviteuseragentserver.md) | Re-INVITE UAS. |
|  [ReSubscribeUserAgentClient](./sip.js.resubscribeuseragentclient.md) | Re-SUBSCRIBE UAC. |
|  [ReSubscribeUserAgentServer](./sip.js.resubscribeuseragentserver.md) | Re-SUBSCRIBE UAS. |
|  [ServerTransaction](./sip.js.servertransaction.md) | Server Transaction. |
|  [SessionDialog](./sip.js.sessiondialog.md) | Session Dialog. |
|  [SubscribeUserAgentClient](./sip.js.subscribeuseragentclient.md) | SUBSCRIBE UAC. |
|  [SubscribeUserAgentServer](./sip.js.subscribeuseragentserver.md) | SUBSCRIBE UAS. |
|  [SubscriptionDialog](./sip.js.subscriptiondialog.md) | Subscription Dialog. |
|  [Transaction](./sip.js.transaction.md) | Transaction. |
|  [TransactionStateError](./sip.js.transactionstateerror.md) | Indicates that the operation could not be completed given the current transaction state. |
|  [TransportError](./sip.js.transporterror.md) | Transport error. |
|  [URI](./sip.js.uri.md) | URI. |
|  [UserAgentClient](./sip.js.useragentclient.md) | User Agent Client (UAC). |
|  [UserAgentCore](./sip.js.useragentcore.md) | User Agent Core. |
|  [UserAgentServer](./sip.js.useragentserver.md) | User Agent Server (UAS). |

## Enumerations

|  Enumeration | Description |
|  --- | --- |
|  [Levels](./sip.js.levels.md) | Log levels. |
|  [SessionState](./sip.js.sessionstate.md) | Session state. |
|  [SignalingState](./sip.js.signalingstate.md) | Offer/Answer state. |
|  [SubscriptionState](./sip.js.subscriptionstate.md) | Subscription state. |
|  [TransactionState](./sip.js.transactionstate.md) | Transaction state. |

## Interfaces

|  Interface | Description |
|  --- | --- |
|  [AckableIncomingResponseWithSession](./sip.js.ackableincomingresponsewithsession.md) | Incoming INVITE response received when request is accepted. |
|  [Body](./sip.js.body.md) | Message body. |
|  [ClientTransactionUser](./sip.js.clienttransactionuser.md) | UAC Core Transaction User. |
|  [Contact](./sip.js.contact.md) | Contact. |
|  [DialogState](./sip.js.dialogstate.md) | Dialog state. |
|  [IncomingAckRequest](./sip.js.incomingackrequest.md) | Incoming ACK request. |
|  [IncomingByeRequest](./sip.js.incomingbyerequest.md) | Incoming BYE request. |
|  [IncomingByeResponse](./sip.js.incomingbyeresponse.md) | Incoming BYE response. |
|  [IncomingCancelRequest](./sip.js.incomingcancelrequest.md) | Incoming CANCEL request. |
|  [IncomingCancelResponse](./sip.js.incomingcancelresponse.md) | Incoming CANCEL response. |
|  [IncomingInfoRequest](./sip.js.incominginforequest.md) | Incoming INFO request. |
|  [IncomingInfoResponse](./sip.js.incominginforesponse.md) | Incoming INFO response. |
|  [IncomingInviteRequest](./sip.js.incominginviterequest.md) | Incoming INVITE request. |
|  [IncomingMessageRequest](./sip.js.incomingmessagerequest.md) | Incoming MESSAGE request. |
|  [IncomingMessageResponse](./sip.js.incomingmessageresponse.md) | Incoming MESSAGE response. |
|  [IncomingNotifyRequest](./sip.js.incomingnotifyrequest.md) | Incoming NOTIFY request. |
|  [IncomingNotifyResponse](./sip.js.incomingnotifyresponse.md) | Incoming NOTIFY response. |
|  [IncomingPrackRequest](./sip.js.incomingprackrequest.md) | Incoming PRACK request. |
|  [IncomingPrackResponse](./sip.js.incomingprackresponse.md) | Incoming PRACK response. |
|  [IncomingPublishRequest](./sip.js.incomingpublishrequest.md) | Incoming PUBLISH request. |
|  [IncomingPublishResponse](./sip.js.incomingpublishresponse.md) | Incoming PUBLISH response. |
|  [IncomingReferRequest](./sip.js.incomingreferrequest.md) | Incoming REFER request. |
|  [IncomingReferResponse](./sip.js.incomingreferresponse.md) | Incoming REFER response. |
|  [IncomingRegisterRequest](./sip.js.incomingregisterrequest.md) | Incoming REGISTER request. |
|  [IncomingRegisterResponse](./sip.js.incomingregisterresponse.md) | Incoming REGISTER response. |
|  [IncomingRequest](./sip.js.incomingrequest.md) | A SIP message sent from a remote client to a local server. |
|  [IncomingRequestDelegate](./sip.js.incomingrequestdelegate.md) | Delegate providing custom handling of incoming requests. |
|  [IncomingRequestWithSubscription](./sip.js.incomingrequestwithsubscription.md) | Incoming NOTIFY request with associated [Subscription](./sip.js.subscription.md)<!-- -->. |
|  [IncomingResponse](./sip.js.incomingresponse.md) | A SIP message sent from a remote server to a local client. |
|  [IncomingSubscribeRequest](./sip.js.incomingsubscriberequest.md) | Incoming SUBSCRIBE request. |
|  [IncomingSubscribeResponse](./sip.js.incomingsubscriberesponse.md) | Incoming SUBSCRIBE response. |
|  [OutgoingAckRequest](./sip.js.outgoingackrequest.md) | Outgoing ACK request. |
|  [OutgoingByeRequest](./sip.js.outgoingbyerequest.md) | Outgoing BYE request. |
|  [OutgoingCancelRequest](./sip.js.outgoingcancelrequest.md) | Outgoing CANCEL request. |
|  [OutgoingInfoRequest](./sip.js.outgoinginforequest.md) | Outgoing INFO request. |
|  [OutgoingInviteRequest](./sip.js.outgoinginviterequest.md) | Outgoing INVITE request. |
|  [OutgoingInviteRequestDelegate](./sip.js.outgoinginviterequestdelegate.md) | Delegate providing custom handling of outgoing INVITE requests. |
|  [OutgoingMessageRequest](./sip.js.outgoingmessagerequest.md) | Outgoing MESSAGE request. |
|  [OutgoingNotifyRequest](./sip.js.outgoingnotifyrequest.md) | Outgoing NOTIFY request. |
|  [OutgoingPrackRequest](./sip.js.outgoingprackrequest.md) | Outgoing PRACK request. |
|  [OutgoingPublishRequest](./sip.js.outgoingpublishrequest.md) | Outgoing PUBLISH request. |
|  [OutgoingReferRequest](./sip.js.outgoingreferrequest.md) | Outgoing REFER request. |
|  [OutgoingRegisterRequest](./sip.js.outgoingregisterrequest.md) | Outgoing REGISTER request. |
|  [OutgoingRequest](./sip.js.outgoingrequest.md) | A SIP message sent from a local client to a remote server. |
|  [OutgoingRequestDelegate](./sip.js.outgoingrequestdelegate.md) | Delegate providing custom handling of outgoing requests. |
|  [OutgoingRequestMessageOptions](./sip.js.outgoingrequestmessageoptions.md) | Outgoing request message options. |
|  [OutgoingResponse](./sip.js.outgoingresponse.md) | A SIP message sent from a local server to a remote client. |
|  [OutgoingResponseWithSession](./sip.js.outgoingresponsewithsession.md) | Outgoing INVITE response with the associated [Session](./sip.js.session.md)<!-- -->. |
|  [OutgoingSubscribeRequest](./sip.js.outgoingsubscriberequest.md) | Outgoing SUBSCRIBE request. |
|  [OutgoingSubscribeRequestDelegate](./sip.js.outgoingsubscriberequestdelegate.md) | Delegate providing custom handling of outgoing SUBSCRIBE requests. |
|  [PrackableIncomingResponseWithSession](./sip.js.prackableincomingresponsewithsession.md) | Incoming INVITE response received when request is progressed. |
|  [RequestOptions](./sip.js.requestoptions.md) | Request options bucket. |
|  [ResponseOptions](./sip.js.responseoptions.md) | Response options bucket. |
|  [ServerTransactionUser](./sip.js.servertransactionuser.md) | UAS Core Transaction User. |
|  [Session](./sip.js.session.md) | Session. |
|  [SessionDelegate](./sip.js.sessiondelegate.md) | Session delegate. |
|  [Subscription](./sip.js.subscription.md) | Subscription. |
|  [SubscriptionDelegate](./sip.js.subscriptiondelegate.md) | Subscription delegate. |
|  [TransactionUser](./sip.js.transactionuser.md) | Transaction User (TU). |
|  [Transport](./sip.js.transport.md) | Transport layer interface expected by the user agent core. |
|  [UserAgentCoreConfiguration](./sip.js.useragentcoreconfiguration.md) | User Agent Core configuration. |
|  [UserAgentCoreDelegate](./sip.js.useragentcoredelegate.md) | User Agent Core delegate. |

## Variables

|  Variable | Description |
|  --- | --- |
|  [Timers](./sip.js.timers.md) | Timers. |


text: var data = {'check-print': {}};


text:
set -e

cat<<EOF
============================================================
Usage: ${0}
This script installs gcloud command. You can modify gcloud
version by GOOGLE_CLOUD_SDK_VERSION env var and download
path by GOOGLE_CLOUD_SDK_DOWNLOAD_PATH env var.
============================================================
EOF

GOOGLE_CLOUD_SDK_VERSION=${GOOGLE_CLOUD_SDK_VERSION:-206.0.0}
GOOGLE_CLOUD_SDK_DOWNLOAD_PATH=${GOOGLE_CLOUD_SDK_DOWNLOAD_PATH:-/google-cloud-sdk}

# Some CI service support cache feature.
# If there are cache, just use it and skip downloading.
if [ ! -e "${GOOGLE_CLOUD_SDK_DOWNLOAD_PATH}" ]; then
    curl -L -o /tmp/google-cloud-sdk-$GOOGLE_CLOUD_SDK_VERSION-linux-x86_64.tar.gz \
         https://dl.google.com/dl/cloudsdk/channels/rapid/downloads/google-cloud-sdk-$GOOGLE_CLOUD_SDK_VERSION-linux-x86_64.tar.gz
    tar -xz -C /tmp -f /tmp/google-cloud-sdk-$GOOGLE_CLOUD_SDK_VERSION-linux-x86_64.tar.gz
    mv /tmp/google-cloud-sdk $GOOGLE_CLOUD_SDK_DOWNLOAD_PATH

    ${GOOGLE_CLOUD_SDK_DOWNLOAD_PATH}/install.sh --quiet
    ${GOOGLE_CLOUD_SDK_DOWNLOAD_PATH}/bin/gcloud components install gsutil --quiet
fi

# Create symlink to default PATH
ln -s ${GOOGLE_CLOUD_SDK_DOWNLOAD_PATH}/bin/gcloud /usr/local/bin/gcloud
ln -s ${GOOGLE_CLOUD_SDK_DOWNLOAD_PATH}/bin/gsutil /usr/local/bin/gsutil


text:
pre.sh_sourceCode {
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: blue; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: darkgreen; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: pink; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: brown; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: darkblue; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: darkred; }                            /* e.g., <, >, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: cyan; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: darkblue; }
pre.sh_sourceCode .sh_predef_func { color: darkblue; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { color: black; font-family: monospace; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: darkblue; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: darkgreen; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: darkgreen; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: darkgreen; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: darkgreen; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: darkgreen; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: darkgreen; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: darkgreen; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: darkgreen; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: darkgreen; }


text:
import os
from setuptools import setup

here = os.path.abspath(os.path.dirname(__file__))
README = open(os.path.join(here, 'README.txt')).read()
CHANGES = open(os.path.join(here, 'CHANGES.txt')).read()

setup (
    name='ztq_worker',
    version='1.3.0',
    author = "xutaozhe",
    author_email = "xutaozhe@zopen.cn",
    description=u"Zopen Task Queue Worker",
    long_description=README + '\n\n' +  CHANGES,
    license = "MIT",
    keywords='Everydo queue async ztq_worker',
    classifiers = [
        'Development Status :: 4 - Beta',
        'Environment :: Web Environment',
        'Intended Audience :: Developers',
        'Programming Language :: Python',
        'Operating System :: OS Independent',
        'Topic :: Internet :: WWW/HTTP',
        ],
    packages = ['ztq_worker'],
    #package_dir={'ztq_worker': 'ztq_worker'},
    #package_data={'ztq_worker': ['system_info/*.vbs'] },
    data_files=[('config', ['worker.ini']),],
    include_package_data = True,
    install_requires = [
        "ztq_core",
        ],
    entry_points = """\
      [console_scripts]
      ztq_worker = ztq_worker.main:run
      """,
    zip_safe = False,
)


text:
package io.netty.protocol.wamp.messages;

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.core.TreeNode;
import com.fasterxml.jackson.core.type.TypeReference;

import java.io.IOException;
import java.io.StringWriter;
import java.util.List;

public class PublishMessage extends WampMessage {
	private static final String WRONG_MSG = "Wrong message format";
	public String topicURI;
	public TreeNode event;
	public Boolean excludeMe;
	public List<String> exclude;
	public List<String> eligible;

	public PublishMessage() {
		super(MessageType.PUBLISH);
	}

	public PublishMessage(String topicURI, TreeNode event) {
		super(MessageType.PUBLISH);
		this.topicURI = topicURI;
		this.event = event;
	}

	@Override
	public String toJson() {
		String jsonStr = null;
		try (
			StringWriter sw = new StringWriter();
			JsonGenerator jg = MessageMapper.jsonFactory.createGenerator(sw)
		) {
			jg.writeStartArray();
			jg.writeNumber(getMessageCode());
			jg.writeString(topicURI);
			jg.writeTree(event);
			if (excludeMe != null && excludeMe) {
				jg.writeBoolean(true);
			} else if (exclude != null || eligible != null) {
				if (exclude != null) {
					jg.writeObject(exclude);
				} else {
					jg.writeStartArray();
					jg.writeEndArray();
				}
				if (eligible != null) {
					jg.writeObject(eligible);
				} else {
					jg.writeStartArray();
					jg.writeEndArray();
				}
			}
			jg.writeEndArray();
			jg.close();
			jsonStr = sw.toString();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return jsonStr;
	}

	public static PublishMessage fromJson(final String jsonStr) throws IOException {
		try (JsonParser jp = MessageMapper.jsonFactory.createParser(jsonStr)) {
			boolean valid = MessageMapper.validate(jp, MessageType.PUBLISH);
			if (valid) return fromParser(jp);
			else throw new IOException(WRONG_MSG);
		}
	}

	public static PublishMessage fromParser(final JsonParser jp) throws IOException {
		PublishMessage pm = new PublishMessage();

		if (jp.nextToken() != JsonToken.VALUE_STRING) throw new IOException(WRONG_MSG);
		pm.topicURI = jp.getValueAsString();

		jp.nextToken();
		pm.event = jp.readValueAsTree();

		if (jp.nextToken() != JsonToken.END_ARRAY) {
			if (jp.getCurrentToken() == JsonToken.VALUE_TRUE || jp.getCurrentToken() == JsonToken.VALUE_FALSE) {
				pm.excludeMe = jp.getValueAsBoolean();

				if (jp.nextToken() != JsonToken.END_ARRAY) {
					// Wrong message format, excludeMe should not be followed by any value
					throw new IOException(WRONG_MSG);
				}
			} else {
				TypeReference<List<String>> typRef = new TypeReference<List<String>>() {};

				if (jp.getCurrentToken() != JsonToken.START_ARRAY) throw new IOException(WRONG_MSG);
				pm.exclude = jp.readValueAs(typRef);

				if (jp.nextToken() != JsonToken.START_ARRAY) throw new IOException(WRONG_MSG);
				pm.eligible = jp.readValueAs(typRef);
			}
		}

		return pm;
	}
}


text:
'use strict';

describe('Service: clubService', function () {

  // load the service's module
  beforeEach(module('beneyluFootApp'));

  // instantiate service
  var clubService;
  beforeEach(inject(function (_clubService_) {
    clubService = _clubService_;
  }));

  it('should do something', function () {
    expect(!!clubService).toBe(true);
  });

});


text:
__author__ = 'RemiZOffAlex'
__copyright__ = '(c) RemiZOffAlex'
__license__ = 'MIT'
__email__ = 'remizoffalex@mail.ru'
__url__ = 'http://remizoffalex.ru'

import sys
import argparse
from crmapp import app, lib, models

def main():
    parser = argparse.ArgumentParser(description='Скрипт добавления пользователя',
        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
    parser._optionals.title = "Необязательные аргументы"

    parser.add_argument("--user", dest="user", help="Новый пользователь")
    parser.add_argument("--password", dest="password", help="Новый пароль")

    args = parser.parse_args()

    user = models.db_session.query(
        models.User
    ).filter(
        models.User.name==args.user
    ).first()
    if user:
        app.logger.warning('Пользователь %s уже существует' % args.user)
        sys.exit(1)
    user = models.User(args.user)
    user.password = lib.get_hash_password(args.password,
        app.config['SECRET_KEY'])
    models.db_session.add(user)
    models.db_session.commit()
    app.logger.info('Пользователь %s успешно добавлен' % args.user)

if __name__ == "__main__":
    try:
        main()
    except Exception as err:
        traceback.print_exc(file=sys.stdout)
        exit(1)

    exit(0)


text:
You've spent the last few weeks improving significant portions of your application and you're ready to deploy. The maintenance page goes up, the code is pushed, and doubt creeps in as to whether things are actually working. Did you remember to update those third party keys? Is that very clever code your co-worker wrote working as expected? Is there anything different about your production environment that's going to cause things to fail?

As developers we'd all prefer to live in a world where we're continuously deploying all of our test-driven code all the time. In reality, the process typically looks a little broken. Imagine being able to spend a few minutes with your app smoke testing to make sure everything works. With Floodgate in place you are able to provide access to developers, testers, and the product owner to click through and see things work the way they are supposed to in production before releasing your product to all of your customers.

## Getting Started

Install Floodgate as a gem.

    gem install floodgate

or by adding it to your Gemfile.

    gem 'floodgate'

Then create an account at [Floodgate.io](http://floodgate.io). Once you receive your welcome email you can configure the middleware with one-line.

    config.middleware.use Floodgate::Control, [YOUR_APP_ID], [YOUR_API_TOKEN]

Now that you've configured the floodgate you can check its status.

    $ rake floodgate:status
    allowed_ip_addresses: []
    filter_traffic: false
    name: your-app-name
    redirect_url:

The floodgate is open by default and no traffic is filtered. You can close the floodgate with the following rake task.

    $ rake floodgate:close

When using Heroku you will also need to restart your dyno for changes to take effect.

    $ heroku restart

Checking its status we can see that we are now filtering traffic.

    $ rake floodgate:status
    allowed_ip_addresses: []
    filter_traffic: true
    name: your-app-name
    redirect_url:

Visitors to the configured site will now receive a status 503 Service Unavailable. That seems less than ideal. Let's redirect them to a status page to let them know to try back in a few minutes.

    $ rake floodgate:set_redirect_url redirect_url=http://bit.ly/1kw8F6q

Now its status includes the redirect URL

    $ rake floodgate:status
    allowed_ip_addresses: []
    filter_traffic: true
    name: your-app-name
    redirect_url: http://bit.ly/1kw8F6q

When we visit the site (remember to restart Heroku if needed) we are now whisked away to the redirect URl. This is configured as a temporary redirect to minimize the impact from search engine spiders and other crawlers.

But, wait! How do we get in to smoke test? You'll need to determine what your IP address is as interpreted by the outside world.

    $ rake floodgate:ip_address:add_me

Checking its status we now have an allowed IP address.

    $ rake floodgate:status
    allowed_ip_addresses: ["24.240.74.8"]
    filter_traffic: true
    name: your-app-name
    redirect_url: http://bit.ly/1kw8F6q

If we go back to the configured site (restart heroku if needed) and reload … We're in! We can smoke test and make sure things work as expected and when we're done let the rest of the internet in with the following command.

    $ rake floodgate:open
    $ rake floodgate:status
    allowed_ip_addresses: ["24.240.74.8"]
    filter_traffic: false
    name: your-app-name
    redirect_url: http://bit.ly/1kw8F6q

Restart Heroku and everyone can now access the application again, hooray!

### Support

* [Github Wiki](https://github.com/adorableio/floodgate/wiki)
* [Github Issues](https://github.com/adorableio/floodgate/wiki)

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request


text:
using System;
using System.Globalization;
using System.Runtime.InteropServices;
using static System.FormattableString;

namespace Frostfire.Math
{
    [Serializable]
    [StructLayout(LayoutKind.Sequential, Pack = 4)]
    public struct BoundingBox : IEquatable<BoundingBox>
    {
        public static readonly int SIZE_IN_BYTES = Marshal.SizeOf(typeof(BoundingBox));

        public static readonly BoundingBox MIN_VALUE = new BoundingBox(new Vector3(Single.MaxValue), new Vector3(Single.MinValue));
        public static readonly BoundingBox MAX_VALUE = new BoundingBox(new Vector3(Single.MinValue), new Vector3(Single.MaxValue));

        public Vector3 Minimum;
        public Vector3 Maximum;

        public float Width { get { return Maximum.X - Minimum.X; } }
        public float Height { get { return Maximum.Y - Minimum.Y; } }
        public float Depth { get { return Maximum.Z - Minimum.Z; } }

        public Vector3 Center { get { return (Minimum + Maximum) * 0.5f; } }

        public Vector3[] GetCorners()
        {
            return new Vector3[8]
            {
                new Vector3(this.Minimum.X, this.Maximum.Y, this.Maximum.Z),
                new Vector3(this.Maximum.X, this.Maximum.Y, this.Maximum.Z),
                new Vector3(this.Maximum.X, this.Minimum.Y, this.Maximum.Z),
                new Vector3(this.Minimum.X, this.Minimum.Y, this.Maximum.Z),
                new Vector3(this.Minimum.X, this.Maximum.Y, this.Minimum.Z),
                new Vector3(this.Maximum.X, this.Maximum.Y, this.Minimum.Z),
                new Vector3(this.Maximum.X, this.Minimum.Y, this.Minimum.Z),
                new Vector3(this.Minimum.X, this.Minimum.Y, this.Minimum.Z),
            };
        }

        public BoundingBox(Vector3 minimum, Vector3 maximum)
        {
            this.Minimum = minimum;
            this.Maximum = maximum;
        }

        #region Comparison

        public override int GetHashCode()
        {
            unchecked
            {
                return (Minimum.GetHashCode() * 397) ^ Maximum.GetHashCode();
            }
        }

        public bool Equals(ref BoundingBox value)
        {
            return this.Minimum == value.Minimum && this.Maximum == value.Maximum;
        }
        public bool Equals(BoundingBox value)
        {
            return this.Minimum == value.Minimum && this.Maximum == value.Maximum;
        }
        public override bool Equals(object obj)
        {
            if (obj == null || obj.GetType() != this.GetType())
                return false;
            return this.Equals((BoundingBox)obj);
        }

        public static bool operator ==(BoundingBox left, BoundingBox right)
        {
            return Equals(left, right);
        }
        public static bool operator !=(BoundingBox left, BoundingBox right)
        {
            return !Equals(left, right);
        }

        #endregion

        #region Collision

        public bool Intersects(ref Vector3 point)
        {
            return (this.Minimum.X <= point.X && point.X <= this.Maximum.X &&
                    this.Minimum.Y <= point.Y && point.Y <= this.Maximum.Y &&
                    this.Minimum.Z <= point.Z && point.Z <= this.Maximum.Z);
        }
        public bool Intersects(Vector3 point)
        {
            return Intersects(ref point);
        }

        public PlaneIntersectionType Intersects(ref Plane plane)
        {
            return plane.Intersects(ref this);
        }
        public PlaneIntersectionType Intersects(Plane plane)
        {
            return plane.Intersects(ref this);
        }

        public bool Intersects(ref Ray ray)
        {
            return ray.Intersects(ref this);
        }
        public bool Intersects(Ray ray)
        {
            return ray.Intersects(ref this);
        }
        public bool Intersects(ref Ray ray, out float distance)
        {
            return ray.Intersects(ref this, out distance);
        }
        public bool Intersects(Ray ray, out float distance)
        {
            return ray.Intersects(ref this, out distance);
        }
        public bool Intersects(ref Ray ray, out Vector3 point)
        {
            return ray.Intersects(ref this, out point);
        }
        public bool Intersects(Ray ray, out Vector3 point)
        {
            return ray.Intersects(ref this, out point);
        }
        public bool Intersects(ref Ray ray, out Faces face, out Vector3 point)
        {
            Plane plane;
            float distance = Single.PositiveInfinity;
            face = Faces.None;
            point = Vector3.ZERO;
            Vector3 newPoint;

            // Front
            plane = new Plane(Maximum, new Vector3(0.0f, 0.0f, 1.0f));
            if (ray.Intersects(ref plane, out newPoint)
                && newPoint.X >= Minimum.X && newPoint.X <= Maximum.X
                && newPoint.Y >= Minimum.Y && newPoint.Y <= Maximum.Y)
            {
                float newDistance; Vector3.Distance(ref ray.Origin, ref newPoint, out newDistance);
                if (newDistance < distance)
                {
                    distance = newDistance;
                    face = Faces.Front;
                    point = newPoint;
                }
            }

            // Back
            plane = new Plane(Minimum, new Vector3(0.0f, 0.0f, -1.0f));
            if (ray.Intersects(ref plane, out newPoint)
                && newPoint.X >= Minimum.X && newPoint.X <= Maximum.X
                && newPoint.Y >= Minimum.Y && newPoint.Y <= Maximum.Y)
            {
                float newDistance; Vector3.Distance(ref ray.Origin, ref newPoint, out newDistance);
                if (newDistance < distance)
                {
                    distance = newDistance;
                    face = Faces.Back;
                    point = newPoint;
                }
            }

            // Right
            plane = new Plane(Maximum, new Vector3(1.0f, 0.0f, 0.0f));
            if (ray.Intersects(ref plane, out newPoint)
                && newPoint.Y >= Minimum.Y && newPoint.Y <= Maximum.Y
                && newPoint.Z >= Minimum.Z && newPoint.Z <= Maximum.Z)
            {
                float newDistance; Vector3.Distance(ref ray.Origin, ref newPoint, out newDistance);
                if (newDistance < distance)
                {
                    distance = newDistance;
                    face = Faces.Right;
                    point = newPoint;
                }
            }

            // Left
            plane = new Plane(Minimum, new Vector3(-1.0f, 0.0f, 0.0f));
            if (ray.Intersects(ref plane, out newPoint)
                && newPoint.Y >= Minimum.Y && newPoint.Y <= Maximum.Y
                && newPoint.Z >= Minimum.Z && newPoint.Z <= Maximum.Z)
            {
                float newDistance; Vector3.Distance(ref ray.Origin, ref newPoint, out newDistance);
                if (newDistance < distance)
                {
                    distance = newDistance;
                    face = Faces.Left;
                    point = newPoint;
                }
            }

            // Top
            plane = new Plane(Maximum, new Vector3(0.0f, 1.0f, 0.0f));
            if (ray.Intersects(ref plane, out newPoint)
                && newPoint.X >= Minimum.X && newPoint.X <= Maximum.X
                && newPoint.Z >= Minimum.Z && newPoint.Z <= Maximum.Z)
            {
                float newDistance; Vector3.Distance(ref ray.Origin, ref newPoint, out newDistance);
                if (newDistance < distance)
                {
                    distance = newDistance;
                    face = Faces.Top;
                    point = newPoint;
                }
            }

            // Bottom
            plane = new Plane(Minimum, new Vector3(0.0f, -1.0f, 0.0f));
            if (ray.Intersects(ref plane, out newPoint)
                && newPoint.X >= Minimum.X && newPoint.X <= Maximum.X
                && newPoint.Z >= Minimum.Z && newPoint.Z <= Maximum.Z)
            {
                float newDistance; Vector3.Distance(ref ray.Origin, ref newPoint, out newDistance);
                if (newDistance < distance)
                {
                    distance = newDistance;
                    face = Faces.Bottom;
                    point = newPoint;
                }
            }

            return !Single.IsPositiveInfinity(distance);
        }
        public bool Intersects(Ray ray, out Faces face, out Vector3 point)
        {
            return Intersects(ref ray, out face, out point);
        }
        public bool Intersects(ref Ray ray, out Faces face)
        {
            Vector3 point;
            return Intersects(ref ray, out face, out point);
        }
        public bool Intersects(Ray ray, out Faces face)
        {
            Vector3 point;
            return Intersects(ref ray, out face, out point);
        }

        public bool Intersects(ref BoundingSphere sphere)
        {
            Vector3 clampedCenter = Vector3.Clamp(sphere.Center, this.Minimum, this.Maximum);
            Vector3 centerDiff = sphere.Center - clampedCenter;

            float lengthSquared = centerDiff.X * centerDiff.X + centerDiff.Y * centerDiff.Y + centerDiff.Z * centerDiff.Z;
            float radiusSquared = sphere.Radius * sphere.Radius;

            if (lengthSquared > radiusSquared)
                return false;

            return true;
        }
        public bool Intersects(BoundingSphere sphere)
        {
            return Intersects(ref sphere);
        }
        public ContainmentType Contains(ref BoundingSphere sphere)
        {
            Vector3 clampedCenter = Vector3.Clamp(sphere.Center, this.Minimum, this.Maximum);
            Vector3 centerDiff = sphere.Center - clampedCenter;

            float lengthSquared = centerDiff.X * centerDiff.X + centerDiff.Y * centerDiff.Y + centerDiff.Z * centerDiff.Z;
            float radiusSquared = sphere.Radius * sphere.Radius;

            if (lengthSquared > radiusSquared)
            {
                return ContainmentType.Disjoint;
            }

            if (this.Width > sphere.Radius && this.Height > sphere.Radius && this.Depth > sphere.Radius &&
                this.Minimum.X + sphere.Radius <= sphere.Center.X &&
                sphere.Center.X <= this.Maximum.X - sphere.Radius &&
                this.Minimum.Y + sphere.Radius <= sphere.Center.Y &&
                sphere.Center.Y <= this.Maximum.Y - sphere.Radius &&
                this.Minimum.Z + sphere.Radius <= sphere.Center.Z &&
                sphere.Center.Z <= this.Maximum.Z - sphere.Radius)
            {
                return ContainmentType.Contains;
            }

            return ContainmentType.Intersects;
        }
        public ContainmentType Contains(BoundingSphere sphere)
        {
            return Contains(ref sphere);
        }

        public bool Intersects(ref BoundingBox box)
        {
            return !(this.Maximum.X < box.Minimum.X || this.Minimum.X > box.Maximum.X ||
               (this.Maximum.Y < box.Minimum.Y || this.Minimum.Y > box.Maximum.Y) ||
               (this.Maximum.Z < box.Minimum.Z || this.Minimum.Z > box.Maximum.Z));
        }
        public bool Intersects(BoundingBox box)
        {
            return Intersects(ref box);
        }
        public ContainmentType Contains(ref BoundingBox box)
        {
            if (this.Maximum.X < box.Minimum.X || this.Minimum.X > box.Maximum.X ||
               (this.Maximum.Y < box.Minimum.Y || this.Minimum.Y > box.Maximum.Y) ||
               (this.Maximum.Z < box.Minimum.Z || this.Minimum.Z > box.Maximum.Z))
            {
                return ContainmentType.Disjoint;
            }
            if (this.Minimum.X <= box.Minimum.X && box.Maximum.X <= this.Maximum.X &&
               (this.Minimum.Y <= box.Minimum.Y && box.Maximum.Y <= this.Maximum.Y) &&
               (this.Minimum.Z <= box.Minimum.Z && box.Maximum.Z <= this.Maximum.Z))
            {
                return ContainmentType.Contains;
            }

            return ContainmentType.Intersects;
        }
        public ContainmentType Contains(BoundingBox box)
        {
            return Contains(ref box);
        }

        #endregion

        #region Conversion

        public void AddPoint(ref Vector3 point)
        {
            Maximum.Maximize(ref point);
            Minimum.Minimize(ref point);
        }
        public void AddPoint(Vector3 point)
        {
            Maximum.Maximize(ref point);
            Minimum.Minimize(ref point);
        }

        public static BoundingBox FromPoints(Vector3[] points)
        {
            if (points == null || points.Length <= 0)
                throw new ArgumentNullException(nameof(points));

            Vector3 boundsMin = new Vector3(float.MaxValue);
            Vector3 boundsMax = new Vector3(float.MinValue);

            for (int i = 0; i < points.Length; i++)
            {
                Vector3 currentPoint = points[i];
                boundsMin = Vector3.Minimize(boundsMin, currentPoint);
                boundsMax = Vector3.Maximize(boundsMax, currentPoint);
            }

            Vector3 extents = (boundsMax - boundsMin) * 0.5f;
            Vector3 center = boundsMin + extents;

            return new BoundingBox(extents, center);
        }

        public static void Merge(ref BoundingBox a, ref BoundingBox b, out BoundingBox result)
        {
            result.Minimum = Vector3.Minimize(a.Minimum, b.Minimum);
            result.Maximum = Vector3.Maximize(a.Maximum, b.Maximum);
        }
        public static BoundingBox Merge(ref BoundingBox a, ref BoundingBox b)
        {
            BoundingBox result;
            Merge(ref a, ref b, out result);
            return result;
        }
        public static BoundingBox Merge(BoundingBox a, BoundingBox b)
        {
            BoundingBox result;
            Merge(ref a, ref b, out result);
            return result;
        }
        public void Merge(ref BoundingBox box)
        {
            Merge(ref this, ref box, out this);
        }
        public void Merge(BoundingBox box)
        {
            Merge(ref this, ref box, out this);
        }

        public BoundingSphere ToBoundingSphere()
        {
            BoundingSphere result = new BoundingSphere();
            result.Center = this.Center;
            result.Radius = Vector3.Distance(Minimum, Maximum) * 0.5f;
            return result;
        }

        public override string ToString()
        {
            return Invariant($"Minimum:{Minimum} Maximum:{Maximum}");
        }

        #endregion

    }
}


text:
      <meta http-equiv="content-type" content="text/html; charset=UTF-8">
      <link rel="icon" type="image/png" href="/images/THD_logo.png" />
      <title>COM Messaging</title>

      <link rel="stylesheet" type="text/css" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.97.6/css/materialize.min.css">
      <link rel="stylesheet" type="text/css" href="https://fonts.googleapis.com/icon?family=Material+Icons">
      <link rel="stylesheet" type="text/css" href="/css/main.css">

      COM Messaging System

        <form class="col s12 offset">

              subtitles
              <input id="icon_prefix" type="text" disabled ng-model="appName" class="validate">

              mode_edit
              <textarea id="icon_prefix2" ng-model="messageText" class="materialize-textarea"></textarea>
              Message

              <button class="btn waves-effect waves-light btn-large" ng-click="getMessage()">GET MESSAGE
              call_received
              </button>

              <button class="btn waves-effect waves-light btn-large" ng-click="submitMessage()">SEND MESSAGE
              call_made
              </button>

                  {{serviceHeader}}

{{serviceData}}

                 settings_backup_restore

        </form>


text:
class node_stringoffset : public base_node
{
public:
	node_stringoffset(int id, bool us, const int con_count, std::string params, bool is_static, bool ut);
	~node_stringoffset();
	void update(float timestep = 0.0f);
	void init();
	void load_node_parameters(std::string params);
	connector* p_connections;
	int connection_count;
	void  set_connection(int pos, base_node* ptr, int dest_pos);
	virtual void serial_income(std::string message);
	//PARAMS

	//VALUES
	std::string p0_a_input; //interval
	int p1_b_input; //start
	std::string p2_c_output; //stop

	void set_value(int position, float value);
	void set_value(int position, int value);
	void set_value(int position, bool value);
	void set_value(int position, std::string value);

	float get_value_f(int position);
	int get_value_i(int position);
	bool get_value_b(int position);
	std::string get_value_s(int position);

private:

};


text:
from functools import wraps
from ..di.decorator import attr
from ..util.encoding import json_encoder

daos = []
services = []
controllers = []

def dao(cls):
    daos.append(cls)
    return cls

def service(cls):
    services.append(cls)
    return cls

def controller(cls):
    controllers.append(cls)
    return cls

def request_mapping(url='/', method='GET'):
    return attr('_request_mapping', dict(url=url, method=method))

def jsonview(f):
    @wraps(f)
    def _decorate(*args, **kwargs):
        body = json_encoder.encode(f(*args, **kwargs))
        return (body, 200, {'Content-Type': 'application/json'})
    return _decorate


text:
\c avdb

CREATE TABLE rights (
   id serial primary key,
   name varchar(20)
);

CREATE TABLE roles (
   id serial primary key,
   name varchar(20)
);

CREATE TABLE users (
   id serial primary key,
   name varchar(20),
   password varchar(20),
   create_date timestamp
);

CREATE TABLE role_rights (
   role_id integer references roles(id),
   right_id integer references rights(id)
);

CREATE TABLE user_roles (
   user_id integer references users(id),
   role_id integer references roles(id)
);

CREATE TABLE order_types (
   id serial primary key,
   name varchar(20)
);

CREATE TABLE order_states (
   id serial primary key,
   name varchar(20)
);

CREATE TABLE orders (
   id serial primary key,
   description varchar(255),
   create_date timestamp,
   order_type_id integer references order_types(id),
   order_state_id integer references order_states(id),
   user_id integer references users(id)
);

CREATE TABLE comments (
   id serial primary key,
   description varchar(2000),
   create_date timestamp,
   order_id integer references orders(id)
);

CREATE TABLE attachments (
   id serial primary key,
   file_content bytea,
   order_id integer references orders(id)
);


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Agaricus ignobilis Britzelm., 1890

### Remarks
null


text:
import { extend, notificationType } from 'flarum/extend';
import app from 'flarum/app';
import Model from 'flarum/Model';
import Discussion from 'flarum/models/Discussion';

import DiscussionStickiedPost from 'flarum/sticky/components/DiscussionStickiedPost';
import addStickyBadge from 'flarum/sticky/addStickyBadge';
import addStickyControl from 'flarum/sticky/addStickyControl';
import addStickyExcerpt from 'flarum/sticky/addStickyExcerpt';

app.initializers.add('flarum-sticky', () => {
  app.postComponents.discussionStickied = DiscussionStickiedPost;

  Discussion.prototype.isSticky = Model.attribute('isSticky');
  Discussion.prototype.canSticky = Model.attribute('canSticky');

  addStickyBadge();
  addStickyControl();
  addStickyExcerpt();
});


text:
<?php

declare(strict_types=1);

namespace OSInet\Beanstalkd\Munin;

use Pheanstalk\Exception;
use Pheanstalk\Exception\CommandException;

class QueueAgePlugin extends BasePlugin
{

    public array $tubes = [];

    public static function createFromGlobals(): QueueAgePlugin
    {
        /** @var \OSInet\Beanstalkd\Munin\QueueAgePlugin $instance */
        $instance = parent::createFromGlobals();

        $tubes = getenv('BEANSTALKD_TUBES') ?: 'default';
        $tubesArray = explode(' ', $tubes);

        foreach ($tubesArray as $tube) {
            $instance->tubes[$instance->cleanTube($tube)] = $tube;
        }

        return $instance;
    }

    public static function cleanTube($tube)
    {
        return str_replace('.', '_', $tube);
    }

    /**
     * {@inheritdoc}
     */
    public function config(): string
    {
        $ret = <<<'CONFIG'
graph_title Job Age
graph_vlabel Max Age
graph_category Beanstalk
graph_args --lower-limit 0
graph_scale no

CONFIG;

        foreach (array_keys($this->tubes) as $clean) {
            $ret .= sprintf("%s_jobs.label %s\n", $clean, $clean);
            $ret .= sprintf("%s_jobs.type GAUGE\n", $clean)
              . sprintf("%s_jobs.min 0\n", $clean);
        }
        return $ret;
    }

    /**
     * {@inheritdoc}
     */
    public function data(): string
    {
        $server = $this->server;
        $ret = '';

        foreach ($this->tubes as $clean => $tube) {
            $server->useTube($tube);
            try {
                $job = $server->peekReady();
            } catch (\Exception $exc) {
                $job = null;
            }

            $val = isset($job)
              ? $server->statsJob($job)['age']
              : 0;

            $ret .= sprintf("%s_jobs.value %d\n", $clean, $val);
        }

        return $ret;
    }
}


text:
#pragma once
#include <aws/sms/SMS_EXPORTS.h>
#include <aws/sms/SMSRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace SMS
{
namespace Model
{

  /**
   */
  class AWS_SMS_API GetReplicationJobsRequest : public SMSRequest
  {
  public:
    GetReplicationJobsRequest();
    Aws::String SerializePayload() const override;

    Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;

    inline const Aws::String& GetReplicationJobId() const{ return m_replicationJobId; }

    inline void SetReplicationJobId(const Aws::String& value) { m_replicationJobIdHasBeenSet = true; m_replicationJobId = value; }

    inline void SetReplicationJobId(Aws::String&& value) { m_replicationJobIdHasBeenSet = true; m_replicationJobId = std::move(value); }

    inline void SetReplicationJobId(const char* value) { m_replicationJobIdHasBeenSet = true; m_replicationJobId.assign(value); }

    inline GetReplicationJobsRequest& WithReplicationJobId(const Aws::String& value) { SetReplicationJobId(value); return *this;}

    inline GetReplicationJobsRequest& WithReplicationJobId(Aws::String&& value) { SetReplicationJobId(std::move(value)); return *this;}

    inline GetReplicationJobsRequest& WithReplicationJobId(const char* value) { SetReplicationJobId(value); return *this;}

    inline const Aws::String& GetNextToken() const{ return m_nextToken; }

    inline void SetNextToken(const Aws::String& value) { m_nextTokenHasBeenSet = true; m_nextToken = value; }

    inline void SetNextToken(Aws::String&& value) { m_nextTokenHasBeenSet = true; m_nextToken = std::move(value); }

    inline void SetNextToken(const char* value) { m_nextTokenHasBeenSet = true; m_nextToken.assign(value); }

    inline GetReplicationJobsRequest& WithNextToken(const Aws::String& value) { SetNextToken(value); return *this;}

    inline GetReplicationJobsRequest& WithNextToken(Aws::String&& value) { SetNextToken(std::move(value)); return *this;}

    inline GetReplicationJobsRequest& WithNextToken(const char* value) { SetNextToken(value); return *this;}

    inline int GetMaxResults() const{ return m_maxResults; }

    inline void SetMaxResults(int value) { m_maxResultsHasBeenSet = true; m_maxResults = value; }

    inline GetReplicationJobsRequest& WithMaxResults(int value) { SetMaxResults(value); return *this;}

  private:
    Aws::String m_replicationJobId;
    bool m_replicationJobIdHasBeenSet;
    Aws::String m_nextToken;
    bool m_nextTokenHasBeenSet;
    int m_maxResults;
    bool m_maxResultsHasBeenSet;
  };

} // namespace Model
} // namespace SMS
} // namespace Aws


text:
<?php

namespace SYSEADModulo\Form;

use Zend\Form\Form;
use Zend\Form\Element\Select;

class Modulo  extends Form
{

    protected $cursos;
    protected $professores;

    public function __construct($name = null, array $cursos = null, array $professores = null) {
        parent::__construct('modulo');
        $this->cursos = $cursos;
        $this->professores = $professores;

        $this->setInputFilter(new ModuloFilter());
        $this->setAttribute('method', 'post');

        $id = new \Zend\Form\Element\Hidden('id');
        $this->add($id);

        $descricao = new \Zend\Form\Element\Text("descricao");
        $descricao->setLabel("Descrição: ")
            ->setAttribute('placeholder','Entre com a Descrição do Modulo');
        $this->add($descricao);

        $curso = new Select();
        $curso->setLabel("Cusro: ")
            ->setName("curso")
            ->setOptions(array('value_options' => $this->cursos));
        $this->add($curso);

        $professor = new Select();
        $professor->setLabel("Professor: ")
            ->setName("professor")
            ->setOptions(array('value_options' => $this->professores));
        $this->add($professor);

        $this->add(array(
            'name' => 'submit',
            'type'=>'Zend\Form\Element\Submit',
            'attributes' => array(
                'value'=>'Salvar',
                'class' => 'btn-success'
            )
        ));

    }

}


text:
using base::android::JavaParamRef;
using base::android::ScopedJavaLocalRef;

// static
ScopedJavaLocalRef<jstring> JNI_OmniboxViewUtil_SanitizeTextForPaste(
    JNIEnv* env,
    const JavaParamRef<jstring>& jtext) {
  base::string16 pasted_text(
      base::android::ConvertJavaStringToUTF16(env, jtext));
  pasted_text = OmniboxView::SanitizeTextForPaste(pasted_text);
  return base::android::ConvertUTF16ToJavaString(env, pasted_text);
}


text:
/**
 * This software is released as part of the Pumpernickel project.
 *
 * All com.pump resources in the Pumpernickel project are distributed under the
 * MIT License:
 * https://github.com/mickleness/pumpernickel/raw/master/License.txt
 *
 * More information about the Pumpernickel project is available here:
 * https://mickleness.github.io/pumpernickel/
 */
package com.pump.util;

/**
 * A minimal interface for an object that stores key/value pairs. You can create
 * a Storage object that maps to a Hashtable, to particular Preferences, etc.
 */
public interface Storage {
	/**
	 * Stores a key/value pair.
	 *
	 * @param key
	 *            the key to define
	 * @param value
	 *            the value to store
	 * @return true if this call changed the existing value of
	 *         key
	 */
	public boolean put(Object key, String value);

	/**
	 * Retrieves a key/value pair.
	 *
	 * @param key
	 *            the key to consult
	 * @return the String associated with that key
	 */
	public String get(Object key);
}


text:
Celebrate!
=========

Run this ruby script when you do something awesome to throw yourself a party.  You deserve it!

Install
=========
make the thing executable
  chmod 755 celebrate

then make a symbolic link in your path
  ln -s ~/path/to/celebrate /usr/local/bin


text:
  <app-panel topic="typescript"></app-panel>
  <app-panel topic="angular2"></app-panel>
  <app-mixpanel topic="weather"></app-mixpanel>


text:
package prototypeGameEngine.component;

public abstract class GameComponent {
	public void render(){

	};

	public void update(){

	};

	public void init(){

	};

	public void input(){

	};
}


text:
//
//  TRMeInteractive.h
//  TRHouse
//
//  Created by wgf on 16/10/18.
//  Copyright © 2016年 wgf. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface TRMeInteractive : NSObject

/** userId */
@property (nonatomic, copy) NSString *userId;

/** 用户昵称 */
@property (nonatomic, copy) NSString *userName;

/** 用户头像 */
@property (nonatomic, copy) NSString *icon;

/** 互动id */
@property (nonatomic, assign) NSInteger interactiveId;

/** 创建时间 */
@property (nonatomic, copy) NSString *time;

@end