// This file was GENERATED by command:

//     pump.py gtest-param-test.h.pump

// DO NOT EDIT BY HAND!!!

// Copyright 2008, Google Inc.

// All rights reserved.

//

// Redistribution and use in source and binary forms, with or without

// modification, are permitted provided that the following conditions are

// met:

//

//     * Redistributions of source code must retain the above copyright

// notice, this list of conditions and the following disclaimer.

//     * Redistributions in binary form must reproduce the above

// copyright notice, this list of conditions and the following disclaimer

// in the documentation and/or other materials provided with the

// distribution.

//     * Neither the name of Google Inc. nor the names of its

// contributors may be used to endorse or promote products derived from

// this software without specific prior written permission.

//

// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

//

// Authors: vladl@google.com (Vlad Losev)

//

// Macros and functions for implementing parameterized tests

// in Google C++ Testing Framework (Google Test)

//

// This file is generated by a SCRIPT.  DO NOT EDIT BY HAND!

//

#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_

// Value-parameterized tests allow you to test your code with different

// parameters without writing multiple copies of the same test.

//

// Here is how you use value-parameterized tests:

#if 0

// To write value-parameterized tests, first you should define a fixture

// class. It is usually derived from testing::TestWithParam<T> (see below for

// another inheritance scheme that's sometimes useful in more complicated

// class hierarchies), where the type of your parameter values.

// TestWithParam<T> is itself derived from testing::Test. T can be any

// copyable type. If it's a raw pointer, you are responsible for managing the

// lifespan of the pointed values.

class FooTest : public ::testing::TestWithParam<const char*> {

  // You can implement all the usual class fixture members here.

};

// Then, use the TEST_P macro to define as many parameterized tests

// for this fixture as you want. The _P suffix is for "parameterized"

// or "pattern", whichever you prefer to think.

TEST_P(FooTest, DoesBlah) {

  // Inside a test, access the test parameter with the GetParam() method

  // of the TestWithParam<T> class:

  EXPECT_TRUE(foo.Blah(GetParam()));

  ...

}

TEST_P(FooTest, HasBlahBlah) {

  ...

}

// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test

// case with any set of parameters you want. Google Test defines a number

// of functions for generating test parameters. They return what we call

// (surprise!) parameter generators. Here is a  summary of them, which

// are all in the testing namespace:

//

//

//  Range(begin, end [, step]) - Yields values {begin, begin+step,

//                               begin+step+step, ...}. The values do not

//                               include end. step defaults to 1.

//  Values(v1, v2, ..., vN)    - Yields values {v1, v2, ..., vN}.

//  ValuesIn(container)        - Yields values from a C-style array, an STL

//  ValuesIn(begin,end)          container, or an iterator range [begin, end).

//  Bool()                     - Yields sequence {false, true}.

//  Combine(g1, g2, ..., gN)   - Yields all combinations (the Cartesian product

//                               for the math savvy) of the values generated

//                               by the N generators.

//

// For more details, see comments at the definitions of these functions below

// in this file.

//

// The following statement will instantiate tests from the FooTest test case

// each with parameter values "meeny", "miny", and "moe".

INSTANTIATE_TEST_CASE_P(InstantiationName,

                        FooTest,

                        Values("meeny", "miny", "moe"));

// To distinguish different instances of the pattern, (yes, you

// can instantiate it more then once) the first argument to the

// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the

// actual test case name. Remember to pick unique prefixes for different

// instantiations. The tests from the instantiation above will have

// these names:

//

//    * InstantiationName/FooTest.DoesBlah/0 for "meeny"

//    * InstantiationName/FooTest.DoesBlah/1 for "miny"

//    * InstantiationName/FooTest.DoesBlah/2 for "moe"

//    * InstantiationName/FooTest.HasBlahBlah/0 for "meeny"

//    * InstantiationName/FooTest.HasBlahBlah/1 for "miny"

//    * InstantiationName/FooTest.HasBlahBlah/2 for "moe"

//

// You can use these names in --gtest_filter.

//

// This statement will instantiate all tests from FooTest again, each

// with parameter values "cat" and "dog":

const char* pets[] = {"cat", "dog"};

INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets));

// The tests from the instantiation above will have these names:

//

//    * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat"

//    * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog"

//    * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat"

//    * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog"

//

// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests

// in the given test case, whether their definitions come before or

// AFTER the INSTANTIATE_TEST_CASE_P statement.

//

// Please also note that generator expressions (including parameters to the

