text:
<?php
namespace Blogger\BlogBundle\Extension;

class CutCadExtension extends \Twig_Extension {

	public function getFilters() {
		return array(
				'cutcad'  => new \Twig_Filter_Method($this, 'cutcad'),
		);
	}

 	public function cutcad($comment, $limit=20) {

			$length = strlen($comment);

			if ($length < 0 ){
				$cutcad ='There is no comment';
				}
				else if ($length < $limit) {
					$cutcad = $comment;
				}
				else {
					$cutcad = substr($comment, 0, $limit);
				}

			return $cutcad;
		}

		public function getName()
		{
			return 'cut_cad_extension';
		}

}

//$cadena='aaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbnnnnnnnnnnnnn';
//$cadenb='aaaaaaaaaaan';

//echo cutcad($cadena) . "\n";
//echo cutcad($cadenb);
?>

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="ru_RU">
<context>
    <name>TrikAdditionalPreferences</name>
    <message>
        <source>Form</source>
        <translation type="vanished">Настройки TRIK</translation>
    </message>
    <message>
        <source>TCP Settings</source>
        <translation type="vanished">Настройки TCP</translation>
    </message>
    <message>
        <source>Enter robot IP-address here</source>
        <translation type="vanished">Введите IP-адрес робота</translation>
    </message>
</context>
<context>
    <name>TrikDisplayWidget</name>
    <message>
        <source>Trik Display</source>
        <translation type="vanished">Дисплей TRIK</translation>
    </message>
</context>
<context>
    <name>TrikFSharpAdditionalPreferences</name>
    <message>
        <source>Form</source>
        <translation type="vanished">Настройки F#</translation>
    </message>
    <message>
        <source>F# settings</source>
        <translation type="vanished">Настройки F#</translation>
    </message>
    <message>
        <source>enter path to F# compile </source>
        <translation type="vanished">Введите путь к компилятору F#</translation>
    </message>
</context>
<context>
    <name>TrikWinScpAdditionalPreferences</name>
    <message>
        <source>Form</source>
        <translation type="obsolete">Настройки TRIK</translation>
    </message>
</context>
<context>
    <name>trik::TrikKitInterpreterPlugin</name>
    <message>
        <source>TRIK</source>
        <translation type="vanished">ТРИК</translation>
    </message>
    <message>
        <source>Show 2d model for TRIK</source>
        <translation type="vanished">Открыть 2D модель для TRIK</translation>
    </message>
    <message>
        <source>Show 2d model for TRIK v6</source>
        <translation type="vanished">Открыть 2D модель для TRIK v6</translation>
    </message>
    <message>
        <source>TRIK (old case)</source>
        <translation type="obsolete">ТРИК (старый корпус)</translation>
    </message>
    <message>
        <source>Enter robot`s IP-address here...</source>
        <translation type="vanished">Введите IP-адрес робота...</translation>
    </message>
</context>
<context>
    <name>trik::TrikV6KitInterpreterPlugin</name>
    <message>
        <source>TRIK (old case)</source>
        <translation type="vanished">ТРИК (старый корпус)</translation>
    </message>
    <message>
        <location filename="../../../../plugins/robots/interpreters/trikV6KitInterpreter/src/trikV6KitInterpreterPlugin.cpp" line="42"/>
        <source>TRIK (model-2014)</source>
        <translation>TRIK (модель 2014)</translation>
    </message>
</context>
<context>
    <name>trik::robotModel::real::RealRobotModel</name>
    <message>
        <source>Interpretation (Wi-Fi)</source>
        <translation type="vanished">Интерпретация (Wi-Fi)</translation>
    </message>
</context>
<context>
    <name>trik::robotModel::real::RealRobotModelV6</name>
    <message>
        <source>Interpretation (Wi-Fi)</source>
        <translation type="vanished">Интерпретация (Wi-Fi)</translation>
    </message>
</context>
<context>
    <name>trik::robotModel::real::TrikV6RealRobotModel</name>
    <message>
        <location filename="../../../../plugins/robots/interpreters/trikV6KitInterpreter/src/robotModel/real/trikV6RealRobotModel.cpp" line="65"/>
        <source>Interpretation (Wi-Fi)</source>
        <translation>Интерпретация (Wi-Fi)</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::TrikKitInterpreterPlugin</name>
    <message>
        <source>Enter robot`s IP-address here...</source>
        <translation type="vanished">Введите IP-адрес робота...</translation>
    </message>
    <message>
        <source>TRIK</source>
        <translation type="vanished">ТРИК</translation>
    </message>
    <message>
        <source>Show 2d model for TRIK v4</source>
        <translation type="vanished">Открыть 2D модель для TRIK v4</translation>
    </message>
    <message>
        <source>Show 2d model for TRIK v6</source>
        <translation type="vanished">Открыть 2D модель для TRIK v6</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::blocks::details::LedBlock</name>
    <message>
        <source>Led is not configured (WTF?)</source>
        <translation type="vanished">Светодиод не сконфигурирован</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::blocks::details::WaitForButtonsBlock</name>
    <message>
        <source>Buttons are not configured (WTF?)</source>
        <translation type="vanished">Кнопки не сконфигурированы (што?)</translation>
    </message>
    <message>
        <source>Buttons</source>
        <translation type="vanished">Кнопки</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::blocks::details::WaitGamepadButtonBlock</name>
    <message>
        <source>Incorrect port for gamepad button %1</source>
        <translation type="vanished">Неверная кнопка Android-пульта %1</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikCameraLineDetector</name>
    <message>
        <source>Camera Line Detector</source>
        <translation type="vanished">Детектор линии по камере</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikColorSensor</name>
    <message>
        <source>Color Sensor</source>
        <translation type="vanished">Сенсор цвета</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikGamepadButton</name>
    <message>
        <source>Android Gamepad Button</source>
        <translation type="vanished">Кнопка Android-пульта</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikGamepadConnectionIndicator</name>
    <message>
        <source>Android Gamepad Connection Indicator</source>
        <translation type="vanished">Индикатор подключения Android-пульта</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikGamepadPad</name>
    <message>
        <source>Android Gamepad Pad</source>
        <translation type="vanished">Активная область Android-пульта</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikGamepadPadPressSensor</name>
    <message>
        <source>Android Gamepad Pad as Button</source>
        <translation type="vanished">Активная область Android-пульта как кнопка</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikGamepadWheel</name>
    <message>
        <source>Android Gamepad Wheel</source>
        <translation type="vanished">"Руль" Android-пульта</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikInfraredSensor</name>
    <message>
        <source>Infrared Sensor</source>
        <translation type="vanished">Инфракрасный сенсор</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikLed</name>
    <message>
        <source>Led</source>
        <translation type="vanished">Светодиод</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikLineSensor</name>
    <message>
        <source>Line Sensor</source>
        <translation type="vanished">Сенсор линии</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikMotionSensor</name>
    <message>
        <source>Motion Sensor</source>
        <translation type="vanished">Сенсор движения</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikMovementSensor</name>
    <message>
        <source>Movement Sensor</source>
        <translation type="vanished">Сенсор движения</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikObjectSensor</name>
    <message>
        <source>Object Sensor</source>
        <translation type="vanished">Сенсор объекта</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikPowerMotor</name>
    <message>
        <source>Power Motor</source>
        <translation type="vanished">Силовой мотор</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikServoMotor</name>
    <message>
        <source>Servo Motor</source>
        <translation type="vanished">Сервомотор</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikShell</name>
    <message>
        <source>Shell</source>
        <translation type="vanished">Командный интерпретатор</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::parts::TrikSonarSensor</name>
    <message>
        <source>Sonic Sensor</source>
        <translation type="vanished">Ультразвуковой сенсор</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::real::RealRobotModelV4</name>
    <message>
        <source>Real Robot (v4)</source>
        <translation type="vanished">Реальный робот (v4)</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::real::RealRobotModelV5</name>
    <message>
        <source>Real Robot (v5)</source>
        <translation type="vanished">Реальный робот (v5)</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::real::RealRobotModelV6</name>
    <message>
        <source>Real Robot (v6)</source>
        <translation type="vanished">Реальный робот (v6)</translation>
    </message>
