#include "gtest/gtest.h"

TEST(TestMath, Add0)
{
	EXPECT_EQ(0+0,0);
}

  

TEST(TestMath, Add1)
{
	EXPECT_EQ(1+1,2);
}

  

TEST(TestMath, Add2)
{
	EXPECT_EQ(2+2,4);
}

  

TEST(TestMath, Add3)
{
	EXPECT_EQ(3+3,6);
}

  

TEST(TestMath, Add4)
{
	EXPECT_EQ(4+4,8);
}

  

TEST(TestMath, Add5)
{
	EXPECT_EQ(5+5,10);
}

  

TEST(TestMath, Add6)
{
	EXPECT_EQ(6+6,12);
}

  

TEST(TestMath, Add7)
{
	EXPECT_EQ(7+7,14);
}

  

TEST(TestMath, Add8)
{
	EXPECT_EQ(8+8,16);
}

  

TEST(TestMath, Add9)
{
	EXPECT_EQ(9+9,18);
}

  

TEST(TestMath, Add10)
{
	EXPECT_EQ(10+10,20);
}

  

TEST(TestMath, Add11)
{
	EXPECT_EQ(11+11,22);
}

  

TEST(TestMath, Add12)
{
	EXPECT_EQ(12+12,24);
}

  

TEST(TestMath, Add13)
{
	EXPECT_EQ(13+13,26);
}

  

TEST(TestMath, Add14)
{
	EXPECT_EQ(14+14,28);
}

  

TEST(TestMath, Add15)
{
	EXPECT_EQ(15+15,30);
}

  

TEST(TestMath, Add16)
{
	EXPECT_EQ(16+16,32);
}

  

TEST(TestMath, Add17)
{
	EXPECT_EQ(17+17,34);
}

  

TEST(TestMath, Add18)
{
	EXPECT_EQ(18+18,36);
}

  

TEST(TestMath, Add19)
{
	EXPECT_EQ(19+19,38);
}

  

TEST(TestMath, Add20)
{
	EXPECT_EQ(20+20,40);
}

  

TEST(TestMath, Add21)
{
	EXPECT_EQ(21+21,42);
}

  

TEST(TestMath, Add22)
{
	EXPECT_EQ(22+22,44);
}

  

TEST(TestMath, Add23)
{
	EXPECT_EQ(23+23,46);
}

  

TEST(TestMath, Add24)
{
	EXPECT_EQ(24+24,48);
}

  

TEST(TestMath, Add25)
{
	EXPECT_EQ(25+25,50);
}

  

TEST(TestMath, Add26)
{
	EXPECT_EQ(26+26,52);
}

  

TEST(TestMath, Add27)
{
	EXPECT_EQ(27+27,54);
}

  

TEST(TestMath, Add28)
{
	EXPECT_EQ(28+28,56);
}

  

TEST(TestMath, Add29)
{
	EXPECT_EQ(29+29,58);
}

  

TEST(TestMath, Add30)
{
	EXPECT_EQ(30+30,60);
}

  

TEST(TestMath, Add31)
{
	EXPECT_EQ(31+31,62);
}

  

TEST(TestMath, Add32)
{
	EXPECT_EQ(32+32,64);
}

  

TEST(TestMath, Add33)
{
	EXPECT_EQ(33+33,66);
}

  

TEST(TestMath, Add34)
{
	EXPECT_EQ(34+34,68);
}

  

TEST(TestMath, Add35)
{
	EXPECT_EQ(35+35,70);
}

  

TEST(TestMath, Add36)
{
	EXPECT_EQ(36+36,72);
}

  

TEST(TestMath, Add37)
{
	EXPECT_EQ(37+37,74);
}

  

TEST(TestMath, Add38)
{
	EXPECT_EQ(38+38,76);
}

  

TEST(TestMath, Add39)
{
	EXPECT_EQ(39+39,78);
}

  

TEST(TestMath, Add40)
{
	EXPECT_EQ(40+40,80);
}

  

TEST(TestMath, Add41)
{
	EXPECT_EQ(41+41,82);
}

  

TEST(TestMath, Add42)
{
	EXPECT_EQ(42+42,84);
}

  

TEST(TestMath, Add43)
{
	EXPECT_EQ(43+43,86);
}

  

TEST(TestMath, Add44)
{
	EXPECT_EQ(44+44,88);
}

  

TEST(TestMath, Add45)
{
	EXPECT_EQ(45+45,90);
}

  

TEST(TestMath, Add46)
{
	EXPECT_EQ(46+46,92);
}

  

TEST(TestMath, Add47)
{
	EXPECT_EQ(47+47,94);
}

  

TEST(TestMath, Add48)
{
	EXPECT_EQ(48+48,96);
}

  

TEST(TestMath, Add49)
{
	EXPECT_EQ(49+49,98);
}

  

TEST(TestMath, Add50)
{
	EXPECT_EQ(50+50,100);
}

  

TEST(TestMath, Add51)
{
	EXPECT_EQ(51+51,102);
}

  

TEST(TestMath, Add52)
{
	EXPECT_EQ(52+52,104);
}

  

TEST(TestMath, Add53)
{
	EXPECT_EQ(53+53,106);
}

  

TEST(TestMath, Add54)
{
	EXPECT_EQ(54+54,108);
}

  

TEST(TestMath, Add55)
{
	EXPECT_EQ(55+55,110);
}

  

TEST(TestMath, Add56)
{
	EXPECT_EQ(56+56,112);
}

  

TEST(TestMath, Add57)
{
	EXPECT_EQ(57+57,114);
}

  

TEST(TestMath, Add58)
{
	EXPECT_EQ(58+58,116);
}

  

TEST(TestMath, Add59)
{
	EXPECT_EQ(59+59,118);
}

  

TEST(TestMath, Add60)
{
	EXPECT_EQ(60+60,120);
}

  

TEST(TestMath, Add61)
{
	EXPECT_EQ(61+61,122);
}

  

TEST(TestMath, Add62)
{
	EXPECT_EQ(62+62,124);
}

  

TEST(TestMath, Add63)
{
	EXPECT_EQ(63+63,126);
}

  

TEST(TestMath, Add64)
{
	EXPECT_EQ(64+64,128);
}

  

TEST(TestMath, Add65)
{
	EXPECT_EQ(65+65,130);
}

  

TEST(TestMath, Add66)
{
	EXPECT_EQ(66+66,132);
}

  

TEST(TestMath, Add67)
{
	EXPECT_EQ(67+67,134);
}

  

TEST(TestMath, Add68)
{
	EXPECT_EQ(68+68,136);
}

  

TEST(TestMath, Add69)
{
	EXPECT_EQ(69+69,138);
}

  

TEST(TestMath, Add70)
{
	EXPECT_EQ(70+70,140);
}

  

TEST(TestMath, Add71)
{
	EXPECT_EQ(71+71,142);
}

  

TEST(TestMath, Add72)
{
	EXPECT_EQ(72+72,144);
}

  

TEST(TestMath, Add73)
{
	EXPECT_EQ(73+73,146);
}

  

TEST(TestMath, Add74)
{
	EXPECT_EQ(74+74,148);
}

  

TEST(TestMath, Add75)
{
	EXPECT_EQ(75+75,150);
}

  

TEST(TestMath, Add76)
{
	EXPECT_EQ(76+76,152);
}

  

TEST(TestMath, Add77)
{
	EXPECT_EQ(77+77,154);
}

  

TEST(TestMath, Add78)
{
	EXPECT_EQ(78+78,156);
}

  

TEST(TestMath, Add79)
{
	EXPECT_EQ(79+79,158);
}

  

TEST(TestMath, Add80)
{
	EXPECT_EQ(80+80,160);
}

  

TEST(TestMath, Add81)
{
	EXPECT_EQ(81+81,162);
}

  

TEST(TestMath, Add82)
{
	EXPECT_EQ(82+82,164);
}

  

TEST(TestMath, Add83)
{
	EXPECT_EQ(83+83,166);
}

  

TEST(TestMath, Add84)
{
	EXPECT_EQ(84+84,168);
}

  

TEST(TestMath, Add85)
{
	EXPECT_EQ(85+85,170);
}

  

TEST(TestMath, Add86)
{
	EXPECT_EQ(86+86,172);
}

  

TEST(TestMath, Add87)
{
	EXPECT_EQ(87+87,174);
}

  

TEST(TestMath, Add88)
{
	EXPECT_EQ(88+88,176);
}

  

TEST(TestMath, Add89)
{
	EXPECT_EQ(89+89,178);
}

  

TEST(TestMath, Add90)
{
	EXPECT_EQ(90+90,180);
}

  

TEST(TestMath, Add91)
{
	EXPECT_EQ(91+91,182);
}

  

TEST(TestMath, Add92)
{
	EXPECT_EQ(92+92,184);
}

  

TEST(TestMath, Add93)
{
	EXPECT_EQ(93+93,186);
}

  

TEST(TestMath, Add94)
{
	EXPECT_EQ(94+94,188);
}

  

TEST(TestMath, Add95)
{
	EXPECT_EQ(95+95,190);
}

  

TEST(TestMath, Add96)
{
	EXPECT_EQ(96+96,192);
}

  

TEST(TestMath, Add97)
{
	EXPECT_EQ(97+97,194);
}

  

TEST(TestMath, Add98)
{
	EXPECT_EQ(98+98,196);
}

  

TEST(TestMath, Add99)
{
	EXPECT_EQ(99+99,198);
}

  

TEST(TestMath, Add100)
{
	EXPECT_EQ(100+100,200);
}

  

TEST(TestMath, Add101)
{
	EXPECT_EQ(101+101,202);
}

  

TEST(TestMath, Add102)
{
	EXPECT_EQ(102+102,204);
}

  

TEST(TestMath, Add103)
{
	EXPECT_EQ(103+103,206);
}

  

TEST(TestMath, Add104)
{
	EXPECT_EQ(104+104,208);
}

  

TEST(TestMath, Add105)
{
	EXPECT_EQ(105+105,210);
}

  

TEST(TestMath, Add106)
{
	EXPECT_EQ(106+106,212);
}

  

TEST(TestMath, Add107)
{
	EXPECT_EQ(107+107,214);
}

  

TEST(TestMath, Add108)
{
	EXPECT_EQ(108+108,216);
}

  

TEST(TestMath, Add109)
{
	EXPECT_EQ(109+109,218);
}

  

TEST(TestMath, Add110)
{
	EXPECT_EQ(110+110,220);
}

  

TEST(TestMath, Add111)
{
	EXPECT_EQ(111+111,222);
}

  

TEST(TestMath, Add112)
{
	EXPECT_EQ(112+112,224);
}

  

TEST(TestMath, Add113)
{
	EXPECT_EQ(113+113,226);
}

  

TEST(TestMath, Add114)
{
	EXPECT_EQ(114+114,228);
}

  

TEST(TestMath, Add115)
{
	EXPECT_EQ(115+115,230);
}

  

TEST(TestMath, Add116)
{
	EXPECT_EQ(116+116,232);
}

  

TEST(TestMath, Add117)
{
	EXPECT_EQ(117+117,234);
}

  

TEST(TestMath, Add118)
{
	EXPECT_EQ(118+118,236);
}

  

TEST(TestMath, Add119)
{
	EXPECT_EQ(119+119,238);
}

  

TEST(TestMath, Add120)
{
	EXPECT_EQ(120+120,240);
}

  

TEST(TestMath, Add121)
{
	EXPECT_EQ(121+121,242);
}

  

TEST(TestMath, Add122)
{
	EXPECT_EQ(122+122,244);
}

  

TEST(TestMath, Add123)
{
	EXPECT_EQ(123+123,246);
}

  

TEST(TestMath, Add124)
{
	EXPECT_EQ(124+124,248);
}

  

TEST(TestMath, Add125)
{
	EXPECT_EQ(125+125,250);
}

  

