// Copyright Aleksey Gurtovoy 2001-2004
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//

// Preprocessed version of "boost/mpl/inherit.hpp" header
// -- DO NOT modify by hand!

namespace boost { namespace mpl {

template<
      typename BOOST_MPL_AUX_NA_PARAM(T1)
    , typename BOOST_MPL_AUX_NA_PARAM(T2)
    >
struct inherit2
    : T1, T2
{
    typedef inherit2 type;
    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, inherit2, (T1, T2))
};

template< typename T1 >
struct inherit2< T1,empty_base >
{
    typedef T1 type;
    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (T1, empty_base))
};

template< typename T2 >
struct inherit2< empty_base,T2 >
{
    typedef T2 type;
    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, T2))
};

template<>
struct inherit2< empty_base,empty_base >
{
    typedef empty_base type;
    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2, inherit2, (empty_base, empty_base))
};

BOOST_MPL_AUX_NA_SPEC(2, inherit2)

template<
      typename T1 = na, typename T2 = na, typename T3 = na
    >
struct inherit3
    : inherit2<
          typename inherit2<
              T1, T2
            >::type
        , T3
        >
{
    BOOST_MPL_AUX_LAMBDA_SUPPORT(
          3
        , inherit3
        , ( T1, T2, T3)
        )
};

BOOST_MPL_AUX_NA_SPEC(3, inherit3)

template<
      typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na
    >
struct inherit4
    : inherit2<
          typename inherit3<
              T1, T2, T3
            >::type
        , T4
        >
{
    BOOST_MPL_AUX_LAMBDA_SUPPORT(
          4
        , inherit4
        , ( T1, T2, T3, T4)
        )
};

BOOST_MPL_AUX_NA_SPEC(4, inherit4)

template<
      typename T1 = na, typename T2 = na, typename T3 = na, typename T4 = na
    , typename T5 = na
    >
struct inherit5
    : inherit2<
          typename inherit4<
              T1, T2, T3, T4
            >::type
        , T5
        >
{
    BOOST_MPL_AUX_LAMBDA_SUPPORT(
          5
        , inherit5
        , ( T1, T2, T3, T4, T5)
        )
};

BOOST_MPL_AUX_NA_SPEC(5, inherit5)

/// primary template

template<
      typename T1 = empty_base, typename T2 = empty_base
    , typename T3 = empty_base, typename T4 = empty_base
    , typename T5 = empty_base
    >
struct inherit
    : inherit5< T1,T2,T3,T4,T5 >
{
};

template<>
struct inherit< na,na,na,na,na >
{
    template<

          typename T1 = empty_base, typename T2 = empty_base
        , typename T3 = empty_base, typename T4 = empty_base
        , typename T5 = empty_base

        >
    struct apply
        : inherit< T1,T2,T3,T4,T5 >
    {
    };
};

BOOST_MPL_AUX_NA_SPEC_LAMBDA(5, inherit)
BOOST_MPL_AUX_NA_SPEC_ARITY(5, inherit)
BOOST_MPL_AUX_NA_SPEC_TEMPLATE_ARITY(5, 5, inherit)
}}


<?xml version='1.0' encoding='utf-8'?>

  <num>21-2055</num>
  <heading>Permissible court orders.</heading>
  <para>
    <num>(a)</num>
    <text>The court shall exercise the authority conferred in this subchapter to encourage the development of maximum self-reliance and independence of a protected individual and make protective orders only to the extent necessitated by the protected individual’s mental and adaptive limitations and other conditions warranting the procedure.</text>
  </para>
  <para>
    <num>(b)</num>
    <text>The court has the following powers that may be exercised directly or through a conservator with respect to the estate and business affairs of a protected individual:</text>
    <para>
      <num>(1)</num>
      <text>While a petition for appointment of a conservator or other protective order is pending and after preliminary hearing and without notice to others, the court may preserve and apply the property of the individual to be protected as may be required for the support of the individual or dependents of the individual.</text>
    </para>
    <para>
      <num>(2)</num>
      <text>After hearing and upon determining that a basis for an appointment or other protective order exists with respect to an individual, the court, for the benefit of the individual and members of the individual’s immediate family, has all the powers over the estate and business affairs that the individual could exercise if present and not incapacitated, except the power to make a will. Those powers include, but are not limited to:</text>
      <para>
        <num>(A)</num>
        <text>Power to obtain medical records for purposes of application for governmental entitlements or private benefits;</text>
      </para>
      <para>
        <num>(B)</num>
        <text>Power to make gifts;</text>
      </para>
      <para>
        <num>(C)</num>
        <text>Power to convey or release contingent and expectant interests in property, including marital property rights and any right of survivorship incident to a joint tenancy or tenancy by the entirety;</text>
      </para>
      <para>
        <num>(D)</num>
        <text>Power to exercise or release powers held by the protected individual as trustee, personal representative, custodian for a minor, conservator, or donee of a power of appointment;</text>
      </para>
      <para>
        <num>(E)</num>
        <text>Power to enter into contracts;</text>
      </para>
      <para>
        <num>(F)</num>
        <text>Power to create revocable or irrevocable trusts of property of the estate that may extend beyond the incapacity or life of the protected individual;</text>
      </para>
      <para>
        <num>(G)</num>
        <text>Power to exercise options of the protected individual to purchase securities or other property;</text>
      </para>
      <para>
        <num>(H)</num>
        <text>Power to exercise rights to elect options and change beneficiaries under insurance and annuity policies and to surrender the policies for their cash value; and</text>
      </para>
      <para>
        <num>(I)</num>
        <text>Power to exercise any right to an elective share in the estate of the individual’s deceased spouse and to renounce or disclaim any interest by testate or intestate succession or by inter vivos transfer.</text>
      </para>
    </para>
  </para>
  <para>
    <num>(c)</num>
    <text>The court may exercise or direct the exercise of the following powers only if satisfied, after notice and hearing, that it is in the best interest of the protected individual and that the individual either is incapable of consenting or has consented to the proposed exercise of power:</text>
    <para>
      <num>(1)</num>
      <text>To exercise or release powers of appointment of which the protected individual is donee;</text>
    </para>
    <para>
      <num>(2)</num>
      <text>To renounce or disclaim interests;</text>
    </para>
    <para>
      <num>(3)</num>
      <text>To make gifts in trust or otherwise exceeding 20% of any year’s income of the estate; and</text>
    </para>
    <para>
      <num>(4)</num>
      <text>To change beneficiaries under insurance and annuity policies.</text>
    </para>
  </para>
  <annotations>
    <annotation doc="D.C. Law 6-204" type="History">Feb. 28, 1987, D.C. Law 6-204, § 2(a), 34 DCR 632</annotation>
    <annotation type="Prior Codifications">Uniform Law: This section is based upon § 2-307 of the Uniform Guardianship and Protective Proceedings Act (1982 Act).</annotation>
    <annotation type="Prior Codifications">1981 Ed., § 21-2055.</annotation>
    <annotation type="Section References">This section is referenced in § 21-2011, § 21-2069, § 21-2071, and § 21-2072.</annotation>
  </annotations>


/*
 * Copyright (c) 2013, 2016, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * COPYRIGHT AND PERMISSION NOTICE
 *
 * Copyright (C) 1991-2016 Unicode, Inc. All rights reserved.
 * Distributed under the Terms of Use in
 * http://www.unicode.org/copyright.html.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of the Unicode data files and any associated documentation
 * (the "Data Files") or Unicode software and any associated documentation
 * (the "Software") to deal in the Data Files or Software
 * without restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, and/or sell copies of
 * the Data Files or Software, and to permit persons to whom the Data Files
 * or Software are furnished to do so, provided that
 * (a) this copyright and permission notice appear with all copies
 * of the Data Files or Software,
 * (b) this copyright and permission notice appear in associated
 * documentation, and
 * (c) there is clear notice in each modified Data File or in the Software
 * as well as in the documentation associated with the Data File(s) or
 * Software that the data or software has been modified.
 *
 * THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
 * ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT OF THIRD PARTY RIGHTS.
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
 * NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
 * DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 * PERFORMANCE OF THE DATA FILES OR SOFTWARE.
 *
 * Except as contained in this notice, the name of a copyright holder
 * shall not be used in advertising or otherwise to promote the sale,
 * use or other dealings in these Data Files or Software without prior
 * written authorization of the copyright holder.
 */

//  Note: this file has been generated by a tool.

package sun.text.resources.ext;

import sun.util.resources.OpenListResourceBundle;

public class JavaTimeSupplementary_sr_Latn extends OpenListResourceBundle {
    @Override
    protected final Object[][] getContents() {
        final String[] sharedQuarterAbbreviations = {
            "K1",
            "K2",
            "K3",
            "K4",
        };

        final String[] sharedQuarterNames = {
            "prvi kvartal",
            "drugi kvartal",
            "tre\u0107i kvartal",
            "\u010detvrti kvartal",
        };

        final String[] sharedAmPmMarkers = {
            "pre podne",
            "po podne",
        };

        final String[] sharedDayAbbreviations = {
            "ned",
            "pon",
            "uto",
            "sre",
            "\u010det",
            "pet",
            "sub",
        };

        final String[] sharedDayNames = {
            "nedelja",
            "ponedeljak",
            "utorak",
            "sreda",
            "\u010detvrtak",
            "petak",
            "subota",
        };

        final String[] sharedDayNarrows = {
            "n",
            "p",
            "u",
            "s",
            "\u010d",
            "p",
            "s",
        };

        final String[] sharedEras = {
            "",
            "AH",
        };

        final String[] sharedJavaTimeLongEras = {
            "BC",
            "BE",
        };

        final String[] sharedShortEras = {
            "Pre RK",
            "RK",
        };

        return new Object[][] {
            { "QuarterAbbreviations",
                sharedQuarterAbbreviations },
            { "QuarterNames",
                sharedQuarterNames },
            { "calendarname.buddhist",
                "budisti\u010dki kalendar" },
            { "calendarname.gregorian",
                "gregorijanski kalendar" },
            { "calendarname.gregory",
                "gregorijanski kalendar" },
            { "calendarname.islamic",
                "islamski kalendar" },
            { "calendarname.islamic-civil",
                "Islamski civilni kalendar" },
            { "calendarname.japanese",
                "japanski kalendar" },
            { "calendarname.roc",
                "kalendar Republike Kine" },
            { "field.dayperiod",
                "pre podne/po podne" },
            { "field.era",
                "era" },
            { "field.hour",
                "sat" },
            { "field.minute",
                "minut" },
            { "field.month",
                "mesec" },
            { "field.second",
                "sekund" },
            { "field.week",
                "nedelja" },
            { "field.weekday",
                "dan u nedelji" },
            { "field.year",
                "godina" },
            { "field.zone",
                "vremenska zona" },
            { "islamic.AmPmMarkers",
                sharedAmPmMarkers },
            { "islamic.DayAbbreviations",
                sharedDayAbbreviations },
            { "islamic.DayNames",
                sharedDayNames },
            { "islamic.DayNarrows",
                sharedDayNarrows },
            { "islamic.Eras",
                sharedEras },
            { "islamic.MonthNames",
                new String[] {
                    "Muraham",
                    "Safar",
                    "Rabi\u02bb I",
                    "Rabi\u02bb II",
                    "Jumada I",
                    "Jumada II",
                    "Ra\u0111ab",
                    "\u0160a\u02bbban",
                    "Ramadan",
                    "\u0160aval",
                    "Du\u02bbl-Ki\u02bbda",
                    "Du\u02bbl-hi\u0111a",
                    "",
                }
            },
            { "islamic.QuarterAbbreviations",
                sharedQuarterAbbreviations },
            { "islamic.QuarterNames",
                sharedQuarterNames },
            { "islamic.abbreviated.AmPmMarkers",
                sharedAmPmMarkers },
            { "islamic.long.Eras",
                sharedEras },
            { "islamic.narrow.Eras",
                sharedEras },
            { "islamic.short.Eras",
                sharedEras },
            { "java.time.buddhist.long.Eras",
                sharedJavaTimeLongEras },
            { "java.time.buddhist.short.Eras",
                sharedJavaTimeLongEras },
            { "java.time.japanese.long.Eras",
                new String[] {
                    "nove ere",
                    "Mei\u0111i",
                    "Tai\u0161o",
                    "\u0160ova",
                    "Haisei",
                }
            },
            { "java.time.japanese.short.Eras",
                new String[] {
                    "n. e.",
                    "Mei\u0111i",
                    "Tai\u0161o",
                    "\u0160ova",
                    "Haisei",
                }
            },
            { "java.time.long.Eras",
                new String[] {
                    "pre nove ere",
                    "nove ere",
                }
            },
            { "java.time.short.Eras",
                new String[] {
                    "p. n. e.",
                    "n. e",
                }
            },
            { "roc.AmPmMarkers",
                sharedAmPmMarkers },
            { "roc.DayAbbreviations",
                sharedDayAbbreviations },
            { "roc.DayNames",
                sharedDayNames },
            { "roc.DayNarrows",
                sharedDayNarrows },
            { "roc.Eras",
                sharedShortEras },
            { "roc.MonthAbbreviations",
                new String[] {
                    "jan",
                    "feb",
                    "mar",
                    "apr",
                    "maj",
                    "jun",
                    "jul",
                    "avg",
                    "sep",
                    "okt",
                    "nov",
                    "dec",
                    "",
                }
            },
            { "roc.MonthNames",
                new String[] {
                    "januar",
                    "februar",
                    "mart",
                    "april",
                    "maj",
                    "jun",
                    "jul",
                    "avgust",
                    "septembar",
                    "oktobar",
                    "novembar",
                    "decembar",
                    "",
                }
            },
            { "roc.MonthNarrows",
                new String[] {
                    "j",
                    "f",
                    "m",
                    "a",
                    "m",
                    "j",
                    "j",
                    "a",
                    "s",
                    "o",
                    "n",
                    "d",
                    "",
                }
            },
            { "roc.QuarterAbbreviations",
                sharedQuarterAbbreviations },
            { "roc.QuarterNames",
                sharedQuarterNames },
            { "roc.abbreviated.AmPmMarkers",
                sharedAmPmMarkers },
            { "roc.long.Eras",
                sharedShortEras },
            { "roc.narrow.Eras",
                sharedShortEras },
            { "roc.short.Eras",
                sharedShortEras },
        };
    }
}


