text:
package com.example.doun.chapter17containers.performancetest;
import java.util.*;

public class Tester<C> {
    public static int fieldWidth = 8;
    public static TestParam[] defaultParams = TestParam.array(
            10, 5000, 100, 5000, 1000, 5000, 10000, 500);

    // Override this to modify pre-test initialization:
    protected C initialize(int size) {
        return container;
    }

    protected C container;
    private String headline = "";
    private List<Test<C>> tests;

    private static String stringField() {
        return "%" + fieldWidth + "s";
    }

    private static String numberField() {
        return "%" + fieldWidth + "d";
    }

    private static int sizeWidth = 5;
    private static String sizeField = "%" + sizeWidth + "s";
    private TestParam[] paramList = defaultParams;

    public Tester(C container, List<Test<C>> tests) {
        this.container = container;
        this.tests = tests;
        if (container != null)
            headline = container.getClass().getSimpleName();
    }

    public Tester(C container, List<Test<C>> tests,
                  TestParam[] paramList) {
        this(container, tests);
        this.paramList = paramList;
    }

    public void setHeadline(String newHeadline) {
        headline = newHeadline;
    }

    // Generic methods for convenience :
    public static <C> void run(C cntnr, List<Test<C>> tests) {
        new Tester<C>(cntnr, tests).timedTest();
    }

    public static <C> void run(C cntnr,
                               List<Test<C>> tests, TestParam[] paramList) {
        new Tester<C>(cntnr, tests, paramList).timedTest();
    }

    private void displayHeader() {
        // Calculate width and pad with '-':
        int width = fieldWidth * tests.size() + sizeWidth;
        int dashLength = width - headline.length() - 1;
        StringBuilder head = new StringBuilder(width);
        for (int i = 0; i < dashLength / 2; i++)
            head.append('-');
        head.append(' ');
        head.append(headline);
        head.append(' ');
        for (int i = 0; i < dashLength / 2; i++)
            head.append('-');
        System.out.println(head);
        // Print column headers:
        System.out.format(sizeField, "size");
        for (Test test : tests)
            System.out.format(stringField(), test.name);
        System.out.println();
    }

    // Run the tests for this container:
    public void timedTest() {
        displayHeader();
        for (TestParam param : paramList) {
            System.out.format(sizeField, param.size);
            for (Test<C> test : tests) {
                C kontainer = initialize(param.size);
                long start = System.nanoTime();
                // Call the overriden method:
                int reps = test.test(kontainer, param);
                long duration = System.nanoTime() - start;
                long timePerRep = duration / reps; // Nanoseconds
                System.out.format(numberField(), timePerRep);
            }
            System.out.println();
        }
    }
} ///:~


text:
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/spi/spi.h>
#include <linux/export.h>

#include "../iio.h"
#include "../trigger.h"
#include "ade7758.h"

/**
 * ade7758_data_rdy_trig_poll() the event handler for the data rdy trig
 **/
static irqreturn_t ade7758_data_rdy_trig_poll(int irq, void *private)
{
	disable_irq_nosync(irq);
	iio_trigger_poll(private, iio_get_time_ns());

	return IRQ_HANDLED;
}

/**
 * ade7758_data_rdy_trigger_set_state() set datardy interrupt state
 **/
static int ade7758_data_rdy_trigger_set_state(struct iio_trigger *trig,
						bool state)
{
	struct iio_dev *indio_dev = trig->private_data;

	dev_dbg(&indio_dev->dev, "%s (%d)\n", __func__, state);
	return ade7758_set_irq(&indio_dev->dev, state);
}

/**
 * ade7758_trig_try_reen() try renabling irq for data rdy trigger
 * @trig:	the datardy trigger
 **/
static int ade7758_trig_try_reen(struct iio_trigger *trig)
{
	struct iio_dev *indio_dev = trig->private_data;
	struct ade7758_state *st = iio_priv(indio_dev);

	enable_irq(st->us->irq);
	/* irq reenabled so success! */
	return 0;
}

static const struct iio_trigger_ops ade7758_trigger_ops = {
	.owner = THIS_MODULE,
	.set_trigger_state = &ade7758_data_rdy_trigger_set_state,
	.try_reenable = &ade7758_trig_try_reen,
};

int ade7758_probe_trigger(struct iio_dev *indio_dev)
{
	struct ade7758_state *st = iio_priv(indio_dev);
	int ret;

	st->trig = iio_allocate_trigger("%s-dev%d",
					spi_get_device_id(st->us)->name,
					indio_dev->id);
	if (st->trig == NULL) {
		ret = -ENOMEM;
		goto error_ret;
	}

	ret = request_irq(st->us->irq,
			  ade7758_data_rdy_trig_poll,
			  IRQF_TRIGGER_LOW,
			  spi_get_device_id(st->us)->name,
			  st->trig);
	if (ret)
		goto error_free_trig;

	st->trig->dev.parent = &st->us->dev;
	st->trig->ops = &ade7758_trigger_ops;
	st->trig->private_data = indio_dev;
	ret = iio_trigger_register(st->trig);

	/* select default trigger */
	indio_dev->trig = st->trig;
	if (ret)
		goto error_free_irq;

	return 0;

error_free_irq:
	free_irq(st->us->irq, st->trig);
error_free_trig:
	iio_free_trigger(st->trig);
error_ret:
	return ret;
}

void ade7758_remove_trigger(struct iio_dev *indio_dev)
{
	struct ade7758_state *st = iio_priv(indio_dev);

	iio_trigger_unregister(st->trig);
	free_irq(st->us->irq, st->trig);
	iio_free_trigger(st->trig);
}

redpajama_set_name: RedPajamaGithub


text:
//-------------------------------------------------------------------------------------
//     Copyright (c) 2014, Anthilla S.r.l. (http://www.anthilla.com)
//     All rights reserved.
//
//     Redistribution and use in source and binary forms, with or without
//     modification, are permitted provided that the following conditions are met:
//         * Redistributions of source code must retain the above copyright
//           notice, this list of conditions and the following disclaimer.
//         * Redistributions in binary form must reproduce the above copyright
//           notice, this list of conditions and the following disclaimer in the
//           documentation and/or other materials provided with the distribution.
//         * Neither the name of the Anthilla S.r.l. nor the
//           names of its contributors may be used to endorse or promote products
//           derived from this software without specific prior written permission.
//
//     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//     ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
//     DISCLAIMED. IN NO EVENT SHALL ANTHILLA S.R.L. BE LIABLE FOR ANY
//     DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
//     (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
//     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
//     ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
//     (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//     SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//     20141110
//-------------------------------------------------------------------------------------

using antdlib.Common;
using MailKit.Net.Smtp;
using MimeKit;

namespace antdlib.Mail {
    public class Smtp {

        public class Settings {
            private static readonly string CoreFileName = "smtpConfig";
            private static readonly string[] Files = {
                CoreFileName + "Current",
                CoreFileName + "001",
                CoreFileName + "002"
            };

            public static XmlWriter XmlWriter = new XmlWriter(Files);

            public static void SetUrl(string value) {
                XmlWriter.Write(Parameter.LabelSmtpUrl, value);
            }

            public static string Url => XmlWriter.ReadValue(Parameter.LabelSmtpUrl) ?? "";

            public static void SetPort(string value) {
                XmlWriter.Write(Parameter.LabelSmtpPort, value);
            }

            public static string Port => XmlWriter.ReadValue(Parameter.LabelSmtpPort) ?? "";

            public static void SetAccount(string value) {
                XmlWriter.Write(Parameter.LabelSmtpAccount, value);
            }

            public static string Account => XmlWriter.ReadValue(Parameter.LabelSmtpAccount) ?? "";

            public static void SetPassword(string value) {
                XmlWriter.Write(Parameter.LabelSmtpPassword, value);
            }

            public static string Password => XmlWriter.ReadValue(Parameter.LabelSmtpPassword) ?? "";

            public static bool ConfigExists => (XmlWriter.ReadValue(Parameter.LabelSmtpUrl) != null);
        }

        public static void Send() {
            var message = new MimeMessage();
            message.From.Add(new MailboxAddress("Fake Name", "fake.name@gmail.com"));
            message.To.Add(new MailboxAddress("Mr. Roger", "address.yeah@gmil.com"));
            message.Subject = "How you doin'?";
            message.Body = new TextPart("plain") {
                Text = @"Roger we got your son"
            };
            using (var client = new SmtpClient()) {
                client.Connect("smtp.gmail.com", 587, false);
                client.AuthenticationMechanisms.Remove("XOAUTH2");
                client.Authenticate("account name", "password");
                client.Send(message);
                client.Disconnect(true);
            }
        }
    }
}


text:
using System;

namespace FP.Spartakiade2017.Docker.BuildInside.WebApp.Module
{
    public class HomeModule : Nancy.NancyModule
    {
        public HomeModule()
        {
            Get("/", args => $"Hallo Spartakiade - {DateTime.Now}");
        }
    }
}


text:
Mathematical functions with automatic domain (:mod:`numpy.emath`)
***********************************************************************

.. currentmodule:: numpy

.. note:: :mod:`numpy.emath` is a preferred alias for :mod:`numpy.lib.scimath`,
          available after :mod:`numpy` is imported.

.. automodule:: numpy.lib.scimath


text:
image Package
=============

.. currentmodule:: SamPy.image

.. autosummary::
   :toctree:

   ImageConvolution
   manipulation
   transform


text:
namespace lean {

enum instruction
{
	LOAD_CONST,
	LOAD_VAR,
	LOAD_ARG,

	QUOTE,

	ADD,
	SUB,
	MUL,
	DIV,
	MOD,

	AND,
	OR,

	EQ,
	NEQ,
	LEQ,
	GEQ,
	LE,
	GE,

	IF,
	ASSIGNMENT,
    FUN_LOAD_ARG,
	FUN_CALL,
	FUN_RET,

    LAMBDA,

	SKIP,
};

inline std::ostream& operator << (std::ostream& ostr, instruction i)
{
	#define LEAN_output_instruction(_x_) if (i == _x_) return ostr << #_x_;
		LEAN_output_instruction(LOAD_CONST)
		LEAN_output_instruction(LOAD_VAR)
		LEAN_output_instruction(LOAD_ARG)
		LEAN_output_instruction(LAMBDA)
		LEAN_output_instruction(FUN_CALL)
		LEAN_output_instruction(FUN_RET)
        LEAN_output_instruction(FUN_LOAD_ARG)
        LEAN_output_instruction(ADD)
		LEAN_output_instruction(SUB)
		LEAN_output_instruction(MUL)
		LEAN_output_instruction(DIV)
		LEAN_output_instruction(MOD)
		LEAN_output_instruction(AND)
		LEAN_output_instruction(OR)
		LEAN_output_instruction(EQ)
		LEAN_output_instruction(NEQ)
		LEAN_output_instruction(LEQ)
		LEAN_output_instruction(GEQ)
		LEAN_output_instruction(LE)
		LEAN_output_instruction(GE)
		LEAN_output_instruction(IF)
		LEAN_output_instruction(ASSIGNMENT)
		LEAN_output_instruction(SKIP)
		LEAN_output_instruction(QUOTE)

	#undef LEAN_output_instruction
		assert(false);
	return ostr;
}

}

#endif


text:
package Image::ExifTool::ISO;

use strict;
use vars qw($VERSION);
use Image::ExifTool qw(:DataAccess :Utils);

$VERSION = '1.01';

