text:
<b:beans xmlns="http://www.springframework.org/schema/security"
		 xmlns:b="http://www.springframework.org/schema/beans"
		 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
		 xsi:schemaLocation="http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/security https://www.springframework.org/schema/security/spring-security.xsd">
	<http />

	<user-service>
		<user name="user" password="{noop}password" authorities="ROLE_USER" />
	</user-service>
</b:beans>

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

        <title>IIIF Test: Mirador Viewer</title>

        <meta charset="UTF-8" />
        <meta name="viewport" content="width=device-width, initial-scale=1" />

        <link rel="stylesheet" type="text/css" href="css/mirador-combined.min.css" />


text:
package vpc

//Licensed under the Apache License, Version 2.0 (the "License");
//you may not use this file except in compliance with the License.
//You may obtain a copy of the License at
//
//http://www.apache.org/licenses/LICENSE-2.0
//
//Unless required by applicable law or agreed to in writing, software
//distributed under the License is distributed on an "AS IS" BASIS,
//WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//See the License for the specific language governing permissions and
//limitations under the License.
//
// Code generated by Alibaba Cloud SDK Code Generator.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

import (
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
	"github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses"
)

// GetNatGatewayAttribute invokes the vpc.GetNatGatewayAttribute API synchronously
func (client *Client) GetNatGatewayAttribute(request *GetNatGatewayAttributeRequest) (response *GetNatGatewayAttributeResponse, err error) {
	response = CreateGetNatGatewayAttributeResponse()
	err = client.DoAction(request, response)
	return
}

// GetNatGatewayAttributeWithChan invokes the vpc.GetNatGatewayAttribute API asynchronously
func (client *Client) GetNatGatewayAttributeWithChan(request *GetNatGatewayAttributeRequest) (<-chan *GetNatGatewayAttributeResponse, <-chan error) {
	responseChan := make(chan *GetNatGatewayAttributeResponse, 1)
	errChan := make(chan error, 1)
	err := client.AddAsyncTask(func() {
		defer close(responseChan)
		defer close(errChan)
		response, err := client.GetNatGatewayAttribute(request)
		if err != nil {
			errChan <- err
		} else {
			responseChan <- response
		}
	})
	if err != nil {
		errChan <- err
		close(responseChan)
		close(errChan)
	}
	return responseChan, errChan
}

// GetNatGatewayAttributeWithCallback invokes the vpc.GetNatGatewayAttribute API asynchronously
func (client *Client) GetNatGatewayAttributeWithCallback(request *GetNatGatewayAttributeRequest, callback func(response *GetNatGatewayAttributeResponse, err error)) <-chan int {
	result := make(chan int, 1)
	err := client.AddAsyncTask(func() {
		var response *GetNatGatewayAttributeResponse
		var err error
		defer close(result)
		response, err = client.GetNatGatewayAttribute(request)
		callback(response, err)
		result <- 1
	})
	if err != nil {
		defer close(result)
		callback(nil, err)
		result <- 0
	}
	return result
}

// GetNatGatewayAttributeRequest is the request struct for api GetNatGatewayAttribute
type GetNatGatewayAttributeRequest struct {
	*requests.RpcRequest
	ResourceOwnerId      requests.Integer `position:"Query" name:"ResourceOwnerId"`
	NatGatewayId         string           `position:"Query" name:"NatGatewayId"`
	ResourceOwnerAccount string           `position:"Query" name:"ResourceOwnerAccount"`
	OwnerAccount         string           `position:"Query" name:"OwnerAccount"`
	OwnerId              requests.Integer `position:"Query" name:"OwnerId"`
}

// GetNatGatewayAttributeResponse is the response struct for api GetNatGatewayAttribute
type GetNatGatewayAttributeResponse struct {
	*responses.BaseResponse
	RequestId              string                 `json:"RequestId" xml:"RequestId"`
	Description            string                 `json:"Description" xml:"Description"`
	NatType                string                 `json:"NatType" xml:"NatType"`
	EcsMetricEnabled       bool                   `json:"EcsMetricEnabled" xml:"EcsMetricEnabled"`
	VpcId                  string                 `json:"VpcId" xml:"VpcId"`
	NatGatewayId           string                 `json:"NatGatewayId" xml:"NatGatewayId"`
	CreationTime           string                 `json:"CreationTime" xml:"CreationTime"`
	ExpiredTime            string                 `json:"ExpiredTime" xml:"ExpiredTime"`
	Name                   string                 `json:"Name" xml:"Name"`
	Status                 string                 `json:"Status" xml:"Status"`
	BusinessStatus         string                 `json:"BusinessStatus" xml:"BusinessStatus"`
	RegionId               string                 `json:"RegionId" xml:"RegionId"`
	ResourceGroupId        string                 `json:"ResourceGroupId" xml:"ResourceGroupId"`
	ForwardTable           ForwardTable           `json:"ForwardTable" xml:"ForwardTable"`
	SnatTable              SnatTable              `json:"SnatTable" xml:"SnatTable"`
	BillingConfig          BillingConfig          `json:"BillingConfig" xml:"BillingConfig"`
	PrivateInfo            PrivateInfo            `json:"PrivateInfo" xml:"PrivateInfo"`
	DeletionProtectionInfo DeletionProtectionInfo `json:"DeletionProtectionInfo" xml:"DeletionProtectionInfo"`
	IpList                 []IpListItem           `json:"IpList" xml:"IpList"`
}

// CreateGetNatGatewayAttributeRequest creates a request to invoke GetNatGatewayAttribute API
func CreateGetNatGatewayAttributeRequest() (request *GetNatGatewayAttributeRequest) {
	request = &GetNatGatewayAttributeRequest{
		RpcRequest: &requests.RpcRequest{},
	}
	request.InitWithApiInfo("Vpc", "2016-04-28", "GetNatGatewayAttribute", "vpc", "openAPI")
	request.Method = requests.POST
	return
}

// CreateGetNatGatewayAttributeResponse creates a response to parse from GetNatGatewayAttribute response
func CreateGetNatGatewayAttributeResponse() (response *GetNatGatewayAttributeResponse) {
	response = &GetNatGatewayAttributeResponse{
		BaseResponse: &responses.BaseResponse{},
	}
	return
}


text:
function clickHandlers(){

}

function formHandlers(){
    $("#frmIletisim").ajaxForm(function(data){
        $("input").val("");
        $("textarea").val("");
        alertify.success("Bayi başarıyla eklendi");
    });
}

function otherScripts(){

}


text:
package usps

import (
	"fmt"
	"os"
	"testing"
)

func TestRateDomestic(*testing.T) {
	var usps USPS
	usps.Username = os.Getenv("USPSUsername")
	usps.Production = true

	var rate RateRequest
	rate.Service = "PRIORITY"
	rate.ZipOrigination = "44106"
	rate.ZipDestination = "20770"
	rate.Pounds = "1"
	rate.Ounces = "8"
	rate.Container = "NONRECTANGULAR"
	rate.Size = "LARGE"
	rate.Width = "15"
	rate.Length = "30"
	rate.Height = "15"
	rate.Girth = "55"

	output := usps.RateDomestic(rate)
	fmt.Println(output)

	usps.Production = false
	//if output.Error != "API Authorization failure. User "+usps.Username+" is not authorized to use API CarrierPickupAvailability." {
	//	t.Error("Pickup availability is incorrect.")
	//}
}


text:
from BasicSpiderConfig import ExRule
from collections import OrderedDict
from misc.common import *
from misc.log import *
import re

class Config:

    list_css_rules = {
        '#live-list-contentbox li': {
            'url': 'a::attr(href)',
            'room_name': 'a::attr(title)',
            'tag': 'span.tag.ellipsis::text',
            'audience_count': '.dy-num.fr::text',
            'anchor': '.dy-name::text',
            'platform': ['douyu'],
            'platform_prefix_url': ['http://www.douyu.com/'],
        }
    }

    ex_rule = ExRule('http://www.douyu.com/all$', list_css_rules=list_css_rules)

    name='douyu.com'
    allowed_domains=['douyu.com']
    start_urls=['http://www.douyu.com/directory/all']
    ex_rules = []
    follow = False

    @staticmethod
    def deal_human_readable_numbers(hrn=''):
        numbers = re.findall(r'\d+\.?\d*', hrn)
        if len(numbers) == 0:
            return 0
        elif len(numbers) > 1:
            warn('suspect numbers:'+str(numbers))

        number = float(numbers[0])

        # FIXME magic logic. Consider to add log here.
        if hrn.endswith(u'万'):
            number = (number * 10000.0)
        return str(int(number))

    # Note that if not force 1 item, item['audience_count'] would contain a list.
    @staticmethod
    def update_audience_count(item):
        if type(item['audience_count']) != list:
            return

        audience_count = [Config.deal_human_readable_numbers(i) for i in item['audience_count']]
        item['audience_count'] = audience_count

    @staticmethod
    def preprocess_item(list_item):
        oi = OrderedDict(list_item)

        process_items_from_list(oi, Config.update_audience_count)

        # for item in items:
            # audience_count = Config.deal_human_readable_numbers(item['audience_count'])
            # print(item['url'], item['audience_count'], audience_count)
            # item['audience_count'] = audience_count
            # info(item)

        # info('------------------')
        # info(items)
        info('------------------')
        info(oi)

        info('## preprocess_item')
        # info(len(oi))
        return oi


text:
//
//  ModuleBoxScalarValues.h
//  Objective-C Learning
//
//  Created by Dmitry Kholodilin on 28.07.15.
//  Copyright © 2015 Dmitry Kholodilin. All rights reserved.
//

#ifndef ModuleBoxScalarValues
#define ModuleBoxScalarValues

/**
 * Box scalar values
 * @param int argc
 * @param char argv
 * @return void
 */
extern void m_box_scalar_values(int argc, const char * argv[]);

#endif


text:
<?php

namespace Gear\Traits;

use Gear\Core;
use Gear\Interfaces\ComponentInterface;
use Gear\Interfaces\ObjectInterface;

trait ComponentContainedTrait
{
    /**
     * @var array<ComponentInterface> $_components массив установленных компонентов у объекта
     */
    protected array $_components = [];

    /**
     * Автозагрузка необходимых компонентов во время создания объекта-контейнера
     *
     * @param array $components
     * @return void
     * @since 0.0.1
     * @version 0.0.1
     */
    protected function _bootstrapComponents(array $components)
    {
        foreach ($components as $name => $component) {
            $this->installComponent($name, $component);
        }
    }

    /**
     * Возвращает установленный компонент
     *
     * @param string $name
     * @param ObjectInterface|null $owner
     * @return ComponentInterface
     * @since 0.0.1
     * @version 0.0.2
     */
    public function c(string $name, ObjectInterface $owner = null): ComponentInterface
    {
        if (!($component = $this->isComponentInstalled($name))) {
            if (!($component = $this->isComponentRegistered($name)))
                throw static::ComponentNotFoundException(['name' => $name, 'class' => get_class($this), 'file' => __FILE__, 'line' => __LINE__]);
            $component = $this->installComponent($name, $component, $owner);
        }
        return $component;
    }

    /**
     * Возвращает массив установленных компонентов
     *
     * @return array
     * @since 0.0.1
     * @version 0.0.1
     */
    public function getComponents(): array
    {
        return $this->_components;
    }

    /**
     * Возвращает массив зарегистрированных компонентов
     *
     * @return array
     * @since 0.0.1
     * @version 0.0.1
     */
    public function getRegisteredComponents(): array
    {
        $components = static::i('components');
        return is_array($components) ? $components : [];
    }

    /**
     * Установка компонента
     *
     * @param string $name
     * @param array|ComponentInterface|\Closure $component
     * @param ObjectInterface|null $owner
     * @return ComponentInterface
     * @since 0.0.1
     * @version 0.0.2
     */
    public function installComponent(string $name, $component, ObjectInterface $owner = null): ComponentInterface
    {
        if ($component instanceof \Closure) {
            $component = $component($name, $owner);
        }
        if (is_array($component)) {
            list($class, $config, $properties) = Core::configure($component);
            $component = $class::install($config, $properties, $owner ?: $this);
        }
        if (!($component instanceof ComponentInterface))
            throw static::ComponentInstallationIsInvalidException(['name' => $name, 'class' => get_class($this), 'file' => __FILE__, 'line' => __LINE__]);
        $this->_components[$name] = $component;
        return $component;
    }