TEST(TestMath, Add126)
{
	EXPECT_EQ(126+126,252);
}

  

TEST(TestMath, Add127)
{
	EXPECT_EQ(127+127,254);
}

  

TEST(TestMath, Add128)
{
	EXPECT_EQ(128+128,256);
}

  

TEST(TestMath, Add129)
{
	EXPECT_EQ(129+129,258);
}

  

TEST(TestMath, Add130)
{
	EXPECT_EQ(130+130,260);
}

  

TEST(TestMath, Add131)
{
	EXPECT_EQ(131+131,262);
}

  

TEST(TestMath, Add132)
{
	EXPECT_EQ(132+132,264);
}

  

TEST(TestMath, Add133)
{
	EXPECT_EQ(133+133,266);
}

  

TEST(TestMath, Add134)
{
	EXPECT_EQ(134+134,268);
}

  

TEST(TestMath, Add135)
{
	EXPECT_EQ(135+135,270);
}

  

TEST(TestMath, Add136)
{
	EXPECT_EQ(136+136,272);
}

  

TEST(TestMath, Add137)
{
	EXPECT_EQ(137+137,274);
}

  

TEST(TestMath, Add138)
{
	EXPECT_EQ(138+138,276);
}

  

TEST(TestMath, Add139)
{
	EXPECT_EQ(139+139,278);
}

  

TEST(TestMath, Add140)
{
	EXPECT_EQ(140+140,280);
}

  

TEST(TestMath, Add141)
{
	EXPECT_EQ(141+141,282);
}

  

TEST(TestMath, Add142)
{
	EXPECT_EQ(142+142,284);
}

  

TEST(TestMath, Add143)
{
	EXPECT_EQ(143+143,286);
}

  

TEST(TestMath, Add144)
{
	EXPECT_EQ(144+144,288);
}

  

TEST(TestMath, Add145)
{
	EXPECT_EQ(145+145,290);
}

  

TEST(TestMath, Add146)
{
	EXPECT_EQ(146+146,292);
}

  

TEST(TestMath, Add147)
{
	EXPECT_EQ(147+147,294);
}

  

TEST(TestMath, Add148)
{
	EXPECT_EQ(148+148,296);
}

  

TEST(TestMath, Add149)
{
	EXPECT_EQ(149+149,298);
}

  

TEST(TestMath, Add150)
{
	EXPECT_EQ(150+150,300);
}

  

TEST(TestMath, Add151)
{
	EXPECT_EQ(151+151,302);
}

  

TEST(TestMath, Add152)
{
	EXPECT_EQ(152+152,304);
}

  

TEST(TestMath, Add153)
{
	EXPECT_EQ(153+153,306);
}

  

TEST(TestMath, Add154)
{
	EXPECT_EQ(154+154,308);
}

  

TEST(TestMath, Add155)
{
	EXPECT_EQ(155+155,310);
}

  

TEST(TestMath, Add156)
{
	EXPECT_EQ(156+156,312);
}

  

TEST(TestMath, Add157)
{
	EXPECT_EQ(157+157,314);
}

  

TEST(TestMath, Add158)
{
	EXPECT_EQ(158+158,316);
}

  

TEST(TestMath, Add159)
{
	EXPECT_EQ(159+159,318);
}

  

TEST(TestMath, Add160)
{
	EXPECT_EQ(160+160,320);
}

  

TEST(TestMath, Add161)
{
	EXPECT_EQ(161+161,322);
}

  

TEST(TestMath, Add162)
{
	EXPECT_EQ(162+162,324);
}

  

TEST(TestMath, Add163)
{
	EXPECT_EQ(163+163,326);
}

  

TEST(TestMath, Add164)
{
	EXPECT_EQ(164+164,328);
}

  

TEST(TestMath, Add165)
{
	EXPECT_EQ(165+165,330);
}

  

TEST(TestMath, Add166)
{
	EXPECT_EQ(166+166,332);
}

  

TEST(TestMath, Add167)
{
	EXPECT_EQ(167+167,334);
}

  

TEST(TestMath, Add168)
{
	EXPECT_EQ(168+168,336);
}

  

TEST(TestMath, Add169)
{
	EXPECT_EQ(169+169,338);
}

  

TEST(TestMath, Add170)
{
	EXPECT_EQ(170+170,340);
}

  

TEST(TestMath, Add171)
{
	EXPECT_EQ(171+171,342);
}

  

TEST(TestMath, Add172)
{
	EXPECT_EQ(172+172,344);
}

  

TEST(TestMath, Add173)
{
	EXPECT_EQ(173+173,346);
}

  

TEST(TestMath, Add174)
{
	EXPECT_EQ(174+174,348);
}

  

TEST(TestMath, Add175)
{
	EXPECT_EQ(175+175,350);
}

  

TEST(TestMath, Add176)
{
	EXPECT_EQ(176+176,352);
}

  

TEST(TestMath, Add177)
{
	EXPECT_EQ(177+177,354);
}

  

TEST(TestMath, Add178)
{
	EXPECT_EQ(178+178,356);
}

  

TEST(TestMath, Add179)
{
	EXPECT_EQ(179+179,358);
}

  

TEST(TestMath, Add180)
{
	EXPECT_EQ(180+180,360);
}

  

TEST(TestMath, Add181)
{
	EXPECT_EQ(181+181,362);
}

  

TEST(TestMath, Add182)
{
	EXPECT_EQ(182+182,364);
}

  

TEST(TestMath, Add183)
{
	EXPECT_EQ(183+183,366);
}

  

TEST(TestMath, Add184)
{
	EXPECT_EQ(184+184,368);
}

  

TEST(TestMath, Add185)
{
	EXPECT_EQ(185+185,370);
}

  

TEST(TestMath, Add186)
{
	EXPECT_EQ(186+186,372);
}

  

TEST(TestMath, Add187)
{
	EXPECT_EQ(187+187,374);
}

  

TEST(TestMath, Add188)
{
	EXPECT_EQ(188+188,376);
}

  

TEST(TestMath, Add189)
{
	EXPECT_EQ(189+189,378);
}

  

TEST(TestMath, Add190)
{
	EXPECT_EQ(190+190,380);
}

  

TEST(TestMath, Add191)
{
	EXPECT_EQ(191+191,382);
}

  

TEST(TestMath, Add192)
{
	EXPECT_EQ(192+192,384);
}

  

TEST(TestMath, Add193)
{
	EXPECT_EQ(193+193,386);
}

  

TEST(TestMath, Add194)
{
	EXPECT_EQ(194+194,388);
}

  

TEST(TestMath, Add195)
{
	EXPECT_EQ(195+195,390);
}

  

TEST(TestMath, Add196)
{
	EXPECT_EQ(196+196,392);
}

  

TEST(TestMath, Add197)
{
	EXPECT_EQ(197+197,394);
}

  

TEST(TestMath, Add198)
{
	EXPECT_EQ(198+198,396);
}

  

TEST(TestMath, Add199)
{
	EXPECT_EQ(199+199,398);
}

  

TEST(TestMath, Add200)
{
	EXPECT_EQ(200+200,400);
}

  

TEST(TestMath, Add201)
{
	EXPECT_EQ(201+201,402);
}

  

TEST(TestMath, Add202)
{
	EXPECT_EQ(202+202,404);
}

  

TEST(TestMath, Add203)
{
	EXPECT_EQ(203+203,406);
}

  

TEST(TestMath, Add204)
{
	EXPECT_EQ(204+204,408);
}

  

TEST(TestMath, Add205)
{
	EXPECT_EQ(205+205,410);
}

  

TEST(TestMath, Add206)
{
	EXPECT_EQ(206+206,412);
}

  

TEST(TestMath, Add207)
{
	EXPECT_EQ(207+207,414);
}

  

TEST(TestMath, Add208)
{
	EXPECT_EQ(208+208,416);
}

  

TEST(TestMath, Add209)
{
	EXPECT_EQ(209+209,418);
}

  

TEST(TestMath, Add210)
{
	EXPECT_EQ(210+210,420);
}

  

TEST(TestMath, Add211)
{
	EXPECT_EQ(211+211,422);
}

  

TEST(TestMath, Add212)
{
	EXPECT_EQ(212+212,424);
}

  

TEST(TestMath, Add213)
{
	EXPECT_EQ(213+213,426);
}

  

TEST(TestMath, Add214)
{
	EXPECT_EQ(214+214,428);
}

  

TEST(TestMath, Add215)
{
	EXPECT_EQ(215+215,430);
}

  

TEST(TestMath, Add216)
{
	EXPECT_EQ(216+216,432);
}

  

TEST(TestMath, Add217)
{
	EXPECT_EQ(217+217,434);
}

  

TEST(TestMath, Add218)
{
	EXPECT_EQ(218+218,436);
}

  

TEST(TestMath, Add219)
{
	EXPECT_EQ(219+219,438);
}

  

TEST(TestMath, Add220)
{
	EXPECT_EQ(220+220,440);
}

  

TEST(TestMath, Add221)
{
	EXPECT_EQ(221+221,442);
}

  

TEST(TestMath, Add222)
{
	EXPECT_EQ(222+222,444);
}

  

TEST(TestMath, Add223)
{
	EXPECT_EQ(223+223,446);
}

  

TEST(TestMath, Add224)
{
	EXPECT_EQ(224+224,448);
}

  

TEST(TestMath, Add225)
{
	EXPECT_EQ(225+225,450);
}

  

TEST(TestMath, Add226)
{
	EXPECT_EQ(226+226,452);
}

  

TEST(TestMath, Add227)
{
	EXPECT_EQ(227+227,454);
}

  

TEST(TestMath, Add228)
{
	EXPECT_EQ(228+228,456);
}

  

TEST(TestMath, Add229)
{
	EXPECT_EQ(229+229,458);
}

  

TEST(TestMath, Add230)
{
	EXPECT_EQ(230+230,460);
}

  

TEST(TestMath, Add231)
{
	EXPECT_EQ(231+231,462);
}

  

TEST(TestMath, Add232)
{
	EXPECT_EQ(232+232,464);
}

  

TEST(TestMath, Add233)
{
	EXPECT_EQ(233+233,466);
}

  

TEST(TestMath, Add234)
{
	EXPECT_EQ(234+234,468);
}

  

TEST(TestMath, Add235)
{
	EXPECT_EQ(235+235,470);
}

  

TEST(TestMath, Add236)
{
	EXPECT_EQ(236+236,472);
}

  

TEST(TestMath, Add237)
{
	EXPECT_EQ(237+237,474);
}

  

TEST(TestMath, Add238)
{
	EXPECT_EQ(238+238,476);
}

  

TEST(TestMath, Add239)
{
	EXPECT_EQ(239+239,478);
}

  

TEST(TestMath, Add240)
{
	EXPECT_EQ(240+240,480);
}

  

TEST(TestMath, Add241)
{
	EXPECT_EQ(241+241,482);
}

  

TEST(TestMath, Add242)
{
	EXPECT_EQ(242+242,484);
}

  

TEST(TestMath, Add243)
{
	EXPECT_EQ(243+243,486);
}

  

TEST(TestMath, Add244)
{
	EXPECT_EQ(244+244,488);
}

  

TEST(TestMath, Add245)
{
	EXPECT_EQ(245+245,490);
}

  

TEST(TestMath, Add246)
{
	EXPECT_EQ(246+246,492);
}

  

TEST(TestMath, Add247)
{
	EXPECT_EQ(247+247,494);
}

  

TEST(TestMath, Add248)
{
	EXPECT_EQ(248+248,496);
}

  

TEST(TestMath, Add249)
{
	EXPECT_EQ(249+249,498);
}

  

TEST(TestMath, Add250)
{
	EXPECT_EQ(250+250,500);
}

  

TEST(TestMath, Add251)
{
	EXPECT_EQ(251+251,502);
}

  

TEST(TestMath, Add252)
{
	EXPECT_EQ(252+252,504);
}

  

