text:
namespace testsuite {

struct ParcelableOptionalSet final {
    std::experimental::optional<std::unordered_set<std::string>> optional_set;

    ParcelableOptionalSet(std::experimental::optional<std::unordered_set<std::string>> optional_set_)
    : optional_set(std::move(optional_set_))
    {}
};

}  // namespace testsuite


text:
<!DOCTYPE html>

		<title>Rows resizing</title>
		<link rel="stylesheet" href="../../../codebase/webix.css" type="text/css" charset="utf-8">

		<link rel="stylesheet" type="text/css" href="../common/samples.css">

Rows resizing

Hover mouse over some horizontal border, then press and drag to change size of the related row.

redpajama_set_name: RedPajamaGithub


text:
<?php

use Vsch\Generators\Generators\ControllerGenerator;
use Mockery as m;

class ControllerGeneratorTest extends PHPUnit_Framework_TestCase
{
    protected static $templatesDir;

    public
    function __construct()
    {
        static::$templatesDir = __DIR__ . '/../../src/config/templates';
    }

    public
    function tearDown()
    {
        m::close();
    }

    public
    function testCanGenerateControllerUsingDefaultTemplate()
    {
        $file = m::mock('Illuminate\Filesystem\Filesystem')->makePartial();
        $cache = m::Mock('Vsch\Generators\Cache');

        $app_path = app_path();
        $file->shouldReceive('put')
            ->once()
            ->with(app_path() . '/controllers/FooController.php', file_get_contents(__DIR__ . '/stubs/controller.txt'));

        $cache->shouldReceive('getFields')
            ->withNoArgs()
            ->andReturn([ ]);

        $generator = new ControllerGenerator($file, $cache);
        $generator->make(app_path() . '/controllers/FooController.php', static::$templatesDir . '/controller.txt',);
    }

    public
    function testCanGenerateControllerUsingCustomTemplate()
    {
        $file = m::mock('Illuminate\Filesystem\Filesystem')->makePartial();
        $cache = m::Mock('Vsch\Generators\Cache');

        $file->shouldReceive('put')
            ->once()
            ->with(app_path() . '/controllers/FoosController.php', file_get_contents(__DIR__ . '/stubs/scaffold/controller.txt'));

        $cache->shouldReceive('getModelName')
            ->once()
            ->withNoArgs()
            ->andReturn('foos');

        $cache->shouldReceive('getFields')
            ->withNoArgs()
            ->andReturn([ ]);

        $generator = new ControllerGenerator($file, $cache);
        $generator->make(app_path() . '/controllers/FoosController.php', static::$templatesDir . '/scaffold/controller.txt',);
    }
}