    /**
     * Проверка на наличие указанного компонента. Возвращает инстанс компонента или false, если такой не был найден
     *
     * @param string $name
     * @return bool|ComponentInterface
     * @since 0.0.1
     * @version 0.0.2
     */
    public function isComponent(string $name)
    {
        if (!($component = isset($this->_components[$name]))) {
            $component = static::i('components');
            $component = isset($component[$name]) ? $this->installComponent($name, $component[$name]) : false;
        }
        return $component;
    }

    /**
     * Возвращает компонент если он установлен, иначе возвращает false
     *
     * @param string $name
     * @return bool|ComponentInterface
     * @since 0.0.1
     * @version 0.0.2
     */
    public function isComponentInstalled(string $name)
    {
        return isset($this->_components[$name]) ? $this->_components[$name] : false;
    }

    /**
     * Возвращает конфигурационную запись зарегистрированного компонента, иначе возвращается false
     *
     * @param string $name
     * @return bool|array
     * @since 0.0.1
     * @version 0.0.1
     */
    public function isComponentRegistered(string $name)
    {
        $component = false;
        if (isset(static::$_config['components'][$name]))
            $component = static::$_config['components'][$name];
        elseif (isset(self::$_config['components'][$name]))
            $component = self::$_config['components'][$name];
        return $component;
    }

    /**
     * Регистрация компонента
     *
     * @param string $name
     * @param array|string|\Closure $component
     * @return void
     * @since 0.0.1
     * @version 0.0.1
     */
    public function registerComponent(string $name, $component)
    {
        if ($component instanceof \Closure)
            $component = $component($name);
        if (!is_array($component))
            throw static::ComponentRegisteringIsInvalidException(['name' => $name, 'class' => get_class($this), 'file' => __FILE__, 'line' => __LINE__]);
        static::$_config['components'][$name] = $component;
    }

    /**
     * Деинсталляция компонента
     *
     * @param string $name
     * @return void
     * @since 0.0.1
     * @version 0.0.2
     */
    public function uninstallComponent(string $name)
    {
        if (isset($this->_components[$name])) {
            $this->c($name)->uninstall();
            unset($this->_components[$name]);
        }
    }
}


text:
define(['./difference', './slice'], function (difference, slice) {

    /**
     * Insert item into array if not already present.
     */
    function insert(arr, rest_items) {
        var diff = difference(slice(arguments, 1), arr);
        if (diff.length) {
            Array.prototype.push.apply(arr, diff);
        }
        return arr.length;
    }
    return insert;
});