TEST(TestMath, Add253)
{
	EXPECT_EQ(253+253,506);
}

  

TEST(TestMath, Add254)
{
	EXPECT_EQ(254+254,508);
}

  

TEST(TestMath, Add255)
{
	EXPECT_EQ(255+255,510);
}

  

TEST(TestMath, Add256)
{
	EXPECT_EQ(256+256,512);
}

  

TEST(TestMath, Add257)
{
	EXPECT_EQ(257+257,514);
}

  

TEST(TestMath, Add258)
{
	EXPECT_EQ(258+258,516);
}

  

TEST(TestMath, Add259)
{
	EXPECT_EQ(259+259,518);
}

  

TEST(TestMath, Add260)
{
	EXPECT_EQ(260+260,520);
}

  

TEST(TestMath, Add261)
{
	EXPECT_EQ(261+261,522);
}

  

TEST(TestMath, Add262)
{
	EXPECT_EQ(262+262,524);
}

  

TEST(TestMath, Add263)
{
	EXPECT_EQ(263+263,526);
}

  

TEST(TestMath, Add264)
{
	EXPECT_EQ(264+264,528);
}

  

TEST(TestMath, Add265)
{
	EXPECT_EQ(265+265,530);
}

  

TEST(TestMath, Add266)
{
	EXPECT_EQ(266+266,532);
}

  

TEST(TestMath, Add267)
{
	EXPECT_EQ(267+267,534);
}

  

TEST(TestMath, Add268)
{
	EXPECT_EQ(268+268,536);
}

  

TEST(TestMath, Add269)
{
	EXPECT_EQ(269+269,538);
}

  

TEST(TestMath, Add270)
{
	EXPECT_EQ(270+270,540);
}

  

TEST(TestMath, Add271)
{
	EXPECT_EQ(271+271,542);
}

  

TEST(TestMath, Add272)
{
	EXPECT_EQ(272+272,544);
}

  

TEST(TestMath, Add273)
{
	EXPECT_EQ(273+273,546);
}

  

TEST(TestMath, Add274)
{
	EXPECT_EQ(274+274,548);
}

  

TEST(TestMath, Add275)
{
	EXPECT_EQ(275+275,550);
}

  

TEST(TestMath, Add276)
{
	EXPECT_EQ(276+276,552);
}

  

TEST(TestMath, Add277)
{
	EXPECT_EQ(277+277,554);
}

  

TEST(TestMath, Add278)
{
	EXPECT_EQ(278+278,556);
}

  

TEST(TestMath, Add279)
{
	EXPECT_EQ(279+279,558);
}

  

TEST(TestMath, Add280)
{
	EXPECT_EQ(280+280,560);
}

  

TEST(TestMath, Add281)
{
	EXPECT_EQ(281+281,562);
}

  

TEST(TestMath, Add282)
{
	EXPECT_EQ(282+282,564);
}

  

TEST(TestMath, Add283)
{
	EXPECT_EQ(283+283,566);
}

  

TEST(TestMath, Add284)
{
	EXPECT_EQ(284+284,568);
}

  

TEST(TestMath, Add285)
{
	EXPECT_EQ(285+285,570);
}

  

TEST(TestMath, Add286)
{
	EXPECT_EQ(286+286,572);
}

  

TEST(TestMath, Add287)
{
	EXPECT_EQ(287+287,574);
}

  

TEST(TestMath, Add288)
{
	EXPECT_EQ(288+288,576);
}

  

TEST(TestMath, Add289)
{
	EXPECT_EQ(289+289,578);
}

  

TEST(TestMath, Add290)
{
	EXPECT_EQ(290+290,580);
}

  

TEST(TestMath, Add291)
{
	EXPECT_EQ(291+291,582);
}

  

TEST(TestMath, Add292)
{
	EXPECT_EQ(292+292,584);
}

  

TEST(TestMath, Add293)
{
	EXPECT_EQ(293+293,586);
}

  

TEST(TestMath, Add294)
{
	EXPECT_EQ(294+294,588);
}

  

TEST(TestMath, Add295)
{
	EXPECT_EQ(295+295,590);
}

  

TEST(TestMath, Add296)
{
	EXPECT_EQ(296+296,592);
}

  

TEST(TestMath, Add297)
{
	EXPECT_EQ(297+297,594);
}

  

TEST(TestMath, Add298)
{
	EXPECT_EQ(298+298,596);
}

  

TEST(TestMath, Add299)
{
	EXPECT_EQ(299+299,598);
}

  

TEST(TestMath, Add300)
{
	EXPECT_EQ(300+300,600);
}

  

TEST(TestMath, Add301)
{
	EXPECT_EQ(301+301,602);
}

  

TEST(TestMath, Add302)
{
	EXPECT_EQ(302+302,604);
}

  

TEST(TestMath, Add303)
{
	EXPECT_EQ(303+303,606);
}

  

TEST(TestMath, Add304)
{
	EXPECT_EQ(304+304,608);
}

  

TEST(TestMath, Add305)
{
	EXPECT_EQ(305+305,610);
}

  

TEST(TestMath, Add306)
{
	EXPECT_EQ(306+306,612);
}

  

TEST(TestMath, Add307)
{
	EXPECT_EQ(307+307,614);
}

  

TEST(TestMath, Add308)
{
	EXPECT_EQ(308+308,616);
}

  

TEST(TestMath, Add309)
{
	EXPECT_EQ(309+309,618);
}

  

TEST(TestMath, Add310)
{
	EXPECT_EQ(310+310,620);
}

  

TEST(TestMath, Add311)
{
	EXPECT_EQ(311+311,622);
}

  

TEST(TestMath, Add312)
{
	EXPECT_EQ(312+312,624);
}

  

TEST(TestMath, Add313)
{
	EXPECT_EQ(313+313,626);
}

  

TEST(TestMath, Add314)
{
	EXPECT_EQ(314+314,628);
}

  

TEST(TestMath, Add315)
{
	EXPECT_EQ(315+315,630);
}

  

TEST(TestMath, Add316)
{
	EXPECT_EQ(316+316,632);
}

  

TEST(TestMath, Add317)
{
	EXPECT_EQ(317+317,634);
}

  

TEST(TestMath, Add318)
{
	EXPECT_EQ(318+318,636);
}

  

TEST(TestMath, Add319)
{
	EXPECT_EQ(319+319,638);
}

  

TEST(TestMath, Add320)
{
	EXPECT_EQ(320+320,640);
}

  

TEST(TestMath, Add321)
{
	EXPECT_EQ(321+321,642);
}

  

TEST(TestMath, Add322)
{
	EXPECT_EQ(322+322,644);
}

  

TEST(TestMath, Add323)
{
	EXPECT_EQ(323+323,646);
}

  

TEST(TestMath, Add324)
{
	EXPECT_EQ(324+324,648);
}

  

TEST(TestMath, Add325)
{
	EXPECT_EQ(325+325,650);
}

  

TEST(TestMath, Add326)
{
	EXPECT_EQ(326+326,652);
}

  

TEST(TestMath, Add327)
{
	EXPECT_EQ(327+327,654);
}

  

TEST(TestMath, Add328)
{
	EXPECT_EQ(328+328,656);
}

  

TEST(TestMath, Add329)
{
	EXPECT_EQ(329+329,658);
}

  

TEST(TestMath, Add330)
{
	EXPECT_EQ(330+330,660);
}

  

TEST(TestMath, Add331)
{
	EXPECT_EQ(331+331,662);
}

  

TEST(TestMath, Add332)
{
	EXPECT_EQ(332+332,664);
}

  

TEST(TestMath, Add333)
{
	EXPECT_EQ(333+333,666);
}

  

TEST(TestMath, Add334)
{
	EXPECT_EQ(334+334,668);
}

  

TEST(TestMath, Add335)
{
	EXPECT_EQ(335+335,670);
}

  

TEST(TestMath, Add336)
{
	EXPECT_EQ(336+336,672);
}

  

TEST(TestMath, Add337)
{
	EXPECT_EQ(337+337,674);
}

  

TEST(TestMath, Add338)
{
	EXPECT_EQ(338+338,676);
}

  

TEST(TestMath, Add339)
{
	EXPECT_EQ(339+339,678);
}

  

TEST(TestMath, Add340)
{
	EXPECT_EQ(340+340,680);
}

  

TEST(TestMath, Add341)
{
	EXPECT_EQ(341+341,682);
}

  

TEST(TestMath, Add342)
{
	EXPECT_EQ(342+342,684);
}

  

TEST(TestMath, Add343)
{
	EXPECT_EQ(343+343,686);
}

  

TEST(TestMath, Add344)
{
	EXPECT_EQ(344+344,688);
}

  

TEST(TestMath, Add345)
{
	EXPECT_EQ(345+345,690);
}

  

TEST(TestMath, Add346)
{
	EXPECT_EQ(346+346,692);
}

  

TEST(TestMath, Add347)
{
	EXPECT_EQ(347+347,694);
}

  

TEST(TestMath, Add348)
{
	EXPECT_EQ(348+348,696);
}

  

TEST(TestMath, Add349)
{
	EXPECT_EQ(349+349,698);
}

  

TEST(TestMath, Add350)
{
	EXPECT_EQ(350+350,700);
}

  

TEST(TestMath, Add351)
{
	EXPECT_EQ(351+351,702);
}

  

TEST(TestMath, Add352)
{
	EXPECT_EQ(352+352,704);
}

  

TEST(TestMath, Add353)
{
	EXPECT_EQ(353+353,706);
}

  

TEST(TestMath, Add354)
{
	EXPECT_EQ(354+354,708);
}

  

TEST(TestMath, Add355)
{
	EXPECT_EQ(355+355,710);
}

  

TEST(TestMath, Add356)
{
	EXPECT_EQ(356+356,712);
}

  

TEST(TestMath, Add357)
{
	EXPECT_EQ(357+357,714);
}

  

TEST(TestMath, Add358)
{
	EXPECT_EQ(358+358,716);
}

  

TEST(TestMath, Add359)
{
	EXPECT_EQ(359+359,718);
}

  

TEST(TestMath, Add360)
{
	EXPECT_EQ(360+360,720);
}

  

TEST(TestMath, Add361)
{
	EXPECT_EQ(361+361,722);
}

  

TEST(TestMath, Add362)
{
	EXPECT_EQ(362+362,724);
}

  

TEST(TestMath, Add363)
{
	EXPECT_EQ(363+363,726);
}

  

TEST(TestMath, Add364)
{
	EXPECT_EQ(364+364,728);
}

  

TEST(TestMath, Add365)
{
	EXPECT_EQ(365+365,730);
}

  

TEST(TestMath, Add366)
{
	EXPECT_EQ(366+366,732);
}

  

TEST(TestMath, Add367)
{
	EXPECT_EQ(367+367,734);
}

  

TEST(TestMath, Add368)
{
	EXPECT_EQ(368+368,736);
}

  

TEST(TestMath, Add369)
{
	EXPECT_EQ(369+369,738);
}

  

TEST(TestMath, Add370)
{
	EXPECT_EQ(370+370,740);
}

  

TEST(TestMath, Add371)
{
	EXPECT_EQ(371+371,742);
}

  

TEST(TestMath, Add372)
{
	EXPECT_EQ(372+372,744);
}

  

TEST(TestMath, Add373)
{
	EXPECT_EQ(373+373,746);
}

  

TEST(TestMath, Add374)
{
	EXPECT_EQ(374+374,748);
}

  

TEST(TestMath, Add375)
{
	EXPECT_EQ(375+375,750);
}

  

TEST(TestMath, Add376)
{
	EXPECT_EQ(376+376,752);
}

  

TEST(TestMath, Add377)
{
	EXPECT_EQ(377+377,754);
}

  

TEST(TestMath, Add378)
{
	EXPECT_EQ(378+378,756);
}

  

TEST(TestMath, Add379)
{
	EXPECT_EQ(379+379,758);
}

  

