text:
//
// NtlmAttributeValuePair.cs
//
// Author: Jeffrey Stedfast <jestedfa@microsoft.com>
//
// Copyright (c) 2013-2022 .NET Foundation and Contributors
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS 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. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

// https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-nlmp/b38c36ed-2804-4868-a9ff-8dd3182128e4

namespace MailKit.Security.Ntlm {
	/// <summary>
	/// An abstract NTLM attribute and value pair.
	/// </summary>
	/// <remarks>
	/// An abstract NTLM attribute and value pair.
	/// </remarks>
	abstract class NtlmAttributeValuePair
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		protected NtlmAttributeValuePair (NtlmAttribute attr)
		{
			Attribute = attr;
		}

		/// <summary>
		/// Get the NTLM attribute that this pair represents.
		/// </summary>
		/// <remarks>
		/// Gets the NTLM attribute that this pair represents.
		/// </remarks>
		/// <value>The NTLM attribute.</value>
		public NtlmAttribute Attribute {
			get; private set;
		}
	}

	/// <summary>
	/// An NTLM attribute and value pair consisting of a string value.
	/// </summary>
	/// <remarks>
	/// An NTLM attribute and value pair consisting of a string value.
	/// </remarks>
	sealed class NtlmAttributeStringValuePair : NtlmAttributeValuePair
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeStringValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair consisting of a string value.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		/// <param name="value">The NTLM attribute value.</param>
		public NtlmAttributeStringValuePair (NtlmAttribute attr, string value) : base (attr)
		{
			Value = value;
		}

		/// <summary>
		/// Get or set the value of the attribute.
		/// </summary>
		/// <remarks>
		/// Gets or sets the value of the attribute.
		/// </remarks>
		/// <value>The attribute value.</value>
		public string Value {
			get; set;
		}
	}

	/// <summary>
	/// An NTLM attribute and value pair consisting of a flags value.
	/// </summary>
	/// <remarks>
	/// An NTLM attribute and value pair consisting of a flags value.
	/// </remarks>
	sealed class NtlmAttributeFlagsValuePair : NtlmAttributeValuePair
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeFlagsValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair consisting of a flags value.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		/// <param name="value">The NTLM attribute value.</param>
		/// <param name="size">The size of the encoded flags value.</param>
		internal NtlmAttributeFlagsValuePair (NtlmAttribute attr, int value, short size) : base (attr)
		{
			Value = value;
			Size = size;
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeFlagsValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair consisting of a flags value.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		/// <param name="value">The NTLM attribute value.</param>
		public NtlmAttributeFlagsValuePair (NtlmAttribute attr, int value) : this (attr, value, 4)
		{
		}

		/// <summary>
		/// Get or set the size of the encoded flags value.
		/// </summary>
		/// <remarks>
		/// Gets or sets the size of the encoded flags value.
		/// </remarks>
		public short Size {
			get; internal set;
		}

		/// <summary>
		/// Get or set the value of the attribute.
		/// </summary>
		/// <remarks>
		/// Gets or sets the value of the attribute.
		/// </remarks>
		/// <value>The attribute value.</value>
		public int Value {
			get; set;
		}
	}

	/// <summary>
	/// An NTLM attribute and value pair consisting of a timestamp value.
	/// </summary>
	/// <remarks>
	/// An NTLM attribute and value pair consisting of a timestamp value.
	/// </remarks>
	sealed class NtlmAttributeTimestampValuePair : NtlmAttributeValuePair
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeTimestampValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair consisting of a timestamp value.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		/// <param name="value">The NTLM attribute value.</param>
		/// <param name="size">The size of the encoded flags value.</param>
		internal NtlmAttributeTimestampValuePair (NtlmAttribute attr, long value, short size) : base (attr)
		{
			Value = value;
			Size = size;
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeTimestampValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair consisting of a timestamp value.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		/// <param name="value">The NTLM attribute value.</param>
		public NtlmAttributeTimestampValuePair (NtlmAttribute attr, long value) : this (attr, value, 8)
		{
		}

		/// <summary>
		/// Get or set the size of the encoded timestamp value.
		/// </summary>
		/// <remarks>
		/// Gets or sets the size of the encoded timestamp value.
		/// </remarks>
		public short Size {
			get; internal set;
		}

		/// <summary>
		/// Get or set the value of the attribute.
		/// </summary>
		/// <remarks>
		/// Gets or sets the value of the attribute.
		/// </remarks>
		/// <value>The attribute value.</value>
		public long Value {
			get; set;
		}
	}

	/// <summary>
	/// An NTLM attribute and value pair consisting of a byte array value.
	/// </summary>
	/// <remarks>
	/// An NTLM attribute and value pair consisting of a byte array value.
	/// </remarks>
	sealed class NtlmAttributeByteArrayValuePair : NtlmAttributeValuePair
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="NtlmAttributeByteArrayValuePair"/> class.
		/// </summary>
		/// <remarks>
		/// Creates a new NTLM attribute and value pair consisting of a byte array value.
		/// </remarks>
		/// <param name="attr">The NTLM attribute.</param>
		/// <param name="value">The NTLM attribute value.</param>
		public NtlmAttributeByteArrayValuePair (NtlmAttribute attr, byte[] value) : base (attr)
		{
			Value = value;
		}

		/// <summary>
		/// Get or set the value of the attribute.
		/// </summary>
		/// <remarks>
		/// Gets or sets the value of the attribute.
		/// </remarks>
		/// <value>The attribute value.</value>
		public byte[] Value {
			get; set;
		}
	}
}


text:
package main;

public class ErrorChecker {

	//Can use this to see if the number of left and right brackets are balanced.

	public boolean bracketCountChecker(String textProgram) {
		int [] brackets = new int[2];
		for (int c = 0; c < textProgram.length(); c++) {
			if (textProgram.charAt(c) == '[')
				brackets[0]++;
			if (textProgram.charAt(c) == ']')
				brackets[1]++;
		}
		if (brackets[0] != brackets[1])
			return false;

		return true;
	}

	public boolean bracketLeftBeforeRight(String textProgram) {
		int []brackets = new int[2];

		for (int c = 0; c < textProgram.length(); c++) {
			if (textProgram.charAt(c) == '[')
				brackets[0]++;
			if (textProgram.charAt(c) == ']')
				brackets[1]++;
			if (brackets[0] < brackets[1]) {
				return false;
			}
		}

		return true;
	}
}

redpajama_set_name: RedPajamaGithub


text:
#include <linux/export.h>
#include <linux/kernel.h>
#include <linux/stddef.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/utsname.h>
#include <linux/initrd.h>
#include <linux/console.h>
#include <linux/bootmem.h>
#include <linux/seq_file.h>
#include <linux/screen_info.h>
#include <linux/init.h>
#include <linux/kexec.h>
#include <linux/crash_dump.h>
#include <linux/root_dev.h>
#include <linux/clk-provider.h>
#include <linux/cpu.h>
#include <linux/interrupt.h>
#include <linux/smp.h>
#include <linux/fs.h>
#include <linux/proc_fs.h>
#include <linux/memblock.h>
#include <linux/of_fdt.h>
#include <linux/of_platform.h>
#include <linux/dma-mapping.h>

#include <asm/cputype.h>
#include <asm/elf.h>
#include <asm/cputable.h>
#include <asm/cpu_ops.h>
#include <asm/sections.h>
#include <asm/setup.h>
#include <asm/smp_plat.h>
#include <asm/cacheflush.h>
#include <asm/tlbflush.h>
#include <asm/traps.h>
#include <asm/memblock.h>
#include <asm/psci.h>

unsigned int processor_id;
EXPORT_SYMBOL(processor_id);

unsigned int elf_hwcap __read_mostly;
EXPORT_SYMBOL_GPL(elf_hwcap);

unsigned int boot_reason;
EXPORT_SYMBOL(boot_reason);

unsigned int cold_boot;
EXPORT_SYMBOL(cold_boot);

static const char *cpu_name;
static const char *machine_name;
phys_addr_t __fdt_pointer __initdata;

/*
 * Standard memory resources
 */
static struct resource mem_res[] = {
	{
		.name = "Kernel code",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	},
	{
		.name = "Kernel data",
		.start = 0,
		.end = 0,
		.flags = IORESOURCE_MEM
	}
};

#define kernel_code mem_res[0]
#define kernel_data mem_res[1]

void __init early_print(const char *str, ...)
{
	char buf[256];
	va_list ap;

	va_start(ap, str);
	vsnprintf(buf, sizeof(buf), str, ap);
	va_end(ap);

	printk("%s", buf);
}

bool arch_match_cpu_phys_id(int cpu, u64 phys_id)
{
	return phys_id == cpu_logical_map(cpu);
}

struct mpidr_hash mpidr_hash;
#ifdef CONFIG_SMP
/**
 * smp_build_mpidr_hash - Pre-compute shifts required at each affinity
 *			  level in order to build a linear index from an
 *			  MPIDR value. Resulting algorithm is a collision
 *			  free hash carried out through shifting and ORing
 */
static void __init smp_build_mpidr_hash(void)
{
	u32 i, affinity, fs[4], bits[4], ls;
	u64 mask = 0;
	/*
	 * Pre-scan the list of MPIDRS and filter out bits that do
	 * not contribute to affinity levels, ie they never toggle.
	 */
	for_each_possible_cpu(i)
		mask |= (cpu_logical_map(i) ^ cpu_logical_map(0));
	pr_debug("mask of set bits %#llx\n", mask);
	/*
	 * Find and stash the last and first bit set at all affinity levels to
	 * check how many bits are required to represent them.
	 */
	for (i = 0; i < 4; i++) {
		affinity = MPIDR_AFFINITY_LEVEL(mask, i);
		/*
		 * Find the MSB bit and LSB bits position
		 * to determine how many bits are required
		 * to express the affinity level.
		 */
		ls = fls(affinity);
		fs[i] = affinity ? ffs(affinity) - 1 : 0;
		bits[i] = ls - fs[i];
	}
	/*
	 * An index can be created from the MPIDR_EL1 by isolating the
	 * significant bits at each affinity level and by shifting
	 * them in order to compress the 32 bits values space to a
	 * compressed set of values. This is equivalent to hashing
	 * the MPIDR_EL1 through shifting and ORing. It is a collision free
	 * hash though not minimal since some levels might contain a number
	 * of CPUs that is not an exact power of 2 and their bit
	 * representation might contain holes, eg MPIDR_EL1[7:0] = {0x2, 0x80}.
	 */
	mpidr_hash.shift_aff[0] = MPIDR_LEVEL_SHIFT(0) + fs[0];
	mpidr_hash.shift_aff[1] = MPIDR_LEVEL_SHIFT(1) + fs[1] - bits[0];
	mpidr_hash.shift_aff[2] = MPIDR_LEVEL_SHIFT(2) + fs[2] -
						(bits[1] + bits[0]);
	mpidr_hash.shift_aff[3] = MPIDR_LEVEL_SHIFT(3) +
				  fs[3] - (bits[2] + bits[1] + bits[0]);
	mpidr_hash.mask = mask;
	mpidr_hash.bits = bits[3] + bits[2] + bits[1] + bits[0];
	pr_debug("MPIDR hash: aff0[%u] aff1[%u] aff2[%u] aff3[%u] mask[%#llx] bits[%u]\n",
		mpidr_hash.shift_aff[0],
		mpidr_hash.shift_aff[1],
		mpidr_hash.shift_aff[2],
		mpidr_hash.shift_aff[3],
		mpidr_hash.mask,
		mpidr_hash.bits);
	/*
	 * 4x is an arbitrary value used to warn on a hash table much bigger
	 * than expected on most systems.
	 */
	if (mpidr_hash_size() > 4 * num_possible_cpus())
		pr_warn("Large number of MPIDR hash buckets detected\n");
	__flush_dcache_area(&mpidr_hash, sizeof(struct mpidr_hash));
}
#endif