text:
define(["jquery", "bootstrap"], function($) {
	"use strict";

	var RajoUiBootstrapModal = {
		dialogInformationImage: "/resources/images/dialog-information.png",
		dialogErrorImage: "/resources/images/dialog-error.png"
	};

	/**
	 * Class: rajo.ui.bootstrapmodal.Modal
	 * Wrapper for the Twitter Bootstrap modal plugin. This object
	 * generates all the necessary markup for you so you don't have to.
	 *
	 * Author:
	 *    Adam Presley
	 *
	 * Constructor:
	 * Takes a config object.
	 *
	 *    * id - ID of the generated top-level DOM element. Defaults to bsp-modal-{datetimestamp}
	 *    * header - Title of the modal dialog
	 *    * headerStyle - Additional style information for the header DIV
	 *    * body - Contents of the body DIV for this dialog
	 *    * bodyStyle - Additional style information for the body DIV
	 *    * buttons - Object where each key is the button text. The value is an object with information about the button. See below
	 *    * keyboard - True/false to allow keyboard shortcuts
	 *    * backdrop - True/false to show a backdrop when this dialog is displayed
	 *    * show - True/false to show on instantiation
	 *    * animate - True/false to animate the display of this dialog
	 *
	 * A button config takes an object with up to two keys.
	 *    * handler - Function to handle the click of this button. Required
	 *    * type - "Primary" to make this a primary styled button.
	 *
	 * Example:
	 *    > require(["rajo.ui.bootstrapmodal"], function(RajoModal) {
	 *    >    var modal = new RajoModal.Modal({
	 *    >       header: "Example Dialog",
	 *    >       body: "
This is a modal dialog box.
",
	 *    >       buttons: {
	 *    >          "Thanks, Got It": {
	 *    >             type: "primary",
	 *    >             handler: { window.location = '/'; }
	 *    >          }
	 *    >       }
	 *    >    });
	 */
	RajoUiBootstrapModal.Modal = function(config) {
		/**
		 * Function: getId
		 * Return the ID assigned to this dialog
		 */
		this.getId = function() {
			return __config.id;
		};

		/**
		 * Function: close
		 * Closes this dialog by calling the "hide" Bootstrap method
		 */
		this.close = function() {
			__$modalDiv.modal("hide");
		};

		/**
		 * Function: show
		 * Shows this dialog by called the "show" Bootstrap method
		 */
		this.show = function() {
			__$modalDiv.modal("show");
		};

		/**
		 * Function: toggle
		 * Toggles the visibility of this dialog
		 */
		this.toggle = function() {
			__$modalDiv.modal("toggle");
		};

		var
			__init = function() {
				var
					$dialog,
					$content,
					$header,
					$closeAnchor,
					$headerDiv,
					$body,
					$footer,

					item,
					cls;

				__$modalDiv = $("
").attr({
					"class": "modal " + ((__config.animate) ? " fade" : ""),
					id: __config.id
				});

				/*
				 * Dialog
				 */
				$dialog = $("
").attr({
					"class": "modal-dialog"
				});

				/*
				 * Content div
				 */
				$content = $("
").attr({
					"class": "modal-content"
				});

				/*
				 * Header
				 */
				$closeAnchor = $("<button />").attr({
					"type": "button",
					"class": "close",
					"data-dismiss": "modal",
					"aria-hidden": true
				}).html("×");

				$header = $("
").html(__config.header);

				$headerDiv = $("
").attr({ "class": "modal-header" });
				if (__config.headerStyle.length > 0) $headerDiv.attr({ "style": __config.headerStyle });
				$headerDiv.append($closeAnchor);
				$headerDiv.append($header);

				/*
				 * Body
				 */
				$body = $("
").attr({ "class": "modal-body" }).html(__config.body);
				if (__config.bodyStyle.length > 0) $body.attr({ "style": __config.bodyStyle });

				/*
				 * Footer
				 */
				$footer = $("
").attr({ "class": "modal-footer" });

				for (item in __config.buttons) {
					cls = "btn" + ((__config.buttons[item].type && __config.buttons[item].type === "primary") ? " btn-primary" : "");
					var $btn = $("<button />").attr({ type: "button", href: "#", "class": cls, id: __generateId("item"), name: __generateId("item") });
					var txt = "";

					if (__config.buttons[item].icon) {
						txt += " ";
					}

					txt += item;
					$btn.html(txt).on("click", __config.buttons[item].handler).appendTo($footer);
				}

				/*
				 * Craft the final modal
				 */
				$content.append($headerDiv);
				$content.append($body);
				$content.append($footer);
				$dialog.append($content);
				__$modalDiv.append($dialog);

				$("body").append(__$modalDiv);

				__$modalDiv.modal({ keyboard: __config.keyboard, backdrop: __config.backdrop, show: __config.show });
				__$modalDiv.on("hidden", __destroy);

				__attachEvents();
			},

			__attachEvents = function() {
				var makeHiddenHandler = function(e) {
					return function() {
						__destroy();
						__config.events[e]();
					};
				};

				for (var e in __config.events) {
					if (e === "hidden") {
						__$modalDiv.on(e, makeHiddenHandler(e));
					}
					else {
						__$modalDiv.on(e, __config.events[e]);
					}
				}
			},

			__destroy = function() {
				__$modalDiv.remove();
			},

			__generateId = function(prefix) {
				return prefix + (new Date().getTime());
			},

			__this = this,
			__config = $.extend({
				id: __generateId("bsp-modal-"),
				header: "Header",
				headerStyle: "",
				body: "",
				bodyStyle: "",
				buttons: {
					"Close": { type: "primary", handler: function(target) { __this.close(); } }
				},

				keyboard: true,
				backdrop: true,
				show: true,
				animate: true,

				events: {}
			}, config),

			__$modalDiv;

		__init();
	};

	/**
	 * Class: rajo.ui.bootstrapmodal.Modal.YesNo
	 * A specialized version of the <rajo.ui.bootstrapmodal.Modal> class which offers
	 * a pre-built dialog with Yes and No buttons.
	 *
	 * For config information see <rajo.ui.bootstrapmodal.Modal>
	 *
	 * Author:
	 *    Adam Presley
	 */
	RajoUiBootstrapModal.Modal.YesNo = function(config) {
		var
			__this = this,
			__config = $.extend({
				header: config.header || "Header",
				body: config.body || "Are you sure?",
				buttons: {
					"Yes": {
						handler: function(target) {
							if (config.handler) {
								if (config.hasOwnProperty("scope")) {
									config.handler.call(config.scope, "yes", target);
								} else {
									config.handler("yes", target);
								}
							}

							__this.modal.close();
						},
						icon: "thumbs-up"
					},
					"No": {
						type: "primary",
						handler: function(target) {
							if (config.handler) {
								if (config.hasOwnProperty("scope")) {
									config.handler.call(config.scope, "no", target);
								} else {
									config.handler("no", target);
								}
							}

							__this.modal.close();
						},
						icon: "thumbs-down"
					}
				},
				show: config.show || true
			}, config);

		this.modal = new RajoUiBootstrapModal.Modal(__config);
	};

	/**
	 * Class: rajo.ui.bootstrapmodal.Modal.OK
	 * A specialized version of the <rajo.ui.bootstrapmodal.Modal> class which offers
	 * a pre-built dialog with an OK button.
	 *
	 * For config information see <rajo.ui.bootstrapmodal.Modal>
	 *
	 * Author:
	 *    Adam Presley
	 */
	RajoUiBootstrapModal.Modal.OK = function(config) {
		var
			__this = this,
			__config = $.extend({
				header: config.header || "Confirmation",
				body: config.body || "OK",
				buttons: {
					"OK": {
						type: "primary",
						handler: function(target) {
							if (config.handler) {
								if (config.hasOwnProperty("scope")) {
									config.handler.call(config.scope, "ok", target);
								} else {
									config.handler("ok", target);
								}
							}

							__this.modal.close();
						}
					}
				},
				show: config.show || true
			}, config);

		this.modal = new RajoUiBootstrapModal.Modal(__config);
	};

	/**
	 * Class: rajo.ui.bootstrapmodal.Modal.OkCancel
	 * A specialized version of the <rajo.ui.bootstrapmodal.Modal> class which offers
	 * a pre-built dialog with OK and Cancel buttons.
	 *
	 * For config information see <rajo.ui.bootstrapmodal.Modal>
	 *
	 * Author:
	 *    Adam Presley
	 */
	RajoUiBootstrapModal.Modal.OkCancel = function(config) {
		var
			__this = this,
			__config = $.extend({
				header: config.header || "Confirmation",
				body: config.body || "OK",
				buttons: {
					"OK": {
						type: "primary",
						handler: function(target) {
							if (config.handler) {
								if (config.hasOwnProperty("scope")) {
									config.handler.call(config.scope, "ok", target);
								} else {
									config.handler("ok", target);
								}
							}

							__this.modal.close();
						}
					},
					"Cancel": {
						handler: function(target) {
							if (config.handler) {
								if (config.hasOwnProperty("scope")) {
									config.handler.call(config.scope, "cancel", target);
								} else {
									config.handler("cancel", target);
								}
							}

							__this.modal.close();
						}
					}
				},
				show: config.show || true
			}, config);

		this.modal = new RajoUiBootstrapModal.Modal(__config);
	};

	/**
	 * Class: rajo.ui.bootstrapmodal.Modal.Error
	 * A specialized version of the <rajo.ui.bootstrapmodal.Modal> class which offers
	 * a pre-built dialog with an OK button and an error icon.
	 *
	 * For config information see <rajo.ui.bootstrapmodal.Modal>
	 *
	 * Author:
	 *    Adam Presley
	 */
	RajoUiBootstrapModal.Modal.Error = function(config) {
		var
			__this = this,
			__config = $.extend({
				header: config.header || "Error",
				body: config.body || "Error",
				buttons: {
					"OK": {
						type: "primary",
						handler: function(target) {
							if (config.handler) {
								if (config.hasOwnProperty("scope")) {
									config.handler.call(config.scope, "ok", target);
								} else {
									config.handler("ok", target);
								}
							}

							__this.modal.close();
						}
					}
				},
				show: config.show || true
			}, config);

		__config.body = "" + __config.body;
		this.modal = new RajoUiBootstrapModal.Modal(__config);
	};

	return RajoUiBootstrapModal;
});


text:
""" Imports Maya API methods in the 'api' namespace, and defines various utilities for Python<->API communication """

# They will be imported / redefined later in Pymel, but we temporarily need them here
import sys, inspect, time, os.path

import pymel.api as api
import pymel.versions as versions
from pymel.util import expandArgs
import pymel.util as _util
import startup
import plogging as _plogging

_logger = _plogging.getLogger(__name__)

class ApiEnum(tuple):
    def __str__(self): return '.'.join( [str(x) for x in self] )
    def __repr__(self):
        return '%s( %s )' % (self.__class__.__name__, super(ApiEnum, self).__repr__())
    def pymelName(self):
        import pymel.internal.factories as factories
        parts = list(self)
        pymelName = factories.apiClassNameToPymelClassName(self[0])
        if pymelName is not None:
            parts[0] = pymelName
        return '.'.join( [str(x) for x in parts] )

if versions.current() < versions.v2012:
    # Before 2012, api had Enum, and when we unpickle the caches, it will
    # need to be there... could rebuild the caches (like I had to do with
    # mayaApiMelBridge) but don't really want to...
    api.Enum = ApiEnum
    Enum = ApiEnum

def _makeDgModGhostObject(mayaType, dagMod, dgMod):
    # we create a dummy object of this type in a dgModifier (or dagModifier)
    # as the dgModifier.doIt() method is never called, the object
    # is never actually created in the scene

    # Note: at one point, if we didn't call the dgMod/dagMod.deleteNode method,
    # and we call this function while loading a scene (for instance, if the scene requires
    # a plugin that isn't loaded, and defines custom node types), then the nodes were still
    # somehow created, despite never explicitly calling doIt()...
    # ... however, this seems to no longer be the case, and the deleteNode calls are apparently
    # harmful
    if type(dagMod) is not api.MDagModifier or type(dgMod) is not api.MDGModifier :
        raise ValueError, "Need a valid MDagModifier and MDGModifier or cannot return a valid MObject"

    # Regardless of whether we're making a DG or DAG node, make a parent first -
    # for some reason, this ensures good cleanup (don't ask me why...??)
    parent = dagMod.createNode ( 'transform', api.MObject())

    try :
        # DependNode
        obj = dgMod.createNode ( mayaType )
    except RuntimeError:
        # DagNode
        try:
            obj = dagMod.createNode ( mayaType, parent )
        except Exception, err:
            _logger.debug("Error trying to create ghost node for '%s': %s" %  (mayaType, err))
            return None

    if api.isValidMObject(obj) :
        return obj
    else :
        _logger.debug("Error trying to create ghost node for '%s'" %  mayaType)
        return None

def _defaultdictdict(cls, val=None):
    if val is None:
        return _util.defaultdict(dict)
    else:
        return _util.defaultdict(dict, val)

class ApiMelBridgeCache(startup.SubItemCache):
    NAME = 'mayaApiMelBridge'
    DESC = 'the API-MEL bridge'
    COMPRESSED = True
    USE_VERSION = False
    _CACHE_NAMES = '''apiToMelData apiClassOverrides'''.split()

    CACHE_TYPES = {'apiToMelData':_defaultdictdict}
    STORAGE_TYPES = {'apiToMelData':dict}

class ApiCache(startup.SubItemCache):
    NAME = 'mayaApi'
    DESC = 'the API cache'
    COMPRESSED = True
    USE_VERSION = True
    _CACHE_NAMES = '''apiTypesToApiEnums apiEnumsToApiTypes mayaTypesToApiTypes
                   apiTypesToApiClasses apiClassInfo'''.split()

    EXTRA_GLOBAL_NAMES = tuple('''reservedMayaTypes reservedApiTypes
                            mayaTypesToApiEnums'''.split())

    # Descriptions of various elements:

    # Maya static info :
    # Initializes various static look-ups to speed up Maya types conversions
    # self.apiClassInfo
    # self.apiTypesToApiEnums
    # self.apiEnumsToApiTypes
    # self.apiTypesToApiClasses

    # Reserved Maya types and API types that need a special treatment (abstract types)
    # TODO : parse docs to get these ? Pity there is no kDeformableShape to pair with 'deformableShape'
    # strangely createNode ('cluster') works but dgMod.createNode('cluster') doesn't
    # self.reservedMayaTypes
    # self.reservedApiTypes

    # Lookup of currently existing Maya types as keys with their corresponding API type as values.
    # Not a read only (static) dict as these can change (if you load a plugin)
    # self.mayaTypesToApiTypes

    # lookup tables for a direct conversion between Maya type to their MFn::Types enum
    # self.mayaTypesToApiEnums

    # TODO: may always need a manual map from reserved types to apiType,
    # but may want to dynamically generate the list of abstract types
    # (and possibly manipulators)?
    # see maintenance/inheritance.py for sample of how to create list
    # of abstract types
    RESERVED_TYPES = { 'invalid':'kInvalid', 'base':'kBase',
                'object':'kNamedObject',
                'dependNode':'kDependencyNode', 'dagNode':'kDagNode',
                'entity':'kDependencyNode',
                'constraint':'kConstraint', 'field':'kField',
                'geometryShape':'kGeometric', 'shape':'kShape',
                'deformFunc':'kDeformFunc', 'cluster':'kClusterFilter',
                'dimensionShape':'kDimension',
                'abstractBaseCreate':'kCreate', 'polyCreator':'kPolyCreator',
                'polyModifier':'kMidModifier', 'subdModifier':'kSubdModifier',
                'curveInfo':'kCurveInfo',
                'curveFromSurface':'kCurveFromSurface',
                'surfaceShape': 'kSurface',
                'revolvedPrimitive':'kRevolvedPrimitive',
                'plane':'kPlane', 'curveShape':'kCurve',
                'animCurve': 'kAnimCurve',
                'resultCurve':'kResultCurve', 'cacheBase':'kCacheBase',
                'filter':'kFilter',
                'blend':'kBlend', 'ikSolver':'kIkSolver',
                'light':'kLight', 'renderLight':'kLight',
                'nonAmbientLightShapeNode':'kNonAmbientLight',
                'nonExtendedLightShapeNode':'kNonExtendedLight',
                'texture2d':'kTexture2d', 'texture3d':'kTexture3d',
                'textureEnv':'kTextureEnv',
                'primitive':'kPrimitive', 'reflect':'kReflect',
                'smear':'kSmear',
                'plugin':'kPlugin',
                'THdependNode':'kPluginDependNode',
                'THlocatorShape':'kPluginLocatorNode',
                'pluginData':'kPluginData',
                'THdeformer':'kPluginDeformerNode',
                'pluginConstraint':'kPluginConstraintNode',
                'unknown':'kUnknown', 'unknownDag':'kUnknownDag',
                'unknownTransform':'kUnknownTransform',
                'dynBase': 'kDynBase',
                'polyPrimitive': 'kPolyPrimitive',
                'nParticle': 'kNParticle',
                'birailSrf': 'kBirailSrf', 'pfxGeometry': 'kPfxGeometry',

                # creating these 2 crash Maya
                'xformManip':'kXformManip',
                'moveVertexManip':'kMoveVertexManip',
    }

    def __init__(self):
        super(ApiCache, self).__init__()
        for name in self.EXTRA_GLOBAL_NAMES:
            setattr(self, name, {})

    def _buildMayaToApiInfo(self, mayaTypes):
        # Fixes for types that don't have a MFn by faking a node creation and testing it
        # Make it faster by pre-creating the nodes used to test
        dagMod = api.MDagModifier()
        dgMod = api.MDGModifier()

        # Put in a debug, because this can be crashy
        _logger.debug("Starting to create ghost nodes...")

        unknownTypes = set()

        for mayaType in mayaTypes :
            apiType = None
            if self.reservedMayaTypes.has_key(mayaType) :
                apiType = self.reservedMayaTypes[mayaType]
            else:
                obj = _makeDgModGhostObject(mayaType, dagMod, dgMod)
                if obj :
                    apiType = obj.apiTypeStr()
                else:
                    unknownTypes.add(mayaType)
            if apiType is not None:
                self.mayaTypesToApiTypes[mayaType] = apiType

        # Put in a debug, because this can be crashy
        _logger.debug("...finished creating ghost nodes")

        if len(unknownTypes) > 0:
            _logger.warn("Unable to get maya-to-api type info for the following nodes: %s" % ", ".join(unknownTypes))

        for mayaType, apiType in self.mayaTypesToApiTypes.iteritems() :
            self.addMayaType( mayaType, apiType )

    def _buildApiTypesList(self):
        """the list of api types is static.  even when a plugin registers a new maya type, it will be associated with
        an existing api type"""

        self.apiTypesToApiEnums = dict( inspect.getmembers(api.MFn, lambda x:type(x) is int))
        self.apiEnumsToApiTypes = dict( (self.apiTypesToApiEnums[k], k) for k in self.apiTypesToApiEnums.keys())

    def _buildMayaReservedTypes(self, force=False):
        """
        Build a list of Maya reserved types.
        These cannot be created directly from the API, thus the dgMod trick to find the corresponding Maya type won't work
        """
        # Must have already built apiTypesToApiEnums

        if not force and (getattr(self, 'reservedMayaTypes', None)
                          and getattr(self, 'reservedApiTypes', None) ):
            return

        # no known api types: these do not have valid api types, so we add them in to avoid querying them on each load
        invalidReservedTypes = {'deformableShape' : 'kInvalid', 'controlPoint' : 'kInvalid'}

        # filter to make sure all these types exist in current version (some are Maya2008 only)
        self.reservedMayaTypes = dict( (item[0], item[1]) for item in filter(lambda i:i[1] in self.apiTypesToApiEnums, self.RESERVED_TYPES.iteritems()) )
        self.reservedMayaTypes.update(invalidReservedTypes)
        # build reverse dict
        self.reservedApiTypes = dict( (item[1], item[0]) for item in self.reservedMayaTypes.iteritems() )

    ## Initialises MayaTypes for a faster later access
    #def _buildMayaTypesList() :
    #    """Updates the cached MayaTypes lists """
    #    start = time.time()
    #    from maya.cmds import ls as _ls
    #    # api types/enums dicts must be created before reserved type bc they are used for filtering
    #    self._buildMayaReservedTypes()
    #
    #    # use dict of empty keys just for faster random access
    #    # the nodes returned by ls will be added by createPyNodes and pluginLoadedCB
    #    # add new types
    #    print "reserved types", self.reservedMayaTypes
    #    for mayaType, apiType in self.reservedMayaTypes.items() + [(k, None) for k in _ls(nodeTypes=True)]:
    #         #if not self.mayaTypesToApiTypes.has_key(mayaType) :
    #         self.addMayaType( mayaType, apiType )
    #    elapsed = time.time() - start
    #    print "Updated Maya types list in %.2f sec" % elapsed

    def _buildApiClassInfo(self):
        _logger.debug("Starting ApiCache._buildApiClassInfo...")
        from pymel.internal.parsers import ApiDocParser
        self.apiClassInfo = {}
        parser = ApiDocParser(api, enumClass=ApiEnum)

        for name, obj in inspect.getmembers( api, lambda x: type(x) == type and x.__name__.startswith('M') ):
            if not name.startswith( 'MPx' ):
                try:
                    info = parser.parse(name)
                    self.apiClassInfo[ name ] = info
                except (IOError, ValueError,IndexError), e:
                    _logger.warn( "failed to parse docs for %r:\n%s" % (name, e) )
        _logger.debug("...finished ApiCache._buildApiClassInfo")

    def _buildApiRelationships(self) :
        """
        Used to rebuild api info from scratch.

        WARNING: will load all maya-installed plugins, without making an
        attempt to return the loaded plugins to the state they were at before
        this command is run.  Also, the act of loading all the plugins may
        crash maya, especially if done from a non-GUI session
        """
        # Put in a debug, because this can be crashy
        _logger.debug("Starting ApiCache._buildApiTypeHierarchy...")

        def _MFnType(x) :
            if x == api.MFnBase :
                return self.apiEnumsToApiTypes[ 1 ]  # 'kBase'
            else :
                try :
                    return self.apiEnumsToApiTypes[ x().type() ]
                except :
                    return self.apiEnumsToApiTypes[ 0 ] # 'kInvalid'

        if not startup.mayaStartupHasRun():
            startup.mayaInit()
        import maya.cmds

        import pymel.api.plugins as plugins
        # load all maya plugins

        # There's some weirdness with plugin loading on windows XP x64... if
        # you have a fresh user profile, and do:

        # import maya.standalone
        # maya.standalone.initialize()
        # import maya.mel as mel
        # mel.eval('''source "initialPlugins.mel"''')

        # ..then things work.  But if you import maya.OpenMaya:

        # import maya.standalone
        # maya.standalone.initialize()
        # import maya.OpenMaya
        # import maya.mel as mel
        # mel.eval('''source "initialPlugins.mel"''')

        # ...it crashes when loading Mayatomr.  Also, oddly, if you load
        # Mayatomr directly, instead of using initialPlugins.mel, it also
        # crashes:

        # import maya.standalone
        # maya.standalone.initialize()
        # import maya.cmds
        # maya.cmds.loadPlugin('C:\\3D\\Autodesk\\Maya2012\\bin\\plug-ins\\Mayatomr.mll')

        # Anyway, for now, adding in the line to do sourcing of initialPlugins.mel
        # until I can figure out if it's possible to avoid this crash...
        import maya.mel
        maya.mel.eval('source "initialPlugins.mel"')
        plugins.loadAllMayaPlugins()

        # all of maya OpenMaya api is now imported in module api's namespace
        mfnClasses = inspect.getmembers(api, lambda x: inspect.isclass(x) and issubclass(x, api.MFnBase))
        for name, mfnClass in mfnClasses:
            current = _MFnType(mfnClass)
            if not current:
                _logger.warning("MFnClass gave MFnType %s" % current)
            elif current == 'kInvalid':
                _logger.warning("MFnClass gave MFnType %s" % current)
            else:
                self.apiTypesToApiClasses[ current ] = mfnClass

        self._buildApiClassInfo()

        allMayaTypes = self.reservedMayaTypes.keys() + maya.cmds.ls(nodeTypes=True)
        self._buildMayaToApiInfo(allMayaTypes)

        _logger.debug("...finished ApiCache._buildApiTypeHierarchy")

    def addMayaType(self, mayaType, apiType=None, updateObj=None):
        """ Add a type to the MayaTypes lists. Fill as many dictionary caches as we have info for.

            - mayaTypesToApiTypes
            - mayaTypesToApiEnums

        if updateObj is given, this instance will first be updated from it,
        before the mayaType is added.
        """

        if apiType is not 'kInvalid' :
            apiEnum = getattr( api.MFn, apiType )
            self.mayaTypesToApiTypes[mayaType] = apiType
            self.mayaTypesToApiEnums[mayaType] = apiEnum

    def removeMayaType(self, mayaType, updateObj=None):
        """ Remove a type from the MayaTypes lists.

            - mayaTypesToApiTypes
            - mayaTypesToApiEnums

        if updateObj is given, this instance will first be updated from it,
        before the mayaType is added.
        """
        self.mayaTypesToApiEnums.pop( mayaType, None )
        self.mayaTypesToApiTypes.pop( mayaType, None )

    def build(self):
        """
        Used to rebuild api cache, either by loading from a cache file, or rebuilding from scratch.
        """
        super(ApiCache, self).build()
        # If we loaded from cache, we still need to rebuild the reserved types
        self._buildMayaReservedTypes(force=False)

    def read(self, raw=False):
        data = super(ApiCache, self).read()
        if not raw:
            # Before 2012, we cached reservedMayaTypes and reservedApiTypes,
            # even though they weren't used...
            if data is not None and len(data) != len(self._CACHE_NAMES):
                if len(data) == 8 and versions.current() < versions.v2012:
                    data = data[2:6] + data[7:]
                else:
                    # we need to rebuild, return None
                    data = None
        return data

    def rebuild(self):
        """Rebuild the api cache from scratch

        Unlike 'build', this does not attempt to load a cache file, but always
        rebuilds it by parsing the docs, etc.
        """
        _logger.info( "Rebuilding the API Caches..." )

        # fill out the data structures
        self._buildApiTypesList()
        #_buildMayaTypesList()

        self._buildMayaReservedTypes(force=True)

        self._buildApiRelationships()

        # merge in the manual overrides: we only do this when we're rebuilding or in the pymelControlPanel
        _logger.info( 'merging in dictionary of manual api overrides')
        self._mergeClassOverrides()

    def _mergeClassOverrides(self, bridgeCache=None):
        if bridgeCache is None:
            bridgeCache = ApiMelBridgeCache()
            bridgeCache.build()
        _util.mergeCascadingDicts( bridgeCache.apiClassOverrides, self.apiClassInfo, allowDictToListMerging=True )

    def melBridgeContents(self):
        return self._mayaApiMelBridge.contents()

    def extraDicts(self):
        return tuple( getattr(self, x) for x in self.EXTRA_GLOBAL_NAMES )


text:
"""Defines a Collection filter which is a collection of mayavi
filters/components bundled into one.
"""
# Author: Prabhu Ramachandran <prabhu [at] aero . iitb . ac . in>
# Copyright (c) 2008,  Enthought, Inc.
# License: BSD Style.

# Enthought library imports.
from traits.api import Instance, Bool, List
from traitsui.api import Item, Group, View, ListEditor

# Local imports.
from mayavi.core.pipeline_base import PipelineBase
from mayavi.core.filter import Filter
from mayavi.core.common import handle_children_state

################################################################################
# `Collection` class.
################################################################################
class Collection(Filter):
    """
    Defines a Collection filter which is a collection of mayavi
    filters/components bundled into one.
    """

    # The filters we manage.
    filters = List(Instance(PipelineBase), record=True)

    ########################################
    # Private traits.

    # Is the pipeline ready?  Used internally.
    _pipeline_ready = Bool(False)

    ######################################################################
    # `object` interface.
    ######################################################################
    def __set_pure_state__(self, state):
        # Create and set the filters.
        handle_children_state(self.filters, state.filters)
        # Restore our state using the super class method.
        super(Collection, self).__set_pure_state__(state)

    ######################################################################
    # HasTraits interface.
    ######################################################################
    def default_traits_view(self):
        """Returns the default traits view for this object."""
        le = ListEditor(use_notebook=True,
                        deletable=False,
                        export='DockWindowShell',
                        page_name='.name')
        view = View(Group(Item(name='filters',
                               style='custom',
                               show_label=False,
                               editor=le,
                               resizable=True),
                              show_labels=False),
                    resizable=True)
        return view

    ######################################################################
    # `Filter` interface.
    ######################################################################
    def setup_pipeline(self):
        """Setup the pipeline."""
        # Needed because a user may have defined the filters by setting
        # the default value of the trait in the subclass in which case
        # the filters_changed handler will never be called leading to
        # problems.
        if len(self.filters) > 0 and not self._pipeline_ready:
            self._filters_changed([], self.filters)

    def stop(self):
        # There is no need to override start since the wrapped filters
        # are always started automatically in the filters_changed
        # handler.
        super(Collection, self).stop()
        for filter in self.filters:
            filter.stop()

    def update_pipeline(self):
        """This method *updates* the tvtk pipeline when data upstream is
        known to have changed.

        This method is invoked (automatically) when the input fires a
        `pipeline_changed` event.
        """
        self._setup_pipeline()
        # Propagate the event.
        self.pipeline_changed = True

    def update_data(self):
        """This method does what is necessary when upstream data
        changes.

        This method is invoked (automatically) when any of the inputs
        sends a `data_changed` event.
        """
        # Propagate the data_changed event.
        self.data_changed = True

    ######################################################################
    # Private interface.
    ######################################################################
    def _setup_pipeline(self):
        """Sets up the objects in the pipeline."""
        if len(self.inputs) == 0 or len(self.filters) == 0:
            return
        # Our input.
        my_input = self.inputs[0]
        filters = self.filters
        if not self._pipeline_ready:
            # Hook up our first filter.
            first = self.filters[0]
            first.inputs = [my_input]
            # Hook up the others to each other.
            for i in range(1, len(filters)):
                filter = filters[i]
                filter.inputs = [filters[i-1]]
            self._pipeline_ready = True
        # Start filters.
        for filter in filters:
            filter.start()
        # Set our outputs
        last = filters[-1]
        self._set_outputs(last.outputs)

    def _filters_changed(self, old, new):
        """Static traits handler."""
        self._handle_filters_changed(old, new)

    def _filters_items_changed(self, list_event):
        """Static traits handler."""
        self._handle_filters_changed(list_event.removed,
                                     list_event.added)

    def _scene_changed(self, old, new):
        """Static traits handler."""
        for filter in self.filters:
            filter.scene = new
        super(Collection, self)._scene_changed(old, new)

    def _handle_filters_changed(self, removed, added):
        for filter in removed:
            self._setup_events(filter, remove=True)
            filter.stop()
        for filter in added:
            if self.scene is not None:
                filter.scene = self.scene
            if len(filter.name) == 0:
                filter.name = filter.__class__.__name__
            if filter is self.filters[-1]:
                self._setup_events(filter)
        self._pipeline_ready = False
        self._setup_pipeline()

    def _fire_pipeline_changed(self):
        # When the last filter fires a pipeline changed we should reset
        # our outputs to that of its outputs.  Calling _setup_pipeline
        # is expensive and will cause a recursion error.
        self._set_outputs(self.filters[-1].outputs)

    def _setup_events(self, obj, remove=False):
        obj.on_trait_change(self.update_data, 'data_changed',
                            remove=remove)
        obj.on_trait_change(self._fire_pipeline_changed,
                            'pipeline_changed', remove=remove)

    def _visible_changed(self, value):
        for filter in self.filters:
            filter.visible = value
        super(Collection, self)._visible_changed(value)

    def _recorder_changed(self, old, new):
        super(Collection, self)._recorder_changed(old, new)
        for filter in self.filters:
            filter.recorder = new


text:
declare namespace java {
  namespace lang {

    class Runtime {
      public static getRuntime(): java.lang.Runtime
      public exit(arg0: number | java.lang.Integer): void
      public addShutdownHook(arg0: java.lang.Thread): void
      public removeShutdownHook(arg0: java.lang.Thread): boolean
      public halt(arg0: number | java.lang.Integer): void
      public exec(arg0: java.lang.String | string): java.lang.Process
      public exec(arg0: java.lang.String | string, arg1: java.lang.String[] | string[]): java.lang.Process
      public exec(arg0: java.lang.String | string, arg1: java.lang.String[] | string[], arg2: java.io.File): java.lang.Process
      public exec(arg0: java.lang.String[] | string[]): java.lang.Process
      public exec(arg0: java.lang.String[] | string[], arg1: java.lang.String[] | string[]): java.lang.Process
      public exec(arg0: java.lang.String[] | string[], arg1: java.lang.String[] | string[], arg2: java.io.File): java.lang.Process
      public availableProcessors(): number
      public freeMemory(): number
      public totalMemory(): number
      public maxMemory(): number
      public gc(): void
      public runFinalization(): void
      public traceInstructions(arg0: boolean | java.lang.Boolean): void
      public traceMethodCalls(arg0: boolean | java.lang.Boolean): void
      public load(arg0: java.lang.String | string): void
      load0(arg0: java.lang.Class<unknown>, arg1: java.lang.String | string): void
      public loadLibrary(arg0: java.lang.String | string): void
      loadLibrary0(arg0: java.lang.Class<unknown>, arg1: java.lang.String | string): void
      public static version(): java.lang.Runtime$Version
    }

  }
}


text:
namespace blaze_util {

using std::string;

TEST(FileTest, TestNormalizePath) {
  ASSERT_EQ(string(""), NormalizePath(""));
  ASSERT_EQ(string(""), NormalizePath("."));
  ASSERT_EQ(string("/"), NormalizePath("/"));
  ASSERT_EQ(string("/"), NormalizePath("//"));
  ASSERT_EQ(string("foo"), NormalizePath("foo"));
  ASSERT_EQ(string("foo"), NormalizePath("foo/"));
  ASSERT_EQ(string("foo/bar"), NormalizePath("foo//bar"));
  ASSERT_EQ(string("foo/bar"), NormalizePath("../..//foo//bar"));
  ASSERT_EQ(string("/foo"), NormalizePath("/foo"));
  ASSERT_EQ(string("/foo"), NormalizePath("/foo/"));
  ASSERT_EQ(string("/foo/bar"), NormalizePath("/foo/./bar/"));
  ASSERT_EQ(string("foo/bar"), NormalizePath("../foo/baz/../bar"));
  ASSERT_EQ(string("foo/bar"), NormalizePath("../foo//./baz/../bar///"));
}

TEST(FileTest, TestSingleThreadedPipe) {
  std::unique_ptr<IPipe> pipe(CreatePipe());
  char buffer[50] = {0};
  ASSERT_TRUE(pipe.get()->Send("hello", 5));
  ASSERT_EQ(3, pipe.get()->Receive(buffer, 3));
  ASSERT_TRUE(pipe.get()->Send(" world", 6));
  ASSERT_EQ(5, pipe.get()->Receive(buffer + 3, 5));
  ASSERT_EQ(3, pipe.get()->Receive(buffer + 8, 40));
  ASSERT_EQ(0, strncmp(buffer, "hello world", 11));
}

TEST(FileTest, TestMultiThreadedPipe) {
  std::unique_ptr<IPipe> pipe(CreatePipe());
  char buffer[50] = {0};
  std::thread writer_thread([&pipe]() {
    ASSERT_TRUE(pipe.get()->Send("hello", 5));
    ASSERT_TRUE(pipe.get()->Send(" world", 6));
  });

  // Wait for all data to be fully written to the pipe.
  writer_thread.join();

  ASSERT_EQ(3, pipe.get()->Receive(buffer, 3));
  ASSERT_EQ(5, pipe.get()->Receive(buffer + 3, 5));
  ASSERT_EQ(3, pipe.get()->Receive(buffer + 8, 40));
  ASSERT_EQ(0, strncmp(buffer, "hello world", 11));
}

TEST(FileTest, TestReadFile) {
  const char* tempdir = getenv("TEST_TMPDIR");
  ASSERT_NE(nullptr, tempdir);
  ASSERT_NE(0, tempdir[0]);

  std::string filename(JoinPath(tempdir, "test.readfile"));
  FILE* fh = fopen(filename.c_str(), "wt");
  ASSERT_NE(nullptr, fh);
  ASSERT_EQ(11, fwrite("hello world", 1, 11, fh));
  fclose(fh);

  std::string actual;
  ASSERT_TRUE(ReadFile(filename, &actual));
  ASSERT_EQ(std::string("hello world"), actual);

  ASSERT_TRUE(ReadFile(filename, &actual, 5));
  ASSERT_EQ(std::string("hello"), actual);
}

}  // namespace blaze_util


text:
package org.apache.lucene.analysis.position;

import org.apache.lucene.analysis.TokenStream;
import org.apache.lucene.analysis.position.PositionFilter;
import org.apache.lucene.analysis.util.TokenFilterFactory;
import org.apache.lucene.util.Version;

import java.util.Map;

/**
 * Factory for {@link PositionFilter}.
 * Set the positionIncrement of all tokens to the "positionIncrement", except the first return token which retains its
 * original positionIncrement value. The default positionIncrement value is zero.
 *

 * <fieldType name="text_position" class="solr.TextField" positionIncrementGap="100">
 *   <analyzer>
 *     <tokenizer class="solr.WhitespaceTokenizerFactory"/>
 *     <filter class="solr.PositionFilterFactory" positionIncrement="0"/>
 *   </analyzer>
 * </fieldType>

 *
 * @see org.apache.lucene.analysis.position.PositionFilter
 * @since solr 1.4
 * @deprecated (4.4)
 */
@Deprecated
public class PositionFilterFactory extends TokenFilterFactory {
  private final int positionIncrement;

  /** Creates a new PositionFilterFactory */
  public PositionFilterFactory(Map<String,String> args) {
    super(args);
    positionIncrement = getInt(args, "positionIncrement", 0);
    if (!args.isEmpty()) {
      throw new IllegalArgumentException("Unknown parameters: " + args);
    }
    if (luceneMatchVersion != null && luceneMatchVersion.onOrAfter(Version.LUCENE_44)) {
      throw new IllegalArgumentException("PositionFilter is deprecated as of Lucene 4.4. You should either fix your code to not use it or use Lucene 4.3 version compatibility");
    }
  }

  @Override
  public PositionFilter create(TokenStream input) {
    return new PositionFilter(input, positionIncrement);
  }
}


text:
//  --------------------------------------------------------------------------------------------------------------------
//  <copyright file="ScenarioBlock.cs" company="PicklesDoc">
//  Copyright 2018 Darren Comeau
//  Copyright 2018-present PicklesDoc team and community contributors
//
//
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the License.
//  You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
//  Unless required by applicable law or agreed to in writing, software
//  distributed under the License is distributed on an "AS IS" BASIS,
//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//  See the License for the specific language governing permissions and
//  limitations under the License.
//  </copyright>
//  --------------------------------------------------------------------------------------------------------------------

using PicklesDoc.Pickles.ObjectModel;

namespace PicklesDoc.Pickles.DocumentationBuilders.Markdown.Blocks
{
    class ScenarioBlock : Block
    {
        protected readonly Scenario scenario;

        public ScenarioBlock(Scenario scenario, Stylist style) : base(style)
        {
            this.scenario = scenario;

            this.lines = RenderedBlock();
        }

        private Lines RenderedBlock()
        {
            var lines = new Lines
            {
                AvailableTags(),

                Heading(),

                AvailableSteps()
            };

            return lines;
        }

        private Lines AvailableTags()
        {
            var lines = new Lines();

            if (scenario.Tags.Count > 0)
            {
                var tagline = string.Empty;

                foreach (var tag in scenario.Tags)
                {
                    tagline = string.Concat(tagline, style.AsTag(tag), " ");
                }

                lines.Add(tagline.TrimEnd());
                lines.Add(string.Empty);
            }

            return lines;
        }

        protected virtual Lines Heading()
        {
            var lines = new Lines();

            if(scenario.Result != TestResult.NotProvided)
            {
                lines.Add(style.AsScenarioHeading(scenario.Name, scenario.Result));
            }
            else
            {
                lines.Add(style.AsScenarioHeading(scenario.Name));
            }

            return lines;
        }

        private Lines AvailableSteps()
        {
            var lines = new Lines();

            if (scenario.Steps.Count > 0)
            {
                foreach (var step in scenario.Steps)
                {
                    lines.Add(style.AsStepLine(string.Empty));
                    lines.Add(Step(step));
                }
            }

            return lines;
        }

        private Lines Step(Step step)
        {
            var stepBlock = new StepBlock(step, style);

            return stepBlock.Lines;
        }
    }
}


text:
'use strict'

require('babel-register')()

var path = require('path')
var tape = require('tape')
var Runner = require('../lib/workflow-runner').default

tape('runner', function (t) {
  t.plan(1)

  var runner = new Runner({ id: 'test-project' }, {}, {
    startTaskId: 'clone',
    tasks: {
      clone: {
        cmd: 'git clone --progress git@github.com:Strider-CD/dirkeeper.git',
        successTaskId: 'install',
        failureTaskId: 'cleanup'
      },

      install: {
        cmd: 'cd dirkeeper && npm install',
        successTaskId: 'test',
        failureTaskId: 'cleanup'
      },

      test: {
        module: 'test',
        options: {},
        successTaskId: 'deploy',
        failureTaskId: 'cleanup'
      },

      deploy: {
        cmd: 'echo "deploying.."'
      },

      cleanup: {
        cmd: 'rm -rf *'
      }
    }
  }, { pluginDir: path.join(__dirname, 'plugins') })

  runner.start()
    .then(results => {
      console.log(results)
      t.equal(results.length, 2, 'Ran right number of tasks')
    })
    .catch(err => {
      t.error(err)
    })
})

tape.skip('runner - parallel', function (t) {
  t.plan(1)

  var runner = new Runner({}, {}, {
    startTaskId: 'test',
    tasks: {
      test: {
        tasks: {
          main: {
            module: 'test',
            options: {}
          },
          secondary: {
            cmd: 'npm info dirkeeper'
          }
        },
        successTaskId: 'deploy',
        failureTaskId: 'cleanup'
      },

      deploy: {
        cmd: 'echo "deploying.."'
      },

      cleanup: {
        cmd: 'ls'
      }
    }
  }, { pluginDir: path.join(__dirname, 'plugins') })

  runner.start()
    .then(results => {
      console.log(results)
      t.equal(results.length, 3, 'Ran right number of tasks')
    })
    .catch(err => {
      t.error(err)
    })
})


text:
package org.callimachusproject.test;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Authenticator;
import java.net.Authenticator.RequestorType;
import java.net.HttpURLConnection;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.PasswordAuthentication;
import java.net.ProtocolException;
import java.net.URL;
import java.net.URLEncoder;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.zip.GZIPInputStream;

import junit.framework.Assert;

import org.apache.http.HttpResponse;
import org.apache.http.StatusLine;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.ResponseHandler;
import org.apache.http.client.methods.HttpPatch;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.callimachusproject.engine.impl.TermFactoryImpl;
import org.callimachusproject.engine.model.TermFactory;
import org.callimachusproject.io.ChannelUtil;

public class WebResource {
	private static final Pattern LINK = Pattern.compile("<([^>]*)>(?:\\s*;\\s*anchor=\"([^\"]*)\"|\\s*;\\s*(?:rel|rev)=\"([^\"]*)\"|\\s*;\\s*rel=([a-z0-9\\.\\-]*)|\\s*;\\s*type=\"([^\"]*)\"|\\s*;\\s*type=([a-zA-z0-9\\.\\-\\+]*))*");
	private final String uri;

	public WebResource(String uri) {
		this.uri = uri;
	}

	public WebResource ref(String reference) throws IOException {
		return new WebResource(TermFactory.newInstance(uri).resolve(reference));
	}

	public WebResource rel(String rel, String... types) throws IOException {
		return findLink(rel, false, types);
	}

	public WebResource rev(String rev, String... types) throws IOException {
		return findLink(rev, true, types);
	}

	public WebResource getAppCollection() throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("GET");
		con.setRequestProperty("ACCEPT", "application/atom+xml");
		Assert.assertEquals(con.getResponseMessage(), 203, con.getResponseCode());
		InputStream stream = con.getInputStream();
		String text = new java.util.Scanner(stream).useDelimiter("\\A").next();
		String result = getQuoteAfter("<app:collection", text);
		return ref(result);
	}

	public WebResource create(String type, byte[] body) throws IOException {
		Map<String, String> headers = Collections.emptyMap();
		return create(headers, type, body);
	}

	public WebResource create(String slug, String type, byte[] body) throws IOException {
		return create(Collections.singletonMap("Slug", slug), type, body);
	}

	public WebResource create(Map<String, String> headers, String type, byte[] body) throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("POST");
		for (Map.Entry<String, String> e : headers.entrySet()) {
			con.setRequestProperty(e.getKey(), e.getValue());
		}
		con.setRequestProperty("Content-Type", type);
		con.setDoOutput(true);
		OutputStream out = con.getOutputStream();
		try {
			out.write(body);
		} finally {
			out.close();
		}
		Assert.assertEquals(con.getResponseMessage(), 201, con.getResponseCode());
		String header = con.getHeaderField("Location");
		Assert.assertNotNull(header);
		return ref(header);
	}

	public WebResource createPurl(String slug, String property, String target) throws IOException {
		StringBuilder sb = new StringBuilder();
		sb.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
		sb.append("PREFIX calli: <http://callimachusproject.org/rdf/2009/framework#>\n");
		sb.append("<").append(slug).append(">");
		sb.append(" a calli:Purl, </callimachus/1.4/types/Purl>;\n");
		sb.append("rdfs:label \"").append(slug).append("\" ;\n");
		sb.append("calli:").append(property).append(" \"\"\"").append(target).append("\"\"\".\n");
		return rel("describedby").create("text/turtle", sb.toString().getBytes("UTF-8")).rev("describedby");
	}

	public WebResource createFolder(String slug) throws IOException {
		StringBuilder sb = new StringBuilder();
		sb.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
		sb.append("PREFIX calli: <http://callimachusproject.org/rdf/2009/framework#>\n");
		sb.append("<").append(slug).append(">");
		sb.append(" a calli:Folder, </callimachus/1.4/types/Folder>;\n");
		sb.append("rdfs:label \"").append(slug).append("\".\n");
		return rel("describedby").create("text/turtle", sb.toString().getBytes("UTF-8")).rev("describedby");
	}

	public WebResource createRdfDatasource(String slug) throws IOException {
		StringBuilder sb = new StringBuilder();
		sb.append("PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>\n");
		sb.append("PREFIX calli: <http://callimachusproject.org/rdf/2009/framework#>\n");
		sb.append("PREFIX sd: <http://www.w3.org/ns/sparql-service-description#>\n");
		sb.append("<").append(slug).append(">");
		sb.append(" a sd:Service, calli:RdfDatasource, </callimachus/1.4/types/RdfDatasource>;\n");
		sb.append("rdfs:label \"").append(slug).append("\";\n");
		sb.append("sd:endpoint <").append(slug).append(">;\n");
		sb.append("sd:supportedLanguage sd:SPARQL11Query;\n");
		sb.append("sd:supportedLanguage sd:SPARQL11Update;\n");
		sb.append("sd:feature sd:UnionDefaultGraph;\n");
		sb.append("sd:feature sd:BasicFederatedQuery;\n");
		sb.append("sd:inputFormat <http://www.w3.org/ns/formats/RDF_XML>;\n");
		sb.append("sd:inputFormat <http://www.w3.org/ns/formats/Turtle>;\n");
		sb.append("sd:resultFormat <http://www.w3.org/ns/formats/RDF_XML>;\n");
		sb.append("sd:resultFormat <http://www.w3.org/ns/formats/SPARQL_Results_XML>.\n");
		return rel("describedby").create("text/turtle", sb.toString().getBytes("UTF-8")).rev("describedby");
	}

	public String getRedirectLocation() throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setInstanceFollowRedirects(false);
		con.setRequestMethod("HEAD");
		int code = con.getResponseCode();
		if (!(code == 301 || code == 303 || code == 302 || code == 307 || code == 308))
			Assert.assertEquals(con.getResponseMessage(), 302, code);
		return con.getHeaderField("Location");
	}

	public int headCode() throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setInstanceFollowRedirects(false);
		con.setRequestMethod("HEAD");
		return con.getResponseCode();
	}

	public byte[] get(String type) throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("GET");
		con.setRequestProperty("Accept", type);
		con.setRequestProperty("Accept-Encoding", "gzip");
		Assert.assertEquals(con.getResponseMessage(), 200, con.getResponseCode());
		InputStream in = con.getInputStream();
		try {
			if ("gzip".equals(con.getHeaderField("Content-Encoding"))) {
				in = new GZIPInputStream(in);
			}
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			ChannelUtil.transfer(in, out);
			return out.toByteArray();
		} finally {
			in.close();
		}
	}

	public byte[] post(String type, byte[] body, String accept) throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("POST");
		con.setRequestProperty("Accept", accept);
		con.setRequestProperty("Accept-Encoding", "gzip");
		con.setRequestProperty("Content-Type", type);
		con.setDoOutput(true);
		OutputStream req = con.getOutputStream();
		try {
			req.write(body);
		} finally {
			req.close();
		}
		Assert.assertEquals(con.getResponseMessage(), 200, con.getResponseCode());
		InputStream in = con.getInputStream();
		try {
			if ("gzip".equals(con.getHeaderField("Content-Encoding"))) {
				in = new GZIPInputStream(in);
			}
			ByteArrayOutputStream out = new ByteArrayOutputStream();
			ChannelUtil.transfer(in, out);
			return out.toByteArray();
		} finally {
			in.close();
		}
	}

	public void post() throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("POST");
		con.setDoOutput(false);
		Assert.assertEquals(con.getResponseMessage(), 204, con.getResponseCode());
	}

	public void post(String type, byte[] body) throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("POST");
		con.setRequestProperty("Content-Type", type);
		con.setDoOutput(true);
		OutputStream req = con.getOutputStream();
		try {
			req.write(body);
		} finally {
			req.close();
		}
		Assert.assertEquals(con.getResponseMessage(), 204, con.getResponseCode());
	}

	public void put(String type, byte[] body) throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("PUT");
		con.setRequestProperty("If-Match", "*");
		con.setRequestProperty("Content-Type", type);
		con.setDoOutput(true);
		OutputStream out = con.getOutputStream();
		try {
			out.write(body);
		} finally {
			out.close();
		}
		Assert.assertEquals(con.getResponseMessage(), 204, con.getResponseCode());
	}

	public void patch(String type, byte[] body) throws IOException {
		ByteArrayEntity entity = new ByteArrayEntity(body);
		entity.setContentType(type);
		HttpPatch req = new HttpPatch(uri);
		req.setEntity(entity);
		DefaultHttpClient client = new DefaultHttpClient();
		URL url = req.getURI().toURL();
		int port = url.getPort();
		String host = url.getHost();
		PasswordAuthentication passAuth = Authenticator
				.requestPasswordAuthentication(url.getHost(),
						InetAddress.getByName(url.getHost()), port,
						url.getProtocol(), "", "digest", url,
						RequestorType.SERVER);
		UsernamePasswordCredentials credentials = new UsernamePasswordCredentials(
				passAuth.getUserName(), new String(passAuth.getPassword()));
		client.getCredentialsProvider().setCredentials(
				new AuthScope(host, port), credentials);
		client.execute(req, new ResponseHandler<Void>() {
			public Void handleResponse(HttpResponse response)
					throws ClientProtocolException, IOException {
				StatusLine status = response.getStatusLine();
				int code = status.getStatusCode();
				if (code != 200 && code != 204) {
					Assert.assertEquals(status.getReasonPhrase(), 204, code);
				}
				return null;
			}
		});
	}

	public void delete() throws IOException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("DELETE");
		int code = con.getResponseCode();
		if (code != 200 && code != 204) {
			Assert.assertEquals(con.getResponseMessage(), 204, code);
		}
	}

	public WebResource search(String searchTerm) throws Exception {
		String text = new String(rel("search", "application/opensearchdescription+xml").get("application/opensearchdescription+xml"));
		int pos = text.indexOf("template");
		int start = text.indexOf("\"", pos);
		int stop = text.indexOf("\"", start + 1);
		String templateURL = text.substring(start + 1, stop);

		int before = templateURL.indexOf("{");
		int after = templateURL.indexOf("}");
		String firstPart = templateURL.substring(0, before);
		String secondPart = templateURL.substring(after+1);
		String fullURL = firstPart + searchTerm + secondPart;
		return ref(fullURL);
	}

	public WebResource sparqlEndpoint() throws Exception {
		String _void = new String(ref("/.well-known/void").get("application/rdf+xml"));
		Pattern regex = Pattern.compile("\\bsparqlEndpoint\\b[^>]*\\brdf:resource=\"([^\"]*)\"\\s*/>");
		Matcher m = regex.matcher(_void);
		Assert.assertTrue(m.find());
		return ref(m.group(1));
	}

	public WebResource query(String sparql) throws Exception {
		String encoded = URLEncoder.encode(sparql, "UTF-8");
		return ref("?query=" + encoded);
	}

	public void update(String sparql) throws Exception {
		HttpURLConnection con = (HttpURLConnection) new URL(uri).openConnection();
		con.setRequestMethod("POST");
		con.setRequestProperty("Content-Type", "application/sparql-update");
		con.setDoOutput(true);
		OutputStream out = con.getOutputStream();
		try {
			out.write(sparql.getBytes("UTF-8"));
		} finally {
			out.close();
		}
		Assert.assertEquals(con.getResponseMessage(), 204, con.getResponseCode());
	}

	@Override
	public String toString() {
		return uri;
	}

	@Override
	public int hashCode() {
		return uri.hashCode();
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		WebResource other = (WebResource) obj;
		return uri.equals(other.uri);
	}

	private String getQuoteAfter(String token, String text) {
		int pos = text.indexOf(token);
		if (pos <= 0)
			return null;
		int start = text.indexOf("\"", pos);
		int stop = text.indexOf("\"", start + 1);
		return text.substring(start + 1, stop).replace("&", "&");
	}

	private WebResource findLink(String rel, boolean rev, String... types)
			throws IOException, MalformedURLException, ProtocolException {
		HttpURLConnection con = (HttpURLConnection) new URL(uri)
				.openConnection();
		con.setRequestMethod("OPTIONS");
		Assert.assertEquals(con.getResponseMessage(), 204,
				con.getResponseCode());
		for (Map.Entry<String, List<String>> e : con.getHeaderFields().entrySet()) {
			if (!"Link".equalsIgnoreCase(e.getKey()))
				continue;
			for (String header : e.getValue()) {
				Assert.assertNotNull(header);
				Matcher m = LINK.matcher(header);
				while (m.find()) {
					if (rev && !header.contains("rev="))
						continue;
					String href = m.group(1);
					String a = m.group(2);
					String r = m.group(3) != null ? m.group(3) : m.group(4);
					String t = m.group(5) != null ? m.group(5) : m.group(6);
					if (a != null
							&& !TermFactoryImpl.newInstance(uri).resolve(a).equals(uri))
						continue;
					if (!rel.equals(r))
						continue;
					if (types.length == 0 || t == null)
						return ref(href);
					for (String type : types) {
						for (String t1 : t.split("\\s+")) {
							if (t1.length() > 0 && t1.startsWith(type)) {
								return ref(href);
							}
						}
					}
				}
			}
		}
		StringBuilder sb = new StringBuilder();
		sb.append("<").append(uri).append("?").append(rel);
		sb.append(">");
		if (rev) {
			sb.append("; rev=\"");
		} else {
			sb.append("; rel=\"");
		}
		sb.append(rel).append("\"; type=\"");
		for (String type : types) {
			sb.append(type).append(' ');
		}
		sb.setLength(sb.length() - 1);
		sb.append("\"");
		Assert.assertEquals(sb.toString(), con.getHeaderField("Link"));
		return null;
	}

}