</context>
<context>
    <name>trikKitInterpreter::robotModel::twoD::TwoDRobotModel</name>
    <message>
        <source>2D Model</source>
        <translation type="vanished">2D модель</translation>
    </message>
</context>
</TS>


text:
// FilterIterator.java, created Tue Feb 23 06:17:30 1999 by cananian
// Copyright (C) 1998 C. Scott Ananian <cananian@alumni.princeton.edu>
// Licensed under the terms of the GNU GPL; see COPYING for details.
package jwutil.collections;

import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 * A FilterIterator filters and maps a source
 * Iterator to generate a new one.
 *
 * Note that this implementation reads one element ahead, so if the
 * Filter changes for an object 'o' between the time that is read
 * (when next() is called, returning the object preceding 'o', and
 * checking that 'o' satisfies the current Filter) and the time when
 * hasNext() is called, 'o' will still be returned, regardless of what
 * Filter.isElement(o) returns.  Thus, it is recommended that only
 * Filters which remain consistent throughout the iteration be used.
 *
 * @author  C. Scott Ananian <cananian@alumni.princeton.edu>
 * @version $Id: FilterIterator.java,v 1.1 2004/09/27 22:42:32 joewhaley Exp $
 */
public class FilterIterator extends UnmodifiableIterator implements Iterator {
    /*final*/ Iterator i;
    /*final*/ Filter f;
    /** Creates a FilterIterator. */
    public FilterIterator(Iterator i, Filter f) {
        this.i = i; this.f = f; advance();
    }

    private Object next = null;
    private boolean done = false;

    private void advance() {
        while (i.hasNext()) {
            next = i.next();
            if (f.isElement(next))
                return; // found next element.
        }
        done = true; // found end of enumeration.
    }

    public Object next() {
        if (done) throw new NoSuchElementException();
        Object o = next; advance(); return f.map(o);
    }
    public boolean hasNext() {
        return !done;
    }

}


text:
using NMF.Collections.Generic;
using NMF.Collections.ObjectModel;
using NMF.Expressions;
using NMF.Expressions.Linq;
using NMF.Models;
using NMF.Models.Collections;
using NMF.Models.Expressions;
using NMF.Models.Meta;
using NMF.Models.Repository;
using NMF.Serialization;
using NMF.Utilities;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;

namespace TTC2017.LiveContest.RefinementsEcore
{

    /// <summary>
    /// The default implementation of the EEnumLiteral class
    /// </summary>
    [XmlNamespaceAttribute("http://www.transformation-tool-contest.eu/2017/LiveContest/RefinementsEcore")]
    [XmlNamespacePrefixAttribute("ecoreR")]
    [ModelRepresentationClassAttribute("http://www.transformation-tool-contest.eu/2017/LiveContest/RefinementsEcore#//EEn" +
        "umLiteral")]
    [DebuggerDisplayAttribute("EEnumLiteral {Name}")]
    public partial class EEnumLiteral : ENamedElement, IEEnumLiteral, IModelElement
    {

        /// <summary>
        /// The backing field for the Value property
        /// </summary>
        private Nullable<int> _value;

        private static Lazy<ITypedElement> _valueAttribute = new Lazy<ITypedElement>(RetrieveValueAttribute);

        /// <summary>
        /// The backing field for the Literal property
        /// </summary>
        private string _literal;

        private static Lazy<ITypedElement> _literalAttribute = new Lazy<ITypedElement>(RetrieveLiteralAttribute);