TEST(TestMath, Add380)
{
	EXPECT_EQ(380+380,760);
}

  

TEST(TestMath, Add381)
{
	EXPECT_EQ(381+381,762);
}

  

TEST(TestMath, Add382)
{
	EXPECT_EQ(382+382,764);
}

  

TEST(TestMath, Add383)
{
	EXPECT_EQ(383+383,766);
}

  

TEST(TestMath, Add384)
{
	EXPECT_EQ(384+384,768);
}

  

TEST(TestMath, Add385)
{
	EXPECT_EQ(385+385,770);
}

  

TEST(TestMath, Add386)
{
	EXPECT_EQ(386+386,772);
}

  

TEST(TestMath, Add387)
{
	EXPECT_EQ(387+387,774);
}

  

TEST(TestMath, Add388)
{
	EXPECT_EQ(388+388,776);
}

  

TEST(TestMath, Add389)
{
	EXPECT_EQ(389+389,778);
}

  

TEST(TestMath, Add390)
{
	EXPECT_EQ(390+390,780);
}

  

TEST(TestMath, Add391)
{
	EXPECT_EQ(391+391,782);
}

  

TEST(TestMath, Add392)
{
	EXPECT_EQ(392+392,784);
}

  

TEST(TestMath, Add393)
{
	EXPECT_EQ(393+393,786);
}

  

TEST(TestMath, Add394)
{
	EXPECT_EQ(394+394,788);
}

  

TEST(TestMath, Add395)
{
	EXPECT_EQ(395+395,790);
}

  

TEST(TestMath, Add396)
{
	EXPECT_EQ(396+396,792);
}

  

TEST(TestMath, Add397)
{
	EXPECT_EQ(397+397,794);
}

  

TEST(TestMath, Add398)
{
	EXPECT_EQ(398+398,796);
}

  

TEST(TestMath, Add399)
{
	EXPECT_EQ(399+399,798);
}

  

TEST(TestMath, Add400)
{
	EXPECT_EQ(400+400,800);
}

  

TEST(TestMath, Add401)
{
	EXPECT_EQ(401+401,802);
}

  

TEST(TestMath, Add402)
{
	EXPECT_EQ(402+402,804);
}

  

TEST(TestMath, Add403)
{
	EXPECT_EQ(403+403,806);
}

  

TEST(TestMath, Add404)
{
	EXPECT_EQ(404+404,808);
}

  

TEST(TestMath, Add405)
{
	EXPECT_EQ(405+405,810);
}

  

TEST(TestMath, Add406)
{
	EXPECT_EQ(406+406,812);
}

  

TEST(TestMath, Add407)
{
	EXPECT_EQ(407+407,814);
}

  

TEST(TestMath, Add408)
{
	EXPECT_EQ(408+408,816);
}

  

TEST(TestMath, Add409)
{
	EXPECT_EQ(409+409,818);
}

  

TEST(TestMath, Add410)
{
	EXPECT_EQ(410+410,820);
}

  

TEST(TestMath, Add411)
{
	EXPECT_EQ(411+411,822);
}

  

TEST(TestMath, Add412)
{
	EXPECT_EQ(412+412,824);
}

  

TEST(TestMath, Add413)
{
	EXPECT_EQ(413+413,826);
}

  

TEST(TestMath, Add414)
{
	EXPECT_EQ(414+414,828);
}

  

TEST(TestMath, Add415)
{
	EXPECT_EQ(415+415,830);
}

  

TEST(TestMath, Add416)
{
	EXPECT_EQ(416+416,832);
}

  

TEST(TestMath, Add417)
{
	EXPECT_EQ(417+417,834);
}

  

TEST(TestMath, Add418)
{
	EXPECT_EQ(418+418,836);
}

  

TEST(TestMath, Add419)
{
	EXPECT_EQ(419+419,838);
}

  

TEST(TestMath, Add420)
{
	EXPECT_EQ(420+420,840);
}

  

TEST(TestMath, Add421)
{
	EXPECT_EQ(421+421,842);
}

  

TEST(TestMath, Add422)
{
	EXPECT_EQ(422+422,844);
}

  

TEST(TestMath, Add423)
{
	EXPECT_EQ(423+423,846);
}

  

TEST(TestMath, Add424)
{
	EXPECT_EQ(424+424,848);
}

  

TEST(TestMath, Add425)
{
	EXPECT_EQ(425+425,850);
}

  

TEST(TestMath, Add426)
{
	EXPECT_EQ(426+426,852);
}

  

TEST(TestMath, Add427)
{
	EXPECT_EQ(427+427,854);
}

  

TEST(TestMath, Add428)
{
	EXPECT_EQ(428+428,856);
}

  

TEST(TestMath, Add429)
{
	EXPECT_EQ(429+429,858);
}

  

TEST(TestMath, Add430)
{
	EXPECT_EQ(430+430,860);
}

  

TEST(TestMath, Add431)
{
	EXPECT_EQ(431+431,862);
}

  

TEST(TestMath, Add432)
{
	EXPECT_EQ(432+432,864);
}

  

TEST(TestMath, Add433)
{
	EXPECT_EQ(433+433,866);
}

  

TEST(TestMath, Add434)
{
	EXPECT_EQ(434+434,868);
}

  

TEST(TestMath, Add435)
{
	EXPECT_EQ(435+435,870);
}

  

TEST(TestMath, Add436)
{
	EXPECT_EQ(436+436,872);
}

  

TEST(TestMath, Add437)
{
	EXPECT_EQ(437+437,874);
}

  

TEST(TestMath, Add438)
{
	EXPECT_EQ(438+438,876);
}

  

TEST(TestMath, Add439)
{
	EXPECT_EQ(439+439,878);
}

  

TEST(TestMath, Add440)
{
	EXPECT_EQ(440+440,880);
}

  

TEST(TestMath, Add441)
{
	EXPECT_EQ(441+441,882);
}

  

TEST(TestMath, Add442)
{
	EXPECT_EQ(442+442,884);
}

  

TEST(TestMath, Add443)
{
	EXPECT_EQ(443+443,886);
}

  

TEST(TestMath, Add444)
{
	EXPECT_EQ(444+444,888);
}

  

TEST(TestMath, Add445)
{
	EXPECT_EQ(445+445,890);
}

  

TEST(TestMath, Add446)
{
	EXPECT_EQ(446+446,892);
}

  

TEST(TestMath, Add447)
{
	EXPECT_EQ(447+447,894);
}

  

TEST(TestMath, Add448)
{
	EXPECT_EQ(448+448,896);
}

  

TEST(TestMath, Add449)
{
	EXPECT_EQ(449+449,898);
}

  

TEST(TestMath, Add450)
{
	EXPECT_EQ(450+450,900);
}

  

TEST(TestMath, Add451)
{
	EXPECT_EQ(451+451,902);
}

  

TEST(TestMath, Add452)
{
	EXPECT_EQ(452+452,904);
}

  

TEST(TestMath, Add453)
{
	EXPECT_EQ(453+453,906);
}

  

TEST(TestMath, Add454)
{
	EXPECT_EQ(454+454,908);
}

  

TEST(TestMath, Add455)
{
	EXPECT_EQ(455+455,910);
}

  

TEST(TestMath, Add456)
{
	EXPECT_EQ(456+456,912);
}

  

TEST(TestMath, Add457)
{
	EXPECT_EQ(457+457,914);
}

  

TEST(TestMath, Add458)
{
	EXPECT_EQ(458+458,916);
}

  

TEST(TestMath, Add459)
{
	EXPECT_EQ(459+459,918);
}

  

TEST(TestMath, Add460)
{
	EXPECT_EQ(460+460,920);
}

  

TEST(TestMath, Add461)
{
	EXPECT_EQ(461+461,922);
}

  

TEST(TestMath, Add462)
{
	EXPECT_EQ(462+462,924);
}

  

TEST(TestMath, Add463)
{
	EXPECT_EQ(463+463,926);
}

  

TEST(TestMath, Add464)
{
	EXPECT_EQ(464+464,928);
}

  

TEST(TestMath, Add465)
{
	EXPECT_EQ(465+465,930);
}

  

TEST(TestMath, Add466)
{
	EXPECT_EQ(466+466,932);
}

  

TEST(TestMath, Add467)
{
	EXPECT_EQ(467+467,934);
}

  

TEST(TestMath, Add468)
{
	EXPECT_EQ(468+468,936);
}

  

TEST(TestMath, Add469)
{
	EXPECT_EQ(469+469,938);
}

  

TEST(TestMath, Add470)
{
	EXPECT_EQ(470+470,940);
}

  

TEST(TestMath, Add471)
{
	EXPECT_EQ(471+471,942);
}

  

TEST(TestMath, Add472)
{
	EXPECT_EQ(472+472,944);
}

  

TEST(TestMath, Add473)
{
	EXPECT_EQ(473+473,946);
}

  

TEST(TestMath, Add474)
{
	EXPECT_EQ(474+474,948);
}

  

TEST(TestMath, Add475)
{
	EXPECT_EQ(475+475,950);
}

  

TEST(TestMath, Add476)
{
	EXPECT_EQ(476+476,952);
}

  

TEST(TestMath, Add477)
{
	EXPECT_EQ(477+477,954);
}

  

TEST(TestMath, Add478)
{
	EXPECT_EQ(478+478,956);
}

  

TEST(TestMath, Add479)
{
	EXPECT_EQ(479+479,958);
}

  

TEST(TestMath, Add480)
{
	EXPECT_EQ(480+480,960);
}

  

TEST(TestMath, Add481)
{
	EXPECT_EQ(481+481,962);
}

  

TEST(TestMath, Add482)
{
	EXPECT_EQ(482+482,964);
}

  

TEST(TestMath, Add483)
{
	EXPECT_EQ(483+483,966);
}

  

TEST(TestMath, Add484)
{
	EXPECT_EQ(484+484,968);
}

  

TEST(TestMath, Add485)
{
	EXPECT_EQ(485+485,970);
}

  

TEST(TestMath, Add486)
{
	EXPECT_EQ(486+486,972);
}

  

TEST(TestMath, Add487)
{
	EXPECT_EQ(487+487,974);
}

  

TEST(TestMath, Add488)
{
	EXPECT_EQ(488+488,976);
}

  

TEST(TestMath, Add489)
{
	EXPECT_EQ(489+489,978);
}

  

TEST(TestMath, Add490)
{
	EXPECT_EQ(490+490,980);
}

  

TEST(TestMath, Add491)
{
	EXPECT_EQ(491+491,982);
}

  

TEST(TestMath, Add492)
{
	EXPECT_EQ(492+492,984);
}

  

TEST(TestMath, Add493)
{
	EXPECT_EQ(493+493,986);
}

  

TEST(TestMath, Add494)
{
	EXPECT_EQ(494+494,988);
}

  

TEST(TestMath, Add495)
{
	EXPECT_EQ(495+495,990);
}

  

TEST(TestMath, Add496)
{
	EXPECT_EQ(496+496,992);
}

  

TEST(TestMath, Add497)
{
	EXPECT_EQ(497+497,994);
}

  

TEST(TestMath, Add498)
{
	EXPECT_EQ(498+498,996);
}

  

TEST(TestMath, Add499)
{
	EXPECT_EQ(499+499,998);
}

  

TEST(TestMath, Add500)
{
	EXPECT_EQ(500+500,1000);
}

  

TEST(TestMath, Add501)
{
	EXPECT_EQ(501+501,1002);
}

  

TEST(TestMath, Add502)
{
	EXPECT_EQ(502+502,1004);
}

  

TEST(TestMath, Add503)
{
	EXPECT_EQ(503+503,1006);
}

  

TEST(TestMath, Add504)
{
	EXPECT_EQ(504+504,1008);
}

  

TEST(TestMath, Add505)
{
	EXPECT_EQ(505+505,1010);
}

  