text:
package container

import (
	"fmt"
	"strings"
	"time"

	"github.com/Sirupsen/logrus"
	"github.com/docker/docker/api/types"
	"github.com/docker/docker/api/types/network"
	"github.com/docker/docker/pkg/registrar"
	"github.com/docker/go-connections/nat"
	"github.com/hashicorp/go-memdb"
)

const (
	memdbTable   = "containers"
	memdbIDIndex = "id"
)

// Snapshot is a read only view for Containers. It holds all information necessary to serve container queries in a
// versioned ACID in-memory store.
type Snapshot struct {
	types.Container

	// additional info queries need to filter on
	// preserve nanosec resolution for queries
	CreatedAt    time.Time
	StartedAt    time.Time
	Name         string
	Pid          int
	ExitCode     int
	Running      bool
	Paused       bool
	Managed      bool
	ExposedPorts nat.PortSet
	PortBindings nat.PortSet
	Health       string
	HostConfig   struct {
		Isolation string
	}
}

// ViewDB provides an in-memory transactional (ACID) container Store
type ViewDB interface {
	Snapshot(nameIndex *registrar.Registrar) View
	Save(*Container) error
	Delete(*Container) error
}

// View can be used by readers to avoid locking
type View interface {
	All() ([]Snapshot, error)
	Get(id string) (*Snapshot, error)
}

