← Back to branch summary

~ubuntu-branches/ubuntu/utopic/aspectc++/utopic

« back to all changes in this revision

Viewing changes to Puma/gen-release/step2/src/CCSyntax.cc

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2012-05-30 10:01:33 UTC
  • mfrom: (1.2.7)
  • Revision ID: package-import@ubuntu.com-20120530100133-rnwnvxsb3xfsvu2w
Tags: 1:1.1+svn20120529-1
* New upstream snapshot.
  - Fixes with fcntl handling on kFreeBSD
  - Upstream fixes in the Puma Parser

Show diffs side-by-side

added added

removed removed

Lines of Context:
Puma/gen-release/step2/src/CCSyntax.cc
2357
2357
  typedef TTarget Target;
2358
2358
  enum { ARGS = TArgs::ARGS };
2359
2359
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
2360
 
  static const int JPID = 5714;
 
2360
  static const int JPID = 10414;
2361
2361
  static const AC::JPType JPTYPE = (AC::JPType)16;
2362
2362
  struct Res {
2363
2363
    typedef void Type;
2398
2398
  typedef TTarget Target;
2399
2399
  enum { ARGS = TArgs::ARGS };
2400
2400
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
2401
 
  static const int JPID = 5690;
 
2401
  static const int JPID = 10390;
2402
2402
  static const AC::JPType JPTYPE = (AC::JPType)16;
2403
2403
  struct Res {
2404
2404
    typedef void Type;
26907
26907
  typedef TTarget Target;
26908
26908
  enum { ARGS = TArgs::ARGS };
26909
26909
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
26910
 
  static const int JPID = 9219;
 
26910
  static const int JPID = 9061;
26911
26911
  static const AC::JPType JPTYPE = (AC::JPType)16;
26912
26912
  struct Res {
26913
26913
    typedef void Type;
27008
27008
  typedef TTarget Target;
27009
27009
  enum { ARGS = TArgs::ARGS };
27010
27010
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
27011
 
  static const int JPID = 9282;
 
27011
  static const int JPID = 9124;
27012
27012
  static const AC::JPType JPTYPE = (AC::JPType)16;
27013
27013
  struct Res {
27014
27014
    typedef void Type;
27046
27046
  typedef TTarget Target;
27047
27047
  enum { ARGS = TArgs::ARGS };
27048
27048
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
27049
 
  static const int JPID = 9280;
 
27049
  static const int JPID = 9122;
27050
27050
  static const AC::JPType JPTYPE = (AC::JPType)32;
27051
27051
  struct Res {
27052
27052
    typedef void Type;
45453
45453
  typedef TTarget Target;
45454
45454
  enum { ARGS = TArgs::ARGS };
45455
45455
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
45456
 
  static const int JPID = 9219;
 
45456
  static const int JPID = 9061;
45457
45457
  static const AC::JPType JPTYPE = (AC::JPType)16;
45458
45458
  struct Res {
45459
45459
    typedef void Type;
45554
45554
  typedef TTarget Target;
45555
45555
  enum { ARGS = TArgs::ARGS };
45556
45556
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
45557
 
  static const int JPID = 9282;
 
45557
  static const int JPID = 9124;
45558
45558
  static const AC::JPType JPTYPE = (AC::JPType)16;
45559
45559
  struct Res {
45560
45560
    typedef void Type;
45592
45592
  typedef TTarget Target;
45593
45593
  enum { ARGS = TArgs::ARGS };
45594
45594
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
45595
 
  static const int JPID = 9280;
 
45595
  static const int JPID = 9122;
45596
45596
  static const AC::JPType JPTYPE = (AC::JPType)32;
45597
45597
  struct Res {
45598
45598
    typedef void Type;
63384
63384
  typedef TTarget Target;
63385
63385
  enum { ARGS = TArgs::ARGS };
63386
63386
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
63387
 
  static const int JPID = 9219;
 
63387
  static const int JPID = 9061;
63388
63388
  static const AC::JPType JPTYPE = (AC::JPType)16;
63389
63389
  struct Res {
63390
63390
    typedef void Type;
63485
63485
  typedef TTarget Target;
63486
63486
  enum { ARGS = TArgs::ARGS };
63487
63487
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
63488
 
  static const int JPID = 9282;
 
63488
  static const int JPID = 9124;
63489
63489
  static const AC::JPType JPTYPE = (AC::JPType)16;
63490
63490
  struct Res {
63491
63491
    typedef void Type;
63523
63523
  typedef TTarget Target;
63524
63524
  enum { ARGS = TArgs::ARGS };
63525
63525
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
63526
 
  static const int JPID = 9280;
 
63526
  static const int JPID = 9122;
63527
63527
  static const AC::JPType JPTYPE = (AC::JPType)32;
63528
63528
  struct Res {
63529
63529
    typedef void Type;
86867
86867
  typedef TTarget Target;
86868
86868
  enum { ARGS = TArgs::ARGS };
86869
86869
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
86870
 
  static const int JPID = 9219;
 
86870
  static const int JPID = 9061;
86871
86871
  static const AC::JPType JPTYPE = (AC::JPType)16;
86872
86872
  struct Res {
86873
86873
    typedef void Type;
86968
86968
  typedef TTarget Target;
86969
86969
  enum { ARGS = TArgs::ARGS };
86970
86970
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
86971
 
  static const int JPID = 9282;
 
86971
  static const int JPID = 9124;
86972
86972
  static const AC::JPType JPTYPE = (AC::JPType)16;
86973
86973
  struct Res {
86974
86974
    typedef void Type;
87006
87006
  typedef TTarget Target;
87007
87007
  enum { ARGS = TArgs::ARGS };
87008
87008
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
87009
 
  static const int JPID = 9280;
 
87009
  static const int JPID = 9122;
87010
87010
  static const AC::JPType JPTYPE = (AC::JPType)32;
87011
87011
  struct Res {
87012
87012
    typedef void Type;
104187
104187
  typedef TTarget Target;
104188
104188
  enum { ARGS = TArgs::ARGS };
104189
104189
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
104190
 
  static const int JPID = 9219;
 
104190
  static const int JPID = 9061;
104191
104191
  static const AC::JPType JPTYPE = (AC::JPType)16;
104192
104192
  struct Res {
104193
104193
    typedef void Type;
104288
104288
  typedef TTarget Target;
104289
104289
  enum { ARGS = TArgs::ARGS };
104290
104290
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
104291
 
  static const int JPID = 9282;
 
104291
  static const int JPID = 9124;
104292
104292
  static const AC::JPType JPTYPE = (AC::JPType)16;
104293
104293
  struct Res {
104294
104294
    typedef void Type;
104326
104326
  typedef TTarget Target;
104327
104327
  enum { ARGS = TArgs::ARGS };
104328
104328
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
104329
 
  static const int JPID = 9280;
 
104329
  static const int JPID = 9122;
104330
104330
  static const AC::JPType JPTYPE = (AC::JPType)32;
104331
104331
  struct Res {
104332
104332
    typedef void Type;
122902
122902
  typedef TTarget Target;
122903
122903
  enum { ARGS = TArgs::ARGS };
122904
122904
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
122905
 
  static const int JPID = 9219;
 
122905
  static const int JPID = 9061;
122906
122906
  static const AC::JPType JPTYPE = (AC::JPType)16;
122907
122907
  struct Res {
122908
122908
    typedef void Type;
123003
123003
  typedef TTarget Target;
123004
123004
  enum { ARGS = TArgs::ARGS };
123005
123005
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
123006
 
  static const int JPID = 9282;
 
123006
  static const int JPID = 9124;
123007
123007
  static const AC::JPType JPTYPE = (AC::JPType)16;
123008
123008
  struct Res {
123009
123009
    typedef void Type;
123041
123041
  typedef TTarget Target;
123042
123042
  enum { ARGS = TArgs::ARGS };
123043
123043
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
123044
 
  static const int JPID = 9280;
 
123044
  static const int JPID = 9122;
123045
123045
  static const AC::JPType JPTYPE = (AC::JPType)32;
123046
123046
  struct Res {
123047
123047
    typedef void Type;
131922
131922
  typedef TTarget Target;
131923
131923
  enum { ARGS = TArgs::ARGS };
131924
131924
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
131925
 
  static const int JPID = 6166;
 
131925
  static const int JPID = 10832;
131926
131926
  static const AC::JPType JPTYPE = (AC::JPType)16;
131927
131927
  struct Res {
131928
131928
    typedef void Type;
132011
132011
  typedef TTarget Target;
132012
132012
  enum { ARGS = TArgs::ARGS };
132013
132013
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
132014
 
  static const int JPID = 6199;
 
132014
  static const int JPID = 10865;
132015
132015
  static const AC::JPType JPTYPE = (AC::JPType)16;
132016
132016
  struct Res {
132017
132017
    typedef void Type;
147730
147730
  typedef TTarget Target;
147731
147731
  enum { ARGS = TArgs::ARGS };
147732
147732
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
147733
 
  static const int JPID = 9219;
 
147733
  static const int JPID = 9061;
147734
147734
  static const AC::JPType JPTYPE = (AC::JPType)16;
147735
147735
  struct Res {
147736
147736
    typedef void Type;
147831
147831
  typedef TTarget Target;
147832
147832
  enum { ARGS = TArgs::ARGS };
147833
147833
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
147834
 
  static const int JPID = 9282;
 
147834
  static const int JPID = 9124;
147835
147835
  static const AC::JPType JPTYPE = (AC::JPType)16;
147836
147836
  struct Res {
147837
147837
    typedef void Type;
147869
147869
  typedef TTarget Target;
147870
147870
  enum { ARGS = TArgs::ARGS };
147871
147871
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
147872
 
  static const int JPID = 9280;
 
147872
  static const int JPID = 9122;
147873
147873
  static const AC::JPType JPTYPE = (AC::JPType)32;
147874
147874
  struct Res {
147875
147875
    typedef void Type;
172974
172974
  typedef TTarget Target;
172975
172975
  enum { ARGS = TArgs::ARGS };
172976
172976
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
172977
 
  static const int JPID = 9219;
 
172977
  static const int JPID = 9061;
172978
172978
  static const AC::JPType JPTYPE = (AC::JPType)16;
172979
172979
  struct Res {
172980
172980
    typedef void Type;
173075
173075
  typedef TTarget Target;
173076
173076
  enum { ARGS = TArgs::ARGS };
173077
173077
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
173078
 
  static const int JPID = 9282;
 
173078
  static const int JPID = 9124;
173079
173079
  static const AC::JPType JPTYPE = (AC::JPType)16;
173080
173080
  struct Res {
173081
173081
    typedef void Type;
173113
173113
  typedef TTarget Target;
173114
173114
  enum { ARGS = TArgs::ARGS };
173115
173115
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
173116
 
  static const int JPID = 9280;
 
173116
  static const int JPID = 9122;
173117
173117
  static const AC::JPType JPTYPE = (AC::JPType)32;
173118
173118
  struct Res {
173119
173119
    typedef void Type;
235896
235896
  typedef TTarget Target;
235897
235897
  enum { ARGS = TArgs::ARGS };
235898
235898
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
235899
 
  static const int JPID = 9219;
 
235899
  static const int JPID = 9061;
235900
235900
  static const AC::JPType JPTYPE = (AC::JPType)16;
235901
235901
  struct Res {
235902
235902
    typedef void Type;
235997
235997
  typedef TTarget Target;
235998
235998
  enum { ARGS = TArgs::ARGS };
235999
235999
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
236000
 
  static const int JPID = 9282;
 
236000
  static const int JPID = 9124;
236001
236001
  static const AC::JPType JPTYPE = (AC::JPType)16;
236002
236002
  struct Res {
236003
236003
    typedef void Type;
236035
236035
  typedef TTarget Target;
236036
236036
  enum { ARGS = TArgs::ARGS };
236037
236037
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
236038
 
  static const int JPID = 9280;
 
236038
  static const int JPID = 9122;
236039
236039
  static const AC::JPType JPTYPE = (AC::JPType)32;
236040
236040
  struct Res {
236041
236041
    typedef void Type;
254238
254238
  typedef TTarget Target;
254239
254239
  enum { ARGS = TArgs::ARGS };
254240
254240
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
254241
 
  static const int JPID = 9219;
 
254241
  static const int JPID = 9061;
254242
254242
  static const AC::JPType JPTYPE = (AC::JPType)16;
254243
254243
  struct Res {
254244
254244
    typedef void Type;
254339
254339
  typedef TTarget Target;
254340
254340
  enum { ARGS = TArgs::ARGS };
254341
254341
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
254342
 
  static const int JPID = 9282;
 
254342
  static const int JPID = 9124;
254343
254343
  static const AC::JPType JPTYPE = (AC::JPType)16;
254344
254344
  struct Res {
254345
254345
    typedef void Type;
254377
254377
  typedef TTarget Target;
254378
254378
  enum { ARGS = TArgs::ARGS };
254379
254379
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
254380
 
  static const int JPID = 9280;
 
254380
  static const int JPID = 9122;
254381
254381
  static const AC::JPType JPTYPE = (AC::JPType)32;
254382
254382
  struct Res {
254383
254383
    typedef void Type;
256091
256091
  typedef TTarget Target;
256092
256092
  enum { ARGS = TArgs::ARGS };
256093
256093
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256094
 
  static const int JPID = 25962;
 
256094
  static const int JPID = 30368;
256095
256095
  static const AC::JPType JPTYPE = (AC::JPType)4;
256096
256096
  struct Res {
256097
256097
    typedef TResult Type;
256210
256210
  typedef TTarget Target;
256211
256211
  enum { ARGS = TArgs::ARGS };
256212
256212
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256213
 
  static const int JPID = 26184;
 
256213
  static const int JPID = 30590;
256214
256214
  static const AC::JPType JPTYPE = (AC::JPType)4;
256215
256215
  struct Res {
256216
256216
    typedef TResult Type;
256291
256291
  typedef TTarget Target;
256292
256292
  enum { ARGS = TArgs::ARGS };
256293
256293
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256294
 
  static const int JPID = 26158;
 
256294
  static const int JPID = 30564;
256295
256295
  static const AC::JPType JPTYPE = (AC::JPType)4;
256296
256296
  struct Res {
256297
256297
    typedef TResult Type;
256338
256338
  typedef TTarget Target;
256339
256339
  enum { ARGS = TArgs::ARGS };
256340
256340
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256341
 
  static const int JPID = 26161;
 
256341
  static const int JPID = 30567;
256342
256342
  static const AC::JPType JPTYPE = (AC::JPType)4;
256343
256343
  struct Res {
256344
256344
    typedef TResult Type;
256385
256385
  typedef TTarget Target;
256386
256386
  enum { ARGS = TArgs::ARGS };
256387
256387
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256388
 
  static const int JPID = 26164;
 
256388
  static const int JPID = 30570;
256389
256389
  static const AC::JPType JPTYPE = (AC::JPType)4;
256390
256390
  struct Res {
256391
256391
    typedef TResult Type;
256432
256432
  typedef TTarget Target;
256433
256433
  enum { ARGS = TArgs::ARGS };
256434
256434
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256435
 
  static const int JPID = 26166;
 
256435
  static const int JPID = 30572;
256436
256436
  static const AC::JPType JPTYPE = (AC::JPType)4;
256437
256437
  struct Res {
256438
256438
    typedef TResult Type;
256479
256479
  typedef TTarget Target;
256480
256480
  enum { ARGS = TArgs::ARGS };
256481
256481
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256482
 
  static const int JPID = 26168;
 
256482
  static const int JPID = 30574;
256483
256483
  static const AC::JPType JPTYPE = (AC::JPType)4;
256484
256484
  struct Res {
256485
256485
    typedef TResult Type;
256526
256526
  typedef TTarget Target;
256527
256527
  enum { ARGS = TArgs::ARGS };
256528
256528
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256529
 
  static const int JPID = 26175;
 
256529
  static const int JPID = 30581;
256530
256530
  static const AC::JPType JPTYPE = (AC::JPType)4;
256531
256531
  struct Res {
256532
256532
    typedef TResult Type;
256573
256573
  typedef TTarget Target;
256574
256574
  enum { ARGS = TArgs::ARGS };
256575
256575
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256576
 
  static const int JPID = 26177;
 
256576
  static const int JPID = 30583;
256577
256577
  static const AC::JPType JPTYPE = (AC::JPType)4;
256578
256578
  struct Res {
256579
256579
    typedef TResult Type;
256703
256703
  typedef TTarget Target;
256704
256704
  enum { ARGS = TArgs::ARGS };
256705
256705
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256706
 
  static const int JPID = 26178;
 
256706
  static const int JPID = 30584;
256707
256707
  static const AC::JPType JPTYPE = (AC::JPType)4;
256708
256708
  struct Res {
256709
256709
    typedef TResult Type;
256750
256750
  typedef TTarget Target;
256751
256751
  enum { ARGS = TArgs::ARGS };
256752
256752
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256753
 
  static const int JPID = 26179;
 
256753
  static const int JPID = 30585;
256754
256754
  static const AC::JPType JPTYPE = (AC::JPType)4;
256755
256755
  struct Res {
256756
256756
    typedef TResult Type;
256847
256847
  typedef TTarget Target;
256848
256848
  enum { ARGS = TArgs::ARGS };
256849
256849
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256850
 
  static const int JPID = 25995;
 
256850
  static const int JPID = 30401;
256851
256851
  static const AC::JPType JPTYPE = (AC::JPType)4;
256852
256852
  struct Res {
256853
256853
    typedef TResult Type;
256929
256929
  typedef TTarget Target;
256930
256930
  enum { ARGS = TArgs::ARGS };
256931
256931
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256932
 
  static const int JPID = 25985;
 
256932
  static const int JPID = 30391;
256933
256933
  static const AC::JPType JPTYPE = (AC::JPType)4;
256934
256934
  struct Res {
256935
256935
    typedef TResult Type;
256976
256976
  typedef TTarget Target;
256977
256977
  enum { ARGS = TArgs::ARGS };
256978
256978
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
256979
 
  static const int JPID = 25987;
 
256979
  static const int JPID = 30393;
256980
256980
  static const AC::JPType JPTYPE = (AC::JPType)4;
256981
256981
  struct Res {
256982
256982
    typedef TResult Type;
257023
257023
  typedef TTarget Target;
257024
257024
  enum { ARGS = TArgs::ARGS };
257025
257025
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257026
 
  static const int JPID = 25988;
 
257026
  static const int JPID = 30394;
257027
257027
  static const AC::JPType JPTYPE = (AC::JPType)4;
257028
257028
  struct Res {
257029
257029
    typedef TResult Type;
257070
257070
  typedef TTarget Target;
257071
257071
  enum { ARGS = TArgs::ARGS };
257072
257072
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257073
 
  static const int JPID = 25990;
 
257073
  static const int JPID = 30396;
257074
257074
  static const AC::JPType JPTYPE = (AC::JPType)4;
257075
257075
  struct Res {
257076
257076
    typedef TResult Type;
257117
257117
  typedef TTarget Target;
257118
257118
  enum { ARGS = TArgs::ARGS };
257119
257119
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257120
 
  static const int JPID = 25992;
 
257120
  static const int JPID = 30398;
257121
257121
  static const AC::JPType JPTYPE = (AC::JPType)4;
257122
257122
  struct Res {
257123
257123
    typedef TResult Type;
257164
257164
  typedef TTarget Target;
257165
257165
  enum { ARGS = TArgs::ARGS };
257166
257166
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257167
 
  static const int JPID = 25994;
 
257167
  static const int JPID = 30400;
257168
257168
  static const AC::JPType JPTYPE = (AC::JPType)4;
257169
257169
  struct Res {
257170
257170
    typedef TResult Type;
257211
257211
  typedef TTarget Target;
257212
257212
  enum { ARGS = TArgs::ARGS };
257213
257213
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257214
 
  static const int JPID = 26000;
 
257214
  static const int JPID = 30406;
257215
257215
  static const AC::JPType JPTYPE = (AC::JPType)4;
257216
257216
  struct Res {
257217
257217
    typedef TResult Type;
257258
257258
  typedef TTarget Target;
257259
257259
  enum { ARGS = TArgs::ARGS };
257260
257260
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257261
 
  static const int JPID = 26002;
 
257261
  static const int JPID = 30408;
257262
257262
  static const AC::JPType JPTYPE = (AC::JPType)4;
257263
257263
  struct Res {
257264
257264
    typedef TResult Type;
257305
257305
  typedef TTarget Target;
257306
257306
  enum { ARGS = TArgs::ARGS };
257307
257307
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257308
 
  static const int JPID = 26004;
 
257308
  static const int JPID = 30410;
257309
257309
  static const AC::JPType JPTYPE = (AC::JPType)4;
257310
257310
  struct Res {
257311
257311
    typedef TResult Type;
257352
257352
  typedef TTarget Target;
257353
257353
  enum { ARGS = TArgs::ARGS };
257354
257354
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257355
 
  static const int JPID = 26006;
 
257355
  static const int JPID = 30412;
257356
257356
  static const AC::JPType JPTYPE = (AC::JPType)4;
257357
257357
  struct Res {
257358
257358
    typedef TResult Type;
257399
257399
  typedef TTarget Target;
257400
257400
  enum { ARGS = TArgs::ARGS };
257401
257401
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257402
 
  static const int JPID = 26018;
 
257402
  static const int JPID = 30424;
257403
257403
  static const AC::JPType JPTYPE = (AC::JPType)4;
257404
257404
  struct Res {
257405
257405
    typedef TResult Type;
257446
257446
  typedef TTarget Target;
257447
257447
  enum { ARGS = TArgs::ARGS };
257448
257448
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257449
 
  static const int JPID = 26020;
 
257449
  static const int JPID = 30426;
257450
257450
  static const AC::JPType JPTYPE = (AC::JPType)4;
257451
257451
  struct Res {
257452
257452
    typedef TResult Type;
257562
257562
  typedef TTarget Target;
257563
257563
  enum { ARGS = TArgs::ARGS };
257564
257564
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257565
 
  static const int JPID = 26007;
 
257565
  static const int JPID = 30413;
257566
257566
  static const AC::JPType JPTYPE = (AC::JPType)4;
257567
257567
  struct Res {
257568
257568
    typedef TResult Type;
257609
257609
  typedef TTarget Target;
257610
257610
  enum { ARGS = TArgs::ARGS };
257611
257611
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257612
 
  static const int JPID = 26009;
 
257612
  static const int JPID = 30415;
257613
257613
  static const AC::JPType JPTYPE = (AC::JPType)4;
257614
257614
  struct Res {
257615
257615
    typedef TResult Type;
257656
257656
  typedef TTarget Target;
257657
257657
  enum { ARGS = TArgs::ARGS };
257658
257658
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257659
 
  static const int JPID = 26011;
 
257659
  static const int JPID = 30417;
257660
257660
  static const AC::JPType JPTYPE = (AC::JPType)4;
257661
257661
  struct Res {
257662
257662
    typedef TResult Type;
257703
257703
  typedef TTarget Target;
257704
257704
  enum { ARGS = TArgs::ARGS };
257705
257705
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257706
 
  static const int JPID = 26013;
 
257706
  static const int JPID = 30419;
257707
257707
  static const AC::JPType JPTYPE = (AC::JPType)4;
257708
257708
  struct Res {
257709
257709
    typedef TResult Type;
257750
257750
  typedef TTarget Target;
257751
257751
  enum { ARGS = TArgs::ARGS };
257752
257752
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257753
 
  static const int JPID = 26015;
 
257753
  static const int JPID = 30421;
257754
257754
  static const AC::JPType JPTYPE = (AC::JPType)4;
257755
257755
  struct Res {
257756
257756
    typedef TResult Type;
257816
257816
  typedef TTarget Target;
257817
257817
  enum { ARGS = TArgs::ARGS };
257818
257818
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257819
 
  static const int JPID = 25929;
 
257819
  static const int JPID = 30335;
257820
257820
  static const AC::JPType JPTYPE = (AC::JPType)4;
257821
257821
  struct Res {
257822
257822
    typedef TResult Type;
257863
257863
  typedef TTarget Target;
257864
257864
  enum { ARGS = TArgs::ARGS };
257865
257865
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
257866
 
  static const int JPID = 25930;
 
257866
  static const int JPID = 30336;
257867
257867
  static const AC::JPType JPTYPE = (AC::JPType)4;
257868
257868
  struct Res {
257869
257869
    typedef TResult Type;
258029
258029
  typedef TTarget Target;
258030
258030
  enum { ARGS = TArgs::ARGS };
258031
258031
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258032
 
  static const int JPID = 26189;
 
258032
  static const int JPID = 30595;
258033
258033
  static const AC::JPType JPTYPE = (AC::JPType)4;
258034
258034
  struct Res {
258035
258035
    typedef TResult Type;
258097
258097
  typedef TTarget Target;
258098
258098
  enum { ARGS = TArgs::ARGS };
258099
258099
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258100
 
  static const int JPID = 26190;
 
258100
  static const int JPID = 30596;
258101
258101
  static const AC::JPType JPTYPE = (AC::JPType)4;
258102
258102
  struct Res {
258103
258103
    typedef TResult Type;
258165
258165
  typedef TTarget Target;
258166
258166
  enum { ARGS = TArgs::ARGS };
258167
258167
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258168
 
  static const int JPID = 26191;
 
258168
  static const int JPID = 30597;
258169
258169
  static const AC::JPType JPTYPE = (AC::JPType)4;
258170
258170
  struct Res {
258171
258171
    typedef TResult Type;
258233
258233
  typedef TTarget Target;
258234
258234
  enum { ARGS = TArgs::ARGS };
258235
258235
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258236
 
  static const int JPID = 26192;
 
258236
  static const int JPID = 30598;
258237
258237
  static const AC::JPType JPTYPE = (AC::JPType)4;
258238
258238
  struct Res {
258239
258239
    typedef TResult Type;
258302
258302
  typedef TTarget Target;
258303
258303
  enum { ARGS = TArgs::ARGS };
258304
258304
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258305
 
  static const int JPID = 26193;
 
258305
  static const int JPID = 30599;
258306
258306
  static const AC::JPType JPTYPE = (AC::JPType)4;
258307
258307
  struct Res {
258308
258308
    typedef TResult Type;
258370
258370
  typedef TTarget Target;
258371
258371
  enum { ARGS = TArgs::ARGS };
258372
258372
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258373
 
  static const int JPID = 26194;
 
258373
  static const int JPID = 30600;
258374
258374
  static const AC::JPType JPTYPE = (AC::JPType)4;
258375
258375
  struct Res {
258376
258376
    typedef TResult Type;
258438
258438
  typedef TTarget Target;
258439
258439
  enum { ARGS = TArgs::ARGS };
258440
258440
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258441
 
  static const int JPID = 26195;
 
258441
  static const int JPID = 30601;
258442
258442
  static const AC::JPType JPTYPE = (AC::JPType)4;
258443
258443
  struct Res {
258444
258444
    typedef TResult Type;
258517
258517
  typedef TTarget Target;
258518
258518
  enum { ARGS = TArgs::ARGS };
258519
258519
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258520
 
  static const int JPID = 26196;
 
258520
  static const int JPID = 30602;
258521
258521
  static const AC::JPType JPTYPE = (AC::JPType)4;
258522
258522
  struct Res {
258523
258523
    typedef TResult Type;
258595
258595
  typedef TTarget Target;
258596
258596
  enum { ARGS = TArgs::ARGS };
258597
258597
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258598
 
  static const int JPID = 26197;
 
258598
  static const int JPID = 30603;
258599
258599
  static const AC::JPType JPTYPE = (AC::JPType)4;
258600
258600
  struct Res {
258601
258601
    typedef TResult Type;
258665
258665
  typedef TTarget Target;
258666
258666
  enum { ARGS = TArgs::ARGS };
258667
258667
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258668
 
  static const int JPID = 26198;
 
258668
  static const int JPID = 30604;
258669
258669
  static const AC::JPType JPTYPE = (AC::JPType)4;
258670
258670
  struct Res {
258671
258671
    typedef TResult Type;
258750
258750
  typedef TTarget Target;
258751
258751
  enum { ARGS = TArgs::ARGS };
258752
258752
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258753
 
  static const int JPID = 26199;
 
258753
  static const int JPID = 30605;
258754
258754
  static const AC::JPType JPTYPE = (AC::JPType)4;
258755
258755
  struct Res {
258756
258756
    typedef TResult Type;
258826
258826
  typedef TTarget Target;
258827
258827
  enum { ARGS = TArgs::ARGS };
258828
258828
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258829
 
  static const int JPID = 26200;
 
258829
  static const int JPID = 30606;
258830
258830
  static const AC::JPType JPTYPE = (AC::JPType)4;
258831
258831
  struct Res {
258832
258832
    typedef TResult Type;
258894
258894
  typedef TTarget Target;
258895
258895
  enum { ARGS = TArgs::ARGS };
258896
258896
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
258897
 
  static const int JPID = 26201;
 
258897
  static const int JPID = 30607;
258898
258898
  static const AC::JPType JPTYPE = (AC::JPType)4;
258899
258899
  struct Res {
258900
258900
    typedef TResult Type;
259010
259010
  typedef TTarget Target;
259011
259011
  enum { ARGS = TArgs::ARGS };
259012
259012
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259013
 
  static const int JPID = 26202;
 
259013
  static const int JPID = 30608;
259014
259014
  static const AC::JPType JPTYPE = (AC::JPType)4;
259015
259015
  struct Res {
259016
259016
    typedef TResult Type;
259079
259079
  typedef TTarget Target;
259080
259080
  enum { ARGS = TArgs::ARGS };
259081
259081
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259082
 
  static const int JPID = 26203;
 
259082
  static const int JPID = 30609;
259083
259083
  static const AC::JPType JPTYPE = (AC::JPType)4;
259084
259084
  struct Res {
259085
259085
    typedef TResult Type;
259148
259148
  typedef TTarget Target;
259149
259149
  enum { ARGS = TArgs::ARGS };
259150
259150
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259151
 
  static const int JPID = 26204;
 
259151
  static const int JPID = 30610;
259152
259152
  static const AC::JPType JPTYPE = (AC::JPType)4;
259153
259153
  struct Res {
259154
259154
    typedef TResult Type;
259212
259212
  typedef TTarget Target;
259213
259213
  enum { ARGS = TArgs::ARGS };
259214
259214
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259215
 
  static const int JPID = 25804;
 
259215
  static const int JPID = 30210;
259216
259216
  static const AC::JPType JPTYPE = (AC::JPType)4;
259217
259217
  struct Res {
259218
259218
    typedef TResult Type;
259258
259258
  typedef TTarget Target;
259259
259259
  enum { ARGS = TArgs::ARGS };
259260
259260
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259261
 
  static const int JPID = 25805;
 
259261
  static const int JPID = 30211;
259262
259262
  static const AC::JPType JPTYPE = (AC::JPType)4;
259263
259263
  struct Res {
259264
259264
    typedef TResult Type;
259318
259318
  typedef TTarget Target;
259319
259319
  enum { ARGS = TArgs::ARGS };
259320
259320
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259321
 
  static const int JPID = 26205;
 
259321
  static const int JPID = 30611;
259322
259322
  static const AC::JPType JPTYPE = (AC::JPType)4;
259323
259323
  struct Res {
259324
259324
    typedef TResult Type;
259413
259413
  typedef TTarget Target;
259414
259414
  enum { ARGS = TArgs::ARGS };
259415
259415
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259416
 
  static const int JPID = 26207;
 
259416
  static const int JPID = 30613;
259417
259417
  static const AC::JPType JPTYPE = (AC::JPType)4;
259418
259418
  struct Res {
259419
259419
    typedef TResult Type;
259503
259503
  typedef TTarget Target;
259504
259504
  enum { ARGS = TArgs::ARGS };
259505
259505
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259506
 
  static const int JPID = 26208;
 
259506
  static const int JPID = 30614;
259507
259507
  static const AC::JPType JPTYPE = (AC::JPType)4;
259508
259508
  struct Res {
259509
259509
    typedef TResult Type;
259637
259637
  typedef TTarget Target;
259638
259638
  enum { ARGS = TArgs::ARGS };
259639
259639
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259640
 
  static const int JPID = 26206;
 
259640
  static const int JPID = 30612;
259641
259641
  static const AC::JPType JPTYPE = (AC::JPType)4;
259642
259642
  struct Res {
259643
259643
    typedef TResult Type;
259720
259720
  typedef TTarget Target;
259721
259721
  enum { ARGS = TArgs::ARGS };
259722
259722
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259723
 
  static const int JPID = 26209;
 
259723
  static const int JPID = 30615;
259724
259724
  static const AC::JPType JPTYPE = (AC::JPType)4;
259725
259725
  struct Res {
259726
259726
    typedef TResult Type;
259784
259784
  typedef TTarget Target;
259785
259785
  enum { ARGS = TArgs::ARGS };
259786
259786
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259787
 
  static const int JPID = 25869;
 
259787
  static const int JPID = 30275;
259788
259788
  static const AC::JPType JPTYPE = (AC::JPType)4;
259789
259789
  struct Res {
259790
259790
    typedef TResult Type;
259905
259905
  typedef TTarget Target;
259906
259906
  enum { ARGS = TArgs::ARGS };
259907
259907
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259908
 
  static const int JPID = 26210;
 
259908
  static const int JPID = 30616;
259909
259909
  static const AC::JPType JPTYPE = (AC::JPType)4;
259910
259910
  struct Res {
259911
259911
    typedef TResult Type;
259991
259991
  typedef TTarget Target;
259992
259992
  enum { ARGS = TArgs::ARGS };
259993
259993
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
259994
 
  static const int JPID = 26211;
 
259994
  static const int JPID = 30617;
259995
259995
  static const AC::JPType JPTYPE = (AC::JPType)4;
259996
259996
  struct Res {
259997
259997
    typedef TResult Type;
260080
260080
  typedef TTarget Target;
260081
260081
  enum { ARGS = TArgs::ARGS };
260082
260082
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260083
 
  static const int JPID = 26212;
 
260083
  static const int JPID = 30618;
260084
260084
  static const AC::JPType JPTYPE = (AC::JPType)4;
260085
260085
  struct Res {
260086
260086
    typedef TResult Type;
260150
260150
  typedef TTarget Target;
260151
260151
  enum { ARGS = TArgs::ARGS };
260152
260152
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260153
 
  static const int JPID = 26213;
 
260153
  static const int JPID = 30619;
260154
260154
  static const AC::JPType JPTYPE = (AC::JPType)4;
260155
260155
  struct Res {
260156
260156
    typedef TResult Type;
260263
260263
  typedef TTarget Target;
260264
260264
  enum { ARGS = TArgs::ARGS };
260265
260265
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260266
 
  static const int JPID = 26214;
 
260266
  static const int JPID = 30620;
260267
260267
  static const AC::JPType JPTYPE = (AC::JPType)4;
260268
260268
  struct Res {
260269
260269
    typedef TResult Type;
260335
260335
  typedef TTarget Target;
260336
260336
  enum { ARGS = TArgs::ARGS };
260337
260337
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260338
 
  static const int JPID = 26215;
 
260338
  static const int JPID = 30621;
260339
260339
  static const AC::JPType JPTYPE = (AC::JPType)4;
260340
260340
  struct Res {
260341
260341
    typedef TResult Type;
260406
260406
  typedef TTarget Target;
260407
260407
  enum { ARGS = TArgs::ARGS };
260408
260408
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260409
 
  static const int JPID = 26216;
 
260409
  static const int JPID = 30622;
260410
260410
  static const AC::JPType JPTYPE = (AC::JPType)4;
260411
260411
  struct Res {
260412
260412
    typedef TResult Type;
260475
260475
  typedef TTarget Target;
260476
260476
  enum { ARGS = TArgs::ARGS };
260477
260477
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260478
 
  static const int JPID = 26217;
 
260478
  static const int JPID = 30623;
260479
260479
  static const AC::JPType JPTYPE = (AC::JPType)4;
260480
260480
  struct Res {
260481
260481
    typedef TResult Type;
260545
260545
  typedef TTarget Target;
260546
260546
  enum { ARGS = TArgs::ARGS };
260547
260547
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260548
 
  static const int JPID = 26218;
 
260548
  static const int JPID = 30624;
260549
260549
  static const AC::JPType JPTYPE = (AC::JPType)4;
260550
260550
  struct Res {
260551
260551
    typedef TResult Type;
260618
260618
  typedef TTarget Target;
260619
260619
  enum { ARGS = TArgs::ARGS };
260620
260620
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260621
 
  static const int JPID = 26219;
 
260621
  static const int JPID = 30625;
260622
260622
  static const AC::JPType JPTYPE = (AC::JPType)4;
260623
260623
  struct Res {
260624
260624
    typedef TResult Type;
260688
260688
  typedef TTarget Target;
260689
260689
  enum { ARGS = TArgs::ARGS };
260690
260690
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260691
 
  static const int JPID = 26220;
 
260691
  static const int JPID = 30626;
260692
260692
  static const AC::JPType JPTYPE = (AC::JPType)4;
260693
260693
  struct Res {
260694
260694
    typedef TResult Type;
260758
260758
  typedef TTarget Target;
260759
260759
  enum { ARGS = TArgs::ARGS };
260760
260760
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260761
 
  static const int JPID = 26221;
 
260761
  static const int JPID = 30627;
260762
260762
  static const AC::JPType JPTYPE = (AC::JPType)4;
260763
260763
  struct Res {
260764
260764
    typedef TResult Type;
260844
260844
  typedef TTarget Target;
260845
260845
  enum { ARGS = TArgs::ARGS };
260846
260846
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260847
 
  static const int JPID = 26222;
 
260847
  static const int JPID = 30628;
260848
260848
  static const AC::JPType JPTYPE = (AC::JPType)4;
260849
260849
  struct Res {
260850
260850
    typedef TResult Type;
260915
260915
  typedef TTarget Target;
260916
260916
  enum { ARGS = TArgs::ARGS };
260917
260917
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
260918
 
  static const int JPID = 26223;
 
260918
  static const int JPID = 30629;
260919
260919
  static const AC::JPType JPTYPE = (AC::JPType)4;
260920
260920
  struct Res {
260921
260921
    typedef TResult Type;
261035
261035
  typedef TTarget Target;
261036
261036
  enum { ARGS = TArgs::ARGS };
261037
261037
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261038
 
  static const int JPID = 26224;
 
261038
  static const int JPID = 30630;
261039
261039
  static const AC::JPType JPTYPE = (AC::JPType)4;
261040
261040
  struct Res {
261041
261041
    typedef TResult Type;
261106
261106
  typedef TTarget Target;
261107
261107
  enum { ARGS = TArgs::ARGS };
261108
261108
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261109
 
  static const int JPID = 26225;
 
261109
  static const int JPID = 30631;
261110
261110
  static const AC::JPType JPTYPE = (AC::JPType)4;
261111
261111
  struct Res {
261112
261112
    typedef TResult Type;
261222
261222
  typedef TTarget Target;
261223
261223
  enum { ARGS = TArgs::ARGS };
261224
261224
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261225
 
  static const int JPID = 26226;
 
261225
  static const int JPID = 30632;
261226
261226
  static const AC::JPType JPTYPE = (AC::JPType)4;
261227
261227
  struct Res {
261228
261228
    typedef TResult Type;
261292
261292
  typedef TTarget Target;
261293
261293
  enum { ARGS = TArgs::ARGS };
261294
261294
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261295
 
  static const int JPID = 25941;
 
261295
  static const int JPID = 30347;
261296
261296
  static const AC::JPType JPTYPE = (AC::JPType)4;
261297
261297
  struct Res {
261298
261298
    typedef TResult Type;
261357
261357
  typedef TTarget Target;
261358
261358
  enum { ARGS = TArgs::ARGS };
261359
261359
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261360
 
  static const int JPID = 26227;
 
261360
  static const int JPID = 30633;
261361
261361
  static const AC::JPType JPTYPE = (AC::JPType)4;
261362
261362
  struct Res {
261363
261363
    typedef TResult Type;
261516
261516
  typedef TTarget Target;
261517
261517
  enum { ARGS = TArgs::ARGS };
261518
261518
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261519
 
  static const int JPID = 26228;
 
261519
  static const int JPID = 30634;
261520
261520
  static const AC::JPType JPTYPE = (AC::JPType)4;
261521
261521
  struct Res {
261522
261522
    typedef TResult Type;
261589
261589
  typedef TTarget Target;
261590
261590
  enum { ARGS = TArgs::ARGS };
261591
261591
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261592
 
  static const int JPID = 26229;
 
261592
  static const int JPID = 30635;
261593
261593
  static const AC::JPType JPTYPE = (AC::JPType)4;
261594
261594
  struct Res {
261595
261595
    typedef TResult Type;
261658
261658
  typedef TTarget Target;
261659
261659
  enum { ARGS = TArgs::ARGS };
261660
261660
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261661
 
  static const int JPID = 26230;
 
261661
  static const int JPID = 30636;
261662
261662
  static const AC::JPType JPTYPE = (AC::JPType)4;
261663
261663
  struct Res {
261664
261664
    typedef TResult Type;
261722
261722
  typedef TTarget Target;
261723
261723
  enum { ARGS = TArgs::ARGS };
261724
261724
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261725
 
  static const int JPID = 25952;
 
261725
  static const int JPID = 30358;
261726
261726
  static const AC::JPType JPTYPE = (AC::JPType)4;
261727
261727
  struct Res {
261728
261728
    typedef TResult Type;
261817
261817
  typedef TTarget Target;
261818
261818
  enum { ARGS = TArgs::ARGS };
261819
261819
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261820
 
  static const int JPID = 26231;
 
261820
  static const int JPID = 30637;
261821
261821
  static const AC::JPType JPTYPE = (AC::JPType)4;
261822
261822
  struct Res {
261823
261823
    typedef TResult Type;
261881
261881
  typedef TTarget Target;
261882
261882
  enum { ARGS = TArgs::ARGS };
261883
261883
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261884
 
  static const int JPID = 25953;
 
261884
  static const int JPID = 30359;
261885
261885
  static const AC::JPType JPTYPE = (AC::JPType)4;
261886
261886
  struct Res {
261887
261887
    typedef TResult Type;
261933
261933
  typedef TTarget Target;
261934
261934
  enum { ARGS = TArgs::ARGS };
261935
261935
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
261936
 
  static const int JPID = 26232;
 
261936
  static const int JPID = 30638;
261937
261937
  static const AC::JPType JPTYPE = (AC::JPType)4;
261938
261938
  struct Res {
261939
261939
    typedef TResult Type;
261997
261997
  typedef TTarget Target;
261998
261998
  enum { ARGS = TArgs::ARGS };
261999
261999
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262000
 
  static const int JPID = 25956;
 
262000
  static const int JPID = 30362;
262001
262001
  static const AC::JPType JPTYPE = (AC::JPType)4;
262002
262002
  struct Res {
262003
262003
    typedef TResult Type;
262051
262051
  typedef TTarget Target;
262052
262052
  enum { ARGS = TArgs::ARGS };
262053
262053
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262054
 
  static const int JPID = 26233;
 
262054
  static const int JPID = 30639;
262055
262055
  static const AC::JPType JPTYPE = (AC::JPType)4;
262056
262056
  struct Res {
262057
262057
    typedef TResult Type;
262121
262121
  typedef TTarget Target;
262122
262122
  enum { ARGS = TArgs::ARGS };
262123
262123
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262124
 
  static const int JPID = 25960;
 
262124
  static const int JPID = 30366;
262125
262125
  static const AC::JPType JPTYPE = (AC::JPType)4;
262126
262126
  struct Res {
262127
262127
    typedef TResult Type;
262169
262169
  typedef TTarget Target;
262170
262170
  enum { ARGS = TArgs::ARGS };
262171
262171
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262172
 
  static const int JPID = 25961;
 
262172
  static const int JPID = 30367;
262173
262173
  static const AC::JPType JPTYPE = (AC::JPType)4;
262174
262174
  struct Res {
262175
262175
    typedef TResult Type;
262217
262217
  typedef TTarget Target;
262218
262218
  enum { ARGS = TArgs::ARGS };
262219
262219
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262220
 
  static const int JPID = 25976;
 
262220
  static const int JPID = 30382;
262221
262221
  static const AC::JPType JPTYPE = (AC::JPType)4;
262222
262222
  struct Res {
262223
262223
    typedef TResult Type;
262265
262265
  typedef TTarget Target;
262266
262266
  enum { ARGS = TArgs::ARGS };
262267
262267
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262268
 
  static const int JPID = 25977;
 
262268
  static const int JPID = 30383;
262269
262269
  static const AC::JPType JPTYPE = (AC::JPType)4;
262270
262270
  struct Res {
262271
262271
    typedef TResult Type;
262339
262339
  typedef TTarget Target;
262340
262340
  enum { ARGS = TArgs::ARGS };
262341
262341
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262342
 
  static const int JPID = 26234;
 
262342
  static const int JPID = 30640;
262343
262343
  static const AC::JPType JPTYPE = (AC::JPType)4;
262344
262344
  struct Res {
262345
262345
    typedef TResult Type;
262404
262404
  typedef TTarget Target;
262405
262405
  enum { ARGS = TArgs::ARGS };
262406
262406
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262407
 
  static const int JPID = 25982;
 
262407
  static const int JPID = 30388;
262408
262408
  static const AC::JPType JPTYPE = (AC::JPType)4;
262409
262409
  struct Res {
262410
262410
    typedef TResult Type;
262511
262511
  typedef TTarget Target;
262512
262512
  enum { ARGS = TArgs::ARGS };
262513
262513
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262514
 
  static const int JPID = 26236;
 
262514
  static const int JPID = 30642;
262515
262515
  static const AC::JPType JPTYPE = (AC::JPType)4;
262516
262516
  struct Res {
262517
262517
    typedef TResult Type;
262581
262581
  typedef TTarget Target;
262582
262582
  enum { ARGS = TArgs::ARGS };
262583
262583
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262584
 
  static const int JPID = 26237;
 
262584
  static const int JPID = 30643;
262585
262585
  static const AC::JPType JPTYPE = (AC::JPType)4;
262586
262586
  struct Res {
262587
262587
    typedef TResult Type;
262650
262650
  typedef TTarget Target;
262651
262651
  enum { ARGS = TArgs::ARGS };
262652
262652
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262653
 
  static const int JPID = 26239;
 
262653
  static const int JPID = 30645;
262654
262654
  static const AC::JPType JPTYPE = (AC::JPType)4;
262655
262655
  struct Res {
262656
262656
    typedef TResult Type;
262719
262719
  typedef TTarget Target;
262720
262720
  enum { ARGS = TArgs::ARGS };
262721
262721
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262722
 
  static const int JPID = 26240;
 
262722
  static const int JPID = 30646;
262723
262723
  static const AC::JPType JPTYPE = (AC::JPType)4;
262724
262724
  struct Res {
262725
262725
    typedef TResult Type;
262791
262791
  typedef TTarget Target;
262792
262792
  enum { ARGS = TArgs::ARGS };
262793
262793
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262794
 
  static const int JPID = 26241;
 
262794
  static const int JPID = 30647;
262795
262795
  static const AC::JPType JPTYPE = (AC::JPType)4;
262796
262796
  struct Res {
262797
262797
    typedef TResult Type;
262915
262915
  typedef TTarget Target;
262916
262916
  enum { ARGS = TArgs::ARGS };
262917
262917
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262918
 
  static const int JPID = 25851;
 
262918
  static const int JPID = 30257;
262919
262919
  static const AC::JPType JPTYPE = (AC::JPType)4;
262920
262920
  struct Res {
262921
262921
    typedef TResult Type;
262987
262987
  typedef TTarget Target;
262988
262988
  enum { ARGS = TArgs::ARGS };
262989
262989
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
262990
 
  static const int JPID = 26242;
 
262990
  static const int JPID = 30648;
262991
262991
  static const AC::JPType JPTYPE = (AC::JPType)4;
262992
262992
  struct Res {
262993
262993
    typedef TResult Type;
263051
263051
  typedef TTarget Target;
263052
263052
  enum { ARGS = TArgs::ARGS };
263053
263053
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263054
 
  static const int JPID = 26033;
 
263054
  static const int JPID = 30439;
263055
263055
  static const AC::JPType JPTYPE = (AC::JPType)4;
263056
263056
  struct Res {
263057
263057
    typedef TResult Type;
263097
263097
  typedef TTarget Target;
263098
263098
  enum { ARGS = TArgs::ARGS };
263099
263099
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263100
 
  static const int JPID = 26034;
 
263100
  static const int JPID = 30440;
263101
263101
  static const AC::JPType JPTYPE = (AC::JPType)4;
263102
263102
  struct Res {
263103
263103
    typedef TResult Type;
263215
263215
  typedef TTarget Target;
263216
263216
  enum { ARGS = TArgs::ARGS };
263217
263217
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263218
 
  static const int JPID = 26243;
 
263218
  static const int JPID = 30649;
263219
263219
  static const AC::JPType JPTYPE = (AC::JPType)4;
263220
263220
  struct Res {
263221
263221
    typedef TResult Type;
263286
263286
  typedef TTarget Target;
263287
263287
  enum { ARGS = TArgs::ARGS };
263288
263288
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263289
 
  static const int JPID = 26238;
 
263289
  static const int JPID = 30644;
263290
263290
  static const AC::JPType JPTYPE = (AC::JPType)4;
263291
263291
  struct Res {
263292
263292
    typedef TResult Type;
263355
263355
  typedef TTarget Target;
263356
263356
  enum { ARGS = TArgs::ARGS };
263357
263357
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263358
 
  static const int JPID = 26244;
 
263358
  static const int JPID = 30650;
263359
263359
  static const AC::JPType JPTYPE = (AC::JPType)4;
263360
263360
  struct Res {
263361
263361
    typedef TResult Type;
263424
263424
  typedef TTarget Target;
263425
263425
  enum { ARGS = TArgs::ARGS };
263426
263426
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263427
 
  static const int JPID = 26245;
 
263427
  static const int JPID = 30651;
263428
263428
  static const AC::JPType JPTYPE = (AC::JPType)4;
263429
263429
  struct Res {
263430
263430
    typedef TResult Type;
263488
263488
  typedef TTarget Target;
263489
263489
  enum { ARGS = TArgs::ARGS };
263490
263490
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263491
 
  static const int JPID = 26053;
 
263491
  static const int JPID = 30459;
263492
263492
  static const AC::JPType JPTYPE = (AC::JPType)4;
263493
263493
  struct Res {
263494
263494
    typedef TResult Type;
263536
263536
  typedef TTarget Target;
263537
263537
  enum { ARGS = TArgs::ARGS };
263538
263538
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263539
 
  static const int JPID = 26051;
 
263539
  static const int JPID = 30457;
263540
263540
  static const AC::JPType JPTYPE = (AC::JPType)4;
263541
263541
  struct Res {
263542
263542
    typedef TResult Type;
263602
263602
  typedef TTarget Target;
263603
263603
  enum { ARGS = TArgs::ARGS };
263604
263604
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263605
 
  static const int JPID = 26246;
 
263605
  static const int JPID = 30652;
263606
263606
  static const AC::JPType JPTYPE = (AC::JPType)4;
263607
263607
  struct Res {
263608
263608
    typedef TResult Type;
263677
263677
  typedef TTarget Target;
263678
263678
  enum { ARGS = TArgs::ARGS };
263679
263679
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263680
 
  static const int JPID = 26247;
 
263680
  static const int JPID = 30653;
263681
263681
  static const AC::JPType JPTYPE = (AC::JPType)4;
263682
263682
  struct Res {
263683
263683
    typedef TResult Type;
263746
263746
  typedef TTarget Target;
263747
263747
  enum { ARGS = TArgs::ARGS };
263748
263748
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263749
 
  static const int JPID = 26248;
 
263749
  static const int JPID = 30654;
263750
263750
  static const AC::JPType JPTYPE = (AC::JPType)4;
263751
263751
  struct Res {
263752
263752
    typedef TResult Type;
263810
263810
  typedef TTarget Target;
263811
263811
  enum { ARGS = TArgs::ARGS };
263812
263812
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263813
 
  static const int JPID = 26060;
 
263813
  static const int JPID = 30466;
263814
263814
  static const AC::JPType JPTYPE = (AC::JPType)4;
263815
263815
  struct Res {
263816
263816
    typedef TResult Type;
263860
263860
  typedef TTarget Target;
263861
263861
  enum { ARGS = TArgs::ARGS };
263862
263862
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263863
 
  static const int JPID = 26249;
 
263863
  static const int JPID = 30655;
263864
263864
  static const AC::JPType JPTYPE = (AC::JPType)4;
263865
263865
  struct Res {
263866
263866
    typedef TResult Type;
263924
263924
  typedef TTarget Target;
263925
263925
  enum { ARGS = TArgs::ARGS };
263926
263926
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263927
 
  static const int JPID = 26063;
 
263927
  static const int JPID = 30469;
263928
263928
  static const AC::JPType JPTYPE = (AC::JPType)4;
263929
263929
  struct Res {
263930
263930
    typedef TResult Type;
263977
263977
  typedef TTarget Target;
263978
263978
  enum { ARGS = TArgs::ARGS };
263979
263979
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
263980
 
  static const int JPID = 26250;
 
263980
  static const int JPID = 30656;
263981
263981
  static const AC::JPType JPTYPE = (AC::JPType)4;
263982
263982
  struct Res {
263983
263983
    typedef TResult Type;
264041
264041
  typedef TTarget Target;
264042
264042
  enum { ARGS = TArgs::ARGS };
264043
264043
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264044
 
  static const int JPID = 26067;
 
264044
  static const int JPID = 30473;
264045
264045
  static const AC::JPType JPTYPE = (AC::JPType)4;
264046
264046
  struct Res {
264047
264047
    typedef TResult Type;
264091
264091
  typedef TTarget Target;
264092
264092
  enum { ARGS = TArgs::ARGS };
264093
264093
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264094
 
  static const int JPID = 26251;
 
264094
  static const int JPID = 30657;
264095
264095
  static const AC::JPType JPTYPE = (AC::JPType)4;
264096
264096
  struct Res {
264097
264097
    typedef TResult Type;
264155
264155
  typedef TTarget Target;
264156
264156
  enum { ARGS = TArgs::ARGS };
264157
264157
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264158
 
  static const int JPID = 26070;
 
264158
  static const int JPID = 30476;
264159
264159
  static const AC::JPType JPTYPE = (AC::JPType)4;
264160
264160
  struct Res {
264161
264161
    typedef TResult Type;
264208
264208
  typedef TTarget Target;
264209
264209
  enum { ARGS = TArgs::ARGS };
264210
264210
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264211
 
  static const int JPID = 26252;
 
264211
  static const int JPID = 30658;
264212
264212
  static const AC::JPType JPTYPE = (AC::JPType)4;
264213
264213
  struct Res {
264214
264214
    typedef TResult Type;
264272
264272
  typedef TTarget Target;
264273
264273
  enum { ARGS = TArgs::ARGS };
264274
264274
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264275
 
  static const int JPID = 26074;
 
264275
  static const int JPID = 30480;
264276
264276
  static const AC::JPType JPTYPE = (AC::JPType)4;
264277
264277
  struct Res {
264278
264278
    typedef TResult Type;
264322
264322
  typedef TTarget Target;
264323
264323
  enum { ARGS = TArgs::ARGS };
264324
264324
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264325
 
  static const int JPID = 26253;
 
264325
  static const int JPID = 30659;
264326
264326
  static const AC::JPType JPTYPE = (AC::JPType)4;
264327
264327
  struct Res {
264328
264328
    typedef TResult Type;
264386
264386
  typedef TTarget Target;
264387
264387
  enum { ARGS = TArgs::ARGS };
264388
264388
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264389
 
  static const int JPID = 26077;
 
264389
  static const int JPID = 30483;
264390
264390
  static const AC::JPType JPTYPE = (AC::JPType)4;
264391
264391
  struct Res {
264392
264392
    typedef TResult Type;
264439
264439
  typedef TTarget Target;
264440
264440
  enum { ARGS = TArgs::ARGS };
264441
264441
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264442
 
  static const int JPID = 26254;
 
264442
  static const int JPID = 30660;
264443
264443
  static const AC::JPType JPTYPE = (AC::JPType)4;
264444
264444
  struct Res {
264445
264445
    typedef TResult Type;
264507
264507
  typedef TTarget Target;
264508
264508
  enum { ARGS = TArgs::ARGS };
264509
264509
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264510
 
  static const int JPID = 26255;
 
264510
  static const int JPID = 30661;
264511
264511
  static const AC::JPType JPTYPE = (AC::JPType)4;
264512
264512
  struct Res {
264513
264513
    typedef TResult Type;
264577
264577
  typedef TTarget Target;
264578
264578
  enum { ARGS = TArgs::ARGS };
264579
264579
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264580
 
  static const int JPID = 26256;
 
264580
  static const int JPID = 30662;
264581
264581
  static const AC::JPType JPTYPE = (AC::JPType)4;
264582
264582
  struct Res {
264583
264583
    typedef TResult Type;
264691
264691
  typedef TTarget Target;
264692
264692
  enum { ARGS = TArgs::ARGS };
264693
264693
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264694
 
  static const int JPID = 26257;
 
264694
  static const int JPID = 30663;
264695
264695
  static const AC::JPType JPTYPE = (AC::JPType)4;
264696
264696
  struct Res {
264697
264697
    typedef TResult Type;
264811
264811
  typedef TTarget Target;
264812
264812
  enum { ARGS = TArgs::ARGS };
264813
264813
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264814
 
  static const int JPID = 26258;
 
264814
  static const int JPID = 30664;
264815
264815
  static const AC::JPType JPTYPE = (AC::JPType)4;
264816
264816
  struct Res {
264817
264817
    typedef TResult Type;
264875
264875
  typedef TTarget Target;
264876
264876
  enum { ARGS = TArgs::ARGS };
264877
264877
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264878
 
  static const int JPID = 26099;
 
264878
  static const int JPID = 30505;
264879
264879
  static const AC::JPType JPTYPE = (AC::JPType)4;
264880
264880
  struct Res {
264881
264881
    typedef TResult Type;
264976
264976
  typedef TTarget Target;
264977
264977
  enum { ARGS = TArgs::ARGS };
264978
264978
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
264979
 
  static const int JPID = 26259;
 
264979
  static const int JPID = 30665;
264980
264980
  static const AC::JPType JPTYPE = (AC::JPType)4;
264981
264981
  struct Res {
264982
264982
    typedef TResult Type;
265095
265095
  typedef TTarget Target;
265096
265096
  enum { ARGS = TArgs::ARGS };
265097
265097
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265098
 
  static const int JPID = 26260;
 
265098
  static const int JPID = 30666;
265099
265099
  static const AC::JPType JPTYPE = (AC::JPType)4;
265100
265100
  struct Res {
265101
265101
    typedef TResult Type;
265174
265174
  typedef TTarget Target;
265175
265175
  enum { ARGS = TArgs::ARGS };
265176
265176
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265177
 
  static const int JPID = 26261;
 
265177
  static const int JPID = 30667;
265178
265178
  static const AC::JPType JPTYPE = (AC::JPType)4;
265179
265179
  struct Res {
265180
265180
    typedef TResult Type;
265291
265291
  typedef TTarget Target;
265292
265292
  enum { ARGS = TArgs::ARGS };
265293
265293
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265294
 
  static const int JPID = 26262;
 
265294
  static const int JPID = 30668;
265295
265295
  static const AC::JPType JPTYPE = (AC::JPType)4;
265296
265296
  struct Res {
265297
265297
    typedef TResult Type;
265416
265416
  typedef TTarget Target;
265417
265417
  enum { ARGS = TArgs::ARGS };
265418
265418
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265419
 
  static const int JPID = 26263;
 
265419
  static const int JPID = 30669;
265420
265420
  static const AC::JPType JPTYPE = (AC::JPType)4;
265421
265421
  struct Res {
265422
265422
    typedef TResult Type;
265480
265480
  typedef TTarget Target;
265481
265481
  enum { ARGS = TArgs::ARGS };
265482
265482
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265483
 
  static const int JPID = 26126;
 
265483
  static const int JPID = 30532;
265484
265484
  static const AC::JPType JPTYPE = (AC::JPType)4;
265485
265485
  struct Res {
265486
265486
    typedef TResult Type;
265584
265584
  typedef TTarget Target;
265585
265585
  enum { ARGS = TArgs::ARGS };
265586
265586
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265587
 
  static const int JPID = 26264;
 
265587
  static const int JPID = 30670;
265588
265588
  static const AC::JPType JPTYPE = (AC::JPType)4;
265589
265589
  struct Res {
265590
265590
    typedef TResult Type;
265658
265658
  typedef TTarget Target;
265659
265659
  enum { ARGS = TArgs::ARGS };
265660
265660
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265661
 
  static const int JPID = 26265;
 
265661
  static const int JPID = 30671;
265662
265662
  static const AC::JPType JPTYPE = (AC::JPType)4;
265663
265663
  struct Res {
265664
265664
    typedef TResult Type;
265777
265777
  typedef TTarget Target;
265778
265778
  enum { ARGS = TArgs::ARGS };
265779
265779
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265780
 
  static const int JPID = 26266;
 
265780
  static const int JPID = 30672;
265781
265781
  static const AC::JPType JPTYPE = (AC::JPType)4;
265782
265782
  struct Res {
265783
265783
    typedef TResult Type;
265841
265841
  typedef TTarget Target;
265842
265842
  enum { ARGS = TArgs::ARGS };
265843
265843
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265844
 
  static const int JPID = 26267;
 
265844
  static const int JPID = 30673;
265845
265845
  static const AC::JPType JPTYPE = (AC::JPType)4;
265846
265846
  struct Res {
265847
265847
    typedef TResult Type;
265923
265923
  typedef TTarget Target;
265924
265924
  enum { ARGS = TArgs::ARGS };
265925
265925
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
265926
 
  static const int JPID = 26274;
 
265926
  static const int JPID = 30680;
265927
265927
  static const AC::JPType JPTYPE = (AC::JPType)4;
265928
265928
  struct Res {
265929
265929
    typedef TResult Type;
266153
266153
  typedef TTarget Target;
266154
266154
  enum { ARGS = TArgs::ARGS };
266155
266155
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266156
 
  static const int JPID = 26137;
 
266156
  static const int JPID = 30543;
266157
266157
  static const AC::JPType JPTYPE = (AC::JPType)4;
266158
266158
  struct Res {
266159
266159
    typedef TResult Type;
266193
266193
  typedef TTarget Target;
266194
266194
  enum { ARGS = TArgs::ARGS };
266195
266195
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266196
 
  static const int JPID = 26135;
 
266196
  static const int JPID = 30541;
266197
266197
  static const AC::JPType JPTYPE = (AC::JPType)4;
266198
266198
  struct Res {
266199
266199
    typedef TResult Type;
266246
266246
  typedef TTarget Target;
266247
266247
  enum { ARGS = TArgs::ARGS };
266248
266248
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266249
 
  static const int JPID = 26315;
 
266249
  static const int JPID = 30721;
266250
266250
  static const AC::JPType JPTYPE = (AC::JPType)4;
266251
266251
  struct Res {
266252
266252
    typedef TResult Type;
266310
266310
  typedef TTarget Target;
266311
266311
  enum { ARGS = TArgs::ARGS };
266312
266312
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266313
 
  static const int JPID = 26138;
 
266313
  static const int JPID = 30544;
266314
266314
  static const AC::JPType JPTYPE = (AC::JPType)4;
266315
266315
  struct Res {
266316
266316
    typedef TResult Type;
266374
266374
  typedef TTarget Target;
266375
266375
  enum { ARGS = TArgs::ARGS };
266376
266376
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266377
 
  static const int JPID = 26316;
 
266377
  static const int JPID = 30722;
266378
266378
  static const AC::JPType JPTYPE = (AC::JPType)4;
266379
266379
  struct Res {
266380
266380
    typedef TResult Type;
266521
266521
  typedef TTarget Target;
266522
266522
  enum { ARGS = TArgs::ARGS };
266523
266523
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266524
 
  static const int JPID = 26325;
 
266524
  static const int JPID = 30731;
266525
266525
  static const AC::JPType JPTYPE = (AC::JPType)4;
266526
266526
  struct Res {
266527
266527
    typedef TResult Type;
266648
266648
  typedef TTarget Target;
266649
266649
  enum { ARGS = TArgs::ARGS };
266650
266650
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266651
 
  static const int JPID = 26335;
 
266651
  static const int JPID = 30741;
266652
266652
  static const AC::JPType JPTYPE = (AC::JPType)4;
266653
266653
  struct Res {
266654
266654
    typedef TResult Type;
266688
266688
  typedef TTarget Target;
266689
266689
  enum { ARGS = TArgs::ARGS };
266690
266690
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266691
 
  static const int JPID = 26349;
 
266691
  static const int JPID = 30755;
266692
266692
  static const AC::JPType JPTYPE = (AC::JPType)4;
266693
266693
  struct Res {
266694
266694
    typedef TResult Type;
266952
266952
  typedef TTarget Target;
266953
266953
  enum { ARGS = TArgs::ARGS };
266954
266954
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
266955
 
  static const int JPID = 26148;
 
266955
  static const int JPID = 30554;
266956
266956
  static const AC::JPType JPTYPE = (AC::JPType)4;
266957
266957
  struct Res {
266958
266958
    typedef TResult Type;
267055
267055
  typedef TTarget Target;
267056
267056
  enum { ARGS = TArgs::ARGS };
267057
267057
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
267058
 
  static const int JPID = 26370;
 
267058
  static const int JPID = 30776;
267059
267059
  static const AC::JPType JPTYPE = (AC::JPType)4;
267060
267060
  struct Res {
267061
267061
    typedef TResult Type;
267119
267119
  typedef TTarget Target;
267120
267120
  enum { ARGS = TArgs::ARGS };
267121
267121
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
267122
 
  static const int JPID = 26149;
 
267122
  static const int JPID = 30555;
267123
267123
  static const AC::JPType JPTYPE = (AC::JPType)4;
267124
267124
  struct Res {
267125
267125
    typedef TResult Type;
267164
267164
  typedef TTarget Target;
267165
267165
  enum { ARGS = TArgs::ARGS };
267166
267166
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
267167
 
  static const int JPID = 26150;
 
267167
  static const int JPID = 30556;
267168
267168
  static const AC::JPType JPTYPE = (AC::JPType)4;
267169
267169
  struct Res {
267170
267170
    typedef TResult Type;
267210
267210
  typedef TTarget Target;
267211
267211
  enum { ARGS = TArgs::ARGS };
267212
267212
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
267213
 
  static const int JPID = 26371;
 
267213
  static const int JPID = 30777;
267214
267214
  static const AC::JPType JPTYPE = (AC::JPType)4;
267215
267215
  struct Res {
267216
267216
    typedef TResult Type;
267572
267572
  typedef TTarget Target;
267573
267573
  enum { ARGS = TArgs::ARGS };
267574
267574
  template <int I> struct Arg : AC::Arg<TArgs, I> {};
267575
 
  static const int JPID = 26424;
 
267575
  static const int JPID = 30830;
267576
267576
  static const AC::JPType JPTYPE = (AC::JPType)4;
267577
267577
  struct Res {
267578
267578
    typedef TResult Type;