TEST(TestMath, Add506)
{
	EXPECT_EQ(506+506,1012);
}

  

TEST(TestMath, Add507)
{
	EXPECT_EQ(507+507,1014);
}

  

TEST(TestMath, Add508)
{
	EXPECT_EQ(508+508,1016);
}

  

TEST(TestMath, Add509)
{
	EXPECT_EQ(509+509,1018);
}

  

TEST(TestMath, Add510)
{
	EXPECT_EQ(510+510,1020);
}

  

TEST(TestMath, Add511)
{
	EXPECT_EQ(511+511,1022);
}

  

TEST(TestMath, Add512)
{
	EXPECT_EQ(512+512,1024);
}

  

TEST(TestMath, Add513)
{
	EXPECT_EQ(513+513,1026);
}

  

TEST(TestMath, Add514)
{
	EXPECT_EQ(514+514,1028);
}

  

TEST(TestMath, Add515)
{
	EXPECT_EQ(515+515,1030);
}

  

TEST(TestMath, Add516)
{
	EXPECT_EQ(516+516,1032);
}

  

TEST(TestMath, Add517)
{
	EXPECT_EQ(517+517,1034);
}

  

TEST(TestMath, Add518)
{
	EXPECT_EQ(518+518,1036);
}

  

TEST(TestMath, Add519)
{
	EXPECT_EQ(519+519,1038);
}

  

TEST(TestMath, Add520)
{
	EXPECT_EQ(520+520,1040);
}

  

TEST(TestMath, Add521)
{
	EXPECT_EQ(521+521,1042);
}

  

TEST(TestMath, Add522)
{
	EXPECT_EQ(522+522,1044);
}

  

TEST(TestMath, Add523)
{
	EXPECT_EQ(523+523,1046);
}

  

TEST(TestMath, Add524)
{
	EXPECT_EQ(524+524,1048);
}

  

TEST(TestMath, Add525)
{
	EXPECT_EQ(525+525,1050);
}

  

TEST(TestMath, Add526)
{
	EXPECT_EQ(526+526,1052);
}

  

TEST(TestMath, Add527)
{
	EXPECT_EQ(527+527,1054);
}

  

TEST(TestMath, Add528)
{
	EXPECT_EQ(528+528,1056);
}

  

TEST(TestMath, Add529)
{
	EXPECT_EQ(529+529,1058);
}

  

TEST(TestMath, Add530)
{
	EXPECT_EQ(530+530,1060);
}

  

TEST(TestMath, Add531)
{
	EXPECT_EQ(531+531,1062);
}

  

TEST(TestMath, Add532)
{
	EXPECT_EQ(532+532,1064);
}

  

TEST(TestMath, Add533)
{
	EXPECT_EQ(533+533,1066);
}

  

TEST(TestMath, Add534)
{
	EXPECT_EQ(534+534,1068);
}

  

TEST(TestMath, Add535)
{
	EXPECT_EQ(535+535,1070);
}

  

TEST(TestMath, Add536)
{
	EXPECT_EQ(536+536,1072);
}

  

TEST(TestMath, Add537)
{
	EXPECT_EQ(537+537,1074);
}

  

TEST(TestMath, Add538)
{
	EXPECT_EQ(538+538,1076);
}

  

TEST(TestMath, Add539)
{
	EXPECT_EQ(539+539,1078);
}

  

TEST(TestMath, Add540)
{
	EXPECT_EQ(540+540,1080);
}

  

TEST(TestMath, Add541)
{
	EXPECT_EQ(541+541,1082);
}

  

TEST(TestMath, Add542)
{
	EXPECT_EQ(542+542,1084);
}

  

TEST(TestMath, Add543)
{
	EXPECT_EQ(543+543,1086);
}

  

TEST(TestMath, Add544)
{
	EXPECT_EQ(544+544,1088);
}

  

TEST(TestMath, Add545)
{
	EXPECT_EQ(545+545,1090);
}

  

TEST(TestMath, Add546)
{
	EXPECT_EQ(546+546,1092);
}

  

TEST(TestMath, Add547)
{
	EXPECT_EQ(547+547,1094);
}

  

TEST(TestMath, Add548)
{
	EXPECT_EQ(548+548,1096);
}

  

TEST(TestMath, Add549)
{
	EXPECT_EQ(549+549,1098);
}

  

TEST(TestMath, Add550)
{
	EXPECT_EQ(550+550,1100);
}

  

TEST(TestMath, Add551)
{
	EXPECT_EQ(551+551,1102);
}

  

TEST(TestMath, Add552)
{
	EXPECT_EQ(552+552,1104);
}

  

TEST(TestMath, Add553)
{
	EXPECT_EQ(553+553,1106);
}

  

TEST(TestMath, Add554)
{
	EXPECT_EQ(554+554,1108);
}

  

TEST(TestMath, Add555)
{
	EXPECT_EQ(555+555,1110);
}

  

TEST(TestMath, Add556)
{
	EXPECT_EQ(556+556,1112);
}

  

TEST(TestMath, Add557)
{
	EXPECT_EQ(557+557,1114);
}

  

TEST(TestMath, Add558)
{
	EXPECT_EQ(558+558,1116);
}

  

TEST(TestMath, Add559)
{
	EXPECT_EQ(559+559,1118);
}

  

TEST(TestMath, Add560)
{
	EXPECT_EQ(560+560,1120);
}

  

TEST(TestMath, Add561)
{
	EXPECT_EQ(561+561,1122);
}

  

TEST(TestMath, Add562)
{
	EXPECT_EQ(562+562,1124);
}

  

TEST(TestMath, Add563)
{
	EXPECT_EQ(563+563,1126);
}

  

TEST(TestMath, Add564)
{
	EXPECT_EQ(564+564,1128);
}

  

TEST(TestMath, Add565)
{
	EXPECT_EQ(565+565,1130);
}

  

TEST(TestMath, Add566)
{
	EXPECT_EQ(566+566,1132);
}

  

TEST(TestMath, Add567)
{
	EXPECT_EQ(567+567,1134);
}

  

TEST(TestMath, Add568)
{
	EXPECT_EQ(568+568,1136);
}

  

TEST(TestMath, Add569)
{
	EXPECT_EQ(569+569,1138);
}

  

TEST(TestMath, Add570)
{
	EXPECT_EQ(570+570,1140);
}

  

TEST(TestMath, Add571)
{
	EXPECT_EQ(571+571,1142);
}

  

TEST(TestMath, Add572)
{
	EXPECT_EQ(572+572,1144);
}

  

TEST(TestMath, Add573)
{
	EXPECT_EQ(573+573,1146);
}

  

TEST(TestMath, Add574)
{
	EXPECT_EQ(574+574,1148);
}

  

TEST(TestMath, Add575)
{
	EXPECT_EQ(575+575,1150);
}

  

TEST(TestMath, Add576)
{
	EXPECT_EQ(576+576,1152);
}

  

TEST(TestMath, Add577)
{
	EXPECT_EQ(577+577,1154);
}

  

TEST(TestMath, Add578)
{
	EXPECT_EQ(578+578,1156);
}

  

TEST(TestMath, Add579)
{
	EXPECT_EQ(579+579,1158);
}

  

TEST(TestMath, Add580)
{
	EXPECT_EQ(580+580,1160);
}

  

TEST(TestMath, Add581)
{
	EXPECT_EQ(581+581,1162);
}

  

TEST(TestMath, Add582)
{
	EXPECT_EQ(582+582,1164);
}

  

TEST(TestMath, Add583)
{
	EXPECT_EQ(583+583,1166);
}

  

TEST(TestMath, Add584)
{
	EXPECT_EQ(584+584,1168);
}

  

TEST(TestMath, Add585)
{
	EXPECT_EQ(585+585,1170);
}

  

TEST(TestMath, Add586)
{
	EXPECT_EQ(586+586,1172);
}

  

TEST(TestMath, Add587)
{
	EXPECT_EQ(587+587,1174);
}

  

TEST(TestMath, Add588)
{
	EXPECT_EQ(588+588,1176);
}

  

TEST(TestMath, Add589)
{
	EXPECT_EQ(589+589,1178);
}

  

TEST(TestMath, Add590)
{
	EXPECT_EQ(590+590,1180);
}

  

TEST(TestMath, Add591)
{
	EXPECT_EQ(591+591,1182);
}

  

TEST(TestMath, Add592)
{
	EXPECT_EQ(592+592,1184);
}

  

TEST(TestMath, Add593)
{
	EXPECT_EQ(593+593,1186);
}

  

TEST(TestMath, Add594)
{
	EXPECT_EQ(594+594,1188);
}

  

TEST(TestMath, Add595)
{
	EXPECT_EQ(595+595,1190);
}

  

TEST(TestMath, Add596)
{
	EXPECT_EQ(596+596,1192);
}

  

TEST(TestMath, Add597)
{
	EXPECT_EQ(597+597,1194);
}

  

TEST(TestMath, Add598)
{
	EXPECT_EQ(598+598,1196);
}

  

TEST(TestMath, Add599)
{
	EXPECT_EQ(599+599,1198);
}

  

TEST(TestMath, Add600)
{
	EXPECT_EQ(600+600,1200);
}

  

TEST(TestMath, Add601)
{
	EXPECT_EQ(601+601,1202);
}

  

TEST(TestMath, Add602)
{
	EXPECT_EQ(602+602,1204);
}

  

TEST(TestMath, Add603)
{
	EXPECT_EQ(603+603,1206);
}

  

TEST(TestMath, Add604)
{
	EXPECT_EQ(604+604,1208);
}

  

TEST(TestMath, Add605)
{
	EXPECT_EQ(605+605,1210);
}

  

TEST(TestMath, Add606)
{
	EXPECT_EQ(606+606,1212);
}

  

TEST(TestMath, Add607)
{
	EXPECT_EQ(607+607,1214);
}

  

TEST(TestMath, Add608)
{
	EXPECT_EQ(608+608,1216);
}

  

TEST(TestMath, Add609)
{
	EXPECT_EQ(609+609,1218);
}

  

TEST(TestMath, Add610)
{
	EXPECT_EQ(610+610,1220);
}

  

TEST(TestMath, Add611)
{
	EXPECT_EQ(611+611,1222);
}

  

TEST(TestMath, Add612)
{
	EXPECT_EQ(612+612,1224);
}

  

TEST(TestMath, Add613)
{
	EXPECT_EQ(613+613,1226);
}

  

TEST(TestMath, Add614)
{
	EXPECT_EQ(614+614,1228);
}

  

TEST(TestMath, Add615)
{
	EXPECT_EQ(615+615,1230);
}

  

TEST(TestMath, Add616)
{
	EXPECT_EQ(616+616,1232);
}

  

TEST(TestMath, Add617)
{
	EXPECT_EQ(617+617,1234);
}

  

TEST(TestMath, Add618)
{
	EXPECT_EQ(618+618,1236);
}

  

TEST(TestMath, Add619)
{
	EXPECT_EQ(619+619,1238);
}

  

TEST(TestMath, Add620)
{
	EXPECT_EQ(620+620,1240);
}

  

TEST(TestMath, Add621)
{
	EXPECT_EQ(621+621,1242);
}

  

TEST(TestMath, Add622)
{
	EXPECT_EQ(622+622,1244);
}

  

TEST(TestMath, Add623)
{
	EXPECT_EQ(623+623,1246);
}

  

TEST(TestMath, Add624)
{
	EXPECT_EQ(624+624,1248);
}

  

TEST(TestMath, Add625)
{
	EXPECT_EQ(625+625,1250);
}

  

TEST(TestMath, Add626)
{
	EXPECT_EQ(626+626,1252);
}

  

TEST(TestMath, Add627)
{
	EXPECT_EQ(627+627,1254);
}

  

TEST(TestMath, Add628)
{
	EXPECT_EQ(628+628,1256);
}

  

TEST(TestMath, Add629)
{
	EXPECT_EQ(629+629,1258);
}

  