var schema = &memdb.DBSchema{
	Tables: map[string]*memdb.TableSchema{
		memdbTable: {
			Name: memdbTable,
			Indexes: map[string]*memdb.IndexSchema{
				memdbIDIndex: {
					Name:    memdbIDIndex,
					Unique:  true,
					Indexer: &containerByIDIndexer{},
				},
			},
		},
	},
}

type memDB struct {
	store *memdb.MemDB
}

// NewViewDB provides the default implementation, with the default schema
func NewViewDB() (ViewDB, error) {
	store, err := memdb.NewMemDB(schema)
	if err != nil {
		return nil, err
	}
	return &memDB{store: store}, nil
}

// Snapshot provides a consistent read-only View of the database
func (db *memDB) Snapshot(index *registrar.Registrar) View {
	return &memdbView{
		txn:       db.store.Txn(false),
		nameIndex: index.GetAll(),
	}
}

// Save atomically updates the in-memory store state for a Container.
// Only read only (deep) copies of containers may be passed in.
func (db *memDB) Save(c *Container) error {
	txn := db.store.Txn(true)
	defer txn.Commit()
	return txn.Insert(memdbTable, c)
}

// Delete removes an item by ID
func (db *memDB) Delete(c *Container) error {
	txn := db.store.Txn(true)
	defer txn.Commit()
	return txn.Delete(memdbTable, NewBaseContainer(c.ID, c.Root))
}

