Processing speed in large C++ raw strings.

unofficial mirror of emacs-devel@gnu.org 
 help / color / mirror / code / Atom feed

* Processing speed in large C++ raw strings.
@ 2019-04-25 18:36 Alan Mackenzie
  2019-04-26  1:25 ` Dmitry Gutov
  2019-04-26 20:15 ` Tadeus Prastowo
  0 siblings, 2 replies; 9+ messages in thread
From: Alan Mackenzie @ 2019-04-25 18:36 UTC (permalink / raw)
  To: Dmitry Gutov; +Cc: emacs-devel

Hello, Dmitry.

Some while ago, you were complaining, justifiably, about the
sluggishness when typing characters into very long C++ raw strings.  To
demonstrate this, you put xdisp.c into C++ mode, and put a raw string
round nearly the entire buffer.

Last week, it was taking over 2 seconds to process a single
self-insert-command into this string, and my machine is not slow.

I have now optimized CC Mode, such that each such self-insert-command
now takes around 0.07s-0.1s.  I used two strategies for this: (i) breaking out
of (expensive) fontification routines early, when the region being
fontified is nothing but a string; (ii) Not fontifying the entire raw
string for a change to only a small part of it.

-- 
Alan Mackenzie (Nuremberg, Germany).

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-25 18:36 Processing speed in large C++ raw strings Alan Mackenzie
@ 2019-04-26  1:25 ` Dmitry Gutov
  2019-04-26 20:15 ` Tadeus Prastowo
  1 sibling, 0 replies; 9+ messages in thread
From: Dmitry Gutov @ 2019-04-26  1:25 UTC (permalink / raw)
  To: Alan Mackenzie; +Cc: emacs-devel

Hi Alan,

On 25.04.2019 21:36, Alan Mackenzie wrote:

> Some while ago, you were complaining, justifiably, about the
> sluggishness when typing characters into very long C++ raw strings.  To
> demonstrate this, you put xdisp.c into C++ mode, and put a raw string
> round nearly the entire buffer.

It was an argument in a discussion, not exactly a bug report (I don't 
write C++), but it's laudable progress, of course.

> Last week, it was taking over 2 seconds to process a single
> self-insert-command into this string, and my machine is not slow.
> 
> I have now optimized CC Mode, such that each such self-insert-command
> now takes around 0.07s-0.1s.  I used two strategies for this: (i) breaking out
> of (expensive) fontification routines early, when the region being
> fontified is nothing but a string; (ii) Not fontifying the entire raw
> string for a change to only a small part of it.

Pulled the latest changes, rebuilt Emacs and tried this. The result 
still feels fairly sluggish at times (the pauses seem longer than the 
timings you mention, especially when I type or delete the relevant 
double-quote characters), but it should definitely make editing such 
literals possible and even bearable.

Here's a seemingly related discussion you might be interested in: 
https://lists.gnu.org/archive/html/emacs-devel/2019-04/msg00715.html



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-25 18:36 Processing speed in large C++ raw strings Alan Mackenzie
  2019-04-26  1:25 ` Dmitry Gutov
@ 2019-04-26 20:15 ` Tadeus Prastowo
  2019-04-27  2:15   ` Stefan Monnier
  2019-04-27 11:37   ` Alan Mackenzie
  1 sibling, 2 replies; 9+ messages in thread
From: Tadeus Prastowo @ 2019-04-26 20:15 UTC (permalink / raw)
  To: Alan Mackenzie; +Cc: emacs-devel

Hi Alan,

On Thu, Apr 25, 2019 at 8:41 PM Alan Mackenzie <acm@muc.de> wrote:
> I have now optimized CC Mode, such that each such self-insert-command
> now takes around 0.07s-0.1s.  I used two strategies for this: (i) breaking out
> of (expensive) fontification routines early, when the region being
> fontified is nothing but a string; (ii) Not fontifying the entire raw
> string for a change to only a small part of it.

I have been working with C++ template metaprograms for two years, and
since quite early, I have experienced CC Mode being very sluggish that
I often switch back-and-forth between cc-mode and text-mode.

I have not made any report since I don't feel like sparing my time to
collect some data for the report now that switching to text-mode does
the trick.  So, since you are already at it, perhaps you may want to
find out why even scrolling the buffer in cc-mode is very slow when
visiting the file at
http://git.savannah.nongnu.org/cgit/tice.git/plain/tests/v1/test-v1_internals_program.cpp?