TEST(TestMath, Add630)
{
	EXPECT_EQ(630+630,1260);
}

  

TEST(TestMath, Add631)
{
	EXPECT_EQ(631+631,1262);
}

  

TEST(TestMath, Add632)
{
	EXPECT_EQ(632+632,1264);
}

  

TEST(TestMath, Add633)
{
	EXPECT_EQ(633+633,1266);
}

  

TEST(TestMath, Add634)
{
	EXPECT_EQ(634+634,1268);
}

  

TEST(TestMath, Add635)
{
	EXPECT_EQ(635+635,1270);
}

  

TEST(TestMath, Add636)
{
	EXPECT_EQ(636+636,1272);
}

  

TEST(TestMath, Add637)
{
	EXPECT_EQ(637+637,1274);
}

  

TEST(TestMath, Add638)
{
	EXPECT_EQ(638+638,1276);
}

  

TEST(TestMath, Add639)
{
	EXPECT_EQ(639+639,1278);
}

  

TEST(TestMath, Add640)
{
	EXPECT_EQ(640+640,1280);
}

  

TEST(TestMath, Add641)
{
	EXPECT_EQ(641+641,1282);
}

  

TEST(TestMath, Add642)
{
	EXPECT_EQ(642+642,1284);
}

  

TEST(TestMath, Add643)
{
	EXPECT_EQ(643+643,1286);
}

  

TEST(TestMath, Add644)
{
	EXPECT_EQ(644+644,1288);
}

  

TEST(TestMath, Add645)
{
	EXPECT_EQ(645+645,1290);
}

  

TEST(TestMath, Add646)
{
	EXPECT_EQ(646+646,1292);
}

  

TEST(TestMath, Add647)
{
	EXPECT_EQ(647+647,1294);
}

  

TEST(TestMath, Add648)
{
	EXPECT_EQ(648+648,1296);
}

  

TEST(TestMath, Add649)
{
	EXPECT_EQ(649+649,1298);
}

  

TEST(TestMath, Add650)
{
	EXPECT_EQ(650+650,1300);
}

  

TEST(TestMath, Add651)
{
	EXPECT_EQ(651+651,1302);
}

  

TEST(TestMath, Add652)
{
	EXPECT_EQ(652+652,1304);
}

  

TEST(TestMath, Add653)
{
	EXPECT_EQ(653+653,1306);
}

  

TEST(TestMath, Add654)
{
	EXPECT_EQ(654+654,1308);
}

  

TEST(TestMath, Add655)
{
	EXPECT_EQ(655+655,1310);
}

  

TEST(TestMath, Add656)
{
	EXPECT_EQ(656+656,1312);
}

  

TEST(TestMath, Add657)
{
	EXPECT_EQ(657+657,1314);
}

  

TEST(TestMath, Add658)
{
	EXPECT_EQ(658+658,1316);
}

  

TEST(TestMath, Add659)
{
	EXPECT_EQ(659+659,1318);
}

  

TEST(TestMath, Add660)
{
	EXPECT_EQ(660+660,1320);
}

  

TEST(TestMath, Add661)
{
	EXPECT_EQ(661+661,1322);
}

  

TEST(TestMath, Add662)
{
	EXPECT_EQ(662+662,1324);
}

  

TEST(TestMath, Add663)
{
	EXPECT_EQ(663+663,1326);
}

  

TEST(TestMath, Add664)
{
	EXPECT_EQ(664+664,1328);
}

  

TEST(TestMath, Add665)
{
	EXPECT_EQ(665+665,1330);
}

  

TEST(TestMath, Add666)
{
	EXPECT_EQ(666+666,1332);
}

  

TEST(TestMath, Add667)
{
	EXPECT_EQ(667+667,1334);
}

  

TEST(TestMath, Add668)
{
	EXPECT_EQ(668+668,1336);
}

  

TEST(TestMath, Add669)
{
	EXPECT_EQ(669+669,1338);
}

  

TEST(TestMath, Add670)
{
	EXPECT_EQ(670+670,1340);
}

  

TEST(TestMath, Add671)
{
	EXPECT_EQ(671+671,1342);
}

  

TEST(TestMath, Add672)
{
	EXPECT_EQ(672+672,1344);
}

  

TEST(TestMath, Add673)
{
	EXPECT_EQ(673+673,1346);
}

  

TEST(TestMath, Add674)
{
	EXPECT_EQ(674+674,1348);
}

  

TEST(TestMath, Add675)
{
	EXPECT_EQ(675+675,1350);
}

  

TEST(TestMath, Add676)
{
	EXPECT_EQ(676+676,1352);
}

  

TEST(TestMath, Add677)
{
	EXPECT_EQ(677+677,1354);
}

  

TEST(TestMath, Add678)
{
	EXPECT_EQ(678+678,1356);
}

  

TEST(TestMath, Add679)
{
	EXPECT_EQ(679+679,1358);
}

  

TEST(TestMath, Add680)
{
	EXPECT_EQ(680+680,1360);
}

  

TEST(TestMath, Add681)
{
	EXPECT_EQ(681+681,1362);
}

  

TEST(TestMath, Add682)
{
	EXPECT_EQ(682+682,1364);
}

  

TEST(TestMath, Add683)
{
	EXPECT_EQ(683+683,1366);
}

  

TEST(TestMath, Add684)
{
	EXPECT_EQ(684+684,1368);
}

  

TEST(TestMath, Add685)
{
	EXPECT_EQ(685+685,1370);
}

  

TEST(TestMath, Add686)
{
	EXPECT_EQ(686+686,1372);
}

  

TEST(TestMath, Add687)
{
	EXPECT_EQ(687+687,1374);
}

  

TEST(TestMath, Add688)
{
	EXPECT_EQ(688+688,1376);
}

  

TEST(TestMath, Add689)
{
	EXPECT_EQ(689+689,1378);
}

  

TEST(TestMath, Add690)
{
	EXPECT_EQ(690+690,1380);
}

  

TEST(TestMath, Add691)
{
	EXPECT_EQ(691+691,1382);
}

  

TEST(TestMath, Add692)
{
	EXPECT_EQ(692+692,1384);
}

  

TEST(TestMath, Add693)
{
	EXPECT_EQ(693+693,1386);
}

  

TEST(TestMath, Add694)
{
	EXPECT_EQ(694+694,1388);
}

  

TEST(TestMath, Add695)
{
	EXPECT_EQ(695+695,1390);
}

  

TEST(TestMath, Add696)
{
	EXPECT_EQ(696+696,1392);
}

  

TEST(TestMath, Add697)
{
	EXPECT_EQ(697+697,1394);
}

  

TEST(TestMath, Add698)
{
	EXPECT_EQ(698+698,1396);
}

  

TEST(TestMath, Add699)
{
	EXPECT_EQ(699+699,1398);
}

  

TEST(TestMath, Add700)
{
	EXPECT_EQ(700+700,1400);
}

  

TEST(TestMath, Add701)
{
	EXPECT_EQ(701+701,1402);
}

  

TEST(TestMath, Add702)
{
	EXPECT_EQ(702+702,1404);
}

  

TEST(TestMath, Add703)
{
	EXPECT_EQ(703+703,1406);
}

  

TEST(TestMath, Add704)
{
	EXPECT_EQ(704+704,1408);
}

  

TEST(TestMath, Add705)
{
	EXPECT_EQ(705+705,1410);
}

  

TEST(TestMath, Add706)
{
	EXPECT_EQ(706+706,1412);
}

  

TEST(TestMath, Add707)
{
	EXPECT_EQ(707+707,1414);
}

  

TEST(TestMath, Add708)
{
	EXPECT_EQ(708+708,1416);
}

  

TEST(TestMath, Add709)
{
	EXPECT_EQ(709+709,1418);
}

  

TEST(TestMath, Add710)
{
	EXPECT_EQ(710+710,1420);
}

  

TEST(TestMath, Add711)
{
	EXPECT_EQ(711+711,1422);
}

  

TEST(TestMath, Add712)
{
	EXPECT_EQ(712+712,1424);
}

  

TEST(TestMath, Add713)
{
	EXPECT_EQ(713+713,1426);
}

  

TEST(TestMath, Add714)
{
	EXPECT_EQ(714+714,1428);
}

  

TEST(TestMath, Add715)
{
	EXPECT_EQ(715+715,1430);
}

  

TEST(TestMath, Add716)
{
	EXPECT_EQ(716+716,1432);
}

  

TEST(TestMath, Add717)
{
	EXPECT_EQ(717+717,1434);
}

  

TEST(TestMath, Add718)
{
	EXPECT_EQ(718+718,1436);
}

  

TEST(TestMath, Add719)
{
	EXPECT_EQ(719+719,1438);
}

  

TEST(TestMath, Add720)
{
	EXPECT_EQ(720+720,1440);
}

  

TEST(TestMath, Add721)
{
	EXPECT_EQ(721+721,1442);
}

  

TEST(TestMath, Add722)
{
	EXPECT_EQ(722+722,1444);
}

  

TEST(TestMath, Add723)
{
	EXPECT_EQ(723+723,1446);
}

  

TEST(TestMath, Add724)
{
	EXPECT_EQ(724+724,1448);
}

  

TEST(TestMath, Add725)
{
	EXPECT_EQ(725+725,1450);
}

  

TEST(TestMath, Add726)
{
	EXPECT_EQ(726+726,1452);
}

  

TEST(TestMath, Add727)
{
	EXPECT_EQ(727+727,1454);
}

  

TEST(TestMath, Add728)
{
	EXPECT_EQ(728+728,1456);
}

  

TEST(TestMath, Add729)
{
	EXPECT_EQ(729+729,1458);
}

  

TEST(TestMath, Add730)
{
	EXPECT_EQ(730+730,1460);
}

  

TEST(TestMath, Add731)
{
	EXPECT_EQ(731+731,1462);
}

  

TEST(TestMath, Add732)
{
	EXPECT_EQ(732+732,1464);
}

  

TEST(TestMath, Add733)
{
	EXPECT_EQ(733+733,1466);
}

  

TEST(TestMath, Add734)
{
	EXPECT_EQ(734+734,1468);
}

  

TEST(TestMath, Add735)
{
	EXPECT_EQ(735+735,1470);
}

  

TEST(TestMath, Add736)
{
	EXPECT_EQ(736+736,1472);
}

  

TEST(TestMath, Add737)
{
	EXPECT_EQ(737+737,1474);
}

  

TEST(TestMath, Add738)
{
	EXPECT_EQ(738+738,1476);
}

  

TEST(TestMath, Add739)
{
	EXPECT_EQ(739+739,1478);
}

  

TEST(TestMath, Add740)
{
	EXPECT_EQ(740+740,1480);
}

  

TEST(TestMath, Add741)
{
	EXPECT_EQ(741+741,1482);
}

  

TEST(TestMath, Add742)
{
	EXPECT_EQ(742+742,1484);
}

  

TEST(TestMath, Add743)
{
	EXPECT_EQ(743+743,1486);
}

  

TEST(TestMath, Add744)
{
	EXPECT_EQ(744+744,1488);
}

  

TEST(TestMath, Add745)
{
	EXPECT_EQ(745+745,1490);
}

  

TEST(TestMath, Add746)
{
	EXPECT_EQ(746+746,1492);
}

  

TEST(TestMath, Add747)
{
	EXPECT_EQ(747+747,1494);
}

  

TEST(TestMath, Add748)
{
	EXPECT_EQ(748+748,1496);
}

  

TEST(TestMath, Add749)
{
	EXPECT_EQ(749+749,1498);
}

  

TEST(TestMath, Add750)
{
	EXPECT_EQ(750+750,1500);
}

  

TEST(TestMath, Add751)
{
	EXPECT_EQ(751+751,1502);
}

  

TEST(TestMath, Add752)
{
	EXPECT_EQ(752+752,1504);
}

  