type memdbView struct {
	txn       *memdb.Txn
	nameIndex map[string][]string
}

// All returns a all items in this snapshot. Returned objects must never be modified.
func (v *memdbView) All() ([]Snapshot, error) {
	var all []Snapshot
	iter, err := v.txn.Get(memdbTable, memdbIDIndex)
	if err != nil {
		return nil, err
	}
	for {
		item := iter.Next()
		if item == nil {
			break
		}
		snapshot := v.transform(item.(*Container))
		all = append(all, *snapshot)
	}
	return all, nil
}

// Get returns an item by id. Returned objects must never be modified.
func (v *memdbView) Get(id string) (*Snapshot, error) {
	s, err := v.txn.First(memdbTable, memdbIDIndex, id)
	if err != nil {
		return nil, err
	}
	return v.transform(s.(*Container)), nil
}

// transform maps a (deep) copied Container object to what queries need.
// A lock on the Container is not held because these are immutable deep copies.
func (v *memdbView) transform(container *Container) *Snapshot {
	snapshot := &Snapshot{
		Container: types.Container{
			ID:      container.ID,
			Names:   v.nameIndex[container.ID],
			ImageID: container.ImageID.String(),
			Ports:   []types.Port{},
			Mounts:  container.GetMountPoints(),
			State:   container.State.StateString(),
			Status:  container.State.String(),
			Created: container.Created.Unix(),
		},
		CreatedAt:    container.Created,
		StartedAt:    container.StartedAt,
		Name:         container.Name,
		Pid:          container.Pid,
		Managed:      container.Managed,
		ExposedPorts: make(nat.PortSet),
		PortBindings: make(nat.PortSet),
		Health:       container.HealthString(),
		Running:      container.Running,
		Paused:       container.Paused,
		ExitCode:     container.ExitCode(),
	}

	if snapshot.Names == nil {
		// Dead containers will often have no name, so make sure the response isn't null
		snapshot.Names = []string{}
	}

	if container.HostConfig != nil {
		snapshot.Container.HostConfig.NetworkMode = string(container.HostConfig.NetworkMode)
		snapshot.HostConfig.Isolation = string(container.HostConfig.Isolation)
		for binding := range container.HostConfig.PortBindings {
			snapshot.PortBindings[binding] = struct{}{}
		}
	}

	if container.Config != nil {
		snapshot.Image = container.Config.Image
		snapshot.Labels = container.Config.Labels
		for exposed := range container.Config.ExposedPorts {
			snapshot.ExposedPorts[exposed] = struct{}{}
		}
	}

	if len(container.Args) > 0 {
		args := []string{}
		for _, arg := range container.Args {
			if strings.Contains(arg, " ") {
				args = append(args, fmt.Sprintf("'%s'", arg))
			} else {
				args = append(args, arg)
			}
		}
		argsAsString := strings.Join(args, " ")
		snapshot.Command = fmt.Sprintf("%s %s", container.Path, argsAsString)
	} else {
		snapshot.Command = container.Path
	}

	snapshot.Ports = []types.Port{}
	networks := make(map[string]*network.EndpointSettings)
	if container.NetworkSettings != nil {
		for name, netw := range container.NetworkSettings.Networks {
			if netw == nil || netw.EndpointSettings == nil {
				continue
			}
			networks[name] = &network.EndpointSettings{
				EndpointID:          netw.EndpointID,
				Gateway:             netw.Gateway,
				IPAddress:           netw.IPAddress,
				IPPrefixLen:         netw.IPPrefixLen,
				IPv6Gateway:         netw.IPv6Gateway,
				GlobalIPv6Address:   netw.GlobalIPv6Address,
				GlobalIPv6PrefixLen: netw.GlobalIPv6PrefixLen,
				MacAddress:          netw.MacAddress,
				NetworkID:           netw.NetworkID,
			}
			if netw.IPAMConfig != nil {
				networks[name].IPAMConfig = &network.EndpointIPAMConfig{
					IPv4Address: netw.IPAMConfig.IPv4Address,
					IPv6Address: netw.IPAMConfig.IPv6Address,
				}
			}
		}
		for port, bindings := range container.NetworkSettings.Ports {
			p, err := nat.ParsePort(port.Port())
			if err != nil {
				logrus.Warnf("invalid port map %+v", err)
				continue
			}
			if len(bindings) == 0 {
				snapshot.Ports = append(snapshot.Ports, types.Port{
					PrivatePort: uint16(p),
					Type:        port.Proto(),
				})
				continue
			}
			for _, binding := range bindings {
				h, err := nat.ParsePort(binding.HostPort)
				if err != nil {
					logrus.Warnf("invalid host port map %+v", err)
					continue
				}
				snapshot.Ports = append(snapshot.Ports, types.Port{
					PrivatePort: uint16(p),
					PublicPort:  uint16(h),
					Type:        port.Proto(),
					IP:          binding.HostIP,
				})
			}
		}
	}
	snapshot.NetworkSettings = &types.SummaryNetworkSettings{Networks: networks}

	return snapshot
}