text:
// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis.CodeActions;
using Microsoft.CodeAnalysis.CodeFixes;
using Microsoft.CodeAnalysis.CodeGeneration;
using Microsoft.CodeAnalysis.Editing;
using Microsoft.CodeAnalysis.Formatting;
using Microsoft.CodeAnalysis.LanguageServices;
using Microsoft.CodeAnalysis.PooledObjects;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.CodeAnalysis.Shared.Utilities;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.AddParameter
{
#pragma warning disable RS1016 // Code fix providers should provide FixAll support. https://github.com/dotnet/roslyn/issues/23528
    internal abstract class AbstractAddParameterCodeFixProvider<
#pragma warning restore RS1016 // Code fix providers should provide FixAll support.
        TArgumentSyntax,
        TAttributeArgumentSyntax,
        TArgumentListSyntax,
        TAttributeArgumentListSyntax,
        TInvocationExpressionSyntax,
        TObjectCreationExpressionSyntax> : CodeFixProvider
        where TArgumentSyntax : SyntaxNode
        where TArgumentListSyntax : SyntaxNode
        where TAttributeArgumentListSyntax : SyntaxNode
        where TInvocationExpressionSyntax : SyntaxNode
        where TObjectCreationExpressionSyntax : SyntaxNode
    {
        protected abstract ImmutableArray<string> TooManyArgumentsDiagnosticIds { get; }

        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
        {
            var cancellationToken = context.CancellationToken;
            var diagnostic = context.Diagnostics.First();

            var document = context.Document;
            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);

            var initialNode = root.FindNode(diagnostic.Location.SourceSpan);

            for (var node = initialNode; node != null; node = node.Parent)
            {
                if (node is TObjectCreationExpressionSyntax objectCreation)
                {
                    var argumentOpt = TryGetRelevantArgument(initialNode, node, diagnostic);
                    await HandleObjectCreationExpressionAsync(context, objectCreation, argumentOpt).ConfigureAwait(false);
                    return;
                }
                else if (node is TInvocationExpressionSyntax invocationExpression)
                {
                    var argumentOpt = TryGetRelevantArgument(initialNode, node, diagnostic);
                    await HandleInvocationExpressionAsync(context, invocationExpression, argumentOpt).ConfigureAwait(false);
                    return;
                }
            }
        }

        private TArgumentSyntax TryGetRelevantArgument(
            SyntaxNode initialNode, SyntaxNode node, Diagnostic diagnostic)
        {
            if (this.TooManyArgumentsDiagnosticIds.Contains(diagnostic.Id))
            {
                return null;
            }

            return initialNode.GetAncestorsOrThis<TArgumentSyntax>()
                              .LastOrDefault(a => a.AncestorsAndSelf().Contains(node));
        }

        private Task HandleInvocationExpressionAsync(
            CodeFixContext context, TInvocationExpressionSyntax invocationExpression, TArgumentSyntax argumentOpt)
        {
            // Currently we only support this for 'new obj' calls.
            return SpecializedTasks.EmptyTask;
        }

        private async Task HandleObjectCreationExpressionAsync(
            CodeFixContext context,
            TObjectCreationExpressionSyntax objectCreation,
            TArgumentSyntax argumentOpt)
        {
            var document = context.Document;
            var cancellationToken = context.CancellationToken;
            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
            var syntaxFacts = document.GetLanguageService<ISyntaxFactsService>();

            // Not supported if this is "new { ... }" (as there are no parameters at all.
            var typeNode = syntaxFacts.GetObjectCreationType(objectCreation);
            if (typeNode == null)
            {
                return;
            }

            // If we can't figure out the type being created, or the type isn't in source,
            // then there's nothing we can do.
            var type = semanticModel.GetSymbolInfo(typeNode, cancellationToken).GetAnySymbol() as INamedTypeSymbol;
            if (type == null)
            {
                return;
            }

            if (!type.IsNonImplicitAndFromSource())
            {
                return;
            }

            var arguments = (SeparatedSyntaxList<TArgumentSyntax>)syntaxFacts.GetArgumentsOfObjectCreationExpression(objectCreation);

            var comparer = syntaxFacts.StringComparer;
            var constructorsAndArgumentToAdd = ArrayBuilder<(IMethodSymbol constructor, TArgumentSyntax argument, int index)>.GetInstance();

            foreach (var constructor in type.InstanceConstructors.OrderBy(m => m.Parameters.Length))
            {
                if (constructor.IsNonImplicitAndFromSource() &&
                    NonParamsParameterCount(constructor) < arguments.Count)
                {
                    var argumentToAdd = DetermineFirstArgumentToAdd(
                        semanticModel, syntaxFacts, comparer, constructor,
                        arguments, argumentOpt);

                    if (argumentToAdd != null)
                    {
                        if (argumentOpt != null && argumentToAdd != argumentOpt)
                        {
                            // We were trying to fix a specific argument, but the argument we want
                            // to fix is something different.  That means there was an error earlier
                            // than this argument.  Which means we're looking at a non-viable
                            // constructor.  Skip this one.
                            continue;
                        }

                        constructorsAndArgumentToAdd.Add(
                            (constructor, argumentToAdd, arguments.IndexOf(argumentToAdd)));
                    }
                }
            }

            // Order by the furthest argument index to the nearest argument index.  The ones with
            // larger argument indexes mean that we matched more earlier arguments (and thus are
            // likely to be the correct match).
            foreach (var tuple in constructorsAndArgumentToAdd.OrderByDescending(t => t.index))
            {
                var constructor = tuple.constructor;
                var argumentToAdd = tuple.argument;

                var parameters = constructor.Parameters.Select(p => p.ToDisplayString(SimpleFormat));
                var signature = $"{type.Name}({string.Join(", ", parameters)})";

                var title = string.Format(FeaturesResources.Add_parameter_to_0, signature);

                context.RegisterCodeFix(
                    new MyCodeAction(title, c => FixAsync(document, constructor, argumentToAdd, arguments, c)),
                    context.Diagnostics);
            }
        }

        private int NonParamsParameterCount(IMethodSymbol method)
            => method.IsParams() ? method.Parameters.Length - 1 : method.Parameters.Length;

        private async Task<Document> FixAsync(
            Document invocationDocument,
            IMethodSymbol method,
            TArgumentSyntax argument,
            SeparatedSyntaxList<TArgumentSyntax> argumentList,
            CancellationToken cancellationToken)
        {
            var methodDeclaration = await method.DeclaringSyntaxReferences[0].GetSyntaxAsync(cancellationToken).ConfigureAwait(false);

            var (parameterSymbol, isNamedArgument) = await CreateParameterSymbolAsync(
                invocationDocument, method, argument, cancellationToken).ConfigureAwait(false);

            var methodDocument = invocationDocument.Project.Solution.GetDocument(methodDeclaration.SyntaxTree);
            var syntaxFacts = methodDocument.GetLanguageService<ISyntaxFactsService>();
            var methodDeclarationRoot = methodDeclaration.SyntaxTree.GetRoot(cancellationToken);
            var editor = new SyntaxEditor(methodDeclarationRoot, methodDocument.Project.Solution.Workspace);

            var parameterDeclaration = editor.Generator.ParameterDeclaration(parameterSymbol)
                                                       .WithAdditionalAnnotations(Formatter.Annotation);

            var existingParameters = editor.Generator.GetParameters(methodDeclaration);
            var insertionIndex = isNamedArgument
                ? existingParameters.Count
                : argumentList.IndexOf(argument);

            AddParameter(
                syntaxFacts, editor, methodDeclaration, argument,
                insertionIndex, parameterDeclaration, cancellationToken);

            var newRoot = editor.GetChangedRoot();
            var newDocument = methodDocument.WithSyntaxRoot(newRoot);

            return newDocument;
        }

        private async Task<(IParameterSymbol, bool isNamedArgument)> CreateParameterSymbolAsync(
            Document invocationDocument,
            IMethodSymbol method,
            TArgumentSyntax argument,
            CancellationToken cancellationToken)
        {
            var syntaxFacts = invocationDocument.GetLanguageService<ISyntaxFactsService>();
            var semanticFacts = invocationDocument.GetLanguageService<ISemanticFactsService>();
            var argumentName = syntaxFacts.GetNameForArgument(argument);
            var expression = syntaxFacts.GetExpressionOfArgument(argument);

            var semanticModel = await invocationDocument.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
            var parameterType = semanticModel.GetTypeInfo(expression).Type ?? semanticModel.Compilation.ObjectType;

            if (!string.IsNullOrWhiteSpace(argumentName))
            {
                var newParameterSymbol = CodeGenerationSymbolFactory.CreateParameterSymbol(
                    attributes: default, refKind: RefKind.None, isParams: false, type: parameterType, name: argumentName);

                return (newParameterSymbol, isNamedArgument: true);
            }
            else
            {
                var name = semanticFacts.GenerateNameForExpression(
                    semanticModel, expression, capitalize: false, cancellationToken: cancellationToken);
                var uniqueName = NameGenerator.EnsureUniqueness(name, method.Parameters.Select(p => p.Name));

                var newParameterSymbol = CodeGenerationSymbolFactory.CreateParameterSymbol(
                    attributes: default, refKind: RefKind.None, isParams: false, type: parameterType, name: uniqueName);

                return (newParameterSymbol, isNamedArgument: false);
            }
        }

        private static void AddParameter(
            ISyntaxFactsService syntaxFacts,
            SyntaxEditor editor,
            SyntaxNode declaration,
            TArgumentSyntax argument,
            int insertionIndex,
            SyntaxNode parameterDeclaration,
            CancellationToken cancellationToken)
        {
            var sourceText = declaration.SyntaxTree.GetText(cancellationToken);
            var generator = editor.Generator;

            var existingParameters = generator.GetParameters(declaration);
            var placeOnNewLine = ShouldPlaceParametersOnNewLine(existingParameters, cancellationToken);

            if (!placeOnNewLine)
            {
                // Trivial case.  Just let the stock editor impl handle this for us.
                editor.InsertParameter(declaration, insertionIndex, parameterDeclaration);
                return;
            }

            if (insertionIndex == existingParameters.Count)
            {
                // Placing the last parameter on its own line.  Get the indentation of the
                // curent last parameter and give the new last parameter the same indentation.
                var leadingIndentation = GetDesiredLeadingIndentation(
                    generator, syntaxFacts, existingParameters[existingParameters.Count - 1], includeLeadingNewLine: true);
                parameterDeclaration = parameterDeclaration.WithPrependedLeadingTrivia(leadingIndentation)
                                                            .WithAdditionalAnnotations(Formatter.Annotation);

                editor.AddParameter(declaration, parameterDeclaration);
            }
            else if (insertionIndex == 0)
            {
                // Inserting into the start of the list.  The existing first parameter might
                // be on the same line as the parameter list, or it might be on the next line.
                var firstParameter = existingParameters[0];
                var previousToken = firstParameter.GetFirstToken().GetPreviousToken();

                if (sourceText.AreOnSameLine(previousToken, firstParameter.GetFirstToken()))
                {
                    // First parameter is on hte same line as the method.

                    // We want to insert the parameter at the front of the exsiting parameter
                    // list.  That means we need to move the current first parameter to a new
                    // line.  Give the current first parameter the indentation of the second
                    // parameter in the list.
                    editor.InsertParameter(declaration, insertionIndex, parameterDeclaration);
                    var nextParameter = existingParameters[insertionIndex];

                    var nextLeadingIndentation = GetDesiredLeadingIndentation(
                        generator, syntaxFacts, existingParameters[insertionIndex + 1], includeLeadingNewLine: true);
                    editor.ReplaceNode(
                        nextParameter,
                        nextParameter.WithPrependedLeadingTrivia(nextLeadingIndentation)
                                     .WithAdditionalAnnotations(Formatter.Annotation));
                }
                else
                {
                    // First parameter is on its own line.  No need to adjust its indentation.
                    // Just copy its indentation over to the parameter we're inserting, and
                    // make sure the current first parameter gets a newline so it stays on
                    // its own line.

                    // We want to insert the parameter at the front of the exsiting parameter
                    // list.  That means we need to move the current first parameter to a new
                    // line.  Give the current first parameter the indentation of the second
                    // parameter in the list.
                    var firstLeadingIndentation = GetDesiredLeadingIndentation(
                        generator, syntaxFacts, existingParameters[0], includeLeadingNewLine: false);

                    editor.InsertParameter(declaration, insertionIndex,
                        parameterDeclaration.WithLeadingTrivia(firstLeadingIndentation));
                    var nextParameter = existingParameters[insertionIndex];

                    editor.ReplaceNode(
                        nextParameter,
                        nextParameter.WithPrependedLeadingTrivia(generator.ElasticCarriageReturnLineFeed)
                                     .WithAdditionalAnnotations(Formatter.Annotation));
                }
            }
            else
            {
                // We're inserting somewhere after the start (but not at the end). Because
                // we've set placeOnNewLine, we know that the current comma we'll be placed
                // after already have a newline following it.  So all we need for this new
                // parameter is to get the indentation of the following parameter.
                // Because we're going to 'steal' the existing comma from that parameter,
                // ensure that the next parameter has a new-line added to it so that it will
                // still stay on a new line.
                var nextParameter = existingParameters[insertionIndex];
                var leadingIndentation = GetDesiredLeadingIndentation(
                    generator, syntaxFacts, existingParameters[insertionIndex], includeLeadingNewLine: false);
                parameterDeclaration = parameterDeclaration.WithPrependedLeadingTrivia(leadingIndentation);

                editor.InsertParameter(declaration, insertionIndex, parameterDeclaration);
                editor.ReplaceNode(
                    nextParameter,
                    nextParameter.WithPrependedLeadingTrivia(generator.ElasticCarriageReturnLineFeed)
                                 .WithAdditionalAnnotations(Formatter.Annotation));
            }
        }

        private static List<SyntaxTrivia> GetDesiredLeadingIndentation(
            SyntaxGenerator generator, ISyntaxFactsService syntaxFacts,
            SyntaxNode node, bool includeLeadingNewLine)
        {
            var triviaList = new List<SyntaxTrivia>();
            if (includeLeadingNewLine)
            {
                triviaList.Add(generator.ElasticCarriageReturnLineFeed);
            }

            var lastWhitespace = default(SyntaxTrivia);
            foreach (var trivia in node.GetLeadingTrivia().Reverse())
            {
                if (syntaxFacts.IsWhitespaceTrivia(trivia))
                {
                    lastWhitespace = trivia;
                }
                else if (syntaxFacts.IsEndOfLineTrivia(trivia))
                {
                    break;
                }
            }

            if (lastWhitespace.RawKind != 0)
            {
                triviaList.Add(lastWhitespace);
            }

            return triviaList;
        }

        private static bool ShouldPlaceParametersOnNewLine(
            IReadOnlyList<SyntaxNode> parameters, CancellationToken cancellationToken)
        {
            if (parameters.Count <= 1)
            {
                return false;
            }

            var text = parameters[0].SyntaxTree.GetText(cancellationToken);
            for (int i = 1, n = parameters.Count; i < n; i++)
            {
                var lastParameter = parameters[i - 1];
                var thisParameter = parameters[i];

                if (text.AreOnSameLine(lastParameter.GetLastToken(), thisParameter.GetFirstToken()))
                {
                    return false;
                }
            }

            // All parameters are on different lines.  Place the new parameter on a new line as well.
            return true;
        }

        private static readonly SymbolDisplayFormat SimpleFormat =
                    new SymbolDisplayFormat(
                        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly,
                        genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters,
                        parameterOptions: SymbolDisplayParameterOptions.IncludeParamsRefOut | SymbolDisplayParameterOptions.IncludeType,
                        miscellaneousOptions: SymbolDisplayMiscellaneousOptions.UseSpecialTypes);

        private TArgumentSyntax DetermineFirstArgumentToAdd(
            SemanticModel semanticModel,
            ISyntaxFactsService syntaxFacts,
            StringComparer comparer,
            IMethodSymbol method,
            SeparatedSyntaxList<TArgumentSyntax> arguments,
            TArgumentSyntax argumentOpt)
        {
            var methodParameterNames = new HashSet<string>(comparer);
            methodParameterNames.AddRange(method.Parameters.Select(p => p.Name));

            for (int i = 0, n = arguments.Count; i < n; i++)
            {
                var argument = arguments[i];
                var argumentName = syntaxFacts.GetNameForArgument(argument);

                if (!string.IsNullOrWhiteSpace(argumentName))
                {
                    // If the user provided an argument-name and we don't have any parameters that
                    // match, then this is the argument we want to add a parameter for.
                    if (!methodParameterNames.Contains(argumentName))
                    {
                        return argument;
                    }
                }
                else
                {
                    // Positional argument.  If the position is beyond what the method supports,
                    // then this definitely is an argument we could add.
                    if (i >= method.Parameters.Length)
                    {
                        if (method.Parameters.LastOrDefault()?.IsParams == true)
                        {
                            // Last parameter is a params.  We can't place any parameters past it.
                            return null;
                        }

                        return argument;
                    }

                    // Now check the type of the argument versus the type of the parameter.  If they
                    // don't match, then this is the argument we should make the parameter for.
                    var expressionOfArgumment = syntaxFacts.GetExpressionOfArgument(argument);
                    var argumentTypeInfo = semanticModel.GetTypeInfo(expressionOfArgumment);
                    var isNullLiteral = syntaxFacts.IsNullLiteralExpression(expressionOfArgumment);
                    var isDefaultLiteral = syntaxFacts.IsDefaultLiteralExpression(expressionOfArgumment);

                    if (argumentTypeInfo.Type == null && argumentTypeInfo.ConvertedType == null)
                    {
                        // Didn't know the type of the argument.  We shouldn't assume it doesn't
                        // match a parameter.  However, if the user wrote 'null' and it didn't
                        // match anything, then this is the problem argument.
                        if (!isNullLiteral && !isDefaultLiteral)
                        {
                            continue;
                        }
                    }

                    var parameter = method.Parameters[i];

                    if (!TypeInfoMatchesType(argumentTypeInfo, parameter.Type, isNullLiteral, isDefaultLiteral))
                    {
                        if (TypeInfoMatchesWithParamsExpansion(argumentTypeInfo, parameter, isNullLiteral, isDefaultLiteral))
                        {
                            // The argument matched if we expanded out the params-parameter.
                            // As the params-parameter has to be last, there's nothing else to
                            // do here.
                            return null;
                        }

                        return argument;
                    }
                }
            }

            return null;
        }

        private bool TypeInfoMatchesWithParamsExpansion(
            TypeInfo argumentTypeInfo, IParameterSymbol parameter,
            bool isNullLiteral, bool isDefaultLiteral)
        {
            if (parameter.IsParams && parameter.Type is IArrayTypeSymbol arrayType)
            {
                if (TypeInfoMatchesType(argumentTypeInfo, arrayType.ElementType, isNullLiteral, isDefaultLiteral))
                {
                    return true;
                }
            }

            return false;
        }

        private bool TypeInfoMatchesType(
            TypeInfo argumentTypeInfo, ITypeSymbol type,
            bool isNullLiteral, bool isDefaultLiteral)
        {
            if (type.Equals(argumentTypeInfo.Type) || type.Equals(argumentTypeInfo.ConvertedType))
            {
                return true;
            }

            if (isDefaultLiteral)
            {
                return true;
            }

            if (isNullLiteral)
            {
                return type.IsReferenceType || type.IsNullable();
            }

            return false;
        }

        private class MyCodeAction : CodeAction.DocumentChangeAction
        {
            public MyCodeAction(
                string title,
                Func<CancellationToken, Task<Document>> createChangedDocument)
                : base(title, createChangedDocument)
            {
            }
        }
    }
}