Specifically, I built master at commit
82fc8ca6ba179596928db614ab903e44968ef44e and fired the result with
`emacs -Q' to visit the file locally.  Then, to experience the
sluggishness, I pressed M-> followed by M-v several times.  To further
experience it, I started to edit some template parameters, such as
changing `node1' to node `node5' in line 680.

Thank you very much for your work.

> --
> Alan Mackenzie (Nuremberg, Germany).

--
Best regards,
Tadeus

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-26 20:15 ` Tadeus Prastowo
@ 2019-04-27  2:15   ` Stefan Monnier
  2019-04-27 10:37     ` Tadeus Prastowo
  2019-04-27 11:37   ` Alan Mackenzie
  1 sibling, 1 reply; 9+ messages in thread
From: Stefan Monnier @ 2019-04-27  2:15 UTC (permalink / raw)
  To: emacs-devel

>> I have now optimized CC Mode, such that each such self-insert-command
>> now takes around 0.07s-0.1s.  I used two strategies for this: (i) breaking out
>> of (expensive) fontification routines early, when the region being
>> fontified is nothing but a string; (ii) Not fontifying the entire raw
>> string for a change to only a small part of it.
>
> I have been working with C++ template metaprograms for two years, and
> since quite early, I have experienced CC Mode being very sluggish that
> I often switch back-and-forth between cc-mode and text-mode.

Could you try out the "quick hack patch" I sent in
https://debbugs.gnu.org/35316 ?

It has a few known bugs, so it would require further work to be really
useful, but I'd be interested to know if it helps your use case.

> `emacs -Q' to visit the file locally.  Then, to experience the
> sluggishness, I pressed M-> followed by M-v several times.

FWIW, I don't expect my patch will help this use-case.


        Stefan




^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-27  2:15   ` Stefan Monnier
@ 2019-04-27 10:37     ` Tadeus Prastowo
  0 siblings, 0 replies; 9+ messages in thread
From: Tadeus Prastowo @ 2019-04-27 10:37 UTC (permalink / raw)
  To: Stefan Monnier; +Cc: Alan Mackenzie, emacs-devel

[-- Attachment #1: Type: text/plain, Size: 1640 bytes --]

Hi Stefan,

First of all, thank you for looking into this.

On Sat, Apr 27, 2019 at 4:28 AM Stefan Monnier <monnier@iro.umontreal.ca> wrote:
>
> >> I have now optimized CC Mode, such that each such self-insert-command
> >> now takes around 0.07s-0.1s.  I used two strategies for this: (i) breaking out
> >> of (expensive) fontification routines early, when the region being
> >> fontified is nothing but a string; (ii) Not fontifying the entire raw
> >> string for a change to only a small part of it.
> >
> > I have been working with C++ template metaprograms for two years, and
> > since quite early, I have experienced CC Mode being very sluggish that
> > I often switch back-and-forth between cc-mode and text-mode.
>
> Could you try out the "quick hack patch" I sent in
> https://debbugs.gnu.org/35316 ?
>
> It has a few known bugs, so it would require further work to be really
> useful, but I'd be interested to know if it helps your use case.

No, it does not help.

> > `emacs -Q' to visit the file locally.  Then, to experience the
> > sluggishness, I pressed M-> followed by M-v several times.
>
> FWIW, I don't expect my patch will help this use-case.

You are right.

I would like to add that C++ template seems to be a specific problem
in CC Mode as shown by the attached C++ program file.