<% include menu/item %>


namespace Touch
{
	[global::Foundation.Register ("AppDelegate")]
	public partial class AppDelegate
	{
	}
}


# Maintainer: Alexey Pavlov <alexpux@gmail.com>

_realname=leptonica
pkgbase=mingw-w64-${_realname}
pkgname=("${MINGW_PACKAGE_PREFIX}-${_realname}")
pkgver=1.80.0
pkgrel=1
pkgdesc="Leptonica library (mingw-w64)"
arch=('any')
url="http://www.leptonica.org"
license=("Leptonica")
makedepends=("${MINGW_PACKAGE_PREFIX}-gcc" "${MINGW_PACKAGE_PREFIX}-pkg-config")
checkdepends=("${MINGW_PACKAGE_PREFIX}-gnuplot")
depends=(${MINGW_PACKAGE_PREFIX}-gcc-libs
         ${MINGW_PACKAGE_PREFIX}-giflib
         ${MINGW_PACKAGE_PREFIX}-libtiff
         ${MINGW_PACKAGE_PREFIX}-libpng
         ${MINGW_PACKAGE_PREFIX}-libwebp
         ${MINGW_PACKAGE_PREFIX}-openjpeg2
         ${MINGW_PACKAGE_PREFIX}-zlib)
options=('!libtool' 'strip')
source=(https://github.com/DanBloomberg/leptonica/releases/download/${pkgver}/${_realname}-${pkgver}.tar.gz)
sha256sums=('ec9c46c2aefbb960fb6a6b7f800fe39de48343437b6ce08e30a8d9688ed14ba4')

prepare() {
  cd "${srcdir}/${_realname}-${pkgver}"
}

build() {
  [[ -d "${srcdir}/build-${CARCH}" ]] && rm -rf "${srcdir}/build-${CARCH}"
  mkdir -p "${srcdir}/build-${CARCH}" && cd "${srcdir}/build-${CARCH}"
  CFLAGS+=" -DMINIMUM_SEVERITY=L_SEVERITY_WARNING"
  ../${_realname}-${pkgver}/configure -C \
    --disable-dependency-tracking \
    --disable-silent-rules \
    --build=${MINGW_CHOST} \
    --host=${MINGW_CHOST} \
    --target=${MINGW_CHOST} \
    --prefix=${MINGW_PREFIX}
  make
}

check() {
  cd "${srcdir}/build-${CARCH}"
  make -j1 check
}

package() {
  cd "${srcdir}/build-${CARCH}"
  make DESTDIR="${pkgdir}" install

  # Fix .pc file
  sed -s "s|$(cygpath -m ${MINGW_PREFIX})|${MINGW_PREFIX}|g" -i "${pkgdir}${MINGW_PREFIX}"/lib/pkgconfig/lept.pc
}


<resources>
    <dimen name="fab_margin">16dp</dimen>
</resources>


//
//  TADotView.h
//  TAPageControl
//
//  Created by Tanguy Aladenise on 2015-01-22.
//  Copyright (c) 2015 Tanguy Aladenise. All rights reserved.
//

#import "TAAbstractDotView.h"

@interface TADotView : TAAbstractDotView

@end


Select2 is a jQuery based replacement for select boxes.


Copyright (c) 2007. Clarius Consulting, Manas Technology Solutions, InSTEDD
http://code.google.com/p/moq/
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 Clarius Consulting, Manas Technology Solutions or InSTEDD 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 THE COPYRIGHT OWNER OR
CONTRIBUTORS 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.

[This is the BSD license, see
 http://www.opensource.org/licenses/bsd-license.php]


## PeterO.Cbor.ICBORToFromConverter<T>

    public interface ICBORToFromConverter<T> :
        PeterO.Cbor.ICBORConverter<T>

Classes that implement this interface can support conversions from CBOR objects to a custom type and back.

### Member Summary
* [FromCBORObject(PeterO.Cbor.CBORObject)](#FromCBORObject_PeterO_Cbor_CBORObject) - Converts a CBOR object to a custom type.

Parameters:

 * <T>: Type of objects to convert to and from CBOR objects.

### FromCBORObject

    T FromCBORObject(
        PeterO.Cbor.CBORObject obj);

Converts a CBOR object to a custom type.

Parameters:

 * obj: A CBOR object to convert to the custom type.

Return Value:

An object of the custom type after conversion.


TIMESERIES XX_TEST__BHZ_R, 12 samples, 40 sps, 2008-01-15T00:00:00.025000, SLIST, FLOAT, Counts
+1.8500999450e+02	+1.8102000430e+02	+1.8502999880e+02	+1.8903999330e+02	+1.9405000310e+02	+2.0505999760e+02
+2.0907000730e+02	+2.1408000180e+02	+2.2208999630e+02	+2.2597999570e+02	+2.2699000550e+02	+2.1900000000e+02


// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package simplifiedchinese

import (
	"unicode/utf8"

	"golang.org/x/text/encoding"
	"golang.org/x/text/encoding/internal"
	"golang.org/x/text/encoding/internal/identifier"
	"golang.org/x/text/transform"
)

var (
	// GB18030 is the GB18030 encoding.
	GB18030 encoding.Encoding = &gbk18030
	// GBK is the GBK encoding. It encodes an extension of the GB2312 character set
	// and is also known as Code Page 936.
	GBK encoding.Encoding = &gbk
)

var gbk = internal.Encoding{
	&internal.SimpleEncoding{
		gbkDecoder{gb18030: false},
		gbkEncoder{gb18030: false},
	},
	"GBK",
	identifier.GBK,
}

var gbk18030 = internal.Encoding{
	&internal.SimpleEncoding{
		gbkDecoder{gb18030: true},
		gbkEncoder{gb18030: true},
	},
	"GB18030",
	identifier.GB18030,
}

type gbkDecoder struct {
	transform.NopResetter
	gb18030 bool
}

func (d gbkDecoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	r, size := rune(0), 0
loop:
	for ; nSrc < len(src); nSrc += size {
		switch c0 := src[nSrc]; {
		case c0 < utf8.RuneSelf:
			r, size = rune(c0), 1

		// Microsoft's Code Page 936 extends GBK 1.0 to encode the euro sign U+20AC
		// as 0x80. The HTML5 specification at http://encoding.spec.whatwg.org/#gbk
		// says to treat "gbk" as Code Page 936.
		case c0 == 0x80:
			r, size = '€', 1

		case c0 < 0xff:
			if nSrc+1 >= len(src) {
				if !atEOF {
					err = transform.ErrShortSrc
					break loop
				}
				r, size = utf8.RuneError, 1
				goto write
			}
			c1 := src[nSrc+1]
			switch {
			case 0x40 <= c1 && c1 < 0x7f:
				c1 -= 0x40
			case 0x80 <= c1 && c1 < 0xff:
				c1 -= 0x41
			case d.gb18030 && 0x30 <= c1 && c1 < 0x40:
				if nSrc+3 >= len(src) {
					if !atEOF {
						err = transform.ErrShortSrc
						break loop
					}
					// The second byte here is always ASCII, so we can set size
					// to 1 in all cases.
					r, size = utf8.RuneError, 1
					goto write
				}
				c2 := src[nSrc+2]
				if c2 < 0x81 || 0xff <= c2 {
					r, size = utf8.RuneError, 1
					goto write
				}
				c3 := src[nSrc+3]
				if c3 < 0x30 || 0x3a <= c3 {
					r, size = utf8.RuneError, 1
					goto write
				}
				size = 4
				r = ((rune(c0-0x81)*10+rune(c1-0x30))*126+rune(c2-0x81))*10 + rune(c3-0x30)
				if r < 39420 {
					i, j := 0, len(gb18030)
					for i < j {
						h := i + (j-i)/2
						if r >= rune(gb18030[h][0]) {
							i = h + 1
						} else {
							j = h
						}
					}
					dec := &gb18030[i-1]
					r += rune(dec[1]) - rune(dec[0])
					goto write
				}
				r -= 189000
				if 0 <= r && r < 0x100000 {
					r += 0x10000
				} else {
					r, size = utf8.RuneError, 1
				}
				goto write
			default:
				r, size = utf8.RuneError, 1
				goto write
			}
			r, size = '\ufffd', 2
			if i := int(c0-0x81)*190 + int(c1); i < len(decode) {
				r = rune(decode[i])
				if r == 0 {
					r = '\ufffd'
				}
			}

		default:
			r, size = utf8.RuneError, 1
		}

	write:
		if nDst+utf8.RuneLen(r) > len(dst) {
			err = transform.ErrShortDst
			break loop
		}
		nDst += utf8.EncodeRune(dst[nDst:], r)
	}
	return nDst, nSrc, err
}

type gbkEncoder struct {
	transform.NopResetter
	gb18030 bool
}

func (e gbkEncoder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
	r, r2, size := rune(0), rune(0), 0
	for ; nSrc < len(src); nSrc += size {
		r = rune(src[nSrc])

		// Decode a 1-byte rune.
		if r < utf8.RuneSelf {
			size = 1

		} else {
			// Decode a multi-byte rune.
			r, size = utf8.DecodeRune(src[nSrc:])
			if size == 1 {
				// All valid runes of size 1 (those below utf8.RuneSelf) were
				// handled above. We have invalid UTF-8 or we haven't seen the
				// full character yet.
				if !atEOF && !utf8.FullRune(src[nSrc:]) {
					err = transform.ErrShortSrc
					break
				}
			}

			// func init checks that the switch covers all tables.
			switch {
			case encode0Low <= r && r < encode0High:
				if r2 = rune(encode0[r-encode0Low]); r2 != 0 {
					goto write2
				}
			case encode1Low <= r && r < encode1High:
				// Microsoft's Code Page 936 extends GBK 1.0 to encode the euro sign U+20AC
				// as 0x80. The HTML5 specification at http://encoding.spec.whatwg.org/#gbk
				// says to treat "gbk" as Code Page 936.
				if r == '€' {
					r = 0x80
					goto write1
				}
				if r2 = rune(encode1[r-encode1Low]); r2 != 0 {
					goto write2
				}
			case encode2Low <= r && r < encode2High:
				if r2 = rune(encode2[r-encode2Low]); r2 != 0 {
					goto write2
				}
			case encode3Low <= r && r < encode3High:
				if r2 = rune(encode3[r-encode3Low]); r2 != 0 {
					goto write2
				}
			case encode4Low <= r && r < encode4High:
				if r2 = rune(encode4[r-encode4Low]); r2 != 0 {
					goto write2
				}
			}

			if e.gb18030 {
				if r < 0x10000 {
					i, j := 0, len(gb18030)
					for i < j {
						h := i + (j-i)/2
						if r >= rune(gb18030[h][1]) {
							i = h + 1
						} else {
							j = h
						}
					}
					dec := &gb18030[i-1]
					r += rune(dec[0]) - rune(dec[1])
					goto write4
				} else if r < 0x110000 {
					r += 189000 - 0x10000
					goto write4
				}
			}
			err = internal.ErrASCIIReplacement
			break
		}

	write1:
		if nDst >= len(dst) {
			err = transform.ErrShortDst
			break
		}
		dst[nDst] = uint8(r)
		nDst++
		continue

	write2:
		if nDst+2 > len(dst) {
			err = transform.ErrShortDst
			break
		}
		dst[nDst+0] = uint8(r2 >> 8)
		dst[nDst+1] = uint8(r2)
		nDst += 2
		continue

	write4:
		if nDst+4 > len(dst) {
			err = transform.ErrShortDst
			break
		}
		dst[nDst+3] = uint8(r%10 + 0x30)
		r /= 10
		dst[nDst+2] = uint8(r%126 + 0x81)
		r /= 126
		dst[nDst+1] = uint8(r%10 + 0x30)
		r /= 10
		dst[nDst+0] = uint8(r + 0x81)
		nDst += 4
		continue
	}
	return nDst, nSrc, err
}

func init() {
	// Check that the hard-coded encode switch covers all tables.
	if numEncodeTables != 5 {
		panic("bad numEncodeTables")
	}
}


<!--
  ~ Copyright 2017 Crown Copyright
  ~
  ~ 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.
  -->

<module>
    <!-- Inherit the core Web Toolkit stuff. -->
    <inherits name='com.google.gwt.user.User'/>

    <inherits name='com.google.gwt.json.JSON'/>
    <inherits name="javax.validation.Validation"/>

    <inherits name='io.swagger.Swagger'/>

    <inherits name="stroom.query.Query"/>
    <inherits name="stroom.datasource.DataSource"/>
    <inherits name="stroom.script.Script"/>
    <inherits name="stroom.visualisation.Visualisation"/>

    <source path="client"/>
    <source path="shared"/>
</module>


// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// +build !gccgo

#include "textflag.h"

//
// System call support for ARM, NetBSD
//

// Just jump to package syscall's implementation for all these functions.
// The runtime may know about them.

TEXT	·Syscall(SB),NOSPLIT,$0-28
	B	syscall·Syscall(SB)

TEXT	·Syscall6(SB),NOSPLIT,$0-40
	B	syscall·Syscall6(SB)

TEXT	·Syscall9(SB),NOSPLIT,$0-52
	B	syscall·Syscall9(SB)

TEXT	·RawSyscall(SB),NOSPLIT,$0-28
	B	syscall·RawSyscall(SB)

TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
	B	syscall·RawSyscall6(SB)


//===-- AssemblerUtils.h ----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_UNITTESTS_TOOLS_LLVMEXEGESIS_ASSEMBLERUTILS_H
#define LLVM_UNITTESTS_TOOLS_LLVMEXEGESIS_ASSEMBLERUTILS_H

#include "Assembler.h"
#include "BenchmarkRunner.h"
#include "Target.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/CodeGen/MachineInstrBuilder.h"
#include "llvm/CodeGen/TargetInstrInfo.h"
#include "llvm/CodeGen/TargetSubtargetInfo.h"
#include "llvm/MC/MCInstBuilder.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/TargetRegistry.h"
#include "llvm/Support/TargetSelect.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

namespace llvm {
namespace exegesis {

class MachineFunctionGeneratorBaseTest : public ::testing::Test {
protected:
  MachineFunctionGeneratorBaseTest(const std::string &TT,
                                   const std::string &CpuName)
      : TT(TT), CpuName(CpuName),
        CanExecute(llvm::Triple(TT).getArch() ==
                   llvm::Triple(llvm::sys::getProcessTriple()).getArch()),
        ET(ExegesisTarget::lookup(llvm::Triple(TT))) {
    assert(ET);
    if (!CanExecute) {
      llvm::outs() << "Skipping execution, host:"
                   << llvm::sys::getProcessTriple() << ", target:" << TT
                   << "\n";
    }
  }

  template <class... Bs>
  inline void Check(llvm::ArrayRef<RegisterValue> RegisterInitialValues,
                    llvm::MCInst MCInst, Bs... Bytes) {
    ExecutableFunction Function =
        (MCInst.getOpcode() == 0)
            ? assembleToFunction(RegisterInitialValues, {})
            : assembleToFunction(RegisterInitialValues, {MCInst});
    ASSERT_THAT(Function.getFunctionBytes().str(),
                testing::ElementsAre(Bytes...));
    if (CanExecute) {
      BenchmarkRunner::ScratchSpace Scratch;
      Function(Scratch.ptr());
    }
  }

private:
  std::unique_ptr<llvm::LLVMTargetMachine> createTargetMachine() {
    std::string Error;
    const llvm::Target *TheTarget =
        llvm::TargetRegistry::lookupTarget(TT, Error);
    EXPECT_TRUE(TheTarget) << Error << " " << TT;
    const llvm::TargetOptions Options;
    llvm::TargetMachine *TM = TheTarget->createTargetMachine(
        TT, CpuName, "", Options, llvm::Reloc::Model::Static);
    EXPECT_TRUE(TM) << TT << " " << CpuName;
    return std::unique_ptr<llvm::LLVMTargetMachine>(
        static_cast<llvm::LLVMTargetMachine *>(TM));
  }

  ExecutableFunction
  assembleToFunction(llvm::ArrayRef<RegisterValue> RegisterInitialValues,
                     llvm::ArrayRef<llvm::MCInst> Instructions) {
    llvm::SmallString<256> Buffer;
    llvm::raw_svector_ostream AsmStream(Buffer);
    assembleToStream(*ET, createTargetMachine(), /*LiveIns=*/{},
                     RegisterInitialValues, Instructions, AsmStream);
    return ExecutableFunction(createTargetMachine(),
                              getObjectFromBuffer(AsmStream.str()));
  }

  const std::string TT;
  const std::string CpuName;
  const bool CanExecute;
  const ExegesisTarget *const ET;
};

} // namespace exegesis
} // namespace llvm

#endif


//
//  AxcSemiModalPresentView.m
//  AxcUIKit
//
//  Created by Axc on 2017/6/4.
//  Copyright © 2017年 Axc_5324. All rights reserved.
//

#import "AxcSemiModalPresentView.h"
#import <Masonry.h>
#import "AxcUIKit.h"

#define imageURL @"http://img.zcool.cn/community/01a39157a980340000012e7e022368.jpg@900w_1l_2o_100sh.jpg"

@implementation AxcSemiModalPresentView

- (instancetype)initWithFrame:(CGRect)frame{
    if (self == [super initWithFrame:frame]) {
        [self createUI];
    }
    return self;
}

- (void)createUI{
//    __weak typeof(self) WeakSelf = self;
    [self.testLabel mas_makeConstraints:^(MASConstraintMaker *make) {
        make.left.mas_equalTo(0);
        make.right.mas_equalTo(0);
        make.centerY.mas_equalTo(0);
        make.height.mas_equalTo(40);
    }];
    [self.imageView mas_makeConstraints:^(MASConstraintMaker *make) {
        make.top.mas_equalTo(10);
        make.right.mas_equalTo(-10);
        make.width.mas_equalTo(100);
        make.height.mas_equalTo(100);
    }];
    [self.imageView AxcUI_setImageWithURL:imageURL
                         placeholderImage:@"placeholder.jpg"];

}

- (UILabel *)testLabel{
    if (!_testLabel) {
        _testLabel = [[UILabel alloc] init];
        _testLabel.text = @"测试推出的文字";
        _testLabel.textColor = [UIColor whiteColor];
        _testLabel.textAlignment = NSTextAlignmentCenter;
        [self addSubview:_testLabel];
    }
    return _testLabel;
}

- (UIImageView *)imageView{
    if (!_imageView) {
        _imageView = [[UIImageView alloc] init];
        _imageView.contentMode = UIViewContentModeScaleAspectFit;
        [self addSubview: _imageView];
    }
    return _imageView;
}

@end


/* This is part of the netCDF package. Copyright 2018 University
   Corporation for Atmospheric Research/Unidata See COPYRIGHT file for
   conditions of use. See www.unidata.ucar.edu for more info.

   Utility to rename a group
*/

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#ifndef LOGGING
#define LOGGING
#endif
#include "netcdf.h"

#undef RENAME_DEBUG

static void
usage(const char* msg)
{
    if(msg != NULL)
	fprintf(stderr,"%s\n",msg);
    fprintf(stderr,"usage: renamegroup <filename> <old group path name> <new name>\n");
    fflush(stderr);
    exit(0); /* do not cause error */
}

static void
check(int status)
{
    if(status == 0) return;
    fprintf(stderr,"%d: %s\n",status,nc_strerror(status));
    fflush(stderr);
    exit(1);
}

int
main(int argc, char **argv)
{
    int stat;
    int ncid, grpid;
    char* filename;
    char* oldname;
    char* newname;

    switch (argc) {
    case 0:
    case 1:
        usage("No arguments");
	break;
    case 2:
        usage("Too few arguments");
	break;
    case 3:
    default:
	filename = argv[1];
	oldname = argv[2];
	newname = argv[3];
	break;
    }

    if(strlen(filename) == 0)
	usage("bad filename argument");
    if(strlen(oldname) == 0)
	usage("bad old name argument");
    if(strlen(newname) == 0)
	usage("bad new name argument");

    stat = nc_open(filename,NC_WRITE,&ncid);
    check(stat);

#ifdef RENAME_DEBUG
    stat = nc_set_log_level(0);
    check(stat);
    nc_log_hdf5();
#endif

    stat = nc_inq_grp_full_ncid(ncid,oldname,&grpid);
    check(stat);

    stat = nc_rename_grp(grpid,newname);
    check(stat);

    stat = nc_close(ncid);
    check(stat);

    exit(0);
}


import React from 'react';
import Layout from './Layout';
import SideMenu from './Menu/SideMenu';
import PureArticle from './Content/PureArticle';

export default function Article(props) {
  const pageData = props.pageData;
  return <Layout route={props.route}>

        <SideMenu
          type="articles"
          defaultSelectedKey={props.routeParams.doc}
          data={props.data}
        />

        <PureArticle pageData={pageData} utils={props.utils}/>

  </Layout>;
}


=pod

=for comment openssl_manual_section:7

=head1 NAME

des_modes - the variants of DES and other crypto algorithms of OpenSSL

=head1 DESCRIPTION

Several crypto algorithms for OpenSSL can be used in a number of modes.  Those
are used for using block ciphers in a way similar to stream ciphers, among
other things.

=head1 OVERVIEW

=head2 Electronic Codebook Mode (ECB)

Normally, this is found as the function I<algorithm>_ecb_encrypt().

=over 2

=item *

64 bits are enciphered at a time.

=item *

The order of the blocks can be rearranged without detection.

=item *

The same plaintext block always produces the same ciphertext block
(for the same key) making it vulnerable to a 'dictionary attack'.

=item *

An error will only affect one ciphertext block.

=back

=head2 Cipher Block Chaining Mode (CBC)

Normally, this is found as the function I<algorithm>_cbc_encrypt().
Be aware that des_cbc_encrypt() is not really DES CBC (it does
not update the IV); use des_ncbc_encrypt() instead.

=over 2

=item *

a multiple of 64 bits are enciphered at a time.

=item *

The CBC mode produces the same ciphertext whenever the same
plaintext is encrypted using the same key and starting variable.

=item *

The chaining operation makes the ciphertext blocks dependent on the
current and all preceding plaintext blocks and therefore blocks can not
be rearranged.

=item *

The use of different starting variables prevents the same plaintext
enciphering to the same ciphertext.

=item *

An error will affect the current and the following ciphertext blocks.

=back

=head2 Cipher Feedback Mode (CFB)

Normally, this is found as the function I<algorithm>_cfb_encrypt().

=over 2

=item *

a number of bits (j) <= 64 are enciphered at a time.

=item *

The CFB mode produces the same ciphertext whenever the same
plaintext is encrypted using the same key and starting variable.

=item *

The chaining operation makes the ciphertext variables dependent on the
current and all preceding variables and therefore j-bit variables are
chained together and can not be rearranged.

=item *

The use of different starting variables prevents the same plaintext
enciphering to the same ciphertext.

=item *

The strength of the CFB mode depends on the size of k (maximal if
j == k).  In my implementation this is always the case.

=item *

Selection of a small value for j will require more cycles through
the encipherment algorithm per unit of plaintext and thus cause
greater processing overheads.

=item *

Only multiples of j bits can be enciphered.

=item *

An error will affect the current and the following ciphertext variables.

=back

=head2 Output Feedback Mode (OFB)

Normally, this is found as the function I<algorithm>_ofb_encrypt().

=over 2

=item *

a number of bits (j) <= 64 are enciphered at a time.

=item *

The OFB mode produces the same ciphertext whenever the same
plaintext enciphered using the same key and starting variable.  More
over, in the OFB mode the same key stream is produced when the same
key and start variable are used.  Consequently, for security reasons
a specific start variable should be used only once for a given key.

=item *

The absence of chaining makes the OFB more vulnerable to specific attacks.

=item *

The use of different start variables values prevents the same
plaintext enciphering to the same ciphertext, by producing different
key streams.

=item *

Selection of a small value for j will require more cycles through
the encipherment algorithm per unit of plaintext and thus cause
greater processing overheads.

=item *

Only multiples of j bits can be enciphered.

=item *

OFB mode of operation does not extend ciphertext errors in the
resultant plaintext output.  Every bit error in the ciphertext causes
only one bit to be in error in the deciphered plaintext.

=item *

OFB mode is not self-synchronizing.  If the two operation of
encipherment and decipherment get out of synchronism, the system needs
to be re-initialized.

=item *

Each re-initialization should use a value of the start variable
different from the start variable values used before with the same
key.  The reason for this is that an identical bit stream would be
produced each time from the same parameters.  This would be
susceptible to a 'known plaintext' attack.

=back

=head2 Triple ECB Mode

Normally, this is found as the function I<algorithm>_ecb3_encrypt().

=over 2

=item *

Encrypt with key1, decrypt with key2 and encrypt with key3 again.

=item *

As for ECB encryption but increases the key length to 168 bits.
There are theoretic attacks that can be used that make the effective
key length 112 bits, but this attack also requires 2^56 blocks of
memory, not very likely, even for the NSA.

=item *

If both keys are the same it is equivalent to encrypting once with
just one key.

=item *

If the first and last key are the same, the key length is 112 bits.
There are attacks that could reduce the effective key strength
to only slightly more than 56 bits, but these require a lot of memory.

=item *

If all 3 keys are the same, this is effectively the same as normal
ecb mode.

=back

=head2 Triple CBC Mode

Normally, this is found as the function I<algorithm>_ede3_cbc_encrypt().

=over 2

=item *

Encrypt with key1, decrypt with key2 and then encrypt with key3.

=item *

As for CBC encryption but increases the key length to 168 bits with
the same restrictions as for triple ecb mode.

=back

=head1 NOTES

This text was been written in large parts by Eric Young in his original
documentation for SSLeay, the predecessor of OpenSSL.  In turn, he attributed
it to:

	AS 2805.5.2
	Australian Standard
	Electronic funds transfer - Requirements for interfaces,
	Part 5.2: Modes of operation for an n-bit block cipher algorithm
	Appendix A

=head1 SEE ALSO

L<blowfish(3)|blowfish(3)>, L<des(3)|des(3)>, L<idea(3)|idea(3)>,
L<rc2(3)|rc2(3)>

=cut


var convert = require('./convert'),
    func = convert('invoke', require('../invoke'));

func.placeholder = require('./placeholder');
module.exports = func;


<?xml version="1.0"?>
<ZopeData>
  <record id="1" aka="AAAAAAAAAAE=">
    <pickle>
      <global name="ProxyField" module="Products.ERP5Form.ProxyField"/>
    </pickle>
    <pickle>
      <dictionary>
        <item>
            <key> <string>delegated_list</string> </key>
            <value>
              <list/>
            </value>
        </item>
        <item>
            <key> <string>id</string> </key>
            <value> <string>my_max_delay</string> </value>
        </item>
        <item>
            <key> <string>message_values</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>external_validator_failed</string> </key>
                    <value> <string>The input failed the external validator.</string> </value>
                </item>
              </dictionary>
            </value>
        </item>
        <item>
            <key> <string>overrides</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>field_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>form_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>target</string> </key>
                    <value> <string></string> </value>
                </item>
              </dictionary>
            </value>
        </item>
        <item>
            <key> <string>tales</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>field_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>form_id</string> </key>
                    <value> <string></string> </value>
                </item>
                <item>
                    <key> <string>target</string> </key>
                    <value> <string></string> </value>
                </item>
              </dictionary>
            </value>
        </item>
        <item>
            <key> <string>values</string> </key>
            <value>
              <dictionary>
                <item>
                    <key> <string>field_id</string> </key>
                    <value> <string>my_max_delay</string> </value>
                </item>
                <item>
                    <key> <string>form_id</string> </key>
                    <value> <string>Base_viewPDMFieldLibrary</string> </value>
                </item>
                <item>
                    <key> <string>target</string> </key>
                    <value> <string>Click to edit the target</string> </value>
                </item>
              </dictionary>
            </value>
        </item>
      </dictionary>
    </pickle>
  </record>
</ZopeData>


// Boost.Geometry Index
//
// R-tree deep copying visitor implementation
//
// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
//
// This file was modified by Oracle on 2019.
// Modifications copyright (c) 2019 Oracle and/or its affiliates.
// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
//
// Use, modification and distribution is subject to the Boost Software License,
// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP
#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP

#include <boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp>

namespace boost { namespace geometry { namespace index {

namespace detail { namespace rtree { namespace visitors {

template <typename MembersHolder>
class copy
    : public MembersHolder::visitor
{
    typedef typename MembersHolder::allocators_type allocators_type;

    typedef typename MembersHolder::node node;
    typedef typename MembersHolder::internal_node internal_node;
    typedef typename MembersHolder::leaf leaf;

    typedef rtree::subtree_destroyer<MembersHolder> subtree_destroyer;
    typedef typename allocators_type::node_pointer node_pointer;

public:
    explicit inline copy(allocators_type & allocators)
        : result(0)
        , m_allocators(allocators)
    {}

    inline void operator()(internal_node & n)
    {
        node_pointer raw_new_node = rtree::create_node<allocators_type, internal_node>::apply(m_allocators);      // MAY THROW, STRONG (N: alloc)
        subtree_destroyer new_node(raw_new_node, m_allocators);

        typedef typename rtree::elements_type<internal_node>::type elements_type;
        elements_type & elements = rtree::elements(n);

        elements_type & elements_dst = rtree::elements(rtree::get<internal_node>(*new_node));

        for (typename elements_type::iterator it = elements.begin();
            it != elements.end(); ++it)
        {
            rtree::apply_visitor(*this, *it->second);                                                   // MAY THROW (V, E: alloc, copy, N: alloc)

            // for exception safety
            subtree_destroyer auto_result(result, m_allocators);

            elements_dst.push_back( rtree::make_ptr_pair(it->first, result) );                          // MAY THROW, STRONG (E: alloc, copy)

            auto_result.release();
        }

        result = new_node.get();
        new_node.release();
    }

    inline void operator()(leaf & l)
    {
        node_pointer raw_new_node = rtree::create_node<allocators_type, leaf>::apply(m_allocators);                // MAY THROW, STRONG (N: alloc)
        subtree_destroyer new_node(raw_new_node, m_allocators);

        typedef typename rtree::elements_type<leaf>::type elements_type;
        elements_type & elements = rtree::elements(l);

        elements_type & elements_dst = rtree::elements(rtree::get<leaf>(*new_node));

        for (typename elements_type::iterator it = elements.begin();
            it != elements.end(); ++it)
        {
            elements_dst.push_back(*it);                                                                // MAY THROW, STRONG (V: alloc, copy)
        }

        result = new_node.get();
        new_node.release();
    }

    node_pointer result;

private:
    allocators_type & m_allocators;
};

}}} // namespace detail::rtree::visitors

}}} // namespace boost::geometry::index

#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP


git https://github.com/jaredcdavis/shellpool.git


module Puppet::Network::HTTP::API::Master
end


/*	Public domain	*/

#ifndef _AGAR_MICRO_BEGIN_H_
#error Inclusion of <agar/micro/close.h> without <agar/micro/begin.h>
#endif
#undef _AGAR_MICRO_BEGIN_H_

/* Unwind Inlining */
#undef _AGAR_MICRO_USE_INLINE

#ifndef _AGAR_MICRO_INTERNAL
/* Unwind Primitive types */
# include <agar/core/close_types.h>
/* Unwind Declarations */
# ifdef _AGAR_MICRO_DEFINED_CDECLS
#  undef _AGAR_MICRO_DEFINED_CDECLS
#  undef __BEGIN_DECLS
#  undef __END_DECLS
# endif
# ifdef _AGAR_MICRO_DEFINED_DECLSPEC
#  undef _AGAR_MICRO_DEFINED_DECLSPEC
#  undef DECLSPEC
# endif
/* Unwind Nullability */
# ifdef _AGAR_MICRO_DEFINED_NULL
#  undef _AGAR_MICRO_DEFINED_NULL
#  undef NULL
# endif
# if defined(_AGAR_MICRO_DEFINED_NULLABILITY) && !defined(_USE_AGAR_NULLABILITY)
#  undef _Nonnull
#  undef _Nullable
#  undef _Null_unspecified
# endif
/* Unwind Restrict */
# ifdef _AGAR_MICRO_DEFINED_RESTRICT
#  undef _Restrict
# endif
#endif /* !_AGAR_MICRO_INTERNAL */

/* Unwind Compiler-specific attributes and annotations */
#include <agar/core/close_attributes.h>


<?xml version="1.0" encoding="UTF-8"?>
<!--
  Copyright 2014 - 2020 Blazebit.

  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.
  -->
<beans xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/beans_1_0.xsd">
</beans>


/* with char|byte|short|int|long|float|double|obj elem */
/*
 * Copyright 2014 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.koloboke.collect;

import com.koloboke.function./*f*/CharConsumer/**/;

import javax.annotation.Nonnull;

/**
 * A mutable pointer to the element in an iteration
 * of // if !(obj elem) //{@code char}// elif obj elem //object// endif //s.
 *
 *
Basic {@code CharCursor} usage idiom is:
{@code
 * for (CharCursor//<>// cur = collection.cursor(); cur.moveNext();) {
 *     // Work with cur.elem()
 *     // Call cur.remove() to remove the current entry
 * }}

 *
 * @see CharCollection#cursor()
 */
public interface CharCursor/*<>*/ extends Cursor {

    /**
     * Performs the given action for each element of the iteration after the cursor in forward
     * direction until all elements have been processed or the action throws an exception.
     * Exceptions thrown by the action are relayed to the caller.
     *
     *
{@code cur.forEachForward(action)} is exact equivalent of
     *
 {@code
     * while (cur.moveNext())
     *     action.accept(cur.elem());}

     *
     * @param action the action to be performed for each element
     */
    void forEachForward(@Nonnull /*f*/CharConsumer action);

    /**
     * Returns the element to which the cursor currently points.
     *
     *
Throws {@code IllegalStateException}, if the cursor isn't pointing to any element: if it
     * is in front of the first element, after the last, or the current element has been removed
     * using {@link #remove()} operation.
     *
     * @return the element to which the cursor currently points
     * @throws IllegalStateException if this cursor is initially in front of the first element
     *         and {@link #moveNext()} hasn't been called yet,
     *         or the previous call of {@code moveNext} returned {@code false},
     *         or {@code remove()} has been performed after the previous cursor movement
     */
    char elem();
}


---
  name: "Nicholas Heidke"
  link: https://twitter.com/NickHeidke
  occupation_title: "ETL Developer"
---


VERSION=@VERSION@

REMOTE=ocaml go rust erlang
DISTDIR=radare2-r2pipe-$(VERSION)
ORIGIN=$(shell cat "$@/ORIGIN" 2> /dev/null)

all:
	@echo Nothing to do.

clean:
	for a in */Makefile ; do $(MAKE) -C $$a ; done
	-rm -rf */node_modules

dist:
	git clone . $(DISTDIR)
	$(MAKE) -C $(DISTDIR) rsync
	rm -rf $(DISTDIR)/.git
	tar czvf $(DISTDIR).tar.gz $(DISTDIR)
	rm -rf $(DISTDIR)

$(REMOTE):
	git clone "$(ORIGIN)" "$@.git"
	mv "$@/ORIGIN" .
	rm -rf "$@/"*
	cp -rf "$@.git/"* "$@/"
	rm -rf $@.git
	mv ORIGIN "$@"

sync: $(REMOTE)

.PHONY: sync rsync clean all $(REMOTE)


package com.twitter.finagle.util

import com.twitter.finagle.benchmark.StdBenchAnnotations
import org.openjdk.jmh.annotations._

class EmaBenchmark extends StdBenchAnnotations {
  import EmaBenchmark._

  @Benchmark
  def update(state: Synchronized): Double = {
    state.synchronized {
      state.ema.update(state.monotime.nanos(), state.rng.nextDouble())
    }
  }

}

object EmaBenchmark {

  @State(Scope.Benchmark)
  class Synchronized {
    val rng: Rng = Rng.threadLocal
    val monotime = new Ema.Monotime()
    val ema: Ema = new Ema(1000)
  }
}


//
//  PGPLogging.h
//  ObjectivePGP
//
//  Created by Marcin Krzyzanowski on 14/05/2017.
//  Copyright © 2017 Marcin Krzyżanowski. All rights reserved.
//

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

#define PGPLogMacro(_level, _tag, _message) NSLog(@"[%s] %@ %s/%tu %@", _tag, @(_level), __PRETTY_FUNCTION__, __LINE__, _message())

#ifdef DEBUG
#define PGPLogDebug(format, ...)                                                     \
    PGPLogMacro(0, "ObjectivePGP", (^{                                               \
                    return [NSString stringWithFormat:(@"" format), ##__VA_ARGS__]; \
                }))
#else
#define PGPLogDebug(format, ...)
#endif

#define PGPLogWarning(format, ...)                                                   \
    PGPLogMacro(1, "ObjectivePGP", (^{                                               \
                    return [NSString stringWithFormat:(@"" format), ##__VA_ARGS__]; \
                }))
#define PGPLogError(format, ...)                                                     \
    PGPLogMacro(2, "ObjectivePGP", (^{                                               \
                    return [NSString stringWithFormat:(@"" format), ##__VA_ARGS__]; \
                }))

NS_ASSUME_NONNULL_END


#include <sysinit.h>

#include "basic/basic.h"

#include "lcd/lcd.h"
#include "lcd/print.h"
#include "lcd/allfonts.h"

#include "filesystem/ff.h"
#include "filesystem/select.h"
#include "funk/nrf24l01p.h"

#include <string.h>

/**************************************************************************/

void show_ticks(void) {
    int dx=0;
    int dy=8;
    lcdClear();
    dx=DoString(0,dy,"Ticks:");
    while ((getInputRaw())==BTN_NONE){
        DoInt(0,dy+8,_timectr);
        lcdDisplay();
    };
    dy+=16;
    dx=DoString(0,dy,"Done.");
};

void gotoISP(void) {
    DoString(0,0,"Enter ISP!");
    lcdDisplay();
    ISPandReset();
}


Content-type: text/plain

Test OpenSSL CMS Signed Content


/*
 * Most of this taken from Redboot hal_platform_setup.h with cleanup
 *
 * NOTE: I haven't clean this up considerably, just enough to get it
 * running. See hal_platform_setup.h for the source. See
 * board/cradle/lowlevel_init.S for another PXA250 setup that is
 * much cleaner.
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <config.h>
#include <version.h>
#include <asm/arch/pxa-regs.h>

DRAM_SIZE:  .long   CONFIG_SYS_DRAM_SIZE

/* wait for coprocessor write complete */
   .macro CPWAIT reg
   mrc  p15,0,\reg,c2,c0,0
   mov  \reg,\reg
   sub  pc,pc,#4
   .endm

_TEXT_BASE:
	.word	TEXT_BASE

/*
 *	Memory setup
 */

.globl lowlevel_init
lowlevel_init:

    mov      r10, lr

	/* Set up GPIO pins first ----------------------------------------- */

	ldr		r0,	=GPSR0
	ldr		r1,	=CONFIG_SYS_GPSR0_VAL
	str		r1,   [r0]

	ldr		r0,	=GPSR1
	ldr		r1,	=CONFIG_SYS_GPSR1_VAL
	str		r1,   [r0]

	ldr		r0,	=GPSR2
	ldr		r1,	=CONFIG_SYS_GPSR2_VAL
	str		r1,   [r0]

	ldr		r0,	=GPCR0
	ldr		r1,	=CONFIG_SYS_GPCR0_VAL
	str		r1,   [r0]

	ldr		r0,	=GPCR1
	ldr		r1,	=CONFIG_SYS_GPCR1_VAL
	str		r1,   [r0]

	ldr		r0,	=GPCR2
	ldr		r1,	=CONFIG_SYS_GPCR2_VAL
	str		r1,   [r0]

	ldr		r0,	=GPDR0
	ldr		r1,	=CONFIG_SYS_GPDR0_VAL
	str		r1,   [r0]

	ldr		r0,	=GPDR1
	ldr		r1,	=CONFIG_SYS_GPDR1_VAL
	str		r1,   [r0]

	ldr		r0,	=GPDR2
	ldr		r1,	=CONFIG_SYS_GPDR2_VAL
	str		r1,   [r0]

	ldr		r0,	=GAFR0_L
	ldr		r1,	=CONFIG_SYS_GAFR0_L_VAL
	str		r1,   [r0]

	ldr		r0,	=GAFR0_U
	ldr		r1,	=CONFIG_SYS_GAFR0_U_VAL
	str		r1,   [r0]

	ldr		r0,	=GAFR1_L
	ldr		r1,	=CONFIG_SYS_GAFR1_L_VAL
	str		r1,   [r0]

	ldr		r0,	=GAFR1_U
	ldr		r1,	=CONFIG_SYS_GAFR1_U_VAL
	str		r1,   [r0]

	ldr		r0,	=GAFR2_L
	ldr		r1,	=CONFIG_SYS_GAFR2_L_VAL
	str		r1,   [r0]

	ldr		r0,	=GAFR2_U
	ldr		r1,	=CONFIG_SYS_GAFR2_U_VAL
	str		r1,   [r0]

	ldr	r0,	=PSSR		/* enable GPIO pins */
	ldr		r1,	=CONFIG_SYS_PSSR_VAL
	str		r1,   [r0]

/*	ldr	r3,	=MSC1		/  low - bank 2 Lubbock Registers / SRAM */
/*	ldr	r2,	=CONFIG_SYS_MSC1_VAL	/  high - bank 3 Ethernet Controller */
/*	str	r2,	[r3]		/  need to set MSC1 before trying to write to the HEX LEDs */
/*	ldr	r2,	[r3]		/  need to read it back to make sure the value latches (see MSC section of manual) */
/* */
/*	ldr	r1,	=LED_BLANK */
/*	mov	r0,	#0xFF */
/*	str	r0,	[r1]		/  turn on hex leds */
/* */
/*loop: */
/* */
/*   ldr	r0, =0xB0070001 */
/*   ldr	r1, =_LED */
/*   str	r0, [r1]		/  hex display */

	/* ---------------------------------------------------------------- */
	/* Enable memory interface                                          */
	/*                                                                  */
	/* The sequence below is based on the recommended init steps        */
	/* detailed in the Intel PXA250 Operating Systems Developers Guide, */
	/* Chapter 10.                                                      */
	/* ---------------------------------------------------------------- */

	/* ---------------------------------------------------------------- */
	/* Step 1: Wait for at least 200 microsedonds to allow internal     */
	/*         clocks to settle. Only necessary after hard reset...     */
	/*         FIXME: can be optimized later                            */
	/* ---------------------------------------------------------------- */

	ldr r3, =OSCR			/* reset the OS Timer Count to zero */
	mov r2, #0
	str r2, [r3]
	ldr r4, =0x300			/* really 0x2E1 is about 200usec,   */
					/* so 0x300 should be plenty        */
1:
	ldr r2, [r3]
	cmp r4, r2
	bgt 1b

mem_init:

	ldr     r1,  =MEMC_BASE		/* get memory controller base addr. */

	/* ---------------------------------------------------------------- */
	/* Step 2a: Initialize Asynchronous static memory controller        */
	/* ---------------------------------------------------------------- */

	/* MSC registers: timing, bus width, mem type                       */

	/* MSC0: nCS(0,1)                                                   */
	ldr     r2,   =CONFIG_SYS_MSC0_VAL
	str     r2,   [r1, #MSC0_OFFSET]
	ldr     r2,   [r1, #MSC0_OFFSET]	/* read back to ensure      */
						/* that data latches        */
	/* MSC1: nCS(2,3)                                                   */
	ldr     r2,  =CONFIG_SYS_MSC1_VAL
	str     r2,  [r1, #MSC1_OFFSET]
	ldr     r2,  [r1, #MSC1_OFFSET]

	/* MSC2: nCS(4,5)                                                   */
	ldr     r2,  =CONFIG_SYS_MSC2_VAL
	str     r2,  [r1, #MSC2_OFFSET]
	ldr     r2,  [r1, #MSC2_OFFSET]

	/* ---------------------------------------------------------------- */
	/* Step 2b: Initialize Card Interface                               */
	/* ---------------------------------------------------------------- */

	/* MECR: Memory Expansion Card Register                             */
	ldr     r2,  =CONFIG_SYS_MECR_VAL
	str     r2,  [r1, #MECR_OFFSET]
	ldr	r2,	[r1, #MECR_OFFSET]

	/* MCMEM0: Card Interface slot 0 timing                             */
	ldr     r2,  =CONFIG_SYS_MCMEM0_VAL
	str     r2,  [r1, #MCMEM0_OFFSET]
	ldr	r2,	[r1, #MCMEM0_OFFSET]

	/* MCMEM1: Card Interface slot 1 timing                             */
	ldr     r2,  =CONFIG_SYS_MCMEM1_VAL
	str     r2,  [r1, #MCMEM1_OFFSET]
	ldr	r2,	[r1, #MCMEM1_OFFSET]

	/* MCATT0: Card Interface Attribute Space Timing, slot 0            */
	ldr     r2,  =CONFIG_SYS_MCATT0_VAL
	str     r2,  [r1, #MCATT0_OFFSET]
	ldr	r2,	[r1, #MCATT0_OFFSET]

	/* MCATT1: Card Interface Attribute Space Timing, slot 1            */
	ldr     r2,  =CONFIG_SYS_MCATT1_VAL
	str     r2,  [r1, #MCATT1_OFFSET]
	ldr	r2,	[r1, #MCATT1_OFFSET]

	/* MCIO0: Card Interface I/O Space Timing, slot 0                   */
	ldr     r2,  =CONFIG_SYS_MCIO0_VAL
	str     r2,  [r1, #MCIO0_OFFSET]
	ldr	r2,	[r1, #MCIO0_OFFSET]

	/* MCIO1: Card Interface I/O Space Timing, slot 1                   */
	ldr     r2,  =CONFIG_SYS_MCIO1_VAL
	str     r2,  [r1, #MCIO1_OFFSET]
	ldr	r2,	[r1, #MCIO1_OFFSET]

	/* ---------------------------------------------------------------- */
	/* Step 2c: Write FLYCNFG  FIXME: what's that???                    */
	/* ---------------------------------------------------------------- */

	/* test if we run from flash or RAM - RAM/BDI: don't setup RAM      */
	adr	r3, mem_init		/* r0 <- current position of code   */
	ldr	r2, =mem_init
	cmp	r3, r2			/* skip init if in place            */
	beq	initirqs

	/* ---------------------------------------------------------------- */
	/* Step 2d: Initialize Timing for Sync Memory (SDCLK0)              */
	/* ---------------------------------------------------------------- */

	/* Before accessing MDREFR we need a valid DRI field, so we set     */
	/* this to power on defaults + DRI field.                           */

	ldr	r3,	=CONFIG_SYS_MDREFR_VAL
	ldr	r2,	=0xFFF
	and	r3,	r3, r2
	ldr	r4,	=0x03ca4000
	orr	r4,	r4,  r3

	str	r4,	[r1, #MDREFR_OFFSET]	/* write back MDREFR        */
	ldr     r4,	[r1, #MDREFR_OFFSET]

	/* ---------------------------------------------------------------- */
	/* Step 3: Initialize Synchronous Static Memory (Flash/Peripherals) */
	/* ---------------------------------------------------------------- */

	/* Initialize SXCNFG register. Assert the enable bits               */

	/* Write SXMRS to cause an MRS command to all enabled banks of      */
	/* synchronous static memory. Note that SXLCR need not be written   */
	/* at this time.                                                    */

	/* FIXME: we use async mode for now                                 */

	/* ---------------------------------------------------------------- */
	/* Step 4: Initialize SDRAM                                         */
	/* ---------------------------------------------------------------- */

	/* Step 4a: assert MDREFR:K?RUN and configure                       */
	/*          MDREFR:K1DB2 and MDREFR:K2DB2 as desired.               */

	ldr	r4,	=CONFIG_SYS_MDREFR_VAL
	str	r4,	[r1, #MDREFR_OFFSET]	/* write back MDREFR        */
	ldr	r4,	[r1, #MDREFR_OFFSET]

	/* Step 4b: de-assert MDREFR:SLFRSH.                                */

	bic	r4,	r4, #(MDREFR_SLFRSH)

	str     r4,     [r1, #MDREFR_OFFSET]    /* write back MDREFR        */
	ldr     r4,     [r1, #MDREFR_OFFSET]

	/* Step 4c: assert MDREFR:E1PIN and E0PIO                           */

	orr	r4,	r4,	#(MDREFR_E1PIN|MDREFR_E0PIN)

	str     r4,     [r1, #MDREFR_OFFSET]    /* write back MDREFR        */
	ldr     r4,     [r1, #MDREFR_OFFSET]

	/* Step 4d: write MDCNFG with MDCNFG:DEx deasserted (set to 0), to  */
	/*          configure but not enable each SDRAM partition pair.     */

	ldr	r4,	=CONFIG_SYS_MDCNFG_VAL
	bic	r4,	r4,	#(MDCNFG_DE0|MDCNFG_DE1)

	str     r4,     [r1, #MDCNFG_OFFSET]	/* write back MDCNFG        */
	ldr     r4,     [r1, #MDCNFG_OFFSET]

	/* Step 4e: Wait for the clock to the SDRAMs to stabilize,          */
	/*          100..200 µsec.                                          */

	ldr r3, =OSCR			/* reset the OS Timer Count to zero */
	mov r2, #0
	str r2, [r3]
	ldr r4, =0x300			/* really 0x2E1 is about 200usec,   */
					/* so 0x300 should be plenty        */
1:
	ldr r2, [r3]
	cmp r4, r2
	bgt 1b

	/* Step 4f: Trigger a number (usually 8) refresh cycles by          */
	/*          attempting non-burst read or write accesses to disabled */
	/*          SDRAM, as commonly specified in the power up sequence   */
	/*          documented in SDRAM data sheets. The address(es) used   */
	/*          for this purpose must not be cacheable.                 */

	/*          There should 9 writes, since the first write doesn't    */
	/*          trigger a refresh cycle on PXA250. See Intel PXA250 and */
	/*          PXA210 Processors Specification Update,                 */
	/*          Jan 2003, Errata #116, page 30.                         */

	ldr	r3,	=CONFIG_SYS_DRAM_BASE
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]
	str	r2, [r3]

	/* Step 4g: Write MDCNFG with enable bits asserted                  */
	/*          (MDCNFG:DEx set to 1).                                  */

	ldr	r3, [r1, #MDCNFG_OFFSET]
	orr	r3,	r3,	#(MDCNFG_DE0|MDCNFG_DE1)
	str	r3, [r1, #MDCNFG_OFFSET]

	/* Step 4h: Write MDMRS.                                            */

	ldr     r2,  =CONFIG_SYS_MDMRS_VAL
	str     r2,  [r1, #MDMRS_OFFSET]

	/* We are finished with Intel's memory controller initialisation    */

	/* ---------------------------------------------------------------- */
	/* Disable (mask) all interrupts at interrupt controller            */
	/* ---------------------------------------------------------------- */

initirqs:

	mov     r1, #0		/* clear int. level register (IRQ, not FIQ) */
	ldr     r2,  =ICLR
	str     r1,  [r2]

	ldr     r2,  =ICMR	/* mask all interrupts at the controller    */
	str     r1,  [r2]

	/* ---------------------------------------------------------------- */
	/* Clock initialisation                                             */
	/* ---------------------------------------------------------------- */

initclks:

	/* Disable the peripheral clocks, and set the core clock frequency  */
	/* (hard-coding at 398.12MHz for now).                              */

	/* Turn Off ALL on-chip peripheral clocks for re-configuration      */
	/* Note: See label 'ENABLECLKS' for the re-enabling                 */
	ldr     r1,  =CKEN
	mov     r2,  #0
	str     r2,  [r1]

	/* default value in case no valid rotary switch setting is found    */
	ldr     r2, =(CCCR_L27|CCCR_M2|CCCR_N10)  /* DEFAULT: {200/200/100} */

	/* ... and write the core clock config register                     */
	ldr     r1,  =CCCR
	str     r2,  [r1]

	/* enable the 32Khz oscillator for RTC and PowerManager             */
/*
	ldr     r1,  =OSCC
	mov     r2,  #OSCC_OON
	str     r2,  [r1]
*/
	/* NOTE:  spin here until OSCC.OOK get set, meaning the PLL         */
	/* has settled.                                                     */
60:
	ldr     r2, [r1]
	ands    r2, r2, #1
	beq     60b

	/* ---------------------------------------------------------------- */
	/*                                                                  */
	/* ---------------------------------------------------------------- */

	/* Save SDRAM size                                                  */
	ldr	r1, =DRAM_SIZE
	str	r8, [r1]

	/* Interrupt init: Mask all interrupts                              */
	ldr	r0, =ICMR			/* enable no sources        */
	mov	r1, #0
	str	r1, [r0]

	/* FIXME */

#ifndef DEBUG
	/*Disable software and data breakpoints */
	mov	r0,#0
	mcr	p15,0,r0,c14,c8,0  /* ibcr0 */
	mcr	p15,0,r0,c14,c9,0  /* ibcr1 */
	mcr	p15,0,r0,c14,c4,0  /* dbcon */

	/*Enable all debug functionality */
	mov	r0,#0x80000000
	mcr	p14,0,r0,c10,c0,0  /* dcsr */
#endif

	/* ---------------------------------------------------------------- */
	/* End lowlevel_init                                                     */
	/* ---------------------------------------------------------------- */

endlowlevel_init:

    mov     pc, lr


#!/bin/bash

# Copyright (c) 2013 The CoreOS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

SCRIPT_ROOT=$(dirname $(readlink -f "$0"))
. "${SCRIPT_ROOT}/common.sh" || exit 1

# Default RSYNC options emerge --sync uses
RSYNC_OPTS="--recursive --links --safe-links --perms --times --compress --force --whole-file --delete --timeout=180"

DEFINE_string portage "git" \
    "Path to a local portage tree or 'rsync' or 'git' to fetch from remote."
DEFINE_string portage_stable "${SRC_ROOT}/third_party/portage-stable" \
    "Path to the portage-stable git checkout."
DEFINE_string git "https://github.com/gentoo/gentoo.git" \
    "git location for the gentoo portage repo (for use with --portage=git)"
DEFINE_string rsync "rsync://rsync.gentoo.org/gentoo-portage" \
    "Rsync location for gentoo-portage to use with --portage=rsync"
DEFINE_boolean commit ${FLAGS_FALSE} \
    "Commit all changes after updating portage-stable."
DEFINE_boolean regencache ${FLAGS_TRUE} \
    "Regenerate cache for updated ebuilds."

# Parse flags
FLAGS "$@" || exit 1
eval set -- "${FLAGS_ARGV}"
switch_to_strict_mode

# Accept arguments from STDIN for batch processing
if [[ -z "$*" ]]; then
    set -- $(</dev/stdin)
fi

if [[ -z "$*" ]]; then
    die "No packages provided"
fi

# eclass updates impact coreos-overlay too, use update_metadata.
if [[ "$*" == *eclass* ]]; then
    FLAGS_regencache=${FLAGS_FALSE}
fi

cd "$FLAGS_portage_stable"

for pkg in "$@"; do
    # Only allow packages, not categories or the whole tree
    if [[ ! "$pkg" =~ ^[a-z0-9-][a-z0-9-]*\/[a-zA-Z0-9-][a-zA-Z0-9_-]*$ ]] &&
       [[ ! "$pkg" =~ ^(eclass|licenses|profiles|scripts|metadata/glsa) ]]; then
        die "Invalid name $pkg, must be category/package or special dir."
    fi

    if [[ "$FLAGS_portage" == git ]]; then
        rm -rf "$pkg"
        if [[ "$(git remote get-url update_ebuilds)" != "${FLAGS_git}" ]]; then
            git remote rm update_ebuilds || true
            git remote add update_ebuilds "${FLAGS_git}"
        fi
        git fetch update_ebuilds
        git checkout refs/remotes/update_ebuilds/master -- "$pkg"
    else
        if [[ "$FLAGS_portage" == rsync ]]; then
            FLAGS_portage="${FLAGS_rsync}"
        fi
        mkdir -p "$pkg"
        rsync $RSYNC_OPTS -v --exclude CVS "$FLAGS_portage/$pkg/" "$pkg"
    fi

    # Make sure we don't change the repo name to 'gentoo'
    if [[ "$pkg" =~ ^profiles ]]; then
        echo portage-stable > profiles/repo_name
    fi

    git add -A "$pkg"

    # Sync up the ebuild metadata cache
    if [[ $FLAGS_regencache -eq $FLAGS_TRUE && "$pkg" == */* && "$pkg" != metadata/glsa ]]; then
        egencache --repo=portage-stable --update "$pkg"
        git add -A "metadata/md5-cache/${pkg}-*"
    fi
done

if [[ $FLAGS_commit -eq $FLAGS_TRUE ]]; then
    if [[ $# -eq 1 ]]; then
        git commit -e -m "bump($1): sync with upstream"
    else
        cat > .git/COMMIT_EDITMSG <<EOF
bump($1): sync with upstream

Packages updated:
$(for p in "$@"; do echo "  $p"; done | sort)
EOF
        git commit -e -F .git/COMMIT_EDITMSG
    fi
else
    git status
fi

if [[ "$*" == *eclass* ]]; then
    info "Please run update_metadata to update cache in all overlays."
fi


GET https://api.stripe.com/v1/invoices/upcoming?customer=cus_test&expand%5B%5D=charge
Stripe-Version: 2019-12-03


var assert = require('assert')
  , AudioBuffer = require('../../build/AudioBuffer')
  , BLOCK_SIZE = require('../../build/constants').BLOCK_SIZE
  , PannerNode = require('../../build/PannerNode')
  , AudioNode = require('../../build/AudioNode')
  , AudioListener = require('../../build/AudioListener')

describe('PannerNode', function() {

  var helpers = require('../helpers')({ approx : 0.01 })
    , dummyContext = {
      sampleRate  : 44100,
      currentTime : 0,
      BLOCK_SIZE  : BLOCK_SIZE,
      listener    : new AudioListener(),
    }

  var testBlockGain = function(block, gainL, gainR) {
    assert.equal(block.numberOfChannels, 2)
    assert.equal(block.length, BLOCK_SIZE)
    helpers.assertAllValuesApprox(block.getChannelData(0), gainL)
    helpers.assertAllValuesApprox(block.getChannelData(1), gainR)
  }

  describe('constructor', function() {
    it('sets attributes to default values', function() {
      var pannerNode = new PannerNode(dummyContext)
      assert.equal(pannerNode.channelCount, 2)
      assert.equal(pannerNode.channelCountMode, 'clamped-max')
      assert.equal(pannerNode.coneInnerAngle, 360)
      assert.equal(pannerNode.coneOuterAngle, 360)
      assert.equal(pannerNode.coneOuterGain, 0)
      assert.equal(pannerNode.distanceModel, 'inverse')
      assert.equal(pannerNode.maxDistance, 10000)
      assert.equal(pannerNode.panningModel, 'equalpower')
      assert.equal(pannerNode.refDistance, 1)
      assert.equal(pannerNode.rolloffFactor, 1)
    })
  })

  describe('_tick', function() {
    var pannerNode, sourceNode

    beforeEach(function() {
      pannerNode = new PannerNode(dummyContext)
      sourceNode = new AudioNode(dummyContext, 0, 1)
      sourceNode.connect(pannerNode)
      sourceNode._tick = function() {
        return AudioBuffer.filledWithVal(1, 2, BLOCK_SIZE, 44100)
      }
    })

    it('should apply the gain for panner position', function() {
      var cases = {
        center : {
          pos  : [0, 0, 0],
          gain : [1, 1],
        },
        '00:00' : {
          pos  : [0, 0, -1],
          gain : [1, 1],
        },
        '01:30' : {
          pos  : [1, 0, -1],
          gain : [0.5, 1.2],
        },
        '03:00' : {
          pos  : [1, 0, 0],
          gain : [0, 2],
        },
        '04:30' : {
          pos  : [1, 0, 1],
          gain : [0.5, 1.2],
        },
        '06:00' : {
          pos  : [0, 0, 1],
          gain : [1, 1],
        },
        '07:30' : {
          pos  : [-1, 0, 1],
          gain : [1.2, 0.5],
        },
        '09:00' : {
          pos  : [-1, 0,  0],
          gain : [2, 0],
        },
        '10:30' : {
          pos  : [-1, 0, -1],
          gain : [1.2, 0.5],
        },
      }

      Object.keys(cases).forEach(function(key) {
        var c = cases[key]

        var pos = c.pos
          , gain = c.gain

        pannerNode._resetPanner()
        pannerNode.setPosition(pos[0], pos[1], pos[2])

        dummyContext.currentTime++
        var block = pannerNode._tick()
        testBlockGain(block, gain[0], gain[1])
      })
    })

    it('should apply the gain for coneEffect parameters', function() {
      var test = function(innerAngle, outerAngle, outerGain, expectedGain) {
        pannerNode.coneInnerAngle = innerAngle
        pannerNode.coneOuterAngle = outerAngle
        pannerNode.coneOuterGain  = outerGain

        dummyContext.currentTime++
        var block = pannerNode._tick()
        testBlockGain(block, expectedGain, expectedGain)
      }

      pannerNode.setPosition(0, 0, -1)

      // The listener is in front of the speaker
      pannerNode.setOrientation(0, 0, 1)
      test(360, 360, 0, 1)
      test(360, 360, 1, 1)
      test(0, 360, 0, 1)
      test(0, 360, 1, 1)
      test(0, 180, 0, 1)
      test(0, 180, 1, 1)

      // The listener is behind the speaker
      pannerNode.setOrientation(0, 0, -1)
      test(360, 360, 0, 1)
      test(360, 360, 1, 1)
      test(0, 360, 0, 0)
      test(0, 360, 1, 1)
      test(0, 180, 0, 0)
      test(0, 180, 1, 1)

      // The listener is on right of the speaker
      pannerNode.setOrientation(1, 0, 0)
      test(360, 360, 0, 1)
      test(360, 360, 1, 1)
      test(0, 360, 0, 0.5)
      test(0, 360, 1, 1)
      test(0, 180, 0, 0)
      test(0, 180, 1, 1)
    })
  })

  describe('setPosition', function() {
    it('throws TypeErrors for invalid parameter', function() {
      assert.throws(function() {
        new PannerNode(dummyContext).setPosition(1)
      }, TypeError)
      assert.throws(function() {
        new PannerNode(dummyContext).setPosition(1, 2)
      }, TypeError)
      assert.throws(function() {
        new PannerNode(dummyContext).setPosition(NaN, NaN, NaN)
      }, TypeError)

      assert.doesNotThrow(function() {
        new PannerNode(dummyContext).setPosition(1, 2, 3)
      }, 'Position must be a 3D vector of finite numbers')
    })
  })

  describe('setVelocity', function() {
    it('throws TypeErrors for invalid parameter', function() {
      assert.throws(function() {
        new PannerNode(dummyContext).setVelocity(1)
      }, TypeError)
      assert.throws(function() {
        new PannerNode(dummyContext).setVelocity(1, 2)
      }, TypeError)
      assert.throws(function() {
        new PannerNode(dummyContext).setVelocity(NaN, NaN, NaN)
      }, TypeError)

      assert.doesNotThrow(function() {
        new PannerNode(dummyContext).setVelocity(1, 2, 3)
      }, 'Velocity must be a 3D vector of finite numbers')
    })
  })

  describe('channelCount', function() {
    it('throws NotSupportedError for invalid parameter', function() {
      assert.throws(function() {
        new PannerNode(dummyContext).channelCount = 0
      }, 'NotSupportedError')
      assert.throws(function() {
        new PannerNode(dummyContext).channelCount = 3
      }, 'NotSupportedError')

      assert.doesNotThrow(function() {
        new PannerNode(dummyContext).channelCount = 1
      }, 'monoral is okay')
      assert.doesNotThrow(function() {
        new PannerNode(dummyContext).channelCount = 2
      }, 'stereo is okay')
    })
  })

  describe('channelCountMode', function() {
    it('throws errors for invalid parameter', function() {
      assert.throws(function() {
        new PannerNode(dummyContext).channelCountMode = 'foo'
      }, 'TypeError')
      assert.throws(function() {
        new PannerNode(dummyContext).channelCountMode = 'max'
      }, 'NotSupportedError', 'PannerNode does not support "clamped-max"')

      assert.doesNotThrow(function() {
        new PannerNode(dummyContext).channelCountMode = 'clamped-max'
      }, '"max" is okay')
      assert.doesNotThrow(function() {
        new PannerNode(dummyContext).channelCountMode = 'explicit'
      }, '"explicit" is okay')
    })
  })

})


The `win_installer*.nsh` files in this folder are used to define localized additional
strings for the NSIS installers.

The default / base language file is English, at:
[**`win_installer_base.nsh`**](win_installer_base.nsh).
It **must** contain _all_ required strings, and is used as a fallback if other
languages are missing translations / strings.

See: **[/doc/Translations.md](/doc/Translations.md)** for details on how to provide / edit translations.

---

`*.nsh` Language Files Header:

```
;  This file is part of Warzone 2100.
;  Copyright (C) 2006-2020  Warzone 2100 Project
;  Copyright (C) 2006       Dennis Schridde
;
;  Warzone 2100 is free software; you can redistribute it and/or modify
;  it under the terms of the GNU General Public License as published by
;  the Free Software Foundation; either version 2 of the License, or
;  (at your option) any later version.
;
;  Warzone 2100 is distributed in the hope that it will be useful,
;  but WITHOUT ANY WARRANTY; without even the implied warranty of
;  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;  GNU General Public License for more details.
;
;  You should have received a copy of the GNU General Public License
;  along with Warzone 2100; if not, write to the Free Software
;  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
;
;  NSIS Modern User Interface
;  Warzone 2100 Project Installer script
;
```


package vrp

import (
	"fmt"
	"go/token"
	"go/types"
	"math/big"

	"honnef.co/go/tools/ssa"
)

type Zs []Z

func (zs Zs) Len() int {
	return len(zs)
}

func (zs Zs) Less(i int, j int) bool {
	return zs[i].Cmp(zs[j]) == -1
}

func (zs Zs) Swap(i int, j int) {
	zs[i], zs[j] = zs[j], zs[i]
}

type Z struct {
	infinity int8
	integer  *big.Int
}

func NewZ(n int64) Z {
	return NewBigZ(big.NewInt(n))
}

func NewBigZ(n *big.Int) Z {
	return Z{integer: n}
}

func (z1 Z) Infinite() bool {
	return z1.infinity != 0
}

func (z1 Z) Add(z2 Z) Z {
	if z2.Sign() == -1 {
		return z1.Sub(z2.Negate())
	}
	if z1 == NInfinity {
		return NInfinity
	}
	if z1 == PInfinity {
		return PInfinity
	}
	if z2 == PInfinity {
		return PInfinity
	}

	if !z1.Infinite() && !z2.Infinite() {
		n := &big.Int{}
		n.Add(z1.integer, z2.integer)
		return NewBigZ(n)
	}

	panic(fmt.Sprintf("%s + %s is not defined", z1, z2))
}

func (z1 Z) Sub(z2 Z) Z {
	if z2.Sign() == -1 {
		return z1.Add(z2.Negate())
	}
	if !z1.Infinite() && !z2.Infinite() {
		n := &big.Int{}
		n.Sub(z1.integer, z2.integer)
		return NewBigZ(n)
	}

	if z1 != PInfinity && z2 == PInfinity {
		return NInfinity
	}
	if z1.Infinite() && !z2.Infinite() {
		return Z{infinity: z1.infinity}
	}
	if z1 == PInfinity && z2 == PInfinity {
		return PInfinity
	}
	panic(fmt.Sprintf("%s - %s is not defined", z1, z2))
}

func (z1 Z) Mul(z2 Z) Z {
	if (z1.integer != nil && z1.integer.Sign() == 0) ||
		(z2.integer != nil && z2.integer.Sign() == 0) {
		return NewBigZ(&big.Int{})
	}

	if z1.infinity != 0 || z2.infinity != 0 {
		return Z{infinity: int8(z1.Sign() * z2.Sign())}
	}

	n := &big.Int{}
	n.Mul(z1.integer, z2.integer)
	return NewBigZ(n)
}

func (z1 Z) Negate() Z {
	if z1.infinity == 1 {
		return NInfinity
	}
	if z1.infinity == -1 {
		return PInfinity
	}
	n := &big.Int{}
	n.Neg(z1.integer)
	return NewBigZ(n)
}

func (z1 Z) Sign() int {
	if z1.infinity != 0 {
		return int(z1.infinity)
	}
	return z1.integer.Sign()
}

func (z1 Z) String() string {
	if z1 == NInfinity {
		return "-∞"
	}
	if z1 == PInfinity {
		return "∞"
	}
	return fmt.Sprintf("%d", z1.integer)
}

func (z1 Z) Cmp(z2 Z) int {
	if z1.infinity == z2.infinity && z1.infinity != 0 {
		return 0
	}
	if z1 == PInfinity {
		return 1
	}
	if z1 == NInfinity {
		return -1
	}
	if z2 == NInfinity {
		return 1
	}
	if z2 == PInfinity {
		return -1
	}
	return z1.integer.Cmp(z2.integer)
}

func MaxZ(zs ...Z) Z {
	if len(zs) == 0 {
		panic("Max called with no arguments")
	}
	if len(zs) == 1 {
		return zs[0]
	}
	ret := zs[0]
	for _, z := range zs[1:] {
		if z.Cmp(ret) == 1 {
			ret = z
		}
	}
	return ret
}

func MinZ(zs ...Z) Z {
	if len(zs) == 0 {
		panic("Min called with no arguments")
	}
	if len(zs) == 1 {
		return zs[0]
	}
	ret := zs[0]
	for _, z := range zs[1:] {
		if z.Cmp(ret) == -1 {
			ret = z
		}
	}
	return ret
}

var NInfinity = Z{infinity: -1}
var PInfinity = Z{infinity: 1}
var EmptyIntInterval = IntInterval{true, PInfinity, NInfinity}

func InfinityFor(v ssa.Value) IntInterval {
	if b, ok := v.Type().Underlying().(*types.Basic); ok {
		if (b.Info() & types.IsUnsigned) != 0 {
			return NewIntInterval(NewZ(0), PInfinity)
		}
	}
	return NewIntInterval(NInfinity, PInfinity)
}

type IntInterval struct {
	known bool
	Lower Z
	Upper Z
}

func NewIntInterval(l, u Z) IntInterval {
	if u.Cmp(l) == -1 {
		return EmptyIntInterval
	}
	return IntInterval{known: true, Lower: l, Upper: u}
}

func (i IntInterval) IsKnown() bool {
	return i.known
}

func (i IntInterval) Empty() bool {
	return i.Lower == PInfinity && i.Upper == NInfinity
}

func (i IntInterval) IsMaxRange() bool {
	return i.Lower == NInfinity && i.Upper == PInfinity
}

func (i1 IntInterval) Intersection(i2 IntInterval) IntInterval {
	if !i1.IsKnown() {
		return i2
	}
	if !i2.IsKnown() {
		return i1
	}
	if i1.Empty() || i2.Empty() {
		return EmptyIntInterval
	}
	i3 := NewIntInterval(MaxZ(i1.Lower, i2.Lower), MinZ(i1.Upper, i2.Upper))
	if i3.Lower.Cmp(i3.Upper) == 1 {
		return EmptyIntInterval
	}
	return i3
}

func (i1 IntInterval) Union(other Range) Range {
	i2, ok := other.(IntInterval)
	if !ok {
		i2 = EmptyIntInterval
	}
	if i1.Empty() || !i1.IsKnown() {
		return i2
	}
	if i2.Empty() || !i2.IsKnown() {
		return i1
	}
	return NewIntInterval(MinZ(i1.Lower, i2.Lower), MaxZ(i1.Upper, i2.Upper))
}

func (i1 IntInterval) Add(i2 IntInterval) IntInterval {
	if i1.Empty() || i2.Empty() {
		return EmptyIntInterval
	}
	l1, u1, l2, u2 := i1.Lower, i1.Upper, i2.Lower, i2.Upper
	return NewIntInterval(l1.Add(l2), u1.Add(u2))
}

func (i1 IntInterval) Sub(i2 IntInterval) IntInterval {
	if i1.Empty() || i2.Empty() {
		return EmptyIntInterval
	}
	l1, u1, l2, u2 := i1.Lower, i1.Upper, i2.Lower, i2.Upper
	return NewIntInterval(l1.Sub(u2), u1.Sub(l2))
}

func (i1 IntInterval) Mul(i2 IntInterval) IntInterval {
	if i1.Empty() || i2.Empty() {
		return EmptyIntInterval
	}
	x1, x2 := i1.Lower, i1.Upper
	y1, y2 := i2.Lower, i2.Upper
	return NewIntInterval(
		MinZ(x1.Mul(y1), x1.Mul(y2), x2.Mul(y1), x2.Mul(y2)),
		MaxZ(x1.Mul(y1), x1.Mul(y2), x2.Mul(y1), x2.Mul(y2)),
	)
}

func (i1 IntInterval) String() string {
	if !i1.IsKnown() {
		return "[⊥, ⊥]"
	}
	if i1.Empty() {
		return "{}"
	}
	return fmt.Sprintf("[%s, %s]", i1.Lower, i1.Upper)
}

type IntArithmeticConstraint struct {
	aConstraint
	A  ssa.Value
	B  ssa.Value
	Op token.Token
	Fn func(IntInterval, IntInterval) IntInterval
}

type IntAddConstraint struct{ *IntArithmeticConstraint }
type IntSubConstraint struct{ *IntArithmeticConstraint }
type IntMulConstraint struct{ *IntArithmeticConstraint }

type IntConversionConstraint struct {
	aConstraint
	X ssa.Value
}

type IntIntersectionConstraint struct {
	aConstraint
	ranges   Ranges
	A        ssa.Value
	B        ssa.Value
	Op       token.Token
	I        IntInterval
	resolved bool
}

type IntIntervalConstraint struct {
	aConstraint
	I IntInterval
}

func NewIntArithmeticConstraint(a, b, y ssa.Value, op token.Token, fn func(IntInterval, IntInterval) IntInterval) *IntArithmeticConstraint {
	return &IntArithmeticConstraint{NewConstraint(y), a, b, op, fn}
}
func NewIntAddConstraint(a, b, y ssa.Value) Constraint {
	return &IntAddConstraint{NewIntArithmeticConstraint(a, b, y, token.ADD, IntInterval.Add)}
}
func NewIntSubConstraint(a, b, y ssa.Value) Constraint {
	return &IntSubConstraint{NewIntArithmeticConstraint(a, b, y, token.SUB, IntInterval.Sub)}
}
func NewIntMulConstraint(a, b, y ssa.Value) Constraint {
	return &IntMulConstraint{NewIntArithmeticConstraint(a, b, y, token.MUL, IntInterval.Mul)}
}
func NewIntConversionConstraint(x, y ssa.Value) Constraint {
	return &IntConversionConstraint{NewConstraint(y), x}
}
func NewIntIntersectionConstraint(a, b ssa.Value, op token.Token, ranges Ranges, y ssa.Value) Constraint {
	return &IntIntersectionConstraint{
		aConstraint: NewConstraint(y),
		ranges:      ranges,
		A:           a,
		B:           b,
		Op:          op,
	}
}
func NewIntIntervalConstraint(i IntInterval, y ssa.Value) Constraint {
	return &IntIntervalConstraint{NewConstraint(y), i}
}

func (c *IntArithmeticConstraint) Operands() []ssa.Value   { return []ssa.Value{c.A, c.B} }
func (c *IntConversionConstraint) Operands() []ssa.Value   { return []ssa.Value{c.X} }
func (c *IntIntersectionConstraint) Operands() []ssa.Value { return []ssa.Value{c.A} }
func (s *IntIntervalConstraint) Operands() []ssa.Value     { return nil }

func (c *IntArithmeticConstraint) String() string {
	return fmt.Sprintf("%s = %s %s %s", c.Y().Name(), c.A.Name(), c.Op, c.B.Name())
}
func (c *IntConversionConstraint) String() string {
	return fmt.Sprintf("%s = %s(%s)", c.Y().Name(), c.Y().Type(), c.X.Name())
}
func (c *IntIntersectionConstraint) String() string {
	return fmt.Sprintf("%s = %s %s %s (%t branch)", c.Y().Name(), c.A.Name(), c.Op, c.B.Name(), c.Y().(*ssa.Sigma).Branch)
}
func (c *IntIntervalConstraint) String() string { return fmt.Sprintf("%s = %s", c.Y().Name(), c.I) }

func (c *IntArithmeticConstraint) Eval(g *Graph) Range {
	i1, i2 := g.Range(c.A).(IntInterval), g.Range(c.B).(IntInterval)
	if !i1.IsKnown() || !i2.IsKnown() {
		return IntInterval{}
	}
	return c.Fn(i1, i2)
}
func (c *IntConversionConstraint) Eval(g *Graph) Range {
	s := &types.StdSizes{
		// XXX is it okay to assume the largest word size, or do we
		// need to be platform specific?
		WordSize: 8,
		MaxAlign: 1,
	}
	fromI := g.Range(c.X).(IntInterval)
	toI := g.Range(c.Y()).(IntInterval)
	fromT := c.X.Type().Underlying().(*types.Basic)
	toT := c.Y().Type().Underlying().(*types.Basic)
	fromB := s.Sizeof(c.X.Type())
	toB := s.Sizeof(c.Y().Type())

	if !fromI.IsKnown() {
		return toI
	}
	if !toI.IsKnown() {
		return fromI
	}

	// uint<N> -> sint/uint<M>, M > N: [max(0, l1), min(2**N-1, u2)]
	if (fromT.Info()&types.IsUnsigned != 0) &&
		toB > fromB {

		n := big.NewInt(1)
		n.Lsh(n, uint(fromB*8))
		n.Sub(n, big.NewInt(1))
		return NewIntInterval(
			MaxZ(NewZ(0), fromI.Lower),
			MinZ(NewBigZ(n), toI.Upper),
		)
	}

	// sint<N> -> sint<M>, M > N; [max(-∞, l1), min(2**N-1, u2)]
	if (fromT.Info()&types.IsUnsigned == 0) &&
		(toT.Info()&types.IsUnsigned == 0) &&
		toB > fromB {

		n := big.NewInt(1)
		n.Lsh(n, uint(fromB*8))
		n.Sub(n, big.NewInt(1))
		return NewIntInterval(
			MaxZ(NInfinity, fromI.Lower),
			MinZ(NewBigZ(n), toI.Upper),
		)
	}

	return fromI
}
func (c *IntIntersectionConstraint) Eval(g *Graph) Range {
	xi := g.Range(c.A).(IntInterval)
	if !xi.IsKnown() {
		return c.I
	}
	return xi.Intersection(c.I)
}
func (c *IntIntervalConstraint) Eval(*Graph) Range { return c.I }

func (c *IntIntersectionConstraint) Futures() []ssa.Value {
	return []ssa.Value{c.B}
}

func (c *IntIntersectionConstraint) Resolve() {
	r, ok := c.ranges[c.B].(IntInterval)
	if !ok {
		c.I = InfinityFor(c.Y())
		return
	}

	switch c.Op {
	case token.EQL:
		c.I = r
	case token.GTR:
		c.I = NewIntInterval(r.Lower.Add(NewZ(1)), PInfinity)
	case token.GEQ:
		c.I = NewIntInterval(r.Lower, PInfinity)
	case token.LSS:
		// TODO(dh): do we need 0 instead of NInfinity for uints?
		c.I = NewIntInterval(NInfinity, r.Upper.Sub(NewZ(1)))
	case token.LEQ:
		c.I = NewIntInterval(NInfinity, r.Upper)
	case token.NEQ:
		c.I = InfinityFor(c.Y())
	default:
		panic("unsupported op " + c.Op.String())
	}
}

func (c *IntIntersectionConstraint) IsKnown() bool {
	return c.I.IsKnown()
}

func (c *IntIntersectionConstraint) MarkUnresolved() {
	c.resolved = false
}

func (c *IntIntersectionConstraint) MarkResolved() {
	c.resolved = true
}

func (c *IntIntersectionConstraint) IsResolved() bool {
	return c.resolved
}


Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!

###############################################################################

Project: "hdbot"=".\hdbot.dsp" - Package Owner=<4>

Package=<5>
{{{
}}}

Package=<4>
{{{
}}}

###############################################################################

Global:

Package=<5>
{{{
}}}

Package=<3>
{{{
}}}

###############################################################################


The DroidSansMono.ttf font used to generate the cfb_fonts bitmaps can be
obtained from:

https://android.googlesource.com/platform/frameworks/base/+/master/data/fonts/DroidSansMono.ttf

To reproduce the font bitmaps use these commands:

${ZEPHYR_BASE}/scripts/gen_cfb_font_header.py \
  -i DroidSansMono.ttf \
  -x 10 -y 16 -s 14 --center-x \
  -o cfbv_1016
${ZEPHYR_BASE}/scripts/gen_cfb_font_header.py \
  -i DroidSansMono.ttf \
  -x 15 -y 24 -s 22 --center-x --y-offset -2 \
  -o cfbv_1524
${ZEPHYR_BASE}/scripts/gen_cfb_font_header.py \
  -i DroidSansMono.ttf \
  -x 20 -y 32 -s 30 --center-x --y-offset -3 \
  -o cfbv_2032


# http://omz-forums.appspot.com/pythonista/post/5227475999129600
# coding: utf-8
import ui
import motion
import sys

main_view = None

def motion_color():
    if not main_view.on_screen :
        motion.stop_updates()
        sys.exit(999)
    color=  motion.get_attitude()
    main_view.background_color = color
    ui.delay(motion_color, .1)

if __name__ == '__main__':
    v = ui.View()
    main_view = v
    motion.start_updates()
    ui.delay(motion_color, .1)
    v.present()


package org.davinci.server.review.user;

import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.davinci.server.review.ReviewerVersion;
import org.davinci.server.user.IPerson;
import org.davinci.server.user.IPersonManager;
import org.maqetta.server.ServerManager;

public class Reviewer implements IPerson{
	private String name;
	private String email;

	private Map<String, ReviewerVersion> versions = Collections.synchronizedMap(new HashMap<String, ReviewerVersion>());

	public Reviewer(String name, String email) {
		if(name ==null) {
			name = "";
		}
		this.name = name;
		this.email =email;
	}

	public String getUserID() {
		if (name.equals("")) {
			//Try and look it up... this is necessary because reviewer doesn't necessarily have
			//a user name at the time they are invited to a review
			IPersonManager personManager = ServerManager.getServerManager().getPersonManager();
			IPerson person = personManager.getPersonByEmail(email);
			if (person != null) {
				name = person.getUserID();
			}
		}
		return name;
	}

	public void setUserName(String name) {
		this.name = name;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public void addReviewerVersion(ReviewerVersion version) {
		if (!versions.containsKey(version.getUniqueID())) {
			versions.put(version.getUniqueID(), version);
		}
	}

	public Iterator<ReviewerVersion> getReviewerVersions() {
		return versions.values().iterator();
	}

	public String getDisplayName() {
		String displayName = this.getEmail();
		IPersonManager personManager = ServerManager.getServerManager().getPersonManager();
		IPerson person = personManager.getPersonByEmail(this.getEmail());
		if (person != null) {
			displayName = person.getDisplayName();
		}

		return displayName;
	}

}