# trim trailing spaces and ignore tag if empty
my %rawStr = (
    RawConv => sub {
        my $val = shift;
        $val =~ s/ +$//;
        return length($val) ? $val : undef;
    },
);

# tag info for date/time tags
my %dateInfo = (
    Format => 'undef[17]',
    Groups => { 2 => 'Time' },
    ValueConv => q{
        return undef if $val !~ /[^0\0 ]/; # ignore if empty
        if ($val =~ s/(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})(.)/$1:$2:$3 $4:$5:$6.$7/s) {
            $val .= TimeZoneString(unpack('c', $8) * 15);
        }
        return $val;
    },
    PrintConv => '$self->ConvertDateTime($val)',
);

# lookup for volume descriptor types
my %volumeDescriptorType = (
    0 => 'Boot Record',
    1 => 'Primary Volume',
    2 => 'Supplementary Volume',
    3 => 'Volume Partition',
    255 => 'Terminator',
);

# ISO tags
%Image::ExifTool::ISO::Main = (
    GROUPS => { 2 => 'Other' },
    NOTES => 'Tags extracted from ISO 9660 disk images.',
    0 => {
        Name => 'BootRecord',
        SubDirectory => { TagTable => 'Image::ExifTool::ISO::BootRecord' },
    },
    1 => {
        Name => 'PrimaryVolume',
        SubDirectory => { TagTable => 'Image::ExifTool::ISO::PrimaryVolume' },
    },
);

%Image::ExifTool::ISO::BootRecord = (
    GROUPS => { 2 => 'Other' },
    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
    # 0 => { Name => 'VolumeType', PrintConv => \%volumeDescriptorType }, # (0 for boot record)
    # 1 => { Name => 'Identifier',      Format => 'undef[5]' }, # (always "CD001")
    # 6 => 'VolumeDesriptorVersion', # (always 1)
    # always extract BootSystem, even if empty, as an indication that this is bootable
      7 => { Name => 'BootSystem',      Format => 'string[32]', ValueConv => '$val=~s/ +$//; $val' },
    39  => { Name => 'BootIdentifier',  Format => 'string[32]', %rawStr },
);

%Image::ExifTool::ISO::PrimaryVolume = (
    GROUPS => { 2 => 'Other' },
    PROCESS_PROC => \&Image::ExifTool::ProcessBinaryData,
    # 0 => { Name => 'VolumeType', PrintConv => \%volumeDescriptorType }, # (1 for primary volume)
    # 1 => { Name => 'Identifier',          Format => 'undef[5]' }, # (always "CD001")
    # 6 => 'VolumeDesriptorVersion', # (always 1)
      8 => { Name => 'System',              Format => 'string[32]', %rawStr },
     40 => { Name => 'VolumeName',          Format => 'string[32]', %rawStr },
     80 => { Name => 'VolumeBlockCount',    Format => 'int32u' },
    120 => { Name => 'VolumeSetDiskCount',  Format => 'int16u', Unknown => 1 },
    124 => { Name => 'VolumeSetDiskNumber', Format => 'int16u', Unknown => 1 },
    128 => { Name => 'VolumeBlockSize',     Format => 'int16u' },
    132 => { Name => 'PathTableSize',       Format => 'int32u', Unknown => 1 },
    140 => { Name => 'PathTableLocation',   Format => 'int32u', Unknown => 1 },
    174 => {
        Name => 'RootDirectoryCreateDate',
        Format => 'undef[7]',
        Groups => { 2 => 'Time' },
        ValueConv => q{
            my @a = unpack('C6c', $val);
            $a[0] += 1900;
            $a[6] = TimeZoneString($a[6] * 15);
            return sprintf('%.4d:%.2d:%.2d %.2d:%.2d:%.2d%s', @a);
        },
        PrintConv => '$self->ConvertDateTime($val)',
    },
    190 => { Name => 'VolumeSetName',       Format => 'string[128]', %rawStr },
    318 => { Name => 'Publisher',           Format => 'string[128]', %rawStr },
    446 => { Name => 'DataPreparer',        Format => 'string[128]', %rawStr },
    574 => { Name => 'Software',            Format => 'string[128]', %rawStr },
    702 => { Name => 'CopyrightFileName',   Format => 'string[38]', %rawStr },
    740 => { Name => 'AbstractFileName',    Format => 'string[36]', %rawStr },
    776 => { Name => 'BibligraphicFileName',Format => 'string[37]', %rawStr },
    813 => { Name => 'VolumeCreateDate',    %dateInfo },
    830 => { Name => 'VolumeModifyDate',    %dateInfo },
    847 => { Name => 'VolumeExpirationDate',%dateInfo },
    864 => { Name => 'VolumeEffectiveDate', %dateInfo },
   #881 => 'FileStructureVersion', # (always 1)
);

# ISO Composite tags
%Image::ExifTool::ISO::Composite = (
    GROUPS => { 2 => 'Other' },
    VolumeSize => {
        Require => {
            0 => 'ISO:VolumeBlockCount',
            1 => 'ISO:VolumeBlockSize',
        },
        ValueConv => '$val[0] * $val[1]',
        PrintConv => \&Image::ExifTool::ConvertFileSize,
    },
);

# add our composite tags
Image::ExifTool::AddCompositeTags('Image::ExifTool::ISO');

#------------------------------------------------------------------------------
# Extract information from an ISO 9660 disk image
# Inputs: 0) ExifTool object reference, 1) dirInfo reference
# Returns: 1 on success, 0 if this wasn't a valid ISO 9660 image
sub ProcessISO($$)
{
    my ($et, $dirInfo) = @_;
    my $raf = $$dirInfo{RAF};
    my ($buff, $tagTablePtr);

    # verify this is a valid ISO file
    return 0 unless $raf->Seek(32768, 0);

    while ($raf->Read($buff, 2048) == 2048) {
        last unless $buff =~ /^[\0-\x03\xff]CD001/;
        unless ($tagTablePtr) {
            $et->SetFileType(); # set the FileType tag
            SetByteOrder('II'); # read little-endian values only
            $tagTablePtr = GetTagTable('Image::ExifTool::ISO::Main');
        }
        my $type = unpack('C', $buff);
        $et->VPrint(0, "Volume descriptor type $type ($volumeDescriptorType{$type})\n");
        last if $type == 255;   # stop at terminator
        next unless $$tagTablePtr{$type};
        my $subTablePtr = GetTagTable($$tagTablePtr{$type}{SubDirectory}{TagTable});
        my %dirInfo = (
            DataPt   => \$buff,
            DataPos  => $raf->Tell() - 2048,
            DirStart => 0,
            DirLen   => length($buff),
        );
        $et->ProcessDirectory(\%dirInfo, $subTablePtr);
    }
    return $tagTablePtr ? 1 : 0;
}

1;  # end

__END__

=head1 NAME

Image::ExifTool::ISO - Read information from ISO 9660 disk images

=head1 SYNOPSIS

This module is used by Image::ExifTool

=head1 DESCRIPTION

This module contains definitions required by Image::ExifTool to read
information from ISO 9660 disk images.

=head1 AUTHOR

Copyright 2003-2022, Phil Harvey (philharvey66 at gmail.com)

This library is free software; you can redistribute it and/or modify it
under the same terms as Perl itself.

=head1 REFERENCES

=over 4

=item L<http://wiki.osdev.org/ISO_9660>

=back

=head1 SEE ALSO

L<Image::ExifTool::TagNames/ISO Tags>,
L<Image::ExifTool(3pm)|Image::ExifTool>

=cut


text:
#ifndef TB_PLATFORM_ADDRINFO_H
#define TB_PLATFORM_ADDRINFO_H

/* //////////////////////////////////////////////////////////////////////////////////////
 * includes
 */
#include "prefix.h"
#include "../network/ipaddr.h"

/* //////////////////////////////////////////////////////////////////////////////////////
 * extern
 */
__tb_extern_c_enter__

/* //////////////////////////////////////////////////////////////////////////////////////
 * interfaces
 */

/*! get the first dns address from the host name
 *
 * @code

    // get the default address (ipv4)
    tb_ipaddr_t addr = {0};
    if (tb_addrinfo_addr("www.tboox.org", &addr))
        tb_trace_i("%{ipaddr}", &addr);

    // get the ipv6 address by the hint info
    tb_ipaddr_t addr = {0};
    tb_ipaddr_family_set(&addr, TB_IPADDR_FAMILY_IPV6);
    if (tb_addrinfo_addr("www.tboox.org", &addr))
        tb_trace_i("%{ipaddr}", &addr);

 * @endcode
 *
 * @param name      the host name (cannot be null)
 * @param addr      the ip address (we can fill some hint info first)
 *
 * @return          tb_true or tb_false
 */
tb_bool_t           tb_addrinfo_addr(tb_char_t const* name, tb_ipaddr_ref_t addr);

/*! get the host name from the given address
 *
 * @code

    // get the host name by address
    tb_ipaddr_t addr;
    tb_char_t   host[256];
    tb_ipaddr_ip_cstr_set(&addr, "127.0.0.1");
    tb_trace_i("%s", tb_addrinfo_name(&addr, host, sizeof(host)));

 * @endcode
 *
 * @param addr      the ip address (cannot be null)
 * @param name      the host name buffer
 * @param maxn      the host name buffer maxn
 *
 * @return          the host name or tb_null
 */
tb_char_t const*    tb_addrinfo_name(tb_ipaddr_ref_t addr, tb_char_t* name, tb_size_t maxn);

/* //////////////////////////////////////////////////////////////////////////////////////
 * extern
 */
__tb_extern_c_leave__

#endif


text:
set PYTHONPATH=%PYTHONPATH%;C:\mat\Src\DarunGrim\Src\UI\FlowGrapher;C:\mat\Src\DarunGrim\Src\Scripts\FileManagement

rmdir /Q /S dist\DarunGrim

pyinstaller DarunGrim.spec
copy /Y ..\..\bin\GraphViz\* dist\DarunGrim

copy ..\..\Release\DarunGrimPlugin.plw dist\DarunGrim
copy ..\..\ReleaseP64\DarunGrimPlugin.p64 dist\DarunGrim
copy ..\..\Release\DarunGrimC.exe dist\DarunGrim

mkdir dist\DarunGrim\DarunGrim3
xcopy ..\..\Release\* dist\DarunGrim\DarunGrim3
copy /Y ..\..\bin\GraphViz\* dist\DarunGrim\DarunGrim3

mkdir dist\DarunGrim\x64
xcopy ..\..\x64\Release-x64\* dist\DarunGrim\x64

copy c:\windows\syswow64\msvcr120.dll dist\DarunGrim

copy DarunGrim.png dist\DarunGrim
copy DarunGrimSplash.png dist\DarunGrim

pushd dist
zip.exe DarunGrim.zip -r -9 -xi DarunGrim\*

copy /Y DarunGrim.zip C:\Users\User\Dropbox\Public\
popd

pause


text:
@typedef {Object} crud.types.FieldPropertiesObject FieldPropertiesObject
@parent crud.types
@option {String} alias The label to display for this field. The default is replace underscores with spaces
and capitalize the first letter
@option {Boolean} exclude If set to true, this field will not display in the identify widget
@option {function(value, attributes)} formatter An optional formatter function for the field's value that will return a string. This function may accept two arguments, the first being the property value, and the second being an object with all of the objects properties. This is provided in case a developer wants to use other proerties to format a value.
```
formatter: function(name, props) {
  return name + ' is Awesome! and my other prop is' + props.otherProp;
}
```