text:
<?php

defined('_JEXEC') or die;

use Joomla\Registry\Registry;

/**
 * Checks if the eAccelerator caching method is enabled. This check should be
 * done through the 3.x series as the issue impacts migrated sites which will
 * most often come from the previous LTS release (2.5). Remove for version 4 or
 * when eAccelerator support is added.
 *
 * This check returns true when the eAccelerator caching method is user, meaning
 * that the message concerning it should be displayed.
 *
 * @return  integer
 *
 * @since   3.2
 */
function admin_postinstall_eaccelerator_condition()
{
	$app = JFactory::getApplication();
	$cacheHandler = $app->get('cacheHandler', '');

	return (ucfirst($cacheHandler) == 'Eaccelerator');
}

/**
 * Disables the unsupported eAccelerator caching method, replacing it with the
 * "file" caching method.
 *
 * @return  void
 *
 * @since   3.2
 */
function admin_postinstall_eaccelerator_action()
{
	$prev = new JConfig;
	$prev = JArrayHelper::fromObject($prev);

	$data = array('cacheHandler' => 'file');

	$data = array_merge($prev, $data);

	$config = new Registry('config');
	$config->loadArray($data);

	jimport('joomla.filesystem.path');
	jimport('joomla.filesystem.file');

	// Set the configuration file path.
	$file = JPATH_CONFIGURATION . '/configuration.php';

	// Get the new FTP credentials.
	$ftp = JClientHelper::getCredentials('ftp', true);

	// Attempt to make the file writeable if using FTP.
	if (!$ftp['enabled'] && JPath::isOwner($file) && !JPath::setPermissions($file, '0644'))
	{
		JError::raiseNotice('SOME_ERROR_CODE', JText::_('COM_CONFIG_ERROR_CONFIGURATION_PHP_NOTWRITABLE'));
	}

	// Attempt to write the configuration file as a PHP class named JConfig.
	$configuration = $config->toString('PHP', array('class' => 'JConfig', 'closingtag' => false));

	if (!JFile::write($file, $configuration))
	{
		JFactory::getApplication()->enqueueMessage(JText::_('COM_CONFIG_ERROR_WRITE_FAILED'), 'error');

		return;
	}

	// Attempt to make the file unwriteable if using FTP.
	if (!$ftp['enabled'] && JPath::isOwner($file) && !JPath::setPermissions($file, '0444'))
	{
		JError::raiseNotice('SOME_ERROR_CODE', JText::_('COM_CONFIG_ERROR_CONFIGURATION_PHP_NOTUNWRITABLE'));
	}
}


text:
#include <aws/greengrass/model/UpdateCoreDefinitionRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>

#include <utility>

using namespace Aws::Greengrass::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;

UpdateCoreDefinitionRequest::UpdateCoreDefinitionRequest() :
    m_coreDefinitionIdHasBeenSet(false),
    m_nameHasBeenSet(false)
{
}

Aws::String UpdateCoreDefinitionRequest::SerializePayload() const
{
  JsonValue payload;

  if(m_nameHasBeenSet)
  {
   payload.WithString("Name", m_name);

  }

  return payload.View().WriteReadable();
}


text:
package org.lnu.is.converter.asset.type;

import static org.junit.Assert.assertEquals;

import java.util.Arrays;
import java.util.List;

import org.junit.Test;
import org.lnu.is.domain.asset.type.AssetType;
import org.lnu.is.resource.asset.type.AssetTypeResource;

public class AssetTypeConverterTest {

	private AssetTypeConverter unit = new AssetTypeConverter();

	@Test
	public void testConvert() throws Exception {
		// Given
		Long id = 1L;
		String name = "name";
		String abbrName = "abbrname";
		AssetType source = new AssetType();
		source.setAbbrName(abbrName);
		source.setName(name);
		source.setId(id);

		AssetTypeResource expected = new AssetTypeResource();
		expected.setAbbrName(abbrName);
		expected.setId(id);
		expected.setName(name);

		// When
		AssetTypeResource actual = unit.convert(source);

		// Then
		assertEquals(expected, actual);
	}

	@Test
	public void testConvertAll() throws Exception {
		// Given
		Long id = 1l;
		String abbrName = "abbr Name";
		String name = "n a m e";

		AssetType source = new AssetType();
		source.setId(id);
		source.setAbbrName(abbrName);
		source.setName(name);

		List<AssetType> sources = Arrays.asList(source);

		AssetTypeResource expected = new AssetTypeResource();
		expected.setId(id);
		expected.setAbbrName(abbrName);
		expected.setName(name);

		List<AssetTypeResource> expecteds = Arrays.asList(expected);

		// Where
		List<AssetTypeResource> actuals = unit.convertAll(sources);

		//Then
		assertEquals(expecteds, actuals);
	}
}


text:
using System;
using System.Collections.Generic;
using EasyPTC.Data.Contracts;
using EasyPTC.Data.Repositories.Base;
using EasyPTC.Models;

namespace EasyPTC.Data
{
    public class EasyPtcData : IEasyPtcData
    {
        private readonly IEasyPtcDbContext context;

        private readonly Dictionary<Type, object> repositories = new Dictionary<Type, object>();

        public EasyPtcData(IEasyPtcDbContext context)
        {
            this.context = context;
        }

        public IEasyPtcDbContext Context
        {
            get
            {
                return this.context;
            }
        }

        //public IRepository<T> GetGenericRepository<T>() where T : class
        //{
        //    if (typeof(T).IsAssignableFrom(typeof(DeletableEntity)))
        //    {
        //        return this.GetDeletableEntityRepository<T>();
        //    }

        //    return this.GetRepository<T>();
        //}
        public IDeletableEntityRepository<TextAdvertisement> TextAdvertisements
        {
            get
            {
                return this.GetDeletableEntityRepository<TextAdvertisement>();
            }
        }

        public IDeletableEntityRepository<Banner> Banners
        {
            get
            {
                return this.GetDeletableEntityRepository<Banner>();
            }
        }

        public IRepository<User> Users
        {
            get
            {
                return this.GetRepository<User>();
            }
        }

        public IDeletableEntityRepository<Advertisement> Advertisements
        {
            get
            {
                return this.GetDeletableEntityRepository<Advertisement>();
            }
        }

        public IDeletableEntityRepository<Category> Categories
        {
            get
            {
                return this.GetDeletableEntityRepository<Category>();
            }
        }

        /// <summary>
        /// Saves all changes made in this context to the underlying database.
        /// </summary>
        /// <returns>
        /// The number of objects written to the underlying database.
        /// </returns>
        /// <exception cref="T:System.InvalidOperationException">Thrown if the context has been disposed.</exception>
        public int SaveChanges()
        {
            return this.context.SaveChanges();
        }

        public void Dispose()
        {
            this.Dispose(true);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.context != null)
                {
                    this.context.Dispose();
                }
            }
        }

        private IRepository<T> GetRepository<T>() where T : class, IEntity
        {
            if (!this.repositories.ContainsKey(typeof(T)))
            {
                var type = typeof(GenericRepository<T>);
                this.repositories.Add(typeof(T), Activator.CreateInstance(type, this.context));
            }

            return (IRepository<T>)this.repositories[typeof(T)];
        }

        private IDeletableEntityRepository<T> GetDeletableEntityRepository<T>() where T : class, IDeletableEntity, IEntity
        {
            if (!this.repositories.ContainsKey(typeof(T)))
            {
                var type = typeof(DeletableEntityRepository<T>);
                this.repositories.Add(typeof(T), Activator.CreateInstance(type, this.context));
            }

            return (IDeletableEntityRepository<T>)this.repositories[typeof(T)];
        }
    }
}


