ÿØÿà JFIF    ÿÛ „  ( %"1!%)+...383,7(-.+  -+++--++++---+-+-----+---------------+---+-++7-----ÿÀ  ß â" ÿÄ     ÿÄ H    !1AQaq"‘¡2B±ÁÑð#R“Ò Tbr‚²á3csƒ’ÂñDS¢³$CÿÄ   ÿÄ %  !1AQa"23‘ÿÚ   ? ôÿ ¨pŸªáÿ —åYõõ\?àÒü©ŠÄï¨pŸªáÿ —åYõõ\?àÓü©ŠÄá 0Ÿªáÿ Ÿå[úƒ ú®ði~TÁbqÐ8OÕpÿ ƒOò¤Oè`–RÂáœá™êi€ßÉ< FtŸI“öÌ8úDf´°å}“¾œ6  öFá°y¥jñÇh†ˆ¢ã/ÃÐ:ªcÈ "Y¡ðÑl>ÿ ”ÏËte:qž\oäŠe÷󲍷˜HT4&ÿ ÓÐü6ö®¿øþßèô Ÿ•7Ñi’•j|“ñì>b…þS?*Óôÿ ÓÐü*h¥£ír¶ü UãSç‚Ÿ[AÐaè[ûª•õ&õj?†Éö+EzP—WeÒírJFt ‘BŒ†Ï‡%#tE Øz ¥OÛ«!1›üä±Í™%ºÍãö]°î(–:@<‹ŒÊö×òÆt¦ãº+‡¦%ÌÁ²h´OƒJŒtMÜ>ÀÜÊw3Y´•牋4ǍýʏTì>œú=Íwhyë,¾Ôò×õ¿ßÊa»«þˆѪQ|%6ž™A õ%:øj<>É—ÿ Å_ˆCbõ¥š±ý¯Ýƒï…¶|RëócÍf溪“t.СøTÿ *Ä¿-{†çàczůŽ_–^XþŒ±miB[X±d 1,é”zEù»& î9gœf™9Ð'.;—™i}!ôšåîqêÛ٤ёý£½ÆA–àôe"A$˝Úsäÿ ÷Û #°xŸëí(l »ý3—¥5m! rt`†0~'j2(]S¦¦kv,ÚÇ l¦øJA£Šƒ J3E8ÙiŽ:cÉžúeZ°€¯\®kÖ(79«Ž:¯X”¾³Š&¡* ….‰Ž(ÜíŸ2¥ª‡×Hi²TF¤ò[¨íÈRëÉ䢍mgÑ.Ÿ<öäS0í„ǹÁU´f#Vß;Õ–…P@3ío<ä-±»Ž.L|kªÀê›fÂ6@»eu‚|ÓaÞÆŸ…¨ááå>åŠ?cKü6ùTÍÆ”†sĤÚ;H2RÚ†õ\Ö·Ÿn'¾ ñ#ºI¤Å´%çÁ­‚â7›‹qT3Iï¨ÖÚ5I7Ë!ÅOóŸ¶øÝñØôת¦$Tcö‘[«Ö³šÒ';Aþ ¸èíg A2Z"i¸vdÄ÷.iõ®§)¿]¤À†–‡É&ä{V¶iŽ”.Ó×Õÿ û?h¬Mt–íª[ÿ Ñÿ ÌV(í}=ibÔ¡›¥¢±b Lô¥‡piη_Z<‡z§èŒ)iÖwiÇ 2hÙ3·=’d÷8éŽ1¦¸c¤µ€7›7Ø ð\á)} ¹fËí›pAÃL%âc2 í§æQz¿;T8sæ°qø)QFMð‰XŒÂ±N¢aF¨…8¯!U  Z©RÊ ÖPVÄÀÍin™Ì-GˆªÅËŠ›•zË}º±ŽÍFò¹}Uw×#ä5B¤{î}Ð<ÙD é©¤&‡ïDbàÁôMÁ." ¤‡ú*õ'VŽ|¼´Úgllº¼klz[Æüï÷Aób‡Eÿ dÑ»Xx9ÃÜ£ÁT/`¼¸vI±Ýµ·Ë‚“G³þ*Ÿû´r|*}<¨îºœ @¦mÄ’M¹”.œ«Y–|6ÏU¤jç¥ÕÞqO ˜kDÆÁ¨5ÿ š;Њ¦¦€GÙk \ –Þ=â¼=SͧµªS°ÚÍpÜãQűÀõ¬?ÃÁ1Ñ•õZà?hóœ€ L¦l{Y*K˜Ù›zc˜–ˆâ ø+¾ ­-Ök¥%ùEÜA'}ˆ><ÊIè“bpÍ/qÞâvoX€w,\úªò6Z[XdÒæ­@Ö—€$òJí#é>'°Ú ôª˜<)4ryÙ£|óAÅn5žêŸyÒäMÝ2{"}‰–¤l÷ûWX\l¾Á¸góÉOÔ /óñB¤f¸çñ[.P˜ZsÊË*ßT܈§QN¢’¡¨§V¼(Üù*eÕ“”5T¨‹Âê¥FŒã½Dü[8'Ò¥a…Ú¶k7a *•›¼'Ò·\8¨ª\@\õ¢¦íq+DÙrmÎ…_ªæ»ŠÓœ¡¯’Ré9MÅ×D™lælffc+ŒÑ,ý™ÿ ¯þǤ=Å’Á7µ÷ÚÛ/“Ü€ñýã¼àí¾ÕÑ+ƒ,uµMâÀÄbm:ÒÎPæ{˜Gz[ƒ¯«® KHà`ßØŠéí¯P8Aq.C‰ à€kòpj´kN¶qô€…Õ,ÜNŠª-­{Zö’æû44‰sŽè‰îVíRœÕm" 6?³D9¡ÇTíÅꋇ`4«¸ÝÁô ï’ýorqКÇZ«x4Žâéþuïf¹µö[P ,Q£éaX±`PÉÍZ ¸äYúg üAx ’6Lê‚xÝÓ*äQ  Ï’¨hÍ =²,6ï#rÃ<¯–£»ƒ‹,–ê•€ aÛsñ'%Æ"®ÛüìBᝠHÚ3ß°©$“XnœÖ’î2ËTeûìxîß ¦å¿çÉ ðK§þ{‘t‚Ϋ¬jéîZ[ ”š7L¥4VÚCE×]m¤Øy”ä4-dz£œ§¸x.*ãÊÊ b÷•h:©‡¦s`BTÁRû¾g⻩‹jø sF¢àJøFl‘È•Xᓁà~*j¯ +(ÚÕ6-£¯÷GŠØy‚<Ç’.F‹Hœw(+)ÜÜâÈzÄäT§FߘãÏ;DmVœ3Àu@mÚüXÝü•3B¨òÌÁÛ<·ÃÜ z,Ì@õÅ·d2]ü8s÷IôÞ¯^Ç9¢u„~ëAŸï4«M? K]­ÅàPl@s_ p:°¬ZR”´›JC[CS.h‹ƒïËœ«Æ]–÷ó‚wR×k7X‰k›‘´ù¦=¡«‰¨¨Â')—71ó’c‡Ðúµ `é.{§p¹ój\Ž{1h{o±Ý=áUÊïGÖŒõ–-BÄm+AZX¶¡ ïHðæ¥JmÙ;…ä¡Ÿˆ¦ ° äšiÉg«$üMk5¤L“’çÊvïâï ,=f“"íἊ5ô¬x6{ɏžID0e¸vçmi'︧ºð9$ò¹÷*£’9ÿ ²TÔ…×>JV¥}Œ}$p[bÔ®*[jzS*8 ”·T›Í–ñUîƒwo$áè=LT™ç—~ô·¤ÈÚ$榍q‰„+´kFm)ž‹©i–ËqÞŠ‰à¶ü( ‚•§ •°ò·‡#5ª•µÊ﯅¡X¨šÁ*F#TXJÊ ušJVÍ&=iÄs1‚3•'fý§5Ñ<=[íÞ­ PÚ;ѱÌ_~Ä££8rÞ ²w;’hDT°>ÈG¬8Á²ÚzŽ®ò®qZcqJêäÞ-ö[ܘbň±çb“Š¶31²n×iƒðÕ;1¶þÉ ªX‰,ßqÏ$>•î íZ¥Z 1{ç൵+ƒÕµ¥°T$§K]á»Ûï*·¤tMI’ÂZbŽÕiÒ˜}bÓ0£ª5›¨ [5Ž^ÝœWøÂÝh° ¢OWun£¤5 a2Z.G2³YL]jåtì”ä ÁÓ‘%"©<ÔúÊ°sº UZvä‡ÄiÆÒM .÷V·™ø#kèýiíÌ–ª)µT[)BˆõÑ xB¾B€ÖT¨.¥~ð@VĶr#¸ü*åZNDŽH;âi ],©£öØpù(šºãö¼T.uCê•4@ÿ GÕÛ)Cx›®0ø#:ÏðFÒbR\(€€Ä®fã4Þ‰Fä¯HXƒÅ,†öEÑÔÜ]Öv²?tLÃvBY£ú6Êu5ÅAQ³1‘’¬x–HŒÐ‡ ^ ¸KwJôÖŽ5×CÚ¨vÜ«/B0$×k°=ðbÇ(Ï)w±A†Á† 11Í=èQšµ626ŒÜ/`G«µ<}—-Ö7KEHÈÉðóȤmݱû±·ø«Snmá=“ä«šmݱŸ¡¶~ó·“äUóJæúòB|E LêŽy´jDÔ$G¢þÐñ7óR8ýÒ…Ç› WVe#·Ÿ p·Fx~•ݤF÷0Èÿ K¯æS<6’¡WШ; ´ÿ ¥Êø\Òuî†åÝ–VNœkÒ7oòX¨Á­Ø÷FÎÑä±g÷ÿ M~Çî=p,X´ ÝÌÚÅ‹’ÃjÖ.ØöÏñ qïQ¤ÓZE†° =6·]܈ s¸>v•Ž^Ý\wq9r‰Î\¸¡kURÒ$­*‹Nq?Þª*!sŠÆ:TU_u±T+øX¡ ®¹¡,ÄâÃBTsÜ$Ø›4m椴zÜK]’’›Pƒ @€#â˜`é¹=I‡fiV•Ôî“nRm+µFPOhÍ0B£ €+¬5c v•:P'ÒyÎ ‰V~‚Ó†ÖuókDoh$å\*ö%Ю=£«…aȼ½÷Û.-½VŒŠ¼'lyî±1¬3ó#ÞE¿ÔS¤gV£m›=§\û"—WU¤ÚǼÿ ÂnÁGŒÃ ‚õN D³õNÚíŒÕ;HôyÄÈ©P¹Ä{:?R‘Ô¨âF÷ø£bÅó® JS|‚R÷ivýáâ€Æé¡è³´IئÑT!§˜•Øª‚¬â@q€wnïCWÄ@JU€ê¯m6]Ï:£âx'+ÒðXvÓ¦Úm=–´7œ $ì“B£~p%ÕŸUþ« N@¼üï~w˜ñø5®—'Ôe»¤5ã//€ž~‰Tþ›Å7•#¤× Íö pÄ$ùeåì*«ÓŠEØWEÈsßg ¦ûvžSsLpºÊW–âµEWöˬH; ™!CYõZ ÃÄf æ#1W. \uWâ\,\Çf j’<qTbên›Î[vxx£ë 'ö¨1›˜ÀM¼Pÿ H)ƒêêŒA7s,|F“ 꺸k³9Ìö*ç®;Ö!Ö$Eiž•¹ÒÚ†ýóéÝû¾ÕS®ó$’NÝäŸz¤5r¦ãÄÃD÷Üø!°ø‡Ô&@m™Ì^Ãä­d q5Lnÿ N;.6½·N|#ä"1Nƒx“ã<3('&ñßt  ~ªu”1Tb㫨9ê–›–bìd$ߣ=#ÕãÒmU¯eí$EFù5ýYô櫨æ왍Ǘ±ssM]·á¿0ÕåJRÓªîiƒ+O58ÖñªŠÒx" \µâá¨i’¤i —Ö ” M+M¤ë9‚‰A¦°Qõ¾ßøK~¼Ã‘g…Ö´~÷Ï[3GUœÒ½#…kàÔ®Ò”‰³·dWV‰IP‰Ú8u¹”E ÖqLj¾êÕCBš{A^Âß;–¨`¯¬ìö ˼ ×tìø.tƐm*n¨y4o&Àx¥n¦×î‡aupáÛj8¿m›è¶ã!o½;ß0y^ý×^EÑ¿ÒjzŒ­)vÚÑnÄL …^ªô× ‡—‚3k Îý­hï]içå–îÏ*÷ñþ»Ô CÒjøjÍznˆ´ ¹#b'Fô‹ ‰v¥'’à'T´ƒHýÍ%M‰ ƒ&ÆÇŒï1 ‘ –Þ ‰i¬s žR-Ÿ kŠ¬á¬7:þ 0ŒÅÒÕ/aÙ¬ÃÝ#Úøœ ©aiVc‰. ¹¦ãµ” ›Yg¦›ÆÎýº°f³7ƒhá·¸­}&D9¡ÂsÉÙÞèŠõØàC™¨ñbFC|´Ü(ŸƒÚÒ-%»'a Ì¿)ËÇn¿úÿ ÞŽX…4ÊÅH^ôΑí@ù¹Eh¶“L8Çjù ¼ÎåVªóR©Ï5uà V4lZß®=€xÖŸ–ÑÈ ÷”¨°¾__yM1tÉ?uÆþIkÄgæ@þ[¢†°XÃJ£j·:nkÅ¢u ‘}âGzö­/IµèŠ¬¼48q¦F°ŽR¼=ûì{´¯RýicS ÕÛ íNtÍÙï£,w4rêì®»~x(©Uñ§#Ñ&œÕ¤>ÎåÍÓ9’Ö{9eV­[Öjâ²ãu]˜å2›qÑšÕJç0€sÄ|Êëè0튔bÁ>“{×_F`Ø©ºê:µä,v¤ðfc1±"«ÔÍän1#=· Âøv~H½ÐßA¾¿Ü€Óš]Õ; I¾÷ç‚Qi†î¹9ywÔKG˜áñ zQY—§ÃÕZ07§X‚ Áh;ÁM)iÌCH-¯T‘ë|A0{Ò½LÚ–TâÖkÜ’dÀ“rmm»”جPF³ÖcbE§T€ÒxKºû’Ó®7±²(\4ŽÃ¸Uu@j™yĵ;³µ!Á¢b.W¤=mõ´êµK k ¸K^ÜÛ#p*Ü14qkZç5ïë †°5Ï%ÍÛ<Õ¤×Ô¥ê†C Õ´¼ú$ƒÖ“”]Ù¬qÞÚ[4©ý!ûÏ—Áb쳐XµA¬â~`›Çr¸8ìùÝ䫦<>ä÷«?xs´ÇÑ /á;¹øüÊÈÙà{"@Žïzâ¬[âß‚ U_<ÇŸ½4èN˜ú61®qŠu ¦þF£»äJ_ˆÙÎ~ ÞAã–Ý„Ï—rŠD;xTž‘ô`É«…suãO`?³à™ô Lý#Íc5öoæØ‚y´´÷«ZR§<&JÇ+éâô´€i!Àˆ0æAoàðLèÖ-2ŸõW.’t^–(KÁmHµV@xÜÇy®Ñø­â^:Ú3w· 7½¹°ñ¸â¹®:',«Mœ—n­Á+Ãbš LÈ‘ÄnRÓÅœ%¦²‰¨ùQ:¤f‚ "PÕtô¸…cæl…&˜Ú˜Ôkv‹ž+vŠ,=¢v­6—Xy*¥t£«<™:“aîϲ=¦6rO]XI¿Œ÷¤zÚ­›¶ 6÷”w\d ü~v®ˆÌk«^m<ÿ ¢‰Õ\)ùºŽ;… lîÙÅEŠ®cѾ@vnMÏ,¼“ñ•ŽBxðÃzãÇç%3ˆ"}Ù•Åî> BÉú;Ò]V+P˜F_´ßé> Øše|ï‡ÄOmFæÇ ãqÞ$/xÐx­z`ï9"œÜij‚!7.\Td…9M‡•iŽ‹¾‘50ÞŽn¥ß4ÉôO ¹*í^QêËÜÇÌ8=Ž§s‰'ÂëÙ«á%Pú[O †ÅP¯VsŽ°.‰,kc¶ ¬A9n˜XÎ-ÞšN["¹QÕ‰ƒMýÁߺXJæÍaLj¾×Ãmã¾ãÚ uñÒþåQô¦¥ /ÄUx:‚ÍÜ’ Đ©ØÝ3V¨‰ÕnÐ6ó*óúK­«…c ¯U òhsý­jóÔj#,ímŒRµ«lbïUTŒÑ8†Ä0œÏr`ð¡¬É Ї ë"À² ™ 6¥ f¶ ¢ÚoܱԷ-<Àî)†a¶ž'Ú»¨TXqØæ¶÷YÄHy˜9ÈIW­YÀuMFë ºÏ’AqÌ4·/Ú †ô'i$øä­=Ä Ý|öK×40è|È6p‘0§)o¥ctî§H+CA-“ xØ|ÐXŠç l8íºð3Ø:³¤¬KX¯UÿÙ // runoutput // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Generate test of 64-bit arithmetic. // Most synthesized routines have different cases for // constants vs variables and even the generated code has // different cases for large and small constants, // so try a good range of inputs. package main import ( "bufio" "fmt" "os" ) var bout *bufio.Writer // 64-bit math without using 64-bit numbers, // so that we can generate the test program even // if the compiler has buggy or missing 64-bit support. type Uint64 struct { hi uint32 lo uint32 } type Int64 struct { hi int32 lo uint32 } func (a Uint64) Int64() (c Int64) { c.hi = int32(a.hi) c.lo = a.lo return } func (a Uint64) Cmp(b Uint64) int { switch { case a.hi < b.hi: return -1 case a.hi > b.hi: return 1 case a.lo < b.lo: return -1 case a.lo > b.lo: return 1 } return 0 } func (a Uint64) LeftShift(b uint) (c Uint64) { switch { case b >= 64: c.hi = 0 c.lo = 0 case b >= 32: c.hi = a.lo << (b - 32) c.lo = 0 default: c.hi = a.hi<>(32-b) c.lo = a.lo << b } return } func (a Uint64) RightShift(b uint) (c Uint64) { switch { case b >= 64: c.hi = 0 c.lo = a.hi case b >= 32: c.hi = 0 c.lo = a.hi >> (b - 32) default: c.hi = a.hi >> b c.lo = a.hi<<(32-b) | a.lo>>b } return } func (a Uint64) LeftShift64(b Uint64) (c Uint64) { if b.hi != 0 || b.lo >= 64 { return } return a.LeftShift(uint(b.lo)) } func (a Uint64) RightShift64(b Uint64) (c Uint64) { if b.hi != 0 || b.lo >= 64 { return } return a.RightShift(uint(b.lo)) } func (a Uint64) Plus(b Uint64) (c Uint64) { var carry uint32 if c.lo = a.lo + b.lo; c.lo < a.lo { carry = 1 } c.hi = a.hi + b.hi + carry return } func (a Uint64) Minus(b Uint64) (c Uint64) { var borrow uint32 if c.lo = a.lo - b.lo; c.lo > a.lo { borrow = 1 } c.hi = a.hi - b.hi - borrow return } func (a Uint64) Neg() (c Uint64) { var zero Uint64 return zero.Minus(a) } func (a Uint64) Com() (c Uint64) { c.hi = ^a.hi c.lo = ^a.lo return } func (a Uint64) Len() int { switch { case a.hi != 0: for i := 31; i >= 0; i-- { if a.hi&(1<= 0; i-- { if a.lo&(1<= 64: return false case b >= 32: return a.hi&(1<<(b-32)) != 0 } return a.lo&(1<= 0 { b = b.LeftShift(uint(n)) for i := 0; i <= n; i++ { quo = quo.LeftShift(1) if b.Cmp(a) <= 0 { // b <= a quo.lo |= 1 a = a.Minus(b) } b = b.RightShift(1) } } rem = a return } func (a Uint64) And(b Uint64) (c Uint64) { c.hi = a.hi & b.hi c.lo = a.lo & b.lo return } func (a Uint64) AndNot(b Uint64) (c Uint64) { c.hi = a.hi &^ b.hi c.lo = a.lo &^ b.lo return } func (a Uint64) Or(b Uint64) (c Uint64) { c.hi = a.hi | b.hi c.lo = a.lo | b.lo return } func (a Uint64) Xor(b Uint64) (c Uint64) { c.hi = a.hi ^ b.hi c.lo = a.lo ^ b.lo return } func (a Uint64) String() string { return fmt.Sprintf("%#x%08x", a.hi, a.lo) } func (a Int64) Uint64() (c Uint64) { c.hi = uint32(a.hi) c.lo = a.lo return } func (a Int64) Cmp(b Int64) int { // Same body as Uint64.Cmp, // but behaves differently // because hi is uint32 not int32. switch { case a.hi < b.hi: return -1 case a.hi > b.hi: return 1 case a.lo < b.lo: return -1 case a.lo > b.lo: return 1 } return 0 } func (a Int64) LeftShift(b uint) (c Int64) { return a.Uint64().LeftShift(b).Int64() } func (a Int64) RightShift(b uint) (c Int64) { switch { case b >= 64: c.hi = a.hi >> 31 // sign extend c.lo = uint32(c.hi) case b >= 32: c.hi = a.hi >> 31 // sign extend c.lo = uint32(a.hi >> (b - 32)) default: c.hi = a.hi >> b c.lo = uint32(a.hi<<(32-b)) | a.lo>>b } return } func (a Int64) LeftShift64(b Uint64) (c Int64) { if b.hi != 0 || b.lo >= 64 { return } return a.LeftShift(uint(b.lo)) } func (a Int64) RightShift64(b Uint64) (c Int64) { if b.hi != 0 || b.lo >= 64 { return a.RightShift(64) } return a.RightShift(uint(b.lo)) } func (a Int64) Plus(b Int64) (c Int64) { return a.Uint64().Plus(b.Uint64()).Int64() } func (a Int64) Minus(b Int64) (c Int64) { return a.Uint64().Minus(b.Uint64()).Int64() } func (a Int64) Neg() (c Int64) { return a.Uint64().Neg().Int64() } func (a Int64) Com() (c Int64) { return a.Uint64().Com().Int64() } func (a Int64) Times(b Int64) (c Int64) { return a.Uint64().Times(b.Uint64()).Int64() } func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) { var zero Int64 quoSign := +1 remSign := +1 if a.Cmp(zero) < 0 { quoSign = -1 remSign = -1 a = a.Neg() } if b.Cmp(zero) < 0 { quoSign = -quoSign b = b.Neg() } q, r := a.Uint64().DivMod(b.Uint64()) quo = q.Int64() rem = r.Int64() if quoSign < 0 { quo = quo.Neg() } if remSign < 0 { rem = rem.Neg() } return } func (a Int64) And(b Int64) (c Int64) { return a.Uint64().And(b.Uint64()).Int64() } func (a Int64) AndNot(b Int64) (c Int64) { return a.Uint64().AndNot(b.Uint64()).Int64() } func (a Int64) Or(b Int64) (c Int64) { return a.Uint64().Or(b.Uint64()).Int64() } func (a Int64) Xor(b Int64) (c Int64) { return a.Uint64().Xor(b.Uint64()).Int64() } func (a Int64) String() string { if a.hi < 0 { return fmt.Sprintf("-%s", a.Neg().Uint64()) } return a.Uint64().String() } var int64Values = []Int64{ Int64{0, 0}, Int64{0, 1}, Int64{0, 2}, Int64{0, 3}, Int64{0, 100}, Int64{0, 10001}, Int64{0, 1<<31 - 1}, Int64{0, 1 << 31}, Int64{0, 1<<31 + 1}, Int64{0, 1<<32 - 1<<30}, Int64{0, 1<<32 - 1}, Int64{1, 0}, Int64{1, 1}, Int64{2, 0}, Int64{1<<31 - 1, 1<<32 - 10000}, Int64{1<<31 - 1, 1<<32 - 1}, Int64{0x789abcde, 0xf0123456}, Int64{-1, 1<<32 - 1}, Int64{-1, 1<<32 - 2}, Int64{-1, 1<<32 - 3}, Int64{-1, 1<<32 - 100}, Int64{-1, 1<<32 - 10001}, Int64{-1, 1<<32 - (1<<31 - 1)}, Int64{-1, 1<<32 - 1<<31}, Int64{-1, 1<<32 - (1<<31 + 1)}, Int64{-1, 1<<32 - (1<<32 - 1<<30)}, Int64{-1, 0}, Int64{-1, 1}, Int64{-2, 0}, Int64{-(1 << 31), 10000}, Int64{-(1 << 31), 1}, Int64{-(1 << 31), 0}, Int64{-0x789abcde, 0xf0123456}, } var uint64Values = []Uint64{ Uint64{0, 0}, Uint64{0, 1}, Uint64{0, 2}, Uint64{0, 3}, Uint64{0, 100}, Uint64{0, 10001}, Uint64{0, 1<<31 - 1}, Uint64{0, 1 << 31}, Uint64{0, 1<<31 + 1}, Uint64{0, 1<<32 - 1<<30}, Uint64{0, 1<<32 - 1}, Uint64{1, 0}, Uint64{1, 1}, Uint64{2, 0}, Uint64{1<<31 - 1, 1<<32 - 10000}, Uint64{1<<31 - 1, 1<<32 - 1}, Uint64{1<<32 - 1<<30, 0}, Uint64{1<<32 - 1, 0}, Uint64{1<<32 - 1, 1<<32 - 100}, Uint64{1<<32 - 1, 1<<32 - 1}, Uint64{0x789abcde, 0xf0123456}, Uint64{0xfedcba98, 0x76543210}, } var shiftValues = []Uint64{ Uint64{0, 0}, Uint64{0, 1}, Uint64{0, 2}, Uint64{0, 3}, Uint64{0, 15}, Uint64{0, 16}, Uint64{0, 17}, Uint64{0, 31}, Uint64{0, 32}, Uint64{0, 33}, Uint64{0, 61}, Uint64{0, 62}, Uint64{0, 63}, Uint64{0, 64}, Uint64{0, 65}, Uint64{0, 1<<32 - 1}, Uint64{1, 0}, Uint64{1, 1}, Uint64{1 << 28, 0}, Uint64{1 << 31, 0}, Uint64{1<<32 - 1, 0}, Uint64{1<<32 - 1, 1<<32 - 1}, } var ntest = 0 // Part 1 is tests of variable operations; generic functions // called by repetitive code. Could make a table but not worth it. const prolog = "\n" + "package main\n" + "\n" + "import \"os\"\n" + "\n" + "var ok = true\n" + "\n" + "func testInt64Unary(a, plus, xor, minus int64) {\n" + " if n, op, want := +a, `+`, plus; n != want { ok=false; println(`int64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := ^a, `^`, xor; n != want { ok=false; println(`int64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := -a, `-`, minus; n != want { ok=false; println(`int64`, op, a, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testInt64Binary(a, b, add, sub, mul, div, mod, and, or, xor, andnot int64, dodiv bool) {\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a * b, `*`, mul; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a % b, `%`, mod; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a | b, `|`, or; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testInt64Shift(a int64, b uint64, left, right int64) {\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if uint64(uint(b)) == b {\n" + " b := uint(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint32(b)) == b {\n" + " b := uint32(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint16(b)) == b {\n" + " b := uint16(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint8(b)) == b {\n" + " b := uint8(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" + "\n" + "func testUint64Unary(a, plus, xor, minus uint64) {\n" + " if n, op, want := +a, `+`, plus; n != want { ok=false; println(`uint64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := ^a, `^`, xor; n != want { ok=false; println(`uint64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := -a, `-`, minus; n != want { ok=false; println(`uint64`, op, a, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testUint64Binary(a, b, add, sub, mul, div, mod, and, or, xor, andnot uint64, dodiv bool) {\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a * b, `*`, mul; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a % b, `%`, mod; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a | b, `|`, or; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testUint64Shift(a, b, left, right uint64) {\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if uint64(uint(b)) == b {\n" + " b := uint(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint32(b)) == b {\n" + " b := uint32(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint16(b)) == b {\n" + " b := uint16(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint8(b)) == b {\n" + " b := uint8(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" + "\n" func varTests() { fmt.Fprint(bout, prolog) for _, a := range int64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ fmt.Fprintf(bout, "\ttestInt64Unary(%v, %v, %v, %v);\n", a, a, a.Com(), a.Neg()) for _, b := range int64Values { var div, mod Int64 dodiv := false var zero Int64 if b.Cmp(zero) != 0 { // b != 0 // Can't divide by zero but also can't divide -0x8000...000 by -1. var bigneg = Int64{-0x80000000, 0} var minus1 = Int64{-1, ^uint32(0)} if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 { // a != -1<<63 || b != -1 div, mod = a.DivMod(b) dodiv = true } } fmt.Fprintf(bout, "\ttestInt64Binary(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", a, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for _, b := range shiftValues { fmt.Fprintf(bout, "\ttestInt64Shift(%v, %v, %v, %v);\n", a, b, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } for _, a := range uint64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ fmt.Fprintf(bout, "\ttestUint64Unary(%v, %v, %v, %v);\n", a, a, a.Com(), a.Neg()) for _, b := range uint64Values { var div, mod Uint64 dodiv := false var zero Uint64 if b.Cmp(zero) != 0 { // b != 0 div, mod = a.DivMod(b) dodiv = true } fmt.Fprintf(bout, "\ttestUint64Binary(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", a, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for _, b := range shiftValues { fmt.Fprintf(bout, "\ttestUint64Shift(%v, %v, %v, %v);\n", a, b, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } } // Part 2 is tests of operations involving one variable and one constant. const binaryConstL = "func test%vBinaryL%v(b, add, sub, mul, div, mod, and, or, xor, andnot %v, dodiv bool) {\n" + " const a %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a * b, `*`, mul; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a %% b, `%%`, mod; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a | b, `|`, or; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" const binaryConstR = "func test%vBinaryR%v(a, add, sub, mul, div, mod, and, or, xor, andnot %v, dodiv bool) {\n" + " const b %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a * b, `*`, mul; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a %% b, `%%`, mod; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a | b, `|`, or; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" const binaryConstR0 = "func test%vBinaryR%v(a, add, sub, mul, div, mod, and, or, xor, andnot %v, dodiv bool) {\n" + " const b %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a * b, `*`, mul; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a | b, `|`, or; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" const shiftConstL = "func test%vShiftL%v(b uint64, left, right %v) {\n" + " const a %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " if uint64(uint32(b)) == b {\n" + " b := uint32(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" const shiftConstR = "func test%vShiftR%v(a, left, right %v) {\n" + " const b uint64 = %v;\n" + " const typ = `%s`;\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " if b & 0xffffffff == b {\n" + " const b = uint32(b & 0xffffffff);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" func constTests() { for i, a := range int64Values { fmt.Fprintf(bout, binaryConstL, "Int64", i, "int64", "int64", a, "int64") if a.hi == 0 && a.lo == 0 { fmt.Fprintf(bout, binaryConstR0, "Int64", i, "int64", "int64", a, "int64") } else { fmt.Fprintf(bout, binaryConstR, "Int64", i, "int64", "int64", a, "int64") } fmt.Fprintf(bout, shiftConstL, "Int64", i, "int64", "int64", a, "int64") } for i, a := range uint64Values { fmt.Fprintf(bout, binaryConstL, "Uint64", i, "uint64", "uint64", a, "uint64") if a.hi == 0 && a.lo == 0 { fmt.Fprintf(bout, binaryConstR0, "Uint64", i, "uint64", "uint64", a, "uint64") } else { fmt.Fprintf(bout, binaryConstR, "Uint64", i, "uint64", "uint64", a, "uint64") } fmt.Fprintf(bout, shiftConstL, "Uint64", i, "uint64", "uint64", a, "uint64") } for i, a := range shiftValues { fmt.Fprintf(bout, shiftConstR, "Int64", i, "int64", a, "int64") fmt.Fprintf(bout, shiftConstR, "Uint64", i, "uint64", a, "uint64") } for i, a := range int64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ for j, b := range int64Values { var div, mod Int64 dodiv := false var zero Int64 if b.Cmp(zero) != 0 { // b != 0 // Can't divide by zero but also can't divide -0x8000...000 by -1. var bigneg = Int64{-0x80000000, 0} var minus1 = Int64{-1, ^uint32(0)} if a.Cmp(bigneg) != 0 || b.Cmp(minus1) != 0 { // a != -1<<63 || b != -1 div, mod = a.DivMod(b) dodiv = true } } fmt.Fprintf(bout, "\ttestInt64BinaryL%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", i, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) fmt.Fprintf(bout, "\ttestInt64BinaryR%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", j, a, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for j, b := range shiftValues { fmt.Fprintf(bout, "\ttestInt64ShiftL%v(%v, %v, %v);\n", i, b, a.LeftShift64(b), a.RightShift64(b)) fmt.Fprintf(bout, "\ttestInt64ShiftR%v(%v, %v, %v);\n", j, a, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } for i, a := range uint64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ for j, b := range uint64Values { var div, mod Uint64 dodiv := false var zero Uint64 if b.Cmp(zero) != 0 { // b != 0 div, mod = a.DivMod(b) dodiv = true } fmt.Fprintf(bout, "\ttestUint64BinaryL%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", i, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) fmt.Fprintf(bout, "\ttestUint64BinaryR%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", j, a, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for j, b := range shiftValues { fmt.Fprintf(bout, "\ttestUint64ShiftL%v(%v, %v, %v);\n", i, b, a.LeftShift64(b), a.RightShift64(b)) fmt.Fprintf(bout, "\ttestUint64ShiftR%v(%v, %v, %v);\n", j, a, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } } func main() { bout = bufio.NewWriter(os.Stdout) varTests() constTests() fmt.Fprintf(bout, "func main() {\n") for i := 0; i < ntest; i++ { fmt.Fprintf(bout, "\ttest%v();\n", i) } fmt.Fprintf(bout, "\tif !ok { os.Exit(1) }\n") fmt.Fprintf(bout, "}\n") bout.Flush() }