        private static Lazy<ITypedElement> _eEnumReference = new Lazy<ITypedElement>(RetrieveEEnumReference);

        private static IClass _classInstance;

        /// <summary>
        /// The value property
        /// </summary>
        [XmlElementNameAttribute("value")]
        [XmlAttributeAttribute(true)]
        public Nullable<int> Value
        {
            get
            {
                return this._value;
            }
            set
            {
                if ((this._value != value))
                {
                    Nullable<int> old = this._value;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnValueChanging(e);
                    this.OnPropertyChanging("Value", e, _valueAttribute);
                    this._value = value;
                    this.OnValueChanged(e);
                    this.OnPropertyChanged("Value", e, _valueAttribute);
                }
            }
        }

        /// <summary>
        /// The literal property
        /// </summary>
        [XmlElementNameAttribute("literal")]
        [XmlAttributeAttribute(true)]
        public string Literal
        {
            get
            {
                return this._literal;
            }
            set
            {
                if ((this._literal != value))
                {
                    string old = this._literal;
                    ValueChangedEventArgs e = new ValueChangedEventArgs(old, value);
                    this.OnLiteralChanging(e);
                    this.OnPropertyChanging("Literal", e, _literalAttribute);
                    this._literal = value;
                    this.OnLiteralChanged(e);
                    this.OnPropertyChanged("Literal", e, _literalAttribute);
                }
            }
        }

        /// <summary>
        /// The eEnum property
        /// </summary>
        [XmlElementNameAttribute("eEnum")]
        [DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Hidden)]
        [XmlAttributeAttribute(true)]
        [XmlOppositeAttribute("eLiterals")]
        public IEEnum EEnum
        {
            get
            {
                return ModelHelper.CastAs<IEEnum>(this.Parent);
            }
            set
            {
                this.Parent = value;
            }
        }

        /// <summary>
        /// Gets the referenced model elements of this model element
        /// </summary>
        public override IEnumerableExpression<IModelElement> ReferencedElements
        {
            get
            {
                return base.ReferencedElements.Concat(new EEnumLiteralReferencedElementsCollection(this));
            }
        }