TEST(TestMath, Add753)
{
	EXPECT_EQ(753+753,1506);
}

  

TEST(TestMath, Add754)
{
	EXPECT_EQ(754+754,1508);
}

  

TEST(TestMath, Add755)
{
	EXPECT_EQ(755+755,1510);
}

  

TEST(TestMath, Add756)
{
	EXPECT_EQ(756+756,1512);
}

  

TEST(TestMath, Add757)
{
	EXPECT_EQ(757+757,1514);
}

  

TEST(TestMath, Add758)
{
	EXPECT_EQ(758+758,1516);
}

  

TEST(TestMath, Add759)
{
	EXPECT_EQ(759+759,1518);
}

  

TEST(TestMath, Add760)
{
	EXPECT_EQ(760+760,1520);
}

  

TEST(TestMath, Add761)
{
	EXPECT_EQ(761+761,1522);
}

  

TEST(TestMath, Add762)
{
	EXPECT_EQ(762+762,1524);
}

  

TEST(TestMath, Add763)
{
	EXPECT_EQ(763+763,1526);
}

  

TEST(TestMath, Add764)
{
	EXPECT_EQ(764+764,1528);
}

  

TEST(TestMath, Add765)
{
	EXPECT_EQ(765+765,1530);
}

  

TEST(TestMath, Add766)
{
	EXPECT_EQ(766+766,1532);
}

  

TEST(TestMath, Add767)
{
	EXPECT_EQ(767+767,1534);
}

  

TEST(TestMath, Add768)
{
	EXPECT_EQ(768+768,1536);
}

  

TEST(TestMath, Add769)
{
	EXPECT_EQ(769+769,1538);
}

  

TEST(TestMath, Add770)
{
	EXPECT_EQ(770+770,1540);
}

  

TEST(TestMath, Add771)
{
	EXPECT_EQ(771+771,1542);
}

  

TEST(TestMath, Add772)
{
	EXPECT_EQ(772+772,1544);
}

  

TEST(TestMath, Add773)
{
	EXPECT_EQ(773+773,1546);
}

  

TEST(TestMath, Add774)
{
	EXPECT_EQ(774+774,1548);
}

  

TEST(TestMath, Add775)
{
	EXPECT_EQ(775+775,1550);
}

  

TEST(TestMath, Add776)
{
	EXPECT_EQ(776+776,1552);
}

  

TEST(TestMath, Add777)
{
	EXPECT_EQ(777+777,1554);
}

  

TEST(TestMath, Add778)
{
	EXPECT_EQ(778+778,1556);
}

  

TEST(TestMath, Add779)
{
	EXPECT_EQ(779+779,1558);
}

  

TEST(TestMath, Add780)
{
	EXPECT_EQ(780+780,1560);
}

  

TEST(TestMath, Add781)
{
	EXPECT_EQ(781+781,1562);
}

  

TEST(TestMath, Add782)
{
	EXPECT_EQ(782+782,1564);
}

  

TEST(TestMath, Add783)
{
	EXPECT_EQ(783+783,1566);
}

  

TEST(TestMath, Add784)
{
	EXPECT_EQ(784+784,1568);
}

  

TEST(TestMath, Add785)
{
	EXPECT_EQ(785+785,1570);
}

  

TEST(TestMath, Add786)
{
	EXPECT_EQ(786+786,1572);
}

  

TEST(TestMath, Add787)
{
	EXPECT_EQ(787+787,1574);
}

  

TEST(TestMath, Add788)
{
	EXPECT_EQ(788+788,1576);
}

  

TEST(TestMath, Add789)
{
	EXPECT_EQ(789+789,1578);
}

  

TEST(TestMath, Add790)
{
	EXPECT_EQ(790+790,1580);
}

  

TEST(TestMath, Add791)
{
	EXPECT_EQ(791+791,1582);
}

  

TEST(TestMath, Add792)
{
	EXPECT_EQ(792+792,1584);
}

  

TEST(TestMath, Add793)
{
	EXPECT_EQ(793+793,1586);
}

  

TEST(TestMath, Add794)
{
	EXPECT_EQ(794+794,1588);
}

  

TEST(TestMath, Add795)
{
	EXPECT_EQ(795+795,1590);
}

  

TEST(TestMath, Add796)
{
	EXPECT_EQ(796+796,1592);
}

  

TEST(TestMath, Add797)
{
	EXPECT_EQ(797+797,1594);
}

  

TEST(TestMath, Add798)
{
	EXPECT_EQ(798+798,1596);
}

  

TEST(TestMath, Add799)
{
	EXPECT_EQ(799+799,1598);
}

  

TEST(TestMath, Add800)
{
	EXPECT_EQ(800+800,1600);
}

  

TEST(TestMath, Add801)
{
	EXPECT_EQ(801+801,1602);
}

  

TEST(TestMath, Add802)
{
	EXPECT_EQ(802+802,1604);
}

  

TEST(TestMath, Add803)
{
	EXPECT_EQ(803+803,1606);
}

  

TEST(TestMath, Add804)
{
	EXPECT_EQ(804+804,1608);
}

  

TEST(TestMath, Add805)
{
	EXPECT_EQ(805+805,1610);
}

  

TEST(TestMath, Add806)
{
	EXPECT_EQ(806+806,1612);
}

  

TEST(TestMath, Add807)
{
	EXPECT_EQ(807+807,1614);
}

  

TEST(TestMath, Add808)
{
	EXPECT_EQ(808+808,1616);
}

  

TEST(TestMath, Add809)
{
	EXPECT_EQ(809+809,1618);
}

  

TEST(TestMath, Add810)
{
	EXPECT_EQ(810+810,1620);
}

  

TEST(TestMath, Add811)
{
	EXPECT_EQ(811+811,1622);
}

  

TEST(TestMath, Add812)
{
	EXPECT_EQ(812+812,1624);
}

  

TEST(TestMath, Add813)
{
	EXPECT_EQ(813+813,1626);
}

  

TEST(TestMath, Add814)
{
	EXPECT_EQ(814+814,1628);
}

  

TEST(TestMath, Add815)
{
	EXPECT_EQ(815+815,1630);
}

  

TEST(TestMath, Add816)
{
	EXPECT_EQ(816+816,1632);
}

  

TEST(TestMath, Add817)
{
	EXPECT_EQ(817+817,1634);
}

  

TEST(TestMath, Add818)
{
	EXPECT_EQ(818+818,1636);
}

  

TEST(TestMath, Add819)
{
	EXPECT_EQ(819+819,1638);
}

  

TEST(TestMath, Add820)
{
	EXPECT_EQ(820+820,1640);
}

  

TEST(TestMath, Add821)
{
	EXPECT_EQ(821+821,1642);
}

  

TEST(TestMath, Add822)
{
	EXPECT_EQ(822+822,1644);
}

  

TEST(TestMath, Add823)
{
	EXPECT_EQ(823+823,1646);
}

  

TEST(TestMath, Add824)
{
	EXPECT_EQ(824+824,1648);
}

  

TEST(TestMath, Add825)
{
	EXPECT_EQ(825+825,1650);
}

  

TEST(TestMath, Add826)
{
	EXPECT_EQ(826+826,1652);
}

  

TEST(TestMath, Add827)
{
	EXPECT_EQ(827+827,1654);
}

  

TEST(TestMath, Add828)
{
	EXPECT_EQ(828+828,1656);
}

  

TEST(TestMath, Add829)
{
	EXPECT_EQ(829+829,1658);
}

  

TEST(TestMath, Add830)
{
	EXPECT_EQ(830+830,1660);
}

  

TEST(TestMath, Add831)
{
	EXPECT_EQ(831+831,1662);
}

  

TEST(TestMath, Add832)
{
	EXPECT_EQ(832+832,1664);
}

  

TEST(TestMath, Add833)
{
	EXPECT_EQ(833+833,1666);
}

  

TEST(TestMath, Add834)
{
	EXPECT_EQ(834+834,1668);
}

  

TEST(TestMath, Add835)
{
	EXPECT_EQ(835+835,1670);
}

  

TEST(TestMath, Add836)
{
	EXPECT_EQ(836+836,1672);
}

  

TEST(TestMath, Add837)
{
	EXPECT_EQ(837+837,1674);
}

  

TEST(TestMath, Add838)
{
	EXPECT_EQ(838+838,1676);
}

  

TEST(TestMath, Add839)
{
	EXPECT_EQ(839+839,1678);
}

  

TEST(TestMath, Add840)
{
	EXPECT_EQ(840+840,1680);
}

  

TEST(TestMath, Add841)
{
	EXPECT_EQ(841+841,1682);
}

  

TEST(TestMath, Add842)
{
	EXPECT_EQ(842+842,1684);
}

  

TEST(TestMath, Add843)
{
	EXPECT_EQ(843+843,1686);
}

  

TEST(TestMath, Add844)
{
	EXPECT_EQ(844+844,1688);
}

  

TEST(TestMath, Add845)
{
	EXPECT_EQ(845+845,1690);
}

  

TEST(TestMath, Add846)
{
	EXPECT_EQ(846+846,1692);
}

  

TEST(TestMath, Add847)
{
	EXPECT_EQ(847+847,1694);
}

  

TEST(TestMath, Add848)
{
	EXPECT_EQ(848+848,1696);
}

  

TEST(TestMath, Add849)
{
	EXPECT_EQ(849+849,1698);
}

  

TEST(TestMath, Add850)
{
	EXPECT_EQ(850+850,1700);
}

  

TEST(TestMath, Add851)
{
	EXPECT_EQ(851+851,1702);
}

  

TEST(TestMath, Add852)
{
	EXPECT_EQ(852+852,1704);
}

  

TEST(TestMath, Add853)
{
	EXPECT_EQ(853+853,1706);
}

  

TEST(TestMath, Add854)
{
	EXPECT_EQ(854+854,1708);
}

  

TEST(TestMath, Add855)
{
	EXPECT_EQ(855+855,1710);
}

  

TEST(TestMath, Add856)
{
	EXPECT_EQ(856+856,1712);
}

  

TEST(TestMath, Add857)
{
	EXPECT_EQ(857+857,1714);
}

  

TEST(TestMath, Add858)
{
	EXPECT_EQ(858+858,1716);
}

  

TEST(TestMath, Add859)
{
	EXPECT_EQ(859+859,1718);
}

  

TEST(TestMath, Add860)
{
	EXPECT_EQ(860+860,1720);
}

  

TEST(TestMath, Add861)
{
	EXPECT_EQ(861+861,1722);
}

  

TEST(TestMath, Add862)
{
	EXPECT_EQ(862+862,1724);
}

  

TEST(TestMath, Add863)
{
	EXPECT_EQ(863+863,1726);
}

  

TEST(TestMath, Add864)
{
	EXPECT_EQ(864+864,1728);
}

  

TEST(TestMath, Add865)
{
	EXPECT_EQ(865+865,1730);
}

  

TEST(TestMath, Add866)
{
	EXPECT_EQ(866+866,1732);
}

  

TEST(TestMath, Add867)
{
	EXPECT_EQ(867+867,1734);
}

  

TEST(TestMath, Add868)
{
	EXPECT_EQ(868+868,1736);
}

  

TEST(TestMath, Add869)
{
	EXPECT_EQ(869+869,1738);
}

  

TEST(TestMath, Add870)
{
	EXPECT_EQ(870+870,1740);
}

  

TEST(TestMath, Add871)
{
	EXPECT_EQ(871+871,1742);
}

  

TEST(TestMath, Add872)
{
	EXPECT_EQ(872+872,1744);
}

  

TEST(TestMath, Add873)
{
	EXPECT_EQ(873+873,1746);
}

  

TEST(TestMath, Add874)
{
	EXPECT_EQ(874+874,1748);
}

  

TEST(TestMath, Add875)
{
	EXPECT_EQ(875+875,1750);
}

  

