text:
using System.Collections;
using System.Diagnostics;

namespace System.Xml.XPath
{
    [DebuggerDisplay("Position={CurrentPosition}, Current={debuggerDisplayProxy}")]
    public abstract class XPathNodeIterator : ICloneable, IEnumerable
    {
        internal int count = -1;

        object ICloneable.Clone() { return this.Clone(); }

        public abstract XPathNodeIterator Clone();
        public abstract bool MoveNext();
        public abstract XPathNavigator Current { get; }
        public abstract int CurrentPosition { get; }
        public virtual int Count
        {
            get
            {
                if (count == -1)
                {
                    XPathNodeIterator clone = this.Clone();
                    while (clone.MoveNext()) ;
                    count = clone.CurrentPosition;
                }
                return count;
            }
        }
        public virtual IEnumerator GetEnumerator()
        {
            return new Enumerator(this);
        }

        private object debuggerDisplayProxy { get { return Current == null ? null : (object)new XPathNavigator.DebuggerDisplayProxy(Current); } }

        /// <summary>
        /// Implementation of a resetable enumerator that is linked to the XPathNodeIterator used to create it.
        /// </summary>
        private class Enumerator : IEnumerator
        {
            private readonly XPathNodeIterator _original;     // Keep original XPathNodeIterator in case Reset() is called
            private XPathNodeIterator _current;
            private bool _iterationStarted;

            public Enumerator(XPathNodeIterator original)
            {
                _original = original.Clone();
            }

            public virtual object Current
            {
                get
                {
                    // 1. Do not reuse the XPathNavigator, as we do in XPathNodeIterator
                    // 2. Throw exception if current position is before first node or after the last node
                    if (_iterationStarted)
                    {
                        // Current is null if iterator is positioned after the last node
                        if (_current == null)
                            throw new InvalidOperationException(SR.Format(SR.Sch_EnumFinished, string.Empty));

                        return _current.Current.Clone();
                    }

                    // User must call MoveNext before accessing Current property
                    throw new InvalidOperationException(SR.Format(SR.Sch_EnumNotStarted, string.Empty));
                }
            }

            public virtual bool MoveNext()
            {
                // Delegate to XPathNodeIterator
                if (!_iterationStarted)
                {
                    // Reset iteration to original position
                    _current = _original.Clone();
                    _iterationStarted = true;
                }

                if (_current == null || !_current.MoveNext())
                {
                    // Iteration complete
                    _current = null;
                    return false;
                }
                return true;
            }

            public virtual void Reset()
            {
                _iterationStarted = false;
            }
        }
    }
}


text:
using System.Runtime.Serialization;

namespace Umbraco.Cms.Core.Models.ContentEditing;

[DataContract(Name = "scriptFile", Namespace = "")]
public class SnippetDisplay
{
    [DataMember(Name = "name", IsRequired = true)]
    public string? Name { get; set; }

    [DataMember(Name = "fileName", IsRequired = true)]
    public string? FileName { get; set; }
}

redpajama_set_name: RedPajamaGithub


text:
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/suggestedEditsItemRootView"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingTop="4dp">

    <ProgressBar
        android:id="@+id/cardItemProgressBar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_marginTop="64dp"
        android:layout_marginBottom="64dp" />

    <org.wikipedia.views.WikiErrorView
        android:id="@+id/cardItemErrorView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:layout_marginTop="48dp"
        android:layout_marginBottom="48dp"
        android:layout_marginStart="16dp"
        android:layout_marginEnd="16dp"
        android:visibility="gone" />

    <androidx.constraintlayout.widget.ConstraintLayout
        android:id="@+id/contentContainer"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">

        <!-- Container layout is necessary to make the ImageView zoomable in-place. -->
        <FrameLayout
            android:layout_width="match_parent"
            android:layout_height="0dp"
            app:layout_constraintTop_toTopOf="parent"
            app:layout_constraintHeight_percent="0.65"
            android:layout_marginTop="64dp">
            <ImageView
                android:id="@+id/imageView"
                android:layout_width="match_parent"
                android:layout_height="match_parent"
                android:scaleType="fitCenter"
                android:contentDescription="@null"/>
        </FrameLayout>

        <TextView
            android:id="@+id/imageCaption"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:layout_constraintTop_toTopOf="parent"
            android:paddingTop="8dp"
            android:paddingBottom="5dp"
            android:paddingStart="16dp"
            android:paddingEnd="16dp"
            android:textAlignment="center"
            android:lineSpacingExtra="6sp"
            android:maxLines="3"
            android:ellipsize="end"
            android:textColor="?attr/color_group_59"
            android:textColorLink="?attr/color_group_59"
            android:textIsSelectable="true"
            tools:text="Lorem ipsum"/>

        <LinearLayout
            android:id="@+id/tagsContainer"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            app:layout_constraintBottom_toBottomOf="parent"
            android:paddingTop="5dp"
            android:paddingStart="16dp"
            android:paddingEnd="16dp"
            android:clipChildren="false"
            android:clipToPadding="false"
            android:orientation="vertical">

            <TextView
                android:id="@+id/tagsHintText"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:textAlignment="center"
                android:text="@string/suggested_edits_image_tags_choose"
                android:textStyle="italic"
                android:textColor="?attr/color_group_59"/>

            <TextView
                android:id="@+id/tagsLicenseText"
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:textAlignment="center"
                android:textColor="?android:attr/textColorTertiary"
                android:textColorLink="?android:attr/textColorTertiary"
                android:textSize="12sp"
                android:lineSpacingExtra="4sp"
                android:visibility="gone"
                tools:text="Lorem ipsum"
                tools:visibility="visible"/>

            <ScrollView
                android:layout_width="match_parent"
                android:layout_height="wrap_content"
                android:layout_marginTop="12dp"
                android:layout_marginBottom="4dp">

                <com.google.android.flexbox.FlexboxLayout
                    android:id="@+id/tagsChipGroup"
                    android:layout_width="match_parent"
                    android:layout_height="wrap_content"
                    app:flexWrap="wrap"
                    app:justifyContent="flex_start"/>

            </ScrollView>

        </LinearLayout>

    </androidx.constraintlayout.widget.ConstraintLayout>

    <FrameLayout
        android:id="@+id/publishOverlayContainer"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:clickable="true"
        android:focusable="true"
        android:visibility="gone"
        tools:visibility="visible">

        <ProgressBar
            android:id="@+id/publishProgressBar"
            android:layout_width="48dp"
            android:layout_height="48dp"
            android:layout_gravity="center" />

        <ProgressBar
            android:id="@+id/publishProgressBarComplete"
            android:layout_width="48dp"
            android:layout_height="48dp"
            android:layout_gravity="center"
            style="?android:attr/progressBarStyleHorizontal"
            android:indeterminate="false"
            android:max="100"
            android:secondaryProgress="100"
            android:progressDrawable="@drawable/circular_progress" />

        <ImageView
            android:id="@+id/publishProgressCheck"
            android:layout_width="34dp"
            android:layout_height="34dp"
            android:layout_gravity="center"
            app:srcCompat="@drawable/ic_check_borderless"
            android:contentDescription="@null"/>

        <TextView
            android:id="@+id/publishProgressText"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:layout_marginTop="38dp"
            android:textAllCaps="true"
            android:fontFamily="sans-serif-medium"
            android:letterSpacing="0.06"
            android:text="@string/suggested_edits_image_tags_publishing"/>

    </FrameLayout>

</FrameLayout>


text:
school
======

School stuff. First Read.me file. You know it.


text:
package io.quarkus.container.image.openshift.deployment;

public enum BuildStrategy {

    BINARY,
    DOCKER;

}


text:
package org.glowroot.agent.plugin.netty;

import java.util.List;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.HttpServerUpgradeHandler;

import static io.netty.buffer.Unpooled.unreleasableBuffer;
import static io.netty.handler.codec.http2.Http2CodecUtil.connectionPrefaceBuf;
import static io.netty.util.internal.ObjectUtil.checkNotNull;

// copied from Netty in order to test against old 4.1.x versions since this class does not exist
// prior to 4.1.10.Final
public class CleartextHttp2ServerUpgradeHandler extends ChannelHandlerAdapter {

    private static final ByteBuf CONNECTION_PREFACE = unreleasableBuffer(connectionPrefaceBuf());

    private final HttpServerCodec httpServerCodec;
    private final HttpServerUpgradeHandler httpServerUpgradeHandler;
    private final ChannelHandler http2ServerHandler;

    public CleartextHttp2ServerUpgradeHandler(HttpServerCodec httpServerCodec,
            HttpServerUpgradeHandler httpServerUpgradeHandler,
            ChannelHandler http2ServerHandler) {
        this.httpServerCodec = checkNotNull(httpServerCodec, "httpServerCodec");
        this.httpServerUpgradeHandler =
                checkNotNull(httpServerUpgradeHandler, "httpServerUpgradeHandler");
        this.http2ServerHandler = checkNotNull(http2ServerHandler, "http2ServerHandler");
    }

    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        ctx.pipeline()
                .addBefore(ctx.name(), null, new PriorKnowledgeHandler())
                .addBefore(ctx.name(), null, httpServerCodec)
                .replace(this, null, httpServerUpgradeHandler);
    }

    private final class PriorKnowledgeHandler extends ByteToMessageDecoder {
        @Override
        protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out)
                throws Exception {
            int prefaceLength = CONNECTION_PREFACE.readableBytes();
            int bytesRead = Math.min(in.readableBytes(), prefaceLength);

            if (!ByteBufUtil.equals(CONNECTION_PREFACE, CONNECTION_PREFACE.readerIndex(),
                    in, in.readerIndex(), bytesRead)) {
                ctx.pipeline().remove(this);
            } else if (bytesRead == prefaceLength) {
                // Full h2 preface match, removed source codec, using http2 codec to handle
                // following network traffic
                ctx.pipeline()
                        .remove(httpServerCodec)
                        .remove(httpServerUpgradeHandler);

                ctx.pipeline().addAfter(ctx.name(), null, http2ServerHandler);
                ctx.pipeline().remove(this);

                ctx.fireUserEventTriggered(PriorKnowledgeUpgradeEvent.INSTANCE);
            }
        }
    }

    public static final class PriorKnowledgeUpgradeEvent {

        private static final PriorKnowledgeUpgradeEvent INSTANCE = new PriorKnowledgeUpgradeEvent();

        private PriorKnowledgeUpgradeEvent() {}
    }
}


text:
Class.forName({
  name: "class Error",
  alias: "js.lang.Error",

  "private name": "js.lang.Error", // 错误名
  "private number": 1,

  Error: function(message, fileName, lineNumber, stack) {
    this.message = message;
    this.fileName = fileName;
    this.stack = stack;
    this.lineNumber = lineNumber;
  },
  'static init': function() {
    var methods = {},
      __methods = js.lang.Throwable.$class.getMethods(),
      __length = __methods.length,
      __index = 0;
    for (; __index < __length; __index++) {
      methods[__methods[__index]._name] = __methods[__index]._value;
    }
    Object.extend(Error.prototype, methods);
  }
});

js.lang.Error.init();


text:
import time

from cql.cassandra.ttypes import (CfDef, ColumnParent, ColumnPath,
                                  ConsistencyLevel, CounterColumn)
from dtest import Tester, debug, create_ks
from thrift_tests import get_thrift_client
from tools.misc import ImmutableMapping

from tools.decorators import since