// generators) are evaluated in InitGoogleTest(), after main() has started.

// This allows the user on one hand, to adjust generator parameters in order

// to dynamically determine a set of tests to run and on the other hand,

// give the user a chance to inspect the generated tests with Google Test

// reflection API before RUN_ALL_TESTS() is executed.

//

// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc

// for more examples.

//

// In the future, we plan to publish the API for defining new parameter

// generators. But for now this interface remains part of the internal

// implementation and is subject to change.

//

//

// A parameterized test fixture must be derived from testing::Test and from

// testing::WithParamInterface<T>, where T is the type of the parameter

// values. Inheriting from TestWithParam<T> satisfies that requirement because

// TestWithParam<T> inherits from both Test and WithParamInterface. In more

// complicated hierarchies, however, it is occasionally useful to inherit

// separately from Test and WithParamInterface. For example:

class BaseTest : public ::testing::Test {

  // You can inherit all the usual members for a non-parameterized test

  // fixture here.

};

class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {

  // The usual test fixture members go here too.

};

TEST_F(BaseTest, HasFoo) {

  // This is an ordinary non-parameterized test.

}

TEST_P(DerivedTest, DoesBlah) {

  // GetParam works just the same here as if you inherit from TestWithParam.

  EXPECT_TRUE(foo.Blah(GetParam()));

}

#endif  // 0

#include "gtest/internal/gtest-port.h"

#if !GTEST_OS_SYMBIAN

# include <utility>

#endif

// scripts/fuse_gtest.py depends on gtest's own header being #included

// *unconditionally*.  Therefore these #includes cannot be moved

// inside #if GTEST_HAS_PARAM_TEST.

#include "gtest/internal/gtest-internal.h"

#include "gtest/internal/gtest-param-util.h"

#include "gtest/internal/gtest-param-util-generated.h"

#if GTEST_HAS_PARAM_TEST

namespace testing {

// Functions producing parameter generators.

//

// Google Test uses these generators to produce parameters for value-

// parameterized tests. When a parameterized test case is instantiated

// with a particular generator, Google Test creates and runs tests

// for each element in the sequence produced by the generator.

//

// In the following sample, tests from test case FooTest are instantiated

// each three times with parameter values 3, 5, and 8:

//

// class FooTest : public TestWithParam<int> { ... };

//

// TEST_P(FooTest, TestThis) {

// }

// TEST_P(FooTest, TestThat) {

// }

// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8));

//

// Range() returns generators providing sequences of values in a range.

//

// Synopsis:

// Range(start, end)

//   - returns a generator producing a sequence of values {start, start+1,

//     start+2, ..., }.

// Range(start, end, step)

//   - returns a generator producing a sequence of values {start, start+step,

//     start+step+step, ..., }.

// Notes:

//   * The generated sequences never include end. For example, Range(1, 5)

//     returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2)

//     returns a generator producing {1, 3, 5, 7}.

//   * start and end must have the same type. That type may be any integral or

//     floating-point type or a user defined type satisfying these conditions:

//     * It must be assignable (have operator=() defined).

//     * It must have operator+() (operator+(int-compatible type) for

//       two-operand version).

//     * It must have operator<() defined.

//     Elements in the resulting sequences will also have that type.

//   * Condition start < end must be satisfied in order for resulting sequences

//     to contain any elements.

//

template <typename T, typename IncrementT>

internal::ParamGenerator<T> Range(T start, T end, IncrementT step) {

  return internal::ParamGenerator<T>(

      new internal::RangeGenerator<T, IncrementT>(start, end, step));

}

template <typename T>

internal::ParamGenerator<T> Range(T start, T end) {

  return Range(start, end, 1);

}

// ValuesIn() function allows generation of tests with parameters coming from

// a container.

//

// Synopsis:

// ValuesIn(const T (&array)[N])

//   - returns a generator producing sequences with elements from

//     a C-style array.

// ValuesIn(const Container& container)

//   - returns a generator producing sequences with elements from

//     an STL-style container.

// ValuesIn(Iterator begin, Iterator end)

//   - returns a generator producing sequences with elements from

//     a range [begin, end) defined by a pair of STL-style iterators. These

//     iterators can also be plain C pointers.

//

// Please note that ValuesIn copies the values from the containers

// passed in and keeps them to generate tests in RUN_ALL_TESTS().

//

// Examples:

//

// This instantiates tests from test case StringTest

// each with C-string values of "foo", "bar", and "baz":

//

// const char* strings[] = {"foo", "bar", "baz"};

// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings));

//

// This instantiates tests from test case StlStringTest

// each with STL strings with values "a" and "b":

//

// ::std::vector< ::std::string> GetParameterStrings() {

//   ::std::vector< ::std::string> v;

//   v.push_back("a");

//   v.push_back("b");

//   return v;

// }

//

// INSTANTIATE_TEST_CASE_P(CharSequence,

//                         StlStringTest,

//                         ValuesIn(GetParameterStrings()));

//

//

// This will also instantiate tests from CharTest

// each with parameter values 'a' and 'b':

//

// ::std::list<char> GetParameterChars() {

//   ::std::list<char> list;

//   list.push_back('a');

//   list.push_back('b');

//   return list;

// }

// ::std::list<char> l = GetParameterChars();

// INSTANTIATE_TEST_CASE_P(CharSequence2,

//                         CharTest,

//                         ValuesIn(l.begin(), l.end()));

//

template <typename ForwardIterator>

internal::ParamGenerator<

  typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type>

ValuesIn(ForwardIterator begin, ForwardIterator end) {

  typedef typename ::testing::internal::IteratorTraits<ForwardIterator>

      ::value_type ParamType;

  return internal::ParamGenerator<ParamType>(

      new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end));

}

template <typename T, size_t N>

internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) {

  return ValuesIn(array, array + N);

}

template <class Container>

internal::ParamGenerator<typename Container::value_type> ValuesIn(

    const Container& container) {

  return ValuesIn(container.begin(), container.end());

}

// Values() allows generating tests from explicitly specified list of

// parameters.

//

// Synopsis:

// Values(T v1, T v2, ..., T vN)

//   - returns a generator producing sequences with elements v1, v2, ..., vN.

//

// For example, this instantiates tests from test case BarTest each

// with values "one", "two", and "three":

//

// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three"));

//

// This instantiates tests from test case BazTest each with values 1, 2, 3.5.

// The exact type of values will depend on the type of parameter in BazTest.

//

// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5));

//

// Currently, Values() supports from 1 to 50 parameters.

//

template <typename T1>

internal::ValueArray1<T1> Values(T1 v1) {

  return internal::ValueArray1<T1>(v1);

}

template <typename T1, typename T2>

internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) {

  return internal::ValueArray2<T1, T2>(v1, v2);

}

template <typename T1, typename T2, typename T3>

internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) {

  return internal::ValueArray3<T1, T2, T3>(v1, v2, v3);

}

template <typename T1, typename T2, typename T3, typename T4>

internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) {

  return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4);

}

template <typename T1, typename T2, typename T3, typename T4, typename T5>

internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4,

    T5 v5) {

  return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5);

}

template 

    typename T6>

internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3,

    T4 v4, T5 v5, T6 v6) {

  return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6);

}

template 

    typename T6, typename T7>

internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3,

    T4 v4, T5 v5, T6 v6, T7 v7) {

  return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5,

      v6, v7);

}

template 

    typename T6, typename T7, typename T8>

internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2,

    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) {

  return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4,

      v5, v6, v7, v8);

}

template 

    typename T6, typename T7, typename T8, typename T9>

internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2,

    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) {

  return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3,

      v4, v5, v6, v7, v8, v9);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10>

internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1,

    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) {

  return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1,

      v2, v3, v4, v5, v6, v7, v8, v9, v10);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11>

internal::ValueArray11

    T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11) {

  return internal::ValueArray11

      T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12>

internal::ValueArray12

    T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12) {

  return internal::ValueArray12

      T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13>

internal::ValueArray13

    T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12, T13 v13) {

  return internal::ValueArray13

      T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14>

internal::ValueArray14

    T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) {

  return internal::ValueArray14

      T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,

      v14);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15>

internal::ValueArray15

    T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,

    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) {

  return internal::ValueArray15

      T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,

      v13, v14, v15);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16>

internal::ValueArray16

    T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,

    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,

    T16 v16) {

  return internal::ValueArray16

      T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,

      v12, v13, v14, v15, v16);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17>

internal::ValueArray17

    T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,

    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,

    T16 v16, T17 v17) {

  return internal::ValueArray17

      T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,

      v11, v12, v13, v14, v15, v16, v17);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18>

internal::ValueArray18

    T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,

    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,

    T16 v16, T17 v17, T18 v18) {

  return internal::ValueArray18

      T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9,

      v10, v11, v12, v13, v14, v15, v16, v17, v18);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19>