TEST(TestMath, Add876)
{
	EXPECT_EQ(876+876,1752);
}

  

TEST(TestMath, Add877)
{
	EXPECT_EQ(877+877,1754);
}

  

TEST(TestMath, Add878)
{
	EXPECT_EQ(878+878,1756);
}

  

TEST(TestMath, Add879)
{
	EXPECT_EQ(879+879,1758);
}

  

TEST(TestMath, Add880)
{
	EXPECT_EQ(880+880,1760);
}

  

TEST(TestMath, Add881)
{
	EXPECT_EQ(881+881,1762);
}

  

TEST(TestMath, Add882)
{
	EXPECT_EQ(882+882,1764);
}

  

TEST(TestMath, Add883)
{
	EXPECT_EQ(883+883,1766);
}

  

TEST(TestMath, Add884)
{
	EXPECT_EQ(884+884,1768);
}

  

TEST(TestMath, Add885)
{
	EXPECT_EQ(885+885,1770);
}

  

TEST(TestMath, Add886)
{
	EXPECT_EQ(886+886,1772);
}

  

TEST(TestMath, Add887)
{
	EXPECT_EQ(887+887,1774);
}

  

TEST(TestMath, Add888)
{
	EXPECT_EQ(888+888,1776);
}

  

TEST(TestMath, Add889)
{
	EXPECT_EQ(889+889,1778);
}

  

TEST(TestMath, Add890)
{
	EXPECT_EQ(890+890,1780);
}

  

TEST(TestMath, Add891)
{
	EXPECT_EQ(891+891,1782);
}

  

TEST(TestMath, Add892)
{
	EXPECT_EQ(892+892,1784);
}

  

TEST(TestMath, Add893)
{
	EXPECT_EQ(893+893,1786);
}

  

TEST(TestMath, Add894)
{
	EXPECT_EQ(894+894,1788);
}

  

TEST(TestMath, Add895)
{
	EXPECT_EQ(895+895,1790);
}

  

TEST(TestMath, Add896)
{
	EXPECT_EQ(896+896,1792);
}

  

TEST(TestMath, Add897)
{
	EXPECT_EQ(897+897,1794);
}

  

TEST(TestMath, Add898)
{
	EXPECT_EQ(898+898,1796);
}

  

TEST(TestMath, Add899)
{
	EXPECT_EQ(899+899,1798);
}

  

TEST(TestMath, Add900)
{
	EXPECT_EQ(900+900,1800);
}

  

TEST(TestMath, Add901)
{
	EXPECT_EQ(901+901,1802);
}

  

TEST(TestMath, Add902)
{
	EXPECT_EQ(902+902,1804);
}

  

TEST(TestMath, Add903)
{
	EXPECT_EQ(903+903,1806);
}

  

TEST(TestMath, Add904)
{
	EXPECT_EQ(904+904,1808);
}

  

TEST(TestMath, Add905)
{
	EXPECT_EQ(905+905,1810);
}

  

TEST(TestMath, Add906)
{
	EXPECT_EQ(906+906,1812);
}

  

TEST(TestMath, Add907)
{
	EXPECT_EQ(907+907,1814);
}

  

TEST(TestMath, Add908)
{
	EXPECT_EQ(908+908,1816);
}

  

TEST(TestMath, Add909)
{
	EXPECT_EQ(909+909,1818);
}

  

TEST(TestMath, Add910)
{
	EXPECT_EQ(910+910,1820);
}

  

TEST(TestMath, Add911)
{
	EXPECT_EQ(911+911,1822);
}

  

TEST(TestMath, Add912)
{
	EXPECT_EQ(912+912,1824);
}

  

TEST(TestMath, Add913)
{
	EXPECT_EQ(913+913,1826);
}

  

TEST(TestMath, Add914)
{
	EXPECT_EQ(914+914,1828);
}

  

TEST(TestMath, Add915)
{
	EXPECT_EQ(915+915,1830);
}

  

TEST(TestMath, Add916)
{
	EXPECT_EQ(916+916,1832);
}

  

TEST(TestMath, Add917)
{
	EXPECT_EQ(917+917,1834);
}

  

TEST(TestMath, Add918)
{
	EXPECT_EQ(918+918,1836);
}

  

TEST(TestMath, Add919)
{
	EXPECT_EQ(919+919,1838);
}

  

TEST(TestMath, Add920)
{
	EXPECT_EQ(920+920,1840);
}

  

TEST(TestMath, Add921)
{
	EXPECT_EQ(921+921,1842);
}

  

TEST(TestMath, Add922)
{
	EXPECT_EQ(922+922,1844);
}

  

TEST(TestMath, Add923)
{
	EXPECT_EQ(923+923,1846);
}

  

TEST(TestMath, Add924)
{
	EXPECT_EQ(924+924,1848);
}

  

TEST(TestMath, Add925)
{
	EXPECT_EQ(925+925,1850);
}

  

TEST(TestMath, Add926)
{
	EXPECT_EQ(926+926,1852);
}

  

TEST(TestMath, Add927)
{
	EXPECT_EQ(927+927,1854);
}

  

TEST(TestMath, Add928)
{
	EXPECT_EQ(928+928,1856);
}

  

TEST(TestMath, Add929)
{
	EXPECT_EQ(929+929,1858);
}

  

TEST(TestMath, Add930)
{
	EXPECT_EQ(930+930,1860);
}

  

TEST(TestMath, Add931)
{
	EXPECT_EQ(931+931,1862);
}

  

TEST(TestMath, Add932)
{
	EXPECT_EQ(932+932,1864);
}

  

TEST(TestMath, Add933)
{
	EXPECT_EQ(933+933,1866);
}

  

TEST(TestMath, Add934)
{
	EXPECT_EQ(934+934,1868);
}

  

TEST(TestMath, Add935)
{
	EXPECT_EQ(935+935,1870);
}

  

TEST(TestMath, Add936)
{
	EXPECT_EQ(936+936,1872);
}

  

TEST(TestMath, Add937)
{
	EXPECT_EQ(937+937,1874);
}

  

TEST(TestMath, Add938)
{
	EXPECT_EQ(938+938,1876);
}

  

TEST(TestMath, Add939)
{
	EXPECT_EQ(939+939,1878);
}

  

TEST(TestMath, Add940)
{
	EXPECT_EQ(940+940,1880);
}

  

TEST(TestMath, Add941)
{
	EXPECT_EQ(941+941,1882);
}

  

TEST(TestMath, Add942)
{
	EXPECT_EQ(942+942,1884);
}

  

TEST(TestMath, Add943)
{
	EXPECT_EQ(943+943,1886);
}

  

TEST(TestMath, Add944)
{
	EXPECT_EQ(944+944,1888);
}

  

TEST(TestMath, Add945)
{
	EXPECT_EQ(945+945,1890);
}

  

TEST(TestMath, Add946)
{
	EXPECT_EQ(946+946,1892);
}

  

TEST(TestMath, Add947)
{
	EXPECT_EQ(947+947,1894);
}

  

TEST(TestMath, Add948)
{
	EXPECT_EQ(948+948,1896);
}

  

TEST(TestMath, Add949)
{
	EXPECT_EQ(949+949,1898);
}

  

TEST(TestMath, Add950)
{
	EXPECT_EQ(950+950,1900);
}

  

TEST(TestMath, Add951)
{
	EXPECT_EQ(951+951,1902);
}

  

TEST(TestMath, Add952)
{
	EXPECT_EQ(952+952,1904);
}

  

TEST(TestMath, Add953)
{
	EXPECT_EQ(953+953,1906);
}

  

TEST(TestMath, Add954)
{
	EXPECT_EQ(954+954,1908);
}

  

TEST(TestMath, Add955)
{
	EXPECT_EQ(955+955,1910);
}

  

TEST(TestMath, Add956)
{
	EXPECT_EQ(956+956,1912);
}

  

TEST(TestMath, Add957)
{
	EXPECT_EQ(957+957,1914);
}

  

TEST(TestMath, Add958)
{
	EXPECT_EQ(958+958,1916);
}

  

TEST(TestMath, Add959)
{
	EXPECT_EQ(959+959,1918);
}

  

TEST(TestMath, Add960)
{
	EXPECT_EQ(960+960,1920);
}

  

TEST(TestMath, Add961)
{
	EXPECT_EQ(961+961,1922);
}

  

TEST(TestMath, Add962)
{
	EXPECT_EQ(962+962,1924);
}

  

TEST(TestMath, Add963)
{
	EXPECT_EQ(963+963,1926);
}

  

TEST(TestMath, Add964)
{
	EXPECT_EQ(964+964,1928);
}

  

TEST(TestMath, Add965)
{
	EXPECT_EQ(965+965,1930);
}

  

TEST(TestMath, Add966)
{
	EXPECT_EQ(966+966,1932);
}

  

TEST(TestMath, Add967)
{
	EXPECT_EQ(967+967,1934);
}

  

TEST(TestMath, Add968)
{
	EXPECT_EQ(968+968,1936);
}

  

TEST(TestMath, Add969)
{
	EXPECT_EQ(969+969,1938);
}

  

TEST(TestMath, Add970)
{
	EXPECT_EQ(970+970,1940);
}

  

TEST(TestMath, Add971)
{
	EXPECT_EQ(971+971,1942);
}

  

TEST(TestMath, Add972)
{
	EXPECT_EQ(972+972,1944);
}

  

TEST(TestMath, Add973)
{
	EXPECT_EQ(973+973,1946);
}

  

TEST(TestMath, Add974)
{
	EXPECT_EQ(974+974,1948);
}

  

TEST(TestMath, Add975)
{
	EXPECT_EQ(975+975,1950);
}

  

TEST(TestMath, Add976)
{
	EXPECT_EQ(976+976,1952);
}

  

TEST(TestMath, Add977)
{
	EXPECT_EQ(977+977,1954);
}

  

TEST(TestMath, Add978)
{
	EXPECT_EQ(978+978,1956);
}

  

TEST(TestMath, Add979)
{
	EXPECT_EQ(979+979,1958);
}

  

TEST(TestMath, Add980)
{
	EXPECT_EQ(980+980,1960);
}

  

TEST(TestMath, Add981)
{
	EXPECT_EQ(981+981,1962);
}

  

TEST(TestMath, Add982)
{
	EXPECT_EQ(982+982,1964);
}

  

TEST(TestMath, Add983)
{
	EXPECT_EQ(983+983,1966);
}

  

TEST(TestMath, Add984)
{
	EXPECT_EQ(984+984,1968);
}

  

TEST(TestMath, Add985)
{
	EXPECT_EQ(985+985,1970);
}

  

TEST(TestMath, Add986)
{
	EXPECT_EQ(986+986,1972);
}

  

TEST(TestMath, Add987)
{
	EXPECT_EQ(987+987,1974);
}

  

TEST(TestMath, Add988)
{
	EXPECT_EQ(988+988,1976);
}

  

TEST(TestMath, Add989)
{
	EXPECT_EQ(989+989,1978);
}

  

TEST(TestMath, Add990)
{
	EXPECT_EQ(990+990,1980);
}

  

TEST(TestMath, Add991)
{
	EXPECT_EQ(991+991,1982);
}

  

TEST(TestMath, Add992)
{
	EXPECT_EQ(992+992,1984);
}

  

TEST(TestMath, Add993)
{
	EXPECT_EQ(993+993,1986);
}

  

TEST(TestMath, Add994)
{
	EXPECT_EQ(994+994,1988);
}

  

TEST(TestMath, Add995)
{
	EXPECT_EQ(995+995,1990);
}

  

TEST(TestMath, Add996)
{
	EXPECT_EQ(996+996,1992);
}

  

TEST(TestMath, Add997)
{
	EXPECT_EQ(997+997,1994);
}

  

TEST(TestMath, Add998)
{
	EXPECT_EQ(998+998,1996);
}

  

TEST(TestMath, Add999)
{
	EXPECT_EQ(999+999,1998);
}