Using `emacs -Q' with your patch to visit the attached file locally,
M-> C-u 10 C-p C-u 6 M-f DEL 10 is not sluggish at all when editing a
non template.  After that, let's edit a template: M-< C-v C-v C-v C-v
C-v C-u 4 M-f DEL is very sluggish.  After that, typing 10 is also
very sluggish.

>         Stefan

-- 
Best regards,
Tadeus

[-- Attachment #2: test.cpp --]
[-- Type: text/x-c++src, Size: 100881 bytes --]

template<unsigned arg__size>
struct Array {
  static constexpr unsigned elems[arg__size] = {
    1
  };
};

template<unsigned... args>
struct tuple;

template<unsigned arg__idx, typename arg__tuple,
         unsigned arg__i = 0, bool arg__is_done = (arg__idx == arg__i)>
struct get;

template<unsigned arg__idx, unsigned arg, unsigned... args, unsigned arg__i>
struct get<arg__idx, tuple<arg, args...>, arg__i, true> {
  static constexpr unsigned value {arg};};

template<unsigned arg__idx, unsigned arg, unsigned... args, unsigned arg__i>
struct get<arg__idx, tuple<arg, args...>, arg__i, false> :
  get<arg__idx, tuple<args...>, arg__i + 1> {
};

typedef tuple<
  1
> Tuple;

#ifdef RUN_TUPLE
static_assert(get<0, Tuple>::value == 1, "Tuple");
#if RUN_TUPLE == 10
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
static_assert(get<0, Tuple>::value == 1, "Tuple");
#endif
#endif

#ifdef RUN_ARRAY
static_assert(Array<1>::elems[0] == 1, "Array");
#if RUN_ARRAY == 10
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
static_assert(Array<1>::elems[0] == 1, "Array");
#endif
#endif

^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-26 20:15 ` Tadeus Prastowo
  2019-04-27  2:15   ` Stefan Monnier
@ 2019-04-27 11:37   ` Alan Mackenzie
  2019-04-27 15:35     ` Tadeus Prastowo
  1 sibling, 1 reply; 9+ messages in thread
From: Alan Mackenzie @ 2019-04-27 11:37 UTC (permalink / raw)
  To: Tadeus Prastowo; +Cc: emacs-devel

Hello, Tadeus.

On Fri, Apr 26, 2019 at 22:15:28 +0200, Tadeus Prastowo wrote:
> Hi Alan,

> On Thu, Apr 25, 2019 at 8:41 PM Alan Mackenzie <acm@muc.de> wrote:
> > I have now optimized CC Mode, such that each such self-insert-command
> > now takes around 0.07s-0.1s.  I used two strategies for this: (i) breaking out
> > of (expensive) fontification routines early, when the region being
> > fontified is nothing but a string; (ii) Not fontifying the entire raw
> > string for a change to only a small part of it.

> I have been working with C++ template metaprograms for two years, and
> since quite early, I have experienced CC Mode being very sluggish that
> I often switch back-and-forth between cc-mode and text-mode.

> I have not made any report since I don't feel like sparing my time to
> collect some data for the report now that switching to text-mode does
> the trick.  So, since you are already at it, perhaps you may want to
> find out why even scrolling the buffer in cc-mode is very slow when
> visiting the file at
> http://git.savannah.nongnu.org/cgit/tice.git/plain/tests/v1/test-v1_internals_program.cpp?

You've submitted a bug report now.  :-)

> Specifically, I built master at commit
> 82fc8ca6ba179596928db614ab903e44968ef44e and fired the result with
> `emacs -Q' to visit the file locally.  Then, to experience the
> sluggishness, I pressed M-> followed by M-v several times.  To further
> experience it, I started to edit some template parameters, such as
> changing `node1' to node `node5' in line 680.

Thanks for drawing my attention to this problem with lots of templates.
The bug is that, in a certain low-level place, CC Mode was failing to
mark the < and > "as parentheses" (with syntax-table text properties),
hence a lot of unneeded buffer scanning was being done.

The following patch should speed up the scrolling operation markedly.
It does not become instantaneous, but takes a fraction of a second,
compared with the several seconds it has taken up to now.  Would you
please try it out.  


diff -r 1940f96b9799 cc-engine.el
--- a/cc-engine.el	Fri Apr 26 01:01:07 2019 +0000
+++ b/cc-engine.el	Sat Apr 27 11:30:06 2019 +0000
@@ -5539,7 +5539,9 @@
 		      (prog1 (looking-at "\\s(")
 			(forward-char))))
 	  (backward-char)
-	  (if (c-forward-<>-arglist nil) ; Should always work.
+	  (if (let ((c-parse-and-markup-<>-arglists t)
+		    (c-restricted-<>-arglists t))
+		(c-forward-<>-arglist nil)) ; Should always work.
 	      (when (> (point) to)
 		(setq bound-<> (point)))
 	    (forward-char)))

> Thank you very much for your work.

> --
> Best regards,
> Tadeus