        /// <summary>
        /// Gets the Class model for this type
        /// </summary>
        public new static IClass ClassInstance
        {
            get
            {
                if ((_classInstance == null))
                {
                    _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://www.transformation-tool-contest.eu/2017/LiveContest/RefinementsEcore#//EEn" +
                            "umLiteral")));
                }
                return _classInstance;
            }
        }

        /// <summary>
        /// Gets fired before the Value property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ValueChanging;

        /// <summary>
        /// Gets fired when the Value property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> ValueChanged;

        /// <summary>
        /// Gets fired before the Literal property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> LiteralChanging;

        /// <summary>
        /// Gets fired when the Literal property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> LiteralChanged;

        /// <summary>
        /// Gets fired before the EEnum property changes its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> EEnumChanging;

        /// <summary>
        /// Gets fired when the EEnum property changed its value
        /// </summary>
        public event System.EventHandler<ValueChangedEventArgs> EEnumChanged;

        private static ITypedElement RetrieveValueAttribute()
        {
            return ((ITypedElement)(((ModelElement)(TTC2017.LiveContest.RefinementsEcore.EEnumLiteral.ClassInstance)).Resolve("value")));
        }

        /// <summary>
        /// Raises the ValueChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnValueChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ValueChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the ValueChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnValueChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.ValueChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        private static ITypedElement RetrieveLiteralAttribute()
        {
            return ((ITypedElement)(((ModelElement)(TTC2017.LiveContest.RefinementsEcore.EEnumLiteral.ClassInstance)).Resolve("literal")));
        }

        /// <summary>
        /// Raises the LiteralChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnLiteralChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.LiteralChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Raises the LiteralChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnLiteralChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.LiteralChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        private static ITypedElement RetrieveEEnumReference()
        {
            return ((ITypedElement)(((ModelElement)(TTC2017.LiveContest.RefinementsEcore.EEnumLiteral.ClassInstance)).Resolve("eEnum")));
        }

        /// <summary>
        /// Raises the EEnumChanging event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnEEnumChanging(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.EEnumChanging;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Gets called when the parent model element of the current model element is about to change
        /// </summary>
        /// <param name="oldParent">The old parent model element</param>
        /// <param name="newParent">The new parent model element</param>
        protected override void OnParentChanging(IModelElement newParent, IModelElement oldParent)
        {
            IEEnum oldEEnum = ModelHelper.CastAs<IEEnum>(oldParent);
            IEEnum newEEnum = ModelHelper.CastAs<IEEnum>(newParent);
            ValueChangedEventArgs e = new ValueChangedEventArgs(oldEEnum, newEEnum);
            this.OnEEnumChanging(e);
            this.OnPropertyChanging("EEnum", e, _eEnumReference);
        }

        /// <summary>
        /// Raises the EEnumChanged event
        /// </summary>
        /// <param name="eventArgs">The event data</param>
        protected virtual void OnEEnumChanged(ValueChangedEventArgs eventArgs)
        {
            System.EventHandler<ValueChangedEventArgs> handler = this.EEnumChanged;
            if ((handler != null))
            {
                handler.Invoke(this, eventArgs);
            }
        }

        /// <summary>
        /// Gets called when the parent model element of the current model element changes
        /// </summary>
        /// <param name="oldParent">The old parent model element</param>
        /// <param name="newParent">The new parent model element</param>
        protected override void OnParentChanged(IModelElement newParent, IModelElement oldParent)
        {
            IEEnum oldEEnum = ModelHelper.CastAs<IEEnum>(oldParent);
            IEEnum newEEnum = ModelHelper.CastAs<IEEnum>(newParent);
            if ((oldEEnum != null))
            {
                oldEEnum.ELiterals.Remove(this);
            }
            if ((newEEnum != null))
            {
                newEEnum.ELiterals.Add(this);
            }
            ValueChangedEventArgs e = new ValueChangedEventArgs(oldEEnum, newEEnum);
            this.OnEEnumChanged(e);
            this.OnPropertyChanged("EEnum", e, _eEnumReference);
            base.OnParentChanged(newParent, oldParent);
        }

        /// <summary>
        /// Resolves the given attribute name
        /// </summary>
        /// <returns>The attribute value or null if it could not be found</returns>
        /// <param name="attribute">The requested attribute name</param>
        /// <param name="index">The index of this attribute</param>
        protected override object GetAttributeValue(string attribute, int index)
        {
            if ((attribute == "VALUE"))
            {
                return this.Value;
            }
            if ((attribute == "LITERAL"))
            {
                return this.Literal;
            }
            return base.GetAttributeValue(attribute, index);
        }

        /// <summary>
        /// Sets a value to the given feature
        /// </summary>
        /// <param name="feature">The requested feature</param>
        /// <param name="value">The value that should be set to that feature</param>
        protected override void SetFeature(string feature, object value)
        {
            if ((feature == "EENUM"))
            {
                this.EEnum = ((IEEnum)(value));
                return;
            }
            if ((feature == "VALUE"))
            {
                this.Value = ((int)(value));
                return;
            }
            if ((feature == "LITERAL"))
            {
                this.Literal = ((string)(value));
                return;
            }
            base.SetFeature(feature, value);
        }

        /// <summary>
        /// Gets the property expression for the given attribute
        /// </summary>
        /// <returns>An incremental property expression</returns>
        /// <param name="attribute">The requested attribute in upper case</param>
        protected override NMF.Expressions.INotifyExpression<object> GetExpressionForAttribute(string attribute)
        {
            if ((attribute == "EEnum"))
            {
                return new EEnumProxy(this);
            }
            return base.GetExpressionForAttribute(attribute);
        }

        /// <summary>
        /// Gets the property expression for the given reference
        /// </summary>
        /// <returns>An incremental property expression</returns>
        /// <param name="reference">The requested reference in upper case</param>
        protected override NMF.Expressions.INotifyExpression<NMF.Models.IModelElement> GetExpressionForReference(string reference)
        {
            if ((reference == "EEnum"))
            {
                return new EEnumProxy(this);
            }
            return base.GetExpressionForReference(reference);
        }

        /// <summary>
        /// Gets the Class for this model element
        /// </summary>
        public override IClass GetClass()
        {
            if ((_classInstance == null))
            {
                _classInstance = ((IClass)(MetaRepository.Instance.Resolve("http://www.transformation-tool-contest.eu/2017/LiveContest/RefinementsEcore#//EEn" +
                        "umLiteral")));
            }
            return _classInstance;
        }

        /// <summary>
        /// The collection class to to represent the children of the EEnumLiteral class
        /// </summary>
        public class EEnumLiteralReferencedElementsCollection : ReferenceCollection, ICollectionExpression<IModelElement>, ICollection<IModelElement>
        {

            private EEnumLiteral _parent;

            /// <summary>
            /// Creates a new instance
            /// </summary>
            public EEnumLiteralReferencedElementsCollection(EEnumLiteral parent)
            {
                this._parent = parent;
            }

            /// <summary>
            /// Gets the amount of elements contained in this collection
            /// </summary>
            public override int Count
            {
                get
                {
                    int count = 0;
                    if ((this._parent.EEnum != null))
                    {
                        count = (count + 1);
                    }
                    return count;
                }
            }

            protected override void AttachCore()
            {
                this._parent.EEnumChanged += this.PropagateValueChanges;
            }

            protected override void DetachCore()
            {
                this._parent.EEnumChanged -= this.PropagateValueChanges;
            }

            /// <summary>
            /// Adds the given element to the collection
            /// </summary>
            /// <param name="item">The item to add</param>
            public override void Add(IModelElement item)
            {
                if ((this._parent.EEnum == null))
                {
                    IEEnum eEnumCasted = item.As<IEEnum>();
                    if ((eEnumCasted != null))
                    {
                        this._parent.EEnum = eEnumCasted;
                        return;
                    }
                }
            }

            /// <summary>
            /// Clears the collection and resets all references that implement it.
            /// </summary>
            public override void Clear()
            {
                this._parent.EEnum = null;
            }

            /// <summary>
            /// Gets a value indicating whether the given element is contained in the collection
            /// </summary>
            /// <returns>True, if it is contained, otherwise False</returns>
            /// <param name="item">The item that should be looked out for</param>
            public override bool Contains(IModelElement item)
            {
                if ((item == this._parent.EEnum))
                {
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Copies the contents of the collection to the given array starting from the given array index
            /// </summary>
            /// <param name="array">The array in which the elements should be copied</param>
            /// <param name="arrayIndex">The starting index</param>
            public override void CopyTo(IModelElement[] array, int arrayIndex)
            {
                if ((this._parent.EEnum != null))
                {
                    array[arrayIndex] = this._parent.EEnum;
                    arrayIndex = (arrayIndex + 1);
                }
            }

            /// <summary>
            /// Removes the given item from the collection
            /// </summary>
            /// <returns>True, if the item was removed, otherwise False</returns>
            /// <param name="item">The item that should be removed</param>
            public override bool Remove(IModelElement item)
            {
                if ((this._parent.EEnum == item))
                {
                    this._parent.EEnum = null;
                    return true;
                }
                return false;
            }

            /// <summary>
            /// Gets an enumerator that enumerates the collection
            /// </summary>
            /// <returns>A generic enumerator</returns>
            public override IEnumerator<IModelElement> GetEnumerator()
            {
                return Enumerable.Empty<IModelElement>().Concat(this._parent.EEnum).GetEnumerator();
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the value property
        /// </summary>
        private sealed class ValueProxy : ModelPropertyChange<IEEnumLiteral, Nullable<int>>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public ValueProxy(IEEnumLiteral modelElement) :
                    base(modelElement, "value")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override Nullable<int> Value
            {
                get
                {
                    return this.ModelElement.Value;
                }
                set
                {
                    this.ModelElement.Value = value;
                }
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the literal property
        /// </summary>
        private sealed class LiteralProxy : ModelPropertyChange<IEEnumLiteral, string>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public LiteralProxy(IEEnumLiteral modelElement) :
                    base(modelElement, "literal")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override string Value
            {
                get
                {
                    return this.ModelElement.Literal;
                }
                set
                {
                    this.ModelElement.Literal = value;
                }
            }
        }

        /// <summary>
        /// Represents a proxy to represent an incremental access to the eEnum property
        /// </summary>
        private sealed class EEnumProxy : ModelPropertyChange<IEEnumLiteral, IEEnum>
        {

            /// <summary>
            /// Creates a new observable property access proxy
            /// </summary>
            /// <param name="modelElement">The model instance element for which to create the property access proxy</param>
            public EEnumProxy(IEEnumLiteral modelElement) :
                    base(modelElement, "eEnum")
            {
            }

            /// <summary>
            /// Gets or sets the value of this expression
            /// </summary>
            public override IEEnum Value
            {
                get
                {
                    return this.ModelElement.EEnum;
                }
                set
                {
                    this.ModelElement.EEnum = value;
                }
            }
        }
    }
}


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Öst. bot. Z. 83: 184 (1934)

#### Original name
Scopulariopsis atra Zach, 1934

### Remarks
null


text:
module DoubleCheck
  require 'rubygems'
  require 'sitemap'
  require 'check_url'
end


text:
<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet href="CoreNLP-to-HTML.xsl" type="text/xsl"?>
<root>
  <document>
    <sentences>
      <sentence id="1">
        <tokens>
          <token id="1">
            <word>What</word>
            <lemma>what</lemma>
            <CharacterOffsetBegin>0</CharacterOffsetBegin>
            <CharacterOffsetEnd>4</CharacterOffsetEnd>
            <POS>WDT</POS>
          </token>
          <token id="2">
            <word>kind</word>
            <lemma>kind</lemma>
            <CharacterOffsetBegin>5</CharacterOffsetBegin>
            <CharacterOffsetEnd>9</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="3">
            <word>of</word>
            <lemma>of</lemma>
            <CharacterOffsetBegin>10</CharacterOffsetBegin>
            <CharacterOffsetEnd>12</CharacterOffsetEnd>
            <POS>IN</POS>
          </token>
          <token id="4">
            <word>a</word>
            <lemma>a</lemma>
            <CharacterOffsetBegin>13</CharacterOffsetBegin>
            <CharacterOffsetEnd>14</CharacterOffsetEnd>
            <POS>DT</POS>
          </token>
          <token id="5">
            <word>harebrained</word>
            <lemma>harebrained</lemma>
            <CharacterOffsetBegin>15</CharacterOffsetBegin>
            <CharacterOffsetEnd>26</CharacterOffsetEnd>
            <POS>JJ</POS>
          </token>
          <token id="6">
            <word>,</word>
            <lemma>,</lemma>
            <CharacterOffsetBegin>26</CharacterOffsetBegin>
            <CharacterOffsetEnd>27</CharacterOffsetEnd>
            <POS>,</POS>
          </token>
          <token id="7">
            <word>off-the-wall</word>
            <lemma>off-the-wall</lemma>
            <CharacterOffsetBegin>28</CharacterOffsetBegin>
            <CharacterOffsetEnd>40</CharacterOffsetEnd>
            <POS>JJ</POS>
          </token>
          <token id="8">
            <word>idea</word>
            <lemma>idea</lemma>
            <CharacterOffsetBegin>41</CharacterOffsetBegin>
            <CharacterOffsetEnd>45</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
          <token id="9">
            <word>is</word>
            <lemma>be</lemma>
            <CharacterOffsetBegin>46</CharacterOffsetBegin>
            <CharacterOffsetEnd>48</CharacterOffsetEnd>
            <POS>VBZ</POS>
          </token>
          <token id="10">
            <word>that</word>
            <lemma>that</lemma>
            <CharacterOffsetBegin>49</CharacterOffsetBegin>
            <CharacterOffsetEnd>53</CharacterOffsetEnd>
            <POS>IN</POS>
          </token>
          <token id="11">
            <word>?</word>
            <lemma>?</lemma>
            <CharacterOffsetBegin>53</CharacterOffsetBegin>
            <CharacterOffsetEnd>54</CharacterOffsetEnd>
            <POS>.</POS>
          </token>
        </tokens>
        <parse>(ROOT (SBARQ (WHNP (WHNP (WDT What) (NN kind)) (PP (IN of) (NP (DT a) (JJ harebrained) (, ,) (JJ off-the-wall) (NN idea)))) (SQ (VBZ is) (ADJP (IN that))) (. ?))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">kind</governor>
            <dependent idx="1">What</dependent>
          </dep>
          <dep type="dep">
            <governor idx="10">that</governor>
            <dependent idx="2">kind</dependent>
          </dep>
          <dep type="prep">
            <governor idx="2">kind</governor>
            <dependent idx="3">of</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">idea</governor>
            <dependent idx="4">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="8">idea</governor>
            <dependent idx="5">harebrained</dependent>
          </dep>
          <dep type="amod">
            <governor idx="8">idea</governor>
            <dependent idx="7">off-the-wall</dependent>
          </dep>
          <dep type="pobj">
            <governor idx="3">of</governor>
            <dependent idx="8">idea</dependent>
          </dep>
          <dep type="cop">
            <governor idx="10">that</governor>
            <dependent idx="9">is</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">kind</governor>
            <dependent idx="1">What</dependent>
          </dep>
          <dep type="dep">
            <governor idx="10">that</governor>
            <dependent idx="2">kind</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">idea</governor>
            <dependent idx="4">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="8">idea</governor>
            <dependent idx="5">harebrained</dependent>
          </dep>
          <dep type="amod">
            <governor idx="8">idea</governor>
            <dependent idx="7">off-the-wall</dependent>
          </dep>
          <dep type="prep_of">
            <governor idx="2">kind</governor>
            <dependent idx="8">idea</dependent>
          </dep>
          <dep type="cop">
            <governor idx="10">that</governor>
            <dependent idx="9">is</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="10">that</dependent>
          </dep>
          <dep type="det">
            <governor idx="2">kind</governor>
            <dependent idx="1">What</dependent>
          </dep>
          <dep type="dep">
            <governor idx="10">that</governor>
            <dependent idx="2">kind</dependent>
          </dep>
          <dep type="det">
            <governor idx="8">idea</governor>
            <dependent idx="4">a</dependent>
          </dep>
          <dep type="amod">
            <governor idx="8">idea</governor>
            <dependent idx="5">harebrained</dependent>
          </dep>
          <dep type="amod">
            <governor idx="8">idea</governor>
            <dependent idx="7">off-the-wall</dependent>
          </dep>
          <dep type="prep_of">
            <governor idx="2">kind</governor>
            <dependent idx="8">idea</dependent>
          </dep>
          <dep type="cop">
            <governor idx="10">that</governor>
            <dependent idx="9">is</dependent>
          </dep>
        </dependencies>
      </sentence>
      <sentence id="2">
        <tokens>
          <token id="1">
            <word>proposals</word>
            <lemma>proposal</lemma>
            <CharacterOffsetBegin>55</CharacterOffsetBegin>
            <CharacterOffsetEnd>64</CharacterOffsetEnd>
            <POS>NNS</POS>
          </token>
          <token id="2">
            <word>for</word>
            <lemma>for</lemma>
            <CharacterOffsetBegin>65</CharacterOffsetBegin>
            <CharacterOffsetEnd>68</CharacterOffsetEnd>
            <POS>IN</POS>
          </token>
          <token id="3">
            <word>action</word>
            <lemma>action</lemma>
            <CharacterOffsetBegin>69</CharacterOffsetBegin>
            <CharacterOffsetEnd>75</CharacterOffsetEnd>
            <POS>NN</POS>
          </token>
        </tokens>
        <parse>(ROOT (NP (NP (NNS proposals)) (PP (IN for) (NP (NN action))))) </parse>
        <dependencies type="basic-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">proposals</dependent>
          </dep>
          <dep type="prep">
            <governor idx="1">proposals</governor>
            <dependent idx="2">for</dependent>
          </dep>
          <dep type="pobj">
            <governor idx="2">for</governor>
            <dependent idx="3">action</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">proposals</dependent>
          </dep>
          <dep type="prep_for">
            <governor idx="1">proposals</governor>
            <dependent idx="3">action</dependent>
          </dep>
        </dependencies>
        <dependencies type="collapsed-ccprocessed-dependencies">
          <dep type="root">
            <governor idx="0">ROOT</governor>
            <dependent idx="1">proposals</dependent>
          </dep>
          <dep type="prep_for">
            <governor idx="1">proposals</governor>
            <dependent idx="3">action</dependent>
          </dep>
        </dependencies>
      </sentence>
    </sentences>
  </document>
</root>


text:
<ManyToOneRelationship xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Dyn365CommunitySchema">
	<LookupAttribute xmlns:d2p1="http://schemas.microsoft.com/xrm/2011/Metadata" i:nil="true" />
	<Relationship xmlns:d2p1="http://schemas.microsoft.com/xrm/2011/Metadata">
		<d2p1:IsCustomRelationship>false</d2p1:IsCustomRelationship>
		<d2p1:SchemaName>contact_customer_accounts</d2p1:SchemaName>
		<d2p1:SecurityTypes>Append</d2p1:SecurityTypes>
		<d2p1:RelationshipType>OneToManyRelationship</d2p1:RelationshipType>
		<d2p1:AssociatedMenuConfiguration>
			<d2p1:Behavior>UseCollectionName</d2p1:Behavior>
			<d2p1:Group>Details</d2p1:Group>
			<d2p1:Label xmlns:d4p1="http://schemas.microsoft.com/xrm/2011/Contracts">
				<d4p1:LocalizedLabels />
			</d2p1:Label>
			<d2p1:Order>50</d2p1:Order>
		</d2p1:AssociatedMenuConfiguration>
		<d2p1:CascadeConfiguration>
			<d2p1:Assign>Cascade</d2p1:Assign>
			<d2p1:Delete>Cascade</d2p1:Delete>
			<d2p1:Merge>Cascade</d2p1:Merge>
			<d2p1:Reparent>Cascade</d2p1:Reparent>
			<d2p1:Share>Cascade</d2p1:Share>
			<d2p1:Unshare>Cascade</d2p1:Unshare>
		</d2p1:CascadeConfiguration>
		<d2p1:IsHierarchical>false</d2p1:IsHierarchical>
		<d2p1:ReferencedAttribute>accountid</d2p1:ReferencedAttribute>
		<d2p1:ReferencedEntity>account</d2p1:ReferencedEntity>
		<d2p1:ReferencedEntityNavigationPropertyName>contact_customer_accounts</d2p1:ReferencedEntityNavigationPropertyName>
		<d2p1:ReferencingAttribute>parentcustomerid</d2p1:ReferencingAttribute>
		<d2p1:ReferencingEntity>contact</d2p1:ReferencingEntity>
		<d2p1:ReferencingEntityNavigationPropertyName>parentcustomerid_account</d2p1:ReferencingEntityNavigationPropertyName>
	</Relationship>
</ManyToOneRelationship>


text:
            {{ title }}

        <ng-content *ngIf="!title" select="igx-dialog-title,[igxDialogTitle]"></ng-content>

            {{ message }}
            <ng-content *ngIf="!message"></ng-content>

            <button *ngIf="leftButtonLabel" type="button" [igxFocus]="isOpen" [igxButton]="leftButtonType" igxButtonColor="{{ leftButtonColor }}" igxButtonBackground="{{ leftButtonBackgroundColor }}"
                igxRipple="{{ leftButtonRipple }}" (click)="onInternalLeftButtonSelect($event)">
                {{ leftButtonLabel }}
            </button>
            <button *ngIf="rightButtonLabel" type="button" [igxFocus]="isOpen" [igxButton]="rightButtonType" igxButtonColor="{{ rightButtonColor }}" igxButtonBackground="{{ rightButtonBackgroundColor }}"
                igxRipple="{{ rightButtonRipple }}" (click)="onInternalRightButtonSelect($event)">
                {{ rightButtonLabel }}
            </button>

        <ng-content *ngIf="!leftButtonLabel && !rightButtonLabel" select="igx-dialog-actions,[igxDialogActions]"></ng-content>


text:
package nl.ing.nakamoto.fsg.model;

import com.googlecode.objectify.annotation.Entity;
import com.googlecode.objectify.annotation.Id;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.util.Date;

@Entity
@Data
@NoArgsConstructor(access = AccessLevel.PACKAGE)
@AllArgsConstructor(staticName = "of")
public class Update implements Serializable {

    @Id
    private long id;

    private String collectionType;

    private Date date;

    private String ownerId;

    private String ownerType;

    private String subscriptionId;

}


text:
using System;

namespace Take.Elephant.Tests.Specialized
{
    public abstract class GuidItemDistributedCacheSetMapFacts : DistributedCacheSetMapFacts<Guid, Item>
    {
        public override string CreateSynchronizationChannel() => "guid-items";
    }
}


text:
"use strict";

/**
 * Module dependencies.
 */

var utility = require('utility');
var ab = require('ab');
var Agent = require('agentkeepalive');
var ots = require('../');
var config = require('../test/config');

var method = process.argv[2];
if (!method) {
  console.log('$ node bench.js [get|put] [concurrency=5] [requests=10000] [keepalive=1]');
  process.exit(0);
}

var concurrency = parseInt(process.argv[3], 10) || 5;
var requests = parseInt(process.argv[4], 10) || 10000;
var options = {
  concurrency: concurrency,
  requests: requests
};

var keepalive = process.argv[5] === '1';

console.log('%s() benchmark with concurrency: %d, requests: %d, keepalive: %s\n', method, concurrency, requests, keepalive);

var client = ots.createClient({
  accessID: config.accessID,
  accessKey: config.accessKey,
  APIHost: config.APIHost,
  agent: keepalive ? new Agent() : null
});

var key = 'ots-bench-key';

function get() {
  var index = 0;
  ab.run(function (callback) {
    var i = index++;
    var uid = utility.md5(key + i);
    client.getRow('tcif', [{Name: 'md5', Value: uid}, {Name: 'user_id', Value: i}],
    function (err, row) {
      callback(err, row && row.uid === uid && row.firstname === ('yuan-' + i));
    });
  }, options).on('end', function () {
    client.close();
  }).on('error', function (err) {
    console.error(err);
  });
}

function put() {
  var index = 0;
  ab.run(function (callback) {
    var i = index++;
    var uid = utility.md5(key + i);
    client.putRow('tcif',
      [
        { Name: 'md5', Value: uid },
        { Name: 'user_id', Value: i },
      ],
      [
        { Name: 'lastname', Value: 'feng\' mk2' },
        { Name: 'nickname', Value: '  苏千\n ' },
        { Name: 'age', Value: 28 }, // int64
        { Name: 'json', Value: '{ "foo": "bar" }' },
        { Name: 'price', Value: 110.5 },
        { Name: 'enable', Value: true },
        { Name: 'man', Value: true },
        { Name: 'status', Value: null },
        { Name: 'female', Value: false },
        { Name: 'createtime', Value: new Date().toJSON() },
        { Name: 'zero', Value: 0 }
      ],
      function (err) {
        callback(err, err ? false : true);
      }
    );
  }, options).on('end', function () {
    client.close();
  }).on('error', function (err) {
    console.error(err);
  });
}
var set = put;

client.getTableMeta('tcif', function (err, result) {
  console.log(err, result);
  client.listTable(function (err, tables) {
    if (err) {
      throw err;
    }
    eval(method + '();');
  });
});


text:
#pragma once

#include "pch.h"
#include <memory>
#include <vector>
#include <wtypes.h>
#include "BitOp.h"

using namespace std;

namespace Microsoft
{
  namespace Media
  {
    namespace RTMP
    {

      enum NALUType : BYTE
      {
        NALUTYPE_UNSPECIFIED = 0,
        NALUTYPE_CODEDSLICE_NONIDR = 1,
        NALUTYPE_CODEDSLICE_DATAPART_A = 2,
        NALUTYPE_CODEDSLICE_DATAPART_B = 3,
        NALUTYPE_CODEDSLICE_DATAPART_C = 4,
        NALUTYPE_CODEDSLICEIDR = 5,
        NALUTYPE_SEI = 6,
        NALUTYPE_SPS = 7,
        NALUTYPE_PPS = 8,
        NALUTYPE_AUD = 9,
        NALUTYPE_EOSEQ = 10,
        NALUTYPE_EOSTM = 11,
        NALUTYPE_FILLER = 12,
        NALUTYPE_SPS_EST = 13,
        NALUTYPE_PREFIX = 14,
        NALUTYPE_SUBSET_SPS = 15,
        NALUTYPE_SLICELAYER_NOPART = 19,
        NALUTYPE_SLICE_EXT = 20,
      };

      enum SEIType : short
      {
        SEITYPE_ITUT_T35 = 4, SEITYPE_NOTRELEVANT = 0
      };

      class NALUnit
      {
      protected:

        std::vector<BYTE> _naluDataEmulPrevBytesRemoved;
        unsigned int _length;
        NALUType _nalutype;
        const BYTE* _naluData;
      public:

        NALUType GetType()
        {
          return _nalutype;
        }

        unsigned int GetLength()
        {
          return _naluDataEmulPrevBytesRemoved.size() > 0 ? (unsigned int) _naluDataEmulPrevBytesRemoved.size() : _length;
        }

        const BYTE* GetData()
        {
          return _naluDataEmulPrevBytesRemoved.size() > 0 ? &(*(_naluDataEmulPrevBytesRemoved.begin())) : _naluData;
        }

        NALUnit(NALUType type, const BYTE *data, unsigned int len) :
          _nalutype(type), _length(len), _naluData(data)
        {
          //CleanRBSPOfEmulPreventionBytes();
        }

        void CleanRBSPOfEmulPreventionBytes()
        {
          std::vector<BYTE> vecnaluDataEmulByteRemoved;
          unsigned int readctr = 0;
          while (_naluData[readctr++] != 0x01); //skip prefix
          readctr++;//skip NALU header;
          bool foundEmulPreventByte = false;
          while (readctr < _length)
          {
            if (readctr + 2 < _length && BitOp::ToInteger<unsigned int>(_naluData + readctr, 3) == 0x000003)//emulation prevention
            {
              vecnaluDataEmulByteRemoved.push_back(_naluData[readctr++]);
              vecnaluDataEmulByteRemoved.push_back(_naluData[readctr++]);
              readctr++;//emulation prevention byte skipped;
              _length--;
              foundEmulPreventByte = true;
            }
            else
              vecnaluDataEmulByteRemoved.push_back(_naluData[readctr++]);
          }
          if (!foundEmulPreventByte)
            vecnaluDataEmulByteRemoved.clear();

        }

      };

      class AVCParser
      {
      public:
        static std::vector<shared_ptr<NALUnit>> Parse(std::vector<BYTE>& sampledata)
        {

          std::vector<shared_ptr<NALUnit>> retval;

          const BYTE* elemData = &(*(sampledata.begin()));

          unsigned int size = (unsigned int) sampledata.size();
          unsigned int readbytecount = 0;
          bool EOS = false;

          //skip leading zero bytes and position on first prefix
          while (elemData[readbytecount] == 0x00 && BitOp::ToInteger<unsigned int>(elemData + readbytecount, 3) != 0x000001)
            ++readbytecount;

          if (readbytecount + 3 >= size) //nothing to parse
            return retval;

          while (true)
          {

            unsigned int NumBytesInNALUnit = 0;
            unsigned int BitSequenceMatchPos = 0;
            //find the next prefix match - after this prefix
            if (FindNextMatchingBitSequence(0x000001, 3, readbytecount + 3, elemData, size, BitSequenceMatchPos) == true)
              //if found - find the number of bytes in the NALU
              NumBytesInNALUnit = BitSequenceMatchPos - readbytecount - 3;
            else
              NumBytesInNALUnit = size - readbytecount - 3;
            //process NALU here

            //read a byte (after the prefix) and skip over first 3 bits(forbidden bit(1 bit) + nal_ref_idc(2 bits) to get nal_unit_type
            auto nal_unit_type = BitOp::ExtractBits(elemData[readbytecount + 3], 3, 5);

            retval.push_back(std::make_shared<NALUnit>((NALUType) nal_unit_type, elemData + readbytecount + 3, NumBytesInNALUnit));

            //done processing
            readbytecount += NumBytesInNALUnit + 3;

            if (BitSequenceMatchPos == size || size - readbytecount <= 3) //we did not find the start of another NALU last time we checked - or nothing else left to parse
              break;
          }
          return retval;

        }

        static bool FindNextMatchingBitSequence(unsigned int sequencevalue, unsigned short numbits, unsigned int startat, const BYTE *data, unsigned int size, unsigned int& MatchPos)
        {
          MatchPos = size;
          if (size < numbits) return false;

          while (startat + numbits <= size)
          {
            if (BitOp::ToInteger<unsigned int>(data + startat, numbits) != sequencevalue)
              ++startat;
            else
            {
              MatchPos = startat;
              break;
            }
          }

          return (startat + numbits <= size);
        }
      };
    }
  }
}


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>eu.agilejava</groupId>
    <artifactId>simple-rest</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>simple-rest</name>

    <parent>
        <groupId>eu.agilejava</groupId>
        <artifactId>security-samples</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </parent>

    <build>
        <finalName>simple-rest</finalName>
    </build>

    <dependencies>
        <dependency>
            <groupId>jakarta.platform</groupId>
            <artifactId>jakarta.jakartaee-api</artifactId>
            <version>9.1.0</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

</project>


text:
env = Environment(DOCBOOK_PREFER_XSLTPROC=1, tools=['docbook'])
env.DocbookHtmlhelp('manual', xsl='htmlhelp.xsl', base_dir='output/')


text:
namespace Nancy.Hosting.Self
{
    using System;

    /// <summary>
    /// Executes NetSh commands
    /// </summary>
    public static class NetSh
    {
        private const string NetshCommand = "netsh";

        /// <summary>
        /// Add a url reservation
        /// </summary>
        /// <param name="url">Url to add</param>
        /// <param name="user">User to add the reservation for</param>
        /// <returns>True if successful, false otherwise.</returns>
        public static bool AddUrlAcl(string url, string user)
        {
            try
            {
                var arguments = GetParameters(url, user);

                return UacHelper.RunElevated(NetshCommand, arguments);
            }
            catch (Exception)
            {
                return false;
            }
        }

        internal static string GetParameters(string url, string user)
        {
            return string.Format("http add urlacl url=\"{0}\" user=\"{1}\"", url, user);
        }
    }
}