// containerByIDIndexer is used to extract the ID field from Container types.
// memdb.StringFieldIndex can not be used since ID is a field from an embedded struct.
type containerByIDIndexer struct{}

// FromObject implements the memdb.SingleIndexer interface for Container objects
func (e *containerByIDIndexer) FromObject(obj interface{}) (bool, []byte, error) {
	c, ok := obj.(*Container)
	if !ok {
		return false, nil, fmt.Errorf("%T is not a Container", obj)
	}
	// Add the null character as a terminator
	v := c.ID + "\x00"
	return true, []byte(v), nil
}

// FromArgs implements the memdb.Indexer interface
func (e *containerByIDIndexer) FromArgs(args ...interface{}) ([]byte, error) {
	if len(args) != 1 {
		return nil, fmt.Errorf("must provide only a single argument")
	}
	arg, ok := args[0].(string)
	if !ok {
		return nil, fmt.Errorf("argument must be a string: %#v", args[0])
	}
	// Add the null character as a terminator
	arg += "\x00"
	return []byte(arg), nil
}


text:
<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.DayNight">
        <!-- Set AppCompat's color theming attrs -->
        <item name="colorPrimary">@color/material_deep_teal_200</item>
        <item name="colorAccent">@color/accent_material_light</item>
        <item name="colorPrimaryDark">@color/material_deep_teal_500</item>
    </style>
</resources>


text:
set -v
set -e

SGX_SOURCE_PATH=/home/sgx/github/intel-linux-sgx_2/linux-sgx

g++ -c -fPIC sgx_memset_s.cpp
g++ -c -fPIC sgx_read_rand.cpp -I/opt/intel/sgxsdk/include/ -I$SGX_SOURCE_PATH/common/inc/internal/ -Irdrand/
g++ -c -fPIC ecp.cpp -I/opt/intel/sgxsdk/include/ -I$SGX_SOURCE_PATH/common/inc/internal/
gcc -c -fPIC consttime_memequal.c

cd rdrand; make; cd -

cd tlibcrypto
g++ -c init_crypto_lib.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_aes_ctr.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_aes_gcm.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_cmac128.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_ecc256.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_ecc256_common.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_ecc256_ecdsa.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_sha256.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c sgx_sha256_msg.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
g++ -c tcrypto_version.cpp -fPIC -I$SGX_SOURCE_PATH/common/inc/internal -I$SGX_SOURCE_PATH/common/inc -I$SGX_SOURCE_PATH/common/inc/tlibc -I$SGX_SOURCE_PATH/external/crypto_px/include
cd -

cd $SGX_SOURCE_PATH/external/crypto_px
make
cd -
g++   -shared	-Wl,--whole-archive \
				sgx_memset_s.o \
				consttime_memequal.o  \
				sgx_read_rand.o \
				rdrand/rdrand.o  \
				ecp.o 							\
				./tlibcrypto/init_crypto_lib.o \
				./tlibcrypto/sgx_aes_ctr.o \
				./tlibcrypto/sgx_aes_gcm.o \
				./tlibcrypto/sgx_cmac128.o \
				./tlibcrypto/sgx_ecc256.o \
				./tlibcrypto/sgx_ecc256_common.o \
				./tlibcrypto/sgx_ecc256_ecdsa.o \
				./tlibcrypto/sgx_sha256.o \
				./tlibcrypto/sgx_sha256_msg.o \
				./tlibcrypto/tcrypto_version.o \
				$SGX_SOURCE_PATH/external/crypto_px/libcrypto_px.a \
				-Wl,--no-whole-archive -o crypto_wrapper.so


text:
//
//  SDLControlFramePayloadStartServiceAck.h
//  SmartDeviceLink-iOS
//
//  Created by Joel Fischer on 7/20/17.
//  Copyright © 2017 smartdevicelink. All rights reserved.
//

#import <Foundation/Foundation.h>

#import "SDLControlFramePayloadType.h"

NS_ASSUME_NONNULL_BEGIN

@interface SDLControlFramePayloadRPCStartServiceAck : NSObject <SDLControlFramePayloadType>

/// Hash ID to identify this service and used when sending an EndService control frame
@property (assign, nonatomic, readonly) int32_t hashId;

/// Max transport unit to be used for this service
@property (assign, nonatomic, readonly) int64_t mtu;

/// The negotiated version of the protocol. Must be in the format "Major.Minor.Patch"
@property (copy, nonatomic, readonly, nullable) NSString *protocolVersion;

/** The transport types for Secondary Transport */
@property (copy, nonatomic, readonly, nullable) NSArray<NSString *> *secondaryTransports;

/** List of transports that are allowed to carry audio service. The values can be either 1 (primary transport) or 2 (secondary transport) and are listed in preferred order. */
@property (copy, nonatomic, readonly, nullable) NSArray<NSNumber *> *audioServiceTransports;

/** List of transports that are allowed to carry video service. The values can be either 1 (primary transport) or 2 (secondary transport) and are listed in preferred order. */
@property (copy, nonatomic, readonly, nullable) NSArray<NSNumber *> *videoServiceTransports;