@since('2.0', max_version='4')
class TestSuperCounterClusterRestart(Tester):
    """
    This test is part of this issue:
    https://issues.apache.org/jira/browse/CASSANDRA-3821
    """
    cluster_options = ImmutableMapping({'start_rpc': 'true'})

    def functional_test(self):
        NUM_SUBCOLS = 100
        NUM_ADDS = 100

        cluster = self.cluster
        cluster.populate(3).start()
        node1 = cluster.nodelist()[0]

        time.sleep(.5)
        session = self.patient_cql_connection(node1)
        create_ks(session, 'ks', 3)
        time.sleep(1)  # wait for propagation

        # create the columnfamily using thrift
        host, port = node1.network_interfaces['thrift']
        thrift_conn = get_thrift_client(host, port)
        thrift_conn.transport.open()
        thrift_conn.set_keyspace('ks')
        cf_def = CfDef(keyspace='ks', name='cf', column_type='Super',
                       default_validation_class='CounterColumnType')
        thrift_conn.system_add_column_family(cf_def)

        # let the sediment settle to to the bottom before drinking...
        time.sleep(2)

        for subcol in xrange(NUM_SUBCOLS):
            for add in xrange(NUM_ADDS):
                column_parent = ColumnParent(column_family='cf',
                                             super_column='subcol_%d' % subcol)
                counter_column = CounterColumn('col_0', 1)
                thrift_conn.add('row_0', column_parent, counter_column,
                                ConsistencyLevel.QUORUM)
        time.sleep(1)
        cluster.flush()

        debug("Stopping cluster")
        cluster.stop()
        time.sleep(5)
        debug("Starting cluster")
        cluster.start()
        time.sleep(5)

        thrift_conn = get_thrift_client(host, port)
        thrift_conn.transport.open()
        thrift_conn.set_keyspace('ks')

        from_db = []

        for i in xrange(NUM_SUBCOLS):
            column_path = ColumnPath(column_family='cf', column='col_0',
                                     super_column='subcol_%d' % i)
            column_or_super_column = thrift_conn.get('row_0', column_path,
                                                     ConsistencyLevel.QUORUM)
            val = column_or_super_column.counter_column.value
            debug(str(val)),
            from_db.append(val)
        debug("")

        expected = [NUM_ADDS for i in xrange(NUM_SUBCOLS)]

        if from_db != expected:
            raise Exception("Expected a bunch of the same values out of the db. Got this: " + str(from_db))


text:
[Ractive](http://www.ractivejs.org/) component wrapping [IScroll](http://iscrolljs.com/) library.

# Usage
1. `npm install ractive-component-iscroll`
2. Include CSS for `.scroll-wrapper` and `.scroller` (see iscroll.css for example)
3. Wrap scrollable part of your template into `<Scroll>` tags (all attributes are optional):

    ```html
    <Scroll class="myscroll" id="..." opts='{scrollbars: false}'>
       ..template..
    </Scroll>
    ```
4. Define height and/or width for `.myscroll` or `.scroll-wrapper` (a class assigned to each `<Scroll>`)

5. Require component in your app:
    ```javascript
    require('ractive-component-iscroll');
    ```
    This will add `Scroll` to `Ractive.components`.

There is a sample application in `example/` folder, check it out.

# Notes

Changing `opts` attribute re-creates iscroll instance.

If provided, `opts.onRefresh(scroll_instance)` function is called when scroller updates.

IScroll inhibits `click` events and can emit `tap` events instead.

Some iscroll options do not work (e.g. `fadeScrollbars: true`), don't know why yet.

[MutationObserver](https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver) is used to detect when scroll should be updated.

# License
MIT


text:
package com.sun.xml.dtdparser;

import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

/**
 * do-nothing implementation of DTDEventHandler.
 */
public class DTDHandlerBase implements DTDEventListener {

    /**
     * Constructs a DTDHandlerBase.
     */
    public DTDHandlerBase() {}

    @Override
    public void processingInstruction(String target, String data)
            throws SAXException {
    }

    @Override
    public void setDocumentLocator(Locator loc) {
    }

    @Override
    public void fatalError(SAXParseException e) throws SAXException {
        throw e;
    }

    @Override
    public void error(SAXParseException e) throws SAXException {
        throw e;
    }

    @Override
    public void warning(SAXParseException err) throws SAXException {
    }

    @Override
    public void notationDecl(String name, String publicId, String systemId) throws SAXException {
    }

    @Override
    public void unparsedEntityDecl(String name, String publicId,
                                   String systemId, String notationName) throws SAXException {
    }

    @Override
    public void endDTD() throws SAXException {
    }

    @Override
    public void externalGeneralEntityDecl(String n, String p, String s) throws SAXException {
    }

    @Override
    public void internalGeneralEntityDecl(String n, String v) throws SAXException {
    }

    @Override
    public void externalParameterEntityDecl(String n, String p, String s) throws SAXException {
    }

    @Override
    public void internalParameterEntityDecl(String n, String v) throws SAXException {
    }

    @Override
    public void startDTD(InputEntity in) throws SAXException {
    }

    @Override
    public void comment(String n) throws SAXException {
    }

    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
    }

    @Override
    public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException {
    }

    @Override
    public void startCDATA() throws SAXException {
    }

    @Override
    public void endCDATA() throws SAXException {
    }

    @Override
    public void startContentModel(String elementName, short contentModelType) throws SAXException {
    }

    @Override
    public void endContentModel(String elementName, short contentModelType) throws SAXException {
    }

    @Override
    public void attributeDecl(String elementName, String attributeName, String attributeType,
                              String[] enumeration, short attributeUse, String defaultValue) throws SAXException {
    }

    @Override
    public void childElement(String elementName, short occurence) throws SAXException {
    }

    @Override
    public void mixedElement(String elementName) throws SAXException {
    }

    @Override
    public void startModelGroup() throws SAXException {
    }

    @Override
    public void endModelGroup(short occurence) throws SAXException {
    }

    @Override
    public void connector(short connectorType) throws SAXException {
    }
}


text:
<![if gte IE 9]>
<!DOCTYPE HTML>

<![endif]>
		<title>Test charting sizing</title>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">


text:
package app

import (
	"fmt"
	"math/rand"
	"regexp"
	"sort"
	"strings"

	kapi "github.com/GoogleCloudPlatform/kubernetes/pkg/api"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/api/validation"
	"github.com/GoogleCloudPlatform/kubernetes/pkg/runtime"
	kutil "github.com/GoogleCloudPlatform/kubernetes/pkg/util"
	"github.com/golang/glog"

	deploy "github.com/openshift/origin/pkg/deploy/api"
	image "github.com/openshift/origin/pkg/image/api"
	route "github.com/openshift/origin/pkg/route/api"
)

type Pipeline struct {
	From string

	InputImage *ImageRef
	Build      *BuildRef
	Image      *ImageRef
	Deployment *DeploymentConfigRef
}

// NewImagePipeline creates a new pipeline with components that are not
// expected to be built
func NewImagePipeline(from string, image *ImageRef) (*Pipeline, error) {
	return &Pipeline{
		From:  from,
		Image: image,
	}, nil
}

// NewBuildPipeline creates a new pipeline with components that are
// expected to be built
func NewBuildPipeline(from string, input *ImageRef, strategy *BuildStrategyRef, source *SourceRef) (*Pipeline, error) {
	name, ok := NameSuggestions{source, input}.SuggestName()
	if !ok {
		name = fmt.Sprintf("app%d", rand.Intn(10000))
	}

	output := &ImageRef{
		DockerImageReference: image.DockerImageReference{
			Name: name,
			Tag:  image.DefaultImageTag,
		},

		OutputImage:   true,
		AsImageStream: true,
	}
	if input != nil {
		// TODO: assumes that build doesn't change the image metadata. In the future
		// we could get away with deferred generation possibly.
		output.Info = input.Info
	}

	build := &BuildRef{
		Source:   source,
		Input:    input,
		Strategy: strategy,
		Output:   output,
	}

	return &Pipeline{
		From:       from,
		InputImage: input,
		Image:      output,
		Build:      build,
	}, nil
}

// NeedsDeployment sets the pipeline for deployment
func (p *Pipeline) NeedsDeployment(env Environment, name string) error {
	if p.Deployment != nil {
		return nil
	}
	p.Deployment = &DeploymentConfigRef{
		Name: name,
		Images: []*ImageRef{
			p.Image,
		},
		Env: env,
	}
	return nil
}

// Objects converts all the components in the pipeline into runtime objects
func (p *Pipeline) Objects(accept, objectAccept Acceptor) (Objects, error) {
	objects := Objects{}
	if p.InputImage != nil && p.InputImage.AsImageStream && accept.Accept(p.InputImage) {
		repo, err := p.InputImage.ImageStream()
		if err != nil {
			return nil, err
		}
		if objectAccept.Accept(repo) {
			objects = append(objects, repo)
		}
	}
	if p.Image != nil && p.Image.AsImageStream && accept.Accept(p.Image) {
		repo, err := p.Image.ImageStream()
		if err != nil {
			return nil, err
		}
		if objectAccept.Accept(repo) {
			objects = append(objects, repo)
		}
	}
	if p.Build != nil && accept.Accept(p.Build) {
		build, err := p.Build.BuildConfig()
		if err != nil {
			return nil, err
		}
		if objectAccept.Accept(build) {
			objects = append(objects, build)
		}
	}
	if p.Deployment != nil && accept.Accept(p.Deployment) {
		dc, err := p.Deployment.DeploymentConfig()
		if err != nil {
			return nil, err
		}
		if objectAccept.Accept(dc) {
			objects = append(objects, dc)
		}
	}
	return objects, nil
}

// PipelineGroup is a group of Pipelines
type PipelineGroup []*Pipeline

// Reduce squashes all common components from the pipelines
func (g PipelineGroup) Reduce() error {
	var deployment *DeploymentConfigRef
	for _, p := range g {
		if p.Deployment == nil || p.Deployment == deployment {
			continue
		}
		if deployment == nil {
			deployment = p.Deployment
		} else {
			deployment.Images = append(deployment.Images, p.Deployment.Images...)
			deployment.Env = NewEnvironment(deployment.Env, p.Deployment.Env)
			p.Deployment = deployment
		}
	}
	return nil
}

func (g PipelineGroup) String() string {
	s := []string{}
	for _, p := range g {
		s = append(s, p.From)
	}
	return strings.Join(s, "+")
}

const maxServiceNameLength = 24

var invalidServiceChars = regexp.MustCompile("[^-a-z0-9]")

func makeValidServiceName(name string) (string, string) {
	if ok, _ := validation.ValidateServiceName(name, false); ok {
		return name, ""
	}
	name = strings.ToLower(name)
	name = invalidServiceChars.ReplaceAllString(name, "")
	name = strings.TrimFunc(name, func(r rune) bool { return r == '-' })
	switch {
	case len(name) == 0:
		return "", "service-"
	case len(name) > maxServiceNameLength:
		name = name[:maxServiceNameLength]
	}
	return name, ""
}

type sortablePorts []kapi.ContainerPort

func (s sortablePorts) Len() int           { return len(s) }
func (s sortablePorts) Less(i, j int) bool { return s[i].ContainerPort < s[j].ContainerPort }
func (s sortablePorts) Swap(i, j int) {
	p := s[i]
	s[i] = s[j]
	s[j] = p
}

// AddServices sets up services for the provided objects
func AddServices(objects Objects) Objects {
	svcs := []runtime.Object{}
	for _, o := range objects {
		switch t := o.(type) {
		case *deploy.DeploymentConfig:
			name, generateName := makeValidServiceName(t.Name)
			svc := &kapi.Service{
				ObjectMeta: kapi.ObjectMeta{
					Name:         name,
					GenerateName: generateName,
					Labels:       t.Labels,
				},
				Spec: kapi.ServiceSpec{
					Selector: t.Template.ControllerTemplate.Selector,
				},
			}

			for _, container := range t.Template.ControllerTemplate.Template.Spec.Containers {
				ports := sortablePorts(container.Ports)
				sort.Sort(&ports)
				for _, p := range ports {
					svc.Spec.Ports = append(svc.Spec.Ports, kapi.ServicePort{
						Name:       p.Name,
						Port:       p.ContainerPort,
						Protocol:   p.Protocol,
						TargetPort: kutil.NewIntOrStringFromInt(p.ContainerPort),
					})
					break
				}
			}
			if len(svc.Spec.Ports) == 0 {
				glog.Warningf("DeploymentConfig %q: Cannot create a service with no ports", t.Name)
				continue
			}
			svcs = append(svcs, svc)
		}
	}
	return append(objects, svcs...)
}

// AddRoutes sets up routes for the provided objects
func AddRoutes(objects Objects) Objects {
	routes := []runtime.Object{}
	for _, o := range objects {
		switch t := o.(type) {
		case *kapi.Service:
			routes = append(routes, &route.Route{
				ObjectMeta: kapi.ObjectMeta{
					Name:   t.Name,
					Labels: t.Labels,
				},
				ServiceName: t.Name,
			})
		}
	}
	return append(objects, routes...)
}