static void __init setup_processor(void)
{
	struct cpu_info *cpu_info;

	/*
	 * locate processor in the list of supported processor
	 * types.  The linker builds this table for us from the
	 * entries in arch/arm/mm/proc.S
	 */
	cpu_info = lookup_processor_type(read_cpuid_id());
	if (!cpu_info) {
		printk("CPU configuration botched (ID %08x), unable to continue.\n",
		       read_cpuid_id());
		while (1);
	}

	cpu_name = cpu_info->cpu_name;

	printk("CPU: %s [%08x] revision %d\n",
	       cpu_name, read_cpuid_id(), read_cpuid_id() & 15);

	sprintf(init_utsname()->machine, "aarch64");
	elf_hwcap = 0;
}

static void __init setup_machine_fdt(phys_addr_t dt_phys)
{
	struct boot_param_header *devtree;
	unsigned long dt_root;

	/* Check we have a non-NULL DT pointer */
	if (!dt_phys) {
		early_print("\n"
			"Error: NULL or invalid device tree blob\n"
			"The dtb must be 8-byte aligned and passed in the first 512MB of memory\n"
			"\nPlease check your bootloader.\n");

		while (true)
			cpu_relax();

	}

	devtree = phys_to_virt(dt_phys);

	/* Check device tree validity */
	if (be32_to_cpu(devtree->magic) != OF_DT_HEADER) {
		early_print("\n"
			"Error: invalid device tree blob at physical address 0x%p (virtual address 0x%p)\n"
			"Expected 0x%x, found 0x%x\n"
			"\nPlease check your bootloader.\n",
			dt_phys, devtree, OF_DT_HEADER,
			be32_to_cpu(devtree->magic));

		while (true)
			cpu_relax();
	}

	initial_boot_params = devtree;
	dt_root = of_get_flat_dt_root();

	machine_name = of_get_flat_dt_prop(dt_root, "model", NULL);
	if (!machine_name)
		machine_name = of_get_flat_dt_prop(dt_root, "compatible", NULL);
	if (!machine_name)
		machine_name = "<unknown>";
	pr_info("Machine: %s\n", machine_name);

	/* Retrieve various information from the /chosen node */
	of_scan_flat_dt(early_init_dt_scan_chosen, boot_command_line);
	/* Initialize {size,address}-cells info */
	of_scan_flat_dt(early_init_dt_scan_root, NULL);
	/* Setup memory, calling early_init_dt_add_memory_arch */
	of_scan_flat_dt(early_init_dt_scan_memory, NULL);
}

void __init early_init_dt_add_memory_arch(u64 base, u64 size)
{
	base &= PAGE_MASK;
	size &= PAGE_MASK;
	if (base + size < PHYS_OFFSET) {
		pr_warning("Ignoring memory block 0x%llx - 0x%llx\n",
			   base, base + size);
		return;
	}
	if (base < PHYS_OFFSET) {
		pr_warning("Ignoring memory range 0x%llx - 0x%llx\n",
			   base, PHYS_OFFSET);
		size -= PHYS_OFFSET - base;
		base = PHYS_OFFSET;
	}
	memblock_add(base, size);
}

void * __init early_init_dt_alloc_memory_arch(u64 size, u64 align)
{
	return __va(memblock_alloc(size, align));
}

/*
 * Limit the memory size that was specified via FDT.
 */
static int __init early_mem(char *p)
{
	phys_addr_t limit;

	if (!p)
		return 1;

	limit = memparse(p, &p) & PAGE_MASK;
	pr_notice("Memory limited to %lldMB\n", limit >> 20);

	memblock_enforce_memory_limit(limit);

	return 0;
}
early_param("mem", early_mem);

static void __init request_standard_resources(void)
{
	struct memblock_region *region;
	struct resource *res;

	kernel_code.start   = virt_to_phys(_text);
	kernel_code.end     = virt_to_phys(_etext - 1);
	kernel_data.start   = virt_to_phys(_sdata);
	kernel_data.end     = virt_to_phys(_end - 1);

	for_each_memblock(memory, region) {
		res = alloc_bootmem_low(sizeof(*res));
		res->name  = "System RAM";
		res->start = __pfn_to_phys(memblock_region_memory_base_pfn(region));
		res->end = __pfn_to_phys(memblock_region_memory_end_pfn(region)) - 1;
		res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;

		request_resource(&iomem_resource, res);

		if (kernel_code.start >= res->start &&
		    kernel_code.end <= res->end)
			request_resource(res, &kernel_code);
		if (kernel_data.start >= res->start &&
		    kernel_data.end <= res->end)
			request_resource(res, &kernel_data);
	}
}

u64 __cpu_logical_map[NR_CPUS] = { [0 ... NR_CPUS-1] = INVALID_HWID };

void __init setup_arch(char **cmdline_p)
{
	setup_processor();

	setup_machine_fdt(__fdt_pointer);

	init_mm.start_code = (unsigned long) _text;
	init_mm.end_code   = (unsigned long) _etext;
	init_mm.end_data   = (unsigned long) _edata;
	init_mm.brk	   = (unsigned long) _end;

	*cmdline_p = boot_command_line;

	parse_early_param();

	arm64_memblock_init();

	paging_init();
	request_standard_resources();

	unflatten_device_tree();

	psci_init();

	cpu_logical_map(0) = read_cpuid_mpidr() & MPIDR_HWID_BITMASK;
	cpu_read_bootcpu_ops();
#ifdef CONFIG_SMP
	smp_init_cpus();
	smp_build_mpidr_hash();
#endif

#ifdef CONFIG_VT
#if defined(CONFIG_VGA_CONSOLE)
	conswitchp = &vga_con;
#elif defined(CONFIG_DUMMY_CONSOLE)
	conswitchp = &dummy_con;
#endif
#endif
}

static int __init arm64_device_init(void)
{
	of_clk_init(NULL);
	of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL);
	return 0;
}
arch_initcall(arm64_device_init);

static DEFINE_PER_CPU(struct cpu, cpu_data);

static int __init topology_init(void)
{
	int i;

	for_each_possible_cpu(i) {
		struct cpu *cpu = &per_cpu(cpu_data, i);
		cpu->hotpluggable = 1;
		register_cpu(cpu, i);
	}

	return 0;
}
subsys_initcall(topology_init);

static const char *hwcap_str[] = {
	"fp",
	"asimd",
	NULL
};

static int c_show(struct seq_file *m, void *v)
{
	int i;

	seq_printf(m, "Processor\t: %s rev %d (%s)\n",
		   cpu_name, read_cpuid_id() & 15, ELF_PLATFORM);

	for_each_online_cpu(i) {
		/*
		 * glibc reads /proc/cpuinfo to determine the number of
		 * online processors, looking for lines beginning with
		 * "processor".  Give glibc what it expects.
		 */
#ifdef CONFIG_SMP
		seq_printf(m, "processor\t: %d\n", i);
#endif
	}

	/* dump out the processor features */
	seq_puts(m, "Features\t: ");

	for (i = 0; hwcap_str[i]; i++)
		if (elf_hwcap & (1 << i))
			seq_printf(m, "%s ", hwcap_str[i]);

	seq_printf(m, "\nCPU implementer\t: 0x%02x\n", read_cpuid_id() >> 24);
	seq_printf(m, "CPU architecture: AArch64\n");
	seq_printf(m, "CPU variant\t: 0x%x\n", (read_cpuid_id() >> 20) & 15);
	seq_printf(m, "CPU part\t: 0x%03x\n", (read_cpuid_id() >> 4) & 0xfff);
	seq_printf(m, "CPU revision\t: %d\n", read_cpuid_id() & 15);

	seq_puts(m, "\n");

	seq_printf(m, "Hardware\t: %s\n", machine_name);

	return 0;
}

static void *c_start(struct seq_file *m, loff_t *pos)
{
	return *pos < 1 ? (void *)1 : NULL;
}

static void *c_next(struct seq_file *m, void *v, loff_t *pos)
{
	++*pos;
	return NULL;
}

static void c_stop(struct seq_file *m, void *v)
{
}

const struct seq_operations cpuinfo_op = {
	.start	= c_start,
	.next	= c_next,
	.stop	= c_stop,
	.show	= c_show
};

void arch_setup_pdev_archdata(struct platform_device *pdev)
{
	pdev->archdata.dma_mask = DMA_BIT_MASK(32);
	pdev->dev.dma_mask = &pdev->archdata.dma_mask;
}


text:
using System;
using System.Collections.Generic;
using System.Linq;

namespace ICSharpCode.NRefactory.CSharp.Refactoring
{
	[ContextAction("Create a backing field for a not implemented property", Description = "Creates a backing field for a not implemented property.")]
	public class ImplementNotImplementedProperty : CodeActionProvider
	{
		bool IsNotImplemented(RefactoringContext context, BlockStatement body)
		{
			if (body.IsNull)
				return true;
			if (body.Statements.Count == 1) {
				var throwStmt = body.Statements.First () as ThrowStatement;
				if (throwStmt != null) {
					return context.Resolve (throwStmt.Expression).Type.FullName == "System.NotImplementedException";
				}
			}
			return false;
		}