- (instancetype)initWithHashId:(int32_t)hashId mtu:(int64_t)mtu protocolVersion:(nullable NSString *)protocolVersion secondaryTransports:(nullable NSArray<NSString *> *)secondaryTransports audioServiceTransports:(nullable NSArray<NSNumber *> *)audioServiceTransports videoServiceTransports:(nullable NSArray<NSNumber *> *)videoServiceTransports;

@end

NS_ASSUME_NONNULL_END


text:
require 'bio-ucsc'
describe "Bio::Ucsc::Hg18::BurgeRnaSeqGemMapperAlignMB435" do

  describe "#find_by_interval" do
    context "given range chr1:1-10,000" do
      it 'returns a record (r.chrom == "chr1")' do
        Bio::Ucsc::Hg18::DBConnection.default
        Bio::Ucsc::Hg18::DBConnection.connect
        i = Bio::GenomicInterval.parse("chr1:1-10,000")
        r = Bio::Ucsc::Hg18::BurgeRnaSeqGemMapperAlignMB435.find_by_interval(i)
        r.chrom.should == "chr1"
      end
    end
  end

end


text:
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE127_Buffer_Underread__wchar_t_alloca_memmove_65b.c
Label Definition File: CWE127_Buffer_Underread.stack.label.xml
Template File: sources-sink-65b.tmpl.c
*/
/*
 * @description
 * CWE: 127 Buffer Under-read
 * BadSource:  Set data pointer to before the allocated memory buffer
 * GoodSource: Set data pointer to the allocated memory buffer
 * Sinks: memmove
 *    BadSink : Copy data to string using memmove
 * Flow Variant: 65 Data/control flow: data passed as an argument from one function to a function in a different source file called via a function pointer
 *
 * */

#include "std_testcase.h"

#include <wchar.h>

#ifndef OMITBAD

void CWE127_Buffer_Underread__wchar_t_alloca_memmove_65b_badSink(wchar_t * data)
{
    {
        wchar_t dest[100];
        wmemset(dest, L'C', 100-1); /* fill with 'C's */
        dest[100-1] = L'\0'; /* null terminate */
        /* POTENTIAL FLAW: Possibly copy from a memory location located before the source buffer */
        memmove(dest, data, 100*sizeof(wchar_t));
        /* Ensure null termination */
        dest[100-1] = L'\0';
        printWLine(dest);
    }
}

#endif /* OMITBAD */

#ifndef OMITGOOD

/* goodG2B uses the GoodSource with the BadSink */
void CWE127_Buffer_Underread__wchar_t_alloca_memmove_65b_goodG2BSink(wchar_t * data)
{
    {
        wchar_t dest[100];
        wmemset(dest, L'C', 100-1); /* fill with 'C's */
        dest[100-1] = L'\0'; /* null terminate */
        /* POTENTIAL FLAW: Possibly copy from a memory location located before the source buffer */
        memmove(dest, data, 100*sizeof(wchar_t));
        /* Ensure null termination */
        dest[100-1] = L'\0';
        printWLine(dest);
    }
}

#endif /* OMITGOOD */


text:
    font-family: "Trebuchet MS", 'Helvetica Neue', Helvetica, Tahoma, sans-serif;
    display: none;
    position: absolute;
    z-index: 1053;
    background-color: #fff;
    box-shadow: 0 4px 14px rgba(0, 0, 0, .2);
    border-radius: 2px;
    width: 264px;
    max-height: 250px;
    margin: 0;
    overflow: auto;
    font-size: 14px;
    padding: 0;
}
#redactor-handle-list a {
    display: block;
    text-decoration: none;
    padding: 10px 8px;
    white-space: nowrap;
    color: #000;
    border-bottom: 1px solid rgba(0, 0, 0, .05);
}
#redactor-handle-list a:hover {
    color: #fff !important;
    background-color: #449aef !important;
}


text:
package org.jzy3d.demos.scatter;

import org.jzy3d.chart.Chart;
import org.jzy3d.colors.Color;
import org.jzy3d.colors.ColorMapper;
import org.jzy3d.colors.IColorMappable;
import org.jzy3d.colors.colormaps.ColorMapRainbow;
import org.jzy3d.colors.colormaps.IColorMap;
import org.jzy3d.demos.AbstractDemo;
import org.jzy3d.demos.Launcher;
import org.jzy3d.maths.Coord3d;
import org.jzy3d.plot3d.primitives.MultiColorScatter;
import org.jzy3d.plot3d.rendering.canvas.Quality;
import org.jzy3d.plot3d.rendering.legends.colorbars.ColorbarLegend;

public class Scatter4D extends AbstractDemo{
	public static void main(String[] args) throws Exception {
		Launcher.openDemo(new Scatter4D());
	}

	public Scatter4D() {
		// Create the dot cloud scene and fill with data
		final int nPointsInEachAxis = 100;
		int size = nPointsInEachAxis * nPointsInEachAxis * nPointsInEachAxis;
		Coord3d[] points = new Coord3d[size];
		Color[]   colors = new Color[size];
		int nPoints= 0;
		MyColorFunction myIColorMap= new MyColorFunction();
		ColorMapper myColorMap= new ColorMapper(myIColorMap, -1.0f, 1.0f); //define my own Color Map with my own Color Function

		//Create the points matrix giving some randomness to position to avoid the aliasing effects of having all the points perfectly aligned.
		for (int incX = 0; incX < nPointsInEachAxis; incX++) {
			for (int incY = 0; incY < nPointsInEachAxis; incY++) {
				for (int incZ = 0; incZ < nPointsInEachAxis; incZ++) {
					Coord3d coord= new Coord3d(incX+(float)Math.random(), incY+(float)Math.random(), incZ+(float)Math.random());
					points[incZ + incY * nPointsInEachAxis + incX * nPointsInEachAxis * nPointsInEachAxis] = coord;
					colors[incZ + incY * nPointsInEachAxis + incX * nPointsInEachAxis * nPointsInEachAxis] = myColorMap.getColor(coord);
					nPoints++;
				}
			}
		}

		//Fill up the matrix if necessary
		for(int incX=nPoints; incX<size; incX++){
			points[incX] = new Coord3d(0, 0, 0);
			colors[incX] = new Color(0,0,0, 1); //Last parameter "a" is the transparency of the color
		}

		MultiColorScatter scatter = new MultiColorScatter(points, colors, myColorMap);
		chart = new Chart(Quality.Advanced); //Needed to have the Legend numbers displayed correctly
		chart.getScene().add(scatter);

		scatter.setLegend( new ColorbarLegend(scatter,
				chart.getView().getAxe().getLayout().getZTickProvider(),
				chart.getView().getAxe().getLayout().getZTickRenderer()) );
		scatter.setLegendDisplayed(true);
	}

	public static class MyColorFunction implements IColorMap {  //Define the function to assign colors to each point
		boolean colorMapDirection= true;
		ColorMapper rainbowMap;
		Color myColor;
		float energy ;
		public float zMin;
		public float zMax;
		double scale;

		public MyColorFunction(){
			this.zMin = -1.0f;
			this.zMax = 1.0f;
			this.rainbowMap = new ColorMapper(new ColorMapRainbow(), this.zMin, this.zMax);
			this.scale= 2.0*Math.PI/100.0;
		}

		public void setDirection(boolean isStandard){
			colorMapDirection= isStandard;
		};
		public boolean getDirection(){
			return colorMapDirection;
		}
		public Color getColor(IColorMappable colorable, float x, float y, float z) {   //Returns the color of point(x,y,z)
			energy= (float)(Math.sin(((double)x)*scale)
					* Math.sin(((double)y)*scale)
					* Math.sin(((double)z)*scale) );

			myColor= rainbowMap.getColor(energy); // We get the  color using the very useful RainbowMap
			myColor.alphaSelf((float) Math.abs(energy/5.0));			// Giving some transparency to view the inside points

			return myColor;
		}

		public Color getColor(IColorMappable colorable, float v) {
			myColor= rainbowMap.getColor(v); // We get the  color using the very useful RainbowMap
			return myColor;
		};
	}

	public Chart getChart() {
		return chart;
	}
	protected Chart chart;
}


text:
$(function () {
  $('#write-related_posts').select2();
  $('#write-rounds').select2();
  $('#write-categories').select2({
    tags: true
  });

  initStars();
});

function initStars() {
  var starButtons = $('#write-stars-display .star');
  starButtons.each(function (i, item) {
    $(item).attr('data-stars', i + 1);
  });
  $("#write-stars-display").on('click', '.star', function () {
    var stars = $(this).data('stars');
    $('#write-stars').val(stars);
    starButtons.each(function (i, item) {
      item = $(item);
      if (item.data('stars') <= stars) {
        item.text('star');
      } else {
        item.text('star_outline');
      }
    });
  });
  var currentStars = $('#write-stars').val();
  if (currentStars > 0) {
    $('#write-stars-display .star[data-stars="' + currentStars + '"]').click();
  }
}


text:
#include "util.h"
#include "debug.h"

static void report(const char *prefix, const char *err, va_list params)
{
	char msg[1024];
	vsnprintf(msg, sizeof(msg), err, params);
	fprintf(stderr, " %s%s\n", prefix, msg);
}

static NORETURN void usage_builtin(const char *err)
{
	fprintf(stderr, "\n Usage: %s\n", err);
	exit(129);
}

static NORETURN void die_builtin(const char *err, va_list params)
{
	report(" Fatal: ", err, params);
	exit(128);
}

static void error_builtin(const char *err, va_list params)
{
	report(" Error: ", err, params);
}

static void warn_builtin(const char *warn, va_list params)
{
	report(" Warning: ", warn, params);
}

/* If we are in a dlopen()ed .so write to a global variable would segfault
 * (ugh), so keep things static. */
static void (*usage_routine)(const char *err) NORETURN = usage_builtin;
static void (*die_routine)(const char *err, va_list params) NORETURN = die_builtin;
static void (*error_routine)(const char *err, va_list params) = error_builtin;
static void (*warn_routine)(const char *err, va_list params) = warn_builtin;

void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN)
{
	die_routine = routine;
}

void usage(const char *err)
{
	usage_routine(err);
}

void die(const char *err, ...)
{
	va_list params;

	va_start(params, err);
	die_routine(err, params);
	va_end(params);
}

int error(const char *err, ...)
{
	va_list params;

	va_start(params, err);
	error_routine(err, params);
	va_end(params);
	return -1;
}

void warning(const char *warn, ...)
{
	va_list params;

	va_start(params, warn);
	warn_routine(warn, params);
	va_end(params);
}


text:
// Copyright 1998-2017 Epic Games, Inc. All Rights Reserved.
/*===========================================================================
	Generated code exported from UnrealHeaderTool.
	DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/

#include "GeneratedCppIncludes.h"
PRAGMA_DISABLE_OPTIMIZATION
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeSqlitePlugin_init() {}
	SQLITEPLUGIN_API UFunction* Z_Construct_UDelegateFunction_UClientBaseController_ClientInitData__DelegateSignature();
	SQLITEPLUGIN_API UFunction* Z_Construct_UDelegateFunction_UClientBaseController_ClientInitError__DelegateSignature();
	UPackage* Z_Construct_UPackage__Script_SqlitePlugin()
	{
		static UPackage* ReturnPackage = nullptr;
		if (!ReturnPackage)
		{
			ReturnPackage = CastChecked<UPackage>(StaticFindObjectFast(UPackage::StaticClass(), nullptr, FName(TEXT("/Script/SqlitePlugin")), false, false));
			ReturnPackage->SetPackageFlags(PKG_CompiledIn | 0x00000000);
			FGuid Guid;
			Guid.A = 0xE2B99D82;
			Guid.B = 0x98E7CA79;
			Guid.C = 0x00000000;
			Guid.D = 0x00000000;
			ReturnPackage->SetGuid(Guid);

			Z_Construct_UDelegateFunction_UClientBaseController_ClientInitData__DelegateSignature();
			Z_Construct_UDelegateFunction_UClientBaseController_ClientInitError__DelegateSignature();
		}
		return ReturnPackage;
	}
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
PRAGMA_ENABLE_OPTIMIZATION


text:
IMAGE_NAME = shipenterprise/vm-loader

image:
	docker build -t $(IMAGE_NAME) .

.PHONY: image