type acceptNew struct{}

// AcceptNew only accepts runtime.Objects with an empty resource version.
var AcceptNew Acceptor = acceptNew{}

// Accept accepts any kind of object
func (acceptNew) Accept(from interface{}) bool {
	_, meta, err := objectMetaData(from)
	if err != nil {
		return false
	}
	if len(meta.ResourceVersion) > 0 {
		return false
	}
	return true
}

type acceptUnique struct {
	typer   runtime.ObjectTyper
	objects map[string]struct{}
}

// Accept accepts any kind of object it hasn't accepted before
func (a *acceptUnique) Accept(from interface{}) bool {
	obj, meta, err := objectMetaData(from)
	if err != nil {
		return false
	}
	_, kind, err := a.typer.ObjectVersionAndKind(obj)
	if err != nil {
		return false
	}
	key := fmt.Sprintf("%s/%s", kind, meta.Name)
	_, exists := a.objects[key]
	if exists {
		return false
	}
	a.objects[key] = struct{}{}
	return true
}

// NewAcceptUnique creates an acceptor that only accepts unique objects
// by kind and name
func NewAcceptUnique(typer runtime.ObjectTyper) Acceptor {
	return &acceptUnique{
		typer:   typer,
		objects: map[string]struct{}{},
	}
}

func objectMetaData(raw interface{}) (runtime.Object, *kapi.ObjectMeta, error) {
	obj, ok := raw.(runtime.Object)
	if !ok {
		return nil, nil, fmt.Errorf("%#v is not a runtime.Object", raw)
	}
	meta, err := kapi.ObjectMetaFor(obj)
	if err != nil {
		return nil, nil, err
	}
	return obj, meta, nil
}

// Acceptors is a list of acceptors that behave like a single acceptor.
// All acceptors must accept an object for it to be accepted.
type Acceptors []Acceptor

// Accept iterates through all acceptors and determines whether the object
// should be accepted
func (aa Acceptors) Accept(from interface{}) bool {
	for _, a := range aa {
		if !a.Accept(from) {
			return false
		}
	}
	return true
}

type acceptAll struct{}

// AcceptAll accepts all objects
var AcceptAll Acceptor = acceptAll{}

// Accept accepts everything
func (acceptAll) Accept(_ interface{}) bool {
	return true
}

// Objects is a set of runtime objects
type Objects []runtime.Object

// Acceptor is an interface for accepting objects
type Acceptor interface {
	Accept(from interface{}) bool
}

type acceptFirst struct {
	handled map[interface{}]struct{}
}

// NewAcceptFirst returns a new Acceptor
func NewAcceptFirst() Acceptor {
	return &acceptFirst{make(map[interface{}]struct{})}
}

// Accept accepts any object it hasn't accepted before
func (s *acceptFirst) Accept(from interface{}) bool {
	if _, ok := s.handled[from]; ok {
		return false
	}
	s.handled[from] = struct{}{}
	return true
}


text:
#ifndef ___VIOSTOR_H__
#define ___VIOSTOR_H__

#include <ntddk.h>
#include <storport.h>

#include "osdep.h"
#include "virtio_pci.h"
#include "virtio.h"
#include "virtio_ring.h"
#include "virtio_stor_utils.h"
#include "virtio_stor_hw_helper.h"

typedef struct VirtIOBufferDescriptor VIO_SG, *PVIO_SG;

/* Feature bits */
#define VIRTIO_BLK_F_BARRIER    0       /* Does host support barriers? */
#define VIRTIO_BLK_F_SIZE_MAX   1       /* Indicates maximum segment size */
#define VIRTIO_BLK_F_SEG_MAX    2       /* Indicates maximum # of segments */
#define VIRTIO_BLK_F_GEOMETRY   4       /* Legacy geometry available  */
#define VIRTIO_BLK_F_RO         5       /* Disk is read-only */
#define VIRTIO_BLK_F_BLK_SIZE   6       /* Block size of disk is available*/
#define VIRTIO_BLK_F_SCSI       7       /* Supports scsi command passthru */
#define VIRTIO_BLK_F_FLUSH      9       /* Flush command supported */
#define VIRTIO_BLK_F_TOPOLOGY   10      /* Topology information is available */
#define VIRTIO_BLK_F_CONFIG_WCE 11      /* Writeback mode available in config */
#define VIRTIO_BLK_F_MQ         12      /* support more than one vq */
#define VIRTIO_BLK_F_DISCARD    13      /* DISCARD is supported */
#define VIRTIO_BLK_F_WRITE_ZEROES 14    /* WRITE ZEROES is supported */

/* These two define direction. */
#define VIRTIO_BLK_T_IN         0
#define VIRTIO_BLK_T_OUT        1

#define VIRTIO_BLK_T_SCSI_CMD   2
#define VIRTIO_BLK_T_FLUSH      4
#define VIRTIO_BLK_T_GET_ID     8
#define VIRTIO_BLK_T_DISCARD    11
#define VIRTIO_BLK_T_WRITE_ZEROES   13

#define VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP   0x00000001

#define VIRTIO_BLK_S_OK         0
#define VIRTIO_BLK_S_IOERR      1
#define VIRTIO_BLK_S_UNSUPP     2

#define SECTOR_SIZE             512
#define SECTOR_SHIFT            9
#define IO_PORT_LENGTH          0x40
#define MAX_CPU                 256u
#define MAX_DISCARD_SEGMENTS    256u

#define VIRTIO_BLK_QUEUE_LAST   MAX_CPU

#define VIRTIO_BLK_MSIX_CONFIG_VECTOR   0

#define BLOCK_SERIAL_STRLEN     20

#define MAX_PHYS_SEGMENTS       64

#define VIRTIO_MAX_SG           (3+MAX_PHYS_SEGMENTS)

#define VIOBLK_POOL_TAG        'BoiV'

#define VIOBLK_MAX_TRANSFER     0x00FFFFFF

#pragma pack(1)
typedef struct virtio_blk_config {
    /* The capacity (in 512-byte sectors). */
    u64 capacity;
    /* The maximum segment size (if VIRTIO_BLK_F_SIZE_MAX) */
    u32 size_max;
    /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */
    u32 seg_max;
    /* geometry the device (if VIRTIO_BLK_F_GEOMETRY) */
    struct virtio_blk_geometry {
        u16 cylinders;
        u8 heads;
        u8 sectors;
    } geometry;
    /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
    u32 blk_size;
    u8  physical_block_exp;
    u8  alignment_offset;
    u16 min_io_size;
    u32 opt_io_size;
    /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */
    u8 wce;
    u8 unused;
    /* number of vqs, only available when VIRTIO_BLK_F_MQ is set */
    u16 num_queues;

    /* the next 3 entries are guarded by VIRTIO_BLK_F_DISCARD */
    /*
     * The maximum discard sectors (in 512-byte sectors) for
     * one segment.
     */
    u32 max_discard_sectors;
    /*
     * The maximum number of discard segments in a
     * discard command.
     */
    u32 max_discard_seg;
    /* Discard commands must be aligned to this number of sectors. */
    u32 discard_sector_alignment;

    /* the next 3 entries are guarded by VIRTIO_BLK_F_WRITE_ZEROES */
    /*
     * The maximum number of write zeroes sectors (in 512-byte sectors) in
     * one segment.
     */
    u32 max_write_zeroes_sectors;
    /*
     * The maximum number of segments in a write zeroes
     * command.
     */
    u32 max_write_zeroes_seg;
    /*
     * Set if a VIRTIO_BLK_T_WRITE_ZEROES request may result in the
     * deallocation of one or more of the sectors.
     */
    u8 write_zeroes_may_unmap;

    u8 unused1[3];
}blk_config, *pblk_config;
#pragma pack()

typedef struct virtio_blk_outhdr {
    /* VIRTIO_BLK_T* */
    u32 type;
    /* io priority. */
    u32 ioprio;
    /* Sector (ie. 512 byte offset) */
    u64 sector;
}blk_outhdr, *pblk_outhdr;

/* Discard/write zeroes range for each request. */
typedef struct virtio_blk_discard_write_zeroes {
    /* discard/write zeroes start sector */
    u64 sector;
    /* number of discard/write zeroes sectors */
    u32 num_sectors;
    /* flags for this range */
    u32 flags;
}blk_discard_write_zeroes, *pblk_discard_write_zeroes;

typedef struct virtio_blk_req {
    LIST_ENTRY list_entry;
    PVOID      req;
    blk_outhdr out_hdr;
    u8         status;
}blk_req, *pblk_req;

typedef struct virtio_bar {
    PHYSICAL_ADDRESS  BasePA;
    ULONG             uLength;
    PVOID             pBase;
    BOOLEAN           bPortSpace;
} VIRTIO_BAR, *PVIRTIO_BAR;

typedef struct _SENSE_INFO {
    UCHAR senseKey;
    UCHAR additionalSenseCode;
    UCHAR additionalSenseCodeQualifier;
} SENSE_INFO, *PSENSE_INFO;

typedef struct _ADAPTER_EXTENSION {
    VirtIODevice          vdev;

    PVOID                 pageAllocationVa;
    ULONG                 pageAllocationSize;
    ULONG                 pageOffset;

    PVOID                 poolAllocationVa;
    ULONG                 poolAllocationSize;
    ULONG                 poolOffset;

    struct virtqueue *    vq[VIRTIO_BLK_QUEUE_LAST];
    USHORT                num_queues;
    INQUIRYDATA           inquiry_data;
    blk_config            info;
    ULONG                 queue_depth;
    BOOLEAN               dump_mode;
    ULONG                 msix_vectors;
    BOOLEAN               msix_enabled;
    BOOLEAN               msix_one_vector;
    ULONGLONG             features;
    CHAR                  sn[BLOCK_SERIAL_STRLEN];
    BOOLEAN               sn_ok;
    blk_req               vbr;
    BOOLEAN               indirect;
    ULONGLONG             lastLBA;

    union {
        PCI_COMMON_HEADER pci_config;
        UCHAR             pci_config_buf[sizeof(PCI_COMMON_CONFIG)];
    };
    VIRTIO_BAR            pci_bars[PCI_TYPE0_ADDRESSES];
    ULONG                 system_io_bus_number;
    ULONG                 slot_number;
    ULONG                 perfFlags;
    PSTOR_DPC             dpc;
    BOOLEAN               dpc_ok;
    BOOLEAN               check_condition;
    SENSE_INFO            sense_info;
    BOOLEAN               removed;
#if (NTDDI_VERSION > NTDDI_WIN7)
    STOR_ADDR_BTL8        device_address;
    blk_discard_write_zeroes blk_discard[16];
#endif
#ifdef DBG
    ULONG                 srb_cnt;
    ULONG                 inqueue_cnt;
#endif
}ADAPTER_EXTENSION, *PADAPTER_EXTENSION;

typedef struct _VRING_DESC_ALIAS
{
    union
    {
        ULONGLONG data[2];
        UCHAR chars[SIZE_OF_SINGLE_INDIRECT_DESC];
    }u;
}VRING_DESC_ALIAS;

typedef struct _SRB_EXTENSION {
    blk_req               vbr;
    ULONG                 out;
    ULONG                 in;
    ULONG                 MessageID;
    BOOLEAN               fua;
    VIO_SG                sg[VIRTIO_MAX_SG];
    VRING_DESC_ALIAS      desc[VIRTIO_MAX_SG];
}SRB_EXTENSION, *PSRB_EXTENSION;

BOOLEAN
VirtIoInterrupt(
    IN PVOID DeviceExtension
    );

#ifndef SCSI_SENSE_ERRORCODE_FIXED_CURRENT
#define SCSI_SENSE_ERRORCODE_FIXED_CURRENT       0x70
#endif

#ifndef SCSI_SENSEQ_CAPACITY_DATA_CHANGED
#define SCSI_SENSEQ_CAPACITY_DATA_CHANGED        0x09
#endif

#ifdef MSI_SUPPORTED
#ifndef PCIX_TABLE_POINTER
typedef struct {
  union {
    struct {
      ULONG BaseIndexRegister :3;
      ULONG Reserved          :29;
    };
    ULONG TableOffset;
  };
} PCIX_TABLE_POINTER, *PPCIX_TABLE_POINTER;
#endif