		public override IEnumerable<CodeAction> GetActions(RefactoringContext context)
		{
			var property = context.GetNode<PropertyDeclaration> ();
			if (property == null || !property.NameToken.Contains(context.Location))
				yield break;

			if (!IsNotImplemented (context, property.Getter.Body) ||
			    !IsNotImplemented (context, property.Setter.Body)) {
				yield break;
			}

			yield return new CodeAction(context.TranslateString("Implement property"), script => {
				string backingStoreName = context.GetNameProposal (property.Name);

				// create field
				var backingStore = new FieldDeclaration ();
				if (property.Modifiers.HasFlag (Modifiers.Static))
					backingStore.Modifiers |= Modifiers.Static;

				if (property.Setter.IsNull)
					backingStore.Modifiers |= Modifiers.Readonly;

				backingStore.ReturnType = property.ReturnType.Clone ();

				var initializer = new VariableInitializer (backingStoreName);
				backingStore.Variables.Add (initializer);

				// create new property & implement the get/set bodies
				var newProperty = (PropertyDeclaration)property.Clone ();
				Expression id1;
				if (backingStoreName == "value")
					id1 = new ThisReferenceExpression().Member("value");
				else
					id1 = new IdentifierExpression (backingStoreName);
				Expression id2 = id1.Clone();
				newProperty.Getter.Body = new BlockStatement () {
					new ReturnStatement (id1)
				};
				if (!property.Setter.IsNull) {
					newProperty.Setter.Body = new BlockStatement () {
						new AssignmentExpression (id2, AssignmentOperatorType.Assign, new IdentifierExpression ("value"))
					};
				}

				script.Replace (property, newProperty);
				script.InsertBefore (property, backingStore);
				if (!property.Setter.IsNull)
					script.Link (initializer, id1, id2);
				else
					script.Link (initializer, id1);
			}, property.NameToken);
		}
	}
}


text:
Data sheet for import

- New entries
- Features:
  - Format of taxon name: Genus  + Species epithet
  - Type status information
  - Separation of collectors
  - Revision data
  - "Not in collection" as transaction (transaction needs to be specified before import!)

##### Preview of imported data in DiversityCollection:

![Preview](https://github.com/ZFMK/Labels-and-Imports-for-DiversityWorkbench/blob/screenshots/preview/herp_example.png)

[Detailed Description of Import schedule for Herpetology (pdf)](https://github.com/BKlasen/Labels-and-Imports-for-DiversityWorkbench/blob/master/ImportSchedules/Herpetology/Description_Import_Schedule_Herpetology_ZFMK.pdf)


text:
<resources>
    <string name="app_name">swipedeck</string>
</resources>


text:
\set frequencia_atirador_campos 'id, controle, cr, calibre, arma_utilizada, numero_serie, guia_de_trafego, quantidade_municao, data_inicio, data_termino, data_criacao, data_atualizacao, data_confirmacao, imagem_numero_controle, imagem_confirmacao, revisao'
\set frequencia_atirador_log_campos 'id_log, acao, id_frequencia_atirador, controle, cr, calibre, arma_utilizada, numero_serie, guia_de_trafego, quantidade_municao, data_inicio, data_termino, data_criacao, data_atualizacao, data_confirmacao, imagem_numero_controle, imagem_confirmacao, revisao'
\set frq_campos 'frq.id, frq.controle, frq.cr, frq.calibre, frq.arma_utilizada, frq.numero_serie, frq.guia_de_trafego, frq.quantidade_municao, frq.data_inicio, frq.data_termino, frq.data_criacao, frq.data_atualizacao, frq.data_confirmacao, frq.imagem_numero_controle, frq.imagem_confirmacao, revisao'
\set log_campos 'id, data_criacao, endereco_remoto'

--
-- Frequência sem confirmação
--

WITH

frq AS (
  INSERT INTO frequencia_atirador (:frequencia_atirador_campos)
  VALUES (DEFAULT, 1234, 380308, '.380', 'Arma do Clube', 'HG72643653', 762556223, 100,
  NOW() - interval '2 hour', -- data inicio
  NOW() - interval '30 minutes', -- data término
  NOW() - interval '29 minutes', -- data criação
  NULL, -- data atualização
  NULL, -- data confirmação
  'iVBORw0KGgoAAAANSUhEUgAAAA0AAAANAQAAAABakNnRAAAABGdBTUEAALGPC/xhBQAAAAFzUkdCAK7OHOkAAAAgY0hSTQAAeiYAAICEAAD6AAAAgOgAAHUwAADqYAAAOpgAABdwnLpRPAAAAAJiS0dEAAHdihOkAAAACXBIWXMAAABIAAAASABGyWs+AAAAG0lEQVQI12P4/4Oht4Ph7g4wgjFWrWAIDUAmAWzDEKvudB5PAAAAAElFTkSuQmCC',
  NULL, 0) RETURNING *
),

idLog AS (
  INSERT INTO log (:log_campos)
  VALUES (DEFAULT, NOW() - interval '29 minutes', '198.51.100.1')
  RETURNING id
)

INSERT INTO frequencia_atirador_log (:frequencia_atirador_log_campos)
SELECT idLog.id, 'CRIACAO', :frq_campos
FROM idLog, frq;

--
-- Frequência sem confirmação expirada
--

WITH

frq AS (
  INSERT INTO frequencia_atirador (:frequencia_atirador_campos)
  VALUES (DEFAULT, 7344, 923714, '.45', 'Imbel 1911', 'SF9153921', 839201286, 150,
  NOW() - interval '2 hour', -- data inicio
  NOW() - interval '40 minutes', -- data término
  NOW() - interval '31 minutes', -- data criação
  NULL, -- data atualização
  NULL, -- data confirmação
  'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAi0lEQVR4Xo2PIQ4CMRBF24QDIZEILHJXcQFSsxssGg2KC2A5QGVlT9FrzNZ8mIT87HQhYZKX5v+Zdvo9APdPrVrjMNx583E9ejYAkD7cUEohqj89+2KtVTH662qR6Y0Y3a4m2+6MnDP0nPl2cLM/IaVEVC8G17uAGOMC9U0Ymez/Zj7DMOF4ebpf9QJNxJnbJOlfVQAAAABJRU5ErkJggg==',
  NULL, 0) RETURNING *
),

idLog AS (
  INSERT INTO log (:log_campos)
  VALUES (DEFAULT, NOW() - interval '31 minutes', '198.51.100.2')
  RETURNING id
)

INSERT INTO frequencia_atirador_log (:frequencia_atirador_log_campos)
SELECT idLog.id, 'CRIACAO', :frq_campos
FROM idLog, frq;

--
-- Frequência com confirmação
--

WITH

idFrq AS (
  INSERT INTO frequencia_atirador (:frequencia_atirador_campos)
  VALUES (DEFAULT, 1246, 114239, '.40', 'Imbel MD2', 'DL28461184', 102483466, 50,
  NOW() - interval '5 hours', -- data inicio
  NOW() - interval '4 hours' - interval '30 minutes', -- data término
  NOW() - interval '10 minutes', -- data criação
  NOW() - interval '5 minutes', -- data atualização
  NOW() - interval '5 minutes', -- data confirmação
  'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAUklEQVR4XqWQ0QmAMAxEL8FhdIp2Hvep87hFxzm5D6GE0ip9kI/A5XHESCJfBzHgPqtZKjvxAe9cawbBCVtrEmFX///G9zKaFjtGc8T1TExQ5gHN9xsWe3/FugAAAABJRU5ErkJggg==',
  'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAATElEQVR4XpWPCwoAIAhDswPrWTyxMcKEBn2EwYPG0yQi2st0gJllO5kHRlUNBIwsrkzjbnN3AdPqc5lXV/gMNqYt7cn9Vvr+NT0k7xkVBY1RndW3lwAAAABJRU5ErkJggg==',
  1) RETURNING id
),

idLog1 AS (
  INSERT INTO log (:log_campos)
  VALUES (DEFAULT, NOW() - interval '4 hours' - interval '10 minutes', '198.51.100.3')
  RETURNING id
),

idLog2 AS (
  INSERT INTO log (:log_campos)
  VALUES (DEFAULT, NOW() - interval '4 hours' - interval '5 minutes', '198.51.100.3')
  RETURNING id
)

INSERT INTO frequencia_atirador_log (:frequencia_atirador_log_campos) VALUES

((SELECT id FROM idLog1), 'CRIACAO', (SELECT id FROM idFrq), 1246, 114239, '.40',
'Imbel MD2', 'DL28461184', 102483466, 50,
NOW() - interval '5 hours', -- data inicio
NOW() - interval '4 hours' - interval '30 minutes', -- data término
NOW() - interval '10 minutes', -- data criação
NULL, -- data atualização
NULL, -- data confirmação
'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAUklEQVR4XqWQ0QmAMAxEL8FhdIp2Hvep87hFxzm5D6GE0ip9kI/A5XHESCJfBzHgPqtZKjvxAe9cawbBCVtrEmFX///G9zKaFjtGc8T1TExQ5gHN9xsWe3/FugAAAABJRU5ErkJggg==',
NULL, 0),

((SELECT id FROM idLog2), 'ATUALIZACAO', (SELECT id FROM idFrq), 1246, 114239, '.40',
'Imbel MD2', 'DL28461184', 102483466, 50,
NOW() - interval '5 hours', -- data inicio
NOW() - interval '4 hours' - interval '30 minutes', -- data término
NOW() - interval '10 minutes', -- data criação
NOW() - interval '5 minutes', -- data atualização
NOW() - interval '5 minutes', -- data confirmação
'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAUklEQVR4XqWQ0QmAMAxEL8FhdIp2Hvep87hFxzm5D6GE0ip9kI/A5XHESCJfBzHgPqtZKjvxAe9cawbBCVtrEmFX///G9zKaFjtGc8T1TExQ5gHN9xsWe3/FugAAAABJRU5ErkJggg==',
'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAATElEQVR4XpWPCwoAIAhDswPrWTyxMcKEBn2EwYPG0yQi2st0gJllO5kHRlUNBIwsrkzjbnN3AdPqc5lXV/gMNqYt7cn9Vvr+NT0k7xkVBY1RndW3lwAAAABJRU5ErkJggg==',
1);


text:
package com.adaptris.core.services.jmx;

import javax.management.MBeanServerConnection;
import javax.management.ObjectName;

public class JmxOperationInvoker<T> {

  public T invoke(MBeanServerConnection mbeanConn, String objectName, String methodName, Object[] params, String[] signatures)
      throws Exception {
    return (T) invoke(mbeanConn, ObjectName.getInstance(objectName), methodName, params, signatures);
  }

  public T invoke(MBeanServerConnection mbeanConn, ObjectName objectName, String methodName, Object[] params,
      String[] signatures)
      throws Exception {
    return (T) mbeanConn.invoke(objectName, methodName, params, signatures);
  }

}


text:
draw2d.BusinessRuleTask=function(configPropCallback){
	draw2d.Task.call(this,configPropCallback);
	this.setDimension(170,60);
	this.setTitle("业务规则任务");
	this.ruleName=null;
	this.inputVariable=null;
	this.excluded=null;
	this.resultVariable=null;
};
draw2d.BusinessRuleTask.prototype=new draw2d.Task();
draw2d.BusinessRuleTask.prototype.type="draw2d.BusinessRuleTask";
draw2d.BusinessRuleTask.prototype.getIconClassName = function(){
	return "business-rule-task-icon";
};
draw2d.BusinessRuleTask.prototype.getStartElementXML=function(){
	var xml='<businessRuleTask ';
	xml=xml+this.getGeneralXML();
	xml=xml+this.getMainConfigXML();
	xml=xml+'>\n';
	return xml;
};
draw2d.BusinessRuleTask.prototype.getMainConfigXML=function(){
	var xml='';
	if(this.inputVariable!=null&&this.inputVariable!='')
		xml=xml+' activiti:ruleVariablesInput="'+this.inputVariable+'"';
	if(this.ruleName!=null&&this.ruleName!='')
		xml=xml+' activiti:rules="'+this.ruleName+'"';
	if(this.resultVariable!=null&&this.resultVariable!='')
		xml=xml+' activiti:resultVariable="'+this.resultVariable+'"';
	if(this.excluded!=null&&this.excluded!='')
		xml=xml+' activiti:exclude="'+this.excluded+'"';
	return xml;
}
draw2d.BusinessRuleTask.prototype.getEndElementXML=function(){
	var xml = '</businessRuleTask>\n';
	return xml;
};
draw2d.BusinessRuleTask.prototype.toXML=function(){
	var xml=this.getStartElementXML();
	xml=xml+this.getExtensionElementsXML();
	xml=xml+this.getMultiInstanceXML();
	xml=xml+this.getEndElementXML();
	return xml;
}


text:
package com.navercorp.pinpoint.profiler.context;

import com.navercorp.pinpoint.profiler.context.id.TraceRoot;

/**
 * @author Woonduk Kang(emeroad)
 */
public class CallStackFactoryV1 implements CallStackFactory {

    private final int maxDepth;

    public CallStackFactoryV1(int maxDepth) {
        this.maxDepth = maxDepth;
    }

    @Override
    public CallStack newCallStack(TraceRoot traceRoot) {
        return new DepthCompressCallStack(traceRoot, maxDepth);
    }
}


text:
app.controller('HomeAdminCtrl', ['$scope', '$http', function($scope, $http) {

    $scope.transactions = [];
    $scope.users = {};
    $scope.status = [];

    function init() {
        $http.get(baseUrl+'/transactions/all', {}).then(function(response) {
            $scope.transactions = response.data;
        }, function() {

        });

        $http.get(baseUrl+'/users/hashed_users', {}).then(function(response) {
            $scope.users = response.data;
        }, function() {

        });

        $http.get(baseUrl+'/statuses/all', {}).then(function(response) {
            $scope.status = response.data;
        }, function() {

        });
    }

    $scope.removeTransaction = function(item) {
        var r = confirm("Are you sure you want to delete this transactions? This cannot be undone.");
        if (r == true) {
            $scope.transactions = [];
            var data = {
                transaction_id: item.id
            };
            $http.post(baseUrl+'/transactions/delete', data, {}).then(function(response) {
                $scope.transactions = response.data;
            }, function() {

            });
        }
    };

    $scope.updateTransaction = function(item) {
        var r = confirm("Are you sure you want to update this transactions? This cannot be undone.");
        if (r == true) {
            $scope.transactions = [];
            var data = {
                transaction_id: item.id,
                status_id: item.status_id + 1
            };
            $http.post(baseUrl+'/transactions/update', data, {}).then(function(response) {
                $scope.transactions = response.data;
            }, function() {

            });
        }
    };

    angular.element(document).ready(function () {
        init();
    });

}]);


text:
#ifndef DRIVERS_LED_H_
#define DRIVERS_LED_H_

/*
 * function to set/clear red, yellow, and green LEDs
 */
void set_leds(unsigned char r, unsigned char y, unsigned char g);

/*
 * function to toggle current value of red, yellow, and/or green LEDs
 */
void toggle_leds(uint8_t r, uint8_t y, uint8_t g);

/*
 * function to set/clear red, yellow, and/or green LEDs
 */
void set_led(uint8_t leds, uint8_t val);

#endif /* DRIVERS_LED_H_ */


text:
/**
 */
package isostdisois_13584_32ed_1techxmlschemaontomlSimplified.impl;

import java.util.Collection;

import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
import org.eclipse.emf.ecore.util.EObjectContainmentEList;
import org.eclipse.emf.ecore.util.InternalEList;

import isostdisois_13584_32ed_1techxmlschemaontomlSimplified.CLASSCONSTANTVALUES;
import isostdisois_13584_32ed_1techxmlschemaontomlSimplified.CLASSVALUEASSIGNMENT;
import isostdisois_13584_32ed_1techxmlschemaontomlSimplified.Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage;

/**
 *
 * An implementation of the model object 'CLASSCONSTANTVALUES'.
 *
 *

 * The following features are implemented:
 *

 *

 *
{@link isostdisois_13584_32ed_1techxmlschemaontomlSimplified.impl.CLASSCONSTANTVALUESImpl#getClassValueAssignments Class Value Assignments}

 *

 *
 * @generated
 */
public class CLASSCONSTANTVALUESImpl extends MinimalEObjectImpl.Container implements CLASSCONSTANTVALUES {
	/**
	 * The cached value of the '{@link #getClassValueAssignments() Class Value Assignments}' containment reference list.
	 *
	 *
	 * @see #getClassValueAssignments()
	 * @generated
	 * @ordered
	 */
	protected EList<CLASSVALUEASSIGNMENT> classValueAssignments;

	/**
	 *
	 *
	 * @generated
	 */
	protected CLASSCONSTANTVALUESImpl() {
		super();
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	protected EClass eStaticClass() {
		return Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.Literals.CLASSCONSTANTVALUES;
	}

	/**
	 *
	 *
	 * @generated
	 */
	public EList<CLASSVALUEASSIGNMENT> getClassValueAssignments() {
		if (classValueAssignments == null) {
			classValueAssignments = new EObjectContainmentEList<CLASSVALUEASSIGNMENT>(CLASSVALUEASSIGNMENT.class, this, Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.CLASSCONSTANTVALUES__CLASS_VALUE_ASSIGNMENTS);
		}
		return classValueAssignments;
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs) {
		switch (featureID) {
			case Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.CLASSCONSTANTVALUES__CLASS_VALUE_ASSIGNMENTS:
				return ((InternalEList<?>)getClassValueAssignments()).basicRemove(otherEnd, msgs);
		}
		return super.eInverseRemove(otherEnd, featureID, msgs);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public Object eGet(int featureID, boolean resolve, boolean coreType) {
		switch (featureID) {
			case Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.CLASSCONSTANTVALUES__CLASS_VALUE_ASSIGNMENTS:
				return getClassValueAssignments();
		}
		return super.eGet(featureID, resolve, coreType);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@SuppressWarnings("unchecked")
	@Override
	public void eSet(int featureID, Object newValue) {
		switch (featureID) {
			case Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.CLASSCONSTANTVALUES__CLASS_VALUE_ASSIGNMENTS:
				getClassValueAssignments().clear();
				getClassValueAssignments().addAll((Collection<? extends CLASSVALUEASSIGNMENT>)newValue);
				return;
		}
		super.eSet(featureID, newValue);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public void eUnset(int featureID) {
		switch (featureID) {
			case Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.CLASSCONSTANTVALUES__CLASS_VALUE_ASSIGNMENTS:
				getClassValueAssignments().clear();
				return;
		}
		super.eUnset(featureID);
	}

	/**
	 *
	 *
	 * @generated
	 */
	@Override
	public boolean eIsSet(int featureID) {
		switch (featureID) {
			case Isostdisois_13584_32ed_1techxmlschemaontomlSimplifiedPackage.CLASSCONSTANTVALUES__CLASS_VALUE_ASSIGNMENTS:
				return classValueAssignments != null && !classValueAssignments.isEmpty();
		}
		return super.eIsSet(featureID);
	}

} //CLASSCONSTANTVALUESImpl


text:
```sh
    export HTTP_PROXY=

    sudo HTTP_PROXY=$HTTP_PROXY docker-compose build
    sudo HTTP_PROXY=$HTTP_PROXY docker-compose up -d

    sudo docker-compose exec web python report/manage.py createsuperuser
    sudo docker-compose exec web python report/manage.py generate_db
```


text:
$identify("org/mathdox/formulaeditor/modules/interval1/interval_multi.js");

$require("org/mathdox/formulaeditor/Options.js");
$require("org/mathdox/formulaeditor/presentation/Boxed.js");
$require("org/mathdox/formulaeditor/presentation/Bracket.js");
$require("org/mathdox/formulaeditor/presentation/Bracketed.js");
$require("org/mathdox/formulaeditor/presentation/PseudoRow.js");
$require("org/mathdox/formulaeditor/presentation/Row.js");
$require("org/mathdox/formulaeditor/presentation/Symbol.js");
$require("org/mathdox/formulaeditor/semantics/MultaryListOperation.js");

$main(function(){

  /**
   * Defines a semantic tree node that represents an interval.
   */
  org.mathdox.formulaeditor.semantics.Interval1Interval_multi =
    $extend(org.mathdox.formulaeditor.semantics.MultaryListOperation, {

      /* to be filled in by extending classes */
      symbol : null,
      leftOpen: null,
      rightOpen: null,
      className: null,

      getPresentation: function (context) {
        var presentation = org.mathdox.formulaeditor.presentation;
        var semantics = org.mathdox.formulaeditor.semantics;

	var contents = [];
	var children = [];
	var child;

	var option = context.optionInterval1Brackets;

	var bracket;

	if (this.leftOpen) {
	  bracket = option.lo;
	} else {
	  bracket = option.lc;
	}

	var left = new presentation.Bracket(bracket);

	child = new presentation.Row(this.operands[0].getPresentation(context));
	children.push(child);
	contents.push(child);

	/* use the fixed list separator string from the context */
	var listSep = context.listSeparatorFixed;

	var i;
	for (i = 0; i<listSep.length; i++) {
	  contents.push(new presentation.Symbol(listSep.charAt(i)));
	}

	child = new presentation.Row(this.operands[1].getPresentation(context));
	children.push(child);
	contents.push(child);

	if (this.rightOpen) {
	  bracket = option.ro;
	} else {
	  bracket = option.rc;
	}

        var right = new presentation.Bracket(bracket);
	var prow = new presentation.PseudoRow();
	prow.initialize.apply(prow, contents);

	var row = new presentation.Row(new presentation.Bracketed(left, prow, right));

	return new presentation.Boxed(semantics[this.className], children, row);
      }

    });
});


text:
package v1beta1

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/kubernetes/pkg/api/v1"
)

// GroupName is the group name use in this package
const GroupName = "authorization.k8s.io"

// SchemeGroupVersion is group version used to register these objects
var SchemeGroupVersion = schema.GroupVersion{Group: GroupName, Version: "v1beta1"}

// Resource takes an unqualified resource and returns a Group qualified GroupResource
func Resource(resource string) schema.GroupResource {
	return SchemeGroupVersion.WithResource(resource).GroupResource()
}

var (
	SchemeBuilder = runtime.NewSchemeBuilder(addKnownTypes, addDefaultingFuncs, addConversionFuncs)
	AddToScheme   = SchemeBuilder.AddToScheme
)

// Adds the list of known types to api.Scheme.
func addKnownTypes(scheme *runtime.Scheme) error {
	scheme.AddKnownTypes(SchemeGroupVersion,
		&v1.ListOptions{},
		&v1.DeleteOptions{},
		&metav1.ExportOptions{},
		&metav1.GetOptions{},

		&SelfSubjectAccessReview{},
		&SubjectAccessReview{},
		&LocalSubjectAccessReview{},
	)

	metav1.AddToGroupVersion(scheme, SchemeGroupVersion)
	return nil
}

func (obj *LocalSubjectAccessReview) GetObjectKind() schema.ObjectKind { return &obj.TypeMeta }
func (obj *SubjectAccessReview) GetObjectKind() schema.ObjectKind      { return &obj.TypeMeta }
func (obj *SelfSubjectAccessReview) GetObjectKind() schema.ObjectKind  { return &obj.TypeMeta }


text:
Vagrant.configure("2") do |config|

config.ssh.insert_key = false
config.ssh.forward_agent = true

end


text:
"""empty message

Revision ID: 4f5fcadcf2d
Revises: 32d7cc46df4
Create Date: 2015-10-22 12:52:30.316386

"""

# revision identifiers, used by Alembic.
revision = '4f5fcadcf2d'
down_revision = '32d7cc46df4'

from alembic import op
import sqlalchemy as sa

def upgrade():
    ### commands auto generated by Alembic - please adjust! ###
    op.drop_table('links')
    ### end Alembic commands ###

def downgrade():
    ### commands auto generated by Alembic - please adjust! ###
    op.create_table('links',
    sa.Column('id', sa.INTEGER(), nullable=False),
    sa.Column('department_id', sa.INTEGER(), autoincrement=False, nullable=False),
    sa.Column('title', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
    sa.Column('url', sa.VARCHAR(length=2083), autoincrement=False, nullable=False),
    sa.Column('type', sa.VARCHAR(length=255), autoincrement=False, nullable=False),
    sa.ForeignKeyConstraint(['department_id'], ['departments.id'], name='links_department_id_fkey'),
    sa.PrimaryKeyConstraint('id', name='links_pkey')
    )
    ### end Alembic commands ###


text:
@ECHO OFF

CALL ts-node "./server/main.ts"

PAUSE


text:
/** \defgroup mrpt_base_grp [mrpt-base]

 Back to list of all libraries | See all modules

Library mrpt-base

This is the most fundamental library in MRPT, since it provides a vast amount of utilities and OS-abstraction classes upon which
the rest of MRPT is built. Here resides critical functionality such as mathematics, linear algebra, serialization, smart pointers
and multi-threading.
l
This library comprises classes in a number of namespaces, briefly described below (click on the namespaces names to see the
complete list of its classes):

mrpt::poses

A comprehensive collection of geometry-related classes to represent all kind of 2D and 3D geomtry transformations in different formats
(Euler angles, rotation matrices, quaternions), as well as networks of pose constrains (as used typically in SLAM problems).

There are also implemented representations for probability distributions over all of these transformations, in a generic way that
allow mono and multi-modal Gaussians and particle-based representations.

See mrpt::poses for the complete list of classes here.

mrpt::utils

RTTI (RunTime Type Information): A cross-platform, compiler-independent RTTI system is built around the base class
mrpt::utils::CObject.

Smart pointers: Based on the STLplus library, any class CFoo inheriting from CObject, automatically has an associated smart
pointer class CFooPtr. MRPT implements advanced smart pointers capable of multi-thread safe usage and smart pointer typecasting with
runtime check for correct castings (tutorial).

Image handling: The class mrpt::utils::CImage represents a wrapper around OpenCV IplImage's, plus extra functionality
such as on-the-fly loading of images stored in disk upon first usage. The internal IplImage is always available so OpenCV's functions can
be still used to operate on MRPT images.

Serialization/Persistence: Object serialization in a simple but powerful (including versioning) format
is supported by dozens of MRPT classes, all based on mrpt::utils::CSerializable.

Streams: Stream classes (see the base mrpt::utils::CStream) allow serialization of MRPT objects. There are classes
for tranparent GZ-compressed files, sockets, serial ports, etc.

XML-based databases: Simple databases can be mantained, loaded and saved to files with mrpt::utils::CSimpleDatabase.

Name-based argument passing: See the structure mrpt::utils::TParameters

Configuration files: There is one base virtual class (mrpt::utils::CConfigFileBase) which can be used to read/write configuration
files (including basic types, vectors, matrices,...) from any "configuration source" transparently (an actual configuration file, a text block
created on the fly, etc.).

mrpt::math

MRPT defines a number of generic  math containers, which are:

Matrices: Dynamic-size matrices (see mrpt::math::CMatrixDouble) and compile-time fixed-size matrices (see mrpt::math::CMatrixFixedNumeric, mrpt::math::CMatrixDouble33, etc.).

Vectors: Dynamic-size vectors. See mrpt::vector_double, which inherits from a standard STL vector<double>.

Arrays: Fixed-size vectors, just like plain C arrays but with support for STL-like iterators and much more. See mrpt::math::CArrayDouble<>.

For a more in-depth description of these types, and their relation to the base Eigen classes,
read this page.

Notice that fixed-size containers should be preferred where possible, since they allow more compile-time optimizations.

Apart from the containers, this namespace contains much more functionality:

A templatized RANSAC algorithm.

Probability distribution functions.

Statistics: mean, covariance, covariance of weighted samples, etc... from sets of data.

A huge amount of geometry-related functions: Lines (mrpt::math::TLine3D), planes (mrpt::math::TPlane3D), segments, polygons, intersections between them, etc.

Graph-related stuff: generic directed graphs (mrpt::math::CDirectedGraph) and trees (mrpt::math::CDirectedTree).

PDF transformations (uncertainty propagation): See mrpt::math::transform_gaussian_linear, mrpt::math::transform_gaussian_montecarlo, mrpt::math::transform_gaussian_unscented.

A templatized implementation of quaternions, mrpt::math::CQuaternion, with support for rotation matrix convertions, Jacobians, etc.

mrpt::synch

This namespace includes threading tools such as critical sections, semaphores or utilities such as the template mrpt::synch::CThreadSafeVariable
that converts any variable into a pair variable-critical section.

mrpt::system

Here can be found functions for filesystem managing, watching directories, creating and handling threads in an OS-independent way, etc.

mrpt::compress

GZip compression methods can be found in this namespace.

*/


text:
cask :v1 => 'nitrous-desktop' do
  version :latest
  sha256 :no_check

  url 'https://www.nitrous.io/mac/NitrousDesktop-latest.zip'
  homepage 'https://www.nitrous.io/mac'
  license :unknown    # todo: improve this machine-generated value

  app 'Nitrous Desktop.app'
end


text:
using System.ComponentModel;

namespace RedEquation.Stark.Enums
{
    public enum ParameterDisplayWidth
    {
        [Description("0")]
        Zero,

        [Description("1")]
        One,

        [Description("2")]
        Two,

        [Description("3")]
        Three,

        [Description("4")]
        Four
    }
}


text:
{% load staticfiles %}
<!DOCTYPE html>

    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}ma.tt-thom.as{% endblock %}</title>
    <link rel="icon" href="{% static 'content/images/icons/favicon.ico' %}" type="image/x-icon"/>
    <link rel="shortcut icon" href="{% static 'content/images/icons/favicon.ico' %}" type="image/x-icon"/>
    <link rel="stylesheet" type="text/css" href="{% static 'content/bootstrap.min.css' %}" />
    <link rel="stylesheet" type="text/css" href="{% static 'content/font-awesome.min.css' %}" />
    <link rel="stylesheet" type="text/css" href="{% static 'content/site.css' %}" />
    {% block head %}
    {% endblock %}

        {% block header %}
        {% endblock %}

    {% block precontent %}
    {% endblock %}

        {% block content %}
        {% endblock %}

ma.tt-thom.as

    {% block scripts %}
    {% endblock %}


text:
typedef struct _LVHITTESTINFO {
    POINT Point;
    UINT32  flags;
    int   iItem;
    int   iSubItem;
    int   iGroup;
} LVHITTESTINFO;

typedef struct tagNMLISTVIEW
{
    NMHDR   hdr;
    int     iItem;
    int     iSubItem;
    UINT32    uNewState;
    UINT32    uOldState;
    UINT32    uChanged;
    POINT   ptAction;
    INT32  lParam;
} NMLISTVIEW, *LPNMLISTVIEW;
#define LVM_EDITLABELW          (LVM_FIRST + 118)
#define LVS_EX_GRIDLINES        0x00000001


text:
/*!
* \file FactorySQLFilm.hpp
* \brief Fichier contenant la définition de la classe FactorySQLFilm
* \author Camille Le Luët
* \author Thomas Minier
* \date 26.11.2014
*/
#ifndef FACTORYSQLFILM_H
#define FACTORYSQLFILM_H

#include "FactorySQL.hpp"
#include "../BDConnector/BDConnector.hpp"

//--------------------------------------------------
/*!
* \class FactorySQLFilm
* \brief Classe réalisant l'interface FactoryBD & instanciant des objets Film à partir d'une base Sqlite
*/

class FactorySQLFilm: public FactorySQL {

	private:
		//Attribut
		std::shared_ptr<BDConnector> bd; //!< Connecteur vers la base de donnée où sont stocké les informations
		//Méthode privée
		std::shared_ptr<Film> genererFilm(std::string id, std::string titre, std::string lien, int annee, std::string affiche, std::string synopsis, std::string pays, bool vu, bool aVoir);

	public:
		//Constructeur & destructeur
		FactorySQLFilm(std::shared_ptr<BDConnector> base);
		~FactorySQLFilm();
		//Méthode publique
		std::vector<std::shared_ptr<Video> > recupererAll();

};

//--------------------------------------------------
#endif


text:
#pragma once

#include "class-internals.h"

namespace il2cpp
{
namespace icalls
{
namespace System
{
namespace System
{
namespace Diagnostics
{

struct CategoryDesc
{
	const char *name;
	const char *help;
	unsigned char id;
	signed int type : 2;
	unsigned int instance_type : 6;
	short first_counter;
};

#define PERFCTR_CAT(id,name,help,type,inst,first_counter) CATEGORY_ ## id,
#define PERFCTR_COUNTER(id,name,help,type,field)
enum {
#include "perfcounters-def.h"
	NUM_CATEGORIES
};

#undef PERFCTR_CAT
#undef PERFCTR_COUNTER
#define PERFCTR_CAT(id,name,help,type,inst,first_counter) CATEGORY_START_ ## id = -1,
#define PERFCTR_COUNTER(id,name,help,type,field) COUNTER_ ## id,
/* each counter is assigned an id starting from 0 inside the category */
enum {
#include "perfcounters-def.h"
	END_COUNTERS
};

#undef PERFCTR_CAT
#undef PERFCTR_COUNTER
#define PERFCTR_CAT(id,name,help,type,inst,first_counter)
#define PERFCTR_COUNTER(id,name,help,type,field) CCOUNTER_ ## id,
/* this is used just to count the number of counters */
enum {
#include "perfcounters-def.h"
	NUM_COUNTERS
};

struct CounterDesc
{
	const char *name;
	const char *help;
	short id;
	unsigned short offset; // offset inside Il2CppPerfCounters
	int type;
};

enum {
	FTYPE_CATEGORY = 'C',
	FTYPE_DELETED = 'D',
	FTYPE_PREDEF_INSTANCE = 'P', // an instance of a predef counter
	FTYPE_INSTANCE = 'I',
	FTYPE_DIRTY = 'd',
	FTYPE_END = 0
};

struct SharedHeader
{
	unsigned char ftype;
	unsigned char extra;
	unsigned short size;
};

struct SharedCategory
{
	SharedHeader header;
	unsigned short num_counters;
	unsigned short counters_data_size;
	int num_instances;
	/* variable length data follows */
	char name[1];
	// string name
	// string help
	// SharedCounter counters_info [num_counters]
};

struct SharedInstance
{
	SharedHeader header;
	size_t category_offset;
	/* variable length data follows */
	char instance_name[1];
	// string name
};

struct SharedCounter
{
	unsigned char type;
	uint8_t seq_num;
	/* variable length data follows */
	char name[1];
	// string name
	// string help
};

struct CatSearch
{
	Il2CppString *name;
	SharedCategory *cat;
};

/* map of PerformanceCounterType.cs */
enum {
	NumberOfItemsHEX32 = 0x00000000,
	NumberOfItemsHEX64 = 0x00000100,
	NumberOfItems32 = 0x00010000,
	NumberOfItems64 = 0x00010100,
	CounterDelta32 = 0x00400400,
	CounterDelta64 = 0x00400500,
	SampleCounter = 0x00410400,
	CountPerTimeInterval32 = 0x00450400,
	CountPerTimeInterval64 = 0x00450500,
	RateOfCountsPerSecond32 = 0x10410400,
	RateOfCountsPerSecond64 = 0x10410500,
	RawFraction = 0x20020400,
	CounterTimer = 0x20410500,
	Timer100Ns = 0x20510500,
	SampleFraction = 0x20C20400,
	CounterTimerInverse = 0x21410500,
	Timer100NsInverse = 0x21510500,
	CounterMultiTimer = 0x22410500,
	CounterMultiTimer100Ns = 0x22510500,
	CounterMultiTimerInverse = 0x23410500,
	CounterMultiTimer100NsInverse = 0x23510500,
	AverageTimer32 = 0x30020400,
	ElapsedTime = 0x30240500,
	AverageCount64 = 0x40020500,
	SampleBase = 0x40030401,
	AverageBase = 0x40030402,
	RawBase = 0x40030403,
	CounterMultiBase = 0x42030500
};

/* maps a small integer type to the counter types above */
static const int simple_type_to_type[] =
{
	NumberOfItemsHEX32, NumberOfItemsHEX64,
	NumberOfItems32, NumberOfItems64,
	CounterDelta32, CounterDelta64,
	SampleCounter, CountPerTimeInterval32,
	CountPerTimeInterval64, RateOfCountsPerSecond32,
	RateOfCountsPerSecond64, RawFraction,
	CounterTimer, Timer100Ns,
	SampleFraction, CounterTimerInverse,
	Timer100NsInverse, CounterMultiTimer,
	CounterMultiTimer100Ns, CounterMultiTimerInverse,
	CounterMultiTimer100NsInverse, AverageTimer32,
	ElapsedTime, AverageCount64,
	SampleBase, AverageBase,
	RawBase, CounterMultiBase
};

enum {
	SingleInstance,
	MultiInstance,
	CatTypeUnknown = -1
};

enum {
	ProcessInstance,
	ThreadInstance,
	CPUInstance,
	MonoInstance,
	NetworkInterfaceInstance,
	CustomInstance
};

/* map of CounterSample.cs */
struct Il2CppCounterSample {
	int64_t rawValue;
	int64_t baseValue;
	int64_t counterFrequency;
	int64_t systemFrequency;
	int64_t timeStamp;
	int64_t timeStamp100nSec;
	int64_t counterTimeStamp;
	int counterType;
};

#undef PERFCTR_CAT
#undef PERFCTR_COUNTER
#define PERFCTR_CAT(id,name,help,type,inst,first_counter) {name, help, CATEGORY_ ## id, type, inst ## Instance, CCOUNTER_ ## first_counter},
#define PERFCTR_COUNTER(id,name,help,type,field)
static const CategoryDesc
predef_categories[] = {
	/* sample runtime counter */
#include "perfcounters-def.h"
{ NULL, NULL, NUM_CATEGORIES, -1, 0, NUM_COUNTERS }
};

#undef PERFCTR_CAT
#undef PERFCTR_COUNTER
#define PERFCTR_CAT(id,name,help,type,inst,first_counter)
#define PERFCTR_COUNTER(id,name,help,type,field) {name, help, COUNTER_ ## id, offsetof (Il2CppPerfCounters, field), type},
static const CounterDesc
predef_counters[] = {
#include "perfcounters-def.h"
{ NULL, NULL, -1, 0, 0 }
};
/*
* We have several different classes of counters:
* *) system counters
* *) runtime counters
* *) remote counters
* *) user-defined counters
* *) windows counters (the implementation on windows will use this)
*
* To easily handle the differences we create a vtable for each class that contains the
* function pointers with the actual implementation to access the counters.
*/
typedef struct _ImplVtable ImplVtable;

typedef bool(*SampleFunc) (ImplVtable *vtable, bool only_value, Il2CppCounterSample* sample);
typedef uint64_t(*UpdateFunc) (ImplVtable *vtable, bool do_incr, int64_t value);
typedef void(*CleanupFunc) (ImplVtable *vtable);

struct _ImplVtable {
	void *arg;
	SampleFunc sample;
	UpdateFunc update;
	CleanupFunc cleanup;
};

struct CustomVTable
{
	ImplVtable vtable;
	SharedInstance *instance_desc;
	SharedCounter *counter_desc;
};

const CategoryDesc* find_category(Il2CppString *category);
const CounterDesc* get_counter_in_category(const CategoryDesc *desc, Il2CppString *counter);
ImplVtable* create_vtable(void *arg, SampleFunc sample, UpdateFunc update);

} /* namespace Diagnostics */
} /* namespace System */
} /* namespace System */
} /* namespace icalls */
} /* namespace il2cpp */


text:
import {Fraction} from "../../Common/DataObjects/Fraction";
import {Voice} from "./Voice";
import {SourceStaffEntry} from "./SourceStaffEntry";
import {Note} from "./Note";
import {Pitch} from "../../Common/DataObjects/Pitch";
import {LyricsEntry} from "./Lyrics/LyricsEntry";
import {TechnicalInstruction} from "./Instructions/TechnicalInstruction";
import {OrnamentContainer} from "./OrnamentContainer";
import {KeyInstruction} from "./Instructions/KeyInstruction";
import {OrnamentEnum} from "./OrnamentContainer";
import {AccidentalEnum} from "../../Common/DataObjects/Pitch";
import { Dictionary } from "typescript-collections";
import {Arpeggio} from "./Arpeggio";
import { SourceMeasure } from "./SourceMeasure";
import { Articulation } from "./Articulation";

/**
 * A [[VoiceEntry]] contains the notes in a voice at a timestamp.
 */
export class VoiceEntry {
    /**
     *
     * @param timestamp The relative timestamp within the source measure.
     * @param parentVoice
     * @param parentSourceStaffEntry
     * @param isGrace States whether the VoiceEntry has (only) grace notes.
     * @param graceNoteSlash States whether the grace note(s) have a slash (Acciaccatura, played before the beat)
     */
    constructor(timestamp: Fraction, parentVoice: Voice, parentSourceStaffEntry: SourceStaffEntry,
                isGrace: boolean = false, graceNoteSlash: boolean = false, graceSlur: boolean = false) {
        this.timestamp = timestamp;
        this.parentVoice = parentVoice;
        this.parentSourceStaffEntry = parentSourceStaffEntry;
        this.isGrace = isGrace;
        this.graceAfterMainNote = false;
        this.graceNoteSlash = graceNoteSlash;
        this.graceSlur = graceSlur;

        // add currentVoiceEntry to staff entry:
        if (parentSourceStaffEntry !== undefined) {
            const list: VoiceEntry[] = parentSourceStaffEntry.VoiceEntries;
            if (list.indexOf(this) === -1) {
                list.push(this);
            }
        }
    }

    private parentVoice: Voice;
    private parentSourceStaffEntry: SourceStaffEntry;
    private timestamp: Fraction;
    private notes: Note[] = [];
    private isGrace: boolean;
    /** States whether the grace notes come after a main note (at end of measure). */
    private graceAfterMainNote: boolean;
    private graceNoteSlash: boolean;
    private graceSlur: boolean; // TODO grace slur system could be refined to be non-binary
    private articulations: Articulation[] = [];
    private technicalInstructions: TechnicalInstruction[] = [];
    private lyricsEntries: Dictionary<number, LyricsEntry> = new Dictionary<number, LyricsEntry>();
    /** The Arpeggio consisting of this VoiceEntry's notes. Undefined if no arpeggio exists. */
    private arpeggio: Arpeggio;
    private ornamentContainer: OrnamentContainer;
    private wantedStemDirection: StemDirectionType = StemDirectionType.Undefined;
    /** Stem direction specified in the xml stem element. */
    private stemDirectionXml: StemDirectionType = StemDirectionType.Undefined;
    private stemDirection: StemDirectionType = StemDirectionType.Undefined;
    /** Color of the stem given in XML. RGB Hexadecimal, like #00FF00. */
    private stemColorXml: string;
    /** Color of the stem currently set. RGB Hexadecimal, like #00FF00. */
    private stemColor: string;

    public get ParentSourceStaffEntry(): SourceStaffEntry {
        return this.parentSourceStaffEntry;
    }
    public get ParentVoice(): Voice {
        return this.parentVoice;
    }
    public get Timestamp(): Fraction {
        return this.timestamp;
    }
    public set Timestamp(value: Fraction) {
        this.timestamp = value;
    }
    public get Notes(): Note[] {
        return this.notes;
    }
    public get IsGrace(): boolean {
        return this.isGrace;
    }
    public set IsGrace(value: boolean) {
        this.isGrace = value;
    }
    public get GraceAfterMainNote(): boolean {
        return this.graceAfterMainNote;
    }
    public set GraceAfterMainNote(value: boolean) {
        this.graceAfterMainNote = value;
    }
    public get GraceNoteSlash(): boolean {
        return this.graceNoteSlash;
    }
    public set GraceNoteSlash(value: boolean) {
        this.graceNoteSlash = value;
    }
    public get GraceSlur(): boolean {
        return this.graceSlur;
    }
    public set GraceSlur(value: boolean) {
        this.graceSlur = value;
    }
    public get Articulations(): Articulation[] {
        return this.articulations;
    }
    public set Articulations(value: Articulation[]) {
        this.articulations = value;
    }
    public get TechnicalInstructions(): TechnicalInstruction[] {
        return this.technicalInstructions;
    }
    public get LyricsEntries(): Dictionary<number, LyricsEntry> {
        return this.lyricsEntries;
    }
    public get Arpeggio(): Arpeggio {
        return this.arpeggio;
    }
    public set Arpeggio(value: Arpeggio) {
        this.arpeggio = value;
    }
    public get OrnamentContainer(): OrnamentContainer {
        return this.ornamentContainer;
    }
    public set OrnamentContainer(value: OrnamentContainer) {
        this.ornamentContainer = value;
    }

    // WantedStemDirection provides the stem direction to VexFlow in case of more than 1 voice
    // for optimal graphical appearance
    public set WantedStemDirection(value: StemDirectionType) {
        this.wantedStemDirection = value;
    }
    public get WantedStemDirection(): StemDirectionType {
        return this.wantedStemDirection;
    }
    public set StemDirectionXml(value: StemDirectionType) {
        this.stemDirectionXml = value;
    }
    public get StemDirectionXml(): StemDirectionType {
        return this.stemDirectionXml;
    }
    // StemDirection holds the actual value of the stem
    public set StemDirection(value: StemDirectionType) {
        this.stemDirection = value;
    }
    public get StemDirection(): StemDirectionType {
        return this.stemDirection;
    }
    public get StemColorXml(): string {
        return this.stemColorXml;
    }
    public set StemColorXml(value: string) {
        this.stemColorXml = value;
    }
    public get StemColor(): string {
        return this.stemColor;
    }
    public set StemColor(value: string) {
        this.stemColor = value;
    }

    public hasArticulation(articulation: Articulation): boolean {
        for (const existingArticulation of this.articulations) {
            if (existingArticulation.Equals(articulation)) {
                return true;
            }
        }
        return false;
    }
    public static isSupportedArticulation(articulation: ArticulationEnum): boolean {
        switch (articulation) {
            case ArticulationEnum.accent:
            case ArticulationEnum.strongaccent:
            case ArticulationEnum.softaccent:
            case ArticulationEnum.invertedstrongaccent:
            case ArticulationEnum.staccato:
            case ArticulationEnum.staccatissimo:
            case ArticulationEnum.spiccato:
            case ArticulationEnum.tenuto:
            case ArticulationEnum.fermata:
            case ArticulationEnum.invertedfermata:
            case ArticulationEnum.breathmark:
            case ArticulationEnum.caesura:
            case ArticulationEnum.lefthandpizzicato:
            case ArticulationEnum.naturalharmonic:
            case ArticulationEnum.snappizzicato:
            case ArticulationEnum.upbow:
            case ArticulationEnum.downbow:
            case ArticulationEnum.bend:
                return true;
            default:
                return false;
        }
    }
    public hasTie(): boolean {
        for (let idx: number = 0, len: number = this.Notes.length; idx < len; ++idx) {
            const note: Note = this.Notes[idx];
            if (note.NoteTie) { return true; }
        }
        return false;
    }
    public hasSlur(): boolean {
        for (let idx: number = 0, len: number = this.Notes.length; idx < len; ++idx) {
            const note: Note = this.Notes[idx];
            if (note.NoteSlurs.length > 0) { return true; }
        }
        return false;
    }
    public isStaccato(): boolean {
        for (const articulation of this.Articulations) {
            if (articulation.articulationEnum === ArticulationEnum.staccato) {
                return true;
            }
        }
        return false;
    }
    public isAccent(): boolean {
        for (const articulation of this.Articulations) {
            if (articulation.articulationEnum === ArticulationEnum.accent || articulation.articulationEnum === ArticulationEnum.strongaccent) {
                return true;
            }
        }
        return false;
    }
    public getVerseNumberForLyricEntry(lyricsEntry: LyricsEntry): number {
        let verseNumber: number = 1;
        this.lyricsEntries.forEach((key: number, value: LyricsEntry): void => {
            if (lyricsEntry === value) {
                verseNumber = key;
            }
        });
        return verseNumber;
    }
    //public createVoiceEntriesForOrnament(activeKey: KeyInstruction): VoiceEntry[] {
    //    return this.createVoiceEntriesForOrnament(this, activeKey);
    //}
    public createVoiceEntriesForOrnament(voiceEntryWithOrnament: VoiceEntry, activeKey: KeyInstruction): VoiceEntry[] {
        if (!voiceEntryWithOrnament) {
            voiceEntryWithOrnament = this;
        }
        const voiceEntries: VoiceEntry[] = [];
        if (!voiceEntryWithOrnament.ornamentContainer) {
            return;
        }
        const baseNote: Note = this.notes[0];
        const baselength: Fraction = baseNote.Length;
        const baseVoice: Voice = voiceEntryWithOrnament.ParentVoice;
        const baseTimestamp: Fraction = voiceEntryWithOrnament.Timestamp;
        let currentTimestamp: Fraction = Fraction.createFromFraction(baseTimestamp);
        //let length: Fraction;
        switch (voiceEntryWithOrnament.ornamentContainer.GetOrnament) {
            case OrnamentEnum.Trill: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 8);
                const higherPitch: Pitch = baseNote.Pitch.getTransposedPitch(1);
                let alteration: AccidentalEnum = activeKey.getAlterationForPitch(higherPitch);
                if (voiceEntryWithOrnament.OrnamentContainer.AccidentalAbove !== AccidentalEnum.NONE) {
                    alteration = voiceEntryWithOrnament.ornamentContainer.AccidentalAbove;
                }
                for (let i: number = 0; i < 8; i++) {
                    currentTimestamp = Fraction.plus(baseTimestamp, new Fraction(i * length.Numerator, length.Denominator));
                    if ((i % 2) === 0) {
                        this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                    } else {
                        this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, higherPitch, alteration, voiceEntries);
                    }
                }
                break;
            }
            case OrnamentEnum.Turn: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 4);
                const lowerPitch: Pitch = baseNote.Pitch.getTransposedPitch(-1);
                const lowerAlteration: AccidentalEnum = activeKey.getAlterationForPitch(lowerPitch);
                const higherPitch: Pitch = baseNote.Pitch.getTransposedPitch(1);
                const higherAlteration: AccidentalEnum = activeKey.getAlterationForPitch(higherPitch);
                this.createAlteratedVoiceEntry(
                    currentTimestamp, length, baseVoice, baseNote.SourceMeasure, higherPitch, higherAlteration, voiceEntries
                );
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp.Add(length);
                this.createAlteratedVoiceEntry(
                    currentTimestamp, length, baseVoice, baseNote.SourceMeasure, lowerPitch, lowerAlteration, voiceEntries
                );
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                break;
            }
            case OrnamentEnum.InvertedTurn: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 4);
                const lowerPitch: Pitch = baseNote.Pitch.getTransposedPitch(-1);
                const lowerAlteration: AccidentalEnum = activeKey.getAlterationForPitch(lowerPitch);
                const higherPitch: Pitch = baseNote.Pitch.getTransposedPitch(1);
                const higherAlteration: AccidentalEnum = activeKey.getAlterationForPitch(higherPitch);
                this.createAlteratedVoiceEntry(
                    currentTimestamp, length, baseVoice, baseNote.SourceMeasure, lowerPitch, lowerAlteration, voiceEntries
                );
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp.Add(length);
                this.createAlteratedVoiceEntry(
                    currentTimestamp, length, baseVoice, baseNote.SourceMeasure, higherPitch, higherAlteration, voiceEntries
                );
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                break;
            }
            case OrnamentEnum.DelayedTurn: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 2);
                const lowerPitch: Pitch = baseNote.Pitch.getTransposedPitch(-1);
                const lowerAlteration: AccidentalEnum = activeKey.getAlterationForPitch(lowerPitch);
                const higherPitch: Pitch = baseNote.Pitch.getTransposedPitch(1);
                const higherAlteration: AccidentalEnum = activeKey.getAlterationForPitch(higherPitch);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp = Fraction.plus(baseTimestamp, length);
                length.Denominator = baselength.Denominator * 8;
                this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, higherPitch, higherAlteration, voiceEntries);
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp.Add(length);
                this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, lowerPitch, lowerAlteration, voiceEntries);
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                break;
            }
            case OrnamentEnum.DelayedInvertedTurn: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 2);
                const lowerPitch: Pitch = baseNote.Pitch.getTransposedPitch(-1);
                const lowerAlteration: AccidentalEnum = activeKey.getAlterationForPitch(lowerPitch);
                const higherPitch: Pitch = baseNote.Pitch.getTransposedPitch(1);
                const higherAlteration: AccidentalEnum = activeKey.getAlterationForPitch(higherPitch);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp = Fraction.plus(baseTimestamp, length);
                length.Denominator = baselength.Denominator * 8;
                this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, lowerPitch, lowerAlteration, voiceEntries);
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp.Add(length);
                this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, higherPitch, higherAlteration, voiceEntries);
                currentTimestamp.Add(length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                break;
            }
            case OrnamentEnum.Mordent: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 4);
                const higherPitch: Pitch = baseNote.Pitch.getTransposedPitch(1);
                const alteration: AccidentalEnum = activeKey.getAlterationForPitch(higherPitch);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp.Add(length);
                this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, higherPitch, alteration, voiceEntries);
                length.Denominator = baselength.Denominator * 2;
                currentTimestamp = Fraction.plus(baseTimestamp, length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                break;
            }
            case OrnamentEnum.InvertedMordent: {
                const length: Fraction = new Fraction(baselength.Numerator, baselength.Denominator * 4);
                const lowerPitch: Pitch = baseNote.Pitch.getTransposedPitch(-1);
                const alteration: AccidentalEnum = activeKey.getAlterationForPitch(lowerPitch);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                currentTimestamp.Add(length);
                this.createAlteratedVoiceEntry(currentTimestamp, length, baseVoice, baseNote.SourceMeasure, lowerPitch, alteration, voiceEntries);
                length.Denominator = baselength.Denominator * 2;
                currentTimestamp = Fraction.plus(baseTimestamp, length);
                this.createBaseVoiceEntry(currentTimestamp, length, baseVoice, baseNote, voiceEntries);
                break;
            }
            default:
                throw new RangeError();
        }
        return voiceEntries;
    }
    private createBaseVoiceEntry(
        currentTimestamp: Fraction, length: Fraction, baseVoice: Voice, baseNote: Note, voiceEntries: VoiceEntry[]
    ): void {
        const voiceEntry: VoiceEntry = new VoiceEntry(currentTimestamp, baseVoice, baseNote.ParentStaffEntry);
        const pitch: Pitch = new Pitch(baseNote.Pitch.FundamentalNote, baseNote.Pitch.Octave, baseNote.Pitch.Accidental);
        const note: Note = new Note(voiceEntry, undefined, length, pitch, baseNote.SourceMeasure);
        voiceEntry.Notes.push(note);
        voiceEntries.push(voiceEntry);
    }
    private createAlteratedVoiceEntry(
        currentTimestamp: Fraction, length: Fraction, baseVoice: Voice, sourceMeasure: SourceMeasure, higherPitch: Pitch,
        alteration: AccidentalEnum, voiceEntries: VoiceEntry[]
    ): void {
        const voiceEntry: VoiceEntry = new VoiceEntry(currentTimestamp, baseVoice, undefined);
        const pitch: Pitch = new Pitch(higherPitch.FundamentalNote, higherPitch.Octave, alteration);
        const note: Note = new Note(voiceEntry, undefined, length, pitch, sourceMeasure);
        voiceEntry.Notes.push(note);
        voiceEntries.push(voiceEntry);
    }

}