@description
An object consisting of a key representing the field name and the value being properties defining each field's appearance.

This object is used by the propert-table component to control the display of each property.

## Example

```javascript
var fieldProps = {
 bbox: {
   exclude: true
 },
 STATE_NAME: {
   alias: 'Name',
   formatter: function(name, properties) {
     return name + ' is Awesome!</strong>';
   }
 }
};
```


text:
  Start your session from shell using batch, and continue monitoring from vAPI

  In case you need to launch your session using batch first, please create a wrapper script that gets as an input the vSIF full path.

  The plugin will execute your script on the selective agent (Jenkins) and will extract the session name out of it.

  The plugin will then use that session_name to keep monitor your execution.

  Example for such script file can be:

  ---------------------------

  #!/bin/csh

  source ~/.cshrc

  setenv VMGR_REGION default

  setenv VMGR_REGION_ROUTE_POLICY LOCAL

  setenv VMGR_USER some_user_id

  setenv VMGR_PASSWORD XXXXXX

  vmanager -execcmd "launch $1"

  ---------------------------

  Please also make sure that

  1) The path to the script is a full path.  No shortcuts or relative paths are allowed.

  2) The shell type (bash, csh, sh) is supplied with full path as well.

  3) This mode can only be used with an Agent that runs on Linux.


text:
Color Base
==========

.. contents::
   :local:
   :depth: 2

Overview
--------

A color base is a container of color elements. The most common use of color
base is in the implementation of a pixel, in which case the color elements are
channel values. The color base concept, however, can be used in other
scenarios. For example, a planar pixel has channels that are not contiguous in
memory. Its reference is a proxy class that uses a color base whose elements
are channel references. Its iterator uses a color base whose elements are
channel iterators.

Color base models must satisfy the following concepts:

.. code-block:: cpp

  concept ColorBaseConcept<typename T>
      : CopyConstructible<T>, EqualityComparable<T>
  {
    // a GIL layout (the color space and element permutation)
    typename layout_t;

    // The type of K-th element
    template <int K> struct kth_element_type;
        where Metafunction<kth_element_type>;

    // The result of at_c
    template <int K> struct kth_element_const_reference_type;
        where Metafunction<kth_element_const_reference_type>;

    template <int K> kth_element_const_reference_type<T,K>::type at_c(T);

    template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
        T::T(T2);
    template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
        bool operator==(const T&, const T2&);
    template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
        bool operator!=(const T&, const T2&);

  };

  concept MutableColorBaseConcept<ColorBaseConcept T>
      : Assignable<T>, Swappable<T>
  {
    template <int K> struct kth_element_reference_type;
        where Metafunction<kth_element_reference_type>;

    template <int K> kth_element_reference_type<T,K>::type at_c(T);

    template <ColorBaseConcept T2> where { ColorBasesCompatibleConcept<T,T2> }
        T& operator=(T&, const T2&);
  };

  concept ColorBaseValueConcept<typename T> : MutableColorBaseConcept<T>, Regular<T>
  {
  };

  concept HomogeneousColorBaseConcept<ColorBaseConcept CB>
  {
    // For all K in [0 ... size<C1>::value-1):
    //     where SameType<kth_element_type<K>::type, kth_element_type<K+1>::type>;
    kth_element_const_reference_type<0>::type dynamic_at_c(const CB&, std::size_t n) const;
  };

  concept MutableHomogeneousColorBaseConcept<MutableColorBaseConcept CB>
      : HomogeneousColorBaseConcept<CB>
  {
    kth_element_reference_type<0>::type dynamic_at_c(const CB&, std::size_t n);
  };

  concept HomogeneousColorBaseValueConcept<typename T>
      : MutableHomogeneousColorBaseConcept<T>, Regular<T>
  {
  };

  concept ColorBasesCompatibleConcept<ColorBaseConcept C1, ColorBaseConcept C2>
  {
    where SameType<C1::layout_t::color_space_t, C2::layout_t::color_space_t>;
    // also, for all K in [0 ... size<C1>::value):
    //     where Convertible<kth_semantic_element_type<C1,K>::type, kth_semantic_element_type<C2,K>::type>;
    //     where Convertible<kth_semantic_element_type<C2,K>::type, kth_semantic_element_type<C1,K>::type>;
  };

A color base must have an associated layout (which consists of a color space,
as well as an ordering of the channels). There are two ways to index the
elements of a color base: A physical index corresponds to the way they are
ordered in memory, and a semantic index corresponds to the way the elements
are ordered in their color space. For example, in the RGB color space the
elements are ordered as ``{red_t, green_t, blue_t}``. For a color base with
a BGR layout, the first element in physical ordering is the blue element,
whereas the first semantic element is the red one.  Models of
``ColorBaseConcept`` are required to provide the ``at_c<K>(ColorBase)``
function, which allows for accessing the elements based on their physical
order. GIL provides a ``semantic_at_c<K>(ColorBase)`` function (described
later) which can operate on any model of ColorBaseConcept and returns the
corresponding semantic element.

Two color bases are *compatible* if they have the same color space and their
elements (paired semantically) are convertible to each other.

Models
------

GIL provides a model for a homogeneous color base (a color base whose elements
all have the same type).

.. code-block:: cpp

  namespace detail
  {
    template <typename Element, typename Layout, int K>
    struct homogeneous_color_base;
  }

It is used in the implementation of GIL's pixel, planar pixel reference and
planar pixel iterator. Another model of ``ColorBaseConcept`` is
``packed_pixel`` - it is a pixel whose channels are bit ranges.

See the :doc:`pixel` section for more.

Algorithms
----------

GIL provides the following functions and metafunctions operating on color
bases:

.. code-block:: cpp

  // Metafunction returning an mpl::int_ equal to the number of elements in the color base
  template <class ColorBase> struct size;

  // Returns the type of the return value of semantic_at_c<K>(color_base)
  template <class ColorBase, int K> struct kth_semantic_element_reference_type;
  template <class ColorBase, int K> struct kth_semantic_element_const_reference_type;

  // Returns a reference to the element with K-th semantic index.
  template <class ColorBase, int K>
  typename kth_semantic_element_reference_type<ColorBase,K>::type       semantic_at_c(ColorBase& p)
  template <class ColorBase, int K>
  typename kth_semantic_element_const_reference_type<ColorBase,K>::type semantic_at_c(const ColorBase& p)

  // Returns the type of the return value of get_color<Color>(color_base)
  template <typename Color, typename ColorBase> struct color_reference_t;
  template <typename Color, typename ColorBase> struct color_const_reference_t;

  // Returns a reference to the element corresponding to the given color
  template <typename ColorBase, typename Color>
  typename color_reference_t<Color,ColorBase>::type get_color(ColorBase& cb, Color=Color());
  template <typename ColorBase, typename Color>
  typename color_const_reference_t<Color,ColorBase>::type get_color(const ColorBase& cb, Color=Color());

  // Returns the element type of the color base. Defined for homogeneous color bases only
  template <typename ColorBase> struct element_type;
  template <typename ColorBase> struct element_reference_type;
  template <typename ColorBase> struct element_const_reference_type;

GIL also provides the following algorithms which operate on color bases.
Note that they all pair the elements semantically:

.. code-block:: cpp

  // Equivalents to std::equal, std::copy, std::fill, std::generate
  template <typename CB1,typename CB2>   bool static_equal(const CB1& p1, const CB2& p2);
  template <typename Src,typename Dst>   void static_copy(const Src& src, Dst& dst);
  template <typename CB, typename Op>    void static_generate(CB& dst,Op op);

  // Equivalents to std::transform
  template <typename CB ,             typename Dst,typename Op> Op static_transform(      CB&,Dst&,Op);
  template <typename CB ,             typename Dst,typename Op> Op static_transform(const CB&,Dst&,Op);
  template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(      CB1&,      CB2&,Dst&,Op);
  template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(const CB1&,      CB2&,Dst&,Op);
  template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(      CB1&,const CB2&,Dst&,Op);
  template <typename CB1,typename CB2,typename Dst,typename Op> Op static_transform(const CB1&,const CB2&,Dst&,Op);

  // Equivalents to std::for_each
  template <typename CB1,                          typename Op> Op static_for_each(      CB1&,Op);
  template <typename CB1,                          typename Op> Op static_for_each(const CB1&,Op);
  template <typename CB1,typename CB2,             typename Op> Op static_for_each(      CB1&,      CB2&,Op);
  template <typename CB1,typename CB2,             typename Op> Op static_for_each(      CB1&,const CB2&,Op);
  template <typename CB1,typename CB2,             typename Op> Op static_for_each(const CB1&,      CB2&,Op);
  template <typename CB1,typename CB2,             typename Op> Op static_for_each(const CB1&,const CB2&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,      CB2&,      CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,      CB2&,const CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,const CB2&,      CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(      CB1&,const CB2&,const CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,      CB2&,      CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,      CB2&,const CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,const CB2&,      CB3&,Op);
  template <typename CB1,typename CB2,typename CB3,typename Op> Op static_for_each(const CB1&,const CB2&,const CB3&,Op);

  // The following algorithms are only defined for homogeneous color bases:
  // Equivalent to std::fill
  template <typename HCB, typename Element> void static_fill(HCB& p, const Element& v);

  // Equivalents to std::min_element and std::max_element
  template <typename HCB> typename element_const_reference_type<HCB>::type static_min(const HCB&);
  template <typename HCB> typename element_reference_type<HCB>::type       static_min(      HCB&);
  template <typename HCB> typename element_const_reference_type<HCB>::type static_max(const HCB&);
  template <typename HCB> typename element_reference_type<HCB>::type       static_max(      HCB&);

These algorithms are designed after the corresponding STL algorithms, except
that instead of ranges they take color bases and operate on their elements.
In addition, they are implemented with a compile-time recursion (thus the
prefix "static\_"). Finally, they pair the elements semantically instead of
based on their physical order in memory.

For example, here is the implementation of ``static_equal``:

.. code-block:: cpp

  namespace detail
  {
    template <int K> struct element_recursion
    {
      template <typename P1,typename P2>
      static bool static_equal(const P1& p1, const P2& p2)
      {
        return element_recursion<K-1>::static_equal(p1,p2) &&
               semantic_at_c<K-1>(p1)==semantic_at_c<N-1>(p2);
      }
    };
    template <> struct element_recursion<0>
    {
      template <typename P1,typename P2>
      static bool static_equal(const P1&, const P2&) { return true; }
    };
  }

  template <typename P1,typename P2>
  bool static_equal(const P1& p1, const P2& p2)
  {
    gil_function_requires<ColorSpacesCompatibleConcept<P1::layout_t::color_space_t,P2::layout_t::color_space_t> >();
    return detail::element_recursion<size<P1>::value>::static_equal(p1,p2);
  }

This algorithm is used when invoking ``operator==`` on two pixels, for
example. By using semantic accessors we are properly comparing an RGB pixel to
a BGR pixel. Notice also that all of the above algorithms taking more than one
color base require that they all have the same color space.


text:
var Subscription = require('../lib').Subscription
var config = require('./config')

var s = new Subscription({
  appSecret: config.appSecret,
  production: config.production,
  restrictedPackageName: config.restrictedPackageName
})

s.subscribeTopic(config.regids[0], 'a', null).then(console.log, console.log)


text:
"""Module for RDP Proxying."""

from oslo.config import cfg

rdp_opts = [
    cfg.StrOpt('html5_proxy_base_url',
               default='http://127.0.0.1:6083/',
               help='Location of RDP html5 console proxy, in the form '
                    '"http://127.0.0.1:6083/"'),
    cfg.BoolOpt('enabled',
                default=False,
                help='Enable RDP related features'),
    ]

CONF = cfg.CONF
CONF.register_opts(rdp_opts, group='rdp')


text:
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.microsoftgraph.graphpickers">
    <application
        android:allowBackup="true"
        android:supportsRtl="true">
        <activity
            android:name=".GraphUserSearch" />
        <activity
            android:name=".GraphFileSearch" />
        <activity
            android:name=".GraphMailSearch" />
    </application>
</manifest>


text:
#include <aws/iam/model/AccessAdvisorUsageGranularityType.h>
#include <aws/core/utils/HashingUtils.h>
#include <aws/core/Globals.h>
#include <aws/core/utils/EnumParseOverflowContainer.h>

using namespace Aws::Utils;

namespace Aws
{
  namespace IAM
  {
    namespace Model
    {
      namespace AccessAdvisorUsageGranularityTypeMapper
      {

        static const int SERVICE_LEVEL_HASH = HashingUtils::HashString("SERVICE_LEVEL");
        static const int ACTION_LEVEL_HASH = HashingUtils::HashString("ACTION_LEVEL");

        AccessAdvisorUsageGranularityType GetAccessAdvisorUsageGranularityTypeForName(const Aws::String& name)
        {
          int hashCode = HashingUtils::HashString(name.c_str());
          if (hashCode == SERVICE_LEVEL_HASH)
          {
            return AccessAdvisorUsageGranularityType::SERVICE_LEVEL;
          }
          else if (hashCode == ACTION_LEVEL_HASH)
          {
            return AccessAdvisorUsageGranularityType::ACTION_LEVEL;
          }
          EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
          if(overflowContainer)
          {
            overflowContainer->StoreOverflow(hashCode, name);
            return static_cast<AccessAdvisorUsageGranularityType>(hashCode);
          }

          return AccessAdvisorUsageGranularityType::NOT_SET;
        }

        Aws::String GetNameForAccessAdvisorUsageGranularityType(AccessAdvisorUsageGranularityType enumValue)
        {
          switch(enumValue)
          {
          case AccessAdvisorUsageGranularityType::SERVICE_LEVEL:
            return "SERVICE_LEVEL";
          case AccessAdvisorUsageGranularityType::ACTION_LEVEL:
            return "ACTION_LEVEL";
          default:
            EnumParseOverflowContainer* overflowContainer = Aws::GetEnumOverflowContainer();
            if(overflowContainer)
            {
              return overflowContainer->RetrieveOverflow(static_cast<int>(enumValue));
            }

            return {};
          }
        }

      } // namespace AccessAdvisorUsageGranularityTypeMapper
    } // namespace Model
  } // namespace IAM
} // namespace Aws


text:
The [prime factors kata](http://butunclebob.com/ArticleS.UncleBob.ThePrimeFactorsKata) in Elm.

## Tests

`elm-test test/AllTests.elm`

OR

`bundle install`

`guard`


text:
//
//  NSArray+TJPArrayUtil.h
//  TJPYingKe
//
//  Created by AaronTang on 2017/9/25.
//  Copyright © 2017年 AaronTang. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface NSArray (TJPArrayUtil)

/**
 检查是否越界和NSNull如果是返回nil

 @param index index
 @return 返回对象
 */
- (id)objectAtIndexChecked:(NSUInteger)index;

@end


text:
<!DOCTYPE html>

    <meta charset="UTF-8">
    <meta name="HandheldFriendly" content="True">
    <meta name="MobileOptimized" content="320">
    <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
    <meta http-equiv="X-UA-Compatible" content="ie=edge">
    <link rel="profile" href="http://gmpg.org/xfn/11">
    <title>Alenta</title>
    <meta name="description" content="Alenta primer centro médico ambulatorio de Colombia"/>
    <link rel="shortcut icon" href="images/favicon.png" />

    <link rel="stylesheet" href="styles/style.min.css">


text:
<?php

/**
 * Provides next triggers:<br>
 *  admin/System/general/optimization/clean_pcache
 */
namespace	cs\modules\System;
use			cs\Cache,
			cs\Config,
			cs\Index,
			cs\Trigger;
if (!isset($_POST['edit_settings'])) {
	return;
}
$Index	= Index::instance();
$Config	= Config::instance();
if ($_POST['edit_settings'] == 'apply' || $_POST['edit_settings'] == 'save') {
	foreach ($Config->admin_parts as $part) {
		if (isset($_POST[$part])) {
			$temp = &$Config->$part;
			foreach ($_POST[$part] as $item => $value) {
				switch ($item) {
					case 'name':
					case 'closed_title':
					case 'closed_text':
					case 'footer_text':
					case 'mail_from_name':
					case 'mail_signature':
					case 'rules':
						$value	= set_core_ml_text($item, $value);
					break;
					case 'url':
					case 'cookie_domain':
					case 'cookie_path':
					case 'ip_black_list':
					case 'ip_admin_list':
						$value	= _trim(explode("\n", $value));
						if ($value[0] == '') {
							$value	= [];
						}
				}
				$temp[$item] = xap($value, true);
				if ($item == 'theme') {
					$temp['color_scheme']	= $Config->core['color_schemes'][$temp['theme']][0];
				}
			}
			unset($item, $value);
			if ($part == 'routing' || $part == 'replace') {
				$temp['in'] = explode("\n", $temp['in']);
				$temp['out'] = explode("\n", $temp['out']);
				foreach ($temp['in'] as $i => $value) {
					if (empty($value)) {
						unset($temp['in'][$i], $temp['out'][$i]);
					}
				}
				unset($i, $value);
			}
			unset($temp);
		}
	}
	unset($part);
}
$Cache	= Cache::instance();
if ($_POST['edit_settings'] == 'apply' && $Cache->cache_state()) {
	if ($Index->apply() && !$Config->core['cache_compress_js_css']) {
		clean_pcache();
		Trigger::instance()->run('admin/System/general/optimization/clean_pcache');
	}
} elseif ($_POST['edit_settings'] == 'save') {
	$save = $Index->save();
	if ($save && !$Config->core['cache_compress_js_css']) {
		clean_pcache();
		Trigger::instance()->run('admin/System/general/optimization/clean_pcache');
	}
} elseif ($_POST['edit_settings'] == 'cancel' && $Cache->cache_state()) {
	$Index->cancel();
}


text:
import now from './now'

const toFixed = (v, dp) => {
  if (typeof dp === 'undefined') {
    return v
  }
  return v.toFixed(dp)
}

const createInstance = (tag) => {
  let totalTime
  let meanTime
  let minTime
  let maxTime
  let count
  let tookTime
  let startTimes

  const reset = () => {
    totalTime = 0
    meanTime = 0
    minTime = -1
    maxTime = -1
    count = 0
    tookTime = 0
    startTimes = {}
  }

  reset()

  return {
    start(id = 'default') {
      const time = now()
      startTimes[id] = time
      return this
    },
    stop(id = 'default') {
      const startTime = startTimes[id]
      if (!startTime) { return -1 }
      tookTime = now() - startTime
      minTime = minTime === -1 ? tookTime : Math.min(minTime, tookTime)
      maxTime = maxTime === -1 ? tookTime : Math.max(maxTime, tookTime)
      totalTime += tookTime
      count += 1
      meanTime = totalTime / count
      startTimes[id] = undefined
      return tookTime
    },
    reset,
    took() {
      return tookTime
    },
    total() {
      return totalTime
    },
    mean() {
      return meanTime
    },
    count() {
      return count
    },
    min() {
      return minTime
    },
    max() {
      return maxTime
    },
    stats() {
      return {
        mean: meanTime,
        took: tookTime,
        total: totalTime,
        count,
        min: minTime,
        max: maxTime
      }
    },
    info(dp) {
      return `${tag ? `[${tag}] ` : ''}mean: ${toFixed(meanTime, dp)
      }ms, took: ${toFixed(tookTime, dp)
      }ms, total: ${toFixed(totalTime, dp)
      }ms, count: ${count
      }, min: ${toFixed(minTime, dp)
      }ms, max: ${toFixed(maxTime, dp)
      }ms`
    },
    log(dp) {
      // eslint-disable-next-line no-console
      console.log(this.info(dp))
    }
  }
}

const isArray = (o) => Object.prototype.toString.call(o) === '[object Array]'

const isString = (o) => (typeof o === 'string') || (o instanceof String)

const createTimer = (tags) => {
  if (isArray(tags)) {
    const a = []
    for (let i = 0; i < tags.length; i += 1) {
      a.push(createInstance(tags[i]))
    }
    return a
  }
  if (isString(tags)) {
    return createInstance(tags)
  }
  return createInstance()
}

export default createTimer


text:
<?php

// BraincraftedBootstrapBundle:Form:bootstrap.html.twig
return array (
);


text:
package org.apache.avro.mapred;

import java.io.Closeable;
import java.io.IOException;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.FSDataInputStream;

import org.apache.avro.file.SeekableInput;

/** Adapt an {@link FSDataInputStream} to {@link SeekableInput}. */
public class FsInput implements Closeable, SeekableInput {
  private final FSDataInputStream stream;
  private final long len;

  /** Construct given a path and a configuration. */
  public FsInput(Path path, Configuration conf) throws IOException {
    this(path, path.getFileSystem(conf));
  }

  /** Construct given a path and a {@code FileSystem}. */
  public FsInput(Path path, FileSystem fileSystem) throws IOException {
    this.len = fileSystem.getFileStatus(path).getLen();
    this.stream = fileSystem.open(path);
  }

  @Override
  public long length() {
    return len;
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    return stream.read(b, off, len);
  }

  @Override
  public void seek(long p) throws IOException {
    stream.seek(p);
  }

  @Override
  public long tell() throws IOException {
    return stream.getPos();
  }

  @Override
  public void close() throws IOException {
    stream.close();
  }
}


text:
#include "shrpx_mruby_module_request.h"

#include <mruby/variable.h>
#include <mruby/string.h>
#include <mruby/hash.h>
#include <mruby/array.h>

#include "shrpx_downstream.h"
#include "shrpx_upstream.h"
#include "shrpx_client_handler.h"
#include "shrpx_mruby.h"
#include "shrpx_mruby_module.h"
#include "util.h"
#include "http2.h"

namespace shrpx {

namespace mruby {

namespace {
mrb_value request_init(mrb_state *mrb, mrb_value self) { return self; }
} // namespace

namespace {
mrb_value request_get_http_version_major(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  return mrb_fixnum_value(downstream->get_request_major());
}
} // namespace

namespace {
mrb_value request_get_http_version_minor(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  return mrb_fixnum_value(downstream->get_request_minor());
}
} // namespace

namespace {
mrb_value request_get_method(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  auto method = http2::to_method_string(downstream->get_request_method());

  return mrb_str_new_cstr(mrb, method);
}
} // namespace

namespace {
mrb_value request_set_method(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;

  check_phase(mrb, data->phase, PHASE_REQUEST);

  const char *method;
  mrb_int n;
  mrb_get_args(mrb, "s", &method, &n);
  if (n == 0) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "method must not be empty string");
  }
  auto token =
      http2::lookup_method_token(reinterpret_cast<const uint8_t *>(method), n);
  if (token == -1) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "method not supported");
  }

  downstream->set_request_method(token);

  return self;
}
} // namespace