#ifndef PCI_MSIX_CAPABILITY
typedef struct {
  PCI_CAPABILITIES_HEADER Header;
  struct {
    USHORT TableSize      :11;
    USHORT Reserved       :3;
    USHORT FunctionMask   :1;
    USHORT MSIXEnable     :1;
  } MessageControl;
  PCIX_TABLE_POINTER      MessageTable;
  PCIX_TABLE_POINTER      PBATable;
} PCI_MSIX_CAPABILITY, *PPCI_MSIX_CAPABILITY;
#endif
#endif

#endif ___VIOSTOR__H__


text:
<?php

require __DIR__.'/lib/UserApp/Autoloader.php';

UserApp\Autoloader::register();


text:
require 'ting_yun/support/exception'
require 'ting_yun/support/hostname'
require 'ting_yun/configuration/server_source'
require 'ting_yun/agent/instance_methods/handle_errors'
require 'ting_yun/environment_report'

module TingYun
  module Agent
    module InstanceMethods
      module Connect

        include HandleErrors

        # Disconnect just sets connected to false, which prevents
        # the agent from trying to connect again
        # @connect_state has three state {:disconnected,:pending,:connected}

        def disconnect
          @connect_state = :disconnected
          true
        end

        def connected?
          @connect_state == :connected
        end

        def disconnected?
          @connect_state == :disconnected
        end

        # Don't connect if we're already connected, or if we tried to connect
        # and were rejected with prejudice because of a license issue, unless
        # we're forced to by force_reconnect.
        def should_connect?(force=false)
          force || (!connected? && !disconnected?)
        end

        def generate_environment_report
          @environment_report = environment_for_connect
        end

        # We've seen objects in the environment report (Rails.env in
        # particular) that can't seralize to JSON. Cope with that here and
        # clear out so downstream code doesn't have to check again.
        def sanitize_environment_report
          if !@service.valid_to_marshal?(@environment_report)
            @environment_report = {}
          end
        end

        # Checks whether we should send environment info, and if so,
        # returns the snapshot from the local environment.
        # Generating the EnvironmentReport has the potential to trigger
        # require calls in Rails environments, so this method should only
        # be called synchronously from on the main thread.
        def environment_for_connect
          ::TingYun::Agent.config[:send_environment_info] ? TingYun::EnvironmentReport.new.data : {}
        end

        # Initializes the hash of settings that we send to the
        # server. Returns a literal hash containing the options
        def connect_settings
          sanitize_environment_report
          settings = {
              :pid => $$,
              :port => ::TingYun::Agent.config[:port],
              :host => local_host,
              :appName => ::TingYun::Agent.config.app_names,
              :language => 'Ruby',
              :agentVersion => ::TingYun::VERSION::STRING,
              :env => @environment_report,
              :config => ::TingYun::Agent.config.to_collector_hash
          }
          settings
        end

        def local_host
          TingYun::Support::Hostname.get
        end

        # Returns connect data passed back from the server
        def connect_to_server
          @service.connect(connect_settings)
        end

        #merge server config
        def query_server_for_configuration
          finish_setup(connect_to_server)
        end

        # * <tt>:keep_retrying => false</tt> to only try to connect once, and
        #   return with the connection set to nil.  This ensures we may try again
        #   later (default true).
        # * <tt>force_reconnect => true</tt> if you want to establish a new connection
        #   to the server before running the worker loop.  This means you get a separate
        #   agent run and Ting Yun sees it as a separate instance (default is false).
        def catch_errors
          yield
        rescue  TingYun::Support::Exception::UnKnownServerException => e
          handle_force_restart(e)
          retry
        rescue TingYun::Support::Exception::ServerConnectionException => e
          handle_delay_restart(e, 60)
          retry
        rescue => e
          handle_delay_restart(e, 60)
          retry
        end

        # Takes a hash of configuration data returned from the
        # server and uses it to set local variables and to
        # initialize various parts of the agent that are configured
        # separately.
        #
        def finish_setup(config_data)
          return if config_data == nil

          if config_data['config']
            ::TingYun::Agent.logger.debug "Using config from server"
          end
          ::TingYun::Agent.logger.debug "Server provided config: #{config_data.inspect}"
          server_config = TingYun::Configuration::ServerSource.new(config_data)
          ::TingYun::Agent.config.replace_or_add_config(server_config)
          #log_connection!(config_data)
        end

        def log_connection!(config_data)
          ::TingYun::Agent.logger.debug "Connected to TingYun Service at #{@service.collector.name}"
          ::TingYun::Agent.logger.debug "Application Run       = #{@service.applicationId}."
          ::TingYun::Agent.logger.debug "Connection data = #{config_data.inspect}"
          if config_data['messages'] && config_data['messages'].any?
            log_collector_messages(config_data['messages'])
          end
        end

        def log_collector_messages(messages)
          messages.each do |message|
            ::TingYun::Agent.logger.send(message['level'].downcase, message['message'])
          end
        end

        def connect_in_sync
          TingYun::Agent.disable_all_tracing { connect!(:keep_retrying => false) }
        end
      end
    end
  end
end


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>KartenManager</title>
<meta name="date" content="2015-01-10">
<link rel="stylesheet" type="text/css" href="../../../../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method

com.haw.projecthorse.level.game.memoryspiel

Class KartenManager

java.lang.Object

com.haw.projecthorse.level.game.memoryspiel.KartenManager

public class KartenManager
extends java.lang.Object

Karten erzeugen, konfigurieren und deren Zustände aktualisieren.

Version:

1.0

Author:

Ngoc Huyen Nguyen

Field Summary

Fields

Modifier and Type
Field and Description

boolean
canOpen

Constructor Summary

Constructors

Constructor and Description

KartenManager()

Konstruktor.

Method Summary

Methods

Modifier and Type
Method and Description

void
checkChanged(float delta)

Zustände von Karten aktualisieren.

java.util.ArrayList<Karte>
getKarten()

Karten Getter.

int
getScore()

Score Getter.

void
restart()

Reihenfolge von Karten shuffeln.

void
setScore(int score)

Score Setter.

void
setUpKarten()

Hier werden die Karten mit Koordinaten erzeugt und Bilder zugewiesen.

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

canOpen

public boolean canOpen

Constructor Detail

KartenManager

public KartenManager()

Konstruktor.

Method Detail

setUpKarten

public void setUpKarten()

Hier werden die Karten mit Koordinaten erzeugt und Bilder zugewiesen.

getKarten

public java.util.ArrayList<Karte> getKarten()

Karten Getter.

Returns:

alle Karten

checkChanged

public void checkChanged(float delta)

Zustände von Karten aktualisieren.

Parameters:

delta - Delta von Methode doRender beim MemorySpiel

restart

public void restart()

Reihenfolge von Karten shuffeln. Karten bekommen neue Bilder und werden
 wieder zugedeckt.

getScore

public int getScore()

Score Getter.

Returns:

Score

setScore

public void setScore(int score)

Score Setter.

Parameters:

score - zu setzende Score

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Prev Class

Next Class

Frames

No Frames

All Classes

Summary:

Nested |

Field |

Constr |

Method

Detail:

Field |

Constr |

Method


text:
'use strict';

const path = require('path');
const sinon = require('sinon');
const editor = require('..');
const memFs = require('mem-fs');

describe('#extendJSON()', () => {
  let store;
  let fs;

  beforeEach(() => {
    store = memFs.create();
    fs = editor.create(store);
  });

  it('extends content of existing JSON file', () => {
    const filepath = path.join(__dirname, 'fixtures/does-not-exist.txt');
    const contents = { b: 2 };
    const write = sinon.spy(fs, 'write');
    const read = sinon.stub(fs, 'readJSON').returns({ a: 'a', b: 'b' });
    fs.extendJSON(filepath, contents);
    sinon.assert.calledOnce(write);
    sinon.assert.calledWithMatch(
      write,
      filepath,
      JSON.stringify({ a: 'a', b: 2 }, null, 2) + '\n'
    );
    write.restore();
    read.restore();
  });

  it('writes to unexisting JSON file', () => {
    const filepath = path.join(__dirname, 'fixtures/does-not-exist.txt');
    const contents = { foo: 'bar' };
    const write = sinon.spy(fs, 'write');
    fs.extendJSON(filepath, contents);
    sinon.assert.calledOnce(write);
    sinon.assert.calledWithMatch(
      write,
      filepath,
      JSON.stringify({ foo: 'bar' }, null, 2) + '\n'
    );
    write.restore();
  });

  it('stringify with optional arguments (for JSON.stringify)', () => {
    const filepath = path.join(__dirname, 'fixtures/does-not-exist.txt');
    const contents = { foo: 'bar' };
    const write = sinon.spy(fs, 'write');
    fs.extendJSON(filepath, contents, '\n', 4);
    sinon.assert.calledOnce(write);
    sinon.assert.calledWith(write, filepath, JSON.stringify(contents, '\n', 4) + '\n');
    write.restore();
  });
});


text:
class Item < ActiveRecord::Base
	has_many :orders
	belongs_to :restaurant
	belongs_to :category
end


text:
"""
Implements the common base class for all RAVEN objects (Entities and Interfaces)
Assures access to:
- InputData initialization
- MessageHandler
and similar utilities

Created on Mar 16, 2013
@author: crisr
"""

from .MessageUser import MessageUser
from .InputDataUser import InputDataUser

class BaseType(MessageUser, InputDataUser): # TODO add InputDataUser when all entities are converted
  """
    Implement the common base class for all RAVEN objects (Entities and Interfaces)
  """
  def __init__(self, **kwargs):
    """
      Construct.
      @ In, None
      @ Out, None
    """
    super().__init__(**kwargs)
    # identification
    self.name = None                     # name of this istance (alias)
    self.printTag = None                 # the tag that refers to this class in all the specific printing
    self.type = self.__class__.__name__  # specific type within this class

  def applyRunInfo(self, runInfo):
    """
      Allows access to the RunInfo data
      @ In, runInfo, dict, info from RunInfo
      @ Out, None
    """
    pass


text:
namespace sw
{
	class Resource;
}

namespace egl
{
class [[clang::lto_visibility_public]] Texture : public gl::NamedObject
{
public:
	Texture(GLuint name) : NamedObject(name) {}

	virtual void releaseTexImage() = 0;
	virtual sw::Resource *getResource() const = 0;

	virtual void sweep() = 0;   // Garbage collect if no external references

	void release() override
	{
		int refs = dereference();

		if(refs > 0)
		{
			sweep();
		}
		else
		{
			delete this;
		}
	}
};
}

#endif   // egl_Texture_hpp


text:
UUpsightReward::UUpsightReward(const FObjectInitializer& ObjectInitializer)
    : Super(ObjectInitializer)
{
}