text:
<?php
$lang = array (
    'account_settings' => "Configurações de Conta",
    'new_password' => "Nova Senha",
    'new_password_check' => "Nova Senha (novamente)",
    'old_password' => "Senha Antiga",
    'update_account' => "Atualizar Conta",
    'name' => "Nome",
    'login' => "Login",
    'login_description' => "Entrar na sua conta",
    'logout' => "sair",
    'balance_title' => "Saldo",
    'balance_description' => "ver tabela de saldos dos membros",
    'transactions_title' => "Transações",
    'transactions_description' => "ver lista de transações",
    'new_bill_title' => "Nova Conta",
    'new_bill_description' => "criar uma nova conta",
    'new_payment_title' => "Novo Pagamento",
    'new_payment_description' => "realizar um novo pagamento de débito",
    'new_cred_transf_title' => "Transferência de Crédito",
    'new_cred_transf_description' => "realizar uma nova transferência de crédito",
    'administration_title' => 'Administração',
    'administration_description' => 'gerenciar membros',
    'value' => "Valor",
    'select_all_members' => "Selecionar todos os membros",
    'add_bill' => "Adicionar Conta",
    'add_payment' => "Adicionar Pagamento",
    'add_transference' => "Adicionar Transferência",
    'username' => "Usuário",
    'password' => "Senha",
    'register' => "Registrar",
    'date' => "Data",
    'type' => "Tipo",
    'payer' => "Pagador",
    'total_value' => "Valor Total",
    'your_share' => "Sua Parte",
    'type_bill' => "Conta",
    'type_payment' => "Pagamento",
    'type_credtransf' => "Transf. Cred.",
    'member_is_admin' => "Este membro é administrador",
    'edit_member' => "Editar conta de um membro",
    'register_member' => "Registrar novo membro",
    'change_member_name' => "Mudar nome de um membro",
    'deactivate_account' => "Desativar a conta deste membro",
    'new_admin_account' => "Nova conta de administrador",

    'success' => "Sucesso",
    'msg_member_registered' => "Novo membro registrado com sucesso.",
    'msg_payment_added' => "Novo pagamento adicionado com sucesso.",
    'msg_bill_added' => "Nova conta adicionada com sucesso.",
    'msg_cred_transf_added' => "Nova transferência de crédito realizada com sucesso.",
    'msg_account_updated' => "A conta foi atualizada com sucesso.",
    'msg_admin_created' => "Conta de administrador criada com sucesso. Lembre-se de apagar o arquivo install.php.",

    'error' => "Erro",
    'error_404_title' => "Erro 404",
    'error_404_description' => "Página não encontrada.",
    'error_403_title' => "Erro 403",
    'error_403_description' => "Acesso negado.",
    'error_username_in_use' => "O usuário escolhido já está em uso.",
    'error_fill_all_register' => "Você deve preencher todos os campos para registrar um novo membro.",
    'error_type_user_login' => "Por favor, informe o seu usuário para realizar login.",
    'error_type_pw_login' => "Por favor, informe a sua senha para realizar login.",
    'error_invalid_user' => "Usuário inválido.",
    'error_user_pw_match' => "Usuário e/ou senha incorretos.",
    'error_deactivated_account' => "Sua conta foi desativada por um administrador.",
    'error_account_not_updated' => "A conta não pode ser autalizada. Por favor, tente novamente."
);
?>


text:
package me.lucko.luckperms.common.cacheddata.type;

import com.google.common.collect.ForwardingMap;
import com.google.common.collect.ImmutableListMultimap;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSortedMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Multimaps;

import me.lucko.luckperms.common.cacheddata.UsageTracked;
import me.lucko.luckperms.common.cacheddata.result.StringResult;
import me.lucko.luckperms.common.config.ConfigKeys;
import me.lucko.luckperms.common.plugin.LuckPermsPlugin;
import me.lucko.luckperms.common.verbose.event.CheckOrigin;

import net.luckperms.api.cacheddata.CachedMetaData;
import net.luckperms.api.cacheddata.Result;
import net.luckperms.api.metastacking.MetaStackDefinition;
import net.luckperms.api.node.types.MetaNode;
import net.luckperms.api.node.types.PrefixNode;
import net.luckperms.api.node.types.SuffixNode;
import net.luckperms.api.query.QueryOptions;
import net.luckperms.api.query.meta.MetaValueSelector;

import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;

import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.SortedMap;

/**
 * Holds cached meta for a given context
 */
public class MetaCache extends UsageTracked implements CachedMetaData {

    private final LuckPermsPlugin plugin;

    /** The query options this container is holding data for */
    private final QueryOptions queryOptions;

    /* The data */
    private final Map<String, List<StringResult<MetaNode>>> meta;
    private final Map<String, StringResult<MetaNode>> flattenedMeta;
    private final SortedMap<Integer, StringResult<PrefixNode>> prefixes;
    private final SortedMap<Integer, StringResult<SuffixNode>> suffixes;
    private final int weight;
    private final String primaryGroup;
    private final MetaStackDefinition prefixDefinition;
    private final MetaStackDefinition suffixDefinition;
    private final StringResult<PrefixNode> prefix;
    private final StringResult<SuffixNode> suffix;

    public MetaCache(LuckPermsPlugin plugin, QueryOptions queryOptions, MetaAccumulator sourceMeta) {
        this.plugin = plugin;
        this.queryOptions = queryOptions;

        Map<String, List<StringResult<MetaNode>>> meta = Multimaps.asMap(ImmutableListMultimap.copyOf(sourceMeta.getMeta()));

        MetaValueSelector metaValueSelector = this.queryOptions.option(MetaValueSelector.KEY)
                .orElseGet(() -> this.plugin.getConfiguration().get(ConfigKeys.META_VALUE_SELECTOR));

        ImmutableMap.Builder<String, StringResult<MetaNode>> builder = ImmutableMap.builder();
        for (Map.Entry<String, List<StringResult<MetaNode>>> e : meta.entrySet()) {
            if (e.getValue().isEmpty()) {
                continue;
            }

            Result<String, MetaNode> selected = metaValueSelector.selectValue(e.getKey(), e.getValue());
            if (selected == null) {
                throw new NullPointerException(metaValueSelector + " returned null");
            }

            builder.put(e.getKey(), (StringResult<MetaNode>) selected);
        }
        this.flattenedMeta = builder.build();
        this.meta = new LowerCaseMetaMap(meta);

        this.prefixes = ImmutableSortedMap.copyOfSorted(sourceMeta.getPrefixes());
        this.suffixes = ImmutableSortedMap.copyOfSorted(sourceMeta.getSuffixes());
        this.weight = sourceMeta.getWeight();
        this.primaryGroup = sourceMeta.getPrimaryGroup();
        this.prefixDefinition = sourceMeta.getPrefixDefinition();
        this.suffixDefinition = sourceMeta.getSuffixDefinition();
        this.prefix = sourceMeta.getPrefix();
        this.suffix = sourceMeta.getSuffix();
    }

    public @NonNull StringResult<MetaNode> getMetaValue(String key, CheckOrigin origin) {
        Objects.requireNonNull(key, "key");
        return this.flattenedMeta.getOrDefault(key.toLowerCase(Locale.ROOT), StringResult.nullResult());
    }

    @Override
    public final @NonNull Result<String, MetaNode> queryMetaValue(@NonNull String key) {
        return getMetaValue(key, CheckOrigin.LUCKPERMS_API);
    }

    @Override
    public final @Nullable String getMetaValue(@NonNull String key) {
        return getMetaValue(key, CheckOrigin.LUCKPERMS_API).result();
    }

    public @NonNull StringResult<PrefixNode> getPrefix(CheckOrigin origin) {
        return this.prefix;
    }

    @Override
    public final @NonNull Result<String, PrefixNode> queryPrefix() {
        return getPrefix(CheckOrigin.LUCKPERMS_API);
    }

    @Override
    public final @Nullable String getPrefix() {
        return getPrefix(CheckOrigin.LUCKPERMS_API).result();
    }

    public @NonNull StringResult<SuffixNode> getSuffix(CheckOrigin origin) {
        return this.suffix;
    }

    @Override
    public final @NonNull Result<String, SuffixNode> querySuffix() {
        return getSuffix(CheckOrigin.LUCKPERMS_API);
    }

    @Override
    public final @Nullable String getSuffix() {
        return getSuffix(CheckOrigin.LUCKPERMS_API).result();
    }

    protected Map<String, List<StringResult<MetaNode>>> getMetaResults(CheckOrigin origin) {
        return this.meta;
    }

    public final Map<String, List<String>> getMeta(CheckOrigin origin) {
        return Maps.transformValues(getMetaResults(origin), list -> Lists.transform(list, StringResult::result));
    }

    @Override
    public final @NonNull Map<String, List<String>> getMeta() {
        return getMeta(CheckOrigin.LUCKPERMS_API);
    }

    @Override
    public @NonNull SortedMap<Integer, String> getPrefixes() {
        return Maps.transformValues(this.prefixes, StringResult::result);
    }

    @Override
    public @NonNull SortedMap<Integer, String> getSuffixes() {
        return Maps.transformValues(this.suffixes, StringResult::result);
    }

    public int getWeight(CheckOrigin origin) {
        return this.weight;
    }

    //@Override - not actually exposed in the API atm
    public final int getWeight() {
        return getWeight(CheckOrigin.LUCKPERMS_API);
    }

    public @Nullable String getPrimaryGroup(CheckOrigin origin) {
        return this.primaryGroup;
    }

    @Override
    public final @Nullable String getPrimaryGroup() {
        return getPrimaryGroup(CheckOrigin.LUCKPERMS_API);
    }

    @Override
    public @NonNull MetaStackDefinition getPrefixStackDefinition() {
        return this.prefixDefinition;
    }

    @Override
    public @NonNull MetaStackDefinition getSuffixStackDefinition() {
        return this.suffixDefinition;
    }

    @Override
    public @NonNull QueryOptions getQueryOptions() {
        return this.queryOptions;
    }

    private static final class LowerCaseMetaMap extends ForwardingMap<String, List<StringResult<MetaNode>>> {
        private final Map<String, List<StringResult<MetaNode>>> delegate;

        private LowerCaseMetaMap(Map<String, List<StringResult<MetaNode>>> delegate) {
            this.delegate = delegate;
        }

        @Override
        protected Map<String, List<StringResult<MetaNode>>> delegate() {
            return this.delegate;
        }

        @Override
        public List<StringResult<MetaNode>> get(Object k) {
            if (k == null) {
                return null;
            }

            String key = (String) k;
            return super.get(key.toLowerCase(Locale.ROOT));
        }
    }

}


text:
package com.sun.corba.se.spi.monitoring;

import java.util.*;

/**
 *

 *
 * @author Hemanth Puttaswamy
 *

 *

 * StatisticsAccumulator accumulates the samples provided by the user and
 * computes the value of minimum, maximum, sum and sample square sum. When
 * the StatisticMonitoredAttribute calls getValue(), it will compute all
 * the statistics for the collected samples (Which are Minimum, Maximum,
 * Average, StandardDeviation) and provides a nice printable record as a
 * String.
 *
 * Users can easily extend this class and provide the implementation of
 * toString() method to format the stats as desired. By default all the stats
 * are printed in a single line.
 *

 */
public class StatisticsAccumulator {

  ///////////////////////////////////////
  // attributes

    // Users can extend this class to get access to current Max value
    protected double max = Double.MIN_VALUE;

    // Users can extend this class to get access to current Min value
    protected double min = Double.MAX_VALUE;

    private double sampleSum;

    private double sampleSquareSum;

    private long sampleCount;

    protected String unit;

  ///////////////////////////////////////
  // operations

/**
 *

 * User will use this method to just register a sample with the
 * StatisticsAccumulator. This is the only method that User will use to
 * expose the statistics, internally the StatisticMonitoredAttribute will
 * collect the information when requested from the ASAdmin.
 *

 *

 *
 *

 *

 *
 * @param value a double value to make it more precise
 *

 */
    public void sample(double value) {
        sampleCount++;
        if( value < min )  min = value;
        if( value > max) max = value;
        sampleSum += value;
        sampleSquareSum += (value * value);
    } // end sample