namespace {
mrb_value request_get_authority(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  auto &authority = downstream->get_request_http2_authority();

  return mrb_str_new(mrb, authority.c_str(), authority.size());
}
} // namespace

namespace {
mrb_value request_set_authority(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;

  check_phase(mrb, data->phase, PHASE_REQUEST);

  const char *authority;
  mrb_int n;
  mrb_get_args(mrb, "s", &authority, &n);
  if (n == 0) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "authority must not be empty string");
  }

  downstream->set_request_http2_authority(std::string(authority, n));

  return self;
}
} // namespace

namespace {
mrb_value request_get_scheme(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  auto &scheme = downstream->get_request_http2_scheme();

  return mrb_str_new(mrb, scheme.c_str(), scheme.size());
}
} // namespace

namespace {
mrb_value request_set_scheme(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;

  check_phase(mrb, data->phase, PHASE_REQUEST);

  const char *scheme;
  mrb_int n;
  mrb_get_args(mrb, "s", &scheme, &n);
  if (n == 0) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "scheme must not be empty string");
  }

  downstream->set_request_http2_scheme(std::string(scheme, n));

  return self;
}
} // namespace

namespace {
mrb_value request_get_path(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  auto &path = downstream->get_request_path();

  return mrb_str_new(mrb, path.c_str(), path.size());
}
} // namespace

namespace {
mrb_value request_set_path(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;

  check_phase(mrb, data->phase, PHASE_REQUEST);

  const char *path;
  mrb_int pathlen;
  mrb_get_args(mrb, "s", &path, &pathlen);

  downstream->set_request_path(std::string(path, pathlen));

  return self;
}
} // namespace

namespace {
mrb_value request_get_headers(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  return create_headers_hash(mrb, downstream->get_request_headers());
}
} // namespace

namespace {
mrb_value request_mod_header(mrb_state *mrb, mrb_value self, bool repl) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;

  check_phase(mrb, data->phase, PHASE_REQUEST);

  mrb_value key, values;
  mrb_get_args(mrb, "oo", &key, &values);

  if (RSTRING_LEN(key) == 0) {
    mrb_raise(mrb, E_RUNTIME_ERROR, "empty key is not allowed");
  }

  key = mrb_funcall(mrb, key, "downcase", 0);

  if (repl) {
    size_t p = 0;
    auto &headers = downstream->get_request_headers();
    for (size_t i = 0; i < headers.size(); ++i) {
      auto &hd = headers[i];
      if (util::streq(std::begin(hd.name), hd.name.size(), RSTRING_PTR(key),
                      RSTRING_LEN(key))) {
        continue;
      }
      if (i != p) {
        headers[p++] = std::move(hd);
      }
    }
    headers.resize(p);
  }

  if (mrb_obj_is_instance_of(mrb, values, mrb->array_class)) {
    auto n = mrb_ary_len(mrb, values);
    for (int i = 0; i < n; ++i) {
      auto value = mrb_ary_entry(values, i);
      downstream->add_request_header(
          std::string(RSTRING_PTR(key), RSTRING_LEN(key)),
          std::string(RSTRING_PTR(value), RSTRING_LEN(value)));
    }
  } else if (!mrb_nil_p(values)) {
    downstream->add_request_header(
        std::string(RSTRING_PTR(key), RSTRING_LEN(key)),
        std::string(RSTRING_PTR(values), RSTRING_LEN(values)));
  }

  data->request_headers_dirty = true;

  return mrb_nil_value();
}
} // namespace

namespace {
mrb_value request_set_header(mrb_state *mrb, mrb_value self) {
  return request_mod_header(mrb, self, true);
}
} // namespace

namespace {
mrb_value request_add_header(mrb_state *mrb, mrb_value self) {
  return request_mod_header(mrb, self, false);
}
} // namespace

namespace {
mrb_value request_clear_headers(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;

  check_phase(mrb, data->phase, PHASE_REQUEST);

  downstream->clear_request_headers();

  return mrb_nil_value();
}
} // namespace

namespace {
mrb_value request_push(mrb_state *mrb, mrb_value self) {
  auto data = static_cast<MRubyAssocData *>(mrb->ud);
  auto downstream = data->downstream;
  auto upstream = downstream->get_upstream();

  const char *uri;
  mrb_int len;
  mrb_get_args(mrb, "s", &uri, &len);

  upstream->initiate_push(downstream, uri, len);

  return mrb_nil_value();
}
} // namespace

void init_request_class(mrb_state *mrb, RClass *module) {
  auto request_class =
      mrb_define_class_under(mrb, module, "Request", mrb->object_class);

  mrb_define_method(mrb, request_class, "initialize", request_init,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "http_version_major",
                    request_get_http_version_major, MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "http_version_minor",
                    request_get_http_version_minor, MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "method", request_get_method,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "method=", request_set_method,
                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, request_class, "authority", request_get_authority,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "authority=", request_set_authority,
                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, request_class, "scheme", request_get_scheme,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "scheme=", request_set_scheme,
                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, request_class, "path", request_get_path,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "path=", request_set_path,
                    MRB_ARGS_REQ(1));
  mrb_define_method(mrb, request_class, "headers", request_get_headers,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "add_header", request_add_header,
                    MRB_ARGS_REQ(2));
  mrb_define_method(mrb, request_class, "set_header", request_set_header,
                    MRB_ARGS_REQ(2));
  mrb_define_method(mrb, request_class, "clear_headers", request_clear_headers,
                    MRB_ARGS_NONE());
  mrb_define_method(mrb, request_class, "push", request_push, MRB_ARGS_REQ(1));
}

} // namespace mruby

} // namespace shrpx


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using DMT.Common.Rest;
using DMT.Matcher.Interfaces;
using DMT.Module.Common.Service;

namespace DMT.Partition.Module.Remote
{
    class MatcherServiceClient
    {
        private const string QuitPath = "/quit";
        private const string StartPath = "/start";
        private const string RestartPath = "/restart";
        private const string CancelPath = "/cancel";

        private string baseAddress;

        public MatcherServiceClient(string baseAddress)
        {
            this.baseAddress = baseAddress.TrimEnd('/');
        }

        public Task ReleaseMatcher()
        {
            return RestClientHelper.SendRequestWithoutBodyAsync(HttpMethod.Post, CreateUrl(QuitPath));
        }

        public Task StartMatcher(MatchMode mode)
        {
            return Task.Run(() =>
            {
                string url = CreateUrl(StartPath);
                StartMatcherJobRequest req = new StartMatcherJobRequest();
                req.Mode = mode;

                using (WebClient wc = new WebClient { BaseAddress = this.baseAddress })
                using (var stream = wc.OpenWrite(url, HttpMethod.Post))
                {
                    XmlSerializer s = new XmlSerializer(typeof(StartMatcherJobRequest));
                    s.Serialize(stream, req);
                }
            });
        }

        public Task RestartWithNewJob()
        {
            return RestClientHelper.SendRequestWithoutBodyAsync(HttpMethod.Post, CreateUrl(RestartPath));
        }

        public Task CancelMatcher()
        {
            return RestClientHelper.SendRequestWithoutBodyAsync(HttpMethod.Post, CreateUrl(CancelPath));
        }

        private string CreateUrl(string path)
        {
            return string.Format("{0}{1}", this.baseAddress, path);
        }
    }
}


text:
{{ 'CLASIFICACION.VIEW._TITLE' | translate }} {{ clasificacion.id }}

{{ 'CLASIFICACION.FIELDS._CODE' | translate }}

{{ clasificacion.code }}

{{ 'CLASIFICACION.FIELDS._NAME' | translate }}

{{ clasificacion.name }}

			{{ 'BUTTONS._CANCEL' | translate }}
			{{ 'BUTTONS._EDIT' | translate }}

{{ 'CLASIFICACION.EDIT._TITLE' | translate }} {{ clasificacion.id }}

		<form #editClasificacionForm="ngForm" (ngSubmit)="onSubmit()" (keyup)="checkForErrors()">

				{{ 'CLASIFICACION.FIELDS._CODE' | translate }}
				<input type="text" class="form-control" (change)="checkForErrors()" #code="ngModel" name="code" [(ngModel)]="clasificacion.code" maxlength="3" required/>
				<span *ngIf="clasificacion.code.length < 1 && code.touched">{{ 'CLASIFICACION.ERRORS._CODE' | translate }}
				{{ 'CLASIFICACION.ERRORS._DUPE_CODE' | translate }}
				<span *ngIf="clasificacion.code.length < 1 && code.touched">{{ 'CLASIFICACION.ERRORS._CODE' | translate }}

				{{ 'CLASIFICACION.FIELDS._NAME' | translate }}
				<input type="text" class="form-control" (change)="checkForErrors()" #nombre="ngModel" name="nombre" [(ngModel)]="clasificacion.name" required/>
				<span *ngIf="clasificacion.name.length < 1 && nombre.touched">{{ 'CLASIFICACION.ERRORS._NAME' | translate }}
				{{ 'CLASIFICACION.ERRORS._DUPE_NAME' | translate }}

				{{ 'BUTTONS._CANCEL' | translate }}
				<button class="btn btn-success" type="submit"
						[disabled]="!editClasificacionForm.valid"
						>{{ 'BUTTONS._SAVE' | translate }}</button>

		</form>


text:
<?php # -*- coding: utf-8 -*-

declare( strict_types = 1 );

namespace Inpsyde\WPRESTStarter\Common\Factory\Exception;

/**
 * Exception to be thrown when trying to create an instance of an invalid class.
 *
 * @package Inpsyde\WPRESTStarter\Common\Factory\Exception
 * @since   3.0.0
 */
class InvalidClass extends \Exception {

}