text:
* a PHP library for PHP developers
* a tool for retrieve real estate-related information from private systems
* only useful for communicating with RETS compliant servers
* easy to install using the [Composer package](https://packagist.org/packages/troydavisson/phrets)
* used by hundreds of software developers
* actively maintained
* well tested through both automated unit and integration tests and real world usage

# PHRETS Isn't...

* a "set it and forget it" installable application (but it could help power one)
* a pre-built website that allows visitors to search available real estate listings (but it could be used to retrieve data to populate one)

# History

The first version of this library was created and released in 2006 in order to help simplify the tedious process of making direct HTTP requests to a RETS server and manually parsing the XML responses.

Since 2006, it has been actively maintained and supported.  In 2015, a major re-write was released as version 2 to better modernize the library using best practices such as [Composer](https://packagist.org/packages/troydavisson/phrets), PHP namespaces, automated tests and [Guzzle](http://guzzle.readthedocs.org/) to make continued use and improvements easier to implement and release.

# RETS?

RETS stands for the **Real Estate Transaction Standard**.  This standard was created in the late 1990s to help facilitate the communication of real estate listing information between different systems.  Today, RETS is primarily used by third party companies to retrieve real estate listings from a local Multiple Listing Service (MLS) database in order to advertise available homes for sale (such as Realtor.com).

# New to real estate data?

If you're a developer jumping into your first project dealing with data from the real estate industry, it's important to know about the restrictions and policies associated with some of this information.  These policies often differ from market to market.

* an MLS system is the local database used by real estate agents to advertise homes to each other.  There are many hundreds of these in the United States alone, and it's not unusual to have multiple systems covering a single large city.
* the MLS system contains listings currently on the market, listings sold (or otherwise no longer available) and anything in between.
* there are often policies which exist that allow agents and authorized third parties to retrieve information about available listings to display to the public.
* there is often information entered into the MLS which is considered private.  For example, the MLS may have the name and phone number for the owner of the property for sale, so even though other information about the listing may be made public, certain details will likely be restricted.

# Why RETS?

Why not FTP?  Why not direct database (SQL) access?

The RETS standard provides a number of different capabilities that would be hard (if not, impossible) to implement using any one existing technology (especially at the time it was created).  Some of those are:

1. the ability to issue custom, "live" queries against the system to return back only the desired information.  This includes both records ("only give me listings in this price range") and fields ("only give me the price and address").
2. the ability to retrieve various media formats.  Through a RETS server, you can often directly download the JPG files associated with particular records.  Some servers go even further by providing other media types such as PDFs, PNGs, virtual tours and HTML code (for embedding YouTube, etc.).
3. the ability to provide updates back to the RETS server.  Although not widely used (yet), the RETS standard defines ways that writes to records can be requested.  Extra metadata provided by RETS servers allows client software to be more familiar with some of the business rules and validation requirements of the MLS.


text:
layout: blog
title: index
permalink: /
---

                <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar">
                    Toggle navigation

                </button>
                {{ site.title }}

{{ site.landing.home }}

{{ site.landing.about }}

{{ site.landing.career }}

{{ site.landing.skills }}

{{ site.landing.projects }}

{{ site.landing.blog }}

{{ site.landing.link }}

        Previous

        Next

About Me

{{ site.author.last_name }} {{ site.author.first_name }}

                    I am a Jr.Cloud automation engineer, Currently working on chef and writing scripts experience. Life is a continuous learning process, so work makes me more rigorous.

My Career

Nextcode

Now I am in Nextcode and develop website with Python code for genetic analysis.

                             Apr. 2016

 Python Developer

Netease Game

In Netease game, I learned game service system and use Python code for ops.

                             Jun. 2015

 Dev Ops

Ucloud

In ucloud, I started to deal with servers and Linux system and use shell scripts to manage massive server.

                             Sep. 2013

 Dev Ops

Graduation

At July 2013,I graduated from college and started my IT technology tour.

                             Jul. 2013

 Student

My Skills

Python

HTML/CSS

Linux/Shell

jQuery

AngularJS

Ionic

My Projects

{{ site.project.saplatform.name }}

Saplatform is a automated service for operations, it has asset management, project release, database access function, it can control mass servers.

                            Star

                            Fork

{{ site.project.jalpc.name }}

Jalpc is a simple, beautiful and swift theme for Jekyll. It's pretty minimal, but leverages large type and drastic contrast to make a statement, on all devices.

                            Star

                            Fork

{{ site.project.angularjs.name }}

Jalpc is a simple, beautiful and swift theme for Jekyll. It has comprehensive function, it can be easily used and edited. It's adapted for many kinds devices.

                            Star

                            Fork

{{ site.project.Rsser.name }}

Rsser is an Ionic application, with this application we can read news and articles freely, you can add rss address from the given list and add it manually.

                            Star

                            Fork

                My Blog

Link

{{ site.jingyu.last_name }} {{ site.jingyu.first_name }}

                        {{ site.jingyu.description }}

© {{ 'now' | date: "%Y" }} {{ site.title }}


text:
package br.copacabana.spring.central;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import br.com.copacabana.cb.entities.Central;
import br.com.copacabana.cb.entities.Payment;
import br.com.copacabana.cb.entities.Payment.PaymentType;

public class ConsolidatedBillBean {
	private Central central;
	private Date start;
	private Date end;
	private List<RestaurantOrdersBean> ordersByRestaurant = new ArrayList<RestaurantOrdersBean>();

	public ConsolidatedBillBean(Central central, Date start, Date end) {
		super();
		this.central = central;
		this.start = start;
		this.end = end;
	}

	public Central getCentral() {
		return central;
	}

	public void setCentral(Central central) {
		this.central = central;
	}

	public Date getStart() {
		return start;
	}

	public void setStart(Date start) {
		this.start = start;
	}

	public Date getEnd() {
		return end;
	}

	public void setEnd(Date end) {
		this.end = end;
	}

	Integer totals = 0;

	private Map<PaymentType, Integer[]> byPayment = new HashMap<Payment.PaymentType, Integer[]>();

	public void addRestaurantOrders(RestaurantOrdersBean r) {
		totals += r.getTotals();
		byPayment.putAll(r.getByPayment());
		this.ordersByRestaurant.add(r);
	}

	public List<RestaurantOrdersBean> getOrdersByRestaurant() {
		return ordersByRestaurant;
	}

	public void setOrdersByRestaurant(List<RestaurantOrdersBean> ordersByRestaurant) {
		this.ordersByRestaurant = ordersByRestaurant;
	}

	public Integer getTotals() {
		return totals;
	}

	public void setTotals(Integer totals) {
		this.totals = totals;
	}

	public Map<PaymentType, Integer[]> getByPayment() {
		return byPayment;
	}

	public void setByPayment(Map<PaymentType, Integer[]> byPayment) {
		this.byPayment = byPayment;
	}
}


text:
import ChoiceChallenge from './choice-challenge';

/**
 * Controller class for the {@link ChoiceChallenge} model.
 * @private
 */
export default class ChoiceChallengeController {
  /**
   * @param {Connection} connection - Object to use for making a connection to the REST API and Websocket server.
   */
  constructor(connection) {
    /**
     * Object to use for making a connection to the REST API and Websocket server.
     * @type {Connection}
     */
    this._connection = connection;
  }

  /**
   * Create a choice challenge. The choice challenge will be created in the current active {@link Organisation} derived
   * from the OAuth2 scope.
   * It is necessary for a choice challenge to exist for a recording to be valid.
   *
   * @param {ChoiceChallenge} choiceChallenge - Object to create.
   * @returns {Promise.<ChoiceChallenge>} Containing the newly created ChoiceChallenge.
   * @throws {Promise.<Error>} choiceChallenge parameter of type "ChoiceChallenge" is required.
   * @throws {Promise.<Error>} If the server returned an error.
   */
  createChoiceChallenge(choiceChallenge) {
    if (!(choiceChallenge instanceof ChoiceChallenge)) {
      return Promise.reject(new Error('choiceChallenge parameter of type "ChoiceChallenge" is required'));
    }
    const url = this._connection._settings.apiUrl + '/challenges/choice';
    const fd = JSON.stringify(choiceChallenge);
    return this._connection._secureAjaxPost(url, fd)
      .then(data => {
        const result = new ChoiceChallenge(data.id, data.question, data.choices);
        result.created = new Date(data.created);
        result.updated = new Date(data.updated);
        result.status = data.status;
        result.choices = data.choices.map(pair => pair.choice);
        return result;
      });
  }

  /**
   * Get a choice challenge. A choice challenge is identified by its identifier and the current active
   * {@link Organisation} derived from the OAuth2 scope.
   *
   * @param {string} challengeId - Specify a choice challenge identifier.
   * @returns {Promise.<ChoiceChallenge>} Containing a ChoiceChallenge.
   * @throws {Promise.<Error>} challengeId parameter of type "string" is required.
   * @throws {Promise.<Error>} If no result could not be found.
   */
  getChoiceChallenge(challengeId) {
    if (typeof challengeId !== 'string') {
      return Promise.reject(new Error('challengeId parameter of type "string" is required'));
    }
    const url = this._connection._settings.apiUrl + '/challenges/choice/' + challengeId;
    return this._connection._secureAjaxGet(url)
      .then(data => {
        const challenge = new ChoiceChallenge(data.id, data.question, data.choices);
        challenge.created = new Date(data.created);
        challenge.updated = new Date(data.updated);
        challenge.status = data.status;
        challenge.choices = data.choices.map(pair => pair.choice);
        return challenge;
      });
  }

  /**
   * Get and return all choice challenges in the current active {@link Organisation} derived from the OAuth2 scope.
   *
   * @returns {Promise.<ChoiceChallenge[]>} Containing an array of ChoiceChallenges.
   * @throws {Promise.<Error>} If no result could not be found.
   */
  getChoiceChallenges() {
    const url = this._connection._settings.apiUrl + '/challenges/choice';
    return this._connection._secureAjaxGet(url)
      .then(data => data.map(datum => {
        const challenge = new ChoiceChallenge(datum.id, datum.question, datum.choices);
        challenge.created = new Date(datum.created);
        challenge.updated = new Date(datum.updated);
        challenge.status = datum.status;
        challenge.choices = datum.choices.map(pair => pair.choice);
        return challenge;
      }));
  }
}


text:
require 'active_record/scoping/default'
require 'active_record/scoping/named'
require 'active_record/base'

module ActiveRecord
  class SchemaMigration < ActiveRecord::Base
    class << self

      def table_name
        "#{table_name_prefix}#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
      end

      def index_name
        "#{table_name_prefix}unique_#{ActiveRecord::Base.schema_migrations_table_name}#{table_name_suffix}"
      end

      def table_exists?
        connection.table_exists?(table_name)
      end

      def create_table(limit=nil)
        unless table_exists?
          version_options = {null: false}
          version_options[:limit] = limit if limit

          connection.create_table(table_name, id: false) do |t|
            t.column :version, :string, version_options
          end
          connection.add_index table_name, :version, unique: true, name: index_name
        end
      end

      def drop_table
        if table_exists?
          connection.remove_index table_name, name: index_name
          connection.drop_table(table_name)
        end
      end
    end

    def version
      super.to_i
    end
  end
end


text:
<?php

namespace Mailgun;

use Mailgun\Exception\InvalidArgumentException;

/**
 * We need to override Webmozart\Assert because we want to throw our own Exception.
 *
 * @author Tobias Nyholm <tobias.nyholm@gmail.com>
 */
final class Assert extends \Webmozart\Assert\Assert
{
    protected static function reportInvalidArgument($message)
    {
        throw new InvalidArgumentException($message);
    }
}


text:
package test.factory;

import org.testng.annotations.Factory;

import java.util.ArrayList;
import java.util.List;

public class OrderFactory {

   @Factory
   public static Object[] testF()
   throws Exception {
       List<OrderSample> result = new ArrayList<>();
       for (int i = 0; i < 5; i++) {
           result.add(new OrderSample(i));
       }
       return result.toArray();
   }
}


text:
/**
 */
package MessagesModel;

/**
 *
 * A representation of the model object 'Team Scored Message'.
 *
 *
 *

 * The following features are supported:
 *

 *

 *
{@link MessagesModel.TeamScoredMessage#getTeam Team}

 *
{@link MessagesModel.TeamScoredMessage#getScore Score}

 *
{@link MessagesModel.TeamScoredMessage#getPlayers Players}

 *

 *
 * @see MessagesModel.ModelPackage#getTeamScoredMessage()
 * @model
 * @generated
 */
public interface TeamScoredMessage extends Message {
	/**
	 * Returns the value of the 'Team' attribute.
	 *
	 *

	 * If the meaning of the 'Team' attribute isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @return the value of the 'Team' attribute.
	 * @see #setTeam(String)
	 * @see MessagesModel.ModelPackage#getTeamScoredMessage_Team()
	 * @model
	 * @generated
	 */
	String getTeam();

	/**
	 * Sets the value of the '{@link MessagesModel.TeamScoredMessage#getTeam Team}' attribute.
	 *
	 *
	 * @param value the new value of the 'Team' attribute.
	 * @see #getTeam()
	 * @generated
	 */
	void setTeam(String value);

	/**
	 * Returns the value of the 'Score' attribute.
	 *
	 *

	 * If the meaning of the 'Score' attribute isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @return the value of the 'Score' attribute.
	 * @see #setScore(String)
	 * @see MessagesModel.ModelPackage#getTeamScoredMessage_Score()
	 * @model
	 * @generated
	 */
	String getScore();

	/**
	 * Sets the value of the '{@link MessagesModel.TeamScoredMessage#getScore Score}' attribute.
	 *
	 *
	 * @param value the new value of the 'Score' attribute.
	 * @see #getScore()
	 * @generated
	 */
	void setScore(String value);

	/**
	 * Returns the value of the 'Players' attribute.
	 *
	 *

	 * If the meaning of the 'Players' attribute isn't clear,
	 * there really should be more of a description here...
	 *

	 *
	 * @return the value of the 'Players' attribute.
	 * @see #setPlayers(String)
	 * @see MessagesModel.ModelPackage#getTeamScoredMessage_Players()
	 * @model
	 * @generated
	 */
	String getPlayers();

	/**
	 * Sets the value of the '{@link MessagesModel.TeamScoredMessage#getPlayers Players}' attribute.
	 *
	 *
	 * @param value the new value of the 'Players' attribute.
	 * @see #getPlayers()
	 * @generated
	 */
	void setPlayers(String value);

} // TeamScoredMessage


text:
/*
 * exceptions-ppc.c: exception support for PowerPC
 *
 * Authors:
 *   Dietmar Maurer (dietmar@ximian.com)
 *   Paolo Molaro (lupus@ximian.com)
 *   Andreas Faerber <andreas.faerber@web.de>
 *
 * (C) 2001 Ximian, Inc.
 * (C) 2007-2008 Andreas Faerber
 */

#include <config.h>
#include <glib.h>
#include <signal.h>
#include <string.h>
#include <stddef.h>
#if HAVE_UCONTEXT_H
#include <ucontext.h>
#endif

#include <mono/arch/ppc/ppc-codegen.h>
#include <mono/metadata/appdomain.h>
#include <mono/metadata/tabledefs.h>
#include <mono/metadata/threads.h>
#include <mono/metadata/debug-helpers.h>
#include <mono/metadata/exception.h>
#include <mono/metadata/mono-debug.h>

#include "mini.h"
#include "mini-ppc.h"

/*

struct sigcontext {
    int      sc_onstack;     // sigstack state to restore
    int      sc_mask;        // signal mask to restore
    int      sc_ir;          // pc
    int      sc_psw;         // processor status word
    int      sc_sp;          // stack pointer if sc_regs == NULL
    void    *sc_regs;        // (kernel private) saved state
};

struct ucontext {
        int             uc_onstack;
        sigset_t        uc_sigmask;     // signal mask used by this context
        stack_t         uc_stack;       // stack used by this context
        struct ucontext *uc_link;       // pointer to resuming context
        size_t          uc_mcsize;      // size of the machine context passed in
        mcontext_t      uc_mcontext;    // machine specific context
};

typedef struct ppc_exception_state {
        unsigned long dar;      // Fault registers for coredump
        unsigned long dsisr;
        unsigned long exception;// number of powerpc exception taken
        unsigned long pad0;     // align to 16 bytes

        unsigned long pad1[4];  // space in PCB "just in case"
} ppc_exception_state_t;

typedef struct ppc_vector_state {
        unsigned long   save_vr[32][4];
        unsigned long   save_vscr[4];
        unsigned int    save_pad5[4];
        unsigned int    save_vrvalid;                   // VRs that have been saved
        unsigned int    save_pad6[7];
} ppc_vector_state_t;

typedef struct ppc_float_state {
        double  fpregs[32];

        unsigned int fpscr_pad; // fpscr is 64 bits, 32 bits of rubbish
        unsigned int fpscr;     // floating point status register
} ppc_float_state_t;

typedef struct ppc_thread_state {
        unsigned int srr0;      // Instruction address register (PC)
        unsigned int srr1;      // Machine state register (supervisor)
        unsigned int r0;
        unsigned int r1;
        unsigned int r2;
	...
        unsigned int r31;
        unsigned int cr;        // Condition register
        unsigned int xer;       // User's integer exception register
        unsigned int lr;        // Link register
        unsigned int ctr;       // Count register
        unsigned int mq;        // MQ register (601 only)

        unsigned int vrsave;    // Vector Save Register
} ppc_thread_state_t;

struct mcontext {
        ppc_exception_state_t   es;
        ppc_thread_state_t      ss;
        ppc_float_state_t       fs;
        ppc_vector_state_t      vs;
};

typedef struct mcontext  * mcontext_t;

Linux/PPC instead has:
struct sigcontext {
        unsigned long   _unused[4];
        int             signal;
        unsigned long   handler;
        unsigned long   oldmask;
        struct pt_regs  *regs;
};
struct pt_regs {
        unsigned long gpr[32];
        unsigned long nip;
        unsigned long msr;
        unsigned long orig_gpr3;        // Used for restarting system calls
        unsigned long ctr;
        unsigned long link;
        unsigned long xer;
        unsigned long ccr;
        unsigned long mq;               // 601 only (not used at present)
                                        // Used on APUS to hold IPL value.
        unsigned long trap;             // Reason for being here
        // N.B. for critical exceptions on 4xx, the dar and dsisr
        // fields are overloaded to hold srr0 and srr1.
        unsigned long dar;              // Fault registers
        unsigned long dsisr;            // on 4xx/Book-E used for ESR
        unsigned long result;           // Result of a system call
};
struct mcontext {
        elf_gregset_t   mc_gregs;
        elf_fpregset_t  mc_fregs;
        unsigned long   mc_pad[2];
        elf_vrregset_t  mc_vregs __attribute__((__aligned__(16)));
};

struct ucontext {
        unsigned long    uc_flags;
        struct ucontext *uc_link;
        stack_t          uc_stack;
        int              uc_pad[7];
        struct mcontext *uc_regs;       // points to uc_mcontext field
        sigset_t         uc_sigmask;
        // glibc has 1024-bit signal masks, ours are 64-bit
        int              uc_maskext[30];
        int              uc_pad2[3];
        struct mcontext  uc_mcontext;
};

#define ELF_NGREG       48      // includes nip, msr, lr, etc.
#define ELF_NFPREG      33      // includes fpscr

// General registers
typedef unsigned long elf_greg_t;
typedef elf_greg_t elf_gregset_t[ELF_NGREG];

// Floating point registers
typedef double elf_fpreg_t;
typedef elf_fpreg_t elf_fpregset_t[ELF_NFPREG];

*/

#define restore_regs_from_context(ctx_reg,ip_reg,tmp_reg) do {	\
		int reg;	\
		ppc_ldptr (code, ip_reg, G_STRUCT_OFFSET (MonoContext, sc_ir), ctx_reg);	\
		ppc_load_multiple_regs (code, ppc_r13, G_STRUCT_OFFSET (MonoContext, regs), ctx_reg);	\
		for (reg = 0; reg < MONO_SAVED_FREGS; ++reg) {	\
			ppc_lfd (code, (14 + reg),	\
				G_STRUCT_OFFSET(MonoContext, fregs) + reg * sizeof (gdouble), ctx_reg);	\
		}	\
	} while (0)

/* nothing to do */
#define setup_context(ctx)

#ifdef PPC_USES_FUNCTION_DESCRIPTOR
guint8*
mono_ppc_create_pre_code_ftnptr (guint8 *code)
{
	MonoPPCFunctionDescriptor *ftnptr = (MonoPPCFunctionDescriptor*)code;

	code += sizeof (MonoPPCFunctionDescriptor);
	ftnptr->code = code;
	ftnptr->toc = NULL;
	ftnptr->env = NULL;

	return code;
}
#endif

/*
 * arch_get_restore_context:
 *
 * Returns a pointer to a method which restores a previously saved sigcontext.
 * The first argument in r3 is the pointer to the context.
 */
gpointer
mono_arch_get_restore_context (MonoTrampInfo **info, gboolean aot)
{
	guint8 *start, *code;
	int size = MONO_PPC_32_64_CASE (128, 172) + PPC_FTNPTR_SIZE;
	MonoJumpInfo *ji = NULL;
	GSList *unwind_ops = NULL;

	code = start = mono_global_codeman_reserve (size);
	if (!aot)
		code = mono_ppc_create_pre_code_ftnptr (code);
	restore_regs_from_context (ppc_r3, ppc_r4, ppc_r5);
	/* restore also the stack pointer */
	ppc_ldptr (code, ppc_sp, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
	//ppc_break (code);
	/* jump to the saved IP */
	ppc_mtctr (code, ppc_r4);
	ppc_bcctr (code, PPC_BR_ALWAYS, 0);
	/* never reached */
	ppc_break (code);

	g_assert ((code - start) <= size);
	mono_arch_flush_icache (start, code - start);

	if (info)
		*info = mono_tramp_info_create ("restore_context", start, code - start, ji, unwind_ops);

	return start;
}

#define SAVED_REGS_LENGTH		(sizeof (gdouble) * MONO_SAVED_FREGS + sizeof (gpointer) * MONO_SAVED_GREGS)
#define ALIGN_STACK_FRAME_SIZE(s)	(((s) + MONO_ARCH_FRAME_ALIGNMENT - 1) & ~(MONO_ARCH_FRAME_ALIGNMENT - 1))
/* The 64 bytes here are for outgoing arguments and a bit of spare.
   We don't use it all, but it doesn't hurt. */
#define REG_SAVE_STACK_FRAME_SIZE	(ALIGN_STACK_FRAME_SIZE (SAVED_REGS_LENGTH + PPC_MINIMAL_STACK_SIZE + 64))

static guint8*
emit_save_saved_regs (guint8 *code, int pos)
{
	int i;

	for (i = 31; i >= 14; --i) {
		pos -= sizeof (gdouble);
		ppc_stfd (code, i, pos, ppc_sp);
	}
	pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
	ppc_store_multiple_regs (code, ppc_r13, pos, ppc_sp);

	return code;
}

/*
 * mono_arch_get_call_filter:
 *
 * Returns a pointer to a method which calls an exception filter. We
 * also use this function to call finally handlers (we pass NULL as
 * @exc object in this case).
 */
gpointer
mono_arch_get_call_filter (MonoTrampInfo **info, gboolean aot)
{
	guint8 *start, *code;
	int alloc_size, pos, i;
	int size = MONO_PPC_32_64_CASE (320, 500) + PPC_FTNPTR_SIZE;
	MonoJumpInfo *ji = NULL;
	GSList *unwind_ops = NULL;

	/* call_filter (MonoContext *ctx, unsigned long eip, gpointer exc) */
	code = start = mono_global_codeman_reserve (size);
	if (!aot)
		code = mono_ppc_create_pre_code_ftnptr (code);

	/* store ret addr */
	ppc_mflr (code, ppc_r0);
	ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);

	alloc_size = REG_SAVE_STACK_FRAME_SIZE;

	/* allocate stack frame and set link from sp in ctx */
	g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
	ppc_ldptr (code, ppc_r0, G_STRUCT_OFFSET (MonoContext, sc_sp), ppc_r3);
	ppc_ldptr_indexed (code, ppc_r0, ppc_r0, ppc_r0);
	ppc_stptr_update (code, ppc_r0, -alloc_size, ppc_sp);

	code = emit_save_saved_regs (code, alloc_size);

	/* restore all the regs from ctx (in r3), but not r1, the stack pointer */
	restore_regs_from_context (ppc_r3, ppc_r6, ppc_r7);
	/* call handler at eip (r4) and set the first arg with the exception (r5) */
	ppc_mtctr (code, ppc_r4);
	ppc_mr (code, ppc_r3, ppc_r5);
	ppc_bcctrl (code, PPC_BR_ALWAYS, 0);

	/* epilog */
	ppc_ldptr (code, ppc_r0, alloc_size + PPC_RET_ADDR_OFFSET, ppc_sp);
	ppc_mtlr (code, ppc_r0);

	/* restore all the regs from the stack */
	pos = alloc_size;
	for (i = 31; i >= 14; --i) {
		pos -= sizeof (gdouble);
		ppc_lfd (code, i, pos, ppc_sp);
	}
	pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
	ppc_load_multiple_regs (code, ppc_r13, pos, ppc_sp);

	ppc_addic (code, ppc_sp, ppc_sp, alloc_size);
	ppc_blr (code);

	g_assert ((code - start) < size);
	mono_arch_flush_icache (start, code - start);

	if (info)
		*info = mono_tramp_info_create ("call_filter", start, code - start, ji, unwind_ops);

	return start;
}

void
mono_ppc_throw_exception (MonoObject *exc, unsigned long eip, unsigned long esp, mgreg_t *int_regs, gdouble *fp_regs, gboolean rethrow)
{
	MonoContext ctx;

	/* adjust eip so that it point into the call instruction */
	eip -= 4;

	setup_context (&ctx);

	/*printf ("stack in throw: %p\n", esp);*/
	MONO_CONTEXT_SET_BP (&ctx, esp);
	MONO_CONTEXT_SET_IP (&ctx, eip);
	memcpy (&ctx.regs, int_regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
	memcpy (&ctx.fregs, fp_regs, sizeof (double) * MONO_SAVED_FREGS);

	if (mono_object_isinst (exc, mono_defaults.exception_class)) {
		MonoException *mono_ex = (MonoException*)exc;
		if (!rethrow)
			mono_ex->stack_trace = NULL;
	}
	mono_handle_exception (&ctx, exc);
	mono_restore_context (&ctx);

	g_assert_not_reached ();
}

/**
 * arch_get_throw_exception_generic:
 *
 * Returns a function pointer which can be used to raise
 * exceptions. The returned function has the following
 * signature: void (*func) (MonoException *exc); or
 * void (*func) (guint32 ex_token, gpointer ip)
 *
 */
static gpointer
mono_arch_get_throw_exception_generic (int size, MonoTrampInfo **info, int corlib, gboolean rethrow, gboolean aot)
{
	guint8 *start, *code;
	int alloc_size, pos;
	MonoJumpInfo *ji = NULL;
	GSList *unwind_ops = NULL;

	code = start = mono_global_codeman_reserve (size);
	if (!aot)
		code = mono_ppc_create_pre_code_ftnptr (code);

	/* store ret addr */
	if (corlib)
		ppc_mr (code, ppc_r0, ppc_r4);
	else
		ppc_mflr (code, ppc_r0);
	ppc_stptr (code, ppc_r0, PPC_RET_ADDR_OFFSET, ppc_sp);

	alloc_size = REG_SAVE_STACK_FRAME_SIZE;

	g_assert ((alloc_size & (MONO_ARCH_FRAME_ALIGNMENT-1)) == 0);
	ppc_stptr_update (code, ppc_sp, -alloc_size, ppc_sp);

	code = emit_save_saved_regs (code, alloc_size);

	//ppc_break (code);
	if (corlib) {
		ppc_mr (code, ppc_r4, ppc_r3);

		if (aot) {
			code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_IMAGE, mono_defaults.corlib);
			ppc_mr (code, ppc_r3, ppc_r11);
			code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_exception_from_token");
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
			ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
			ppc_ldptr (code, ppc_r11, 0, ppc_r11);
#endif
			ppc_mtctr (code, ppc_r11);
			ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
		} else {
			ppc_load (code, ppc_r3, (gulong)mono_defaults.corlib);
			ppc_load_func (code, ppc_r0, mono_exception_from_token);
			ppc_mtctr (code, ppc_r0);
			ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
		}
	}

	/* call throw_exception (exc, ip, sp, int_regs, fp_regs) */
	/* caller sp */
	ppc_ldptr (code, ppc_r5, 0, ppc_sp);
	/* exc is already in place in r3 */
	if (corlib)
		ppc_ldptr (code, ppc_r4, PPC_RET_ADDR_OFFSET, ppc_r5);
	else
		ppc_mr (code, ppc_r4, ppc_r0); /* caller ip */
	/* pointer to the saved fp regs */
	pos = alloc_size - sizeof (gdouble) * MONO_SAVED_FREGS;
	ppc_addi (code, ppc_r7, ppc_sp, pos);
	/* pointer to the saved int regs */
	pos -= sizeof (gpointer) * MONO_SAVED_GREGS;
	ppc_addi (code, ppc_r6, ppc_sp, pos);
	ppc_li (code, ppc_r8, rethrow);

	if (aot) {
		// This can be called from runtime code, which can't guarantee that
		// r30 contains the got address.
		// So emit the got address loading code too
		code = mono_arch_emit_load_got_addr (start, code, NULL, &ji);
		code = mono_arch_emit_load_aotconst (start, code, &ji, MONO_PATCH_INFO_JIT_ICALL_ADDR, "mono_ppc_throw_exception");
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
		ppc_ldptr (code, ppc_r2, sizeof (gpointer), ppc_r11);
		ppc_ldptr (code, ppc_r11, 0, ppc_r11);
#endif
		ppc_mtctr (code, ppc_r11);
		ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
	} else {
		ppc_load_func (code, ppc_r0, mono_ppc_throw_exception);
		ppc_mtctr (code, ppc_r0);
		ppc_bcctrl (code, PPC_BR_ALWAYS, 0);
	}
	/* we should never reach this breakpoint */
	ppc_break (code);
	g_assert ((code - start) <= size);
	mono_arch_flush_icache (start, code - start);

	if (info)
		*info = mono_tramp_info_create (corlib ? "throw_corlib_exception" : (rethrow ? "rethrow_exception" : "throw_exception"), start, code - start, ji, unwind_ops);

	return start;
}

/**
 * mono_arch_get_rethrow_exception:
 *
 * Returns a function pointer which can be used to rethrow
 * exceptions. The returned function has the following
 * signature: void (*func) (MonoException *exc);
 *
 */
gpointer
mono_arch_get_rethrow_exception (MonoTrampInfo **info, gboolean aot)
{
	int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;

	if (aot)
		size += 64;
	return mono_arch_get_throw_exception_generic (size, info, FALSE, TRUE, aot);
}

/**
 * arch_get_throw_exception:
 *
 * Returns a function pointer which can be used to raise
 * exceptions. The returned function has the following
 * signature: void (*func) (MonoException *exc);
 * For example to raise an arithmetic exception you can use:
 *
 * x86_push_imm (code, mono_get_exception_arithmetic ());
 * x86_call_code (code, arch_get_throw_exception ());
 *
 */
gpointer
mono_arch_get_throw_exception (MonoTrampInfo **info, gboolean aot)
{
	int size = MONO_PPC_32_64_CASE (132, 224) + PPC_FTNPTR_SIZE;

	if (aot)
		size += 64;
	return mono_arch_get_throw_exception_generic (size, info, FALSE, FALSE, aot);
}

/**
 * mono_arch_get_throw_corlib_exception:
 *
 * Returns a function pointer which can be used to raise
 * corlib exceptions. The returned function has the following
 * signature: void (*func) (guint32 ex_token, guint32 offset);
 * On PPC, we pass the ip instead of the offset
 */
gpointer
mono_arch_get_throw_corlib_exception (MonoTrampInfo **info, gboolean aot)
{
	int size = MONO_PPC_32_64_CASE (168, 304) + PPC_FTNPTR_SIZE;

	if (aot)
		size += 64;
	return mono_arch_get_throw_exception_generic (size, info, TRUE, FALSE, aot);
}

/*
 * mono_arch_find_jit_info:
 *
 * See exceptions-amd64.c for docs.
 */
gboolean
mono_arch_find_jit_info (MonoDomain *domain, MonoJitTlsData *jit_tls,
							 MonoJitInfo *ji, MonoContext *ctx,
							 MonoContext *new_ctx, MonoLMF **lmf,
							 mgreg_t **save_locations,
							 StackFrameInfo *frame)
{
	gpointer ip = MONO_CONTEXT_GET_IP (ctx);
	MonoPPCStackFrame *sframe;

	memset (frame, 0, sizeof (StackFrameInfo));
	frame->ji = ji;

	*new_ctx = *ctx;
	setup_context (new_ctx);

	if (ji != NULL) {
		int i;
		mgreg_t regs [ppc_lr + 1];
		guint8 *cfa;
		guint32 unwind_info_len;
		guint8 *unwind_info;

		frame->type = FRAME_TYPE_MANAGED;

		unwind_info = mono_jinfo_get_unwind_info (ji, &unwind_info_len);

		sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
		MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
		if (jinfo_get_method (ji)->save_lmf) {
			/* sframe->sp points just past the end of the LMF */
			guint8 *lmf_addr = (guint8*)sframe->sp - sizeof (MonoLMF);
			memcpy (&new_ctx->fregs, lmf_addr + G_STRUCT_OFFSET (MonoLMF, fregs), sizeof (double) * MONO_SAVED_FREGS);
			memcpy (&new_ctx->regs, lmf_addr + G_STRUCT_OFFSET (MonoLMF, iregs), sizeof (mgreg_t) * MONO_SAVED_GREGS);
			/* the calling IP is in the parent frame */
			sframe = (MonoPPCStackFrame*)sframe->sp;
			/* we substract 4, so that the IP points into the call instruction */
			MONO_CONTEXT_SET_IP (new_ctx, sframe->lr - 4);
		} else {
			regs [ppc_lr] = ctx->sc_ir;
			regs [ppc_sp] = ctx->sc_sp;
			for (i = 0; i < MONO_SAVED_GREGS; ++i)
				regs [ppc_r13 + i] = ctx->regs [i];

			mono_unwind_frame (unwind_info, unwind_info_len, ji->code_start,
							   (guint8*)ji->code_start + ji->code_size,
							   ip, NULL, regs, ppc_lr + 1,
							   save_locations, MONO_MAX_IREGS, &cfa);

			/* we substract 4, so that the IP points into the call instruction */
			MONO_CONTEXT_SET_IP (new_ctx, regs [ppc_lr] - 4);
			MONO_CONTEXT_SET_BP (new_ctx, cfa);

			for (i = 0; i < MONO_SAVED_GREGS; ++i)
				new_ctx->regs [i] = regs [ppc_r13 + i];
		}

		return TRUE;
	} else if (*lmf) {

		if ((ji = mini_jit_info_table_find (domain, (gpointer)(*lmf)->eip, NULL))) {
		} else {
			if (!(*lmf)->method)
				return FALSE;

			/* Trampoline lmf frame */
			frame->method = (*lmf)->method;
		}

		/*sframe = (MonoPPCStackFrame*)MONO_CONTEXT_GET_SP (ctx);
		MONO_CONTEXT_SET_BP (new_ctx, sframe->sp);
		MONO_CONTEXT_SET_IP (new_ctx, sframe->lr);*/
		MONO_CONTEXT_SET_BP (new_ctx, (*lmf)->ebp);
		MONO_CONTEXT_SET_IP (new_ctx, (*lmf)->eip);
		memcpy (&new_ctx->regs, (*lmf)->iregs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
		memcpy (&new_ctx->fregs, (*lmf)->fregs, sizeof (double) * MONO_SAVED_FREGS);

		frame->ji = ji;
		frame->type = FRAME_TYPE_MANAGED_TO_NATIVE;

		/* FIXME: what about trampoline LMF frames?  see exceptions-x86.c */

		*lmf = (*lmf)->previous_lmf;

		return TRUE;
	}

	return FALSE;
}

/*
 * This is the function called from the signal handler
 */
void
mono_arch_sigctx_to_monoctx (void *ctx, MonoContext *mctx)
{
#ifdef MONO_CROSS_COMPILE
	g_assert_not_reached ();
#else
	os_ucontext *uc = ctx;

	mctx->sc_ir = UCONTEXT_REG_NIP(uc);
	mctx->sc_sp = UCONTEXT_REG_Rn(uc, 1);
	memcpy (&mctx->regs, &UCONTEXT_REG_Rn(uc, 13), sizeof (mgreg_t) * MONO_SAVED_GREGS);
	memcpy (&mctx->fregs, &UCONTEXT_REG_FPRn(uc, 14), sizeof (double) * MONO_SAVED_FREGS);
#endif
}

void
mono_arch_monoctx_to_sigctx (MonoContext *mctx, void *ctx)
{
#ifdef MONO_CROSS_COMPILE
	g_assert_not_reached ();
#else
	os_ucontext *uc = ctx;

	UCONTEXT_REG_NIP(uc) = mctx->sc_ir;
	UCONTEXT_REG_Rn(uc, 1) = mctx->sc_sp;
	memcpy (&UCONTEXT_REG_Rn(uc, 13), &mctx->regs, sizeof (mgreg_t) * MONO_SAVED_GREGS);
	memcpy (&UCONTEXT_REG_FPRn(uc, 14), &mctx->fregs, sizeof (double) * MONO_SAVED_FREGS);
#endif
}

gpointer
mono_arch_ip_from_context (void *sigctx)
{
#ifdef MONO_CROSS_COMPILE
	g_assert_not_reached ();
#else
	os_ucontext *uc = sigctx;
	return (gpointer)UCONTEXT_REG_NIP(uc);
#endif
}

void
mono_ppc_set_func_into_sigctx (void *sigctx, void *func)
{
#ifdef MONO_CROSS_COMPILE
	g_assert_not_reached ();
#elif defined(PPC_USES_FUNCTION_DESCRIPTOR)
	/* Have to set both the ip and the TOC reg */
	os_ucontext *uc = sigctx;

	UCONTEXT_REG_NIP(uc) = ((gsize*)func) [0];
	UCONTEXT_REG_Rn (uc, 2) = ((gsize*)func)[1];
#else
	g_assert_not_reached ();
#endif
}

static void
altstack_handle_and_restore (void *sigctx, gpointer obj)
{
	MonoContext mctx;

	mono_arch_sigctx_to_monoctx (sigctx, &mctx);
	mono_handle_exception (&mctx, obj);
	mono_restore_context (&mctx);
}

void
mono_arch_handle_altstack_exception (void *sigctx, gpointer fault_addr, gboolean stack_ovf)
{
#ifdef MONO_CROSS_COMPILE
	g_assert_not_reached ();
#else
#ifdef MONO_ARCH_USE_SIGACTION
	os_ucontext *uc = (ucontext_t*)sigctx;
	os_ucontext *uc_copy;
	MonoJitInfo *ji = mini_jit_info_table_find (mono_domain_get (), mono_arch_ip_from_context (sigctx), NULL);
	gpointer *sp;
	int frame_size;

	if (stack_ovf) {
		const char *method;
		/* we don't do much now, but we can warn the user with a useful message */
		fprintf (stderr, "Stack overflow: IP: %p, SP: %p\n", mono_arch_ip_from_context (sigctx), (gpointer)UCONTEXT_REG_Rn(uc, 1));
		if (ji && jinfo_get_method (ji))
			method = mono_method_full_name (jinfo_get_method (ji), TRUE);
		else
			method = "Unmanaged";
		fprintf (stderr, "At %s\n", method);
		abort ();
	}
	if (!ji)
		mono_handle_native_sigsegv (SIGSEGV, sigctx);
	/* setup a call frame on the real stack so that control is returned there
	 * and exception handling can continue.
	 * The frame looks like:
	 *   ucontext struct
	 *   ...
	 * 224 is the size of the red zone
	 */
	frame_size = sizeof (ucontext_t) + sizeof (gpointer) * 16 + 224;
	frame_size += 15;
	frame_size &= ~15;
	sp = (gpointer)(UCONTEXT_REG_Rn(uc, 1) & ~15);
	sp = (gpointer)((char*)sp - frame_size);
	/* may need to adjust pointers in the new struct copy, depending on the OS */
	uc_copy = (ucontext_t*)(sp + 16);
	memcpy (uc_copy, uc, sizeof (os_ucontext));
#if defined(__linux__) && !defined(__mono_ppc64__)
	uc_copy->uc_mcontext.uc_regs = (gpointer)((char*)uc_copy + ((char*)uc->uc_mcontext.uc_regs - (char*)uc));
#endif
	g_assert (mono_arch_ip_from_context (uc) == mono_arch_ip_from_context (uc_copy));
	/* at the return form the signal handler execution starts in altstack_handle_and_restore() */
	UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
	{
		MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)altstack_handle_and_restore;

		UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
		UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
	}
#else
	UCONTEXT_REG_NIP(uc) = (unsigned long)altstack_handle_and_restore;
#endif
	UCONTEXT_REG_Rn(uc, 1) = (unsigned long)sp;
	UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG) = (unsigned long)(sp + 16);
	UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 1) = 0;
	UCONTEXT_REG_Rn(uc, PPC_FIRST_ARG_REG + 2) = 0;