-- 
Alan Mackenzie (Nuremberg, Germany).



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-27 11:37   ` Alan Mackenzie
@ 2019-04-27 15:35     ` Tadeus Prastowo
  2019-04-27 17:29       ` Alan Mackenzie
  0 siblings, 1 reply; 9+ messages in thread
From: Tadeus Prastowo @ 2019-04-27 15:35 UTC (permalink / raw)
  To: Alan Mackenzie; +Cc: Stefan Monnier, emacs-devel

Hi Alan,

On Sat, Apr 27, 2019 at 1:37 PM Alan Mackenzie <acm@muc.de> wrote:
>
> Hello, Tadeus.
>
> On Fri, Apr 26, 2019 at 22:15:28 +0200, Tadeus Prastowo wrote:
> > I have not made any report since I don't feel like sparing my time to
> > collect some data for the report now that switching to text-mode does
> > the trick.  So, since you are already at it, perhaps you may want to
> > find out why even scrolling the buffer in cc-mode is very slow when
> > visiting the file at
> > http://git.savannah.nongnu.org/cgit/tice.git/plain/tests/v1/test-v1_internals_program.cpp?
>
> You've submitted a bug report now.  :-)

I realize that now I have enough real data :-)

> > Specifically, I built master at commit
> > 82fc8ca6ba179596928db614ab903e44968ef44e and fired the result with
> > `emacs -Q' to visit the file locally.  Then, to experience the
> > sluggishness, I pressed M-> followed by M-v several times.  To further
> > experience it, I started to edit some template parameters, such as
> > changing `node1' to node `node5' in line 680.
>
> Thanks for drawing my attention to this problem with lots of templates.

My pleasure.  And, thank you very much for looking into this.

> The bug is that, in a certain low-level place, CC Mode was failing to
> mark the < and > "as parentheses" (with syntax-table text properties),
> hence a lot of unneeded buffer scanning was being done.
>
> The following patch should speed up the scrolling operation markedly.
> It does not become instantaneous, but takes a fraction of a second,
> compared with the several seconds it has taken up to now.  Would you
> please try it out.

I apply the following patch to master at commit
8dc00b2f1e6523c634df3e24379afbe712a32b27, and I confirm that the
following patch works to solve not only the buffer scrolling
sluggishness but also the template parameter editing sluggishness,
including the one that I sent to Stefan earlier today.  Thank you very
much, Alan, I really appreciate it.  Three lines of a diff to solve my
two-year old sluggishness problem.

> diff -r 1940f96b9799 cc-engine.el
> --- a/cc-engine.el      Fri Apr 26 01:01:07 2019 +0000
> +++ b/cc-engine.el      Sat Apr 27 11:30:06 2019 +0000
> @@ -5539,7 +5539,9 @@
>                       (prog1 (looking-at "\\s(")
>                         (forward-char))))
>           (backward-char)
> -         (if (c-forward-<>-arglist nil) ; Should always work.
> +         (if (let ((c-parse-and-markup-<>-arglists t)
> +                   (c-restricted-<>-arglists t))
> +               (c-forward-<>-arglist nil)) ; Should always work.
>               (when (> (point) to)
>                 (setq bound-<> (point)))
>             (forward-char)))

-- 
Best regards,
Tadeus



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-27 15:35     ` Tadeus Prastowo
@ 2019-04-27 17:29       ` Alan Mackenzie
  2019-04-30 14:44         ` Tadeus Prastowo
  0 siblings, 1 reply; 9+ messages in thread
From: Alan Mackenzie @ 2019-04-27 17:29 UTC (permalink / raw)
  To: Tadeus Prastowo; +Cc: Stefan Monnier, emacs-devel

Hello again, Tadeus.

On Sat, Apr 27, 2019 at 17:35:16 +0200, Tadeus Prastowo wrote:
> Hi Alan,

> On Sat, Apr 27, 2019 at 1:37 PM Alan Mackenzie <acm@muc.de> wrote:

> > Thanks for drawing my attention to this problem with lots of templates.

> My pleasure.  And, thank you very much for looking into this.

> > The bug is that, in a certain low-level place, CC Mode was failing to
> > mark the < and > "as parentheses" (with syntax-table text properties),
> > hence a lot of unneeded buffer scanning was being done.

> > The following patch should speed up the scrolling operation markedly.
> > It does not become instantaneous, but takes a fraction of a second,
> > compared with the several seconds it has taken up to now.  Would you
> > please try it out.

> I apply the following patch to master at commit
> 8dc00b2f1e6523c634df3e24379afbe712a32b27, and I confirm that the
> following patch works to solve not only the buffer scrolling
> sluggishness but also the template parameter editing sluggishness,
> including the one that I sent to Stefan earlier today.  Thank you very
> much, Alan, I really appreciate it.  Three lines of a diff to solve my
> two-year old sluggishness problem.

Thanks indeed!  Thanks also for such a rapid reply.

I've just committed the patch to all the usual places (including the
Emacs master branch).  So I think the bug is now fixed.

> > diff -r 1940f96b9799 cc-engine.el
> > --- a/cc-engine.el      Fri Apr 26 01:01:07 2019 +0000
> > +++ b/cc-engine.el      Sat Apr 27 11:30:06 2019 +0000
> > @@ -5539,7 +5539,9 @@
> >                       (prog1 (looking-at "\\s(")
> >                         (forward-char))))
> >           (backward-char)
> > -         (if (c-forward-<>-arglist nil) ; Should always work.
> > +         (if (let ((c-parse-and-markup-<>-arglists t)
> > +                   (c-restricted-<>-arglists t))
> > +               (c-forward-<>-arglist nil)) ; Should always work.
> >               (when (> (point) to)
> >                 (setq bound-<> (point)))
> >             (forward-char)))

> -- 
> Best regards,
> Tadeus

-- 
Alan Mackenzie (Nuremberg, Germany).



^ permalink raw reply	[flat|nested] 9+ messages in thread

* Re: Processing speed in large C++ raw strings.
  2019-04-27 17:29       ` Alan Mackenzie