    /**
     *  Computes the Standard Statistic Results based on the samples collected
     *  so far and provides the complete value as a formatted String
     */
    public String getValue( ) {
        return toString();
    }

    /**
     *  Users can extend StatisticsAccumulator to provide the complete
     *  Stats in the format they prefer, if the default format doesn't suffice.
     */
    public String toString( ) {
        return "Minimum Value = " + min + " " + unit + " " +
            "Maximum Value = " + max + " " + unit + " " +
            "Average Value = " + computeAverage() + " " +  unit + " " +
            "Standard Deviation = " + computeStandardDeviation() + " " + unit +
            " " + "Samples Collected = " + sampleCount;
    }

    /**
     *  If users choose to custom format the stats.
     */
    protected double computeAverage( ) {
        return (sampleSum / sampleCount);
    }

    /**
     * We use a derived Standard Deviation formula to compute SD. This way
     * there is no need to hold on to all the samples provided.
     *
     * The method is protected to let users extend and format the results.
     */
    protected double computeStandardDeviation( ) {
        double sampleSumSquare = sampleSum * sampleSum;
        return Math.sqrt(
            (sampleSquareSum-((sampleSumSquare)/sampleCount))/(sampleCount-1));
    }

/**
 *

 * Construct the Statistics Accumulator by providing the unit as a String.
 * The examples of units are "Hours", "Minutes",
 * "Seconds", "MilliSeconds", "Micro Seconds"
 * etc.,
 *

 *

 *
 * @return a StatisticsAccumulator with ...
 *

 *

 * @param unit a String representing the units for the samples collected
 *

 */
    public StatisticsAccumulator( String unit ) {
        this.unit = unit;
        sampleCount = 0;
        sampleSum = 0;
        sampleSquareSum = 0;
    }

    /**
     *  Clears the samples and starts fresh on new samples.
     */
    void clearState( ) {
        min = Double.MAX_VALUE;
        max = Double.MIN_VALUE;
        sampleCount = 0;
        sampleSum = 0;
        sampleSquareSum = 0;
    }

    /**
     *  This is an internal API to test StatisticsAccumulator...
     */
    public void unitTestValidate( String expectedUnit, double expectedMin,
        double expectedMax, long expectedSampleCount, double expectedAverage,
        double expectedStandardDeviation )
    {
        if( !expectedUnit.equals( unit ) ){
            throw new RuntimeException(
                "Unit is not same as expected Unit" +
                "\nUnit = " + unit + "ExpectedUnit = " + expectedUnit );
        }
        if( min != expectedMin ) {
            throw new RuntimeException(
                "Minimum value is not same as expected minimum value" +
                "\nMin Value = " + min + "Expected Min Value = " + expectedMin);
        }
        if( max != expectedMax ) {
            throw new RuntimeException(
                "Maximum value is not same as expected maximum value" +
                "\nMax Value = " + max + "Expected Max Value = " + expectedMax);
        }
        if( sampleCount != expectedSampleCount ) {
            throw new RuntimeException(
                "Sample count is not same as expected Sample Count" +
                "\nSampleCount = " + sampleCount + "Expected Sample Count = " +
                expectedSampleCount);
        }
        if( computeAverage() != expectedAverage ) {
            throw new RuntimeException(
                "Average is not same as expected Average" +
                "\nAverage = " + computeAverage() + "Expected Average = " +
                expectedAverage);
        }
        // We are computing Standard Deviation from two different methods
        // for comparison. So, the values will not be the exact same to the last
        // few digits. So, we are taking the difference and making sure that
        // the difference is not greater than 1.
        double difference = Math.abs(
            computeStandardDeviation() - expectedStandardDeviation);
        if( difference > 1 ) {
            throw new RuntimeException(
                "Standard Deviation is not same as expected Std Deviation" +
                "\nStandard Dev = " + computeStandardDeviation() +
                "Expected Standard Dev = " + expectedStandardDeviation);
        }
    }

} // end StatisticsAccumulator


text:
namespace gpopt
{
// fwd declaration
class CDistributionSpec;

//---------------------------------------------------------------------------
//	@class:
//		CPhysicalSplit
//
//	@doc:
//		Physical split operator
//
//---------------------------------------------------------------------------
class CPhysicalSplit : public CPhysical
{
private:
	// deletion columns
	CColRefArray *m_pdrgpcrDelete;

	// insertion columns
	CColRefArray *m_pdrgpcrInsert;

	// ctid column
	CColRef *m_pcrCtid;

	// segmentid column
	CColRef *m_pcrSegmentId;

	// action column
	CColRef *m_pcrAction;

	// tuple oid column
	CColRef *m_pcrTupleOid;

	// required columns by local members
	CColRefSet *m_pcrsRequiredLocal;

public:
	CPhysicalSplit(const CPhysicalSplit &) = delete;

	// ctor
	CPhysicalSplit(CMemoryPool *mp, CColRefArray *pdrgpcrDelete,
				   CColRefArray *pdrgpcrInsert, CColRef *pcrCtid,
				   CColRef *pcrSegmentId, CColRef *pcrAction,
				   CColRef *pcrTupleOid);

	// dtor
	~CPhysicalSplit() override;

	// ident accessors
	EOperatorId
	Eopid() const override
	{
		return EopPhysicalSplit;
	}

	// return a string for operator name
	const CHAR *
	SzId() const override
	{
		return "CPhysicalSplit";
	}

	// action column
	CColRef *
	PcrAction() const
	{
		return m_pcrAction;
	}

	// ctid column
	CColRef *
	PcrCtid() const
	{
		return m_pcrCtid;
	}

	// segmentid column
	CColRef *
	PcrSegmentId() const
	{
		return m_pcrSegmentId;
	}

	// deletion columns
	CColRefArray *
	PdrgpcrDelete() const
	{
		return m_pdrgpcrDelete;
	}

	// insertion columns
	CColRefArray *
	PdrgpcrInsert() const
	{
		return m_pdrgpcrInsert;
	}

	// tuple oid column
	CColRef *
	PcrTupleOid() const
	{
		return m_pcrTupleOid;
	}

	// match function
	BOOL Matches(COperator *pop) const override;

	// hash function
	ULONG HashValue() const override;

	// sensitivity to order of inputs
	BOOL
	FInputOrderSensitive() const override
	{
		return false;
	}

	//-------------------------------------------------------------------------------------
	// Required Plan Properties
	//-------------------------------------------------------------------------------------

	// compute required sort columns of the n-th child
	COrderSpec *PosRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
							COrderSpec *posRequired, ULONG child_index,
							CDrvdPropArray *pdrgpdpCtxt,
							ULONG ulOptReq) const override;

	//-------------------------------------------------------------------------------------
	// Derived Plan Properties
	//-------------------------------------------------------------------------------------

	// derive sort order
	COrderSpec *PosDerive(CMemoryPool *mp,
						  CExpressionHandle &exprhdl) const override;

	//-------------------------------------------------------------------------------------
	// Enforced Properties
	//-------------------------------------------------------------------------------------

	// return order property enforcing type for this operator
	CEnfdProp::EPropEnforcingType EpetOrder(
		CExpressionHandle &exprhdl, const CEnfdOrder *peo) const override;

	// compute required output columns of the n-th child
	CColRefSet *PcrsRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
							 CColRefSet *pcrsRequired, ULONG child_index,
							 CDrvdPropArray *pdrgpdpCtxt,
							 ULONG ulOptReq) override;

	// compute required ctes of the n-th child
	CCTEReq *PcteRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
						  CCTEReq *pcter, ULONG child_index,
						  CDrvdPropArray *pdrgpdpCtxt,
						  ULONG ulOptReq) const override;

	// compute required distribution of the n-th child
	CDistributionSpec *PdsRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
								   CDistributionSpec *pdsRequired,
								   ULONG child_index,
								   CDrvdPropArray *pdrgpdpCtxt,
								   ULONG ulOptReq) const override;

	// compute required rewindability of the n-th child
	CRewindabilitySpec *PrsRequired(CMemoryPool *mp, CExpressionHandle &exprhdl,
									CRewindabilitySpec *prsRequired,
									ULONG child_index,
									CDrvdPropArray *pdrgpdpCtxt,
									ULONG ulOptReq) const override;

	// check if required columns are included in output columns
	BOOL FProvidesReqdCols(CExpressionHandle &exprhdl, CColRefSet *pcrsRequired,
						   ULONG ulOptReq) const override;

	//-------------------------------------------------------------------------------------
	// Derived Plan Properties
	//-------------------------------------------------------------------------------------

	// derive distribution
	CDistributionSpec *PdsDerive(CMemoryPool *mp,
								 CExpressionHandle &exprhdl) const override;

	// derive rewindability
	CRewindabilitySpec *PrsDerive(CMemoryPool *mp,
								  CExpressionHandle &exprhdl) const override;

	//-------------------------------------------------------------------------------------
	// Enforced Properties
	//-------------------------------------------------------------------------------------

	// return rewindability property enforcing type for this operator
	CEnfdProp::EPropEnforcingType EpetRewindability(
		CExpressionHandle &,		// exprhdl
		const CEnfdRewindability *	// per
	) const override;

	// return true if operator passes through stats obtained from children,
	// this is used when computing stats during costing
	BOOL
	FPassThruStats() const override
	{
		return false;
	}

	//-------------------------------------------------------------------------------------
	//-------------------------------------------------------------------------------------
	//-------------------------------------------------------------------------------------

	// conversion function
	static CPhysicalSplit *
	PopConvert(COperator *pop)
	{
		GPOS_ASSERT(COperator::EopPhysicalSplit == pop->Eopid());

		return dynamic_cast<CPhysicalSplit *>(pop);
	}

	// debug print
	IOstream &OsPrint(IOstream &os) const override;

};	// class CPhysicalSplit
}  // namespace gpopt

#endif	// !GPOS_CPhysicalSplit_H

// EOF


text:
<?xml version="1.0" encoding="utf-8" ?>
<athletes>
<athlete>
<athlete_id>217619</athlete_id>
<birthdate>07.08.1988</birthdate>
<birthyear>1988</birthyear>
<firstname>Saud</firstname>
<lastname>Al-Zaabi</lastname>
<height></height>
<weight></weight>
<gender>M</gender>
<club></club><nationality>UAE</nationality><birthplace></birthplace><accomplishments>
</accomplishments>
</athlete>
</athletes>