#endif

#endif /* !MONO_CROSS_COMPILE */
}

/*
 * handle_exception:
 *
 *   Called by resuming from a signal handler.
 */
static void
handle_signal_exception (gpointer obj)
{
	MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
	MonoContext ctx;

	memcpy (&ctx, &jit_tls->ex_ctx, sizeof (MonoContext));

	mono_handle_exception (&ctx, obj);

	mono_restore_context (&ctx);
}

static void
setup_ucontext_return (void *uc, gpointer func)
{
#if !defined(MONO_CROSS_COMPILE)
	UCONTEXT_REG_LNK(uc) = UCONTEXT_REG_NIP(uc);
#ifdef PPC_USES_FUNCTION_DESCRIPTOR
	{
		MonoPPCFunctionDescriptor *handler_ftnptr = (MonoPPCFunctionDescriptor*)func;

		UCONTEXT_REG_NIP(uc) = (gulong)handler_ftnptr->code;
		UCONTEXT_REG_Rn(uc, 2) = (gulong)handler_ftnptr->toc;
	}
#else
	UCONTEXT_REG_NIP(uc) = (unsigned long)func;
#endif
#endif
}

gboolean
mono_arch_handle_exception (void *ctx, gpointer obj)
{
#if defined(MONO_ARCH_USE_SIGACTION) && defined(UCONTEXT_REG_Rn)
	/*
	 * Handling the exception in the signal handler is problematic, since the original
	 * signal is disabled, and we could run arbitrary code though the debugger. So
	 * resume into the normal stack and do most work there if possible.
	 */
	MonoJitTlsData *jit_tls = mono_native_tls_get_value (mono_jit_tls_id);
	mgreg_t sp;
	void *sigctx = ctx;
	int frame_size;
	void *uc = sigctx;

	/* Pass the ctx parameter in TLS */
	mono_arch_sigctx_to_monoctx (sigctx, &jit_tls->ex_ctx);
	/* The others in registers */
	UCONTEXT_REG_Rn (sigctx, PPC_FIRST_ARG_REG) = (gsize)obj;

	/* Allocate a stack frame below the red zone */
	/* Similar to mono_arch_handle_altstack_exception () */
	frame_size = 224;
	frame_size += 15;
	frame_size &= ~15;
	sp = (mgreg_t)(UCONTEXT_REG_Rn(uc, 1) & ~15);
	sp = (mgreg_t)(sp - frame_size);
	UCONTEXT_REG_Rn(uc, 1) = (mgreg_t)sp;
	setup_ucontext_return (uc, handle_signal_exception);

	return TRUE;
#else
	MonoContext mctx;
	gboolean result;

	mono_arch_sigctx_to_monoctx (ctx, &mctx);

	result = mono_handle_exception (&mctx, obj);
	/* restore the context so that returning from the signal handler will invoke
	 * the catch clause
	 */
	mono_arch_monoctx_to_sigctx (&mctx, ctx);
	return result;
#endif
}