internal::ValueArray19

    T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,

    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,

    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) {

  return internal::ValueArray19

      T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8,

      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20>

internal::ValueArray20

    T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4,

    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,

    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) {

  return internal::ValueArray20

      T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7,

      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21>

internal::ValueArray21

    T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4,

    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,

    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) {

  return internal::ValueArray21

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6,

      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22>

internal::ValueArray22

    T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3,

    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,

    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,

    T21 v21, T22 v22) {

  return internal::ValueArray22

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4,

      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,

      v20, v21, v22);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23>

internal::ValueArray23

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2,

    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,

    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,

    T21 v21, T22 v22, T23 v23) {

  return internal::ValueArray23

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3,

      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,

      v20, v21, v22, v23);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24>

internal::ValueArray24

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2,

    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,

    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,

    T21 v21, T22 v22, T23 v23, T24 v24) {

  return internal::ValueArray24

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2,

      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,

      v19, v20, v21, v22, v23, v24);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25>

internal::ValueArray25

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1,

    T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11,

    T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19,

    T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) {

  return internal::ValueArray25

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1,

      v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17,

      v18, v19, v20, v21, v22, v23, v24, v25);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26>

internal::ValueArray26

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

    T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,

    T26 v26) {

  return internal::ValueArray26

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15,

      v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27>

internal::ValueArray27

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26,

    T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,

    T26 v26, T27 v27) {

  return internal::ValueArray27

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14,

      v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28>

internal::ValueArray28

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27,

    T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,

    T26 v26, T27 v27, T28 v28) {

  return internal::ValueArray28

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13,

      v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27,

      v28);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29>

internal::ValueArray29

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9,

    T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17,

    T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25,

    T26 v26, T27 v27, T28 v28, T29 v29) {

  return internal::ValueArray29

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12,

      v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26,

      v27, v28, v29);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30>

internal::ValueArray30

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8,

    T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16,

    T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24,

    T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) {

  return internal::ValueArray30

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11,

      v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25,

      v26, v27, v28, v29, v30);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31>

internal::ValueArray31

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,

    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,

    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,

    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) {

  return internal::ValueArray31

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10,

      v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24,

      v25, v26, v27, v28, v29, v30, v31);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32>

internal::ValueArray32

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7,

    T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,

    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,

    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,

    T32 v32) {

  return internal::ValueArray32

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9,

      v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,

      v24, v25, v26, v27, v28, v29, v30, v31, v32);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32, typename T33>

internal::ValueArray33

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6,

    T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15,

    T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23,

    T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31,

    T32 v32, T33 v33) {

  return internal::ValueArray33

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8,

      v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23,

      v24, v25, v26, v27, v28, v29, v30, v31, v32, v33);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32, typename T33, typename T34>

internal::ValueArray34

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5,

    T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14,

    T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22,

    T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30,

    T31 v31, T32 v32, T33 v33, T34 v34) {

  return internal::ValueArray34

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7,

      v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22,

      v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32, typename T33, typename T34, typename T35>

internal::ValueArray35

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4,

    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,

    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,

    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,

    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) {

  return internal::ValueArray35

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6,

      v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21,

      v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32, typename T33, typename T34, typename T35,

    typename T36>

internal::ValueArray36

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4,

    T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13,

    T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21,

    T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29,

    T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) {

  return internal::ValueArray36

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4,

      v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,

      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,

      v34, v35, v36);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32, typename T33, typename T34, typename T35,

    typename T36, typename T37>

internal::ValueArray37

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3,

    T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,

    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,

    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,

    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,

    T37 v37) {

  return internal::ValueArray37

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3,

      v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19,

      v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33,

      v34, v35, v36, v37);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,

    typename T26, typename T27, typename T28, typename T29, typename T30,

    typename T31, typename T32, typename T33, typename T34, typename T35,

    typename T36, typename T37, typename T38>

internal::ValueArray38

    T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28,

    T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2,

    T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12,

    T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20,

    T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28,

    T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36,

    T37 v37, T38 v38) {

  return internal::ValueArray38

      T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25,

      T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2,

      v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18,

      v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32,

      v33, v34, v35, v36, v37, v38);

}

template 

    typename T6, typename T7, typename T8, typename T9, typename T10,

    typename T11, typename T12, typename T13, typename T14, typename T15,

    typename T16, typename T17, typename T18, typename T19, typename T20,

    typename T21, typename T22, typename T23, typename T24, typename T25,