text:
package io.vividcode.feature9.process;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

public class LongRunningProcess {

  public ProcessHandle start() throws IOException {
    final ProcessBuilder processBuilder = new ProcessBuilder("top")
        .inheritIO();
    return processBuilder.start().toHandle();
  }

  public void waitFor(final ProcessHandle processHandle) {
    final CountDownLatch latch = new CountDownLatch(1);
    processHandle.onExit().whenCompleteAsync((handle, throwable) -> {
      if (throwable == null) {
        System.out.println(handle.pid());
      } else {
        throwable.printStackTrace();
      }
      latch.countDown();
    });
    final Thread shutdownThread = new Thread(() -> {
      try {
        Thread.sleep(1000);
      } catch (final InterruptedException e) {
        e.printStackTrace();
      }
      if (processHandle.supportsNormalTermination()) {
        processHandle.destroy();
      } else {
        processHandle.destroyForcibly();
      }
    });
    shutdownThread.start();
    try {
      shutdownThread.join();
      latch.await();
    } catch (final InterruptedException e) {
      e.printStackTrace();
    }
  }

  public static void main(final String[] args) {
    final LongRunningProcess longRunningProcess = new LongRunningProcess();
    try {
      longRunningProcess.waitFor(longRunningProcess.start());
    } catch (final IOException e) {
      e.printStackTrace();
    }
  }
}


text:
<?php

namespace Humweb\Pages;

use Humweb\Module\AbstractModule;

class Module extends AbstractModule
{
    public $name          = 'Pages';
    public $version       = '1.1';
    public $author        = 'Ryun SHofner';
    public $website       = 'humboldtweb.com';
    public $license       = 'BSD-3-Clause';
    public $description   = 'Pages Module';
    public $admin_section = 'Content';
    public $autoload      = [
        'routes.php',
    ];

    public function boot()
    {
        $this->app->bind('Humweb\Pages\Repositories\DbPageRepositoryInterface', 'Humweb\Pages\Repositories\DbPageRepository');
    }

    public function install()
    {
        Schema::create('pages', function ($table) {
            $table->increments('id');
            $table->integer('parent_id');
            $table->string('uri');
            $table->string('title');
            $table->string('slug');
            $table->text('content');
            $table->boolean('published');
            $table->integer('created_by');
            $table->datetime('published_at');
            $table->timestamps();
            $table->text('css');
            $table->text('js');
            $table->string('meta_title');
            $table->string('meta_description');
            $table->enum('meta_robots', array('noindex', 'nofollow', 'both', 'index', 'all'))->default('all');
            $table->boolean('is_index');
            $table->boolean('comment_status');
            $table->integer('order');

            $table->index('parent_id');
            $table->index('created_at');
            $table->index('uri');
        });

        $homePage = Page::create([
            'created_by' => 1,
            'slug'       => 'home',
            'parent_id'  => 0,
            'uri'        => 'home',
            'title'      => 'Home',
            'content'    => 'Welcome to your new site!',
            'published'  => 1,
            'is_index'   => 1,
            'order'      => 0,
        ]);

        return $homePage->slug == 'home';
    }

    public function upgrade()
    {
        return true;
    }

    public function uninstall()
    {
        Schema::dropIfExists('pages');

        return true;
    }

    public function admin_menu()
    {
        return [
            'Content' => [
                [
                    'label'    => 'Pages',
                    'url'      => url('/admin/pages'),
                    'icon'     => '<i class="fa fa-book" ></i>',
                    'children' => [
                        ['label' => 'List', 'url' => url('/admin/pages')],
                        ['label' => 'Create', 'url' => url('/admin/pages/create')],
                    ],
                ],
            ],
        ];
    }

    public function admin_quick_menu()
    {
        return [
            'index' => [
                ['label' => 'Add Page', 'url' => '/admin/pages/create'],
            ],
        ];
    }
}


text:
using System;
using Tellurium.VisualAssertions.Screenshots.Service;
using Tellurium.VisualAssertions.Screenshots.Service.ComparisonStrategies;

namespace Tellurium.VisualAssertions.Screenshots
{
    public class VisualAssertionsConfig
    {
        public string BrowserName { get; set; }
        public string ProjectName { get; set; }
        public string ScreenshotCategory { get; set; }
        public Action<string> TestOutputWriter { get; set; }
        public bool ProcessScreenshotsAsynchronously { get; set; }

        public ContinousIntegration ContinousIntegration { get; set; }
        /// It is possible to implement custom comparison strategy by supplying a class implementing IScreenshotComparisonStrategy interface
        /// </summary>
        public IScreenshotComparisonStrategy ScreenshotComparisonStrategy { get; set; }
    }

    public class PixelByPixelComparisonParameters
    {
        /// <summary>
        /// Percentage of pixels that can be different when matching two images.
        /// If percentage of pixels that are different is greater than this value then the images are considered unmatched
        /// </summary>
        /// <remarks>
        /// Accepted values: <0.0, 100.0>
        /// </remarks>
        public double MaxPercentOfUnmatchedPixels { get; }

        /// <summary>
        /// Number of pixels that can be different when matching two images.
        /// If number of pixels that are different is greater than this value then the images are considered unmatched
        /// </summary>
        public uint PixelToleranceCount { get; }

        public PixelByPixelComparisonParameters(double maxPercentOfUnmatchedPixels)
        {
            MaxPercentOfUnmatchedPixels = maxPercentOfUnmatchedPixels;
            PixelToleranceCount = uint.MaxValue;
        }

        public PixelByPixelComparisonParameters(uint pixelToleranceCount)
        {
            PixelToleranceCount = pixelToleranceCount;
            MaxPercentOfUnmatchedPixels = 100.0;
        }
    }
}


text:
using namespace celero;

///
/// \class Impl
///
class celero::JUnit::Impl
{
	public:
		Impl() :
			fileName(),
			results(),
			totalTime(0)
		{
		}

		std::string fileName;

		/// Store the test case size, measured baseline, objective baseline, and total run time in seconds.
		std::map<std::string, std::vector<std::shared_ptr<Result>>> results;

		double totalTime;
};

JUnit::JUnit() : pimpl()
{
}

JUnit::~JUnit()
{
}

JUnit& JUnit::Instance()
{
	static JUnit singleton;
	return singleton;
}

void JUnit::setFileName(const std::string& x)
{
	assert(x.empty() == false);
	this->pimpl->fileName = x;
}

void JUnit::add(std::shared_ptr<celero::Result> x)
{
	this->pimpl->results[x->getExperiment()->getBenchmark()->getName()].push_back(x);
	this->save();
}

void JUnit::save()
{
	std::ofstream ofs;
	ofs.open(this->pimpl->fileName);

	if(ofs.is_open() == true)
	{
		const auto os = &ofs;

		*os << "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n";

		for(auto i : this->pimpl->results)
		{
			uint64_t testSuiteTime = 0;
			size_t testSuiteFailures = 0;

			auto runs = i.second;

			for(auto j : runs)
			{
				if((j->getExperiment()->getBaselineTarget() > 0.0) && (j->getBaselineMeasurement() > j->getExperiment()->getBaselineTarget()))
				{
					testSuiteFailures++;
				}

				testSuiteTime += j->getRunTime();
			}

			*os << "<testsuite errors=\"0\" ";
			*os << "tests=\"" << i.second.size() << "\" ";
			*os << "time=\"" << celero::timer::ConvertSystemTime(testSuiteTime) << "\" ";
			*os << "failures=\"" << testSuiteFailures << "\" ";
			*os << "name=\"" << i.first << "\">\n";

			for(auto j : runs)
			{
				*os << "\t<testcase ";
				*os << "time=\"" << celero::timer::ConvertSystemTime(j->getRunTime()) << "\" ";
				*os << "name=\"" << j->getExperiment()->getName() << "#" << j->getProblemSpaceValue() << "\"";

				// Compare measured to objective
				if((j->getExperiment()->getBaselineTarget() > 0.0) && (j->getBaselineMeasurement() > j->getExperiment()->getBaselineTarget()))
				{
					// Failure
					*os << ">\n";

					*os << "\t\t<failure ";
					*os << "type=\"Performance objective not met.\" ";
					*os << "message=\"Measurement of " << j->getBaselineMeasurement() << " exceeds objective baseline of " << j->getExperiment()->getBaselineTarget() << "\" ";
					*os << "/>\n";

					*os << "\t</testcase>\n";
				}
				else
				{
					// Success
					*os << "/>\n";
				}
			}

			*os << "</testsuite>\n";
		}

		ofs.close();
	}
}