text:
var _fun = function() {};
%FunctionGetScriptSourcePosition(_fun);


text:
package org.apache.camel.model.language;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlRootElement;

/**
 * An expression which extracts the named header
 *
 * @version
 */
@XmlRootElement(name = "header")
@XmlAccessorType(XmlAccessType.FIELD)
public class HeaderExpression extends ExpressionDefinition {

    public HeaderExpression() {
    }

    public HeaderExpression(String expression) {
        super(expression);
    }

    public String getLanguage() {
        return "header";
    }
}


text:
<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
Partial Class frmHost
    Inherits System.Windows.Forms.Form

    'Form overrides dispose to clean up the component list.
    <System.Diagnostics.DebuggerNonUserCode()> _
    Protected Overrides Sub Dispose(ByVal disposing As Boolean)
        Try
            If disposing AndAlso components IsNot Nothing Then
                components.Dispose()
            End If
        Finally
            MyBase.Dispose(disposing)
        End Try
    End Sub

    'Required by the Windows Form Designer
    Private components As System.ComponentModel.IContainer

    'NOTE: The following procedure is required by the Windows Form Designer
    'It can be modified using the Windows Form Designer.
    'Do not modify it using the code editor.
    <System.Diagnostics.DebuggerStepThrough()> _
    Private Sub InitializeComponent()
        Me.btnEnterPlayers = New System.Windows.Forms.Button()
        Me.mnuFastMenu = New System.Windows.Forms.MenuStrip()
        Me.FileToolStripMenuItem = New System.Windows.Forms.ToolStripMenuItem()
        Me.ExitToolStripMenuItem = New System.Windows.Forms.ToolStripMenuItem()
        Me.HelpToolStripMenuItem = New System.Windows.Forms.ToolStripMenuItem()
        Me.AboutToolStripMenuItem = New System.Windows.Forms.ToolStripMenuItem()
        Me.mnuFastMenu.SuspendLayout()
        Me.SuspendLayout()
        '
        'btnEnterPlayers
        '
        Me.btnEnterPlayers.Location = New System.Drawing.Point(177, 392)
        Me.btnEnterPlayers.Name = "btnEnterPlayers"
        Me.btnEnterPlayers.Size = New System.Drawing.Size(454, 73)
        Me.btnEnterPlayers.TabIndex = 0
        Me.btnEnterPlayers.Text = "Enter Players"
        Me.btnEnterPlayers.UseVisualStyleBackColor = True
        '
        'mnuFastMenu
        '
        Me.mnuFastMenu.Items.AddRange(New System.Windows.Forms.ToolStripItem() {Me.FileToolStripMenuItem, Me.HelpToolStripMenuItem})
        Me.mnuFastMenu.Location = New System.Drawing.Point(0, 0)
        Me.mnuFastMenu.Name = "mnuFastMenu"
        Me.mnuFastMenu.Size = New System.Drawing.Size(814, 24)
        Me.mnuFastMenu.TabIndex = 4
        Me.mnuFastMenu.Text = "MenuStrip1"
        '
        'FileToolStripMenuItem
        '
        Me.FileToolStripMenuItem.DropDownItems.AddRange(New System.Windows.Forms.ToolStripItem() {Me.ExitToolStripMenuItem})
        Me.FileToolStripMenuItem.Name = "FileToolStripMenuItem"
        Me.FileToolStripMenuItem.Size = New System.Drawing.Size(37, 20)
        Me.FileToolStripMenuItem.Text = "&File"
        '
        'ExitToolStripMenuItem
        '
        Me.ExitToolStripMenuItem.Name = "ExitToolStripMenuItem"
        Me.ExitToolStripMenuItem.Size = New System.Drawing.Size(92, 22)
        Me.ExitToolStripMenuItem.Text = "&Exit"
        '
        'HelpToolStripMenuItem
        '
        Me.HelpToolStripMenuItem.DropDownItems.AddRange(New System.Windows.Forms.ToolStripItem() {Me.AboutToolStripMenuItem})
        Me.HelpToolStripMenuItem.Name = "HelpToolStripMenuItem"
        Me.HelpToolStripMenuItem.Size = New System.Drawing.Size(44, 20)
        Me.HelpToolStripMenuItem.Text = "&Help"
        '
        'AboutToolStripMenuItem
        '
        Me.AboutToolStripMenuItem.Name = "AboutToolStripMenuItem"
        Me.AboutToolStripMenuItem.Size = New System.Drawing.Size(152, 22)
        Me.AboutToolStripMenuItem.Text = "&About"
        '
        'frmHost
        '
        Me.AutoScaleDimensions = New System.Drawing.SizeF(6.0!, 13.0!)
        Me.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font
        Me.ClientSize = New System.Drawing.Size(814, 477)
        Me.Controls.Add(Me.mnuFastMenu)
        Me.Controls.Add(Me.btnEnterPlayers)
        Me.Name = "frmHost"
        Me.Text = "Host | Otaku Break the Safe"
        Me.mnuFastMenu.ResumeLayout(False)
        Me.mnuFastMenu.PerformLayout()
        Me.ResumeLayout(False)
        Me.PerformLayout()

    End Sub
    Friend WithEvents btnEnterPlayers As System.Windows.Forms.Button
    Friend WithEvents mnuFastMenu As System.Windows.Forms.MenuStrip
    Friend WithEvents FileToolStripMenuItem As System.Windows.Forms.ToolStripMenuItem
    Friend WithEvents ExitToolStripMenuItem As System.Windows.Forms.ToolStripMenuItem
    Friend WithEvents HelpToolStripMenuItem As System.Windows.Forms.ToolStripMenuItem
    Friend WithEvents AboutToolStripMenuItem As System.Windows.Forms.ToolStripMenuItem
End Class