export enum ArticulationEnum {
    accent,
    strongaccent,
    softaccent,
    marcatoup,
    marcatodown,
    invertedstrongaccent,
    staccato,
    staccatissimo,
    spiccato,
    tenuto,
    fermata,
    invertedfermata,
    breathmark,
    caesura,
    lefthandpizzicato,
    naturalharmonic,
    snappizzicato,
    upbow,
    downbow,
    scoop,
    plop,
    doit,
    falloff,
    stress,
    unstress,
    detachedlegato,
    otherarticulation,
    bend
}

export enum StemDirectionType {
    Undefined = -1,
    Up = 0,
    Down = 1,
    None = 2,
    Double = 3
}


text:
<iterator-tree description="main query">
  <TupleStreamIterator>
    <WindowIterator>
      <WindowVariable name="w">
        <LetVarIterator varname="closings"/>
      </WindowVariable>
      <WinCondVariable name="start-CurrentIn"/>
      <WinCondVariable name="start-CurrentInNextIn"/>
      <WinCondVariable name="start-CurrentInNextInCurrentOut"/>
      <CompareIterator>
        <FnDataIterator>
          <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,price)" typename="*" nill-allowed="false">
            <ForVarIterator varname="first"/>
          </ChildAxisIterator>
        </FnDataIterator>
        <FnDataIterator>
          <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,price)" typename="*" nill-allowed="false">
            <ForVarIterator varname="second"/>
          </ChildAxisIterator>
        </FnDataIterator>
      </CompareIterator>
      <WinCondVariable name="end-CurrentIn"/>
      <WinCondVariable name="end-CurrentInNextIn"/>
      <WinCondVariable name="end-CurrentInNextInCurrentOut"/>
      <CompareIterator>
        <FnDataIterator>
          <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,price)" typename="*" nill-allowed="false">
            <ForVarIterator varname="last"/>
          </ChildAxisIterator>
        </FnDataIterator>
        <FnDataIterator>
          <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,price)" typename="*" nill-allowed="false">
            <ForVarIterator varname="beyond"/>
          </ChildAxisIterator>
        </FnDataIterator>
      </CompareIterator>
      <GroupByIterator>
        <ForIterator>
          <ForVariable name="closings"/>
          <TupleSourceIterator/>
          <DescendantAxisIterator test-kind="match_name_test" qname="xs:QName(,,closing)" typename="*" nill-allowed="false">
            <ElementIterator copyInputNodes="false">
              <SingletonIterator value="xs:QName(,,stocks)"/>
              <FnConcatIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(ABC)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-01)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(105)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(DEF)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-01)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(057)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(ABC)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-02)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(101)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(DEF)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-02)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(054)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(ABC)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-03)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(102)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(DEF)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-03)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(056)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(ABC)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-04)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(103)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(DEF)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-04)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(052)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(ABC)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-05)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(101)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(DEF)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-05)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(055)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(ABC)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-06)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(104)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
                <ElementIterator copyInputNodes="false">
                  <SingletonIterator value="xs:QName(,,closing)"/>
                  <FnConcatIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,symbol)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(DEF)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,date)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(2008-01-06)"/>
                      </TextIterator>
                    </ElementIterator>
                    <ElementIterator copyInputNodes="false">
                      <SingletonIterator value="xs:QName(,,price)"/>
                      <TextIterator>
                        <SingletonIterator value="xs:string(059)"/>
                      </TextIterator>
                    </ElementIterator>
                  </FnConcatIterator>
                </ElementIterator>
              </FnConcatIterator>
            </ElementIterator>
          </DescendantAxisIterator>
        </ForIterator>
        <Spec>
          <TreatIterator quant="?">
            <FnDataIterator>
              <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,symbol)" typename="*" nill-allowed="false">
                <ForVarIterator varname="closings"/>
              </ChildAxisIterator>
            </FnDataIterator>
          </TreatIterator>
          <GroupVariable/>
        </Spec>
        <Spec>
          <ForVarIterator varname="closings"/>
          <NonGroupVariable/>
        </Spec>
      </GroupByIterator>
    </WindowIterator>
    <ElementIterator>
      <SingletonIterator value="xs:QName(,,run-up)"/>
      <AttributeIterator qname="xs:QName(,,symbol)">
        <EnclosedIterator attr_cont="true">
          <ForVarIterator varname="symbol"/>
        </EnclosedIterator>
      </AttributeIterator>
      <FnConcatIterator>
        <ElementIterator>
          <SingletonIterator value="xs:QName(,,start-date)"/>
          <EnclosedIterator attr_cont="false">
            <FnDataIterator>
              <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,date)" typename="*" nill-allowed="false">
                <ForVarIterator varname="first"/>
              </ChildAxisIterator>
            </FnDataIterator>
          </EnclosedIterator>
        </ElementIterator>
        <ElementIterator>
          <SingletonIterator value="xs:QName(,,start-price)"/>
          <EnclosedIterator attr_cont="false">
            <FnDataIterator>
              <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,price)" typename="*" nill-allowed="false">
                <ForVarIterator varname="first"/>
              </ChildAxisIterator>
            </FnDataIterator>
          </EnclosedIterator>
        </ElementIterator>
        <ElementIterator>
          <SingletonIterator value="xs:QName(,,end-date)"/>
          <EnclosedIterator attr_cont="false">
            <FnDataIterator>
              <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,date)" typename="*" nill-allowed="false">
                <ForVarIterator varname="last"/>
              </ChildAxisIterator>
            </FnDataIterator>
          </EnclosedIterator>
        </ElementIterator>
        <ElementIterator>
          <SingletonIterator value="xs:QName(,,end-price)"/>
          <EnclosedIterator attr_cont="false">
            <FnDataIterator>
              <ChildAxisIterator test-kind="match_name_test" qname="xs:QName(,,price)" typename="*" nill-allowed="false">
                <ForVarIterator varname="last"/>
              </ChildAxisIterator>
            </FnDataIterator>
          </EnclosedIterator>
        </ElementIterator>
      </FnConcatIterator>
    </ElementIterator>
  </TupleStreamIterator>