text:
<!DOCTYPE html>

	<meta charset="utf-8">
	<title>Phaser Source: D:/wamp/www/phaser/src/geom/Point.js</title>

	<link type="text/css" rel="stylesheet" href="styles/default.css">

	<link type="text/css" rel="stylesheet" href="styles/sunlight.default.css">

	<link type="text/css" rel="stylesheet" href="styles/site.cerulean.css">

			Phaser API

					Namespaces

							Phaser

							PIXI

					Classes

							Animation

							AnimationManager

							AnimationParser

							ArrayList

							ArraySet

							ArrayUtils

							AudioSprite

							BitmapData

							BitmapText

							Button

							Cache

							Camera

							Canvas

							Circle

							Color

							Device

							DOM

							Easing

							Ellipse

							Events

							Filter

							FlexGrid

							FlexLayer

							Frame

							FrameData

							Game

							GameObjectCreator

							GameObjectFactory

							Gamepad

							GamepadButton

							Graphics

							Group

							Image

							Input

							InputHandler

							Key

							Keyboard

							Line

							LinkedList

							Loader

							LoaderParser

							Math

							Mouse

							MSPointer

							Net

							Particle

							Particles

							Arcade

							Emitter

							Physics

							Arcade

							Body

							Ninja

							AABB

							Body

							Circle

							Tile

							P2

							Body

							BodyDebug

							CollisionGroup

							ContactMaterial

							DistanceConstraint

							FixtureList

							GearConstraint

							InversePointProxy

							LockConstraint

							Material

							PointProxy

							PrismaticConstraint

							RevoluteConstraint

							RotationalSpring

							Spring

							Plugin

							PluginManager

							Point

							Pointer

							Polygon

							QuadTree

							RandomDataGenerator

							Rectangle

							RenderTexture

							RequestAnimationFrame

							RetroFont

							Rope

							ScaleManager

							Signal

							SignalBinding

							SinglePad

							Sound

							SoundManager

							Sprite

							SpriteBatch

							Stage

							State

							StateManager

							Text

							Tile

							Tilemap

							TilemapLayer

							TilemapParser

							Tileset

							TileSprite

							Time

							Timer

							TimerEvent

							Touch

							Tween

							TweenData

							TweenManager

							Utils

							Debug

							World

							AbstractFilter

							AjaxRequest

							AlphaMaskFilter

							AsciiFilter

							AssetLoader

							AtlasLoader

							BaseTexture

							BitmapFontLoader

							BitmapText

							BlurFilter

							BlurXFilter

							BlurYFilter

							CanvasBuffer

							CanvasGraphics

							CanvasMaskManager

							CanvasRenderer

							CanvasTinter

							Circle

							ColorMatrixFilter

							ColorStepFilter

							ComplexPrimitiveShader

							ConvolutionFilter

							CrossHatchFilter

							DisplacementFilter

							DisplayObject

							DisplayObjectContainer

							DotScreenFilter

							Ellipse

							Event

							EventTarget

							FilterBlock

							FilterTexture

							Graphics

							GraphicsData

							GrayFilter

							ImageLoader

							InteractionData

							InteractionManager

							InvertFilter

							JsonLoader

							Matrix

							MovieClip

							NoiseFilter

							NormalMapFilter

							PixelateFilter

							PIXI

							PixiFastShader

							PixiShader

							Point

							Polygon

							PolyK

							PrimitiveShader

							Rectangle

							RenderTexture

							RGBSplitFilter

							Rope

							RoundedRectangle

							SepiaFilter

							SmartBlurFilter

							Spine

							SpineLoader

							SpineTextureLoader

							Sprite

							SpriteBatch

							SpriteSheetLoader

							Stage

							Strip

							StripShader

							Text

							Texture

							TilingSprite

							TiltShiftFilter

							TiltShiftXFilter

							TiltShiftYFilter

							TwistFilter

							VideoTexture

							WebGLBlendModeManager

							WebGLFastSpriteBatch

							WebGLFilterManager

							WebGLRenderer

					Core

Game

Group

World

Loader

Time

Camera

State Manager

Tween Manager

Sound Manager

Input Manager

Scale Manager

					Game Objects

Factory (game.add)

Creator (game.make)

Sprite

Image

Sound

Particle Emitter

Particle

Text

Tween

BitmapText

Tilemap

BitmapData

RetroFont

Button

Animation

Graphics

RenderTexture

TileSprite

					Geometry

Circle

Rectangle

Point

Line

Ellipse

Polygon

					Physics

Arcade Physics

Body

P2 Physics

Body

Spring

CollisionGroup

ContactMaterial

Ninja Physics

Body

					Input

Input Handler

Pointer

Mouse

Keyboard

Key

Gamepad

					Community

Phaser Books

Phaser Github

Phaser Examples

Phaser Plugins

Forum

Stack Overflow

Newsletter

Twitter

IRC

GitTip

Source: D:/wamp/www/phaser/src/geom/Point.js

/**
* A Point object represents a location in a two-dimensional coordinate system, where x represents the horizontal axis and y represents the vertical axis.
* The following code creates a point at (0,0):
* `var myPoint = new Phaser.Point();`
* You can also use them as 2D Vectors and you'll find different vector related methods in this class.
*
* @class Phaser.Point
* @constructor
* @param {number} [x=0] - The horizontal position of this Point.
* @param {number} [y=0] - The vertical position of this Point.
*/
Phaser.Point = function (x, y) {

    x = x || 0;
    y = y || 0;

    /**
    * @property {number} x - The x value of the point.
    */
    this.x = x;

    /**
    * @property {number} y - The y value of the point.
    */
    this.y = y;

};

Phaser.Point.prototype = {

    /**
    * Copies the x and y properties from any given object to this Point.
    *
    * @method Phaser.Point#copyFrom
    * @param {any} source - The object to copy from.
    * @return {Phaser.Point} This Point object.
    */
    copyFrom: function (source) {

        return this.setTo(source.x, source.y);

    },

    /**
    * Inverts the x and y values of this Point
    *
    * @method Phaser.Point#invert
    * @return {Phaser.Point} This Point object.
    */
    invert: function () {

        return this.setTo(this.y, this.x);

    },

    /**
    * Sets the `x` and `y` values of this Point object to the given values.
    * If you omit the `y` value then the `x` value will be applied to both, for example:
    * `Point.setTo(2)` is the same as `Point.setTo(2, 2)`
    *
    * @method Phaser.Point#setTo
    * @param {number} x - The horizontal value of this point.
    * @param {number} [y] - The vertical value of this point. If not given the x value will be used in its place.
    * @return {Phaser.Point} This Point object. Useful for chaining method calls.
    */
    setTo: function (x, y) {

        this.x = x || 0;
        this.y = y || ( (y !== 0) ? this.x : 0 );

        return this;

    },

    /**
    * Sets the `x` and `y` values of this Point object to the given values.
    * If you omit the `y` value then the `x` value will be applied to both, for example:
    * `Point.setTo(2)` is the same as `Point.setTo(2, 2)`
    *
    * @method Phaser.Point#set
    * @param {number} x - The horizontal value of this point.
    * @param {number} [y] - The vertical value of this point. If not given the x value will be used in its place.
    * @return {Phaser.Point} This Point object. Useful for chaining method calls.
    */
    set: function (x, y) {

        this.x = x || 0;
        this.y = y || ( (y !== 0) ? this.x : 0 );

        return this;

    },

    /**
    * Adds the given x and y values to this Point.
    *
    * @method Phaser.Point#add
    * @param {number} x - The value to add to Point.x.
    * @param {number} y - The value to add to Point.y.
    * @return {Phaser.Point} This Point object. Useful for chaining method calls.
    */
    add: function (x, y) {

        this.x += x;
        this.y += y;
        return this;

    },

    /**
    * Subtracts the given x and y values from this Point.
    *
    * @method Phaser.Point#subtract
    * @param {number} x - The value to subtract from Point.x.
    * @param {number} y - The value to subtract from Point.y.
    * @return {Phaser.Point} This Point object. Useful for chaining method calls.
    */
    subtract: function (x, y) {

        this.x -= x;
        this.y -= y;
        return this;

    },

    /**
    * Multiplies Point.x and Point.y by the given x and y values. Sometimes known as `Scale`.
    *
    * @method Phaser.Point#multiply
    * @param {number} x - The value to multiply Point.x by.
    * @param {number} y - The value to multiply Point.x by.
    * @return {Phaser.Point} This Point object. Useful for chaining method calls.
    */
    multiply: function (x, y) {

        this.x *= x;
        this.y *= y;
        return this;

    },

    /**
    * Divides Point.x and Point.y by the given x and y values.
    *
    * @method Phaser.Point#divide
    * @param {number} x - The value to divide Point.x by.
    * @param {number} y - The value to divide Point.x by.
    * @return {Phaser.Point} This Point object. Useful for chaining method calls.
    */
    divide: function (x, y) {

        this.x /= x;
        this.y /= y;
        return this;

    },

    /**
    * Clamps the x value of this Point to be between the given min and max.
    *
    * @method Phaser.Point#clampX
    * @param {number} min - The minimum value to clamp this Point to.
    * @param {number} max - The maximum value to clamp this Point to.
    * @return {Phaser.Point} This Point object.
    */
    clampX: function (min, max) {

        this.x = Phaser.Math.clamp(this.x, min, max);
        return this;

    },

    /**
    * Clamps the y value of this Point to be between the given min and max
    *
    * @method Phaser.Point#clampY
    * @param {number} min - The minimum value to clamp this Point to.
    * @param {number} max - The maximum value to clamp this Point to.
    * @return {Phaser.Point} This Point object.
    */
    clampY: function (min, max) {

        this.y = Phaser.Math.clamp(this.y, min, max);
        return this;

    },

    /**
    * Clamps this Point object values to be between the given min and max.
    *
    * @method Phaser.Point#clamp
    * @param {number} min - The minimum value to clamp this Point to.
    * @param {number} max - The maximum value to clamp this Point to.
    * @return {Phaser.Point} This Point object.
    */
    clamp: function (min, max) {

        this.x = Phaser.Math.clamp(this.x, min, max);
        this.y = Phaser.Math.clamp(this.y, min, max);
        return this;

    },

    /**
    * Creates a copy of the given Point.
    *
    * @method Phaser.Point#clone
    * @param {Phaser.Point} [output] Optional Point object. If given the values will be set into this object, otherwise a brand new Point object will be created and returned.
    * @return {Phaser.Point} The new Point object.
    */
    clone: function (output) {

        if (typeof output === "undefined" || output === null)
        {
            output = new Phaser.Point(this.x, this.y);
        }
        else
        {
            output.setTo(this.x, this.y);
        }

        return output;

    },

    /**
    * Copies the x and y properties from this Point to any given object.
    *
    * @method Phaser.Point#copyTo
    * @param {any} dest - The object to copy to.
    * @return {object} The dest object.
    */
    copyTo: function (dest) {

        dest.x = this.x;
        dest.y = this.y;

        return dest;

    },

    /**
    * Returns the distance of this Point object to the given object (can be a Circle, Point or anything with x/y properties)
    *
    * @method Phaser.Point#distance
    * @param {object} dest - The target object. Must have visible x and y properties that represent the center of the object.
    * @param {boolean} [round] - Round the distance to the nearest integer (default false).
    * @return {number} The distance between this Point object and the destination Point object.
    */
    distance: function (dest, round) {

        return Phaser.Point.distance(this, dest, round);

    },

    /**
    * Determines whether the given objects x/y values are equal to this Point object.
    *
    * @method Phaser.Point#equals
    * @param {Phaser.Point|any} a - The object to compare with this Point.
    * @return {boolean} A value of true if the x and y points are equal, otherwise false.
    */
    equals: function (a) {

        return (a.x === this.x && a.y === this.y);

    },

    /**
    * Returns the angle between this Point object and another object with public x and y properties.
    *
    * @method Phaser.Point#angle
    * @param {Phaser.Point|any} a - The object to get the angle from this Point to.
    * @param {boolean} [asDegrees=false] - Is the given angle in radians (false) or degrees (true)?
    * @return {number} The angle between the two objects.
    */
    angle: function (a, asDegrees) {

        if (typeof asDegrees === 'undefined') { asDegrees = false; }

        if (asDegrees)
        {
            return Phaser.Math.radToDeg(Math.atan2(a.y - this.y, a.x - this.x));
        }
        else
        {
            return Math.atan2(a.y - this.y, a.x - this.x);
        }

    },

    /**
    * Rotates this Point around the x/y coordinates given to the desired angle.
    *
    * @method Phaser.Point#rotate
    * @param {number} x - The x coordinate of the anchor point.
    * @param {number} y - The y coordinate of the anchor point.
    * @param {number} angle - The angle in radians (unless asDegrees is true) to rotate the Point to.
    * @param {boolean} asDegrees - Is the given rotation in radians (false) or degrees (true)?
    * @param {number} [distance] - An optional distance constraint between the Point and the anchor.
    * @return {Phaser.Point} The modified point object.
    */
    rotate: function (x, y, angle, asDegrees, distance) {

        return Phaser.Point.rotate(this, x, y, angle, asDegrees, distance);

    },

    /**
    * Calculates the length of the Point object.
    *
    * @method Phaser.Point#getMagnitude
    * @return {number} The length of the Point.
    */
    getMagnitude: function () {

        return Math.sqrt((this.x * this.x) + (this.y * this.y));

    },

    /**
    * Calculates the length squared of the Point object.
    *
    * @method Phaser.Point#getMagnitudeSq
    * @return {number} The length ^ 2 of the Point.
    */
    getMagnitudeSq: function () {

        return (this.x * this.x) + (this.y * this.y);

    },

    /**
    * Alters the length of the Point without changing the direction.
    *
    * @method Phaser.Point#setMagnitude
    * @param {number} magnitude - The desired magnitude of the resulting Point.
    * @return {Phaser.Point} This Point object.
    */
    setMagnitude: function (magnitude) {

        return this.normalize().multiply(magnitude, magnitude);

    },

    /**
    * Alters the Point object so that its length is 1, but it retains the same direction.
    *
    * @method Phaser.Point#normalize
    * @return {Phaser.Point} This Point object.
    */
    normalize: function () {

        if (!this.isZero())
        {
            var m = this.getMagnitude();
            this.x /= m;
            this.y /= m;
        }

        return this;

    },

    /**
    * Determine if this point is at 0,0.
    *
    * @method Phaser.Point#isZero
    * @return {boolean} True if this Point is 0,0, otherwise false.
    */
    isZero: function () {

        return (this.x === 0 && this.y === 0);

    },

    /**
    * The dot product of this and another Point object.
    *
    * @method Phaser.Point#dot
    * @param {Phaser.Point} a - The Point object to get the dot product combined with this Point.
    * @return {number} The result.
    */
    dot: function (a) {

        return ((this.x * a.x) + (this.y * a.y));

    },

    /**
    * The cross product of this and another Point object.
    *
    * @method Phaser.Point#cross
    * @param {Phaser.Point} a - The Point object to get the cross product combined with this Point.
    * @return {number} The result.
    */
    cross: function (a) {

        return ((this.x * a.y) - (this.y * a.x));

    },

    /**
    * Make this Point perpendicular (90 degrees rotation)
    *
    * @method Phaser.Point#perp
    * @return {Phaser.Point} This Point object.
    */
    perp: function () {

        return this.setTo(-this.y, this.x);

    },

    /**
    * Make this Point perpendicular (-90 degrees rotation)
    *
    * @method Phaser.Point#rperp
    * @return {Phaser.Point} This Point object.
    */
    rperp: function () {

        return this.setTo(this.y, -this.x);

    },

    /**
    * Right-hand normalize (make unit length) this Point.
    *
    * @method Phaser.Point#normalRightHand
    * @return {Phaser.Point} This Point object.
    */
    normalRightHand: function () {

        return this.setTo(this.y * -1, this.x);

    },

    /**
    * Math.floor() both the x and y properties of this Point.
    *
    * @method Phaser.Point#floor
    * @return {Phaser.Point} This Point object.
    */
    floor: function () {

        return this.setTo(Math.floor(this.x), Math.floor(this.y));

    },

    /**
    * Math.ceil() both the x and y properties of this Point.
    *
    * @method Phaser.Point#ceil
    * @return {Phaser.Point} This Point object.
    */
    ceil: function () {

        return this.setTo(Math.ceil(this.x), Math.ceil(this.y));

    },

    /**
    * Returns a string representation of this object.
    *
    * @method Phaser.Point#toString
    * @return {string} A string representation of the instance.
    */
    toString: function () {

        return '[{Point (x=' + this.x + ' y=' + this.y + ')}]';

    }

};

