#if defined(__MWERKS__)
#   pragma template_depth(2000)
#endif

#if !defined(N)
#   error "N is not defined!"
#endif

template< int i > struct x;

template< int i, class x > struct y {};
#if N > 0
template< int i >  struct y< i, X<-0> > { char a[0]; };
#endif
#if N > 1
template< int i >  struct y< i, X<-1> > { char a[1]; };
#endif
#if N > 2
template< int i >  struct y< i, X<-2> > { char a[2]; };
#endif
#if N > 3
template< int i >  struct y< i, X<-3> > { char a[3]; };
#endif
#if N > 4
template< int i >  struct y< i, X<-4> > { char a[4]; };
#endif
#if N > 5
template< int i >  struct y< i, X<-5> > { char a[5]; };
#endif
#if N > 6
template< int i >  struct y< i, X<-6> > { char a[6]; };
#endif
#if N > 7
template< int i >  struct y< i, X<-7> > { char a[7]; };
#endif
#if N > 8
template< int i >  struct y< i, X<-8> > { char a[8]; };
#endif
#if N > 9
template< int i >  struct y< i, X<-9> > { char a[9]; };
#endif
#if N > 10
template< int i >  struct y< i, X<-10> > { char a[10]; };
#endif
#if N > 11
template< int i >  struct y< i, X<-11> > { char a[11]; };
#endif
#if N > 12
template< int i >  struct y< i, X<-12> > { char a[12]; };
#endif
#if N > 13
template< int i >  struct y< i, X<-13> > { char a[13]; };
#endif
#if N > 14
template< int i >  struct y< i, X<-14> > { char a[14]; };
#endif
#if N > 15
template< int i >  struct y< i, X<-15> > { char a[15]; };
#endif
#if N > 16
template< int i >  struct y< i, X<-16> > { char a[16]; };
#endif
#if N > 17
template< int i >  struct y< i, X<-17> > { char a[17]; };
#endif
#if N > 18
template< int i >  struct y< i, X<-18> > { char a[18]; };
#endif
#if N > 19
template< int i >  struct y< i, X<-19> > { char a[19]; };
#endif
#if N > 20
template< int i >  struct y< i, X<-20> > { char a[20]; };
#endif
#if N > 21
template< int i >  struct y< i, X<-21> > { char a[21]; };
#endif
#if N > 22
template< int i >  struct y< i, X<-22> > { char a[22]; };
#endif
#if N > 23
template< int i >  struct y< i, X<-23> > { char a[23]; };
#endif
#if N > 24
template< int i >  struct y< i, X<-24> > { char a[24]; };
#endif
#if N > 25
template< int i >  struct y< i, X<-25> > { char a[25]; };
#endif
#if N > 26
template< int i >  struct y< i, X<-26> > { char a[26]; };
#endif
#if N > 27
template< int i >  struct y< i, X<-27> > { char a[27]; };
#endif
#if N > 28
template< int i >  struct y< i, X<-28> > { char a[28]; };
#endif
#if N > 29
template< int i >  struct y< i, X<-29> > { char a[29]; };
#endif
#if N > 30
template< int i >  struct y< i, X<-30> > { char a[30]; };
#endif
#if N > 31
template< int i >  struct y< i, X<-31> > { char a[31]; };
#endif
#if N > 32
template< int i >  struct y< i, X<-32> > { char a[32]; };
#endif
#if N > 33
template< int i >  struct y< i, X<-33> > { char a[33]; };
#endif
#if N > 34
template< int i >  struct y< i, X<-34> > { char a[34]; };
#endif
#if N > 35
template< int i >  struct y< i, X<-35> > { char a[35]; };
#endif
#if N > 36
template< int i >  struct y< i, X<-36> > { char a[36]; };
#endif
#if N > 37
template< int i >  struct y< i, X<-37> > { char a[37]; };
#endif
#if N > 38
template< int i >  struct y< i, X<-38> > { char a[38]; };
#endif
#if N > 39
template< int i >  struct y< i, X<-39> > { char a[39]; };
#endif
#if N > 40
template< int i >  struct y< i, X<-40> > { char a[40]; };
#endif
#if N > 41
template< int i >  struct y< i, X<-41> > { char a[41]; };
#endif
#if N > 42
template< int i >  struct y< i, X<-42> > { char a[42]; };
#endif
#if N > 43
template< int i >  struct y< i, X<-43> > { char a[43]; };
#endif
#if N > 44
template< int i >  struct y< i, X<-44> > { char a[44]; };
#endif
#if N > 45
template< int i >  struct y< i, X<-45> > { char a[45]; };
#endif
#if N > 46
template< int i >  struct y< i, X<-46> > { char a[46]; };
#endif
#if N > 47
template< int i >  struct y< i, X<-47> > { char a[47]; };
#endif
#if N > 48
template< int i >  struct y< i, X<-48> > { char a[48]; };
#endif
#if N > 49
template< int i >  struct y< i, X<-49> > { char a[49]; };
#endif
#if N > 50
template< int i >  struct y< i, X<-50> > { char a[50]; };
#endif
#if N > 51
template< int i >  struct y< i, X<-51> > { char a[51]; };
#endif
#if N > 52
template< int i >  struct y< i, X<-52> > { char a[52]; };
#endif
#if N > 53
template< int i >  struct y< i, X<-53> > { char a[53]; };
#endif
#if N > 54
template< int i >  struct y< i, X<-54> > { char a[54]; };
#endif
#if N > 55
template< int i >  struct y< i, X<-55> > { char a[55]; };
#endif
#if N > 56
template< int i >  struct y< i, X<-56> > { char a[56]; };
#endif
#if N > 57
template< int i >  struct y< i, X<-57> > { char a[57]; };
#endif
#if N > 58
template< int i >  struct y< i, X<-58> > { char a[58]; };
#endif
#if N > 59
template< int i >  struct y< i, X<-59> > { char a[59]; };
#endif
#if N > 60
template< int i >  struct y< i, X<-60> > { char a[60]; };
#endif
#if N > 61
template< int i >  struct y< i, X<-61> > { char a[61]; };
#endif
#if N > 62
template< int i >  struct y< i, X<-62> > { char a[62]; };
#endif
#if N > 63
template< int i >  struct y< i, X<-63> > { char a[63]; };
#endif
#if N > 64
template< int i >  struct y< i, X<-64> > { char a[64]; };
#endif
#if N > 65
template< int i >  struct y< i, X<-65> > { char a[65]; };
#endif
#if N > 66
template< int i >  struct y< i, X<-66> > { char a[66]; };
#endif
#if N > 67
template< int i >  struct y< i, X<-67> > { char a[67]; };
#endif
#if N > 68
template< int i >  struct y< i, X<-68> > { char a[68]; };
#endif
#if N > 69
template< int i >  struct y< i, X<-69> > { char a[69]; };
#endif
#if N > 70
template< int i >  struct y< i, X<-70> > { char a[70]; };
#endif
#if N > 71
template< int i >  struct y< i, X<-71> > { char a[71]; };
#endif
#if N > 72
template< int i >  struct y< i, X<-72> > { char a[72]; };
#endif
#if N > 73
template< int i >  struct y< i, X<-73> > { char a[73]; };
#endif
#if N > 74
template< int i >  struct y< i, X<-74> > { char a[74]; };
#endif
#if N > 75
template< int i >  struct y< i, X<-75> > { char a[75]; };
#endif
#if N > 76
template< int i >  struct y< i, X<-76> > { char a[76]; };
#endif
#if N > 77
template< int i >  struct y< i, X<-77> > { char a[77]; };
#endif
#if N > 78
template< int i >  struct y< i, X<-78> > { char a[78]; };
#endif
#if N > 79
template< int i >  struct y< i, X<-79> > { char a[79]; };
#endif
#if N > 80
template< int i >  struct y< i, X<-80> > { char a[80]; };
#endif
#if N > 81
template< int i >  struct y< i, X<-81> > { char a[81]; };
#endif
#if N > 82
template< int i >  struct y< i, X<-82> > { char a[82]; };
#endif
#if N > 83
template< int i >  struct y< i, X<-83> > { char a[83]; };
#endif
#if N > 84
template< int i >  struct y< i, X<-84> > { char a[84]; };
#endif
#if N > 85
template< int i >  struct y< i, X<-85> > { char a[85]; };
#endif
#if N > 86
template< int i >  struct y< i, X<-86> > { char a[86]; };
#endif
#if N > 87
template< int i >  struct y< i, X<-87> > { char a[87]; };
#endif
#if N > 88
template< int i >  struct y< i, X<-88> > { char a[88]; };
#endif
#if N > 89
template< int i >  struct y< i, X<-89> > { char a[89]; };
#endif
#if N > 90
template< int i >  struct y< i, X<-90> > { char a[90]; };
#endif
#if N > 91
template< int i >  struct y< i, X<-91> > { char a[91]; };
#endif
#if N > 92
template< int i >  struct y< i, X<-92> > { char a[92]; };
#endif
#if N > 93
template< int i >  struct y< i, X<-93> > { char a[93]; };
#endif
#if N > 94
template< int i >  struct y< i, X<-94> > { char a[94]; };
#endif
#if N > 95
template< int i >  struct y< i, X<-95> > { char a[95]; };
#endif
#if N > 96
template< int i >  struct y< i, X<-96> > { char a[96]; };
#endif
#if N > 97
template< int i >  struct y< i, X<-97> > { char a[97]; };
#endif
#if N > 98
template< int i >  struct y< i, X<-98> > { char a[98]; };
#endif
#if N > 99
template< int i >  struct y< i, X<-99> > { char a[99]; };
#endif
#if N > 100
template< int i >  struct y< i, X<-100> > { char a[100]; };
#endif
#if N > 101
template< int i >  struct y< i, X<-101> > { char a[101]; };
#endif
#if N > 102
template< int i >  struct y< i, X<-102> > { char a[102]; };
#endif
#if N > 103
template< int i >  struct y< i, X<-103> > { char a[103]; };
#endif
#if N > 104
template< int i >  struct y< i, X<-104> > { char a[104]; };
#endif
#if N > 105
template< int i >  struct y< i, X<-105> > { char a[105]; };
#endif
#if N > 106
template< int i >  struct y< i, X<-106> > { char a[106]; };
#endif
#if N > 107
template< int i >  struct y< i, X<-107> > { char a[107]; };
#endif
#if N > 108
template< int i >  struct y< i, X<-108> > { char a[108]; };
#endif
#if N > 109
template< int i >  struct y< i, X<-109> > { char a[109]; };
#endif
#if N > 110
template< int i >  struct y< i, X<-110> > { char a[110]; };
#endif
#if N > 111
template< int i >  struct y< i, X<-111> > { char a[111]; };
#endif
#if N > 112
template< int i >  struct y< i, X<-112> > { char a[112]; };
#endif
#if N > 113
template< int i >  struct y< i, X<-113> > { char a[113]; };
#endif
#if N > 114
template< int i >  struct y< i, X<-114> > { char a[114]; };
#endif
#if N > 115
template< int i >  struct y< i, X<-115> > { char a[115]; };
#endif
#if N > 116
template< int i >  struct y< i, X<-116> > { char a[116]; };
#endif
#if N > 117
template< int i >  struct y< i, X<-117> > { char a[117]; };
#endif
#if N > 118
template< int i >  struct y< i, X<-118> > { char a[118]; };
#endif
#if N > 119
template< int i >  struct y< i, X<-119> > { char a[119]; };
#endif
#if N > 120
template< int i >  struct y< i, X<-120> > { char a[120]; };
#endif
#if N > 121
template< int i >  struct y< i, X<-121> > { char a[121]; };
#endif
#if N > 122
template< int i >  struct y< i, X<-122> > { char a[122]; };
#endif
#if N > 123
template< int i >  struct y< i, X<-123> > { char a[123]; };
#endif
#if N > 124
template< int i >  struct y< i, X<-124> > { char a[124]; };
#endif
#if N > 125
template< int i >  struct y< i, X<-125> > { char a[125]; };
#endif
#if N > 126
template< int i >  struct y< i, X<-126> > { char a[126]; };
#endif
#if N > 127
template< int i >  struct y< i, X<-127> > { char a[127]; };
#endif
#if N > 128
template< int i >  struct y< i, X<-128> > { char a[128]; };
#endif
#if N > 129
template< int i >  struct y< i, X<-129> > { char a[129]; };
#endif
#if N > 130
template< int i >  struct y< i, X<-130> > { char a[130]; };
#endif
#if N > 131
template< int i >  struct y< i, X<-131> > { char a[131]; };
#endif
#if N > 132
template< int i >  struct y< i, X<-132> > { char a[132]; };
#endif
#if N > 133
template< int i >  struct y< i, X<-133> > { char a[133]; };
#endif
#if N > 134
template< int i >  struct y< i, X<-134> > { char a[134]; };
#endif
#if N > 135
template< int i >  struct y< i, X<-135> > { char a[135]; };
#endif
#if N > 136
template< int i >  struct y< i, X<-136> > { char a[136]; };
#endif
#if N > 137
template< int i >  struct y< i, X<-137> > { char a[137]; };
#endif
#if N > 138
template< int i >  struct y< i, X<-138> > { char a[138]; };
#endif
#if N > 139
template< int i >  struct y< i, X<-139> > { char a[139]; };
#endif
#if N > 140
template< int i >  struct y< i, X<-140> > { char a[140]; };
#endif
#if N > 141
template< int i >  struct y< i, X<-141> > { char a[141]; };
#endif
#if N > 142
template< int i >  struct y< i, X<-142> > { char a[142]; };
#endif
#if N > 143
template< int i >  struct y< i, X<-143> > { char a[143]; };
#endif
#if N > 144
template< int i >  struct y< i, X<-144> > { char a[144]; };
#endif
#if N > 145
template< int i >  struct y< i, X<-145> > { char a[145]; };
#endif
#if N > 146
template< int i >  struct y< i, X<-146> > { char a[146]; };
#endif
#if N > 147
template< int i >  struct y< i, X<-147> > { char a[147]; };
#endif
#if N > 148
template< int i >  struct y< i, X<-148> > { char a[148]; };
#endif
#if N > 149
template< int i >  struct y< i, X<-149> > { char a[149]; };
#endif
#if N > 150
template< int i >  struct y< i, X<-150> > { char a[150]; };
#endif
#if N > 151
template< int i >  struct y< i, X<-151> > { char a[151]; };
#endif
#if N > 152
template< int i >  struct y< i, X<-152> > { char a[152]; };
#endif
#if N > 153
template< int i >  struct y< i, X<-153> > { char a[153]; };
#endif
#if N > 154
template< int i >  struct y< i, X<-154> > { char a[154]; };
#endif
#if N > 155
template< int i >  struct y< i, X<-155> > { char a[155]; };
#endif
#if N > 156
template< int i >  struct y< i, X<-156> > { char a[156]; };
#endif
#if N > 157
template< int i >  struct y< i, X<-157> > { char a[157]; };
#endif
#if N > 158
template< int i >  struct y< i, X<-158> > { char a[158]; };
#endif
#if N > 159
template< int i >  struct y< i, X<-159> > { char a[159]; };
#endif
#if N > 160
template< int i >  struct y< i, X<-160> > { char a[160]; };
#endif
#if N > 161
template< int i >  struct y< i, X<-161> > { char a[161]; };
#endif
#if N > 162
template< int i >  struct y< i, X<-162> > { char a[162]; };
#endif
#if N > 163
template< int i >  struct y< i, X<-163> > { char a[163]; };
#endif
#if N > 164
template< int i >  struct y< i, X<-164> > { char a[164]; };
#endif
#if N > 165
template< int i >  struct y< i, X<-165> > { char a[165]; };
#endif
#if N > 166
template< int i >  struct y< i, X<-166> > { char a[166]; };
#endif
#if N > 167
template< int i >  struct y< i, X<-167> > { char a[167]; };
#endif
#if N > 168
template< int i >  struct y< i, X<-168> > { char a[168]; };
#endif
#if N > 169
template< int i >  struct y< i, X<-169> > { char a[169]; };
#endif
#if N > 170
template< int i >  struct y< i, X<-170> > { char a[170]; };
#endif
#if N > 171
template< int i >  struct y< i, X<-171> > { char a[171]; };
#endif
#if N > 172
template< int i >  struct y< i, X<-172> > { char a[172]; };
#endif
#if N > 173
template< int i >  struct y< i, X<-173> > { char a[173]; };
#endif
#if N > 174
template< int i >  struct y< i, X<-174> > { char a[174]; };
#endif
#if N > 175
template< int i >  struct y< i, X<-175> > { char a[175]; };
#endif
#if N > 176
template< int i >  struct y< i, X<-176> > { char a[176]; };
#endif
#if N > 177
template< int i >  struct y< i, X<-177> > { char a[177]; };
#endif
#if N > 178
template< int i >  struct y< i, X<-178> > { char a[178]; };
#endif
#if N > 179
template< int i >  struct y< i, X<-179> > { char a[179]; };
#endif
#if N > 180
template< int i >  struct y< i, X<-180> > { char a[180]; };
#endif
#if N > 181
template< int i >  struct y< i, X<-181> > { char a[181]; };
#endif
#if N > 182
template< int i >  struct y< i, X<-182> > { char a[182]; };
#endif
#if N > 183
template< int i >  struct y< i, X<-183> > { char a[183]; };
#endif
#if N > 184
template< int i >  struct y< i, X<-184> > { char a[184]; };
#endif
#if N > 185
template< int i >  struct y< i, X<-185> > { char a[185]; };
#endif
#if N > 186
template< int i >  struct y< i, X<-186> > { char a[186]; };
#endif
#if N > 187
template< int i >  struct y< i, X<-187> > { char a[187]; };
#endif
#if N > 188
template< int i >  struct y< i, X<-188> > { char a[188]; };
#endif
#if N > 189
template< int i >  struct y< i, X<-189> > { char a[189]; };
#endif
#if N > 190
template< int i >  struct y< i, X<-190> > { char a[190]; };
#endif
#if N > 191
template< int i >  struct y< i, X<-191> > { char a[191]; };
#endif
#if N > 192
template< int i >  struct y< i, X<-192> > { char a[192]; };
#endif
#if N > 193
template< int i >  struct y< i, X<-193> > { char a[193]; };
#endif
#if N > 194
template< int i >  struct y< i, X<-194> > { char a[194]; };
#endif
#if N > 195
template< int i >  struct y< i, X<-195> > { char a[195]; };
#endif
#if N > 196
template< int i >  struct y< i, X<-196> > { char a[196]; };
#endif
#if N > 197
template< int i >  struct y< i, X<-197> > { char a[197]; };
#endif
#if N > 198
template< int i >  struct y< i, X<-198> > { char a[198]; };
#endif
#if N > 199
template< int i >  struct y< i, X<-199> > { char a[199]; };
#endif
#if N > 200
template< int i >  struct y< i, X<-200> > { char a[200]; };
#endif
#if N > 201
template< int i >  struct y< i, X<-201> > { char a[201]; };
#endif
#if N > 202
template< int i >  struct y< i, X<-202> > { char a[202]; };
#endif
#if N > 203
template< int i >  struct y< i, X<-203> > { char a[203]; };
#endif
#if N > 204
template< int i >  struct y< i, X<-204> > { char a[204]; };
#endif
#if N > 205
template< int i >  struct y< i, X<-205> > { char a[205]; };
#endif
#if N > 206
template< int i >  struct y< i, X<-206> > { char a[206]; };
#endif
#if N > 207
template< int i >  struct y< i, X<-207> > { char a[207]; };
#endif
#if N > 208
template< int i >  struct y< i, X<-208> > { char a[208]; };
#endif
#if N > 209
template< int i >  struct y< i, X<-209> > { char a[209]; };
#endif
#if N > 210
template< int i >  struct y< i, X<-210> > { char a[210]; };
#endif
#if N > 211
template< int i >  struct y< i, X<-211> > { char a[211]; };
#endif
#if N > 212
template< int i >  struct y< i, X<-212> > { char a[212]; };
#endif
#if N > 213
template< int i >  struct y< i, X<-213> > { char a[213]; };
#endif
#if N > 214
template< int i >  struct y< i, X<-214> > { char a[214]; };
#endif
#if N > 215
template< int i >  struct y< i, X<-215> > { char a[215]; };
#endif
#if N > 216
template< int i >  struct y< i, X<-216> > { char a[216]; };
#endif
#if N > 217
template< int i >  struct y< i, X<-217> > { char a[217]; };
#endif
#if N > 218
template< int i >  struct y< i, X<-218> > { char a[218]; };
#endif
#if N > 219
template< int i >  struct y< i, X<-219> > { char a[219]; };
#endif
#if N > 220
template< int i >  struct y< i, X<-220> > { char a[220]; };
#endif
#if N > 221
template< int i >  struct y< i, X<-221> > { char a[221]; };
#endif
#if N > 222
template< int i >  struct y< i, X<-222> > { char a[222]; };
#endif
#if N > 223
template< int i >  struct y< i, X<-223> > { char a[223]; };
#endif
#if N > 224
template< int i >  struct y< i, X<-224> > { char a[224]; };
#endif
#if N > 225
template< int i >  struct y< i, X<-225> > { char a[225]; };
#endif
#if N > 226
template< int i >  struct y< i, X<-226> > { char a[226]; };
#endif
#if N > 227
template< int i >  struct y< i, X<-227> > { char a[227]; };
#endif
#if N > 228
template< int i >  struct y< i, X<-228> > { char a[228]; };
#endif
#if N > 229
template< int i >  struct y< i, X<-229> > { char a[229]; };
#endif
#if N > 230
template< int i >  struct y< i, X<-230> > { char a[230]; };
#endif
#if N > 231
template< int i >  struct y< i, X<-231> > { char a[231]; };
#endif
#if N > 232
template< int i >  struct y< i, X<-232> > { char a[232]; };
#endif
#if N > 233
template< int i >  struct y< i, X<-233> > { char a[233]; };
#endif
#if N > 234
template< int i >  struct y< i, X<-234> > { char a[234]; };
#endif
#if N > 235
template< int i >  struct y< i, X<-235> > { char a[235]; };
#endif
#if N > 236
template< int i >  struct y< i, X<-236> > { char a[236]; };
#endif
#if N > 237
template< int i >  struct y< i, X<-237> > { char a[237]; };
#endif
#if N > 238
template< int i >  struct y< i, X<-238> > { char a[238]; };
#endif
#if N > 239
template< int i >  struct y< i, X<-239> > { char a[239]; };
#endif
#if N > 240
template< int i >  struct y< i, X<-240> > { char a[240]; };
#endif
#if N > 241
template< int i >  struct y< i, X<-241> > { char a[241]; };
#endif
#if N > 242
template< int i >  struct y< i, X<-242> > { char a[242]; };
#endif
#if N > 243
template< int i >  struct y< i, X<-243> > { char a[243]; };
#endif
#if N > 244
template< int i >  struct y< i, X<-244> > { char a[244]; };
#endif
#if N > 245
template< int i >  struct y< i, X<-245> > { char a[245]; };
#endif
#if N > 246
template< int i >  struct y< i, X<-246> > { char a[246]; };
#endif
#if N > 247
template< int i >  struct y< i, X<-247> > { char a[247]; };
#endif
#if N > 248
template< int i >  struct y< i, X<-248> > { char a[248]; };
#endif
#if N > 249
template< int i >  struct y< i, X<-249> > { char a[249]; };
#endif
#if N > 250
template< int i >  struct y< i, X<-250> > { char a[250]; };
#endif
#if N > 251
template< int i >  struct y< i, X<-251> > { char a[251]; };
#endif
#if N > 252
template< int i >  struct y< i, X<-252> > { char a[252]; };
#endif
#if N > 253
template< int i >  struct y< i, X<-253> > { char a[253]; };
#endif
#if N > 254
template< int i >  struct y< i, X<-254> > { char a[254]; };
#endif
#if N > 255
template< int i >  struct y< i, X<-255> > { char a[255]; };
#endif
#if N > 256
template< int i >  struct y< i, X<-256> > { char a[256]; };
#endif
#if N > 257
template< int i >  struct y< i, X<-257> > { char a[257]; };
#endif
#if N > 258
template< int i >  struct y< i, X<-258> > { char a[258]; };
#endif
#if N > 259
template< int i >  struct y< i, X<-259> > { char a[259]; };
#endif
#if N > 260
template< int i >  struct y< i, X<-260> > { char a[260]; };
#endif
#if N > 261
template< int i >  struct y< i, X<-261> > { char a[261]; };
#endif
#if N > 262
template< int i >  struct y< i, X<-262> > { char a[262]; };
#endif
#if N > 263
template< int i >  struct y< i, X<-263> > { char a[263]; };
#endif
#if N > 264
template< int i >  struct y< i, X<-264> > { char a[264]; };
#endif
#if N > 265
template< int i >  struct y< i, X<-265> > { char a[265]; };
#endif
#if N > 266
template< int i >  struct y< i, X<-266> > { char a[266]; };
#endif
#if N > 267
template< int i >  struct y< i, X<-267> > { char a[267]; };
#endif
#if N > 268
template< int i >  struct y< i, X<-268> > { char a[268]; };
#endif
#if N > 269
template< int i >  struct y< i, X<-269> > { char a[269]; };
#endif
#if N > 270
template< int i >  struct y< i, X<-270> > { char a[270]; };
#endif
#if N > 271
template< int i >  struct y< i, X<-271> > { char a[271]; };
#endif
#if N > 272
template< int i >  struct y< i, X<-272> > { char a[272]; };
#endif
#if N > 273
template< int i >  struct y< i, X<-273> > { char a[273]; };
#endif
#if N > 274
template< int i >  struct y< i, X<-274> > { char a[274]; };
#endif
#if N > 275
template< int i >  struct y< i, X<-275> > { char a[275]; };
#endif
#if N > 276
template< int i >  struct y< i, X<-276> > { char a[276]; };
#endif
#if N > 277
template< int i >  struct y< i, X<-277> > { char a[277]; };
#endif
#if N > 278
template< int i >  struct y< i, X<-278> > { char a[278]; };
#endif
#if N > 279
template< int i >  struct y< i, X<-279> > { char a[279]; };
#endif
#if N > 280
template< int i >  struct y< i, X<-280> > { char a[280]; };
#endif
#if N > 281
template< int i >  struct y< i, X<-281> > { char a[281]; };
#endif
#if N > 282
template< int i >  struct y< i, X<-282> > { char a[282]; };
#endif
#if N > 283
template< int i >  struct y< i, X<-283> > { char a[283]; };
#endif
#if N > 284
template< int i >  struct y< i, X<-284> > { char a[284]; };
#endif
#if N > 285
template< int i >  struct y< i, X<-285> > { char a[285]; };
#endif
#if N > 286
template< int i >  struct y< i, X<-286> > { char a[286]; };
#endif
#if N > 287
template< int i >  struct y< i, X<-287> > { char a[287]; };
#endif
#if N > 288
template< int i >  struct y< i, X<-288> > { char a[288]; };
#endif
#if N > 289
template< int i >  struct y< i, X<-289> > { char a[289]; };
#endif
#if N > 290
template< int i >  struct y< i, X<-290> > { char a[290]; };
#endif
#if N > 291
template< int i >  struct y< i, X<-291> > { char a[291]; };
#endif
#if N > 292
template< int i >  struct y< i, X<-292> > { char a[292]; };
#endif
#if N > 293
template< int i >  struct y< i, X<-293> > { char a[293]; };
#endif
#if N > 294
template< int i >  struct y< i, X<-294> > { char a[294]; };
#endif
#if N > 295
template< int i >  struct y< i, X<-295> > { char a[295]; };
#endif
#if N > 296
template< int i >  struct y< i, X<-296> > { char a[296]; };
#endif
#if N > 297
template< int i >  struct y< i, X<-297> > { char a[297]; };
#endif
#if N > 298
template< int i >  struct y< i, X<-298> > { char a[298]; };
#endif
#if N > 299
template< int i >  struct y< i, X<-299> > { char a[299]; };
#endif
#if N > 300
template< int i >  struct y< i, X<-300> > { char a[300]; };
#endif
#if N > 301
template< int i >  struct y< i, X<-301> > { char a[301]; };
#endif
#if N > 302
template< int i >  struct y< i, X<-302> > { char a[302]; };
#endif
#if N > 303
template< int i >  struct y< i, X<-303> > { char a[303]; };
#endif
#if N > 304
template< int i >  struct y< i, X<-304> > { char a[304]; };
#endif
#if N > 305
template< int i >  struct y< i, X<-305> > { char a[305]; };
#endif
#if N > 306
template< int i >  struct y< i, X<-306> > { char a[306]; };
#endif
#if N > 307
template< int i >  struct y< i, X<-307> > { char a[307]; };
#endif
#if N > 308
template< int i >  struct y< i, X<-308> > { char a[308]; };
#endif
#if N > 309
template< int i >  struct y< i, X<-309> > { char a[309]; };
#endif
#if N > 310
template< int i >  struct y< i, X<-310> > { char a[310]; };
#endif
#if N > 311
template< int i >  struct y< i, X<-311> > { char a[311]; };
#endif
#if N > 312
template< int i >  struct y< i, X<-312> > { char a[312]; };
#endif
#if N > 313
template< int i >  struct y< i, X<-313> > { char a[313]; };
#endif
#if N > 314
template< int i >  struct y< i, X<-314> > { char a[314]; };
#endif
#if N > 315
template< int i >  struct y< i, X<-315> > { char a[315]; };
#endif
#if N > 316
template< int i >  struct y< i, X<-316> > { char a[316]; };
#endif
#if N > 317
template< int i >  struct y< i, X<-317> > { char a[317]; };
#endif
#if N > 318
template< int i >  struct y< i, X<-318> > { char a[318]; };
#endif
#if N > 319
template< int i >  struct y< i, X<-319> > { char a[319]; };
#endif
#if N > 320
template< int i >  struct y< i, X<-320> > { char a[320]; };
#endif
#if N > 321
template< int i >  struct y< i, X<-321> > { char a[321]; };
#endif
#if N > 322
template< int i >  struct y< i, X<-322> > { char a[322]; };
#endif
#if N > 323
template< int i >  struct y< i, X<-323> > { char a[323]; };
#endif
#if N > 324
template< int i >  struct y< i, X<-324> > { char a[324]; };
#endif
#if N > 325
template< int i >  struct y< i, X<-325> > { char a[325]; };
#endif
#if N > 326
template< int i >  struct y< i, X<-326> > { char a[326]; };
#endif
#if N > 327
template< int i >  struct y< i, X<-327> > { char a[327]; };
#endif
#if N > 328
template< int i >  struct y< i, X<-328> > { char a[328]; };
#endif
#if N > 329
template< int i >  struct y< i, X<-329> > { char a[329]; };
#endif
#if N > 330
template< int i >  struct y< i, X<-330> > { char a[330]; };
#endif
#if N > 331
template< int i >  struct y< i, X<-331> > { char a[331]; };
#endif
#if N > 332
template< int i >  struct y< i, X<-332> > { char a[332]; };
#endif
#if N > 333
template< int i >  struct y< i, X<-333> > { char a[333]; };
#endif
#if N > 334
template< int i >  struct y< i, X<-334> > { char a[334]; };
#endif
#if N > 335
template< int i >  struct y< i, X<-335> > { char a[335]; };
#endif
#if N > 336
template< int i >  struct y< i, X<-336> > { char a[336]; };
#endif
#if N > 337
template< int i >  struct y< i, X<-337> > { char a[337]; };
#endif
#if N > 338
template< int i >  struct y< i, X<-338> > { char a[338]; };
#endif
#if N > 339
template< int i >  struct y< i, X<-339> > { char a[339]; };
#endif
#if N > 340
template< int i >  struct y< i, X<-340> > { char a[340]; };
#endif
#if N > 341
template< int i >  struct y< i, X<-341> > { char a[341]; };
#endif
#if N > 342
template< int i >  struct y< i, X<-342> > { char a[342]; };
#endif
#if N > 343
template< int i >  struct y< i, X<-343> > { char a[343]; };
#endif
#if N > 344
template< int i >  struct y< i, X<-344> > { char a[344]; };
#endif
#if N > 345
template< int i >  struct y< i, X<-345> > { char a[345]; };
#endif
#if N > 346
template< int i >  struct y< i, X<-346> > { char a[346]; };
#endif
#if N > 347
template< int i >  struct y< i, X<-347> > { char a[347]; };
#endif
#if N > 348
template< int i >  struct y< i, X<-348> > { char a[348]; };
#endif
#if N > 349
template< int i >  struct y< i, X<-349> > { char a[349]; };
#endif
#if N > 350
template< int i >  struct y< i, X<-350> > { char a[350]; };
#endif
#if N > 351
template< int i >  struct y< i, X<-351> > { char a[351]; };
#endif
#if N > 352
template< int i >  struct y< i, X<-352> > { char a[352]; };
#endif
#if N > 353
template< int i >  struct y< i, X<-353> > { char a[353]; };
#endif
#if N > 354
template< int i >  struct y< i, X<-354> > { char a[354]; };
#endif
#if N > 355
template< int i >  struct y< i, X<-355> > { char a[355]; };
#endif
#if N > 356
template< int i >  struct y< i, X<-356> > { char a[356]; };
#endif
#if N > 357
template< int i >  struct y< i, X<-357> > { char a[357]; };
#endif
#if N > 358
template< int i >  struct y< i, X<-358> > { char a[358]; };
#endif
#if N > 359
template< int i >  struct y< i, X<-359> > { char a[359]; };
#endif
#if N > 360
template< int i >  struct y< i, X<-360> > { char a[360]; };
#endif
#if N > 361
template< int i >  struct y< i, X<-361> > { char a[361]; };
#endif
#if N > 362
template< int i >  struct y< i, X<-362> > { char a[362]; };
#endif
#if N > 363
template< int i >  struct y< i, X<-363> > { char a[363]; };
#endif
#if N > 364
template< int i >  struct y< i, X<-364> > { char a[364]; };
#endif
#if N > 365
template< int i >  struct y< i, X<-365> > { char a[365]; };
#endif
#if N > 366
template< int i >  struct y< i, X<-366> > { char a[366]; };
#endif
#if N > 367
template< int i >  struct y< i, X<-367> > { char a[367]; };
#endif
#if N > 368
template< int i >  struct y< i, X<-368> > { char a[368]; };
#endif
#if N > 369
template< int i >  struct y< i, X<-369> > { char a[369]; };
#endif
#if N > 370
template< int i >  struct y< i, X<-370> > { char a[370]; };
#endif
#if N > 371
template< int i >  struct y< i, X<-371> > { char a[371]; };
#endif
#if N > 372
template< int i >  struct y< i, X<-372> > { char a[372]; };
#endif
#if N > 373
template< int i >  struct y< i, X<-373> > { char a[373]; };
#endif
#if N > 374
template< int i >  struct y< i, X<-374> > { char a[374]; };
#endif
#if N > 375
template< int i >  struct y< i, X<-375> > { char a[375]; };
#endif
#if N > 376
template< int i >  struct y< i, X<-376> > { char a[376]; };
#endif
#if N > 377
template< int i >  struct y< i, X<-377> > { char a[377]; };
#endif
#if N > 378
template< int i >  struct y< i, X<-378> > { char a[378]; };
#endif
#if N > 379
template< int i >  struct y< i, X<-379> > { char a[379]; };
#endif
#if N > 380
template< int i >  struct y< i, X<-380> > { char a[380]; };
#endif
#if N > 381
template< int i >  struct y< i, X<-381> > { char a[381]; };
#endif
#if N > 382
template< int i >  struct y< i, X<-382> > { char a[382]; };
#endif
#if N > 383
template< int i >  struct y< i, X<-383> > { char a[383]; };
#endif
#if N > 384
template< int i >  struct y< i, X<-384> > { char a[384]; };
#endif
#if N > 385
template< int i >  struct y< i, X<-385> > { char a[385]; };
#endif
#if N > 386
template< int i >  struct y< i, X<-386> > { char a[386]; };
#endif
#if N > 387
template< int i >  struct y< i, X<-387> > { char a[387]; };
#endif
#if N > 388
template< int i >  struct y< i, X<-388> > { char a[388]; };
#endif
#if N > 389
template< int i >  struct y< i, X<-389> > { char a[389]; };
#endif
#if N > 390
template< int i >  struct y< i, X<-390> > { char a[390]; };
#endif
#if N > 391
template< int i >  struct y< i, X<-391> > { char a[391]; };
#endif
#if N > 392
template< int i >  struct y< i, X<-392> > { char a[392]; };
#endif
#if N > 393
template< int i >  struct y< i, X<-393> > { char a[393]; };
#endif
#if N > 394
template< int i >  struct y< i, X<-394> > { char a[394]; };
#endif
#if N > 395
template< int i >  struct y< i, X<-395> > { char a[395]; };
#endif
#if N > 396
template< int i >  struct y< i, X<-396> > { char a[396]; };
#endif
#if N > 397
template< int i >  struct y< i, X<-397> > { char a[397]; };
#endif
#if N > 398
template< int i >  struct y< i, X<-398> > { char a[398]; };
#endif
#if N > 399
template< int i >  struct y< i, X<-399> > { char a[399]; };
#endif
#if N > 400
template< int i >  struct y< i, X<-400> > { char a[400]; };
#endif
#if N > 401
template< int i >  struct y< i, X<-401> > { char a[401]; };
#endif
#if N > 402
template< int i >  struct y< i, X<-402> > { char a[402]; };
#endif
#if N > 403
template< int i >  struct y< i, X<-403> > { char a[403]; };
#endif
#if N > 404
template< int i >  struct y< i, X<-404> > { char a[404]; };
#endif
#if N > 405
template< int i >  struct y< i, X<-405> > { char a[405]; };
#endif
#if N > 406
template< int i >  struct y< i, X<-406> > { char a[406]; };
#endif
#if N > 407
template< int i >  struct y< i, X<-407> > { char a[407]; };
#endif
#if N > 408
template< int i >  struct y< i, X<-408> > { char a[408]; };
#endif
#if N > 409
template< int i >  struct y< i, X<-409> > { char a[409]; };
#endif
#if N > 410
template< int i >  struct y< i, X<-410> > { char a[410]; };
#endif
#if N > 411
template< int i >  struct y< i, X<-411> > { char a[411]; };
#endif
#if N > 412
template< int i >  struct y< i, X<-412> > { char a[412]; };
#endif
#if N > 413
template< int i >  struct y< i, X<-413> > { char a[413]; };
#endif
#if N > 414
template< int i >  struct y< i, X<-414> > { char a[414]; };
#endif
#if N > 415
template< int i >  struct y< i, X<-415> > { char a[415]; };
#endif
#if N > 416
template< int i >  struct y< i, X<-416> > { char a[416]; };
#endif
#if N > 417
template< int i >  struct y< i, X<-417> > { char a[417]; };
#endif
#if N > 418
template< int i >  struct y< i, X<-418> > { char a[418]; };
#endif
#if N > 419
template< int i >  struct y< i, X<-419> > { char a[419]; };
#endif
#if N > 420
template< int i >  struct y< i, X<-420> > { char a[420]; };
#endif
#if N > 421
template< int i >  struct y< i, X<-421> > { char a[421]; };
#endif
#if N > 422
template< int i >  struct y< i, X<-422> > { char a[422]; };
#endif
#if N > 423
template< int i >  struct y< i, X<-423> > { char a[423]; };
#endif
#if N > 424
template< int i >  struct y< i, X<-424> > { char a[424]; };
#endif
#if N > 425
template< int i >  struct y< i, X<-425> > { char a[425]; };
#endif
#if N > 426
template< int i >  struct y< i, X<-426> > { char a[426]; };
#endif
#if N > 427
template< int i >  struct y< i, X<-427> > { char a[427]; };
#endif
#if N > 428
template< int i >  struct y< i, X<-428> > { char a[428]; };
#endif
#if N > 429
template< int i >  struct y< i, X<-429> > { char a[429]; };
#endif
#if N > 430
template< int i >  struct y< i, X<-430> > { char a[430]; };
#endif
#if N > 431
template< int i >  struct y< i, X<-431> > { char a[431]; };
#endif
#if N > 432
template< int i >  struct y< i, X<-432> > { char a[432]; };
#endif
#if N > 433
template< int i >  struct y< i, X<-433> > { char a[433]; };
#endif
#if N > 434
template< int i >  struct y< i, X<-434> > { char a[434]; };
#endif
#if N > 435
template< int i >  struct y< i, X<-435> > { char a[435]; };
#endif
#if N > 436
template< int i >  struct y< i, X<-436> > { char a[436]; };
#endif
#if N > 437
template< int i >  struct y< i, X<-437> > { char a[437]; };
#endif
#if N > 438
template< int i >  struct y< i, X<-438> > { char a[438]; };
#endif
#if N > 439
template< int i >  struct y< i, X<-439> > { char a[439]; };
#endif
#if N > 440
template< int i >  struct y< i, X<-440> > { char a[440]; };
#endif
#if N > 441
template< int i >  struct y< i, X<-441> > { char a[441]; };
#endif
#if N > 442
template< int i >  struct y< i, X<-442> > { char a[442]; };
#endif
#if N > 443
template< int i >  struct y< i, X<-443> > { char a[443]; };
#endif
#if N > 444
template< int i >  struct y< i, X<-444> > { char a[444]; };
#endif
#if N > 445
template< int i >  struct y< i, X<-445> > { char a[445]; };
#endif
#if N > 446
template< int i >  struct y< i, X<-446> > { char a[446]; };
#endif
#if N > 447
template< int i >  struct y< i, X<-447> > { char a[447]; };
#endif
#if N > 448
template< int i >  struct y< i, X<-448> > { char a[448]; };
#endif
#if N > 449
template< int i >  struct y< i, X<-449> > { char a[449]; };
#endif
#if N > 450
template< int i >  struct y< i, X<-450> > { char a[450]; };
#endif
#if N > 451
template< int i >  struct y< i, X<-451> > { char a[451]; };
#endif
#if N > 452
template< int i >  struct y< i, X<-452> > { char a[452]; };
#endif
#if N > 453
template< int i >  struct y< i, X<-453> > { char a[453]; };
#endif
#if N > 454
template< int i >  struct y< i, X<-454> > { char a[454]; };
#endif
#if N > 455
template< int i >  struct y< i, X<-455> > { char a[455]; };
#endif
#if N > 456
template< int i >  struct y< i, X<-456> > { char a[456]; };
#endif
#if N > 457
template< int i >  struct y< i, X<-457> > { char a[457]; };
#endif
#if N > 458
template< int i >  struct y< i, X<-458> > { char a[458]; };
#endif
#if N > 459
template< int i >  struct y< i, X<-459> > { char a[459]; };
#endif
#if N > 460
template< int i >  struct y< i, X<-460> > { char a[460]; };
#endif
#if N > 461
template< int i >  struct y< i, X<-461> > { char a[461]; };
#endif
#if N > 462
template< int i >  struct y< i, X<-462> > { char a[462]; };
#endif
#if N > 463
template< int i >  struct y< i, X<-463> > { char a[463]; };
#endif
#if N > 464
template< int i >  struct y< i, X<-464> > { char a[464]; };
#endif
#if N > 465
template< int i >  struct y< i, X<-465> > { char a[465]; };
#endif
#if N > 466
template< int i >  struct y< i, X<-466> > { char a[466]; };
#endif
#if N > 467
template< int i >  struct y< i, X<-467> > { char a[467]; };
#endif
#if N > 468
template< int i >  struct y< i, X<-468> > { char a[468]; };
#endif
#if N > 469
template< int i >  struct y< i, X<-469> > { char a[469]; };
#endif
#if N > 470
template< int i >  struct y< i, X<-470> > { char a[470]; };
#endif
#if N > 471
template< int i >  struct y< i, X<-471> > { char a[471]; };
#endif
#if N > 472
template< int i >  struct y< i, X<-472> > { char a[472]; };
#endif
#if N > 473
template< int i >  struct y< i, X<-473> > { char a[473]; };
#endif
#if N > 474
template< int i >  struct y< i, X<-474> > { char a[474]; };
#endif
#if N > 475
template< int i >  struct y< i, X<-475> > { char a[475]; };
#endif
#if N > 476
template< int i >  struct y< i, X<-476> > { char a[476]; };
#endif
#if N > 477
template< int i >  struct y< i, X<-477> > { char a[477]; };
#endif
#if N > 478
template< int i >  struct y< i, X<-478> > { char a[478]; };
#endif
#if N > 479
template< int i >  struct y< i, X<-479> > { char a[479]; };
#endif
#if N > 480
template< int i >  struct y< i, X<-480> > { char a[480]; };
#endif
#if N > 481
template< int i >  struct y< i, X<-481> > { char a[481]; };
#endif
#if N > 482
template< int i >  struct y< i, X<-482> > { char a[482]; };
#endif
#if N > 483
template< int i >  struct y< i, X<-483> > { char a[483]; };
#endif
#if N > 484
template< int i >  struct y< i, X<-484> > { char a[484]; };
#endif
#if N > 485
template< int i >  struct y< i, X<-485> > { char a[485]; };
#endif
#if N > 486
template< int i >  struct y< i, X<-486> > { char a[486]; };
#endif
#if N > 487
template< int i >  struct y< i, X<-487> > { char a[487]; };
#endif
#if N > 488
template< int i >  struct y< i, X<-488> > { char a[488]; };
#endif
#if N > 489
template< int i >  struct y< i, X<-489> > { char a[489]; };
#endif
#if N > 490
template< int i >  struct y< i, X<-490> > { char a[490]; };
#endif
#if N > 491
template< int i >  struct y< i, X<-491> > { char a[491]; };
#endif
#if N > 492
template< int i >  struct y< i, X<-492> > { char a[492]; };
#endif
#if N > 493
template< int i >  struct y< i, X<-493> > { char a[493]; };
#endif
#if N > 494
template< int i >  struct y< i, X<-494> > { char a[494]; };
#endif
#if N > 495
template< int i >  struct y< i, X<-495> > { char a[495]; };
#endif
#if N > 496
template< int i >  struct y< i, X<-496> > { char a[496]; };
#endif
#if N > 497
template< int i >  struct y< i, X<-497> > { char a[497]; };
#endif
#if N > 498
template< int i >  struct y< i, X<-498> > { char a[498]; };
#endif
#if N > 499
template< int i >  struct y< i, X<-499> > { char a[499]; };
#endif




template< int i > struct test
    : test<i-1>
#ifndef DIFF
    , y< i, x<i> >
#endif
{
};

template<> struct test<0>
{
};

int main()
{
    return sizeof(test<100>);
}