@ 2019-04-30 14:44         ` Tadeus Prastowo
  0 siblings, 0 replies; 9+ messages in thread
From: Tadeus Prastowo @ 2019-04-30 14:44 UTC (permalink / raw)
  To: Alan Mackenzie; +Cc: emacs-devel

Hi Alan,

On Sat, Apr 27, 2019 at 7:29 PM Alan Mackenzie <acm@muc.de> wrote:
>
> Hello again, Tadeus.
>
> On Sat, Apr 27, 2019 at 17:35:16 +0200, Tadeus Prastowo wrote:
> > Hi Alan,
>
> > On Sat, Apr 27, 2019 at 1:37 PM Alan Mackenzie <acm@muc.de> wrote:
> > > The following patch should speed up the scrolling operation markedly.
> > > It does not become instantaneous, but takes a fraction of a second,
> > > compared with the several seconds it has taken up to now.  Would you
> > > please try it out.
>
> > I apply the following patch to master at commit
> > 8dc00b2f1e6523c634df3e24379afbe712a32b27, and I confirm that the
> > following patch works to solve not only the buffer scrolling
> > sluggishness but also the template parameter editing sluggishness,
> > including the one that I sent to Stefan earlier today.  Thank you very
> > much, Alan, I really appreciate it.  Three lines of a diff to solve my
> > two-year old sluggishness problem.
>
> Thanks indeed!  Thanks also for such a rapid reply.
>
> I've just committed the patch to all the usual places (including the
> Emacs master branch).  So I think the bug is now fixed.

I am currently experiencing some sluggishness in the following way
using `emacs -Q' that locally visits the file at
http://git.savannah.nongnu.org/cgit/tice.git/plain/internals/v1/v1_internals_program.hpp?id=6ed1f0b6d977eccf91386ead562e10e6801e95aa:

M-g g 2874
C-u 17 M-f
M-DEL remaining (this should be a bit sluggish)
M-d M-d M-DEL source_node_ids (this is sluggish)

Would you kindly see if you experience the same thing, please?  If so,
would it be easy to fix?  Thank you.

> > > diff -r 1940f96b9799 cc-engine.el
> > > --- a/cc-engine.el      Fri Apr 26 01:01:07 2019 +0000
> > > +++ b/cc-engine.el      Sat Apr 27 11:30:06 2019 +0000
> > > @@ -5539,7 +5539,9 @@
> > >                       (prog1 (looking-at "\\s(")
> > >                         (forward-char))))
> > >           (backward-char)
> > > -         (if (c-forward-<>-arglist nil) ; Should always work.
> > > +         (if (let ((c-parse-and-markup-<>-arglists t)
> > > +                   (c-restricted-<>-arglists t))
> > > +               (c-forward-<>-arglist nil)) ; Should always work.
> > >               (when (> (point) to)
> > >                 (setq bound-<> (point)))
> > >             (forward-char)))

> --
> Alan Mackenzie (Nuremberg, Germany).

-- 
Best regards,
Tadeus



^ permalink raw reply	[flat|nested] 9+ messages in thread

end of thread, other threads:[~2019-04-30 14:44 UTC | newest]

Thread overview: 9+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2019-04-25 18:36 Processing speed in large C++ raw strings Alan Mackenzie
2019-04-26  1:25 ` Dmitry Gutov
2019-04-26 20:15 ` Tadeus Prastowo
2019-04-27  2:15   ` Stefan Monnier
2019-04-27 10:37     ` Tadeus Prastowo
2019-04-27 11:37   ` Alan Mackenzie
2019-04-27 15:35     ` Tadeus Prastowo
2019-04-27 17:29       ` Alan Mackenzie
2019-04-30 14:44         ` Tadeus Prastowo

Code repositories for project(s) associated with this public inbox

	https://git.savannah.gnu.org/cgit/emacs.git

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).