</iterator-tree>


text:
#if !defined (_VGA_H_)
#define _VGA_H_

#include "QuickDraw.h"
namespace Executor {
#define NUM_STANDARD_VGA_MODES  2
#define NUM_VESA_MODES 8
#define EXTRA_VGA_MODES    16  /* Arbitrary, but allow for extra modes. */
#define MAX_VGA_MODES \
(NUM_STANDARD_VGA_MODES + (NUM_VESA_MODES * 2) + EXTRA_VGA_MODES)

typedef struct
{
  int width;
  int height;
  unsigned char log2_bpp;
  unsigned char planar_p;
  unsigned char win_read;
  unsigned char win_write;
  unsigned short row_bytes;
  unsigned short bios_mode;
  unsigned long win_granularity;   /* Size in BYTES */
  unsigned long win_size;          /* Size in BYTES */
  unsigned short winfunc_offset, winfunc_segment;
} vga_mode_t;

#define VESA_MODE_P(mode) (((mode) & 0x100) != 0)

#define VESA_GET_VGA_INFO   0x4F00
#define VESA_GET_MODE_INFO  0x4F01
#define VESA_SET_MODE       0x4F02
#define VESA_WINDOW_CONTROL 0x4F05
#define VESA_SUCCESS        0x004F

#define MEMORY_MODEL_FOUR_PLANES   0x3
#define MEMORY_MODEL_PACKED_PIXELS 0x4

#define VGA_STATE_TO_SAVE 0x7  /* All state. */

typedef struct
{
  char signature[4];
  unsigned short version;
  unsigned short oem_string_offset, oem_string_segment;
  char capabilities[4];
  unsigned short mode_list_offset, mode_list_segment;
} vesa_info_t;

typedef struct
{
  unsigned short mode_attributes;
  unsigned char win_a_attributes;
  unsigned char win_b_attributes;
  unsigned short win_granularity;
  unsigned short win_size;
  unsigned short win_a_segment;
  unsigned short win_b_segment;
  unsigned short winfunc_offset, winfunc_segment;
  unsigned short row_bytes;

  /* Optional information, valid iff (mode_attributes & 0x2). */
  unsigned short width;
  unsigned short height;
  unsigned char char_width;
  unsigned char char_height;
  unsigned char num_planes;
  unsigned char bits_per_pixel;
  unsigned char num_banks;
  unsigned char memory_model;
  unsigned char bank_size;
} mode_info_t;

#define ATTR_LEGAL_MODE    0x1
#define ATTR_EXTENDED_INFO 0x2
#define ATTR_GRAPHICS_MODE 0x10

typedef struct
{
  unsigned char and_mask, xor_mask;
} vga_cursor_xfer_t;

typedef struct
{
  int elt_size;
  int row_bytes;
  union
    {
      vga_cursor_xfer_t *packed;
      unsigned char *raw_bits;
    } cursor_bits;
} vga_cursor_mask_desc_t;

extern int vdriver_init (int max_width, int max_height, int max_bpp);
extern void vdriver_shutdown (void);
extern void vdriver_update_screen (int top, int left, int bottom, int right);
extern int vdriver_info (int *max_bpp, Point *sizes);
extern void *vdriver_frame_buffer (int *width, int *height, int *row_bytes,
				   int *bpp);
extern void vdriver_set_colors (int first_color, int num_colors,
				const RGBColor *color_array);
extern int vdriver_set_mode (int width, int height, int bpp);
}
#endif /* !_VGA_H_ */


text:
<?php /*b5ba2c626520ba032cbe39ed30e01c0d0eaf7cd5*/

/**
 * @package    GoodForNothing Core
 * @version    1.0.0 Alpha 3
 * @since      1.0.0 Alpha 3
 * @author     GoodForNothing Labs
 * @copyright  Copyright © 2012-2015 GoodForNothing Labs <http://gfnlabs.com/>
 * @license    https://gfnlabs.com/legal/license
 * @link       https://gfnlabs.com/
 */
abstract class GFNCore_Db_Schema_Abstract
{
    abstract public function parse();

    public function __toString()
    {
        return $this->parse();
    }
}