Phaser.Point.prototype.constructor = Phaser.Point;

/**
* Adds the coordinates of two points together to create a new point.
*
* @method Phaser.Point.add
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.add = function (a, b, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    out.x = a.x + b.x;
    out.y = a.y + b.y;

    return out;

};

/**
* Subtracts the coordinates of two points to create a new point.
*
* @method Phaser.Point.subtract
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.subtract = function (a, b, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    out.x = a.x - b.x;
    out.y = a.y - b.y;

    return out;

};

/**
* Multiplies the coordinates of two points to create a new point.
*
* @method Phaser.Point.multiply
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.multiply = function (a, b, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    out.x = a.x * b.x;
    out.y = a.y * b.y;

    return out;

};

/**
* Divides the coordinates of two points to create a new point.
*
* @method Phaser.Point.divide
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.divide = function (a, b, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    out.x = a.x / b.x;
    out.y = a.y / b.y;

    return out;

};

/**
* Determines whether the two given Point objects are equal. They are considered equal if they have the same x and y values.
*
* @method Phaser.Point.equals
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @return {boolean} A value of true if the Points are equal, otherwise false.
*/
Phaser.Point.equals = function (a, b) {

    return (a.x === b.x && a.y === b.y);

};

/**
* Returns the angle between two Point objects.
*
* @method Phaser.Point.angle
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @return {number} The angle between the two Points.
*/
Phaser.Point.angle = function (a, b) {

    // return Math.atan2(a.x * b.y - a.y * b.x, a.x * b.x + a.y * b.y);
    return Math.atan2(a.y - b.y, a.x - b.x);

};

/**
* Creates a negative Point.
*
* @method Phaser.Point.negative
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.negative = function (a, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    return out.setTo(-a.x, -a.y);

};

/**
* Adds two 2D Points together and multiplies the result by the given scalar.
*
* @method Phaser.Point.multiplyAdd
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {number} s - The scaling value.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.multiplyAdd = function (a, b, s, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    return out.setTo(a.x + b.x * s, a.y + b.y * s);

};

/**
* Interpolates the two given Points, based on the `f` value (between 0 and 1) and returns a new Point.
*
* @method Phaser.Point.interpolate
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {number} f - The level of interpolation between the two points. Indicates where the new point will be, along the line between pt1 and pt2. If f=1, pt1 is returned; if f=0, pt2 is returned.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.interpolate = function (a, b, f, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    return out.setTo(a.x + (b.x - a.x) * f, a.y + (b.y - a.y) * f);

};

/**
* Return a perpendicular vector (90 degrees rotation)
*
* @method Phaser.Point.perp
* @param {Phaser.Point} a - The Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.perp = function (a, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    return out.setTo(-a.y, a.x);

};

/**
* Return a perpendicular vector (-90 degrees rotation)
*
* @method Phaser.Point.rperp
* @param {Phaser.Point} a - The Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.rperp = function (a, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    return out.setTo(a.y, -a.x);

};

/**
* Returns the euclidian distance of this Point object to the given object (can be a Circle, Point or anything with x/y properties).
*
* @method Phaser.Point.distance
* @param {object} a - The target object. Must have visible x and y properties that represent the center of the object.
* @param {object} b - The target object. Must have visible x and y properties that represent the center of the object.
* @param {boolean} [round=false] - Round the distance to the nearest integer.
* @return {number} The distance between this Point object and the destination Point object.
*/
Phaser.Point.distance = function (a, b, round) {

    var distance = Phaser.Math.distance(a.x, a.y, b.x, b.y);
    return round ? Math.round(distance) : distance;

};

/**
* Project two Points onto another Point.
*
* @method Phaser.Point.project
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.project = function (a, b, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    var amt = a.dot(b) / b.getMagnitudeSq();

    if (amt !== 0)
    {
        out.setTo(amt * b.x, amt * b.y);
    }

    return out;

};

/**
* Project two Points onto a Point of unit length.
*
* @method Phaser.Point.projectUnit
* @param {Phaser.Point} a - The first Point object.
* @param {Phaser.Point} b - The second Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.projectUnit = function (a, b, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    var amt = a.dot(b);

    if (amt !== 0)
    {
        out.setTo(amt * b.x, amt * b.y);
    }

    return out;

};

/**
* Right-hand normalize (make unit length) a Point.
*
* @method Phaser.Point.normalRightHand
* @param {Phaser.Point} a - The Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.normalRightHand = function (a, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    return out.setTo(a.y * -1, a.x);

};

/**
* Normalize (make unit length) a Point.
*
* @method Phaser.Point.normalize
* @param {Phaser.Point} a - The Point object.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.normalize = function (a, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    var m = a.getMagnitude();

    if (m !== 0)
    {
        out.setTo(a.x / m, a.y / m);
    }

    return out;

};

/**
* Rotates a Point around the x/y coordinates given to the desired angle.
*
* @method Phaser.Point.rotate
* @param {Phaser.Point} a - The Point object to rotate.
* @param {number} x - The x coordinate of the anchor point
* @param {number} y - The y coordinate of the anchor point
* @param {number} angle - The angle in radians (unless asDegrees is true) to rotate the Point to.
* @param {boolean} [asDegrees=false] - Is the given rotation in radians (false) or degrees (true)?
* @param {number} [distance] - An optional distance constraint between the Point and the anchor.
* @return {Phaser.Point} The modified point object.
*/
Phaser.Point.rotate = function (a, x, y, angle, asDegrees, distance) {

    asDegrees = asDegrees || false;
    distance = distance || null;

    if (asDegrees)
    {
        angle = Phaser.Math.degToRad(angle);
    }

    //  Get distance from origin (cx/cy) to this point
    if (distance === null)
    {
        distance = Math.sqrt(((x - a.x) * (x - a.x)) + ((y - a.y) * (y - a.y)));
    }

    var requiredAngle = angle + Math.atan2(a.y - y, a.x - x);

    return a.setTo(x + distance * Math.cos(requiredAngle), y + distance * Math.sin(requiredAngle));

};

/**
* Calculates centroid (or midpoint) from an array of points. If only one point is provided, that point is returned.
*
* @method Phaser.Point.centroid
* @param {Phaser.Point[]} points - The array of one or more points.
* @param {Phaser.Point} [out] - Optional Point to store the value in, if not supplied a new Point object will be created.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.centroid = function (points, out) {

    if (typeof out === "undefined") { out = new Phaser.Point(); }

    if (Object.prototype.toString.call(points) !== '[object Array]')
    {
        throw new Error("Phaser.Point. Parameter 'points' must be an array");
    }

    var pointslength = points.length;

    if (pointslength < 1)
    {
        throw new Error("Phaser.Point. Parameter 'points' array must not be empty");
    }

    if (pointslength === 1)
    {
        out.copyFrom(points[0]);
        return out;
    }

    for (var i = 0; i < pointslength; i++)
    {
        Phaser.Point.add(out, points[i], out);
    }

    out.divide(pointslength, pointslength);

    return out;

};

/**
* Parses an object for x and/or y properties and returns a new Phaser.Point with matching values.
* If the object doesn't contain those properties a Point with x/y of zero will be returned.
*
* @method Phaser.Point.parse
* @static
* @param {object} obj - The object to parse.
* @param {string} [xProp='x'] - The property used to set the Point.x value.
* @param {string} [yProp='y'] - The property used to set the Point.y value.
* @return {Phaser.Point} The new Point object.
*/
Phaser.Point.parse = function(obj, xProp, yProp) {

    xProp = xProp || 'x';
    yProp = yProp || 'y';

    var point = new Phaser.Point();

    if (obj[xProp])
    {
        point.x = parseInt(obj[xProp], 10);
    }

    if (obj[yProp])
    {
        point.y = parseInt(obj[yProp], 10);
    }

    return point;

};

