#ifndef l110010100110 
#define l110010100110 
#include "bitset" 
namespace
l110010001100
{
#ifndef O110010100111 
#define O110010100111 
enum
l110010101000
{
l110010101001
=
01
,
O110010101010
=
02
,
O110010101011
=
04
,
O110010101100
=
l110010101001
|
O110010101010
,
O110010101101
=
l110010101001
|
O110010101011
}
;
#endif 
template
<
class
O110010101110
,
unsigned
l110010101111
,
class
l110010110000
>
class
l110010110001
{
public
:
typedef
typename
O110010101110
::
O110001111011
O110001111011
;
typedef
typename
O110010101110
::
l110001111010
l110001111010
;
typedef
typename
O110010101110
::
size
size
;
inline
l110001111010
insert
(
l110001111010
h
)
;
inline
l110001111010
search
(
O110001111011
O110010000110
,
l110010101000
O110010110010
=
l110010101001
)
;
inline
l110001111010
l110010110011
(
void
)
;
inline
l110001111010
l110010110100
(
void
)
;
inline
l110001111010
remove
(
O110001111011
O110010000110
)
;
void
O110010010101
(
void
)
{
l110010110101
=
l110010001010
(
)
;
}
bool
l110010110110
(
void
)
{
return
(
l110010110101
==
l110010001010
(
)
)
;
}
bool
l110010001011
(
void
)
{
return
(
abs
.
l110010001011
(
)
)
;
}
l110010110001
(
void
)
:
l110010110101
(
l110010001010
(
)
)
{
}
class
O110010010010
{
public
:
O110010010010
(
void
)
{
O110010110111
=
~
0
;
}
void
l110010111000
(
l110010110001
&
O110010001111
,
O110001111011
O110010000110
,
l110010101000
O110010110010
=
l110010101001
)
{
const
int
O110010111001
=
(
int
)
~
(
(
~
(
unsigned
)
0
)
>>
01
)
;
O110010111010
=
&
O110010001111
;
int
l110010111011
,
l110010111100
;
l110001111010
h
=
O110010111010
->
l110010110101
;
unsigned
O110010111101
=
0
;
O110010110111
=
~
0
;
if
(
h
==
l110010001010
(
)
)
return
;
if
(
O110010110010
&
O110010101010
)
l110010111100
=
01
;
else
if
(
O110010110010
&
O110010101011
)
l110010111100
=
-
01
;
else
l110010111100
=
0
;
for
(
;
;
)
{
l110010111011
=
l110010111110
(
O110010000110
,
h
)
;
if
(
l110010111011
==
0
)
{
if
(
O110010110010
&
l110010101001
)
{
O110010110111
=
O110010111101
;
break
;
}
l110010111011
=
-
l110010111100
;
}
else
if
(
l110010111100
!=
0
)
if
(
!
(
(
l110010111011
^
l110010111100
)
&
O110010111001
)
)
O110010110111
=
O110010111101
;
h
=
l110010111011
<
0
?
O110010111111
(
h
)
:
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
{
O110010110111
=
~
0
;
break
;
}
if
(
h
==
l110010001010
(
)
)
break
;
l110011000001
[
O110010111101
]
=
l110010111011
>
0
;
O110011000010
[
O110010111101
++
]
=
h
;
}
}
void
O110010010100
(
l110010110001
&
O110010001111
)
{
O110010111010
=
&
O110010001111
;
l110001111010
h
=
O110010111010
->
l110010110101
;
O110010110111
=
~
0
;
l110011000001
.
reset
(
)
;
while
(
h
!=
l110010001010
(
)
)
{
if
(
O110010110111
!=
~
0
)
O110011000010
[
O110010110111
]
=
h
;
O110010110111
++
;
h
=
O110010111111
(
h
)
;
if
(
l110010001011
(
)
)
{
O110010110111
=
~
0
;
break
;
}
}
}
void
O110011000011
(
l110010110001
&
O110010001111
)
{
O110010111010
=
&
O110010001111
;
l110001111010
h
=
O110010111010
->
l110010110101
;
O110010110111
=
~
0
;
l110011000001
.
set
(
)
;
while
(
h
!=
l110010001010
(
)
)
{
if
(
O110010110111
!=
~
0
)
O110011000010
[
O110010110111
]
=
h
;
O110010110111
++
;
h
=
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
{
O110010110111
=
~
0
;
break
;
}
}
}
l110001111010
operator
*
(
void
)
{
if
(
O110010110111
==
~
0
)
return
(
l110010001010
(
)
)
;
return
(
O110010110111
==
0
?
O110010111010
->
l110010110101
:
O110011000010
[
O110010110111
-
01
]
)
;
}
void
operator
++
(
void
)
{
if
(
O110010110111
!=
~
0
)
{
l110001111010
h
=
O110011000000
(
*
*
this
)
;
if
(
l110010001011
(
)
)
O110010110111
=
~
0
;
else
if
(
h
==
l110010001010
(
)
)
do
{
if
(
O110010110111
==
0
)
{
O110010110111
=
~
0
;
break
;
}
O110010110111
--
;
}
while
(
l110011000001
[
O110010110111
]
)
;
else
{
l110011000001
[
O110010110111
]
=
true
;
O110011000010
[
O110010110111
++
]
=
h
;
for
(
;
;
)
{
h
=
O110010111111
(
h
)
;
if
(
l110010001011
(
)
)
{
O110010110111
=
~
0
;
break
;
}
if
(
h
==
l110010001010
(
)
)
break
;
l110011000001
[
O110010110111
]
=
false
;
O110011000010
[
O110010110111
++
]
=
h
;
}
}
}
}
void
operator
--
(
void
)
{
if
(
O110010110111
!=
~
0
)
{
l110001111010
h
=
O110010111111
(
*
*
this
)
;
if
(
l110010001011
(
)
)
O110010110111
=
~
0
;
else
if
(
h
==
l110010001010
(
)
)
do
{
if
(
O110010110111
==
0
)
{
O110010110111
=
~
0
;
break
;
}
O110010110111
--
;
}
while
(
!
l110011000001
[
O110010110111
]
)
;
else
{
l110011000001
[
O110010110111
]
=
false
;
O110011000010
[
O110010110111
++
]
=
h
;
for
(
;
;
)
{
h
=
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
{
O110010110111
=
~
0
;
break
;
}
if
(
h
==
l110010001010
(
)
)
break
;
l110011000001
[
O110010110111
]
=
true
;
O110011000010
[
O110010110111
++
]
=
h
;
}
}
}
}
void
operator
++
(
int
)
{
++
(
*
this
)
;
}
void
operator
--
(
int
)
{
--
(
*
this
)
;
}
bool
l110010001011
(
void
)
{
return
(
O110010111010
->
l110010001011
(
)
)
;
}
protected
:
l110010110001
*
O110010111010
;
l110010110000
l110011000001
;
unsigned
O110010110111
;
l110001111010
O110011000010
[
l110010101111
-
01
]
;
int
l110010111110
(
O110001111011
O110010000110
,
l110001111010
h
)
{
return
(
O110010111010
->
abs
.
l110010000101
(
O110010000110
,
h
)
)
;
}
int
l110011000100
(
l110001111010
l110010001000
,
l110001111010
O110010001001
)
{
return
(
O110010111010
->
abs
.
l110010000111
(
l110010001000
,
O110010001001
)
)
;
}
l110001111010
O110010111111
(
l110001111010
h
)
{
return
(
O110010111010
->
abs
.
l110001111100
(
h
,
true
)
)
;
}
l110001111010
O110011000000
(
l110001111010
h
)
{
return
(
O110010111010
->
abs
.
l110001111111
(
h
,
true
)
)
;
}
l110001111010
l110010001010
(
void
)
{
return
(
O110010111010
->
abs
.
l110010001010
(
)
)
;
}
}
;
template
<
typename
l110011000101
>
bool
O110011000110
(
l110011000101
l110010100001
,
size
l110011000111
)
{
if
(
l110011000111
==
0
)
{
l110010110101
=
l110010001010
(
)
;
return
(
true
)
;
}
l110010110000
l110011000001
;
l110010110000
O110011001000
;
unsigned
O110010110111
=
0
;
size
l110011001001
=
l110011000111
;
l110001111010
l110011001010
=
l110010001010
(
)
;
l110001111010
h
,
O110011001011
;
for
(
;
;
)
{
while
(
l110011001001
>
02
)
{
l110011001001
--
;
O110011001000
[
O110010110111
]
=
!
!
(
l110011001001
&
01
)
;
l110011000001
[
O110010110111
++
]
=
false
;
l110011001001
>>=
01
;
}
if
(
l110011001001
==
02
)
{
h
=
*
l110010100001
;
if
(
l110010001011
(
)
)
return
(
false
)
;
l110010100001
++
;
O110011001011
=
*
l110010100001
;
if
(
l110010001011
(
)
)
return
(
false
)
;
l110010100001
++
;
O110011001100
(
O110011001011
,
l110010001010
(
)
)
;
O110011001101
(
O110011001011
,
l110010001010
(
)
)
;
l110011001110
(
O110011001011
,
0
)
;
O110011001101
(
h
,
O110011001011
)
;
O110011001100
(
h
,
l110010001010
(
)
)
;
l110011001110
(
h
,
01
)
;
}
else
{
h
=
*
l110010100001
;
if
(
l110010001011
(
)
)
return
(
false
)
;
l110010100001
++
;
O110011001100
(
h
,
l110010001010
(
)
)
;
O110011001101
(
h
,
l110010001010
(
)
)
;
l110011001110
(
h
,
0
)
;
}
while
(
O110010110111
)
{
O110010110111
--
;
if
(
!
l110011000001
[
O110010110111
]
)
break
;
O110011001011
=
h
;
h
=
l110011001010
;
l110011001010
=
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
return
(
false
)
;
O110011001101
(
h
,
O110011001011
)
;
l110011001001
<<=
01
;
l110011001001
+=
01
-
O110011001000
[
O110010110111
]
;
if
(
l110011001001
&
(
l110011001001
-
01
)
)
l110011001110
(
h
,
0
)
;
else
l110011001110
(
h
,
01
)
;
}
if
(
l110011001001
==
l110011000111
)
break
;
O110011001011
=
h
;
h
=
*
l110010100001
;
if
(
l110010001011
(
)
)
return
(
false
)
;
l110010100001
++
;
O110011001100
(
h
,
O110011001011
)
;
O110011001101
(
h
,
l110011001010
)
;
l110011001010
=
h
;
l110011000001
[
O110010110111
]
=
true
;
l110011001001
+=
O110011001000
[
O110010110111
++
]
;
}
l110010110101
=
h
;
return
(
true
)
;
}
protected
:
friend
class
O110010010010
;
O110010101110
abs
;
l110001111010
l110010110101
;
l110001111010
O110010111111
(
l110001111010
h
,
bool
access
=
true
)
{
return
(
abs
.
l110001111100
(
h
,
access
)
)
;
}
void
O110011001100
(
l110001111010
h
,
l110001111010
O110001111110
)
{
abs
.
l110001111101
(
h
,
O110001111110
)
;
}
l110001111010
O110011000000
(
l110001111010
h
,
bool
access
=
true
)
{
return
(
abs
.
l110001111111
(
h
,
access
)
)
;
}
void
O110011001101
(
l110001111010
h
,
l110001111010
O110010000001
)
{
abs
.
l110010000000
(
h
,
O110010000001
)
;
}
int
l110011001111
(
l110001111010
h
)
{
return
(
abs
.
l110010000010
(
h
)
)
;
}
void
l110011001110
(
l110001111010
h
,
int
l110010000100
)
{
abs
.
O110010000011
(
h
,
l110010000100
)
;
}
int
l110010111110
(
O110001111011
O110010000110
,
l110001111010
h
)
{
return
(
abs
.
l110010000101
(
O110010000110
,
h
)
)
;
}
int
l110011000100
(
l110001111010
l110010001000
,
l110001111010
O110010001001
)
{
return
(
abs
.
l110010000111
(
l110010001000
,
O110010001001
)
)
;
}
l110001111010
l110010001010
(
void
)
{
return
(
abs
.
l110010001010
(
)
)
;
}
private
:
l110001111010
l110011010000
(
l110001111010
O110011010001
)
{
l110001111010
O110011010010
;
if
(
l110011001111
(
O110011010001
)
>
0
)
{
O110011010010
=
O110011000000
(
O110011010001
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
if
(
l110011001111
(
O110011010010
)
<
0
)
{
l110001111010
l110011010011
=
O110011010001
;
O110011010001
=
O110010111111
(
O110011010010
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
O110011001101
(
l110011010011
,
O110010111111
(
O110011010001
,
false
)
)
;
O110011001100
(
O110011010010
,
O110011000000
(
O110011010001
,
false
)
)
;
O110011001100
(
O110011010001
,
l110011010011
)
;
O110011001101
(
O110011010001
,
O110011010010
)
;
int
l110010000100
=
l110011001111
(
O110011010001
)
;
if
(
l110010000100
!=
0
)
{
if
(
l110010000100
>
0
)
{
l110011001110
(
l110011010011
,
-
01
)
;
l110011001110
(
O110011010010
,
0
)
;
}
else
{
l110011001110
(
O110011010010
,
01
)
;
l110011001110
(
l110011010011
,
0
)
;
}
l110011001110
(
O110011010001
,
0
)
;
}
else
{
l110011001110
(
l110011010011
,
0
)
;
l110011001110
(
O110011010010
,
0
)
;
}
}
else
{
O110011001101
(
O110011010001
,
O110010111111
(
O110011010010
,
false
)
)
;
O110011001100
(
O110011010010
,
O110011010001
)
;
if
(
l110011001111
(
O110011010010
)
==
0
)
{
l110011001110
(
O110011010010
,
-
01
)
;
l110011001110
(
O110011010001
,
01
)
;
}
else
{
l110011001110
(
O110011010010
,
0
)
;
l110011001110
(
O110011010001
,
0
)
;
}
O110011010001
=
O110011010010
;
}
}
else
{
O110011010010
=
O110010111111
(
O110011010001
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
if
(
l110011001111
(
O110011010010
)
>
0
)
{
l110001111010
l110011010011
=
O110011010001
;
O110011010001
=
O110011000000
(
O110011010010
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
O110011001100
(
l110011010011
,
O110011000000
(
O110011010001
,
false
)
)
;
O110011001101
(
O110011010010
,
O110010111111
(
O110011010001
,
false
)
)
;
O110011001101
(
O110011010001
,
l110011010011
)
;
O110011001100
(
O110011010001
,
O110011010010
)
;
int
l110010000100
=
l110011001111
(
O110011010001
)
;
if
(
l110010000100
!=
0
)
{
if
(
l110010000100
<
0
)
{
l110011001110
(
l110011010011
,
01
)
;
l110011001110
(
O110011010010
,
0
)
;
}
else
{
l110011001110
(
O110011010010
,
-
01
)
;
l110011001110
(
l110011010011
,
0
)
;
}
l110011001110
(
O110011010001
,
0
)
;
}
else
{
l110011001110
(
l110011010011
,
0
)
;
l110011001110
(
O110011010010
,
0
)
;
}
}
else
{
O110011001100
(
O110011010001
,
O110011000000
(
O110011010010
,
false
)
)
;
O110011001101
(
O110011010010
,
O110011010001
)
;
if
(
l110011001111
(
O110011010010
)
==
0
)
{
l110011001110
(
O110011010010
,
01
)
;
l110011001110
(
O110011010001
,
-
01
)
;
}
else
{
l110011001110
(
O110011010010
,
0
)
;
l110011001110
(
O110011010001
,
0
)
;
}
O110011010001
=
O110011010010
;
}
}
return
(
O110011010001
)
;
}
}
;
template
<
class
O110010101110
,
unsigned
l110010101111
,
class
l110010110000
>
inline
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110001111010
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
insert
(
l110001111010
h
)
{
O110011001100
(
h
,
l110010001010
(
)
)
;
O110011001101
(
h
,
l110010001010
(
)
)
;
l110011001110
(
h
,
0
)
;
if
(
l110010110101
==
l110010001010
(
)
)
l110010110101
=
h
;
else
{
l110001111010
O110011010100
=
l110010001010
(
)
;
l110001111010
l110011010101
=
l110010001010
(
)
;
int
O110011010110
;
unsigned
O110010110111
=
0
,
O110011010111
=
0
;
l110010110000
l110011000001
;
l110001111010
O110011011000
=
l110010110101
;
l110001111010
l110011011001
=
l110010001010
(
)
;
int
l110010111011
;
while
(
O110011011000
!=
l110010001010
(
)
)
{
if
(
l110011001111
(
O110011011000
)
!=
0
)
{
O110011010100
=
O110011011000
;
l110011010101
=
l110011011001
;
O110011010111
=
O110010110111
;
}
l110010111011
=
l110011000100
(
h
,
O110011011000
)
;
if
(
l110010111011
==
0
)
return
(
O110011011000
)
;
l110011011001
=
O110011011000
;
O110011011000
=
l110010111011
<
0
?
O110010111111
(
O110011011000
)
:
O110011000000
(
O110011011000
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
l110011000001
[
O110010110111
++
]
=
l110010111011
>
0
;
}
if
(
l110010111011
<
0
)
O110011001100
(
l110011011001
,
h
)
;
else
O110011001101
(
l110011011001
,
h
)
;
O110010110111
=
O110011010111
;
if
(
O110011010100
==
l110010001010
(
)
)
O110011011000
=
l110010110101
;
else
{
l110010111011
=
l110011000001
[
O110010110111
++
]
?
01
:
-
01
;
O110011010110
=
l110011001111
(
O110011010100
)
;
if
(
l110010111011
<
0
)
O110011010110
--
;
else
O110011010110
++
;
O110011011000
=
l110010111011
<
0
?
O110010111111
(
O110011010100
)
:
O110011000000
(
O110011010100
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
if
(
(
O110011010110
!=
-
02
)
&&
(
O110011010110
!=
02
)
)
{
l110011001110
(
O110011010100
,
O110011010110
)
;
O110011010100
=
l110010001010
(
)
;
}
}
if
(
O110011011000
!=
l110010001010
(
)
)
while
(
h
!=
O110011011000
)
{
l110010111011
=
l110011000001
[
O110010110111
++
]
?
01
:
-
01
;
if
(
l110010111011
<
0
)
{
l110011001110
(
O110011011000
,
-
01
)
;
O110011011000
=
O110010111111
(
O110011011000
)
;
}
else
{
l110011001110
(
O110011011000
,
01
)
;
O110011011000
=
O110011000000
(
O110011011000
)
;
}
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
}
if
(
O110011010100
!=
l110010001010
(
)
)
{
O110011010100
=
l110011010000
(
O110011010100
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
if
(
l110011010101
==
l110010001010
(
)
)
l110010110101
=
O110011010100
;
else
{
O110010110111
=
O110011010111
-
01
;
l110010111011
=
l110011000001
[
O110010110111
]
?
01
:
-
01
;
if
(
l110010111011
<
0
)
O110011001100
(
l110011010101
,
O110011010100
)
;
else
O110011001101
(
l110011010101
,
O110011010100
)
;
}
}
}
return
(
h
)
;
}
template
<
class
O110010101110
,
unsigned
l110010101111
,
class
l110010110000
>
inline
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110001111010
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
search
(
O110001111011
O110010000110
,
l110010101000
O110010110010
)
{
const
int
O110010111001
=
(
int
)
~
(
(
~
(
unsigned
)
0
)
>>
01
)
;
int
l110010111011
,
l110010111100
;
l110001111010
l110011011010
=
l110010001010
(
)
;
l110001111010
h
=
l110010110101
;
if
(
O110010110010
&
O110010101010
)
l110010111100
=
01
;
else
if
(
O110010110010
&
O110010101011
)
l110010111100
=
-
01
;
else
l110010111100
=
0
;
while
(
h
!=
l110010001010
(
)
)
{
l110010111011
=
l110010111110
(
O110010000110
,
h
)
;
if
(
l110010111011
==
0
)
{
if
(
O110010110010
&
l110010101001
)
{
l110011011010
=
h
;
break
;
}
l110010111011
=
-
l110010111100
;
}
else
if
(
l110010111100
!=
0
)
if
(
!
(
(
l110010111011
^
l110010111100
)
&
O110010111001
)
)
l110011011010
=
h
;
h
=
l110010111011
<
0
?
O110010111111
(
h
)
:
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
{
l110011011010
=
l110010001010
(
)
;
break
;
}
}
return
(
l110011011010
)
;
}
template
<
class
O110010101110
,
unsigned
l110010101111
,
class
l110010110000
>
inline
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110001111010
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110010110011
(
void
)
{
l110001111010
h
=
l110010110101
,
l110011011001
=
l110010001010
(
)
;
while
(
h
!=
l110010001010
(
)
)
{
l110011011001
=
h
;
h
=
O110010111111
(
h
)
;
if
(
l110010001011
(
)
)
{
l110011011001
=
l110010001010
(
)
;
break
;
}
}
return
(
l110011011001
)
;
}
template
<
class
O110010101110
,
unsigned
l110010101111
,
class
l110010110000
>
inline
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110001111010
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110010110100
(
void
)
{
l110001111010
h
=
l110010110101
,
l110011011001
=
l110010001010
(
)
;
while
(
h
!=
l110010001010
(
)
)
{
l110011011001
=
h
;
h
=
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
{
l110011011001
=
l110010001010
(
)
;
break
;
}
}
return
(
l110011011001
)
;
}
template
<
class
O110010101110
,
unsigned
l110010101111
,
class
l110010110000
>
inline
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
l110001111010
l110010110001
<
O110010101110
,
l110010101111
,
l110010110000
>
::
remove
(
O110001111011
O110010000110
)
{
unsigned
O110010110111
=
0
,
l110011011011
;
l110010110000
l110011000001
;
l110001111010
h
=
l110010110101
;
l110001111010
l110011011001
=
l110010001010
(
)
,
O110011001011
;
int
l110010111011
,
l110011011100
;
for
(
;
;
)
{
if
(
h
==
l110010001010
(
)
)
return
(
l110010001010
(
)
)
;
l110010111011
=
l110010111110
(
O110010000110
,
h
)
;
if
(
l110010111011
==
0
)
break
;
l110011011001
=
h
;
h
=
l110010111011
<
0
?
O110010111111
(
h
)
:
O110011000000
(
h
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
l110011000001
[
O110010110111
++
]
=
l110010111011
>
0
;
l110011011100
=
l110010111011
;
}
l110001111010
O110011011101
=
h
;
l110001111010
l110011011110
=
l110011011001
;
l110011011011
=
O110010110111
;
if
(
l110011001111
(
h
)
<
0
)
{
O110011001011
=
O110010111111
(
h
)
;
l110011000001
[
O110010110111
]
=
false
;
l110010111011
=
-
01
;
}
else
{
O110011001011
=
O110011000000
(
h
)
;
l110011000001
[
O110010110111
]
=
true
;
l110010111011
=
01
;
}
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
O110010110111
++
;
if
(
O110011001011
!=
l110010001010
(
)
)
{
l110010111011
=
-
l110010111011
;
do
{
l110011011001
=
h
;
h
=
O110011001011
;
if
(
l110010111011
<
0
)
{
O110011001011
=
O110010111111
(
h
)
;
l110011000001
[
O110010110111
]
=
false
;
}
else
{
O110011001011
=
O110011000000
(
h
)
;
l110011000001
[
O110010110111
]
=
true
;
}
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
O110010110111
++
;
}
while
(
O110011001011
!=
l110010001010
(
)
)
;
if
(
l110011011001
==
O110011011101
)
l110011011100
=
-
l110010111011
;
else
l110011011100
=
l110010111011
;
O110011001011
=
l110010111011
>
0
?
O110010111111
(
h
,
false
)
:
O110011000000
(
h
,
false
)
;
}
if
(
l110011011001
==
l110010001010
(
)
)
l110010110101
=
O110011001011
;
else
if
(
l110011011100
<
0
)
O110011001100
(
l110011011001
,
O110011001011
)
;
else
O110011001101
(
l110011011001
,
O110011001011
)
;
l110001111010
O110011011111
=
l110011011001
==
O110011011101
?
h
:
l110011011001
;
if
(
h
!=
O110011011101
)
{
O110011001100
(
h
,
O110010111111
(
O110011011101
,
false
)
)
;
O110011001101
(
h
,
O110011000000
(
O110011011101
,
false
)
)
;
l110011001110
(
h
,
l110011001111
(
O110011011101
)
)
;
if
(
l110011011110
==
l110010001010
(
)
)
l110010110101
=
h
;
else
{
O110010110111
=
l110011011011
-
01
;
if
(
l110011000001
[
O110010110111
]
)
O110011001101
(
l110011011110
,
h
)
;
else
O110011001100
(
l110011011110
,
h
)
;
}
}
if
(
O110011011111
!=
l110010001010
(
)
)
{
h
=
l110010110101
;
l110011011001
=
l110010001010
(
)
;
O110010110111
=
0
;
while
(
h
!=
O110011011111
)
{
if
(
l110011000001
[
O110010110111
++
]
)
{
O110011001011
=
O110011000000
(
h
)
;
O110011001101
(
h
,
l110011011001
)
;
}
else
{
O110011001011
=
O110010111111
(
h
)
;
O110011001100
(
h
,
l110011011001
)
;
}
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
l110011011001
=
h
;
h
=
O110011001011
;
}
bool
O110011100000
=
true
;
int
l110010000100
;
l110010111011
=
l110011011100
;
for
(
;
;
)
{
if
(
O110011100000
)
{
l110010000100
=
l110011001111
(
h
)
;
if
(
l110010111011
<
0
)
l110010000100
++
;
else
l110010000100
--
;
if
(
(
l110010000100
==
-
02
)
||
(
l110010000100
==
02
)
)
{
h
=
l110011010000
(
h
)
;
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
l110010000100
=
l110011001111
(
h
)
;
}
else
l110011001110
(
h
,
l110010000100
)
;
O110011100000
=
(
l110010000100
==
0
)
;
}
if
(
l110011011001
==
l110010001010
(
)
)
break
;
O110011001011
=
h
;
h
=
l110011011001
;
l110010111011
=
l110011000001
[
--
O110010110111
]
?
01
:
-
01
;
if
(
l110010111011
<
0
)
{
l110011011001
=
O110010111111
(
h
)
;
O110011001100
(
h
,
O110011001011
)
;
}
else
{
l110011011001
=
O110011000000
(
h
)
;
O110011001101
(
h
,
O110011001011
)
;
}
if
(
l110010001011
(
)
)
return
(
l110010001010
(
)
)
;
}
l110010110101
=
h
;
}
return
(
O110011011101
)
;
}
template
<
class
O110010101110
,
unsigned
l110010101111
=
040
>
class
O110010001101
:
public
l110010110001
<
O110010101110
,
l110010101111
,
std
::
bitset
<
l110010101111
>
>
{
}
;
}
#endif