text:
<?xml version="1.0"?>
<?mso-application progid="Excel.Sheet"?>
<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
 xmlns:o="urn:schemas-microsoft-com:office:office"
 xmlns:x="urn:schemas-microsoft-com:office:excel"
 xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
 xmlns:html="http://www.w3.org/TR/REC-html40">
 <DocumentProperties xmlns="urn:schemas-microsoft-com:office:office">
  <Author>Grahame</Author>
  <LastAuthor>Lloyd McKenzie</LastAuthor>
  <Created>2012-03-19T11:12:07Z</Created>
  <LastSaved>2014-01-26T22:05:00Z</LastSaved>
  <Version>14.00</Version>
 </DocumentProperties>
 <OfficeDocumentSettings xmlns="urn:schemas-microsoft-com:office:office">
  <AllowPNG/>
 </OfficeDocumentSettings>
 <ExcelWorkbook xmlns="urn:schemas-microsoft-com:office:excel">
  <WindowHeight>6345</WindowHeight>
  <WindowWidth>22755</WindowWidth>
  <WindowTopX>5520</WindowTopX>
  <WindowTopY>6075</WindowTopY>
  <ProtectStructure>False</ProtectStructure>
  <ProtectWindows>False</ProtectWindows>
 </ExcelWorkbook>
 <Styles>
  <Style ss:ID="Default" ss:Name="Normal">
   <Alignment ss:Vertical="Bottom"/>
   <Borders/>
   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>
   <Interior/>
   <NumberFormat/>
   <Protection/>
  </Style>
  <Style ss:ID="s62">
   <Alignment ss:Horizontal="Left" ss:Vertical="Top" ss:ShrinkToFit="1"
    ss:WrapText="1"/>
  </Style>
  <Style ss:ID="s63">
   <Alignment ss:Horizontal="Left" ss:Vertical="Top" ss:ShrinkToFit="1"
    ss:WrapText="1"/>
   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"
    ss:Bold="1"/>
  </Style>
  <Style ss:ID="s64">
   <Alignment ss:Horizontal="Left" ss:Vertical="Top" ss:ShrinkToFit="1"
    ss:WrapText="1"/>
   <Borders>
    <Border ss:Position="Bottom" ss:LineStyle="Continuous" ss:Weight="1"/>
   </Borders>
   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"
    ss:Bold="1"/>
   <Interior ss:Color="#EEECE1" ss:Pattern="Solid"/>
  </Style>
  <Style ss:ID="s65">
   <Alignment ss:Horizontal="Left" ss:Vertical="Top" ss:ShrinkToFit="1"
    ss:WrapText="1"/>
   <Interior ss:Color="#D9D9D9" ss:Pattern="Solid"/>
  </Style>
  <Style ss:ID="s68">
   <Alignment ss:Vertical="Bottom" ss:ShrinkToFit="1" ss:WrapText="1"/>
  </Style>
  <Style ss:ID="s69">
   <Alignment ss:Vertical="Top" ss:WrapText="1"/>
  </Style>
  <Style ss:ID="s70">
   <Alignment ss:Vertical="Top"/>
  </Style>
  <Style ss:ID="s83">
   <Alignment ss:Vertical="Top" ss:WrapText="1"/>
   <Borders/>
   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>
   <Interior/>
   <NumberFormat/>
   <Protection/>
  </Style>
 </Styles>
 <Worksheet ss:Name="Data Elements">
  <Table ss:ExpandedColumnCount="16" ss:ExpandedRowCount="14" x:FullColumns="1"
   x:FullRows="1" ss:StyleID="s62" ss:DefaultRowHeight="15">
   <Column ss:StyleID="s63" ss:AutoFitWidth="0" ss:Width="150.75"/>
   <Column ss:StyleID="s62" ss:Width="29.25"/>
   <Column ss:StyleID="s62" ss:Width="22.5"/>
   <Column ss:StyleID="s62" ss:Width="60"/>
   <Column ss:StyleID="s62" ss:Width="27"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="119.25"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="106.5"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="192.75"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="161.25"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="77.25"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="114"/>
   <Column ss:StyleID="s62" ss:AutoFitWidth="0" ss:Width="135" ss:Span="1"/>
   <Row ss:Height="30" ss:StyleID="s64">
    <Cell><Data ss:Type="String">Element</Data></Cell>
    <Cell><Data ss:Type="String">Card.</Data></Cell>
    <Cell><Data ss:Type="String">Inv.</Data></Cell>
    <Cell><Data ss:Type="String">Must Understand</Data></Cell>
    <Cell><Data ss:Type="String">UML</Data></Cell>
    <Cell><Data ss:Type="String">Type</Data></Cell>
    <Cell><Data ss:Type="String">Binding</Data></Cell>
    <Cell><Data ss:Type="String">Short Name</Data></Cell>
    <Cell><Data ss:Type="String">Definition</Data></Cell>
    <Cell><Data ss:Type="String">Aliases</Data></Cell>
    <Cell><Data ss:Type="String">Requirements</Data></Cell>
    <Cell><Data ss:Type="String">Comments</Data></Cell>
    <Cell><Data ss:Type="String">RIM Mapping</Data></Cell>
    <Cell><Data ss:Type="String">v2 Mapping</Data></Cell>
    <Cell><Data ss:Type="String">To Do</Data></Cell>
    <Cell><Data ss:Type="String">Committee Notes</Data></Cell>
   </Row>
   <Row ss:Height="30">
    <Cell><Data ss:Type="String">Query</Data></Cell>
    <Cell ss:StyleID="s65"/>
    <Cell ss:StyleID="s65"/>
    <Cell ss:StyleID="s65"/>
    <Cell ss:StyleID="s65"/>
    <Cell><Data ss:Type="String">Resource</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell><Data ss:Type="String">A description of a query with a set of parameters</Data></Cell>
    <Cell ss:Index="11" ss:StyleID="s83"/>
    <Cell ss:Index="13" ss:StyleID="s83"><Data ss:Type="String">QuerySpec</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.identifier</Data></Cell>
    <Cell><Data ss:Type="String">1..1</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
    <Cell><Data ss:Type="String">uri</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell><Data ss:Type="String">Links query and its response(s)</Data></Cell>
    <Cell ss:Index="11" ss:StyleID="s83"/>
    <Cell ss:Index="13" ss:StyleID="s83"><Data ss:Type="String">.queryId</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
   </Row>
   <Row ss:Height="45">
    <Cell><Data ss:Type="String">Query.parameter</Data></Cell>
    <Cell><Data ss:Type="String">1..*</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
    <Cell><Data ss:Type="String" x:Ticked="1">Extension</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell><Data ss:Type="String">Set of query parameters with values</Data></Cell>
    <Cell ss:Index="11" ss:StyleID="s83"/>
    <Cell><Data ss:Type="String">Unless otherwise specified, parameters are usually strings</Data></Cell>
    <Cell ss:StyleID="s83"><Data ss:Type="String">.parameter</Data></Cell>
    <Cell ss:StyleID="s83"/>
    <Cell ss:StyleID="s83"/>
   </Row>
   <Row ss:Height="60">
    <Cell><Data ss:Type="String">Query.response</Data></Cell>
    <Cell><Data ss:Type="String">0..1</Data></Cell>
    <Cell ss:Index="5"><Data ss:Type="String">right</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">If this is a response to a query</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">QueryAck (indirectly linked through .queryId, directly linked via Message.acknowledges</Data></Cell>
   </Row>
   <Row ss:Height="135">
    <Cell><Data ss:Type="String">Query.response.identifier</Data></Cell>
    <Cell><Data ss:Type="String">1..1</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">uri</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">Links response to source query</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">.queryId?</Data></Cell>
    <Cell ss:Index="15"><Data ss:Type="String">Need to explain if/how this differs from value of Query.identifier</Data></Cell>
   </Row>
   <Row ss:Height="30">
    <Cell><Data ss:Type="String">Query.response.outcome</Data></Cell>
    <Cell><Data ss:Type="String">1..1</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">code</Data></Cell>
    <Cell><Data ss:Type="String">QueryOutcome</Data></Cell>
    <Cell><Data ss:Type="String">ok | limited | refused | error</Data></Cell>
    <Cell><Data ss:Type="String">Outcome of processing the query</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">.queryResponseCode</Data></Cell>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.response.total</Data></Cell>
    <Cell><Data ss:Type="String">0..1</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">integer</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">Total number of matching records</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">.resultTotalQuantity</Data></Cell>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.response.parameter</Data></Cell>
    <Cell><Data ss:Type="String">0..*</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String" x:Ticked="1">Extension</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">Parameters server used</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">Not supported</Data></Cell>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.response.first</Data></Cell>
    <Cell><Data ss:Type="String">0..*</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String" x:Ticked="1">Extension</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">To get first page (if paged)</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">Not supported</Data></Cell>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.response.previous</Data></Cell>
    <Cell><Data ss:Type="String">0..*</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String" x:Ticked="1">Extension</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">To get previous page (if paged)</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">Not supported</Data></Cell>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.response.next</Data></Cell>
    <Cell><Data ss:Type="String">0..*</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String" x:Ticked="1">Extension</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">To get next page (if paged)</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">.continuationToken</Data></Cell>
   </Row>
   <Row>
    <Cell><Data ss:Type="String">Query.response.last</Data></Cell>
    <Cell><Data ss:Type="String">0..*</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String" x:Ticked="1">Extension</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">To get last page (if paged)</Data></Cell>
    <Cell ss:Index="13"><Data ss:Type="String">Not supported</Data></Cell>
   </Row>
   <Row ss:Height="90">
    <Cell><Data ss:Type="String">Query.response.reference</Data></Cell>
    <Cell><Data ss:Type="String">0..*</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">Resource(Any)</Data></Cell>
    <Cell ss:Index="8"><Data ss:Type="String">Resources that are the results of the search</Data></Cell>
    <Cell ss:Index="12"><Data ss:Type="String">Is query only used in messaging? </Data></Cell>
    <Cell><Data ss:Type="String">.controlAct.outboundRelationship[typeCode=SUBJ].target
or
.controlAct.participation[typeCode=SBJ].role</Data></Cell>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Selected/>
   <FreezePanes/>
   <FrozenNoSplit/>
   <SplitHorizontal>1</SplitHorizontal>
   <TopRowBottomPane>1</TopRowBottomPane>
   <SplitVertical>1</SplitVertical>
   <LeftColumnRightPane>1</LeftColumnRightPane>
   <ActivePane>0</ActivePane>
   <Panes>
    <Pane>
     <Number>3</Number>
    </Pane>
    <Pane>
     <Number>1</Number>
    </Pane>
    <Pane>
     <Number>2</Number>
    </Pane>
    <Pane>
     <Number>0</Number>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
 <Worksheet ss:Name="Invariants">
  <Table ss:ExpandedColumnCount="6" ss:ExpandedRowCount="6" x:FullColumns="1"
   x:FullRows="1" ss:StyleID="s68" ss:DefaultRowHeight="15">
   <Column ss:Index="2" ss:StyleID="s68" ss:AutoFitWidth="0" ss:Width="115.5"/>
   <Column ss:StyleID="s68" ss:AutoFitWidth="0" ss:Width="153"/>
   <Column ss:StyleID="s68" ss:AutoFitWidth="0" ss:Width="204.75"/>
   <Column ss:StyleID="s68" ss:AutoFitWidth="0" ss:Width="198.75"/>
   <Column ss:StyleID="s68" ss:AutoFitWidth="0" ss:Width="188.25"/>
   <Row ss:AutoFitHeight="0" ss:StyleID="s64">
    <Cell><Data ss:Type="String">Id</Data></Cell>
    <Cell><Data ss:Type="String">Name</Data></Cell>
    <Cell><Data ss:Type="String">Context</Data></Cell>
    <Cell><Data ss:Type="String">English</Data></Cell>
    <Cell><Data ss:Type="String">OCL</Data></Cell>
    <Cell><Data ss:Type="String">XPath</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="s63"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="s63"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="s63"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="s63"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="s63"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
    <Cell ss:StyleID="Default"/>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Unsynced/>
   <FreezePanes/>
   <FrozenNoSplit/>
   <SplitHorizontal>1</SplitHorizontal>
   <TopRowBottomPane>1</TopRowBottomPane>
   <SplitVertical>2</SplitVertical>
   <LeftColumnRightPane>2</LeftColumnRightPane>
   <ActivePane>0</ActivePane>
   <Panes>
    <Pane>
     <Number>3</Number>
    </Pane>
    <Pane>
     <Number>1</Number>
    </Pane>
    <Pane>
     <Number>2</Number>
    </Pane>
    <Pane>
     <Number>0</Number>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
 <Worksheet ss:Name="Events">
  <Table ss:ExpandedColumnCount="6" ss:ExpandedRowCount="3" x:FullColumns="1"
   x:FullRows="1" ss:DefaultRowHeight="15">
   <Column ss:AutoFitWidth="0" ss:Width="82.5"/>
   <Column ss:AutoFitWidth="0" ss:Width="198.75"/>
   <Column ss:AutoFitWidth="0" ss:Width="157.5"/>
   <Column ss:AutoFitWidth="0" ss:Width="162.75"/>
   <Column ss:AutoFitWidth="0" ss:Width="195.75"/>
   <Column ss:AutoFitWidth="0" ss:Width="74.25"/>
   <Row ss:AutoFitHeight="0" ss:Height="33">
    <Cell ss:StyleID="s64"><Data ss:Type="String">Event Code</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Description</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Notes</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Request Resources</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Response Resources</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Follow Ups</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="s69"><Data ss:Type="String">query</Data></Cell>
    <Cell ss:StyleID="s69"><Data ss:Type="String">Request to perform a query according to the attached query resource</Data></Cell>
    <Cell ss:StyleID="s69"/>
    <Cell ss:StyleID="s69"><Data ss:Type="String">query</Data></Cell>
    <Cell ss:StyleID="s69"><Data ss:Type="String">query</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">query-response</Data></Cell>
    <Cell><Data ss:Type="String">Response with the result of processing the query</Data></Cell>
    <Cell><Data ss:Type="String">Used when queries are performed asynchronously</Data></Cell>
    <Cell><Data ss:Type="String">query</Data></Cell>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Unsynced/>
   <FreezePanes/>
   <FrozenNoSplit/>
   <SplitHorizontal>1</SplitHorizontal>
   <TopRowBottomPane>1</TopRowBottomPane>
   <SplitVertical>1</SplitVertical>
   <LeftColumnRightPane>1</LeftColumnRightPane>
   <ActivePane>0</ActivePane>
   <Panes>
    <Pane>
     <Number>3</Number>
    </Pane>
    <Pane>
     <Number>1</Number>
    </Pane>
    <Pane>
     <Number>2</Number>
    </Pane>
    <Pane>
     <Number>0</Number>
     <ActiveRow>2</ActiveRow>
     <ActiveCol>2</ActiveCol>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
 <Worksheet ss:Name="Search">
  <Table ss:ExpandedColumnCount="8" ss:ExpandedRowCount="41" x:FullColumns="1"
   x:FullRows="1" ss:DefaultRowHeight="15">
   <Column ss:AutoFitWidth="0" ss:Width="70.5"/>
   <Column ss:AutoFitWidth="0" ss:Width="382.5"/>
   <Row ss:AutoFitHeight="0" ss:Height="16.5" ss:StyleID="s64">
    <Cell><Data ss:Type="String">Name</Data></Cell>
    <Cell><Data ss:Type="String">Description</Data></Cell>
    <Cell><Data ss:Type="String">Type</Data></Cell>
    <Cell><Data ss:Type="String">Path</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">identifier</Data></Cell>
    <Cell ss:Index="3"><Data ss:Type="String">token</Data></Cell>
    <Cell><Data ss:Type="String">Query.identifier</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">response</Data></Cell>
    <Cell ss:Index="3"><Data ss:Type="String">token</Data></Cell>
    <Cell><Data ss:Type="String">Query.response.identifier</Data></Cell>
   </Row>
   <Row ss:Index="6" ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:Index="8" ss:StyleID="s63"/>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Unsynced/>
   <FreezePanes/>
   <FrozenNoSplit/>
   <SplitHorizontal>1</SplitHorizontal>
   <TopRowBottomPane>1</TopRowBottomPane>
   <SplitVertical>1</SplitVertical>
   <LeftColumnRightPane>1</LeftColumnRightPane>
   <ActivePane>0</ActivePane>
   <Panes>
    <Pane>
     <Number>3</Number>
    </Pane>
    <Pane>
     <Number>1</Number>
    </Pane>
    <Pane>
     <Number>2</Number>
    </Pane>
    <Pane>
     <Number>0</Number>
     <ActiveRow>2</ActiveRow>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
 <Worksheet ss:Name="Bindings">
  <Table ss:ExpandedColumnCount="5" ss:ExpandedRowCount="4" x:FullColumns="1"
   x:FullRows="1" ss:DefaultRowHeight="15">
   <Column ss:AutoFitWidth="0" ss:Width="93"/>
   <Column ss:AutoFitWidth="0" ss:Width="221.25"/>
   <Column ss:AutoFitWidth="0" ss:Width="81.75"/>
   <Column ss:AutoFitWidth="0" ss:Width="106.5"/>
   <Column ss:AutoFitWidth="0" ss:Width="274.5"/>
   <Row ss:AutoFitHeight="0" ss:Height="15.75">
    <Cell ss:StyleID="s64"><Data ss:Type="String">Binding Name</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Definition</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Binding</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Reference</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Description</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="s62"><Data ss:Type="String">QueryOutcome</Data></Cell>
    <Cell ss:StyleID="s62"><Data ss:Type="String">The outcome of processing a query request</Data></Cell>
    <Cell ss:StyleID="s70"><Data ss:Type="String">code list</Data></Cell>
    <Cell><Data ss:Type="String">#query-outcome</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="s62"/>
    <Cell ss:StyleID="s62"/>
    <Cell ss:StyleID="s70"/>
    <Cell ss:StyleID="s70"/>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="s62"/>
    <Cell ss:StyleID="s62"/>
    <Cell ss:StyleID="s70"/>
    <Cell ss:StyleID="s70"/>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Unsynced/>
   <FreezePanes/>
   <FrozenNoSplit/>
   <SplitHorizontal>1</SplitHorizontal>
   <TopRowBottomPane>1</TopRowBottomPane>
   <SplitVertical>1</SplitVertical>
   <LeftColumnRightPane>1</LeftColumnRightPane>
   <ActivePane>0</ActivePane>
   <Panes>
    <Pane>
     <Number>3</Number>
    </Pane>
    <Pane>
     <Number>1</Number>
    </Pane>
    <Pane>
     <Number>2</Number>
    </Pane>
    <Pane>
     <Number>0</Number>
     <ActiveRow>7</ActiveRow>
     <ActiveCol>4</ActiveCol>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
 <Worksheet ss:Name="query-outcome">
  <Table ss:ExpandedColumnCount="3" ss:ExpandedRowCount="5" x:FullColumns="1"
   x:FullRows="1" ss:DefaultRowHeight="15">
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">Id</Data></Cell>
    <Cell><Data ss:Type="String">Code</Data></Cell>
    <Cell><Data ss:Type="String">Definition</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="Number">1</Data></Cell>
    <Cell><Data ss:Type="String">ok</Data></Cell>
    <Cell><Data ss:Type="String">The query was processed successfully</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="Number">2</Data></Cell>
    <Cell><Data ss:Type="String">limited</Data></Cell>
    <Cell><Data ss:Type="String">The query was processed successfully, but some additional limitations were added</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="Number">3</Data></Cell>
    <Cell><Data ss:Type="String">refused</Data></Cell>
    <Cell><Data ss:Type="String">The server refused to process the query </Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="Number">4</Data></Cell>
    <Cell><Data ss:Type="String">error</Data></Cell>
    <Cell><Data ss:Type="String">The server tried to process the query, but some error occurred</Data></Cell>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Unsynced/>
   <Panes>
    <Pane>
     <Number>3</Number>
     <ActiveRow>1</ActiveRow>
     <ActiveCol>1</ActiveCol>
     <RangeSelection>R2C2:R5C2</RangeSelection>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
 <Worksheet ss:Name="Examples">
  <Table ss:ExpandedColumnCount="6" ss:ExpandedRowCount="4" x:FullColumns="1"
   x:FullRows="1" ss:DefaultRowHeight="15">
   <Column ss:AutoFitWidth="0" ss:Width="54"/>
   <Column ss:AutoFitWidth="0" ss:Width="120"/>
   <Column ss:AutoFitWidth="0" ss:Width="94.5"/>
   <Column ss:AutoFitWidth="0" ss:Width="132"/>
   <Column ss:AutoFitWidth="0" ss:Width="120.75"/>
   <Column ss:AutoFitWidth="0" ss:Width="57.75"/>
   <Row ss:AutoFitHeight="0">
    <Cell ss:StyleID="s64"><Data ss:Type="String">Name</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Description</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Identity</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Filename</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">Type</Data></Cell>
    <Cell ss:StyleID="s64"><Data ss:Type="String">In Book</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">Simple</Data></Cell>
    <Cell><Data ss:Type="String">Simple example</Data></Cell>
    <Cell><Data ss:Type="Number">1</Data></Cell>
    <Cell><Data ss:Type="String">query-example.xml</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">y</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">Request</Data></Cell>
    <Cell><Data ss:Type="String">Request Message Example</Data></Cell>
    <Cell><Data ss:Type="String">req</Data></Cell>
    <Cell><Data ss:Type="String">query-example-request.xml</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">n</Data></Cell>
   </Row>
   <Row ss:AutoFitHeight="0">
    <Cell><Data ss:Type="String">Response</Data></Cell>
    <Cell><Data ss:Type="String">Response Message Example</Data></Cell>
    <Cell><Data ss:Type="String">resp</Data></Cell>
    <Cell><Data ss:Type="String">query-example-response.xml</Data></Cell>
    <Cell ss:Index="6"><Data ss:Type="String">n</Data></Cell>
   </Row>
  </Table>
  <WorksheetOptions xmlns="urn:schemas-microsoft-com:office:excel">
   <PageSetup>
    <Header x:Margin="0.3"/>
    <Footer x:Margin="0.3"/>
    <PageMargins x:Bottom="0.75" x:Left="0.7" x:Right="0.7" x:Top="0.75"/>
   </PageSetup>
   <Unsynced/>
   <Panes>
    <Pane>
     <Number>3</Number>
     <ActiveRow>3</ActiveRow>
     <ActiveCol>2</ActiveCol>
    </Pane>
   </Panes>
   <ProtectObjects>False</ProtectObjects>
   <ProtectScenarios>False</ProtectScenarios>
  </WorksheetOptions>
 </Worksheet>
</Workbook>