//   Because PIXI uses its own Point, we'll replace it with ours to avoid duplicating code or confusion.
PIXI.Point = Phaser.Point;

		Phaser Copyright © 2012-2014 Photon Storm Ltd.

		Documentation generated by JSDoc 3.3.0-dev
		on Tue Jan 06 2015 06:31:49 GMT-0000 (GMT) using the DocStrap template.


text:
using namespace MX;

void Viewport::Push()
{
    Graphic::TextureRenderer::current().Flush();
    auto c = get().current();
    get()._stack.push_back(c);
}

void Viewport::Push(int w, int h)
{
    Graphic::TextureRenderer::current().Flush();
    get()._stack.push_back(Rectangle { 0.0f, 0.0f, (float)w, (float)h });
    UseCurrent();
}

void Viewport::Pop()
{
    Graphic::TextureRenderer::current().Flush();
    get()._stack.pop_back();
    UseCurrent();
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  #%L
  Travis Jr. App
  %%
  Copyright (C) 2013 Lonepulse
  %%
  Licensed under the Apache License, Version 2.0 (the "License");
  you may not use this file except in compliance with the License.
  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  #L%
  -->

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@id/root"
    android:layout_width="match_parent"
    android:layout_height="80dp"
    android:background="@color/bg_logo"
    android:baselineAligned="false"
    android:orientation="horizontal"
    android:weightSum="1" >

    <RelativeLayout
        android:id="@+id/panel_indicator"
        android:layout_width="0dp"
        android:layout_height="80dp"
        android:layout_weight="1"
        android:gravity="left"
        android:paddingRight="5dp" >

        <ImageView
            android:id="@id/status_started"
            android:layout_width="86dp"
            android:layout_height="86dp"
            android:layout_alignParentLeft="true"
            android:layout_alignParentTop="true"
            android:layout_marginLeft="-25dp"
            android:layout_marginTop="-20dp"
            android:scaleType="centerCrop"
            android:src="@drawable/gear_started"
            tools:ignore="ContentDescription" />

        <TextView
            android:id="@id/build_number"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginLeft="38dp"
            android:layout_marginTop="7dp"
            android:singleLine="true"
            android:text="@string/not_available"
            android:textColor="@color/txt_blue"
            android:textSize="@dimen/txt_xxl"
            android:textStyle="bold" />

        <TextView
            android:id="@id/message"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignLeft="@id/build_number"
            android:layout_below="@id/build_number"
            android:ellipsize="end"
            android:maxLines="2"
            android:text="@string/not_available"
            android:textColor="@color/txt_dark"
            android:textSize="@dimen/txt_s"
            android:textStyle="bold" />
    </RelativeLayout>

    <RelativeLayout
        android:id="@id/panel_event"
        android:layout_width="150dp"
        android:layout_height="80dp"
        android:layout_marginRight="10dp"
        android:gravity="right" >

        <TextView
            android:id="@id/branch"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignParentRight="true"
            android:layout_alignParentTop="true"
            android:layout_marginTop="7dp"
            android:singleLine="true"
            android:text="@string/not_available"
            android:textColor="@color/txt_blue"
            android:textSize="@dimen/txt_m"
            android:textStyle="bold" />

        <TextView
            android:id="@id/event"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignRight="@id/branch"
            android:layout_below="@id/branch"
            android:singleLine="true"
            android:text="@string/not_available"
            android:textColor="@color/txt_dark"
            android:textSize="@dimen/txt_s" />

        <RelativeLayout
            android:id="@+id/panel_duration"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_alignRight="@id/event"
            android:layout_below="@id/event"
            android:layout_marginTop="3dp" >

            <TextView
                android:id="@id/minutes"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:gravity="bottom"
                android:singleLine="true"
                android:text="@string/not_available"
                android:textColor="@color/txt_blue"
                android:textSize="@dimen/txt_l" />

            <TextView
                android:id="@id/min"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignBaseline="@id/minutes"
                android:layout_toRightOf="@id/minutes"
                android:gravity="bottom"
                android:singleLine="true"
                android:text="@string/lbl_minutes"
                android:textColor="@color/txt_dark"
                android:textSize="@dimen/txt_s" />

            <TextView
                android:id="@id/seconds"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignBaseline="@id/min"
                android:layout_toRightOf="@id/min"
                android:gravity="bottom"
                android:singleLine="true"
                android:text="@string/not_available"
                android:textColor="@color/txt_blue"
                android:textSize="@dimen/txt_l" />

            <TextView
                android:id="@id/sec"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:layout_alignBaseline="@id/seconds"
                android:layout_toRightOf="@id/seconds"
                android:gravity="bottom"
                android:singleLine="true"
                android:text="@string/lbl_seconds"
                android:textColor="@color/txt_dark"
                android:textSize="@dimen/txt_s" />
        </RelativeLayout>
    </RelativeLayout>

</LinearLayout>


text:
<m:FindItemResponse xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types" xmlns:m="http://schemas.microsoft.com/exchange/services/2006/messages">
  <m:ResponseMessages>
    <m:FindItemResponseMessage ResponseClass="Success">
      <m:ResponseCode>NoError</m:ResponseCode>
      <m:RootFolder TotalItemsInView="3" IncludesLastItemInRange="true">
        <t:Items>
          <t:Message>
            <t:ItemId Id="BUEm5G5U" ChangeKey="LABU0Ut45"/>
            <t:ParentFolderId Id="AQAUAH" ChangeKey="AQA"/>
            <t:ItemClass>IPM.Note</t:ItemClass>
            <t:Subject>test</t:Subject>
            <t:Sensitivity>Normal</t:Sensitivity>
            <t:DateTimeReceived>2009-12-11T16:40:44Z</t:DateTimeReceived>
            <t:Size>754</t:Size>
            <t:Importance>Normal</t:Importance>
            <t:IsSubmitted>false</t:IsSubmitted>
            <t:IsDraft>false</t:IsDraft>
            <t:IsFromMe>false</t:IsFromMe>
            <t:IsResend>false</t:IsResend>
            <t:IsUnmodified>true</t:IsUnmodified>
            <t:DateTimeSent>2009-12-11T16:39:44Z</t:DateTimeSent>
            <t:DateTimeCreated>2009-12-11T16:40:44Z</t:DateTimeCreated>
            <t:DisplayCc/>
            <t:DisplayTo>'foo-bar-test@example.com'</t:DisplayTo>
            <t:HasAttachments>false</t:HasAttachments>
            <t:Culture>en-US</t:Culture>
            <t:Sender>
              <t:Mailbox>
                <t:Name>Lannister, Jaime</t:Name>
              </t:Mailbox>
            </t:Sender>
            <t:ConversationIndex>Acp6gIr/Ta2Ik/1+S+apI9ymV3kTuw==</t:ConversationIndex>
            <t:ConversationTopic>test</t:ConversationTopic>
            <t:From>
              <t:Mailbox>
                <t:Name>Stark, Eddard</t:Name>
              </t:Mailbox>
            </t:From>
            <t:InternetMessageId><93C802589845@example.com></t:InternetMessageId>
            <t:IsRead>true</t:IsRead>
          </t:Message>
          <t:Message>
            <t:ItemId Id="4wpPi" ChangeKey="FwAAABYA"/>
            <t:ParentFolderId Id="AQAU" ChangeKey="AQA"/>
            <t:ItemClass>REPORT.IPM.Note.NDR</t:ItemClass>
            <t:Subject>Regarding Brandon Stark</t:Subject>
            <t:Sensitivity>Normal</t:Sensitivity>
            <t:DateTimeReceived>2009-12-10T04:03:04Z</t:DateTimeReceived>
            <t:Size>5492</t:Size>
            <t:Importance>Normal</t:Importance>
            <t:IsSubmitted>false</t:IsSubmitted>
            <t:IsDraft>false</t:IsDraft>
            <t:IsFromMe>false</t:IsFromMe>
            <t:IsResend>false</t:IsResend>
            <t:IsUnmodified>true</t:IsUnmodified>
            <t:DateTimeSent>2009-12-10T04:03:04Z</t:DateTimeSent>
            <t:DateTimeCreated>2009-12-10T04:03:04Z</t:DateTimeCreated>
            <t:DisplayCc/>
            <t:DisplayTo>tyrion@example.com</t:DisplayTo>
            <t:HasAttachments>true</t:HasAttachments>
            <t:Culture>en-US</t:Culture>
            <t:Sender>
              <t:Mailbox>
                <t:Name>Tyrion Lannister</t:Name>
              </t:Mailbox>
            </t:Sender>
            <t:IsReadReceiptRequested>false</t:IsReadReceiptRequested>
            <t:IsDeliveryReceiptRequested>false</t:IsDeliveryReceiptRequested>
            <t:ConversationIndex>Acp5TaxEDBVAU</t:ConversationIndex>
            <t:ConversationTopic>Regarding Brandon Stark</t:ConversationTopic>
            <t:From>
              <t:Mailbox>
                <t:Name>Tyrion Lannister</t:Name>
              </t:Mailbox>
            </t:From>
            <t:InternetMessageId><871mi5@example.com></t:InternetMessageId>
            <t:IsRead>true</t:IsRead>
          </t:Message>
          <t:Message>
            <t:ItemId Id="AA==" ChangeKey="FwAA"/>
            <t:ParentFolderId Id="XncAAAA" ChangeKey="AQAA"/>
            <t:ItemClass>REPORT.IPM.Note.NDR</t:ItemClass>
            <t:Subject>Re: Regarding Brandon Stark</t:Subject>
            <t:Sensitivity>Normal</t:Sensitivity>
            <t:DateTimeReceived>2009-12-08T04:04:13Z</t:DateTimeReceived>
            <t:Size>5492</t:Size>
            <t:Importance>Normal</t:Importance>
            <t:IsSubmitted>false</t:IsSubmitted>
            <t:IsDraft>false</t:IsDraft>
            <t:IsFromMe>false</t:IsFromMe>
            <t:IsResend>false</t:IsResend>
            <t:IsUnmodified>true</t:IsUnmodified>
            <t:DateTimeSent>2009-12-08T04:04:13Z</t:DateTimeSent>
            <t:DateTimeCreated>2009-12-08T04:04:13Z</t:DateTimeCreated>
            <t:DisplayCc/>
            <t:DisplayTo>tyrion@example.com</t:DisplayTo>
            <t:HasAttachments>true</t:HasAttachments>
            <t:Culture>en-US</t:Culture>
            <t:Sender>
              <t:Mailbox>
                <t:Name>Tyrion Lannister</t:Name>
              </t:Mailbox>
            </t:Sender>
            <t:IsReadReceiptRequested>false</t:IsReadReceiptRequested>
            <t:IsDeliveryReceiptRequested>false</t:IsDeliveryReceiptRequested>
            <t:ConversationIndex>AcAAA7</t:ConversationIndex>
            <t:ConversationTopic>Re: Regarding Braondon Stark</t:ConversationTopic>
            <t:From>
              <t:Mailbox>
                <t:Name>Tyrion Lannister</t:Name>
              </t:Mailbox>
            </t:From>
            <t:InternetMessageId><7@example.com></t:InternetMessageId>
            <t:IsRead>true</t:IsRead>
          </t:Message>
        </t:Items>
      </m:RootFolder>
    </m:FindItemResponseMessage>
  </m:ResponseMessages>
</m:FindItemResponse>