diff --git a/client/docs/statik/statik.go b/client/docs/statik/statik.go index 038c0c0159..55c5dac519 100644 --- a/client/docs/statik/statik.go +++ b/client/docs/statik/statik.go @@ -7,6 +7,6 @@ import ( ) func init() { - data := "PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00 \x00favicon-16x16.pngUT\x05\x00\x01\x80Cm8\x00\xbd\x01B\xfe\x89PNG\x0d\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x01\x84IDATx\x01\x95S\x03Luq\x1c\xfd\x8c\xf1\xc3\xec0\xa7)\xcda\xb6k6\xb2\x9b\xf9\xb2k\xc85/\xdb\x8dqx\xc6\x94m\xcc{\xef\x7fO\xff\xf3l\xdc\xed\xf2\xe0\xfe\xf8\xc9\xffP\x14\x11/\x14[\xa3P\xc4\xa1\xbc?\xf1t>7\x12s\x13\x03\x85\xca7IR a\xb5j\x8f\xa71\xbe]\x88\xf6\xb9L\xf0\x1c\x93\xcf\xda\xe3)\x10\x93f\x8d\xe4\x06\x13\xcf\xde<\x9b\xd14\x95\x8a\x92\x81OA\xcfF\x89\xdd<\x9b M\xe6}L\xe4\x07\x15\xc5\xf5\xe3\xffI\x0c{\xd6\x8d\xffs\x994\xbasfh\xae?\xafk\x1aprw\x10 <\xb9\xdb\xc7\x86\xa6\xd1\x19I\n\xa8\xb1\xd7\x84y3g\x171T$\xb5c\x7fq\xfbbq\xbfk\x8e'\x1dQ\xb0\xc2,\x92\x0bx|;F\xe5\xf0\xef\x00\x83\xf2\xa1\x1fx|?q\xbd\xcb\xc2\x16\x80ZF\xf0\xc4J\xf3\xe3\xe4n1\xcc\x17k`:}\xcby\xe8\x98\xcbB\xc7|6z\x97r\xd14\x9d\x06\xd3\xf9\x8a\xe4\x94\x90\x8b\xb6\xd9\x0cP\xebc@\xd0|\xbe*\xc94\xc8\xa7\x98'\xcdh\x00\xe3\xd92\xa6vK}\x0cB\xa4\xf0+D\n\xc7\x81)\xb0\x10\x9a\xe3\xa9\xd8\x8bx\xe4(\xa2\xbb\x8dl\x0d\x01\xb6\x8a-\xf378\xbe\xdd\xc7\xa6\xb6\xc9\xd9\xc6d\xd8\\m\xf4\x0c\x92 uQ\x0e\xd2\xf5\xb3\xd1\xf1w\xdfQ\x16\xb34a$\xa1\xc4\xc4(V\xbcF\xd9\xdf\xa4\x91\xe9\xb0&,\x12+\xcd\x93\xcf\x1c\x1cb\xdc\xca\x00qt\xeb\xcc-\x14\x89\xfe\xfc\x0fm2j\x88\xec\xccs\x18\x00\x00\x00\x00IEND\xaeB`\x82\x01\x00\x00\xff\xffPK\x07\x08\xd4`4t\xc7\x01\x00\x00\xbd\x01\x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00 \x00favicon-32x32.pngUT\x05\x00\x01\x80Cm8\x00u\x04\x8a\xfb\x89PNG\x0d\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\x00\x00\x04|ID\xc4\xcf\xd0@\x04&%\xad\x1e\x16\x0f\xf7\x8d\x97AR\xfa\xca\xe7l\x87\x05\xf8\xd2\xfb\x0c\x84\x1d\x0dLVY\xdc/ju\x13\x1a\x88\xd2\xa0\xaaa\x82|nzp_\xf4\x03\xc8 \xd4;^\x8a9}\xeeu\x9a\x91 `\x04\x14s\xec\xe1\x0c\xc6]\xa3\x05``\xd1w\x12*~ \x00\xf3\xae\xd3\xa0\x9cb\x82\xa2bx(\xb3n\x1fqx\xd2\xf2\xda4\x1d\x8a}\x1ck\xd4>\x9cI+\xeb\xb3\xf4k\xc8u`L\x93\xf3]4\xb5\xd0\xc3\xe33\xd9\xee\xd7\xf2\xd9\x19\xea\x18\xc9\xc1Y:\x18\xfb(-\xadN\x82\x06e\xd5\x1f0\xa2\x1dV\xf8\xbe0\xc1\x985\x01\xf8\xd2~\\\xa6\xa5\xb5)&\xf6\x98V\x80l\xe4\x03\xf8\x03\x04\x00s\x9a^\xec\x85\x00\xf4+\x0b\x00\xe1:G\xf2p\x96\x0e\xc4,\xe46\x1e5\xbbP\xdd\x15J\x80}\xce\xa4\xe2\xc8{m\xa4\xe2\xc3\xc2\x01\x07\xc0\xdb\xa4\x18-\xa1\x931\xba\x10S\xfa%\xb6P`\x10\x19v\x99#|Gg\x9b \x10W\xf6\x8dI1\xba\x92\xd66\x17E\x12\xfa\xd9\xa8\xf3UTe\n\x1b\x95\x9d\x81f\xe5\x18\xa5umc\x81\x86\xa6\xeb\xec \x804\xcbg\x17\xa19\xfa\xc6\xf7<\xa3\xbd\xf2\x0e\x7f\x02\x80\x97Y\xc7\xac\x184$h\xa3v\xba! \xcc{\xcd\xb4!\xb1\xd8\x92%h\xe3\x93\xdc\xd3_\xda1\xe6\xaei\xcf\x83\xa6p\xbc$\xf0\xb2\xda\x94\xa2q\x14B@\x13\xdb\xff\xf3\xd7\x0d\xfaA\xb9\xc5n{\x8e\xd6Y\x08\x01u\xc1'~\x16\x8e\xe9\x04\xa2\xfbA+\xc74\x0c\x98\xab\xd7:\xfc0\xd1v\xaf$\xa2#\xb7\xf1\x08\xfdm!OXh8\x10j|g\xd1\xe0a\xb2\x99\x04\x9a[y\x9a\xbdk\xf24C$\xa0\x9e#\x9f\xa3\xa8\x001\xc6\x1a\"\xc0\xe4i\xa6\xcc0\xf3\xf7\xb7\xf5XE\xb8\xe0\xa1\xc9\xc2\x0c\x90\x83\x80$\x838\xdf\xd6\xe3\xd4\x82FNG\x0f\x876\x8a\xbf1\xa8d(\xa7@\x8cQX\x90\xdb\x19\x9f\xc5YG\xe9\x9e\x00\xa5y3]\x9aJ\xe1\"\x00\x00\x00\x00IEND\xaeB`\x82\x01\x00\x00\xff\xffPK\x07\x086B\xc8\xd7\x7f\x04\x00\x00u\x04\x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00 \x00index.htmlUT\x05\x00\x01\x80Cm8\xb4T]O\xdc:\x10}\xdf_1\x98\x07\xe0\n\xc7\x17V\x17]\xa5I\x1e(\xad\x8aDU$\xd8\x87\xaa\xaa*'\x9ed\x0d\x8e\xbd\xb2\x9d\xfd\x00\xf1\xdf\xab8\xc9\x86v\x11\x95\xaaV+\xad\xc7s&\xe7\x8cg\xc6N\xf6(\x85\x0f\xb7\x1f\xaf\xa04\x16\x9c\xe7^\x16 \xa4\xf3V\xe6\x8d\x97FC\xdeh\xa1\x10\xf2F*\x01\x94f\x93d\xef\xe2\xd3\xdb\xdb\xcf\xd7\xef`\xeek\x95M\x92v\x01\xc5u\x95\x12\xd4$\x9b\x00$s\xe4\xa25\x00\x92\x1a=\x87b\xce\xadC\x9f\x92\xd9\xed{\xfa?\xe9!/\xbd\xc2\xecf\xc5\xab\n-\xcc.\x13\xd6y:TI}\x0f\x16UJ\x9c\xdf(tsDO\xc0o\x16\x98\x12\x8fk\xcf\n\xe7\x08\xcc-\x96)\x99{\xbfp1c\x85\xd0w.*\x94iD\xa9\xb8\xc5\xa805\xe3w|\xcd\x94\xcc\x1ds\x9d\x14m$\x9bF\xd3\xff\xa2\x93g\x9e(\xd0\xedh\xcb\xc2\xe8AU\xd6\xbcB\xb6\xd0\xd5 [\xf2e\x8b\xd3\xe9\xe9zz\x1a\x05\xc0\xc9\x07t) \x1e\x02\xec\xf7\xf8N\xce\xd6'g?\xf0\x05\xcf\xc8\x17*\xd2\xd9\x10\xda\xd0\x9b\x8f\xfd\n\x90\x9b5u\xf2A\xea*\x86\xdcX\x81\x96\xe6f\xfdf\x8b\x9b%\xdaR\x99U\x0c\xb46\x0f\xd4\x15\xd6(\x95s\xeb\xe8\x12\xad\x97\x05W\xbb\xb1t\x13C\x178`O\x93\xde\xf8\xe7x0\xe2\x1cKcq\xdc\xf3\xd2\xa3}5?\xa9\xe7h\xa5\xdf!\xcd\x8d\xd8\xec|Xs[I\x1d\xff;\xa6\x97\xf3\xe2\xbe\xb2\xa6\xd1\"\x86\xfd\x92\xb7\xbf\x91\xaa\xfdO\xd8\xb6^ \xebF\xb35[\xfa\xbe\x9eB.A\x8a\x94\x8c\xe3@\xb2\x84 \xb9\xcc&}\xc1\x0b+\x17\x1e\x9c-\xfe\xc8\xb0\xd1\xeeVEw\x8edmz\x81=\xfb;R\xces-\xb82\x1a\xe9\xc2\xa2C\xff\x8aj\xb7YI-\xcc*2Z\x19. \x85\xb2\xd1E\xfb\x16\x1c\x1e\xc1\xe3\xd0\x1b\xc6\xe0<< \x1c\xdc\xc6y\xac{\x7fa\xb4\xf3\xd0HH\xa1\xbf\xd8\xb3\xcb\xf3p\xd8\xc3\xb1\x87\x8dU1\x90h\xc82\xda\xf0Z\x91\xe3-,L\xfdM\x8a\x18\x0e\xf6\xc7c\x1c<\x83\x11\x17WR\xdf\x87\xd9\xf1\xb6\xc1\x11\xea\x0e\xe8b\xf8\xb2u\xc1\xcfyD}P\xc4\x17\xd2\x1d\xbf\x14w\xb3\xad\xd8u\x08\xdd\xc6|}\xa6\xa4\x9aJ\xea_)uA\xd1\x85Y\x85Z\xce\xacz\x89K\xf1\x8di|\x0cd\x14\xbe\n.2\x8c\xf1\xd1P\xf6\xbe5\xa1\xbe\x8d\x0c\xce\xa70\xd6c\xff\x12\xd6\x0dv\xc2\xba\xf7\xf9{\x00\x00\x00\xff\xffPK\x07\x08\x8e\x10\x9f\xf1}\x02\x00\x00\xe3\x05\x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00 \x00oauth2-redirect.htmlUT\x05\x00\x01\x80Cm8\xc4VMo\xe36\x10\xbd\xfbW\xbc\xf0\x10I\xb0\xab\xa0=*Q\x82\"\xd8C\nl\xb7\xd8 \xbd\x04\xc1\x82\xa6\xc66\x1b\x99\x94I\xca\x86k\xfb\xbf\x17\x94eK\xb2e\xd4=u\x0e\x968\x9cy\x9a\x8f7\xa4\x1fn2-\xdc\xba \xcc\xdc<\x7f\x1c<\xf8\x07r\xae\xa6)#\xf5\xd3\xdb+{\x1c<\x8cu\xb6\x86V\xb9\xe6Y\xcaL\xa9\xc2\xc8k\xef\xbc\xda?kO+\x8c,\xdc\xe3\x00\x00\x82\xd2\x12\xac3R\xb8\xe0\xbe\xd2LJ%\x9c\xd4\n\xa6T\x08#l*\xad\x97%7\xd0\xbct\xb3_\x90b%U\xa6W\xb1.H\x91\x89\xed\x8aO\xa7d\xde^\xbeS&\x0d \xf7\xad\xb2\xbb\xef\xf8ZR\xee\xd5qGHk\x9c\xd8\xfae\xd7\xca\xd4\x08o&o\xecZ\xca\xae\xb5\xb4\x7f\xf2\\f#,\x8a\x11\xb81\xf7\x83\xe3\xb6\x9c \xbc\x13:\xa3\xad\xd3\x9f\xa4\xb6d\x8c6w\xb1#\xeb\xc2:\xfa\\\x0b\xees\x8dg\xdc\xce\xa2v\xae^\x16E\x93g\xc72\xb6\xe5\xd8\xd7LM\xc3\x9f\xa3&\x9e\x1d(\xb7\xd4\x07r\xf4\xb6\xc4\x8d\xb8\xe8\xdf\xc4\xce\x8dA\x8aE\x11\xdb\"\x97.d\xb7,j\xef\xc5\x13m\xbep1\x0b\x8f\xcd\n\x97#9\xfa\xc1\x8d\x89\xb0\x81\x7f\xbe\xcb\x0f\xa4\x08X\x80!\x96\xb1\xa1\"\xe7\x82\xc2 \x0dF\x08X\xc2\x82\x08C\xbf{\xbfk\x80\xabP\x17\x05\x9e\xf0\xdb\xeb\xb7\xdf\xe3\x82\x1bKa\xb0\xf1\x08\xfe\x9b\x7fi\xa9\xc2\xcam\x17\x8c:9\xa2M\x9b\xf0\x93\xd6#,y^\xd2iA\x0fb\xc8\x95F\xe1\x93\xd6H\xd3\x14\x8c\xe1i\xef\x80\x04\x19\xf9\x96\xbd}\x7fy\xd6\xf3B+R.\xdcc\x9d!\xed\x8e\x9a\x08 6\xad\xea\xd5\xa4\xa8+\xb8g\\\x9a6\xfc\xebr$l!\xd7t\xf3\xbf\xb1\x153\x9a\xf3xJ.d\x93\\\xafX\xb4\x8f\x96\x0bA\xd6>\xeb\x8c\xd8v\xfb_}K7\xd3F\xfe]\xb1\xa1\x82h%q{\x8b\x9b6\x88/\xc4i }\xc07u~}\xe5\xad\xfd\xc9\x98\xe7q\xd8_}o\xf1\x92%\x9dx\x15\x9f\xd3yO\xbdX]\x1aA\xc9>t\xd6o\x93\xd3\x92\xf2\x04l\xc5\x8d\x92jz\xc1jN\xd6\xf2\xa9\x87\xfa\xb5]\x05\xcc\xf9\x1acB\xa9,\x9f\xd0\x08\x05\xb7\x962\xec\xdb\xb6\xe2\x16b\xc6\xd5\x942H\x05KfI\x06\x7f\x9c\x98\xa8\xc0\xd5\x9c\xa2\x0c\x13\xa3\xe7U\x8e\xb55;'Nk\xe6\xd0\x9d;\xd4%^\x14\xbd\xd5\xf7\x92QN\x8e.\x1c`\x079m\xe3\x9e\x8a\xfe\xed\xa2\xad\xe0y>\xe6\xe23\xdc\xf8u\xa7=\xa3\xf6\xa1\x98\xb4\x17g\xa9\xf4\x1dA\xa8Z\xe4\xf6\x88_\xfc)\xf8\xd5N\xcf,\xea\xb4\xabS\xf2\xd2\xe0v\x10\x90\x82\xbd\xb3\xe1\xc1g\xc8>\x120\x0c{\x1d\xbd\x1c\xd1\x7fd\xb4\xbf\x82|\xf7\x9f\xd0\xa7\x1e\x82\xc5`H\xc0\x94F3p0$H.\x0f]v3\xaa\x9b\x1c\x83EW}\xba4\x12O`_\xb5!H5\xd1 \x9a\x0c\xaa\xcd\x04\x8cE\xe7M:\xe1\x08\xfe\xefQ\xab\x02\xfe\xb7A\xeb\xb6k\xbb\x05{\xef\x8e\xde\x84\xcb\x9c\xb2\x8f\x04\xd7U\xf9\x9aQ:\xbe\xf51\xf1\x1a\xaaW\x97uR\xdd\xe7\xf59\x974\xb7\xfc5s\xd0\xc4P\xdf\xdd\"\xd7\x96\xc2\xdab7x\xb8;\xfc\x01\xfa'\x00\x00\xff\xffPK\x07\x08]\x12r 9\x03\x00\x00T \x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00 \x00swagger.yamlUT\x05\x00\x01\x80Cm8\xec\xbd\xfb{\x1c9\x8e \xf8\xbb\xff\n\x9c\xef\xbeU\xd5\xb4\x9dz\xf8\xed\xdd\x9a[\xf9Y\xea*\x97\xd5\xb6\\=\xd3s\xbdif\x043\x93\xa5\xc8\x88t<$\xa5k\xfa\x7f\xbf\x8fd\xbc3H\x82\x11\x91\xb2l\x13\xbb\xdf\xb4K\x19\x04I\x10\x04@\x00\x04\x93K\xb2X\xd0\xf8)\xec\x1dM\x0e\xf6n\xb1p\x1e=\xbd\x05\x90\xb24\xa0O\xe1\xf8\x97\xe3\xf7?\xc3]X\xbc;}\x0e\xafIJ/\xc9\x06\xfc\xc8Kn\x01\xf84\xf1b\xb6NY\x14>\x85\xbdcx\xf7\xf2\xfd\x19\xb00\xa5\xf1\x9cx\x14\xe6Q\x0cIJR\n\x9f2\x1a3\x9a\xdc\x81\x80.\x88\xb7\x814&aB<\xde0\xd9\xbb\x05pA\xe3D 9\x9c\x1cL\x0en\xadI\xbaL\xf8\x18\xf6\xc99I\x96\xfb>]\x07\xd1fE\xc3t\xff\xe2pFSrX\xfbS\xb2_\x8c\x18`AS\xf9\x0f\x80$[\xadH\xbcy\n/\xca/\x8ba@\xd5\x18|\x9a\x12\x16$y\xa3hMc\xc2Gu\xe2\xd7\x1b\xe6\xbf\xc64YGaB\x93\xa2\x0f\x80\xbd\xa3\x83\x83\xbd\xea?[$9\x86$\xf3<\x9a$\xf3,([Oj_'\xde\x92\xaeH\xbd=@\xbaY\xd3\xa7\x10\xcd\xfe\xa0^\xda\xf8a\x1d\xf3\xe1\xa5\xac\xde\xbf\x84j>\xed_4\xe8@\x8b\x12\x1ah\xa7\xcc\xef\xfa\xc0\x80\x1d\x8c=p\x88.C\x1a\xab~,zH\xd2\x98\x85\x0b\xc5G~B?\x0dB\x00\x9cUW$}\n\x19\x0b\xd3\x87\xf7\xbb\xa7*\xf7C\xc5\x15'/ I\xa3\x98&r\n@B\x1f\x12\xfa)\xa3\xa1G!\xccV3\x1aw \x12\x1bBGL\xcdHi\x98\xadT\x13\xbd\x0b,\xbc \x01\xf3\x95\xbf\xf3\xfdvA\x95?{A\x94\xd0\xee\xd6>\x9d\x93,H\x9fj\xbbhp\xfe\xbf\xdf5\x0d\xf3)\x9c\xc6t\xce\xae YFY\xe0s\xba\xc4)\\\xb2t \x07\xc0B1\xd7 \xbc\x8fTkN\xbd\x80pB\x81\x9f\xadV\x1bIV\xd5\xf2\x16s\xaf\xaf\xde\xb1\xf8\x0b\xf84\x8cR\x9a\xe4r\x8aK\xac\x9ap\xd0R\xac$Y\x1d\xebs\xf1\x17=V\x0d\xa1s\x1e{/\x9a\xb1\x04\x88\xa4\x03\\.\x99\xb7\x84\x98\xcei\x9c@\x1a\xe5x\xa3y\x0dm\x07\xbeB\xaa\xf6c\xb6bK\xcc6\x9d\x84\xf5bJR\xeaOI\x87\xcc\x01\x1b\xfc\xdd;.\xa7\xc4^Mz\xe7\x9b\xcd\xafm\xc0;9%\xf8\xd6\xcbg[H\xf4\xbd\x16\xcaE\x1ce\xeb\x0e!$\xc7I\xe2\x98l\xb6~c)]u\xca-\x83\xd83 =1\x16\xa5L5\xa2\x07D\x17`\x96\xac\x885\x02\xa3tE\"AIX\x0e\x0bTo\xdc\xc6Xt\x8a\xd7\x02\xf4\xdc%!\xe71\xa5\xac\x02x\xcd\x17\xaa%\xe7\xef\xd4\xf7rK\xdesFTO\x8d#Ch\x08\xad\x8e@\xd1[\xa7'\xcc\x9a\x82\x7f\x11\xadi\xa8\xf9yM2\x95\x08\x83\xbc\x87$\x9b\xcf\x99\xc7\xb8\xf10\xcfB?\xd1|\xac\x11\x88H\xdd\x83\xd5>\xe3\xe9\x1fK\x0dT\xd0\xf4\xa9d\xa9\xb7k\x1av( \xc9!Z\xda\x97\xc4/0\xc5>\x8d;5N\x8eL\xfe\xae\xc3\xb7\xbdV9\xee\x93\xda\x0f\xaf\xf8\xdf\x95\xbdX,wMm\x8aN\x94\x1aSb\xd6\xf2\x86\xb5\xba\x1485\"9YSo\xc7B9$+\xe5\xd6\x06\xdc\xf6\xe6'\x91O\x19\x8b\xa98\xfe\x98\x91i\xc7\x0c\xc8qsH\xd8\"\xa4\xfet\xb6\xd1\x7f\x86\x91\xac\x05\xbc\x17(\x9fm `I\xca\x97\xe8\x9cn\x12H\x97$\x85\x94\x86$L\x13\xa0Wk\xea\xa5\x90\xaa\xb7b\x01KrA\xc5 I\x9aqy=\x8f\xa3\x95i\xa48\n\x81\x05\x958\x90 \x98Fs\xf3wz\xfbc\x1b\x94\x16\xc96\xa0\x18\xa9\xf69z\xc9\xa0\x9c\x1f\xff\x1f\xb9`,\x84t\xc9\x12\xb9\x8a\xab,I\xc5Z\xa0PI\xa6\x02\x92\xa61\x9be)\xd5\x88\x8e\x1cH\xb8\xf9\xb6\x89+\xe6\x07$\x85\x80\x12\xb9+\xa29\xa4K*i\xcd\xb9Z\xfc\x17'6\na\xb9 \x96\xc4\xae>3Q\x05Oh$\x91-\xf6\xa5\xdd\xce\x04ND\xccg\xd6\x8b|A\x82L+\xda+\xb0\xc2\\8\xe2\x8a\xc5\x80\x98\xaec\x9ap\xd9\xcf\xe7\"\xfb\x855a:{\x18\xac\xb8\xb0\xea\xab\x10\xcb\x15+\xe4r9\x17\xcb(!\x0b\x82]\xd7qt\xc1|\xad\xd5\x9e\x8f\xf04 \x9ePn\xefjzN\xd9,\xa6I\x94\xc5\x9e~\xf1q\x0c\x8a`N4c\xe2\x99\x125\x01 \xe8\xde\xc1j\x04\x1c\xbcu\x86\xf9\xccr\x0c`=\x0e\x0eY\xc8\xf4\x86M\x13\xacG\x04\xbdF\x05r\x93\xdb|n\xb9\xd5\xeb`\xf0\xbft\x03~\x8bW\xf0!d\xa5s\xc5[gw`EWQ\xbc\x91\xfe\xcc4\x8a\xc9\x02\xdf?\xc0\x8a\xa61\xf3\xccJ\\\x02^\xc3T\x80\xdb\xcaM@l\xec&\xf4b\xa9\xbeLe\xa1\x93*\xe8\xcdX\x16z\xaa\x82\x9e\xbd\x8d\xa6\xbb$\xd8\xb2\xf7\xf3\xd3\x0f\x05g\x17BV\xca\x16\xc1\xdc\xde:\x03/\n\xe7\x0c;#\xa4\xd9$A\xee\"\x1c\x9d\xad\xb9\xcd\x9e\xcf>e$LY\x8a\x1c\x10\xf4\x19\x14\xf4\x1a\x188\xa9j\x06'U\xed\x99\xcaI\xd5\x1dI\xd57\x92\x93\xdb\x82\xb5\x900\x82\xc5%\xb7#\x11Z\xc9\xd5|\xf3\xe0Hm\xcdp\xf6\xac\xe6\x04\xab\x00'X\x15\xe0\x04\xab\x80\xde\x8c\xf5\x1d \xd6\xf7\x92}\xb5\x92\x15\x89*\xdf v\xa2\x95\x86\xfe:b\x86\x98B\x05\xb6\x9cm\xc5\xd5=8\xba\x0f7\x9f\xb3P\x19\x86\xef\x82\x9e\x8c\xa5\x8f\xc8v\xc1]x\xff\xf3\xf1\xbb\x97/\xa6?\x9f\x9d\x9dZ\xb6|w\xfc\xdb\x8b\xb7o\xa6\xa7o\xdf\x9dY\xb4,#\xad\xfd:\xc6F`\xbb\xa01\xd9\xa7\xf0B\xa0\x9a\xd1<\xa2'\x99\xd2\n\xa1\x08 \xcd\xa8\x17\xad8\x12\xf8%\x9b\xd18\xa4)M\xe0$\\\xc44\xc1\xec\x86\x1a4H\xaa\x18\x9f\xa6\xcf\xdf\"\x9f\x9eF\xb1\xcd\x14lE\x87\x84\xb3%K\xf2\x85\xe0\xa3[F\x97\xc2\xf3Z\x0e\x91\xd9\xcd\x9b\xad\xd6\x81p\xbeR\x1f.\x974\x94Q\x07J\x12\x11m\x95i\x10\xba\xd8r\x03\xecg\xf4\xb2\x18v5#\x02\xebl\x160/\xd8\x00\x11\x99\x95l\x16\xe0\xd5\xfd\xc9)$4\xbe`\x9e\xb9\x89\xcdh\xdf\xe5r\xfa\x83\xf0,\xd4\x06\x1b\x04@.\x08\x0b\x08n\x90\xa5\x1fXH\x99\xa4\x957\xb6\x1fF>\x05\x9az\xb7\x10\xa8\xd8\x1c\xe6\x8c\x06>_\xa7\x90\x05\x95*\xe1\xff\x1d\xa5\x90k5\x19\xb7\xc3\x8cm\xc1.h\x08>I\xc9\xdd$\x8d3/\xcdbS3/\xca\xba\x12R\xdb %\xaa9\xa3G\x02&\xaf\xa7\x80u\xcc<\x84\xe5`\xa5i\xect\x8cO\xc3\x08)\xf7-\x15\x0bY\xe1\xa8\x0b\xb6\xa8\xed\xc5\xf8\xf3\x88\x85\\y\xb0Pl\xd04:\xa7\xa1L\xa4!\x92\x00,\x149\xd5H\xeb\x85\x84\xf9\xe4&\xb70\x9c\xfe\xdb\xdb\xb3\x97O\xe1lI\xf3V\x15\xdf\x93\x10N\xc2T&\x83 \x10\x95\xc2.\x11b\xce\xcb\x924Z\xf1\xf3\xc12\xf21\x03\xa9\xe5\x1d\xe4\xe9\x19>\xcc6\xb0\x88\x16\xd1:\x8e\xd2h\xa2\xc5\x81\x957\x85\xac)l\xc4,d\xe9\x1dH\xa3\x94\x04r\xc3\x89s\x90\xe0|\x88\xe6\x06d\x85TP|\x96\x8fI\xa4\xe9\xbc_S\xaf\xe83Od[S\x8f\xcd\x99'\xd6\xb6[\xaf\x98rDQ\xaci\xda\xf1E\xa6\xe8k9\xaa\xfa\x10\x99_O\x10m\x0e\xb8L\x07j'\x8ar\xfe\x8f.\xa7\xc4S\xc8/\xad\xb8\xd0\x8b\x87\x1df\xd1'^\xb4\xd6\xc8:\x04\x9d\xaf\xd4\xf9\xa8\x88\xf6\xc5\xc9IR\xed\xe4\x05\xdf\x80|\x1b\xe5d\x04\xe6\xd30es\xd6)\xe25\x89\xaa\x86\x8e\xbf\\6\xbd&K\xcf\x90\xd1x\x17\xa2\x0b\x1a\xfb1\xb9\xecF\x80\xcaxl\x88\xe9\xffFd\xdb\xe7+#r\xe5N\xe4\x1fs!\x99\x7fbJ\xa1\x97\xe9\x8b9\x1a\x91\xc0\x98/\xb1\xdca\xc2>\xe4\xb2\xbbX\xf0D\x9b\xc8Xe\x01\xe6\x18\xf3<@\x13N-e\xeb\xa4\xad\x86Z\xfc\xc5\x88[\xbf,\x8dd\xc3\\\xccT\xd9\x8a\xfc \x04G\x81\xb0\x03\xc7\x8c\x04$TY$#\xc8\x00\x83\xb5a\xdc\x10f\xab\xc2\x88\x02g=\xd8X\x0c\x18{\x00g\x03\xb44\xbc\x02\x17J\xef\xf7\xd1\xf5\xe2\xce\xdb\x9c\xc61\xdd\x9d\x16p\x1cp\x939 \xa1i\x1a\xec\xfc\xcaL.\xf6lE\x94\xca\x00\xfd[F\xe3Mu\x0b\xe7]~\x8b\x91\x93\xb6\xb8\xd1(\x06.\xba\xe0\xe2U4\xd8\xdf\xba\x01s?\x11p\x9b]\x82\xe9\x9e\"\xd8 C\xdfW\x1c\xed^\xb8\x04\xed\xcd?\xc0\xcf\xc0\x1co2\x9dp\x8b\xaf\xf4w\xa0\xf3\x8f\xf4\xa72\xec\x99\xb6\xf8\x14c@J\x18\xef6\x1f\xd8\xdf\xe8\x83\x9d\xdd,/p\x8f~\xbf\\\x82\xf5\xb59\xed-s \xda\xbb\xe6\x12\x90\xac\x8bJ$1{\x16\xc1\xbe\xc7aw\x85\xado\xaak\xe4q\xbd&I\x13T\xd7\xd8%\xe8\xd4\x94\x04C\x0c\x1e%\xe1q\xf2\xddt\xc9]\x02\xaaC@w\nX\xb5\x82f\x0e@\xaa\x16+\x84\x16\xea\x05\x10\x97\xe2%\xe8\xcf\x1bm\xc00\xbd\x043\xebK\xb0\xbd,o@\xc7w\n\xfe\xca\xbc\x04\xa3\xfa\xb4X%\xb3\n\xc5*Q\xe3\x85\xfa\xe2#\xc3\xb5\xfa\xe23\x9b\xdb\xd6y\x13\xa3N\xb0R\xd1vJzl5\xddKQ\x8fw\x01\xbf\xc06\xee5\xfc\x02\xeb5_\xc6/\xba\x1d\xedJ\xbe\x04k\x0bC}1_\x82\xf9z\xbe\x84\x1d\xa8\x13\xd3\x85} h\xb1\x82\xbf\xbc/\x01=#\xb0\x9a\x15\xd8\\\xe7\x97\x80\xd5\x03\x05\xa0\xaf\xf6#\xf1\xa5Q\x9f\x0b\xfe\x12\xac\xa8\x08\xd6\x94\x04\xab+\xff\x12\xcc\xb6\xda6XeP\x82\x1d[V`\xbb\xd00nA\x00 v7\xd5+\xc0\x17\x07\x90\xf0\x8d-\x03\xaet\x80\x05\xc6\xe6\x02\xf6Z\x16\xdb\xacy\xdb%\xb1Z\x0ekI\xd0G\x16Xg\xc8\xf7b\x10\xeb\xcc\xf8\x1e\xbd|\xe1\x8cxD!\x02$\xa6z\xb9\x02l9\x02 \xbd\x8a\x12H\xb0\xbe\xd9\x8fcz4\xc3[2\xbb-\xa3[LO\x82\xe5x\xa0\xc7\x98\xc0\xa6\x94\x81\x84\x1e\xa3\x82\x9e#\x03\xfb\xe2\x06\x12z\x8e\x11\x06\x8c\x13\xfa\xdc\x1f\x93\xd0C\xd0\xd4\x01\xe5\x02\xec\x06[\x01S\xc1\xb8\xf7\xca$\xd8\xdd.\x93`\xab-+\xb0\x11!M@\x0b\x94&\x0c`\xcaali\xad_+\x18\xc8\x9a\xd6:\xb7\x82A=\x8f\xac\x87%\xf4\xdb,#\x17U\x90`ePJ\xb0)\xb0 \xa1'\xbf\xf6\xe5T\xfb\x9b\xc1\x12z\x0e\x13\x06\x0c\x15\x9c\xacw\xb2^\x0b\x03\x98r\x18[:Y\xff\x05e=\xa2\xd4\x83\x15\xbeb\x9f\xd9K{\xab\xb2\x0f\x12z\xb2l_fu\xe2\x1e\x01N\xdc;qo\x00'\xee\xbf\x98\xb8\x1f\xb1\x00\x85\x84^e($X\x16\xa3\x90\xd0o\x9f\xf4\xd8#\xbd\xf7G\xff\xbda[\xaaB\xc2 \xd6\xc4\xe4@tA\xff\xe2\x15\x12\xfa\x96\xb0\x900\xb0\x90\x85\x04\xbb\x0c\x87.\x18\xbd\xa8\x85\x84\x91K[H\xb8\xfe\x02\x17\x12\xfa\x89) #\x17\xbb\x900j\xc9\x0b }\xe78z\xf9\x0b \x16E0$\xd8\x8f\x7f\xac\x82\x18\x12F,\x8b!\x01Y\x1c\x03\x8fOrI\x8f\x12\x19\x12\x90\x852$Hy\x8e\xcd\xf2\x93\x80\xcf\xf5+\x00Y:CB\x0f]\xd8G\x0bZ\x14\xd3\x90\xd0K\xf5\x99.@nC\x8fn\xfa*\x17\xec\xb5I4B\xe4\xf5\xcam\xc0]\xb8D\xa3\x1bZ|CB\x9fK\x99m\xb0\x93v\x16\xe58P\xf8\xa2\xb9\xa9(\x87\x84\xc1\xa59$\xe0\xd2\xe8-X\x1c'i04\xb6/\xe7\xa1A\xa6N/4U\xfb\x90\x80\x90p\x18\x89v\xad\xb7\xab\x0c\x15A$\xa0\x17V[\x1dD\x02\x12\xd7\xa0J!\x12\x8c\x19\xfe\xa8\xa1\x18\x93\xc5QX0\x87$\\\x9a8\"I\x1c\x95\xc8m\xaa/\"\xc1\"\xdd\x1bWkD\xc2x\x15G\n|\xe3\xd6\x1d)\xb0\xee\xa2\xfaH\x81{w5H$\x0c\xafD\"A[\x8fD\xc2\xc82 e\xc2!\xb7\x1d\xd6TC\xa2\xb31\xc9\xb0fXn^!&a2\xbdp\xe6V\xcd\x8c\xd2b\xb34\xb1\xfa\x9bU\xc6\x9a'\xf9g\x8e\xcb:\xc0q\x19\x92\xcbLuU$ W\x08c\xc1\x0e\xab\xb4\xd2\xc0\xa1\xe0\x01\xdb\xaa+j$\xb5J,]\xb5W$\xac\xc9\"g\xa6m\nj7\xa7~K\x86\xf4*\x9d*\xc39\xc6\x051\xc6\ns\x1a*M\x92\xa2\xffB\xeb\xf2\x7f\xa6\x11\xcc(\xacI\xc2\xf5}\x1a\xc1)Y\xd0w\xf4SF\x93t\"\x7fW \x13\xf5:\x04\x1a\x8e\x96\x93\x8c\xc2*JR\xa0\xc5e\xab\xa0+\xe6 \xce\x82\x03 `~\x95^)J\xe4Q\x94\xcf_\xfc#\x7f\xa6X\x1e3\xb3 M*\x7f\x1c0\xd5 \xaaN\"\xc1\xceS\x81L\xb5\x9d/I\xc2\xb7\xe4\x1d`i\x92\x07\xaf\x18?\x19KQ\xe6C\x94.i|\xc9\x92\xed55KG9\x94j3\xc8\xd5\xa4\xab\x19\xf5}n\xbf\x85\xb0\xe0L^\xee\x91\xbc\x92N\xc2M\xadNo\x1c\xdf;\x1d\x7f\xf6\xa2X\xe2\xf0Y\xb8\x10\xf2\x88&i\x81\x0d\x96$\x81\x8c\xf3O\x9d2\x9d\xe4(Z\xbc\x8fV\xd5\xb8\xff\xd4\xc9\xc1\x98\xae\xc5\x99\x1c\x9e\x91\xb8\\\xa4\x9f\xe0\xf0\x7f\xea\x1a5\xc8\"8\xf3'8\xeal\xf1\xaf\xc6\x1fU\xdc\xd3\x12?\x89\xad\xfciK\x9e\xc4\x95}\xca\xc1\x95}\xd2 \xbck.\xfb4g\x01\xffa\x97\xb5\x9f\x8a.\xae\xad\x00\xd4v\xd7\xedS\xf6\x08}\x17]Tv\x03\xd7\x9d\xb5V:\x97A\xae\x90I\xae\x1bb\x9afq(\x85w]\x8eMJ\xed-\x84\xfc\x825-\\1\x03.\x9c\xf5\x1ay\x02o\xc3`\x03QH\xe5]\xb8yBS\x88bh\x0e\x17\x8a\x0b\xe93\xcaU\xd7d\\j),\x99\x0e\"\xca\xf1\xa9\xe8\xd8\x12\xd3\xf9d\x04)\xc3lEc\xe6\x15\x7f\x13\x91Z\x8f\x84|>BQ OCN\xf8,,u~Ki\x9d\x08l\x01M\x92\x8a\x84\x1cW\x08Y\xc2I}N-\xe9\xd9D\xbfc\xe2*\xb6A\x8d\xbc\x01[1,u\xc5\xb7\x85\xe1\xa82\x9e\xa4\xf9Q\xe7`\xfe\xb5\xfc\xb5\x81\x8d\xf3f\x9b\xd8s\x08\xe8<\x05\xbaZ\xa7\x1b`)\\\xb2 (\x94\"\xc7\\l\x10\xd9 \xa7\xf3l\x03\x94xK \xeb\xf5\x17\xa4b\xdd\x04\xac\xda\xebhYk\xc1)*84\x824\xce\xa8\xb8\xd5\xcdB\x9fy\xfc\xec$\xef\x86\x97\x14\x14\x1f\xe6\x8cTG\xc7B/\xc8\xfc\x96\xddF\xf2xK~\xdd\xb5\xbdbB\xe5\xd5\x8c]n\xb7Ts\x82\x96p\xf9p\x92\xb4V\xab5\x85\x88o\x02n\x8cH\xe3Dl\xafj?\xf2-7\xc9w\x13[\x84Q\xbb\xf2C\xb1\x1b\x9b]H\xca\x0c]\xd8Y\x14\x05\xb4\xe6\x0d\xe8X\xc0\x98^\xd0\xb8\xd1T\xb7x\xf9\xd7\xed\x85c\xb5#DL\xbbwB\x03\x0f\xef\x83J{ZT\xc3\x18w\xa2\xf6u\x0fe%\xa5}\x16\xce#\xd9\xb0\xab\xe4\xa1\x8cB\x15\xc5\x0ee\x18\xaaY\x9e\xa9Q\xee\xf0u-\xcetc\x0b\x1d\x8aY\x8cz\xce\xd7\x97z2z\xf7Lf\xa51\xe0\x83\xb0\x0c\xf5%\x9c\x10\x08P\xa7qS\xa9&\xfd\xd9\xa0\x00\xb3\x0b\xcat\xea\xb7-\xc5T\x15[R 4\x97`\xba\xa1\x95\xf8\xb5%\x95,J)i#o\xa8X\x9a\xd9\xb9\x01#\x96J\xb2*\x914Ni\xa4qK\"]s)\xa4\xd1J \x8dV\xfa\xc8T\xf2h\x04\xb1\xaa/md\xdc\xb6\xd8RF\xc6\x91\x02j\xb4\x80/Yd\x92\x8f\x05\xa0K\x14\x15\xc5\x87\x0c\xf8lJ\x13\xa1\xa8\x02h\xca\x80E \"\x9do\xa8\x0d\xe8\xdcx\x04\xbb\xd4>F.\x10\xa0K\x0b\xe5\xac\x81\xc1\x87\xbd\x8b\x80-%\xf4\x95\x91\x13W\"H\x90\x17\x81\xae_i \xecM(,iQdE\xef8\x9b=\x87\xbe\xafd\xb5\xa0\xe8\xbbH\x16XG\xbag\x84\xe55D\xe9\x9eFQ\x1e\xd3\xe81%{z\x94\xeaA\xd4\xb0\xc10\xa1\x91\x01\x91\xcc\x87e<\xc4\xb0% \xfb\x05\x8b\xbe\x01_b\xc7\xa2w\xb0\x1c\x01\xd8\x96\xd2\xb1\x1c\x0b\xf4\x18\x0f\xd8\xdf\xab\xb5\xd8\xc0u0\xc6\xc6\xb7\x01\xbbq+\x18\xf3\xde\xac\xcd}Y\xacv\xa8\x00\xb3E\x9b`\xdc\xb0M\xe8\xc1<\xfd\xd8\x07\xadO*\xe8\xc9Bh\x1dSA\xaf\x9eF\xd2;\x0ddH&\x1e\xb5T\x0d\xca\xb0\x91\x80/Mc\xc9W\xb6\x1ce[\x93\xc0r8\xd0cH\xe0d\xa4\n\x9c\x8c\xc4\x82\x93\x91fdH&F\x94x\xc9y\x1a\x85\xceBJZ\x94t\xb1d-[\xa6rb\xd2\x89\xc9\x02\x9c\x98\xb4g\xa1\xef@LbJ\xa3Xq\xb2\x85\xa0\xb4*\x85b\xc7\xbf\x16\xbck\xcd\xb7\xf6#mQ\x86O\xcfJ}u\xb7\xf63\xe6c\x9d\xda\xdc\xcar.m \xce\xa5\xed\\\xdaC\x90\xdf(\x97v\x93\x92_\xa4\xd7\x8e+p}znP\xb9\x87\xa7>`I.\xc8\x14\x9e\xfa\xa4\xee\xaaO\xa4\x1a\xcb\x0b\x92\xe5_\xb7\x1d\xf6\xc5\xdfo\xb2\xc7\xfe\x86\xc8\x9d\xce\xd8\x81\x04\xa3\xc1d\xc6\x0e\x86h\x82\x04DG\x80\xec\x0c\xcc\xf1\x05 \x08\x89(A\x1fk\x90\x80F\x86\x8c;H\xd0G\x1f$\xe85f\x130\x11\x02 \xfax\x84\x84\xdd\xf4l\x8ePH@R\x1cw\x8c\x970B\xccBB\xdf\xc8\x85\x84\xaf\xf2) mt\xa3\xf8H\xe7<\xcf?1>\x8a\x80r\xde\x14\x9fbNJ\x12\xc6\x8a}H\xb0\x8a\x80H\x18\x1e\x07)\xf0\x8c\x12\x0d)\x90\x0d\x8d\x89\x14xF\x88\x8cH\x18)>\"\xc1\x98v8\xb2bB\xa5\x1a\"\xb7\xb7\xd9\x95 \x01\x89\xcef\xb3X:\x17\x10\x930\xa5\x14Z\xbb\x1f\xb4\xd8,S \xfb\xb8\"$\x98\"1\x12\x90+\x84\xd1\xa1Cc3\x12L\x11\x1a \x88\xbd\x81\xd9\x17\xd7j\x19\xbaw\xac\x0cC\xf9*\x8d\x0f\xa3\xd20\xc7\x84$\xf45.\xdc;V\x86+$\xbb\x8c\x1bI\x18\x1e=\x92\xe0\xde\xb1\xaa\x813\n\x94\xd0\xdf(0\xc6\xa9\xf2\xcf\x1c\x97u\x80\xe32$\x97\x99ba\x12\x90+daz\xf6\x8c\x8e5p(x\xa0g\xe8\xac\x13\x97{\xb9\xca\xbd\\\xe5^\xae*\xc1\xbd\\U\x0b\xcd\x9b_\xa8\xaa\x04\x8c{\x8c\xaa\x00\x17\x9c\xbfA\xc1\xf9\xef\xe31\xaa/\x10\xab/ \xfb\xe5\xba\xdeE\xd4~\xbb\x97\xb6\x1bb\xc4.\xdcC_\x18j)\x0c?\xf7\xd0\xd7\xb8\xc45?Q\xe5\x1e\xfa\x1a\x83\x8au\x8b\xb9j\xef\x1e\xfar\x0f}\xdd\xdc\x87\xbeZ\xc9j\xa2l\x92\xe9b\xb9H\xf0(\xf3\xd5d\xa5%\xcd\xe5r\xf1\xf9\xadb\xec74YM\xccbT\x97\x88\xc0\xe8\xae\x98\x831\xc9K\x7f\xe6*\x00\xe3\x9f\xfb\x8a\xae\x98\xe7\xe7q\xb17\xaa\x8c\xacZ\x99\x06.\x9b\x83\xda\xce\xa9\xc3\x97\xbb\xb1f\xb8\xe1\x8d~?\xea\x1b\xbf\xef]\xe4'\x89\xe5=\x16\xff\xd1\x91\x0c$%\xa7>\xad\xac\xfbY/\xc96\x88g\xbd\xf22x\xd8e\xa9\x05HE\x17\xca<&\x89w\xcc;\xde*^w\xb7\xbc\x05X\x06\x85\x8c\x81\x1f\xeb\x90\xcf\x97\xb8\xecd\xca-2\xd2\x16u\xd9iO\xda3\xb9\x08\xce%\xf2\x9d\x16g\x1a\xefz\xaf\x89\xa8\x858\xaa \x91G\x91viD|\xd5w\xbes\x9a\x1b\xe8\xa3\xec\xdd]\x19\xaf\xc3\x8e\xb4\xae\\\xa2v2P+\x17F-[\xf2%\x16\x07F}\xc2R\x911T\xefQ\x916$\xde\xc6\xaa\x10\xe3\xee\x98\xd7\xf1*\xd3\x86Z\x98-n\x9a7\x86\xadI\x1bj\x8f\x1ds\xdf<\xc7-\xb5q\xc7\x87\xb1\x81\x9b\x07I\x18\xa7bo\xb2\x8au\xf5\x04r\xf8.W\x9f\xcfO\xca\x1f\xb7\xfe\xdf\xdf\xfa\xb7\xb4\xc3v:S\xa1hnu\xb4\x12~Da,cS \xa4\x99\xedr $\xb8\\\x82\x1b\x94K\xe0.\xfa\x8f\x15\xc1\xff\x8e/\xfa\xe7\xb1\x13\xfdU\x7f!\x04\x93f\xf0\xc4|\xdd_\xb6\xbaUL\xe1&\xc7Pn\x88\x04R\xc4s$\x18\xed\x1a3~0Fx$ \xba\x02dw`\x8e\xf9H@\xc8G \xee\xda\x7f7\xec\xa6gs\xd4H\x02\x92\xe2\x83\"H\x12n\xdeM8\xd4\x1d{|8#o`\xbc\xbe\x85\xf2}\x15\x9fbN\x13\x12\xc6\x8a>I\xb0\x8aAI\x183\x12U`\xbc\xd6xT\xd1\xe9HQ) \xa3\xc5\xa6$\xb8\x1b\xf6%\xd8l\x0e\xcb\x037b\x12\xdf\xe85'S\x14L\x02r\x850\xeaj\x9c\xb8\x98\x04StL\x02b\x87`v\x87)^&\x01\xd1\x19 ;\x04s\x04M\x02run\xd8}{S|M\x02jW\xc8\xc1\x15rp\x85\x1cJp\x85\x1c\xba\xb8\xa7\x12:\xe8\xda\x0ey,r[\xec\xb8\xfc\x0c\x97\x9fq\xa3\xf23\\\xad\x87\x1cL]\xdb&N\xb8Z\x0f\xc3\xbbp\xb5\x1e0\xd4r\xb5\x1e$\xec\x98\xb8\xe6*\x05\xae\xd6\xc3\x18Tt\xb5\x1e\\\xad\x87\xaf\xbc\xd6\x83\x18\x80\xa9\xd6\xc3[\xfeQ\x99\xae(\x9a\xe8j=\x88\xcfo\x15c\xbf\xa1y\x8ab\x16\xa3zM\x04\xc6]^\xd3t\xb5\x1e\xdap=\xb5\x1e\xf2\xd3\xb6`\xeb!\x0f\xe7\xdc\xd0\x0b\xa3\x86r\x0e\xdft\x8d\x06\x19s\x16+\xabx\x8dFJ;\xdc\xbb\xfc\x02\x8f\xfa-\x1a\x89j%\x7fWc+b\xd5\x02\x9b2\xcdM\"S>Ic\x9d\xde\x16\xc5~\xe7&\xe1\x8a}g\x12M(\xe4!\xf2(W\x8d\"\x9e`Bd\x08\x11\x99G\x0by\xa0\x81\xfa\xd3\x99\xc27^\x80\xc9\xbd[\xc0{\x81\xee\xd9\x06\x02\x96\x08\x8b\xed\x9cn\x92\xdc\xfa\xa3! \xd3\x04\xa4O\x8d\xaf\xd5\x92\x98\x123\xebq\x90y\x1c\xad\xf4c\xc4P\x05\xd0\x94\xe1@\x82`\x1a\xcdM_\xe9\xdd]mP\xba\xbf\xda\x80`\x97\xda\xc7\xc8\x05\x82rVB\xcc\x8b\xe5\x11&\x1d?\x1e\xf25[eI*V&g\x0d\x0c\xbe4\x8d\xd9,K\xa9!\xe3\x15H\xb8\xf9\x16\xc9)f\x05$\x15\xc9\x83\xa9<=\x17q\x1e\xc9\xb7\xe2\xbf8y\x11\xe8\xda\x0b\x80#o\xf5\x91a##I\x8b\"+z\xc7\xd9\xec9\xe1F2\x7fd\xb9\xa0Z\xdfn\x1d,\xb0\x16\xc9\x88\x05\xe9!\xa6\xeb\x98&\xe2\xde\xeb9\xdd\xe4\x87\xfc5a\xfa\xeb\x16X^\xab\xfa)\x84k\xb5\xe8\xb9t\xcd\x85+BX\xca\x88t\x87\x9b\xb2\xf5Q\x1eO\x0e\x88'\x94\xd2\xbb\x9a~R4\x8ai\x12e\xb1\xa7[h\x0c\x13\x1a\x19\x10\xc9|X\xc6C\x0c[\x02\xb2_\xb0\xe8\x9b\x83\xb7\xce\xcc\x1fY\xf5\x0e\x96#\xe0\x90\x85Lgx4\xc1r,\xd0c< \xb7.\xfec\xab\x0d\\\x07c\x90\x7f\x1b\xb0\x1b\xb7\x82\x0f!+\x932\xbcuv\x07Vt\x15\xc5\x1bq\xea\xe2\x7f&\x0bl\xdf\"\x9e\x193\xcf\xa4r%`\xb5C\x05\x98-\xda\x04\xe3\x86mB\x0f\xe6\xe9\xc7>h}RAO\x16B\xeb\x98\nz\xf54\x92\xdei C2\xf1\xf3\xd3\x0f\x05\xff\x16\x02S\xca\x0c\xc1\xc2\xde:\x03/\n\xe7\x0c7\x17\x94a#A\xee\x13\x0cm-\xf9\xca\x96\xa3>e$LY\x8a\x1a\n\xd8\x0f\x07z\x0c \x9c\x8cT\x81\x93\x91Xp2\xd2\x8c\x0c\xc9\xc4o$\xbf\xb6\xc5d!9\x04#K\x9eF\xa1\xb3\x90\x92\xf9\xf6\xc0\x90\xd7\x92\xb5l\x99\xca\x89I'&\x0bpb\xd2\x9e\x85\xbe\x031\xf9^2\xa9^N\xdap\xb2\x85\xa0\xa4\xa1\xbf\x8e\x98\xd6\xc7^\x81\x1d\xffZ\xf0\xae5\xdf\xda\xf3\xec9\x0b\x8dWo+\xe8\xc5B\xe6k\xa7M\xb8\x0b\xef\x7f>~\xf7\xf2\xc5\xf4\xe7\xb3\xb3S\xabv\xef\x8e\x7f{\xf1\xf6\xcd\xf4\xf4\xed\xbb3t\xbb2\xa4\xd7\xa7S\\\xa8\xaf\x0b\x1a\x93|\n/\x04\xa2\x19\xcd\xe3V\x92\xf9,\xd0\x89\x00\xca\x8cz\xd1J\xdc~\xf9%\x9b\xd18\xa4)M\xe0$\\\xc441s|\x0d\x1a\x84T\x8cM\xd3\xe3o\x91OO\xa3\x18?|;\xb1 \xe1l\xc9\x92\x9c\xfc|d\xcb\xe8R\xf8+\xcb\xe11\x9b\x19\x97Wt\x8a|\x1e\xe1\x8d\x97E;x/\xeb \xda\xa0\x02\x1d\xf6syY\x0c\xb8\x9a\x0b\x81u6\x0b\x98\x17l\x80\x88\xc4\x106\x0bp\x02\x0e\xe0\xe4\x14\x12\x1a_0\xcf\xd4\x00?\xcew\xb9\xdc\xfd N\xf1\xb5a\x06A-\xa9\xaa\xf4\x8e\x1a\xf1q\x19\x92\x88\x88\xae$,\xa7\xfb~\x18\xf9\x14h\xea\xe9/=q`\xf3\xea\x9eU\xc8\x82J-\xf0\xff\x8eR\xc8\xb5SW\x1aR\x17,\xd8\x05\x0d\xc1')\xb9\x9b\xa4q\xe6\xa5Y\xe7\xed\x8b\n<\xfc\xfd6S\"\x86\x04s:F\x01\xc6\x92+`\xa73l\xb4\x05\xea\x96 \xd8\xaa\x08\xdcmA\xb0Ck+\x94\xc7\xbc9\x08\xe8\xdb\x83\x80\xbeAhD\xd3\xac\xa6js\x8b\x10\x06\xdc$\x04\xb4\x14)$Ha\xc9e!K\xef\xe4i\x9a2s\xb3,\xa7\x02\x91\xean\x97\x84b\xb7w~\x94\x8f\xe6u\x1ce\xeb\xf7k\xea\x15\xfd-\xf8\x1fD^\x07\x9b3O\xace\x97\x982U\x9c1\xb2 \xee\xdd\x05\x99[X\xe4T\xc9\x14\xab;\xad\xb4\x14A\x10\x99a\x95\xa7\x1d6\xeb\xcc\xe4\xb8D\xa6\xa3\xc0\x87\xbd\xfc$;w\xd5h%\xb8\xdbN7\xe8\xb6\x93\xabF;\xd6\x1d\xa3\xeb\xacF\xdb+\xf9Z_,V\xc8\xa8\xa4\x99}m.\x16+[\xdd*\xe6v\x93\x93\xb0o\x88\x80\xd0\xa7o\x1b\xd1\x03\xa2\x0b0'q\xa3D\x89)\x91\x1b\x89\x04\x99\xccmJ\xe76\xa9\x95\np\xb6\xbd\xa98\xeb\x98\xbd\x8d\x95\xdam\xa8J\x86X\x0e\xbd[\xc8\x94\xe2mH\xf26\xa6y\x1b\x12\xbd\x91\xa9\xde\xf8\xc3\xc6X\xe9\xde\x96 \xdfc\xa5|\x8f\x9d\xf4=Z\xda\xf7\x88\x89\xdf\xba\xd4\xef\xd1\xa4\xa1>\x01\x1c\xb5q\xb0I\xe0\xa81\x03r\xdc\x80O\x05\xc7\x1e\x0b\xc12\x1d\xdc\x88\xac\xcc\x89\xc5&\x84\xa3)\x04\x16T\x02\x8b\xb4p\xbd\xe2\xdf\x06\xeb\xd8\x81Q!\x96\x9f\xa3\x97\x0c\xd0 \xe2(T69\xcc\x12\xb0I\xe2_-q\xc7M\x17\xef\x9b0n\x13\xc9\xc5\x13\x1aId\x8b}i\xb73-\"\xb4\x96\x8bl\x11\x91\xb5\xc2\x8f@GB\x8b\x04\xfa\xd1R\xe8\x87&\xd1\x0fK\xa3\xc7\xcb\x9b\x11S\xe9\x0d\xc9\xf4\x83\xd3\xe9\xcd \xf5(\xd64\xed\xf81\xd3\xea\xdd\xfbB\xee}!\xf7\xbeP\x03\xdc\xfbB\xf9\x0d\x1b\xf4\xfbBy\xfa\xba{_\xc8\xdd\xb8\xe9\xf8\xfd&\xdd\xb8q\xef\x0b\xe5`\xea\x1aw\x15\xa6\x83\xb0_\xaek\xf7\xf2\x0f\xfa\xa5\x9a]?N\xe3^\xfe\xd9!q\xcdo\xd6\xb8\x97\x7f\xc6\xa0\xa2{\xf9\xc7\xbd\xfc\xf3\xb5\xbd\xfcSd\x1c\x97\xd7O\x8b?\xe4\x8d\xba.\x9f\x9e\x16\x9f\x94\xf7O\xcbF\xf9\xa7\x8d[\xa7\xa7\xad\x1fo\xec\xc5\xd3\xd6\xd4\xeb\xf0%Le\xed\xa5P\xa3\xa5\xbb\x8c\x92t\x9a\xc5\xac7\x02s _G\x14 \x86p\xa6\x81@\x12Ld\x92`\x0c\xb7\x1b\xe7+\x01\x11JGa\x1a\x18&\xaf\x9e\xde\xda\x06\x04\xd504\xa3+\xc2\xb4\x99/\xa8y^\xd2Y\xc2\xd4w\\\x01\x87\xa7\xb8\xd4\x90o\xc0\x93p\xde\xe5Xk}\xb5}1\x97\xf3|\xeb\x0d\xb2\x02\x9c\xd3\xd29-\x9d\xd3\xb2\x06\xcei\x19oJ\xcb\x04\xeb\xb7l\x9b2\x05\xb8bA\x12\x9c\xeb\xf2\x06\xb9.\x9d\x0f\xca\xee\x80\xef|P;$\xae\xd9{\xe2|PcP\xd1\xf9\xa0\x9c\x0f\xea\xab\xf1A\xed\x19\x9dP\xfb\x7f\x8a\xd3\xdd\xbfr\xe7\x90\xce\x1b\xb5\xe5\x8c\xd2\xbdF}\xda\xbch\x7f\xe3]R\xa3\x1eZ5\x8e%\x83\x15\xa2w*\x19\x1a\x9b\x1cJ&w\x92\xd6\x994\x92S\xc4\xe0FB\x18i\x08\x17\x12\x02\xcb \xf7\x91\xdayd\xa4\x92\x99F\x06\xb7\x11bnF\x97\x91\x11\x07\xc6]\xd4\xdfY\x84:2\xda\x9e\x18]\xae\x8b;0v\xfd~\x93\x0e\x8c]9.k\x92\xd63\x83+\xbd\xcf\xed\x8c\xda\x0f\x1d\xa3QF\x9e\xc2\xc8\xa7\xd3JH\xd5\x94z\x83\xe1\xf9\xb6\xe6\xe3\x17y\xd1\xb3(\x93\xd6\xa7\x17\x85\xa1\xdc\x02\x1cM\xde\xae4\x06\xced\x11\x9d|Y\n{\xb3\xb3M{x\xaf #\xf0\xee\xe5\xfb\xe2>\xd0:\x8e\xfc\xacQq\xe6.\xb7\xed\x83<\x9dw\xff\x8f$*\xec\x1bk\xf3\xe1\xb7\xc8\xa7\"\xef6\xab\x8b\x9e\x91vnm\x90Sn\x1dv\xfa\xbc\xf5\xbc;\xcbX\xe0O\x9b\x14\xaa\x83\x81\xf7\xbc\x80\x1fN\xa7\xea:~\xa6\xf6\xd1j\xc5\xfaU\x18_h5\x9f\xb2Y\xef\xa1&4\xbe\xa0q\xff\xa9*\x17\xc8\xd0\xb6\xb5\x87\xea\xa0_ZU-[\xc38WQ\xc8\xce{Z\x8d\x00\xf4\x8a\xac\xd6\\\xa9\x8a\xf2\x9e$\x8d\xe2\xbb\x9cb\x1d\xdf\x8a{\x00^\x14\xa89\x17\x8cS\x14_\x1c\xadU?!\xc6\x0b\xf51?R|2\x0b\"\xef|\xacN\x0e\x0f\x14\xdf\x90\xf5h\x13\xe9\xea\"\xa4\xe9e\x14+\xa6aD_\xa2^\x10F\xee\xb6\x158\x07oI\xc2\x90vid0w\x10\xb0$\xa5\xe1\x94\xf8\xfe`\xc6\xdb;|r49|\xf8x\xf2\xe0\xe1\xe4\xf0\xe9\xd1\xc3\x87\x0f\x1e\xb6\xef5\x80i;6D\xf8\x19\x0d}\x1a\xafX\x98\x16\x8d\x06\x8e\xf0`r\xf8`\xd2\xb5D\"\x9a\x84\x18\xd1*\x8a\xa9\xb0\xfd\x0b\xa5\x19\x85\xc5\xd0\xba\xef\x9e\x8cp\x1aH\xaf\xa6,\xf4\xe9\xd5X,\xba\x17\x85]\xcb\xc2!^{\x82\x13h\xa29\xbfY\xf6\x96z\xeb\xa7\xfb\xfb\x07\x13\xf1\xff\x04W<\xaa\xba\xdf{\xa0S\xe1\xaf\x08\x0bd|U\x86M\xc3\x86J\xdfO6\xa1\xc7\xc2\x85l\xde\xe5\xb6x/?\xa8n\xdfhL\x93\x1a\xafU\xc7\x88\xc6h^\xd3\x14\x984v\xc4@X\x02^\x16\xc7\xc2\xcb\x0e\xc9&\xe4=\x89\xfbf\xf2f\x0f\xff\xa6\xe0\x89\xdd\xdb9\xb5\x99\xee\xc2\xdei\x90\xba\x0e\x12W\xdb\xe7\xa6_\xd6\xf7B\x9f\x8b\xf3J\x1c\x92@\x1e\x83\xf8\x82\ni\x9f\xec\x07$\xa5\xba\xc2\xfc\xaf\xa94S\xe5wRG\xd8\xac\xea.W\xe3\xac{\\0\xdeR\x08\xb4\xd3\x15M\x89j5z9\xac\x96\x94t\xfa\xc0\xc0\x84\x16\x8c\xa8A\xea(\x16j\x8a\xfc\xdb\x8a\x15/JVQ\xb2\xccf\x9d\x1a\x11\xc4\x84\xd8b\xa9\xb9\x9a*\xfb\x93\x0ers\x7f\x87\x8aOR\xa6\xab\xa3m7\xa7\xbd\xa3\x83\xc3Gw\x0f\x8f\xee\xde;8;x\xf0\xf4\xc1\xbd\xa7\x07O&G\x8f\x1f\xfd\xe5\xe0\xf0\xe9\xc1\x81Jf\x87\xd9j\x9a^\x19\xe55v\xa2*\x1b) I:\x95\xbcg^\xc5Q\xd2\xcd\x96$Y\xea~G\x92\x17\xea\xb3{\xf9\xf2\xc1\xab{\xf7\x0f\xee\x1f\xdc\xbb\xff\xfc\xc1\xd1\xfd\x07\x07\x87\x0f\x8f\x9e<{\xf0\xf0\xe5\xc1\x8b\x17\xcf\xef=~u\xfc\xe2\xe1\x83\xc3W\x07\xba+\xddk\x12\x9b*\x93\xa0\x88\x00hBp\xd0$\x005>\xc3\xacu\x01\xc65/\xc0\xbc\x12`\xb3\x1a0\xe2\x8a\x08\xba\x8c\xc9\xff\xf7\x1e\xe86\x80<5O\xf5\x04A\x11b,\x02\xf8$%7i<\xe5\xe93\xb9I\xa3\x12\xa9\x147sh\x1e\xb7/\xc2$\xbbQ\x83\"\xeb\xf5M\x1a\x8e\xd8{y\xb4\xf5&\x8d\x8b^0\x9f\x86\x1e\xbdIc\xe2:%Jh<\xd2A\xaea\xdd\xce\xa8\xb7\xbcw\x044\xf4\"\x9f\xfa\x90\xf7`\x9e\x92\xb4\xd6\x0e}\xba>\x7fp\xdf\xcb\xc8\x1f\x8b\xf3\xcf\x94<\xfc\xbc^\x9c\x7f\xba\xf70\x0d\xff\xb8\xf4?_\xdc's\xef\x9e\x7f\xa4r\x05i\xdd\x06\x80\xd5\xba8\x8dkp;\x01\x96x\x80r?\x81\xc9\x05\x05\xbd\xfa\xeb\xeaNo\xc0\x19)h\xa6\xdeM\xda\x08zC\xcd8Y@M\x18p\xc6\x19\xca\x08\x01\xd3\xf2\x15`6\xc8P\x94\x86\x11\xa8\xad\xd8*\xee$Z\x81;\x89\xe6`7Qw\x12u'\xd16\x98W\x02lV\x03F\\\x11w\x12u'Q\xc4\xa8\xdcI\xd4nP\xee$\x8a\x1a\x97;\x89\xba\x93\xa8I\xdb\xdd\xa8\x93\xa8RQJ\xf4\x83R\x94\x95c+v\xc9\xf5\xf7\\\xd3\xd9;;\xd98\x9b\xd8\xd9\xc4J@\xaf\x06\x8c\xb8\"\xeb\x98J\x9e7\xca~}\xf9~c\xc9~\xe4\x9abW\xb4\xb4\xcf\xcc\xaaK\x02\x9a\xba\x15fCN\x8f\x044\xde\xfa\xe1]y@\x97`rGH\xd8E\xcfq\x94\x99\x9f9\xd8E\xc7)[\xd1$%+\x83f\xeb\xd9y/g\x89\x04\xd1\x1fjL(\xa9Q\x8eI\xe5\x8a\x92`V\x14\x12\x90\xbb\n,v\x16\xa0\x05\x96\xd5b\xc0\x88B\xab\x02\x842\x91`A(\xb0$\x16\xe0\xd5\x8b\x04\x0bv)\x00\xadj$`\xd7\x0f\xec\xd7\x10F_\xc7\xb2\x1e\xbai\xc4\x16#-Gh\xac\x93\x0e\xf0(;{\xfe\xe8\xfe\xdf\x82\xf3\xf0\xd3\x7f\xfe\xfd\xe5\xe5\xe2\xd1\xef\xe1\xc37\x8f\xdf\xae\x1e\xbd\xca\xfeq\xf0\xf2\xed\xfd\xd9\x1f\x17\xd9\x1f\x0f\xe3\xcb\x9f\x0fWg\x1f\xfe\x1a\xbf\xcb\xde\xbc\xf9\xc7\xc5\xf1\xf1\xa7\xb3'\xbf\xff\xf1\xdb\xe2\xf4\xe0\xdd\xf1\xfe\xd9\x8b\xf5\xc3l\xff\xc9\xd1\xf1\xa7\xf8\x1f\xf3\xff\xf8\xeb\xfb\xf5\xb3\xbf\xfd\xf4S\xd9q\xbf\\\xbb\xbd\"\xd9\xeeO\xa9\x0et\xb7?_\xd3\x14\x88\x14\x1a@\xf8?=\x1a\xa7\x84\x85\xb9&\xc9?\x1f;\xf5\xae\xfb\x16M\xc7}\x19y\xb1\xa61\x16h\x93\xe1\x99\x18\xfc\xd67\x86\xab6[\x9b\xe8\xea\xee\x96\x1b\xbeW\x86`\x8d\x96E\xfd\xfa\xed\xc1\xb9|A\xc4Y\x06\xeb\xcapQ\x9a\x02\\\x94\xc6,\xe2\xc7TA\x08#\x02E\x04@\x13\x02\xf0&\x03j\xad\x0b0\xaey\x01\xe6\x95\x00\x9b\xd5\x80\x11W\xc4Ei\\\x94\x061*\x17\xa5\xb1\x1b\x94\x8b\xd2\xa0\xc6\xe5\xa24.Jc\xd2v7*J\xe3\xf2\x05K0N\x16P\x13\x06\x9cq\x862B\xc0\xb4|\x05\x98\x0d2\x14\xa5a\x04j\xbb|Aw\x12\xcd\xc1\x9dDw\xbf\xdd\xea\xe0N\xa2\n@\xaf\x06\x8c\xb8\"\xee$\xeaN\xa2\x88Q\xb9\x93\xa8\xdd\xa0\xdcI\x145.w\x12u'Q\x93\xb6\xbbQ'Q\x97/\xd8\xd5~\xd0\xc9\xc6\xd9\xc4\xce&V\x02z5`\xc4\x15q\xf9\x82mp\xf9\x82_\xa2c\x97/\xd8\x00\xb3\xa2\x90\x80\xdcU`\xb1\xb3\x00-\xb0\xac\x16\x03F\x14Z\x15 \x94\x89\x04\x0bB\x81%\xb1\x00\xaf^$X\xb0K\x01hU#\x01\xbb~`\xbf\x860\xfa:~\xfb\xf9\x82\xf7u\xd9i'\xa1\xd08\xedl\xb4\xbd\xfb\x07\xf7\xd5\x8d\xf2\xc7\xcb\xf2\xb46\xd9\x14\xfc\x88&\xe1^\x0dE\xaf<\xc5\xfd\xca\xf5AS\xeb\xd2\x80ec\xa8^\x15\x1a;O\xb1W\x02`c`@\xb6\xeb\x19\xee8\x1dP\xa5\xd35L]-\x84\xaa\xd9\xf5V~7XZ\x88\xed\xd9\xdfA\xd0r\x0f\\\x90\x80\x8f\xf5\xf0\xe1\xd5\x86\xae\xd6t\xb5^?9\xbaz\xb2\xdc|\xfe\xfc\xe42^\xcc\x9f\xdc\x8f\x1f\xfe\xf1d\xf9`~ty?<\n:q\xae\xb3\x99\xfa\x8dK\xd4l0B\xa6\x1c\xae\x17\x85\xc9:\x9b\x1d~\xf6\xfe\xf03\xba\xfetp\x91\x1d}^\x9c/\xce\xef?\xa1sr\x10~\xba\xfc\x1c\xfa$\xfc\xf4`u\xdf{\xb4&\xf7\xb2\xfbd\xfd\xf9\xfe\xe2(~\xb2H\xd6\x9f\x16\x0f\x17O\xbc\xe4\xde\xf9\x13/\xeb~\xed\xf1\"JY\xb8\x98\xae\xa3\xcb\x01\xaf\xeb\xd6M\xa6\xc3\x03\x95eT:\x8d\xd61\x8bb\x96\x8eB\xc2V\x7f\xfdD\xd7^Kv\xa13\xad[\xc2\xc1\xa5[\x0fM\xb7\xde\x92\xb6\xb5\xb4k'm\x058i[\x03\xc4l\x9c\xb4\xdd\x9d\xb4\x1d\xdf@}V\xdc\xb7\xc8m\xd30J\xab\xa7\xf0*\x1c=\xc5|z\xc5\x85;I\x96\x1d\xa2\xdd\xa7\xeb\x98z$m \xbd\x96\xc4?\xbb\x82\xd9F\x9c\x93\xf2\xdf\xb7\xa4{L\xc2\x84xi\xad\xce|\xcb\x02OcF/(\x10H\xabO\xf3W+Y\x9a\x08\xdc\xc5\x0bF;\xd4\n\xd5\x0c\xb6\x86xv\xd5\xfe\xd9\xe6\xa1\x1bh\xaa\x83g\xcf\x9f\xbd<:x\xf9\xf8\xc5\xfd\x87\x8f\x1e<~\xf6\xe4\xe1\xf1\xcb\x07\x8f\x1f\xdf{\xf6\xe8\xc9\xd1\xe3\x07\x8f\x8f\x9e<<~~\xf0\xf0\xe5\x83\xc3\xfb\xf7\x1e\xdc\x7fr\xf0\xea\xd9\x8b\xe7\xc7/\x8f\x1e\x1c?:zv\xef\xf9\xf3G\x0f\x9f\xdd*F`\xabM\xaed\x89\xf7T\xbe\x81s\xc1\xb8\xf4jMk$\xd5\xd1}j\xd6\xee+\xbdPzq\xf0\xf8\xc1\xe1\xbd\xc7/\x9e\x1c\xde{\xf2\xe4\xde\x93\xc3'GO\x1e\xbczu\xff\xd9\xc1\xf1\x93\xc3\x83G\xaf\x0e_\x1d=\x7f\xf1\xf2\xe0\xc5\xbdG\xc7\x8f\x1f=\x7fy\xf0\xf0\xfe\xfd\x97G\x87\x8f\x9e?{u\xef\xd9\xfd'\x0f\x1fn\xfd\x98v87\xb5JK\xaf\xb2VIG\xb5z0hO0\xf9\x8e\x0dbmN\xb5\xa1\xa2A\xd1\x9a\x051:\xc5\xb5\xe2\x96\xac\xa2,4f\x95\xdd,\xbf\xbaO\xc3h\xa5\xff\x045\xf7\x02J\xf6KRr\xde\xf54N\x05&rI\xe8\xd3\xf7\xde\x83N\xe5\xba\xa2\xab~\xef*\x19\x9a}:{\xf3\xe0\xc1\xdf\xb3\xc3{\x8f?\xffm\xf6\xca\xfb\xfb\xd5\xfd\xbf<\x7f\xb59>Y\xd0\x07\x7f\xff\xedt\xfe\xcbIv\xf1\xf9\xd9?\x1e>y\xb3\xf9\xf4s\xf2\xe9\xc5\xe3\xf7\x87'\x97\xec\xe5\xfa/\xec\xc3\xec\xe1\xef\xef\xfd4X/\xfe\xf3'E\xd7\x06\x9b\x10AH@\x11\x13\nTZ~A\xd1\x13\xea4M\xcb\x03\xe0\xfei6\xfb\x85n\xdeSo}\xf4\xe0\xe1\xb9*\x01\x14L\xaf\xdfI\xb0\x1f\xc9\xf1\xc5\xe7\x83\xfb\xbf/\xd3_\xfe\xba||\xfc\xfc\xf9\xef\x9f\x83\x93\xc7\xe4,J^o\x0e\xd8\xf9\xab\xff\xf8\xe5\xe4\xf7\x9f\xffv\xef\x8f_\xde\xc4Q\xf2\xb3JXy\xf2\xbda\xa9FLk\x82e;u\xd8'\xa1\x9f2u\xa0\x1fF\xe8I\xe6\x00\x8d\xaa\xe2\x82H\xab\xe2\x94c]\x90dzIBn\x93\xf6i\xde\x0ce\x1d(\xce\n\xbc\x93,\x19\xa3\x8b\x87\xf7\x1e\xdc\xef\xea\xc1\xf4t\xde \x15\xaf\xdd\xe6\x98M\xfe\xe5^\xb9\xd5\x1fcN\x8a\xf3K~\x9eyY8\xda\xcb\x04\x1b\xf3\xe9\x05q:\xa9\xde`\xa2$\xf6\x96\xf5SI\xe7\x01\xa6\xe33\xf1\xda\xfb\x05\x0d\xd3d\xd4\x83K\xfb\x99myr\xc9\x1fB\x9d\xc8\xbek?+\x16\xaa1\xf8\x96:\xab\x9f\xc0\xe4\x04 \xc9\xbc%\x90\x04\xf6\x9a\xfd\xfc\x94\xd0\xd0\xdf\x83\xcb%\xf3\x96\xe5k\xe2\xad\xa7\xd8\xf9Qc\x1e\x05At\xc9\xcfr4\xf4\xd7\x11\x0b\xd3\xa7\xb0\xf7\xfa\xe5\x99X\xb5\xff\xb7\x0b\xe7\x84\x9fq\xe5\x83\xf2\x0dl\xe2\xf9\xfcU\xe4g\x01\x05?\xf2\xb2\x95\x18\x1e?!F\x97\xc5h'\x10D\xd1\xb9xd\xf7\xeaj\x9a\xffm\xd5\xf9\xa6\xb9\x17\xc5\xf2\x0c%\x9e5\x97\x0e\x8f\xbb\x89\x7f\xbe\xefG^\xb2\x9f\xac\xa9\x07>\x8b\xa9\x97F\x0d\x9a\xd7Nr|\xb4V+\x94\x08=7\xde\nqf\x96\x87:\x89YR\xb6\xf1\xb9\x8a\xca\xff\xa39\xa6\x9f\xf2dA\x93c\xea\xe0\xe1\xfa\xea\xeab\xaf\x9b\x1eV8P\x84[\x93\x85\xf2\xa9\xfbS\xb2\xa0\xdbg5I\xd1\xed\xf7\x84;\xfc\xb1\xfa\xae\x03\xb6bJ'\xf1\x1br\xc5V\xd9*\xef\x1e\xa2\xb9\x94\xcb\xb0\xa6q{\xcc\xa3\x0d(\xbd\x9a\xacX\xb8\xe5\xedU\xe1o\x8c\xb7!\x9b\xa2P\xfavs\xd6\xc9\xfdJ\x8b\x98\x92\x94\xcf%\x06\xfa)#\x01\xa4K\x96H1\xde=\xea\xa3\x07\xe8a\x93\xab\x9d\x0d;\xa0I\xc2EE\x88\x1f\xf8c\xa1\xf8\xf3\xdf\xac\xdd(\xc7A\x00\xe9U\x02+\x92zK.9\x1a\xfe\x14)qjmG\xf2\xa8\xc8\x1b\x17^\xf7\xb9N\xe23\xb9-\xda\xb6\xf4\xa8\xc88\xd3+-\xde\x01(\x15\xe9 \xfd0\x8a-\xdd\x17\xd9\xbdv\xc2HgV\xaf\xce|\xdbU|C\x97\xa3\x82\xb0\xd50'\xdb\x91\xfdo\x12\xf4\xc9y\xdaU\x91\xa0\xf1\xc8I\xe8\xf2\xcb\xe5\xbf\x8cc)+=u\x12L\xc6\xbc\x04\xa3g\n\xb5\x8c\x1a\x0f\x9e\x04\xc4\x94\x019m0\xf9\xf4$\xa0F\x0d\x96\x0e+\x135\x01GQ\xc0SD\x02\x96.\x12P\xde? h*\x15`\xe1 \x94\x80#\xaf\x84\xfe\xa3Q\xf8\x06%\xa8=\x84\x12P\xdd\"|y\xe8E\xc5.'\xaaO\xc0\xce@\x02F\xe2\x16\xf0\x85<\x8a\x12\x8c~E H\x92\x83\x05\xd9\xa1@k\xfc\xca\x8a\xf20\xd8\xeb(\xc1\xe8\xdd(\xa0\xef\xd8F\xf0CJ\xc0z#%X\x0c\x17\xe1\x99\x94`\xf6OJ\x18\xb3o\x95\xc7R\x02\x82_1|\xaa\xf4aJ@\xcd\xc7\xe4\xcf\x94\x80B\x85\xf3mJ\xd0{8%\xd8w\xaa\xf2vJP\xfb<\xf3\xdfQ\xea\x1d\xa1\xda\x11\xcb+\x01\xb3\xc8\x12\x10B\x10M0\xc0\xcb\x8fN\x8c\xb8\x1c\x93D:%[\xe7\xd1~\xfeU\x80u\x94\x94\xbb\xc9\xc6\x83\xfa,\x8e\x88\xef\x91D\xa4\xad\xb1EH}H\xafnut\xdd\xf9!\xa4\x11\x10\x98gAP\x7f\xfd\xde\x8b\xc2$[\xe1<\xa9c8]g\x91\xdf\xe5\xd5(G\xac\xa2fK\xb9\x9f-)\x9f\xd2*KR\x98\xd1j\x9a\xefS\xff\xecj\"~N\xb2\xf5:\x8aS\xea\xc3\xac$\xc7*\xf2i\x02,\xf4\x82\xcco\xdaz\x1fo\x0bw\xc8\xed\x8f?\xc44\xcd\xe2\x10\xc8<\xa51\xefC\xdeC\xfb\xf1\x0e|\xbc\x9dlB\xaf\xfe\x05\x8d\xe1\xf9\x92z\xe7gW?\x02\xa9y/%B\xd2\xfc<\x16\x1e\x16rI6?Nj_*s_\xc6\xf2u\xb8l\n\x97M\xd1\x02\xd4y\n1\xf7\x02,\xceP&rI\xe8\xd3\xb7\xcb\xa6p\xd9\x14\xc63\x0e\x8a\x9e0\xf8\\\x83\xb0H\xecG2\xc2)\x06{~A\x0d\xcexn\xc0\x9cV\x86\xf6\xc45\xbaJ\xc1)\xb0\x96\xd8\x84\xc6\xcf\x7f\xb6\x8e\\\x9c]Uv\x05\x0b\x17\xf9!\xa9\xf6\xf5H\xfa\xdb\xe3\x06\xc6td-\xeeuR\x0dJ\xa4\xdb\x91\xa4\x02|\xd2U>\x1eL47\x1d\x92L\xdd\x9aNv\xa6\xf6,\x9c\xf7\xd3\x02}Sk\\N\nn\x13\xaa\x98\xb3\xf3F\xb1`>\xf1\x7f\x15+\xc5\xff\x8f\x8e\xf7\xe0A\x15\xabl\x7f\x90\xb3\x17\x1c\x1et\x7f#XH\xfc_\xab\xe5\xbe\x0b{\xdd\xd2\xb1\xe3\x07\x9f\x06\xec\x82\xc6n\xb7\xbb\xdd.\xe0\xfb\xd9\xed]\x15\x0b\xbf\xf5\xdd>\xe4^G\xcf\n\x07\xfa\xab\x1a\xed\x0d\xd5\xcf\xbf%nA\xc9\xfb|\xb2m\xdd\xdd5B\x1e\xe1K\x81\xbau\xbf)\x8dD\xe6\xc8\xf1\x8a\x85\x11\\\xb2\x98\xc2<\x8aWe\xca\x9b\xca\x95\xd4\x89\xeb\x87\xdc\x97\x14\xc5\x10F\xe9\x8f0\x8f\xa3\x15\xfc\xf5\xfd\xdb\xdfx/3\x92\xd0\x87\xf7\xef\x16\xf7\x15E\x87%\xba\x84\xc6\x8c\x04\xec3\xf5a\xb6Ii1\xf4\x1b\xe2cS-d\xeeKK\xa3\xfc\x16f\xed;\xe7\x9c2\xedH\xe7\x9c2\xcfS\x82y\xb6\x12\x9cs\n\xcc\x9d8\xe7\x94sN9\xe7\x14\x86\xed\xbe\x84s\xca\xde\x99$U\xf0%\x11\x17\x04<\x9a$\xf3,\x086\xe0\xd3\xbc,B\xe8CL\x0b\xab\xa3\x86e\xe7z\xd8d\x88\x8aG\x0c;l\xa2\xbbm[H\xdc\"H\xc5<+\xa2h\x83\xaf5\xa2\xacH \xed\xb9\xda\xe4\xfb]\xd2\x17\xd6\xa9$\xabl;\xb2u\xfa\x82vX\x94\xc2\x82\xecc\x9fvb\xeb\xb4O\xad\xecRn\xebq\x836\xff\xe0\xab\xb1O\xe5\xba\xd5\xbe\xfbr\xf6\xa9i_tj\xbb\xf7\x17\xcf\xd8\x7f\xd0\xfb\xbf\x9c~b\x7f\xfc\xe7?\xa2_^\xbd\xfa\xf9\xe5\xe7\xbf>\xf6\x8e~>=\x9e_\x1c\xbd|\xf5\xc1;Y^\x1dlN\xc9\xe2\xf2\xe5\xf2lspqz\xfc\x97\xd7\xaf\x97\xcf_&\xc1/\xffA\xee\x1f\xcf\x0f\xb2g\x7fY\xcd\xdf/\xa37\xcf\x17\xbf\x7f\xf6_\xbf\x8a\xff\xf1\xee\xe4\xc5\x9b\xb3\xe3\xcb\x97\x8b\xbf\xfd\xed\xf2\xaf\xd1\x9b\xbc\xdb\xb1E\xd0\xf8\xb4\xed4\xd6u\x06\xa9!\xe3\xbbsE:\x8d\xf3\x01'\x0c\xa5AnP\x15:\xcb\xd2d\x84#\x0e'\x83]DF\xa3\x1b\xa5\n\xd1\xc6\xb6\xd9\xd0\xb6\xed\xaf\xc3\xc0\xee6\xae5\x885&\xef\x00\x96A\x99\xea\x9a\x89\x9a\x0d\xe8/`#a\x11G\x1e\xc5@\xea,\xa9\xb4]\x1a\xady\x93.\x1fj\xfe\x19\xb0\xb0\xa8\xad\xd6\xb04aX\xb9\xa5>\x97R\xadM\x91\xe3n\xaa\x83\xd6\xf6\xd8\xd6\x9f\x9dzS#\x9btRI\xa9\x1f\x0d\xbb\xc3\xa0\x0f\xd5z\x10\x8b\xb7\xa1\xf7\x06\xed\x9b\x9c\xd7k\xfbf_\x9c:\xe64Nr\xa4\x88\xb3R\xed\xba\x7f\xe8\x83\x17\xb10\x91\x07\x94(\xac\xb6S\x1a\x01 \xa3tY\xc6\x1a4\x1b\xea\xba\x0f'\xdf\xd6\xde\xd3\x1e\xb9\xf2\xe5P\xcdJ$\xd1\n\xdd)\xfc\x0f\xe9\x95\x08\x87\xf1\xf94\x0b#\xec\xfa\x10\xc6\x8f\xb6\xd3\x98~\x1a\xd5*\xe3<9T\xdf\xe5\x0b\xb2xB\x96\xf1\xc3\xab\xe52}\x10\xaf>]\xd0\xf0\xe1\xd1\xe3\xf0<\xb8\n\xb2\xcf\x9b\x8b\xc7\x9f\x9f\xfc\xf1\xe9\x0fo\xe5u\xa2j\xedOI\xeb\x9c\x89\xa2\x18~\xa1\x1b>y\xb1\\|\xd3,hHc\x92\xb6\x1c\x02\x1d\x98{\xfb\x95k\xb3\xbb\xfd\x9e\x86)\\0\x02\xcf\xc5<\xe1\xf7hC\x164\x86\xff\xef\xc3\xc1\xc1\xc1\xe1\xab\x87\x8f\x0fnw`\xd0\xbf\x92\x89\xef^vz\xf7\xe7l\xd6\xf1\xddWe\x15\x1d*\xaa\xe2\x0cF\xac\xaf\xb9C\xfc?\xb2$]Q\xfd\xb1\x13\xd5\xd1\xe1\xe4\xa8\xab\x979U\x19\xf0\xeeH\xdb\x01\xb6\xfd)bF [e\x01I\xb5|9\x8b\xa2\x80\x92.\xc9P\xc3?'A\xd2=\x1f\xdd\xcd\x8b\n^&)\xe3v;\xe76\xe1\xddm\xb9)=\x12\x86\x91\xb8\x9e\x91%\xd4oW\xb3\xa9\xc0\x8b\xc2?\xb2P6\x12\xc5(\n17\x8d\xc2`\xf3c\xab\x95\x8a\xce:\x96\xdbU\xad\x00-\x8b!\x96\x1b\xc1Zz\xb6\xb2\xe9\xa3\xc6N\xdd\x16\xf9\x91\xbe\xdai\xe9\x18\x94~\xc1b\x91\x9cgPB_\x81\xee<\x83\x0d\xb8\x161\xea<\x83\xce3\xe8<\x83p\x8d60\xda3X\xdc\xb8\x8d\xe5KBU\xab^\xae\x0d\xe9\xd9\xa8\x95=\xb2\xf0\x01\x9e\xf1V\xe2\x16i\xb0\x81h\x9e\xfb2d\xe9;y\xca\xc9[\x8c\xe3\x0d\xb4\xf6\x92\xbd\xfd\xa5\xf6\xcbH\x9aW[ \xaa\x97\xee\xfd\xeel+\x13\xab\xaa\xd2f\xf7j\xbc\xba\xff\xa7\x98=\x0b\x05\x97\x14\xfe\xebm\x9fU\x87\xc7Jzv\xea\xcdou\x0e\xe3y\xc4\xc2\xee\xcf\x14\xee\x9cNr\xd4\xbcS\x19I\xa3\x95\xf8a\xc0\x1e#\x90\xb0p\x11P\xb1\xd9\xba\x86w\xb3\xf7Z\x8b:8I\xa7\x9aj\x7fF\"Y\xba\xecp\xe7\x0e\x0f\x83\xd4\xfc\x7fe\x01A\x9d$<\xceJ\xce\xb4X\x9d\x9d\xfafk\x9f]\xb3+\xd6\x9a\xe9\x8e\xbb\xa9\xce\x17d\x8b\xf20\xa2\x0e\xe84\xb04\xd2Pa\x14\x0d0\x8cG0m\xb4\xcf\x14\x19\xda\nM\xafk\xe9Nd\x0d\xb0\xedO\xe1\xd8Zg\xb3\x80y7\xfb\xf00\xec\x00\xd0\xc3\x9c\xb6\xb0{i=\xa4\xc7\xd7\x94\x85\x8b}\x9f\x06t!\x9e\x0f\xe3FE\xfe\xefc\xdf\x8f\xffU\xfc\xc4\xa20\xe9ca\xd4p\xdd\xea\x1c\xdc3\x19\x02;\xf6\xbc\xe3\"\xa41\x87\x17E\xbb\xb2MO{\xc3^\x04[*>\x12\x04P#\x91\x8cb\x92j\xe2y\x9b\xb6\xce{/ \x9f\xff\xc5B\xedY\xeb\x07\xa4Q\xb2\xeb\xc0xN\x0e\xdd\x83\xe7\xdam\x81z2]\x8b!Y\x92\xb8{\xcfk\x9b\xe5\xe9\x05\xeav\xdf\xe3\xd9\x05e\xb2\x96\x8b\xbeeU\xf53Y\x9b\x99\x05U\nA6[\xb1\xb4\xb6 \x8bMe\x97Y\xbc\xd5~k\\\xb9P\xa2@\xc2\x9c\xb0\\T\x05\xecS\xc6\x8a\x1c\x06Q<\xabdU\xd4\xc6\xb3\xb2\xba\\\x90\xdb\x05\xb9[0\x82\x15|}\x0e>\x17\xe4\xde\x02w\x16P\x7ff:\x0b|\xe7An\x84U\xa5%tcn\xc8'v\xdb\x12\xdf\xa7\xeb\xf3\x07\xf7\xbd\x8c\xfc\xb18\xffL\xc9\xc3\xcf\xeb\xc5\xf9\xa7{\x0f\xd3\xf0\x8fK\xff\xf3\xc5}2\xf7\xee\xf9G\x8fZh\x10\xc6\xdc\xae\x07>\xe8U`}vA/%\xac\xd9\xa2\xc6\xcdb\xdc\x96\xe6\xe81\x06{m\x13\xea\x8f3\xbbI\xc6\xdc\xd5\xc9\xc7\xca\x00sI\x07\x8d\xa6N\xad5\xc0\xb6?\x97t\xe0\x92\x0e\x9a\xe0\x92\x0eJ\xb8\xae3\xc9p\xbf\x06?\x9fV\xee\x83\")\xa1\xe9f\xd8\xbb\x7fp\xa8F\xfd\x0b\xdd\xc0\x9a$\xc9e\x14\xfb\xc0\x12\xb8\x8c#\xb4wW\x1d\xe1\xb3\xf3\xee\xee\xffY\x9ae\xe2\xb7\xef\xc2\xdb\xab\x99M\x83\x1a\xda\xd9\xbc]s\x1b]~\x98Oi\xdb\x074hJ=\xacU\x0b?\xf6\xdf2\x1aod\xc2J\x16\xc74\xac;\xd3`F\xd3KJ\xc3\xbaO[\\\xf4\xd8\xf6s\xddx\x1f\xb7\x95\xa57\xecp5\xec\x84\xa3rUk\x9a(\xdd\xd4\x03\x8c\x80\xaf\xebL2H|\x97\xeb5\x92\xaf\x1a%|\xb3p&_B\x9d\xba \x9b1\xc8V\x12\xcb\x85\xdb\x04\xdc\xf4p\x1b\x0bY\xcaH05\xc6\xcf\x14\xed\xfb\xb6\xf3b*Vq\xaa~\xeaP\xb6W\x15\x86]\xb1p\x9a\xb2\x95\xa6\xe7\xad\n\x98\xfd\xe4N\xd5\xbe\x97\x88\xd1\x87\xc3H\xd8\xb9c\x8a\x1d0vl\xec\x83\xe8\xab\x19\x19\xe3\x7f\xa1~\xae\xcc\x8a\x9d\xea\x82c.8&\xc0\x05\xc7$\xb8\xe0\x98\xf3\"6\xc1\xb6?\x17\x1cs\xc1\xb1\x1a\x8c0\xf0\x1e\xee\x86\n\\p\xcc\x05\xc7j\xa0\x13\xf1.8\xd6\x01N\xad\xb9\xe0\x98\x0b\x8eu\x81\x0b\x8e\x95p]g\x92q\xbc\xab]\x9e\x88\xaf*L\xd6\xe9\xa9u\x01\xb3\xe6l\xbe\xb7\x80\x99\xda+\xedbf}\x8e.\xc3\x0e>4L\xe3N\xf53\xc0\x00\xed}\xb5\x03\xe1\xfc\x06\x8c \x1e\xda\x1e\xe1\x0c\x07\x0c\x1e\x9dO\x1cT\x08\x06(\x8c\xb1\xc3q\xa5\x8c\x8fim\x9f\xea\xe5\xf5'\xbe\xc9\xcb\x8eZ\x02\xfbVg\xf7\xd6\xc2\xba\xe9Z\xe9\xa0\xa2z(\xd5n\x99\xc7\xf9\x95z\xd5x~'Am<\xefc\xefw\x8d\xb0\x1deHid1\xa0\x17I:`@\x16b\xbb\x08%6\x98\x00~\x98\xb3 \xa51\xcc6rR\x92!\x92\xc2\x9ft\xe3%42\x94\xf8\xff\xc4t\xfe\x14\xf6\xfe\xef}\x9f\xce\x85x\xe2\x16\xcc\xbb\x1a%\x86\x97\xa6@\x18R\x0d\xd2\x7f\x17\x06\x93U5\xdc/\xce\x17\xe7\xf7\x9f\xd099\x08?]~\x0e}\x12~z\xb0\xba\xef=Z\x93{\xd9}\xb2\xfe|\x7fq\x14?Y$\xebO\x8b\x87\x8b'^r\xef\xfc\x89\x97\xcd\xb7\xfa\xf9\x83\xb0\x80v:\x9d\xf4'\xe2$%i\xa6Y;\xd5]\x8f4:\xa7\xddE<\x0d'\x9f\xe2\xf4\xda\xb3\xa8\\\x9de\x94m{G\x1fWQ\xc8\xce\xd5o\xa3\x1bU\x06\xf3i\x98\xb2T\xf9\xe0\xbd\x11\xc1%\x9d%L\xe5\xdb@\xb4O\xa8\x97\xc5,\xddL\xbd(L\x89\xd7?n\xe9\xd3\x94\xb0\xc0`\x9e+\xdasAi\xbcDd\xdeM]J]\xa0fa\x1a\x93iz5\x15&D\xf7r\xe9\xb9\xb7\xd6\xcb\xc1\xd6\x8fU\xca\xcan\xe6P\xe1\xd7_\x96B`?|\xf2\xe8\xe0\xee\xc1\xe1\xdd\x83\xc3\xb3\x83\x83\xa7\xe2\xff\xffc\xbbC/Z\xadX\x92\xecf\xcb\xc4JW\x9cq\x1e`\xa2\x14\x87\x15\xb9\x9a^G\x1f\xde\x92\x84\x0b\xba\xf3\xae\xb2\xb5ORj\x9f\x12\xd0\x04,\x07\xf4\xb4V\xab\xf6\xd7a\x90\xbal\xb0\xe6l\xf0\xd9`\xadl\x80qg\xd3\xc3\xae\xb2\xb7\xbak\xf9*\xdf\x84\xc9m\xe5)4[\xd0hS\x08k=\x0f_\xe3\n\xcc\x96\xb3v\xf8z\xaby\xf76\xb3\xcab\xd6\xd9\xcb*kYgm\xa8,e\x0dq\xccV\xb2\xb6\xb1\xc6B\xd6*{\xbd\xaa\xd7\xda\xc6\x06\x9d\xa5\xb7\x8b\x0d\x8d\xb56\xb1\xa1-\xce\x1e6 \xd1\xda\xc2\x9a\xb6Z;\x18\xb77\xb6\xcd\x08\xa4\x05\xac\xb7\x7f\x95\xd6\xaf\xd9\xf6\xed;n\x93\xd5\x8b\xc4\x8b\xb1xu\xf6\xee\x80\x0d\xa06\x0d\x8d\x16\x9b\xc1,\xd4\xdb\xb8c`7Z\xb7C;1\xda\xb5\x16\x1d\xec\xc4\xa6\xddirle\xccJ\x1c\x16\x86PM\xfb\x15Y\x96\xd50=\x12\xfa\xfc\x9f4\x99\xc0\xb3\x0d\xf8tN\xb2 \x05\x96BL\xd3,\x0e\x13\x88\xc2@\x16\xa0\x92\xa6R\x89\xab\x1a\xd1$\xff\x9b:\x0d\xae\x99\x91Z\x98\xa1R\xd7\xd5\xfe\xacXA]\xb2\xc4\xd9\x92\xd6f#\n]H\xb4\x13x\x93%\"7\x82\xb2tIc\xd8\x93\xe3\xdf\xbb\x03{RR\x88\x7fGM\xd1\xb5W\n\x91\xbdI\xed\x87\x9a\xe9\xda\xa2\x82n~k\xb2\xa0\xaai\xf0q\xf3\xdfA\x86'&[T\xd8\x16\xac\xb5A\x1c\xa2\xfa\x0f\xd8\x8a\xa5\xba\x01\xac\xc8\x15[e\xab|\x0c\xdc\xc2\x17\xee[X\xd3X\x0c\xae\xe7\xa8n\xbc\x0d\xed\xdc\xd6F\xd3\x1bc|\x1b\xa7\xe1\xdc\xd6\xdb\xed\x94G-\x93AnD\xe0\xdc\xd6\x9a\xf683\x1d\x81\xc8\xb9\xad\x9d\xdbZ\x80i\xcb\xec\xda\xcf\xeb\xdc\xd6\x1d\x80\xe5\x80~\xd6\xf8^\x879>\xdc\xb7\x8c\xf7\xc6~\x1bws\xf9Y\xa2\xfe\"f^}.\x7f7\xf6\xdb\xbe\x85k\xb6\x0d\xd1J\x1ek\x17\x0e_\xe1\n\xcc6\xa1v\xf8\xce!\xab$\x8e\xd9\xfe\xd36v\x0e\xd9\x12p\x96\x9e\x01\x89s\xc8\xd6\xa0\xef\xb8M\xf6\x1c\x12/\xc6\x96s\x0e\xd9\x06\xa0\xec\xb6\xa1\x9d\x18-6\x8b\x0e\xc6p\xc8\x8e\xed{\xc5X{\xc3\x9e\xe0\xfd~,?\xcds\xbc_\x9d\xc1\xb7[\xef!\xe2\xf6\x9dagU\xf7\xc7\xfab\xe8\xe9\x822\x96\x05\xef}\x96\xfe\xd6\x9f\xe3\xfd\"\xa2k\xa4'\x0e\xbe?!\xa6}\xee\xc0\x89\xb3\x06\xdc\x04q\x86\xa8\xf84L\xae)\xda!*<\xe9m\xf6]=w0\xb6\xb8)\xa5\xcd:\x8a\x82\xa7}\xb6U\xfd\x81#~\xe2\xa6\\8\xf0?\xe6\x98\x81c\xfeZv\x94\x95G(\x88\xa2\x84N{x\x0cd \xbaOK\x16\xce\x03\xc9\x98\x01IR\xfb\xc3Y\xd9\xde\xaa\x958,\x88\x0e\xab\xc3\xda4\xa6 \xb5;q\xaecz1\xcd\xe7n\xe5*\x19\xca\xda-\x8d8\x8c\xc1%O\x17(\xe5\xbd\xc9\xe4\x9b\xe4\xef\x8a\xd9D\xc1 y*E.Y\x1b\xc3\x8a\\\xf5m\xc9\xec\x98u\x11q}!\xb8\xcc\xaa\xdd\x00\x97\x07?\xb3\xb7\xb3|\xb6\x9bv\xab\n\xe1!R\x18\xc9\xa3n\x86\x80$K\xbe\x1b\x12\xb6\x08\xf9,Y8\x8f\xfam\x08\x8eA\x84\x01\xb8\xa4_\xb0\x0b\x1a\xb6nH\xde\xea\x18\xd8V\xc3\xce&\x16[dk\xaf\xe5\x13,0Yf4\xe92~N\xabl\x9f\xda'\xaaUU\x98\xc1cg\x01\xbd1d\x00\x8d4\xd2\x07\xb7\x8aow#\x91vk\xc3&)\x89S\xa3\x11\xa74>}z5\x8d\xe6\xf3NEgh,\x03\x16\xd3,LY`\xdd\x98\xebX\xeaOgA\xe4\x9d'\xe6\x94\x80\xb6\x84\xb0\xb4$\xd7\xd9,`\x1e\x9c\xd3\x8d\xa8T\x14\x85\xa5 \xb7\xb5?\xfb\x8a\x9f\xbdJ\xfeh\x8f\xb5\x9cj\xc59\xd6\xa2\xc2\xdf\x07\xd1\x10HN\xf5\xad\x93\\c\x8c\xefi\xe87\x8a1\xa5\x11d\x06\x04\xbb)V\xd3K\x84)\x18\xa7\xeb\xd4\xae>,\xe8=\x00\x1a\xc9\xb0\xe5I\x18\xe7(\x0fbj\x8d9\xec\xedm\x8dV.\xf3\xb3fa\xc6\x8eZ\x8d\xca\xd1\x8fd\x18\xed\xa4\xe8bgi \xd0\xc8\xc9\x02\x10\xa5r\x94\xde\xaf\xceRA`\x9a\x08\x18'\x03\xba\xb2A`\x1e\x17\x18\xddzf\xba\x80\x896\x80\x99\xa7\x04\xf3l%\x18K\n\x01n\xee\x05 \xbc\x9f\x05\x98\xc8%\xa1O\xdf\x8aZ{\xbd\xebh\xa2\x8a\x03\x0db=C\x0f`\x1e\xa3\x04S\x16\xac\x84/P\x8a\x88\x83\xb6\x1c\x11`\x08 (bB\x81J\xcb/(zB\x9d\xa6\xd6%\x8a\xc0\\\xa6\x08z\x8dd`\xb9\"@\x96,\x02\xec\xe0\x8c\x19w\xa6\xf2E0\xa0'kC\xdfU\xd03n#WAO\xbf\x17\x91j\xce\xac\xe2l\xfbs\x15\xf4\xaeUm\xb9\nz\xd8\xde\x07\xaa$\x8c:2\x0e\xc8\xa0\x86\xbe\\\x05\xbd\xads-Dqy(\xabp\xf5\xf2TT\x8e\x8a1\xc3\x069\xce\xda\x91>obr\x01\xe0\x9d \xd6z\x1b\xe9\xa0\xb3\xd3\xce\xe4jJ/\x98\xcf\xf9bJ,\xa3\x05\\\xe4U^\xafK\x16\xfa\xd1\xa5\x15\x82\x15\x0b\xa79\x925\x8d\xfb`\xf0\xa3l\x16P\x81d*\x03\x02S?\x8b{D\xcc\xa2\xcb0e+:\x08\x89\xe0\x9a\xe9<\x96n\xaaiml\xc3\xd0\xc8\xa1!q\xf4\xdcE\x8b\xe8b\x9f\xb3I\x94\x90\"\x17\xd7\xc6\xa1W>\xd9Q\xe0\xb8\xd5\xd1y\x97#/Q4\xbc\x1e\x07\xde\xeb\xe8\x82\x93#\xf4\x8a u\xbb\xf0\x1a\xb3h\xe9\xe7R\xc2e\xc2\x0b\xfb\xf1v1\x91)_\x9e\xdb\x1f\xc1#!\xcc(|\xbc\x9d\xd2\xab\xf4\xf6\xc7;\x8d\xd6\x1fo\x97=\xe6\xf1\xba\xdb\x1f\xef\xc0\xc7\xdbI4O/IL\xa7\xd9z\x11\x13\x9f\xde\xfeXk\x96\x07@\xa2$\x9d\x96\x9d\xcd\xbeM'\x9b{\xd9\xc44;\xf7\xb2\xc9HV\x8d{\xd9d\x0b\xdc\x91T\xfd\x99\xc9\xdb\xfa\x9d\xbfl\x92\xb24\xc0\x9a,\x12\xea\xb3\xb1i\xd7\xd0\xb7V-\x1b\x87\xc7\xab\xae0u\x94\xa8o\xff(P6\x16\xa5\xdf\xbd\xc1~O\xb2\x14\xa9\x97>]G Sfz\xf5r\xba}w\xd9\xe4\xd6\x873\xe7T5rC_]\xea\x9c\xaa\x0d\xb8\x16\x0d\xe6\x9c\xaa\xce\xa9\xea\x9c\xaap\x8d\xc7\x0fk\xa7ja\xf7\x8c\xf1\xea\x88\x95\xb3T\x96\x96(\x9dE\xb7:\xfai}\xd2\xa8A!l\xc7-\xbf\xea\xee\x9d8\xea\xb4\xcd\x8b(m\xa4Y6\xa6\"~\xec\xb0\xdcT/3+\x16]\xd7\x7fn\xb1E\xca1\x94\x1f\xecv\x1c[E\x02u\x07\x8c\x92\xfdd\xab;uGXR9\xbd\xf2\xa1O\xd74f\x91\xbf\xed\xfe\xba\x88R\x16.\xaa\x9f\x85G,Ih\xfe\xef\x98rA\xc8\xff\xab\xef\x94\xad-9\xa4\x9b}\xb7y\xb0\xe5\xa1\xa6\xdbC#\xb1*\xeb\xa2u\x9f\xbd,\x0e.\xb6m\x0dg0lkS!8E\xfb9\x0by\xd7$\x086\xd3\x98&Y\xa0\xc9\xfe\xed}\x92\xd9\xdb\xd0dOoI\"O\x19\x07\x93\x83\x12\xba\xd3E\xc8,II\xd75\n #\xf7\xb6\x17F\xd75\xb10\x9ar\xf1?\xbd\xa0\xa9\xc2\xf19j\x972\xb8\xd0\xaf\xc4Y\x1a\xa5\xba\xc3\xb4\xe9\xe8\xa19x\x8c`\xe2\x19\x8e\x1c\x08\x12\"\x8f\x1b\xa6\xc3\x86]O\x9d\xae\xb2\\\x03\xc8\xcc\x7f\xab\xa5\xc2\xd9I\x9f\xa4-\xd268\xfa\x9aJ\xcdH\x99\x0c:7\xaeZ\xd9\x84\xcd^W\x91\x82\xea\x86\x9aDV)\xd8\xed\x18B\xeb\xa2N/\x1c_M\x80M\x96\xefUM\x8c\x1b\xbf\xf2\xb5 Q\x83\x88\x85\x89\xb8\xa8T6h\xa0\x92\x8d\xb7\xb3\xea](\x0dyJq\xa1\xb4\x0e\x0c.\x94&\xc1\x85\xd2\x9c#\xb2 \xb6\xfd\xb9P\xda8\xa1\xb4\xc6\x1d\xafS\xae\n\xe1\xb9P}\xad\xef\xfa\x86\xdc\x1a\xf8?\x88\xdad\xb0\"W]\xd7\x0f%|m\xb14\x17C\xab\x83M\x1f\x1d[8\xb7\xban\x061\x93l\x96\xac\x89\xfa\x1e\x86\xcd\\\x93F\xb5\x88&h.\xfa\xd8t\xf1\x86\\\xfd\xae\xdaT\x12\x12\xe5\x8b\x01`\xd9\xd7^\xf7\x99]\xeb\xd1\xefX\x0dk\x87\x1b7\xf0\xebb\xd4\xc5Q]\x1c\xb5\x13\x10\xcc\x0c8y\x07F\x99\x07=\xfasqT\x17Gm\x82\x8b\xa3\x96p]g\xcf/\x1aG\xddky\x07\xff,\xfey\xe2\x17\xaf\x15X\x07Z\xf59\xf5\xedo`\xb6\x01Vh\xca\xdd;\xee\x14\x0b\x93\xbb\xd5\xca\xc9\xd7~\xeaY\xa9b\xef\xa8wj\x162\xa0ge8h\xe3s\x12\x9f\xa2^\xbd\xf5a\xae\xef!\xcd\x10\x93\xc3\xb4\xd4\x17\xe4\xef6v\x10\xb1\xb8\x01\x8aL\x13\x85\xb3\x91\x11\x86@\x956\xfe6b?\xea\xc8\xdb\x88\x9d\x98cn#u\xa6\x8d\xb6i\xfa0D\xda\x06\x98\xe3\xbdO\x89_\xfb\x91\x1b\x11S\xeb\xec\xc1Rc\xb2J\xb0\x8f\xaf/\xf7\x0b\xa7Q_\xc5Y\xb4\xbf\xd51 \xf9\xc5\\\xbcTN\xcb/s\x9f^K\xdf:-\xfa\x05\xb5\xa8FA\xa1\xdd\x89\x96\\}\xf2b\x97\\\x9d\xcb\xb9\xa4/W\x17\xed\xd5\\]|\xc1M\xc1-\xe6q\xccl\xc1\xcc\xbb\xcd\xf1Rk\x00\x9d\xcas\xa9%u\xd0\x87\x8e\xb4\xf2\xc5\xd0C\x99si\xdd\xb2_\xdcbp\xe4\xc2R\xca\x0d\xd6\xddv\x99./$9\xf3\xf7\xba \x8dz\xdc\x15\xf7\xcd8nTV\x8b\x82K\x1a\xf3\xecZ\x8f\xdd\nKL\xe1F\x91\x10S\xa4\xee\xba|\x986\xb4w\xaa\xcb\x87\xa9\x83\xcb\x87\x91Paw\xf90[\xe0\x02J\xea\xcf\xf4F\xcdw\x9f\x0f\xa3\xb1\xcc\x0c\x16\x9d\xbdU6\xd0&\x93\xa0b\x0c\xdd\x1eq\x9e-:\xecB6\xf2\x88ge\x87\xb8t\x81FS'\xdd\x1b`\xdb\x9fK\x17p\xe9\x02M(\xe9\xe6\xd2\x05\xae\xcb4\xef\x9f.\xc0|~@+|\x12\xcd\xe4\x81\xfb\x07\x87jL\xbf\xd0\x0d\xacI\x92\\F\xb1\x0f,\x81\xcb8\xaa;\xab{9cP.\xe7\xfd?K\xd3\xa9w6B\x8e\xe1V\xc7\xd8\x1a\x1f4\x9d\xcf@B_y\x8b\xf9{v\xc4`F\x96?\x0e\xa2\xbb\x04\xae\xbeG\xdes\x94\xb9\xb9kz\x11\xe4\xe0\xe1\xfa\xea\xea\xe2V\xd1\xd5\x0d0\xd1\x9c\xad]\x03\x9b>:\xac\x91\xbe\xe1\xb9\xaf\xe8\x806D\xe6w\xbd\xe9y\xff\xe0\xbe\x1a\xdd\xab(\x0b}\x08\xa3\x96\x10\xdd\x89\xcc\xbf\x88R\xda;\xc6(j^h\"\x8c\xf2\xf7FU\x8f\x1b\x15k\xfc\xc2\x82}W\x82p\xb7\xe1H\xb1\xa8j)\xa8\xd8\xb3CBl\x91\x9c>\xb6\x99\xf5^\xadZ\xf6\xda_v\x01\xae\xdf#y\x05\xdb2\xa6u\xd1\xd9\xcc\x85\xb1\x8c\x9b\xcctm|\xab.\xb3\xe4\xb6\xdb\x1fa\xceh\xe0W\x15j64\x91\xb5f\xc2h\xbb\xd7\x98\xb2U\xa7\x9c\xa9\xd9\x11\xafi\x9a\xd8!\x9c\xc0\xc9\xbcv;\x90S\xbb\"\xee\x9a\x86>\x0b\x17\xd5]\xab\x1f\xd8\x84\xe6\xa5\xb0a/\xbf\xecp*\x8aZ\xef\xfd\x08,\x85\x98\xa6Y\x1c&@B\xa0\xabu\xba\x91\xdd\x97\xf8\xe40&\xf9\x7f\x7f\xaf\x12\xeeFH\x06\xc5\x15s\xe4\xd9SwAZy\xad|\x04\xdc\xddW\xc9G@\xac\xbf>>\xa8\x03kaW\xb5\xec%\xa7\xa4\x98*\xf7\xc3~\xe3\xca\xb9\x85l\x92\xe6\xcb\xa2\xdcie\xce\xcbV\x91a\x954B`\x98\x88\xbaX+r5m\x96\xd0\x87,\xe4\xf2\x86\xc4\xb4\xee\x1a\nI\x18%\xd4\x8bB?\xd9\x85\x10\xb9\x11\x1bs\xc5BW%\xa0\x016}t\xb9\x0d\xb6\x98\xab\xf7\x06\x7f\xfc\xf0\xfe\x81\xfd\x16\xff_Q\xba\xa4\xf1\x94\xab\x86\x7f\xe7\xa7\x9a0\xe2J\xbf^\xb6\x9b\xab\x14\x9a\xa4M\xed\x81\xb4l\x94\xbbr,\xf9!T8\x0b\x17\xc3\x05\x88\xb4E\xf4\xe2\x03\xdb\xe8f\xef{\xf5\x9eJ\x971M\x96Q\xd0\x9f \x0f&\x0f\x94jl\xa0\xfa\xbaw\xef\xbe\x02q\xb5 \xd35\x0dI\x90v\xb8\x8a\xd0\xdd\x1c\x1c\xde\xac-\xa4`\xb1\xb16\x90,S2|\xfbH<\x03\xd4\xef\x16\x02\xa9}\x1b\x8f\xd3|#\x8aW{$\xaef\xdb\x9b\x89o\xa2&P\xf1G_>\xde\xdb\xf7\x19'\xc4,\x13\x0b\xea\xd3\x80.D\x85\xd6\xfd?\xcb\x7f\x1f\xfb~\xfc\xaf\xfd\x98^\x92\xd8/\xce\x13\xdbg\xb1\xbb\xdbg\xa3\"\x97\xb7\x86\xe7V\xe7\xe8r?\xcf\xb1\xe7\x1d\x17\xb9\x0fsxQ\xb4+\xdb(Ne\x9d\xcb\xd9\xe1\xd9yt\xf9\xe4a\xea_\xac\xc8gr\xee_\x9e_\x1ee\x0f\x1e\x1d\x1d=\xa2~\x96\x05\xe4\xc8\xdb\x96\x1e\xeb\xed6\xd2\x9f\xddv`#\xdc\x13\x16>\x87]\x19|\xbb\xbd\xda\xae4J\x0c\"\xc9`\x84\x98\nx\x9b\xf1~\xc5^6\x1c\xcfn\x7f\xdf\xedL\xcbc>\x05o\xb771\x82\x89\x9d\x8f\xad\x00\xe7c\xeb\xea\x11?;\xe7c\x1b\xc9\x8as>\xb6-pGp\xf5g\xce\xc7\xe6|l\xa3\xaa\xba\xbe\xa2\xc6\xf9\xd8\x1ap-\x1b\xdc\xf9\xd8\x9c\x8f\xcd\xf9\xd8\xe0\x1a\xad\xb3\xe1'OY\x0b\xb1<\xc9}\xf1\xeb\xccX\xb7\xdbe~J+R\xce\xbeb\x7f\xdbN\xb33\x8b\xec\xc9\x82^$h\xf9\x1cL\xd9\x98\xb5d\xcb=\x0d\xb6 \x9c-Y\xc2\xf9\x807*\x98\xabf6].\x99\xb7\x14?f \x8d\xe1\x92\x05\x01\xc4\xd4\xa3\xec\x82\xd6\x06\n\xf3,\xb4\xc9\xca\xb1p\x03\xec\xca\x06\xeb\xd8\xa8\xb6I\x8cm\x96\xb0,\xb8\xd3s\xeb\x0f\xdc\xabvN\xa7wt\x1d\x10\x8f\xf6\xe0\xc9zK$3\xe6\x06}H/!\n\xe9\x04\xcfN\xce\x01U\x80s@u\xf5\x88\x9f\x9ds@\x8dd\xe28\x07\xd4\x16\xb8\xf3\xa9\xfa3\xe7\x80\xd2\x96\x10l\x9b\xcd*\xad\xa0\xa0\xb3\xada\x03C\x8d\x9b]\x19m\xceq\xe6\x1cg7G09\xc7\x99s\x9c9\xc7\x19\\\xa3U9\xc0q\x16\xc5\xa5\x16\xbdy\x89je\xd2\xc5\x08 i\xdfO\n\xd7\xef\xc5`\xa1N\xccz]\xc3[\x1d\x93\x97\xb9\\\xc2-\xa1h%\xae1\x0f\xc8\x87\xb1\xf01\xdc\x08C)\xca\xf9\xe0\xcbY\x97=\xf8\xa4\x82\x84\x06\xf3\xe9,\n\xfd\xe9\x8d\xba^\xfd\xf5\xde9\x95pA\x82\xa9\x17\xadV,I\x98\xba\x88\xa2\xa3i\x1b\xbai\x8aSW\xa5\xb0\x19\xc9\xd9\x8bV3\xfbQ\x96&)\x11\x95\x15\xa7\xbd+g|?\xaa\xe7\x15m\xa9\x8f\x1a\xfdJ\x0f\xf7\xd7\xafF\\n\xf0\xeew\x9e\xdbm\xc6\xdd\xf6\xbcTC\xa225W\xf8w\xb7\x8b\x02h\xf7\x9b\xc2\x04\xf4\xd0\x98K\x84\x16q)\xb7\x83M;\xedzv\xf0\x17\xd1\xbdv\x81\xd62z\xc8\xb9\xb2\x1c\xca^\x82*\x9a\xd1n\xd3fc\xce\xda\x15\xa7\xb7q\"\x18\xd9\x05X\x0bp\x01\xd6\xae\x1e\xf1\xb3s\x01\xd6\x91\\a.\xc0\xba\x05.\x8e\xa1\xfe\xcc\x05X]\x86\xff\xa8\xaa\xae\xaf\xa8q\x81\xca\x06\\\xcb\x06w\x81J\x17\xa8t\x81J\xb8F\xebl\xcc\xd3\xe7\xb5\x07'\x9b\xae+~p\xccB\x96n\xa6\xeb(\xca\xebyZ\xfanDs\xe0\xcd\xb7\x0bA#N\x9f\x16G\xca]\xe9s\xe7F\x19\x87\x99\xdaG~\x0bF\xdar\xb9\x7fu\xacdpF\xac\xc5k;4\x9e\xaa\n\x18kVm\x16\x85Y2\x08C\xb5\xcdSr\x85l\xd9\x93#\xb8\x02b\xe1b\x083\xbc\x91(`\x15\xf9Y@\xcd\xac\xc0\xbf\xbf\xd9,\xc0\x892U\x08\x02\xcd\xb2\xb1p\x1e\x88qO\xc5\xd9\xc6[\x92p\xa1\xb4\xda\x0c\x18V\xe8\x85\xdfji\xf9\xb4\xd6\"\"\x81\x08\xd9S;&\x9d\x05\x91w\x9eL\xd74\x9en(\xc1>\"8\x90M\xcbiZs\xe9\xf3\xfcM\xbb\x1cSE0iX\xddp^\xdd\x05-I\x18f$\xb8\xbb\x8e\xa3\x0b&|\xd1\x83i*1B\x85\xf1\xbb\xa3\xadt\x18\xef\x93,]\xee_\x1c\xcehJ\x0e\xf7scy\x9b\xbc%\x1d\x8f\xf3/\xaa\xe7\x11\xf3\xca\xdb\xf4\x8a%\x92\xb2\xf9\x17yK\x99%\xc4\xa2\xf0\xc4\xafZ\xf7%\xd01$\x99\xe7\xd1$\x99gA\xd9z\x82\"\x9a\x95k\xa5I\x87:\xe8|\x0d\xbbJ_\xe1\xcd\xa7Y\xdcQ\x14\xbf\xfa\xddp\x9e\xc29\xd1\x00\x8e\xe1\xc3\xbb_\xf7c\x9aDY\xec\x15\xbe\xfe%I!\x0b\xd9\xa7\x8c\x06\x1b`>\x0dS6gT\xde\xfd\xe4}C4W\"\x14O|\xd0\x98\x91\x80}\xa6\xfe-\xe5w\xeb8J#/\n`\x96\xcd\xe74\x86\x15M\x12\xb2\xa0\xf9ES97XeI\n^\x14\xa6\x84\x85@T\xee\x1a\x80\x80\x92$U\xf7\x15\x85\x14n\xef\xdf\x06oIb\xe2\xa54\x96o\x07\x05$I!\xa1\x8b\x15\x97\x13\x91|I\xf4\xc3\xbb_\xf7\x92\xf6K\x98M\x10\x83\x8a\xb9\xf8Ih\xa8\xe9\x95\xa3\x9bgA\xb0\x81O\x19 8\x05}I\xdf\xbc+A\xc9\x1f\x88\xb8F\xabD\xf2\x91\x0fe\x7f\x11E\x8b\x80N\x04\xcdf\xd9|\xf2\"\x93[\xec\xe3\x8fr&\x02m\xb2\x8c\xb2\xc0\x87\x19U;;\x01\x08x$\x8cB\xe6\x91\x00\xe6Q\xbcR\xf7\xfc\x03\x9d,&w8iE\xb2\xca\xed\xc9\xed\xf2\xd5\x1f\xcf\xa3\xeb\x94\xfa?Nn\xa9\x9b\x9f\x84\xb0\xe6\xc4f\x1e\xbd\x03)%\xab\x04\xb2$\x93\x8fU\xc5\xd4\x8bVk\x16\xf0\x91\xa6\x91 \xc6\x8c\x85$V\xbd\xb4\x01R\xe8l\xd6\x82\x07\xe5C\xb0\x1bu\xd7\xf4jM\xbd\x14X\ni\x04Y\xc2{\xc9\x83\xf8aJ\xaf\xc4R\x1f\x87\x9b \xfc\x1c]\xd2\x0b\x1a\xdf\xe1\x84P\"\xfb\xf0\xee\xd7$\xbf\xdd\xccQ\xa5K\xaa\xeeX\x08#\n\x1f\x97i\xba\xfexG\xfeo\xf2\xf1\x0eD1\x84Q\xfe\xeb\x1d\xc1\x8d\x1e \xf3W\x87\x1bo\xccn!\xa4)dk b\xee\x9a~\xa5\xa4\x17\xa4Y\x91u\"YK\x8c<\x8d\x8a\x9d\x05>\x9d\xb3\x90\xa5B\xf7\x11\xd53+\x00\xf3(\x08\xa2\xcb\xe4\xa9fm\xff\x0dN\xe6\xd5\x8c8[\x08\xb5\xeaS\xbf\x9c4\xff#I\x92lE\xfd\x89\x0e\xd1q\x08?\x9f\x9d\x9d\xc2\xeb\x97g\x10\x85\xc5\x16\x94{l\xc3h\xe0\x03Q\xb6\xfe\xaf\xf6\xb68\xdb\xac\xe9?\xff\xeb\x9f\xca\x06\xb9\xa3\x8a\xf3\x83\xe47\x90\xb9\xbcb\x85r=/\x9e\xff\xe5*s\xa2\x1bu\xa5\xff\xe5sc\x84\xd3\x8c\xfa\x9c\xdc\x1e\xf1\xb8l\x89\xa2\xf3l\x9d?\x1a\x9c\x88\x83\x9b\xaf\x91O\x82\xafT?\x0b&\x14c\\\x12y\x9d~U\xdbC\xbe\xdcD\xa4\x98\x12\xff\xf7E\xc4| \xa1\x9a\xb1 \x1f\xa0\x10\x1f1\x9dG1\xbdS \xe0xI\xcaf,`\xe9\x06BJ}\xc1F3\nB\xe4\xc5\x17\x9a\x99\x88\xb9\xc8\xc3\x85h$\xf6\xec\x04~\xf8\x90P\xb8\xa017\xbc8\x958{r\x99%\xf9\x93\x84d\xa1\x9b\xfd,\xa6\xe4\x9c\xcb\xa0\x1c\xf1\xe4G5G\xfd\x16\xa5\xf4)\xa4\\\x87\xcc\xf3\xb0\x0e\x11\xf3\xc8eW\xfe|t\xb0\x01rAX@f\x81V\\r~\x8c\xe6s\xe61\x12\x18t\xd9,\x9bCL\xb9&\xa2wD&\x05K\x8bNE\x04j\x1e\xc5\xd5\xbeT\xa2\x9a\xd1\x05\x0bC>\xd9K\x96.5\xcae\xb3\xa6\x13\xc9\xffd\xcd\x92\x89\x17\xadt\xd2\xf8\xbd\xd8\xa9 \x887\xdc\xb8\xa0\x08\xdbR\n~\xe0\xe3\xe3v\x9dx\xfbZn\xed\xf6\xfd\xc2\nVl\xb1La\xa6\x11Jb\xd2\"\xa2\xc6V\xeb\x80r%+\xcf4\xc9\x9azl\xce\x93\xb2\xa2\x8c\xff\xf2\xc1\xa7\xcbHf\xf5\xa9\xc43\x1f\x8f\\\xc2\xee\xfe^J\x0f)\x1c>\x85S>~.\x17\xf2\xa9\x90\x92\xe8,\x84\xe7\x7f\xf9\x8bFM\xbe\x8a\"\x98G\x11\xfc\x04\x93\xc9\xe4\x7f*?\xe3\x83!\xe1F\xfd\x01 7\x13>\x8cWq\xb4\xfaa\x1eE?\xaa?\x9dL\xd4\xfa\x8f\xcd\xe1\x07\x8e\xea\x83\x98\xc8Y\xf4\xc3\xff\xe0\xb8~\x84?52\\\x87\xef_z\xda\x1d\x19h\xf7WrAF#\x1e\xfc$lC\xde\xcb\x08\x14b\xc9\x0f\xaf\xa2h\xe2\x05$I\x0c\x04\x92C\xe4\x8d\xe4\x1ck\x0d\xd5cPP\xae$\xdd=\x03\xe9N7\xe92\n5\xc4\x93\xa3z\x15E?L&\x13\xb56( \xf7\x83\xf6\x1b\xc1|\x82\xac}\xa9\xca\x91\x9cH\xa2\xbex\xf9\xfe\xf9\xbb\x93\xd3\xb3\xb7\xef~T) \xc8\xbb\x95\x8c\xaa\xefXv\xad'\xe7}\x039_GjJ\nR>\xfd \xfe\xc7z6y\x15E\x7fN&\x93\x7f\xa9?&\xe1\xe6\x0e7Cy\x8b\xb54\xa2\xde\x908Y\x92\x80\x13Y?\x11\x1d \xdb\xa3\xd0\x0c\x81\xcd[\x03\xf8\x10\xae\xaa!\x88\x01\x8a\x0d\"\xbe\xfa\xbf~\x82\x90\x05Z\x06\xd7\x8fK\xc1\xc9\xfcp+\xe8\\\xc8\xe2\xe2\xa0\x01\xb3Mev\x15\xdaCT\x9d\x9au[\xbd>\x9d\x93,\x10\xb6XwW{\x1d&\xd5>?\xbfO\xc4\x0f\xdc\\\xdd\x03R\xd3v\\\x13rNP\xe9\x06\xc9!\xdd\x9d\x95\xaa%\x0c6\xc5\xb9r\xcbYP\x9a\xc9@\xe6\xa90\xdb\xba;\x12~\x8c\xbd\xfd\xbd\xee\xaer\x9dX\x0cY\x9cv\x8b\xc8\x1d\xdc\x9eG\xd1dFb1\xd9\xab\xfd\xcd\xe4\xf3mIEq\xf6\xea\xc4\xa7>\x8a\x8a\xa1\xde\xe68\xb8:\xec\xfc\xe4\xaf\xef\xdf\xfe\xd6\xfd\xcbO?\xfd\xf4\x93\x9a\x07x\xbb\xca\xe7R\xdd\xbe\x0cs#H\x9e\xeb\xb2$\xb7Fb\xba\xc8\x02\x12w\xe3\xdbF#kOUf\xcb\x1d\xa0\xab\x19\xf5\xfd\xca\x80\xb9#\xcd\xf1.tD\xe1\xbd\xa9\x99\x14sq\x90\xfd\xf8\xbf9\xe9>\xe6\xce\x84\xd2l\xab/N\xf7\x06\xc9\xc5\xcfS\xcd\x01\x84x\xe7\\\x06U\x07\xe29\x0b\xa8Zo\x142\xeb\x94\xc6I\x14j\xb7m\xee\x89\x9b\xb38I\xa7b\x85\x7f\x82C5\xe6\xb2\x01g\xca\xe2\xfb#{\x0d\x06\xa0\x1d\xd5mA\xcb\xdbO\xe1v\xd7\xaem\x92a\"gy\xfb\x8e\x0e\x9f\x98\xdfod\xc5q\xfe/9\x85\x7f\xd76\xe0\xf3k}o;\xc9\x93y~\xe0j\xf2\x9a\xe4\x06\x96\xc0%\x0d\x82\xbb\xe7at)3\xf3\x97$\x01\x02^\x96\xa4\xd1\xcars5Y\xfe\x8e4\xe0[\xfb@\n\xcf\xdap8\x03+\x0eWD\xb2twg\x1f\xc5f,\xf8|\x19\x05\xbedr9r\xb9\x95YX\xee\x0f\x90\x1e\xc0nTr\xcbt\xf7#\x860)\x95\xf3\x0f\\\xae\x15$\xdcr\x0d\x15\x1e\xd3\x7f\xfe\xd7?\x7f\xd4l\xa41x\xae\xd9\xa1\x9e\xed\x04\xa98\xca\xc3\xc9\xd1\xe1Q\xd2\x95\xd2.a[Q\xa7,\x0d\xe8\xd32r!\xdcP\xba\xb8L\x01k\xb2`a-NY\x87\xc6\xa9\xb3\xfaP\xba\x0es\xd9Z\xfbs\xaeZ\xba\xe22\x12\xb4q\x10}\x14$\xa4W\xa9)aNs\xfc7\x1e\xfes\xf2\xfd\xb7\xea\xd0_\xf4_\xd4\xbc\xe4\xff\xcc\xbd`$I\xa4\xab\xef\x94,\xe8;y\xc9d\"\x7fW \xfbT^$\xe3h9 )\xac\xa2$\x05*|K\xc2!\xd5\xd1T\xf122\xd8\x10 ca\xfa\xf0\xbe\x8e\x04J\xbf\x87|\xfa\x9d\xcf_\xfcC&\xd4q}Yx5k.4U@\xa8N\"\x99\x97'\x90\xa9v\xe0%I \xa1\xe9\x1d`iR8k\x13\xc8B\xc9\x80\xbe\xf4_]\xb2V\xe6\xb8\xdeY\"n\xf1\x15\x81\xc8w9\xaf\x16\xcbZ\xf0\xae\x14\xba\xf3\xdc\x07&\x9a\xec\x1fwo\xa0w\xa7\xcfs\xfb\xadb\xf8\xdc\xbaT\xc71C\xc8B\x19\x97\xa0\xbe\xf4/\x97]\xd7\xda\x8c\x14\xcd\x14\xf8U\xa1LEV\x8f\xaf\xcc\x06aaJ\x17\x1d~\xa3\x82\xc3X\x98\xde;j\xfd\x9a\xcba\xab1\xf84%,p!X\x17\x82u!X .\x04+\xc0\x85`\xb7\xc1\x85`]\x08V\x05.\x04\xebB\xb0\x02\\\x08\xd6\x85`]\x08\xd6\x85`%\xb8\x10\xac\x0b\xc1\xba\x10\xac\x0b\xc1\xaa\xc0\x85`]\x08\xd6\x85`]\x08\xb6\x06c\x84\xc3\\\x08V\x80\x0b\xc1~+!\xd8\xeert\xb2\xf6\\\x15\x1c\x9d\x9c\xd3\xba\x16l\x1c&[A\xc7<\xcaHr\x11*/\xda \xa7R\x1e>\xcb\xc3\xabeHR\xb8\x82\x16-\x9f\x89\x881\xf2m\xaf\x0f3N\xe0-WxQ(\xce\x8a\xd1|\x9e\xd0\x94\x1f\xbf\x9a\xc3\x85\x9a+;\xa1i](\xb2\xf0\xa9\xec\xab\xf6\xb7\xaa&h\xbb\xac\x93\xc2I\xd0\xe9\x18\xe8 \xa2\x1c\x9f\x8a\x8e\xadCy>\x19A\xca0[\xd1\x98y\xc5\xdf\xc4n\xf3HX\xd6\x83\xba\\\xd2\xb0 |\x16\x96\x8e\xa8\x96\xf9y\"\xb0\x054I*\x12J\xd7M\x96pR\x9fSKz6\xd1\xef\x98\xb8\xad\xd0o\x07y\x03\xb6bX\xea\x8ao\x8b\xb0\xa9*\",\x9d\x94u\x0e\xce\x83\xacY\xd0\n^J\x97D\xfdO's\x08\xe8<\xcd\xbd_,\x95\xe2\xb00\x1a\x85\x7fUn\x10\xd9 \xa7\xf3l\x03\x94xK \xeb\xf5\x17\xa4b=\xae]\xb5\xd7\xd1\xb2\xd6\x82STph$\xae1\x03\xff\x07\x0b}\xe6\x91\x94\x96\x91\x96\x9c\x82\xe2\xc3\x9c\x91\xea\xe8X\xe8\x05\x99\xdf2 \x89\xec\xa5\x0cu\xb5VL\x04Nk\x1eX.\xba\x1b\xa9\x1d\x0dd\x1fN\x92\xd6j\xb5\xa6 \xac\xe8\x98&y\x84[l\xafj?\xf2-7\xc9w\x13[\x84Q\xdc\xf2_\x17\xbb\xb1\xd9\x85\xa4\xcc\xd0\x85\xdd\xaeFW\n\x9f\xd6/\x1dK\x1b\xd3\x0b\x1a7\x90\xea\x965\xff\xba\xbd\xa4\xac\x961\x11\xd3\xee=\xd2\xc0\xc3\xfb\xa0\xb2Fx\x14\xfb4\xbe.\x12\xb4o\xc1\xff-\xefgO{w|\xff\xcf\xbc\x14Q\xf1\x08\x89\xe6\x1ayu\x8b<\xff\xef<\xe8/\xa33\x10\x85\xe5\x83\xb39\x82\xae\xdb\xe4\xb7\x8aY\xdf\xec\xcb\xe4\xaaD\x86^\xe9P\xa96\x1f\xc1\xe8\x8a\xc7\xf8\xb2G\xcfD\xc0\xe5!\xf4\xc9B\xd0g\x1b\xf4\xca5\x10](\x10\x1a3\x0dF\xc83\xe8\x99e\xa0\x8c\xcd\xe2r\x0c\x06e\x18\xf4\xca/\x00\x12\xb4\x1ff) \xc5e\x17\xf4\xc9-\xd0E\xfcP\x99\x05#\xe7\x15\xa0\xb2\nF\xcc)0f\x14\x8c\x94O0$\x9b\xc0:\x97`\x84L\x82\x91\xf3\x08\x0cY\x04\xa3\xe7\x10\xec&\x83`\xf4\xfc\x01|\xf6@\xbf\xdc\x01\x0d\xd1M\x99\x03\xa3\xe5\x0d\xe0\xb2\x06:\xdc\x16j\xf9:r\xc6\x80)_``\xb6\x80&W\xc0h\x9e\x18\xf3\x04p\xf6\xcb\xb89\x02\xa6\x0c\x01\xf3\x98\xfae\x07\x14\x92\xbd\x03\xa1)7`\xc4\xcc\x80\x01y\x01\xdd\xd9<\xba\xac\x80qs\x02\xf4\x19\x01c\xe4\x03\xa0\x02\xda\x86\\\x00t&\x80:hg\x9f\x05\xa0\xc6\xd5\xe9 \x1f%\xfeoC,l\xec\xdfL\x13t\xdc\xbfG\xd4\xbf;\x980R\xc4\x1f\x15\xef7G\xfb1\xb1~-\x15m\xe3\xfc\xd8(\xbf*\xc6?B\x84\xdf\"\xbe\xdf?\xba\xaf\x89\xa1c#\xfb#\xc7\xf55#\xea\xe4\xd4^\x11\xfd\xc2\x11\xdb\x81O\x11\xcf\x1f9\x9a\xaf\x8e\xe5\xf7\x8d\xe4\x0b\x8f@\xd7\xc0\xbb\xe3\xf8\xe3F\xf1U\x07?c\x04_\x15bTE\xef\xc7\x8d\xdd\xf7\x8f\xdc+\xa2\xf4\xbdb\xf4\xc6x\xbc]4\x1e\x1d\x8b\xb7\x8c\xc4\xdb\xc4\xe1\x95Qx\xf5h\xb0\xd1P\\\x04\xde2\xfen\x11}\xef\x9c\xda\xb8\x91w\xd5\xa6\x18\x10u\xef\xf4S(c\xee\xfd\"\xee\xba\xe8\xfa\xf8\xb1\xf5\xe1\x9c\x84\x8e\xabc\xa3\xeaM\x15\x89\xbf\xc7\xd9\xe3\x1ag\x0b\x9b\xbb\xc5)\xc1\xdd\xe2t\xb78+p\xb78\xdd-\xce\n\xfaDZ\x94\xc8\xdc-\xcem\x18)\xea2,\xee\xd2#\xf22J\xece\xf4\xe8\x8b1\xfe\xb2\x83\x08\xcc\xaeb0;\x88\xc2\xd8\xc4a\xfaFb\xb42\xdc\x14\x8b\x191\x1a\x83\x8d\xc7XFdF\x8f\xc9\x98\xa32\x83\xe32\xee\x16\xa7qd\xfd\xe24\x9d\xa8\xdc-\xce>\x11\x1bS\xccf\x9c\xa8\x0d2\x14a\x8c\xdcX\xc4n\x8c\xb7\xe9,\xe37\xee\x16\xa7\xbb\xc5\x89\x89\xec\x18\xa9j\x1b\xdd\xc1\xc7w\xdc-\xce\x16\x8c\x1c\xedq\xb78\xeb\xd07\xf6\xd3\x89\xcc\xdd\xe2\xb4\x88\x04\x0d\x89\x05u\xa2s\xb78;\x1b\xa0\xa2G\xee\x16\xe7x\xb1$w\x8bsp\xa4i\x1c\x9eCG\x9b\xf0\xf1&\xdc-\xce\xf6\xd3\xda\xadSd\xfes\xa3*n\xf1\xb74\xca\x8b\xbd\xce\xa3\xadk;-gxuk\xa7\xf6~%t\x1f\xc9U7s:/\xe6\x88\xa9i\x9et<\x15\xbf\x8bq2*\x1ft\xac\xa8\xd1}\xf1&K\x97\xb2\xd5\xadb\xec7\xf4\xeeM}\xeeuhU6\x16\x04hV5.\x08P\xe81\xf9d\xf0\xb6\"Q\x0e\n\x8c\x01\xa9\x15\xb9\x9a\xae\xe8*\x9a\x96\xf1\x13M\xdc\n\x950\xab\xac\xee\x9b^M\x13\xb6\x98\x8aK\x9b;\xed\xe33\x9dzQ\x92\x8a\xb7vg\x9bth\x06\xb0\xb23>\x9b\x0b\x1a\xb3\xf9F\xf6G\xfd\xa3\x07\x0f\x0e\x9f\\Ww \xf5\xd6G\x0f\x1e\x9e\x1f\x8e\xdf!\"\xea-\xf7\x9eM\xd0;\xdf\xe3\xefN\x9f\xb7\xf0\xb9\x98\xb7\x8by\x9b\x1c\xbe\x18\x9f)\xb8\x98\xb7\x8by+\xbft1o\x01.\xe6\xbd\x0d.\xe6\xedb\xde*p1o\x17\xf3\x16\xe0b\xde.\xe6\xedb\xde.\xe6-\xc1\xc5\xbc]\xcc\xdb\xc5\xbc]\xcc[\x05.\xe6\xedb\xde.\xe6\xedb\xde5\x18#\xfe\xe8b\xde\x02\\\xcc\xfb[\x89y\x1b\xeb;\xceHx^\x86\x91g$ \xa1G\x91\xf5\x1d\x83\xe0Y\xfe}\x19X\x16\xaeY\xf9G!o\x83\x00\xbc\x88K-Nl\x02 \x0b\x17\x01-\xaa%v\xc7\x9d+\xac\xf9\xcf76\xf0\\P\xebf\x04\x81|\x1aF\xab\xde\xee\x0f\xb2\xea\xae_)\xc1\xd0\x1c\xe3|x\x1e\xb1\xeaQa\x02itN\xc3\xdcq \x87^\x94\xa1\xe5\xa2\x8b\x84\xf9\x80T\xe7\xe4\xdf\xde\x9e\xbd|*4\xbd\xfc.W\x99Lx5N\xc24\x17&\xa5'\xa9.Q:\x11J\x03\xab\xbb\xb3\x84-B\x92f1M\xca\x04\x0enN.\xa2E$\xb6\xef\xb6\x16n\x10\xa4`\x93\"\x86[\xfew\xbeAd\xa8\x81\x85[n-\xf7l\xb3\x00\xf7l\xf3\xf7\xf5ls\xa5\x00P\xd9\x0f]8\xf6\xeb\xba\xe9\xdd\xe9\xf3\xf6$\\F\x84\xcb\x88\xd0o\xca\x1d\x04\x13FH?d\x8a\xcc\xc3R\xa5\x8c\x9b\x82\xe8\x1e\xb9\xe8\xfb\x82\x80{\xe4b\x87\xc45?\xcf\xe0\x1e\xb9\x18\x83\x8a\xee\x91\x0b\xf7\xc8\x85\x80o\xfe\x91\x0b\x83\x13d\xffOqB\xd59CrkS\xe9\x08)\\\x1f\xfc\xa0\x87w\x86\xe4Xo\x15\xe4\xb8\xd9\x8e\x10\x95\xe9\xd7\xebT\xa9qg\x18\xcc/\x9d+C\xdb\xd4\xec\xc6\x18\xd3\x891\xb2\x0bC\xed\xc0\xb0s_ Nh9W\xa2Ng\xf9y\xac\xc9\xc8\x05\xb8\x82l\x12\xdcQ\xcc\x1d\xc5\x8c\x96[1>!gT\xa3\x13?\x16c\xf3\xa4\xb4\xe2\x7f\xd9\xf5\xf0\xec4\xac\x18\xd34\xba\x0ci\x9c tkM\n\xbd\xe0\xdf\xbe\x15\x0dKU+\xb4i\x10\x94\xefK\xe5KR\xe4~\x8bp\x18_\xf1\x94y\"\xc8[N\x83K\xefJ`\xd6\xe5w\xa72\xae\xf5\x9d\xff|c\x15r\x9d\xc07C\n\xe4\x8b2`\x1b\x9b\xb5\xb3\x04\xedU\xcd\x9c!\x92n\x8ehC\x17K4Ai\xf9H0\x10\x0d\x10\x84\x03Sh\x07p\xe43\x85x\x00\x87\x06\xbb\ncZJ\x12z\xd9KJlypY\x17\xf6\x01k\xdbI\x02\x86D\x95,)\x89\x94\xa4q\xe6\xf1\xae\xaa@\xbb(I\x1c\x96\x82\x8dso'6\xc1\xd1Q\x9c\xc7\xce\x15\x89\xb8\x15\xbfW\x0b \x82#\xe74\x14g\xd8F\x86 \xe9\xac\xa0+\xa1\xd8Mb\xe9\xf2\xeft\xbb\xa3J\x99iw\xdbj\xe5\x02^\x02\\\xc0\xeb\xbb\nx\xd5\xec\x8a\xf2HU\xe7j~J*\xcfV\xc2\x97\xb0m\x89\x14\xc0\xbf\x15+\xea\x0eT\xee@uC\x0eT\xda\x03KkK\xc8\xd3J\x9d\xfb\xabCL!\xda\xcb\xb3L\xdd\xe8\xe7\xaa\xaf\xbd\x1d\xc6=\xe2\xb8`X\xdfH\x83\x0b\x86\xed\x90\xb8\xe60\x8e\x0b\x86\x8dAE\x17\x0cs\xc10\x01\xdfj0L\xed\xa9K\xa6+\x9a\x12\x9f\xa4D\xed\xa3\xfb\xef\x96\x8f.y\x937iD\xc4\xbc@\x08\xd7\x02]\xe9\xba\x8b\xe9\x82%)\xe5\xa7k\xae\xefKTu\xbd\xdf]\xa6\xaa\xd9Y\xfe\xc5\x8d\xf5\xcb\x15\x13\xbf!\x96d\x9d\x06\x9d\x1f \xccA\xe9j\xccB\x96\x1a\x9c{\xddS\x93\xa0\x9c\xa0\x04\x84\x1b\xcd\xde\x02\xcc\xa4\xaci\x96\xb6\xd8,HZ\xdfg\xc2\x96P\"\x93\xfb\xb2a\\\xd4\x81\xef\x99\xde*\x10/\xe3x7\xed\xb9\x88\xbf\xc9\xed\xfaCu\x1e\xe7\xbf\x94\xb3S\xe2\x13;\xbe\xb6\xe7\x0e\x14\x1b\xcbg\xc9: \n\x87\xb5\xfd\x0c5<\x96\xf7T\x9enr5\x97-\x164\xe1g\x86\\\xb8rN+'kB&\xedgi;*j\xbf\x08\x9b\xbe\xff\xecrf\xdc\x13z\xb8\xee}j\xd4_\x131\xac\x1f\xe8\xe2)<\x17\xa62\x1csQ\xb6\xd7\x893\xd9\xacfQ\x7f\x17\x1d\x9e\xa5dG\xd5\x91\x9d\x8f1\xff[Q?-YF\x97!D!\xd0\xab\xbc\"\x92\x12\x9b\x98\xdd\xf1\xd9\xdb7?\xe6\x85\xf5<\xd5ue\x90\xae\x0d\xb1\xba\xe2\xca\xb9\x1c@\xbed\xdd\xab\x94\xc5\xec\x1a(\xf2\xe1\xdd\x89t$\xf8\x91\x97\x89Z}?D\\\x93\xf3\xa3\xea]oIX\xf8c\xee*\xca\x03^JL\xb5+\xd9,\x94\x16\x0f?/\xc2\xdb\xb5\xfc\xabr\x96\xd3%I\x96\xd73\xd5\x9fI\xb2\x94z&Y\x92\xa3\x07\x0f\x81w-\xc3\x04\xe5\xfc\xd7\x117\xe9D\xe4\xf2\xc3\xbb\x13\xb5\xee=\xe1r4\xcb#H\xb2\x14\xaa\x0c:*[\x88%/\xba\xf1\x99\x1f\xee\xa5y\xd5-=\x950\xe2\xa4j(S\x19\\\x93\xad\xa1\xfe\xe6B\xa7*\xada\xc9\x7f\xbe\xb1\xba\xb4N\x90:| \xee\xd2\xaa7#s\xb8\xc7\x15\xc6|\\!w\x0d\xe5\x1c\xcf\n?V\xc1\xff\x85\xbd\xdc\xd6\xbf.\xcbR\x80\xcb\xb24\xba\xb2\xbf\x9a,K\xd5D\x84\x9e\xa9I\xfa\xfeN\x95\xba\xd2Q\xbaT\xca?:\xa3\xaa\xf9\x9b3\xaav`T\xb9\xc4J\xeb\xcc\x1e\x97X\xe9\x12+]be\x05.\xb1\xd2%V~\xf5\x89\x95\xf2\xc4\x83\xc8\xa7\x94\xe6\xdb\xdby\xc3kP\xf3\x17\xd4\x9f&\xe8\xf4\x19\x14\x08n\x15\xd3\xbd\xa1\x0e\x03\xd51{\xc0iLs\xee7X/\xee\x15\x82&\xd8\x9d\xf3\x11\x0e\xe2\x82+Q\x87\x9b\xfc8\xd3\xe2\xe4\x02\xdc;\x04\x12\xdcY\xe6\x06\x9de\x86E\x87\xaf\xb9\xce\x7f\xa5\xa1\x12\xba\x9f\xd2\xd0\xa7\xf1\x8a\x85i\xf5\xa6N\x10y\xe7\xc9~@R\x9a\xa4jU\xf5\x9a\xa6\xbf\x8aO\x9e\xf1\xefs%\x9d'\x11\x8a\xbf\x83@\xd4\xa9\xa5\x9amo\x15s\xbb\xa1\xbaJ\xccc\xca:\xa2u\x03\xb4\xd5\x80\xdc'\x83\xdfpM\xe2t\x9a\xd0t\xba\xa4\xc4\xa7\x1d\x92\x08L#\x07\xe3\xe89h<\x7f`\x14_\x05`r\xd8u\x05\x1a\x10\xe4\x023\xc9J\xf7\xdc)\x89\xd3\x84\xa6?\x0b\xcam/\xb7\xfcH0\xed\xc9\x8b..\x19\x97Ev\xbb~\xdc\x00\xef\xf4\xb0\x17\x90OW\xe6\x8b\x89\xe9\x89\xf4>\xc3J\x8cR\xfaMA\xcc:\xa0\xd6\x1dp^f d\xbd\xbe\xde.\xcd\xe6c\x01\xcf\xb9h\x0b\x93,\x01\x8f\xac\xa5e&\xb5I\xf1\xe78\x0b\xf2l\xf7u\x1cq\x99\xa8\x1f\")\xd7S\x06\xff\xf9\x7f\x88\x84\xcf;\xba\xdb\x06\xf2\xf0,\xd3\xeb\x83Z#\x10yM\xe5\xa3\x08\xf2\xb5\x01a\xdf\xf1Qi\x10\xe6\x07n\xb2^\x07\xfc\x14\xcf\xa2pO\x93^\x01\"Y\x83B\x1a\x930\x11 \xa7\xb0\"\xde\x92\x85\x1dQ\x1d bt\x9d\x92\xbb\x00\xc4\x92.)[,5\x17v\x10(pr.e\xea\xc2H\x96\xdd\xf8$\xa5w9>\xc5\x97\x01I\xd2\xa9Z\xaf\x150\xe2\x8e\xd6\x0bq\xc0N\x100\xc2\\\x02J\x0f\x16\x80\x9a)\xa0g\x0bf\xfdX~\x86\xd2\x93\x05`\xf8\xa8\x003\xc9\xc1\x86\xec\x80'=R\x9f\xb6>\xee\xd6\xab\x05\x08\x96\xf5\xa2\xd5\x8a\xa5\xda\x92M\xc8\x19\xa1f\x92\x0f\x8cwGE\xfe\xa3\x94\x9a\xb5\x0b\xa9m\xe0?]\xd3\xf0.H\xc0|\x92FqrM\x1d\xb6\xe91\x8f\xc5%\x14!\xbf!\xca\xd2u\x96V\x7f[\xc7\xf4B\x92K\x81M\x84h\xae}\x0e\xa5\xc6\xbc\xa6\xfe\xc8z}M=\x89\xfd\x91;O\xaf\xa9Kz\xc1|\x1az\xf4\x9a\xba+\xf9\xaf2{4\xf6(\x17\xd4QB\xe3\xa9\xe19\xb3\xb1\xc6\xd70\xe6\xa4\xc0k\xe4\xa4ToF G\xeeYy\xf0\xce\x85\x8a\xd4R\x9d\x99\xa3\x9d\xf7\xca\x01\xa3\xb5\xcc\xda*\xbd2RF\x7f\xef\xd3x\xeb\x13E^\x04\x81\xc1\xcab>\xbbJdLH\x84\xc6f\xb9\x91)\x1d\x99\xd2\x8c\xfc\xdf\xb9\x83\xe2ga\xdf\xfd\xe5p\xa2\xb3<\xa5\xef5\x8cRY<\xee*\x81%\x8d\xa9\x08R\x08\x196\x01\xf8;\xdd\x8b)\xfc\x91%)\x90EL\xa9~\xba\x91\xb4\xbc\xe5%\xe79\x8b\x93T\xdb\xbf\xb8X\xb6\xa2$\xccg%\x87~\xbc^\x8b\xfbM~D\x131\xb8<\xbc\xc5Q':\x05\x9d^)\x8as\x9a\xf2m^pK\xbf\xf1\xfa\x98\x08\xe2\xce\xa5QN<\xbe2I1\x8c\xce\x88M\x05*\xedP\x88\x95\x9d\xf1\xbc\xbe\x03\x18\x97\xf1\x8d6\xa5y\xbc\x12\xfcL\x9e\x92\xe8\xf4\"J\xe9\xd4< \xc8Q\x80\xc5H8\x881(\xc4R\x13,\x06\x00\x96\x83\x80\x02=\xeaK\xb4(\xaa\x03\x0d3C\x0d\xfa:\xdc\x85\xf7'\xaf\x7f{\xf9b\xfa\xe6\xfd\xeb\xe9\xd9\x7f\x9e\xbe\x9c~\xf8\xed\x97\xdf\xde\xfe\xfd\xb7\x01\x18N\xdf\xbd\xfc\xfd\xed\xd9\xcba\x18\x9e\xbf}\xf3\xe6\xe4l\x10\x8e\xb7\xa7o\xdf\x1f\xff\x8aDQ\x84d\x06\xd2\x03/\xef\x9b\xf0\x9e-B\xea\xbfI\x16g\x9b5\x95i.|\xedE\x81\x00\xf1\x13\x1aS\x1eK)<%\xa5\xe9\xa1\x95\xd6-P\xae\xe9S\xf8=J\xb5\x1e\x92\x16\xa8\xd7\xe5)\x9c\n\x83\x87\x048t&\xafF\x13zl\x1c\x9b\x93\xaa\x848\xcaB\xed}\xa2:\xd8\x1d\x9b%\xe8bf\xdd`v\x914\xc1R\xd6A\x0fy\x07\xe8\x93}\x05=\x96\x0f\xb0&Y\x1b\xac\xdc.M\xe8A=\xe8IA\x0eH\x07M\x13\xfa\xf0]\x01\xf6[\xa2\x00\xdb\x05\x87\xfe\x8b\x0e}\x17\xde\xd2\xe9\xd3\x04\x94\x0b\xa8 )[\xd1$%+\x83\xd3\xbe\x82\x1e\x04\xc1\xfaS\x9bPz5\xccg\xcf&\x0c\x18!z\xa9\xaa\xc1\xb1\xd0\xa7WvC\xb3\xe3{{y[f\x9e\xd8\x0dk\x97\x14\xebc\x82p\xad\xde,\xcf\xb0\x8e)\xb7\x98\xef\xf0\x7fH'\xe6\x1d\x88pt\x94\x9f\x0b\x83[\xba\xd7*\xa7\x19\x9f\x0b\xce\x0e\xa9\xd9-\xa6O\x85e?\xc3,\x80\xa5\xbc\xb6\x95\xd3\xce\xb2o\x81\xb3\xec\x9deo\x06g\xd9\x9b\xbe\x06g\xd9\xdb\xe9@ \xce\xb2W\x82\xfd\x96(\xc0v\xc1\xa1\xff\xa2C\xdf\x85w\x96}\x01\xce\xb2\x97`/o\x9de\xbf\x0d\xd7m\xd9\x0b\xb18\xbd\x88R\x16.\xa6\xa2\xaa/f1,\x17\xc2N\x14V<{3\xc6c%zz\x8e\x04+rl\xf9\xf3E\x11 \xe2L\xfa2\x0f\x0fU\xc1\xba\"`$\xe2\xcfFd\xe5\xc2\xe4f5\xa4\x97\x11\xc75\x0f\x98\xc7\xf9Gp\xad\x81\xe7\x02n\x88Ne\xd1\xd1)IS\xe2\x9d\x7f\xe9\xb0Um\x06SD\x92\xa9\x04\x8b\xb1\x80\xe5x \x17\x8d\xd4\xb7\xb4\xaa,\xc7\x04=\xc6\x05\x86\x1c\xe4n\xe810\xe898\xc0d1w\x83mns7\xf4\x9c+\x0c\x98/\xe0\xb2\xa3\xbb\xc1R`\xb5\xa1\x10`\xc6L\xean0\xe6Ww\xc3\x97\x1c\xb4\xad\x08n\x03.o\xdb\x1am3\xcf\xbb\x95\xcdm\x8d\x0d\x99\xfd\xdd\x0d\xd8\x9cpk\xc4\x8d\x1cr\xebL\xf1n\xb0\xcd\x1f\xef\x06sVy7\xf4fd;\x8fN\x01\xbd\xbb\xb3\xb5\x99\xea\xa0\xcfa\xef\x86\x11\x06\x8a5\xa9\x9a\x80\xcc\x82\xef\x86/$\xfb\xfb\xf8\x0b`\x18\x91\xc1\xfeh\xd5\x84\x01\x8e\xa3\x02\x06P\x1b\x06R\x1c\xfa:\x94\n\xe8s\xc0nC\xff\x1dY@_\xc6\x81\xe1\xcc\x03C\x19h\x90\x03\xaa\x80\x1e\x8e\xa8\x02\xf0w\x0f\xbaa\x00\xfd\x06\xd0\xcd\xfe\xf6B7 \xee4t\xc3\x97\x986\xfaFA7|\x89!\x9b\xb3n\xd5\x80\xbd\x8aa\x8dXwu\xa3\x1b\xec.tt\xc3\x97 ?\xf6JH7|\x89\x11\x9b/\x95t\xc3\x97\x18\xab\xc5\xb5\x94n\xf8\x12\x83F^l\xe9\x86/1`\xbb\xab1\xdd\x80\xbf0\xd3\x0d\xd7?\xef!\xa7s\xe3\x0d\x1d+l\x16\xb7y\xbaA\x1a\x176$\xefi\x11\xf7\xb5\x84\xbf\xa23\xa8U\xb6A\x01C\x8ct\xfbhX\x01\xee\xf0\x89\x81\x9e\xe2A\x82;|\xf6\xe6\xeb\x02\xfao\xc5\x02\xfa2\x0e\x0cg\x1e\x18\xca@_\xfa\xf0YUc\xb3\xa5\xa0\xa4\x9c\xe9\xd9\xce.0\xdem\xeb\x86A\x1be\xd86)$\xe9t\x1e\x10\xe5+}z\x18\xcchv\x19\xa5M\xb8\x0b\xcf~}\xfb\xfc\x97\xe9\xc9\x8b\xe9\xab_\x8f_[fS\xb6\xa1\x8d\xed\xf8\xd9\xfb\x97\xbf\xe1\x93D\x9b\xd0Ff\x99q\xda\x846\xb2\xdfN\xb0\x89\xa7M(\xd3P\xc7#[\xffS\xb8\x04\xb9\xb9\xfdW\x01Y\xd4^\xee\x94E\x19\x9f\x05^t~\xf2\xa2W|FB)\x06\x80\xc9\xec\x10S\x83m\xe8\x9d\xbd\xd4\x84\xc1\xfbd\xb08\xb6\xc8\xd1\xd8\x86\xd1\x86\xdf/\xe8 \xc1:\x1d\xaa \xa3\xcd\xa1\xd7\x12\x0c9wIx.\x8e;\xef\xd9Bfps\x1b\xad\x08\xf1\x89\x0c\xab\xe2\x02y\x0f\xd4,\x04\x92\xe3\xc7\x1f\xbf\x86\xcdI\xf6\xd6\xbc\x16_f\xdb\x88\xeb\xfav\xa7Iy\x84\xbc$I~,\xcc\xdf&%\xf9]{+\\\x95C\x0eG\x8dJF$\x14}\xdc\xeb\xa1\xf7\xfbh\xfbj.\xf86}\xad\xa0\x1e\x16P\x0f*H\xe8C\x0b \xbd\xe5\xf8 \x012@x\xac\xb3\x99\xfa\xc5\x1c\x1d\xf4&.\x0c\"0\x07\xea\x1f=xp\xf8\xa4O\xd3\x81\x84\x86a\xc4\x06\xf1&\xa1\xb7>z\xf0\xf0\xfc\xf0k\x1c\xfe\x10\x8b\xec4\x9b\x05\xcc\xfb\x85n\x1a>\xbes\xbai\x95\xf2\xef\x81:K\xa8\xac\xe1]s\xfb\xfd^\xca&K\x84\xb6\xe9\xb8M\x18\xb4>C\xce\xf5\xa5\xb7x\x1d\xb3(fi\xef-}\xadc/Fm3\xd8\x9e\x92\xa7\xaf\xcc\xe9)\xd2\x07\x10\xb3\xf7\x16\xed)\xcc{\x12\x14\x06\x10\x15\x86\x89\xf1\x01\xc4\x85!\x04\x86\xa1\x02\xfc\xcb\x0d\xbc\xbf\xe8\xde\x99\xe0\x1eQl\x0f\x11\xda\x03\xd6\xa4\x9f\xd0\x831\xc4\xf5\xb5\x8f\xba\xdfe\x95\x02z\x0e\xd7n\xa8\xfct\x16\x85S|h\xccrTv\xa3\x99m>\x930e!\x9d\xda\x9d\x93\xec\xceG\x16\xe7\"k9o/\xdd\xad\x95\xa5\xe5\nH\xe8!\x06\xadU\xa35\xb1\xa0\x17\xc1\xa0\xaf\"\xecE8\xe8G<\xe8\xaf\xf6\xaew\x98}\x94\xdc\x0e\xd4\xdb(\x8a\xad\x9f\xa4\xedEo;\xb9&a\x80\x02\xbb\x861\xf6SV\x96\x03\xb3\x1c\x92\x8d\x97\xbc\xe7H\xb0\x1ep[\xe7\xea\xaf\\\xa1>\x17\xf7\x06\x8f\xc5\xb5\xc1\xa1\xb7\x19\xf3\"\xa5\xb5\xfb\xb5$M\xe9j-n2\xa6\x11\xacX\x12P\xe2\x03\x91w\x16\x8d\xf8\xe4\x9d\xc6.\x8fj-U\xb8\x9b\xf0FAo\x16\xea&\x83\x03\xb5\x9a\x18n2d\xd2\xc8~L\xb9\x05\x98\xec\x18s\x1e\x8c\x91l\x80\"\x1d\xa0\x92\x11P\x04\x04\xbc\xd6\xb0\xcaAA\xcd\x14\xd0\xb3\x05@g\x90\xe0\xd6\xb3\x00\x0c\x03\x15`&9\xd8\x90\x1d\xf0\xa4\xb7\xcc\xde@\xe5i`220V\xb5\xd1\x96F\xb2\x02\x96\x11\xacr$,\x16\x03\x97\xf7\xd07\xc3\xa1g.C\xcf\xac\x05\xfb\xfc\x84A\x99\x08x\x0br\xac\xec\x02\xab<\x02\xeb\x8c\x01\x0b\xae\xb1\xd8\xc0HK\xa6G\xe78\x0b\x06\x1d\xad\xef1\x02\xc3\xf4mL'lT]\xc4\xc8\x11\x98\xba#\xc6\xb8\x11!b\xe2\x8a8\xb7\x02!\xd96\xe2l\xde!m>9\x88z\x88\xb4\x85A>K\xdaz\xf6\xd0=G*Ag\xe4\xb9\xe7HM\xccY\xc11|x\xf7\xeb~L\x93(\x8b=*\x9e\x17\x95\xbb%\x0b\xd9\xa7\x8c\x06\x1b\xe0[(e\xf3\xe2q\xe8T\x16?T\"\x94O4\xc4\x8c\x04\xec3\xed|\xedW\x82x\xd8\xd7\x8b\x02\x98e\xf39\x8d\x8bE\x9b\xc8\x97'\xe4\xdc`\x95%\xe5\x96\x06\xa26I\x02J\x92T\xddW\x14R\xb8\xbd\x7f\x1b\xbc%\x89\x89\x97\xd2x\"^5\xe6G'H\xe8bE\xab\xb7\xd8?\xbc\xfbu/i\xbf\x82\xda\x041\xa8\xb2$\x93\xbaW\x8en\x9e\x05\xc1\x06>e$\xe0\x14\xf4%}\x8bg\xdf9%\x7f \xb0P\x8d\xe4#\x1f\xca\xfe\"\x8a\x16\x01\x9d\x08\x9a\xcd\xb2\xf9\xe4E&\xdf6\xfd\xf8\xa3\x9c\x89@+_\x9f\x87\x19m\xbf\x10_\x07\x02\x1e \xa3\x90y$\x10{H\xdd\xf3\x0ft\xb2\x98\xdc\xe1\xa4\x15\xd5\x16nOns\xe1%^$\xf1<\xbaN\xa9\xffc\xf7\xb3\xd1\x12NBXsb3\x8f\xde\x81\x94\x92U\x02Y\x92\x11N\x0eY\xb8j\xcd\x02>\xd24\x12\xc4\x98\xb1\x90\xc4j\xcbU<\x82\xb2Y\xd3\xa4|w\x7f\xa3\xeeZ\x8a:`\xe2\x99\xf7,\xa9W\xdcL\xe9\x95X\xea\xe3p3\x81\x9f\xa3KzA\xe3;Z\xab\xe4\xc3\xbb_\x0b\xab\x87\xa3\xe2bZ\xf9\xad\x90\xa0\x14>.\xd3t\xfd\xf1\x8e\xfc\xdf\xe4\xe3\x1d\x88b\x08\xa3\xfc\xd7;\x82\x1b=\x12B$v'\xa7\x88\x1a!M![\xe7%G5\xfd\xd2\xf8\x82\xc6\x924+\xb2N$k\x89\x91\xa7QYwT\xb8\xff\x98|0\x85\xa8\xbdt\xf3(\x08\xa2\xcb\xe4\xa9fm\xff\x0dN\xe6\xd5\x8c8[\xac\xe3\x88\xebZ\xbf\x9c\xb4\xb0\x08\x92$[Q_S\xdf\xf4\xdf\xb8n\xfa\xf9\xec\xec\x14^\xbf<+\x9e\xa8\xf9\xf0\xeeW\xb9\xc76\xe2\xb9q\xb5\xe1\xf0_\xedmq\xb6Y\xd3\x7f\xfe\xd7?\x95\x0d\xf2w\x9a9?H~\xcb\xd5\x88X\xa1u\x1c\xf9\x99G\x81\x84R\x85\xa9\xd3\xd7\xfe\x0d\x8e\xab\xb2 \x89x\x93\x87p\x9aQ\x9f\x93\xdb#\x1e\x97-Qt\x9e\xad!\xbf\x88\x083\x92h\x92\x0b#S\x1d\x95\x0f\xef~\x15c\\\x92\x0b\xc1\x82\xab\xda\x1e\xf2\xe5&\"\xc5\x94\xf8\xbf/\"\xe6\x03 u\xf1\x159@!>b:\x8fbz\xa7@\xc0\xf1\x92\x94\xcdX\xc0\xd2\x0d\x84\x94\xfa\x82\x8df\xe2b\xaf`5]\x9ad\x14r1\x1b.\xa8h$\xf6\xec\x04~\xf8\x90\xd0\xa2r\x12\xa7\x12gO.\xb3$\x7f\x92\x90,t\xb3\x9f\xc5\x94\x9cs\x19\x94#\x9e\xfc\xa8\xe6\xa8\xdf\xa2\x94>\x85\x94\xeb\x90y\x16zr\x87\xf1y\xe4\xb2\xcb\xcb\xe2\x98\x86i\xb0\xa99\xbf5\xe2R<\x994\x9f3\x8f\x91\xc0\xa0\xcbf\xd9\x1cb\xca5\x11\xbd#\x8a\xc9\xb0\xb4\xe84K\xa8/\x8d\xbcb_*Q\xcd\xe8\x82\x85!\x9f\xec%K\x97\x1a\xe5\xb2Y\xd3\x89\xe4\x7f\xb2f\xc9\xc4\x8bV:i\xfc^\xec\xd4\x04\xa2t)\x05E\xd8\x96R\xf0C\xfe\x1a>]\xad\xd3M\xbe\xb5\x7fT+A\xb6X\xa60\xd3\x08%1i\x11%`\xabu@\xb9\x92\x15\x1b\x06\x925\xf5\xd8\x9cy\x90\xd0\x15 S\xe6)2Ew\xf0\xa6z\x1b\xb0V\xd2\x1b.\x8ef\x14\x88<\x0c\xd4\x0c\x9c-;\xa6(\x1c4\x8b.\xd4<\x9d\x93 \xdf\n\x9do\xb0!F\xf6\xf18\xdc|\xacN<$\x04\x12\xcfX\x1a\xf3M\xac\x1ea'\xaaBG\x90 \xcaY\x0fH\xf7\xd2r\xe9,\x14\x8d\x1c\xe1\xaci\x16\xb6\xcc\xbf\xd2\xaaS\xb0\xe6i\xb1q\x026\x13\xc3\xce\xf5H\x02I\xb6^G\xb1\xd0\xe0k\xe2\x9d\xefg!\xff\x1f\xae\xb7%_t\xef\xa0\\\xd1\xab\x0d\x9bh\x0eY*\x05[!\x1e\x12.X\x89\xef3)+`AC\x1a\x93T\x0c\x9e\x9f\xb3\x8aZP\x9d\xf8\xf8x\xe4\x12v\xf7\xf7\xf2\x8ap\xe6\x87\xc3\xa7p\xca\xc7\xcf\xe5B>\x15R/\x08\xfe\xfc/\x7f\xd1\xa8\xc9WQ\x04\xf3(\x82\x9f`2\x99\xfcO\xe5g|0$\xdc\xa8? \xe1f\xc2\x87\xf1\xff\xb3\xf7\xaeMr\x1b\xc9\xd9\xe8w\xfe\x8a|yN\x98\x94=\x9c\xb1\xe4\xf7|\xa1_9L\x91\x94vl\x89\x9c\x97Cjc\xc3\xb1\xd1\xc2tW\xf7`\x89\x06z\x01\xf4\\,\xef\x7f?Q7\xdc\xba.Y\x85\xea\xe1\xac\x94\xf9E\xd44\x90\xa8J\xd4\x0d\xf5<\xf9\xd4\xf7u\xb5}\xbe\xae\xaa\xaf\xec\x97\x9e\x9e\xda\xe7\xbf|\x0d\xcf\xb9\xabO\xa2\"\x1f\xab\xe7\xff\xc0}}\x05\xbf:\xc6p\x97\xbf\xbf\xb9c\xf7\x8d'v\xff\x91\xddd\xc9\x82\x07\xdf\x8a\xb5!\x7fJ\x82\x08\xe5\xcd\xf3\xef\xab\xeatYdM\xe3 \x90,\"\xbfI\xd6qp\xa3\xbd\x0c\x96\xc8u\xa1\xfb\x17O\xe8.\xee\xdb\xeb\xaat\x04O\x96\xea\xfb\xaaz~zzj\x9f\x0d\xba\xc0=w^#\x1a\x9f\x08klT\xb9\x93s\x19\xd47o/_\x7f8\xbf\xf8\xf8\xfe\xc3W\xae]\xb2\xbe\xa1\xba\x1f,\x1f\xed\x0e\xe7\xff\xf6\x84\xf3\x87\xca!\x11\xc7C\xf9\xf2[\xf8\x87\xdd\xd5\xe9\xf7U\xf5\xeb\xe9\xe9\xe9\xdf\xec\x17g\xe5\xfd _\x86\xf2;vr\x11\xf5SV7\xd7Y\xc1\x83\xec\xae\x88+\x84\xd3R8\x8a\x90\xaf'\x05\xf8Tn\xfb\"\x88\x02\x8a\x0e\"\xae\xfa_\xdfB\x99\x17\xce\x06\xee.\x97\xa5%\xf3\x8f[\x11g=\x16\xeb\x0f\x0d\xb8\xba\xef\x97]z\xf6\x90Go\x9aW\xbdj\x93\x8c/K\xcc\x8fzfXR\x9d\xf1\xef\xf7S\xf1\x03_\xae>\x83l0\xdb\xf1\x99P\x89\x06\x1a\x1d\xca\x16b~X7\xb5\x94\xc5\xbd\xfe\xae<\xd8,\xe8\x96\xc9\x90\xad[f\xda\"\x94&\xf61\x9e\x9d=3?J\xcd\x89\xba\xc8\xe2k\x17\x98j\xd1O\xd7Uuz\x95\xd5\xa2\xb2wg\xf7\xa7\xff\xfdTFQ|{\x19\xfd\xd9?EEQ\x9fr\x1f|:4^\xf2\x1f\x97\xef\xdf\x99\x7f\xf9\xf6\xdbo\xbf\xb5\xb7\x01~_\xbf\xe7\"\xd7\x91\x15\x1f\x0e\xd4\"H~\xd7\xed\x1b\xa6\xb7W7\xfb\"\xb3\x08Z\x1f\xba\xe1\xb7\xacX\xbfl9\x01\xb6\xbdb\xabU\xbf\x809\x91\xcbq\x93\xbb\xcc\xb2{3XR\xac\xc5\x87\xec/\xff\xceC\xf7\x8b\xdaL\x18mT\xeb\x97c\xee j\xf8y\xe9\xf8\x00\xc9\x96\x9f\xf9\x18\xd4\x7f\x10\xaf\xf3\x82\xd9\xe7\x0d=f]\xb0\xba\xa9Jg\xb7U;q\xe2\xc4\xd8\x85x\xc3\xdf\xc2\xd7v\xcf\xdd\x0d\x82\x97\xa0\xae\xff&|\x06\x03p\x96\xea\xa9\x88\xe5\xd3\x97\xf0\xd4\xd4k\xc7a8\x95\xb5|z\xe2\xf2'\xea\xf7.\xdbr\x9f\xffGV\xe1\xdf\x9c7\xf0\xfaM\xae\x0f\xad\xe4\xf9Z}p\x8d\xdb\x9al\x0dy\x03\xb7\xac(^|.\xab\xdbR\x8c3\xd7Y\x03\x19,\xf7M[m\x03;\xd7\xb8\xc9\x9f\xc8\x05\xfc\xa4\x1f\xe8s\x8b\xbb\xe2\xf0\x06l\xf9\xb8\xcad\x936?\xec\x17\xd1\x19u;\xbf\xae\x8a\x95\x12\xa1\x15%\x97]9/\xbb\xfe\x01r\x07\xd0\xecJv\x19\xf3sD\x11N\xbb\xc9\xf99\x1f\xd7t\x08\x0f\xb6\x86\xf4\x8e\xe9\x9f\xff\xeb\xcf_9:R\x8a67~\xa0\xbb\xd9\x89Pq\x97_\x9f~\xf3\xf57\xcdSG\x13\x92\xffm\xb3\xcd\x004x\x01\x97\xac\xbe\xc9\x97_\x1d\xfaP\xd7h\xdciP\x89g\xdf\xfc\xf3??\xb3\x83W\xd0\xec\x97K\xd64\xeb}\xd1\xdd=\x1c'\x13\xc1VvF\x90\xd5\x19x\xa1\x1c;\x0d\xc5\xbb\x7f\xe1\xd9\xbd@1|\x9c%\x07o\xe9\xc1\xcf\xe4iQ\x0c\x1e\x0cs\xe7!\x8e\xf4G1s\x9c\x8c\x1c\x8b\x12\xfa\x9c&r\xdc\xf7\xe7\x95\xab\x0f\x15\xa6\xf7\x96 P\xe5\x02\x9c\xac<\xea\xbd\xc3\xe0\xdd{U\xd7\xbd\xa2\xf0\xa9\x1f\x89\xd9\xc9\x93\x86\x13o\x87\xb1\x18\xbb\xab\xaa#\x99v\xac\xec:V`},\x98\xeep\x18*\xa5\x1e*\x9a\xee\x97GG\xbc\xd2\x07\xa3\xb8\xba\x05\xcb\x83\x1e\xe3\xe3\x12!\xe5\xc6\x13\xf6h?\xed\x12UA\xc0\x0c\xe6\xd2P\xf3\xa06TM\x01][\xf0\xcf\x8f\xdde\xa8yR\x1b\xa6\x1di\xf3\x87\x1cB\xc2\x0e\xf8\xd0#\xe7\xd3\xc9\xc5n\xa6+^\xf8\x1aU#TM\xc2e\xab\x11\x02\xd5\xa9\x8a\x87\xd67N\xf5\xc0i<\xbcJ\xcfN\xe5\xe60\x8d\xe6Tu\xc0*,\xa7z\x9e_\x1f9\xd5\x93\x02\xd4\x8dS=\x12\xa9M\x9c\xeaqa\xca\xc2x\x0d\xe14\xe5\x1b-\xe6\xbc\x92\xbe!2\xbd|L9\xdaW@{\xe7\x8dL\x92\xcc\x01\xef\x04\xe3\x0d0\x04\xad\x98?\xde)B\x98\xde\xbc\x12\x8bL\x89\x0e\xc8e\xe4\xbf\xcb\xc0\x9f\xcaM\x88\x7f\xfa\xday\xd8\xf2;q\x90\xb2\xa0\xb8\x15\x05\x0f\x1a\\\xb3\x9a \x82\x8f\x18\xc3N\x01\xfe\xc8\x9e\xd5\x0c\xfe\xb2oZ\xc865c\xee\xea*FSU\xf3v\"\xb6\x18\x9d\xcf\x17\xd4\xc7-\xcbJU+Y\xf4W\xbb\xdd\x1f\xb2\xe6\x1aV\x15\x93t\x12E\xab\xe6\xae\x1b\xd7\x04\xdd\xdeY\x98\x15\xbe$\x807|\xa5?\xda\xa0VTh\xb1(\xcf\x14l>dw\xdb\xe9K\xb6\xd9\xc1}._\x826\xef?\xf8/a\xc3\xf7\xae)\xfd\xe5\x95\xb6\xd2g*.\xc4\xb1\xf8\xfeJHC\x96\x02\x02J\x02\xfah~\xcb\xb04\xb6\x80\x02@`!@\xbbG]\x89\x1e\x8a\x86\x86K(\xd2FG\xf3+\xa3\xa3\xf9\x07FG\xf3\xa3\xee \x12\xcb\x0f\xfbl\x96\xe6\xca\x0c1\x9b\x7f\x8bdl\x81c\x1dD\x8cw\x80\xfe\xb2\xef-\xe2\xf5\x01vI6\xb5\xa0m\x97\xb1ED\x0f\"#\xc8\x0d\xb9A3\xb6\x98v\xa7-\xbcKh\x0b}\xe1\x10\xff\xd2!\xf6\xc5\x07n\xfa\x8c\x0d\xb5\x0546t.\xa6\xb6\x88\x80`\xf7S\xc7\x16\x9c\xaa\xaamF \xd1\xaf\x8a\x8e\xe6\x0f\x8bX\xcc\x12\xe4\xef\xfah~\xb1\xb2\xbf\xc2\xbc\x80\xc0\xf1:t\x9c\xa6\x95\xfd\xc4heO+{\xbf\xd1\xca\xdew5\xd0\xca>l\x0e\x94F+{\xab\x85w m\xa1/\x1c\xe2_:\xc4\xbexZ\xd9k\xa3\x95\xbd\xb4\xf0\xf1\x96V\xf6\x87\xf6\xd0+\xfbG(\x0d\xd9\xb7\xd9\xc7Q\x9e\xa0\xa1'\xb2$\xd8!'\xb4}\xbe\xd1\x00\x11o\xa4se*\xbb\x17\xa3\x96\xd5\xd0\xdeV\xdc\xd7\xba\xc8\x97B\xaa\x92\xb7ZO\x9b\x13\x02\x96\x0b)P\xb9\xc8\x84z\xe6\x97\x86\xad\x065X H\xa6\xd2\x02\xca\x02\x81\xe5\x0154\xb2U\xe0\xaa*\xb0L\x10Q.\xf0p\x90\xcd\x16Q0\x88,\x1c`X\xccf\x0b\xe56\x9b-\xb2\xae0\xa3\xbe\x80cG\x9b-p\xc0\x9a\x9a\x1e\xc0\xbcLj\xb3y\xf9\xd5f\xfb\x92\x85\x0e\x1d\x82\xa7\x86\xe3m\x07\xbb\x1d\xf3\xbc'l\xee`oH\xf6\xb7\xd9\xb0\x9c\xf0`\xc7#\x0ey0S\xdcl\xa1\xfcq\xb3\xf9Y\xe5f\x8bn\xc8a;:\xda\xa2\x1f\x17\xbaf\x1a\x9a\x9b\xc3n\xb6\x04\x05\xc5.\xa9\xc6\x86d\xc1\x9b\xed\x0b\x8d\xfd1\xfb\x050/\xc8\x10\xfei5\xb6\x19\x1bG\xdafD\x1bfF\x1cb7\x94\xb4\xc5|`O-\xbeGj\x8bm80\xbf\xf1\xc0\xdc\x064k\x03J[\xc4F\x946|\xee\x81\xd9f\xc4oF\xdc\xc2\xb3\x17\xcc\x86\xc8i0\xdb\x97\xa86:\xa3\xc0l_\xa2\xc8~\xd6\xad\xdd\xb0\xa9\x18\xc1\x8e]\xa9\x1bf\x0bK\xe80\xdb\x97\x08?6%\xc4l_\xa2\xc4\xfe\xa4\x12\xb3}\x89\xb2\x06\xa4\xa5\x98\xedK\x14\x1a\x99\xd8b\xb6/Q\xe0\xb0\xd4\x18\xb3\xe1\x13f\xcc\xf6\xf0\xf5\x9e\xf3u\xee\xcd\xd0 \xf2\x16\x90\xcdc6\xd71=f\x8b\\\x11\xc7\xae\x84\xff\x8e\xbeA\x83\xd8\x06\xda\xe6,\xd2\xc3\xd10m\xf4\xf1\x89\xb1\xc8\xe1A\x1a}|F\xb7km\xf1]Q[l\xc3\x81\xf9\x8d\x07\xe66\xa0/\xfd\xf1\x899\xe2\xc9l2r\xd8\xe3T\x87\xe6\xcdm3\xdb\xac\x8e2\xaf\x9b\x04\x1d(e\xb6\xd9\x0d-\x8cQ:\xb6\xd8#\xa9\xcc\x16yP\x95\xd9\"\x8f\xaf2[\xf8\xa1Vf\x9bu\xd4\x95\xd9\xe2\xbf\xc2\xa5\xa5:\x16\xcblA\x87e\x99-\x9a\xbd4\xb6\xd9\xfdd\xf6p\x1c\xc0\xd18\xb4d\xc5\x8f\x03\x1d\xa4\x05\xd3\xa1\xc6\x96\xac\x0eQ\xaf`\xcew\x974\xec\xf1`\x11\xae\xf3\x122\xe7\xa1af\x9bS'\xc4\x01cA\xfe\xcc\x87\x91u\xc7\x8e\x05\xf9\xb2\x1dQf\xb3~\x8ch\x18\xfas/b\xde\x8f\x99\xed\xc3\x0e\x93\xd7\x16\xb7\n\x8aX\x01EDAZL,\xa4E\x8f\xe3\xb3\x06\x90\x19\x83G\xf0a\xf4\xda\xa2\x83\x0b\xb3\x02\x0c\xb1\x87\xd4k\x9b\x15h\x98\x17l\x88?\xbc^\xdb\x97-\xfe\x9c\x15\xd9\x11\x0e\xb7\xd7\x96\xe4\x90{m\xa1t\xdc\xb1\xcdz?s\xbe\xebw\xf1\x87\xe0k\xfb\x02e\xd7\xa5\x0e)l\xe4\xc8\x13;\xe6D\x0e\xe93\x82\x19\xddE#\x07\xf3\xc8\x80\xc2\x8c\xa0\xc2\xbca|FpaN\x80a\xee\x00\xfe\xe5\n\x1e?t\x1fm\xe0N8l\xcf\x19\xb4g\xbc\x93\xb8A\x0fR\x0c\xd7\x0f^\xea\xb8d\x15m\x91\xc5\x0d+*\xff:\xab\xca\x05\x1e\x1a\x0b,UXi\xae\xee\xff;+\xdb\xbcd\x8b\xb0\xef\xa4\xb0\xef\xa3\x80\xef\xa2\xe0q>|t\x0f\x9e,\x03\xdf\x80\xb4\x88a0xj\x0c\x0e\x16D\x05\x0cb'\xc2\xa8\xc0A\\\xf0 ~\xda{\xd8b\xc6LrG\x98\xde\x92Llq#mT\xbc\xc3\xc65i3&\xb0\x07(c\xdcd\x15X\xb0\xc0\"\x85\xec\x92G\x96\x04\xbb\x03\x1e\xba\xb9\xfa#\x9fP_\x8b\xbc\xc1W\"mpn6\xa3\x12)\x1d\xe4\xd7fm\xcb\xb6;\x91\xc9\xd8V\xb0\xcd\x9b\x82e+\xc8d\xce\xa2\xd7\x9f\xcci4\xed\xa8\x0e\xa8\xc2\xe6\xc0{\x07z\xff\xa0\xee[p\xa0\xde&\xa65y\x984\xf29>n\x01\x86\x1d\xe3\xe7\xc1x\xc3\x06\xa8\xd0\x01\x8a\x8c\x80\n \xe0g\x8d \x0e\n\xaa\xa6\x80\xae-\x00\x9aA\x82{\x9f\xda0\x0dH\x9b?\xe4\x10\x12v\xc0\x87>\x90\xbd\x81\xe2i`\x18\x19\x98U\xb5w-\x8dl\n\xd8\x86\x10\xc4\x91\x08x\x198\xdeC,\xc3!\x92\xcb\x10\xc9Z\x08\xe7'\xccb\"\xe0W\x90\xa9\xd8\x05A<\x82`\xc6@@\xab \xe8\xc0\xc8\x95L\xc4\xc3q+\x184Z\x1fQ\x02O\xf5C\x96NXT]`\xe4\x08Of\xc4\x18W\"\x04&n\xc1\xb9-\x0e\xb3\xc3E\xdc\xb8|\xeerM\x0f\x1d\xfc\xa0\xce\x0b\xe4\xa1\x92\xe7\xc2\xaa\xff\xe7\xaf\x90\xbf\x1cCg\xfa\xbf{V\xdf\x9f\x1d\x1c\x81\xf8\xe1\xe2\xb5:\xb5\xb7/\x90\x1e\x14\x06\x1e\xc6g\x17\x96\xb0/\xd9\xdd\x8e-y\xa5Y]WuW\x84\xc1=\x89N0\x14\xfe\x0f\xdb\xae\xa3\xb5.\xab\x95\xa1\xb1\xbb\x17\x08\xae\x85\x9e\x12\xdb\x0b*\xc3\x8a\xb5Y^\x18\x86\x1c\xd7\xdcj\x9dS=s\xa9o\x0e\xe5\xb7/\xf6\xb5u\x15\x85\xe8\xf9\xb8\x8e\x03\xf0\n>}\xf8\xf1\xacfM\xb5\xaf\x97\xea\x98g\xd1c\xf6e\xfe\xd7=+\xee\x81w\xa36_\xe7lpF\xb0\x83\x17\"\x8fi\xd0G\x18;\xce\n\xae\xab\xb6ZV\x05\\\xed\xd7k\xd6\x1d\x99z*O\x9f\x90u\x83\xed\xbe\xe9\xba5d\xf6eI\xc1\xb2\xa6\xb5?\xab*\x19<={\n\xcb\xeb\xac\xce\x96-\xabO\xc5i\xce\xe2\xc0\xea\x86m\xb6\xac\xec\xc6\xaeO\x1f~|\xd6\xc0.\xb3\x9c\xb2\xccM\x14\xaa\x93e\xb2?\xb55\x9c\xa5-\xe2\xab\x1e%\"\xf9\xe5\xc3\x978\x95d\xb9d\xbb\x96\xad\xbe:\xb5\x1c\xaf\xcd\xed\xbc\x84\x1d\x0fv\xbed'\xd0\xb2l\xdb\xc0\xbe\xd9g<\x1cR\xbcj\x97\x17\xbc\xa4\xf2\xd8]\xb8\xca\xcb\xac\xb6\xaf^\xc5A(\xf7;\xa6N$i\xaf\xd9\xbd\xfd\xd1r\xa8\x83\xbc\xe5_\xdb\xfbf\xa8\xba\xd9\xb2;\xf1\xaa_\x95\xf7\xa7\xf0\x87\xea\x96\xdd\xb0\xfa\xc4\xb92\xf9\xf4\xe1G\xbd\xf2Q\x07\xa4\xdb\x1f,FP\x06\xbf\\\xb7\xed\xee\x97\x13\xf9\xdf\xe6\x97\x13\xa8j(+\xf5\xeb\x89h\x8d\xcb\xac\x84j'\xcf\xe5.\xec\xd5\xe6\xb3\xd0~\xa7dG\x1d\xcfe\xf5\x8d8\x98=ka\x9b\xed\x1a\xd9\xb4D\xc9\xdb\xaa\xd3\x1e\x15[\x80\xb9<4%\xb3\xef\xd4\xad\xab\xa2\xa8n\x9b\x97\x8ew\xfb\x8fp\xbe\xeek\xc4\x9b\x85>\x0f\xbf\xab\xb4X\x154\xcd~\xcbV\x0e\x8d\xd3\x7f\xe4s\xd3\x1f>~\xbc\x80\x1f\xde~\xd4\xc7\xd4|\xfa\xf0\xa3\xecc\xe2\xf0w\xc7\xe2\xe1\xe0t\xe5\x8f\xf7;\xf6\xe7\xff\xfa\xb3\xf5\x06P\x07\xb4\xe7\xa5joj\x1a\x11ohWW\xab\xfd\x92AV\xca)\xccNa\xfbGx\xd5K\x834\xe2\\\x9e\x8c\xc7\x8c\xadx\xb8\x97\xd9\x92\x8f-U\xf5y\xbf\x03\x95\x8c\x08WY\xe3 \x18V>-\x15q`~U\xc3uv#\x9a\xe0v\xd0\x87V\xb2\x13e\xbaJ\xfc\xdf7U\xbe\x82\xacta,\xb2\x80b\xf8\xa8\xd9\xba\xaa\xd9\x89v\xc0\xfdfm~\x95\x17y{\x0f%c+\xd1\x8c\xaeDr\xafhj.\xaadU\xf2a\xb6\xdc0q\x93\xe8\xb3\xa7\xf0\xfcS\xc3\xb4z\x12\x8f\x12o\x9e|\xcc\x92\xed3+\xb3\x8d\xab\xf6W5\xcb>\xf31H9>\xfd\xca\xde\xa2\xdeU-{ -\x9fC\xd6\xfbr){\x18\xaf\x87\x1a\xbb\x96\xfb\xbafe[\xdc\x0f6\xc0\x1d\xc3\xa586i\xbd\xce\x97yVx\xe6\xb2\xab\xfd\x1aj\xc6g\"v\"\x04e\xf2V?t\xdf\xb0\x95\\\xe6\xe9~iuu\xc56yY\xf2\xca\x8a\x93\xfe\xed\x05;<\xfb\xdb5\x1a_\x8a\x9e\xda@\xd5^\xcb\x81\xa2\x9c\x8eR\xf0\\.C\x81mw\xed\xbd\xea\xda_\xd9'A\xb1\x1a\xbdr\x0cJ\xa2\xd2\x02)\xc8\xb7\xbb\x82m\xbb\x13\xde\x9b\x1d[\xe6\xeb| \x0d\xdbfe\x9b/-lQ\xd1Wg,\x81\x10\x1f=\xd8U\xd2O|8\xbab\x90\xc9\x0f\x82\xc1\x02\xe7`\x1d\xa3\xc5\x83\xae\xaa\x1b{\x9bV!P]\xc1x\x0e\x1b\xa2d\xbf\xbc*\xef\x7f\xe9\xbfz\xb2\x12\xb2\xfa*ok\xde\x89\xed%4\xba\xd2sDVT\xaa\xe9Af~\xb5|t\x16\x13\x8d,\xe1\xd5xY8Y\xfeu\xab:K\xd3\xbc\xd0\x1d\xa7\xc8\xafD\xb1\xd5<\xd2@\xb3\xdf\xed\xaaZ\xcc\xe0\xbbl\xf9\xf9l_\xf2\xff\xf0y[\xb6\x0bs\x0fR\x13\xbd}aS\xada\xdf\xca\x81M\x0f\x0f\x0d\x1fX\xb3\xd5*\x97c\x05lX\xc9\xea\xac\x15\x85\xe7\xdfYZ\x0f\xca\xe8\x8f\x97G\xbeB\xf3\xf3\xde\xdee\xbc\xf1\xc3\xd7/\xe1\x82\x97\x9f\x8f\x0b\xaa*\xd9P\x14\xfc\xf5?\xfd\x93c\x9a\xfc\xbe\xaa`]U\xf0-\x9c\x9e\x9e\xfe\xab\xf52^\x98\xac\xbc\xb7_\x90\x95\xf7\xa7\xbc\x18\xdf\xd7\xd5\xf6\xf9\xba\xaa\xbe\xb2_zzj\x9f\xff\xf25<\xe7\xae>\x89\x8a|\xac\x9e\xff\x03\xf7\xf5\x15\xfc\xea\x18\xc3]\xfe\xfe\xe6\x8e\xdd7\x9e\xd8\xfdGv\x93%\x0b\x1e|+\xd6\x86\xfc) \"\x947\xcf\xbf\xaf\xaa\xd3e\x915\x8d'@\xb2\x88\xfc&Y\xc7\xc1\x8d\xf62X\"\xd7\x85\xee_<\xa1\xbb\xb8o\xaf\xab\xd2\x11\xb4\x92\xe7k\xf5\xc15nk\xb25\xe4\x0d\xdc\xb2\xa2x\xf1\xb9\xacnK1\xce\\g\x0dd\xb0\xdc7m\xb5\x0d\xec\\\xe3&\x7f\"\x17\xf0\x93~\xa0\xcf.\xee\x8a\xc3\x1b\xb0\xe5\xe3*\x93M\xda\xfc\xb0_Dg\xd4\xed\xfc\xba*VJ\x88V\x94\\v\xe5\xbc\xec\xfa\x07\xc8\x1d@\xb3+\xd9e\xcc\xcf\x11E8\xed&\xe7\xe7|\\\xd3!<\xd8\x1a\xd2;\xa6\x7f\xfe\xaf?\x7f\xe5\xe8H)\xda\xdc\xf8\x81\xeef'B\xc5]~}\xfa\xcd\xd7\xdf4O\x1dMH\xfew\x97\xd5\xd9\x96\xb5lH\xb7}!F\xde\x97\x8a\xaa3p\x91\x97/\xa7[\xd95\xfb\xeb>\xaf\xd9\xea%\xb4\xf5~\x18t\xcb\x07\xb5\x89x\xd1f\x9b\xd1\xd3/Y}\x93/\xb9\xb3\xb3e\xd5l\xab\xe6\xec*k\xd8Y\xdb\x11\x04\xcfn\xbe\xbebm\xf6\xf5YY\xad\xd8\"/\xd7\x95\xbc}\xd3g}6\xfb\xed6\xab\xef_\xc2\x0f\xac}W\xad\xd8y\xb9\xae\xe0\xaf{Vk\xdcAm\xdc\x00w!\xf4\xa6\xf4XY\xed\x98\x8c\xf4\xf9jt\xf7\x13]a t\x0dJ\xfc\xec\x9b\x7f\xfe\xe7gv\xb4\x0c\x9a\xfdr\xc9\x9af\xbd/\xba\xbb\x87\x03s\"\x9cL-H\x16\x93\x98\x0c\xcd\xea\x15\xbc \x92\xfe\xe8_85\xcb\x9d\x0f\x00\xefC\xc4\x15\xdf8\xa0r\xc4.M\xdf\xc4\x9c\xa2\xd9\x1e\x19\xf2t\x0fr\n\x87\xa7y\xcc\xf8\xcd[xh\x9eG\x15y\xd3\xb2R0%\xa2\xee/Y{[\xd5\x96\x88z\xeeE4)\xeb\xbd\xcb\xeb\xac,\x99 hE\xdc\xec\xdd\xd3\xdbVe\xfe\xd9\xc6y\xf38\x17[\xa3G\xeb&\xed\x9d\xef\xa0\x1co\xdd\x01\xea\xdd\xd2\xcf\x8dq\xf8\x19(\x9a\xdb\xc7\x85\x19\x83\x8e\x98\x86bb\x9f\xedv\x8b\xe8\x9b\xe74\xc7M\x8e!\xd0Zo\xbf\xda\xe7\xc5j1\x9e\x0f\x03n\xdfT\x98\xe1\xd9\xf3\xf4\x15\xdb9\x9fn\xa7\x05:)\x81\xde6\xefk\x0c\xea\x9a\xacu\x921\x11\xad^\\&\xa9k\xdbj\xb5/\x98\x1b\x9eG\x1c\xd2\x11\xf5P\xe5\xd7z}\xe3\xe6%\x86=sy\xcd\x96\x9f\x9b\xbdy\x9d\xdf]\xf5\x93,Y>\xf8\x88\xe4\x8b\xe0\x9feI\xcf\xcd\xa2\x9cr\x89\xb6hV\x9fg4\xbe\xd1\x8ai\xf0\xbc\x83\xb2\xf0\xff\x19,\xca:&T\x07\x0cX\xbd\x9aXU\x07n:B\xd5_\xf7\xaci\xc7\x8f\xed\x18T\x93\x15\xa16\xa2RI#*\x15Q\xa9z#*\x15Q\xa9z#*UKT*\xb3\x11\x95J\x1bQ\xa9\x88JET*\xe4*\x89\xa8T\x9d\x11\x95jhD\xa5\"*\x95\xc1\x88Je\xbc\x86\xa8TD\xa5\xb2\x18Q\xa9\x88JET*\xa2R\x0d,\x05\xad\x85\xa8T\xc2\x88J\xf5[\xa1R\xc5\xd3\x98\x9a\xfbr\x99\x97J\xd5\xc4Bb\xba\x94\xd7t\x1c&\xc1[R7\xda\xa8K\xea\x1e\xf5\xeb\xa3e.\x8d\xaa?4\xe9\xeb\xaa\xaa\n\x96\x1dn\x04u\x9b\x08\x86\xdf\xbd\xc8\x9f\n\x0dJI\xa1G\xfe\xc6\x01\xd5F\xc0\x9f4\x02\xfe\x08\xf8\xeb\x8d\x80?\x02\xfez#\xe0\xaf%\xe0\xcfl\x04\xfci#\xe0\x8f\x80?\x02\xfe\x90\xab$\x02\xfe:#\xe0oh\x04\xfc\x11\xf0g0\x02\xfe\x8c\xd7\x10\xf0G\xc0\x9f\xc5\x08\xf8#\xe0\x8f\x80?\x02\xfe\x06\x96\x02\x84!\xe0O\x18\x01\x7f\x04\xfc\xf5r\xe0\xacm\xce\x8a\xaceM\xebD\x01\x7f\x14\x97t\xe7#]\xb2\xb6\x03\x04\xe5\xdd\xbd\xc2\xf8\x8b\x86\xb56`\xf0\xd0\x8d\xba\xf0\xd1b\x84\xf2\xf8\x07\xdb\xe11\xce\x9d\x07\xd7Y\x1f\xae\xd3\xe6\xda/\x802y\xb2\xb1\xbd;,\x9e\xa3\xdb<\xa5\x03D \x01\x81\x85\x01\xa6\xa8\xd20{*\xdaBq1\xa73\xf3\xe6\x88\xe3[!5>\x06~\x8c\x0c\"p2w\x05\xb2\xf6\x1a\x8d\x95A*\xbc\x0c\"13\xa7C\x1e\\4n\x06\xf3\xb13\x08\xc6\xcf\x9c\xae\xd4\xbe~\x10\x86\x06\xa9q4\x08\xc4\xd2 \x14Os\xb7\xec\x0ek\xc3bj\x90\x1aW\x03\x1c\xb6\x06)\xf15\x98\x8d\xb1A\x1c\xce\x06\xa9\xb06\x88\xc2\xdb\xdc\xdd!k\xd8\xca\x8f\xb9\xc1qp78\"\xf6\x06\xc7\xc1\xdf \x10\x83\x838\x1c\xce7\x04\xe3\xb08H\x8b\xc7A\x00&\x07\xe1\xb8\x1cD`s\x88!\xf3+\x04>\x07)0:\xf0\xe1t\x80_\x9e!\xf0:\x08\\\xc5\x05\xe3vNo\x02\xd3C`w\x10P\xca\x84\x18\x1e\x04\xe1x\x90\x1a\xcb\x83H<\xcf\xdd\xae\x1a?\xa6\x07\xf1\xb8\x9e\xd5\x1f\x7f\xa2\x0f\xdb\x83d\xf8\x1e\xe0a*\xc0\xe0|\x10\x86\xf5\x81os>\x12\xf3\x03\x84_\xc7\xfe_\"\xfc\x0f\xa2\x82\x8b\xc7\x01\x01Q\xcb\x08<\x10b1ApG5\x1d6\x08x|\x10\x90\x18!\xa0qB\xc0E=\x1c/\x84 \xcc\x10\x9c\xb8!\xa4\xc2\x0e!\x14?\x84\x99\x18\" \xc2\x1b\x80%\xc21\xf0D\xc0\x94\xd1\xd1\x13\xd2a\x8b\x80\xc1\x17a\x06\xc6hu\xc8/t\xe1\x8c\x90\x1ak\x04/\xde\x08\xb1\x98\xa3\xd5\x9b\xfcFu\x7f\xae#\xb0GpB$\xe0\xc4 !\n\x87\xb4\xbar\xe2\x93\x10\x8bQZ\xbd\xc9u\xa0c\xd7,\x1dV (\xbc\x12\"0K\x08\xc3-!\x06\xbb\x84`\xfc\x12<\xb3\xad\x07S\x82\x00\\ \x8beB\x0c\x9e \xa1\x98&\xb8+\x1e\x83mZ\x9d\x0d\x90Cl\x97\xc1a\x9c\xce\x0eQn\xdc8'\xa4\xc5:\xc1\x87w\x82\x1b\xf3\xb4\xde\x13\x8b\x85B\xc2\xb6\x1b\x80\x89B\x10.\n\x03ltl7U\x9b\x97\x9b\xc5\xae\xba\xb5I#\xa3v&\xfc\xa7\xf7\xef\xeajW5\xac^\xec\xea\xbc\xaa\xf3\xd6\x83\x88\xcdz\xdaX\xbbT\x03\x8aF\xe5R#8\xabm\x97m\xf2R\xbc\x8b\xc3\xc2\x8e\x9e\xd1_(\xf7\xb9\x99\xd8\xa3\x18\xfcU?\xce\x84\xc7Jk]@\xa0G\x94\x99\xdd\xb5v\x8c\xd1\x1bO\xef\x8e\x92\xd2\xa2\xfd\x1f\xdb\xfe\x8c~\xbe\x0e0\xff\xa7\xda\x8e\xcd\x9aF\xee?_d\x1b\xf6Aj\xb8\x9e\xca\xdf-\xce\xfe\xbag\xf5\xbdp\xc3\xdd\xf2\x182\xd8VM\x0bLlj\x8a\xddP\xc3\xadm\xd5f\x16\xf4\x13\x1d\x00\x87j\xbc\xef`}\xf1xQ\x7f\xf1\x8fr\xbf\xbd\x92\xbbe:\xb5e\x90Ga\xdbO\x19\x86hY\xed\xcbv!\x9c\xd9\x86\x9e\xdb\xac\x81\x86\xb5'\x90\xb7\x8dF\x11\x1a\xd8\x97\xb2\x01\xae\xe4F\xe9m\xde\x8c\xdf\xa97\x0d\xf7\x90\x88\x80\xca\xc8\x9d8\xea\xf2s\x87\x8e\xe8\x88\xf3\x89Qz.\xa5\xe7\xf6F\xe9\xb9\x94\x9e\xdb[RZA\x08\xa5 \x88N@\xe9\xb9s\xa9\x03\x11\xb4\x81$\x94\x81p\xba\x00\xa5\xe7\xce\xa1\x07\x84P\x03\"h\x01\x94\x9eK\xe9\xb9\x94\x9e\x8b\x85\xf5\x93B\xfa1p>\xa5\xe7\xda.\xf3\xc2\xf6\x01\x90=&\xf94\x04\xaa\xa7\xf4\\J\xcf\xc5\xc0\xee\x94\x9e+l\x0e\xb4N\xe9\xb9&O^\xf8<\x16:\xb7\xce\x0d\x94\x9e{h\x94\x9e\x1b\x01y\xfb\xe1\xeeP\xa8;\x00\xe6\x0e\x86\xb8\xc3\xe0mJ\xcf\x0d\x83\xb0)=\xb7\xb3\xdfez\xae\xeb\x88\xf3\x1e4=\xfd\xcc\x86\xb3\xe0\xe8cr\x82E*\xf01SCh\xcd\xda}]\x8aM%\x85\xaa)\xd4\xb5C*\xc5V\xd0f\xb2g\"\xa0G\xde\xed\xdd\xe8\xe3)\xbc\xe7\x13^U\x8ao\xc5j\xbdnX\xcb?\xbf\xc6\xc5\x85\xc1V\xf6\x04Z\xce\xcb\x97\xf2Y\x83\xbf\xf5\xa7\xb6\xaf\xb3b\x84hY6 \x8c\x1b\x03\x86 \xca\xf2\xd9\xe28\xf9(W\x95\x11\xa1,\xf7[V\xe7K\xfd7\xd1\xdb\x96Y\xc9\xeb#wE\xaeY\xa9\x03\xbf/\xbb\x8d\xa8\xc9\xf2\xf3\\x+X\xd3\xf4!\x94[7\xfb\x86\x87\xfa3\x0b\x8c\xe7\xd8\xfd\x91\x83;A\x84\x0d\xe1-\xf2m\x8e\x8d\xae\xb8\xb6c!X\x80b\xb9I9l\xc1\ns\xdd\x17\x13\xf0RnI\x0c\xfft\xbe\x86\x82\xad[\xb5\xfb\x95\xb7r8\xd4\x8bF\xb1\xbf*;\x88|\x08\x8f\xf3\xd5=\xb0ly\x0d\xd9n\xf7\x05\xa38\x84\xbb\xfb\xfb]\xb1\x1c\xdc\xc1#*Zh\x05m\xbdg\xc0\xff\x91\x97\xab|\x99\xb5\xacCZT\x04\xc5\x85\xaa!\x0d\xdd\xe5\xe5\xb2\xd8\xaf&K\xc2L>\xa5\x83\xba&oL\x00\xa7\x83\x1dX>t\x0f(\x1f\x93\xc1\xe5\xd3y3y[\x93*\x88Ut\xcd\x1a\x85p\x8b\xee\xd5\xf7G\xde\xe5NUo\xca7eUO\xf6\xafuo\x1c?BFf\xee\x8b=\x94\xf3\xb6 }\x1b^m\xcdnX=r\xeaz\xad\xea\xea\xe9+\xcd\x07D\x8a\x9a\x99\xfb\xc8\xc8\x0f\x7f\x06+\x05\xe6W\xd5+V?T\x08\xec\xc2\x13\xcf\xc2\x94'~\x95\xc2\n\x7fS:\x0f\x16\xf1 #\xbbB\xcbO\x8c\xa8M\x90\xb5\x90\xc1&\xbfa%H\xd76%\n\x93\xcf':J\xa4E\xa1\xad\xfd\x02\x94\n\xd2\xa2pX( \xc4\xe9\xcc\x8c\x0486\xc6R\x93A\xc0O\x08\x81\x08R\x88\xbb\x02\xa4E\x11K\x14\x81`\xb2\x88\xd3\x15iQ\x90\x16E,\xa1\x04\xe2H%\x90\x8aX\x02Q\xe4\x12ww -\x8a0\xb2 \x04\x12N \x8et\xe2\x1b\x82q\xc4\x13HK>\x81\x00\x02\n\x84\x93P \x82\x88\x82\x182I\x8bBZ0I\xc5\xe9\x8d\xb4(H\x8bbbi\xc8,\x80\xe7d\x00\x86\xd4\x02a\xc4\x16\xf0!\xd1\x91\x04\x17@\xf8%-\n\x87E\x11`\x80\xb4(\x94E\x91c \x88 \x03\xa4E\x81!\xce\xc01\xc83\x80)#iQ\xa4%\xd6\x80\x97\\\x03\xb1\x04\x1b\xab7\xd2\xa2\xc0\x11r\xac\xdeH\x8b\x02I\xd4\x81`\xb2\x0e\x90\x16\x85\xd1b\x88\x0d\xfa\xc9\x07}\xe7\x98/\x02\xd0\xd8G\xf2\x0b\xf1{7n\xcb\xcb\xbb\x1c\xa1\x81G\xd8V\xab}\xc1\xcc#\xf7\xe0:\xe9\xf0\x89\xae\xde#\x1d\xb3\x87a\x19\xda\x98\x9f%\x831|\xd9}{\xd21\x1a\x87\xa57ggrw\xa5\x9ep\xd9fw\xf6\xbe\xe6\xe8\x0dWY\xc3\x16\x9d\x90\x9e\x8b\xbe\xe0sT\x95\xfb&\x89\xa7\xd1\xcc\xb6`evU0\xa7\xa7CVko6\x8a/x\xbf\xb2D\xa7\x91m\x145\xcf\xa9\x99Mu\x93\x0f\x17\xaf'\xfehV\xa3Y\xed\xc1g\xb5\xb8\xe5\x7f\xbf\x8b`B\xab\x04\xcd;o\x9a\xbc*\x1d\x0b\xff\xeeC\xfeuwu7wd\xcb\xe5~\xbb/\x84\x94D\xefLt\xa4\xcc\xc3v3\xb8U\x97=\xda\x19\xa4\xaf\xa1g\x16\x19\x84b8\x93\xc8?\xe7J\x03\xaa\xdfl\xac\xd9\x92\xe57\xcc\xc0\xac\x999\xa3\xd8\n\x0b\x9e\x8e\x05>\x02\x9b\xa7\x83\x81\xb7t\xd2\xbc\xd45D_\xf1\xa1p\x80s\xe3\xdf\xa8\x93\x16\x8c\xc89*\x8f\xa5\xabE!sVoH\xaaZ\x18Bg\x93\x81\x15\xc3\x94\xa1\xab\xa3&b\x93\xaf3\xd3p\xd4\x7fkv\xb7\xd0\xa4<\xfe\x8d&\xe5#L\xca\xaeO\xcd\xdf\x07$\xe5Y`T\xfb\xb6i3\x91\xf7\xb6\xf0\x93\xee\xbb\xae\xfd\xbe\xbfmJ\x96\xd1(\xbf\xd8\\<\x08\x8e{\xa5q\xe8\xf6\x89\x8e\xd3#]qx\xb82Q\x0b\x03\xabO\xa0U\xc1\xd4hU0\xb1\xb0U\x01\xa0B\xe8\xea\xf6\x03\xf2\xfa`,18y\xbe/_\xe8\xfd\x86\xf2+\xdd\xc8M\x15\x99|\x9c@.\x96\x01e\x93\xdf0\x99\xdf\x9b-?\x9fH\xb5\xd3\x06\x1a\x11>h\xb227\x1e\x1b\xb9\xbcf\xcb\xcf\xe1){\x8e*{WF\x13\x7f\x06\xb5\xde\xc9B\xc9\x10V\xda\x9c\x97F+&Z1=\xae\x15SSd\xcd5C\xad\x92.\xe5\xa5\xdd\xd2H\xdc\n\xecF\x8e\x96k\xfc\x0e\x8cr\xf4D\x87\xe0\x91.\x86Th\x1eG\xe7\xea_\xdd\x8e\xd5y\xe5\xc9\x14Du\x13\xc7\x11#k!3o\xdb\xca\xf1>\xc5?\x07\xc3\xa45\xbc\xe5\xadh8\xfb\x0eg\xccAC\xb3\xc8I\xaa\x93<\xf2F,?\xf2\xa5\x90~i\xaf\x95xL\xd3V\xb58 \xc6r\xb78\x1e!o\x84.\xb7\x16\x1c/\x96b\x9b\x11\xb2\x1d\x7f3u.\xfe\xbd\xd5r(M+\xd4\xb3\x8d\xde\xc4J\xcc\xb8\x12\x90k\x81\x9e\"\xacE\xf0\xb3\x9au\xd8E\xa9\x84 3U\xebk\x8b\xac|\xb5\x14\xb2\xdb\xbe\xec8\xd5\x86\xc7yI\xeao\xb8M\xc19\xe7\x0eI8k\xa0\x083Za$\xdd~\xa4s\x87\xe8\xdc\xa1\xa8s\x87<[\x88j\xae\xf2\xae\x92\xfd\xfb\x87z\xfa\xa4\xb5\xb04Z\x0b\xd3Z8z-\xdc\x97\xbci\xb3Z\x1c\x1bx \xd5\xe8Z\x85L\xee\x1aUB\x1f\"\xd3]\xa4T \xfb\xbaL\xfb\xba\x9aQ\xa7\xf5\x0b\x15\xd9:x\xa1\x1e\x019)\xf0u\x84\x8a+\xe5\xb0GZmR\xc8\x0c\x0b#)d\x1e1\xb8\xfe6J\n\x99)\xa2H\n\x99\xa4\x90)\xec\xb7\xa6\x909\xa5\xd8\xb2\x9b|\xc5\xca%\xeb6\xf0\xf4\x1f\xec;t\xaf\x8a\xe2\xad\xba\xa8gJ\x15\x05\xe8;\x8d\xbbq\x83\x9b\x9e\xe8\x1a>\xd2\x8d\xb8q\x04\x86\xf6w\xb9\xb4\xc7\xed\x8f\x01\x9d$J'\x89Z\xaf\xa4\x93D\x85\xd1I\xa2\x87F'\x89\xd2I\xa26\xa3\x93D\xe9$Qat\x92\xa8\xbdM\xd3I\xa2\xd2\xe8$Q:I\x94N\x12\x15F'\x89\n\xa3\x93D\x85\xd1I\xa2\xd2\xe8$Q:I\x94N\x12\xa5\x93D\xa7\x86=\xd5\x91N\x12\x15F'\x89\xfeVN\x12\xedm\xf4\x85\xa8\xf1\x0b\x85G\x8d\xc1\x99\x83\xefk\"\\\n#\xc2\xe5o\x94pi\xceP\x1a\xc0\x91\xf1\\\xcb!\x10\xfa\xe1\xe2\xf5\xb4\x12\xc4\xba$\xd6\xa5o_\x12\xb3\xb5\x07\x04\xcd\x124k\xbd\x92\xa0Ya\x04\xcd\x1e\x1aA\xb3\x04\xcd\xda\x8c\xa0Y\x82f\x85\x114K\xd0,A\xb3\x04\xcdJ#h\x96\xa0Y\x82f \x9a\xb5\x19A\xb3\x04\xcd\x124K\xd0\xec\xc0R\xc0d\x04\xcd\n#h\xf6\xb7\x02\xcd\xba\xc4\x0f(\xa1<,[\x97\x12\xca\x8f\x18\\\x7f*4%\x94\xa7\x88\"%\x94SB\xb9\xb0\xdfjB\xf93oF\xf9\xd9\xaf\xfa_\x8b\xeb\xac\xb9v\x9d&\x7f\x90_\xdeq\x9a\x04B\x03U\xd9\xff\x85\xfb2\xa6\x9c\xffV\xf2\xcd\xa3\xf8R\xad\x93\x9b\xe0\xdd\x96\xc7\xeck'g%\xe08 1\x8c\x047\xf3 \x8aw \x1eaq\xe8e\x1d$\xe0\x1cD2\x0e\xac8-\x8eo0\x8bm\x10\xc55\x80\xac0\x1f\xf7\x0fX\xa6A\x0c\xcf\xc0\x85\xfe\xa1X\x06\x899\x06(\x86AB~\x81\x97]\x90\x88[0\x87Y\x10\xcc+H\xc0*H\xcc)\xf00\n\x92\xf3 \x8e\xc3&H\xce%\xc03 \xe2x\x04\x8e\xa0\xfbX\x04\xc98\x048\x06\x81a\x0b\xc3>\xbe&f\x0f\xf8\xb8\x033\x99\x03\x0e\xde\x80wy\xe2\xe5\x0c\xe0\xd6/i\xf9\x02>\xb6\x80\xbfLqL\x01=\xb2\x1b\x1c\xfax\x02 Y\x0238\x02ff\x8f\x8b!\x90\x96\x1f\xe0f\x07\xa4\xe0\x06\xa0\xc0m\x0f/\x00\xcd\n\xb0\x03x\xe1\x8c\x00\xbb/\xe3fy\x12.@H\xb0\xb0<\x00\x7fL\xd0\x1c\x80\x08\x06\x80\x19XH\x84\xfe\xa3\xb0\x7f?\xf2\x8f\xc1\xfd\x9dQ\x0c\xc5\xfc\xb1\x88\xbf\x0d\xefO\x80\xf6\x07`\xfd\xf1H\xbf\x03O\xc7\xa2\xfc\x891~G\x89\x8c-5\n\xdd\xd7\x9b\xb2\x06\x7f\x16l?1\xb2o\xc7\xf5cQ}\xb1#`*\xb8\x19\xd3O\x8b\xe8\xdb>\xfc\xbch\xbe\x0dn\xb4!\xf9iq\xfcx\x14\xdf\x82\xd8G\xe1\xf5^l>\x0c\x99G\xe3\xf2\x81\xa8|\x08&oE\xe4\xed\xa5\xc1\"\xa384>\x10\x8b\x0f@\xe2\x8dUK\x8b\xc2\xdb:\xc5\x0c\x04\xde\xb8Oa\xc5\xdf\xe3\xd0w\x17\xd2\x9e\x1eg\x9f\xdf\x92\xd0\x18;\x16a\x1fO\x91\x88D\xcf\xa0,O\x95\xd79\x01\x0e\xb4\xd1I\x1a\xd2(\xa7\x93r:{\xa3\x9cN\xca\xe9\xec-\x06k\xb1:\xa3\x9c\xceCK\x84\xbb\xccC^\"\xb0\x97$\xe8Kr\xfc\xc5\x8b\xc0\x1c\x01\x839\x16\ns\x04\x1c&\x04\x89\x89\xc5b\x9cc\xb8\x0f\x8dI\x88\xc7`\x11\x99@L&9*\xe3\xc7ef#3\x94\xd3\xe9-Y\x1cRctE9\x9d1\x98\x8d\x0f\xb5I\x83\xdb \xc1\x08/v\x13\x80\xdexs\xeb\x02\x11\x1c\xca\xe9\xa4\x9cN\x0c\xb6\xe3\x8dj(\xbe\x83Gx(\xa7sb\x89\xf1\x1e\xca\xe9\x1cZ,\xfactF9\x9d\x01X\xd0\x1c4\xc8\xe8\x8er:\x8d7\xa0\xf0#\xca\xe9L\x87&QN\xe7l\xac)M\x9bC\xe3Mx\xc4 \x97\xd39\xcal\x19x2\n\xf3\x8a\x8bF\"\xba\xe2\x0fj4\xac\xa5<*[\x1d\x1c\xa8\x08\x90\xe0 k\xe3\xc7\xb97\xa9gS\xddt\xf9<\"\x0e\xcd\xd9\xaf\xf2\xbf\x0b\xfe\x14W.\xcf\x85\xb8ltRd\x1fI]\xe9Mu\x03\xdbj\xb5/\xcc\xa7G\xfeP\xddH7Ot\x95\x1fi.\xcfM%N\xbb\x96\xa19\\\x1b\x8f\xca4\xbav\xa2\xa9\xdc\xc5\xa7f\x85\xf8 n+u\xfd\xe1\xbb\x13\xe5\x96\x8f\x12\xc5~\xc5C\xc6W \xbcc\xf6\x1d\x12\xf8k\xecjd\xfb*=/\xf36\xcf\n\xb5\x0f\x0dS\x96Ag\xdb\xaal\xaf\x0f\xf6\xb0\xdb\xac(\xeeq\xe3\xca\xf0R\xc4\xa8\".O:\xa6\xfcu_\xd5{K\x7f\xf5\xbe\x1c\xef6;\xf2\xed\xa9V\xb7c\xf5\x92\xafI7r;Y\xa4m7m\xf6\x99 $\xaa\x9b\x84$]\xc6\x86\x0d\xaa,t\x81Z\xd9^\xdb\xb2*\x9b|\xc5x\x07\x11\x9b\xfa\xa6f\xd0^\xd7\xac\xe1\xed\xe7\x91\xc4\x86\xb7\xd8Z\x7f\xb5\xfe\x895\"\x12\x8dL\x89\x1f\xf4\xcf]\xd6X0\x15\x807j\x1fD\xb5\xea\x7f>\xfd\xff\x8cy1\xac\xad\x16\x8f\xac\xf6\xf2\x1b\xbfZ\xc3\xcfL\xb5\x01\xd1\xa7?\x8a&\"\xffW,\xd6\x1cp\xfe0H\xf6\x96\xc1+\xcfV\xa7\xd3P}}\xf6/\xe3P!\x98_r\xc1\x18\xc2\xfbR+\xd5\x0f\x17\xaf'\xfe\x88\xf5E\xac\xafT\x8b\x1db}\x11\xeb\xcbl\xc4\xfa\x12F\xac\xafC#\xd6\x17\xb1\xbelF\xac/b} #\xd6\x17\xb1\xbe\x88\xf5E\xac/i\xc4\xfa\"\xd6\x17\xb1\xbe\x88\xf5e3b}\x11\xeb\x8bX_\xc4\xfa\x1aX\n\x06\x0e\xb1\xbe\x84\x11\xeb\xeb\xf7\xc0\xfa\x1a0\xa0\x06~\\_\x92\x83;:\xb8Y\xbe\xb6\x01\xe0\xdcV\xea\x84\xf0uU\x9fhEz)\x1e?r\xf6T\xd2\x00\x9e\x9e\x8c\xc3\xfbT\xa0\xd4\xfc\x07\xfe\xa1\xf5T\x01\xefO\x13\xb2\xc8lt1#[L\xe1~\xea\x06#CL_2&\x89u\x7f\xed4\x9f7\xf9\x0d+\xa1i\xb3v\xdf\x18yb\x9d\xa7'\xbaR\x8f\x94'6\x89\xca\xd0\xda/\x80\x7f\xe9\xe2,r\x0b\xe0\x1c\xb4\xff\xe38c^ \x02vb\x91\xa7\x1a\x80\xa8\n \xe0<\xc0\xd5\x07\x90\xdbB\xdaB\xa1=\xa73\xf3\xfe\x8e\xe3s'5\xc4\x07~\x98\x0f\"\xa0>w\x05\xb4\xb06\x06\xee\x83T\x90\x1fD\xc2~N\x87<\xb8h\xe8\x0f\xe6\xc3\x7f\x10\x0c\x01:]\xf5\xe2\xdbx\x18\x10RC\x81\x10\x08\x07B($\xe8n\xd9\x1d\\\x88\x85\x05!54\x088x\x10RB\x840\x1b&\x848\xa8\x10R\xc1\x85\x10\x05\x19\xba\xbb\x83^\x82\xf8\xfa\xcdQ\xa0C8\"|\x08\xc7\x81\x10!\x10F\x848(\xd17\x04\xe3\xe0DH\x0b)B\x00\xac\x08\xe1\xd0\"D\xc0\x8b\x88!\xf3+\x04\xc4\x08)`F\xf0A\x8d\x80_\x9e! G\x08\\\xc5\x05C\x8fNo\x02\x96D\xc0\x8f\x10P\xca\x840$\x04A\x91\x90\x1a\x8e\x84HH\xd2\xdd\xae\x1a?, \xf1\xd0\xa4\xd5\x1f\x7f\xa2\x0f\x9e\x84d\x10%\xe0\x916\xc0@\x95\x10\x06W\x82\x0f_\x88\x84-\x01\xe1\xd7\xb1\x85\x99\x08\xc2\x84\xa8\xe0\xe2\xa1L@\xd42\x02\xd2\x84XX\x13\xdcQM\x07o\x02\x1e\xe2\x04$\xcc h\xa8\x13pQ\x0f\x87\xc8\x16\xdc\xb0\xad\xf5\x9eX8\x17\x12\xb6\xdd\x00X\x17\x82\xa0]8\x10\x92\xd7&\xa1\xc5\x19\x10\x18+m\xc9\xbc \x90\xd2\x8b\x0f\xef/\xde_\xbe\xfaqq\xf9\xf1\xd5\xc7O\x97\x8bO\xef./\xde\xbe>\xff\xfe\xfc\xed\x9b\x80\xbb\xde\xbc\xbdx\x7fy\xfeqq\xf1\xf6\xc3\xf9\xfb\x90\x1b\x7f~\xff\xf1\xfc\xdd\x0f\xe1\xf7]\xbc\xba\xbc\x0c*\xe1\x87\xb7\xff\xf1\xf6\xf5\xc7\xa0[\xbe\x7fu\xfe\xa3\xf5\x06\x9dq\x19\x11@\xec\xae\x8a\xc6\x8e/E\x1b\x10oR|\xfb\xcb\xce\xa9\xf6\x82\xc4oL0\x94\xedCO\x9f\xddno\x82\xce\xa6\xe0\xac\xe6(M]\xaf \xc5#w\x8dL\xd8\x1e\xa0\xe3\xa8'\x8f\x9b\xd3\xe1\xc3\xc7\xbf\x0f\x94\x1a\xba\x9c^\xf9PX\xed\xc54(\x0b&X\x07\xf6\x18Y\xa5\x0b\x94y\x1a\xefa)G?\xe3\n)\xf9\x13)\xcb(;\xcaa\xe1\xe4\xdf\x1d\xa5\xe2\x0dj\x90#\xcd\xe7\xa1k\x070\xb4\xcb\x9a\x86\x85\x15Mw\xc9\xc3\xc2\xe9_\xd2\x15\xef\x8a\xb1\x12j\xf6\x17\x91\x00\x1dTJ9\n\x1c\x96Q\xfe=] \xd7Y^\xd8\x8a\xb6\xce\xcb\xacXHi\x08 \x0e\x1d\x99\xaf\xf0\xec\x9e5\xcff\xef\x86gW\x0d_q\xcf\xf6\xf3\xac\xac\xe6\x17\xa6\xac\x16\xfc\x0bbq\xc3\xdaj\xa63\xec\x00\xfe\x91\xbf\xb0\x0fR~\xa2o'M\x9b\x95\xab\xac^I\xed\x0e\xa5\xa8\xb2\xa9nX]f\x87g\xbc\xf4\xe6\x96(i\xf6W\xdb\xbc]\xb4\xf96E\xc2\xd4*k\xd9\x0b\xee\xcbx\x9d\xd6qa\xe5\xeaa\x1e(\x94?\xdcJGn\x9a\x924\xa7\xda\x11\xaa\xef\xe0z\x0fB\xf3\x08\x15\x1c@\xe9\x1e!]a\x1bm\xb0\xfa\x91\xb7\xf0n\xe80\xad2\x12Z\x1b)V\x1dI \x945mV?PoSO|\xa0\xce\x86i&za:Z\xf8-\xab\x9a\xa9w\xb7\xe5_\xa6\xb5\x9a\x01=#\x9bmT\xdbe\x1b\xd5\xcc\x0e+<*c\x7f\xe1D.\xa9\xfb\xb3\xda\xc73\x91'\xa59;\xbe\xbb\xc3\x97\xec\xae]|f\xf7\xe6\xb7\xe2}'^\xb4\xb8\xcd\xdb\x82\xbd\x84\xff\xb1\xf5W\xfd|\xad&\xc3\xff\xa9\xa8\x16bA\xc6\xff\xe7\"\xdb\xb0\x0fR\xc3\xf1T\xfenq&9\xbe\xdc\x0dw\xcbC\xc8`[5-0AX\x10L\x07\xc3\xadbt\x9e\x19\x00\x07CS\x85\xc0:dIY(^\x7f\xf1\x8fr\xcf\x1b\x1fo{:\xf3~\x90\xe6m\xc3J\x87!Z\xf2Qh!\x9c\xd9\x86\x8f\xdb\xac\x81\x86\xb5'\x90\xb7\x8df\x085\xb0/e\x03\\I\x12\xc4m\xde\x8c\xdf)F\"H\xb3pQ*A&\x0fg=w\xf9\xc3\xc5\xebi\x05H7\x88t\x83|\xb3\x04f\x06\x80\x08r\xb1l\xba\xa4\x1b\x84 \x12'!\x11\xc7\x10\x88I7(!Y8\x84(\x1cD\x12&\xdd\xa0\xb9\x84\xe0\x082p\x12\"p8 \x98t\x83\xe6\x90~C\x08\xbf\x11d_\xd2\x0d\"\xdd \xd2\x0d\xc2\x92u\x93\x12ucH\xba\xa4\x1bd\xbb\xccK\xc6\x0d \xe2bTqB\x08\xb8\xa4\x1bD\xbaA\x182-\xe9\x06 \x9bC\x98%\xdd \x93'/)6\x96\x10k\x9d\x1bH7\xe8\xd0H7(\x82\xc8\xea'\xb1\x86\x12X\x03\xc8\xab\xc1\xc4\xd50\xd2*\xe9\x06\x85\x11SI7\xa83\xd2\x0dR\xd6\xe9\x06i\xb9\x15\xc9]\x1a\xf8\x1a}MN`\xc8\xc9]#\xfc\xb5'A 4V\x83R\xd3u\xd2\xc3\xb2\x0e\xbf\x1c\xd3\xd0\xc8\xdc\xfbB\x8cBdY\x8e\xc9\x1c4\xb2\x05\x1f\x9e!\xe8b\x05>,\x13\xf0\x90\xfd\x97\x97/% ?\xf8[/\x89\xb5\xce\x8a\xc6\xa3\x89\x05F\xf67\x9e\xf1\xed\xeb,\x9e\x8b\xed\xccn\x14\x9b\x1b\xc9\xe0F\xb0\xb6\x83\x98\xdaz@\xbc\xa9\xda\xd1~\xd7h\x18\x14?\x8e\xc6\x1f\xf9\x97l\xb5\xaaY\xd3hx~8\xea\xf5\x9e\x12\xbcW]H5\xd0T\xd6\x82v\x17L\x06Ky\xf0\x99*.k`]W\xdb\x07)q\xcf\xca9\xfd\xcc\xeem\xc5\x9eL3\x8a\xde\x92\xa9\xa5z\xcd\xda}]\n\xf0B\xf16\x14\xaf\xa7\xe3\xc2\x08\xc8a3\xd9\x9b\x175\xd0\xa3\xa2\x9d\xdfr\n\xef\xf9\x87\x95\x14\xb7\x83j\xbdnX\x0bU\x0d\xe3\xe2\xc2\x002mX\x9b8Z\x96\x0dhC\x10e\xf9lq\x9cl\xfe\xaa\xca\x88P\x8a\\\x82|\xa9\xff&\xc6$\xa5\xeb'w\xdf\xafY\xa9\x03\xbf/;\xc0c2}\x9f\x0bo\x05o\xf3]\x08%D\xb0ox\xa8?\xb3\xc0x\x8e\xdd\x1f9\xb8\x13\xce\x91!\xbcE\xbe\xcd\xb1\xd1\x15\xd7j\xba\x8e\x8d\x8a$\xc1\xb0a\x0b\x96\xdf\x9c\xfc\xd7\x91\xb7\x9d\xdc\xfa\x1e\xfe\xe9|\x0d\x05[\xb7\ne\xc9[\xb9\xec\xd6+\x1f\x81\xe3\xc9\x0e\"\x1f\xc2\xe3|u\x0f,[^C\xb6\xdb}\xc1(\x0e U\xfd\xfd\xaeX\x0e\xee\xe0\x11\x15-\xb4\x122\x90\xc0\xff\x91\x97\xab|\x99\xb5\xacC\xf4\xf5\x19\x7f\xfcB\xd5\x90\x86\xee\xf2rY\xecW\x93\xad\x87L>\xa5\xa3TL\xde\x98 \xe8\x0c\x90>q\xac\xde\x90S8r\xf6\xe9|\xba\xb2\x9dTA\xec\xd6\xd4\xacQL*\xd1\xbd\xfa\xfe\xc8\xbb\xdc\xa9\xeaM\xf9\xa6\xac\xea N\xaa{\xe3\xf8\x1122s_\xecUU\x15l\xc4\xe2\xed\x06\x9f\xc9/\x86W[\xb3\x1bV\x8f\x9c\xba^\xab\xbaz\xfaJ\xf3\x01U\xaff\xe6>2\xf2\xc3\x9f\xc1J\xc1-\xa9\xea\x15\xab\x1f*\x04a\x87R\xeb\xa9\xf4\xec\xd7]/f\xe9<\x97Z\xaf\x10\xb5\xe8\xe8\xae\xe7\xd9\n\x8aY/\xfa\xa5/=\x7f\xa3\xebnT\x1d}\xa2\xeb\xff\xc8EGm\xdc\xb9(J\xee \xda\xc7\"\xa5:EC\x9dE\x07o\xf1\x01\xc1\xe2C\xd4\x01\x90H\xb0\xb4(.\x9f\xc3_\x90LhR>\x9f\x97\xd1\x97\x9a\xd3\x87g\xf5%\xe2\xf5\xc51\xfb\x1c\xee\x02\x85Ag\xb2\xfbR\xf3\xfb\x02\x19~\x899~a,\xbf@\x9e\x9f\xab\x0dGH\x81&\xe5\xfa\xa1\xd8~ \xf9~s\x19\x7fQ\x9c\xbfD\xac\xbf\x18\xde\x9f\xc3\x19Z\xfa\xf3\x08\xdc\xbf\xe3\xb1\xff\x8e\xc2\xff\x0bc\x00&\xe7\x00bY\x80Iy\x80x&`0\x170\x9c\x0d\xe8\x1d\nq\"\x9f\xb3\x19\x81^\x81O\xd4\x82\n\xc1\x0b\x0cYu\x05s\x03]\x93 Z\xd6\x13W\xbe\x84\x0c\xc1\x10\x8e`b\x96`\x1cO\xd0\xd5\x82PR\x9e\x91\\A\x8b\xb7\x16%\xe3\x99\x86/\x88&\xbd!8\x83A\xacA\x9f\n^\x0cs\xd0\xe7\xd3\xca H\xc4\x1f\x0c\x0f&\x9eC\xe8\xab[\x04\x8f0\x92I\xe8bb$c\x13\xa2\xf9\x848F!\x96S\x88\x88r8\xaf0\x84Y\xe8\x16\xe6L\xc2.\x0c\xe4\x17\xcec\x18\xfa\x02\x1a\xc02<\x02\xcf\xd0[:kKO\xc76D\xf0\x0d\xe3\x19\x87\x16w\xadW\x803)\xeb\xd0\xc7;\x8cd\x1eZ|\xf9\x857\x11\xecC\xb7\xe8\xa6Kr35\x0719\x0b\xd1\xceCL\xc9D\xc4p\x11\xc3\xd9\x88A|\xc4\x08Fb('\xd1#\xa3\xe9.\x1d\x96%\x86e&Fp\x13\x03\xd9\x89\x8e\xea\xc60\x14-\xae\x10\xc2\x991,EG\x93\xf7\x8bf&d*z\x053\x8f\xc1VL\xd5\x16\x03\x18\x8b!\x9cE\xb3\x1c\xa6K\x0c\xd3\xfb\xfd\xee\x12\xc2\xc4\x93\xa2\\\xf7\xa0D0C\x88R\xae\xbb\x9c\x02\x98H\xf2\x94\xeb\x06\x87\xf8e\x10\xa1j|#f\xe7!\x95\xece\xaf,dkf\x0fK>u=\xf7\xa1h\xa8\xbdy\xa4$\xbf\x105\xb5\xb7\xe0\xf2\x1d\x93\xae\xda\x9bG\xe6\xf2\xe1)\xac\xbd\xe1$.\x1f\x96\xd6\xda\x9b]\xde\x12+n\xd9\xce\xc7\xd5=\xb2\x96\xde9\x04!i\x89\xf0\xe1\x96\xb3D8\xc0IYz\x1d\xe1\x86\xe3\x94\"\x96\xfd\x90|\xf8\x9bW\xc0\xd2[\x1f\x9c\xbc\x1dF\xba2\xc9\xa3\x10\xa2\x95\xadC!\n|\x82\x95\xde\xfe\x80\xe9\x11\x08\xa9Jo0\x00%S\x89p\x83k\x90\xc1\x02\x95\x08\x19\xca\xb4\"\x94H \xca\x18\x01J\xa4\xfc\xa47\xd8\x98\x06\x8c\x12\x9eL\xf0$\xffkO'8i\x1e\x81\x02\x94\xf9P\xc2|\x13)\xbe\x89\xbf\x0f\x17\xafI\x88\x8f\x84\xf8\x92\x0d\x87Q\xe4=\x12\xe2\xc3P\xf6\x92\x10\xf6b\xe8z$\xc4\x97\x90\xa4\x17B\xd1\x0b\"\xe8\x91\x10\xdf\\Z^\x04)/ %/\x9c\x90GB|s\x88x!4\xbc\xc4$<\x1c\x05/!\x01\x0fK\xbf3\xec\xac\x93\x10\xdf\xd8\x10\x84;\xec*)\x98lGB|(\x8a]\x0c\xc1\x8e\x84\xf8l\x97yIu\x01\x94:\x8c\xcc\\\x08\x9d\x8e\x84\xf8H\x88\x0fC\x9a#!>ashr$\xc4g\xf2\xe4%\xc6\xc5\xd2\xe2\xacs\x03 \xf1\x1d\x1a \xf1E\xd0\xdf\xfc\xe4\xb7P\xea[\x00\xf1-\x98\xf6\x16Fz#!\xbe0\x9a\x1b \xf1uv\x0cj[\x8a6\x17@k\xc3\x93\xda\x82\x84\xf8\xf2\xe1\xc8=>\xf0\xac\xbfd\x84\x87\xc9\xdd~\xc8WS\xd1\xbd\xe1\x88\x94\x8b\x13\xd3F\xc3`\xaf\x8e\xd1\xd6\xfbX\xe1\x97\x14\xd2\x18g\n+o\x1c\x1a\x19o\xd4%\x9dFF&4p\xd4\x1f\x05\xfe\xd7\xe4\xe5\xa68\xac\xfdH C\xbby\xa2C\xf0H\x052t\xcd\x1e\x07\xa6\xe5U\xd6\x08\xda\xd3q\x1c\xf9\xd6\xe9\x96E?\xc6\xcdGp\x05O\x1a\x1d\x15\x8a\xd8R\x0bfbx\x0b\xff\x1b:*\x14\x13D5\x0c\xf5\x11\xd4\\\x15\xdd\x03\xe4s\xf8\x9f\x97R\xadJK\x0cZ\xcep\x14W\xb6\xf9\x8deuo\xe3_\xd1a\x9b\xc2\xe8\xb0\xcd\xdf\xd5a\x9bz\x11\x10B\xe9\x99,\x1c\xb4\x11\xa5G\x1aQz\x88\xd2\xd3\x1bQz\x88\xd2\xd3\x1bQzZ\xa2\xf4\x98\x8d(=\xda\x88\xd2C\x94\x1e\xa2\xf4 WID\xe9\xe9\x8c(=C#J\x0fQz\x0cF\x94\x1e\xe35D\xe9!J\x8f\xc5\x88\xd2C\x94\x1e\xa2\xf4\x10\xa5g`)\xe8\x15D\xe9\x11F\x94\x1e\xa2\xf4<^J\x0f\x9d\xda\x16{$\x16\x9d\xdav\xc4\xe0\xfa\xdb(\x9d\xda\x96\"\x8atj\x1b\x9d\xda&\x8cNm\x1bPS\xcf~\xed\xb8\x89\xae\xa3\xdc\x06!\xd4\x1c/MXU\xf4T}\x08k^\xcaR\xf3\xe6)\x0fv\xd1\xcf=\x7f\xd3\xafQ\xd4\xd5\xafV\xab\xda\xc5gU?=v:\xab\x8d\xce\x11E\n\xf3\x92R\xbd\x98\x84\x97\x16\xe5\xa1\xa3z\x1e\xe0\xa2e\xb6\x1e\"* \x80\x19-\x90v\x8a \x97\xa6\xa5\x96\"\x89\xa5\xe1\xb4R\x7f\x80\x12SJ\x9d\x84\xd2h1-U\xc8\x08\xe2\xdd\xc4\x1b\xf1\xee\xa4\x11\xef.\xcd\xc0B\xbc;\xe2\xdd\x99\x8dxw\xc2\x88wwh\xc4\xbb#\xde\x9d\xcd\x88wG\xbc;a\xc4\xbb#\xde\x1d\xf1\xee\x88w'\x8dxw\xc4\xbb#\xde\x1d\xf1\xeelF\xbc;\xe2\xdd\x11\xef\x8exw\x03K\xc1\x81\"\xde\x9d0\xe2\xdd\x11\xef\xee\xef\x81w\xd7\xe1\xce\xb6\xf2w\x17L\xce#\x94\x10\xa0\x02\xf6X\x03\xeb\xba\xda\x8e\xea\xd1$\xacH\x12~\x858F\xccA\xa8\x18\x9eB\xa6\x99\x14b\xaa\x10[\xe8\xe3\x93\xe8n\xaa\x96\x19Y\x12\x03'Ot=\x1f)SB\xd4+)O\xc2q\xf6\x9dg\xf7\xc8y\xe6\x9d\xe7^\xfbYw\x9e\x1b\xfdg\xdc9\x1d\xf87\x8cR\x9dk\x17\x0d\x82\x0f\n\x10\x02\x84\x7f4@$\x04\x83K#\x18\x9c`\xf0\xde\x08\x06'\x18\xbc7\x82\xc1[\x82\xc1\xcdF0\xb86\x82\xc1 \x06'\x18\x1c\xb9J\"\x18\xbc3\x82\xc1\x87F08\xc1\xe0\x06#\x18\xdcx\x0d\xc1\xe0\x04\x83[\x8c`p\x82\xc1 \x06'\x18|`) I\x82\xc1\x85\x11\x0cN0\xf8\xe3\x85\xc1\x93\xc0\xca7U\xcb\\\xc7I\xfd\xcc\x7f\xef\x00eq\xb5\x04\x937\xf9\x0d+\x0f\xea;B\x93\xc5\xbdOt\x8d\x1f)\x8e,\xaa\xf48\xf0+o\xa2~\xd0\xfe\x8d\xe3\x0c\x13^\xe7\xf8\x93\xa3\xe4\x06\xbc\xedv\xcc\x0e\x0c\xc84\xec\x9a-\xb3\x96w\x82\x8b\x9a\xad\xf9BM\xc2\x0e\xbf\xc8\x074\xbf@^6-\xcbV\n\xdcZ[\xd7V\xd0\xa9\x86\xf0\x11R5V\xfbh%>\x88Vr\x11\x99\xaf\xe1\x97\x82\x95\xcf\xd53\xbf\x82o\xbf\x85\xaf\x7fQ\x0b\xd4\xacU\x95\xe5\x93\x88\xd5\xdd-\x13\x9bz_\x9f\xc2y Y\xe1\xd8\xf0\x94\xdb\x88\xcb\xaca\xcd\x89\xdal\x15K\x9c\x89\xe2\x8d\xf5\xfe\x9f\xdf\x7f|\xbbx\x7f\xf1\xf1\xfc\xfd\xbb\xc5\xa7w\x97\x17o_\x9f\x7f\x7f\xfe\xf6\x8d\xed\xfb\xc0\xfb&\x01X\xb9w(\x1b\xbc\xb0=\x11y\xc7\x9f\xde^\"\xaf|\xf5\xdd\xe5\xc7W\xe7\xef\x90W\xbf{\x8f\xbep\xf1\xc7\xf3\x8f\x7fX\xfc\xfc\xf6\xa3\xed\x16\xcd\x02\x08\xaa\xaaj-\xee.\xf48NOs\xf7Vi\x88\x86\"\xcd\xdd\\\xa4\x857\x1a\xd3}\xae\xa6c\xba\xde\xd7\x80L\xf78\x9a\x91\xf9roc\x92\x16\xd5\xa4\xfa\x9bq\xe3\xa74>\xc5\xbe\x97C\x14\x13\xdagY\xab\x96&r\xc7\x9d\x8f\xf4\xba\xb5J\xae\x8e\xc7\xa1\x9c\xd6{>\xcf`\x86\xf7\xdci\x7f\xf1\xd6@\x0chEe\xf5\xa2\xda\x0d\x8b\xeb\xd8\xf40=\xeeOo/_N\xff0p\x7f\xaf\x16/q\xceU\xe3zi\xfa\xe3HGD\xf2\xc0f<\xe9\xdd\xfb\x97\x93\xff\x1f\xc5h\x96\xe7\xbe\xf5N\x9f\xd1\xff2~\x9a\x004nX\x8b~\xae\x9c\n\x13\x0c6\xf8^\xf0G\xf1H\xb6\x1a\xf4\x84\xbe\x0e\xfb2\x17\xbc\x05Q|\xde\xfc\xf9?\x1c\xce\x9a]\x91\xb7\xb1\xb8\x12/\xc1\xe0\xd92d\xe5\x88\x1d\xe7\xebM\xaf\xa4\x93eU6y\xa3\x8fk\xedh\x9b\xe7oNd\xd7\xe6\xcb\xb7\x13\xbd\x89f\xaf\x93\xed}\x8d*#\x97\xf4\xfa\xa88\xeeO\xae\x9f\xe4\xd8q\x801\xd2A\x88\xc2\xe8 \xc4\xdf\xd5A\x88\xe2K6\x84\x83*?\x9b?\\\xbc\x9ex#\x0e*qP}\xb3\x1ff\xae\x01\xe2\xa0\x12\x07\xd5z%qP\x85\x11\x07\xf5\xd0\x88\x83J\x1cT\x9b\x11\x07\x958\xa8\xc2\x88\x83J\x1cT\xe2\xa0\x12\x07U\x1aqP\x89\x83J\x1cT\xe2\xa0\xda\x8c8\xa8\xc4A%\x0e*qP\x07\x96\x82\x0fH\x1cTa\xc4A%\x0e\xea\xe3\xe5\xa0\x1aO\xcf\xa2#\x10\xc1\x1fF:\x02\xf1\x88\xc1\xf5\xb7Q:\x021E\x14\xe9\x08D:\x02Q\x18\x1d\x81\xa8s)\xce~\x15\xf4,\xd7\xd9\x87\xcf\x04\xc9k\x98S\xb12\x9crX\xf5\xd9\x15\xe7oN$\xe9K\x1co\xf8L\xf9;\xc8\xb5x\xa2c\xf2\x88S-l,\x8d(\x96\x977a\xc2\x0b5xyN\x8eT \x8fs\x17\xf1\x1a\x03\x11D\xa7H@n\xc3\xa8p \x12I\xd3#\xb0\xc9\x11\xf3R#\x82\x12#\xbc\x8d\xc2\xc5r\x0fe\xb7cY\xed!lv$\x8b=\x90\xbd\x1e\xc1Zw\xa6A\xb4\x9e$\x88\x878\xb9\xd3\x9f\xfc\xe0m\x0c\xd2\xfc\x89\x0f\xa1\x0d\xc3t\x97/\xe9!\xa4\x91\x98\xee\xf0$<\x046\x18i\x11\xcd\xa6\xbf\x153\nJK\x9c\xe8\x10\x9d\xe6\xf0\xa0I\x0eGLqx\xa8\x04\x87c\xa57\xda\x81q\x12\x95\xa1%\x1a\x10\xfbpY\xc6l\xb9_\xc3\xf5\xdd\xf0\xba\xa8\xb3\x96-$\xae=\xef\xc9\xdb\xec.\xdf\xee\xb7z\xb5*]\xf2\xef\xec~(\xe7\xcfr\x16f\x9b\xdd\xa5)D\xc83s\x0b!\x1e\xfd\xcc\xbc\xc4=sSe\xc5\xe2\xaa*W,6=G=\x91;\xe2/y\xc7\xea%\x9f4\xa5O\xc8\xdajk\xfa6\xb8*\xaa\xe5\xe7f\xb1c\xf5\xe2\x9eeq\xd9;\x88\xd4\xa0\xaex\xdd4'\x1f\xcc\x8b \xfc\xc1\xa3{\x10s\xb8\x1cVP\x13\xb8\x9a\xb2\xd5\x98F\x8cU\x9a\xae\x0d\xbf?\xb6\xe9Z\xce5\xe8 {\xf0 \xaf\xda\xb9N\x99\xcczJK7YIz\xb9\x9c\xa9NT~G\xde6\xd0\xec\xaf\x9a]&hf\xfd&\xddgvo\x9c\xdc\xff\x8e&v\xcc\xbc>\x9a\xd6\xb5\xac\x7f\x17\xb1\xa4\xf3\xb9\x0es\xd4`\x1b+\xd4\xefh\xc3\xd6;\xa3\xc6a\x1a\x83i\x0c6\xdf\xfe\xd8\xc6`\x17\\\xa1\xfb\xa8\xad\x01vC\xe5p\xd8\x90#*_Z\xf7\xc7P\xf4\x83\xee\xba\x9a\x9d\xa2?\xa9\xa1.\xacCD\xe63\xbb\x1f\x15\x91\xff\xbfFQ\xba\x92)\x14^\xd7)i)}\x13]Sd\xcdu^n\xd0S\xddd~;\xfc\n\xd3\x1e\xd5\xebP\xf7\x8f\xe6\xaeKu\xc9\xdf\xd1\x1cf\xed\xc7qSP\xbe)\xd9j\xa1V\xff\xb7y\xb9\xaan\x03'\x07m\x83a\xcb\xb8\xf4\xdf\xe6\xe5B=\x8e\x7fe$y\x96\x855\xbb\xaan\xcb6\xdf\xb2\xc5_\xb2\xbcX\xac\x14\xc8\x19\xf5,\xd1\x88\x16k\x91$R\x95\x8bU\xb5\xbf*\x98\xa8G\x94;o\xd1\x0f\x9e'kr\x8c\x87\xf9\xd1\xa7n\xfbGa\xf0\x07\xbd\xac\xe3\x8c_\xc9ANw9\xd3\xeb7\xec\x87\xd8\x8e\xc39\xce\x97]\xf7GZT\x8c\x7f\xa3E\xc5\x11\x16\x15\xc1\xf3\x1d\x1fS\xf2r\xb3\xc8\xcbu\xe5\x98\xf6.\xe5e\xe7\xfc\xaan\xf2S\xf7\nE\x1c\xf1QW\x142 k\xabZ\xcfk\xe3\x99o\xe0F\xfd\xfeh\xe7=^\xab\xc7\xd1\xd0\x14\x8d#\xba\xa54mV\xb7\x8bkgZ\xbc\xd7\x89\x7f\xaa\x05\xc7\xd8\xda\xdb\x1f\xa4\xccL\xd6*\x12T\xd7`\xc4\x99`\x82k&31W\xfc\xcf\x0c\xde\x7f\xe0?X\xdd\xedK>\xdbZ\xd2\xae\xf2r\xc5\xee\x16R\xe2\xeb\xc8\x15\xf7Ok\xd2\xcey\x91T\xd5\xf3\x06\xf2rY\x8b\xfc\x1f>\xe4g\xcbk\xe0\xd3\xae\x98\\\xc6q\xb1g\xfa\xc9\x1dV;m+/!\x93\xdb\x9d\x82)\xb7\xcd\xeee\xaa\x9c\\\x14\x89<\x7f\xb6\xac\xb6\xdb\xbc\x95\xb9\x98\xadL3v\xf9[V\xe5_T\x86\x88\xcc\x87qf~\xfer)\x9e\xf4\x9dX\xec\xfdQ\xac\xbf~\xe96=ZVo\xbb\xaf\x03\xf1\xbaLZc#w?\xe5M\xa3\xdd}\x97\xb7\xafxW\xfc\xc5\xcc\x0e\x95Mc\xb1/\xdb<~\x94\xee\xdf?o\x8f/\xf8\x0b\x9a\xd9\x06>\xe6[\xd6\xb4\xd9v\x07\xa2d\xaa5\x8c_z\xde\xa8\xd2\xc3J\xa8 Z\x9d\x15\xf9\x0d+Y\xd3t\xcbOs(\xdaj{\xd5\xb4Ui\xdb\xe0\xd7\x818\x94a\x1b\x9aM\x95nl\xd88\xfc\xf1\x9a\x89\x9c;\xd9\xeet\x06\x99\xa8\xfeu\xd6\xc0\x15c\xe5\xa0\xdc\xf0\xfcs^\xd8z:\xb7j/\xc56:'\x0dk\xbf\xd2\x8a~\x0ds&\xc1/\xa7\x9dNv \x919\xc6\xbf7o\xaa\xa5\xa2D\x8b/ig\x02\xa9\x12\xc8\xaa\xcau\xbe\xd9\xd7l\x05\xdb\xbc\xb9b\xd7yvc\xcb\x9c\xdd\x8a&\xad\xbf\x87\x84j\xe1\x8cS\xdf\xd3\x0eX\xaf@\x95\x07>\xb3]\xdb\xa7\xd0\xee\xcb\x92\xf1Y8\xab\xef\xe5t\x085\xcbVS\x05\xc6\xa1\xbd\xab\xb4Z\xe4/\x97\xfb\xedsS?\xfe\xea\x17\xc8\x8a\xdb\xec\xbe\xe1A\xcf\n\xfb(4\x1a\x05^\xcb\x02\x1a\x07\x01L5\x7f\xd6o}\xb0<\x19\xea\xa9\xe8\x9f\x9fM\x96<\xb6\xdc\xf8mU\xe6mU+\x9d\xdb\xdc\xc2\xb5\xef:.\xff\xe8\xba\xc9\xdb{\xc3.\xaf\x9cM\xc5\xc3\xd4\x97\x08j\xcd\xa5\xcdu\x04\xec\x8c\xcfw:\xb2\x95\x8el\xc5\x1e\xd9\n\xa8>8\x94\x90\x96\xb5\x1a\xd1\xed\xf3\x126\x1f.^\xf7\x9f\xe1\xea\xdb\xb1\x81\xdbkV\x9b\x1a\x91eE\xb2\xacj\xe9C\xe8v\xd4\xb2\xf2\x1d3\x9eO:boa\x18\x19c8\xf4\x1d\x97\xd5\xb6/\xb73\xc3\xabf;&2g\xbf\xcb\xea\xee%y\xd2E\xc6a\x11-\xd3\x9602NVs\xeep\x0c\xbf\xc1P\xfb\x1c&'g\xa3\x0fB+\x0b\xad\xfb#m~\x8c\x7f\xa3\xcd\x8f#l~8\x13@H\xf4\xde\x0b\x96\x80mr&\xd1\xfb\xb4\xc1\xf5\xcb\xb5\x93\xe8}\x8a(\x92\xe8=\x89\xde\x0b\xfb\xcd\x8b\xde\xbb\xf7\xf5\xcf~]Ve\xb3P\xfb\xc8.\xc1\xfb\xe1\x17\xf0\x10\xe3\x9e~vJ\xd6\xd6Rh|I\xaf\xca\x93m\xbb\xff\x89\x0e\xc8#\xdd\xed\xbf\xc9\x8a\xc50fI?\x98\x9d\x1b\xf8\x9e\xb5\x8e\x7f\xf3\xde\xbbX\xf2o\x07\xf9>7\x93n\xda;\xb6\xec\xfd\x1b\xf6 *\xeb\xff\x1c\x85\xf4\x1b\xf5\xeem\xfa\xc8Mz\xbb<[\xc8\x16}\xd2\x0dz\xfc\xf6\xbc\x7fs\x1e\xfd\xae\xdd\x1b\xf3\xb8\xf7\x9dpS\x1e\xb5%\xef\xdb\x90\xf7o\xc7c6\xe3qu\x8f\xdb\x88\x87jo\x93\x9d\x8d\xd9\x86O\xb9 \x1f\xba\x05\x1f\xb0\x01\x8fn\x94s\x07\xa0T\x1b\xef\xe9\xb6\xdd\x91\x9b\xee\xfe\xea\xa5\xddp\xc7l\xb7\xe37\xdb\x8d\x05\x9e\xae\x0el\xbb\xf1jG\x91\xad\xf8\x1dbydp6^0I\xc3\xee\xd8%\xd9\xb0\xa3\xfd:\xda\xaf3\xfd\xfe\x98\xf6\xeb\x86\x1f,\xb6F8\xbcFw\x08\xfd\xbf\x1d\x0bz\xd2E\x07\xbe\x8e$|\xd2\x7f\x93\xb5B\x9a\xb7\xfb$[\xb1\x82m\xc4\x04\xd6\x9c\xfd\xaa\xfe\xa7\xaaE\x05\\\x9fd\x831\xe1\x8d\xbe\xe9M\xef\xaaO\xb5\x11{2\xfd\xdfE\x96\x8d\xfcN\xeb\x1e\xd6yRa2\xa6\xd6\x98\x9e\xa2\xae{\xb4\x9fo}\xc5\x17\x862j\xfb\x12\x1d\xaf/\x99\xbb\xf3\xcc>Ai\xdc\xa2\x1c|1\xc0uX@M\xe5\xc3k'\xcf\xd7]\xf2\x8a-\xaf\xff\xe5\x9b\x17\xac\xe4\x83\xf2\xaa\xeb\xa1\x8e\x83\x12\xb8\xb5BxN\xb94\xd3&@\x0eKr\xad\xf0\x85j}\xf0\xfc\xf9\xb5\xee\\\xdak\xdd\\g\xb5\xab-\xc4UUzU\x0b\xb1\xe1\x0b\x10\xd2\xd4\xf2\xc7\x9a-Y~\xc3V\xb6\xb2ac\xd7\x8f-S\xa27\xffRV\xdf\xac\xd5gV6p\xcd\n\xa1ii\xe5\x1b\x01dK\xb1VV_\x19\x0e\xa2\xcfm)\xf51\xabr\xd0\xba\x94&\xb9P\xe5\xaf\x96\xb9\x80i\xbb\x8ff\x9b\xab\x9bJj\x10T\xb7r\xdb\xb6*\x1d\x1c8\xcf+\xbd\xca\x8a\xac\xb4e\xe4%\x1c \xac9\xfc\xd2Pm&\xdb\xf2H\xcft\x83m%\xaf\xab|x\x9e\x92h\x10J\x82[VG\xef\x8a\xf3\x17\x98\x95\xaap.\xb5\xf7w\xef?\xbe})t3\xe5\xb5\xddA\x8c\xfc\xf6\xf3Ropu\xba\xec\x8d\xb3\x11(\xdd>\xb5x\xb6w\xd7|Sf\xed^\xf6\x1f\xb9\xc2\xe0\x8dpSm*!\x8a\x17K\\\xea;\xd1\xf0\xbb@|*g\x85@\xc4\xaaaGcwK\xf1%ym9.&o\x07\x8a\xe9\xe6\xda\xa8\x96:\x15)T\x83C\xb7[\xb6\xadj\x06\xcd>o5\x82at\xb6,\x04l\xd7M\xd81\x9f\x92\xa6\x89\xbfo1E1\x19\xc6\x9ag=s\xca\xee\xed\xb0\x9f\xba\x98T\xa3B\x0e\x90\x9a\xb1R\xc7\x00\xc0\x19}\xb9%\xcd\xed%f\x161\xb3\xb0\xcc,\x17\xf1Am\x1a\x98\xbe\x04\xbc\xc9\xd6&Gg\xc6/\x17\x12\xe2\x93F\x1b\x0fiV\x0bt`\x1b\x1d\xd8f6:\xb0M\x18\x1d\xd8vht`\x1b\x1d\xd8f3:\xb0\x8d\x0el\x13F\x07\xb6\xd9\xdb4\x1d\xd8&\x8d\x0el\xa3\x03\xdb\xe8\xc06at`\x9b0:\xb0M\x18\x1d\xd8&\x8d\x0el\xa3\x03\xdb\xe8\xc06:\xb0mj\xd8\xc3\xb3\xe8\xc06at`\xdb\xef\xe1\xc0\xb61\x9bh\xe0j\xf419\xbej\x84\xb8v?\x1dR\x02\x0dR\xa83x\x80\x94c\x1c\x9b\xc0I9\xc6G\x0c\xae?;\x96r\x8cSD\x91r\x8c)\xc7X\xd8o?\xc7\xd8\xccg\xaf\xeaC:\xfbY\xcd\x86\x9c+\xe9\xd6Dn\xff0\xbc\xae\xa3\xb2\x8f\xee\xee\xd3\x8d]\xa4\xf5\x91\xa3':2\x8f\x94\xad>\xac\xdfc\xe3\xab\x0f\xcbvtB\xea\xef\x9b\xb1\xde\xd4\xcb/Tsc\x19t\xed\xfb\xfc\xcba[p\xfaS\x8c\x1b\xd9#\xfb%7&\x08\xab\xa6\xfd\xe2A\x18\x94aF\x10V\xaci\xf5\x0c\x8a\x8f\x04+\xdb\xda\xd9K\xdc\xc3@o\xd6\x01\xa17D\xbf\x95\x86\xe9\xbd\xd2\x965\x93\xc3\x98[^\xb87\xe4\x8b\x94\xe6\xcf\xa5\x1dZ\xc8\xcb\x976)=\x8c\xbe \xd5\xdf\xbaDp\x84\xbfa[\x81\xb6\xaa>\xc3\xae\x98\x1cia\xb2e\xc5\xbf\xfaEA\xec\xb2\xfbC\x8b\n\xa2O\xbe\xb6\xb7\x88@\x8ek0=@\xfdN\xca%\xb8\xb8I\xbd\x8d\x82\xd8;\xf6\x05Q\xf0\x81\xb2b\xe1I\xa6\xe8-(\x88\xe1!\x99\x94g\x14\x12\xf5\x9b\xa6\xd3#\xbc\x89E\xf2(2B\x18\xc4\x9e\x88\xa3MR\xf3\xf9\x10\xf7\xc5#\xd2\x17\xa5\xcb\xd6\xdc\xaa\xaf\x14\xc4\xdd\x83\xe1\xf5\xc5@\\@f\x1e\x88\x8e,\x90\x14\x84\xa7a\x18\xdd\xe1\x0b\xab\xe3p\x0d\xfa\xb6l\xeb\xfbA\xea\xca\xe8\xd5!F`\x90\xc4\x85\x9a\x15\xec&+[\xd8\xb26[em\xe6*\xef\xa8\xb4j^\x91\x1f\x1d\xe2#rP\x00\xf5\xa3\xcd\x19\xb6\xda\x1f\xc6=u\x00\x02\x14y\xd3\xca\x0c\xd4]V\xb7\xf9R \x1867\xdd\xa2\xe9\xd9p\xe9_nD*\x98#\x9bk]W\xdb\xd1\x13\xf4:\xa4o\x1eb\xe3\x00U\x84~\xee\xf6$ky&l\xffd\xed\x99\xa8Q\x934n\x82\x1e}g\xf0r[\x12C\xb4\xa1\x1e\x0d\xe8\xc7\x03\xad\x0f&F\xeb\x03Z\x1fh\xa3\xf5\xc1\xd4h}p\xdc\xf5\x01\xaa\xe5\xa3\xde1\xbe\xde\x07u\xb6g\xaa\xda\xc9\xf1\xa6\xd0\x0d\x92Y!wd\xae\xc0\x80T\x1a\x92\xbe\xeap8LlUI\xac\xae\xe7;\xf2[q\x91\x1cV\xde\x11\xbe\xf1rL\xc6\xc7\xe8O\xc5\xac\xd1K\x19s\xe1\xbbT\xa5\xd9QC\xc7\xcb\x1a)J\xbf\x15F\xe9\xb7\xbf\xd1\xf4\xdb\x83\xea\x08\xf0e\x84i\xc4\xe5\xdd\x8e\xf1\x15\xab\xeeW\xdf\x0b(\xffv\xfc\x1b\xe5\xdf\xfa\x9ajo\x94\x7fK\xf9\xb7f\xa3\xfc[a\x94\x7f{h\x94\x7fK\xf9\xb76\xa3\xfc[\xca\xbf\x15F\xf9\xb7\x94\x7fK\xf9\xb7\x94\x7f+\x8d\xf2o)\xff\x96\xf2o)\xff\xd6f\x94\x7fK\xf9\xb7\x94\x7fk\xee \x94\x7f{`\xd8\\H\xca\xbf\x15F\xf9\xb7\x94\x7f\xfb8\xf3o\x9bz\xb9\x18\xeb\xf1\xdb\xca}x\xe5\xa8\xec=}dP\xf6\x8e\xa1\xc1\x04\xf1pZ\x83\xd0\xb4,K\x1dVM\x8b\xac\xc3\xe1\x95Au\x18\xab\x8e'\xac\x01eAc\xa2EY\xd0\xd2\x8e\x1c\\\x7f\xfe.eA\xa7\x88\"eAS\x16\xb40\xca\x82\x1edA\xef\xcb\xabJ\xd4a1`\xe1\x04\x1e\xf5\xf5I\xfb\xb0\x9d\xf9\xd5=\xe4\xe0\xf4\xaf\xce\x99H\x9f\xee\x1b\xd6\xc1\xd2L\x07\xd7|\x0c\x98\xa9\x04\xea\x86G\x9ba\xddG\xfe\x91\xa5W\x8f\x9b\x88#\xe9\x15\x01Jap\x1d0=\xd3\x9b\xe7\xec\x84\x90;wV\xa8\x0dw\"W\xc2\x1a\x86\x9f\xc2\xe5\xac\xe1o'\x03((\xfd\x06\xf1B\xa4\xe1\xd3n\xb0/P\xda4\xdd&7'\xda\xf4\xbd\xdb\xe3\x0f\x97a\x13\x94]\x13\x1c#\\VM`\x9c&\xd94\xb9!\x91\x06\x1d$\\\x06MP\xf6\x0c:Ha\xd5ve\xcc\xa8\xb3\xe2\xd4%\x0e\x1a\x944>\xcd\xac\xf6\x85d\xd9\xa83\xed\x80\x7f\x1f\xa1\x82\xf1%\x83\xe0\xa8\xfc\xa8* \xde:\xbe`\x86%\xc2$\xc1\xa5\x1c\xacS\xbc\xe9-a\xa9-+W\xda\xabiu\xe4J\x7f\xc5\xd4\xd9P[h\xda\xaaV\x0b2\x91\xf6\xca\xbf\x8d\x0b6Lm5\xba\xea\x8b\xe7\xc8u\x15g\x9dk\x8f\x83\xd3\xe8K\x1eV\xde\xdf_\x88%2[\x89\xb4[\xca\x9d0{\xa0\xdc\x89\xdfS\xee\xc4\xb4\x8f\xe2\xcf0\x9bx3\x90tej\x85\xf3 t\xb6\x992\xca\xadH\xf3\x85C\xb9\x15\x94[a6\xca\xad\x10F\xb9\x15\x87F\xb9\x15\x94[a3\xca\xad\xa0\xdc\na\x94[A\xb9\x15\x94[A\xb9\x15\xd2(\xb7\x82r+(\xb7\x82r+lF\xb9\x15\x94[A\xb9\x15\x94[1\xb0\x14\x0f\x00A+\x15!\xd9\x8ca\xc03\x14\xbb\xf1\xe2\xb7\xe7y\xb9,\xec\xcb\x83\x86\x15\xeb\x17\xbd\xce\x8e\xa5\x11\xf4|\ny\x82\xf0\x03Tm\xfa\xc8\x1e]\x174\x1f\xf5\xc7\xbci\xf6\x12y\xb0OX\x03\xec\xbd\xf7j\xd9B\x1d\x96nv\x05\xba\xeb&L\xd0\xfe\xef-\xab\xb7\x0d\x98O\x83\xed\xcd\xa3m\x97\x0c\xdd\xdfVe\xfe\x99\x19\x04FzC\xbc`\x08\x88\x11\xf4O\x1d\x1c\xac~\xbd\xdff\xe5\x8b\x9ae+\xc1\x06\x13\xeb>_\x8c\x00\x13'P<\x81\xd6\xca\x93\x80\xe3\xd4Q?v(\xae\xa5Q\xd0\xfe\xc7&\xdf\x94Y\xbb\xaf\x19\x9a\x18\x07\x7f\xeeS1\x8e<\xe5\xf5\xcf\\\xd4Y\xeb\x16f\xc5\xbe\x150\xf8\x1dUT)^\x0e.r\xfa\x92\x0e$\xf1\xa0\x03\xcb\xa5\xee\xaa\xf8*FL{\xa8x\x012f\xa0\xca\xe4\xdb\xb8Gt\x08m!\xa1\x05\xf5x\xfd\xe93h6\xe2\xcf\xcb\xeb\xac\xde\x885\xa1\xd7M\xbf\x1a<\x01\x91\x01\xb6\x16$/\xb7\x92(\xc06\xbb[|\xe1\x00\xe8\"\x8c\xda\xd56\xbb\xcb\xb7\xfb\xed4\"^grt\xec{\xfe2+\x81\xdd\xb0Z\x85286\x92\x95\xf2\x18B4(\x891R\xab,\xf7\xea\xce\x8a\x94\x86\x9ae\x0d; \xf3\x0e\"-\x83\xe4u\xe5\x0f\xe2~\xc7g\x07\xaf\xac12p\xd8\x19\x07\x02\x03<(\xa5\xee\x87\x02\x88\x10\x7f0\xf5\xca[\x0f\x19O\xbe\xa9\x959.\xdb\xbc\\\xf0\x0f\xd5\x81&\xff\x8cY\x18[O\xc3S\x0f\xb6[\x9e5\xe2\x0b\x1aVlYd\xd3L\x92\x893\xd1\xe2\xd4\xd5\xda\xa1\xa9\xbe\x98\xf2u\x89\x02\x83\xcf\xa6\xaeP'\xd0V\x1b\xb9\xa1%\xc0\x86V\xa7\xdc\x18]e\xdbAj\x8ey\x03\xf2\xe7Au\xf9B@\x7f}\xab\x14\xfd\xbc\x06v'_\xa0|\xd9b\xe9\x90\x97\x96\xc9\xfb\xb2\xc8\x9ak>u\xe9D\x14\x1b\x858\xe3a\x95=OaX\xa3\xc7\x9cH\xe2\xa1\xe0\xc1Uum\x9b\xd8\x96Y\xb1\xdc\x17\x1dt\xb3\xde\xf3/,\xf3\x03\xf7\xe5\xf0<\x06\x1e\xbbj\xdfB\xde\x8a\x8c\x8dr\x03\xd5\x8d\xf8N\xed\xb6\x10\xe0\x8f\xd7\xac\x94U5W\xa0\x1eo\xc8\x98\x9f:^\x96\x9eL\x86\x98\xbc\xe1s\xfd*o59,\x1b4\x1f\xa3\xbf\xdb\xeb\xaaa}v\x95\xf9\xa1\xc3\xd7\x987#\x1a\xe6\xa0E\x88\xaa\xf5U0zZ\xe5\x1dN+7\xdb\x05\x97\xd0\xfc\xd4\xd1\xfb;\x85\x9f+\x11\xd6]u\xcbj\x9d\x11\xa9_\x17[ \xec\xd5\xdal\xf5~\xab\xa8\x82\xf9i\xdb}\xd1\xe6\xbb\"\x97\x85\x1b?\xfb\xe0\x86Q\xaf\x1b\xe4\xf7\x8cD\xbb\x87o\xa6y&s\x7f\x84v\xb4\xf5\x80\x05\x92r\x16FR\xce\xbfQ)\xe7\x837*\xf2\xf4\x0c mN\x01g\xc3\xd6\x9eTl6%\xe2\x91N\xb34\xd2iN\xb3\xce\x0b\xcd.\x93\xad\x96t\x9a\x11\x99dm\x8a,\xb2\x98\x0c2\xd2iN\x98-\x16\x92)\x16\x94%F:\xcds3\xc2\"\xb2\xc1\x92d\x82\x85g\x81\x91N\xf3\x9c\xac\xaf\x90\x8c\xaf\x88l/\xd2i&\x9df\xcf*)8{\x8bt\x9aQ\x99Z1YZ\xa4\xd3l\xbb\xcc\x9b\x8d\x15\x90\x89\x85Q!\x0e\xc9\xc0\"\x9df\xd2i\xc6dS\x91N\xb3\xb09\x19S\xa4\xd3l\xf2\xe4\xcd\x8a\x8a\xcd\x88\xb2\xce\x0d\xa4\xd3|h\xa4\xd3\x1c\x91\xc9\xe4\xcfb\n\xcd`\n\xc8^\n\xce\\\n\xcbZ\"\x9d\xe6\xb0\xcc$\xd2i\xee\x8ct\x9a\x95\x91N3\xe94\x93Ns\xff\xb7\xe8\xe0\xfa\x15\x86I\xa79E\x14I\xa7\x99t\x9a\x85\x91Nsf\xd2i>\xfb\xb5\xfb\xb7\xfc-V\xb8\xb9\xd3m\x1e\x9e\xc2o\x96l\xee/\xe9\xfc\xed\xb2\xbc\x8b\xe4H\xb9\xf9\xf0A\xea\xaa\xc7\xaf\xd8l#xD\x11\xc7p\xba\xcb^\xa8\x02\xb3\xd7\x9fZq9\\o\x19\xa7\xb6\xec\x8c&x#\n\x08\xf6\x0b\"\xa2\x80\x8e*\xc4r`\x1c\xfe\x82\xf4\x95\x93\xf2`\xbcL\x98\xd4\\\x18<\x1b&\x11\x1f&\x8e\x11\xe3p\x17\xa8\xa8<\x93\x15\x93\x9a\x17\x13\xc8\x8cI\xcc\x8d c\xc7\x04\xf2c\\m\xb8c\xce`\x192\x8992(\x96LB\x9e\xcc\\\xa6L\x14W&\x11[&\x86/\xe3p\x86\xd6L>\x02g\xe6x\xac\x99\xa3\xf0f\xc2\x983\xc9\xb93X\xf6LR\xfe\x0c\x9eA\x13\xcc\xa1 g\xd1x\x87B\x9c:\xf2l&\x8dW\x19\x19\xb5\xa0B\xf0iBV]\xc1\x9c\x1a\xd7$\x88\xd6C\xc6\x95/!\xb3&\x84[\x93\x98]\x13\xc7\xafq\xb5 \x94\x06r$\xc7\xc6\xe2\xadE\xe9\x1f\xa7\xe1\xd9\xa0\xc9\"\x08\xaeM\x10\xdb\xc6'\x1f\x1a\xc3\xb8\xf1\xf9\xb4\"o\x89x7\xe1\xc1\xc4so|u\x8b\xe0\xdfD2p\\\x08f2\x16\x0e\x9a\x87\x83c\xe2`\xb98\x88(\x87\xf3qB\x189nE\xe3$\xac\x9c@^\xce\x85U\x03\xed\xc4@\xe7(\x81\x92\x10\xa82\x12\x02%!\xd0\xdeH\x08\x94\x84@{K\x9a\xec\x10\x92\xea\x10\x94\xe8@B\xa0s\xd3\x1b\"\x92\x1b\x92\xa46\x84'6\x90\x10\xe8\x9c\x84\x86\x90t\x86\xc4\xc9\x0c-*\x95!a\"\x036\x8d\xa1\x0dKb\x08Ma !\xd0\x91\x05'-\x90\x10(*U!&Q\x81\x84@m\x97y\x93\x13\x02R\x1302\x97!i $\x04JB\xa0\x98\xe4\x03\x12\x02\x156'\xdd\x80\x84@M\x9e\xbc \x06\xb1\xe9\x05\xd6\xb9\x81\x84@\x0f\x8d\x84@#\xd2\x08\xfcI\x04\xa1)\x04\x01 \x04\xc1\xe9\x03a\xc9\x03$\x04\x1a\x96.@B\xa0\x9d\x1d#E E\x9b\x0bH\x0f\xc0'\x07\xfcV\x85@\xc7\x8ag\xb62\x8f\xaf\x1a\x95\xb9G;\x8f\\\xe6`\xd1\xb7\xeb\xbci\xab:_f\xc5\"/\xd7\xd5\xd9\xaf\x92\xe1\xe7Ru\xfbCw\xcby\xb9\xae:\x197^\xcf\xde\xdbT\xcbM\xba\xd55\x1d)\xb6\x8d\xfd=\xd1\x95~\xa4jm\xbc\x8a\x87K\xf9QQ\xf8%\xa3\xd7?\x0d\x8b\xd2\x814E\xa67k\xd9\xc0\x0b\xce]\xb3le\xa3\x8a;\xdd\x82\xd757\xb5G\xea`\xe5\xc8\x135\xaf\xb2&_\xc2UQ-?\x8bz\xdb\xaf\xf7\x95 P\xe5\xe2&\x9e\x96\x88B\x858;TZ\xb6\xdb=\xec#1\x1bo\xd2^ke\xdff\xcb\xeb\xbc\xb4\x08\xb1\x08>V^.rKJ\x1b\xe0^\xa9\x8b\xdd\x0d8\x17\x18\x967\xc0\x03r\xe4\xc4\x8aY\xbc@wt\xe4\x08\xb0\xab\xd9\xcd\x03\x0f\x00\xd7Ys\x9d\xb83:E\x85\xc4j\xa7]4\xac]\xb8\x86]m\xa8\x9a\x02\xba\xb6\xdc\x1c\xc7#\x8f.sRU\xa6\x86iv\xda\xfc!\x87\x90\xb0\x03>\xf4]C\xbb\xc8\xea\xb6a\xed\x1f\xc4\x1bp5]A\xcbl\x17\xee\"\xa3\x8a\x8a*\xa2*\x1e\x7f\x1c\x13{\xf4\xb23\xf0a\xcfr\x0f\xff\xe9\x81\x8a\xd7\x8b\xfa>\xd0\x03\xa7\xf1X\xd7\xd5V\x8f\xe3P\xed\xdb\xdd\xbe\xed\xff\xd6\x8f\x1d\x16oBA\xff\xc1\xeb\xd0K\xcd>\xcc\xf3\xb2\xdd\xee\x81\x9e$\xfa\x87\xe2\x02<\xd0#\xd9M\xbeb\xe5\x92=\xd0\xe3\xba\xf6\xd7/\x7f\x1c\xd3\x12\x1f\x81\xab\x86y\x14\x94!Y\xf9F\x8b:9\x92\x8d\xbe\"\xbae\x92\xd8T\x84\x8f\xac\\\xb1z\x9b\x97\xad\x1aT\xe4\xf4cZ\xd1\xdcdE\xc3\x9ciff\xea \xb8\xe8\x83\x80\x9b\xcd0\xf3\x18N\xabZ\x1a*\xd6!+\xe4 \xf5j\xa7\x9f!=>\\\xc3Z\x1aN\xc9Z\x1a\"\xfa\x80|\x03\xa0\xdc\xb9\xb5\xad\xfb\xeb\x10o\x00\x02\xdf\x02D\x10=\xbd\x0e[#\xe2\xef\xfaR\x90\x86&~z=\xf5\xc4P\x1f\x01T[(\x11\xd4\xebp\x97\xb5\xd7hB\xa86\x13\xd6\x13L\x0c\xd5\x86'\x88z]\x0d \xa4\x01DQm3 \xa3\xda\xc2\x88\xa3^w\x8a\xd4\x16D \xd5\x16J$\xf5:\\Wu\x10\xa1T[\x10\xb1\xd4\xeb-FG[\x1a\x8ah\xea\xf52&\xa2b\x08\xa7\xda\x92\x11O{\x87s\x08\xa8\xda\"\x88\xa8\xda\x92\x10R\xb5\xe1\x89\xa9^W#\xe2\xaa\x9f\xa0\xaa\xed\x08DUm\xc7\"\xacj;\x02qU[\x08\x81U\x1b\x9a\xc8\xea\xf54$\xba\x8a\xf6\xed'\xb4j\x0b\"\xb6z\xbd\x89q\x02Kp\xd5\xd6\x86\x11]\xb5\x85\x12^\xbd\x0eC\x94\xbb\xa5\xcd&\xc0j\xf3\xa8xK\x0bX:z?\x97z\x0b]e\x06\x11e\xbd\xdeZM\xa4E\x10f\xb5\x85\x948\x90@\xeb\xf45^\xcd\"\x88\xb4\xda\x82\x08\xb5NO^]pi1\xa4[\x7f\xfbDi\x84K\x8b!\xe1\xfa\x1c\xb6(\xbdpiiH\xb9\xda\x90\xfcRm^\x92\xae\xb6\x00\xb2\xae6\x8f\x90\xaf\xb0\x18\xf2\xae6\x8c\x7f\xa7\x16h2R\xaf\xb6\xb8\xe0\xe3I\xbe\xda05\x8f \xfdj\x8b\"\xffj\xf3D<\x1d\x19X\x1b\x92\x14\xac\x0dC\x0e\x1e\\\x8b kC\xbe\x95p\xd2\xb06\xe9\x8dNE\xd0\x16\x9a\xcc\xe6\xdc\xf1\x0cIb\x0bJ^\xa3S\x11\xe6&\xa5E$\xa3%IB\xc3'\x9f\xd1\xa9\x08)\x92\xcbB\x92\xca\xd0\xc9dt*\x02\x9d\x8a\x80^%\x05%{\xc9\xaf%:\x15\x81NEH\x95\x80\x85\xcc\xfd\xf1&\\\x05$Za4\xffC\x12\xab\xe8T\x04:\x15\x01\x93\xf0D\xa7\"\x08\x9b\x93\xb8D\xa7\"\x98\x84\xbcZ\xf0 \xc6\xbe\x88\x06A4\x08\x1f\x06\x80\xeb\xabD\x83 \x1a\x84\xedJ\xa2A\x08#\x1a\xc4\xa1\x11\x0d\x82h\x106#\x1a\x04\xd1 \x84\x11\x0d\x82h\x10D\x83 \x1a\x844\xa2A\x10\x0d\x82h\x10D\x83\xb0\x19\xd1 \x88\x06A4\x08\xa2A\x0c,\x05$M4\x08aD\x83\xf8\xad\xd0 \x82\xe9\x02UU8\xc8\x02UU\x8ch\x02\xfc\xf2\x11\xf3a\xc4\x0e\xe0\x97\xab\xbf?^R@W\xe1\xa1\x8d)\x01\xbc\x92C\x88\xef\xa0\xd6\xbdYK\x00^\x1c\xa7\xac\xda\x85L\xc5^\xb8\x94*=;\x19s<\x8cj-\x11\xc8\xaa*\xd0\xf8#\x8f\xca\x87\x8b\xd7\x847\x12\xde\xe8\xddl\xc3\xecW\x01\xe1\x8d\x847Z\xaf$\xbcQ\x18\xe1\x8d\x87Fx#\xe1\x8d6#\xbc\x91\xf0Fa\x847\x12\xdeHx#\xe1\x8d\xd2\x08o$\xbc\x91\xf0F\xc2\x1bmFx#\xe1\x8d\x847\x12\xde8\xb0\x14\xd8\x0f\xe1\x8d\xc2\x08o\xfc\xbd\xe2\x8d\xd3\xccR\x13\xea\xf8s\x9f\x08\xaa\xb1\xc7\xac(\x06\xb9\x9fzg\xb1]JU\xefM~\xc3Ju,\x9f\x11\x98\xec=\xaa_\x1f-<\xe9\xca\xbcm\xbf\x00\xf4#\xc3X\xd5\x8bl\xb5\xaaYc\xb9\n\xb5\xff\x81\xd9B\x00\xc3#GP\xac\xfe\xdb\xf4\xec\x82g\xf6-,\xed\xef_\xe1\x8a-\xaf\x81\x95\xcbj%v)E\xd77OqK\xfez\xcbf\xdf,v\xfb\xab\xcf\xccz\xa8\x98'\xba\x80\x880 \x006\xc0E\x18\x02\xa2\x0c\x11`\x9b\xd3\x99y\xc7\xc5\xf1\x01\x92\x1at\x03?\xf0\x06\x11\xe0\x9b\xbb\x02Y{\x8d\x06\xe0 \x15\x08\x07\x91@\x9c\xd3!\x0f.\x1a\x8c\x83\xf9\x80\x1c\x04\x83rNW\n,\x08\x02\xe6 58\x07\x81\x00\x1d\x84\x82t\xee\x96\xdd\x01xX\xa0\x0eR\x83u\x80\x03\xec %h\x07\xb3\x81;\x88\x03\xef \x15\x80\x07Q \x9e\xbb;\x0cN\xa8\xf0T\xe1\x08`\x1e\x1c\x11\xd0\x83\xe3\x80z\x10\x08\xecA\x1c\xb8\xe7\x1b\x82q\x00\x1f\xa4\x05\xf9 \x00\xe8\x83p\xb0\x0f\"\x00?\xc4\x90\xf9\x15\x02\xf4\x83\x14\xc0\x1f\xf8\xc0?\xc0/\xcf\x10 \x04\xae\xe2\x82\xc1@\xa77\x01\x14\"\x00A\x08(eB`\x10\x82\xc0AH\x0d\x10B$H\xe8nW\x8d\x1f(\x84x\xb0\xd0\xea\x8f?\xd1\x07\x18B2\xd0\x10\xf0\xd8\x17`\xc0C\x08\x03\x10\xc1\xb7\xe3\x1f $\x02\xc2\xafcS1\x11\xa8\x08Q\xc1\xc5\x83\x8b\x80\xa8e\x04\xc8\x08\xb1@#\xb8\xa3\x9a\x0ep\x04<\xe8\x08H\xe0\x11\xd0\xe0#\xe0\xa2\x1e\x0eBB\x10\x10 N0\x12R\x01\x92\x10\nJ\xc2L`\x12\x10\xe1\x0d\x00(\xe1\x18 %`\xca\xe8\xe8 \xe9\x00K\xc0\x80\x960\x03\xb8\xb4:\xe4\x17\xba\xc0KH\x0d`\x82\x17\xc4\x84X \xd3\xeaM~\xa3\xba?\xd7\x11\x80&8q\x17p\x02\x9b\x10\x05nZ]9AO\x88\x05>\xad\xde\xe4:\xd0unf2\x00\x14P (D\x00\xa1\x10\x06\x86B\x0c \n\xc1\xa0(xf[\x0fP\x05\x01`\x15\x16 \x85\x18\x90\x14B\x81RpW<\x060\xb5:\x1b\xc0\x91\xd8.\x83\x03N\x9d\x1dB\x1c\xed\xee\x00O!-\x80\n>\x10\x15\xdc@\xaa\xf5\x9eX\x80\x15\x12\xb6\xdd\x00\xa0\x15\x82\xc0V\x18\x00\xaec\xfbK\x96\x17l\xe5F\xa7\xae\xaa\xaa`\xd6\xad\xe3nC\xc2y\x15\xf6K_\x96G!v+\xb8\xbdfj\xbfgxV/\xef\x07W\x8c\x95\xeaj{;\xa8\xabmwX\xad\x00w\xe5\xa6\xb8Q\xeb\x15\xd4%\xb6X`k\xa0\x1e4=\xedZ\xfd\xddz\xdbsY\xce\xb3N\xcdW\xfdK\x80 \xe6[\x10;F\xac\xdc[\xa4kA\xa0\xed\xdf\xbd\x7f\xf7fq\xf9\xf1\xd5\xc7O\x97\x8bO\xef./\xde\xbe>\xff\xfe\xfc\xed\x1b\xf4\x1d\xfc\xff\x02/?\x7f\xf7\x03\xf2z\xa7s\x9d#\x1aT\x05W\x92+*\x9e\xd8F \x1f\xa4\x9a\xb1Z\x95\xf4gT\x8b\xdf\x9e\xe7\xe5\xb2\xb0/\x0f\x1aV\xac_\xf4R\xcd\x96F\xd0\x1d\x96\xbd\x90\x871?@\xd5\xa6\x8f\xec\xd1\xf5\xaa\xcd\x8a\xfe\x8c\xebf/\x91\x07\xfb\x845< ~p\xea\xb7\xa5\xa2}\xe9fW\xa0\xbbn\xc4\x0c\x18\xfe\xbde\xf5\xb6\x01\xf3a\xd2\xbdu\x15p\xf7\xd0\xd9\xe8\xfe\xb6*\xf3\xcf\xcc\x90\x83\xdc\x1b\xe2\x05C@\x8c\xa0\x7f\xea\xe0d\xfc\xeb\xfd6+_\xd4,\x93z\xd5b\xdd\xe7\x8b\x11`\xe2\x04\x8a'\xd0Zy\x12p\x9c:\xea\xc7\xf6\x95\xec\xd3\x18\xfb\x1f\x9b|Sf\xed\xbef\xf0\x9c\xdd\xb9?\xa5?]Tu\xcbg\x99\xffd\xf7WY\xc3\xac\x837\xc0-\xbbj\xf26\x05&0\xaa\xb1rk\xac\x91\xfe\xad\xc8\xcb\xcf\xae\xa1g\xb9\xaf\xf3\xf6~!\xbeh\x96m\xea\x12z\xde\xc9\xf4\xf1\xc6\x9a\xb0m\x96\x17^(]\xbb\x02\xe5\xca^gk\xba|o1UUn\xf5D \xc1\xab\xae\x12\xeaWs\xa9\xfa\xa3\x18\xe49\"3\x86v\xbf\xf2>\xfe\x0dM\x8b\xa5\xdf\xce \xe4\x83s!N\xc4\x88\xaa\xaepPn\xe4\x17\x81\x00@\xa7\xcb\xbb\xcd\xbet\x9f3\x81;\xff\"(@\xab\xace/\xb8\xafdA\x92Gg\xd8C\xb4\xcdKy\xbc\x86\xab)\x8f\x17\x92m%\x00\xf0\x82\xb5\xcc\x17\xa0e\xb5\xdd\xe6M\x83\x9d4\xfb\xcbG\x13\xe3\xe0\xcf\x87\xa7\xbbL-\xd1\x94\xd7?sQg\xad\xebJ\xfc[\x01\x83\xdfQE\x05A%+\x06\x179}I\x07\x92x\xd0\x81\xe5\xcb\x9ae\xad\xfc*FL{\xa8x\x012f\xa0\xca\xe4\xdb\xb8Gt\x08m!\xa1\x05\xf5x\xfd\xe93h6\xe2\xcf\xcb\xeb\xac\xde\x885\xa1\xd7M\xbf\x1a<\x01A\x12_\x0b\x92\xd7\xf4D\x8c\xa9m\xb3\xbb\xc5\x17\x0e\x80.\xc2\xa8]\xe9ch&\x11\xf1:\x93\xa3c\xdf\xf3\x97Y \xec\x86\xd5*\x94\xc1\xb1\x91\xac\x94\xc7\x10\xa2AI\x8c\x91Ze\xb9CEB[^\xf2\xde\xd6\xb0\x032\xef \xd22H^W\xfe \xeew|vp\xce4\x80\x0f\x1cv\xc6\x81\xc0\x00\x0fJ\xa9\xfb\xa1\x00\"\xc4\x1fL\xbd\xf2\xd6C\xc6\x93oje\x8e\xcb6/\x17\xfcCu\xd1\x7f\xa8\xce\x98\x85\xb1\xf54<\xf5`\xbb\xe5Y#\xbe\xa0a\xc5\x96EV;\xf6\x88\xb6y)Z\x9c\xbaZ;4\xd5\x17S\xbe.Q`\xf0\xd9\xd4\x15\xea\x04\xdaj#7\xb4\x04\xd8 \x80\x02\xfe\xd5lt\x95m\xab}G%6o@\xfe<\xa8._\x08\xe8\xafo\x95\xc5\x97\xd7\xc0\xee\xe4\x0b\x94/[,\x1d\xf2\xd22y_\x16Ys\xcd\xa7.-\xf2a\xa3\x10g<\xac\xb2\xe7)\x0ck\xf4\x98\x13I<\x14<\xb8\xaa\xaem\x13\xdb2+\x96\xfb\xa2\x83n\xd6{\xfe\x85e~\xe0\xbe\xec\xdfL#bW\xed[\xc8[\x91\xa1Qn\xa0\xba\x11\xdf\xa9\xdd\x16\x02\xfc\xf1\x9a\x95\xb2\xaa\xe6\n\xd4\xe3\x0d\x19\xf3S\xc7\xcb\xd2\x93\xc9\x10\x937|\xae_\xe5\xad&\x87e\x83\xe6c\xf4w{]5\x83C\xaa\xcc\x0f\x1d\xbe\xc6\xbc\x19\xd10\x07-BT\xad\xaf\x82\xd1\xd3*\xefpZ\xb9\xd9.\xb8\x84\xe6\xa7\x8e\xde\xdf)\xfc\\\x89\xb0\xee\xaa[&g\x9d+\xd6\xbd.\xb6\x12\xd8\xab\xb5\xd9\xea\xfdVQ\x05\xf3\xd3\xb6\xfb\xa2\xcdwE.\x0b7~\xf6\xc1\x0d\xa3^7H\xe1\xe9\xd9`\xea\xcc=\x99\xea\xb3\x02\xfb\x11o\xbbl\xa3N\xd6:\x1c\xa5F\x8f\xe9/\x1c\xcb\xf8\xf5\x7fV\xed\xde\x94\xc8#\xcd\xb9\xae\xf3\xe8\xfa\xb1\xbbva\xcd\x19\xf1\x0e\xa4^\x86`\x9b\xb7\x05{ \xffc\x1ba\xf5\xf3\xf5\xa0\xca\xff\xa9\xe8\xb5Y\xd3\xc8]\xbd\x8bl\xc3>\xb0\xbf\xeeY\xd3\x9e\xca\xdf-\xce\xfa\xa3/\xb9[\x1eB\x06\xdb\xaai\x81 \x92\xaa`\xb7\x1an\x15\xedkf\x00\xf6\xf6\xef]\x15\x02\xeb$#\xf72s\xbd\xa9\xd9\x1f,\xa7\x87\xc6\x81\xd8\x8e\x8d\x1f7\x0c\xd1\x92w\xdc\x85\xec4\x96\xcbo3>e\xb5'\x90\xb7\x8df\x857b\xe4\x93P\x88\xd8;\xb8\xcd\x9b\xf1;\xb5UD\xa4\xd1\xf5YkXI\xc6\x83<7m\xbdLc\xf7\x03\xa94\x8e\x7f#\x95F\xdc\x12 \"\x12\xc7d[%\x95FD\x92X\x9b\"A,&9\x8cT\x1a\x13&\x82\x85$\x81\x05%\x80\x91J\xe3\xdcd\xaf\x88D\xaf$I^\xe1 ^\xa4\xd28'\xa1+$\x99+\"\x91\x8bT\x1aI\xa5\x91T\x1a\xb1\x89XI\x93\xb0b\x12\xb0H\xa5\xd1v\x997\xd1* \xc9\n\xa3A\x18\x92\\E*\x8d\xa4\xd2\x88I\x94\"\x95Fas\x92\xa1H\xa5\xd1\xe4\xc9\x9b\xf0\x14\x9b\xecd\x9d\x1bH\xa5\xf1\xd0H\xa51\"I\xc9\x9f\xa0\x14\x9a\x9c\x14\x90\x98\x14\x9c\x94\x14\x96\x90D*\x8daIG\xa4\xd2\xd8\xd9\xefR\xa5\xb1\xe7\xfd\xf5\x8b\x9e\x17b\xe4}y\x98\xd82\xfa\x88T\xe90\xac\xcc\xae\n\xb9\xf1\"\x11A\x1e\xb6\x01\x9a+\xb4\x18%m\xce$\xc6\x08bFy)\xef\x1d\xfc\xadf\x7f\xdd\xe75[\xbd\x84uV\x8c`%\xe3\x97\xba.r\x0f\xe4\x9e~f\xf7\xb6\xa2O\x00R\x85\x88fj\xd4\xafY\xbb\xafK\xa9\x03(\xa1>\x05\x05w\xf0\xa9\xd8\xbd\xdaL\xb6yD\x0dxE\xdd\x90\xe8)\xbc\xe7stU\x8a\xcf\xdbj\xbdn\x98\xa0\x95\x8f\x8b\x0b\x83\xdd\xf7\x86\xb5\x89\xa3e\xd9\xcb0\x04Q\x96\xcf\x16\xc7\xc9>\x82\xaa\x8c\x08e\xb9\xdf\xb2:_\xea\xbf\x89\x01B\xf1\x0d\xe4F\xce5+u\xe0\xf7e\xb7w6Y1\x9f\x0bo\x05k\x9a>\x84r\xb7i\xdf\xf0P\x7ff\x81\xf1\x1c\xbb?rp'0\xb5!\xbcE\xbe\xcd\xb1\xd1\x15\xd7j\xe4\xde\x86^\xcb}\xd5a\x0bVd\x86}1\xc1[\xe5.\xca\xf0O\xe7k(\xd8\xbaU\x1bvy+Gp\xbd\xce\x15[\xc2\xb2\x83\xc8\x87\xf08_\xdd\x03\xcb\x96\xd7\x90\xedv_0\x8aC\x0c\xbe\xbf\xdf\x15\xcb\xc1\x1d<\xa2\xa2\x85V\xd0\xd6{\x06\xfc\x1fy\xb9\xca\x97\x82V\xa5\xc0!\x15Aq\xa1jHCwy\xb9,\xf6\xab\xc9*6\x93O\xe9\xd0\xb9\xc9\x1b\x13X\xef`\xd3\x98\x0f\x9b#\x1a\xca\xc8\xd9\xa7\xf3f\xf2\xb6&U\x10\x0b\xff\x9a5\n\x94\x17\xdd\xab\xef\x8f\xbc\xcb\x9d\xaa\xde\x94o\xcaj\xca\x9b\xd3\xbdq\xfc\x08\x19\x99\xb9/\xf60}\xd4\x96Xjx\xb55\xbba\xf5\xc8\xa9\xeb\xb5\xaa\xab\xa7\xaf4\x1f\xb0;jf\xee##?\xfc\x19L\xb0\xef\xa1\xaaW\xac~\xa8\x10\xd8$\x93\x9f\xf95\x93\xcf~\xed\xfe-\xd4q\xff\xa6\x04\x8b\x9d*\xca\x9d\x88\xf2\x80\xfcV\xae+\xd1\x16\xe5d\xdd\xff\xa0\xe4uu(\xcc\"\xcaOt<\x1e\xbb\x86\xb2\x8d\x97\x11E\xeb\xc2)!{\x11\x06\xcc\x16}j\x0d\xe4p\x05d\x9c\xfe\xb13\x9a\xe0\x8d( H+\x88\x88\x02:\xaa\x10K]q\xf8\x0bR\xd3\x98\xa4U\xf8L\xd7\xdd,x6p\xf9D\x07\xe3\x91j\x9f\xf5\xc1Z\x18\xca\xa8\xad\xfd\x02\xa0\x97\x8fm\xe1}\x00 \x1e\x02#\xee\xbcS\xa9M\x1ab\x9f \x90\xdb5\xfd\xb5\x93\xe7k\xb6\xc7\x15[^\xff\xcb7/\xb4\xfcZ/\xe3\xe6t\xd7\xf6\xd9\x0c\xaeM\xebq\xafy\xf8Z\x1f<\x7f~\xad\x11\xd4AW*\x86\xb4\x98\xaa\x8er.\x86/@lo\xca\x1fk\xb6d\xf9\x8d\xeddm|\xec\xfa\xb1\xa5\x9f\xb0U\xe0\xaaRm\xb0\xaa\x14\x96k\xbe\xca\xbc\xba\x07\x87\\V\xb6\x14\x8a\xa1J\x05\xd4>\x0fV\xb7\xa5\xfc\xc6\xaa\xcaA\xebR\xfb\xda\x02\xd9\xa9\x96y\xd61H\\\xe8\xc5\xcd\x90\x9aQ\xad\xb9G\xfbs=\xaf\xf4*+\xb2r\xe9\xd9\x14N0@\x94\x955)\x0b\xb0mF\xf2^f\xba\xc1\xb6\x92\xd7U^\x0e\x88Z\xa2A\xf4\xe4\x9e\xb2\xdajEY\xfe\x02\xb3R\x15\xce\x85\x18\xbc{\xff\xf1\xedK\xf1\xed\xa5\x08<\xf2#&\x17\xfb\xcc\xe7e\xab\x96w\xdd\xde~\xe3l\x04j\xed\xa7\x88+\xf6\xee\xaas@\x9an9\xc1\x1b\xe1\xa6\xdaTba\x15\xbbS\xdew\xa2!\xfd\x86?\xe1&+\x84\x9at5\xech\xecn\xc9vR\xae\xda\xe8.o\x07\xbb\xee\xe6\xda\xa8\x96:]\xe8\xaa\xc1A\xc5\xae\x81mU3h\xf6y\xab\xd5\x7f\x8d\xce\x96\x85\x90\xbc\xee&\xeci\x18\xe8\xe0kat\xf0\xf5o\xee\xe0\xeb\x83w9&\xd3\x0d\x16\xde^^\x9d\xc9\xd1\x99\xf1\xab\x80(v\xc2\x88b\x97fn&\x8a\x1dQ\xec\xccF\x14;aD\xb1;4\xa2\xd8\x11\xc5\xcefD\xb1#\x8a\x9d0\xa2\xd8\x11\xc5\x8e(vD\xb1\x93F\x14;\xa2\xd8\x11\xc5\x8e(v6#\x8a\x1dQ\xec\x88bG\x14\xbb\x81\xa5\xa0;\x11\xc5N\x18Q\xec\x88b\xf7\x98(vt\x1av\xecQ\xc3t\x1a\xf6\x11\x83\xeb?\xc7\x99N\xc3N\x11E:\x0d\x9bN\xc3\x16F\xa7a\x9b\xa9\xe2g\xbf\x8ey\xb8\xae\xa3\xb2\x07\xd404c\xbcgM\xc2.\xcb\xcd\x04\xf27S\xd9\xad\xbf'\xda\xb8\x8d\xc7\x11E\x0d\xf3\x91\xbf\x9d\xae\xc1\xeb\x1e\xc2h\xdf\x08\xe4\x03\x07\x1f\xe8+C \xdf\x1e\xac\xd2K\xf7\x0e {'\xaek8\xcd\xdbSW/\xc9\xdbG\xf1\x0e\xaf\xe0|z7.^)\xa9\xdd8bw8\xad[\xd1\xb7-\xfe0\xa4n\xe7\x0bt\x12\xba\x93tz'\x95\x1b\xd16|4n\xaf\x0b\\[HM\xe0NI\xdfF\x91\xb7\xc3\xa9\xdb\xfe\xc0\xc4\xd3\xb6!7\xb5\x187i;!e\xdbM\xd8vW\\,p\xcc5w\xe9E\x1e\xac%\xb4\xf5l\xd6\xbe\x14Dg\x1d\xffFtV_\xab\xec\x8d\xe8\xacDg5\x1b\xd1Y\x85\x11\x9d\xf5\xd0\x88\xceJtV\x9b\x11\x9d\x95\xe8\xac\xc2\x88\xceJtV\xa2\xb3\x12\x9dU\x1a\xd1Y\x89\xceJtV\xa2\xb3\xda\x8c\xe8\xacDg%:+\xd1Y\x07\x96\x82ZHtVaDg%:\xeb\xe3\xa4\xb3\x8e\xd9\x14\xb62\x8f\xaf\x9a\x1c5\xaf\x899G.\xf3\x83Q\x97\xce\xfa\x83\x93\xfb\xcb\x1c|\xa6\x01\xd7\xf7\x93\xbe\xd3\xc0q\xea\xbc\"HN\x9dC+\xd9\xc9\xf0$u\xd9\xa3e=\xc9\x00\x1c\x83\xe8\xe4c\xe6x7\xab0\xbb=\x89\x99GN\xd6\x11\x92q\x94\xa8^IYFN\x82\n+\xdb\xda\x89\xba\xda\x90^p\xa1\xbd\xe0kD\xd2|\xa8/7y\x94vU:\x8f\xb6\x97\xe6\x0d\xbe4\xff1\xf7\xd2p\xafJ\xda\xa4\x94\xfau\xa9\xff\xd3\x87\xd8\x0f\x8efwzk\xab\xea3\xec\x8ali\xdc\x08\x95\xa6N{\xe7\xcft\x9fh\x1c\x1c\x17\xff\xa9\xc6\x81\xb1\x19\x97T\xc7f_\xe6w\xfd\x19\xf7\xb8\xc0\xf4\xae\x1c{\"\xf2\xf4\xf6\x85GK\x13\xf0\x81 \xa9\xec\xe4\xe9\xa3\x89Yq\xdd\xd4%\x0e\x90\x13\xd4\x10\xbf\xda\x17\x12ASl<\xc8ZT\x08\x8eTuG\x9dB\xcb\x88\x0d\xa9aR}[\xb6\xf5}O%+\x07\xd3\xb8\xe7\x08}\xb1\x89_\xb3\x82\xddde\x0b[\xd6f\xab\xac\xcd\x10\x0cG5HJ&\xf9\xb0\x17\x0f\x89\x93\xea\xa2\x18\x1e\x98i\x91\xd2\xb4\x958$\xba(\xc4g=4y\xb9)\x06\x8b\xbbg\xa6\xfd\xfe\xbe`\xfc\xbfF\x9a$\xefl\x9d\xb7~\xa1\xc3??J\xd1\x1d_\x08\xfa;[A\x917\xed1\x89]\xa6\xdb\xcfL\xab\xa8\xc9\x85D\xf8\x92F\x84/\"|\xf5F\x84/\"|\xf5F\x84\xaf\x96\x08_f#\xc2\x976\"|\x11\xe1\x8b\x08_\xc8U\x12\x11\xbe:#\xc2\xd7\xd0\x88\xf0E\x84/\x83\x11\xe1\xcbx\x0d\x11\xbe\x88\xf0e1\"|\x11\xe1\x8b\x08_D\xf8\x1aX\n\xf2\x0d\x11\xbe\x84\x11\xe1\x8b\x08_D\xf8\x9aW\xe6\xa4\x84/\x13\xa7\xcbu\xc0\xf1`\x07\xa0;\xd5\xcc\x80\x166\x06z\xd7\xe0\x01b\xca\xec\x1c\x1dPc\xcc\xe7\x1f\x9b\x1e\xa3nx\xe4\xdc.\x1e\xde\xc7y\x0e\xb2\x8fI\x85\xda\xdf\xc2l\x11Aj\x9e\x98\x87)\x86\xe6\x8a%\xadaR\xc6\x98W\x95\xca\xc9\x1a\xf3\xf3\xc6<\xcc1o\x13\x93\xe6kh\xd2\x02\xf8c\xa8\x17\"\x0d\xcb!\xc3\xbf@iiyd8&Y\x10\x97,\"F\x18>Yp\x9c\xd2q\xcap\xac\xb2 ^Y@\x90\xc2\xaa\x9d\x8c]6\x8f_\x86b\x98\x1d-\x08X\x1aZ\x82\xb7\x8e/XR\xa2Z\x18U-)Y\x0dW\xe7d\x845\x14em\x1ei\x8d\x8e\x8fVF\xc7G\xffv\x8e\x8fF01\x9d_/Nr\xe6\xc4\x9b\x81\xef39\\\xda\xf8\x19F4MiD\xd3L\xf3\x85C4M\xa2i\x9a\x8dh\x9a\xc2\x88\xa6yhD\xd3$\x9a\xa6\xcd\x88\xa6I4MaD\xd3$\x9a&\xd14\x89\xa6)\x8dh\x9aD\xd3$\x9a&\xd14mF4M\xa2i\x12M\x93h\x9a\x03KA\x99#\x9a\xa60\xa2i\x12M\xf3q\xd24\xe9\x98\xe9\xb03|\xe9\x98\xe9#\x06\xd7\x7f@2\x1d3\x9d\"\x8at\xcc4\x1d3-\xec\xb7z\xcc\xb4f\xee\xb7w\x1di\xbf\xc9\xb7\xfb\"k\xd5\x86\xf6\xaej\x0e\xb9\xf8\x97\xea\x12\xd0\xd76\xc0\xee\xd8r\xdf\xf2ze\xd0\xd6Y\xd9db\xcfR~\xc35m\xbe\xcd\xc4\x8f\x9b\x8c7\x191BH\x9f#\xc6\xbd\xf6\xfbDW\xfe\x91\x92\xeb7Y\xb3\xc8\xcbu\xe5\xe1\x93\xe9\xcb\xf4\xd0\xca\xff\xcd_\x8e8\xe7\xf4\xaa\xda\xb7*\x1c\xfdp\xaa\xe2i$%Z\xcb ^\xa2\x06/\xc8mV\xb6\xcc \xf6\n\x18\x8c\x02\xc1\xad\xc2\xe0\x00\x00?d\xcd\x1fEAtL\xb6\xd9]\xbe\xddoa_\xe6\xad\xd8\xc0\xbe\xad\xea\xcfp\xab\x80J\x89\x8f\xb5wv\xa2\xd9\x8e\xd5\xbcp\xa6\xefQ^k\x1e\xdc\x07\xaa\xf3\x0fY\xf3\xa9\xe9+\xa6\xce\xa5\xad\xd6\xe2%g\xcbVR\n\x96U\xa9\xb0\xe6\xb1+9\x8cx\x1a\x94\x9a+\xf2f8sh,\xe38Mg\x95\xb5\xd9\xcc\x00Za-\\\x93y\x93\xb5\x99X\xf9\x95\xf7\xa24\xfd\xf8\xba\xae\xc5\xb1\xbd\xf2CJ\x80\xce\xe5\xaa\xb0\xe0F\xa0G\xa8\xaa\x14\xd3\xd5O\x9f.?:P\xc1\x82\x95\x9b\xf6\x1av5[\xe7w\xb2\x7f\x8a\xf1\x9a\x0f\xf1\x0d\xe3\xdf6-\x93\xa5\x91\x85\xd8\x17m\xbe+l8\x9a.cW\x04#\x90XT\x9b\xc8H\xe3\x02\xf9c\xb5\x19o\xe6\x14\xd5f4&\xc5\xc6\xd3p\x01\xbbae\xfb\x88e\x85\x85\x1b\xeb\xaf\x88\x90s\xcb\xda\xb6\xce\xaf\xf6\xad;\x03\xc5W]i\x9e\x8c\x18\xc0U]\x1a&\x00\xd2\xact\xe3\xa1\xa1b\xa1\xcd\xdb\xe9{s\xc2\xe6\xbd\x1d\xeb\xf1y\xb9bw\xd8\xc7\x1f\xae\xb3\xccf[\x80\x9a\x0c\xd7k\xb5\xbd\xe5=\xea\x95nq\xf2SX1\xe2?\xb3\xfb\x17\xf2\xfbi\x97\xe5\xb5k\x1b\x87\xdb\xf4\x14\xfc\xac\x94\xbd\x15\x95]\xe0(\xa6(\xa0\x9c\xb6\x1b\xfe\xd9\xa6yG\xb0b7\xac\xe0-R|Dfm+\xbe\xeb\xbaMg\xab\xc3\xe1\xd0\xd4:\x00+\xbd\x8b\xf2\x1d\xdb\xe4\xe5wE\xb5\xfc|\xd2\xfd\xedm\xb9\x9a\xfc\xe5\xf55[~\xfexg\xef\xd4\xe5\xaa\xbb\xf6\x0d+\xf2\x1bV\x7f\xbcs\x00\x8f?f-\xabO\x86k\xde\x06\xb6\xd9=\xff\x10\x90\x99\xa8+\xb5\xa3\xd0^\xb3\x86\xa9\x81\xd1\x1ck\\\xa4E\x9c\x9b\x01\x9b\x02\x9a\"_\x8a=\n\xf9\n\xe4\x08\xa1\x08\x88\xb7\xacf\xc0\xb6y\xdbZ\xc9P\xab\xbd\xa4\xb0\xca\x81\xdfV\xd3~>\xb0\x8d\xfc\xae\x8d0\xe8\xd6\xf6C\xeay;\xc8\xa5\x90\x9b\xc9fm\xe0KV\xdf\xe4Kv\xda\xf9 n\xb90\xe2\x96\x13\xb7\xbc7\xe2\x96\x13\xb7\xbc7\xe2\x96\xb7\xc4-7\x1bq\xcb\xb5\x11\xb7\x9c\xb8\xe5\xc4-G\xae\x92\x88[\xde\x19q\xcb\x87F\xdcr\xe2\x96\x1b\x8c\xb8\xe5\xc6k\x88[N\xdcr\x8b\x11\xb7\x9c\xb8\xe5\xc4-'n\xf9\xc0R\xf0|\x89[.\x8c\xb8\xe5\xbf\x07n\xf9U\xb5\x1a\xce}yy\xf0'+\xff\xdb\x84\xfd\xfc\xbf5[\xbf\x84g\xff\xcf\xd9`\xe3P\x91\xe6N\xdb\xbbSE\x9a\xeb\x91)\xa9\xfc\xf4L\xf9\x98\xd2\xee\x14\x90e&\xde\xb5w\xeaZ\x93\xfc\xed\x0f\xac\xfdx\xd7H\x80o\xcd\xda\xe55\x1f\xe4\xef\x1a\xc1\x93\x1d\xa2\xb7#>\xdd\xe0&\xf5\xf3\xc3P\xea\x90A\x1b\x14O\xa3\x82\xcf\x9e\xf4\xa5 \xa6\xefg\xe6\xeb9\x18zX\xb9\xdf\x8e\x97%\xe6\xf0\xda.yu\xf9\xda\xf6\x13\xaf\xc7\xe8\xa5J\x8e\x8e\xcb\xbd\x9d\x02e\x11\x17\xfb\xae\xae\xb2\xd52k\xda\x8fwp\xa5\xff=\\\xd2\x19\xa9N\x83\xbb\xd4\xcf\x0fCuj\xc3\xb9D\xed]w&\xb7\x8d\x99\x13%\xd5\xe4:\xe1\xd8\x8b,\x0d\xa8G\xee\xc3\x13?^3\xb8*\xaa\xe5g\xf5<\xc3\xb5\xed\xddu\xd6\\G\x16d\xf4J\xf8\xc3\x86\x8by\xee\xd7\xb4\x9d\xb0\xacV\xac\xd9e\xb6\x13i\xbd\x0fUu\xe3\x9f\xbe\xc2\x8d\xd6\xa1\x80\xd7\xd5\xca\xf4\x11g&w\x81\x97\xe0\x05\xa8H\x8fB\xd0\xe9e\xf0g\x1aA\xb5x\x85\xae\xd1\x83\x9e}\x90\xab\x04\xbe\xa8nN\xf4\xbe\xf43\xc3\x8duv\xbb8\xb6X\x15\x7f\xf3\xd5\xbe\xdd\xed\xbb%\xc8@R\xe6Y\x03E\xb5\xd9\xb0\x1a\x9e\xd7\xd9\xadz\xd8W\xa7\xf0\x93Ub\xc9\x8e\xe9\x96U\xf9b\xc5\xbf=\xb7y\x997m\xbe4\xc5\xb8\xa86\x8fX\xccj\xdbl\x16^5#\x7f\xc3\x94\xe6o\x9e\xe0\xd2*\x93\xe6m\x04\xe0\xd1\x08\x93\xe6\x0b\xae\xb4/#\x9d%\\z\xaeA\x06B\x1aNML\x1a.0\xd2\x10\xe1\x91\x86\x0e\x924|\xa8\xa4\xa1\xb4\xc6\xa4\x05DM\x1aRJLZ\xa0w\xdcx5\xb6^\xa7kp\xfew\xf7\x82\xe1\xb6\xcev;V\xf3\x0f\x97\xda\xc5\x11\xea\xadU\x072g\xe5J}\xc6f\xb5\x83\xa624Y\xd1\x06\xf2\xb2iY\xb6\x12\xdf\xdb\xd9\xad\x1c\xe6\x1d\xd8Up\xcd/\xc5s$C]\xd7\x9a\x95#M\xaa\xa0\x8a\x0bv$\x1f\xf7\xbb~\xe1\xab\xaf\xe6\xd4~f\xf7g\xbd\x1e\x9abW\xf2o\xa7I(<\xee\xb0\x81\n S\xb8x\x97\xd3\x9d\x12\xf6\xd2\x12^M\xb5\xf54\n\xa7h#\x04T\xe6\xd5w\xaf\xcf\x7f\x92\xfb\xd2?V\x9b\xbe\x99\xf3\x18\xef\x97\xed\xbef\xba\x92B\x13\xb8\x94r{\x0e\x92]{'|v\x9b\xddE\xb51\x97\x11WB\xec\xfa\x81\x0f\x06+\xb9t\xe0\x8b\x04\xb33\xd4\x1a\xc1,\x08\x0c\x98\x01g\xfc\x19\xd2Cl\x03\x05<]B\\Y\x92 \xfe\"\x17\xa9\xafFb\xb7\xb5L\x82\xd1\xf4\xc0\xc3/\xb7\xa1%R\xe9\x8d*\xa8\x16\xe3\x85\xab{_1[\xcb\xe2\xca;i\xfa\xa7\xc9\xd6\x93\x18\x81\x88\x02\xa0\xfb\x05\xc4\xa6G8\xfc\x1d0\xe4\\cP\xd2\x14 o\x92D\xea4 |\xa2D\xa2T\x89\xb8d \x87;\x1ePt\xba\xc4\xec\x84\x89\xd4)\x13\x81I\x13\x89\xd3&\xc2\x12'\x02S'\\m\xb8K\xaa\xc0&O$N\x9f@%P$L\xa1\x98\x9bD\x11\x95F\x91(\x91\"&\x95\xc2\xe1L$Y\xf8\x93)\x8e\x92Nq\xbc\x84\x8a\xa3\xa4T\x84%U$O\xab\xc0&V$M\xad\xc0'W\xc8eD@zEx\x82\x85w(\xfc\n\x91b\x91 \xc9\xc2\xbb!\x80ZP!R-BV]\xc1\xe9\x16\xaeI\xf0\xaa\xbaa\x88\x84\x0bl\xf9\x12&]\x84\xa4]$N\xbc\x88K\xbdp\xb5\xa0\xc6\x9f|\x11\x9d~a\xf1\xc6\x9f\xe6K\xc0H\x95\x82\x81\xce#@\xa4a\x04%bxx\xd3Q\xc9\x18>\x9fVRf\xa2\x94\x8c\xf0`\xe2\xd32|u\x8bH\xcd\x88L\xcep\x91[\x93%h\xa0S4pI\x1a\xd84\x0dD\x94\xc3S5B\x925\\\xe9\x1a\x89\x126\x02S6\xe6%m\xf8\x02\x1a\x90\xb8q\x84\xd4\x0do\xe9\xac-=]\x02\x07\"\x85#>\x89\xc3\xe2\x8e_\xe6J\xe3H\x9c\xc8\xe1K\xe5\x88L\xe6\xb0\xf8\x92_\x86\xae\x8fcDB\x87\x8bu\xeeJ\xeaH\x9f\xd6\x91<\xb1\xc3\x9e\xda\x912\xb9\x03\x93\xde\x11\x9e\xe0\x11\x94\xe2\x11\x91\xe4\x11\x9a\xe6\xe1L\xf4p\xd3\xee\xf1\xc4{l\xb2GD\xbaG`\xc2\x87\xa3\xba1I\x1f\x16W\x83\x84\n\\\x97\xc0%~8\x9a\xbc8\xb3\xd2\x91\xfa\x914\xf9\xc3\x93\xfeq\x9c\x04\x90Tm1 $$\x0d\xa4O\x04\x19Z\x9boY\xd3f\xdb]$2\x84\xfb\xf2\xfd\x98\xf7\x1b\xf2\xbb\x9a\xdd\xe4\xd5\xbe\x91\xfc\xb6S\xf8\xbe\xaa\x15\xc9\xad\x81\x7f\x83\xafO o\x9f5\x8e7{+\xae\x15\xcd\x7f\x95g|\xac\xb6\xbd\x121\x82\xea\xfa\xe9\\|\xb5/pS\xb5\xfdw\xa7,\xc9\x8fY\xd3\xbe\xae\xb6\xdb\xdczHW_T\xf8\xf6[\xf8\xfa\xc4:\xd5\xf2\x1a\xf0\xaf\xd1&oD \x0e\x1d\xfa\xe3\xf6\xf1\xae#\xa5yp\xdf\x9a\x15\xec&+[h\xef\xe4i\x89\xe6U\xc9\x96\xb5\x19\xffY\xec3\x9a\x8a\xdef\x9bf\x80\xe0\xcb\x05\x88JS\x95\xc7\x186\xb2\x17\xae\xd8\xb2ZMO\xd7te\xcf\xc0\x909:\xe7l\xaa!m\x95\xce\xa6\"-;\xdf\xfe\xa2\xbf\x9bI\x8b\x02kI\xcb\x0e\x03\xd1&\x01hc\xe0Y\xd2\xb2K\x08\xca\x86@\xb2A\x80,i\xd9\xcd\x85a#@\xd8$\x10l8\x00KZvs\x80\xd7\x10\xd851\xe8\x8a\x83\\\x13\x02\xaeX\xb8\xd5\xf0%EZvcC\x00\xac\xd8UR0\xb8JZv(H5\x06P%-;\xdbe^\x105\x00B\xc5(\xb5\x85\xc0\xa7\xa4eGZv\x18\x90\x94\xb4\xec\x84\xcd\x81EI\xcb\xce\xe4\xc9\x0b\x84\xc6\xc2\xa0\xd6\xb9\x81\xb4\xec\x0e\x8d\xb4\xec\"\xe0N?\xd8\x19\nu\x06\x00\x9d\xc10g\x18\xc8IZva\xb0&i\xd9uv\x0c(3E\x9b\x0b\x801\xf1 &F\xcb.\xf1\xd9TV\x10\xc3\xa9=\"\xf2Y\x83\xa0\x17\xcf\x97\xfa\xe8KX?\xa0\x83\xd0\xb2[Wj\xdd\xd6\x81,Y\xcar(o#\xed\x05|\xf7\xe1\xfd\xab7\xaf_]~\\\xfc\xf4\xfe\xcd[\xab\xd4\x8d\xe5\xf2\xef~|\xff\xfa?1\x17^\xfe\xe9\xddk\xccu\xaf\x8c\x17v\x9a9\x01\xa5\xf5\xef5t\xe8\xe3O\xd5\x8a\x0d\x14\x92\xc4\xce}'\xa2\xc3\xa3m\x811A\xe0\xba\x07`&|\xb8x\xdd\xc1\x99\xa6\xb6\xef\x8a\xfaK\xf8oVW/\xe4\xd4/:?\x7f\xbe\xd0<\xb2\x8c[\xe6\x97r\x10+\xf1\xd7\x01\xf6\xdc\x0e\x94\x82\x04*\xc5\x9f#r\xcc\xe5\xb8V\x08\xe5\xbd\xdb,o\x1b\x0b\x94 \xe6\xf8;\xb5\x8b\xba\x14P{+\xd5\xb52\x85\xc1\xa3\x8a\xcb\xdf\xf8Ai\xf9\x1f\x93\x166\x83\xd7\xd7l\xf9\xf9\xe3]\x9f\xce\xddC\xd5|\xc1\x8a+\xec+ci\xff\x7f\xf6\xde\xb4\xcb\x8d\x1bI\x14\xfd\xee_\x11W\xef\x9d\x914]\xa26K\xb64W\xf7Li\xb3\xabmY\xd5R\xc9}g\xfa\xf5-\x81$H\xa6\x95\xcc\xa4r\xa9\x12\xd5\xd7\xff\xfd\x1dl\xb9b d&\xcb\xb2\x8d8s\xa6\xe5b\"\x00\x04\"\x02\x81X\x80\xe3A\xc3\x15\xf7\x91\xe9|>\xd1\x96gC\x14\xb4;,;S\xb7\xa2\xf2\xbc\x9c\xb8\x0e\xca\x8b\xff,\xbcb\xf2\x12I\x97\x87\x9b\xec-\xfeb\xbe\xaf\xea\xba\xfe\xcd\xbe\xdb\xff\xda\x90|\xf3\xab\xbcW\xca\xf8v_\xf5j\x9f \xe9\xbeu\x97Q\xff\xd5>\xf9\xc3\xd5\\b\xe5\xf3^_x\xa9\x0fBv\x83\xd3\xb5\xef\xde\xb1\x04\x84\xec\x86\x90\xdd\xa0\x87\x90\xdd\xc0!d7\xf4!d7\x84\xec\x06\x13\x84\xec\x86\x90\xdd\xc0!d7\x84\xec\x86\x90\xdd\x10\xb2\x1b\x04\x84\xec\x86\x90\xdd\x10\xb2\x1bBv\x83 BvC\xc8n\x08\xd9\x0d!\xbb\xa1\x01SD\x9aCv\x03\x87\x90\xdd\xf0g\xc8n\xd8\x90\xbc\xa9\xa2\xda\x8fK\xb0\x1f\xab\xe7\xbf>\xf1o\x19\xe5\xf9c7G@\x13^\xb6\x0b\x9c\xc56\xf4\x93\x94\xe2\xd6\xeb\x13Q\xf2\xb8\xeb\x187fKh\x8e\xe7\x88\xb8^\xb9[gdI\xab\xe0\x1e\xbf1\x9a.\xcfw1In\xff\x8bM\xd2\x16\xe5;\x16_\x9f\xc6$\xe1\xd3\xe2\x0f\x14U5\xe5\xf1\x1e$:\x90\xdd\x00C\xcb\xec\x88\xa8\xc89\x05\xb5\xc1\xc0\x06\xd6\xaf\xd4\xa4\xaf\"$X\xf8G\xdeL\xef\xcfX}%\xf6\xfb\x9b[\xf3\x90\xf5\xed\x92\x89\x9ao\xd0\x00)\xa4\xb8\xb3_8]/\x19+ \xda\xf9\x84\x9d\xff\xc6\xf8\xb1A\xf3!\x15\xe1\x1c\xc7\xed&;\xbc9}\xd6\x95\xf9P\"\x1e\x82\xa8.\x0f\"\xc6 \x07!\x88\x1a\x82\xa8\xc6/C\x10\x95C\x08\xa2\xf6!\x04QC\x10\xd5\x04!\x88\x1a\x82\xa8\x1cB\x105\x04QC\x105\x04Q\x05\x84 j\x08\xa2\x86 j\x08\xa2\x9a \x04QC\x105\x04QC\x10\xb5\x01S\x04\xb4B\x10\x95C\x08\xa2\xfe\x19\x82\xa8\xec\xff7\x10\xb4\x8e\x90\\\x12e \xaa\xe9\x84V\x81E\x1e\xf8RAU\xb6E4U\xd1\xc4\xe1S\x1e\xe4\xfa\n\xc0\x14;\x95>\x1a\x1e;5\xc7L\x9f\x89\xafZ1S\xc1f\xfc\xef\xadP\xa96<\xda@\xf0\x95\x9a\xd4\x17\x1a\x1e\xad)\xd1\x84\xd6P\xf8\x02Fn\x12\xd4`\x1c\x078CT\x9c\xdf\xb4\xbc\xea\xf4\xcb`\x1c\x1b\x00oi\xd1\xe0U\x19+U\xf3\x911\"\xfe\x93\xd2Z\xdc\xdbd|(\xa5\xd1\xd8\x18\x92\x92\xee\xc9\xca\x89\x91\xae\x8aK\x92Q\xeeO\xdd\xedbq:\xe4\x8e\x1b\x12\xc3\xb54\xb9%\x11\x9adv\x91n\xb7$Y\xe6\xf2\x81mS\xb7\xdc\xf0c\x9b\x0f<\xa5\xeb(y\xcaC\xd3\xc2<\xac\xcd\xbej%#Cd\xba\x86\x13\xeeu$q\xceC\x1f\xc6\xd9\x16),i\xc1\xdfU\xdfP\xee\x14$\xf5\x94\x15)\x16$\x81\x0dI\x961\x05\x02\xeb\xe8\x82\x9a\x1c\xa5\xd5\xc2\xf0\xb8\x80\xa9O5 \x812\x13n\xa6\xa2ZJ\xb6\xbf\xcd)Mx\xd4#\xb2\xb9\xc4\xd5@\x8f *\x14\x07\x98:\x95A\x88*nT\xcf2\xca!-\x8b[\xe9\xea\xd6\x92\x14\xbc.=i\xd2\xda\x80O\\\xfa\x9f\xc1\xf7*\xa3\xc0\xd4qF\xc9b\xd3\xb8j\xbe\xea\x97\x0f\x98~\xd2_\xc8_D\x83%K\xf9;\xd9ln1<#\xe4\xef9\xb3\x0d\x16\xa4`\n\x9e\xcfX<%*I\x93\x8b@\x04_\xace\xf5\xe5\x8c\x7fi@\xd8j\x0fq\xba\x8e\x16&\xc2U|\x90\xd1mzA\x97\xb0\xca\xd2-'\xe1\xdb\xe7?\x18}\x15\xdc\x98\x8arikK\xc7;\xf7e\x1fU!\x9dJ[\x14\x9b,\xbd\xd4\xbe\xd5mJD\x01\x9f\x15@>(\xde{N@\x01;\xf1\xe8\xb2S\x14\xf9\xb6\xd2\x1d\xbd\xa3\x19\xeb\xd2\xac\x0c^\xcb\xe3\xe5\x92\x9d\xe6\xf9:J\xc2\xe4T\xcb}#\xde\xa1/\xa2\"\xa6\x16\x8e\xe2\xfe\xb5:lVG\x01*\xd5\x96\xacR\x19g\x8a\x92E\\\x9a\x1f^I\x93[\x8b\x0d1G\xcd\xf3r\xb1\x11\xe9`\xeb\xa8\x907r\x08\xf9\xe7\xde{R\xa4Y\x0e\x0b\x1e,'e\x91nI\x11-,aX5\xc0\"\xd5|\xa0v\x95sq\x99\xc5y^\x90\xc2*\xc0\xe1\xb9wd\x82\xc8\xc4)\"\xce$\x91\xa9\xd3D\xf0\x89\"\x13\xa5\x8a\x0cK\x16\xb1\xa0\x0b\xcf\xbd\x0bkzH\xda\x88_\xe2\x88g\xea\x88\x8d\x87\xab\xa4\x12l\xf2\xc8\xc4\xe9#\xa8\x04\x92 SH\xc6&\x91\x0cJ#\x99(\x91dH*\x89\x05Yx\xee\x1d\x9dR\xe2\x97T2yZ 6\xb1d\xd2\xd4\x12|r\x89wz\x89\x7f\x82\x89S\x15\x86\xe7\xde=\xd2Ml\x9b`x\xee]\x0bCROl\x1c\x14\x9e{W\xe0LC\xf1JDq\xbd\xb4<$\x19\xc5\x853<\xf7\xde\x81A\xc9)\xe1\xb9w\xcfT\x15\x9fd\x95\xf0\xdc\xbb\xe5\xdb\xc9SW\x9c\xa3\x0b\xcf\xbdO\x91\xc8\xe2Je\x19\x98\xccb\xc0\x15\x9e{\x0f\xcf\xbdK\xf0Nr\xf1Ms \xcf\xbd+\x18\x92\xf4b@\x15\x9e{\x9f>\x01f*^\xf4H\x82\xf1I\x83\xe9>\xf7\x8e\xa8\xc8n\xa4y\x0c\xaf\xc8n&\x9b\x84\x8a\xecP\x91\xad\xfb=Td7 Td\x87\x8a\xec\x1a&\x0d\xad\xf9\x04\xd6\xbc\xc2j\xa1\"{l0m@(m\x92@\x9a\x7f\x18-Td\x8f \x9f\xf9\x04\xcf&\x0e\x9d\xe1\x02g\x13\x86\xcd\xb0A3\x8d=\x1c*\xb2\xdb\x80\x08\x93a\xad$\xef\x10Y\xa8\xc8F\x05\xc6\x86\x84\xc5BE\xb6\xe93g(\xcc#\x10\x86\xa97\xf6 \x82\x85\x8a\xecP\x91\x8d u\x85\x8al\x0ec\x82[\xa1\"[\x87\xc9\x19\xce\x1a\x1a\xcc2\xee\x0d\xa1\"\xbb\x0f\xa1\"{@\xd0\xca\x1d\xb2\xf2\x0dXy\x84\xab\xbc\x83U~\xa1\xaaP\x91\xed\x17\x9c\n\x15\xd9\x15\x1c\" 5\x05\xcfy\x04\xa3\xf0\xa1(\xb5Q\xfbV7o\xd3e\x19\xd3s\xe9{\xc9\xcd\x05\xce\xaf\xf8\x87?\xcb\xefZ5\xceq\x94s\xa7\xa9\xc0\xa5\xfc8\xb9\xa8\x94\xe3%H\xda\x8a\xe76F\xf9\xc5\x17[\xf4\xac%T\x13\x8a\xdf \x10d\xae|Fy@d\x95\\\xa7\x02_NU\xdbFN\x7fD\x9f\xca\xebR\x9a\xcb\x12\xab\x81-\xd8Z&y\x99w\xcb\xa1\xad\xa3l\xb1G\x8b\xc9\x1a\xcf\x89\x13\xc5\xad\xc2\x13\x97\xf7\xfb\xea\xef\xb5n\x9fK\x87I\xb8\x93\xbb+\x1e\xc2\xaf)\xab\x8di\x94\xd5=k\x10*L\xed\xc1 \xe2\xccm\xe1\x1a\x1ej\xee\x08i\xe7\x9b\xfe\xa3\xd3!\xda\x1c\xa2\xcd}pK\x8e\x80\x10m\x0e\xd1f=\x84h3\x87\x10m\xeeC\x886\x87h\xb3 B\xb49D\x9b9\x84hs\x886\x87hs\x886\x0b\x08\xd1\xe6\x10m\x0e\xd1\xe6\x10m6A\x886\x87hs\x886\x87hs\x03\xa6\x88\xfc\x85h3\x87\x10m\xfe\xa3D\x9bm\xf7\x7f\xcbXXb\xb9\x06\xbcs\xe5h\xa3\x85\x88\x9c MU\xdd\x03N\xea\xc3\xba&\xf8\xd7\x0f\x166\xe2\xcf\xf0#%\x17L\x11p_\x8cp*\xf4\x8a\xf1W\xb4\x90W\x9b\xb2\xbd\xcf#\xac\x0d\xf2V\xf2\x8f2\xd8\xae\xa0\xbe\x96|E\xe2VtK\xe300E\xee\x8d\x8f:\xd7\x97}\xaa\x99\x8b\xfb>o\xff\x8bk;qe\xab\xed\x9d\xe7\x06\xf9\xdfI\\\xcf\x14\xaa\xb7\x0cS\xfb&\xf3\x8a\xbe\xbc\x17!\xb5\\L\xb9\x17\xaeB\xc5\xf5B\x91\x959;\xb4~\xa0YB\xe3\xea\xca\xec\x84~*\xda\xb1\xdc(\x07~{\xea\x0cN$6n\x844n\x82\xcc\x8b4c\xf2/\xeeK\xe6\xd6\x85\xbc\x8d\xb6\x8d\xc05\x977\xa7\xcf\xc4e\xb3\xe2,\xaf\xdcA1]\x93\xc5^\xceT\xb9#Zy\nz|\xf2\xcb/6_\xc1\xc4\x1d^qH\x8b\xdb\n\x11\x83\xd6\x13nx,\xda\xb0\x10\x9doCLZ@\x88I\x87\x98t\x0d!&\x1db\xd25\x84\x98t\x11b\xd2z\x081i\x05!&\x1db\xd2!&\x8d\xb4\x92BL\xba\x82\x10\x93nB\x88I\x87\x98\xb4\x06BLZ\xfbM\x88I\x87\x98\xb4\x01BL:\xc4\xa4CL:\xc4\xa4\x1b0E|0\xc4\xa49\x84\x98\xf4\x9f!&\xdd\x08\x8c6\xf0\xd8b\xd2\xbdxc\xfd\x9e1\x0f;V\xaf_26a\x8b\x96\xd1\x8f%\xcd\xdb\x8ex\xbe'F\xb9\x8axIte\xb2\xa4\x99\xe4\x01\x1e\x18\xedFX\xb9\x97?\xcdZ\xce\xa4\x91\x8f_\x03\xe8\xdf\x05u\x95\x8d\x93\xb2\xd8|\xae\"\xcf\xeb\x8c$\x85\xa5V\xfc\xfa\x1bZ\x94Y\x92W!\xf4\xf7\xc7e\xb1I\xb3\xe8\xb3\xf0\xc9\x1f\x01\xc7 \xbc\x81\x8c\"\xe2?)3Y\xea\xff\xccf\xd7%\xe2V8\xf6;\xde\xf9Wj\xee_h\xf8\xb5I\xa2&\x14\xbfA\xb0\x8c4\x89ow\x17Y\xde\x03u\xf7\x03\x88\xc0\x1c\xe0\x01Rl\xd0\x81;\x98*x\x07\x03\x03xV\x84\x9e/\x85\x8e\x0e\xe4\x81w0\xcf\x8aJ\x06\x19\xbc\x02z0uP\x0f<\x03{\xe0\x1b\xdc\xb3s\xf6\x80wC'\x0e\xf2\x01.\xd0\x07S\x06\xfb`t\xc0\x0f\x86\x05\xfd`\xaa\xc0\x1f\x0c\n\xfe\xd9\xc5\x01\xfb\x8e\xe8A\x82\x80p\xc0@ \x1c&\x18\x08\x9e\x01A\x18\x16\x14t\xa9`\\`\x10\xa6\x0d\x0e\x82G\x80\x10\xfc\x83\x840 P\x88P\x99\xb8\xd7E'\x08\x18\x82+h\x08x\xf3\x0c\x11<\x04O+\xce;\x88h\xc5\x86\x7fk\x14?\xca \x03\x8a\xe0\x15T\x84\xa9\x03\x8b00\xb8h\xe7+\xd4\xbb\xa3\x83\x83\x8cF|\x05\xea\xed\xd1\xa9\x82\x8d\x80\x8f\x99\x01&\xe8\x08~\x81GpE\n\x06\x06 \x01\x81\xd7\xe2\x8c\x9c(\x18 \x83\x88\x8b\x0fJ\x02b\x96\x03\x82\x9304@ \x8e\xd7\xd8&\x0bT\x02>X \xc8\x80%\xa0\x83\x96\x80\xa3\xba\x7f\xf0\x12\xbc\x02\x98\xe0x\xa9t\xa2@&\xf8\x063ad@\x13\x10\xe4\xf5\x08l\xc2!\x82\x9b\x80\x19\xa3E\x12\xa6\x0bt\x02&\xd8 #\x02\x9eF\x84\x85\xf3\x05\xd3\x89\x03\x9f\xe0\x0c~\xc2\xd0\x00\xa8\x11\x9b\xfb%ST \x14\x1c\xaf\x99\xda\xdf3\x1d\x12\x145\xa2r\xbct:0`j\xc4&\xec@\x8b\xd7l\xba\xc0)\xa0\x82\xa70 \x80\n~AT\x18\x12H\x05\xef`*\xb8\xde>u\xbd8\x89\x0fra\x03\xab0$\xb8\n\xbe\x01V\xb0O|H\xa0\xd5\x88\x0c\xf1\x12\xea\xb0\x80\xabU \xdc\xaf\xa1N\x1ax\x05W\xf0\x15\xec\x01Xc\x9b\xa1\x81Y\x98\x90w=\x02\xb4\xe0\x15\xa4\x85\xde\x9b\xa9\n\xe8\xa7]\x94!\"T\xa8\x84\xe6%)\xe8\xad\"\xda\xea\xa8l\x8b\xf6*\xe01FXG\x174\x87\x1d\xcd\xb6Q.J\x7f\x8b\x14\xe8'\xba(\x0d\x1e\x0f\xc6J\xd2*\x91\xdb\xb8\xd0\xe5\xf5\xdc\x80\x0d\xaa\xaf\x8a\xdd\xee\x87V\x0c\xafs\xb1\xb0\x885V1U\xc6du@U\x83K\x85W;?\xed\xc8:J\x0c+\xd0\x1a`\xfd\xa1p\xa6S\xee\x08i\xfcU\x95\xfb\xea\xe2\xab\x02\n[\xb4\xd1\x1egL\xe8\xa7\xe2\xfc\x03\xdd\x9b\x0b\x03\xadL\xe2t[\xc9\xbb\xa7\x0d\x9cQ\xf7\xaf\xa2\xf9\xec\x9f\xd2\xe7K\xf2\\8\xb9O\xc9\x9a\xbe\x11\x89\x003\xf1\xbb\x01\x99(l/Ti\xf4\x8e\xe9\xdcm\x9a\x17@\xb9\xe7\x94\xbb\\5M\x8b\xb4 \x86\x10+\x9a\x00\x96\x0b\xb8% \x8c~0\xde=\x9f?\xffGRn\xe7\xc2%\xa7\x8ay\x1a\x95#&\xa7M\x93D\x8b\xb4L\x8as\x8e\xcc\xa4\xdf.I\x0e9-\x8e\xf8]\xdd2T\x91\xf3\x14\n\xc6\x80K\xe1\x8d\xbd\x8cr\xef\"e\x91N0\xbc(\xf9\xb8-\x98\xa1\xfaX@\xa8>\x0e\xd5\xc75\x84\xea\xe3P}\\\xc3\xa4\x89\n>I\n^ \n\xa1\xfaxl2\xc2\x80D\x84I\x92\x10\xfc\x13\x10B\xf5\xf1\x98\x84\x03\x9fd\x83\x01\x89\x06\xa1\xfa8T\x1f\x87\xeacl\xa2\xc0\xa4I\x02C\x12\x04B\xf5\xb1\xe93g\"\x80G\x12\x00\xa6\xb6\xd6'\xf8\x1f\xaa\x8fC\xf51&\x90\x1f\xaa\x8f9\x8c \xd6\x87\xeac\x1d&g@~h0\xde\xb87\x84\xea\xe3>\x84\xea\xe3\x01Atw\x00\xdd7x\xee\x118\xf7\x0e\x9a\xfb\x05\xccC\xf5\xb1_P/d\xd0\xa3\xd1\xc6v\x08~-\xbd\xa7G\xad\xc6Gp\xb9\xa1\x89\x88\xe4q\x86\x16\x01P\xbe\xcd\xca0\xf6\x96\x14\x8bM\x97\xb1\xd7\xd1\x05M\x18\xa6\xde\x81|\xc2Y\xd6\x11\xec\xd9\x07\xba7\xcd\xb3\x13\x18\x96\x91`\"\xb7\xb8\x8cW>s\xa7\x9f\x0cq\xca\x10x\x156\xe6\xae\xbau\xc7\xa7\xc5g \xee'\xb7\x85\x82g\xf0\x9aQ*M\xf8Y>]\xadrZ\xb0\xe3q{\xb8\xd0\x085\xe4\xb4\x98\x98Z\x06\xc7\x8d\x86\x88b|H~\x91\x93\xe1\xa4L\xca-\xcd\xa2\x85\xfa\x1b\xd7\x86\x0b\x92\xb0\xf9\x08\xaf\x15\xe3!I\xf82\xa9\x1c\x85\x9d\xe3\xc1 \xc7\x16\xd3<\xafI(\\ke\xceH\xfd\x81z\xd2\xb3\x8d\xfe\xc0\xc4\xed\x84\xe75\xe4\x8d\xa3m\x84\xa5.\xffV\x05\xb7MQ{\xe1Dnr\xb0\x0c\x85\x97q'\xb8,\\F\xcd?\x9d\xac \xa6\xabBz'#y\x97\xbb2\xea\xb9\xff[\x08\x88\xe8\x84\xd1y\xbe\x07J\x16\x1b \xbb\xddoH\xc5f\xeeA\xdd\xdeF\xcbF\x0b~E\x03\xe5\xf3+\xb2\x92\x02\xfbG\x94,\xa3EuA~MA\xfe\xa1d\xa4&\xba(Y\xc4\xe5\xb2c\xb2\x13\xd1K\x15\x8a\xec\xac\x18\x0fl7<\xe4lkm\xe4\xdft\x94\xcb\xbb\x93\xbc\xb3Z\x9d)p\xf5\x9b\xd1\\f p\xf1\xaa\xe5\x91\x89\xdcLJS\xb4N:\x17R@%\x8d\xed.\x04e\xc6.\xec\x93\xd6\x11I\xf6\xac\xaf9\xc9\xa3\x05?\x93\xae\xa2\xb8\xa0\x19\xe38J\xeb\xcf\xf5n\x0c+\xb3\x81\x93\xe1\x00\x91\x18\x85X$@/\x14\x0cM\x8f\xb2\xe0\xf3\xba\xf5e\xd2\x14)g\x92\xd4\xd4iR\xf8D\xa9\x89R\xa5\x86%KY\xd0y\xde\xf322aj\xea\x94)\xcf\xa4\xa9\x89\xd3\xa6\xfc\x12\xa7\x0d\x03b\xd4\xf6 \x84\x07\x1b\x87\xc6\xad\xc1;vmE\x15\x1el\x1c\x94\xd6;qL\x1bpqm\x982\xb6\x0d\xa3\xe3\xdb0,\xc6\x0dS\xc5\xb9aP\xac\xdb.\x0e\xd84\xdf\x83\xc4\xbc\xe1\x80qo8L\xec\x1b<\xe3\xdf0,\x06\xeeR\xc1\xb888L\x1b\x0b\x07\x8fx8\xf8\xc7\xc4a@\\\x1c\xa12q\xc9\xbf\x13\xc4\xc7\xc1\x15#\x07\xbcy\x86\x88\x95\x83\xa7\x15\xe7\x1d3\xb7b\xc3\xa5\x02\xbb\xae\xa7\x9f4\x1dX\x9f\x10\x0c\xc6B\xbc\x86\xf6d\xffy\xdd\xf4*\x83\xa9\xe43\xbc\xc1\xc0!\xbc\xc1\xf0\xa7z\x83\xa1\xf6@M\x90>\x1f\xde`P\x10\xf2\xe7\xa7\xf1N\xf9\xfa*\x94?\xc2\x88\x10\xeb\xa7\x98\xd4G\x11\xf2\xe7C\xfe|\x0d\x93\xfa\x1e|\xfc\x0e^>\x87\x90??\xd6\xbf0\xc0\xb70\x89_\xc1\xdf\xa7\x10\xf2\xe7\xc7\xf8\x10|\xfc\x07\x03|\x07!\x7f>\xe4\xcf\x87\xfc\xf9\x90?_\x84\xfc\xf9\x1a0\xd9\xe1!\x7f\xde\xf4[\xc8\x9f\xd7~\x13\xf2\xe7C\xfe\xbc\x01B\xfe|\xc8\x9f\x0f\xf9\xf3!\x7f\xbe\x01S\xe42\x87\xfcy\x0e!\x7f\xfe\xcf\x93?\xdf\xa4\xe4\xc8\x04\xef\xf0|\xc0\xd0\xbb\xd9\xc3\xf3\x01\x07$\xae\xfb\xe2\xfb\xf0|\xc0\x14T\x0c\xcf\x07\x84\xe7\x038\xfc1\x9f\x0fh\xc4\xc3\xd8\x8f\xe4\x03\xc97\xb39\xc9\xe9L\x96+\xcd\x8e\x8b\"\x8b\xe6e!\xbd\xd0E7\xaa\xdf\x8f\xe3\xb7\xf2\x864\x02\xd8\xf1i\xf7\xbe\x90\x991U\xc7\xb5\x91\x96s\xad.\x14\xc5\x8e\xf0\xea5\xcd\x88\x9f\x9d\xbeC\x8f\xb5L\xa2\"\xef\x8e\xa5\x93\xb3\xa0\xcfT\xb8\xe8&\x07\x19\xbd\xf1\xda\xfdPN\xf2\xfa\xbb$*D&[\x0e\x8b]y\x04[\xbaM\xb3=7v\xd9\x9f\xf96O\x8b,Z\xe4\xd7ec\xa2\x08\xd3\x1bx;C\xa3\x97\x99\xa1\x9d\x9d9\x13C\x93\xffe\x9c\xa36Na\xf8\xdak}\xab\xcf\x9f\x9d\xbeSt\xaa25\xf8\xeaqR-v%;M\xae\xa2u\x83\x1fn\xa4\xb2\xa30\x9b$O:\xaa\xa6B\x97m\xda+ \xc9\xfe\xb0c\xecE\xfbE\x8f@\n\x91\xe7(\xce\xe3\\\x95\xf090b\x0b\xc5\xa2\x9bD\x17WwJ\x7f2\x01\xd46Q,^\xd3B\xf2\xb8d\xf1\x06\x8de\xfc\xa9%\xcdZ\x11\xd4K\xeb\x1b)\xea\xefj\xdb\x1b!\xa5\x8b]9H\xadw,|ck3\x06\xd0m\x0e`[;\xb0e\xde\x8c\xd8(\xc0\xc0\xab0L\xfc\xb4\xb9\xd9\xb6\xbclCE\x88\x95\x0e\xc6\x0c&K\xab\xe1\xfc<\xec\x94\x00<\x1cT\x9b\x1a\xe0\xc7b}\xb3\xc3\x88\xc0\x8c\x04\x02\x97I\xf8\xf2\xb9l\xa8\xe9\x02<4\xc8\x89\x1e\x18M@`4\x1b\xa3\xbd\x95\x84\xb3r\x9a\xa2n\x8f\xd5\xd4)\xec\xd0VM\xcb?\xd2D\xa1\xa5F\xd7W\"\xc0\xe41Q\xbf\xea\xfc&\x02\xac\xde\x13\xf5\x89=\x91t\xdc1\xbb\x87N\xe3YQ\xfdLw\x00\xaf\xc1\\I8\xf6t\xdeC\xd8\xf2\xb8\x08\x18\xe5w\xe9\x0f\xbee\x1c6\x91\xc5q#\xa0\xa1\x04ATy\x88+\xb0\xc4\xd8\xd8Tn'\xe9R))Z,T\xe0!Z\xc9$\x94(\xe7\x89Z\x954\xc9\x0cu)\x93*\xb0%\x9e\xa4_\x92\x82\xdc\xca\x8b\xac\\\xb0S\x9d\xdd\xa0\xfd\xb9\xd6\x0d\x08\x83\xb6\xa5\x83\xb5\xf2\xd2\xd3\xb9\x03u\xadf\xc8\xead\x8b\x1em\xf7T\xea\xa1H:\xb3\x9a\xe6\x14\xda=\x81\x8e\x1eOK|\xa6:mv\x86\xdd\xed\xaa\xf2/46\x04\x9e\\/\xe2td\xc1\x03q-\x8fCu\x1akz\x1a\xaa\xd2-u2kv,\x7f:\x8e\xe3\xd7+\x9e?\xb3\xcb\xe8\x82.)\x7f\xbexFgL.\x8a\x0d\xcd\xc4c\xc6\xd5\x8c\x13\xa6'\x8al\x0f\xc7\xc9\xfe\xf5\xaa\x1f\xdc\xcb\xe8\x9adK\x1e>/R\xaeZ\xb6$\xa9\x82|\xac\xa9\xac\x96\xcc\xaa\xd8%_\xdf9\xdd\x90\x8b(-3\x19+[F\xf9\xa2\xccs\x93\x07\xf0m\xd3\\B\xf0ip\x01r\xf8\xc2=\x10\xa3\xcd\x1b\xc1)\xb5\xca\xaf\xf8\xe5y\xf5'4\xcb\xd4X\xce\xa3^\xa0\x07\xc57\xe9e\xd2\xbd%\xd0@\xa7eN?\xa2>4\xe6(H\xd2\xd5\xf3\xe5\xa0\x0d\x88\xae\x00\xd9\x1d\x04Y\xec@\x90E\xed\x87\x13\xc9\xe2\x98L\x9e6\xf4\xf2z\xda\x80X#\xcc\xea\x04q\x0c\xe2h\x02\x8fU\xf8R\xc5qx@\xb0\x0f\x9a\xec\xa76\xb8\x17\xdc\xb1\xd8\xa8\x85\xc6-\xb2.\x87\xaa\x0d\xe8\xb5\xd0\xe7W\xb5\xc1\x9em\xd5\xfd\xd6\x9c{\xd5\x06D&V\xb7\x81\xfb\x82\xbf\x1a\xbc\xb3\xb4\x1c\xf8\\\xd5p:8L\x06W\x1b\\\xce\x07\x05~\xd9]\x0ed\xd6\xca,=\xc8q\x0e\xcd\xfc\xd2\"3LzpV\x98\x16['S\xac\x99#\xd6\x86!\x19c\xfa\x1e\xbbYdm\xe0i>:\x99\x15Bo\xba\xff\xdd\x14\x82P\xb0\xcb\"\xfdsw#\x8f\xffK\x9a\xa4F\x15\xe3\xd4Sdk\x9a-\xb8\x9bc4\xc6\xb34j<\x9a\x01E\xfa\x81&\xf2:O1tu\x0f\x02\xdbLH\"\x07d\xba\xbd\xf2\xa7\xd7g/\x1e\xf3\xfb\xb7\xc4w5G\x90\x04N\x92Bz\xc8+Ik\xde\xf3\xa3E(\xae=\xd3w\xd6H\xeaRu\xff\xfc1\x91t\x9d\xf2Ku\xbawc)3I\xc9\x87\xda8\xd9q\xf2H^\x0b!n\x8a`s\xe5\xfc o\xf4\xe0\x9f\xd7&\x93D\xc4\x03\x07owt\xa1\x10\xc9 \x94\xbc\xadV\\\xf6,\x1bM\x90E\xf0\x9d\xc0\xde\xec*Z6\x93\x07\xda\x1dWa\x07k\x12\x01G:\"\x7f\xa0\x11\xfb\xe9\xc4\xc0,\xf1\xaf/&\xcf`H\x84k\\t\xeb\xc0\x91\xad\xc1Q\xad\xc1\x11-;g}\x01\xd1\xfcn\x98Z\xbfK8\xc4n\\8Z\xfe\xe2\x16\xc4\xb7UP\x10A\xb0v PC\x0e}\x00P\xbb\x9d\xe971C\xd0O\xf1\xca\x88\xd8^?\x92g\xdce\xcd\xfb\xab)zg;\xaa8\xc2<\x86\xadt\xdah\x9d)Rw\xb0qk\xb7\xfeaQ9}\x8d0\xe8\xea\x84!\x14,\xd9\x8e\xf3\x93F\xd9\x10\x116M\x88K\xb7\ncs\xa6\x8d\x91\xb4\x81\xabh\x88\x9e\x8d4\xca\xad\x113\x84\xa7\xc2\x85\x1f\xdc\xae@\xa7\xe9/\x00\xe1\x02\x9c\xcc\xfd\xe7v\xfd}Q^ \x97\x9b\x0fIa\x84{\x0f\x85i\xa0\x1eh5\x9e\"\xdae\x8et\x8d\x14\x1a\x97;\x1d\xb1\xb6\xae. \xc8\x8d\x1e\x10\xb4\xc5Q\xf7\x8f)7\xd3D\xa6,Q\xa9 :-\x08\xa2\xa3\x07$\x85\xbf$\xd1\x99*\x8ad\x8d \xd9\x17\xd1\xb2\x80\xce\xc5s/\x9c=Z\x84\xa2\xb3+J\x84\x8d\x10\xe1\xa2C^\x91!\x8c\x8fW\x80wD\xc8\xfaP\xbf_4\xe8\xd0\x91 L\x14\xc8/\x02\xc4c<6]\x8a\x8e\xfeL\x16\xf91Or\xba\x88\x0f*\xda3I\xa4\xc7\x12\xe5\xd1Fx\x84\xa0\xea\xa3;\xe6\xc8\x8e6\xaa3\xf0(j\x8c\xe4Xu\x889\x82ci\xe6\x92\xea\xe9\xa26\x93FlL\xd1\x1a\x9fH\xcd$Q\x1a\xcf\x08\x8d\xd1+\xcb\xef}\xae\x0b\xc1\xd4\x03\x04b5{l\xd4g\x9e\x1ae\xcd\x00Z\xee\xd3\xf3\x9d\xa1\xd8\xda\x88\xc5\x8c \xf4\xc5a\xe0`\xc3^\x81\x97\xa3\x81\xa5X\xacZ\x14\xdf\xba:\x05\x9d\xe2-\xb0\x8dD\xb7a\xeb\n\xb9\xa0Qn\xda\xfbs\xa7\xe8\x07lEZ\xe0\x14\xda\xd1\xc1\xab\x0e\xbe^\xc1\x164\xe62\xaet\xb6\xc66\xba\x84V\x81w|\xa9W\xc0\x0d\xba\"n\xb01\x81\xe1\x1c\xa3\x0b\xc5\xa2\xf0hK\x17\xc7\x15w\x83\xaa\x07;\xb0W\xb6_TjEcC\x05fM\xe2P\x0dzm\xe24\xc1-\x1a\x05\xb4E\xa8\x02l\xf6\x028\xb2A\xcc\x96\xd6\xf0h`\x0f\x95Y\xd3iu\x9d\x95N\xa6k\xc2\xf4\x1a\x0f\xfa\x05\xac\xea\xcf\xbd2V\xf5\x83\xbd\x9aR~\xa4\x11|\x87\xceti\xcdQz\xb3\xcf\x81\xfd$\x80fGC\xd2\x01\x9a\xed\xc7$\x064\xf1\x1c4E\xa0\xd9\xd1\xc0d\x81\x1a\xbc\xd5z_\x14t\xe5\xb0\x12\xf90\xe5\xd4/\x90\x15`U3\xe6b\xd9f\xe3\xc1\xfe?K\xf9\xac\x00\xf7\x01\xd6;\xdcn\xc4d\x0b\xc3\xd7\xe0\xf4\xbc\xb8g\x0d\x8e\x12[\x01n\x07\x1f\xb8\x9d|\xe0Z\xe0\xc6gNRC5nd\xac\xdf\x8e\xc9\x9ey\x0d\x8e\xda]\x01_(\x91|s\x08\xac\xd8P\xc9\x13\x02\x82\xdb\xd8\x00(L\xa3\xdc\xc6\x80\xe2\x8e!i\x0d6*\xf7\x8b\x8a\x05 \x12\x1fj@T\xf9\xfe6.j\xeb\xc0\x048{\x01TO`/H\x16\x80\xea\x0b\xd0\xfd\x81+\xe1\xa2\x06t\xcf\xe0\xd5;\xb8cc5\xa0D\xa8 \x88xY\x0d\x93E\xcejp+\xc3\x1a\xdcj\xb1\x06\xc4n\"\xc0k\xd5|\xd7\x0d\xa1>k\xf0^;\x84J\xad\xc1\x13\xfbh5\xdbB\xe3\xacp\xc1\xe6\x8e\xa0\xb9\xc9\xf2\xa1\xbd\x9aZ\x00\x9a+\xf0\xfc\xe0\n\xa3\xd7\x80\xee\x1c\xbc\x06\x00A\x91H\x08\x8a\xa4\x0d\x7f E\x82O\xa6A\xf3\x93\xe5CG)\xb8\x004c\xe0Y\"\xe8\x92\x1a\x82.\xf1\\\xb7\xa0K\x90\xba\xc4'\xbb\x08\xcdQ\x96\x0f\x9du\xec\x02\xb0\x1c\x87\xe26\x0fN\xf3\xe12w\x95\xbb\x00O\x06p\xe52\xd5\x80\xcdj\xaa\x01\x97\xdfT\x83W\xa6S\xb3\x196\xe7\xa9\x06t\xf6\x13\n\x1b\xe6\x01Q;\x1c:#\xaa\x06\xac\xa8\npgI\xa1\xd0\xa0\xdf1\xb5\x01~\xe4\x1e\xc9UN\\\xe6\xb2{\x01\x98Q\x0dJ\xc8\xb2\xe0\xd3<\xd9b.\xc4\x170I\x92V\x0d\x8e\xa2|\x01\xc6\xd2|\x01BS\x99C\xb2\x02\xece\xfa\x02\x8c\xc5\xfa\x02P\x1a\x19\xa7\x8b\xad\xe5\xfb\x02\x90\n\xd8^\xca/\x00\x85\n\xaf\xfe<\xd3\xc4\x9c\x837\x95\xfd\x0b\x18\x94Jf\xc1'\x92\xcc\xacW\x00\x08\xf0I/\xaba\x92D\xb3\x1e:l\xcaY\x0d\xa6|\x14+7\x98\x84DMj\xcce\x01\x0c\x18\x8b\xa5\x97\xe7\xf2Q\x9dz`Z\xc9\xd2K\xd2\x04\x19k\xf9\"\xddi\xc4\xdcB\x97O\xfd\x1c\x17\xcb\xf7\xca\x18\x16\xb3k=\x1f\x91\xb6\x9ew\xb7\xfei\xf3Ru\xf9\xf1VD6d`\xcf\x98\x17\xe08\x1a\xb8\x0e\x05\xc6\xccW\xc0X\xef\xa6\x0cX\xc04vf\xc2\x8e\xce\xb0\x17\xa0\xcd=\x05\xf7\x08\xcd\x8e%s\x1e*\x98\xf3\xef\xd5\x8f\xfa\xbd\xdae\xc1\xa8O\xdc'\xa5)\xf3K\xc1\x95c\n\x93\xe7\xe8+\x9c\x93e\xea\x0b\xf0N\xec\xd4\xe6\xeb\x0b\xd0f\xed\xcbn\xec,e\x0db\x98\xcfM\x80\xc7l\xc9\xfe\x1e\x9f\xd9/\xa0\x9b\xdf/;1z\xa0\x0d>g\xab\xe2\xb2\xab-S\xf6\xbf\x00\xa7\xb3\xc4\xa5\x13\x1dZ\xd1\xb9\x16\xe0\xd0\x8c(\x04\x08\xed\x08\x96j\x01\x01\xa2\x9f\xf1\x0e*\x97\x8bp\xc2*\x02\x01.\x9dn\xd1\xea\x08\xea\xdaB\x06v\xddn\xac4P?\x1a\xea\x0d\xd4\xcf\x984v\xf9\xa9Q\x95\xa1v\n\xdc^1`\xb70\xf1\xbb\xedb\xc2.\x8c\xadLPX\xa6\xa9OP\xd8\xae\xa8JAu7\xbaVA\x80\xf7\xc6f\x12;s\xdd\x82\xech\xbcZ5U2\x08p\x8a\xad\xbb\xaaA\x80s\xa4\x80\x1a-`\xea\x1c\x04\xb8\xf4\xa3\x82\xe9j\x1e\x04\xe0*\x1f\x04\xa0\xa8\x02h\xca\x00\xaa\x16B\x80\xd96\xe8\x03*B\x0d8vi|\x8c\\ \x98\xb4RB\xe2\xc3\xc4\xf9\x01U5!\xe0wFN\x8f\x9a\n\x04:\xfc\xb5\x94M\xc0f\xef`I\x8b\"+Z\xe2|d\x0e\x9d\xa9\xe3\xb5\xa0\xe8\x0c\x1d\x0f\xacW\x9c\x99\xe3[\xa1\xe1\x1a\xbd\xe9\xf1\xb7\xd6G>\xd5\x1a\x02\xd0\xa5\x11v&t2 \x92\xf9\xb0\x8c\x87\x18\xb6\x00d\xbf\xe0\xd17`j<\x04x\xf4\x0e\x9e#\x00|\xd5\x87\x00\xcf\xb1\xc0\x80\xf1\x80O\xca\xa5\x00\x0f\x01n\x82W\xfa\xa5\x00\xac\xe0\xd6\x80H\xd7D\xe3\x92i\x9d\xa8\xef\xb1\xbbC\x0d\x18\x11m\x83S`\xdb0\x80y\x86\xb1\x0fz?\xa9a \x0b\xa1\xf7\x98\x1a\x06\xf54\xd1\xbe\xd3B\x86d\xe2\x89JV\x04\xa0\x0c\x1b\x01\x98\xf2\x15\x01\x9e|\xe5\xcbQ\xf8$t\x01\x9e\xc3\x81\x01C\x82\xa0#M\x10t$\x16\x82\x8et#C2\xf1d\xd58\x02<\xb4$\xaa2G\x80'k\xf92UP\x93AM*\x08j\xd2\x9f\x85\xfe\x04jr\xc2B#\x01\x1e\x8a\x12Yt$\xc0\x8f\x7f=x\xd7\x9bo\xfdy\x16[\x92$`\x10\x0b\xe1\xcb\x93\x04\xf8\x17) \xf0-U\x120\xb0`I\x00.\xc2\xa8\x03L\xf1\x92\x07:sY\x91W \x93\x80\xab+d\x12\xe0\xa7\x16\x04LT\xd4$`\x92\xd2&\x01\xbes\xc1\x969!\xd1Y\xdf\x18m\x02~\x9c\x9e\x85ON|\x85\xba\xa9\xda\xb7\xfcI\x80_\x11\x94\x13\x1d/\x92\xc2\x95B p\x14D \x10z\xd2\x95u\"\xc0\x9d{\xa2\xc0Q\"%\xc0c\xcf\xf0\xd9-\x10ES\x02\xbc\xb6\x08L\x01\x95\x00\x0f\xb4\xbeJ\xd93W\xda\x89\x0fSX%\x00\x97]\xedD\xa3\xcd\xbeF\x14Y \xf0\xc9\xc0\xee\x02N\x8b\xf8\x95cYQ)i\xd7~4\xb8^K\x80=\xfb\x10\xc1\x82vI\x9e\xaa\x8eK\x80\xa9\x9aK\xf6eV\x026\xa1?H~\xb5\xa1\xe2K\x80\x93\xa6\xda\xea/\x01\x8e\xb6\x83*\xc1\x04\x0c\xbb\x0c\xf9\xea\xb3\xac\x8d\xb9a\xd6\xdc9S\xfd\x98\x00Df\x9d\xbd\x96L\xc0\xf8\x8a2\x85g\x9a\xba2\x85m\xca\xea2\x85s\xfa\x1a3\x01\xc3+\xcd\x04h\xeb\xcd$\xeaq2\x1d^@\x1fV\x03%`\xca\x17\xd0-uk\xf2\xe7\xb0\xd2\x7f\x94\x956\xd5\xbf pP\x13Q\x1e\xe1Y\x11\xd7j\xdbY\x9f\xd1\xd5q-loN\x9f\xd55r\x0cvd-\x17\xb6\xa6\x84\x96\xd1\xf5\xec\x9d\xd0O\xc5y\xcfSk$\xa0\xd1]/\xe7\xde\xdb\x02\x15~\xa5\xfd\xd9?\x8b\x14\xe6\x14v$g\xfbM\x91\xc2)Y\xd37\xf4cI\xf3b&~\xef \xf9\xc8(\xc2\x9b3tl\xca\x14\xb6i^\x00U\xf9\xd5q\xd3\xdd\xc8\xcdi\xcf \x99_t\xe9\x89\x9b\xb0\xd6\xd9|\xf8?d\x11\x83\xb8<\xa1\x8c\x8b\xbc\xe1\n\x88\xba&|s\xaa\x9c}\xce9\x92\xaeX\\\x92\x9c\xb1\xf8\x11DE.\xfd\xca\x11;,\x08\xf1^BZlhv\x19\xe5\xf5\x1a\x98\x0d\x11\xd1e\xcdt\x82\xfat;\xa7\xcb%\xdb\xef\x13X3\xa6\xaaxqK\xf3\x9c\xaci\xce\xb6\xe8\x8cv<\x07\x8b4\x13\x1f.\xa3d\xcd\x85\x95\xe6\x85j\x02\x1b\x92C\xc9\x16\xb59\xcd\xd6\xdc\xd4\x97o\xd3m=\xa8\x7f\xe9\x94BFw\xfc\x0c\x02OIVQ\xf6 \xdc\xfd\x0f\xdd\xc7\xad9r\xf6x\x02\xf7Z_\xfe\xca\xff\xa3\xbb\xa4\xa6ZR\xbcp\xe6\xfe\xb5\xab\xfc\xd4\xe3]\xb5\xca\x0f>\x83D\\_ e\xdc\x0c\xcd\xdb\xe0o\xfd\xc4\x92\xa9\xc0\xc9\xeeb2k{\x93\x80OV\xc0\xf4[<\xf7\xa4\xbd\x135\xa6\xa0h\x9aB\xa2+* \x1a]84\xba`\xc8T(4@\xbd\xe8\x0b\x82,\xca\xc2^\x00d\xb5\xf6\xed\xb6\xbe\xa3\xd0\xc7\xe5\xea\x9b\xaa\xb0\x07S\xd0\xe3\xf4q\xbbN5\xee\xc2\x1d\xd1\xc5$\x19\xe8\x0e\xa7\xb5\x8b\xb00aA\x8e3\x02\xee*\xc0\xf9\xc2\xc8\xe2QXS\x93\xc9\x82\x10SP\xe3\xcaoq\x91\xc8J\x1e'gcx\xdb\x99\x85\x82Z\x00g\x86 \x02\xcb\xc8\xec\x11\x17\x0f\xf8\x16\xbcX\"\x82\xc6B\x17\x8f\x02\x17K\x85\x88\x8d)\x8c\x0c1\xd2u\xe3,X\x99\x88\xd9\x1c\x85)\x88^\x00\xd9\x13`\x0bP\x90}\x82G\xbf\x80\xcf\x0eD\x08F\x13<\xb2\x01U\x0c \x91\xdb\x87\xbb\xd5\xdb\xa5\xccjp\xa9\xb5\x1a\x9c\xfa_\x80\xc7\x1a\xf9\xad\x92S\xfd\xd5\xe0\xb9RN\x95X\x83\x17\xe6\x91j\xb2\x85\x04[\x80\xe1\xb6\x050E\x15\xc8E\xc4.\x1f6+\x18\xd9-xt\x0dA\xbe\x83|\xff\x0e\xe4\xdb\x91k1Qm\x01B9 j \x90,\x80]\xfc\xa0\x1d\x82vp~\x1b\xb4\x83\x05&K\xa9G\xe8\x07T\n=\x8e\xaf\x10<\x85\xe6'(\xe5\x1d\x13\x8do\x03&\xc5\x1d\xfb>\xc7\xd8\xd4\xf6\xabJi\xc7\x89\xa1\x00w\n{31\x1d\x81p`\xea:v\xcc\xd8Tu\xf7\x8b\x1c\xf6\x14u\xf7x\xb3\xc0\xbc\x81y%\x1c\x94y}\x9c?z\xf65\xb8tLK\xa0%\xbf\x85\xf46\xb2\x9b\x9c1\x0e\x8a\xd9j\xab\\\xde\x0f\x97S\x05\xe9F\xc1\x9c5\xd0\xae\x92\xda=\xa1\xc5\x83u\x8e\x1c\xce\x1db?\xbc\xfb\xb9<*\x87\x86\x16\x97\xcb\xc9!G\xe2\xe1\xb5\xe8\xf9%t\x93\x19\xe4{`\x1a\xb2\x81\xc3\xe1m\x18\xe2_\xd0\xfb\x11\xb4O\xfdu}\x05\xbaCS\xc7\x1f\xe0q\xa4\xd0\x9c\xf2\x0d2\xaa;\xc9k?5\xa7\xf9\x0f>\x9f\xd7(\x06\x1d\xc8;\x07\xef\x1a\x1b\xee\xa4=\xc1\xd9Z\x9c EUNuz'+\x88\xe9\xaa\x00\xba\xdd\x15{\x88\n\xb8\x8c\xe2X)K\x86U1\x9d\xe8\x80\x91b\xbe\x07J\x16\x1b \xbb\x9d\x9aw\xa3\x00\xbb;\xfby\x9a\xc6\x94$\x88y6\x90\xb0\xd9\xf2\x15N\xa1\xc8J\n\xec\x1fQ\xb2\x8c\x16L\xf1\x88\xf2\xafjv\xfc\xc3\xde\xbaD\xc9\".\x97\xb49U\"\x8f?\xb2\x9a\xa7KI\xeeXj\x9c\xb6\x99~\xab\xaf\x04`\x14}w\x92\xb7h\xd7\x19p\xca\xb8&\xa3\xf9\x8e.*?C\xcd\xbd\x8cAg\x92\xfd\xa2u\x92f\xf2\x93\xb6\x98\xb7N\xecy\x93\xb5\x1aJ\xa3E\xd1\x8c^\xd0,\xefiJ<\xd9%\x82.\xc9\xa3F\x15~F\x0d\xfc\xc5\xb0R^\xc1\xde\x94\xd8lI3\xfb\xb0\xf5\xe2\xde.i\x17\x05\xf1\xbd\x8a\xf6\x97i\ny\xba\xa5\xe7;\x92\x91--h\xa6\xadeo\xe8\xed\xe6*6\x8b\xd9[\x85\xec\xd5 \x9a\x0dm5\xfe\xadz}q\xf5`\xa5P$\xaa\xba\xdf\x19\xbc\xf8\xf4\x18\xb1\xcfxV\xb2\xf7\xaf\x9c\xc0\xef6\xddy\xc3\x14WLx\\/\xa1U\x168U\xa9\x1b\xba\xd7U\x12\xc6\xcb#j|~\xf7F\xe8\xf9y\xb2\xfb\"\xc6\xdc\x15\x81\xbb'\x02}G\x84\xfd~\x88_;<\xae\xb8\x9b\x9d\x92\xd0\\\xdd9\xbfi8\xa3{n\xeb}\xa2_\x8f\x91g\xb5\xe9\xcei\x983\xda:M\xd71\x9d\xf1\xff\x9e\x97\xab\xd9q\xb2GS\x90}r^f.\xf12\xef \xc7\xf0\xee\xcd\x8f\xb7+\x17qB\xb6r\xdb-\x93\xe8cI\xe3}m>K\xb3d\xbf\xa3rcm\xa0\xc9i\x16\x918\xfaL[iD|J\x8b4\x86y\xb9Z\xd1Lq\xe8L8\xf2\xc5\x18Ea\xed\"M\n\x12%U-n\x13\x0b3\xcf\xae\xdd\xbe\x06\x8b\x0d\xc9\xc8\xa2\xa0\xd9\x8c/MLrf\x11\xac\xf9\xed\x12r\xa7\x7f\xf7\xe6\xc7\xeb9\xecH\xb1\x11h\xab\x00W\x13\x1f\xfbpU\xc6\xf1\x1e>\x96$f3[\x8ay+s\x81\xcd\xf0\x06\xc9!J\x9a\xcd\xde3\xb4\xb7\xbb\x8b\xf5\xbc\xcc8'\xbd\xbf)F\xc5\x11\xd5F3\x9b\x123\\\xd3$Z\xb4\xb4\x0eSxM\xec7\xe8l=;b\x93\xe7\x92\x7fmv\x0d\xa4\xbb\x9e,\x16tW\xd0\xe5\xcdv^\xd8I\x02;F\x8ehA\x8f\xa0\xa0d\xcbTCI\xd8\xb4v\x19]\xa4\xdb]\xc44`\xc2v\xf9\x0d\x85y\x94\x90l\xcf\xc3\x0c\x05\x0f)t2g\x8bM\xdb$\x91\xc5\xf6\x117\x13\xca\x9c*;\x80-\x14S\xf8\xe9\n\x8e\x93\xfd\x0c\xbeO/\x99Uq\xc4\xb7\xc5wo~\xcc\xa5l\x949mco\"\xcf\x17\x1b\xba\xa5\xf0~S\x14\xbb\xf7G\xe2\x7f\xf3\xf7G\xcc\xf4NR\xf9\xeb\x11_wf\xf3\xa7\x9co\xf9\xcc\x98\xd9R\xee\x98D\xefwm\x8c4\xbb\xa0\x99\xe0\xdc-\xd9\x89\xb8\x89\x18O\x91V\x9a\x91k\x84Hdg\x11\xb6\x93\xc7qz\x99?n\xd1\xf5\xdf\x99\xa1\\\x8d\x82-\x82\xac\xed]V\x03\xe5\x8a \xcf\xcb-]\xce\xdaM\x8f\x13\xf8\xfe\xec\xec\x14\xbe{q\x06i\xa2XR\xf0\xe2\x9e\xeb\x10\x02\xff\xe8\xb2\xd0\xd9~G\xff\xf9\x8f\x7f6\x10\x81\xda\x87\x12\xb5nb\x7f\xe4\x14\xdae\xe9\xb2\\P~\"\xcf\xb24\x9b\xb5G\xb0\xdb\xc5U\x06\x1a3\xe7\x08\x9b\xa3\xd8\xd0\x17d\xc1\xe4&M?\x94\xbbJ\xf53\xed\xbd\x94\x83m\x0d\xe1\xdd\x9b\x1fy\x7f\xfcj\x80bC\xb7\x0d\xbeZ\n\xc6\"jx\xec\xdf\x17i\xc4ti;\x86+:\xe3\xa2\x91\xd1U\x9a\xd1#\xd5\x84a\"E4\x8f\xe2\xa8\xd8CB\xe9Rm\x9b\\d\xb3\x8bND.M\x98\x02H\xd8\xa6\xc9X\x9a\xf1\xf0\x0cn\xbc\xcb\xa9zk\x9d\xcd\x91-:\x93@\xb1\xea$\xe9\xd6!\xcc3J>0\xf9\x92\xa8f7[\xee\xb9\xb4\xa0\x8f\xc5\xcd\x08\xab2Y\x08\xaec\xa3\x93\x92\xb8(\xb3\x8c\x1b6M\x13C\xacr\xca\xad\x9e\xf6\xa5Tj\x81!\xa3<\xd8x\xc4w\x1bq\xc0c\xe8\xf8N\xces\xfd*^\xe5G\xf9\x84\x0d\x90mV-\xa5\xb5\xdf\xd1\x99\xe0\x1c\xb2\x8b\xf2\xd9\"\xdd\xb6\xf5\xc1[\xce\xaf\xb90W\xc49\xb7#_pC\xe6\x15\x8a\x13\xa0`\xf0\x9b\xb0\x8d\xd6\x9b\x02\xe6-q\x12gl\xb6_V{\x9c\xd8/U\x8a#\xe4tK\x92\"Z\xe4\x8a\xfd:\x89 x\xf3\xd4\xbc7\xbdbb3\xa7\xe2`\x1a-\x1b\x9bLog\x91\xaa\x9b\xcc\xd3\x0b\xaa\x06\xd9b N\xbf\xaf\xcc\xfd\xbd?N\xf6\xef\xd56\xc4\xf7y\x92\xcd\xa3\"c\xacj\xe9Wi\x16\x12\xa7j\xd1\x04>\xa2\xc8\xc9\xe4\x9f\xab\xa5:\xd6\xdb\xd9F\x9b\xf8\xd5\x0eY-\xed\xa9b\xa28\x9a\xf3\xc1Hm\x94C^\xeevi\xc6\xf5\xf3\x8e,>\xdc.\x13\xf6?L+\x8b\xb5\xc8\x15o6\xb7\x9at\x05e!DN\xb1x\xce\x84\x9c,\x97\x91\xe0wX\xd3\x84f\xdcB\x14\x96L\xae\x86\xc90\x0b2*l/>\x11\xc6\x1ep\xf71\x9c\xb2\xbe\x19\x7f\xcba\x90\x8a4Q\x02\xcf\xfe\xf2\x97\x96\xa2d'\xbbU\x9a\xc2\x13\x98\xcdfM\xc3\x93uA\x92}\xf3O$\xd9\xcf\x18\xf2\x97Y\xba\xbd\xb1J\xd3\x9b\xcd\x1fg\xb3\xa6\xf6\x8bVp\x83}\xfe\x8e\x0f\xe1,\xbd\xf1o\xec\xfb\x9b\x1d\x1b\xb8\xdd\xe6\xd7\xee\\\xee9\xe6\xf2WrA\xbc&\x03O\xf8N\xc90!\xc7\x1f\xe57^\xa6\xe9l\x11\x93<\xef\x0d_t\xc5>\x13\xa3k|\xfa\x1f\xbayU\x13\xbb\xef\x98\xd8\xe9\xbe\xd8\xa4Ikj\xa2\xaf\x97izc6\x9b\xddl/\x8a\x98\xd6\x8d\x9b\x9a\xa5\xe2\xd3\xb4\xcd\x92}x\"&\xf9\xfc\xc5\xdbgoNN\xcf^\xbf\xb9\xd9\x8e\xce\xd4\x0b\xd9E'\x10v\xa7\xf7\xb5cz\xdf\xa5\xcd\x99\xf1\xa9=~\x02\xff\xb6\x9b\xcf^\xa6\xe9\xbff\xb3\xd9\xaf_\xb5{?b\xdb+\xfbf'6\x9bW$\xcb7$f\x93\xee\x0e\xa8=\xc1.\xee\x16\xe2h\xd5A\xfb.\xd9\xd6\x88y\xb7\x9cI\xf8W\xff\xe3 O\xe0\xe8\x9c\xe1:\xbdU+\xcd\xccO>o%\xb7\xcapa'\x8e]W\x8fp\xef\xdf|_9\x00\x99\xc1&\x11]\xd7l6\xb7\x99\xc5<\xe3?\xb0\x0d\xf6:\xb3\x9f*=\xc6t\x1c\xa3;\xfb\x83\xa0\xbdBU\xa9\x90$\xdes3Rg|W\xdb6\x90UA\xc5\x1e\xc5\xad\xfb\xeb\xb7\xaf+DR\x97\xa9\xee\x84\xbdI\xe5\xda_[\xa5\xe9lN2>\xd0O\xb7\xf7\xb3\xcf\xd7\xc4\xfc\x84\xcd\xd54\x16y7\xd7\xd8\x17L\x8d\xc9?\xfe\xf5\xed\xeb\x9f\xd4\xbf\x9fa#\xeb|\xa1\x1b\xde\xc9J\x9aJ\xed\xb5\x11\xf4\x8dr\xb8\xa4q|\xebC\x92^\n\x1f\xc2\x86\xe4\xec\xa0'<\x00Mvj3\xc0\x910\x05:\\!D\xb1\xd1\x19[\xf0d\x0dD,\xb7B\xf5\x9e\xb3\x9aZ\xf5M\x1a/[~\x07\xce\xa8\xec\xbc)\xb9\x05\xe4\xc9O2\x8b\xc2\xc2QV\xdc\x017\x98\x1c\xa9\xc9\xf5\x8e&\xeat\xfb\xcf\x7f\xfc\xf3\xe6\xe3\xf1+\xd7F\xda]<>=\x86\xe4\xee\xec\xde\xdd{\xf9\xb5\xd6\xb2\x00\xac\xb3\xddb\xb6&\x05\xbd$\xfbYV&E\xb4\xa5\xb3\x17\xec\x04\x84\xf6\x96\xd0\xfak\xd0\xdb\xa8\x8bt\xd93b- o\xf7\xef\xc9\xbfJ\nZq/iA\xa2\xb8Wi\xd3N|\xed%\xbd\xf6\xa6%\xc0\x94\xecZ\xf4\x1cBM4\xdaDWW\x86\xe9D.\"\x01zG\x91\x80i\xdcE\x02\x86;\x8dz\xa8\xb4N$\x01\x03]I\x02\x06;\x94z\x98*\x07S\xcf\xad$\xc0\xdb\xb9$`\xa4\x8bIC-\x11\xce\xdb\xf7\xbb\x1a\xe9n\xea\xe1\x93\xa6F\xbf\xa3\x91\xae\xa7\x1e\xbe\xbe+J\xf63\x99CJ\xc0\x08\xb7\x94B0\x99sJ\xc0@\x17U5\x9a\xc9\x1cU\x02&qW \x98\xcei%`\x12\xd7\x95\x00\xbb\x03K\xc0p7V_\x8bj\xdcZ\x02\xc68\xb7z\xc8\xba\xce.\x01\x1a[B\xa7\xa5\xc69\xbez\xe8\xe6\x1aa\x1e\xe0\x0e\x13\xa0\xad\xd6\xb1l\xc5\x96J(\xd7.=\xd0Y\xd6W\\\xcay\xd6p\x99 \xb0\x8d`\n\xf7Y\x0b\xa18\x02\xb5\x97b\xa4+M\xc0x\x87Z\x0b]\x7f\xc3\x1d\xe9bk\xe1*Z\xee6\x01C\x9dn\x02\x8c\xde*\x01\x1a\x07\x9c\x00\xab\x1bN@\xc7/\xc1\x01\xe7\x923\xb7\xffU?wo'\x9d\x00\xdc\xe4m\x0e;\x01\xb6\x99Z\x9dw\x02\x90.<\x01\x1d\n\x8cq\xe7 0:\xf5\x04\xe8]{\xd5oZ\x07\x9f\x00\x03U0\xce>\x016\x97\x9f\x80\xa6\xe3O\xc0@\xf7\x9f\x00\x87\x13P\x80\x9f+P\x80\x8e\x14V\xb7\xa0\x80 \x9c\x83\x02\xb4\xfdw8i2w\xa1\x80 \x9d\x86\x02&s\x1d\n\x98\xca\x81(@\xebF\x14\xd0\xf4\xfe\x08h\xba\x14\x05\x8cw,\n\x98\xc4\xbd(`:'\xa3\x00\xb7\xabQ\x80\xd5\xe1(\x00\xe1vl}ht>\n\xe8j\xd4\x9e;K\x00\xd6\xa9evGJQ\xc6$\x7f\xcc4\x9c\x81\x92\x8eP_\xe8\xca]\x85P'{\x05\x14fc\x14\xf2\x12h|\x18\x1aw\xb4G\xbf\xfcQ)\x1f\xc7\xbe\xfd\x05\x17\xb8\x0e\xd9b\xba\x1b\xcb4\x9b\xca\x94\x1b\xca\xf4\x9b\x89a#\x11\xab\xbe%\xd9\x07Z\xdf\xb7\xf8T\x99-\x08Km\x1e-\x87Zi\x9aG$\x0d\x12\xdc\x7f<\xd2\xf0\xa1\xb1\xe4F\xf7`d\xa1\x8d\x83\x83\xe5j\xd8t\x02\x1c\xeaM%\xc4|\xcc\xfa\xe8i\xb4\xec\xbcJ)4O\x1c\xcb\x80AN?\xca\x1a\xa2\xa6Au\x0cy\xc9\xef\xf6Y\x951[\xb9\xc6EF?R\x92\xd3\x1b'\xcfoV\xf5\xf5\x87\xb3<\xc9\xa2\x88Z>\xfa[\x10\xa7\xad\x10u\xcf:\x1di\x87\x8e}a\xd2x\xb3\xc8\xd3hixW\x92\x91\xb7os\x8a\xa9\xf3v\xafH\xb1\xd8h\xdfh\xd47e$\xe2\x0d\x7fL\xf3\xc2\xd0\xaaC\xc6\x86Nz\x1a-\x8doB\xb2\x96\x1dz\xb7\xca\xe61\xafA\xce\xab5 \xb7$\x1drK\xd7\xdf\xff\xab\x9d\xbb\xf1\xe2\x8b\xebO\xa3\xa5R\x1e\\\x93\x1c\xb5\xd6\xb1\xbe_\xe9\xbae\x87\x98\xca&h)\x83\x96\"h)\x81\x81\xd6\xc1 \xc1\xd7\xdf\x89\x81\x17\xf5\x81b\xee/\xe2\x83\xc4{\xa0h\x9b\xf8\xe0e\x14\x174\xcb\xd1\x06\x83\xdb\xe7\xd1\xde\xed\xad\xac\xdd\xda\xe5\xd7\x9av\x98k\xdd\xd2\x81\xed\xfa;\xf9\x00\x07\x8e\\\x8d\x9a\x90\x95NZ\xc5d\x9d\xd7\xcb\x1e\xe5L\xbf\xb0O,\x8b\xe1q?\xc9\x9fj\x1d\xf4\x8ab\x80\x15\x85\xb5\xa0\xb4\x0b\xc4\xbf@/\x10O@ \xb6\xb5\x0f\x0e\x0f\xdbZ\xca\x1d_\x92\x9a \xd8\x8a\xca\x84V\xa6\xf9\xf8\x12\xc8&.A\x06\xb4=\xac1\x7f\xad\xef{\xff\x0e\x8ca\xb5\xdfqr\x1e\xf3\xff\xd0lD\xe2r\xd2\xde\xf4\x0dO\xa4\x8b\xa5A<\x91.\xef<\xb5>\x91^\xef\x94\x1c\xadq\xaf\x14\xb8\xc6\x1a\xc3M\xbe \xe6\xf0\x17o\x0es\x96P*@j\x84\xa3\xcej\"\x8cb\xder\x84Y\xdc\xb1\x84\x8d\x0c\xfd\xc5\xd8\xc5\xc3\xa5\xfe\xc0\x12?X\xda\x07K\xba\x99!\x82}l\x1d\xabk[m\xee\xd3f\x0bY,$\xc2F\x96\xd2\x1dV\xc3Ek\xa7M\xa4%\xef\xeb\xac\xea\x01C\\\xf6u\xb0p\xf18\xe4\x02q*\xfb\x9e\\\\\x82\x06h\xfb\x15\xe3\xcf\xfd\xe2-V\xe1\xd3\xe1\x944xu8wZ\\\xb8\xbc\xad\xd9\xbb#\x9ao\xc5\xefm\x0cjs\xe2\x18\x8c\x9b\x93@\xd0\xf2\xe8zoO\x1c\x87b\x80\x1d]\x0c\x92\xb4\x84lq\xc94\xd2N\xe3\xb6\x9d\xae\x81\xe6}\x0b\xf3\xeb\x16\xcc\xfe\xa3\xcb\xf3\xb9\xee9\x17\xcbs\noy\xb3\xa7{\xb1\x19\xa4+\xf8@\xf7\xb9\xac\xd1\xa2 aV\xa7\xac\xca*RQUS\x1b\x9a\x1at\xab,\xdd\xf6\xfb7\xcd\x06\xac3b@\xe2\xf8<]\xe9~Qh\xcd\xcf\xbeZ\x1f|5\xaa\xb4\xea\x03A41\x00\xae)8ex\x02i\x94\x0br\xf1\xa2\xa9\x8a(ti\x7f\xd1\x96$\xfb\xdfv.\xc67\n\xc5\xc8\xaa:J. \"\xa5\x90\xcf\x99-\xaa\xc8\xa9mM\xda\x80\xccE\x8a\xf0\x0e\x8f\xfcY&\xc9y\xbe\xc3\xa3m\xaa\x84\xb7\xa6\xad\x94^)\xbc\x8d5Tv\xcdW\x1a\x84\xa71Ypu\xf4\xa6\xa1\x99\x1a\x1fj\xde \x04\xcb\xaaM\xf9t\x8f\xa1k\x01#9\xa0\xf7\x80a\x0d\x0e\xcc\x80\xc0\x0e\xe6\xe7\x0dk@\xf4\x03\xc8\xbe\x00\xf7\xca\xbc\x93\xb7k\xb0\xd4\xa35A\xb9\x07F\xbc\xd1U\x03\xeeUy\x97\xda\x14\xf0\x1b\xbd\xfc\x8dyA\xdec\x15\x90/\xc7\xa31\x8e\xd0?-\x04\xe3\x1eb\xacA\xf7$c\x0d\x88\x05\xc2,\x8d\xf9\xcd\xbb\x1a\x10]\x01\xb2;\x08\xb2\xd8\x81 \x8b\xda\x0f'\x92\xc5\xb1OK\xd6\xa0}d\xb2\x06\xc4\x1aaV'\x88c\x10G\x13x\xac\xc2\x97*\x8e\xe3\x1f\xcb\xac\xc1\xf0lf\x0d\xee\x05w,6j\xa1q\x8blzh\xb3\x06\xf4Z\x98\x1f\xdf\xac\xc1\xfd\x0cg\xf3[\xfb\x83\x9c5 \x9f\xe6l6\xb0_\xce\xd0\x06\xef\xe7:\x1d\xf8\x08\xfa\xe1\xce\x1a\x0e\xf7\x84g\x0d.\xe7\x83\x02\xbfg=\x1d\xc8\xaa\x04o\xd7\x03\x9f5\xc8q\x8ey\xea\xb3\x87\xcc0\xe9)\x9e\xff\xac\xc1\xf1\x10h\x0dC\x9e\x04\xd5\xf7\xa8{&\xb4\x86E?\xba.@\x08\xbd\xce\x7f/\xc0\x14 \x10\xd0\xc9\x0c\xa8a\xe4\xf1_\x937P\x83SO\xe9r jp4\xc7h\x8c\xc1\x99\x06Zlc\x92\x0e\xb4\x08e\"\x82\xf67lN\x82\x02e&\x8dx\xd2\xb4\x85\xe8\xbb,-wowt\xa1\x10\xad\xd9\x1f\xaa\xfbz\xc4\xb5S\xb2\xd1\x04y\x11<>QE\x99D\xd0\xe9\xa8\x13\\\xe0#\x171'\x19$4\xe6Gpt#\xf2#li\xc3_HF\xc4\x90\xa8\xd2\xb8\x88\xd2\xc0h\xd2\xe0H\x92ye\xff\xbc\x89\x0e\xae\xd0j3lk\xcea\x90+\xe4\xcea\x90\xe1\xdf?\x1d\xa1\x87F\xbf\xb5D\xfc[I\xb3\xfd\xd3h\xe9\xfdf\xd5|`\xbeB\xb7P\xce\xd8\xdc\x8c\x02\xf4i\x0f`\xdf\x97\xfb\xe9\x0f\x8e\x06\x964\x08\xd0\xa6B\x80\xd3\x14\xb2\x19B\xfd\xb4\x08\x18\x85O\x9f\x04\x0c\xb69\x9b\xd3\"aX\x9a\xb8\x02l\xba\xb8\x82\x8e&\x01\xdb\xa0u\x07I]\xc2\x06\xe8\x926@\x9f\xb8!\xfe\xdc\xad\"\xd3et\x80-\xab\x03\x9c\xa6\xe0\xe8\x9d\xb7\x83\xaf\x97\xe1\x01\x8d\xfd\x18_\xb9S\xb7\x1cT\xc1S7\xf7\xad\xe4\xa9[\x0e\xa8\xe8Q\xe0\xbd\xa9\xcf[k\xa69\x8f\x0cPP\x86\xd3\x87E\xdf\x98N\x1c8q\xed\xb1\xd6T\xe7\x8b O\x16\xfa3\x85\xcfiBg\xcd\x83\x8dF\xd6\x042\xaf\x02@\x06\xe2Z\x80sy\xdf\xcd\xa0\xfdo\x82\xbdOs\xad\x0f\xd8Y\xabw\xbd\x8f\xf5{\xe5&E_\xf3\x03^y\x88W\xac\xdc5\n\x02\xb4w\xfc\x80\x97*\xefm\x8f\xc3_\x1b\xaf1\x8c{u\xbc\xc63\xc5\xeb\xe3\x8dQM\xf6\n\xb9\x82\x96\x86F\xbdF\xae\xa0w\x1d\x0d\x0c\x93\xa1\xa0\x9e\x0f\xa1\x9e\x8b\x8c$\xf9\x8af\x19\x1d\xaf\xe5\xc2\n\x1db\x85rZ\x14\xf1d\x1b\xa8T\x07X\x11\x96\xad\xbagNF\x8a\xea\xf1\\6\x10\x8e\x82\x11\x81\x7fy\x9b\xed\xd2oN\x9f\xd5\xb5Q\xd6\x93l>\xe4(\x9bw\xf7\xf2i\xdf\xed\x98\xf7\xf7_\xa3D\xd8\x1d\xdb\xba\xe3\xb3\x00\x0bB@x\xcb\x0d\x07j\x01\xd6S2\x18\x0f\xd7\x02\x9c\x8d\x1d\x07m\x01\xfa\xe3\xb6\x00\xfb!Y\x80=\x06\x01\xc6\x03\xb8\x80iz0\x1f\xc9\x058(e\xb7?\x04\x8c8\xa4\x0b\xf0=\xaa\x0b\xd0\xd8t\x02\x1cS2G\x81MV\x9e\xfaUg\xf8\xc8\x9f\xb4\xc7y\xf5\xa3\xee\xb4)\x7f\xd2\xdb?.\xabP}\xe2\x8e\xf8\x8c8\xec\xeb\x85\xae\xefzo\xc3\xf0\x83\xbfj?\xea\xf8\xaf\x90\x0cu\x02\xa8\xf6#\\\x01\x02F:\x04\x04\x840\xe5(+H\xc0\x84\xb6\x90\x80)\xc3\x94f\xf7\x82\x00\x075m\xfa\x7f\xa8\xc3A\x80\xc9\xed q\x0f\xb3$\x0ebE\x18\\\x13\x02\x9c\xcc\xacuS\x08p\xb4\x1d\xe4\xb2\x10`4|\xac]~Q\x1b\x9eQ\xf1\x99\x1d\x1d\x02|76\x83\xd11\xde\xf5\xa1\xf0L\xe3\x00Q\xd8\xa6t\x83(\x9c\xd3;C\x04\x0cw\x89\x08\xd0:F$\xeaq2\x1d6\xa8/g\x832:X\xe4\xcfa\xa5\xff(+mr\xd4\x08\x18o\x8ax\xbanZmG;p\x18\xec\xc8Z\xaeW=A-\xff\xea\xb96\xa1\x9f\x8a\xf3^\xc2\xb9\xd3\x8d\xd5K\xe8\x97S\xea\xedl\n\xbfR\xea\xec\x9f\xf21@\x92\xe7\xe2%\xc3S\xb2\xa6o\xe8\xc7\x92\xe6\xc5L\xfc\xdeA\xf2\x91M\x9f7g\xe8\xd8\x94)l\xd9!\x88\xaa\x0b[\xe2f\x04\x97g\xc2yNH\xe321%\xa9\x8aD;6\x1f\xfe\x0f\xe1\x05\x90\x89v\xfc\x11\xc6\xc6\x8b\x81\xabN\xdb\xe6T\xc5\x9b\x14\x1cI\x97\xdb/I\xce8\xf7\x08\xa2\"WoH\xe6P&Bje\x86\xdce\x94\xd7k`\xb6/D\x975\x87 \xeaW/\x93D \xac\x19SU\x8c'\x9f\x0b\xc9\xd9\xce\x9b\x89\x07Bkd\x8b4\x13\x1f\xf2\xe7L21\x93\xea\x85\x91\x0d\xc9\xc53\x80\xcdi\xb6\xe6\xa6\xbe|\x9bn\xebAi_g\xca\xe8\x8e\x1f\"\xe0)\xc9*\xca\x1a\x9e\xb4i\xcf\x91\xb3G\xf7Q\x1b\xf1\x90TG\xf0r\x0f\xc9\xcb\xb1\xbeS\xee\xde\xf1v\x9e\xc6\xf5e~\xda\x16\xfaV\xa0\xbd\xd8\xcf\x88\xc0\x8c\x04B.\x90\x84\x89s\x81$\xc7\xe1.\xc1Qp\xb8\xd0\xae!E\xc7~\xdb\x9d\xe9p\x84\x8f\xf2\xfeV ;\xc3\xaf\x14\xabq\x1c\xf4j\xb1\xba\x9b\x81W\x8c)\xf0\xf6\xcduy.\xa4\xeb\xb4`B\xb3v|\xb4q\xe2t\x1d\xff\x0b\n\xa1\xf6\x9e\xed\x9aoo\x81\xdfV\xa5{\x87\xcb\x88\xc2\x8c\x06\xbe\xd4\xe4\x1d\xdd;]\x96^\xfel\xb9>\xd6]`\xc0\xc3+\x1dl\x06\xe7\xdb4\xcf\xb1\xd4\xd8\x94\xa2\x1e\xff,Kc\x84\x13?\xcf\xa2@r\xb1\xee\xbd/\xe8\xbd\xf9\x05\xc3$1\xa8\xfcC\xa8\xfc\x90\xa0\xf5%\xaf\x8e\xe6\xad1\x08\xeb\xf3\xa5\xacOG\xeb\xf5]s\x8dw\xca\xda>\x81\xd6\xd9\xdd\xe5\x14\x10f\x94\x8fW\xc0?\xa7\x8a\xdbb\x07\xce\xaa\xea\xb8\x1e\xac8lx\xc0\xe8\x8c\x10`A \x08\xafz\xc8\xac\xfa\xe23\xab\x069;\x04\\} \xd8\x9a\xde\xe4>\xb1\xcb\x0f\xff\x80\xc9N\xe3\x9d&\n\xd3\x95\xb8NTg#\x1d(\x02F\xbbQ\x04\x84$\xa7Q\xb6\x84\x80 -\n\x01\xd3F\x16\x0f\x9e\xe44\xccM#\xc0\xe4\xac\x91=\x0c\xdb\xdcM\xee\x1b\x01#Y\xfbw\x98\xf2dr\xf7H\xc4\xb6~C\xb6\xd4\xa4;\xa3\xaf\xf3H\x8b\xb0\xff\x92o\x1b\xa6u$)\x9c\xd3\xbb\x93\x14\xe6C9\x95\x048\\K\x02\xfa\x0e&\xd9x\x9c\xae\x08\xdb\xe0\x97\xb3\x0d\x86\x84\xb9?\xc3*\x1b\x1c^\x02\xc2:\xffA\xd6\xd9\xcfq\xd6j3\x89\xfb\x0cB>[\xc8g\x13\x10\xf2\xd9|\xf3\xd9\xda\x1ef\x94\xf4\xa1s\xda\xf8%Y\xde\xce\xeb4\xd3<\x10\x86\x92\xe2\xfeS^F\x04f$\x10r\xda$\x98\xf1I\x06\xf2\xbe\x04M\xc1\x15'&\x18\xd2\xd7~\x97\xb9iC.w\xac[\x8f\xb9\xe4\xb1\xc62\xe8\xb2G\x05\xde\xbe\xd2\xe6\xf3a\x0c\xdaO\x88\xc10 \xef?'\x06vy5?+\x06.[\xd6n\xc9Z\x9e\x18\x03\xcb\xf6\xab\xc0\xfb\xa91\x03\x9e\x86\xd1\xa7}n\x0c\\\xb3\x04\xe7L\xc1\xf1\xf4\x18T]\xd8/\xd8w^\xaf\xef\xb4\xfe\x01AX\xa8F\x8b|\xa7\xcc\x86\xc7~\x0b\xbd\xfd\x153\xf8\xf2\xc82\xe5\xcbf\x00\xee\xd7\xcd\x00\xf1@\x83\x8bD\x88\xc7\xde,\x9c\x8d\xe1m\xe7\x13\x0c\xa8\x05p>\xbb\x80\xc0\xa2\xbc\xd3\x03\x9fZp\xf1\xc0\x90'\xd2\xccT\xed?\x9c\x06\xf5\x18\\\x8f\xa7\x81\xfd\x153\x1bS\x1c\xea\xe9;\xeb\xa3j\xe0\xc6\x0f\x88>\xc0\xfe\xc0\x1a\xe0z\x01dO\x80yl\x0d\xf0}\x82G\xbf\x80{]\x06p\x82\xd1\x04\xe3!\xbe\x0f*\xb66\xc9K3\x80Pf5\xb8\xd4Z\x0dN\xfd/\xc0c\x8d\xfcV\xc9\xa9\xfej\xf0\\)\xa7J\xac\xc1\x0b\xf3H5\xd9B2\xd5\x83m\xe0|\xb4\x0d\xf0\x8b\x88]>\xcc\x8bQ\x80\xef\x16<\xba\x86 \xdfA\xbe\x7f\x07\xf2\xedxi\x07\xffF\x1c\x92o\x8c\x9f9\xde\x90\x03<\x0b`\x17?h\x87\xa0\x1d\x9c\xdf\x06\xed`\x01\x9f'\xeb\x90\x9cc\xfc\xcc\xf9\xa4\x1d\xa0\xf9\n\xc1Sh~\xc2\xf3\x92\xfb\x99;\xf0]j\xccsw\xc0]\x9b\xd8W\xe9\xd4\xf7\xd8g\xef\xa0\xe9\\\xf6\xe9\x04\x13kn\x03\xfa <\x04.\xed\x03u\xc8g\xf0\xa0K\xa0\x03=\x85\x07h1\x140\xe9\x93x0\xecY<\xf0\x18\xb3\xc7\xdby\x0eL\xe6\x97\xf5\x005\x9eA/\xec\x19\xb1\xad\xd2\x0c\xff\xca\x1eL\xf9\xd2\x1e\x03\xc7k{`{q\x0f*\xfd3\xber\xc2\x90\xf1\x0d8\xdd\x8a\xd1\xaa\xd6D\x19\xc0\xaaR{\xc2\x0c\xe0\xd0`\x95\xd9\xb4\xc9304\x81\xc6\x88M$\xd6X\x93h`@\"\x0d4\x8c\xcd\xd1\xaf\xf55\x90\xf9\xbc\xd8\x07\xd3_\x1c0\xfc\x05\xbfv\xaaB+\x9d\xc0\x95\xa9 :\xf5IT\xf0/\xb3\xe3#oH\x9e\xce\xaa\x1a[f\xa7\xcfi\xb0*\x07\x9bR\x18\x96An*\x83s\x88\xbc\xa3\xfc\xcdT\xfa\xe6R\xadv\xb5j*w\x1b\x83ul\xbe\x83!\x07\xdfB>\xbd\xc5j\xce\xbb7\xe4\xdc\x1b\xeb\xd5\x0c\x89\xf8\x8e${\x97\xfe\x1e\x91\x03\xd1\xe79[\xc9\xd9\xb8<\x88\xa92!F\xe7BL\x90\x0d\xa1\xcb\x87\x18\xac\x1d\xf4Y\x11\x0e9\xb7gF8\xcd\x18\x97 \xe3\xc8\x8f\xc0\xd8\xadS\xe5H\xe0\xb2$\x9c3\x06\xc4\xac\x01\x91+1\xf91\xdey\x9av\x93\x1a&\xcc\x9a@\xb9;\\\x99\x13_,\x91|s(\xac\xd8\x1a\x04u\x11\xcd\xed|t\x13\xccA,\x04\xff\xe3$\x00\xe1TD.\n\xc2\x89\x88\xc24\xdai\xe8\xe6\x8e \xb3+,\xf9\x15^\x19\x16\x8e\xa4\x06;\xc3X\x98\xc5\xc9(n&qf[ z\x01TO\xe0\xce\xb9@\xf6\x05\xe8\xfe\x00\x9by\xe1\xd13x\xf5\x0e\xf8\x08\x0cR\x84\x9a\xe0\x11\x859@\x1c\x06\xa3\x0ckp\xab\xc5\x1a\x10\xbb\x89\x00\xafU\xf3]7\x84\xfa\xac\xc1{\xed\x10*\xb5\x06O\xec\xa3\xd5l\x0b\x8d\xd3\xc5\x8aM\xde@s\x93\xe5Cwr\x87\x07W\xe0\xf9\x01\x1b\xc4\xf5\xe8\x1c\xbc\x06\x00A\x91H\x08\x8a\xa4\x0d\x7f E2Q\x1a\x08R\x95 RA<\x18\x03\xcf\x12A\x97\xd4\x10t\x89\xe7\xba\x05]\x82\xd4%\x93%\x8d \xb5 *q\x04\xcfq(n\xf3\xe04\x1f.\xc3\xa5\x90x3\x006\x8d\xc4?\x91\xc47\x95d`2\x89\xdb\x83\xaf\x83)\x13J\xc6\xa7\x94\\]R ^T\x05\xb8\x13KPh\x1a\xc9'CSK|F>]z\x89+\xc1\x047\xaai\x93L\x06\xa4\x99L\x9ch\x82J5q$\x9b(MeO7qEF\x05XSN\x90\x1a\x19\xa7\x8b\x9d\x89'h\x05\xecN>A\xa2\xc2\xab?\xcf\x14\x14\xe7\xe0m\xc9)S\xa7\xa7\xa0\x13T\x86\xa5\xa8L\x9c\xa428M\xc5v\x99\xa2\x85\x1bLB2E\xbaJ\xb8\x88&\\D\xc3!\\D\xe3{\x11M;\x07\x0b\x95\xde\xa5\xbd\x88FE\xbc\xaa\x0c\xaf\xd3\xd6\xed\xd4=Y\xd4\xa4u\xb5s\xa44\xbc\xbaI\xf3\xe2\xbc\xcc\"\xebG\xbac\xbc\xee\xf046CLs\x9c6\x8a\x97\xf6xl\xf8\xda\xfb\xb8\x1b%\xabt\x90\xd2\xa3[\x12\xe1\x14\xc4%\x9d\xe7\x11\xea\xea\x18\x15\xdd\x94\x8b\x7f\x92\xac\xd2\xaf4\x7f\xef\xe7rm\xc43\xf9\\\xa9\xbb\x99\xea\xa4\x9a3\x82\xb1:\xf3\xd4\x8c\xbb7\xbf\xde7\xfay\x19F\xc9eE}\xea\x9d\xde\xd8\xbf\xd6\xddcM\xf1\xaf\x14\xf5\x85\xc9\xf2\xb1\xc97f\xf2Jh\xbd\x10\x16\x1b\xd7f\xd9\x1a\xfcVV\xc3\xd3\xe8\x8f\xb2\xb4\xf2\x16<\xe8 \x1f\xd8fi\x9e\xa3F\x10\xc1>V\xad@Z\xdb\x98\x04S\xf3\x9bS8\xdb;H\x97\xd1]{H\xd5\x0df\x17i\xf5\xe0\x9f*\xac\xf0\x1dx/\xd0\xa6\xf7\x1a\x97B/y\x96\x06f\xcf\xb4I\xfe\x8c~@\x8b\x0c\xba\xce\x97F\xff\xb1U\x12\xad\xbeak\xcbA\xf2\xa8\x93\xc8\xc1\x9a\xc7 \x97\x8eq\x1be\x13\xa3}\xb4\xf29DB\xc3\x91(\x1c\x898\x84#\x91\xef\x91\xa8\xb7\xdd`w\xb4\xce\xc1\xe8\xd9\x86.>\x9c}z\xc3\x87\x88\xde\xb2\x16\xe9\xb2g\x88\xb6\x1d\x90KR\x90\xee\x17-\x06^\x93\xfc\x9cQ\xdb\x8e\x86}uI\x92\xc2\xf5\x9d\xee|\xd1\xea.N\xd7\xd6\xdf\x0b\xb2>\xf0\xfe;\xfdY\x8c~\"\xdb]L[\x8b\x02w\x9a\x0b\xc0\xff\x7f\x83\x02\xec\xffu\xe9\x0f\x0f\xee\xdc\xb9\xd3'7\xdc\xbdS\xff\x9d\x93\x97\xff\x7f-\xb9n\xc1\xf5\xeb\xdd\xffxN\xe3\xe8\x82f\x81\xb5\xfe8\xac\xf5\xa0\xb9\x00\xbf!k=\xcdR\xb2\\\x90\xbc8\xfb\xf4,\xddn\xa3\xc2\x97\xc5\x98\xce;/>u\x17\x05er\xb4\xf9\x13\x0cL\x03=>\x05\xf3\xa2\xf4\xf9\xd5\x86V\xc7\xb7\xb6\xefM\xa7\xbf\xde0Z|l\xf9\xae\xbd@`\xe0i\xf8\xdd\x9d\xb0;<\x0f=\x95\n:\xde\x87>\xff\x83I\x06\xc0\"\x07\xa0\x93\x05\xd0\x92\xbb%\x13\x9d?,\x85\xda\x0d\xdc\x1d\xb8\x1b\xc9\xdd\x0f\xba\x8b\xfa\x05s\xf7\x86\xe4\x9b._\x1b\xe6 /^x\xf8\xe2\xce\xf3\xe7\xcf\xee\x7f\xfb\xf2\xf8\xf9\xc3\x07w_\xdeQ\xa7\xa6\x0d\x8d\xd6\x9b\xde#\xf45\xc3\xfd\xf0\xf3)\x89\xf0\x81\x82\xd6\x82j\x06\xdaY\xbc\xce\x17\xaf\xf2u\xb3\xa7\xea\xef\xc7\xcbeF\xf3\\\xfb[\xe7\x145\xa7\x8b\xcd\xfd{@\x13\xb6\xcaK \xa2\xe5W-\x12-\xd2|\x9b\xe6w\x97t\xf7\xe1\xc1\xd7\x8b\x92\xfc\xb2\xfe\xf0\x99\x92\x87\x9fw\xeb\x0f\x1f\xef?,\x92_.\x97\x9f/\xbe&\xab\xc5\xfd\xe5\xbdo\xbe\x02\xf8\x99\xc4\xd1\x92\x14iv\x90q\\\x90\x98Q\xf1\xee\xc3O{\xba\xdd\xd1\xedn\xf7\xe8\xde\xa7G\x9b\xfd\xe7\xcf\x8f.\xb3\xf5\xea\xd1\xd7\xd9\xc3_\x1em\x1e\xac\xee]~\x9d\xdc\x8b\xbf\x12qx\xf4\x82t2\x0e\xec\xbc\x93\x17\xe4\x83:8v\x13\x0c\xec-\xaf?\xb8\xc3\x98\xf5\xfb\x8aQ{\x9f\x0fa\xd0\xb3O\xfc\x10\x87\x9e\xac\x8f\x9c<\xbf\xf3\xed\x83\xbb\xf7\xbf}\xfe\xe8\xee\xfdG\x8f\xee?\xba\xfb\xe8\xde\xa3\x07/_~\xfd\xf4\xce\xf1\xa3\xbbw\xbeyy\xf7\xe5\xbdg\xcf_\xdcy~\xff\x9b\xe3o\xbfy\xf6\xe2\xce\xc3\xaf\xbf~q\xef\xee7\xcf\x9e\xbe\xbc\xff\xf4\xebG\x0f\x1f<\xb4\xca\x8fp/\xf4;\xbd\xff\xf0[\xf9\xc7\x81\x1b\xd56\xd7\xaas/-\xdd\xd3\xab+\xaa\xdd\xfc\xbc\xfc\xe4k\xa2Q\xef\x16=n\x7f|\xfbj\xaf'\x1e\xf7n\x92A~\xda0\xeaq%\xd0H\x9a\x82-\xdd\xe2\x0c\x81*\xade\xf4R\x1b0\x81k\"\xd5\x14\xb4YF\xaf^\xbc{v\xf2\xb7\xe7w\xee\xad\xf2\xe7\xa7\x19\xf9\xf6U1\x7f\x93\xef\x9f\xde\xbd\xfcf\xfe\xf1\xec\xd5\x83\x07\x7f/\xef\xde\xff\xf6\xf3\xdf\xe6/\x17\x7f\xff\xf4\xf5_\x9e\xbd\xdc\x1f\x9f\xac\xe9\x83\xbf\xfft\xba\xfa\xe1\xa4\xbc\xf8\xfc\xf4\xbf\x1f>z\xb5\xff\xf8}\xfe\xf1\xf9\xb7o\xef\x9e\\F/v\x7f\x89\xde\xcd\x1f\xfe\xfcvY\xc4\xbb\xf5\x7f=\xe9t\xb9+\xe7}\x0f*\xb8x\xc9\xceI\xbc\xa9v\xfd\x9c\x0b\\\xd1\xa6\xa0\xc9\x92f\xdb()n\x9f\x96\xf3\x1f\xe8\xfe-]\xec\xee=x\xf8\xe1\xae\xa6\xddP\xf7=4{<\xbe\xf8|\xe7\xeb\x9f7\xc5\x0f\x7f\xdd|{\xfc\xec\xd9\xcf\x9f\xe3\x93o\xc9Y\x9a\x7f\xb7\xbf\x13}x\xf9\xbf\x7f8\xf9\xf9\xfb\xbf\xdd\xff\xe5\x87WY\x9a\x7f\xdf\x15b\xf9\x8e\xa9PwC\xd9\xe1\xfa\x9dn\xf6SN?\x96T\xfb\x16\x9e/\xc6\xacqD\x06?U\x8b\xb5\x9c\xed\xa6\xbbf\xa8\xf50\xef1S\xb15{\xdb\xa9\xc1\x8e\xea\xe1\xfd\x07_71\xfd\xf1\x0c\xfaS\x114\xa1Kn\x14\x9c}j\xd9aV\xbb\x80\xbb\xeb\xcf\x17:\x83\xc6\xb4S+q\x1b\xd4hG\xd6\xb4'\x14\x1eM;\xb1\x10\\\xcb8\xdaF\xe8\x91\xdeW'\x94\xe2S\xdem3\xad\x93\xaem\x935Qh\xd9aj\xfbL\x0e\xa2c\xa55\x87\xd1!Qg\x18\xb5\xc5&\xdb|\x9aHRz\x96\x9c\x00\x9b\xfd\x83\xb88\xc0 b=\x0b\xaf\xd9f\xb0\xdd\xa4\xb5\xf9\x048\xb7\x1f\x8cA\xf4e\xdc\xb71]\xce6\xcaR\x140Yz7XlG\x01}\x0bR\x80\x15\xbd\xc5\x06t\x12\xdfEv+np\x8dL\x80\xdd\xd6\x14p\xc5\x16\xa7\x00\xa3\xdd)\x00\xc1\xb7.\xf2\x81Bc\xe1 \x04\x05a\xb0U*\xc0Yv\xe8;\x86\x11v\xaa\x00\x97\xb5*\x001,\x8b\xe5*\xc0l\xbf\n\x18\xd3G\xd7\xa2\x150p\x13\xea\xd9\xb8\x02\xac\xe33\xd9\xbb\x88\xa6v\xdbW\x80\xde\x02\x16\x80G\xde\xb5\x86e\xfb\x9eM,\xff>n\xd3\xb5\x88\xab[X\xad\xa5\xbf\x08Fq\xc8Y\x07\xc3\xdbby&-\x98\xde\xd8\xfbcm\xd9(\x1e\xc6ak\xc0-\xdbCK0=\x91z\xd6\x85\x81\x18\xba\xad\xd2\xb4\xa0S\x1eu\x8cv\x01\x96K\xf56\x80y\xe7\xc7\xe2m\xec\xf2\xed\xbd]\x83@\xb3\xd7z,\x91\xd5\xa7d;\xae\xf6v\xe5+\xdc\x8b\xb5;\xb0\x91\x07\xcc\x1c\xa0\xdfc\xad\x8b\xe4\xbf\x9f\x1a\xa4\x1b\xd7\xcb\xc0\x1d\xd3\xb6O\xba\x97\xb6\xbd_\xe9wB,\x96\xa7q\xba\xf8p\xf2\x1c\xad\xaf|\xfc\xff\x1ea\x08\xde\x19\xc9\x8a\xdeI\x19%$\xc6\xc4F\xcd\xc1\xb3\x1a]3\x80\xd8?A\xbb\xe9\xe71;N\xe4\xef)\xf1\xa9\x07ZlH\x94\xb4\xae`\xb6\x13[D\xba6\xe5\xfc\xd6=\xb5T^q\x13%\x16E\xb45G\x0f;m\xae\xdf\xbbs\xf7\x9b[w\xef\xdd\xba\x7f\xe7\xec\xce\x83\xc7\x0f\xee?\xbe\xf3hv\xef\xdbo\xfer\xe7\xee\xe3\xda\xf0H\xca\xed\xb9\xc6\x07b\x1a\x88Z\x97\x98\xe4\xc5\xf9\x9cQNC\x05\x14[\x1cxU\xab\xce\xdb|\x0b\x03u]\x9f\x87\xc1\xc6\xc7`\xe2e0x\x84\xb0*\xcd\x93\x02\xc2\xf1\xe7\xb1\xbe\xf7\x1f4\x17x\xc1\xd3\xac\xce\x0f\xa8V\x96\xa4 \x87\xc4\x7f\xa1B\xd7\xf9!{\xe1\xf9\xe2W\xd3\xd5\"Mr\x9a\xe4\xe5A;!\xbb\xdd!\xd1s\xde\x92\xd9\xd1\x87\xec\x87^DK\xb6\xf9\x1e\xb2\x0f\xa63\xd2\x9cf\xe7\xa4\x99\x1ba\xec\x06\x9b#\x01\xfd\xdd\x03\x9f\xaf\xc1\xe0\x82f\xf9\xd0\xf2\n\xae\xd7}u\xf3\xdd\xa6\x9a#\xbb\x9do\xfb;j+Fo\xc2\x9b\xc6\x9e\xadm\xa2o\x06\xda\xfd\x1bP\x83\xec\xef\xe3`\xf0\xae\xbbM\x9c\xa6\xa9\xdb\xde\xd7\x015\x16\xdc\xfe\x0e\xba=\x1eP\x03l.\xa8a\xbf\x87a\xdb\xe9\x15\xee\x80\n4v\x00\xd8\x06\x0fN\xe7\x85\xc1&\x00\x97]\x006\xdb\x00\x8c\xd4\x01\x17\x85`$\x954\xb6\x02\xa0\xf8\xe4\xfe\x83.\xa3h\xed\x06@q\xf5\x80\x81kl\x88\x83\xf5e\xdc\xe4\x0f\xd6\xa3\xdd\xb68X\xb7&;\xe3`\x1d\xf6m\x8e\x83ue\xb1?\x0e\xd6\xa7\xc1\x169X\x7ff\xbb\xc4\xda\xa5\x8f}\x02cm\x14\xd0\xd9)0lK\xd1\xd8,\xe0\xd2\x98z\xdb\x05t\xf6\x0b\xa0q\x8dM,h\xe1W\\3\x1eSC/\x0f\xb2\x98\xc2\xde\xdfj\xfa\x07\xdb\xfbw\x19\x15\xbc\xa1\xd5\x13\x87\x8d#T{\x9b^U \xb0\xce\xbe\xc6\x10%K\xdaKPq\xb6o\x1a\xd5\x9a\x88\x9c>y\x06Fb\xcd\xd2R\x7f#\xe9\x18\xa4\xec\x1c\x91\x17d\xab\xd1^\x1e\x88\xd1\x07\x8b\x06^c\x7fFI\xa8\xfa\xbb\xd7\xfbQ\xafl\x04X\xa5\xd6%\xb76\x01s\x12\x08F\nY\x0d\x06\x85$\xc01A@L\x12\xec*J~\xe0RT\x02\xac\xeaJ\x80\x8d\xa6\x80\xa3+LB[DV\x8e\x9b\xfd\x0d\x193\xdf\x94g\xcf\xbe\xf9\xfao\xf1\x87\xe4\xe3\x7f\xfd\xfd\xc5\xe5\xfa\x9b\x9f\x93\x87\xaf\xbe}\xbd\xfd\xe6e\xf9\xdfw^\xbc\xfez\xfe\xcbE\xf9\xcb\xc3\xec\xf2\xfb\xbb\xdb\xb3w\x7f\xcd\xde\x94\xaf^\xfd\xf7\xc5\xf1\xf1\xc7\xb3G?\xff\xf2\xd3\xfa\xf4\xce\x9b\xe3\xdbg\xcfw\x0f\xcb\xdb\x8f\xee\x1d\x7f\xcc\xfe{\xf5\xbf\xff\xfav\xf7\xf4oO\x9e(\xb7\x87_\xa5\x87\x90\x90-\xed\x97D\xa3v\xf3\xae\xeb\xc4\xd8\xdc\x8c\x02\x8cn\x14p\x11\xdb\xe1N\x01\x8b\xce\xb52\xad\xd6\xb5\x02\xa0s\xaf\x00z\x8c~\xdaP\xebj\x01\xf4\xc0\xbb2fq\xbb\x80KU\xd8\x95\xc4odh(\xb0h@\xa7\xfesk?\x87\xeeCi>\xa7\xde\xb3k='\x15a\x02J\x1a\\6\xe0\x9a\xa3\xdeu\x03N\xf7\x0d\xb8&6vB\x06W\x0e\x1c\xba_\xab\x7f\x05\x0e\xdd\xbb\xdb\xc5\x03\x87\x1e\x82\xcd\xdd\x03\x87\xee\\\xef\xfa\x81Cw\xebp\x03\xc1\xa1\xfb\xb7\xb8\x84\xe0\xd0}\xdb\xddC\xe0\xea\xde\xd7M\x04\xfd]\xdf\xdfU\x04&w\x11\xb8v\x0d\xfb\x8eap\x1d\x81\x8b\x08\x006\x17\x12\x98\xdcH\xe0\x85\xb7\x896\xf8`ZM\xff@>\x98\x0e\x0b\x06K>X\xf2\x0d\x08\x96\xbc\xfeG\x84\xa0\x83K\xd8!X\xf2\x07\xd1\xf7\xc1\x92\xff\x8d\x86\x10,\xf9\xab\xef?X\xf2\xc1\x92w\xe2m\xa25d\xd9x\x05\xdaz}\xf6\x83\xc50\x11fm\xf0\x18\x86Y\x9a\xc1\x06jC\xb0\x81\x14\x98\x82\xd0`\xe1b8\xe0\xb5H\xa8\xc04`\xa8\x83\x08P\x03\x06O\xf30c(\xbd5\x07\xaba\xa2\x1e\x8c\x81k\x98\xa8\x03k\x10\x1b|;\xf1:\xf4 \xe0\xf8\xad}[\xa5\xad\xea\xbb\x1f\xd8\x06Gp\x1b\xdc\\\x0b\x08\xce\x05\xa7@\xa3\x88\x08\x13\x08u\x0d\xd6\xa07\xe0&\x0e\xc8\xc9\x83[m\xca\x8f\xdc\xcb\xa9\xc0\xa9B\x05\xb8\xe8\x0ex\xda\xc3d\xf4\xbf\xaa+%\x0e\x18$\x7fNc\xba\xe6OF\xc8\x7f\xa5\xd9\x1bzI2)G=\xe6\xe9\xb3\x89E\x9fk\xa7\xefc\x1awLb\xef;-\x81\xdflPO\x07\x0c{\xde\xd8\xdb\x88\xb4E\xdb\x96\xc5\xaf\xe6\xd5/\xd6\xd6\x17jcp\xc9\x02\xedj\x1d\xcf\x98\xa4\x8a\xc5\xcc\xd1\xab\x995\xbf\x87\x03\x91\xcbi\x02X\xa6\xeb\xc3>\x02\xa6`\"\x01]V\x12`6\xa2\xa6\x7f\x91\xc7rk\x90S\xd7X\x98N\x80\xedv <\xf6\xc6=\x01\xda\x0b\xc7\xa6e\xa5/I\xf2\x9e\x92\x9c\xbe\xa1\x1f\xd1\xb2\xb6\xca\xf0w\xe8J\x9f\xc0\xfa\x11\xd9d\x0f?m6\xc5\x83l\xfb\xf1\x82&\x0f\xef}\x9b|\x88?\xc5\xe5\xe7\xfd\xc5\xb7\x9f\x1f\xfd\xf2\xf1\x97\xc5vQ5o \xcb[\x9a\xf0\x07U\x85\x90@\x9a\xc1\x0ft?'9\x85\x84l)\x14)\xaciB3RP Pd$\xc9\xc9\x82\xb5\x94\xd8\x9c\x97>4F{\xed-M\n\xb8\x88\x08<\xe3\xe3\x86\x9f\xd3=Y\xd3\x0c\xfe\xbfww\xee\xdc\xb9\xfb\xf2\xe1\xb7w\xae\xc9V\xbe5\xdf\x02\xe1\xad\xef\xcb\xb9\xfc\xcdt\xaf\x80\x1dMm%\xf7\xef\x12p\xb4\xbc\xabZ\xb6\xae\x12q4j\xdfK\xb3&\xf99Y\xfeR\xe6\xc5\x96z\xdc\x86|wvOaXQz`%\xfd%I\x16pck[\xc6\xa4\xffd\xe3\xd7>\x86\x87n\xff\x99\x9e/\xd2\xbc8\xdf\xd1\xec|\xbe\xefG\xb21\x88\xd8(.h\x16\xad\xf6\x02\x17]\xde{\xf0\xe0\xee\xa3)P\xe5\xea\xb1\x08\x7fd\xad\x1dX\xac\x10p\x0b\x89\xe6Pl(\xec\xd8\x9f(#>\x0f\xb0\xb3?\xb1E\x85m\xba,c:3,5\xbf\xbb\xe7X\xa4w\xbc\xa1\xf9.Mr\xbc\xae\x90i!F\xc9\x13\xa0\x97\x02\xf6\xe9y\x99i\x9fW\xd00\xae9\xb5\x80\xc11\xbc{\xf3\xe3\xed\x8c\xe6i\x99-T\xae\xcd\x86\x14P&\xd1\xc7\x92\xc6{\xe9\xcc[E\x92X\xac\x1fHW\xec\xdf\x1dT9\xcd\"\x12G\x9f\xe9\xf2\xab\xce/\xbb,-\xd2E\x1a\xc3\xbc\\\xadh\x06[\x9a\xe7dMgp\xb6\x89r9f\xd8\x96y\x01\xdc\xaf\x17%@\n\x88)\xc9\x8b.\xa64\xa1p\xed\xf65\xa8\xe4\x85\xe1\xa0\xbcV\x05r\xba\xde\xd2\xa4\x90\x83c\xf3\xba\x9e\xc3\x8e\xb0\x85,\xf3\xa2\x83(\xa3\xbb\x8c\xe64\xe9\xf5\xc0\x9a\xae\xca8\xde\xc3\xc7\x92\xc4l\xdeKA\x15\x89\x96\xcf\xff\x06\xc9!J\xbaM\xdf\xb3\xcen\xaf\xd3t\x1d\xd3\x19\x9f\xf3\xbc\\\xcd\x9e\x97\x19\xb7\x9a\xdf\xdf\x14c\xe5\xc8\xf2MZ\xc6K\x98S`\x93\xed\xe0Y\x90$M\xa2\x05\x8993w{\xb9Ag\xeb\xd9\x11#\x0f;\x1d\xc2\xb5\xd95\x88rH\xd2\x821\x15\xdd\x15tys\xf6U\xb7\xd1I\x02;F\xb0hA\x8f\xa0\xa0L\x02\xca\xbc$l\x9a\xa2\x02c\x17\xc5l,E\xca'9\x8f\x12\x92\xed\x81\xc41\x9fo7g\x913H\xb1\xa1\xfbn7\xf4\xd3\x8e.\n\x88\n(R(s>;\x86\x8f-+\xfd\xc4\x97\xe68\xd9\xcf\xe0\xfb\xf4\x92^\xd0\xec\x88\xcb\xdb\xbb7?\xe6p\xb9\x89\x16\x9b\x0e6\x86\x80\xb1Y\x97\xcf\x16\x1b\xba\xa5\xf0~S\x14\xbb\xf7G\xe2\x7f\xf3\xf7G\x90f\x90\xa4\xf2\xd7#\xce)\x0b\x92\xc8\xf0\x08\x9fiN\x0b(w=r\xb3\x19\xf6\xfa\xa0\xd9\x05\xcd\xc4D\xb7d\x97\x8be\xe7#-R\xc5\xbf\xd08f\x01\xcf\xce\x89\xe3\xf42\x7f\xdc\xa3\xfe\xbf\xc3\xc9\xaa\x1e\x1b[\xae]\x96^DK\xba\xac\x86\xcf\xfeH\xf2\xbc\xdc\xd2\xe5\xac\xdf\xfc8\x81\xef\xcf\xceN\xe1\xbb\x17g\x90&\x8a\xbd\x85\xc8\xec#\x1a/\x81\xc0?\xba\x8cw\xb6\xdf\xd1\x7f\xfe\xe3\x9f\x1ddr\xcfg+#WYhLN\xbf]\x96.\xcb\x05\x05\x92\x00\xcd\xb24\x9b\xf5G\xb2\xdb\xc5\xd1\x82\xc89g\x94\xf1HzI\x97\x8c,\x0b\xb2`\xb2\x98\xa6\x1f\xca\x9d|\xb2-\x879\xc9\xe9R\x0e\xba7\x94wo~\xe4\xfdn\xc8\x05_\xeam\x83\x1b\x97\x82\x1d\x89\x1a&\xfb\xf7E\x1a-\x81$\xfdr \xd1)\x17\xb0\x8c\xae\xd2\x8c\x1e\xa9f\x0c\x1b)\xa2y\x14G\xc5\x1e\x12J\x97| \xe7\x14\xb8\x02\xc8.\xe8\xb2\x87-M@x\x8a\xf9\xa7\\\x02fp\xe3]NU\x01#\x9b/c\x08&\xcb\x82#HB\xd6\xfd\xf9\xcd3\xcam<\x85nv\xb3\xbb\xb6?\xa5\x05}\x0c\x05\xd3\x83+\x99\xb4E\xf8H\xa5L/\xca,\xa3I\x11\xef\x81\\\x90(&\xf3X UW3\xaeV\xd1\"\"\xb1V\xf7\xce\xcb\x15d\x94iTz\x04$Y2 \x95\x1d\xf0\xac1\xbe\xedU\x1c>\xa7\xeb(a\xb6\xbdH\x1f\xd3\x88\xcbL\xf0\x1a\xd9E\xf9l\x91n\xfb\xfa\xe6-\xe7\xf4\x1c\xd2b#\xc4(\xe9\xca+\xdc\x90[-\xdd\xee\x8a\xbd\x14\x8d\x9b\xb0eG\x03\x98\xf7\x04\x92\x0f\x93\x0d\x07\"f\x841E\xcf\x99\x10\xf2\x1d]D\xabh\x019\xdd\x92\xa4\x88\x16y\x93i5OI\x197Je90\xe3\xa7\xf5\x83}\x07}\xc5\x84pN\x81\x087Oc\x1b\xec\xed{r\x0b!\xf3\xf4\x82\xaa\x81\xf7\xd8\x8f\xd3\xf7+w\xdf\xef\x8f\x93\xfd{\xb5a\xe6LdI6\x8f\x8a\x8c1\xbde\x0cJw\x918m\xcd\x9f\xd3\x964\xc9\xce4\x0cW\x80b\x0c\xf3\xbe\x01\xd0\xecG\xed\xe9-V8U\xcc\x17Gs>0\xa9\xf7r\xc8\xcb\xdd.\xcd\xf8>\xb1#\x8b\x0f\xb7\xcb\x84\xfd\x0f\xdb\x1d\xc4\x9a\xe5}.\xefn\x86\xe9\n\xcaB\x88\xb5\x12\x1d\x9e7L\x96\xcbH\xc8Q\x95\xef\xc8\x86Wl\xd2e\xae\x06\xce\xfa\x11\x84nb|!,|\xb8\xcb\xcc\xc4\xc5\x07.)r`\xa4\"\\\x94\xc0\xb3\xbf\xfc\xa5\xa7\xa4_\xa6)\xac\xd2\x14\x9e\xc0l6\xfb\x8f\xce\x8f\xac;\x92\xec\xbb\x7f&\xc9~\xc6:z\x99\xa5\xdb\x1b\xab4\xbd\xd9\xfd`6\xebj\xe0h\x057X\xb3w|Xg\xe9\x8d\x7fc\xedn\xc2\xbfz\xba\xa7\xdf\xf6W\xdd\\\xef9\xe6\xfaWrA\x06M\x16\x9e\xf0\xbd\x9ea\xf4\x9c[\x94\xdfx\x99\xa6\xb3EL\xf2\\;5\xd15\xfbT\x8c\xb8\xf1y\xb7\x97\xd6\x9c\xabI\xdfwL\xfat_l\xd2\xa47m\xd1\xef\xcb4\xbd1\x9b\xcdn\xf6\x17SL\xf9\x86\xe6\x17\xbe\xcc\x9c\x0c\x18*\xb0\x06'\x82\x08\xcf_\xbc}\xf6\xe6\xe4\xf4\xec\xf5\x9b\x9b\xdd\xa3\xaa@,\x18A\x87Z \xd7M\xffk\xc7\xf4\xbfK\xbb3\xe7S\x7f\xfc\x04\xfem7\x9f\xbdL\xd3\x7f\xcdf\xb3_\xbb\x9f\x90d\x7f\xc4\xcc\x06\xf6\xddNl\x9a\xafH\x96oH\xcc\x88\xa2\x1b`\x7f\xf2\xdd~z\x9dD\xabN\x17\xef\x92m\xdd \x1f\x02g6\xfe\xd5\xffx\x02I\x14k\x18H\xd7s\x8bS\xce\xf8\xb1p\xf1\xa1\xd2\x1b\xca`\x83\xf9\xbe\xdeR\x95V\xbb\x8c\xe2\x98\xfd\xb0\xa4+R\xc6|Om\"\xbb\xae\xd92o\xb33\xc6\x8c\xff\xc0\x8c\x88\xeb\xcc~\xac\xb4+\xd3\xbclm\xd8\x1f\xc4\xfa4\xd1U\xaa,\x89\xf7\xcaF\xee\x1dY*\xf3\x04\xc8\xaa\xa0b\xa7\xe5\xa7\xa4\xeb\xb7\xaf7\x91I\x03]u+,r\xe9\xe9\x80k\xab4\x9d\xcdI\xc6\x07\xfc\xe9\xf6~\xf6\xf9\x9a\x98\xab\xb09\xbb\x863\xef\xee\x1a\xfb\x8a\xa9\xd5\xc6\x0f\x7f}\xfb\xfa\xa7\xe6\x7f?y\xf2\xe4I\x97\xda\xec\x9b\xfaT&\xf6\xf6\x94\x89\x82\xdc\xe8\x84\xd5Z\xe6r\x17\xca\xe8\xba\x8cI\xd6\xc4\xd2o\xcc>\\\xd2z\x93:\x02\xba\x9d\xd3\xe5\xb2\xde\xae\x8e\xe4\xbe\xd7:\xcb56\x90\x15\x9f\xe8\xfb\xffdS}/\x0e)\xf5\x96\xdb$\xdcL \xd7\xe3\x9e\x01F\x16\x1f\x98\\\xd5\xe6\xf9*\x8aiWO)\xe9;\xa5Y\x9e&\x1a\x96\x95\xa7\xe4U\x94\xe5\xc59\xa7\xf4\x13\xb8\xdb\xc5R}\xc6/o\x90_\xdd\xb3\xebD\x00Mo\xd7\xf8\x8c\xaf=\x86k:\xdemOe&\xc6|\xed\xa8\x8f\x85\x8f\xf6'\xb2e\x98\xfe\xa7\x18\xda\xff\xd2|\xc6F\xdb\xf9\xca6\xe4\x93\x954\x1c\xdbk)\xd6\"\xca\xe1\x92\xc6\xf1\xad\x0fIz\x99p)\xda\x90\x1c\x08,\xca\xbcH\xb7=Vl3\xcd\x910x:\x9c$\xc4\xbb\xd1!c\x90d\x0dD\xb0G\x13\xdd{\xce\xa6\x8aS6i\xbc\x14l\xd2\xe8\x9d\x9f\xf8%\x87\x81\xa2u\xfaM\xed\xf6\x1b\xed\xf8\x9b\xdc\xf57\xca\xf97\xbd\xfboB\x07\xe0\xd4.\xc0 \x9d\x80\x187\xe0\x84\x8e@\xb3+p\x9c3\xb0\x87L\xe7\x1cD\xba\x07\xc7:\x08{\xe8\xfa\x0e\xc3\xc1.C\xc3\xfb\xf3\x96\xad\xd8\xe88t\xef\xd2\x03\x9d\x87}\xc5\xa5\x9c\x89\x1d\xf7\xa1}\x04\x13\xbb\x10uN\xc4I\xdc\x88\x13;\x12\xfb\xae\xc4\xd1\xce\xc4\x16\xae\xa2\xe7X\x1c\xe7Zt\xf8\xdb\x8c\xeeE\x84\x83Q\xeb \xf1p2\xea\xdb\xff\xaa\x9f\xfb W#v\xf2.w\xa3}\xa6N\x97\xa3\x97\xd3\xb1\x7f\xc4\x1e\xe9xt\xb8\x1em\xceG\xbb\xfb\xd1H\x15\xac\x0b\xd2\xed\x84\xec\xbb!G9\"Q\xae\xc8!\xceH=)\x9c\x0e\xc9\xc9\\\x92\x86\xfe;\x9c4\xa9crr\xd7\xe4\xc4\xce\xc9i\xdd\x93\x16\x07e\xdfE\xd9wRN\xe5\xa6\x9c\xd0Q9\xb5\xab\x12\xeb\xacD\xb8+\xd1\x0eK\x9c\xcbR\xe3\xb4\xd49\xb6\xf0\xae-\xbb\xe3\x12\xed\xbaD9/{\x83\x9f\xd2\x819\xb9\x0bsJ'\xe6\x94n\xccq\xeb\xedte\xba\x9d\x99\xca\x9d\xc9@\\wRy\x07\xf9Q\x98/\xe9\xa7(/8a\xe5/\xb2\xc5\x8e\xac\xa3\xa4Q\x94\x02]\xcb\xbc\xfe\xa0\x93\x9aX\xfdY\xaaB\xe5\x1a\xad\xb7\n\xad\xafQ\xefi\xe4W\xd5\xb7\xf2\x84aPF\x84\x9c\xfe\xff\xed\x1eh\x14~\xe5\xc7e\xff\x94'm\x92\xe7\xc2MpJ\xd6\xf4\x0d\xfdX\xd2\xbc\x98\x89\xdf;H>\x96\x94\x9d\xf67\x94\xa3c$\xa0\xb0M\xf3\x02(?\xd7\xf2Cp\xa3\x89\xe6\xcaO\xe7\x84Z\x99\xa6\xb2\x8d\x98R\xef\x8c\xc6\xd1\xf3\xf9\xf0\x7f\x88{\xbc\x98\xceV\x1e\x8e\xc6q|\xd5i\xdb\x9c\xaa\xb8\x06\x8c#\xe9r\xf6%\xc9!\xa7\xc5\x11DE\xae\x1c49\x94\x89`\x84\xa58#_F\xf2\xba(\xb77=\x1f\xe0N\xcf\xfd\xfc\xe9\"\x8b\xd6\xdb\x9b\xbek\xa4G\xf7\xe6\xb2\xb3f\xe6\xca]\xb2\xce\xc9\x15\xe0\xc1\xfc\xd6dk\x18\xc46\xfa\xc4\xeb\x11\xb8\xccI\xd8\xc3\x90:\x13\xb2\xa7A\xabI\xce\xf6E\xdcb\x05\x0d\x8faxY\xe6v\xbf9}\xd6\xe7\xe19I>T<\xfc\x9c&\xe9\xf6\xf5e\xe2q\x7f\xce\x80b/u\x97a\x93\xa3\xd5\xdf\xf8&\x9d^&lg\xdf\x91\xac\x88\x16\xccN\x14\xf5\x0dR\xe3+&\xbf\x9a*kt)uk\x8a\xad\x1d\xe0Y\x1a\xd5\xbb\x17\x117XH\xb3\xb551n\xd4\x90Dv\xd9:\x1b\xfe\xf4\xfa\xec\xc5cnh\x8b\x1f\xa5U\x1bq\xe7\xd4IRH\x9b\xa4r\xe8\xb5\x0c\x13\xb1\xe6m6\x157 \xe7\x90\xd1\x8fe\x94\x89c\xd2:]\xa7\xdc$\x98\xf59\xaf\x9aP\xcd\"\xd5\x94\xf2\"+\x17\x0c]m]\xf1\xad>Q\xbb}cU\xd3L\x1aN*\xee\xa3[d\xbe!~\xa0\xc9\x0cN\x8a\xb6\xad\xae\x10*v\xe1\x14\x13\x7fksE}z\xe8\xe2\xb4\xb1\xfe\xbb\xc4\xe3\x02\xa7\x0e\x0f\xb9\x99\x827\xa8i$f$\xad\xfcf\x9cm\x1d]\xd0D~]&Q\xc1#^P\x92\"\xdd\xdeT\xccO?\xed\xd2Ds\x0be\xf7*\x0d\xa5Q\xda\x9a\xca\xec\xfcTx\x9b\xc3\xe4\xb7\xf3\xb1\xc1\xdd\xbdS\xff.\x964\xa1\"\xca\xd8\xc0\x90\x91H\x1eo\xe7$\xa7\xe7b\x1aE\xca\xec\xb44[\xb2Sm\n\x94\x9dy\x1bs\xad\x88\x7f=\x17\xf3n\"\xbc+I\xf1\x04\xee\xfe\x9f\xaa\xfb\x1aw\xf3S\x1e\x1aT\xa2\xd5\xe8>] \xf2\xd5\xb10^\xb3K\x81\xd4]\xb3\x8f\xae\xb3\x8f\x9a\xf7Yt}\xf9U\xffO\xe0!;Q\x94\xf9c\xb8\x0b\xac\x15\x1b\xde\x9d\xff\xf3\xb0\xb3L$\x8eH\xee]\xaf\xace%eZ\x0b\x8c\\\xf4!\x8er>n\xc9D\xea7\xa5\xfd\x1b\x8c\xe4\x92hN\x81\xc6\x9a\x13)\xd5]\x175\x11H\x9b\"\xa0\xb4W)\x89(\x97>Z\xd8\x05\xee\x15-\xc8\x92\xa87\xbbQ\xf2\x86\xbb(\x91\x0f\xea\x9c\x8df\x18\xdd\xd1\xd9 \xbeEw\xae\xa0\xc7(\xfd\xd0\xc3\xd6fD\x01}\xad!@\xaf;\x04\xe85\x88\x00\xd7\x8c\xc6k\x13\x01#u\x8a\x9e\xd2\xfdn<4\x8d\x80\x91\xfa\xa6\x87O\xe8\x1fC\x04\xd1W\xf7\x08\xe8i \x01:y\x10`\xbd\xfe\\\xcb\xd7\x13h&\x01f\x13j\x94\x96R\xc8q\xba\xaa5\xa7\x86.\xe9\n\xa6\x9aas\xef\x12\xf7\x10\x8b\xc9-\xd2H\x0d\x80q\x86\x8f\xa1\xd0\x92$~\xd7w\xa7o\xfe7\xc1j7\xeal\x1a\xf6KM&\xce\x95\x8ag\x1a\xf8\x9e\xc0\x9d\x8aE\x96Q\xbe\x8b\x89\xab<\xda\xbc,\xb2=D\xc92Z\x90B\xda\xf2y\xb9^\xd3\x9cY\\RP\xd9\xe2T\xc3\xec7\x97\xd73\xc7\x11\x9b\x9f\x1a\x1aSx\x8eq\xc95\xba\xceuc\xf30\xd1JZ\xe2\xd6\xf6\x0d\xbaV\x97\x90\xc31\x13\x92\xea\xf2\xd5\xfdv\x9e\xda+\xe4m\x8b#\x9a\xab3\x98\xe8K\xfeM%\x17\xe5\x9b\xf42\x814\x01\xfaI\xe5M\xf0\xd1\x1c\x9f\xbd~uSd\x835\x10.\xda\x9el\xb9\xaa9\x8f \x88N$\xd1\x14\x9d\xca,\x1a<\xfawoNx\xf6\x08,\xd3E\xc9\x93\xc8n\xa4L\xa3B\xbaZ\xdd\xe2W\xbc\xdf\x14\x8bW\x87\xc2+\xbfz\x03M\x94\x88=\x82\x9d\xcd\xe0\xb5L2j\x8c\xaf\xf3\x12\xa0\xff \xbf'\xf9F\xa8\x95|C\xee=x\xc8\xdf\x95\xe1\xe1\x85z\xe4\xbb\x94m_\xfc\x1c\xf3\xee\xcd ;9\\\xcfE\xaaC\xcb\x91&N\xe7|VM:s\xc2*T\xcbh\x99\\/dRJwFzaP\xc6\x0cB9\xc9\x16\x04c#y\x96\xcd\xe74Y\x9e\xd3\x84\xcc57-\xfe\x96\xa6OoH\xcd\xef\xbb7\xc1\x0b\xa8\\\xac\xbd_m6\xc7[\x9a,_\x88\xceD\x9e\xdaB\x1c\xbd\xa5\xb9@Z\x14\x92\xd7M\xc2\x8d\xcb\x0d\xe5\xd96\xa4?E\x88\xf2\xf6F\xcc\x10\xb0\xd6\xb5\n\x15!\xc4s\x1b\xed\xbb\x93\xd0M\xae5-\\1>c\x95~1~\x8b\x81\x84\xfb3\x8e\x9f\x8aS\xb1\xbfgR\x1e\xa7\xbf(K\xda\xeb\x86\n\x9bM1\x81cfj\xd7\x0c\xd69\xd3\x9b\x9aZ(\xb5\x17U\xff\xcd\xd4d,\x0cc&\x0d\xd5\x06\x1bB/!\xf4r\x05\xa1\x97\xbe\xee\xc1x\xac\x1b\xcd$\xb67\xa7\xcf\xd4 \xed>l\x8e@6\x1e\xaa\xee\xba\xda\x0e\xc5\xc9\x1a%fX\xf5\xe0S\xd6pJg\xc90\\\"\x9b\xd8Bt}\xd6\xe0'$e\xafy3\xc8\xb6\xe5\xb5\xd26\xd27\xec\xce\xde\xbd\xf8\x06O\x16\x18\xf6`0\x9d\xdd\x0d{1X\xf6c0\xed\xc9`Se\xaa\x9d\xdd'\x04#<]Zd\x1a\xefx\x0d&\x8f\x17T\x13\xd1{\xbd\xc0\xe1\xf9\x02\xe4L\xa7\xf2\x80\xc10/\x98\x16\x8f\xd5\xdb^\x83\xb77\x0cFz\xc4\xb4\x08+\xaf\xbc\xc1+\x06\x83=c`\xf6\x8e\x81E\xc6\x04\x18\xdfYv\xca\xc7d\xde2pX\xb70\x85\xd7\x0c\xbc=g\x00\x13{\xcf\xa0\xe7A\x03\x1b\x95\xedR9\xc6\x9b\xd6A\xd5\xe0\xba;-\xd6\xeay\xd5\x00=\xde\xde\x12\x8e\xf4\xb0\x81\xc3\xcb\x06=O\x1b\xd8\xc6:\x85\xc7\x0d4^7k\xa7\xf6\x05\x1d\xed\x81\xeb\xe0\xe3\xd5\x99\x8bn>)\xc6\x13\x07]o\x1c\x0c\x9f\xd5D\x9e9py\xe7@\xeb\xa1\x83Q\x03\x1f\xe5\xad\xeb\xa0+R\x93\xc7\x8e\xff\x8a\xf6\xda\x81U\xd0\xfc\xbdw\xa0\xf3\xe0Y\xcd[\xad\xd9i5r\x9b\xado\xb7\x9a{\x1e\x86\xea\x94\x0d\x7f\xff\x8fP\xe1)o\xdc\xb5y\xa7\xf5\x01\x8d|Tx\xa2\xa4\"\x01\xd6\x9b\xfc\xaf\xc8\x926\xbf\xeb\x8b%\x89\xc6$\x1d|l\xeca\x1asz\xec!\x93\xa7\xc9\xde\xdfq\x87J\x01\xb6\xa9\x8fNZjaS L\xad?\x8e\xcecj\x0b\x83\xcci\xd2q\xa55\xb5 \x82g/x\xf6\xae\xc4\xb3\xa7\xd9UZ\xdc\xf4\xe6\xf4Y\xbd\xaf\xf1\xdd\xbf\xd1\xa2\xe1\xb2\xe1+\xe0\xde\xbf\xf2\xd1.\x9b\x03\xef_F\xe7\x8e\xd5\x9628xl\xc7\xcf/\xeb}z\xd7\x8e\xa3\xbe\x9a\xd0\xe1\xe3p\xf9\xd8\x9d>n\xb7\x8f\xdb\xf1\x83\x9d\xf5\x94\xce\x9f\xe9\xdc?h\x07\xd0@\x17\xd0\x10'\x90k\xa0(7\xd0\x18G\x90\xd5\x15\xe4r\x06Y\xddA\x08\x19\x9a\xd4%\xe4\xf2(\xc0Tn\xa1!\x8e\xa1\x03\xb8\x86t\xce\xa1Q6\xf2\x84.\"\x8b\x93\xc8\xe0&\xc2\x8f\\\xb3\xb0\x138\x8b\xdc\xee\"\x9d\xc3\xc8:\xea\xa9\x9cFz\xb7\x11\x9e`\x9a\xa5\x1e\xee<\xea\xa1j\xa4s\xe9\xdcGX\x07\x92\xc6\x854j\x86\x13:\x92\x10\xae$\x933i\xec\x14\xa6t)\xb9\x9cJ\xben%\xbbX\x0es-i\x9dK\xbd\xaeZ\xb4RVn}\x03\x0c?os\xf9m.\x9cP\xa52!$\xa3\xeb(/h\xd6\"\x92xa7\x1c&\xc3a\xf2\x8a\x0f\x93\xbd#\x9e\xa7{4\x1f\xe8\x1f\x9d\xa8h\xd7\x83\x9b\xf5\xc9\x82`14\x7f\xfb\xc8\xbe!\x89\xb3n\xa7O\xe4\x04k2' \xf4\xff\x94I\x9dP\x9dE\xbb\x89\x9d\xa0K\xee\x14\x9f\xdb\x12<\xc1:}\xd3\xc4[S\x1e\x94\xeci\x95\xa6N\x85p\x13s_\x94\xb8\xd2bG\x8cO\xb7Y\x1fM\xe6\xe6#\xb0\x8a\x8ex \xed\xf5\xca[x\xba\xdem\x0f\xe1\xd1\xb0\xaf\x81qC\x9e\x95\x869\xbaK\x86I\xb4Rm\xfc2\xad\xce\xd8\x96!\x9az\xf3G\xdexb\x0f\x0czq\xbc\xc7.d\x1d+\xc0\xb1\x15\xd4\xe6\x86X \xc5<\xf2\xbf\xe4a\x8e\xe7\x19\xcb\x06\xc1~\x0c\xf6\xe3D\xf6cw\xa0&%\x83\xd1h\x8df\x12[\xcff4\xa8\xb6\x869\x82\xd6f\x1dM\xa3Y\xa5\xa9*G*\xc6\x1ci5\xd5V\x92@\xd72\x8d*\xb2\xe4tV\xd0dI\xb3m\x94\x14\x15\x85\xbe\xa3\xc5\xd38]|x\xba\xff\x9e\xbfh\xeb\xad\xfc\xf9c\xb4\xe7Q\x8f\x1a(I\xf7He1H\xf9\x8ed\xcc\xdc+\xce7\x94,\x9b\x8f\xe1\x82\xcd\xe66[\xdc\x1a9\x85\n\x93)\x0ea\x8bA\xe8\x1c,\x0e\xeb\xdd\xa5\xd0NIV\xe4\xb4\xf8\x9e\xcf\xf8\xab\xce\x8f|5O\x9e7Wg\xd8\xd2LCOy\xcf\xb4\x86\x02b\xb8\xc2s\xc2\x87\xc9=\x1f\x06J\x0d\n\x95u&\xdf\x04+\xfd\xc1\xae\x83\x05\x90\xdd\xee0\xa8]G,f\x94$9M\xf22\x87\x05\xd9 ;@\xec\xe4\xea\xcfY\x19\xcb\xf0\xc3.K\x174\xcf\xc55y\x9c\x1e\x1a|r\xcf\xe6?s7\xe3\x91.f\x13%\x8b\xb8\x14\x17\xee\xc5q\xe3c\xe0\xa7\xf8*E#\xaf\xae\xd6\x14\xa30\xbc\xc6\xc0 \xa8\xaea\xbf\xae9\xdf\xf1\x87\xb6\x0b\nEF\x92\\\xdc\xd1\xb7%\x8bM\x94\xd0n\x94\x82\x8f\xa2\xa5\x81\x14X\x96\xa2\xfb~7\xa2\x89]\xce\x8b\xa8\xefhG\xa2[\x92\x82\xdeb\xed;_\xf0\xdb$\xfb\xfaU\xc1\x08\xc9\xd0+%p\x0d\x18l\xcaI\x80U\x1f+\xb0\x8e\x1c\x9c\xa3\x07\xb3\x9e\xae~\xb6\xeak\x05\xee\xd8\xb1\x8dT\x80!\x17\xb8I\xe6\xd0\xeb\x9d\x8f\xda\xfa]\x01g\x95E\xba\xddF\x85\xd6\xa5\x8f\xe4D\xed\x08e\xc7\x0c\xad\x90g\xa1\xad\x99\xd8w\xbee\x7f\x9a\xb8\xfb\x8b\xea\x91\xf8\x89\x11w\xe7\xb5\xcax\xb8\x8d2\xbd\x04iY\xec\xca\xa2\xfe\xdb.\xa3\x17Z\xf5\xc9\x8f\x12\x07\x1bc\xa5\xd1'\xc6Kv\xbb\x891r\xfe\x93g\x8d\x89Q\xd3\x8bhI\x93\x05\x9d\x18m\xb5\xfe\xf5\xb6\xa9\xb1?\x98\"Js\x9a\x9d\x1b2^\x87\xf6\xdf\xda\xe4\x85\xc0\xb7N\xd4u\xc6#\x0f\x9c\x9dU\x86\xbb\x14>\xa1][\xae\xcfV\xa1\x1b\x0c\xb3\xd6\x8aO\xc6\x19\xea\xf3)\x8c\xb9\x14\x0e\xc5h]\x18\xb7\x05t\xf6I&\n\xab;\x81\xb91!\xdc \xc2l\xf8OA\xa8\x998\xd5\xfc\xe5\xae\xe6:z\xe5\x98\xe1\xaf\x11\xc51\x9b{1\xac\xe5\xb3\xd7\xaf^\x9d\x9c\x0dj\xfb\xfa\xf4\xf5\xdb\xe3\x1f\x1dMe4\xe9\xf1\xc0\xf9\xba\xd5X\x1b\xdeF\xeb\x84._\xe5\xeb3y\x85\xbax\xe1\x8b'\x96\xf1\x9f\x9a\xafJ\xe8\x15P\x1b\xaa\x9dM\xab\x8c:`\\\x9b\xc7\xf0sZh\xdeTCa\x10t~\x0c\xa7|\x1f%\xb1\x1d\x8d\xe9P\xd6\x06\x0f\x86\xc6\x18\xf8\x02\xb2\xb4L\xb4\xf1\xd2&\xe0N\x15\x02\x1a]\xdf\xbfg\xfd\xd6|\xc2k\x03Rw\x80\x87\xfe\x00\xe7\x01\xa7\x06\x0f\xb2\x83k\x87\xef\x02\xea\xd4\xd8\x06\x0fj\x80'E\x188\xce\x97m\xf0\xe1\x0b\x05x\xd6T\x80](\xf0_,\xf0]0\xe4\x99U\xdbD\x7f\x82\xed~\xba\xa5yA\xb6\x06\x1f[\xe3C\xfcD]\xee\x966T\x87:\xb3\xe9\xdf\x86\x01#q\x92\xba\x1eD\x94,\xe9'\xdc\x10p|\x88\xd7OU\xb8\x11\xd7\xfd\x94\x14\xf0\xd9B\xd9.\xd5\xce\xdcc\xa7\xf6\xb4\xa0G\xf2=\xc6m$\xde\x88\x14\xff\xe4\xc6\x9a\x15!?\xfd\xd7g{6f\xfb>\xda\xd8oM\x9fp\x0bq\x1e,D|\xcb`!\xd6\x10,\xc4`!\xda\x00\xa9;\xc0C\x7f\x80\x87\xe1\xe1Av\xc0\xef\x01\x02\x82\x85\x88\x00\xecB\x81\xffb\x81\xef\x82\x05\x0b\xb1\x07\x03F\xe2$u\xb0\x10\xf1[\xe8\xef\xc2B\xe4j\xe5\xfc\"-\xa2d}\xce\x0bP\xdd\xd6\xa2\x93\xa08UR\xf3\xd2\xd5\xf6\x8b\x12e\xcf\x1e]\"\x8c\xe5\x9b\xe7\xca\x91\xcc\x98\xe7\x85t#\xd7nw\xe5X\x16a\x9a\x8a\x80Ft\xd2L+.S\x86c\x15G\x0b~\x93\x05\xe34\x03O\xc4\xcc\xe09\x17\xb5A\xe7\xa4(\xc8\xe2\xc3U\xb9\xb3\x1b#<\xb7\xe4\xd2\x08@\xf4 \xc8~\xa1\"\x14r\xb7G\xf6\x0d\x1e\xfd\x83!\x05J\x0f\x1e\x03\x00\xcfA\x80-\x89J\x0f\xd8\xd4*=x\xce\x05\x06\xcc\x07\xec\xc9Yz@*\x80.(\x85`L\xe4\xd2\x831\xbdK\x0fW98\xac\xea\xea\x02.m\x0c\x8dN\x9f^\x86=y*p$\x9d\xe9\x01\x9b\x8a\x86F\xa8KYs'\xa8\xe9\x01\x9b\xb6\xa6\x07s2\x9b\x1e\xbc\x19\x0fw\x82V\xe0\x8d\x1e\xbb\xe77A\x9f:\xa7\x87\x11\x03r\x99\x04mp$\xdf\xe9\xe1\x8at\xa7\xcf9\x0f\x86\x11\x0d\xf0&x\x1b\x06\x1c\xd4\x15\x0c\xa0\x1e\x0c\xa4 \xf8\x1e\xe0\x15\xf8\x1c\xa0\xba\xe0/\x19\n|\x17\x1c\x86/:\x0c]\xf8A\x07~\x05\x1e\x07\x7f\x05\xee\x94G=\x0c\xa0\xcb\x00z\xe0\x93&\xf5`I\xa5\xd4\xc3UL\xcb\x99\xe8\xa8\x87\xab\x18\x9a\xb94\xca\x0c\xd8\xccO4BS\x82}\x1fpy\xa3z\xb8\nr\xba2O\xf5p\x15#3\xe7\xae\xea\xe1*\xc6\x84\xc8~\xd5\xc3U\x0c\xce\x91?\xab\x87\xab\x18\x18.\x03W\x0f\xee\xbc\\=\x1c~^CNg> \xc0(\x84\xa6$a=\x88M\x14CBO\x0b\xcd\xd72\xfb\x02\xcf&\xa8\xa8\x9f\x82!\xc6!\xde\xcb\xae \x1cJ<\xc4Q@8\x94\x18\xc1_$\x14\xf8.8\x0c_t\x18\xba\xf0W}(\xa9\xaff\xc0RFP\xc4|[e\x1f\xac\xf7W\xf6a\x10\x03\x0fc_\xa5\x99\xceW1\xd1\\\xbbg\x83\xc1\x8c\x81\xcbHj\xc3-x\xfa\xe3\xebg?\x9c\x9f\x8c\x1e\xa6\x9fSU\x00:]\xa0\x0d\xa3\xc7\xeaE\xd2!v\xbc\x80g\xdc\x9c~\x1b\xadE\x86\x1e\xb3=TH\x81g \xa8\x92,\x0f\x94Q\x02D\xe2u\x9b\xf3\xc3\xc6.\xb0\xb7\x0b\xca\xaa\xe86\xafV3_ \xd0\x87K\x92\xcbc\x85\xbc\xe6\x93\xa8\xea\xb4\xda\xe9a\x9fI-\x7f9u\x1e <\xf68\x9f\x9d\xad\x1e\xab\xfb[\xdf\x9d\xdcc\x17\xf7\x98\x9d\x00\x9f9\n\xf0\xd6q\x83\x84q\x80 \xee\xcay\xff*(\x1bx\x13\x0b\x06\x11\x8c\x01]\xde{\xf0\xe0\xee#\x9f&\x03 \x07\xc3\x88\x07\xfc2\xa0\xc5\xee\xde\x83\x87\x1f\xee~\xc9\xc3\x1cb5\x9c\x96\xf38Z\xfc@\xf7-\xbf\xc9\x07\xbao^v\xe5\xb7\xe7\x979\x15\x97\xbb5\xea\xad\x7f\xaet\x00\x12\x116u\xab\x0d\x83\xe8=\xe4\xecVy\xcevY\x94fQ\xe1-Z\x07\x1d\xa3\x1a\x1dfP\x9e\x92\xee+\xe3\x9e*q\x00q\xbcE\xc5S\x19z\x12\x08\x06\x10 \x86\xa9\xc1\x01\xc4\x82!\x04\x83\xa1\n\xf0\xea\x06\xe8\xaf\xfa&W|\x13\xa8\xbd!Jo\x00\x8d\xfd\x94 \x8cQw\x07\x1f\x9d_\xa2o\xd5\xcaoX\xb8!1K=M\xce\xdd\xeewd\xef\xb8^\xe7\xfb\xcf$)\xa2\x84\x9e\xe3\xecl\x9c}\x8d\xb0\xab\xd1z\x11\xaf\x0d\xd1\x9b\x05\x92\x82\x02<\xd4 zk@O\x1e\xbc\x08\x00\xbe\x1b\x81\x17!\xc0\x8f\x18\xe0\xaf\xf6\x0f;\x1c\x1f%\x8fU\xefLm#\xd0\x0dV\xec~\x9a\xc9\x8b~8\xfd `\x80\x02?\xc0X\xfc\x945r\x00\xc8\xae1\x9e=\xcf\x1e]^;\xac\x03\xe9G\xb6a<\xe3\xb5 \xc7\xbc4\xc1U!!\x9c@F|\x8dZ\x1aR\x14t\xbb\xe3\xd5\x11E\n\xdb(\x8f)Y\xf2\xb7\xb6\xd6\x9bB\xbe\x95\xd2\xf4 5\xd2\xc1\xda\x842*<\xb3r\x9b\xfcrHC\x14Y\xe0C\xdc*\xdb\x8b\x0c\x87[!\xb5\x10n\x85l\x81-\x1ai\xb3\xa6\x0eu+\x17*>\x88 \x9e=\xe6\xe7\x1b\xdd\xf3\x8c\xe3yF\xec\xf0\xb1\xb9AQ\xb8\xd6\xfa;\xc3g\xb8\x80\x18:\xf4\x85X*\x04\x97;\xb67\x8fN\xec\xdb\x9a3\xec\xe4\xd1\x93a:\xad}\x13\x1b\x072Gw\xec\xdb0:bc\x88\xc6t\xd0ib3\xfa\xfeMW\xc6\xe3_\x80\xeab\xe0\xef\x0fk\x1e)1^Y\xff#co\x81#\\X\x1f.\xac\xe70\x11=\xc3\x85\xf5=p\xa0v\x1f\x16p\x95\x87\x10.\xac\xb7,\xc5\xe4g\x92pa=\x87p4\xe9\x03\xc2h\x1b{4qWo\xa18Q;B|\xedU\xb8\xb0~\xda1\xba\xca\x86\x86\xe2\x0d\x17\xd6\x03\xe0\xcae\xdc\x851\xc3\xfa\x0f\x17\xd6[\x16\xc6m\x01\x85\x0b\xeb\xc3\x85\xf5V\x03!\\X\xdf\xfe\xc6e\xa2\x08\xc0%\xff\x87\xebHq\xf3u\xab\xb16\x84\xebH\xdd\x19\x13\xe0\xc7\xd0\x18\x03_\x00\xaa0\x11w\xaa\x10`\x0b7\xb5\x01[\x80\x88\xd4\x1d\xe0\xa1?\xc0y\xc0\xa9\xc1\x83\xec\xe0\xda\xe1\xbb\x80:5\xb6\xc1\x83\x1a\xe0I\x11\x06^\x85\x83>|\xa1\x00\xcf\x9a\n\xb0\x0b\x05\xfe\x8b\x05\xbe\x0b\x86<\xb3j\x9b`\n\x00\x9da\x8c\xeaC\xfcD]\xee\x966\xa0\xa36\n\x06\x8c\xc4I\xeap\x1d)~\x0b\xfd]\\G\x1a.\xac\xf7m\x19,\xc4\x1a\x82\x85\x18,D\x1b u\x07x\xe8\x0f\xf00<<\xc8\x0e\xf8=@@\xb0\x10\x11\x80](\xf0_,\xf0]\xb0`!\xf6`\xc0H\x9c\xa4\x0e\x16\"~\x0b\xfd]X\x88\xbfajt\xb8\xb0\xbe\x0f\xe1\xc2\xfapa\xbd\xeb;\xaf\x01\x80\xe7 \\X/\x00\xa9\x00\xba\xa0\x14\x82\xd7\x9d\xf0\xe1\xc2z7\x84\x0b\xeb\xf5\x80M[\xd3C\xb8\xb0\xde\x0e#\x06\xe42 \xda\x10.\xac\xc7\x9a\xe0m\x18pPW0\x80z0\x90\x82\xe0{\x80W\xe0s\x80\xea\x82\xbfd(\xf0]p\x18\xbe\xe80t\xe1\x07\x1d\xf8\x15x\x1c\xfc\x15\xb8S\x1e\xf50\x80.\x03\xe8\x81O\x9a\xd4C\xb8\xb0\xdeoh~E\xe1\x02\xb0\x99\x9fh\x84\xf8\x0b\xddpy\xa3z\xb8\nr\xba2O\xf5p\x15#\x0b\x17\xd6{\x0e.\\X\xdf\x80\xc3\xcfk\xc8\xe9\xcc'\x01\x18\x850\\X\xaf\x07\x7f\x0b\x0c\x15\xf5S0\xc48\xc4{\xd9\x15\x84C\x89\x878\n\x08\x87\x12#\xf8\x8b\x84\x02\xdf\x05\x87\xe1\x8b\x0eC\x17\xfe\xaa\x0f%\xe1\xc2z\xe7\x85\x14z\x18\xcc\x18\xb8\x8c\xa46\xf8^i\xa1\x07\xcf\x8b.\xf4\xe0y\xfd\x85\x1e\xf0\x97b\xe8a\xd0U\x19z\xf0?\x85 @\xde\xb8\xe1\x89\x15u?\x87\x1e\xbc\xa3\xfbm\x18\xcc\xcf\x83\xd5\x1c\"\x86\xda\x87\xd1\xc3\xf4s\xaa\n@\xa7\x0b\xb4a\xf4X\xbdH:\xc4\x8e\x17\x80\xbd\xa8\xc4\x03e\xb8\xb0\xde\xf6\xa9\xd7\x1e\xe7\xb3\xb3\xe1.\xd2T\xe0\xb7\x93{\xec\xe2\x1e\xb3\x13\xe03G\x01\xde:n\x900\x0e\x10D\xf4E\x9c\n\xbc\x89\x05\x83\x08\x06\xbe\x17t*\x18D8\x18F<\xf0\xbf\xb8S\xc1\xd5\x0es\x88\xd5\x80\xbd\xd8\xd3\x03\xe5\x0477\xfb^\xf4\xa9`\x10\xbd\x87\x9c\xddv\xfe\x17\x80*\xb8\x821\xee\xc2\x85\xf5\x16\xf0T\x86\x9e\x04\x82\x01D\x82ajp\x00\xb1`\x08\xc1`\xa8\x02\xbc\xba\x01\xfa\xab\xbe\xc9\x15\xdf\x04jo\x88\xd2\x1b@c?e\x02c\xd4\xdd\xc1G\xe7\x97\xe8[\xb5\xf2\x1b\x16nH\xe1\xc2z=\xe0\xb5!z\xb3@RP\x80\x87:Ao\x0d\xe8\xc9\x83\x17\x01\xc0w#\xf0\"\x04\xf8\x11\x03\xfc\xd5\xfea\x87\xe3\xa3\xe4\xb1\xea=\\Xo\x82\x03\x8c\xc5OY#\x07\x80\xec\x1a\xe3\xd9\xf3\xec\xd1\xe5\xb5\xc3:\x90\xc2\x85\xf55\xd8V3\\X\x8f\x88\xbf:w&\xf7n\x14n\x85lA\xb8\xb0\x1e\x13\xc6\xf2\x8c\xe3yF\xec\xf0\xb1\xb9AQ\xb8pa=z[s\x86\x9d\x1e\xc3\xbb7?\xde\xceh\x9e\x96\xd9\x82BB\xb6\x92i\xcb$\xfaX\xd2x\x0f\x8c\x93\x8bh\x15\xc9\x13P!o:1e\x01\xe44\x8bH\x1c}\xa6K}\xad\xd6.K\x8bt\x91\xc60/W+\x9a\xa9\xabRf\xe2VN1\x17\xd8\x96y%Q@\n\x88)\xc9\x0b=\xbe4\xa1p\xed\xf65XlHF\x16\x05\xcd\x18&\xca\xedP\xc8\xe9zK\x93J\xdc\xdf\xbd\xf9\xf1z\x0e;Rlx\x07ZtU]\xba\xbe7\x86fU\xc6\xf1\x1e>\x96$fTY\n\x9a\xc9.8un\x90\x1c\xa2D\x8f\xe0=\xeb\xfe\xf6:M\xd71\x9dqZ\xcc\xcb\xd5\xecy\x99\xf1\x02\xb7\xf77\xc5\xe89\xca|\x93\x96\xf1\x12\xe6\xfc\x1a\x19}\xb9\xc2\x82$i\x12-H\xcc\x05D\xdf\xe3\x0d:[\xcf\x8e\x18 y\xa9\xde\xb5\xd95\xa6#\xf8m\xab\x8b\x05\xdd\x15tys\xf6\x95\xbe\xe9I\x02;F\xd4hA\x8f\xa0\xa0d\x9bC\x99\x97\x84M_T\xea\xef\xa2\x98\x8d\xaeH\xc5\xa5\xa6QB\xb2=\x908\xd6\xd3n\xbf\xa3\xf2\xc6\xd5bC\xf7\xfa.\xe9\xa7\x1d]\x14\x10\x15\xec\xb8Q\xe6\xea\n\x1d\xce\x0c\xf4\x13_\xca\xe3d?\x83\xef\xd3KzA\xb3#\xae\xda\xde\xbd\xf9Q\x7f\x8c\x16;/C\xc3\xd8U\xcf\xaf\x8b\x0d\xddRx\xbf)\x8a\xdd\xfb#\xf1\xbf\xf9{~\xff@\x92\xca_\x8f8\x97-H\x02)\x97&N\x81\xbe\xea\x16P\xee\xe4}@\x86\xfehvA3A\x86-\xd9\xe5\x82e\xd8\x0c\xf8\x01K^\x1c\xc4}\x0e\x91\xb8;\x96\xe8\xe7\xb6J\xe38\xbd\xcc\x1f\x1b\xd6\xee\xdf\xe1dU\xcf\x80-\xf9.K\xd9\xb6\xb4\xac&\xc97\xc4[\xa4[\x93\xc6|\xcb\xa5-\x87\xb4\xd8\x08!O\xba\x9a\x05nH[\x8cnw\xc5^\x8a\xe7M-\xb2-\xf7\xb1\xcc\x0d\x8a\x84O\x90\xbb\x15\xa3\xed.\xa6l\xa3\xe3\xcc\x0f\xf9\x8e.\xa2U\xb4\x80\x9cnIRD\x0bM\x8a\x0f\x97\xb7\x01&\x85\x8f\xe1m\xb08^1\xd51\xa7\xea\x9e\x8e\x86\xc1\xd0\xb3\x0dT\x05\xf8<\xbd0\x18\x1bb\xaa\x92\x9d\xbb\xd3t\x8d\xe6\xfdq\xb2\x7f_\x1b\xee$\x01\x92\xcd\xa3\"c\xc2g\x19\x95\xd4\xd1=t$N\x93\xb5X\x11\xd2_2\xa65\xb9\xd2\x17\xa3\x9a\xf7\xcd\xa9f\x9f\xca*\xd2\xb0\xd9\xa9b\xfc8\x9a\xf3\xa1J\xbd\x9eC^\xeevi\xc6w\xce\x1dY|\xb8]&\xec\x7f\xd8~)\xd6\x9b[%]t\xdc\xa2\xd1\x1a\x0f\xe9\n\xcaB(\x1f%\xce9S|d\xb9\x8c\x84l\xc3\x9a&4#\x05\x1f0;:TE\xfb\xc7\x1a}'\x96\xa8\xdf\xcf\x8bO\x8410\xdc}\x0c\xa7l\xbcL\x8e\xe5\xd0I\xf3&\xbdg\x7f\xf9\x8ba\x9bz\x99\xa6\xb0JSx\x02\xb3\xd9\xec?\xb4\x9f0\"\x90d\xaf\xff\x91$\xfb\x19\xeb\xfae\x96no\xac\xd2\xf4\xa6\xfe\xb3\xd9L\xbf\xf7D+\xb8\xc1P\xbc\xe3\x83>Ko\xfc\x1b\xc3q\x13\xfee\xd0\xa7&<\xbf\x9ais\xcfA\x9b\xbf\x92\x0b2\x9a8\xf0\x84\xdbV\x0c\xfb\x08*D\xf9\x8d\x97i:[\xc4$\xcf-D\x10Cb\x0d\xc4|\x1a\x8d\xf4\xfdj\xa8S\x91\xe7\xbe\x83<\xa7\xfbb\x93&\x06\x02\x89\x91\xbcL\xff\x7f\xf6\xfe\xaeKn\xdcH\x17\x85\xef\xfd+b\xeb}\xd7H\xf2T\xa7N\xf7\xecs\xa3\xbd\xe55jI\xdd]\xde\xddR\x1d\xa9\xda>^^^)V&\xaa\x8a#&\x99M2KU\x1e\xfb\xbf\x9f\x85/\x12 \x02@\x80D\xca=\x9e\xc4M\xb7*\xc9\xc0\x07\x81@ \"\x9e\x07\xcd\x93\xd5j\x85k\xe2ap\x9ex\x7f\x17\x13H\x0c[\xea\xa8\xf1\x97\xcf\xe5\xa0\xbd~\xf3\xe1\xd5\xfb\xf3\x8b\xcbw\xef\x9f\xfa\xbc#\xe3D\xf3W&\xab\xf3\x0f\xd7\xff\x8c\x0c\xd7\xf7\x8d\x87g\x83\x0f\xd5\xf3\x17\xf0/\xfb\xab\xd5wM\xf3\x9f\xab\xd5\xea\xef\xf8\x83E\xfdp\xc6\xcd5\xfe\xf4^\x1a ?\x15mw[T|\x10\xfd\x0d\xf7\x0d\xd3\xb4fO\xb5\xe5\xf5\xa4\xd2\x9f\xeb\xddX\xadh\x94\x98\xd8\xe2\xa9\xff\xf1\x02\xea\xb2\xf2NP\x7f[\x90\x99\xc8\x0fmb\x1c\xb5\x1e\xd4\xc66\\=\x8c\xa6\x8a\xd6\xd8\xf2\xba\x8c\x07\xedjt\xa4\x1d:d\xcf\x7f\x8c\x98!\xcf\xf8Yt%~\xe0\xa6\xdcc(\x8c]\x85\xef8\x8aQ\xc5\xadA|u\xb7\x92A\x8d\xd7\xd5\x83>79\x07\xde\xc1t\x84\xe2\xbag\xd2\x9a\xe1\xe7m\xb7\xc9\xcf\x1e\xbbU\xa8\x03\x9dn\xa2<\xc1153\x1f]7\xcd\xea\xaahE\xe7\xee\x9f=\xac\xfe\xfaH\x8e\x96\xbb\xf9\xafP&C\xe0$\xe6\x0f\x8dF\xd34fH\xb5\x8eQ\x83\xc3_\x07\x1az3\xbe0\xb8\xe4\xbf\xea\xd8\x10D\xd9\x177e-\xc6nl\x8c%s|`\xc8\xb5)j\xf3\xafZ\xbc\x0ej\x8c\xfbr\x8f9\xd5qw\xba\xe0\xfap\xfc\xf2\xde\xf1\xf0\x9etU\xa8\xefo\xd3\xf3\xa4\x96\xaf\x07\x86\xff\xafr\xd7\x14]'\xfdP\x17\xc5\x0d{\xcf~9\xb0\xae_\xc9\xdf'B~9\xb0\xf6A\xbc\xce\xc5\xf11`\xb0k\xba\x1e\x98p\x86\x08\xef\x89\xf1\n\x12h\x8fv\x08!\xb9\xf3\xe5E \xf1\xa2?\xe2\x7f\xea\xc3\xeeJ\x9e\xca\xb5\x0b\xcd\xf0\xe3L\xb3I\xcc\xaen\x9aC\xdd\xaf\x85\x90\xe9\x12\xfd\\t\xd0\xb1\xfe\x0c\xca\xbe\xd3^\xc0\x0e\x0e\xb5\x9c\x08[\xe9H\xf9\\\xaa\x1c\xabH$\x0c\x8bF%\xdd\xdfl\n\x98}\x8d\xf3\xdbf\xcb\xce\xeb\xeb&9\x1e\xa6\xcc\xc1u\xddl\xd9\xba\xac\xaf\x9bi\\\x8b4\xcf\xb5\xbbb\x8d\xd2U\xa2\x82\xfc\xc2\xc4/\xdf A\xe1\xa0\x9f(0\xd5\xbc\x8c\x93\xf3\x05\xa2\x1c\x91\xf3\xc4\xd9_`KZYU\xd9\xf5\xac\x161z\xd2\xf35\xeb?7\xed'\xd2\xb3\x81O\xe8<\xbb\xb9-\xea\x9aU\x1d\xe9a\xaf~\xdb5u\xf9 \xbfp\xda\x11\"\xd6\xe6\xe2\xe9\xd5\xdf\xfb8\xb3\x03\xdf\xb0\xddo\x92\xee\x824H$\xddu\x91\xb0\xb8\xb8\x91J\x1a\x9bb\xbf_\x93\x1fN\xf9\xcc7e(\xbf\xcey\xfc\xeaPV\xdbu_\xdc\xd0\xe6\xc5M\x13R\x1b\x1e\xe9[\xb6G\xa5\xbbYMhF\x93w\xce\x84\x03\xe3\xfb\xa2Gs\xbf\x82+\x7f\xd8\xebv\xcd\xf6P1!\xc4y(\xc0\xf3\x9b$\\\xc9q\x9e\xeb\xf0\xb4)\x9a\xec\xcd-\xdb|\xea\x0e\xbb\xe9 \xca_\x7f\x925Om\xb3?\xc8\x96\x9c\xdb\xbcNr+[w\xdbO \x1f\xdd\xb6\x06G\xb9\xa8=\x88\xec\x86\xa3k\xdb\x91fn\xe8\xcek\xc36.L\n\xbb\x9aa\xff\xd6o\xf1=[\xc9J\xd9\xb9?<\xd4\x9b\xb2\xbeI\xde\xb8;\xf9\xdeT\xa3\\5M\xc5\x8a\xf1\xfb\x0f*\xd7\xf8\xbbw\x00&m!\xe6\xf5\xa8\xb7f\xf6\x1f3\x7f\x92\x07\xe3\x94\xd5\xa3\xdf8e\xf5\x9c\xb2zNY=p\xca\xea9e\xf5\x9c\xb2zNY=\xb2\x9c\xb2zNY=b\xa4NY=f9e\xf58\x85\x9e\xb8r\xca\xea\xc1\x1e9e\xf5\x9c\xb2zNY=\xd3r\xca\xea9e\xf5\x9c\xb2z\x86r\xca\xea9e\xf5\x9c\xb2zNY=\xa7\xac\x9eSV\xcf\xaf.\xab'\x14\x8f\xfa\xc2y=2\xb0J\x0e\x82\xd9\xc1i\xf4\xeby\x03\xd1\x9e\xfc\x84\xe0\xebv\xa8\xd9\n0\x87\xde\xb6\x82\xc9)!\xe4\xc8h\x0d\xe3M\x1e0'\x1c\x874\xdb \xc1%\xe8\x89\x1e\x0d\xb8y\x97U\xd8\xc9\x941\xbc\xe6\x0f\xac\xe5\x0b\xa9e\x0b\xa6y\xc3h\x0b\x02h\xb9Bg\xe1\xa0\xd9\xacp\xd9\xec@\x99\xe8\xef4\xbe\xe3\x0d\x91\xcd\x0e\x8eI\xdbl\"\xcd\x13\x16[\x12\x10\x13\xc1\xafio\x903\xdb\x9c \x98?\xe0\xb50\xd4E\nr\xd1\x03Z\x0bBY\x0b\x82X\xe8)?[\xa8*o\x90*[x*\x1e\x98\xca\x16\x92\xf2\x05\xa3\x96\x84\xa1\xd0\x90\x13r\x16q\xf5\xcd\xdc0\x937\xa443\x98\x84\x84\x91\xa2\xf6\xa7cP\x87w\xd0\x99\xe1\xa214\x84\x8d\xefo\xe2u/\x0b\x0e\xc9`\x90!\xce\x0d\x0be\x08\x08-\x0b\x05Mf\xf9t3\\\x18\xfeQ\x03mJ\\\x12\xe8 F1<\xc1\x9dhX\xc7\xf5\xf0\xd2C9\xee\xbb\x7f\xc7\xfa:+pC\xe9l,X\xe3\xef[4@\x93\x10\x9a\xb1\xbdX\x0b\xc31\xc1@\x8c?\x04\x13\n\xbe\xa0\xa3@\x0d\xb8\xc4B-\xd3 \xcb\x82\xf0\n!\xb0\x92\x1eRA\x02\x18\xb10J\xa6\x00\nR\xb35S\x16\x85K\xa6\xe1\x91%\x81\x11$\x10\xb2(\x042\x0dy\xe4\x0cvx\xc3\x1cS\xdf\xef4\xb4\x91'\xa8\x91-\x9c\x917\x90A\x0baD\x83\x17\xc4\xb0\x05%`\xe1x\xf6\xdd\xda\xa8\xae\xe7px\x82\x18\x98 \x84$\xac&\xe7\x0cC,\n@\xb8\x01\x87|\xa1\x86|A\x86\xf9_7\x1aX\x88\x85\x14\xb4\xfa\xc6\xc3\x08\xa8%\x8e9\xf9\x03A\x03\xa2\x8c%!\x82\x98\x83p\xf4&\x92]\x846\x9c\n\xe9\x83\x8b\xb9B\x1e\xa2xW1\x8c\x15\xf2\x18\x86\xad\xc2\xa4!\x98*\xaf4\x1bK\xd5\x1f\x01\xf8\x80\xe1\xa6\xbc\xc7\xbb(^\xca\x83\x95\"\x0b\xc40R\x08>*.\x0f\xc1E\xa58\xb4!\x82\x87r\x1a\x90\x13\x07e,\x90M\xfb\xb0\xef\x9b\xd5p\xfb\x04yu8\xb7~\x04\x17\xb9q\\Gn\xe8\xa0\xbd\xaa\x89\xd1\x13.\xca\x08_\x83a\x0c\xc3\xfe\x9b\xfd\xea\xb54\x0c\xf5\xc0\x91G\xc2\x0f\x80FW\x8a\x07E=\x05={g\xa07\x02\x87\x00\x9d\xd3\x858\xe0\xe64\x11^@3\"\x06\x052#\xcf9\x00\xe6\x99Z\xd6\x05,\xd3\xe6\x1d\x02RF^\x9c\x80\x93\x13>=\x0eH\xf6\x8c\xbb\x17\x88<\xb7\xdf\x8d\x8d%Lp\xb7\x81H\xe3\xd0\x86\x85\x1bu\xa1\x16\xce\x1f\xcc\x8fGh\x8f\xb5V\x82\xdf\xd0\x9a\x9b\x93\xf5A\x7f\xd1Z\x13\xb4\xd7\x8c\x9e\xf6\xe2\x04\xfc\xedX9\xa1\x87\xd3\xfb2\x12f\x13\x8e\xac\x95\xaa\xf3\xaa\xe8\xca\x8d\"\x87/ml\xaew[\x0f\xe1\n\x7f\xcd\xd4\n1\x8f\xf0+\xbe)\xd6\xdd\xa1\x83M\xb1\x17\x97e\xe8 \x98\xfas{\xa8\x98\xb8,\x81\x0f\xc0\x86u\x9dpy\x05\x9f\xb4\x0c\n\x15\x875\xaf\"\x1a\x0c\x18%J\xaf\x82YS\xc0}\x19\xe6\xcd\x83d\xa2\x8b\xedA\x1aGl}\xd7\xf4l\x8d7D\x96\xe0\x86\x1c\xdb\x92\x85\xbb\x94\xad\x0b\xfc\xb7\xa8p T\x00Z\x8c\xf7W\xc2\x16-K\xf8\xe64\x10\xf7\x95}8\xff\xfe\xed\x9b\xd7\xeb\x9f>|\xbf\xbe\xfc\xd3\xc5\x9b\xe8\xfdi\xf8[\x17\xef\xdf\xfc\xe1\xdd\xe5\x9b\xf4\xb7\"\xf7\xa9\xf9\xde{w\xf1\xee\xc3K\xdf\xd5j\x00\xc6\xf5j\xe9\xfd\x8b!\x7f\xcd\xf2\xa1\xbc\xa9\xd9\xf6\xa7\xee\xe6R\xc57${\x03_r\x9d\xf8\xc9\x0c\xdd\xfai\x01d\x19v\x0b\x0f\xd6p(\xde\xf1\x7f.\xee\x1a\x8b\xdc\xf5\xea\x1f\xcf\xe7p!\xf6\xa5\xa2\xf2\x8b\xf8\xc2\xd7F{\xee\xd2\x1cK\xdc\x12\x96\xc5\xa8\xce\xb9_s,\xfe\x9b6\xc7BX\xe3@\\\xe7\x10\xbd\\R\x16\xe2\x90B\xcc87K\xf4\xe4b\x17b\xaf!\xa1\xe7\xbcD\xee\xf04\x1e$~g]h\xd3K\x17\xcaG\x80\xb4\x0f\x01)\x1f\x83pnB\x1f\xc7o\x025\x1f\xfb\xf2\xd7 '\\) \xe9\xb5\x07\x87r\xac\xd8\xc3\xf58\x16\xea|\xa2\xe9\x8d\xe8m\x93\x90\xb5\xa7\xd4-J\xdc<9D\xcc\xc5\xbd\x94-\xe3\x16\xcc\x99J\xe6\xdd\x952\xb9X\xfe\xaf0n\xbc\xc2\xc4\x89\xd3\xb8\xb3\xf9\xbaAp\xab\xba\x18{\x19\xf6\xb3\xb0\xa2\xaeNV\xd4\xc9\x8a\x82\x93\x15\x85\x16\xe2\xe4\xa4ms'+\n\xe8C\n4\x1d,\xcb\xc9\x8a2\n\xe5#@\xda\x87\x80\x94\x8fq\xb2\xa2\xa8\xb5\x9f\xac\xa8\x84-\xeaWkE\x89e\xbf\x0e\xf1\x00\x0cO\xc6\x07-\xbe\xd4\xc7yq\xfc\xba\xa2K.\xa1\x96\xd0R\xa3\xcc\x81\xd7\xda\xb9\xc8'\xc2\x1b}\xe7\xfa\xe0f\x1dna\x17\xee\xf5a\x90PQ\xca\x9c\xe9?7\xfc\xfd\xeb\xaa\xdc\xf0o'f\x0c\xf2\x8d+n$\xac7U\xc9\xea~]\xf4}\xb1\xf9tL\xd7\xa6\xd1\xa2\xb5'\xc6/\x0ba\x17\x8b\xd5\x05\xc3`\x10vNB}@\xac\x13\x904\x0b\xbc\x10+\x85\x84\x8a!\xcc\xfa>-\x94\xf4\x0d\xcf\x9b\xf4\xb6Cb\xfb\xc1\x9f\x00\x82\x17\xc2B\x9d\x16\xbdp\xd1d\x11\xbc\xa0)$x\xf9\x12\x0d\xa2\xa8\x95i\xa1\xa7\xa6\x90\xc4\xa1\xe9+\xb1\x84\x15\xbc\xa4\xa4\xb1\x90\x04NS]\xc2\xc9-x\xa1\xa4\xbc\xe0\x05O\x84\xc1K\xd2d\x89\x9f\xeatI\x12K\xd9/\xcd\xe2\xa6\xddx\x9e\x9b\xd7\x88\xb8\xe5\xaaK q\x07/G\xd6[\xd4\xf3 \xa4\x0f\x0e\xd0LN\xbb$\x1e\x1euI\x1c%\x981R\x90r\xa8\xd4\x85z\x18\x98\x96\xb4\xd9\xadK\xca\xc7\x84y\x1f\x14\xe6|\xd4\xe4C\xe8\xe4\xb5\xd8aT\x97p\xba\x14^\x12\xc7 \xb1\xef\xb4\x84+\xbcx\xd2\xb0\xf0r\xccn\x04\x93\xa6\xf0r\xcc\xe6\xf8\xf9\xb5\xf0B\xcd\x18# \x9bf\x95\xe1%\x9ek\x86\x97c\x0e[([\x0d/\xc7l\x0d\x9e\xef\x86\x97c\xb6#\x921\x87\x97c6(\x90s\x87\x97c6&\x9e\xb5\x87\x97p.\x1f^\x8e\xd7\x8f\xd4\x93GJ\xc2`T\x18\x96P\x88\x17\xecn9\xb7$X:)\x16\xce\xaf\xc4N\x8fFetI5\xach\xdeV]N\x06\xba\xb7\x9c\x0ctQ\xd2\xa6\xb5.)\x1f\x13\xe6}P\x98\xf3Q\xbf\x94\x81>D3H\x9fT\xf6\xde\xcd\x92\xc5\x0b\x9a;\x8b\x97\xe4\xc9\x98>\x15\xb5\x06Y_W\xc5\x0d\xf5\xa5\x99\x1f<\x9e\x8da\x97\xaf\xe0\xdb\x1f\xdf\xbd\xfa?\xeb\xf3\xd7\xeb\xef~|\xf9=!saZ\xa6\x12^~\xfb\xe1\xcd\xdbp\xb2\x85]\xa6\x02\x08\xd9\x1av\x99\nx{\x1eJ\xda\xb0\xcb\x90\xc2\xb1l\x18\xd2N!\xb2\xc8\x85\xb2\xfd\xae*n\xa0\xac\xb7\"\x84\xa2\xd8$\xe1\xdbj\xd3|:\x7f\x1d\xcd\xe6\xb0\xcb\xb0\xa4\xa0\xa4;B\x13#\xa9v\x995Gg\xa9$B\x88\xd9.\x8b\x9aFw\xe2\xc9B\n\xcd\xdaeQ\xfb\xc8C\x97j\xef\xca\xf2J\x98\x9f\x1f\xca\x1b\x99m\xc4\xf7y\xed\x8a\x16\xd1^\x0d\x91 \x8a+k(\x94\xcc\x98\xfb9\xb5\xbdR\xaa\x0d\xea\x18\"\x8e\x02-\xa2\xbd\xfb\x9f=w\xfd\x99E\x9a\xdd\xbdD\xc1\x14\x1a\x1d2\x1e\xde\xfd\xad\x1f\xd7P\xc7\x08\x89K\xd1\xfd\x86\xba\xcb`\x17\xb5\xe2\x85\xbe\x83\x12wObOd\xa1\xf6G\x96$=\x94\xbc\x90\x12\x17\x91\xe7\xceY\xbc$\x0d\n$\x0f\x0c`\x1c#\xb1\x92<@\x90>H\x80s\x98\xc4\xca\x97iZ\xea\xeeL%S!\x8a\x8bR\xae\xc4\n%\x85\xc5.\xc9\xe3\x9az\x86\xd9\xc7.\xc3\xc0\xcb\x11\xdb\xa5[\x14kH\xc2\nMY\x9b *+q\x10\x92\xa6{\x82\xb2J\x18\x08H\x1c\x0cHWS\x89\x83\x02\xa9\x03\x03s\x14\xd4\xf1\x1b\x95\xa6\x9a\xa8\x8aI\xd0x\xc6\x84\x81\xa6N\x9e\xa7\x96R\x95R\xe2X\xd2\x17>\xccUGGk\x11=\xf1px\x83\xde\x94x3\xb8\x15\xdb\xd4\xce\xe5\xffv!\xd4\x18\xaf\xe9\xea\xe1\xafE\xdd\x975[\xc7\xed\xd0\xb8\xfd\x19\xb1;I\xfa\x8a\xa6\xa5H\xca\x9a0B\xb2\x10\x97Cdf\x06\xb6\x06\xa2`\xff\x96\x10\x0c\x11\x10\xa5#\xcd\xb6\xf6\x19\xaa\xdf\x1e\xf7\xc8\xfb\xb7\xac$/;\xeeE7\xa4\xd9\xfet\x9c\x14\xf4\xfc\xb5\x1c&g\xb9\xba\x8b\xd4VT\xe8H\"\xe3\xe7\xd5\xcb \x9b\x9f\xf7\x8a\xd0\xc8\xbee\xe9\xdb\xa5|j^}\xea\xe8Q\xdfH\x7f7\xa84\xa7fSm\x85\x15UP5\x05\x95\x91O\xfd\x10\x14\xcer\x15\xe3\x8c\xc9+\xc3\x16\xa2L\xbe\x89\xfd\x13\x9c~\xe6\xa7\x9f\xd8<\xf8\xbc\xc1l\x1d\xd7\xceI\x98\xb1K'[\xc4\x9e\x99amyl\x98\xb0\xfd\x12\xb2]r\x9aoA[\x05\xb5S0\x1b\x05\xb3O\x96\xde\x1f\x10\xb4G\x02\x9d\xc5\xed\x10\xaa\x0dB\xb4?\x88\xb6G\xdc\xee \xa8\x80\xb1,W\x06c\x89\xda\x1a\x81!\x0e\xcc&\x8f}A\x10\x86\xdb\x15^\x9b\x82 q\xd2\xbcLv\x04nC\xe4\xb3\x1f\"\xb6\xc3\xd0p\xb2\x02\xf7,$t\x00\xa7\x8b'\xbel\xa2\x0b&\xbaTB\x8b\x84\xb8<\xf2,\x8c\xc0\x92\xa0\xda\\\xc8\x02\x08\xbe:\x9d\xf4\xc8t\xa7U\x9der;\x93\xed\xf5\xc0\x05K\x98g\x16\xffk\xc2\x8e\xe0\xacat\xfd\xfaM\xf7\x85<\xaf\x8b8^%\xab\xab\xd9v\x87\xdfu\x19\xb7k\x16^W\xf7\xbbb\x84\x06\xe4\x0f=e@M\xb0\xce\xc4\xa3\xc6\xbf\x03z\x1c\xdb\xc7\xa9<[Tf-:\x97\x16\x91=+\x89/\xcb\x9a\xd2\x7f\x9b:PS9\xb1B\xbcW\xa9LW\xa9\xdcV'\x1f)\x9c|\xa4\xd3r$\x1f\xa9\xc7\xc6\x8cN7\xcc\xbe\x8c\x18\xc1Q\x99\x93\xae\x05y\x93\xd2\xe7\xb2\xc7\xf6Mk\x95\x7f\xdf\x9c\xc3j4e/\xfa\x8dU\xbb\xa9w\x1c\xe6\xa2)\xe3\xe3i\xd7\x18\xcai\xd7\x18Jtr\x9fv\x0d\xa3\x9cv\x8d\xd3\xae\xf1\xcf\xbdk\x84r'\xd0.aS\xd3\xcb[G\x96\xb0\xec\\\x8f\x8f\xe6I\xdb,\xb6eyp\xf8\xe1}\xd0\xa7\x7f!\x88\xa8_\xb0c\x1fkS%\xd8\x19\x10k9D[\x0fa\x9b\x03\xa2\xe3\xadK\xcc\xf6\x80(\xf2<:\\\x10\x1f2\x82-\x02!{\x04\xfc6 \xc4\x9a\x18\x8e\x98D\xed\x13\xa0\xcaG\xba\x1ee\x06\x9e\xbff\x02\xd9#\xf3Z\x1b\xceO\x9cm\xc7\xf8F\x04e\xf2E\xf9{\xb1\xbb\x0fN\xbb\xe1i7<\xed\x86V9\xed\x86\xa7\xddP\xfdD\x99\xca\xa7\xdd\x10\xfeK\xee\x861t\x84\xb7\xbb\xbe\xa9\x1fd\xa9O\x96\x96\xcfq\xe4\xff\x02\xb9<\x01\xe0\xf3\x06\x00\x99K\x1e\xd5k\xb8.\x8b\xb0\xc5\xcf\xb0h\"|\xf0Kv\x8b\xe3\xaa\xf2(\xa7{*\x93{\xb4M@j\x17\xd0\xb8\xdaI[\x00\x18\x93;J\x83\x1eec\xcf]%\x05\x8c$\x0b\x9de\x1dF\x06\xf5PWgq\xab\xa70\xaa\x8fl\xe9\x01\x81\xa9<\xea\xa9\xec\xe9q\xcet\xc2'\x8d\xf1.\x12D\xd0L\x9e0\x03zR51\xa2$\"\xc7y\xc6\x15\x1d\xe7\xd5#u\x10(v\x9d,$\x93X\x17RO\x81\xdc[\x88\x9b\xca\xc3c$\x93Y\x17\xca<\xd2%>\xe4\x902\xec@\x1fz\xa2i=y8LQHg\x0e'\xf5\x88\xd4\x93tnp\x02#x\xae\xe6\x91\xc9\xabsU8\x1d\x8f(]w\x90\x8a;\x8d\x80;W\x1f\xa8\x14\xdb\xb9\xea\x8b\x93h\xe7\xaa)\x81&;W\x95D\"\xec\\\xd5A\x12\xd5\xf5\x9eLp\x9d\xa7}\x961\x97\xc2O\x1d\xe5\x9f\x0e\xb1NG\xf7\xad\xf8~\xf5\xc5\xec\x9b\x08s4m#\x0c\xf9\x1ft9\x196c!\xf5\x14\xc8\xbd\x85\x93a\x93\xdb\xb0\xa10.\xcb\xbe\x84Y\"\xa3\xfc\x90\xc4\xa9@\x9d\x08Q\xec\xbdY\x12>\x06\x8d+9\x0e\xf2\xa1\xbdG\xe4E\x8e\x02\x82h\xaf\xc59\x90\x89\xe0!\xbcP\x19u\xf2\xb1\x1cG\xe9\x01\xccB\xf0j\xdb%a\xd6$,`\"g\xf1\x8c\xcac\xc7nY\xc8\xac\xc43Z\x10\xe9>\xdd\xe3Dg\x1b\x16\x80,\x82$\xdcICk\xd1|\xa4\xa2G \x81E8\xc2\x1d\x1c\xd4\xa6a\x1d\x1ace\x8bi\xfb\xa0\xa6'hy\x8a\x86'\xacP\xe2\xf4$MM\x02\x0b\x1b\xa1c@\xec\x1c\xd0\xf9\xd7\x88\x9d\x04jG!\x85y-\x7f\xe5\xb4\x1d\"/\xe3Z\x1a\xdf\x1a\x85r\x0c\xe8cC\xb3+\xf7)\xcf\xa3K\x98\xd4\x11\xc2\xc4\x8a.\xdehg\x80\xd4!\xa0.[R\xc7\x80\xd69\xa0/\xd8\xbc\xd5R\x96j\xce\x85\x9a\xb2Li\x8b\x944\x1e\xb1e\x02i\xcb3K\x9d\xb1\xf0\xfe\xf0\\\xac2_E\x01.X\xafL\x9f\xac8\xdb\xab\xcf\x9e\xc8\xc9\xc4v$\xf2\xaf\x80j\x89(\x95\x98:\x89(\x92\xe8\xa7%\xac\xe2\xa8\xdaX^IXI$\xab\x87\xd8\xb5y\x01\xc5\x10[-\xc4Y\x80/I\x92\x02\x98YCl\xb1'/\xc8/\x91}3\x93\xa3\x14\xc73Q\x99I\xbd\xf8\x9c\x1f\xcb\x8e\xce\xcd\xe5\xcb\xdf!\xf1n8\xcb\xdd\xb7\xcc\xa3H\xa0\xa0\xd4\x90d\xf0`\x83dY\xa8\x95\xc4\xeb\xe8/\xd1\xf9\x0dQ\xdfYJ\xc6\xb4\xef\x0d\x7f\xdet\xe0\x8d\x88\xb7,!\x87Z\x96\xe4Lj\xfd\x1a\xc5\xd7\x90\x9eU\xed\x15\x14\xc9\xb6\x96eN\xce\xb5\xff\xcdX\xe6\xb5,_\x80\x84>\x18\xed\x915\x84c\x03\xf1HO,\xceC8v\xc4\xd6#\x10\xc2\x0d\x84\xe1\x82\xf8N.KBl\x87\xd0; \xf6\x10\x80\x18\xd5\xa1|7]\xe2SD\x97\xd8\x00\x03}\x90\x81:\xd0I\x91\x1cB\x1c'\xeaV&t\x80\xe6F&{\xd1\x13j\xf4\x0eU4[\\\x16\xca\xbc\x88\xaf\xe7\xa8c|y\x8f([@\xae\xbcrY\xc2\xd9\xe5\xb2\xa09\xe6\xeau\x04w%\xcb\xc9\xd28Y\x1aC9Y\x1aG\xd5L'K\xe3di \x854\xd0'K\x03(Cu\xb24\xfe\xc1\x96F\xcc\x0f\xa6\x9e\n\x0fLx)\x06Qn\xb2,\x92\x7f\xcc\xab\"b\xdfs\x11\x1e\xce\xed\xc9\xe7\xc6\x8f\x8a\x93\x85\x86\x8dS\xe2\xe6\xb9\xb9\"h9Y\x16\xda\xa1\x11\xfc\x9c,\x84\x1d(V\x0fD\x10u\xb2\x10*\x02be@\xc1\xd8\xc9\x92\x8a\xb4So\xd1\xda\n \xed\x05\x1a\xf6N\x16\x82\x8e4\x8b^`Q\x1c\x9e,Q4\x9e,\xc7lDl\xc9O\x0b\x1d\xa5\x17\x155\xa2\xf8fb\xf5dIE\xecE\x05\xca\x1e\xa4\xe2\xf6dIE\xef\xc9\x12\xc7\xf0\xc9B\x9e\x08\xb1|wY\xc8\xe2b{\x92Y\xc2\x08?\xf5Lz\xc5\xb4\xb4C\"\xe6O\x96#\xe9\x16\x8a\xfd\x0di\x83\x00qS\xcc. \x07\x1f]\x12F\x03\x12G\x04\xa8\x07\"](\x06\xf0\xb4\xd0g\xa8.\xd4\x0f\x05\xe9\x1f\x0bR?X\xd2\x01j\xf2J8\xf5^\x16:\xb2P\x96\x84\xfe&\xf43\x1dk(\x0b\x01q(\xcb1\x9aM\xc6\xef\xc9r\x8c&\xe4E%\xca\x92\x86M\x94\xe5\x18}\xa3\xa2\x15e9F\x0b\xe2\xf8EY\x8eQw\x02\xa2Q\x96c4\x82\x88q\x94\xe5\x18\x0dHC=\xcaB\xc7>\xca\x92\xbf\xdd)\xa6s:X2(\xce\x0f\xa4\x94%\x04\xa7\x94\x85\xb8\xddS\xb7\xf9\x7f\xa0\xc1\x19\x81\\\xca\x92bQ\xc4]k\xba\x9c,\xcd\x93\xa5\x19{\x1a\x12>\x14\xa4\x7f,H\xfd`\xc7\xb64)POYdO\xc3\x80OY\xa2\xb0OY\x92&V\xda\xb4J\x02\x82\xca\x92\xfc!i\xa0PY\xe6BCe\x99 \x10\x95e<\x96t\xb0\xa8,\x8b \xa3\xb2P\xb0\x06f\xc9\x05\x1f\x95% D*\x0b94e\x97\xe4y\x97\xac>\x88\xe0RYf7\x87\xe6\xf1\x91%\x1a\xeb\xb2\xcb\xec6\x91\x86(\xc5.\x94%\x1f\x0c\xd5\x94\x17\xf29\xa6\xb41 \x98\x1a\x94\x84^\xaf\x19\x80\xa7\xca\x12\x01\xa9\xcaB\xd0\xfd\x14\x8d\x1f\x83\xad\xcaB\xdb\xb9\x08\xbb\x16\xa1\xd5\xb2P\xda.\x0bYW$-\x82\x84\x05\x10E\xca\xe9B\xee<$\x0d\x00\xc4\x81/vI\x1a\x08H\x1b\x0c\xa0@d\xecr\xdc\xe6\xa4\xec\x82)\xd0\x1a\x82\xb8 \xf8&\x8e\xc0\xd3%\x16\xaf\xb7K\xd2\xf8\xa5\xd8\xf2$\x80\x8e]\x8e\xd0\x960\xa4V\x16\xe2\xca\xa2\xae)\xa2JI\xe8,y\xca\x12\x95 \xb1\xc3\x90\xd0iHS# \x9d\x87\x94\x01\x80T\x05r\xbc\x86\xd0UGV\xc51Sm\xa4(\x8d\x841\xa3-R\x98\xa3.\xb2\xb7\x82\x96\xed4\\u\x00\xf4+K\xa4\x96\xb0\xf48\x0cX\x96\xb0}\x16\xb0\xcb\xa2z$\xae=\xa2\xca\x924\xce\x84e\x19U\x8d\xd1\xce\x00\xa9C@U\x84\xa4\x8e\x01\xads@W{y\xab\xa5(\xb9\x14\xf5vb$\x18J\xb8N\x9a\xb2Z\xa4>\xfe\x91\xa9\x933\xc1\xcc\x8e\x1c#\x01v6\xa4\xf9\x07\xc3U\xef( W!8 ~\xb1T>T\xf1\xe0\x8a\xc6{?\x01\xf2!\xf4'p\xf2\xda\x9c4\xbaT\x11\xfe\x8fGOw\xf3\xa7\xb3M\xbb\xeb&\xb6\xa5\xa6\xb0Y)j\xf6@\xe0\xc9j\xb1\xb447\x01\x0d\x19\xc2\xe9\xa6\x8e\x8e2\xb6\x02\xed\x94\xb0\xe0k\xd3\xe5\xe5I\xe8J\x98an\xec%:;&\x1bD0\xc4\xe5\xddd\xfd\x1b\xab'@%%\x11\xee\xa4q4\x1b\x1e^\n*4\xef^\x18\x0c\x0e\xa1a \x7fjQ\xf0K[5\xc7\x13\x83\x90\x14 \xaaxo\x92\x0bU\xc0\xb2\xf4\x9bp\xa2\x0d\xb5\x0d\xbe4\x19\xea\xfbn\x92\x0b\xf5\xcd@\x8a\nU\x84'\xc1\x84\xfaz8=\xc4\x9f\x08B\x93\x9f\x8f\xd4\xda\xd9h\xc5\xa6\xff\xed\xb8\xc5\x116[\x0fT E\xe1\xe5\xd1R\xde\xb4\xfe\xd8\xee?<\x17:~\x84\x8f\x1d\x81\xf4\xfc\xa8\xa5\xe9\xb5\x12t\xf1&\xdd/\x15\x1d3\x01\x17Z\x13\x88\xe0\xd5\xc6\x95\x9cYbv\xe5\xb1\x02WQ/\xb5\xd7;\x1d\x0eEGg\x8e\xd3\x1aZ\xc8\xd9\x13jN\xad.\x18\x9eM\x15\xb6;n\xe79F\xff\xd4\xdd\\\xf2A\x11\xef9\xc3c.\xa7\xaf\xe0\xc3\xf9\xf7o\xdf\xbc^\xff\xf4\xe1\xfb\xf5\xe5\x9f.\xdeL\xe6\xa4\xfb\xfb\xc5\xfb7\x7fxw\xf9&\xf4\xbb\xb5\\\xb0'\xde]\xbc\xfb\xf0R\xae\x93ae\x84\xdaa\x0d\xee\xdf\xf4\xe0Z}\x95\x1f\x8d\xf7\x95\x7f4\x89(\x80\x1d\xeb\xba\xe2\x86\xe9\\o\xe3rn=\xa2\xde\xfe=\x17\x1f\xbd\x0b='{\xf1\x1c.\x84mRT\x1d\xf6A\x06\xaf\x9b\xf91\x82N\x8d\x99TR\x88\x0f5\xc1\x14A=\xa6Q[d\xb2\xa4<\xfe\xd141\x9874\x93\x1f\xd4\xf1\x80.t*\x06<\x9d$\x19\xfe\xc9\xf2AG\xdf \xf3\xe5\xe4\xed?y\xfb\xffy\xbc\xfdnT:A\x8be8\x1cz&\xa7wj\xfa'\xa6wZ\x06\xe7N`\xe6\x04&\xe4<\x91\xbe\xa9\x98q\"\xa2\xd30\x03\x96Q\x97\xc8\xf4K\x92\xb78\xd0\xe4\xea\xf3\xa6\xa7c)\xfb\xc1b\xf3V8=\x08\xc5\xac7\xfc\x19\xdb\x82\xf3>\xe3\x1cz\"\x96\x1cP\xad9\xf0Zt\x90\xc9\xaa\xf3\xf6 \xb1\xec|\xcfb\xd6\x1d,a\"\x9e8j\xe4{\x81\xb0\xdb\xe0\xa0q\x9d3 *q\xb9s\xeeDA<\xf9\xd1v\xae,\x8b,\x07O\xe6A9F\xd3G\x11e\xbde\xf7s\xe6\x18r\xc0\xa6\xd5\x8e/dq`n\xd9\xbee\x1d\xab{q\x9cn\xd9]\xd3\xb33\xfe?\xf2\x8c{\x06M\xab\x8e\xbb|G`\xd2Cop\xcc\x8f~\x0cc\x89[ZV\x05qWC\x90\x92\xaclQ\xb0\xba\xa7\xafV\xcc\xd4\n\xbdR_\xc3\x9d\x03KC\xabF\xcc\x13 \xa9\xe6\x08\xa5\xa2!\xd4P\xe8t\xd3t\xbb\xa6[]\x15\x1d[\xdd}}\xc5\xfa\xe2\xeb\xd5k\xb6y\xd5\x945\xf9\xd3lY\xdd\xec\x82c\\\xec\x9aC\x1dR\xc1\xf8\xa4T\x0d\x19\x8c\x9a\x02\xfa\xe6\x13\xab\xa5\x05S\xc8z\xcbZ\xf4V\x0c\n\xff\xd3\xa6\xdc\x15\x95\xaap\xd8_\xde\x8a]\xe4\xf2\x96\xa9\x1f\xe0\xbad\xd5V\xecU5\xafE9\xe8\xca\xdd\xbeb;1\xff\xc5w=t}\xb3\x83\x1d\xebo\x9b\xedt\xd9u\xd0\xb2_\x0ee+\xfd>7\xcdM\xb3o\x9b\xbe1\xc6t[\xf2\x0e^\x1dx\xf3\x8c\xb1\xad\xd8\x8dh\xb1\xfa\xbf\xa6}\xcf>\x17\xed\x96<\xdai\xea\xa75\x84\x8f\x8f\xe4=gN\xbe\xbf)\x03\xd1\xe6\xd3\xb9\x10|\xdcoud\x9c\x1d\xb2\xe4\x9b#\xb2Pf\x8a\x7f\xe2{f\x89\xa9\xa2ehT\x7f\x12\xf5\xa6\x08\x80m\xf5K\x8f;\xfd\xff|\x10\xe4\\\x88\xcd\xd0\x8b\xa2-vt\xbd\xcc\xf7\x83C]\xf6\x0f\xeb\xbep62\xeb{r\x1d\xb3\x1e\xcc\x7f|b\xda/4\xf5\xa1Kz\x83\x7f\xfam[|\x16Kc\xcdj~\xeeq\xde\xb8j\x9a\x8a\x15c\x9e\xcb\xb0C\x1a\x7f\xb7>\x8b\x1c\x11;\xe2(\x13\xc3\xf6\xf2\x17\xae\xf0\xf9_\xcd\xf1\x84]\xb3=T,6\xda\xff\xcf\x81\xb5\x0f\xaf\xf4\x18^4M\xf5\x9eu{\xbe\xa1\x90\xbf\xc0\xbei\x9c\xe4\xb0\xd3\x02\xff\xb5,p\xa7\x93\xfcs\x0d]\x1aV\x8f\xf8\xf3c\xfe\x87\xb2\xee\x10\xd50\xd8 \xfe \xc3{\"\xcc\x02\xfdo>\xe4zn\x9ao?\xb3^\xd7\x83\xf4\xfe\xe2\x95\xea%i\xce\x8e*Jj\xa6.y\xde\xca\xf5|d\x1f\xe8i\xeaf\x9c\xba\xea\x8bY\x9aP\xff\xad\xd8l\xda\x83\x0e\x82\x8d\x9bNh\x97\x0b\xcf#\xfatvD\xcc\x9f\xcb\x97\xfc\xa8\xfb\xab\x9e\xd0\xd1\xb8\xb0wrO\xf7O\xf3q\x0c\xd6\xe7\x01\xf5y\xda+K8\x83\x03]\x8c\xb2x[-\x0b\xbe0 \xaf\xc6\xd1\x9a\xb3\x97\xaa\xb7\x99\xab\xdf`\xfcPK\xd60\"N\xadj\xe4\x17\xfa\xe2\x8e\xe9\xb0\xb9F\xa8,4S\x14i\xc7T\xcd\xf0\xe3pL\xd54Cz\x17\x9a,\x9fw\x0d\x9e6\x95\x8c\x9b\x8a\xf8^\xb6q}\xd8\x89\xc9c\x7f\xf6\x84\x9d\x04\xd3\xe2s\xb6\x13S\xce\xcc=\xa5i\xc7\x80J\xf2\x86\xb20P<\x99\\\xd6\xd0\x19^;s\xe8\xcd\x0b#\xc7\xa5\xc5\xc7N/\xde\xfa\x86\x0f\x1a\xf5c`\xddO\xfe\x12\xa6\x90\xd9\x9f\xe1\x8f\xeah\xf8R\xee\x9a\xc9\xdf\xc2:Z\xc6\xbc.\x93\xa1\x99\xbek\x0d\xf98\xca\xfa\xd7\xbe\x81_x\xdb\xd3\x06\xda\xd3\xc1\x19\xa3=\x91\x94:\xe4\xf2\xb8\x9c<\xc0{\xc3\xef\xe0\xf4y\xef\x1e\xc1\xc5\x9fX\xcfZ\xed\x025N\xdc\xe6\x87!\x05]<^\x0c\xf0+\xea\xb07#\xf4b\xd8\xab\x11x3\xe2\xdd\x18\xdf\x9cz8\x80\xe2\xe5@\xbe]p\xee\xa8Y\xa3\x9c#\x89sdX\xd0\"\xd7\xae\xeb\x84\xed\x9e8a6\xc3\xab\x9eI3>`M\x1c\xf9g\xfeWK\xe3A\xcb6\xac\xbcc\xdb\xd9\x13h\xda\x18\x08\x98\xd79\xb3u\xbdfu\xd02\xf6\x9b\xd4\x81\xd7b\xe6\xf4l\x13\xc5\xd3<\xcc\x94^b\xb78\xc2|f4\xcd\x98Q\xf1E[#\x07\xe66]\x19#B\x8c5\x96\xb4\xc4\xde\x1d\xfa\xae/\xeamY\xdfd>\xd9\x92V\x86\xf3.\x9c\x96\xc5?\xf9\xb2\x80\xe0\x90\x04&\xa6y\xb2l\xc6_\xe1\xc9\xa1\xfeJ\xef~\xf5Swr\x99\x0d\xe5\xab\xa90\xd4zY\xb3\xfb=\xab\xbb\xf2\x8eq\xcb\xaao\x8b\xcd\xa73~\xb8h>w\xd0\x89\xe1\x80\xae\x10>\xd8\xcd-\xdb|\x8a\x1f4\x08+k\xc6BGFc\xee\xa6\xfa\xa1\x12\xa8\xba\xe4e\xde\xc9\xf7\xa6\xcb\x9ct\xd8 \x1f\x9eG\x07\xd6\x9e\xb5e\xe3qH\xa1\xcb\x0c\x8d\xef\xab\x9f\xdab\xd3;\xbb\xef\xacc\xb6=\x8co\xeeX\xdd\xdb\x99\x11\xe3\xdc\x12\x03\x06\xecN\xc1\xfd\xc7\xf2\x83\xc89\xe2\xb3\x80O\xb0rS\xf6b\xad\xab\x04\xa8\xaeoZ\x91\x9eg\xbfty\xcb\x9f\xef\xa0fl\xcb\xb6|\xb2n\x8ajs\xa8\x8a^\xe0\"\xdbf\xdf\x96\xe2\xff\xe5\xfan\xae\xa1\xeb\x8bO\x92\x84\xe0\x13\xabm\xef\x0b\x9fk\xa3\xc3ECP\x8a\x96\x0dfd\x0d\xc5u\xcf\xf8b\x91\xdd\xb8-:h6\x9bC\xdb2\x9fgFM\x10\xfb\xb4\xae\xfe\x166\xa6\xf6\xc5\x8dRp^\x0b_?0\xb1\xf2\x87?\xab\xc1\xd3Kj\x96\x99&P\xa3\x9e\\Qd\xca\xc5\xb2\x8e\xfe6U\xf5Z\xbe^\xff\xfc\x7f\xfb\x06\xaexG\xbaN~\xd4\x8b\xe2\x86\xbdg\xbf\x1cX\xd7\xaf\xe4\xef\x13!\xf2\xf0\xc7_\xe7\xe2\xf8\x10\xf0\xb3M\xd7\x03\xbb\xbe.7%\xab\xfb\xca\xdc5\x91\xf4\xach\x87\x90\x15\xe4\xcb-\x95\xfe\x19\xde\x1f\xf1?\xf5aw\xc5Z>\xf9\x140\xd5\xc80-\xa7\x04\xfafW7|\xd2\xae\x85\x90\xe9\xbe\xf2\xb9\xe8\xa0c\xfd\x19\x94}\xc7\xe7\xd0A\xe8\xcfC-'\xc2\x16\x9a\xfe\x96\xb5\x9f\xcb.\x94\xc0\x14\xd4\x803\xd4\xb1\x92\x90\xa0\x83\x87W_n6\x87\x9dX\xb6\xdbW\x93c\x01A c'\x89c\xe8\xe1\x93\x13s\xbe\x13\x13\xef`x\x02X{\xc8\xf8\x80\xf1\xbd\x95\x98\xa9\x01\xf3\x89\xed{(\xf8H\xb5\x87\xba\xe6\xea^,%\xd6\x9e\xc1\xa6\xa8\xb9n14z\x0fE\xfd R\x1c\xc9\xd3\xd55<\xc8s\xf5\x8bD\xbcN\x13\xf5h\x13u\xae\x05>\xd8\xddR^\x16\x93\x9b4WG\x93\x8c\xa5\xbc\xac*M\xbb\x95|@a\xd6uWp$\x85\xc3\x1f_\x1fZ'\xe5}\x81\x03\xe0%\xfc\xfc\xfe\xc7g-\xeb\x9aC\xbbaP\x17;\x85$>\xd4\xe5/\x07V=\x00\xefX_^\x97\xca\xee\xed\x15\x82\xc2eI\x02\xe8X[\x16U\xf9W\x86\x1c\xd0\xc5\xda\xdf4\x15\\\x1d\xae\xafY\xab\xa1\x17+99d\xdbaw\xe8\x06x3\xdf2*Vt\xbd+\xab\xa9\x19T\xd5\x03\xfcr(*>\x02[9>J\xb4\x18\x89'E\x07e\xed\xbe\xfc\x91W\xf9\xec\xa6in*\xb6\x12}\xbf:\\\xaf^\x1fZ1w?>\x95-\x16\xe2\xba\xdb\xe6Pm\xf9v\xc9;\xedH\xda\x14uS\x97\x9b\xa2\x12\x1a\xc0\xad\xe9 [\xdd\xac\xce\xf8P }\xf8h\xf5H,\xb5\xa6\xe7\x9b9\xdb\xf7l\xfb\x14\xf3\xca\x9c\xd7\xb0\x17\xcac\xc3\xce\xa0g\xc5\xae\x83Cw(xwe^\xfd\xbe\xe4\x86s\xcd\xd5\xe4-\x83\xab\xb2.\xda\x07\x19\xfa|\xd83\x97\x91SL\x9a\xfe\x96=\xb8Uq\x9d\xbb\xe9\xa1\xec\xf9\xca?t&\xdc\xa6\xe7\xe7\x88\xe6\x1a^\xd6\x0f+\xf8\xa1\xf9\xcc\xee\xb8\xf5\xc0\x17\xfa\xcf\xef\x7fT+\xdc\x91\xc7E\xf0\xe9\xe7\xce\xbf\xcd-\xdb1\xf8x\xdb\xf7\xfb\x8fg\xf2\xbf\xddG\x81\x0e\xa8\x1b\xf5\xeb\x99\x98=\xdc>i\xc4\xaa\x10=\xeeX\x0f\x87\xbd#O\xe2\x85\x90zX{\xc7Z\xd9\xe5]\xb1\xef\xe4T\x10-\xee\x9b\x01T$\xf6\xe7R\xaa\xaa\xa2\x83\xebFl3\xcf\x91o\xf1[8\xbf\x1e[\xc8?\xdf\xbem\xb8F\xd9\x0e\x9d\x10\xfbq\xd7\x1dv\\\x91!\x02^\xd6\xf0\xc3\xe5\xe5\x05|\xff\xe6\x12T\x00\xe1\xe7\xf7?\xca\x05\xf5 6\xf4\x02\xfe<\x9d\x8e\x97\x0f{\xf6\x97?\xff\xc5\x11\x07\xfa\xacS\xeb\xef.7\x1f1\x92\xfb\xb6\xd9\x1e6\x8c[\x07\xacm\x1b\xe7b\x11\xd1\x9a1\xdb\xbf\x13\nZl\xb1Z\xf5o\xf8Zm\x9aO\x87\xfdpT\xbb*\xf8\x19\xb4\xa9Q\xb5\x02\xbc+\xa2\xee\xdb\xe2N|\xfa\x9d1G\xb7r\x92\x16\xba\xa9\xfc\xff\xef\x9ar\xcb\xedMD\x94\xacX,\xbf\x96]7-;\xd3/ryE_^\x95\x15\xdf\xff\xf9^\xd5\xe9#2W\x11\xed\x1d\xdb\"\xf2\x9a\x9a\xab\xa1\xfa\x86\x89\x87\xc5\xdaX\xc1\x93\x9f;\xa6y\x01y\xaf\xf9\xf4\xe0k]\xce\x8f\xa2.n\xb0^^\xb5L\xeezJ\xe0\xea)\xe2Lmz\xf6\x1cz\xae3\xaf\x0f\xf5F\xce`\xde^\xb5\xe6\xc5^\xc7\xcf\xe1\xe6\xe9\x17\x1f\xd6F\x1c\xda\xddC\xaf\xd2\xd5W\x07~\x92\xe6\x1a\x98\x9d ;\xb2\xecu%\x07\xfe\xb1\xc4!u\x98\xf7W\xec\xa6\x14g\x00G\x98\xe0\xfau\xd5\xc5\xc3\x9e\xad\xe4|,\xf6e\xb7\xda4;LK}\x10+\xa2\x93\x07m\xbe\xe0\xea\xe9\xea\x86'*\xea\xc7v\xfb\xfeA-\xa1\xa7\xb0\xe3\x06\x8a#\xee\nY\xcc\xa23\xc2v\x1eL\\i;w{\xb6)\xaf\xcb\x0dtlW\xd4}\xb9\xe9\xec\xa9.\xd6H\xc2V\x1c\xc0\xe3\xc6v\xe9\x9f\xf82\xbeb\xda,36Zg_U\x9bSq\xd5\xdc!\x1b\xb4\xec\x92\x9a\x92\xde|\xabI\x0b>\xbe\xac\x1f>\x8e\xac#E\x0dE{U\xf6-_4\x81\x96h=XT\xcdd,\xe4I\xc5\xfe\x14\\[ \x85*[r\xe5\x9a\x1bf]\xdaz\x98L\x99\x0b=q\xab\xf2J4O\xe9\xd1\x0e\xba\xc3~\xdf\xb4b\x07\xda\x17\x9bO\xcf\x0e5\xff\x0f\xdfw\xe4w\xec\xb0U\xe2n\xb8\xcd5\x1cz\xa9 \xf4\xf2\xeb@fH\x94r-\xc2\x0d\xabY+\x0e\xd0\xf2p4d\x01\xbc\x9c\xe8#\xf9 l\xf9o\xee\x0bq\x08\xf9\xfa9\\\xf0\xf6\xf1u\xa7\x9aZ\x98h\xd5W\xff\xfa\xaf\xc86\xf0]\xd3\xc0u\xd3\xc0\x0bX\xadV\xff\xcb\xf9\x99w\xb6\xa8\x1f\xdc\x1f\x8a\xfaa\xc5\xab\xfb\xaemvO\xae\x9b\xe6\xa9\xfb\xc8j\xe5\xea\xf9\xf2\x1a\x9e\xf0W\x7f\x16\x0d\xbcl\x9e\xfc\x0b\x7f\xf7)\xfc'\xa2\xdb\xb0\xf7\xff\x8e\xf7\xfd\x9bH\xdf\x7f_\xdc\x15\xb3;\x0f/\x84\xad\xc1\xa5\xce\xe8i\xd9=\xf9\xaeiV\x9b\xaa\xe8:OGe\x13\xf8\xc3\xb2\xed\xc6\x0bn]\x93\x11\x18\x86\xe0\xdf\"Cp\xf1\xd0\xdf652\x08\xb2\xf6\xef\x9a\xe6\xc9j\xb5z\x8a}h9\x00O\xd0\xdf\xc4$\x10\xc3B\x1d\x15\xfe\xd2\xb9\x1c\x94\xd7o>\xbcz\x7f~q\xf9\xee\xfd\xd3\xa9R\x04%^N\x14\xbc\x02Y\x05>\x1c\xff32\x1c\xdf7\xeeH\x88\xa1x\xfe\x02\xfee\x7f\xb5\xfa\xaei\xfes\xb5Z\xfd\xdd}\xa8\xa8\x1f\xce\xb8\x19\xc3\x9f\xdc\xcb\xcd\xfb\xa7\xa2\xedn\x8b\x8a\x0f\x12\xdePl(\xa6\xb5!U\x95\xd7\x93\x8a~\xaewcU\xa2!bB\x8a\xa7\xfe\xc7\x0b\xa8\xcb\n\x9d`x\xfd\x93\x99t)\"\x14\x9bO\x83\x0e\xd2\x06%\\=\x8c\xdb\xbb\xd6\x92\x9f\xcb\xaa\xe2?(\xcc=\xdf\x12mq\x8f\x91\xed\xfa\x19?\x1b v\x82\x157m\x1es\x1bw\xd0\xd8\\\x9bk4\xa8\xfcb\xb6\xc0A5\xd6\xd5\x83\xb6\xe7\x9d\xc3\xd6`6\xa9S}\xaf\xcfx\x8f\x9f=\xb6\xc5\xa9\x03\x85\xaeZ\x9e \x98\x9a=\x8f\xae\x9bfuU\xb4\xa2\xd1\xf7\xcf\x1eV\x7f}${,\xedb\xd7\xc4\x17U>\xe2\xcfq\xf5l\xfd\xf4\xfb\x0f\xef\xde\xda\x7fy\xf1\xe2\xc5\x0bw\xec\xf9s\xe3\xd9R\xda\x13\x0d_.j3\x95\xf6\xf5\xa1\x1b\xb0\n7\x87\xaahm9\xee\xeb\xbd\xc8\xca\x1b\xb7\xc13`\xbb+\xb6\xdd\x8e\x1b\xe2\x99\xda[''Rc{\x92\xde\xbd\x8f\xff\xce\xbb\xfdQ\xb9P,B1=\x88+\xbd\xfc\x9e#\x06b\xb1\xf9\xc4\xd7\xdex\xa0\xb8.+\xe6\xea7\xbdF/X\xdb55:\x9d\xd5\xc9\xff\xbal\xbb~-F\xfe\x05|\xedJ\x1a\x1e\x14\xd4\xa3\xea\xb9o\xe2\x1a\x15\x00\xad\xf5\x91\xe8\xff\xa3\xe7\xf0\x08\x9b\xd9v\xb7V\xb2\xf5\x8f\xce09\xa2\xddo\x8b\x1d\x97\xf5\xbfe\x13\x7f\x87>\xc8\xdb=y.\xd6\xf8\xf3ke\xd8\xda\xdfX~\xa1\xb2\x83\xcf\xac\xaa\xbe\xfaT7\x9f\xa5\x9f\xf7V\xb8\xe2\x95c\xd6\x9d\xa8\xf6t:\x93\xc6\xd6d\x8eIE`T\xc9'\x8e@\x8a\x8bic\x0b\xfc(&\xb1\x9eC\xb7M\xb5\xb5\\\xc3b \x94\xf50\xf7@y\x12\xd4\xd4\xb3e \xf1\xc3\x8c\x83'|\xfd\xea\xee:\xc7V\xedE\xf9\xcb\x9f\xff\xf2\x14\x99\x9cK\xbe\xb7]\x01\xfe\xc9E\xb7\xb9\xa8\xafW\xdf|\xfdM\xf7\x08\xf9\x8c\xfa\xff,\xabz`\xeakY\x7fhk \x1f\xd0\x7f\xecN\xf1\xe8S<\xfa\x98\xf1h\x1b\xa7\x89\xf8\xba)9\xb5\xc6kJ\xda\xfb\x8bW\xba\x91N0\x1aw\xb3g\xf7\xb1\x93\xe6s\x8f\xba\xce\xbd\x9f?| \xcf\xe84\xf7\xbb\xcc\xf39\xcc\xb3\xb9\xcb\xbd\xce\xf2\x05\xae\xf2\\\x8e\xf2\xb0\x9b|\x96\x93<\xaf\x8b\xdc\xeb \xcf\xeb\x1e\xf78\xc7\x17\xba\xc6\x9d\xe1v\xad\xe6\xdcn\xf1\x85N\xf1\xcc.\xf1\x05\x0e\xf1\xdc\xee\xf0l\xce\xf0\xbc\xae\xf0l\x8e\xf0\xb8\x1b<\x9b\x13\xdc\xe7\x02_\xe2\x00G\x1d\xde\x88\xd5\xe9\xea\x9be\xcen\xc4\xb9=\xd3\xb5\x8d8\xb6\xa3v\x92c\xf8\x85w\xd0\x99\x0e\xed\xd1\x81\x8d\x8d\xefo\xe2ugve\xbb\x8e\xec\x0cn\xec\xacN\xec\xe9f\xb8\xd0\x81\x8d8\xad\x97\xb8\xac\x83>[\x8f\xbb:\xea\xacv\xfdctG\xb5\xfb\xee\xdf\xb1\xbe\xcerQS:\x1bsO\xfb\xfb\x16uM'8\xa6m?\xc4B\xa7t\xd0%\xedwH\x87\xdc\xd1\xe8(P]\xd11G\xf4\xd4\x0d\xbd\xc0 MpA\xa7;\xa0\x11\xf7o\xcc\xf9\x9c\xc9\xf5\x8c\xd4l\xcd\x94\xacN\xe7\xcc.\xe7\xac\x0e\xe7\x9c\xeef\xaf\xb3y\xea\xc1\x9b:\x9a\xf3\xb8\x99\xb39\x99\xf3\xba\x98i\x0e\xe6\xa8{\x99\xe8\\\xa6\xb8\x96\x1d\xc7\xb2[\x1b\xd5\xc9\x18v*\x13]\xca\x04\x87\xb2\xd5\xe4\x9c\xce\xe4\xcc\xae\xe4|\x8e\xe4|n\xe4\xf9_7\xeaB\x8e9\x90\xa5\xfa\x0e8\xef\xe6x\xee\x86\x0be\xdf_\xbcR\xb2\x1c\x7f\xddMsg\xd0\x81\xee\x9b\xae\xa4'3\xef\x15\xb75B.M\xc9c\xde\xca\xea\x9a0O:\xce\xd6\x9a7\xc7\xf6\x1f\x94\xd4\x9f\x96\xd1_\xcfH\xe5?\xaf\xfb/\x99\xca\xaf&\xd0\xd8'\xddf\xfd\xad\x15OR\x0d\xc5Fx\xbcM\x96\x11\xf1\xd7\xbe\x1c2\x98\xf4\xec\nO\xd6D\x82\xd0]Y\xaf\xb7\xe64\x87\xd3\x94\xfa\x95L)\xa7k?\x95u\xb9;\xec\xf4\xdcQ\xc0\x0e=-\xf8\x94a5\xb7\xd8\xe4\x95\x0b \x01\x15Z\xd6\xae\xb8\xd7\x1f\x9a\x06\xb5\xf0\xfb\x0f~*\xeeE;\xa4\x18\xd1\x8c\x97\xbc\xa7|\xd3b\xad\x98\xbb\xba\x89|`\xc7\x89\x0b\xe7u\xd9\x97\x16n^\xbaY\xc0\xbc<\x11vM\xdd\xdfb@ok\x8a\xbbt3\x9d\x02G\x88\x87\xb8\x95\x0b7\xcd\x1dk\xeb\x82\xab|\xdd\x88\xce\xb3|\xf4\xbd\x04\xe4\x95\xb3P\xd9\x0b\xc7\xb6\xab\xc7Oq\x9cS\x1c\xe7\x14\xc7\xd1\xe5\x14\xc7\xd1\xaf\x9f\xe28\xa78\xce)\x8es\x8a\xe3\x9c\xe28\xc6\xbfOq\x9cS\x1c\xe7\x14\xc79\xc5qNq\x9cS\x1c\x07Nq\x1c\xeb\xb1S\x1c\xe7\x14\xc7\xd1e\xfe\xd7\xcd\x14\xc7\x91\xb7\xdc\x1d\x1c*\xa2\x89\x0d\xee\xde\xc7\xaa\xef\x0d]\x7f\xb8|y\xf9\xf3\x87\xf5\xcfo?\\\xbcyu\xfe\xdd\xf9\x9b\xd7\xc1\xe7^\xbf\xb9x\xf7\xe1\xfcr}\xf1\xe6\xfd\xf9\xbb\xf0\xa3\x7fxwy\xfe\xf6{\xca\x93\x17/?|\x88\xd4\xfb\xfe\xcd\xef\xdf\xbc\xba\x8c<\xf4\xdd\xcb\xf3\x1f\x8dG\x86K^)\x9d\xf5\xfb\xba\xb5\x03\xf3\x83\x18i1\x96\xc2\xf25\xb8\xff\xd4W\x90\xd7\x12\x1a~Yk\xbe\x04\x07=\xd8\xc8 q\xba\xdc E%\xfb\xae\xa8T\xe5\xabp]\xf6\x87s\xab\xb3\x7f7<\xfb\x83\x1b\\V\x03\xdb\x83P\x83\xb2)\xc2#lTl\xbb\xc6=M\xb1&\x86\xdb\x12\xebgZC\xa4c>\xb5\x1dr\xda\xb9\x0d\x90\x7f\x0f\xd4l}d\xa9\xd7n\x0b\xd3\x93'Q&\x91\xea\xf5\x94v\x1b\xa0\x7fY\xd2\x84+\xc6jh\xd9\x7f\xb0M\x1fm\x89\\7n;\xe4\xdf\x97\xb4\xe2\xba(\xab\xb1\xfa\xeb\xb2.\xaau_T\xd5\xc3Z:\xb1fy\xe9\x1f?\xb0\xee1\xc9\xf3P\\u\xdc\x9e =\xfb\xb8nhB\xebf\xcd-\x9b\xf5\x1d\xeb\x1b\xc2\x0b\x96b\xb9\xe4}\x7f/\xban\x0c\xab\xa0\x1b+\xda-\x88\xa1Q\xe1'$\xc4\xa2\xc7\xb1;\\\xed\xca~\xdd\x97;\xea5\xb8\xd3\xcb|u\xc0\x8a\xd5\xdb%b\xe4M\xe4\xa70\xe7\xaf4\xcc\xa9\xae\x88\xef\xfa\xa2]4[\x94\x9cE\x93\xc5\x1ad\xbd\xa5N.(h\x99\x1a\x99\x1d\xb7\x07[\xa5_<\x0b!\x10j\xfc`\xd8DN\x13M[\x88b\x07\xc5\xb6R\xefc\x98\xfd\x13\xb1}\xa2vO\xd0\xe6!\xdb;\xf8\x84\xcfa\xe7|)\x1b'\xf6Q\x8ea\xdfLl\x8a/n\xd7D\xeb?\x8e=3\xb1e\xbe\xa4\x1d\x83\xdb0_\xca~\x19m\x17D\xd5\xa8K\x88\xc4\xfcH\xc6\x9az6L\x92\xf1\x83fG\x00%\xf8\xe2\x80\x8d\x91\xb4\xb8\x80 lK\xc56z\xf8\xe7\xbd\xcfb\xb61\xe0HZb\x118\xc22\xdfZaY@Y\x13\xed`\x92l\x17\xccC\x9d,.J\x1a\xaan,1\x0b\xd5\xac&\xfd\xd6\x08\x9d\x0eu\\\xb3\xd7\xbb\xdc\x83\x139\xc0/\xe0Y\xf43m\xe9\xff\xc6\x17\xa8\xe6S\x06\x99\xd5\xc1Q.I\xfd\xdd\x94%|\x91Z\xb0\xe7\x97T\x11\xe8\xb4\xd7\xed9\xf1\x96\x9cxK\x8e\xcf[2\xdd\x0b\x12\xf6\x9c.i\xd3\x99yW\xa4:\x87\x07\xaf\x8c\xb4\x9eqSy\xe5\xcd\x91-\x93\x970\xf4\x8dz~\xd6j\xd0U!\xf7\x19yg\x90\xd5\xd6\x1fY}\xd3\xdf\xeap\"\x9a]=dV\x87\xfal?D\xe8\xb4zaV\xaf\xd1\xc4~8\x19\xc3\xf3\xf7\xbf\xac\xbb\xdfrc\x18\xa6\x9d_\x04\x0f\x80\x08D\x00\xc8\xab\xc5M\x8f\xcb\x08\x17\x00\x0fd\x00&\xb0\x01\x90>\xea\xf0z4\x1f!\xacF\xf1\xf8\xac\xb5\xf8\xcb\xa1i\x0f;\xe2`\xceMBT_\x7f\xcf\xda\x0d\xab{\xbe\x9br\x85%v\xb3\xae/>1\xe3\xe2\x89\xbb\xa6gjz\xc8\xed\xcd\xdd\x9d\xaf\x9cT\xd6MSw\xe5\x96\xf1 )\x9cl\xe6\xcc\xe9o[\xd6\xf1\xef\xf9\x85\xfa\xc8gH\xdb\xab\x1c\x8f?\xb1N\xf4H\xc2?\xcc\xf9\xce\xad\x91\x15\xbc\x96^:|\x16\xfd_\xab\xff\xdb\xec\xc8\x1d\xeb\x9b\xf5\x17\xee\x8d4\x05\x9ak\xf8\x03S\xdfF\xac q\xbd\xb9\xfa\xa7\x08\xbfO\xbb\x17\xfdb\xbc3l;\x0c\x80\xee\xf2\xd7\xcf\xfe\x0d9\xd5\x1e\xe1\x82a\xd7\x9eP\x8dO\xb6(t\xaf\x9f\xcfY}\x19]Q\x0eh\x07B{\xa4\x7f\x87\xec=w\x98,>\xede\x04\xf3@\xe4.\x93\x9c\xa0\x1e\xc8 \xec\x81\xf0\x8d&\x8b\x00>\x90\x11\xe4\x03Q\xa0\x0f\xcc\x05\xfb\xc0\x12\xc0\x0f6b\x0f{1_\xbc\xb7\x9b,\x00\xfe \xb2\xa4!\xe5\xbd\xe1d\x19\x00\x08\x11w\xd8{o9\xc9\x0d\x04\x82\xe5` \xc8\x0f\x08\x82e\xa0 X\x06\x0c\xc2\x97(\xda\xc8lp!\xc8\x0e\x19\x82\x9c\xb0! A\x87 '|\x08\x82\xb7\xa1,\x83\x11ak\x1c\xbd\x11E\xaa\x9a(\xb8\x08\x16\x03\x8c\x10\x81\xd8\xbd(\xb3aG\xe0\xbb\x1b%\xb2\xc5\x07\xeeG\xa1\xec\xff3\xa1H\x98\xda\xf3\xde\x92\x12k\xc72X\xd2D\x98\x00)\xa1w\xa5d\x81'An\x88\x12 0%X\x0eU\x9aH\xeb\x91[S\x96\x81\x97 \x86\xe9\x81\xd0\xdd)\x04 \x13\xf8.mH\x004\xf9e8 \xed\x8b\xc0M\x900\x181\x90\x13D\xfb\x1d\x05;A\x1a\xe0 \xd0\x1b\x00\x16\x02\x9f \x06~\x82\xc8\xcd*\xb1\xbbU\x02\xa3D\x05C\x01\x01\x10\x05\xe8\x1d+\x8b\x80Q@\x03G\xc1,\x80\x14x\x07&\n\x94\x82|`)\xf0\xb7\xc2\x99iY\x81S\xb0\x10<5\x11\x85\xdd\xc2\x92\x19N\x05\x99!U\x10\xbe\x8b\x05\xbb\x8d\x05\xbb\x8f%\x17\xc4\nr\xc2\xac ;\xd4\n\x80\n\xb7\x02\n\xe4\n\xe8\xb0+ B\xaf\x00\xbf\x9f\x05\xbf\xb1\x83\x0e\xd4\x89\xdd\xd1B\x86b\x01\x0d\x8e\x05X7r\xc2\xb2`)4k\"\x0b\xb9\xbb%'X\x0b\xb2\x02\xb6`\xf1|\x88\x02\xb7\x80\x00\xde\x02\xeb\x1e\x17\x17\xc4\x05\xa1\xd3\xcc\x14\xcc\x05\xb1\xbc\xdb\xe8\xb3^P\x17\xfe\xb8\x0f\xd8\x85?\xed\x80\xbb\xf0\xc7\x10\x80\x17\xfe\xe0\x04\xe4\x05)\x89\xcf\xe3\x0b\xfe\x8c\xff<\x89\xd0\xba|\xa9\x84h\x7f}\xc7O\x8c\xd6\x05\x01]\xe1M:r\xa2tr{\x8e\x938=4\xc3\x05\x83\xe1\xcd8^\"\xb5.~P\x18\xde\xa2\xe3$V\xebb\x83\xc3 \x02\x10\x83y\x11!\x04,\x06a_\x11\n\x1a\x8b\xbc\xe3\x82\xc7\"/\xf8Ad\xc1\x17\x8f\x00&\x03\x1f\xa0,\xd8\x10\x1fT\x08\x8c\x9c\x1d\x17/4[\xa4\x07h\x06\xa7\xb4\x9b\x7f\xa2\xb4\x9b\x00\\\x0d\xe6N\x1c/tm\xa6\xc4\xec0\xb6`B\xe24\xaeOJ\x1c\xd0\x8dJJHT/\xa5\xe7$\xea\xbe\xfcW\xcb\x83G3\x0ef+\x88\xde\x9bw\x10\xd1\x11\xf1\x05\x0f\xf9\xb3\x0fb\xf9\x07\xb93\x102\xe7 D\xb2\x10\x16\xe7!\xe4\xcdD\xa0\xe4\",\xc8F\xc8\x9b\x8f@\xcaH\xc8\x9b\x93@\xc8J\xc8\x9e\x97\x10\xc9L\x98\x97\x9b\x80\n\n\xe6+d\xc9X \xe6,\xa0o&\xe51,\xced\xc8\x9d\xcb\xe0\xcff\xc8\x9c\xcfp\x8c\x8c\x86\xcc9\x0d\xd4\xac\x86\xccy\x0d\xe1\xcc\x86\xec\xb9\x0d\xfe\xec\x86\x84\xfc\x86\xf9\x19\x0e\xa80\x1f\xad\xaa,\x0b\xb2\x1c\xbcy\x0eQ\x93\"\x98\xeb@\xb38\xf2\xe5;\x843\x1e\xe2\xad\xc9\x9a\xf5\x10\xce{\xc8\x96\xf9\xb04\xf7\xc1\x11',\x1a\xd4x\xc8\x9b\xff\xe0\xcb\x80X\x9e\x03A\x08\xfc\x07\xf3 \x88\x99\x10\xdepjb6\x84_\x0e\x12cZ\x9c\x13\x9128\x94\xbc\x88\xf8(\x90r#\x92\xb3#\xf0\x08\\\x86\x0c B\x8eD,K\"\x9e'\x11\x1c\xb5\x94\\ Z\xb6\x04\x9e/\xb18c\x82\x9c317k\xc2?L\xa4\xcc\x89\xac\xb9\x13\x81\xb6 3qQ\x06\x85#\x0d\xc9\xa8\xc8\x9aS\xe1\xcb\xaaX\x98W\xe16\xd9\xcd\xb3\xc8\x9fi\x11\xc9\xb5\xc0\xb3-\xf0|\x8b\x9c\x19\x17\x99s.\x8e\x91u\x91\x92wA\xcc\xbcH\xca\xbd\xa0g_x\xf2/|\x11wz\xcc=\x9e\x83\x91\x94\x85A\xce\xc3@;\x94;\x17#o6\x86'\x1f#wFF\xee\x9c\x8c\xe5s\x84\x94\x97A\xcb\xcc\xb0s3\xf0\xec\x8c\xe0\x19\x0c\xcb\xd0H\xcb\xd1\x88\x07\xf2 /\x84\xf24\xc8\x99\x1a \xb9\x1a\xc4l\x8d\x19\xf9\x1a\xb1\x8c\x8d\xbc9\x1b_>k#\xfe\xb9\x8f\x99\xb7\xe1\xcd\x94\x88N\xaa\xe3\xe5n$\xb5\xe9\xb8\xf9\x1b\xde\x0c\x8e\x7fL\x0eG,\x8b\xe3\xcb\xe7q`\x99\x1c\xf1\\\x8e\xd9\xb16OFG,\x18\xef\xcb\xea\x88\xbc\x87gvD^\ngw\xd0\xe3\xff\xf92<\x029\x1e\xa4\x08*\x16[\x8fez,\x10\x1c\xc8\xf7\xf0g|\x9c\xa8\xc7\x92s@2g\x81\xe4\xa2\x1e\x8b\xe6\x82,\x98Z\xc1\x8c\x90\xd9r\x8f\x90\x17rb=;\xb1\x9e\x1d\x87\xf5\xecoh\x92Q\x1a=\x89~))\xcd\xc8\xd8\xcf\x92\x13\x8d\xc4f7M2\"\xcd\xdf\xff\xe6\xf7\x05\x04\xf2\xcb\x90\xefA\xf9\xf8\xe2\xb5\xa4\x0f\xff\x87\xa6g\xc9_\xfc\xae\xe9\x1d\xaey\xd2\x07\xf7&\x8b\xa5/q\xde\x06\x1a?\xb2L:\xb1\x1f\x0do\xe5\xaf\xd9\xbee\x9b\xa2g[\xbee\xb0k\xd6\xeat\x9a\x8fRX\xf7\x11\xca\xba\xebY\xb1U\x89W\xc3\xde\xdc\xb1\xde\x0d\x13r\x15X\xb2n\xaa(D\xf0b+\x9d\xc5\xe55|\xacX\xfdD\xc9\x7f\n/^\xc0\xd7\x1f\x95\x03\xba\xe8U'\x84\xd3\xea3\x13\x81\xed\xaf\xa7\x07\x8c\xf3Z\xe4\x0eM\xfe*C\xe9\x9b\xa2c\xdd\x99J.\x10m\x15~+}\x0e\xee\x1b\xf8\xc3\xbb\xcb7\xebw\x17\x97\xe7\xef\xde\x9a\xc7\xe6\x15e\x84}\xd0\x17\x8f\xcc\xe0s\x7fz\xf3!\xf8\xfb\xcbo?\\\xbe<\x7f\x1b|\xe6\xed\xbb\xc8\xcf\xeb?\x9e_\xfe\xb0\xfe\xc3\x9b\xcbw\x93Y\xa1\xdc\x1f\xf1\x86\xab\xef\x84M\xc0\xe3f\xe3\xf8J\xcc\xb4\x07\xe0\xaa\xf2\x9d\\\x86\xa8\x17Kp\xcc\xa9y\xa1U\x7fy\xc7\xf0\x04)tS@\x9f\xf4\x7f\x1eo\x07\x8d\x1d\xa9n\xbej\xf6f\xd3\x9f\xfe\xc1\x10\xfa\xa0\xf8\xe7RD\xaa)\xf0\x1c\xfb#\x98l\xc5r\xa7O\x96\xff\xf6\xdd\xf3\xc9\xbf\xadQ\x98!o\x9ccS\xc9\xe3/v\x1d\xe2\xa4w\xa79\xed\xbc\xb5I\x05\x9e\xb8\x84\xad\x19\xfaG!\x81m\x8d)96\xe4P\x97\"\xd1s\xe0<\x14\xff\xd3\xed+\x93W\xd5\xef\xb6\xe52\x0di\xb2'u\xdc\x91\xf1R\xbe)H\x13\xbb~\xea\xa1:\x7f}\xa6}\x8a\xac=\x1bn\xfat\xc6\xc9e\xe83-\x14\x8a\x0d$ZAc\xe7\xe3\x8f\xa6'\xd6\x0b\x82\xc2\xa9\xf9\xf3+O\xaaG\xac\xa5\x80(|\x8f\x89\xe9\xc8eV\x93#\xae\xac}vSv\xcb\xc9g;e\xb6\x9e\x82\x1f\xcf\x17\x9a\xa2\xeea\xf1m\x99\xb6%G\xb7c\xf2V\x9c\xb4\x0d\xa3\xf6\xd4\x97\xf5(\xfa-\xab\xa8m\x15\xb2\xaeR>\"\xf6\xbc\xcf\xc2\xa2~P\xecY\x8f\x95\x95\xf0qeI\xfa\xc4\xe3Kq[+\xb3\xb5\x95do}!\x8b\xeb(6\xd7\xf1\xad\xae\xfcv\xd7\x17\xb4\xbcB\xb6W\x8a\xf3\x7f\xb9\xfd\x15\x0e\x9c\xcf\xb5\xc1rYaN\xfb$)\xb3\xf6`\xf2w\xe4\xde,\xd7aw\xf2\x8b\x9f\xfc\xe2\xc7\xf4\x8b\xbb\xd6:\xf5$@ \xea\x16N\xd3\x0b\x836\x9fp\x06\x98\xf2\xdb\xa3\x9f\x02\x9dW\xfee\xbf\x94\xcf~\xc2\x87\xeec\xafG\xb8\xdeg\xb6\xfewh\xeb\xdb\x19L\xf5.\xa0\xc6`\xa9\xf71\xd4\xcfl5:\xe6s\x19\xe9'c\x9e\xc4?o\xcc\xbb\x892\x14\x7f\x12s\x99?R\xd67\xaa M\x8dm\x00]h^\xbf7\x12<\x08\xf3z\x12\x91A\x86\xd8\x89\xc4 \xcf\xd8\x11\x18\xe4\x01<\xf2\xe2<\x989\xe2\x82\x8c\xd1\x1f\x86H\x06ap\xd0Syp\x16Z\nxr\x06G^\x9c\x9e@\xfc\xabm\xd9Y\xdb\x8eP \xa7\xec\xa5\xe7k87+\x98\x9c\xac\xb3\x9d\xa9\xd1\xa1\x9f\x1e\xc4(\x87\xaf\xd0\x81+v\xc8\n\x1c\xac\x08\x87)\xe2\x01\xca9\x1d\x1f\xc3\xe9\x84\x9f\x7fO.\x0bb\xee+r\x92\xcdv\x86%\x9e^\x8f~n\xcd|b=\xe6Y5\xe7)\xf5\x8b\x9cO\xf1\x93\xa9g\xf9e<\x8d\xe2\xc6\xd1\x9c\x13h\x8e\xb3\xa7g\x8f~g\xe8&gH\xec\x8b\xe3\xc3K\xd7\xa7sB\x9a\xc6\xa3_\"Z\x85\xa4Kp\x0d2Wo\x18\x1fGIr\xb5\xc5\x91tD\x16\xcd\x90_\x1f,\xd7\x02G\\\xfb\xf8\\/\xeb\x9b\xc4\xc3\xa8\xe7\xbaGTuX\x13.z\xcd\xa3\xf5\xb4\xd96\xdf\x81E\xc9H;\xa8\xb8\xfa\x8b\xdc\xf5\xa9\xcd\xf2\xdf\xc7$\x0cY\x1f\xf9\xf4\x07\xa0:\xc4\xedI6=\xe2\x8a\x9e\xa9K\\A9\xf4\x89+u\x8eN\xc1\xa4d\xd4+\x80X\x13\xe1\xb3\xf5\x12\x0bB-\xe8]Y\xf7\xc3\x8aNT`\xfc\xdd\xf5$\xa1\x1f]\xc9\xca{\xd9+\xd6\x8fMS\n<$\x7f_=S\xd6\xd7\x95p$\xaf\xf9\xa4_K\xca\x1d\x9a\xd4\x9d\xba\xb5\xb3\xa8\xebCQ)\xb6\x1e(\xebQ&p\x99NE\xbb\xe2>\xad\x82\x98\xbc\x88we\x94\xa7\x9cW\xa8\xbc\x9b\xa6\xa8\xd6WM\xbde\xb1-AI\xe3/\xf0AU\xeeG\x90\xefB\xd17;\x8d+\xba\xaa\x9a\xcd\xa7\x8eo4\xeb\x07V\x84}\x19^/\xb4\xaaN2\x95\xb1\xad\x12\xca\xab\x05.\xd4\x9d\x9cj\xc7\x91\xc8X\xe3\xa2R\xed\xec\xe5_\x1fv\xcd\xf6P1\xdf|\x14\xfe\xe0\x97\xe2\xbb^\xb4\xcd]\xd9q\xcd\x97\x9c\xf8!'\xc6z?H \x0e\x80\xdf\x17\xe9H\xd4nm\xc5\xf5$\xfa&\xd0\xc4rN\x1a\x0f\n\xd7b\xc8\x82\x0f\xf69\xe8>7\x05<\x9bJ\xc0\xfd\xe9\xeeh\x9f\xebI\x99<\xcc\xc3t^<\xbc\xe3\xc2\xf0\x0c\xeb\xf8\x00m8\x9dNQ\xc2\x10\xc3K\xa1\xc4lw\x00g^E\x1e\xbc\xff7|\xf3\xaf\xb2\x03\xc7\xa5d\x0e>)\xf0\x86)r\x089\x91\xe2\n\x1d\xe2J\x9dRC\x9ar\x07\xbf\x82O\xa9\x8c\"\x9b\x08j\xa0)}\xf0)~\x8ad\xc2\x06\x00\xa1M XG<$I\xdf\x10\x8epq\xaf\\\x18\xb6\xfd\xf2\xca\x98f\x84\x85\xd7\x1d\xae\xba}\xb1 \x1b\x1bVP\x1a\xf9}\x12\x07\x0b[m\x83n2\x9ak\x1a\xb2e\xbd-\xef\xca\xad\xd88\xf4*W3_\xd2\xc6H\x82PS\x08\x7fD\n\xbap\x03'\x93AZ\xac\xa5BJ\xca\xd2Q:\xd7`\xe8\xc5,\xe5\xe4~ \xf0\xcfXj\xf6\x00\xc2\x04\x18\xfeh\x9e\xc9;w\xe2vU\xd1\xdd\x96\xf5\xcd\\\xd3\xbb+oj\xb6]\xabE\xfd\xb9\xac\xb7\xcdg\xe2\xbek\xae\xe4]Y\xaf\x95(\xae\x18\x92\xe4\x18\xfb\xf7\xb6\xf9\\\xf7\xe5\x8e\xad\xff\xa3(\xab\xf5Vq\x86\x04\xe5\x88\x01X_\x0b\x9e\xdd\xa6^o\x9b\xc3U\xc5D[\xd2\xabwd\xc9\xd6\xa4\n\xc2\xac\xd7\x815\xc6\xd9u\x07\xa6\xcd+\x99\x0d\xa2\xbf\xa8k\xd2:\xdfz\xf1\nt,X\xdaB\n\xce\x19\xa0l\x03\xd3] 2\x7fH2'\xe9;\xb1\xb9\x14\x90I\x99S\x81\xd7\xbdM\x8a\xce\xaft\xa1\xd9\xe7\xda\xb0\x1f\xe7\xdaec\xf3\xf7CyS\x97\xf5\xcdy}\xdd$O\xe2\xbb\xa2\x12\x9f\xa5\xaco\xd6e}\xed\xe4\x12\x90\xa6s\xb1\xdd\xb6\xac\xebH_A\xc2\xdeo\x91PM\xf4\xb3y\x0d\x9f\x1fd\xd4\xbc\xd0\x88~\xe1\xa3+\xfa\xa6\x15\x19S\x82=\x0b\n\xd8\x14\xf5\x96\xff\x99\xc1\xbb\xf7\xe2\x87C\xfd\x1f\x82\xdc\xc3\x10Y\xd6[v\xbfn\xae\xaf;\xb6\xbcu\xe1\xe0\xe69\xafJS\x10tP\xd6\x9bV\xb0\x10\xb0-\xb0bs\x0b|^\x8f\x1e\xc7\xa17\x85\xb2*\x1d(d\xcd\x7f\xe2\nE\x04\x86v\xc5\x83$\x88\x96:A\x84\x91\xd8\xa6\xd9\xed\xca^2\x8b\xf7*\xab\xc1\x81Zn\x9a\xfa?\x14\xdb\xaat\x90!\xcc\xe5\x1f?\x08\xa9\xdf\n\xfd\xf5G\xa1j>\x0eVG\xcf\xda\xdd`x\x88\x01\xc5I\x96?\xfeTv\x9d\x16\xf2m\xd9\xbfl\xdb\xe2\xe1\xa3\xe9\xe2\x93\x9fg}\xa8\xfb25q\xcfG\xea\x11\xfa\"\x97\xe5\x8eu}\xb1\xdb\x83\xa8Q}\x1b\xfb\x13\x94\x9dj\x15l\x0f\x8c\x1f\xb4\xaa\xf2\x8e\xd5\xac\x9b\x12\xc7h\xcddv\xa7ovW]\xdf\xd4\xf8\xb1\xe2\xaai*V\xd4\xb8\xc2B~\x0b\xf7\xe5\x8f\xb7L$\x89\xc8o\xad\xb9\x8eE\x17n\x8bN\xf2\xec\x8c\xed\x81'\x9f\xca\x8aw\xaa9\xf4\xd0L\xb3\x13\xc7W;\xd6?]\xc1y\xaf\x11'\x93\x07\x9bz3\x9d\xb2r\xca c\x9a\xfdr(\xef\x1aI\x90\xce\xdb%\xdc\xe6\xf5\x83\xccfq'\xe1uysh\xd9\x16vew\xc5n\xcb\xe2\xcef^\xdf\x89\xc9\xa3\xb7P\x914ID3\xcf_\xb2/A\xd5\x03\x9f\xd8\xbe\x1f\xc9\xd5\x0fu\xcd6\xac\xeb\xc4\xe5\x03|\x16C\xcb\x8am\xe7$\x18\xbcmzu\xb9\xc5\xc7\x0f\x87\xdd\x13l\xfe?\xfd\x08E\xf5\xb9x\xe8\xf8p\x15\xd5tZYk\xe6\x95l\x8c\xb1d\x02\x01\x0d\xfdE\x8c\xcd\xc2\x8cN\xeb\x9f\x1fw\xa0\xb6\x03~>\x96\xd9z\xbb\xa6.\xfbf2\x8a\xfd-+-\xceI\xbd\x10\x80\xef\xcdwe\xff`\x1c1\xa4\x9a\x9e\xee5z3\xb4*\x14 \xb3\"\x13V\xa6]\x8a`\xb8\xdea~cH\xb3\xe1\xfe\xc8\x1eH\xd9k\x8d\xd7\x94\xb4\xf7\x17\xaft\xaf\x92w\xdft\x1b\x12\xdbr\xf3\xe6$\xa1{s`m\xf8\xf7\xe7\xc0K\xa1%u\x84]:\xb4O\xcfne,\x15)\xf3~\x9dq\xc7\xa6\xed\xd9\x99vm\xca\xbe\x1d\xda\xb9I\xdf\x07\xdf\xbd\xe3\xdf(\xe7\x0e\x8e\xef\xe1\xfe]<\xb4\x8f\x87w\xf2x\xbfr\xee\xe6 \xfby\xce\x1d\x9d\xb2\xa7\x93vu\xd2\x04\x9a\xb3\xc0\x97\xee\xee9\xf6\xf7\xe8\x0e\x1f\xee\xc6\x82]\xde\xfe\x0c\xc3\x8e\xef\xee\xf3\x94\x9d>\xb4\xbb\x17U56D\xf7\x1f\x83=%\x1c@Op\xa5Xl\xe0\xd7\x0fW\x02\xafs~\xac\xd20\xec\x1a\x8b2\xba\xac\xe1\xe6\xfd\xc5\xab\xd1\xd6S|\xcd\x1d|\xbee-\x9b\xecc\x9b\xa6\x95\x0f\n\x9eien\x0e\x14\xcf\\\xa3\n7\x8f\xd9M\xabo\xfa\xc9\x0f\xcdnl\x14\xca\xf2\xdc\xb2=\x13\xd7\x93|[\xb4\xc3\xc8\xfa\xf8\xc8\xad>\x8a\xe91e#\x97\xe4\xcd1\x038\xc9\xdbd\xbe\xa7\xe4\xa5\x98\xc0\x98\xc6![\xbf\x8em\x8aLp\xdc\x1eEW\x02\xae\xfc\xb3Z\x9f\xb8\xdd\x99\xd0\x1a\xbf\xf6\xceh_\xce\xb7,MK\xd2\x10\x88\xd9\x94\x8b\xad\xc9\xb0\x1d\x89[\x90\xc1\x91\x8e\\ij\x8dv.Kqj#b\xd6!n\x17\xfa,B\x7f\x9bsY\x81$\xfbo\x81\xe5gXz\x86@\xc4\xe6\x8bX{Y\x96\xd5\x12\xabn\x99=\x17\xb0\xe4H\xd1\xa9l&\x0c\xad2\xae\xd6a4\x0c\x01\x934b\x8d\x7f\xb0VHT\x0d\xbc\x1f\x974A\x17\xd8\x1f\x1b\x1d\xa9#\xad\x1bw\xcd\xc4k\xb7\xa6\xd8\xd2u\"V\x86\xa9\x93Bk\xc4\xbb>f4z\xd6\x9a\x18\xdbn69\xbc\x1e\xf0fL\xa6\xca\x02M\xae\xb5\xb8\xde\xda\x0b\xd2T}-\xa7F\xca\x8e5\xcc\xa65\xe5x;\xe9\xb8\xf3\xb2\x9e\xbeWls\xfbo\xdf|\xc5\xeaM\xa3\xae\xc8\x12\xbf\x0ew\xba\xa9\xd7\xf4\x14\x18\xfa6\xa7\x11\xce\xcb\xb4F8\x9bcw[\xb4,\xa9f\xf9\x86\xfa\xcaf\xcf\xf8\xc7U?\xb6l\xc3\xca;Tc\x0dv\xde\xf8\xd9\xa6\xa9<\xdcFQ\xc7\xd9\xe6\x13\xab;\xb8e\x95\xb8\xac\xa1\xa8\xa1\xd8\x88\xa3\x82:\x10)Q\xcd\xe7Z\xde\xe6\xd0\xd4\xc68\xab\xcb\x9e\xc5\xf5\xe5\xcd\xa6\x14.\x1e}H\x1e`\x80\xcdg\xe9Qkj6\xfd,\xa4)\x97\x1cM\xdcNf+\xfa\x1a\xfe*\x84g.\x90w\xd6\\3\x18\xc2\xb3\x98\xde\xa0\\\xb3\x19\x90\x19MoE\xfa\xccvDX\xfe\xd0\x8c3\x1cr\xcfr\x98\xcet^\xae\x8a\xaa\xa8\xdd\xdcn\xe2\xc4\xa4\xe2!\xb0\x9bi\xe2j\xc7\x1a\xd9\xd97\xd0\x8c\"\x96\\<3\xba\\u\xa1\xdd.\x13S\x84\xa6OXxo\x8a\x8a\xd5\xc2\x1fbL%v\xbf\x11N\x12q\xa0\xeb\x8d\x9b\xc9\xed\x8f8\xbdMQ\xcd\xdf\xc1w\xb9kZ\x06\xdd\xa1\xecE\xf8\x80\x9b\x87\x9b\xaa\xe4\xb5iGt\x17\xd4\x7fcG\xa8\x8ao\xd7\xd4\xe5\xa7\xa8\xeb\xc8\x1a\"\xf5\x8a\xf1\xa5o\x0f\xbb\xa2\xfe\xaae\xc5V4[\\\x07\xaa}\xe5\xcet.\xb7\xac\xee\xcb>\x8cE\x08\x19WZ\x80\xe9;\x90\x00\xd4\xa2\x1a\x7f\x1c\xbe=q\xe1\x93\xff+\xae\x90\xea\xee\xd0\xc1\xa6\xd8K5+\xcf\x8b\xfa\xcf\xed\xa1\x1a\xd9\xf76\xac\xeb\xa4/H\x8f\xdeD\x9c\xd8\x82\xf9O\x9b\xdb\xa2\xac\xcf\xdc4\xddMu\x90\xd7\xdbV\x95\xf1 ?\xdb\x17\xbco\x87\x8dl\x83fw\x91\xb5\xa3\xbe\x86b\xbf\xafJ\xe9\x83\x7f\xecP|w=?\xb2\xf5mQwRO\xef\x8a\xcdmY[\xc9,\xa2f\xeaM2YR\xb6g$\xebc\xb9@\xe2\xbef1xn\xeb\xe5\x0c\xdf\xb7\xec.\xe3\x04\xbf-\xba\xdb\x99\x13\xd2I2\x10\xc8\x91~\xdd\xb1~=]\xde\xbax[\x08\xc1V\x8aW\xdd\xb4\x81\xe1'!\xb5\xac{v\x83\xa4\xe7@$}\x06\xbc\xc3\x00\xb1\xa1\x80\xf0p\x0c\x1f\xed\xa2h\xfb\x8e\xf5?\x88Q\x99~n\x19}Z\xbbM\x88\xce _\x9a\x07\x17%\xd7\x96\x9c(| \x1a\xcf\xf1\x7ff\xa8n\xccu\xc9 l\xda\xf6\xeb\xb6\xd9 5Q\xec\xf7\xd0\x1c\xfa\xfd\xa1\x1f\xff6\xae\x01C\x82He\xc9\xda\xa6ASf\x90U\xec\xf7\x19\xa4\x88\xf9\xa2\xb2-2\x88cw\xdc\x1e\xdb\xb0\x0c\xa2\x86\xef7n/\x13\xf5$\xb9bX\xea\x91\x17\xad\xcf\xda\xf8\xe4\xaa\xb2\xa4\xe5\xf9k\xebC\x8b\xaa\xf9\x88\"\x8e\x8d\x12\x88\x90\xf9\xcf\xef\x7f|\xd6\xb2\xae9\xb4\x1bu\x10\x12G\xc2C]\xfer`\xd5\x83:\x9f\\\x97j\xf4zE>\x80e\x0b\x8380\xb4eQ\x95\x7f\xc5\xb2\xa0A\xf6\xb5o6M\x05W\x87\xebk6\\\xb6\xaf\xb2Rd_`w\xe8\x86\x13)\x14=T\xac\xe8\x90\x8cU\x10\xb9\x0b\x0c\x1e={$\xbc\xe4\xc5\xa6g\xedJ\x1c\xc6E0\xa4c7\xfc\xc8\xad\xbf\xf4\xcf\xef\x7f|\xdc\xc1\xbe\xe8oE\x05\xa8\xb8\xc1\xc1\x82\xd7\xc6\xc5\\\x1f\xaa\xea\x01~9\x14\x15\x1f\x95\xad\x1c3U\x85\x18\x9d'\x85H\xdcF\x05|\xe4\xd5{\xef\xfb\xff\xf8T\xb6^\x88\xecn\x9bC\xb5\x85+y\x04G\xa5m\x8a\xba\xa9\xf9AC\xe8\x04\xbc\xc6'lu\xb3:\xe3C(L\xd1G\xabG:\xb8\\l6l\xdf\xb3\xedS\xfcJ]q\xcf\xcb^8\xee7\xec\x0czV\xec:8t\x07A\x1d,\xb3\x8a\xf6e\xc5[\xd77\xd2\x14.k\x91aQU\xf8\xd8=\xec\xc5\x1c*z\xfe\xf4\x03^\xa5\xe45\x80\xb2\xd7\x0c\xbd\x8a\xe1\x9eO\x06v/>\xe5\xcb\xfaa\x05?4\x9f\xd9\x1dk%2\xff\xe7\xf7?\xbak\x97\x17\xe9\xa5\xe0b\xd0$y^\xba\xcd-\xdb1\xf8x\xdb\xf7\xfb\x8fg\xf2\xbf\xdd\xc73\x99x\xa3~=\x13\xb3lc\x1c[\xab\x07\xf4\x16\x1e\x10\xa1>(D_=\xf5\xb1\xf6\x8e\xa98\xfa\xae\xd8wr\xca\xf0\x1e\x08*\x0f\x95m(\xf4\x95\xb0\xe5;@.*\x07\xb1\x0bTU\xf3\xb9{\xee\xf9v\xbf\x85\xf3\xeb\xb1\x07\xfc\x93\x0b:\x9c-\xdb\x0e\x9dT\xde\xbe\xc3\x8em=\xb7{\xfc\x16^\xd6\xf0\xc3\xe5\xe5\x05|\xff\xe6\x12\x9aZ/#\xb9@\x1f\x84\xa7\x0b\x9f\x99\x7f\x9eN\xf1\xcb\x87=\xfb\xcb\x9f\xff\x82>\xac\x88\x01\xf8\xb7VsHnq\xe2+\xec\xdbf{\xd80\x91\x89\xd4\xb6\xd3$r]~\x0b/\xc7\x13R\x07E\xcb\xf8\xcb\xa8\xdf\xa6\xd8p\x9d\xd04\x9f\x0e\xfb!5\xf3\xaa\xe8\xd8\x16\x1a\xfc\x0e\x14\x9fz\x03\xde}\xd1.\x91e\xd7\xdf\xb2\x9d\xb1\x16\xb6r1\x14\xba\x1bC\x06RQOo\xe4\xd1E6J,\xfb\x96]7-;\xd3/s\x99E_^\x95U\xd9?\x086{\x1d\xee\x12*\xaa\xbd\x9b\xe0d\xc6\xd2\xd4*\xd4+^\x10\xebn\x05O~\xee\x98v\x14\xf0Q\xe1\xd3\x8e\xeb\x199\xef\x8a\xba\xb8\xf1\xf5\xf8\xaae\xc2\xc1\xa1\x85\xae\x9e\xe2\xb3\xe5m\xd3\xb3\xe7\x8a\xa3Z\xe5\x15\x16\xa2\xedJ\xdf(>\xa1\xea\xc1\xcc7\xc6q'\xbc4\"U\xdaM5\x96EO,h\x19\xdf\x1d\x98\xf2_\x0f\x993\x03x{\\_W\xec\xa6\xack\xdf\xa1\xe5s\xd9\xdfz\x94\xfe\xc3\x9e\xad\xe4|.\xf6e\xb7\xda4;\x9f\xc6\xfc V[\xa7E\x85\xedD\x16\xeb\x95G\x91\x88\x0e\n_\xf5\xe0[V\x11\x86=\xdb\x94\xd7\xe5\x06:\xb6+\xea\xbe\xdct\xee\x92A\x888d\x89\x98\x14\xc1\x93\x1d\xcd\xe2\xf8\x89\xab\x8e+\xa6\xfdj\x86\xc1\xe0\xd8\x06jS-\xae\x9a;\x8f\xb1!\xbb\xaa\xa6\xf3\xb4\x9b\xb1\xd6||Y?|4\x1c\xdf5\x14\xedU\xd9\xb7|\xf1\x05Z\xa5t\xb4#\xae\xa8\x9a\xfaFE\x0f\xdcO\xc6\xb5\xa6P\xfa\xb2UW\xae9e\xd6\xa9\xad\"d\x9a]\xe8\x89_\x95W\xa2\xa9J\xafw\xd0\x1d\xf6\xfb\xa6\xed\xe5}\x11\x9bO\xcf\x0e5\xff\x0f\xdf/\xe5\xf7F\xe1d\xc2\xa2A\x8d\x87\xe6\x1a\x0e\xbdT>z9w\\\xf1\xe9h@Q\xc1\x0d\xab\x05]\xe6VE2\x06\xa3\xfa%\xa2\xef\xe4'r\xebys_\xf0 \x0c_?\x87\x8bB\xa51\xab\xa6\x17\xc3\x86X\xd6\xf0\xea_\xff\xd5\xb3M}\xd74p\xdd4\xf0\x02V\xab\x15\x9an/\x06\xa1\xa8\x1f\xf0\x1f\x8b\xfaa\xc5\xab\xfe\xaemvO\xae\x9b\xe6)\xfe\xd8j\x85\xef=\xe55<\xe1\"~\x16\x8d\xbel\x9e\xfc\x0b\x97\xf1\x14G \x04\xe4\xfc\xdd?6\xdfD\xc6\xe6\xf7\xc5]\xb1xp\xe0\x85\xb0\xad\xb8\xf4\x05\xa3PvO\xbek\x9a\xd5\xa6*\xba.0\x08\xb2I\xfc\x05\xd9\x1f\xe3%\xbc^dt\x86\xe1\xf9\xb7\xc8\xf0\\<\xf4\xb7M\xed\x19 \xd9\x92\xef\x9a\xe6\xc9j\xb5\xc25\xf108O\xbc\xbf\x8b $\x86-u\xd4\xf8\xcb\xe7r\xd0^\xbf\xf9\xf0\xea\xfd\xf9\xc5\xe5\xbb\xf7Oq\xd7\x9b\xacJN4\x7fe\xb2:\xffp\xfd\xcf\xc8p}\xdf\xe0#%\x86\xea\xf9\x0b\xf8\x97\xfd\xd5\xea\xbb\xa6\xf9\xcf\xd5j\xf5w\xfc\xc1\xa2~8\xe3\xe6\x1a\x7fz/\x0d\x90\x9f\x8a\xb6\xbb-*>\x88\xfe\x86\xfb\x86iZ\xb3\xa7\xda\xf2zR\xe9\xcf\xf5n\xacV4JLl\xf1\xd4\xffx\x01uYy'\xa8\xbf-\xc8L\xbc\x14\xcc1\x9bO\x83\x1e\xd4\xc66\\=\x8c\xa6\x8a\xd6\xd8\xe2\xee\x8e\xab\x07\x9d\xdd\xecH;t\xc8\x9e\xff\x181C\x9e\xf1\xb3\xe8J\xfc\xc0M\xb9\xc7P\x18\xbb\n\xdfqTd\xc1\xadA|u\xb7\x92A\x8d\xd7\xd5\x83>79\x07\xde\xc1t\x84\xe2\xbag\xd2\x9a\xe1\xe7m\xb7\xc9\xcf\x1e\xbbU\xa8\x03\x9dn\xa2<\xc1153\x1f]7\xcd\xea\xaahE\xe7\xee\x9f=\xac\xfe\xfaH\x8e\x96(J%K\x9c\xceG\x98\xa6\x0c\x15|H\xe4\xecV>SK\xec\x99Lp\x10q\xf9\xa6m\xd9\xa6\x87MQm\x0e\x95v7Z\xc2\xae\x0f\xdc:\xb6+8\xd4\xe3hv\xa2\xff\xcd\xa1\x87\xb2g\xad\xdc\x1f\x9a;q>\x18\x0eL\xf0\xc7[V\xcb\xae@\xd1\xda\xf3\xd9<6\xda\xb5\x88|\x00s\xc0\xa7\xbc;\x9b\x96m\xcb\x01nV\x98`\xb9\xcf\xb7Mg\xd73p\x97\xd9\x95\x98\x9f\xa1\x1cS;De\xe3\x97\x94M\x1f\x9b*.\xfc\x90>\xfa\xa9A\xa2r\x15\xecZ\xac\xf1_\xa9+\x1e\x15*\x8ek\xd6+6|\x02\xb6\x15\xbex1\x95\xd4\xd50\xb2y\xb6\xc4\xdd\xa1\xea\xcb}U\xcaF\xd8\xf2\xc5\x83\xf8\xcc\xb6\x11&\xa3\xefW&q\x8a\x89h\x0cq-U\x11\x1f\xd0k\xe7\xdad\x91\xfd9\x04\x8b\x14=P\xdf\xb4\xb2\x03\xfb\xa2\x15#\xa7 .\x8a\xf9\x9e/\xd9^LAi\xbd\xeeY+\xef\xb0\x15~\xbd\xfa\xa3\x12\xb6k\xc6\xa4\xbd\x96\x89[r\xec\x86\xeb\x1f\x9f|\xac?*Z\xa2\x81k\x7fZ\xe1\xc7\xdb\xe1\xd55\xab\xfb\xb6d\xdd\xc7\xd1x\x13\x879\x0f\x1c'\xf1\x8e\x0f\x9f)\x8d\xaaA\xeb\xf3Lla\xa5\xe8\xa4]\xac\xbc\x87\"\xa8>\xb5h\xf9v7fiOk\x9c\xe6\xf0\x13H\x91l\x81\xba!z\xe7\x1c\xe9\xff\xc6g\xcc\xa6\xa8\xd1\xcd\xd0\x0e\x87a@\x896Z\x04\xfaO\"\nT\nM<\x0c\x90\xa9\n, \\\xcb\x8c_\x9e\xecY\x0b\xfb\xa2l\x9f\xf5m\xd9\x0c\xc7zw\xbed\xe8\x91+T\xf7e\x1c\xd5\xf1\x99\xa1s}\xa3\xd7\x88n\x1d\xef!\xe9\x12G\xab\xfa\xf1-\xcb&\xe2\x7f\x16>\x9b\x8d\xc4\xb3\x8e\xc0UD\x89\xf8\xae\xa4\xb5\xaf \xb4\xd7_hu5ME^[u\xd3\xab\xcb\xb6\xd6S\xbf%\xd2y\xea\x93V\xf7\xc6k\x9e\x9aFp^\x8e\x89`m\xb1\x11}R\xfa\x98k\xc9\xba\xe9\xbfR\xff\x94\xe0\xdf\xee\xb0\xdfW\x0f:X\xc7\x7f\xfa\x8d\xfe\x0e\xf6\xa8z\x86C\x10-f\x81\xf5\xaf[\xeb]\xf4}\\\x86-\xc76\xe7\xbc\x87:\xffq.B\x15\x001S8f$\"5\x90`\xfb!ASc>\xc2.\x00\xcb\xfb0\x8fz $h\xda\x07\xdc\xb3\x9e\xd2\xf0y\xc4\x04\x8e\x18\xa7\xff\x8b \n&\xf2J\x07\xe1\xb8\x9c\xb3`*\xb0v\x12 \xd0\x81w\xa8\x0c`\xee\"rh\x0d \xfc\xed0z\x83\xe0+\xe1o4\x9b\xea`\"g \xdf\xc1D\x94b?\x98Ns\x12\x05\x02\x04;\x9c\x87\n\xc1\x10h%t.dF0$Y\x1c \xbe\x0ey\xb6\x14\x88\xdc\x83g\xf4/p\x93jh\xffj\xdaQF\xfau\x17\xc8N\xe6l\xe2y\x01e1\x17F\xb2+\x97\xb0\xf3E\xdd@\xf1\x9d#\xe3\xfe\x17\xd8\x01I{`\x96\xded\xdb \x03{\xa1\x7f7L\xeb\xc2\xfc\x1d1>\x16\xcbvEG\x9c\xa4\xf1q\xfe\xbcpgt\xe5]c{\xa3\xf7S\xa0\xfb\xe3\x82\x05\x87\xee\x92\x91o\xea\xdb)\x17\xb9.s\xed\x97YwL\xdf\x9e\x99\xb2k\x86\xbb\xbeh\xe7\xb4$\x19\x84B\xd8\x8c\xc9\xb0{:\xfb'L;\x87\xedA\xe3G\xad\xaa\xc9\x8a\xef\x1e\x8f7W\xb8\x9a\x14\xbb\xb7\xc2\xaam|`r\xba\x1e\xfe\xac\xfc\xb8\xba-c\xab\x13Nv\xa7\xfb/\xbc\xe4/\xffe\xee\xbf\xc0=\x16Q\xdb\xcbk\xf2\x99\x02\x9ea\x12<\xd7!\x07\x8d\xbf\x9f\xb5\x1bn\x89\x158\xfaD\xbf\xac\x11x\x14Z\x81Lv\x9a\xc7F\x8b\xdag\x0bZ\x9e\xc9&\xf3\x18\x01\x8e\x7fU\x16\xec\xf3\xca\xe2|d\xf3\x85YT82\xa9\xa1\xa9=)?\xb2D,\xc38'N|\xa0e\x99\xb4F\x0f\xb6\xfa\xd7x\xff\xc4\xe8\xe9\xee\x9b\xe6\x93G\xd8\xbe*6\x0e\xb6\x11d\x86\xc8\xbeb\xa2\x1e_\x8c:\xa1\xcf\xa18\xf5\xa4\xdf\x93\x8au\xf7\x0euy?\xa6\xf8\x8c}\x1b\x1f\xc7z\xa1RY\xd6\x1eKR\x96h/h\xdfeR\x97\xb5M+S\\=RIh\xee\xf6P\xc9\x90&.O\x1d\x0d\xa0\xe8#\x9d\xcc\xd8\xb9@\xdb\xfb\x86\xda\xa2\xf8p!\xda\xffM\xdd\xb7V\x1e\xe6\xf8\x89\xe5\x9a\x95\x18jWV\xcb*vW\xd4=\xdf\x81\x8am\xd1\x17\xc1\xa3\x94\x0e\x9a\x14\xf2.'<\x1c\xa4\x1e\xa2\x9a\xb5Hod\x94S\x9a\x81\xc2\xe0\xeb\xca\xfa\xa62\xceP\x8f\x8d\x0b\x13,a\xfco\x93\x93\x98\x8c\xab* f\xe8\x95\x0f\x13_\x12_5\xed\x96q\xa3\xbc2\x82@'\x8b\xf2dQ\x1e\xdf\xa2\x9c\xce\xfd\x05\xa6eP\xd4\x1c\x1bsH\xa5I6,\x87E65'IS>\xcc=\xe5\x9d)a\xb59\x93ujd\x99\x9a\xc8\x8bqN\x85\x19\xa7\xbc\xc6\x94\xdf\x90\xea\xbd\\S\xc1-*\xbe\x99df\x99\nsL\xe5e\x98\xca\xca/\x15d\x97\xea\x97qK\xe5d\x96\x8a\xf3J\xcdf\x95\xca\xc9)\xd5\xc7\x19\xa5r\xf2IE\xd9\xa42sI\x05\x99\xa4\xe6\xf0H\x859\xa320F\x91\xf8\xa2\xd2\xb8\xa1\x162C\xe5\xe5\x85\xf2\xc5)\xb2rB\xe5g\x84\xca\xca\x07Ec\x83\xca\xca\x05\x15b\x82\xca\xcc\x03\xe5c\x81\xea\xa9\x1cPs\x19\xa0$\xdb\x13\"\x10\xe7\x7fZ\xc0\xfe\xe4\xe1~\nn\xf1A\xde\xa7\xf8\xfe\x9f\x8f\xf3)\xc4\xf8\x14nGV\xb6\xa7\x10\xd7S&\xa6\xa7e\x99\xcf\x81d\xc3&u\xf11 y\xf9\x8f\xe8\xed\x9f\xcb}\x14g>\xa2\xb7\x01\x1d\xc3|\x9cG\x1e\xc6#/\xdf\x11\xbd\xe1\xc9\\Ga\xa6#o\xc5\xfe4\xa7\xf08ff8\x9an\x9a^~\xa3\x10\xbbQ\xb4\x93x^\x13\xb5\xa3\x0bY\x8d\xc6.F9\x8d|\x8cF\xd3\xcc\xab\x99|F34k\x9c\xc9(\xbe\xec\xf2\xb2\x18%r\x18y\xfb\x0c\xd1|B?\xd3Mp9\x03iP ;oQ\x88\xc1'\xccY\x94\xa9;\xd9\xd8\x8a\x0c\xa6\x9ed\xae\"\x12SQ\xc6\x0e's\x14y\xe2[`\xf7\x9b\xcaP\x14\xe4'\nv3\x9e\xf3i\x0d\xc2\x1c\n\"\x8cn(J64\xd3\x0c^B3$\xfe:\x917\x8a\x19[\xefoAn\x82\xa1\xac\xf4B8\xb9PFj!\x97X(\x1f\xad\x90y\xce2k\xc8I)\x84\x12\n]\xe5\xa5\x13B\xc8\x84rS \xa5\x11 y 'N6\x1e!%\xd0}yQ\x1e`:\xc2\xc4\xcf\x9c\x93\x17X\x12N\x19\x0c*\xdc\xd8\x8e23q\xd0+\xe7t]%1\x910\x96J\x98;\x990s:\xe1\xe9\xbaJ\xab\xe4L-$%\x17\xe6M/$$\x18fO1<]W)KRJ\xe2\xe2\xa4\xc4\xdci\x89\xa7\xeb*\xcdBKP\xcc\x9c\xa2x\xba\xae\xf2t]\xe5\xe9\xba\xca\xd3u\x95\xf1tFB\x0e\xdf\xe9\xbaJ\xca\xe0PR\x1c\xe3\xa3@JsLNt<]W\xa9\n%\xf1\xf1t]\xe5\xf24\xc8\xd3u\x95\xc9)\x92n\x93O\xd7U\xe6J\x9f\xcf+M4*\x82\xd1\x03\xc8\x80\xd3\x83\xf9X=\xaf\xbc\x82\x84\xd7\x83e\x98=\x98\x8b\xdb\xf37\xbb\xaa\xc4xE\xb1{0\x13\xbf\xe7\x15&P;\x04\x0c\x1f,\xc0\xf1\xf9\x05\xb2>\x86\xe5\x83\x9cx>\x88c\xfa \x17\xae\x0f\x16a\xfb \x1d\xdf\x0790~\xb0\x00\xe7\x17\xd0O\x9e\xd3\xb1.\x99\xf1~p$\xcc\x1f\xe4\xc7\xfdA\x02\xf6\x0ff\xe3\xff\x82:<\x8c\x01\x84Y8@\xaf\xa8\x01\x1f\x18\xc0\x02\x822\x01\x88x@\xc8\x8d \x84(.\x10\x96b\x03!\x84\x0f\x04\x9a \x14=I\xd3\xad\xa4\x9cxA\x88b\x06\x81\xd8\xb2y\xd8AT\x94\xde#\xc2\xf8A\xc8\x89!\x84e8BT\x9e\xda\xe8\xfd\x86\xcd\x02\x1c&\xcc\xc6b\xe2\xa2|\xf8L8\x02F\x132\xcd9\"V\x13\xc8xMp0\x9b\xe0\xc5m\xc2p6\xc6\xd1\x99\x10\xc5o\x02\xf1\xf49\x1b\xc7\x89J\xd3\xf9\x89~,'x\xf1\x9c0mq>L'\xc4]\x0d8\xb6\x13\x92\xf0\x9d\xd8\xd3\x1e\x8c\xa7\xefQ\x0c\xe7\xe9>\xeb\x15\x9a\x84\xf7\x04\xf0a>!>^\xd6\x97\xca\x85\xfd\x841\xfd\xd7\x8b\xff\x84\xc4\xb6y\xe6}2\x16\x14\x95b\xa6\x9e\xfb\xf0\xa00iQ\xac\xc1\xc6?\x96\xe2Bay\x103\x80\x11\x85\xf8\x97\x80i\xe7\xb2aE!\x82\x17\x85\x19\x8d\x0b\xb8\x0e\xe7`G\xbd\xc2\xf4\xf5\x1f\x01\xfc(\x841\xa40\xa3w\xf3\xb1\xa4@\xc4\x93\xc2\x8cV\x05\xc6<'\xb6\x14B\xf8R\x10\x8d\xf2bLaF\xb7f`M\x81\x807\x85xSb n\x94\xd1_\x80?E\xe5\xd9\xc0\x8d8\x06\x15\xa28T\xa0\x0f\xc4b\xd4T>\\*\xa4bS!\x88O\x85i\x0f\x96`Ta\xf9^A\xc1\xab\x02q\xd4a\x01n\xd5+\xf0\x8a\xa5cW!>.@\x18\x1b\x88\xe0X!>\xa1u\xa1\x0e\x1f\xcc\xc2\xb4\x06\xc5\x110\x9e@\xc0\xb6\xc2q:\x9b\x11\xe7\n\x8b\xb1\xae@\xc7\xbb\xc2\xf1\x86#\x0d\xfb\x1a\x147M\xc4K\xc1\xbfB\x1c\x03\x0b\xb4A\xa0huH\x18\xa8l\x98X\xf0\xe1b\x81\x86\x8d\x85x\xff)}\xca\x8a\x93\x850V\x16\x08mZ\x8a\x99u\x04\xa2\xa9[\xb3q\xb4\x8e$\x8d\xab\xf5bi!7\x9e\x16<\x98Z\xc8\x8c\xab\x85\xf1\xd4\x8b`k\xc11\xd3\x92\xf0\xb5\x8e,\x81\xb7\xf5al!\x03\xce\x16\x9b\x188\xd6\x16\x96\xe2m\x1di\x18\xfe\x16(\x18\\|\xb5\x04`\x86^\x80\xa3\x826\xdao)y\xef/^\xe9\xb6\xd1 \x8e\x17\xdc*L\xbf\xdeE\x18\x93\x86\xbdc\xf5N\xfe\xa8\x1c\xc7\"\xf1S\x04\x01\xb5\xf9)\xb7\x93\xb2\x83]\xb3=T\xf3p\xbf\xb3\xee\x1e\xb4\x1a9\xb1\xed\x95\xa2\x94v\xbe\xf2\xfc\x8ad\x13\xcc:\xe7\xdb\xeb\x88\x12\xc1j\xc7\xb0H\xfe\xe3\x99\xed'\xb1\x84\xeb\x86\xe9]{\x84\xeb\x8e\xcfL\x9b\xc6\xea\xbeu\xac\xd1\xc5\xedr4\xbcQ\x95\xd1J\xd0\x7f\x12Q\xcaRh\xf8a\x10MX\xbe\x93\xb2\xdb2\xe3\xd7'{\xd6\xc2\xbe(\xdbg}[6\x96\x9bd\x84\xca\x1e\xa9\xa7n\x05\xba\x7f\xe3\xe8\x1bx]\xfdL\xdf\xc0\x9e\xb5]\xd9Y~\x06\xde\xf3\xf5\x96\xd5\xcdn\xce,\x1d\xdf\xb6l8\xfeg\xe13\xe3J\x12\xc4\xef\nU\x8f(\x1bd\x9d\xc7t\x8b|:\x01)}\xd14U\xba\x12i\x9a\xca\xa7B\x9a\xa6\xb2y\x03\xf8\x1f\xca\xfa\xba\x99\xa5.\xea\xa6_K\x85\xbeN\xb8q:\xe5\x0dd\xc4\x8d!\x89\x8e7\xef\x1d}\xb4\xdf\x1b+%]w\x9b\xebl\xad[e\xf4O\x8a\xc8{M\x97Y\xe7\xd4\xfc\x0d\x1c\xb1CG\xeb\xd1\x8d\x7f\\\xa8\x92S\x8fV\x06Wls\xfbo\xdf|\xa5\xf1F6j),\xca5>\x07m\xbe\xee\xda\xcd\x91{\x84\xd6\xe5\x06\xdb,},\xe1E\xa88\x8d\xbf\xd2#\x10\xea\xdc\xb6\xeb\xbfX\xe7\x8c\xba\xc2\x9d\xf3|\xab\xae\xd7L%\xf1\x1e\xa2\x1b\x91,\xd8r\x1a\x0b\x8a\xdd3_\\\x84\x9b\x96\x9e\xae\xa6\x0e\xf8\x94e!\x1c\xbf\xe3\xfeeY(\x1fI\x96I\xeb\xc0&\xc4\x90\x7f\xd3\xcc\x86!\x07\x855Q\xfb\xa6\xf9\x04\xfb\xaa\xd8\xa0Y\xd9 }\x8b\xfb\x8a\x89\x8aC\x1e\x89\xc4A\x89y%\x92\x06\xc6n\xa15.\x87\xba\xbc\x1f]\xcd\xd1i<\x15\xe8\x1b\x14\xe5S]_\x15UQo\x96\x0e\n\xbd\xab\x93zQ?\xaf\xfe\xed\xf3-\x0bu\xd2\xd6W}\xd1\xf6\x98?F\x16y\x8c\xe3*\xe2\x8b\xf5t\xacRk\xa3\xf1\xack(\x9b\xaf\x06\x1d\x15\x95%\x17\x90\xe1\xd9n\xfc[\x8dg\x9b n1\x91\xab\xd8M+\x92\xb7\xc7\x13\x8b?\xedb\xa7]\xec\xb4\x8b\x9dv1\xaf\xac\x7f\x86],8\xdf\x82_ \xde\x1f\xa7/\xa6S\x81\xfdr(\xef\x8a\x8a\xd5\xbd\xdcV\x9c\x87\x11\x81\xec~\xc3\xf6\xbdL!.Q\xfa\x83\x11\x918\xcc\xdaI\xbe\xaf\xfatR\xaf W.\x12r\x00\xe8\x0ee/\xfcT\"\xec^\x95\x1e\xba\x85\xc1 a\x8emhd\xccnR\x87c\xd2o{{W\x1b\xaa\xdd\xb8\x81\xb7\"e\x14\xac>\xdb\xe2\x90\xfe;=?\xf1j\x9ex5\x8f\xc1\xabiG\x9cP\x07b\xccIi\xbd\xa4\xa4%\xc7\x9b~\xd6\xa1\x80\xd7\xce\x02&;0e8a\xea\xb0$\xcd\xeb\x88\xd3\xd0;\x1f\xac\xb1\x9c\xe7\x11\xc4\xbd\x7f\xa3\xbbjA\x83\x1c!\xb4\x06\xa1\x87\x8b@H\xe5\xb8\xccS\x04+?b\xcb\xc4,\xfb\xf8^\xebZ\xf3%n\xc7\x1b!-n\xaa\xa3\xa2<\xe6;\xc1p'\xf6\x93\x9c\xde8\xb5\xc4K\xcc\x08\x1f{\x14\xb2\xb3 \x16v\x06'n\xc8\x9eV\xa8\x02\xf5H%\x99.\xb6\x87Jf6`\xd2Z\xb6a\xe5\x1d\x83\xa2\x0fv-S\x97\x02m\xee\x1bZ[bC\x84(\xd1\x89\x95k\xe4\xd7\x06m\xdc\x88u\x1b\xf4\xce\xa0Q]\xc7Kc\x89\xb0\xec\x00\xa4\x17\xd0\xf5\x8dH\xde\xa9*\xe9\x99\xe9\xca\xfa\xa6b\xa6W\xc6\xa8V\xba`F\x81|\x16\x0f\xaf\x18\xd9+5\x1f\x0f>\xcf\xbfj\xda-k\xd9V\xb8~\x90H)J>=11C;$\xd2#%\x90\x1e\xdb\x1b\xf2\x99^\xbb;4y\x874\\3_(\xc07\xd6\x98i;\x88\xec\xd4\xb2\xa4\xac\xcb_Ix\xef\xb8\xbd\x99g \x84E\xb9\xbd\xc9\x03\xcf\xb2\xd0W\xa6\x85$\x14\x81\xfcQ\xa9K\xc7\x03\x12\x1b\x0bC\xa5\x0c(\xd91uB\xa5\x1cJ\xa5|\xcb*\xe1{(j(6\xc2\xf8v;|\xce\x0d\x01\xf7\xe4\xda|\xae\xa5\xdf\xa2\xa9\x0d\x1d\xa5\xc8\xa3\x04}Z\xb3)\x8b!kN\xd8\\F\xfa\x99+\xef\x9aKr\xeb\xf1|\n\xcf\x865{\xc199*\xb2\x04\xbf\xa9\xf4\xfe$\xbe\x16\xfbz\xafdV\x8b\xf6\xd8\x88\x0f5&\x1e\x8e\xc9.b\xa0\xf9w\xdb\xc9\xcf\xe6\x8e\xdc\xdbw\x97o\x9e\x0b\x02\x02\xe5\xa6\x92H\xfeRl\x91\xe7\xb5\xb6\xe8\x06\x82+9G<\x10m\xa9\xc0\xddJ\x06\xec\x17\x9f\xaf\xbf\x1c\xcaVN\x8a\x9b\xe6\xa6\x11hb\xaaW\x03\xdfpl\x9f\xc6k\x9f?\xc3\x924:p~\x83\xcd\x98d?\x86\xf6]\x98\xb2N\xae\x8b\x93\xeb\xe2X\xae\x8b\xe9\xd8G-#\xafef\nx\x86I0L3\xaae\x96l\x8e\x0d\xfa{\x96\xcf\"L\xc9L\xf3\x108\x9f|&\x01\xf3H\xb6<\x91\x17\xa3^\x0e\x93.{\xb7,\xff\x86\xd5{)\x96\x83\xfbUl\xeb\x99O\xa8\xec1\xa4\xc2T\xcasH\x94\xfdd\xc9\xb3h\x92\x85xDX\x90 \xb9_F\x8d<\x93\x14\x19\x85\xe2\xc7\xe9\x90g\x13!\xcf\xa2@\xe6\x87Wl\xc4\xe2\xe4\xc7sh\x8f}d\xa4Q\xc2\xe3\xb9T\xc7\\\x8b#\xe2\x82$\xc7s\xe8\x8d\xc34\xc6\x19\x08\x8cI\xd4\xc5i\x14\xc5\x0b\xc9\x89\xe7\xd2\x12\x03\x1a5\xf7\x9d\xeb\xb2R\x11\xe7'!\xceJ?L#\x1e\x9eG9\xec\x19\xe0\x10\xd9p:\xcd\xf0H'\x8c\xadq\x0f\xc1pO\xa5\x16\x9eK*,\xc9\x83\x11\x818\x9d\xf0\x02\"a\x0f\x85pp\x8b\x0f\xd2\x06\xc7\xf7\xff|T\xc1!\x92\xe0p;\xe6\x11\x03kM:\x11\x16\xa2\x04\xceD\x06\xbc\x80\x06\x18_I\xd8V\xbe\x80\xfa\x97\xd77\x91\xd6\xa3\xa4\xbfK\xe9~\xa3\\\xb5\x01\x8a_\x12\xb9/\xce\xc1\x99F\xe8\x8b\xcbp8\xee\x16\xd3\xf7R\x07\x83B\xd9\x1b\xee7\x89\xa67\x91\xa0\xd7\xe5\xfc\xcb@\xca\x1b\xa5\xe3\x0d\x13\xf1\xc6(x\xbd\xa3\x94B\xbbK!\xdc\xc5\xa8v\x17\x92\xec\x12\xe9u\xe7\x11\xebz\xa8k)d\xba\x19it=\xadpf\xda,\xd2\\\x08\x10\xe4f\xa4\xc6\xc5Iq\xe7\xd2\xe1z\xa9o\x17\x90\xde\xa2\xc7\x90 \xb5-\xc6\xbb\x89\xd1\xd9\xe6#\xb2\x9dOa\x8b\xd0\xd5\xce\"\xaa\x0d\x92\xd2\xd2\xe9hID\xb4\xca\x8fA\xa1\xa0U\x8fF\xc9gQFV\xbcv*\xedg\x9cj6\x81d\x96H/\xebtc\x01\xa5,:\x8d\x17\x10\xc7:\xde\x16\x942v\x1eY\xac\x8f\x186/%\xec\xb2\xf9@\xa2\x81\xa5\x10\xc0\x9a\xdb\nF\xfa*O3\x18\x99k\x88\xe85|\x82\x98M\xee\x8a\x13_xi]1BW;\xca\x9b\x89\xca\xd5{\xe4\xc3\xe8[\xa9\xc4\xad$\xcaV\x1aYk\x94\xa65\x81\xa0\x95\x848\x1f\xe5\x1a\xa3\x9d\x87\x8eu\xcc\x89\xc0\"\xfd\xb4\x9683r*t\x8c8xhW\xcd\xb8\x83O\x967c\xdc\xdf0\xe3\x1fV\xd0\xc3\xfc;\x89d\xb5O\x0fZx)U\x83\x0e\x0d\xab\xf9\x99hT\xfd\x04\xaa\xf4\xa6\xa0\xee\x939t\xa9\x03-*\"\xcfG\x94\xea\xa5H\xa5\xb7\x7f.-j\x9c\x10\x95\xde\x06t\x0c\xf3\xd1\x9fz\x88O\xbd\x94\xa7\xf4\x86'\xd3\x9c\x86 N\xbd\x15\x139[\x9cq\\@d*\\\xc1\x13q\xd3M\xd3Ka:\x8b\x99(\x9c\xd1K\xed\xe8B\x92R\x0b\xa1\x1a\xa6'\xf5\x11\x93Z-\x9dOI:C\xb3\xc6 H\xe3\xcbn.\xe9(\\a\xde\xdfD\xbaQo\x9f!\x8a\x91\xf5\x13L\x06\x973\x90\x06\x05fQ\x89\nVH\x8f\xb4\x10Wd\x98>4Sw\xb2\x91\x85\x8e+&\x9d&\x94D\x10\x9a\xb1\xc3it\xa0\xa1\xc4P\xab\xdfT\"\xd0 \x05h\xb0\x9bq\xb4\x835\x08sX=1\xf6\xce(o\xe7L3x K\xa7\xf8\xebD\x1e\x06\x98\xf5\xb7`)''L\xb2 f\xb3o\x0el\x9b\x860\x9cw3#\xe3\xa6\xcb\xb5\x99\x8fe\xd3\xd0\xb2d\x04Nz\xa1\x93$\xf0dB\x9f\xc3l'\xd3\xc3L.\x08% DI\xe8\x05\xed\xbb\xe4\x85R\x92\xc1\x94K81`\xda\xb9\x0c\x90J\xcap\xe5\x83UF\x81\x95\x93\xe6\xcc\x83V\x86\xfb\xb4\x14^i \xbbr\xd9\xae\xe6\xa0-O \x91\x13H$\x1bH\xc4\x9a6\x1e\xa8H\xc8\xa0K\xc4\x8c`\xa2\xe6\xe0z\xd3\x0d\xcaaq\x1d\xd9\x8e\x0c\x03M\x16\x19c3\xe1&^9\xff+\n8\x89AN\x82\xa6W\xc8\xf0\xea\xbd\xc0\x93\xe8\xb6\x16\x1b%\xc8\x0f?\x89\x01PrCP2\x83P\"0\x94\xc5@\x94\xbcP\x14\n\x18e\x01\x1c%/ E\xce\xd6\x08$%/(\x85\x00K\xc9\x0eL\x89@S\xe6\x81SPAA\xc0J\x16\xc8\n\x11\xb4\x82\xbe\x99\x04dY\x0ce\xc9\x0df\xf1\xc3Y2\x03Z\x8e\x01i\xc9\x0cj\xa1\xc2Z2\x03[\xc2\xd0\x96\xec\xe0\x16?\xbcE*.\x12\xc0e>\xc4\x05\x15&`/\x1e\x90\xcb\"\x98\x8b\x17\xe8\x125)\x82`\x17\x9a\xc5\x91\x0f\xf0\x12\x86\xbc\xc4[\x93\x15\xf6\x12\x06\xbed\x83\xbe,\x05\xbf8\xe2\x84E\x83\x1a\x0fy\x010j\x19!\x1dZ\n\x82! ?\x82@\x18\"\x14\xc6\x9bO\x9f\x08\x87\xf1\xcbA\x92\x8c\x17\x83bR\x06\x87\x02\x8c\x89\x8f\x02 \x1c\x93\x0c\x8f\xc1S\xb03@d\x08 \x99\x18L&\x0e\x94 \x8eZ\nX\x86\x06\x97\xc1\x013\x8b!3d\xd0\xcc\\\xd8\x8c\x7f\x98H\xd0\x99\xac\xe0\x99@[\x90\x99\xb8\x08B\xe3HC 5YA5>X\xcdB`\x8d\xdbd\x17h\x93\x1fj\x13\x01\xdb\xe0p\x1b\x1cp\x93\x13r\x93\x19ts\x0c\xd8M\n\xf0\x86\x08\xbdI\x02\xdf\xd0\xe17\x1e\x00\x8e\x0frA\x07]\xc4A8I0\x1c2\x10\x07\xedPn0N^8\x8e\x07\x90\x93\x1b\x92\x93\x1b\x94\xb3|\x8e\x90\x8094h\x8e\x0d\xce\xc1\xe19\xfa\x0c\x86\x81p\xc2\x10\x9d\xf8\x89'3L'\x00\xd4\xc1\xa1:\x93\x16\xe6\x02\xeb\x04\x8f\xad\x18`\x87\x0e\xd9!\x82v\xa8\xb0\x1d\x02p\x07R\xa0;8x\x87\x1e;\xc9\x03\xe0\x81\x08\x84\x87\xde\x9e`J\xd0r \x0fx\xa0\xa8\xb8\xa6\xf5B|\x02 \x9f\xb4\x9e\xcc\x05\xfaP\xa0>i-\xf1\x8ci>\xc0\x8f\x17\xf2\x03~\xd0OZ\x17\x92\x81?1\xe8O\xb0\xfaPzZld3C\x80\x12@@a\x18\x10\xa9\xc3\xbe\xdc4z\xa7\x17\xc2\x81\x92\x00A~H\x90\x9bG7\x13\x144[?\xc7\xa1A\xf1Q\xc5\xe4,\x83\x07%\x03\x84\"\xb9\xa2\xb1l\xd1\x10L(\xaa\x00\x808D\x90\x1d,\x14\x86\x0b\xc5\x00CY;\x96\x0d6\xb4\x0c8D\x84\x0ee\xefz2\x80\xc8+\xcd>[\x90!D\x11\x10Q\xb4\xc31\xcd\n\xc4\x01\x99\x830\xc2\x15\x8a\x8b:\"\xe0\x8e\x16\xd9\xeeK\xd0G\x8e0\xf5\x94\x8b?\n\xb7#7\x06)3\n\xc9\x87C\xca\x8aD\xc2\xb0H9\xd1H\xe0\xc5#\xe5E$y0I\xd9QI(.)?2\x89\x80M\x82\xe9\xec\x1e\xb33\x8d\xc8uU\x89\x9e\xfer`-\x175>\xa3\x85\x9c\xf2\xa0Oy\xd0\x99\xf2\xa0\xa7\x0d\xf5\xa4\x1b\x93qs\"\xabY\xc9\x8a\xc1\xe7\xcc;\x01\xe5\x90;\x93\xcf{;\x11\x96h\x8c~\xa8\xc9\xf1s\x0e \xcd\x05\xa0\x8d\xf0\xb0\xae\xdd\xcci\x8851Pi\xae\x1f\xd5\xbe\xdcWf\xf8\xea\x94fC\x9az\xdfm\xea\xb6\xeb36\xd5\x90\x16i*~E\xb9n\xf9\xb4\xbd\x0e6\xae?B\xb2z\x04\xfdF8a\xcfq)$]\xf6\xed^\xe9\xed\xc8C\x80n\x11\x88\x1b\xa1cs]\x07\x99.\xec\xf6\x81\xb0\"\xa8\xb7\x05Vm\xea\xf5\xdb\xe1\xf6\xa3\x97n\xfb\xaf\xda^\xd0\xee\xe4\xcb\xb4'Wf;\x02\x03Wh\x87\xda2\xe7\xba\xec\x01\xe1fIr\xd1nV\xbdS\x9c\x9b%\xdc\xc2\xb7\xe1\xcd\xb5\xees\xb6\x02\xecU\xd9\xf5\x12\xd3\xb6/\xda\xbe\xe4&_k\xe1\xda\xc6\xaa\x86\xcfd\x81\xdaDP\xcdz[\xe9g\xcb\x0b6\x11?|\"\xdbqC\xd8,\xc50\x93wL\xaf\xb2C'\x1f\xae\xe0l7\xdc2=f\xeb-\xaf\xc6\n\xb6\xce\xd5RSG\xe1\x0ce\x84(\x1f\xaf\xda\x89\xef\x9b\x8b\xf4\xcaT\x8f`\x1a$\xde\x04k\xa5.\xd5\x17pe\xda\xc9\xae\xa6\xb0j^\xa4\x14,E@]\x0e\xc9\xc08\xb3\x19k6\xae(\xf4u\\\x04\xc4L\x89\xe8\xd1!\x95\x98l\xe1\xd2\x9bHs\x0c\x88\xa0\xf9\x10\xed\x0c\x81\x80,\xdb\xc2\x84\x98M\xe0mmx\x80\x17\xad\xda\x89,\xc4\x16\xf0Y\x023[\xbbtMO\xc4y-\x00\x7f+\x16-tC\xcet\xef\x8f+\xdc\xf8&o\xe9\x05pnC,\x90\xc6\x1b\xd7\"*\x81\xe5\xe05\x1a\x1d4\x8b\xafB\x1cT\x90q\x0b\"A\xd1-\xd2q\xb3\xb4\xdb`\x04-\xb9?\xce\x112\xf3\xd4\x0d\xf1\x937\xbdQ\xceZ\x9a\x7f\n\x9f\x08\xf2\x9dl!~\x1a\x87\x1c\xcd_z2\x87H\x1fN\x97\xfc\xcf\xdc\x82Qq\xaeElT\x15'\xac!vxi\xd8j\xde\xbe\x1d\x11\xe5v\x98\xc0m\x13\xe90\xa53\xa9{<*$d\xad\x8f\xc5\x7f\xf2\x87<}\x99k\x01\xf8\xa7\xb6\x0c^\xf8<\x01@hW.\x9b@\x16\x9c\x03g\xa6g\xc0y\xd5k\xcc\xa4y\x08\x0c!\xa6\xaf\xc0\xa5\xbeY\xe6)0\x049\xc9\x1e_\xc4q\x1a:4\x05\x05\x86\x84\xc2I\xb7\xcfQu'\xdd\x8e\x94\x93n\xff\xaf\xaf\xdb\xd3|\xfcI\xbe\xe9\xa4\xd3\xa0%jra\xbe\xf5[\x86\x93\xa1-\xcf:%\xca2\xb91?~\xfa\xa5vu\xd23={\xd4v29\xfc.\xe8\xe1\x8c\xb3/\xc2\x9aE>\xfa\x06N\xaeq\xc7i\xae\x13\xebx(\x9b\xd1\x08\xe7eZ#\xfe1\x86\xc1\x17\x88\xa8\xce# \xfd\x07FI3\xd1~\xfecB\x9fi\xf4\x9e\x04\x1a\xcd\x85\xcd_H\xe3\x19\x1a\x8a\xd9\xd4\x9dY\xc2\x98q\xbaN\xeb\xf5!Kj)E\xa7:\x9bHa\xe9|\x9ct\x95\xfd+\x8bV\xceQ\x1b_$H\x99\xac\x1e\x16\x04'\xad\x150[\x0d\x18\xcb\xce\x10\xe76tF\x03g/w\xbc\x9b\xd9\x968!49\xe4\xc2\x91\xe7\xbc\x9f;3>P\xd6\x97\x9c\xc9\x949a\xc64\x04z82\xfd\xec\x98\xa8\xd9\x80\x1b\x0d=\xca\x85\xe9\xdd\x0f\xc2\x9bYF\xe6K?\xe7e>\xb6\xcbl<\x97^\x86\xcb~>\xb7e.V\xcb0\x9f\xe5,&\xcb\xd9\x1c\x96\xa2\xbf\xd3\x93\xb1\x97\xbdr6o%\n\xdd\xf10V.\xe1\xaa\x14\xbc\x94\xd3\xde t*s\xf8)\xfd\\\x94\x0bY(I\xfc\x93t\xae\xc9\x05,\x93\x0b\xf8%\x11\x85\x91\x91E2/\x7fd6\xe6\xc88gd6\xb6H\x1fO\xe4\x12\x86H\x94\x0d\xb2\xa7\xf0@\xcee\x80\xf4\xb2=\xce\xe4yD\x18\x1e\xbd\x1b\xa5\x17g\x11\xdeAg29\x8e\xac\x8d\xd8\xf8\xfe&^\xf72\xdeF\xc9\xd3h\x88s\x19\x1b3p5.ci\x9c\xcc\xf2\xe9f\xb8\x90\x99Q\x0d\xb4)q \x07c\x90`\xd0\xc3\xbb\x18e\\t\xc9\xd7\xe8,\x8b\xee\xbb\x7f\xc7\xfa:\x8bS\x91\xd2\xd9\x18\x8f\xa2\xbfoQ\xee\xc4\x04\xd6D\x9b`j!Sb\x90#\xd1\xcf\x8e\x18\xe2EDG\x81\xca\x85\x18cA\x9c\xf2\x1f.`>$p\x1e\xa6\xb3\x1d\"\xdc\x821\x86\xc3L\xdc\x86H\xcd\xd6LY\xc4d8e.\\\xc2Y\x88p\x14.b'\x9c\xb2\x11\xe6\xe4!\xf42\x10Ni\xd9\xa6\xac\x83y\xf8\x06\xb31\x0d\xe6\xe5\x18\xa4\xb1\x0bFy\x05\xd5)9\xc6(\xa8\x1e\x0br :\xa4{nmTV\xb80s \x913\x90\xc0\x16h59'C\xe0\"n@\x97\x0b0\x1f\x0b`>\xfe\xbf\xf9_7\xca\xf9\x17c\xfb\xd3\xea{\xca\xf0'm\xf0){\x9f\x8f\xd5\xcfo\x03gd\xf2C9\xfc\xa6\xec}VKr\xf0\xf6\xa1\x87\x91)W\x1f\x85\xa5/\xca\xcf\x17g\xe6\x0br\xf2\x11\xd9\xf8\xa6<|h\xff\xacQ\\\xce\xbd7\x06\x9d\xa7\xac{\xf1\xda\xad\xd94\x154z\x81\xd38\xf6\x069\xdd\xd8\xc4\xb1N\xbc!\xc6?,\xe7\xb3\xf9\xf7(\xa3^Ow\"\xa3\xfcy\xde\xa3\xb1\xd5\xd4\x0c\x9cy8[\x1e\xadz\x17z2\x9b\x1b\x0f&\xf9#\x80\xb2\xe2\xa1|x\xb4\xb6\xce\xe1\xc0\x0b\xb3\xdf\xd1\xea\x9dIm\x87\xd1\xd8\xa1\x04v\xb4V$\x91\xd6\xf9\xe9\xea\xd0\xca\x08\x01Lk\xa2d\xa4\xa5\x9b\xee,(!\x9d\x8f\x8a.\xd8\x99H\xe0\xd3\xd3\xa1>\x91rn\xec\x80!.H6\x87\xd1\xccMC\xb23\x08\xe6\x12\xd4U\x98N.\xac\x1f\x16P\xc8 \xb7\xe3D\x1c\x8d<\x0e\xed\x1b\x04\x93yqZ1\xefR\x83h\xc7!+1\x9c\x8f!\xccO\x06\xb7\xb0\xe9\xe9\xd4o\xe8\xcc\xd6%\x8d\xf4-J\xf7\x96\xa1s\xc9\xe4n\x88\xdb\x1flb;\n\xad\x9b\x97\xd0\xcd\xdb\xa5\x04\xa0\xea\x1c\x9e\xb6)'[\x90\x8d-\xd1\xa6[\xc2\xbd&\xfe\xfa\x1b\xb3\xa3v\xf6/^kN\xa6\xb5\xe5\x1ck:\x0e\xa7\x04\x8eA\xeb\xa5\xbcj\x13.\xb5\x85,j\xa3\xd1\xaf\xe4\x8d\xfci\x8b\x99\xd3\x14[\x94\x127r\xa6edK\x9b\xf0\xa4\xe5dH\x8bp\xa3\xa9\\\x1a\xde\xf8Uq\xb5)\x87l\x9a\x97\xdf\xbe:\xffI\xfa\x0b~ln\xc8)5\xbb\xeef]\xd6[v?]qe\xdd\xb3\x1b6*V\xcc\x00\xabtE\x80/Tv\xc7\xea\xfe\xc8 \xb5\xe2q\xeb/\x01\xc5V\xf4}[^\x1d\x10~Z\xaci\xb2\xa0\xc8\xcc\xc0\x86\x0fQ\x96X\xe4\x9a\\Y\x82{L\xe0\xfa\xba\xc5\xbb\xd3K=.\xe6\xc1a\x18,\xf8\xdc\x16\xfb=Wa\xb7L%c~b\x0fB)\x89&!\x02\x8b)\xeb\xa2,\xb2\x81\x1d\x94u\xd7\xb3b+\x08\xdd\x8a\xcf\"\x02\xeb\xbfr}\xc2w\xf7A\xc8x\xc3\xa7\xd6\xd0ZV\x83\xfc\x83\xceH\xb3\x1a\xac\x89\x02\xc7\xafo \xd49H\x9f\xd8\xc33\xe9u\xde\x17e\xdbI\xd7 \xd7U\xb4V\xfb\xdb,\x9af\x12\x17BW\x95\x1b\xb1\xc1\x9b\xadV5~\xe6Mf\xbb\xb2\x17\xda\xe7 \xdc\xbb]c\xed\xc1\xec\x9em\x0e\xb1}\xc9V\x08\xc6\xe6\xd4\xf5\xeda#N\xc6\xaaE\xc2\xb0\xadA\xa8\x01n\x1e\xde\x8bw'7\xfeU\xcdMX\xff\xe8\xc1%\xab\x1e$\x1f\xce\x9a\xc0\x93\xe9\xee<\x81\x0f\xf8\xb2\xa9l0|\xc6\xbe\xbaw$\xbe/\xba\xf3\xfa\xba!\x8f\xc3M\xd1\xad?\x17u\xef:L=\xc7\xc6C\xe0\x10\xfc}\xd1\xfdQ\xc8\xd2V\x8f6.\x0fu\xd9\x8bp\xf8\xe7\xa6\xfd\x04\x9fU\"\x8f\xdcm\xfb{\x11\x97g-\xafae4\x8b\x1f\x87\xf24\xea\xe7nl\xd2\xb8\xd9\xdep\xa3u\xd3\xcb\xc4\xb4MS\xab|(L\x00\x1f\xd2\xd1j\xbe\x1f\xd7\x80\x10\xa2\x12\xce\x82\xdf\xe5\xbd\xb0\x8c\xc8\x9fe[\xf4\x05\xb1\xefV\x06\x89_\xdb\xbe.\xfaB\xe4}\xd5\x0fB:\xb4\xac?\xb4\xb5vQko\xbfp4\xd4\xdb\x8a\xb5\xc6B\x87\xf3\x1e~\xfa\xf9\xc3\xa5!\xceN\x9a\xa9X}\xd3\xdf\xc2\xbee\xd7\xe5\xbd\xccD\x15\xa9\xe8\x02s\xc4\xf8q\x9c/ ^\xab\xacL\x9a\x19\x0c\xb9\xd7s\xa8tPn\xb1}~\xd2i\xaenlTps\x03e-G\x8b\x7f\xb1xw\x95\xe0\x93\x01\x91\xd5\x80\x08\xe4<\xc92\xd7\xc2\x80\xb8\xe8\x89\x91i\x16)\x1a\xbf\xdbI\x16_\xa4H\x97\xb8\x85#6\xdaqo(\xbb\x11\xc6\xf1\x89=|5\xee\xfb\xfc \xdd5\x9b\xb2\x18O\x18X\x9b\xc4\xcc\xf4\x9a,\x93&\xc8]^(\xdc\x0e\x8a1\xa3\x12\xb6\xec\x8eU\xfcK\x0b\xffS\xd1\xf7\xc5\xe6\xd6\x0cG\x1b\x8b\xc6\x9e\xb3\x93\x84\x0d\x8da\xfc\x96\xdd\x94\xf5\xb7U\xb3\xf9t6\xfc\xedM\xbd\x9d\xfc\xe5\xd5-\xdb|\xba\xbc\xe7\xbb\x1e*\xe55\xab\xca;\xd6^\xdeO\x12b~,z\xc6\x0fdmQw\x85\xca\xbf\xda\x15\x0f\xfcx\xa39\x98\x0f\x9d\x00\x86\xdc\xb2\x8e\xa9\xc5\xeb1\x90~\x97\xd5@2di}f\xfc\xc9\xafa\xac&\xc9\xfd\xc1\x80\x97\xc8s\xaf\x1e\x95\xef\xc4\x97\x10\xa6\xc2d \x83\xbb\x8ea\xae\x92\xb7\x1e[%!+\x0fSC\xc7\xd0\x8d\x88\xa2\xf1\xea\x01Twx\x9e\x0e\xd9\xf7\xd9\x0c8Ybf\x9c\xaf1\x19\x8f\x19\x8b\x0f\x18\xde\xc9uy\x9fLu\xb5 \xda\xa28\xb0/o\x19\\q\x8d\xa2d\xe9I{\x7f[t\xb7)v\x02\x17d(\x13\xe0\xef\x8f!\x88-\xeb\xf6E\x14\x0c\xa5\xda\xf4\xb6\xd8\xc9\xc7\x87\xa0\xc7\xabf\xcb\x0cYS1\x14\xf7\x86\xab\x1f$P\x9c\xcb\xd3\xed$X\x89\x96\x90\xc7J\xcb\x88o{\xa6\x93\xff\x1e\xab\x87\xdb\xe2\xf3:\xd1\xd8\xb2V\x0f\x1f\xd1\xe6\xd0\xef\x0f\x03*\xc6\xd8m\x1ew\xdc\x10\xbba-<\xe1\xb3K\n}\xba\x82\x9f\x84\n7\xa4\xd4M\xfd\xd5\x96\xf5\xac\xdd\x95u\xd9\xf5\xe5\xc6\xb0\x03\x8f\xacp\x10w\x94)g\xfa\xd5d\xf1#\xa3\xad\xb14\x05!\xfakjk\x9a\x8f\x7f\x19\xb3\x0e\xb3D\x8d_\xfc\xc6\x97\xdf*5_\xc7:!\x8b\xa7+\xb2\x04;$K\xb8[\xb2xmVY\xa2\xe6%\x84\xcdSY\x08R\xe2\xa6\xa2,s\xb7\xa1p\xe3}\x8e1Yb\xfb\x80]\xe2=\x99\xbd\x87\x05\xe7\x18\xd6\xfe\xc5[\x9cYb\x1d\x9bo.\xbach\xf8\xd7\x9c\x1f\x9d\xe3(D\x1a\xb7\xd4\xe5f \xd3\xe7c\xe5x\x8b\xd5NU\xfd|\x89l\x93\xb4~98\xb3\x80\xb4#\xbdD\xcf/\xbaF\x7f=\xc9~\xb0\xc0^\xfd\xd2r1\xb5\xf26\x10\x0d|\x1aM\x8e\x99\xbe.r\xc5\xda\xa5%\xa2Gn\xb5\xbd\x13u!%G\xf4'@\xf0 \x10|\x02\x04\x9f\x00\xc1'@\xf0PN\x80\xe0\x13 \xf8\x04\x08>\x01\x82O\x80\xe0\xc0\xbb'@\xf0 \x10|\x02\x04\x8br\x02\x04\xabr\x02\x04\x9f\x00\xc1\x0b \xa3'@\xf0 \x10L\x00\x04\xf7\xe5\x8eu}\xb1\xdb\xa78\x12m\xfff9\xba`\xf6-\xbb+\x9bC'\xc3\x90+\xf8\x8e\x9f E,\xb2\x83\xdf\xc1\xd7gP\xf6\x8f\xe5\xb0\x7f\x16\x7f\x15Sd[Z\x89\x1c\xf6]\xdab%\xeb6\xda\xd4\x7fp\xd7\xf4\x835\xaaj\xfc\xb1\xe8\xfaW\xcdnW\xf6f\xe5\x96\x82\x83\xaf\xcf,5\xcb[\xc4\xad\xd1\xae\xecDMH\xecy\xe8\xef\x18\xd6\x8d\xf9\x90\x87\xab\xe0\xfa{\x99\xdc\xc5\xe7\xfb\x94X\xf5rt\xa1\xf4\xc5Mg\xf8\xe3\xe5V\xa1w\x1a\x91\xa6\xd5\xc99\xbae\x82\xd0\xd0\x88>o\xda\x87}\xdf\xacD\xe2XW\x8e4\x8e\xaf\xf8\xf9z\xd3\x7f[\xf6/\xdb\xb6\xa0\x13\x98\xb2\xfb\xbe-\xd6We\xdf\xad\x05\x1d\xab\xe3|\xa5\x84hYeE\xae\xd09\xe5\x1c\xeb\xf0\xf8\xe9\xa4\x1f2Qoz\xd8\x94l\xb1\"\xd0<\xdc\x8b\x0dWe/\x83k\xe3\x80\x97\x02bpP\x97o\xb3\xba;\xb4l\xf0\x9a\x0dl\x91\xe2\x8b\xf5\xc5'\xd6 \xb7\x94\xc4\xa1\x98\xd8\x10%OV(\xf7q\xb1*\xa5\x04\x03\xb1\xa7k\xe4\x07\xfa\xfe\xb6e\xc5\x16\xba\xe2Z\x9f\xf5\xe5\xdf\xf9x\n\xc0\x81@\xb45\xb5\xf2,\xc0A\x1e\xdb\x86\x0f\xdd\xdf\xaf\xba\xf2\xa66\xa9:?\x947\xf5OC\x14\xdd\x19e\x13\xc0\xfe\x15|8\xff\xfe\xed\xfa\xa7w\xaf\xdf xq\xf3\xd7\xd7\xe7\xef\xdf\xbc\xbaD~\xb8|\xf3\xff^\xfe\xfc\xf2G\xe4\x97\x1f\xdf|\xff\xf2\xd5\x9f\xd6/\x7f:\x7f\xfbn-4\xb9\xfc\x9e\n\xab\xee\xaf\xd9\x93\xe3\xa1\xba5\xea{\x99\x16&:\x0f;\xfe\x8b\xf48\xf4\x1d\xf0\xcdd\xc0\xcd\xde\x1c\x8a\xb6\xa8{\xc6\xba\xd1\xbe\xf6t\xdc\xd3\xaa\xe1\xf4\xaf(U\xe5neU\xcd?\x9d\xdayT\x1d-\xe3\xebit\x18\xb8\xa3\xf9\xdc\xf9\x8bY\xd1\xa4kb\x8b\x12\x06\x15\x1f\x88\xd7\xcdF\xcd\x16%\xfe\x8e\xb5R?H~W\x1d\xad\x93\xd9\x9b\x97\xf7X#\xd4\x97{\xee\xfeIf\xdcI\x0c\x91\xdd\x0c\x19\xa4\xe3\xfd\x14\x15>\x98\xc9\xee\x13\xa0y\xcf\xee\xfbCQ9\x86\x1e\xdfF\xf7Zi+\xb7\x9f\xfd\x8c\x92'\x9a\xee\x99\x81\xe1\x89\xf6<\xf4\xa3\xec\xdcU\xb1\xf9\xf4\xb9h\xb7\xdd\xc4\xe58\x19lU\xdd\xcb]Y7R\xd7\x1a\x1f\x1aZ\xb6k\xeed\xfa\xae\xb4\xea\x05\xe8\xca\\\x9bC\xc2\xfd\xa1\xbfM\xca3\xe7\xa3\xce\xdauY_7\xa9Y\x1c\xff\xff\x96]?\x87\xc7\xff\xbfg\x86\xc3\xfb\x99\xdb\xa4\x0f\xa2\x06\xde\xa8\xc7\xc3\xcb\xfe\x1d\xddl\x8f\x85\x874\xa7\xc7\xc8\x7f\xd0\xb2_\x0ee\xcb\xb6\xea\xbdN\xf8z\x0dq\n\xf5e\xfc\x85\x8f\xab\xcc\x81n\xae\xc5N!\x16\xb8\xf0\x99\xef\x8a~\xb8\x9c\xc6\x16\xab\xa7\xf7\xb7\xcd\xf6\xe1qg\x1f\xbb\x84\xf1%+\x96v\xb8\x96\xaa\x93\x06\xf7m\xb9\x13\xee7!k\xd8X\x9b\x9a9\xf1\x8d}\xf1\xd0M-\x90k68\xfe\xae\x99\xe1\xb5\xf4\x8f\xe1wl\x80]^3\xa92n\x8a\x0e\xaarW\xf6\xc3\xc8\x99\x91G\xa3\xed\xaa\x91\x16\xd6}\x12m\x89\xf5G\xf4bh\xba\x94\xcd\x98\xc2\xbc\x19rF\xf4\x9b)\xddB\xe0m\x1ays\x14\xe3\x16\xa5\xc4\x10\x8a\xd5\xdclev\xdf\xb6\x11\x81z\xcd\xea`\x88\x91zJ\x86$L\xf1\xdaE9N\x97\xb2\xd3p<\xd6\xf5\xe5N\xf8\x05\xefJ\xae\x16w\n\xe8\xb8\x9a\xac\x0bR+\x02?\xfd\xbdn\xcf\x13\xa9#\x0f\x9d\x0ci\x8a\xbfnUxON\xe4\xe9`\xeb}\xfc\xa9SS\xc7z\xa5\x07\x87\xb7\xb7\x0d\xeb\xe0\xb7u\xd3\xffVE\x14\xa5>\xe6\x9b\x9c@]_\x0f\xf3y*K\xefn\xc8\x9e`\xceSa\xd6R\xbf\x9ao*\x96\xd7\xe3\x10\xf3\xfd@\x0e\xd7\x13V\x0el]\xd67\x1ciJ\x0e\x9e\xcc\x12)@\x0c\xc1S\x9d\xcd\xa3\x93\xcbD\x0d\xa2\xdd\x03\x81\xc7\xf4\x8b5\xe2\x8b\xf2\xafi\xe6\x9fY\xad{,-|u\x9d\x02\x9f3.\xee\xa3\xd8sm\xdc\x96E\xcf\x8cJ\xc5'\xe1\xe7+v/.?\x94\x9d\xd9\xdc\x16\\#6n\xba\x1c\x7fT\x07\xbf\x06)\xdd\x99\xfc\xca\xc2\x0c\xbc.\xcaJ\xbc\x84\x9fZ\xf4\x84\x99\x84\xe5\xf4\xfe\xaf\x06U\x1aOC\xfe\x9d>\x8a\xf2_\x87\x04\x88\xc9$p\x0d\xbao\xdb\xa6\xd8n\x8a\xae'\x1f\xfe\xbe}\xff\xee\xe5\xebW/?\\\xfaO\x80\x93G\xbe\xfd\xf1\xdd\xab\xff\xe3\xfb\xf1\xc3\x9f\xde\xbe\xf2\xfd\xf6r\xf8q$+\x0b\xd7\x8ek\x19\xab\x93\xc6qI\x98\x1f\xfa7i\xc5\xeb\xd5sy\xff\x81\xb5w\xe5\x86\x8d#\x04\xef/tK\xe5\xaec\x9e\x0c\xfd\xedz\x0e\x7fem\xa3\xf0G\xc2\xc5\xc7\xeb\xd1\x0b\xda+A\x0c\x9a\xd3_\xf1Ws\x1b\xbe\x1f;`\x1c\xfbt\xc6\xaa\xbch\x0c>\x17\xfc|;\xde\xad&\xd4\xc3\xbd\xda\xd0\x04}\x87@\xda\xc8K\xcd\x84\xfb\xcb\xdb,\xfeE\x9cV\xf1?.nT\x01\x1a\xb54\x02?\xf5\xd5h\"\x10\xe2o\xd4K\xb4U/g5K\"6\x07v\x8d\x9dp+\xf6LV\x1fX?\x97\xf7\xef\xa5\xd6\"\x9f\xd6\xfa\xfb\xb58n\xa7:\xb7`:\xcf\xb5 m\x16\xf0\x83<\xa2\xfdw\x08HbR\x17\xc2S\x18[\xed\xe8c\xe6\x8aG\x1f0V=\xfa\xfbK\xeb\x01\xea\xea\x87\xa0\x9d\x91G\x0b\x18\x02\xdf_\xbcr4\x01\xda\x9bdm\x80J9\xa6F\x80$\xad\x806\xefx\x9a\x01\x92\xb4\x03\xda\xb8\xe3i\x08p\xb5\x84o[wu\xc5\xb0b\xd5?ExKO>g\xea\x0d\xaf)y\xe6\xfc\x8b\xea\xa6D\x10Y\x7f\xbfn\xadw\xd0\xf7\xf0w\x01\x01\xa1\x01\xe5,\xe4=\ny\x00i\xe2\x89 (\x0d\xc8\x87\x90\x108\x0dp\x80ZP8\x05\xa8\x06\x0eXm\x14\x89A\x9f\xfc#\x13\x07\xae\x89\xa7,\xf0\x1a\x90\xc7&\x0cb\x03\x0c\xc8F\x17\xfe\xb7\xe9i\x82\x8al\x08\x83\xda \x04q\x00\x07\xdc\x06_\xc8\x87\xe3\x05\xbcA\xf0\xcb\xcb\xe2\xff\xfe\x80\x83\xdf \xec\xe5\xf1\x81\xe0 0\x18\xb2\x04\x10d\x81\x81\x91%\x8e\x1e\x13\"<\xbfE:$K\x0c \x07\xd1\x0e\xca\x12\x04\xca\x01\xa5\xb3\xb2\xc4\xbb,K\x044\x07\xb4\xde\xcb\x12\x05\xcf\x01]Z\xcc\x1dh\x969@\xba\xa0@\x1b\xeb\x1d|Tv\x84\x86:\x93\x85\xd6\xb3\x9c\xc0:\x88\x82\xeb`>\xc0\xce#\xcd;\x00\x94\xeeg\x84\xdf\xf1\x12\x84\xe0\x81\x0f\x86\x07\x84\xc6f\x85\xe3\x81\x0f\x92\x07\xd1\x96P7\xb0\xde\x07\xcd\x83\xd8\xdeeC\xf4\x80\xbc\xd7\xce\x85\xea\x81\x07\xae\x17\xac\x99h\xad$B\xf7\x00\x85\xefA\xf6\x86D\xa0|\xa2\xc2{\xac\x01\xc8f\xe0W\xff=\n\xed\x83\x98f\x8e\xad\x84\xac0?\x08B\xfd +\xdc\x0frB\xfe \x04\xfb\x03X\x04\xfd\x83\x8c\xf0?\x88B\x00a.\x0c\x10\x96@\x01\xb1\x11{\xf8\xff\xd8\xfb\x9a\xe6\xb8q$\xed{\xff\x8a\x8c\xbex\xde\x08[\x8ewn\xeb\x9b\xbf\xd6\xeb\x98\xfeZK=\xb3s\xd2P,Hb\xa8\x8a\xac&A[\x9a\x88\xfe\xef\x1bD\x12$H$>H\xa4z6&\x80\x8b\xad\xaab\x12\x00A \xf1 \x13\"\x832\x81\x9c\x9d\xc9\xf0=\xd8\x10\xc2\xe7\x0f\xd0\x84\xf8 M\x88\x0b\xd4\x04\xaa\x19\x9c\x01\x9b\x90\x1a\xb4\xb9\xb2e\x85p\x02k\x18'\xb0\x86rB\xf2x\x08\x86tBDX'\x18\xa1\x9d\x00dx'D\x83\xd06^\x9e\x14\xeai\xcd\xe1\x87\xaa\xa8W\xe1\x9e\x00\xa9!\x9f+c\xe3\x11\x82V\xd8'\xb8C?\xc1\xdb\x0fi!\xa0\x86\xa1)\x18\xd4\x0c\x03\x1d\xca\x9eP\xd0(\xed\xcaX\xedI\xbc2\xfe-\x0d\xf5\xcax\x19\xa1a\xf1JV\xfeS\xc4KT\xd6a\x0e\x92\xa0wS\xb3\xd5\x92\x01\x18\xceAO\x07^8~\xee\x93D\xec\x0e\xb60\x8d\xa4\xc4Y\xe8\xb8\n\xd3^|HEb8\x05\x11JA\xf6\xa1#\x84\x82\xd2\xac3\x85N\xd0a\x13\xb1!\x13\xabp \xb2M\xee\xf9\"9DB)\xf6\xcdWaGx\x84d\x0c\x8d\xa0\xc3\"\x92B\"t\x10\x84a\xcf\x13\x0ea\x85B\x90O\x84\x1aN\xac\xe1\x0f\xfbC\x1fv\x87=\x98\x81\x0ef_\xed\ny\xd8\x1b\xee0\xf5\xa8\nq\xac\xcbc\x7f\x10\xf4T\xa1&\x89\xaa\xc6\x86\xea\x05l|\x83\xbf\x9b'\x0d\xe3\x84\xd7\xf10?;0R9E\xa0\xf6[j\x1e\x14\xb7\xb7\xa2\x94\xd5\x84\x83~\x7fWt\xe7\xb6*\xc5\xf7\xd3*\x8f\xd3\xe44\xde1\xb3[s\x12p\xaaNU\xdd\x9f\xc6\xdbjNn\xe6\xd5N\xe2tn\x9a#\xbd\xd2}\x12\xfbd\x99\xf3h\x8d\x0c\xd9\xbdzt\x84\xea\xcaG=\x19\xea\xb3=\xc8\x04\xb6Y\x07\x9au\xa0Y\x07j\xfd8\xeb@\x1d\x17f\x1d\xa8Y\xc2M\xc6\x92u\xa0D\xc9:\xd0\xac\x03\xc5+\xb3\x0et,Y\x07\x9au\xa0Y\x07\x9au\xa0Y\x07\x9au\xa0Y\x07\nY\x07\x9au\xa0Y\x07\xba(Y\x07\x9au\xa0Y\x07\x9au\xa0Y\x07\x9au\xa0\x90u\xa0Y\x07:\x97\xac\x03\xb5J\xd6\x81f\x1dh\xd6\x81f\x1d(\x02`Y\x07\xea\xd0\x81.\xd4*^\xe1\xe7$\xf9T\x97x\xc5\x9e\xea\x17\x9db\x92v\x08a\xac\xbc\x89<\x19\xee=r\x99)\xc1\xe2\xb1\xc2L\xe6\x84n\xa6#\x843[kj5\x1f\x8b\x8bK\xa0$6^\x88\xc1'&\x08\x0bmh\xa9\x8d\xf7\x86\x9b\xe46N\xc1\x8d\xf7\x16\xb1\xa2\x1bJv\xe3\x97_\xf8z+N|C\xc9o\xe2\xfb+,\xc1q\x88p\xe2oa q\xe2\x99\xcc\xb0\x14'@hRr\x1c\x9fD\xc3!\xccp\xbc3X\xfc\"\x0c\xaf0\xc7?6\xb0\xf8\xc59NyNP\x83\xe1\x96\xe8\x845,^\xfd\x8a\xb7\xb3\xb0\xc4\xe8V\xa4W\xac\x13l\x1e\x96\x18\xc1N\xb8\xb9X\x82\xa2\x9d\xa8\xa6c\x89\xe9\x00,\x11\xd2\x9d\xc8\xbe\xc0\x12%\xdf\xd9`1\x0c\x19\x9be\xab\x88'\xdc9[d<{\x84<\xf1-\xdc%\xe6q\x0f\xffaR\x0c\xcay\xb8\x05=\x1eIOlG0\xcbz\"\x84=\x1eiOL\xa5\x13\xe4=\x0ekn\x81O\xb8>\xb1K\xa3\xf4\x89|\x82\xab\xa2-\xf4\x89_\xcfS\xc4>n\xb9\xcfn\x9f2U\xf4\xe3\x92\xfd\xd1\xd2'Z\xfc\xc4)\x7fb\x16@=\x87\x04j\x8b\x08*R\x06\xb5I\x08\x15/\x85r\x88\xa1\\\xf2\x97x\x01LX\x10\xb5I\x12\x15-\x8a\"\x1b\xc4-\x8c\xe2\x95F9\xc4Q\xdc\xf2(n\x81T\xfa\x18\x89\x12I\xc5\xc9\xa4\x96B)\xa7T*\x1e\xc6\xa7\xb8\x07N\xc1\x94G2\xc5,\x9a\xf2\xcb\xa6\xbc\xc2)\x7f\x9f\xb0\x89\xa7<\xf2\xa9\xbd\x02*\xab\xee\xa6$\xc8%%\x9a\x1b4m\xec\xcf\xc5\xdd\x98\xee\xed\x0dmw\xfe\x81\xc9\xd9\x1a\x9fj-\x8c\xbe\xfb\\?I\xf1\x164cQ\x8bGymq\xdd\xce\xb1\xec\x04\x13F\xa5\x8e\xa59\xd1\xf6u\xcf\x0c\xff\xd59\xe2\xba\xf1l\xeb_\x8a;1\x9e\x81y\x81\xdf\xaf\x8c\x0c\xdd\x88\x99\x9f\x06sC\x1f\x0885\x9d\x04\xa1\xf0&\x05P\x19\x97\xc8F\x16\xc7\x8d\x0d\xdap`\xbf2\xaf\xda\xa3\xfeS\xf7\xa7\x1b\x04>4Ji@e\xeb\x13\xec\xcd\xa6\xaa\xccl\xd7\xca\xc8\xfa\xdd\xf9Vt\x98\x8a\xac\x92\x9d\x06Z;\xe8k\x1c\x08\x07\xc4\xaa\xbeU\x1d>\x03Z\xf5C\xe8\xf0\xe2$~W\x8f\xdd\xbb'd\x93GS\xa1#I\x7fl\x0e\xe2\xf3\xc4lZ\xa3\xcf\x1ey]U\xdf\x1d\xcd\xd4S\xd8\xd5\xf8\xf1\xbc\xda\xa9\xd7\x1e?\xc3\x9ck{F\xf8\xc9N\xc8\x84wS\xe7\xc0\x8e=2\x98\x9f\xce\x86\xd5\xd8\x0eyg\xf0\x8d\xa6\xf5I\xcb\xa0N\xad\xbd\xfc\xfc\xe9'\xdfA\xcb\xeb_}\xf8\xfc\xe5\xe3\xfb+\xcf\x0f\xae>\xfe\xcf\xd5\xafo\x7f\xf0\xfc\xe2\x87\x8f\x9f\xde\xbe\xff\xfb\xf5\xdb\x1f?\xff\xf4\xf3\xb5r4\xcc_N'/\x87k\xe6_\xba.\xab\xbbZ\x9d\xbb\xbczdFg\"\xdc)1_]'\xca\xbe\xad\xe4\x1ah\xba\xeb\x0b\x95\xb4o\x95\x96P\x15G\xf79\xean\x1c\x00]\xd4\xd0\xd7\xe8z-*4\xcc\xf0\xa3\x03\xb5\xbaW+\x86\xe1d/\xa8\xf6\xb3yc}b\xdex\xd5\x01\x9a\xd0\xeaTw}hJ\x84\xbd\xd7\x14\xd1W\xd1\xe2\x12\xa4zlR\xc7\xc0m\xdb\x9c\xe0\xca\x92<\x10\xe3\xe1\x8d\xfd\x91\xe2\x8b\xe0\xb6W\xeb\xe6\xa2Z\xa8\x02\x19\xfaA\xdd\xf8 u\x1e\xcb{\xdc\xf7\xa7\xa2~\xd5\x8a\xe2\xa0f3)\x1ee_\x1c\xad]\xd2\xe0\x1f\x9e\xf5[\x83L\x88\xd5\xb3\xe6\x15\xebg\xacZ\x18\x18\xfe\xfe\xd1\xfd\xc6\xf7%\xf6\xc1MQ>|+\xdaC\xb7\"iV\xcfhu\xdb\xb7\xa7\xaan\xd0\x0b0\xc6\x0d\xb4\xe2\xd4|\x1dS\x8a\xaa\xdd\xf6\xd0\xbf\xe3\xa5\xa7\xfe(\xaby\x12\x88\x14(\xeb)\xf4\xe2\xc7\xe1\xf2\x17\xeb\x99Q\x19]\xbee5*,\xd47]ug\xceS\x8b\x97V[^\xa1\xd8\xeb\x19o\x9ai\x9b\xd6a\xda?\xf7c\xc5\xa3W\x80\x9bJ*\xdd\x9f\xb5\x06\xe8/\x8c\x17\n\x9f\xce\x83x\xea\xd4\xbb1v\xfaT\xbbb\x1e\xda{\xd6\x07\xf1(\xdb\xe2\xfa\xa6\x92\xddu'\x9b\x96\xceB\xb3%{\x9f8Zz\xc5\xa0\xfb\xb1\xf0\xa7\xdcs\xee\xfba\xe8\x96\xf2]%\xdf\xaa>\xc2\xac\xbf+2 \x1f\xa6\x92KO\xfe\xd1\xd0\xad(\xb4\\\xcc\xb0J\xc01x\x16\xa3'&\xea\xaeo\xc5D\xf8\x83\xa8\x95\xe7\x8b\xae\xb5,\x1eD\x87\\\xf9\xa9\xaa\xabSq\x1cSz\x1a\x06\x97{\x0e\xac\x04\"NjW\x86\x06\xab\xfa\x8e\xacE\xdd\x0cw\x1d\xa6\x1b\xe8\x8a[M\x0f\xe2\xe7\xc3\x03\xa8\x0f#?X6\xf5HLB\x8f\x9c\x0b\x1a\x1a\xc6\xf2uU\xdf6[\xb5\xf9\x1b_R\xeb\xf5\\\xb8\xbds-\xb4wQ6-\xba\\\x07\xfd\xc6u\xb3\x93\xa1R\xdb\xea?\xf5\xa06\xcci\xac\xa8W\x99vU>U\xeb\x05=\xf77\xc7\xaaT\xaf\xc8wF\xb5\xd4+9\xe5FV\xee\xce0\x11\x0c]XP\x17\xfb_\xf0K\xc3i\x8bx\xc3\x97~W\x92\xcfE\xbe>k_+\xecgy},\xbf\x7f\x15\xe7[E\xfaU\xee\xf7{\xaf?\xe5\xf4\xa0\xfe \xef\x89\xf2\x9c\x9e\xdfk\xda\xe01=\xb7\xb7\xc4\xe2)\xb9\xbd\xa4\xa0\x87\xf4\xc7{G\x9b=\xa3\xf5T\x89\xd3\x89kvZL\x04\x17\xf0Y\x89D&\x08hL.\xbf\xa4\xf5e\x83\xfa!\xb4\xb0\x82\xde;\xe8\xfa\xf2~\xb8\xec\xd8\x94\xc5\x98N\x9d\x18\x00\xa6\xb6e\xaa\xbc=)\xfe\xdc\x1eD\xfb\xee\xc9\x9c\x0c\x8d\xe9\xc9\x9c\x9a^\xc1\xcf_>|\xfcr\xfd\xee\xef\xc4\\`|\xf9\xf6\xf2\xbd\xfd\xe1\x87\x8f\xe3\xa7\xd3\xcc\xe24FO*\xf4\xddi3\x8e\xb7\xbfi\xe5<\xed\xaa\xf4\xec\x1706_WK\xe9\x91\xde^\xbe\xc7\xee\xab:(\x0b\x03\x8eZ6\xf2\xcd\xe2\xaf\x19\xda\xeaJ\x81\xcb\xa3\xba\x05q\xed\xd0\x17o\x96\x7fNW\x0f\x8d\xb7.\x1f\x07\x9cQW\xf5[\xb5\xcc`\xa3\xa6\x1f\xdb\x0f\xf8R\x0d\xbcM\xa0\x06\xae\xa3K0m\x83\x1f*I\xd5\xb0\xd3s\xf4o\xcc\x195\xc2nu0\x9f.\x98M\x11\xec\xd4\x02\xcb\xfd*`.\xfd\xaf_\xf9\xbbK\xf3\xbb[\xed\xab\xda\xbb\xde\xec:u\xbe\xbb\x15\xbe\xb8t\xac\xac9\xb4\xbd)\xaa^\xb5+Y\xb7\x86 \x9e\xf7(y\xdd\xaa\xddD\xbdn\x94R7^\x95\x9b\xa0\xc7MP\xe2\x12\x13\x06\xa3\xde\x96Wi\xcb\xa6\xb1\x0d\xabk\xd9t\xb5.Em\x8a\x96\x96\xd4\xcd\x12\x84\xaa=\xdf\xec\xd5\xca:u\xb1;\x15\xb1\x84\x16v\x1b\xc4\x02\xc1\x15t\xa7\xe6u\xd6\xb7R\xfd\xfb]\xf8\xdei\nWT\xb4\x1a\xe6lm+\x83\xaa5M\xcf\xba\x1a\xe5\xeb\xc50Q\xc3:v\xb4i1E\xad\xea\x95b:\x14\xaaAm\xaa-S\x8b\xd7\xa3\xda\xd7\xfeN\xb5u\x97\xfa4\xa6\xb1!\xc5\xa9\xbbmA\x95\xe9\x06}\xe9R\x8a\x93\xa8)\xf5\xaaI\xdd:R\x9f\x82\x94\xec\x85X\xd5hH/\xbaV\x8a&hD#\xd4\xa1\xdbu\xa1\x84\n3\xa4\x05eR\x81\x12w\xfe}\x894'h>\xd7\x1a\xcf\x14u'\xa1\xe6L\xd2q\xaeu\x9b\x9c\x8aM\xa7Vs-`[\xeb3y\x94\x99l\x9aL^5f\x9c\x0e3\xa8\xc0\x8c\xd4^\xc6\xa8.-y\xa2}\xb7X\xfd\x9c_c\x19\xa9\xae\x8c\xd0U.\xaa\xcc\xa9\xa5LRQ\xda\xaaI>\xbd$\x9fRr\xff\xd3\x0d\xaa#C\xbaH=}OL\xd7n\xba;\x92I\x0bp\xd7r\"\xd24e\xa8\xe9q\xc3\xd8\xac\x1f\x94\xcd\xe4\xa7\x12D\xda\x83xz\xa1\x91\x91N\xfc\xd6\x8b\xba\xb4\x0e\xc9[m3\x1c\"2\xb7\x93\xaf\xedNT\x98\xfe[o%\xf0\xd8\xce\x97\xe3\x80[\xb4~15O\xda\xb3R\xa94\xe5*m\x99>\xac\xf3\xe6 \n\xb8\xab\xbe\n5F[\xd1u\x1aRW\x87O\xce\x06\xe5\xc2E8\xb7*Y\xd1\xf0\xe2\x1c\x8b'(\xa4,\xca\x87q#F\x8b\xcef\xd8t\xf5\xc8f\x92Q=\"\xa7\xfa@6\xe7WG\xf1U\xe8xt\x9f\xf4\xe0\xb2:\xf5\xc7BjA]4P\xcby\xdc\xe2b\xbc\xceg/\x9a\xa9\xd0\x86\xe16\xd6\xd4\xf4N>\x0c\xb3Q9\xecb.\xe0R\xd4\x07E`\xc9\xc7\x91\xc3\x1a\xb3\xc6\\LU\xbeV\x9fG\x0eD\xb7\x9c@\x1b\x9a\xa4\x80\xc3M\xd7\x191\\\xcfv\xd1\xdd\xb3\x98\x10\xff\x94\x94\x96P_3\x9a\x08 \xe7[lL\x1cxWt\xab\x89h\xd1\x06\xfd\xb5\xae\xb3\x91?e\xd8\xb6\xf7Re \x99N V\xd3\x89\xaa\xc9\"I\x88U\x0f\xba.\x90r\xb8\x12\xa1C\xf5\xe3\x14\x9f\x8a\xeeo\xeaF\xb0:\x03\xb9\xaf\x15K|\x0b\xdf\x9a\xf6\x01\xbe\x8d\x90\x1ebR\xf2\xd1\x16\xd9\x9eE;T\xe2b\xd5\x8a\x1d\xe72\x85\xda\xf0\xa9\xe8~\xed\xe6\n\x17\x8bT-E)\x11\xc0\xd69[t\x85\x10yt<`\xfc\xd2\xd0\xb7\x0e\x7fM+C\xd2\xa3\xdcp\xc8\xe6N\xa8\xe9C!\x0b\x94\xf2<\xa1\xd2\xa6\x15\xb2o\x87y[\xf1\xbe\xda=P\x80j}8\x8a\xd6\xc8\xbb\x04\x9f\xd7\x14\xc8\x8f\xbf^^\x11H\xdbQ\xd4w\xf2~\x98\xd2o\xabG\x1c\xe7\x8a\xfdR\xd3\x938\x17m!\x05\xde\x1do:\xac\x88\x83\x87B\x87NO\x15X\xc0r;O\x0c\xb5:\xe4\x87\xe6n\xe9\x8e+5\xbe\xf1\xce:\xfa\xc5UI\xb3\x8eT\xfa=Ih\x84\x80\xf9\xa0Pu\x99\xf5\xa9\xa7\x8b \x98F\xcfUm,\xcf{\xa4\xa77=\x9e\xb7M\xba\x04\xf2\x12@8g\x1e\xd7m\x9e\xdf\x85\xe2\x80\xb0(\xe9\xfd\x9c\xb0\xaf2T\xf0\x0f\xe2\xe9\xd5\x9cl\xee%\x14]\xd7\x94\x95BB\x15\xa6O\x1b,j\x1c\xf5kl$T\x1dL\x1b\xa7\x96\x8d\xce\xcc\x86\x06\x87\xc1A\x1bF\x88\"I\x94[xol\xaf-C\xe6\xab+\x89@e\xbd\xdc\xbf\x13wU\xfd\xee\xd8\x94\x0f/\xa7\xcf>\xd6\x87\xd5'\xef\xefE\xf9p\xf5h\x85\xfa\x98\x96>\x88c\xf5U\xb4W\x8fDL\xf5\x0f\x85\x14\xed\xcb\xa5\x9f|\xc2\x1cj:^\xa7\x1f\xfa{\x98y:1N\x18\xcb\xbe\xf3\xf7\xdc\xfeL|c\xce\xbd\x95==\x05\xaf>&\xd7\x03\xf5\x9b\x90\xff\x16\x11\x0d\xa2\xafY\xf9q!\x07\xee\xea1\xdae\xbbi\x0e\x84\xfa\xb79L\xa1B\xe7\xb6)\x87\x96\xdf\x1cG\xa6y\x16\x01\x18\xcfn\xb6\x10\xbf\xa4\x8f\x1d\xfa/Z\x05rj\xb8\x9c\x1a\x8e\xb4\x96S\xc3AN\x0dG\xdf'Qj\xa2\x8dD\x08N\xc8+\xa3E(X\x12\xa4(X\x12\x04)\xae\x17\xddQU6\xa9\n\x16^\xc1\n\x166\xd9\n\x96\xb0x\x05\x0b\x9b\x84\x05KN\x0d\x97S\xc3!\xdc\x93S\xc3\x19%MJc\x99\x9395\\X~\x83%\x94\x14-,\xc5\xc1\x92S\xc3m\x93\xee`\xc9\xa9\xe1T I}\xb0\xe4\xd4p2A\x14\x84%\xa7\x86\xdb()\xb2\xab\x9cS\xc3q\xc8\x90\xb0\xf0\x8a\x91\xb0\xc4I\x92\xb0\x04\x85IX\"\xe5I\x8b\x1f\xe7\xd4p\xaap\xca\x99\xb0$\x89\x9a,k95\x1cwj8\xff\x0eE\x83\xceH\xe8\xe8\x0ca\xd3\xa7\x88\x05 \x90/\x0e\x08\x1c\xb6\xe2\xb7\xbej-``\xce\x19\xb0\xee\"y\xdftb\xb6\x89!\x8f\xea\xf9\x8cJ\xa1a\xa4!\xed\xdb\xdc\xaaD\x15\x8a\xa9\xb06\x12o{y\xaf\xe4Y\xd6\x01Hx\xef1\xbd\xc1`\xed\xea\xf1\x05\xca\x8c\n\xd9\xb7\xa2\xbb\x80\x8fEy?\xd5|\x92e\xa1\xea\xc8\xcezS\xa8Aj\x93Br\xca\xa26\xac]j\xdd\x1a\xde[\x95F\x0e* MY\xf6\xad\x9d.\xe8\x9d\xd2\x0d|\x15\xb5~C\xf4u\xeb\n\xfdIC\x9f\x8aJ\x9e~G?3\x0b!\xa9:h\xc5\xadh[\x04\xa4\nMXT'\xb5\xdb\x9c\xa5h\xe7\xe2 \xbf\xbb\x15kjE\x97o\xf7\xcd\xd1Z\x06\x1d\x87\xd4\x9c\xc4\xa9aa\xd8\x07CZr0o\x93\xebF\x8a\xd7esR0;\x0eH\xfd|`E\xbbX=\xff\xb7\xb7_~\xfa\xfc\xd3\xa77\xc3\xe4P\x1e\xaba\\\xbdT\xe6Q\xf9u|\x02\xf1xnT\x9e\x11\xf1(5\x1c^7\xd2\xce\xc3T\x16\xc7\xa3\x9a0O\x8d\x95U\xf0\xa6\x97\x06\x94>\xfe\xf2\x1fC\xc5\xff1\x9d\xb4\xf5\xa7NX\x99\x8c\xa4B\x9d\xb2\xbc\x1fW\xcc1\xf3\xe5\x14\xfad\x98[FP\xcdQO\xcb0\xa7\xe9`\xc1\xb2\xa9kQ\xaa\x93\xe3\xa6\x1b\x0e>Laf\xb83\x0c\x1e\xab\x87\x85\xff\xe0K\x82<8nM\xa7\xc6\x06\x91\xc4\xedj\xca,\xdc\xc9\xa2>\x14\xed\xe8\x16M\xb0\xd3M\xdb\x14\x87\xb2\xe8T\xe5\xcc\xd4v\xae^)\xc4)\xed\xe4\x93vsI\x88_\x13\xbd\xe5\xe4\x91vsH\xe4\xe9x\xce\xf3\xf1\xd2\xb8#\xe8\xcf\x96=\x17o\xb4\x873\xf2\xf1C\xc9\xdcP\x14/\xb4\x85\x03J\xe2\x7f\x12\xb8\x1frZa\xe5x\xb8\xf9\x1dFn'\x86\xd7a\xe4t\xdc|\x0e+\x97C\xf38\x84\x8bO\xcdR{\xf9\x1b\xe4j,s\x14w\xb3\x9b\xb7!9\x1b\xcfR\xec\xe1jB\xab4\x17G\xe3\xe6g|5H\xe3e\xac\x13\xf7\xa83\xf7\x98\xf8\x984.\xc6zK\xec\x05\x97\x93\x83\x91\x04\xff\x92\xc6\xbd\x04\xa8\x05'\xe7\x12\xc1\xb7P\xe0\xeb\x16\x9e\x85\xba\xfew\xba\xed;\xb9\x95\xb8\xc6\x879\x15_K#\xb8\x94M<\xca\x1atJ\xe6O\x02\xdc\x89\x8f7\xf1s&\x8e^\x89\xe7J\xc2<\x89\xcd\x91$\xf1#Q\xdc\xc8\x1e^\x84\xe4!\xc2|\x08\x1b\x17B\xde\x7f5\x92\x92\xf8\x0f\x9b\xefH\xe1:Hn#\x89\xd7\xb0y\x0c^\x0e\xc3\xc3_\xd8\xb0\xae\xcd[pq\x16\x8c|\x057W\x11\xcbSDp\x14\xd1\xfcD\x1c7A\xc0\xf8\xd4]c\xb1\xe6\x10\x1f\x11\xcdED\xf1\x10\xab\xca\xf3\xf2\x0fI\xdc\x03\xc55p\xf2\x0c\x9c\x1cC\xca\xf3\x8e\xe0\x16\xc2\xbc\xc2<\xf9\xbb\xbdj\x0d\x18\xeeHv\xe5Ho\xb5;\xb5\x95#\x99\x15g\"+*\x89\x95\xdc\x9e\xc0\x8a1y\xd5\xd8O\x8b\x1dvR\xd2*;M\x15\x91\xa2j\x99\x9e\x8a\xdc+\xfa\x86\x0cgJ\xaa\x94tTcZ\xa9U\xdd\x16\xa9\xa8v\xa4\xa1\xda\x9d\x82\xca\x95~\x8a\xec_G\xda)\x8aH\xe2L7\x15J5\xe5\x89l\x91\x99IX\x94\xcc$d&!3 \x99I\xc8LBf\x122\x93\xb0\xfa*\xb4Jg&Af&!3 \x99I\xc8LBf\x122\x93\x90\x99\x84\xcc$d&!3 \xff\xe7\x99\x04*2!%*\x81\x88C`\x8cA \x90\xb0\xa4D@\xb1I\x80d\x86J\x17%C\xa5\x19*\xcdPi\x86J3T\x9a\xa1\xd2\x0c\x95\xae\xbe\n\xad\xd2\x19*\xcdPi\x86J3T\x9a\xa1\xd2\x0c\x95f\xa84C\xa5\x19*\xcdPi\x86J3T\xfa\xaf\x83J\xe94-\xcc)Z\xa4\xa8\x0f\xa2=U\xb5\xbc(n\xca\xea\xe2\xe3WQ\xcb\xe8D\x18\xea'\xf3\xa3\xb07f\x85\x94mu\xd3\xcb\xe7\xce\x95\xf1 \x9e8\xb6\x89l\xfb\xcd\xaa>\x88G\xda\xd0M\xd3\x1cE\xb1N\x05:Y\xb2\xbe]<\xf0\x17\xea\xf9\xbc\xd5\xbd\x8a\xf1\x04]U\xdf\x1d\xc5\xd0\x07\xafp\xd1;\x17U\xfb\x12\x8a\xaek\xcaJm\x93\xc6\x15\x0b\xc4p\xf5\xc5\x0b{ M\xaf\x8f\xb2\x8fXR\x07\xc5\x8c1\xc1A|\x15\xc7\xa1\xf31\x01\x8c\x94Eyo.zF\xca\x17C\xfa\xffEt\xe7\xa6\xee\xc4;qW\xd5\xef\x8eM\xf9\xf0r\xfa\xecc}X}\xf2\xfe^\x94\x0fW\x8f\xc3+\xb1\xba\xfe\x838V_E{\xf58\xf9\xaf?\x14R\xb4/\x17\xb9]\xe0T<\x0d\xaf\xcbo\xbdh\x07\xe7\xa6\xefT\xf6\x17\xf5\x1a\xaa\x96w\xce\x11?\xf5h\xf4\xd0_\x8c8r\x88\x10\x83c5\xbeb/[\x8d&z\x1cQ#\xe8y\xc6\xce\x98?\xa7?\xdf\xb5\xc5ALIt~l\x0e\xfdQ\xfc\x15!\xb9\xe8~\x1c\xfc\x8c@\x8f\x8cS\xbcI\x0c\x14\xe73\x9c\xd4\xfdt\xcf\x9a\xb7uZ\xf2\x87\x03\x94\xc3H\xab\xbb\xbe\xd3\xd6\x1cw[\xf4\xea\xa2\xd5\x13\xfa3t-^1\xe2z\x9dm\xfd\xc2\xdd\x95\xbf\x1c\x0b\xd6\x1etCO\x97B\xe2\xe2\xa1zWG\xb7\xe8\xfa s\xa4\xbe\xd2kQo\x844\x8c?[8-\xab\xae\xeb\x9a[\xf9mX'\x87I\xe3|>\"B\xa0\xba\xa98\xc2\xf7M\xfdj4\xf2=\x94\xcd\xe9T\xd4\x07\x93\xf78\xf4\xaa\x19\xc6'r\x8a\x02\x9a\xa7\x94q\xabclaF\x9bj\x88\x0fs\x988\\\xc0g\x85\xad\x16\xc7\xae1\xcc\x0d\xadY\x98o\xe0 \xa4(\xe5\xb0\xe8+@\xb4\x98\x9b\xa0\x9b6x\x0c\xb8PC\x01w\xd5WQ\xcf\x1d\xa6X\x06\xd3\xa2\xae\n^\xd0\xe2\xeb$\xa7n\x1d<\xca\x1b!j\xc5\x8f\x8c{,}\xc3\x97PI\xd5\xef\x86\xb9%\xbc:\xd2\x15\x1334\xd7\xb5\xea\xa0\xe9\xe5\xab\xe6\xf6\xd5\xa1\x90bvatu\xae\xaa\xe1e2\x93\x7f\xfd\x17\x86\xbaT\x0b\xd7\xa7\x15Ey?8\xa9\xe3Fs\xb2\xaf\x86\x83x\xac\xa4\x19\x96\x13\xf9\xf6\x0d5z5\xfc>b|~\x18\xbc\xe7r\x98\x88\xde`\x9d\x91\xc6\x18\x9b\xd1!]\xa1:\xf00\xfd\xf2\xc2\xf8%\xf1$\x8e\xcd]U\x9a\x8d\x9c\x9eA+N\xcdWq\x98\xe3\xc8.?\xfce\x01\x98\xa8\xedB\xd5\x8d;\xbc\x11\xaaW\xa8\xf8\xcb\x89\xac\x99\xde\x14y\xdf6\xdf\xa6`\xb0M\xe1J\xcb\xe9i\xd1;\x8b\x98\xa5a\x1f\xacC\x94\xe4\x14\x9f4?\xe5\xd3\x08j\x9fE;\x98\x16\x07\x13\xd6\xf8y\x04\x06\x0eP\xddb\x8f\x8d\x0d\xea\xc4\xf4T\x97\x89\xfb|\xb3\xf3\xa2^\n 4\x9c\x87 \xe7\x9f^\xcc\xfa\xb6\x19\x99\x9f\xaa.\x8f\xfdAQS\xaf\xd6\xc7\xf1w\xfd\xe0dt\xea5\x93j\x82\xa8$\x0ev\x05\xd2\x17\xb2i\x87\x89\xb5?\x1e\xa0\xe8e3\xb8\x1f\x98\xbbO\xdfG\xea\x97]OU\xd7\x18\xfdv\xdd\xc9BZ\xe3u\xe5n\xd2\xce\xa6$\x15\x02N'\xd1\xcf;0j\x03\xdc\xca\x00>]\x00\x9b*\xc0\xa9 \xa0@\xaaHE\x00\x97\x1e\xc0\xaf\x06\xd8\xa5\x05\xe0U\x028u\x00\xbc*\x00\x87\x06 Q\x01`u\xb7$\xf8\x7f^\xf6?\x91\xfbgf\xfe\x13x\x7fn\xd6\x9f\x8d\xf3\xe7e\xfc\xd9\xf8\xfe0\xdb\xcf\xc6\xf5\xbb\x98\xfe\x14\x9e\x9f\xe4\xf5 p\xcd\x9eo\xd28}\x82\xc3\xdf\xc9\xe0\x13x\x8as\xa1tb)\xfe\x15t'o?\xf3\xf4T\xff~\x17\xbe73co\xf3\xf5\x0cl=+W\xbf^\x0c\x13y\xfa\xb1\xa3M\x8b)\xcc\xbc\x97\x9av\xb0\xf2AN\xde\xa6\x01\xe3\xf9x\xfb\xda\xdf\xa9\xb6\xeeb\xe2c\x1a\x1bb\xe1\xddm\x0b2\xf0\x1b\xf8\xf7%\xdd\x92\xc8\xbd{\x99w7\xef\xeec\xdd\xc9^\x88e\xdcC|\xfb\x9amO\xe0\xda#\x98\xf6\xed<;\xc1r\x878v&\x86\x9d\xb8\xf3b\xa4\xb0r\xeb\xcc\xcc:+\xaf\xce\xc9\xaa;9\xf55Q\xb9\xe6\xd3y\xd8t6.\x9d\x97I\x8f\xe3\xd1\x83,z$\x87\x1e\xc3\xa0[\xfc\xb9}\xb7X.\xd5\xcf\x9dG2\xe7\x11\xbc\xf9\xa2\xca\x9c\x9c93c\xce\xc7\x97\xf3\xb1\xe5\xfb\x9fn\x90)\x0f\xf1\xe48}\xd3>\xec/\xc7\xc2\xa4+L\xfa\xae\xb8iz \x05\x9c\x8fE]\xcf`\xabz\x9a\nH\xaet\xb6\xa7\xd1\x96J\xde\xe5\xa13\xfe\xbb\x17\xed\xd3[\x04\xe2\x87\xfbjV/\x9a\xe2\xe0\x02O\xef5\xc6\x8d0\xcb\"\xc5\x93\x89\x9f\x0e-\x87o\xc5\xcc\x1ex:\xd2\xd58}\x97V\xff\xad\xde\x0f\xcd\xb0\xa8\xab^\x1b\x97\x8d\xd6\xbe\xfc\xf2^\x0f \\hB\xdd\xfa\x1ew\xa8\xbb\xba\xf5<\xd1LV\xf3T\x0fT\xfa\xedQ\xb7\x98\xc6\xc1\xf0\xdd\xc5\xeaYDA\xa7K\xa6\n\xf6\xc3\xa6)\xac\xd5\xca\x14\xc5a\x017\x8f\x05$\x97\x05\xe9|\xd6\xcaZq\xec\x1a\x8b\xd3\x02\x06^ke\xceb\xb9 \x9d\xe9ZY\x1b\x9f\xdc\xfa&\x9c\x8c\x17\xb8X/\xd8\xc4|\x81\xc5~A\x0c\xcea\xb3`\x10\x1c\xf7\x8cl\x18\xf8\x181\xd8\xc4\x8aA\x1a3\x06\xc4\x04\x0f1=\xb8\x9c\xe8\xc1\xcb\x94A*[\x06\x91\x8c\x19X\xac\x19\xf8\xda\xe2:\x83,\x8dA[\x19K\xa5\xd1\xac\xc9\xc4\xf8 @\xac\x81k\x85\x00\x8f\x9a\xcbE\xb2\x81\xaf'!\xf8\xf6\x00/\xe1\x06\x81p\\N\xe2\x0d8\xc97\xf0\x07\xe5&\x91p\xc0H\xc4A\x90\x8c\x83\xbd\x84\x1c\xa4\x90rT\x8f=\x9d\xf5Ykt\x80n\x029G\xd8\xc2\xb9\xcb\x19\xa4\x9bF\xd2\x11\xe6\xfa\xb33P\x97\x9b\xac\x83t\xc2\x0e\xf8I;H#\xee \x8d\xbc\xa3_Q\xb2\x92l\x94\x1e\xb0\xd3z\xc0I\xedA\x14\xbd\x07\x9c\x14\x1fx\x03z\xd3\xa8>\xea\x1d'\x83z# @H&\x01 \x83Th\xefnj\x10\\r\xeb\xc0\x12\xef \xf1\x8dY\xffw\xd2\x85\xd4\xb4\xe7\x0c\xf4\x0d\xd5#\x8d:\\\x19SD\"\x19\xee\xcbB!\x027\x8d\x08d\xd0o2\x9d\xb8\xb2&\x89\xc0\xdf4\x82\x11B\xbc\x1b\xf8\xc2\x7f#\xc8Fp\x1ez\x1fO:\xbamX\xa0s\x12\x01 \x1b:#DDB\xb0\xddAB\x12\xb6\x91\x92@\x06\xb1%\x92\x93\x10\"(!\x10\x1c\x1c\n\x0f\xf6\xf4R,a \x11\xa4%\x90a\xc2I\xe4%\xc4\x11\x98\xb0\x8b\xc4\x04g\xc7\x04\xc9L\xe0#4\xc1]\x0bk\xa4\xb1\x92\x9b\x90Hp\xaeLQ\x81\xc4\xcc\x94'0\xd3\x9e\xe0\x0f'\xa6\x02\x8a\xa9\x90b.\x1a\x148\xa9P`\xa7C!\x9a\x12\x85\x18Z\x14\xe2\xa9Q\x88\xa4G\x81\x0e1\xa6\x83N\xe3\xc9\xb4P\x98q4]\nq\x94)P\xcd\xe0\xa4N!\x95>]\xd9\"\xc2\x8f9 U`%U!y<\x04\xc9U\x88 X!@\xb2\xba\x18\xba\x18n\xd0\xb8l\xb4\xb6\x99\x1b\\\xc4\xa6u\x9b\xe9A\x0c`\xbb\x1ew\xe6\xcf\x1c\xc1ks\x83\xde\x8d`LL \x16+20h\xdb\x11%8^\xb7-V\x10\x0bc\xc4 apyn\xd4\xf2\xa1\xc1\xf2\xc41\xbc\x01\x82+#?'\xaav\xbe\x93aH[\x08r\xdf\xf4(\xf3\x0eq\xf3\xf2\xd7\xcb\xeb\xbf\x9b\x07{\xe4(\xffud \xde\xebF\\\xcaB\x8a\xcd\xa3}&2\xb4\x1d:H(\x14\xae\xeb\xe9)\x7fM\xe3{\x8c\xb6\xe3\xed\xb9\xa2\x97\xf7\xff\x9c\xfa\xedS[l\x88\xf2\x1f\xaem\xda\xea\x9fj\xa6\\wG\x14\xf1/s\xccT:m\x93c\xa6\xe2\xe8\x19\x84\x95\xad>\xca1S[h\x98D\n\x86\x99~I\xa0^\x12h\x17b\xc2`$Xx\xc9\x156b%L\xaa\xb0\x11*9f*\xc7Lm >r\xcc\xd4\xd8\xd1\xa6\xc5\x14J#&\x8c(\xc7L\x19%\xc7LA\x8e\x99\xca1S9f\x8a\x8b,`#\nxI\x828\x82 H\x0eD\x12\x031\xa4@\x8e\x99\x9am%\x81\xfe9f**fJ\xe1\x02UK\"^QY\xadh%\xba\xc2\xddThE\x07g\xd1\x9e\xaa\x0eAZ\xd9\x80x\x14e?y\xf1C\x0f\x8f\xf3\xb7\x8e\x06Qo\xfd\\+\x15r\xe0\x04\xf8\x14N\xa8\xee\xb6\x1d\xf6\xbfS\x97=/\xda\xef\x80\x14\xbd\xb6|\xf6\xc0 2\xce\xdf9%e\xa1\xed\x12\x16F\xd8\x11\x8b_;\xce Aba\x03\"\xb1x\x15\xe4I\xa0$\x16.h\x12KXG\xbe\x13\xa6\xc4\xb2\x1b\xac\xa4\xfb.\xac&O\x00.IkAEy\x1a\x88I\x1a\xf4\xaa\xca\xf7\x01\x9a\xa4!\xaf\xd6<\x19\xea\xd4F\"\x00O\xf2\xcah\x10\x14K\x02\x14\x8a%\x01\x10u\xbd\xe8\x8e\xaa\xb2A\xa5Xx\x01S,l\xb0)\x960x\x8a\x85\x0dB\xc5\xe2S\xa5\xa7\xc1\xa9\xf4\\\xe1P\xa6G\x02\xadX\xf6\xc2\xad\xa41\x17\x04\x8be'\x10\x8b\xc5\xa1Q\x0f\xba\x14^\x9dz\x9c\xc7\xb1\x13\xa6\xa5'S\x8fZ=\\\x9b4\xe0\xd62\xe7\xd3\xac\xb3\x80\xb8X\xd2\xa0\\\xcb\x9c\xf2hH\xe7!\x11\xd6\xb5\xefD\xaa\xd7\xd3\xc0^,A\xd1\xb6W\xc3\x1e\x01\xffbqHa7@\xc1X\\v\x08}`\x128\x8c%\xbesB@1\x96P/\x04Ac,\x1b\xa0c,\x94z2\x11F\xc6\x12\xd4\xb7\x87\x14\xeea\x8d\xbb\xb7\xd7bAf,!\xa8\x19\x0b\xa5uO\x82\x9d\xb1D\x80\xcfX\xb6C\xd0X\\\xdd\x14\x84\xa3\xb10\x81\xd2X\x9cu!Fb\x12LmY#\xd4\xf0i\xe0\xb5}\x07R\x11\x9f\x08i\xdbU\xb65\xf2\xbc@7\x16\xafN\x9eV\xca\xd3Zy.\x00\x1c\x0b\x1b\x0c\x8e\x85\x17\x0c\xc7\x12\x07\x89c \x02\xe3X\"\xe1\xf1\xc5\x8f\x83\xcay\x87v\xde\xa5\x96\x8e\x07V\xc3\xfa\xf9h\xf0|\xfcq\x18B\xc7B4\x88\x13N\xc7\x92\x04\xaa[\xd6H-='\xd4n\xdc\x86\x05p\xc7\x92:F\x82\xe0\xfbh.BUo\x1e\xf1\x05\x0e8\x1e\x8bg\x1f\xe6K\xb5\xe3K\x15\x13\x0d\xd3c\xd9\x00\xd6\x13\xf7^@\xe1+\xbd6B\xf1\xf8\xcf\xb8I\xc7\xff\x8baQ\xc4\xffN0\xcf\xb9\xb8\xab\xeaU\x17-szM?@\xd4L\xa8\x9d\x9c\xf1\xa9\x0e@\xd0\n\xe4\xb9\xc62^\xeb[\x8bGym\x9d\xc7\xe5|J\xce}2u\xae\x04\x18\xf6\xb5\\z\xf8\xef\x08\xf6\x14]\x87(\xd6/\xc5\x9d\xf8\"~\xebE'/\xf0\xfb\x95\x91\xdfz\xd1\xe2\x196\x83\xb9\xa1\x0f\x04\x9c\x9aN\x82\xd0'\xb9\x1d\xcdm\x99ld\x11+^\xf6D\x0f\xb8\x92\xfd(\xf3\xaa=\xea?u\x7f\xba\xc1=\xbd\x06\xe0\x0c\x14\xe8vu\xad\xd9\xd4\xb2\xe9ky\xad\x8c\xac_\xf0oE\x07\x9d\x90/U`\xc1\x88!v\xd0\xd78\x10\x0e\x08\xc3|\xab\xba\xa0\x86}I*\xc5\x04\xb2\xbc]\x0e\xf0/\xbf\xbc\x1f\xedY\"\xf5[!\xd4\x98\xde\xa9S\x1f\xdf\x87\x00_\xe7\xc6:\xc6\xebu\x9b\x8a\xc3\xa1\x15\xdd\xb4Q\xef;1\xbe}j\xce\xaf\x115-\xeaR\xa3\x12\x95\x99[\xec\xb6\xaf\x0f\x13\x9a4\xbe\xb3\x89\x15\x13\xbe\x8a\xdd\x88\xa1Vz\xa2X\xd5\xce0U\xd4\x08\xb8\x0d\x17\xbd\xe8\x96\xd5\x9c.q\xcc\x1f\xb3I}f\"\x1etxStU\xa9\x16\xda\xdb\xea(E;\xccTB\xcc?\xdf5\x8d\xc8\x1c2\x90\xce\xd4\xe5\x90\x818\x16\x0e\x91\x7f\xab\x8fr\xc8@\x0e\x19\xd8\xc6\x90\x91\x10\x02\x1b\x0f\xc6\xcb\x80\xb1q_a\xd6\x8b\x8d\xef\xca!\x03\xffv!\x03\xa3S\x8c{.\xb5P6\xadz-\x94\x95\xbf\xfc\xf5r\xf8{\x18}\xc3;\xd3\x0es\x80\xf2r\xb0\x9b\x865L\xcf\xbb\x1e?\x12s4k\x7fd\xb3\"*\xde1R\xbb\xb7\xf9\xcf\xb8\x8d\xdb&\xbf\xc8rra\xbf[\xc4\xe9\xf0\xc2\xda\xe9\x05\xca\xf1\x85\xd4\xca\xb28\xc1\x10p\x84\x81~\xe6\xc0\xef\x10\x83\xeb\xe1CN\x8f\xba\xc1a\x06N\xa7\x19B\xe2\xb6\x04\xe7\x19\x18\x1dh\x08:\xd1\xb0\xd7\x91\x86\x14g\x9a\xea\xb1\xb0\xa0m\xb7SM\xd8\n\x8a\xd9R\x9ck\xc2\\N\x8f\x9a\xe6pC\x9a\xd3M\xbf\xa2d%\xd9\\q`w\xc7\x81\xd3%\x87(\xb7\x1c8]s\xc8\xe9Q\xa9\xdb\xect\xe9\xe1\xdf5=*\xa7\xbb\xef\x05\xaa-w?\n\xab\x9e<\xba-0\xf5\xf2~\xdb#.&\xc7\xf0\x99\xa3.\xc8\xbd\x83w@\x85FL\xc2\x0e\xc2\x1e\xd7*\x15\x91\xe5\x88;v\x11\x0c\xd5f\xdbK\x84w\x13\xce\xfd\xc4\xb3\xec(<{\x8a\x1cB\xb3\x7f\x87\xc1\xbc\xc7\xc8!4\x8b\xc2\xb9\xdf\x88\xdaq\xf0\xee9\"v\x1d\xec\xfb\x8e\x1cB\x83e\xd3>%y\xa7\xc2\xbdW\xc9!4f\x89\xdb\xb50\xef[r\x08M\x0e\xa1I\x08\xa1\xe1\xdd\xd3\x80\xd3)4\xa6\x9a\xe1\xcf\x17Y\x19\xb6(Y\x19\xb6(\x7f\xb42\xcc\xde\x00o\xdaqS\xca\xb0N\x94}[\xc9\xa7\x0f\xb3\x872\xf4\xf5\x83\xde\x05cW\xab\xcd\xd1w\xff\x1b\x00\x00\xff\xffPK\x07\x08\xba\xce\xd4\xf9\xfb\xe6\x01\x00\xbf\xfa\x18\x00PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\xd4`4t\xc7\x01\x00\x00\xbd\x01\x00\x00\x11\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x81\x00\x00\x00\x00favicon-16x16.pngUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(6B\xc8\xd7\x7f\x04\x00\x00u\x04\x00\x00\x11\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x81\x0f\x02\x00\x00favicon-32x32.pngUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\x8e\x10\x9f\xf1}\x02\x00\x00\xe3\x05\x00\x00\n\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x81\xd6\x06\x00\x00index.htmlUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(]\x12r 9\x03\x00\x00T \x00\x00\x14\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x81\x94 \x00\x00oauth2-redirect.htmlUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\xba\xce\xd4\xf9\xfb\xe6\x01\x00\xbf\xfa\x18\x00\x0c\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x81\x18\x0d\x00\x00swagger.yamlUT\x05\x00\x01\x80Cm8PK\x05\x06\x00\x00\x00\x00\x05\x00\x05\x00_\x01\x00\x00V\xf4\x01\x00\x00\x00" + data := "PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00 \x00favicon-16x16.pngUT\x05\x00\x01\x80Cm8\x00\xbd\x01B\xfe\x89PNG\x0d\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00\x10\x00\x00\x00\x10\x08\x06\x00\x00\x00\x1f\xf3\xffa\x00\x00\x01\x84IDATx\x01\x95S\x03Luq\x1c\xfd\x8c\xf1\xc3\xec0\xa7)\xcda\xb6k6\xb2\x9b\xf9\xb2k\xc85/\xdb\x8dqx\xc6\x94m\xcc{\xef\x7fO\xff\xf3l\xdc\xed\xf2\xe0\xfe\xf8\xc9\xffP\x14\x11/\x14[\xa3P\xc4\xa1\xbc?\xf1t>7\x12s\x13\x03\x85\xca7IR a\xb5j\x8f\xa71\xbe]\x88\xf6\xb9L\xf0\x1c\x93\xcf\xda\xe3)\x10\x93f\x8d\xe4\x06\x13\xcf\xde<\x9b\xd14\x95\x8a\x92\x81OA\xcfF\x89\xdd<\x9b M\xe6}L\xe4\x07\x15\xc5\xf5\xe3\xffI\x0c{\xd6\x8d\xffs\x994\xbasfh\xae?\xafk\x1aprw\x10 <\xb9\xdb\xc7\x86\xa6\xd1\x19I\n\xa8\xb1\xd7\x84y3g\x171T$\xb5c\x7fq\xfbbq\xbfk\x8e'\x1dQ\xb0\xc2,\x92\x0bx|;F\xe5\xf0\xef\x00\x83\xf2\xa1\x1fx|?q\xbd\xcb\xc2\x16\x80ZF\xf0\xc4J\xf3\xe3\xe4n1\xcc\x17k`:}\xcby\xe8\x98\xcbB\xc7|6z\x97r\xd14\x9d\x06\xd3\xf9\x8a\xe4\x94\x90\x8b\xb6\xd9\x0cP\xebc@\xd0|\xbe*\xc94\xc8\xa7\x98'\xcdh\x00\xe3\xd92\xa6vK}\x0cB\xa4\xf0+D\n\xc7\x81)\xb0\x10\x9a\xe3\xa9\xd8\x8bx\xe4(\xa2\xbb\x8dl\x0d\x01\xb6\x8a-\xf378\xbe\xdd\xc7\xa6\xb6\xc9\xd9\xc6d\xd8\\m\xf4\x0c\x92 uQ\x0e\xd2\xf5\xb3\xd1\xf1w\xdfQ\x16\xb34a$\xa1\xc4\xc4(V\xbcF\xd9\xdf\xa4\x91\xe9\xb0&,\x12+\xcd\x93\xcf\x1c\x1cb\xdc\xca\x00qt\xeb\xcc-\x14\x89\xfe\xfc\x0fm2j\x88\xec\xccs\x18\x00\x00\x00\x00IEND\xaeB`\x82\x01\x00\x00\xff\xffPK\x07\x08\xd4`4t\xc7\x01\x00\x00\xbd\x01\x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00 \x00favicon-32x32.pngUT\x05\x00\x01\x80Cm8\x00u\x04\x8a\xfb\x89PNG\x0d\n\x1a\n\x00\x00\x00\x0dIHDR\x00\x00\x00 \x00\x00\x00 \x08\x06\x00\x00\x00szz\xf4\x00\x00\x04|ID\xc4\xcf\xd0@\x04&%\xad\x1e\x16\x0f\xf7\x8d\x97AR\xfa\xca\xe7l\x87\x05\xf8\xd2\xfb\x0c\x84\x1d\x0dLVY\xdc/ju\x13\x1a\x88\xd2\xa0\xaaa\x82|nzp_\xf4\x03\xc8 \xd4;^\x8a9}\xeeu\x9a\x91 `\x04\x14s\xec\xe1\x0c\xc6]\xa3\x05``\xd1w\x12*~ \x00\xf3\xae\xd3\xa0\x9cb\x82\xa2bx(\xb3n\x1fqx\xd2\xf2\xda4\x1d\x8a}\x1ck\xd4>\x9cI+\xeb\xb3\xf4k\xc8u`L\x93\xf3]4\xb5\xd0\xc3\xe33\xd9\xee\xd7\xf2\xd9\x19\xea\x18\xc9\xc1Y:\x18\xfb(-\xadN\x82\x06e\xd5\x1f0\xa2\x1dV\xf8\xbe0\xc1\x985\x01\xf8\xd2~\\\xa6\xa5\xb5)&\xf6\x98V\x80l\xe4\x03\xf8\x03\x04\x00s\x9a^\xec\x85\x00\xf4+\x0b\x00\xe1:G\xf2p\x96\x0e\xc4,\xe46\x1e5\xbbP\xdd\x15J\x80}\xce\xa4\xe2\xc8{m\xa4\xe2\xc3\xc2\x01\x07\xc0\xdb\xa4\x18-\xa1\x931\xba\x10S\xfa%\xb6P`\x10\x19v\x99#|Gg\x9b \x10W\xf6\x8dI1\xba\x92\xd66\x17E\x12\xfa\xd9\xa8\xf3UTe\n\x1b\x95\x9d\x81f\xe5\x18\xa5umc\x81\x86\xa6\xeb\xec \x804\xcbg\x17\xa19\xfa\xc6\xf7<\xa3\xbd\xf2\x0e\x7f\x02\x80\x97Y\xc7\xac\x184$h\xa3v\xba! \xcc{\xcd\xb4!\xb1\xd8\x92%h\xe3\x93\xdc\xd3_\xda1\xe6\xaei\xcf\x83\xa6p\xbc$\xf0\xb2\xda\x94\xa2q\x14B@\x13\xdb\xff\xf3\xd7\x0d\xfaA\xb9\xc5n{\x8e\xd6Y\x08\x01u\xc1'~\x16\x8e\xe9\x04\xa2\xfbA+\xc74\x0c\x98\xab\xd7:\xfc0\xd1v\xaf$\xa2#\xb7\xf1\x08\xfdm!OXh8\x10j|g\xd1\xe0a\xb2\x99\x04\x9a[y\x9a\xbdk\xf24C$\xa0\x9e#\x9f\xa3\xa8\x001\xc6\x1a\"\xc0\xe4i\xa6\xcc0\xf3\xf7\xb7\xf5XE\xb8\xe0\xa1\xc9\xc2\x0c\x90\x83\x80$\x838\xdf\xd6\xe3\xd4\x82FNG\x0f\x876\x8a\xbf1\xa8d(\xa7@\x8cQX\x90\xdb\x19\x9f\xc5YG\xe9\x9e\x00\xa5y3]\x9aJ\xe1\"\x00\x00\x00\x00IEND\xaeB`\x82\x01\x00\x00\xff\xffPK\x07\x086B\xc8\xd7\x7f\x04\x00\x00u\x04\x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\n\x00 \x00index.htmlUT\x05\x00\x01\x80Cm8\xb4T]O\xdc:\x10}\xdf_1\x98\x07\xe0\n\xc7\x17V\x17]\xa5I\x1e(\xad\x8aDU$\xd8\x87\xaa\xaa*'\x9ed\x0d\x8e\xbd\xb2\x9d\xfd\x00\xf1\xdf\xab8\xc9\x86v\x11\x95\xaaV+\xad\xc7s&\xe7\x8cg\xc6N\xf6(\x85\x0f\xb7\x1f\xaf\xa04\x16\x9c\xe7^\x16 \xa4\xf3V\xe6\x8d\x97FC\xdeh\xa1\x10\xf2F*\x01\x94f\x93d\xef\xe2\xd3\xdb\xdb\xcf\xd7\xef`\xeek\x95M\x92v\x01\xc5u\x95\x12\xd4$\x9b\x00$s\xe4\xa25\x00\x92\x1a=\x87b\xce\xadC\x9f\x92\xd9\xed{\xfa?\xe9!/\xbd\xc2\xecf\xc5\xab\n-\xcc.\x13\xd6y:TI}\x0f\x16UJ\x9c\xdf(tsDO\xc0o\x16\x98\x12\x8fk\xcf\n\xe7\x08\xcc-\x96)\x99{\xbfp1c\x85\xd0w.*\x94iD\xa9\xb8\xc5\xa805\xe3w|\xcd\x94\xcc\x1ds\x9d\x14m$\x9bF\xd3\xff\xa2\x93g\x9e(\xd0\xedh\xcb\xc2\xe8AU\xd6\xbcB\xb6\xd0\xd5 [\xf2e\x8b\xd3\xe9\xe9zz\x1a\x05\xc0\xc9\x07t) \x1e\x02\xec\xf7\xf8N\xce\xd6'g?\xf0\x05\xcf\xc8\x17*\xd2\xd9\x10\xda\xd0\x9b\x8f\xfd\n\x90\x9b5u\xf2A\xea*\x86\xdcX\x81\x96\xe6f\xfdf\x8b\x9b%\xdaR\x99U\x0c\xb46\x0f\xd4\x15\xd6(\x95s\xeb\xe8\x12\xad\x97\x05W\xbb\xb1t\x13C\x178`O\x93\xde\xf8\xe7x0\xe2\x1cKcq\xdc\xf3\xd2\xa3}5?\xa9\xe7h\xa5\xdf!\xcd\x8d\xd8\xec|Xs[I\x1d\xff;\xa6\x97\xf3\xe2\xbe\xb2\xa6\xd1\"\x86\xfd\x92\xb7\xbf\x91\xaa\xfdO\xd8\xb6^ \xebF\xb35[\xfa\xbe\x9eB.A\x8a\x94\x8c\xe3@\xb2\x84 \xb9\xcc&}\xc1\x0b+\x17\x1e\x9c-\xfe\xc8\xb0\xd1\xeeVEw\x8edmz\x81=\xfb;R\xces-\xb82\x1a\xe9\xc2\xa2C\xff\x8aj\xb7YI-\xcc*2Z\x19. \x85\xb2\xd1E\xfb\x16\x1c\x1e\xc1\xe3\xd0\x1b\xc6\xe0<< \x1c\xdc\xc6y\xac{\x7fa\xb4\xf3\xd0HH\xa1\xbf\xd8\xb3\xcb\xf3p\xd8\xc3\xb1\x87\x8dU1\x90h\xc82\xda\xf0Z\x91\xe3-,L\xfdM\x8a\x18\x0e\xf6\xc7c\x1c<\x83\x11\x17WR\xdf\x87\xd9\xf1\xb6\xc1\x11\xea\x0e\xe8b\xf8\xb2u\xc1\xcfyD}P\xc4\x17\xd2\x1d\xbf\x14w\xb3\xad\xd8u\x08\xdd\xc6|}\xa6\xa4\x9aJ\xea_)uA\xd1\x85Y\x85Z\xce\xacz\x89K\xf1\x8di|\x0cd\x14\xbe\n.2\x8c\xf1\xd1P\xf6\xbe5\xa1\xbe\x8d\x0c\xce\xa70\xd6c\xff\x12\xd6\x0dv\xc2\xba\xf7\xf9{\x00\x00\x00\xff\xffPK\x07\x08\x8e\x10\x9f\xf1}\x02\x00\x00\xe3\x05\x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00 \x00oauth2-redirect.htmlUT\x05\x00\x01\x80Cm8\xc4VMo\xe36\x10\xbd\xfbW\xbc\xf0\x10I\xb0\xab\xa0=*Q\x82\"\xd8C\nl\xb7\xd8 \xbd\x04\xc1\x82\xa6\xc66\x1b\x99\x94I\xca\x86k\xfb\xbf\x17\x94eK\xb2e\xd4=u\x0e\x968\x9cy\x9a\x8f7\xa4\x1fn2-\xdc\xba \xcc\xdc<\x7f\x1c<\xf8\x07r\xae\xa6)#\xf5\xd3\xdb+{\x1c<\x8cu\xb6\x86V\xb9\xe6Y\xcaL\xa9\xc2\xc8k\xef\xbc\xda?kO+\x8c,\xdc\xe3\x00\x00\x82\xd2\x12\xac3R\xb8\xe0\xbe\xd2LJ%\x9c\xd4\n\xa6T\x08#l*\xad\x97%7\xd0\xbct\xb3_\x90b%U\xa6W\xb1.H\x91\x89\xed\x8aO\xa7d\xde^\xbeS&\x0d \xf7\xad\xb2\xbb\xef\xf8ZR\xee\xd5qGHk\x9c\xd8\xfae\xd7\xca\xd4\x08o&o\xecZ\xca\xae\xb5\xb4\x7f\xf2\\f#,\x8a\x11\xb81\xf7\x83\xe3\xb6\x9c \xbc\x13:\xa3\xad\xd3\x9f\xa4\xb6d\x8c6w\xb1#\xeb\xc2:\xfa\\\x0b\xees\x8dg\xdc\xce\xa2v\xae^\x16E\x93g\xc72\xb6\xe5\xd8\xd7LM\xc3\x9f\xa3&\x9e\x1d(\xb7\xd4\x07r\xf4\xb6\xc4\x8d\xb8\xe8\xdf\xc4\xce\x8dA\x8aE\x11\xdb\"\x97.d\xb7,j\xef\xc5\x13m\xbep1\x0b\x8f\xcd\n\x97#9\xfa\xc1\x8d\x89\xb0\x81\x7f\xbe\xcb\x0f\xa4\x08X\x80!\x96\xb1\xa1\"\xe7\x82\xc2 \x0dF\x08X\xc2\x82\x08C\xbf{\xbfk\x80\xabP\x17\x05\x9e\xf0\xdb\xeb\xb7\xdf\xe3\x82\x1bKa\xb0\xf1\x08\xfe\x9b\x7fi\xa9\xc2\xcam\x17\x8c:9\xa2M\x9b\xf0\x93\xd6#,y^\xd2iA\x0fb\xc8\x95F\xe1\x93\xd6H\xd3\x14\x8c\xe1i\xef\x80\x04\x19\xf9\x96\xbd}\x7fy\xd6\xf3B+R.\xdcc\x9d!\xed\x8e\x9a\x08 6\xad\xea\xd5\xa4\xa8+\xb8g\\\x9a6\xfc\xebr$l!\xd7t\xf3\xbf\xb1\x153\x9a\xf3xJ.d\x93\\\xafX\xb4\x8f\x96\x0bA\xd6>\xeb\x8c\xd8v\xfb_}K7\xd3F\xfe]\xb1\xa1\x82h%q{\x8b\x9b6\x88/\xc4i }\xc07u~}\xe5\xad\xfd\xc9\x98\xe7q\xd8_}o\xf1\x92%\x9dx\x15\x9f\xd3yO\xbdX]\x1aA\xc9>t\xd6o\x93\xd3\x92\xf2\x04l\xc5\x8d\x92jz\xc1jN\xd6\xf2\xa9\x87\xfa\xb5]\x05\xcc\xf9\x1acB\xa9,\x9f\xd0\x08\x05\xb7\x962\xec\xdb\xb6\xe2\x16b\xc6\xd5\x942H\x05KfI\x06\x7f\x9c\x98\xa8\xc0\xd5\x9c\xa2\x0c\x13\xa3\xe7U\x8e\xb55;'Nk\xe6\xd0\x9d;\xd4%^\x14\xbd\xd5\xf7\x92QN\x8e.\x1c`\x079m\xe3\x9e\x8a\xfe\xed\xa2\xad\xe0y>\xe6\xe23\xdc\xf8u\xa7=\xa3\xf6\xa1\x98\xb4\x17g\xa9\xf4\x1dA\xa8Z\xe4\xf6\x88_\xfc)\xf8\xd5N\xcf,\xea\xb4\xabS\xf2\xd2\xe0v\x10\x90\x82\xbd\xb3\xe1\xc1g\xc8>\x120\x0c{\x1d\xbd\x1c\xd1\x7fd\xb4\xbf\x82|\xf7\x9f\xd0\xa7\x1e\x82\xc5`H\xc0\x94F3p0$H.\x0f]v3\xaa\x9b\x1c\x83EW}\xba4\x12O`_\xb5!H5\xd1 \x9a\x0c\xaa\xcd\x04\x8cE\xe7M:\xe1\x08\xfe\xefQ\xab\x02\xfe\xb7A\xeb\xb6k\xbb\x05{\xef\x8e\xde\x84\xcb\x9c\xb2\x8f\x04\xd7U\xf9\x9aQ:\xbe\xf51\xf1\x1a\xaaW\x97uR\xdd\xe7\xf59\x974\xb7\xfc5s\xd0\xc4P\xdf\xdd\"\xd7\x96\xc2\xdab7x\xb8;\xfc\x01\xfa'\x00\x00\xff\xffPK\x07\x08]\x12r 9\x03\x00\x00T \x00\x00PK\x03\x04\x14\x00\x08\x00\x08\x00\x00\x00!(\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x00 \x00swagger.yamlUT\x05\x00\x01\x80Cm8\xec\xbd\xfb{\x1c9\x8e \xf8\xbb\xff\n\x9c\xef\xbeU\xd5\xb4\x9dz\xf8\xed\xdd\x9a[\xf9Y\xea*\x97\xd5\xb6\\=\xd3s\xbdif\x0433J\x91\x11\xe9xHJ\xd7\xf4\xff~\x1f\xc9xg\x90\x04\x19\x91\xb2l\x13\xbb\xdf\xb4K\x19\x04I\x10\x04@\x00\x04\xd3K\xb2X\xd0\xe4)\xec\x1dM\x0e\xf6n\x05\xd1<~z\x0b \x0b\xb2\x90>\x85\xe3_\x8e\xdf\xff\x0cwa\xf1\xee\xf49\xbc&\x19\xbd$\x1b\xf0c/\xbd\x05\xe0\xd3\xd4K\x82u\x16\xc4\xd1S\xd8;\x86w/\xdf\x9fA\x10e4\x99\x13\x8f\xc2\xdd_\x14\xe8@\x89\x12Zh\xa7\x81\xdf\xf7\x81\x06;h{`\x10_F4\x91\xfdX\xf6\x90fI\x10-$\x1f\xf9)\xfd4\x08\x010V]\x91\xec)\xe4A\x94=\xbc\xdf?U\xb1\x1fj\xae8y\x01i\x16'4\x15S\x00\x12\xf9\x90\xd2O9\x8d<\nQ\xbe\x9a\xd1\xa4\x07\x11\xdf\x10*b*FJ\xa3|%\x9b\xe8]\x08\xa2\x0b\x12\x06\xbe\xf4w\xb6\xdf.\xa8\xf4g/\x8cS\xda\xdf\xda\xa7s\x92\x87\xd9Se\x17-\xce\xff\xf7\xbb\xbaa>\x85\xd3\x84\xce\x83+H\x97q\x1e\xfa\x8c.I\x06\x97A\xb6\x84\x03\x08\">\xd7 \xbc\x8fekN\xbd\x900B\x81\x9f\xafV\x1bAV\xd9\xf2\x96so\xae\xde1\xff\x0b\xf84\x8a3\x9a\x16r\x8aI\xac\x86pPR\xac\"Y\x13\xebs\xfe\x175V\x05\xa1\x0b\x1e{\xcf\x9b\x05)\x10A\x07\xb8\\\x06\xde\x12\x12:\xa7I\nY\\\xe0\x8d\xe7\x0d\xb4=\xf8J\xa9j\xc7l\xe5\x96\x98mz \xeb%\x94d\xd4\x9f\x92\x1e\x99\x03&\xf8\xfbw\\A\x89\xbd\x86\xf4.6\x9b\xdf\xd8\x80w\nJ\xb0\xadW\xcc\xb6\x94\xe8{\x1d\x94\x8b$\xce\xd7=BH\x8c\x93$ \xd9l\xfd\x16dt\xd5+\xb74bO'\xf4\xf8X\xa42U\x8b\x1e\x10]\x80^\xb2\"\xd6\x08\xb4\xd2\x15\x89\x04%a\x19,P\xbd1\x1bc\xd1+^KPs\x97\x80\x82\xc7\xa4\xb2\n\xe05[\xa8\x8e\x9c\xbf\xd3\xdc\xcb\x1dy\xcf\x18Q>5\x86\x0c\xa1!\x94:\x02Eo\x95\x9e\xd0k\n\xf6E\xbc\xa6\x91\xe2\xe75\xc9e\"\x0c\x8a\x1e\xd2|>\x0f\xbc\x80\x19\x0f\xf3<\xf2S\xc5\xc7\n\x81\x88\xd4=X\xed3\x9e\xfe1\xd4@%M\x9f\n\x96z\xbb\xa6Q\x8f\x92\x10\x1c\xa2\xa4}E\xfc\x12S\xe2\xd3\xa4W\xe3\x14\xc8\xc4\xef*|\xdbkU\xe0>i\xfc\xf0\x8a\xfd]\xda\x8b\xc1r7\xd4&\xefD\xaa1\x05f%o\x18\xabK\x8eS!\x92\xd35\xf5v,\x94#\xb2\x92nm\xc0mov\x12\xf9\x94\x07 \xe5\xc7\x1f=2\xe5\x98\x019n\x06i\xb0\x88\xa8?\x9dm\xd4\x9fa$k \xef9\xcag\x1b\x08\x834cKtN7)dK\x92AF#\x12e)\xd0\xab5\xf52\xc8\xe4[\xb1\x84%\xb9\xa0|\x90$\xcb\x99\xbc\x9e'\xf1J7R\x1c\x85\xc0\x80J\x0cH\x18N\xe3\xb9\xfe;\xb5\xfd\xb1\x0dR\x8bd\x1bP\x8c\xd4\xf8\x1c\xbddP\xcd\x8f\xfd\x8fX\xb0 \x82l\x19\xa4b\x15Wy\x9a\xf1\xb5@\xa1\x12L\x05$\xcb\x92`\x96gT!:\n \xd1\xe6\xdb&.\x9f\x1f\x90\x0cBJ\xc4\xae\x88\xe7\x90-\xa9\xa05\xe3j\xfe_\x8c\xd8(\x84\xd5\x82\x18\x12\xbb\xfeLG\x15<\xa1\x91D6\xd8\x97f;\x13\x18\x111\x9f\x19/\xf2\x05 s\xa5h\xaf\xc1\x08s\xe9\x88+\x17\x03\x12\xbaNh\xcad?\x9b\x8b\xe8\x17\xd6$P\xd9\xc3`\xc4\x85u_\xa5X\xaeY\xa1\x90\xcb\x85XF Y\xe0\xec\xbaN\xe2\x8b\xc0WZ\xed\xc5\x08OC\xe2q\xe5\xf6\xae\xa1\xe7\xa4\xcd\x12\x9a\xc6y\xe2\xa9\x17\x1f\xc7\xa0\x08\xe6D3&\x9e)Q\x13\x10\x80\xee\x1d\x8cF\xc0\xc0[\xe7\x98\xcf\x0c\xc7\x00\xc6\xe3`\x90G\x81\xda\xb0i\x83\xf1\x88\xc0jT 6\xb9\xc9\xe7\x86[\xbd \x1a\xffK?\xe0\xb7x\x0d\x1f\xa2\xa0r\xaex\xeb\xfc\x0e\xac\xe8*N6\xc2\x9f\x99\xc5 Y\xe0\xfb\x07X\xd1, <\xbd\x12\x17\x80\xd705\xe0\xb6r\x1b\x10\x1b\xbb\x0dV,e\xcbT\x06:\xa9\x06k\xc62\xd0S5X\xf66\x9a\xee\x12`\xca\xde\xcfO?\x94\x9c]\nY![8s{\xeb\x1c\xbc8\x9a\x07\xd8\x19!\xcd&\x01b\x17\xe1\xe8l\xccm\xe6|\xf6)'Q\x16d\xc8\x01\x81\xcd\xa0\xc0j`\xe0\xa4\xaa\x1e\x9cT5g*'Uw$U\xdf\x08N\xee\n\xd6R\xc2p\x16\x17\xdc\x8eDh$W\x8b\xcd\x83#\xb5)W\x1bq\xb4\x057\xdbp\xb2\xcec\xd8\x05+\xa62W\x0fV\xf3\x07K\x1a\x80\x8d\x92\xb0$\x85\x00+Ea\xbe\x97\x04\x8c\xab,L\xd5\x85\x9d\xc20\xdf\\\x02\x8c\xb6\x98\x00KF\xb3g5+\xd51\x88\xdd\xac\xd4\xc7\x80\x1eGV!6\x8c\xff^0\xb6R\x8f\xa0\x91\x15\xbb\xc4L\x95\xd0\xc8_\xc7\x81&\x86R\x83)\xbf\x1bq\xba\x05\x8f\xdbp\xf7y\x10I\xd3\x0e\xfa\xc0\x92\xc1\xd4\x11\xe8>\xb8\x0b\xef\x7f>~\xf7\xf2\xc5\xf4\xe7\xb3\xb3S\xc3\x96\xef\x8e\x7f{\xf1\xf6\xcd\xf4\xf4\xed\xbb3\x83\x96Ud\xd9\xaecl\xc4\xb9\x0fZ\x93}\n/8\xaa\x19-\"\x98\x82)\x8d\x10\xf2\x80\xd9\x8cz\xf1\x8a!\x81_\xf2\x19M\"\x9a\xd1\x14N\xa2EBS\xccnh@\x8b\xa4\x92\xf1)\xfa\xfc-\xf6\xe9i\x9c\x98L\xc1\\|08[\x06i\xb1\x10lt\xcb\xf8\x92{\x9a\xab!\x06f\xf3\x0eV\xeb\x90;\x9b\xa9\x0f\x97K\x1a\x89(\x0b%)\x8f.\x8b\xb4\x0fU,\xbd\x05\xe63zY\x0e\xbb\x9e\x11\x81u>\x0b\x03/\xdc\x00\xe1\x99\xa4\xc1,\xc4\x9b\x02'\xa7\x90\xd2\xe4\"\xf0\xf4MLF\xfb\xae\x90\xd4\x1f\xb8'\xa51\xd80\x04rA\x82\x90\xe0\x06Y\xf9\xbd\xb9\x94I;yr\xfbQ\xecS\xa0\x99w\x0b\x81*\x98\xc3<\xa0\xa1\xcf\xd6)\n\xc2Z\x99\xb0\xff\x8e3(t\x9b\x88Sb\xc6\xb6\x08.h\x04>\xc9\xc8\xdd4Kr/\xcb\x13]3/\xce\xfb\x12p\xbb $\xaa>\x83I\x00&\x8f\xa9\x84u\x12x\x08\x1b\xc2H\xd3\x98\xe9\x18\x9fF1R\xee\x1b*\x16\xb2\xc2Q\x17LQ\x9b\x8b\xf1\xe7q\x101\xe5\x11D|\x83f\xf19\x8dD\xe2\x10\x11\x04\x08\"\x9eC\x8e\xb4_HTLnr\x0b\xc3\xe9\xbf\xbd={\xf9\x14\xce\x96\xb4hU\xf3=\x89\xe0$\xcaD\xf2\x0b\x02Q%\xecR.\xe6\xbc<\xcd\xe2\x15;9,c\x1f3\x90F\x9eE\x91\x8e\xe2\xc3l\x03\x8bx\x11\xaf\x938\x8b'J\x1cXyS\xca\x9a\xd2J\xcc\xa3 \xbb\x03Y\x9c\x91Pl8~F\xe2\x9c\x0f\xf1\\\x83\xac\x94\n\x92\xcf\x8a1\xf1\xb4\xa4\xf7k\xea\x95}\x16\x89{k\xea\x05\xf3\xc0\xe3k\xdb\xafWt9\xb1(\xd6\xd4\xed\xf823\xf6\xb5\x18Us\x88\x81\xdfL\x88m\x0f\xb8J\x7f\xea&\xc62\xfe\x8f/\xa7\xc4\x93\xc8/\xa5\xb8P\x8b\x87\x1d\xde\x1aH\xbdx\xad\x90u\x08:_\xc9\xf3o\x11\xed\xcb\xf3\x93\xa0\xda\xc9\x0b\xb6\x01\xd96*\xc8\x08\x81O\xa3,\x98\x07\xbd\"^\x91\x98\xab\xe9\xf8\xcb\xdd\x1ePd%j28\xefB|A\x13?!\x97\xfd\x08P\x19\x9e-1\xfd\xdf\x88\xdb\x05\xc5\xca\xf0\xdc\xc0\x13\xf1\xc7BH\x16\x9f\xe8\xae\x0c\x88t\xcd\x02\x0dO\xd8,\x96X\xec0n\x1f2\xd9].x\xaaL\xdc\xac\xb3\x1e\x0b\x8cE\xde\xa3\x0e\xa7\x92\xb2M\xd2\xd6C-\xff\xa2\xc5\xad^\x96Vre!f\xea\xecLv\x10\xe0\x82\xa3D\xd8\x83cFB\x12\xc9,\x92\x11d\x80\xc6\xda\xd0n\x08\xbdU\xa1E\x81\xb3\x1eL,\x06\x8c=\x80\xb3\x01:\x1a^\x82\x0b\xa5\xf7mt=\xbf\xe37\xa7IBw\xa7\x05\x1c\x07\xdcd\x0eHi\x96\x85;\xbf\"T\x88=S\x11%3@\xff\x96\xd3dS\xdf:zW\xdc\xdad\xa4-op\xf2\x81\xf3.\x98x\xe5\x0d\xf6\xb7.\x8b\x96\xf0\xee\xf4yI\xda\xf2O\xa5\xc2k|\xd9\xbe6\x1aA\x1e\x89\xf4:\xea\x03M\x928\xd9\xe5\xedQ\xde\x81\xcc\xee\xeb]\x1d/\xf6{\xa4\xba\xfa`\xdbX\xcb{G\x9d_W4M{Cz\x8a1\x14\xd7\xbcdm\xae\xf7B\x17k>\xcd\x13i|J\xcb\xe9J\xf7\xbf\xb6uo\xb4jM\x12\xb2\xa2\x19M\x1ac\xbe+\x82\x89\x10\xf8\x13n\x836\xb0\x05\xd1S~?\xbaI\xb4r\xa7?\x859 \xd3\xa6\xfc\xe8\x1dR\x03\xbb\x9f\xd2O\xe3\"\x97\xdc \xcb\xc8\xa25\xbf\xbf\x15\xbd\xe0n\x8e\x87AZlC\xf5\xcd\xf1\xb4\xe7\xea\xb8\xe6\xcex\xf9\xf3Wpi\xfc\x86l\"\xd5-v\x01Z\x8bA\xdf \xe0\xee\xb5\x0b@\xf4\x07\xc8>\x01s\x1f\x13p\x9b]\x80\xee^&\x98 C\xdf\xcf\x1c\xed\x1e\xbc\x00\xe5MG\xc0\xcf@\x1fo\xd2\x9dp\xcb\xaf\xd4w\xbe\x8b\x8f\xd4\xa72\xec\x99\xb6\xfc\x14c@\n\x18\xef\xf6\"\x98\xdf`\x84\x9d\xdd\xa4/q\x8f~\x9f^\x80\xf15A\xe5\xadz\x01\xca\xbb\xf5\x02\x90\xac\x8bJ4\xd1{\x16\xc1\xbc\xc7aw\xa3\x8do\xe6+\xe4q\xb3\x06K\x1bd\xd7\xf6\x05\xa8\xd4\x94\x00M\x0c\x1e%\xe1q\xf2]w\xa9_\x00\xaaC@w\nX\xb5\x82f\x0e@\xaa\x16#\x84\x06\xea\x05\x10E\x00\x04\xa8\xcf\x1b]\xc00\xbd\x00=\xeb\x0b0-\x0e\xa0A\xc7v\n\xbeD\x80\x00\xad\xfa4X%\xbd\n\xc5*Qm\x01\x81\xf2#M\x19\x81\xf23\x93\xdb\xe5E\x13\xadN0R\xd1fJzl5m\xa5\xa8\xc7+8Pb\x1b\xb7\xec@\x89\xf5\x9a\x8b\x0f\x94\xdd\x8eV\x82@\x80\xb1\x85!/D @_\x8e@\xc0\x0e\xd4 .\xdd\x18-V\xf0\xc5\n\x04\xa0g\x04F\xb3\x02\x93\xf2\x05\x02\xb0z\xa0\x04t)\x03$\xbe,\xb6)h \xc0\x88\x8a`LI0*q @o\xabm\x83Q\x06%\x98\xb1e\x0d\xa6\x0b\x0d\xe3\x16@\x10`v3\xbf\x06|1\x04\x01\xdf\xd82\xe0J%\x18`l/\xa0\xd5\xb2\x98f\xd3\x9b.\x89\xd1r\x18K\x02\x1bY`\x9c/o\xc5 \xc69\xf2\x16\xbd\x8c\x9c\x17o\xca\xd3\x88\xc2\x0bHL\xcd\xf2\x0c\xd8\xf2\x0b\x02\xac\x8a0\x080\xaed\x80cz4\xc3\x1b2\xbb)\xa3\x1bLO\x80\xe1x\xc0bL`R\xbaA\x80\xc5\xa8\xc0rd`^\xccA\x80\xe5\x18a\xc08\xc1\xee\x8e\x19\xd8 \x9a&\xa0\\\x80\xfd`*`j\x18\xfb\xce\x19X\xdc;\x03\x0bmY\x83\x89\x08i\x03Z\xa0\xb4a\x00S\x0ecKc\xfdZ\xc3@\xd64\xd6\xb95\x0c\xeayd=,\xc0n\xb3\x8c\\DB\x80\x91A)\xc0\xa4\xa0\x84\x00K~\xb5\xe5T\x9b;\xc4`?L\x180Tp\xb2\xde\xc9z%\x0c`\xcaal\xe9d\xfd\x17\x94\xf5\x88\xd2\x16F\xf8\xca}f.\xed\x8d\xca\\\x08\xb0\xdb#\x16\xfb\xc3zo\xd8\xef\x0b\x9cW\xba\x0b\x03\xd8\xd2V\x99\x0d\xa0\x0e\x0c\xa2\x10\xd8\xab\xb4A\x84\x120@\xad\xd9\xeeU\x01\xbbPmv\xcam\x88z\xb3\xdd\xbc\x02,\xb6\xb0\x80A\xac:\x94Y\x07(\xba\x11\x18v\x80\xb2\x1b\xdc\xfbN\x14\x9e\xfd6\x1a\xb5\x10\x87\x00\xabr\x1c\x02\x0c\x8br\x08\xb0\xdb=\x16\xfb\xc6z\xc7\xd8\xef\x15\xd3\x92\x1d\x02\x06\xb1(&\x17\xa4\x0f\xec\x8bx\x08\xb0-\xe5!``A\x0f\x01f\x99\x1e}0zq\x0f\x01#\x97\xf8\x10p\xfd\x85>\x04\xd8\x8a*\x18\xbf\xe8\x87\x80QK\x7f\x08\xb0\x9d\xe3\xe8e@\x04\x18\x14\x03\x11`>\xfe\xb1\n\x83\x08\x18\xb1<\x88\x00d\x91\x10<>\xc1%\x16\xa5B\x04 \x0b\x86\x08\x10\xf2\x1c\x9b\xed(\x00\x9f\xf3X\x02\xb2\x84\x88\x00\x0b]h\xa3\x05\x0d\x8a\x8a\x08\xb0R}\xba\x8b\xa0\xdb`\xd1\x8d\xadr\xc1^\x1fE#D^3\xdd\x06\xdc\xc5S4\xba\xa1EH\x04\xd8\\N\xed\x82\x99\xb43(K\x82\xc2\x17\xcfu\xc5I\x04\x0c.Q\"\x00w\x9d\xc0\x80\xc5q\x92\x06Cc\xf3\xb2&\nd\xf24K]\xd5\x13\x01\x08 \x87\x91h\xd7z\xcbLS\x19E\x00za\x95UR\x04 q\x0d\xaa\x98\"@{\xd3\x015\x14m\xd2<\n\x0b\xe6\x90\x84K\x97G$\xcb\xa3\x12\xdauuV\x04\x18\xa4\xbd\xe3j\xae\x08\x18\xaf\xf2J\x89o\xdc\xfa+%\xd6]Ta)q\xef\xae\x16\x8b\x80\xe1\x15Y\x04(\xeb\xb2\x08\x18Y&\xa1L8\xe4\xb6\xc3\x9ajHt&&\x19\xd6\x0c+\xcc+\xc4$t\xa6\x17\xce\xdcj\x98QJl\x86&\x96\xbdY\xa5\xad\xfdR|\xe6\xb8\xac\x07\x1c\x97!\xb9LW_F\x00r\x850\x16\xec\xb0\x8a3-\x1c\x12\x1e0\xad>#G\xd2\xa8H\xd3W\x83F\xc0\x9a,\nf\xda\xa6\xa0rs\xaa\xb7dD\xaf\xb2\xa94\xb8\xa3]\x10m,\xb1\xa0\xa1\xd4$)\xfb/\xb5.\xfbg\x16\xc3\x8c\xc2\x9a\xa4L\xdfg1\x9c\x92\x05}G?\xe54\xcd&\xe2w 2^\xb7\x84\xa3ah\x19\xc9(\xac\xe24\x03Z^:\x0b\xfbb\x0e\xfc,8\x90\x00\x8a\xcb\xb2\xba\xa3\x948\x8a\xb2\xf9\xf3\x7f\x14\xcfS\x8bcf\x1efi\xed\x8f\x83@v\x82j\x92\x88\xb3\xf3\x94#\x93m\xe7K\x92\xb2-y\x07\x82,-BX\x01;\x19\x0bQ\xe6C\x9c-ir\x19\xa4\xdbk\xaa\x97\x8eb(\xf5f\x10\xabIW3\xea\xfb\xcc~\x8b`\xc1\x98\xbc\xda#EE\xa1\x94\x99Z\xbd\xde8\xb6wz\xfe\xec\xc5\x89\xc0\xe1\x07\xd1\x82\xcb#\x9af%6X\x92\x14r\xc6?M\xca\xf4\x92\xa3l\xf1>^\xd5\xe3\xfeS%\x07\x13\xba\xe6grxF\x92j\x91~\x82\xc3\xff\xa9j\xd4\"\x0b\xe7\xcc\x9f\xe0\xa8\xb7\xc5\xbfZ\x7f\x94qOG\xfc\xa4\xa6\xf2\xa7+yRW\xfe\xaa\x00W\xfeJ%\xf0\xae\xb9\xfc\xd5<\x08\xd9\x0f\xbb\xac\x81Uvqm\x85\xb0\xb6\xbb\xee\x9e\xb2G\xe8\xbb\xec\xa2\xb6\x1b\x98\xeel\xb4R\xb9\x0c\n\x85L\n\xdd\x90\xd0,O\"!\xbc\x9brlRio.\xe4\x17A\xdb\xc2\xe53`\xc2Y\xad\x91'\xf06\n7\x10GT\xdc \x9c\xa74\x838\x81\xf6p\xa1\xbc\x98?\xa3LuM\xc6\xa5\x96\xc4\x92\xe9!\xa2\x18\x9f\x8c\x8e\x1d1]L\x86\x932\xcaW4 \xbc\xf2oF.\x10\xa0K,\x15\xac\x81\xc1\x87\xbd\x8b\x80-\xa9\xf4\x95\x91\x13W*\x89\x93\x17\x81\xce\xaeD\x12\xf6\x86\x14\x96\xb4(\xb2\xa2w\x9c\xc9\x9eC\xdf^2ZP\xf4\xad$\x03\xac#\xdd6\xc2\xf2\x1a\xa2\x84Q\xab8\x91n\xf4\x98\xd2E\x16%\x8b\x10\xb5|0L\xa8e@$\xf3a\x19\x0f1l\x01\xc8~\xc1\xa0o\xc0\x97\x1a2\xe8\x1d\x0cG\x00\xa6%\x85\x0c\xc7\x02\x16\xe3\x01\xf3\xbb\xb7\x06\x1b\xb8 \xda\xd8\xf86`7n\x0dc\xde\xa95\xb9I\x8b\xd5\x0e5`\xb6h\x1b\xb4\x1b\xb6\x0d\x16\xccc\xc7>h}R\x83%\x0b\xa1uL\x0dV=\x8d\xa4wZ\xc8\x90L\xa6B\xdeb\xd6`5s0\x17\xf5V\x04\x10`!\xeeM\xf7\x8a\x801E\xbe\x99\xd0\xb7\x11\xfb\xa6\x9bG\x80\xc1\x16\x12`\xc5R\xb6Le\xa1\x00\x060\x96\x85\x12\xb0\xeemTE`\xce\xde#\x96\x80\xb1(\xfdbT\xf2\xc5\x8c\xab\x0d\xf8\xd9\x98\x93\xcdy\xd8\xac\x94\x8b\x15+\xe9o%\xb6\xc1\xb6d\x8b]\xa9\x96A%Zp\x91\xd4>\x18\xb9$\xcb\xa8\xa5X\xae\xbb\x04\x8b\xa9h\x80\xb1K\xae\x8cXj\xc5t.#\x97VA\x97T\xc1\x8f\x13UB\xa5\xf6\x02k\xf1e\xc3J\xa7 K\xa6\xf4\xe5}\xf5\x81q\xa9\x14T\x89\x14!'u\xd95\x02\xf496%\xa0J\xa1\x18\xe8\x0c\x13m\x81\xba\xc9\x08\xa6*\x02w\xa3\x11\xcc\xd0\x9a\n\xe51o7\x02\xfa\x86#\xa0o9j\xd1\x0c+Yb\x7f\xdb\x11+E\x0cJ\x93\xa8\x8bg\x80\xba$\xc9\xc0R$\xba\x12$Z\x16T\xef\xe4bt{\xe6\xe5D\xc4W{\xb7z\xb0\xf1\xe4R\x8eQ{1\xaa\xb8\n%\xbaw\x97\xa0\x04\xb8KP7\xe8\x12T\xe0\xef\xf2\xfeS\xe0\x7f\x89\xabO\x81?Y\x0c\xefu\x9b}\xfbd\x8d&\xf3|E\x92sZg\x9d\xcf\x02_\x97s\xfe,\xf0\xab\x8c\xf3Y\xe0\xab\xf2\xcd\x9fU\xb9\xa676\xdb|\xd6\x97\x16\xae\xdcb\xea\x0d6\x0b|\x97i\x0e\xd7\x96i\x0e\x10_S?er\x8f\xae/\x05\xedp\x85\x8a\x9e\x05~'5^\xd8\x98a(\xae\xa6CJ?\x15y\xee\xb2sUk\xf3\xb0=Z\x1f\xc9\x7fe\x07\xd8\x1fN^\xfc\xd8g\xc1\xdd\xd0$y\xe5\xab\xfcw!\x8c\xa5\x99\x80\xdfEZ\xfc\xb3\xc0\x97$\xc5\xb3\xa5W\xa7\xc4\x0b\xd2r\x1coH\xe6-{\x93\xca\xf5h\xd8\x12p$\xbf\xc6i&\xc1\xa0X\xa6Fz\xfb\xb3\xc0\x97&\xb73,c\xa6\xb6\xcfz\xd7\\q\xa0\x1eA\x80k\x8e\xcc\xdam\xa6?\x1ekQ\xe0X\xda\xf0\x00\xac=\xe0\xe2\x8e\xb5\x9dc\xab\x04\x17\xea0ks\x84\xbd\xa6\xd3\xde\xb3\xc0/\x05<\x97\xf6wZ\x9b\x9f\x90?n\xfd\xbf\xbf\xf5\xefh\x87\xedt\xa6R\xd1\xdc\xeai\xc5\xfd\x88\xdcX\xc6\xa6\x12\x083\xdb\xe5\x12\x08p\xb9\x047(\x97\xc0]\xf4\x1f+\x82\xff\x1d_\xf4/b'\xea\xab\xfe\\\x08\xa6\xed\xe0\x89\xfe\xba\xbfhu\xab\x9c\xc2M\x8e\xa1\xdc\x10 $\x89\xe7\x08\xd0\xda5z\xfc\xa0\x8d\xf0\x08@t\x05\xc8\xee@\x1f\xf3\x11\x80\x90\x8f\x02\xdc\xb5\xff~\xd8M\xcf\xfa\xa8\x91\x00$\xc5\x07E\x90\x04\xdc\xbc\x9bp\xa8;\xf6\xf8pF\xd1@{}\x0b\xe5\xfb*?\xc5\x9c&\x04\x8c\x15}\x12`\x14\x83\x120f$\xaa\xc4x\xad\xf1\xa8\xb2\xd3\x91\xa2R\x02F\x8bM p7\xec+0\xd9\x1c\x86\x07n\xc4$\xbe\xd1kN\xba(\x98\x00\xe4\na\xd4\xd58q1\x01\xba\xe8\x98\x00\xc4\x0e\xc1\xec\x0e]\xbcL\x00\xa23@v\x08\xfa\x08\x9a\x00\xe4\xea\xdc\xb0\xfb\xf6\xba\xf8\x9a\x00\xd4x\xb4\x86+\n\xcb\xcd3X\xb4w\xce\x11\xd6\x87>6'\xe0\x1a\xac\x94\x81\xd1:\x01\xf8\x98\x9d\x80\xddD\xeeJ\xdc\xbb\x8b\xdf\x95=\xec:\x8a'\x00\x19\xcb\x13 \x8f\xe8 \x18Y\x06:\x93d\x0b\xbei\x93\xc4U\x90h\x80\xe30)\xd8s\x98&2)\xc0\xf1X\x1f8\x1eC\xf1\x98]\xf4\xb3\xd5VU\xc4\xc1.4\xda\x8b\xcf\x15rp\x85\x1c\\!\x87\n\\!\x87>\xee\xa9\x85\x0e\xba\xb6C\x11\x8b\xdc\x16;.?\xc3\xe5g\xdc\xa8\xfc\x0cW\xeb\xa1\x00]\xd7\xa6\x89\x13\xae\xd6\xc3\xf0.\\\xad\x07\x0c\xb5\\\xad\x07\x01;&\xae\xbeJ\x81\xab\xf50\x06\x15]\xad\x07W\xeb\xe1+\xaf\xf5\xc0\x07\xa0\xab\xf5\xf0\x96}T\xa5+\xf2&\xaaZ\x0f\xfc\xf3[\xe5\xd8oh\x9e\"\x9f\xc5\xa8^\x13\x8eq\x97\xd74]\xad\x87.\\O\xad\x87\xe2\xb4\xcd\xd9z\xc8\xc397\xf4\xc2\xa8\xa6\x9c\xc37]\xa3A\xc4\x9c\xf9\xcaJ^\xa3\x11\xd2\x0e\xf7.?\xc7#\x7f\x8bF\xa0Z\x89\xdf\xe5\xd8\xcaX5\xc7&Ms\x13\xc8\xa4O\xd2\x18\xa7\xb7\xc5\x89\xdf\xbbI\x98b\xdf\x99D\xe3\ny\x88<*T#\x8f'\xe8\x10iBD\xfa\xd1B\x11h\xa0\xfet&\xf1\x8d\x97\xa0s\xef\x96\xf0\x9e\xa3{\xb6\x810H\xb9\xc5vN7ia\xfd\xd1\x88DY\n\xc2\xa7\xc6\xd6jIt\x89\x99\xcd8\xc8<\x89W\xea1b\xa8\x02h\xca0 a8\x8d\xe7\xba\xaf\xd4\xee\xae.H\xdd_]@\xb0K\xe3c\xe4\x02A5+.\xe6\xf9\xf2p\x93\x8e\x1d\x0f\xd9\x9a\xad\xf24\xe3+S\xb0\x06\x06_\x96%\xc1,\xcf\xa8&\xe3\x15H\xb4\xf9\x16\xc9\xc9g\x05$\xe3\xc9\x83\x998=\x97q\x1e\xc1\xb7\xfc\xbf\x18y\x11\xe8\xba\x0b\x80#o\xfd\x91f##I\x8b\"+z\xc7\x99\xec9\xeeF\xd2\x7fd\xb8\xa0J\xdfn\x13\x0c\xb0\x96\xc9\x88%\xe9!\xa1\xeb\x84\xa6\xfc\xde\xeb9\xdd\x14\x87\xfc5 \xd4\xd7-\xb0\xbcV\xf7S\n\xd7z\xd1\x0b\xe9Z\x08W\x84\xb0\x14\x11\xe9\x1e7e\xe7\xa3\"\x9e\x1c\x12\x8f+\xa5w\x0d\xfd$i\x94\xd04\xce\x13O\xb5\xd0\x18&\xd42 \x92\xf9\xb0\x8c\x87\x18\xb6\x00d\xbf`\xd07\x03o\x9d\xeb?2\xea\x1d\x0cG\xc0 \x8f\x02\x95\xe1\xd1\x06\xc3\xb1\x80\xc5x@l]\xfc\xc7F\x1b\xb8 \xda \xff6`7n\x0d\x1f\xa2\xa0J\xca\xf0\xd6\xf9\x1dX\xd1U\x9cl\xf8\xa9\x8b\xfd\x99,\xb0}\xf3xf\x12x:\x95+\x00\xab\x1dj\xc0l\xd16h7l\x1b,\x98\xc7\x8e}\xd0\xfa\xa4\x06K\x16B\xeb\x98\x1a\xacz\x1aI\xef\xb4\x90!\x99\xf8\xf9\xe9\x87\x92\x7fK\x81)d\x06gao\x9d\x83\x17G\xf3\x007\x17\x94a#@\xec\x13\x0cm\x0d\xf9\xca\x94\xa3>\xe5$\xca\x82\x0c5\x140\x1f\x0eX\x0c \x9c\x8c\x94\x81\x93\x91Xp2R\x8f\x0c\xc9\xc4o\x04\xbfv\xc5d)98#\x0b\x9eF\xa13\x90\x92\xc5\xf6\xc0\x90\xd7\x8cw\x0d\xf8\xd6\x98g\xcd\xf9U\xede\xeb\x82\x05\xfb\x98\ny\x8bY\x83\xd5\xcc\xc1\\\xd4[\x11@\x80\x85\xb87\xdd+\x02\xc6\x14\xf9fB\xdfF\xec\x9bn\x1e\x01\x06[H\x80\x15K\xd92\x95\x85\x02\x18\xc0X\x16J\xc0\xba\xb7Q\x15\x819{\xbf\x17\xec\xab\xd4\x06HT\xc5N0Q\x084\xf2\xd7q\xa0\x8c%\xd4`\xc6\xd5\x06\xfcl\xcc\xc9\xe6<|\x1eD\xda+\xc65X\xb1\x92\xfezm\x1b\xee\xc2\xfb\x9f\x8f\xdf\xbd|1\xfd\xf9\xec\xec\xd4\xa8\xdd\xbb\xe3\xdf^\xbc}3=}\xfb\xee\x0c\xdd\xae\n]\xdat\x8a\x0bi\xf6Ak\x92O\xe1\x05G4\xa3E|N0\x9f\x01:\x1e(\x9aQ/^\xf1[>\xbf\xe43\x9aD4\xa3)\x9cD\x8b\x84\xa6z\x8eo@\x8b\x90\x92\xb1)z\xfc-\xf6\xe9i\x9c\xe0\x87o*\x1a\x18\x9c-\x83\xb4 ?\x1b\xd92\xbe\xe4~\xd9jx\x81\xc9\x8c\xab\xabHe\xde\x12\x8f:\x88\xe2$\xac\x97u\x18oP\x01\x1d\xf3\xb9\xbc,\x07\\\xcf\x85\xc0:\x9f\x85\x81\x17n\x80\xf0\x04\x98`\x16b\xd5\xf8\xc9)\xa44\xb9\x08<]\x03\xfc8\xdf\x15\x92\xf7\x03\xf7V4\x86\x19\x86\x8d\xe4\xb1\xca\x0b\xac\xc5\xc7dH\xca#\xd7\x82\xb0\x8c\xee\xfbQ\xecS\xa0\x99\xa7\xbe\xdc\xc5 \x98\xd7\xf7\xc9\xa2 \xac\x15\x03\xfb\xef8\x83BG\xf5\xa5[\xf5\xc1\"\xb8\xa0\x11\xf8$#w\xd3,\xc9\xbd,\xef\xbdeR\x83\x87\xbf\xc7\xa7K8\x11\xa0O;)A[Z\x06\xcct\x86\x89\xb6@\xdd\x86\x04S\x15\x81\xbb\x15 fhM\x85\xf2\x987$\x01}K\x12\xd07%\xb5h\xdaUcMnK\xc2\x80\x1b\x93\x80\x96\"\xa5\x04)m\xb9<\n\xb2;E:\xaa\xc8P\xad\xca\xc6@,\xbb\xc3&\xa0\xdc\xed\xbd\x1f\x15\xa3y\x9d\xc4\xf9\xfa\xfd\x9aze\x7f\x0b\xf6\x07\x9e\xbf\x12\xcc\x03\x8f\xafe\x9f\x98\xd2U\xd6\xd1\xb2 \xee} \x91CY\xe6\x8e\x89T\xb2;\x9d\xf4\x1bN\x10\x91IV\xa4W\xb6\xeb\xe9\x14\xb8xF'\xc7\x87\xbd\xe4%:wUw\x05\xb8[]*v\xbe\xe6[]\xae\xea\xeeXw\xa9\xae\xb3\xea\xaeU\x92\xb9\xba(.\x97Qi;\xcb\\_\x14W\xb4\xbaU\xce\xed&'\x9b\xdf\x10\x01\xa1NS\xd7\xa2\x07D\x17\xa0OVG\x89\x12]\xc2:\x12 2i]\x97\xb6\xaeS+5\xe0l{]\x11\xda1{\x1b+\x85]S}\x0d\xb1\x1cj\xb7\x90.\x95]\x93\xcc\xaeMg\xd7$\xb4#S\xda\xf1\x87\x8d\xb1\xd2\xda\x0d\x13\xdb\xc7Jm\x1f;\xb9}\xb4\xf4\xf6\x11\x13\xdcU)\xee\xa3IC]\x08\x0e\xb1q\xb0\xc9\xee\xa81\x03r\xdc\x80Oy\xc7\x1e\x0b\xc10\xed]\x8b\xac\xca\xfd\xc5&\xbe\xa3)\x04\x06T\x02\x83\xf4w\xb5\xe2\xdf\x06\xe3\xd8\x81V!V\x9f\xa3\x97\x0c\xd0\x89\xf0(T&\xb9\xda\x02\xb0\xc9\xf0_-q\xc7M\x8b\xb7M\x8c7\x89\xf0\xe2 \x8d$\xb2\xc1\xbe4\xdb\x99\x06\xf1Z\xc3E6\x88\xcd\x1aa\x1e-\x0e\x8b\xe7\xc2\x91\x13\xe6\x91)\xf3VI\xf3\xc8\xfcs\x1c\x83\"\x98\x13\xcd\x98x\xa6DM@\x00\xbaw0\x1a\x01\xe0\xd3\xe8\x0d\xc7\x00\xc6\xe3\x00\xd3dz\x8b\x11\x81\xd5\xa8\xc0\xe5\x10\xe9\xc1\xe5\x10\x993\x95\x81N\xaa\xc1\x9a\xb1\x0c\xf4T\x0d\x96\xbd\x8d\xa6\xbb\x04\x98\xb2\xf7\xa8I\xf7F \xa5&\x89\xf7\x16\xdcf\xceg.3\x93\x83\x93\xaa\x12pR\x95\x835c}GRu\xe44}C\xb9j\x90\xaao\xce\xd5F\x1cm\xc1\xcd6\x9c\xac\xf3\x18v\xc1\x8a\xa9\xcc\xd5\x83\xd5\xfc\xc1\x92\x06`\xa3$,I!\xc0JQ\x98\xef%\x01\xe3*\x0bSua\xa70\xcc7\x97\x00\xa3-&\xc0\x92\xd1\xecY\xcdJu\x0cb7+\xf51\xa0\xc7\x91U\x88\x0d\xe3\x8f\x98\xe0o\x95\xe2o\x98\xe4o\xce\xefF\x9cn\xc1\xe36\xdcm\x96\xeeo\xcd`\xa6)\xff\xf6I\xff\xb6i\xff\x03\x13\xff\xf1\x81\xdf>\x189\xf9\x7f\xe4\xf4\xff\xeb\xbf\x00`#>`\xecK\x00\xa3^\x03\xb0\x99\xd1\xc8W\x01\x0c.\x03\x98\x8d\x16u!\x00\x81\xa7\xf2{s)3\xe0J\xc0\xe8\x97\x02,\xae\x05 /\x06\x94\x12U\x9f\xcc#\x00\x93\xd2S\x02\xeaz\x80\xa1\xa61\xd31\xe8K\x02\xc6\x8a\x05\x7fQ\xc0\x10\xb5\xb9\x187\xb9.\x80@G\"\x83\x0b\x03\xa3]\x19\x18zi`\xd8\xb5\x01\xbc\xbc\x19\xf1\xea\x80\xe6\xf2\xc0\xe0\xeb\x03\xfa\x0b\x04(\xd6\xd4\xed\xf81\xaf\x11\xb8w\xa3\xdc\xbbQ\xee\xdd\xa8\x16\xb8w\xa3\x8a\x1bE\xe8w\xa3\x8at}\xf7n\x94\xbba\xd4\xf3\xfbM\xbaa\xe4\xde\x8d*@\xd75\xee\xeaO\x0fa\xbf\\\xd7\xeeE'\xf4\x0bD\xbb~t\xc8\xbd\xe8\xb4C\xe2\xea\xdf\"r/:\x8dAE\xf7\xa2\x93{\xd1\xe9k{\xd1\xa9\xcc\xb0\xae\xae\xdb\x96\x7f(\x1a\xf5]\xb6=-?\xa9\xee\xdbV\x8d\x8aO[\xb7lO;?\xde\xd8\x8b\xb6\x9d\xa97\xe1K\x98\xca\xcaK\xb0ZKw\x19\xa7\xd94O\x02k\x04\xfa\x00\xbf\x8a(\x024\xe1L\x0d\x81\x04\xe8\xc8$@\x1b|\xd7\xceW\x00\"\xa8\x8e\xc240X^?\xa9\xb6\x0d\x08\xaaahFW$Pf\xc7\xa0\xe6yIgi \xbf\xd3\x0b8<\xe5%\x8eb\x03\x9eD\xf3>\xc7Z\xe7\xab\xed\x8b\xc8\x8c\xe7;o\xcb\x95\xe0\x9c\x96\xcei\xe9\x9c\x96\x0dpN\xcbdSY&X\xbfe\xd7\x94)\xc1\x15G\x12\xe0\\\x977\xc8u\xe9|Pf\x07|\xe7\x83\xda!q\xf5\xde\x13\xe7\x83\x1a\x83\x8a\xce\x07\xe5|P_\x8d\x0fjO\xeb\x84\xda\xff\x93\x9f\xee\xfeU8\x87T\xde\xa8-g\x94\xea\x95\xf1\xd3va\x81\x1b\xef\x92\x1a\xf5\xd0\xaap,i\xac\x10\xb5SI\xd3X\xe7P\xd2\xb9\x93\x94\xce\xa4\x91\x9c\"\x1a7\x12\xc2HC\xb8\x90\x10X\x06\xb9\x8f\xe4\xce#-\x95\xf44\xd2\xb8\x8d\x10s\xd3\xba\x8c\xb480\xee\"{g\x11\xea\xc8hzbt\xb9.\xee\xc0\xd8\xf7\xfbM:0\xf6\xe5\xb8\xacI\xd6\xcc\x0c\xae\xf5>\xb33\x1a?\xf4\x8cF\x1ay\x8ab\x9fNk!\xd5P\xea-\x86g\xdb\x9a\x8d\x9f\xe7E\xcf\xe2\\X\x9f^\x1cEb\x0b04E\xbb\xca\x188\x13E\x83\x8ae)\xed\xcd\xde6\xdd\xe1\xbd&\x01\x81w/\xdf\x97\xf7\x81\xd6I\xec\xe7\xad\n;w\x99m\x1f\x16\xe9\xbc\xfb\x7f\xa4qi\xdf\x18\x9b\x0f\xbf\xc5>\xe5y\xb7yS\xf4\x8c\xb4s\x1b\x83\x9c2\xeb\xb0\xd7\xe7\xad\xe6\xddY\x1e\x84\xfe\xb4M\xa1&hx\xcf\x0b\xd9\xe1t*\xbf\x85\xack\x1f\xafV\x81]E\xf5\x85R\xf3I\x9bY\x0f5\xa5\xc9\x05M\xec\xa7*] M\xdb\xce\x1ej\x82zie\xb5{5\xe3\\\xc5Qpni5\x02\xd0+\xb2Z3\xa5\xca\xcb\x99\x92,N\xee2\x8a\xf5|\xcb\xef\x01xq(\xe7\\\xd0N\x91\x7fq\xb4\x96\xfd\x84\x18/4\xc7\xfcH\xf2\xc9,\x8c\xbd\xf3\xb1:9<\x90|C\xd6\xa3M\xa4\xaf\x8b\x88f\x97q\"\x99\x86\x16}\x85zA\x02r\xb7\xab\xc0\x19xK\x12E\xb4O#\x83\xbe\x830H3\x1aM\x89\xef\x0ff\xbc\xbd\xc3'G\x93\xc3\x87\x8f'\x0f\x1eN\x0e\x9f\x1e=|\xf8\xe0a\xf7^\x03\xe8\xb6cK\x84\x9f\xd1\xc8\xa7\xc9*\x88\xb2\xb2\xd1\xc0\x11\x1eL\x0e\x1fL\xfa\x96\x88G\x93\x10#Z\xc5 \xe5\xb6\x7f\xa94\xe3\xa8\x1cZ\xff\xdd\x93\x11N\x03\xd9\xd54\x88|z5\x16\x8b\xee\xc5Q\xdf\xb20H\xd6\x1e\xe7\x04\x9a*\xceo\x86\xbde\xde\xfa\xe9\xfe\xfe\xc1\x84\xff?\xce\x15\x8f\xea\xee\xf7\x1e\xa8T\xf8+\x12\x84\"\xbe*\xc2\xa6QK\xa5\xef\xa7\x9b\xc8\x0b\xa2\x85h\xde\xe7\xb6x/>\xa8o\xdf(L\x93\x06\xaf\xd5\xc7\x88\xd6h^\xd3\x0c\x02a\xec\xf0\x81\x04)xy\x92p/;\xa4\x9b\x88\xf5\xc4\xef\x9b\x89\x9b=\xec\x9b\x92'vo\xe74f\xba\x0b{\xa7E\xea&\x08\\]\x9f\x9bzY\xdfs}\xce\xcf+IDBq\x0cb\x0b\xca\xa5}\xba\x1f\x92\x8c\xaa\x1e\"xM\x85\x99*\xbe\x13:\xc2dUw\xb9\x1ag\xfd\xe3\x82\xf1\x96\x82\xa3\x9d\xaehFd\xaba\xe5\xb0ZR\xd2\xeb\x03\x03\x1dZ\xd0\xa2\x06\xa1\xa3\x82H\xf1\xa8\x81\xa9X\xf1\xe2t\x15\xa7\xcb|\xd6\xab\x11\x81O(X,\x15WSE\x7f\xc2A\xae\xef\xefP\xf2I\x16\xa8\xaa\x00\x99\xcdi\xef\xe8\xe0\xf0\xd1\xdd\xc3\xa3\xbb\xf7\x0e\xce\x0e\x1e<}p\xef\xe9\xc1\x93\xc9\xd1\xe3G\x7f98|zp \x93\xd9Q\xbe\x9afWZy\x8d\x9d\xa8\xccF\nI\x9aM\x05\xef\xe9Wq\x94t\xb3%I\x97\xaa\xdf\x91\xe4\x85\xe6\xec^\xbe|\xf0\xea\xde\xfd\x83\xfb\x07\xf7\xee?\x7fpt\xff\xc1\xc1\xe1\xc3\xa3'\xcf\x1e<|y\xf0\xe2\xc5\xf3{\x8f_\x1d\xbfx\xf8\xe0\xf0\xd5\x81\xeaJ\xf7\x9a$\xba\xca$(\"\x00\x9a\x10\x0c\x14 @\xad\xcf0k]\x82v\xcdK\xd0\xaf\x04\x98\xac\x06\x8c\xb8\"\x9c.c\xf2\xff\xbd\x07\xaa\x0d N\xcdS5AP\x84\x18\x8b\x00>\xc9\xc8M\x1aOu\xfaLo\xd2\xa8x*\xc5\xcd\x1c\x9a\xc7\xec\x8b(\xcdo\xd4\xa0\xc8z}\x93\x86\xc3\xf7^\x11m\xbdI\xe3\xa2\x17\x81O#\x8f\xde\xa411\x9d\x12\xa74\x19\xe9 \xd7\xb2ng\xd4[\xde;\x02\x1ay\xb1O}(z\xd0OIXk\x87>]\x9f?\xb8\xef\xe5\xe4\x8f\xc5\xf9gJ\x1e~^/\xce?\xdd{\x98E\x7f\\\xfa\x9f/\xee\x93\xb9w\xcf?\x92\xb9\x82\x94n\x03\xc0j]\x9c\xc6\xd5\xb8\x9d\x00K<@\xb9\x9f@\xe7\x82\x02\xab\xfe\xfa\xbaS\x1bpZ\n\xea\xa9w\x936\x82\xdaP\xd3N\x16P\x13\x06\x9cq\x862B@\xb7|%\xe8\x0d2\x14\xa5a\x04jK\xb6\x8a;\x89\xd6\xe0N\xa2\x05\x98M\xd4\x9dD\xddI\xb4\x0b\xfa\x95\x00\x93\xd5\x80\x11W\xc4\x9dD\xddI\x141*w\x125\x1b\x94;\x89\xa2\xc6\xe5N\xa2\xee$\xaa\xd3v7\xea$*U\x94\x02\xfd\xa0\x14e\xe9\xd8\xca]r\xfd=7t\xf6\xceN6\xce&v6\xb1\x14\xd0\xab\x01#\xae\xc8:\xa1\x82\xe7\xb5\xb2_]\xbe_[\xb2\x1f\xb9\xa6\xd8\x15\xad\xec3\xbd\xea\x12\x80\xa6n\x8dY\x93\xd3#\x00\x8d\xb7yx\x97\x1e\xd0\x05\xe8\xdc\x11\x02v\xd1s\x12\xe7\xfag\x0ev\xd1q\x16\xach\x9a\x91\x95F\xb3Yvn\xe5,\x11\xc0\xfbC\x8d %5\xaa1\xc9\\Q\x02\xf4\x8aB\x00rW\x81\xc1\xce\x02\xb4\xc02Z\x0c\x18Qh\xd5\x80P&\x02\x0c\x08\x05\x86\xc4\x02\xbcz\x11`\xc0.%\xa0U\x8d\x00\xec\xfa\x81\xf9\x1a\xc2\xe8\xebX\xd5C\xd7\x8d\xd8`\xa4\xd5\x08\xb5u\xd2\x01\x1e\xe5g\xcf\x1f\xdd\xff[x\x1e}\xfa\xcf\xbf\xbf\xbc\\<\xfa=z\xf8\xe6\xf1\xdb\xd5\xa3W\xf9?\x0e^\xbe\xbd?\xfb\xe3\"\xff\xe3ar\xf9\xf3\xe1\xea\xec\xc3_\x93w\xf9\x9b7\xff\xb88>\xfet\xf6\xe4\xf7?~[\x9c\x1e\xbc;\xde?{\xb1~\x98\xef?9:\xfe\x94\xfcc\xfe\x1f\x7f}\xbf~\xf6\xb7\x9f~\xaa:\xb6\xcb\xb5\xdb+\x93\xed\xfe\x14\xea@u\xfb\xf35\xcd\x80\x08\xa1\x01\x84\xfd\xd3\xa3IF\x82\xa8\xd0$\xc5\xe7c\xa7\xde\xf5\xdf\xa2\xe9\xb9/#.\xd6\xb4\xc6\x02]2<\xe3\x83\xdf\xfaFs\xd5fk\x13]\xdd\xddr\xc3[e\x086hY\xd6\xaf\xdf\x1e\x9c\xcb\x17D\x9ce\xb0\xae\x0c\x17\xa5)\xc1Ei\xf4\"~L\x15\x840\"PD\x004!\x00o2\xa0\xd6\xba\x04\xed\x9a\x97\xa0_ 0Y\x0d\x18qE\\\x94\xc6Ei\x10\xa3rQ\x1a\xb3A\xb9(\x0dj\\.J\xe3\xa24:mw\xa3\xa24._\xb0\x02\xedd\x015a\xc0\x19g(#\x04t\xcbW\x82\xde CQ\x1aF\xa0\xb6\xcb\x17t'\xd1\x02\xdcIt\xf7\xdb\xad \xee$*\x01\xf4j\xc0\x88+\xe2N\xa2\xee$\x8a\x18\x95;\x89\x9a\x0d\xca\x9dDQ\xe3r'Qw\x12\xd5i\xbb\x1bu\x12u\xf9\x82}\xed\x07\x9dl\x9cM\xeclb)\xa0W\x03F\\\x11\x97/\xd8\x05\x97/\xf8%:v\xf9\x82-\xd0+\n\x01\xc8]\x05\x06;\x0b\xd0\x02\xcbh1`D\xa1U\x03B\x99\x080 \x14\x18\x12\x0b\xf0\xeaE\x80\x01\xbb\x94\x80V5\x02\xb0\xeb\x07\xe6k\x08\xa3\xaf\xe3\xb7\x9f/x_\x95\x9dv\x12q\x8d\xd3\xcdF\xdb\xbb\x7fp_\xde\xa8x\xbc\xacHk\x13M\xc1\x8fi\x1a\xed5PX\xe5)\xee\xd7\xae\x0f\x9a\x19\x97\x06\xac\x1aC\xfd\xaa\xd0\xd8y\x8aV \x80\xad\x81\x01\xd9\xaeg\xb8\xe3t@\x99NW0u\xbd\x10\xb2f\xd7[\xf9]ci!\xb6\xa7\xbd\x83\xa0\xe3\x1e\xb8 !\x1b\xeb\xe1\xc3\xab\x0d]\xad\xe9j\xbd~rt\xf5d\xb9\xf9\xfc\xf9\xc9e\xb2\x98?\xb9\x9f<\xfc\xe3\xc9\xf2\xc1\xfc\xe8\xf2~t\x14\xf6\xe2\\\xe73\xf9\x1b\x97\xa8\xd9`\x84L5\\/\x8e\xd2u>;\xfc\xec\xfd\xe1\xe7t\xfd\xe9\xe0\"?\xfa\xbc8_\x9c\xdf\x7fB\xe7\xe4 \xfat\xf99\xf2I\xf4\xe9\xc1\xea\xbe\xf7hM\xee\xe5\xf7\xc9\xfa\xf3\xfd\xc5Q\xf2d\x91\xae?-\x1e.\x9ex\xe9\xbd\xf3'^\xde\xff\xda\xe3E\x9c\x05\xd1b\xba\x8e/\x07\xbc\xae\xdb4\x99\x0e\x0fd\x96Q\xe54Z'A\x9c\x04\xd9($\xec\xf4g'\xba\xf6:\xb2\x0b\x9di\xdd\x11\x0e.\xddzh\xba\xf5\x96\xb4m\xa4];i\xcb\xc1I\xdb\x06 f\xe3\xa4\xed\xee\xa4\xed\xf8\x06\xea\xb3\xf2\xbeEa\x9bFqV?\x85W\xe3\xb0\x14\xf3\xd9\x15\x13\xee$]\xf6\x88v\x9f\xae\x13\xea\x91\xac#\xf4:\x12\xff\xec\nf\x1b~N*~\xdf\x92\xee \x89R\xe2e\x8d:\xf3\x1d\x0b8\xbc\x7f\xef\xc1\xfd'\x07\xaf\x9e\xbdx~\xfc\xf2\xe8\xc1\xf1\xa3\xa3g\xf7\x9e?\x7f\xf4\xf0\xd9\xadr\x04\xa6\xda\xe4J\x94x\xcf\xc4\x1b8\x17\x01\x93^\x9di\x8d\xa4:\xfaO\xcd\xca}\xa5\x16J/\x0e\x1e?8\xbc\xf7\xf8\xc5\x93\xc3{O\x9e\xdc{r\xf8\xe4\xe8\xc9\x83W\xaf\xee?;8~rx\xf0\xe8\xd5\xe1\xab\xa3\xe7/^\x1e\xbc\xb8\xf7\xe8\xf8\xf1\xa3\xe7/\x0f\x1e\xde\xbf\xff\xf2\xe8\xf0\xd1\xf3g\xaf\xee=\xbb\xff\xe4\xe1\x83\x87\xdd\xf1)\x95\x9a\xc4\x9fP\x8d\xf0\xde\xc3\xc7\x9d\x1f\xb3\x1e\xe7\xa6Ri\xa9U\xd6*\xed\xa9V\x0f\x1a\xed :\xdf\xb1F\xac\xcd\xa92T4(Z\xb3 Z\xa7\xb8R\xdc\x92U\x9cG\xda\xac\xb2\x9b\xe5W\xf7i\x14\xaf\xd4\x9f\xa0\xe6^B\xc5~iF\xce\xfb\x9e\xc6\xa9AG.\x016}\xef=\xe8U\xae+\xba\xb2{WI\xe3\xb1\xd2.\x89~1\x10>1\x14!0F\x13\xc0\x9b\x97\x1f\x9e\x9f\xfc\xed\xc5\xc1\xd1<}q\x9a\x90\xc7o\xb2\xd9\xbbt\xf3\xec\xf0\xf2\xd1\xec\xd3\xd9\x9b\x07\x0f\xfe\x9e\x1f\xde{\xfc\xf9o\xb3W\xde\xdf\xaf\xee\xff\xe5\xf9\xab\xcd\xf1\xc9\x82>\xf8\xfbo\xa7\xf3_N\xf2\x8b\xcf\xcf\xfe\xf1\xf0\xc9\x9b\xcd\xa7\x9f\xd3O/\x1e\xbf?<\xb9\x0c^\xae\xff\x12|\x98=\xfc\xfd\xbd\x9f\x85\xeb\xc5\x7f\xfe$\xe9Zc\x13\"\x08 (bB\x89J\xc9/(zB\x93\xa6Yu\x00\xdc?\xcdg\xbf\xd0\xcd{\xea\xad\x8f\x1e<<\x97%\x80\x82\xee\xf5;\x01\xe6#9\xbe\xf8|p\xff\xf7e\xf6\xcb_\x97\x8f\x8f\x9f?\xff\xfdsx\xf2\x98\x9c\xc5\xe9\xeb\xcdAp\xfe\xea?~9\xf9\xfd\xe7\xbf\xdd\xfb\xe3\x977I\x9c\xfe,\x13V\x9exoX\xa8\x11\xdd\x9a`\xd9N\x1e\xf6I\xe9\xa7\\\x1e\xe8\x87\x11z\x129@\xa3\xaa\xb80V\xaa8\xe9X\x17$\x9d^\x92\x88\xd9\xa46\xcd\xdb\xa1\xac\x03\xc9Y\x81u\x92\xa7ct\xf1\xf0\xde\x83\xfb}=\xe8\x9e\xce\x1b\xa4\xe2\x95\xdb\x1c\xb3\xc9\xbf\xdc+\xb7\xeac\xccIy~)\xce3/KG{\x95`\xa3?\xbd N'\xf5\x1bL\x94$\xde\xb2y*\xe9=\xc0\xf4|\xc6_{\xbf\xa0Q\x96\x8ezp\xe9>\xb3-N.\xc5C\xa8\x13\xd1w\xe3g\xc9B\xb5\x06\xdfQg\xcd\x13\x98\x98\x00\xa4\xb9\xb7\x04\x92\xc2^\xbb\x9f\x9fR\x1a\xf9{p\xb9\x0c\xbce\xf5\x9ax\xe7)vv\xd4\x98\xc7a\x18_\xb2\xb3\x1c\x8d\xfcu\x1cD\xd9S\xd8{\xfd\xf2\x8c\xaf\xda\xff\xdb\x87s\xc2\xce\xb8\xe2A\xf9\x166\xfe|\xfe*\xf6\xf3\x90\x82\x1f{\xf9\x8a\x0f\x8f\x9d\x10\xe3\xcbr\xb4\x13\x08\xe3\xf8\x9c?\xb2{u5-\xfe\xb6\xea}\xd3\xdc\x8b\x13q\x86\xe2\xcf\x9a\x0b\x87\xc7\xdd\xd4?\xdf\xf7c/\xddO\xd7\xd4\x03?H\xa8\x97\xc5-\x9a7Nrl\xb4F+\x94r=7\xde\n1f\x16\x87:\x81YP\xb6\xf5\xb9\x8c\xca\xff\xa3=\xa6\x9f\x8adA\x9dc\xea\xe0\xe1\xfa\xea\xeab\xaf\x9f\x1eF8P\x84[\x93\x85\xf4\xa9\xfbS\xb2\xa0\xdbg5A\xd1\xed\xf7\x84{\xfc\xb1\xea\xae\xc3`\x15H\x9d\xc4o\xc8U\xb0\xcaWE\xf7\x10\xcf\x85\\\x865M\xbac\x1em@\xd9\xd5d\x15D[\xde^\x19\xfe\xd6x[\xb2)\x8e\x84o\xb7`\x9d\xc2\xaf\xb4H(\xc9\xd8\\\x12\xa0\x9fr\x12B\xb6\x0cR!\xc6\xfbG}\xf4\x00=lr\xb5\xb3a\x874M\x99\xa8\x88\xf0\x03\x7f\xcc\x15\x7f\xf1\x9b\xb1\x1b\xe58\x0c!\xbbJaE2o\xc9$G\xcb\x9f\"$N\xa3\xedH\x1e\x15q\xe3\xc2\xeb?\xd7 |:\xb7E\xd7\x96\x1e\x15\x19cz\xa9\xc5;\x00\xa5$\x1d\xc4\x0e#\xdf\xd2\xb6\xc8\xeeu\x13Fz\xb3zU\xe6\xdb\xae\xe2\x1b\xaa\x1c\x15\x84\xad\x869\xd9\x8e\xec\x7f\x13\xa0N\xceS\xae\x8a\x00\x85GN@\x9f_\xae\xf8e\x1cKY\xea\xa9\x13\xa03\xe6\x05h=S\xa8eTx\xf0\x04 \xa6\x0c\xc8i\x83\xce\xa7'\x005j0tX\xe9\xa8 8\x8a\x02\x9e\"\x02\xb0t\x11\x80\xf2\xfe @S\xa9\x04\x03O\xa0\x00\x1cy\x05\xd8\x8fF\xe2\x1b\x14 \xf7\x10\n@u\x8b\xf0\xe5\xa1\x17\x15\xbb\x9c\xa8>\x01;\x03\x01\x18\x89[\xc2\x17\xf2(\n\xd0\xfa\x15\x05 I\x0e\x06d\x87\x12\xad\xf6+#\xca\xc3`\xaf\xa3\x00\xadw\xa3\x04\xdb\xb1\x8d\xe0\x87\x14\x80\xf5F\n0\x18.\xc23)@\xef\x9f\x140f\xdf2\x8f\xa5\x00\x04\xbfb\xf8T\xea\xc3\x14\x80\x9a\x8f\xce\x9f)\x00\x85\n\xe7\xdb\x14\xa0\xf6p\n0\xefT\xe6\xed\x14 \xf7y\x16\xbf\xa3\xd4;B\xb5#\x96W\x00f\x91\x05 \x84 \x9a`\x80\x97\x1f\xbd\x18q9&\xa9pJv\xce\xa3v\xfeU\x80u\x9cV\xbb\xc9\xc4\x83\xfa,\x89\x89\xef\x91\x94\xa7\xad\x05\x8b\x88\xfa\x90]\xdd\xea\xe9\xba\xf7C\xc8b 0\xcf\xc3\xb0\xf9\xfa\xbd\x17Gi\xbe\xc2yR\xc7p\xba\xceb\xbf\xcf\xabQ\x8dXF\xcd\x8er?[R6\xa5U\x9ef0\xa3\xf54\xdfg\xfe\xd9\xd5\x84\xff\x9c\xe6\xebu\x9cd\xd4\x87YE\x8eU\xec\xd3\x14\x82\xc8\x0bs\xbfm\xeb}\xbc\xcd\xdd!\xb7?\xfe\x90\xd0,O\" \xf3\x8c&\xac\x0fq\x0f\xed\xc7;\xf0\xf1v\xba\x89\xbc\xe6\x174\x81\xe7K\xea\x9d\x9f]\xfd\x08\xa4\xe1\xbd\x14\x08I\xfb\xf3\x84{X\xc8%\xd9\xfc8i|)\xcd}\x19\xcb\xd7\xe1\xb2)\\6E\x07P\xe7)\xc4\xdcK08C\xe9\xc8%\xc0\xa6o\x97M\xe1\xb2)\xb4g\x1c\x14=a\xf0\xb9\x06a\x91\x98\x8fd\x84S\x0c\xf6\xfc\x82\x1a\x9c\xf6\xdc\x809\xad\x0c\xed\x89it\x99\x82\x93`\xad\xb0q\x8d_\xfcl\x1c\xb98\xbb\xaa\xed\x8a Z\x14\x87\xa4\xc6\xd7#\xe9o\x8f\x19\x18\xd3\x91\xb5\xb8\xd7K5\xa8\x90nG\x92J\xf0I_\xf9x\xd0\xd1\\wH\xd2u\xab;\xd9\xe9\xda\x07\xd1\xdcN\x0b\xd8\xa6\xd6\xb8\x9c\x14\xdc&\x941g\xef\x8db\xce|\xfc\xffJV\x8a\xfd\x1f\x15\xef\xc1\x83:V\xd9\xfd\xa0`/8<\xe8\xff\x86\xb3\x10\xff\xbfF\xcb}\x17\xf6\xfa\xa5c\xcf\x0f>\x0d\x83\x0b\x9a\xb8\xdd\xeev;\x87\xefg\xb7\xf7U,\xfc\xd6w\xfb\x90{\x1d\x96\x15\x0e\xd4W5\xba\x1b\xca\xce\xbf\xc5oA\x89\xfb|\xa2m\xd3\xdd5B\x1e\xe1K\x8e\xbas\xbf)\x8by\xe6\xc8\xf1*\x88b\xb8\x0c\x12\n\xf38YU)o2WR/\xae\x1f\n_R\x9c@\x14g?\xc2<\x89W\xf0\xd7\xf7o\x7fc\xbd\xccHJ\x1f\xde\xbf[\xdeW\xe4\x1dV\xe8R\x9a\x04$\x0c>S\x1ff\x9b\x8c\x96C\xbf!>6\xd9B\x16\xbe\xb4,.na6\xbes\xce)\xdd\x8et\xce)\xfd<\x05\xe8g+\xc09\xa7@\xdf\x89sN9\xe7\x94sNa\xd8\xeeK8\xa7\xcc\x9dIB\x05_\x12~A\xc0\xa3i:\xcf\xc3p\x03>-\xca\"D>$\xb4\xb4:\x1aXv\xae\x87u\x86(\x7f\xc4\xb0\xc7&\xba\xdb\xb5\x85\xf8-\x82\x8c\xcf\xb3&\x8a2\xf8\xda \xca\x8a\x84\xc2\x9ekL\xde\xee\x92>\xb7N\x05YE\xdb\x91\xad\xd3\x17\xb4\xc7\xa2\xe4\x16\xa4\x8d}\xda\x8b\xad\xd7>5\xb2K\x99\xad\xc7\x0c\xda\xe2\x83\xaf\xc6>\x15\xeb\xd6\xf8\xee\xcb\xd9\xa7\xba}\xd1\xab\xed\xde_<\x0b\xfe\x83\xde\xff\xe5\xf4S\xf0\xc7\x7f\xfe#\xfe\xe5\xd5\xab\x9f_~\xfe\xebc\xef\xe8\xe7\xd3\xe3\xf9\xc5\xd1\xcbW\x1f\xbc\x93\xe5\xd5\xc1\xe6\x94,._.\xcf6\x07\x17\xa7\xc7\x7fy\xfdz\xf9\xfce\x1a\xfe\xf2\x1f\xe4\xfe\xf1\xfc \x7f\xf6\x97\xd5\xfc\xfd2~\xf3|\xf1\xfbg\xff\xf5\xab\xe4\x1f\xefN^\xbc9;\xbe|\xb9\xf8\xdb\xdf.\xff\x1a\xbf)\xba\x1d[\x04\x8dO\xdb^c]e\x90j2\xbe{W\xa4\xd78\x1fp\xc2\x90\x1a\xe4\x1aU\xa1\xb2,uF8\xe2p2\xd8E\xa45\xbaQ\xaa\x10ml\xeb\x0dm\xd3\xfez\x0c\xec~\xe3Z\x81Xa\xf2\x0e`\x19\x94\xa9\xae\x98\xa8\xde\x80\xfe\x02\xc6\xb3\xd2p\xd6\xf2\xa4\x9e#\xd5\xc6\xb2\x96f0\xc8H\xd6\x18\xc8f\xbd\x0f4\x8c1F\xb1v@\x1acXm\x08\xdba\xff\x02\xa6\xdd\xde\xfe\x8cD\xe7\xfb3\x12\x92\xc8\xa3\xe9\xfe\x9fE11\xcbbL\xcc^+\xa8\x0f%\xce\xe2\xbb\xaeA\xf8\x8cDe\x1cy\x14\x03\xa9\xb7\xa4\xd2vi\xb4\xf6M\xbab\xa8\xc5g\x10Dem\xb5\x96\xa5 \xc3\xca-\xd9\\J56E\x8e\xfb\xa9\x0eJ\xdbc[\x7f\xf6\xeaM\x85lRI%\xa9~\xd4\xec\x0e\x8d>\x94\xebA,\xde\x96\xde\x1b\xb4o\n^o\xec\x9b}~\xea\x98\xd3$-\x90\"\xceJ\x8d\xeb\xfe\x91\x0f^\x1cD\xa98\xa0\xc4Q\xbd\x9d\xb2\x18H\x14g\xcb*\xd6\xa0\xd8P\xd7}8\xf9\xb6\xf6\x9e\xf2\xc8U,\x87lV<\x89\x96\xebN\xee\x7f\xc8\xaex8\x8c\xcd\xa7]\x18a\xd7\x870v\xb4\x9d&\xf4\xd3\xa8V\x19\xe3\xc9\xa1\xfa\xaeX\x90\xc5\x13\xb2L\x1e^-\x97\xd9\x83d\xf5\xe9\x82F\x0f\x8f\x1eG\xe7\xe1U\x98\x7f\xde\\<\xfe\xfc\xe4\x8fO\x7fx+\xaf\x17Ug\x7f\nZ\x17L\x14'\xf0\x0b\xdd\xb0\xc9\xf3\xe5b\x9bfA#\x9a\x90\xac\xe3\x10\xe8\xc1l\xedWn\xcc\xee\xf6{\x1aep\x11\x10x\xce\xe7 \xbf\xc7\x1b\xb2\xa0 \xfc\x7f\x1f\x0e\x0e\x0e\x0e_=||p\xbb\x07\x83\xfa\x95L|\xf7\xa2\xd3\xbb?\xe7\xb3\x9e\xef\xbe*\xab\xe8PR\x15g0bu\xcd\x1d\xe2\xff\x91\xa7\xd9\x8a\xaa\x8f\x9d\xa8\x8e\x0e'G}\xbd\xcc\xa9\xcc\x80wG\xda\x1e0\xedO\x123J\x83U\x1e\x92L\xc9\x97\xb38\x0e)\xe9\x93\x0c\x0d\xfcs\x12\xa6\xfd\xf3Q\xdd\xbc\xa8\xe1e\x9a\x05\xccng\xdc\xc6\xbd\xbb\x1d7\xa5G\xa2(\xe6\xd73\xf2\x94\xfa\xddj65xq\xf4G\x1e\x89F\xbc\x18E)\xe6\xa6q\x14n~\xec\xb4\x92\xd1Y\xc5r\xbb\xaa\x15\xa0d1\xc4r#XK\xcdV&}4\xd8\xa9\xdf\"?RW;\xad\x1c\x83\xc2/X.\x92\xf3\x0c\n\xb0\x15\xe8\xce3\xd8\x82k\x11\xa3\xce3\xe8<\x83\xce3\x08\xd7h\x03\xa3=\x83\xe5\x8d\xdbD\xbc$T\xb7\xb2rm\x08\xcfF\xa3\xec\x91\x81\x0f\xf0\x8c\xb5\xe2\xb7H\xc3\x0d\xc4\xf3\xc2\x97!J\xdf\x89SN\xd1b\x1co\xa0\xb1\x97\xec\xed/\x8d_F\xd2\xbc\xca\x02QV\xba\xf7\xbb\xb3\xadt\xac*K\x9b\xddk\xf0\xea\xfe\x9f|\xf6A\xc4\xb9\xa4\xf4_o\xfb\xacz\x0b\x03\xeff\x1f\x1e\x86\x1d\x00,\xcci\x03\xbb\x976CzlM\x83h\xb1\xef\xd3\x90.\xf8\xf3a\xcc\xa8(\xfe}\xec\xfb\xc9\xbf\xca\x9f\x828Jm,\x8c\x06\xae[\xbd\x83{&B`\xc7\x9ew\\\x864\xe6\xf0\xa2lW\xb5\xb1\xb47\xccE\xb0\xa1\xe2#a\x08\x0d\x12\x89(&\xa9'^\xb4\xe9\xea\xbc\xf7\x82\xf0\xc5_\x0c\xd4\x9e\xb1~@\x1a%\xbb\x0e\x8c\x17\xe4P=x\xae\xdc\x16\xa8'\xd3\x95\x18\xd2%I\xfa\xf7\xbc\xb2Y\x91^ o\xf7=\x9e]P&k\xb5\xe8[V\x95\x9d\xc9\xda\xce,\xa8S\x08\xf2\xd9*\xc8\x1a\x9b\xb0\xdcTf\x99\xc5[\xed\xb7\xc6U\x08%\n$*\x08\xcbDU\x18|\xca\x832\x87\x81\x17\xcf\xaaX\x15\xb5\xf1\x8c\xac.\x17\xe4vA\xee\x0e\x8c`\x05_\x9f\x83\xcf\x05\xb9\xb7\xc0\x9d\x05\xe4\x9f\xe9\xce\x02\xdfy\x90\x1baU) \xdd\x9a\x1b\xf2\x89\xdd\xae\xc4\xf7\xe9\xfa\xfc\xc1}/'\x7f,\xce?S\xf2\xf0\xf3zq\xfe\xe9\xde\xc3,\xfa\xe3\xd2\xff|q\x9f\xcc\xbd{\xfe\xd1\xa3\x0e\x1a\x841\xb7\xeb\x81\x0fz\x15X\x9d]`\xa5\x84\x15[T\xbbY\xb4\xdbR\x1f=\xc6`olB\xf5qf7\xc9\x98\xbb:\xf9\x18\x19`.\xe9\xa0\xd5\xd4\xa9\xb5\x16\x98\xf6\xe7\x92\x0e\\\xd2A\x1b\\\xd2A\x05\xd7u&\x19\xee\xd7`\xe7\xd3\xda}P&%\xb4\xdd\x0c{\xf7\x0f\x0e\xe5\xa8\x7f\xa1\x1bX\x934\xbd\x8c\x13\x1f\x82\x14.\x93\x18\xed\xdd\x95G\xf8\xcc\xbc\xbb\xfb\x7fVf\x19\xff\xed\xbb\xf0\xf6*f\xd3\xa2\x86r6o\xd7\xccF\x17\x1f\x16S\xda\xf6\x01\x0d\x9a\x92\x85\xb5j\xe0\xc7\xfe[N\x93\x8dHX\xc9\x93\x84FMg\x1a\xcchvIi\xd4\xf4i\xf3\x8b\x1e\xdb~\xae\x1b\xef\xe36\xb2\xf4\x86\x1d\xae\x86\x9dpd\xaejE\x13\xa9\x9bz\x80\x11\xf0u\x9dI\x06\x89\xefj\xbdF\xf2U\xa3\x84o\x1e\xcd\xc4K\xa8S\x17d\xd3\x06\xd9*b\xb9p\x1b\x87\x9b\x1en\x0b\xa2 \x0bH8\xd5\xc6\xcf$\xedm\xdby \xe5\xab8\x95?u(\xda\xcb\n\xc3\xae\x82h\x9a\x05+E\xcf[\x150\xed\xe4N\xdd\xdeJ\xc4\xa8\xc3a$\xea\xdd1\xe5\x0e\x18;6\xf6\x81\xf7\xd5\x8e\x8c\xb1\xbfP\xbfPf\xe5Nu\xc11\x17\x1c\xe3\xe0\x82c\x02\\p\xccy\x11\xdb`\xda\x9f\x0b\x8e\xb9\xe0X\x03F\x18\xb8\x85\xbb\xa1\x06\x17\x1cs\xc1\xb1\x06\xa8D\xbc\x0b\x8e\xf5\x80Sk.8\xe6\x82c}\xe0\x82c\x15\\\xd7\x99d\x1c\xefj\x9f'\xe2\xab\n\x93\xf5zj]\xc0\xac=\x9b\xef-`&\xf7J\xbb\x98\x99\xcd\xd1e\xd8\xc1\x87FY\xd2\xab~\x06\x18\xa0\xd6W;\x10\xceo\xc0\x08\xe2\xa1\xed\x11\xcep\xc0\xe0Q\xf9\xc4A\x86`\x80\xc2\x18;\x1cW\xc9\xf8\x846\xf6\xa9Z^\x7fb\x9b\xbc\xea\xa8#\xb0o\xf5vo,\xac\xdb\xae\x95\x1e*\xca\x87R\xef\x96yR\\\xa9\x97\x8d\xe7w\x126\xc6\xf3>\xf1~W\x08\xdbQ\x86\x94\xc5\x06\x03z\x91f\x03\x06d \xb6\xcbPb\x8b \xe0\x87y\x10f4\x81\xd9FLJ0DZ\xfa\x93n\xbc\x84F\x86\x12\xff\x9f\x84\xce\x9f\xc2\xde\xff\xbd\xef\xd39\x17O\xcc\x82y\xd7\xa0\xc4\xf0\xd2\x14\x08C\xaaE\xfa\xef\xc2`2\xaa\x86[\xc4\xeeZ\x1cZr\xda\xd8!;l\xe1\xd6\x91l\x03\x17\x9ds\xd1\xb9\x0e|U'a\x17\x9d\xdb\x02\xe7\xc6\x94\x7f\xe6\xa2s\xdfzt.M\xbcr\xf0_d\xfc\x16.\x8e\x1a\xeai\xf8i\xf6\xe5\xd6`\xd0\x1c,\xb2d[\xe2\xf0\xe0\xeb\x8a\xd8\xb9\xea\xbaZ\x95a\xab\x8e],\xaf\x05\xd7\xa2\x04],\xcf\xc5\xf2\\,\x0f\xae\xf1\x043N,\xaf\xe9\x9a\x90\xc4\xf0v\xe7>\xaa\xcc\x96\xef\xc3wd\xe0\xdb\xacCR5\x8d [\x92\xac\x15\x84\n\xd22+\xbb\xf2\xd0~+\xfeM\x85XS \xb4\xb8\x08EZ\xdfs\xb0\xb3\x83\xc7\xb5\x84\x85\x8dJ\xa34O\xa7\xeb|&\x11\xfd\x9ai\xe84Y5N\xd6\xd7:\x9f\x1d~\xf6\xfe\xf0s\xba\xfetp\x91\x1f}^\x9c/\xce\xef?\xa1sr\x10}\xba\xfc\x1c\xf9$\xfa\xf4`u\xdf{\xb4&\xf7\xf2\xfbd\xfd\xf9\xfe\xe2(y\xb2H\xd7\x9f\x16\x0f\x17O\xbc\xf4\xde\xf9\x13/\x9fo\xf5\xf3\x07 B\xda\xebtR\x9f\x88\xd3\x8cd\xb9b\xeddw=\xb2\xf8\x9c\xf6\x17\xf1\xd4\x9c|\xca\xd3\xabeQ\xb9&\xcbH\xdbZG\x1fWq\x14\x9c\xcb\xdfF\xd7\xaa\x8c\xc0\xa7Q\x16d\xd2\x07\xef\xb5\x08.\xe9,\x0dd\xbe\x0dD\xfb\x94zy\x12d\x9b\xa9\x17G\x19\xf1\xec\xe3\x96>\xcdH\x10j\xccsI{&(\xb5\x97\x88\xf4\xbb\xa9O\xa9s\xd4A\x94%d\x9a]M\xb9 \xd1\xbf\\j\xeem\xf4r\xb0\xf5c\x9d\xb2\xb2\x9b9\xd4\xf8\xd5\x97\xa5\x10\xd8\x0f\x9f<:\xb8{px\xf7\xe0\xf0\xec\xe0\xe0)\xff\xff\xff\xd8\xee\xd0\x8bW\xab Mw\xb3e\x12\xa9+N;\x0f\xd0Q\x8a\xc1\x8a\\M\xaf\xa3\x0foI\xa2\x05\xddyW\xf9\xda'\x195O h\x03\x96\x03,\xad\xd5\xba\xfdu\x18\xa4.\x1b\xac=\x1b|6X'\x1b`\xdc\xd9X\xd8U\xe6Vw#_\xe5\x9b0\xb9\x8d<\x85z\x0b\x1am\na\xad\xe7\xe1k\\\x83\xderV\x0e_m5\xef\xdef\x96Y\xcc*{Yf-\xab\xac\x0d\x99\xa5\xac \x8e\xdeJV6VX\xc8Je\xafV\xf5J\xdbX\xa3\xb3\xd4v\xb1\xa6\xb1\xd2&\xd6\xb4\xc5\xd9\xc3\x1a$J[X\xd1Vi\x07\xe3\xf6\xc6\xb6\x19\x81\xb4\x80\xd5\xf6\xaf\xd4\xfa\xd5\xdb\xbe\xb6\xe3\xd6Y\xbdH\xbc\x18\x8bWe\xef\x0e\xd8\x00r\xd3Pk\xb1i\xccB\xb5\x8d;\x06v\xadu;\xb4\x13\xad]k\xd0\xc1Nl\xda\x9d&\xc7\xd6\xc6\xac\xc0a`\x085\xb4_\x99eY\x0f\xd3#\x91\xcf\xfeI\xd3 <\xdb\x80O\xe7$\x0f3\x082Hh\x96'Q\nq\x14\x8a\x02T\xc2T\xaap\xd5#\x9a\x14\x7f\x93\xa7\xc1\xb53RK3T\xe8\xba\xc6\x9f%+\xa8J\x968[\xd2\xc6lx\xa1\x0b\x81v\x02o\xf2\x94\xe7F\xd0 [\xd2\x04\xf6\xc4\xf8\xf7\xee\xc0\x9e\x90\x14\xfc\xdfq[t\xedUBdo\xd2\xf8\xa1a\xbav\xa8\xa0\x9a\xdf\x9a,\xa8l\x1al\xdc\xecw\x10\xe1\x89\xc9\x16\x15\xb6\x05kc\x10\x87\xa8\xfe\xc3`\x15d\xaa\x01\xac\xc8U\xb0\xcaW\xc5\x18\x98\x85\xcf\xdd\xb7\xb0\xa6 \x1f\x9c\xe5\xa8n\xbc\x0d\xed\xdc\xd6Z\xd3\x1bc|k\xa7\xe1\xdc\xd6\xdb\xed\xa4G-\x9dA\xaeE\xe0\xdc\xd6\x8a\xf683\x1d\x81\xc8\xb9\xad\x9d\xdb\x9a\x83n\xcb\xec\xda\xcf\xeb\xdc\xd6=\x80\xe5\x00;k|\xaf\xc7\x1c\x1f\xee[\xc6{c\xbf\x8d\xbb\xb9\xec,\xd1|\x11\xb3\xa8>W\xbc\x1b\xfbm\xdf\xc2\xd5\xdb\x86h%\x8f\xb5\x0b\x87\xafp\x0dz\x9bP9|\xe7\x90\x95\x12Go\xff)\x1b;\x87l\x058KO\x83\xc49d\x1b`;n\x9d=\x87\xc4\x8b\xb1\xe5\x9cC\xb6\x05(\xbbmh'Z\x8b\xcd\xa0\x831\x1c\xb2c\xfb^1\xd6\xde\xb0'x\xbf\x1f\xcbO\xf1\x1c\xefWg\xf0\xed\xd6{\x88\xb8}\xa7\xd9Y\xf5\xfd1[\x0c\x96.(mYp\xeb\xb3\xf4\xb7\xfe\x1c\xef\x17\x11]#=q\xf0\xfd 1\xe5s\x07N\x9c\xb5\xe0&\x883D\xc5\xa7arM\xd2\x0eQ\xe1Im\xb3\xef\xea\xb9\x83\xb1\xc5M%m\xd6q\x1c>\xb5\xd9V\xcd\x07\x8e\xd8\x89\x9b2\xe1\xc0\xfeX`\x06\x86\xf9k\xd9QF\x1e\xa10\x8eS:\xb5\xf0\x18\x88@\xb4M\xcb \x9a\x87\x821C\x92f\xe6\x87\xb3\xaa\xbdQ+~X\xe0\x1d\xd6\x87\xb5iBSjv\xe2\\'\xf4bZ\xcc\xdd\xc8U2\x94\xb5;\x1aq\x18\x83\x0b\x9e.Q\x8a{\x93\xe97\xc9\xdf5\xb3\xf1\x82\x13\xe2T\x8a\\\xb2.\x86\x15\xb9\xb2m\x19\x981\xeb\"f\xfa\x82s\x99Q\xbb\x01.\x0fvf\xeff\xf9l7\xedW\x15\xdcC$1\x92G\xdd\x0c!I\x97l7\xa4\xc1\"b\xb3\x0c\xa2yl\xb7!\x18\x06\x1e\x06`\x92~\x11\\\xd0\xa8sC\xf2V\xcf\xc0\xb6\x1a\xf661\xd8\"[{\xad\x98`\x89\xc90\xa3I\x95\xf1sZg\xfb4>\x91\xad\xaa\xc4\x0c\x1e;\x0b\xe8\x8d&\x03h\xa4\x91>\xb8U~\xbb\x1b\x89\xb4[\x1b6\xcdH\x92i\x8d8\xa9\xf1\xe9\xd3\xabi<\x9f\xf7*:Mc\x11\xb0\x98\xe6Q\x16\x84\xc6\x8d\x99\x8e\xa5\xfet\x16\xc6\xdey\xaaO \xe8J\x08CKr\x9d\xcf\xc2\xc0\x83s\xba\xe1\x95\x8a\xe2\xa82\xe1\xb6\xf6\xa7\xad\xf8\xd9\xab\xe5\x8f\xf2X\xcb\xa8V\x9ec\x0d*\xfc}\xe0\x0d\x81\x14T\xdf:\xc9\xb5\xc6\xf8\x9eF~\xab\x18S\x16C\xaeA\xb0\x9bb5V\"L\xc28}\xa7v\xf9aA\xed\x01PH\x86-O\xc28Gy\xe0Sk\xcdaook\xb4b\x99\x9f\xb5\x0b3\xf6\xd4j\x94\x8e~$\xc3h'E\x17{K\x03\x81BN\x96\x80(\x95#\xf5~\xf5\x96\n\x02\xddD@;\x19P\x95\x0d\x02\xfd\xb8@\xeb\xd6\xd3\xd3\x05t\xb4\x01\xcc<\x05\xe8g+@[R\x08ps/\x01\xe1\xfd,AG.\x016}Kj\xedY\xd7\xd1D\x15\x07\x1a\xc4z\x9a\x1e@?F\x01\xba,X\x01_\xa0\x14\x11\x03e9\"\xc0\x10\x12P\xc4\x84\x12\x95\x92_P\xf4\x84&M\x8dK\x14\x81\xbeL\x11X\x8dd`\xb9\"@\x96,\x02\xec\xe0\xb4\x19w\xba\xf2E0\xa0'cC\xdfU\xd0\xd3n#WAO\xbd\x17\x91jN\xaf\xe2L\xfbs\x15\xf4\xaeUm\xb9\nz\xd8\xde\x07\xaa$\x8c:\xd2\x0eH\xa3\x86\xbe\\\x05\xbd\xads-\xc4Iu(\xabqYy*jG\xc5\x98a\x83\x02g\xe3H_4\xd1\xb9\x00\xf0\xce\x04c\xbd\x8dt\xd0\x99igr5\xa5\x17\x81\xcf\xf8bJ\x0c\xa3\x05L\xe4\xd5^\xaf\xcb \xf2\xe3K#\x04\xab \x9a\x16H\xd64\xb1\xc1\xe0\xc7\xf9,\xa4\x1c\xc9T\x04\x04\xa6~\x9eXD\xcc\xe2\xcb(\x0bVt\x10\x12\xce5\xd3y\"\xdcT\xd3\xc6\xd8\x86\xa1\x11CC\xe2\xb0\xdcE\x8b\xf8b\x9f\xb1I\x9c\x922\x17\xd7\xc4\xa1W=\xd9Q\xe2\xb8\xd5\xd3y\x9f#/\x954\xbc\x1e\x07\xde\xeb\xf8\x82\x91#\xf2\xca \xf5\xbb\xf0Z\xb3\xe8\xe8\xe7J\xc2\xe5\xdc\x0b\xfb\xf1v9\x91)[\x9e\xdb\x1f\xc1#\x11\xcc(|\xbc\x9d\xd1\xab\xec\xf6\xc7;\xad\xd6\x1foW=\x16\xf1\xba\xdb\x1f\xef\xc0\xc7\xdbi<\xcf.IB\xa7\xf9z\x91\x10\x9f\xde\xfe\xd8hV\x04@\xe24\x9bV\x9d\xcd\xbeM'\x9b{\xd9D7;\xf7\xb2\xc9HV\x8d{\xd9d\x0b\xdc\x91T\xfe\x99\xce\xdb\xfa\x9d\xbfl\x92\x05Y\x885Y\x044gc\xd2\xae\xa5o\x8dZ\xb6\x0e\x8fW}a\xea8\x95\xdf\xfe\x91\xa0l-\x8a\xdd\xbdA\xbb'Y\xca\xd4K\x9f\xae\xe34\x90fzY9\xdd\xbe\xbblr\xe3\xc3\x99s\xaaj\xb9\xc1V\x97:\xa7j\x0b\xaeE\x839\xa7\xaas\xaa:\xa7*\\\xe3\xf1\xc3\xd8\xa9Z\xda=c\xbc:b\xe4,\x15\xa5%*g\xd1\xad\x9e~:\x9f\xb4jPp\xdbq\xcb\xaf\xba{'\x8e\xc9\xecmh\xba\xa7\xb6$\x91\xa7\x8c\x83\xc9A\x05\xfd\xe9\"d\x96f\xa4\xef\x1a\x85\x80\x91{\xdb\x8b\xe2\xeb\x9aX\x14O\x99\xf8\x9f^\xd0L\xe2\xf8\x1c\xb5K\x11\\\xb0+q\x96\xc5\x99\xea0\xad;z(\x0e\x1e#\x98x\x9a#\x07\x82\x84\xc8\xe3\x86\xee\xb0a\xd6S\xaf\xab\xac\xd0\x00\"\xf3\xdfh\xa9pv\xd2'a\x8bt\x0d\x0e[S\xa9\x1d)\x13A\xe7\xd6U+\x93\xb0\xd9\xeb:RP\xdfP\x13\xc8j\x05\xbb\x1dC\xe8\\\xd4\xb1\xc2\xf1\xd5\x04\xd8D\xf9^\xd9\xc4\x98\xf1+^\x9b\xe05\x88\x82(\xe5\x17\x95\xaa\x06-T\xa2\xf1vV\xbd\x0b\xa5!O).\x94\xd6\x83\xc1\x85\xd2\x04\xb8P\x9asD\xb6\xc1\xb4?\x17J\x1b'\x94\xd6\xba\xe3u\xcaT!<\xe7\xaa\xaf\xf3\x9dm\xc8\xad\x85\xff\x03\xafM\x06+r\xd5w\xfdP\xc0\xd7\x16Ks1\xb4&\x98\xf4\xd1\xb3\x85\x0b\xab\xebf\x103\xcdg\xe9\x9a\xc8\xefa\x98\xcc5mU\x8bh\x83\xe2\xa2\x8fI\x17o\xc8\xd5\xef\xb2M% \x95\xbe\x18\x00\x86}\xed\xf5\x9f\xd9\x95\x1e\xfd\x9e\xd50v\xb81\x03\xbf)F]\x1c\xd5\xc5Q{\x01\xc1\xcc\x80\x93w\xa0\x95y`\xd1\x9f\x8b\xa3\xba8j\x1b\\\x1c\xb5\x82\xeb:{~\xd18\xea^\xc7;\xf8g\xf9\xcf\x13\xbf|\xad\xc08\xd0\xaa\xce\xa9\xef~\x03\xb3\x0d\x04\xa5\xa6\xdc\xbd\xe3N\xb20\x85[\xad\x9a|\xe3'\xcbJ\x15{G\xd6\xa9Y\xc8\x80\x9e\x91\xe1\xa0\x8c\xcf |\x92z\xf5\xc6\x879\xdbC\x9a&&\x87i\xa9.\xc8\xdfo\xec bq\x03\x14\x99\"\ng\"#4\x81*e\xfcm\xc4~\xe4\x91\xb7\x11;\xd1\xc7\xdcF\xeaL\x19mS\xf4\xa1\x89\xb4\x0d0\xc7\xadO\x89_\xfb\x91\x1b\x11S\xeb\xed\xc1Pc\x06\xb5`\x1f__\xee\x97N#[\xc5Y\xb6\xbf\xd53 \xf1\xc5\x9c\xbfTN\xab/\x0b\x9f^G\xdf:-\xfa\x05\xb5\xa8BA\xa1\xdd\x89\x86\\}\xf2b\x97\\]\xc8\xb9\xd4\x96\xab\xcb\xf6r\xae.\xbf`\xa6\xe0\x16\xf38f6`\xe6\xdd\xe6x\xc95\x80J\xe5\xb9\xd4\x92&\xa8CGJ\xf9\xa2\xe9\xa1\xca\xb94ni\x17\xb7\x18\x1c\xb90\x94r\x83u\xb7Y\xa6\xcb\x0bA\xce\xe2\xbd.\xc8b\x8b\xbb\xe2\xbe\x1e\xc7\x8d\xcaj\x91pIk\x9e}\xeb\xb1[a\x89)\xdc\xc8\x13b\xca\xd4]\x97\x0f\xd3\x85\xeeNu\xf90Mp\xf90\x02j\xec.\x1ff\x0b\\@I\xfe\x99\xda\xa8\xf9\xee\xf3a\x14\x96\x99\xc6\xa23\xb7\xca\x06\xdad\x02d\x8c\xa1\xda#\xce\xb3E\x87]\xc8F\x1e\xf1\x8c\xec\x10\x97.\xd0j\xea\xa4{\x0bL\xfbs\xe9\x02.]\xa0\x0d\x15\xdd\\\xba\xc0u\x99\xe6\xf6\xe9\x02\x81\xcf\x0eh\xa5O\xa2\x9d\n\xb7\x97\x02\xc7\x03\xe2J1\x90\xf6s\x8dY\xb0\xea\x953\x0d;\xe25\xcdR3\x84\x138\x997n\x072j\xd7\xc4]\xd3\xc8\x0f\xa2E}\xd7\xea\x87`B\x8bR\xd8\xb0W\\v8\xe5E\xad\xf7~\x84 \x83\x84fy\x12\xa5@\"\xa0\xabu\xb6\x11\xddW\xf8\xc40&\xc5\x7f\x7f\xaf\x12\xeeFH\x06\xc9\x15s\xe4\xd9SuAZz\xad|\x04\xdc\xfdW\xc9G@\xac\xbe>>\xa8\x03caW\xb7\xb4\x92SBLU\xfba\xbfu\xe5\xdc@6 \xf3eQ\xed\xb4*\xe7e\xab\xc8\xb0L\x1a!0Lx]\xac\x15\xb9\x9a\xb6K\xe8C\x1e1yC\x12\xdat\x0dE$\x8aS\xea\xc5\x91\x9f\xeeB\x88\xdc\x88\x8d\xb9\n\"W%\xa0\x05&}\xf4\xb9\x0d\xb6\x98\xcbz\x83?~x\xff\xc0|\x8b\xff\xaf8[\xd2d\xcaT\xc3\xbf\xb3SM\x143\xa5\xdf,\xdb\xcdT\nM\xb3\xb6\xf6@Z6\xd2]9\x96\xfc\xe0*<\x88\x16\xc3\x05\x88\xb0E\xd4\xe2\x03\xdb\xe8f\xef{\xf9\x9e\xca\x96 M\x97qh\xcf\x84\x07\x93\x07R56P}\xdd\xbbw_\x82\xb8^\x90\xe9\x9aF$\xccz\\E\xe8n\x0e\x0eo\xd6\x16\x92\xb0\xd8X\x1bH\x94)\x19\xbe}\x04\x9e\x01\xeaw\x0b\x81\xd0\xbe\xad\xc7i\xbe\x11\xc5\xab<\x12\xd7\xb3\xb5f\xe2\x9b\xa8 d\xfca\xcb\xc7{\xfb~\xc0\x081\xcb\xf9\x82\xfa4\xa4\x0b^\xa1u\xff\xcf\xea\xdf\xc7\xbe\x9f\xfck?\xa1\x97$\xf1\xcb\xf3\xc4\xf6Y\xec\xee\xf6\xd9\xa8\xcc\xe5m\xe0\xb9\xd5;\xba\xc2\xcfs\xecy\xc7e\xee\xc3\x1c^\x94\xed\xaa6\x92SY\xefr\xf6xv\x1e]>y\x98\xf9\x17+\xf2\x99\x9c\xfb\x97\xe7\x97G\xf9\x83GGG\x8f\xa8\x9f\xe7!9\xf26\x0f\x1e\x1d\x85s\xd3\x1d\xccN\xf7\xech\xcdK?AA$\x98\x91\x90\xef\xc6y\x12\xaf\xf8+\x0e\x05\x11\x828\xd2\xed\xe8\x12a\x9a\xaf\x18\x15Xc\xf6\x9f%fJ\x92\x88\xfa0\xdb4Q\xb2\xff$\x90\x06\xd1\"\xa4\x0d\n\xb7\xe97`3\xbfh\xf0\xc8\xce\xb6\xb3\x85\x1d]\x10E\xb6\xc3\xaf\xd7\x86\xaeJ\x86O\x0b\xffU\xffg([\xb7E9d\xbcZ@\x87\xeb/H\xc8F\xaduk\x1e]\xde\x8f\x8e\xc2^\x9c\x82\xc8\xea\xc9\xc8\x03\xa1\x9aP\xa8\x96\xea\x02t\xb4\x17\xa0\x0d\x88\xa2h/\x00q\xa2\x11\xa0\x0f\x8b\xda\xf4\xdas\xc6\xe1\x12\xe6f\xb0\xfa\xd7{\\\xc49j*\xd1\xb9\xed\x8a\xb6\xd2\xb2f\xf9\xb7\x7f\x0f\xb2\xa5\x9f\x90\xcbJ\xf6W\xc3\xd9K\x1bR\xbf\x94~\xb7z\x06b\x87\x02!\xf6w\x93\xce+\x7f\xe6\xb2\x93i*,\x8ajv\xa5%\xd5\xf9\xca\xccXt\xd9\xa5.\xbb\xb4\x03_U\x00\xdfe\x97n\x81\xcb\xbe\x92\x7f\xa621\xe0\xfb\xcd.\xbd\x11\xe7\x19\x97^\xd9j\xea6x\x0bL\xfbs\xe9\x95.\xbd\xb2\x0d\x15\xdd\\z\xe5uYgc\x9e=\xbf@^\xa5\xa1wx\xff\xcf\xca\x0b\xc6\xff\xfe\x15{\x8bM\xf2\x00\xa5\xb3iQC9\x9b\xb7kf\x93\x88\x0f\x8b)U\x8d\xc7\x99\x92\x85+\xd0\xc0\x0f^\xbe\xde\xb2\xe5\\\xb8\xd53\xe7\xf2c\xe1\xb1\xden#\xfc\xd9]\x076\xc2=a\xe0s\xd8\x95\xc1\xb7\xdb\xab\xedR\xa3D#\x924F\x88\xae\x80\xb7\x1e\xefW\xece\xc3\xf1\xec\xf6\xf7\xfd\xce\xb4\"\xe6S\xf2vw\x13#\x98\xd8\xf9\xd8Jp>\xb6\xbe\x1e\xf1\xb3s>\xb6\x91\xac8\xe7c\xdb\x02w\x04\x97\x7f\xe6|l\xce\xc76\xaa\xaa\xb3\x155\xce\xc7\xd6\x82k\xd9\xe0\xce\xc7\xe6|l\xce\xc7\x06\xd7h\x9d\x0d?y\x8aZ\x88\xd5I\xee\x8b_g\xc6\xba\xdd.\x8bSZ\x99r\xf6\x15\xfb\xdbv\x9a\x9dYfO\x96\xf4\"a\xc7\xe7\xa0\xcb\xc6l$[\xee)\xb0M\xe0l\x19\xa4\x8c\x0fX\xa3\x92\xb9\x1af\xd3\xe52\xf0\x96\xfc\xc7<\xa5 \\\x06a\x08 \xf5hpA\x1b\x03\x85y\x1e\x99d\xe5\x18\xb8\x01ve\x83\xf5lT\xd3$\xc6.K\x18\x16\xdc\xb1\xdc\xfa\x03\xf7\xaa\x99\xd3\xe9\x1d]\x87\xc4\xa3\x16<\xd9l\x89d\xc6\xc2\xa0\x8f\xe8%\xc4\x11\x9d\xe0\xd9\xc99\xa0Jp\x0e\xa8\xbe\x1e\xf1\xb3s\x0e\xa8\x91L\x1c\xe7\x80\xda\x02w>\x95\x7f\xe6\x1cP\xca\x12\x82]\xb3Y\xa6\x15$t65l`\xa8q\xb3+\xa3\xcd9\xce\x9c\xe3\xec\xe6\x08&\xe78s\x8e3\xe78\x83k\xb4*\x078\xce\xe2\xa4\xd2\xa27/Q\xadJ\xba\x18!!\xed\xfbI\xe1\xfa\xbd\x1c,4\x89\xd9\xackx\xabg\xf2\"\x97\x8b\xbb%$\xad\xf85\xe6\x01\xf90\x06>\x86\x1ba(\xc5\x05\x1f|9\xeb\xd2\x82OjHi8\x9f\xce\xe2\xc8\x9f\xde\xa8\xeb\xd5_\xef\x9dS\x01\x17$\x9cz\xf1j\x15\xa4i /\xa2\xe8h\xda\x85~\x9a\xe2\xd4U%lFr\xf6\xa2\xd5\xcc~\x9cgiFxe\xc5\xa9u\xe5\x8c\xefG\xf5\xbc\xa2\x1d\xf5\xd1\xa0_\xe5\xe1\xfe\xfa\xd5\x88\xcb\x0d\xde\xfd\xces\xbbM\xbb\xdb\x9eWj\x88W\xa6f\n\xff\xeevQ\x00\xe5~\x93\x98\x80\x1e\x1as\x85\xd0 .\xe5v\xb0n\xa7]\xcf\x0e\xfe\"\xba\xd7,\xd0ZE\x0f\x19WVC\xd9KQE3\xbam\xbal\xccX\xbb\xe6\xf4.N\x04#\xbb\x00k .\xc0\xda\xd7#~v.\xc0:\x92+\xcc\x05X\xb7\xc0\xc51\xe4\x9f\xb9\x00\xab\xcb\xf0\x1fU\xd5\xd9\x8a\x1a\x17\xa8l\xc1\xb5lp\x17\xa8t\x81J\x17\xa8\x84k\xb4\xce\xc6<}^{p\xb2\xed\xbab\x07\xc7<\n\xb2\xcdt\x1d\xc7E=OC\xdf\x0do\x0e\xac\xf9v!h\xc4\xe9\xd3\xe0H\xb9+}\xee\xdc(\xe30S\xf7\xc8o\xc0H[.\xf7\xaf\x8e\x954\xce\x885\x7fm\x87&SY\x01c\xc5\xaa\xcd\xe2(O\x07a\xa8\xb7yF\xae\x90--9\x82)\xa0 Z\x0ca\x867\x02\x05\xacb?\x0f\xa9\x9e\x15\xd8\xf77\x9b\x05\x18Q\xa6\x12A\xa0X\xb6 \x9a\x87|\xdcS~\xb6\xf1\x96$ZH\xad6\x0d\x86\x15z\xe1\xb7Z\x1a>\xad\xb5\x88I\xc8C\xf6\xd4\x8cIga\xec\x9d\xa7\xd35M\xa6\x1bJ\xb0\x8f\x08\x0ed\xd3j\x9a\xc6\\\xfa\xbcx\xd3\xae\xc0T\x13L\x18V7\x9cWwAK\x12E9 \xef\xae\x93\xf8\"\xe0\xbe\xe8\xc14\x15\x18\xa1\xc6\xf8\xdd\xd1V8\x8c\xf7I\x9e-\xf7/\x0eg4#\x87\xfb\x85\xb1\xbcM\xde\x8a\x8e\xc7\xc5\x17\xf5\xf3\x88E\xe5mz\x15\xa4\x82\xb2\xc5\x17EK\x91%\x14\xc4\xd1\x89_\xb7\xb6%\xd01\xa4\xb9\xe7\xd14\x9d\xe7a\xd5z\x82\"\x9a\x91k\xa5M\x87&\xa8|\x0d\xbbJ_a\xcd\xa7y\xd2S\x14\xbf\xfe]s\x9e\xc29\xd1\x00\x8e\xe1\xc3\xbb_\xf7\x13\x9a\xc6y\xe2\x95\xbe\xfe%\xc9 \x8f\x82O9\x0d7\x10\xf84\xca\x82y@\xc5\xddO\xd67\xc4s)B\xfe\xc4\x07M\x02\x12\x06\x9f\xa9\x7fK\xfa\xdd:\x89\xb3\xd8\x8bC\x98\xe5\xf39M`E\xd3\x94,hq\xd1T\xcc\x0dVy\x9a\x81\x17G\x19 \" 2w\x0d@HI\x9a\xc9\xfb\x8a#\n\xb7\xf7o\x83\xb7$ \xf12\x9a\x88\xb7\x83B\x92f\x90\xd2\xc5\x8a\xc9\x89X\xbc$\xfa\xe1\xdd\xaf{i\xf7%\xcc6\xf0A%L\xfc\xa44R\xf4\xca\xd0\xcd\xf30\xdc\xc0\xa7\x9c\x84\x8c\x82\xbe\xa0o\xd1\x15\xa7\xe4\x0f\x84_\xa3\x95\"\xf9\xc8\x86\xb2\xbf\x88\xe3EH'\x9cf\xb3|>y\x91\x8b-\xf6\xf1G1\x13\x8e6]\xc6y\xe8\xc3\x8c\xca\x9d\x9d\x00\x04<\x12\xc5Q\xe0\x91\x10\xe6q\xb2\x92\xf7\xfc\x03\x9d,&w\x18iy\xb2\xca\xed\xc9\xed\xea\xd5\x1f\xcf\xa3\xeb\x8c\xfa?Nn\xc9\x9b\x9fD\xb0f\xc4\x0e\x0f\xbc\x80\x84\x1a]6\xcb\xe7\x90P\xa6\x89\xe8\x1d\x9eI\x11de\xa7<\x025\x8f\x93z_JQ\xcd\xe8\"\x88\"6\xd9\xcb [*\x94\xcbfM'\x82\xff\xc9:H'^\xbcRI\xe3\xf7|\xa7\xa6\xc0\xdfpc\x82\"\xeaJ)\xf8\x81\x8d\x8f\xd9u\xfc\xedk\xb1\xb5\xbb\xf7\x0bkX\x05\x8be\x063\x85P\xe2\x93\xe6\x11\xb5`\xb5\x0e)S\xb2\xe2L\x93\xae\xa9\x17\xcc\x03\x0fR\xba\"Q\x16xi\xffVS:\x95\x11&\x90\xd8\xdbOa\xb6\xc9d\xdc\x85\xb5\x92\xde0q4\xa3\xd5{w\xb5\x81\xb3e\xc7\x14\xca\x9d\xcc\xe2\x0b9O\x17$(\xb6B\xdf\xf41#\xfbx\x1cm>\x96\xe6\x11\x7f\xb7\x9c$\xb3 K\xd8&\x96\x8f\xb0\x17U\xa9#H\x18\x17\xac\x07\xa4\x7fi\x99t\xe6\x8aF\x8cp\xd66\x0b;\xe6_e\xd5IX\xf3\xb4\xdc8a0\xe3\xc3.\xf4H\ni\xbe^\xc7 \xd7\xe0k\xe2\x9d\xef\xe7\x11\xfb\x1f\xa6\xb7\x05_\xf4\xef\xa0B\xd1\xcb\x0d\x9bx\x0ey&\x04[)\x1ex\xae\x0b\xf1\xfd@\xc8\x8a*\xfe\xcb\x06\x9f-c\x91\xd5'\x13\xcfl\xf0\x89\x9c\xc5?\xfc\x0f\x86\xebG\xf8S!\xc3U\xf8\xfe\xa5\xa6\xdd\x91\x86v\x7f%\x17d4\xe2\xc1O\xdc6d\xbd\x8c@\xa1 \xfd\xe1U\x1cO\xbc\x90\xa4\xa9\x86@b\x88\xac\x91\x98c\xa3\xa1|\x0c\x12\xcaU\xa4\xbb\xa7!\xdd\xe9&[\xc6\x91\x82xbT\xaf\xe2\xf8\x87\xc9d\"\xd7\x06\x15\xe1~P~\xc3\x99\x8f\x93\xd5\x96\xaa\x0c\xc9\x89 \xea\x8b\x97\xef\x9f\xbf;9={\xfb\xeeG\x99\x92\x80\xa2[\xc1\xa8\xea\x8eE\xd7jr\xde\xd7\x90\xf3u,\xa7$'\xe5\xd3\x9f\xe0\x7f\xacg\x93Wq\xfc\xe7d2\xf9\x97\xfcc\x12m\xee03\x94\xb5X\x0b#\xea\x0dI\xd2% \x19\x91\xd5\x13Q\x91\xb0;\n\xc5\x10\x82yg\x00\x1f\xa2U=\x04>@\xbeA\xf8W\xff\xd7O\x10\x05\xa1\x92\xc1\xd5\xe3\x92p2;\xdcr:\x97\xb2\xb8\xf2\xcdX\xf2\xf92\x0e}\xc1\xe4b\xe4b+\x07Q\xb5?@x\x00\xfbQ\x89-\xd3\xdf\x0f\x1f\xc2\xa4R\xce?0\xb9V\x92p\xcb5TzL\xff\xf9_\xff\xfcQ\xb1\x91\xc6\xe0\xb9v\x87j\xb6\xe3\xa4b(\x0f'G\x87Gi_J\xbb\x80mE\x9d\x05YH\x9fV\x91\x0b\xee\x86R\xc5eJX\x93E\x105\xe2\x94Mh\x9d:\xeb\x0f\x85\xeb\xb0\x90\xad\x8d?\x17\xaa\xa5/.#@\x19\x07QGA\"z\x95\xe9\x12\xe6\x14\xc7\x7f\xed\xe1\xbf \xdf\x7f\xcb\x0e\xfde\xffe\xcdK\xf6\xcf\xc2\x0bF\xd2T\xb8\xfaN\xc9\x82\xbe\x13\x97L&\xe2w \xb2O\xd5E2\x86\x96\x91\x90\xc2*N3\xa0\xdc\xb7\xc4\x1dR=M%/#\x83 \x01\xf2 \xca\x1e\xdeW\x91@\xea\xf7\x10O\xbf\xb3\xf9\xf3\x7f\x88\x84:\xa6/K\xaff\xc3\x85&\x0b\x085I$\xf2\xf282\xd9\x0e\xbc$)\xa44\xbb\x03A\x96\x96\xce\xda\x14\xf2H0\xa0/\xfcW\x97A's\\\xed,\xe1\xb7\xf8\xca@\xe4\xbb\x82W\xcbe-yW\x08\xddy\xe1\x03\xe3M\xf6\x8f\xfb7\xd0\xbb\xd3\xe7\x85\xfdV3|a]\xca\xe3\x98\x11\xe4\x91\x88KP_\xf8\x97\xab\xae\x1bmF\x8afr\xfc\xb2P\xa6$\xab\xc7\x97f\x83\x04QF\x17=~\xa3\x92\xc3\x82(\xbbw\xd4\xf9\xb5\x90\xc3Fc\xf0iF\x82\xd0\x85`]\x08\xd6\x85`\x05\xb8\x10,\x07\x17\x82\xdd\x06\x17\x82u!X\x19\xb8\x10\xac\x0b\xc1rp!X\x17\x82u!X\x17\x82\x15\xe0B\xb0.\x04\xebB\xb0.\x04+\x03\x17\x82u!X\x17\x82u!\xd8\x06\x8c\x11\x0es!X\x0e.\x04\xfb\xad\x84`\xfb\xcb\xd1\x89\xdasuptrN\x9bZ\xb0u\x98\xec\x04\x1d\x8b(#)D\xa8\xb8h\xc7\x9dJE\xf8\xac\x08\xafV!I\xee\nZt|&<\xc6\xc8\xb6\xbd:\xcc8\x81\xb7L\xe1\xc5\x11?+\xc6\xf3yJ3v\xfcj\x0f\x17\x1a\xae\xec\x94fM\xa1\x18DOE_\x8d\xbf\xd55A\xbbe\x9d$N\x82^\xc7@\x0f\x11\xc5\xf8dt\xec\x1c\xca\x8b\xc9pRF\xf9\x8a&\x81W\xfe\x8d\xef6\x8fDU=\xa8\xcb%\x8dJ\xc2\xe7Q\xe5\x88\xea\x98\x9f'\x1c[H\xd3\xb4&\xa1p\xdd\xe4)#\xf595\xa4g\x1b\xfd\x8e\x89\xdb \xfd\xf6\x907\x0cV\x01\x96\xba\xfc\xdb2l*\x8b\x08\x0b'e\x93\x83\x8b k\x1ev\x82\x97\xc2%\xd1\xfc\xd3\xc9\x1cB:\xcf\n\xefW\x90 qX\x1a\x8d\xdc\xbf*6\x88\xe8\x84\xd1y\xb6\x01J\xbc%\x90\xf5\xfa\x0bR\xb1\x19\xd7\xae\xdb\xabh\xd9h\xc1(\xca94\xe6\xd7\x98\x81\xfd#\x88\xfc\xc0#\x19\xad\"-\x05\x05\xf9\x87\x05#5\xd1\x05\x91\x17\xe6~\xc7$$\xa2\x97*\xd4\xd5Y1\x1e8mx`\x99\xe8n\xa5v\xb4\x90}8I;\xab\xd5\x99\x02\xb7\xa2\x13\x9a\x16\x11n\xbe\xbd\xea\xfd\xc8\xb6\xdc\xa4\xd8M\xc1\"\x8a\x93\x8e\xff\xba\xdc\x8d\xed.\x04e\x86.\xecv5\xbaJ\xf8t~\xe9Y\xda\x84^\xd0\xa4\x85T\xb5\xac\xc5\xd7\xdd%\x0d\x1a\x19\x13 \xed\xdf#-<\xac\x0f*j\x84\xc7\x89O\x93\xeb\"A\xf7\x16\xfc\xdf\x8a~\xf6\x94w\xc7\xf7\xff,J\x11\x95\x8f\x90(\xae\x91\xd7\xb7\xc8\x8b\xff.\x82\xfe\":\x03qT=8[ \xe8\xbbM~\xab\x9c\xf5\xcd\xbeL.Kd\xb0J\x87\xca\x94\xf9\x08ZW<\xc6\x97=z&\x02.\x0f\xc1&\x0bA\x9dm`\x95k\xc0\xbb\x90 \xd4f\x1a\x8c\x90g`\x99e \x8d\xcd\xe2r\x0c\x06e\x18X\xe5\x17\x00 \xbb\x0f\xb3\x94\x90\xe1\xb2\x0blr\x0bT\x11?Tf\xc1\xc8y\x05\xa8\xac\x82\x11s\n\xb4\x19\x05#\xe5\x13\x0c\xc9&0\xce%\x18!\x93`\xe4<\x02M\x16\xc1\xe89\x04\xbb\xc9 \x18=\x7f\x00\x9f=`\x97;\xa0 \xba.s`\xb4\xbc\x01\\\xd6@\x8f\xdbB._G\xce\x18\xd0\xe5\x0b\x0c\xcc\x16P\xe4\nh\xcd\x13m\x9e\x00\xce~\x197G@\x97!\xa0\x1f\x93]v@)\xd9{\x10\xear\x03F\xcc\x0c\x18\x90\x17\xd0\x9f\xcd\xa3\xca\n\x187'@\x9d\x110F>\x00*\xa0\xad\xc9\x05@g\x02\xc8\x83v\xe6Y\x00r\\\xbd\x0e\xf2Q\xe2\xff&\xc4\xc2\xc6\xfe\xf54A\xc7\xfd-\xa2\xfe\xfd\xc1\x84\x91\"\xfe\xa8x\xbf>\xda\x8f\x89\xf5+\xa9h\x1a\xe7\xc7F\xf9e1\xfe\x11\"\xfc\x06\xf1}\xfb\xe8\xbe\"\x86\x8e\x8d\xec\x8f\x1c\xd7W\x8c\xa8\x97S\xad\"\xfa\xa5#\xb6\x07\x9f$\x9e?r4_\x1e\xcb\xb7\x8d\xe4s\x8f@\xdf\xc0\xfb\xe3\xf8\xe3F\xf1e\x07?m\x04_\x16b\x94E\xef\xc7\x8d\xdd\xdbG\xee%Qz\xab\x18\xbd6\x1eo\x16\x8dG\xc7\xe2\x0d#\xf1&qxi\x14^>\x1al4\x14\x17\x817\x8c\xbf\x1bD\xdf{\xa76n\xe4]\xb6)\x06D\xdd{\xfd\x14\xd2\x98\xbb]\xc4]\x15]\x1f?\xb6>\x9c\x93\xd0qulT\xbd\xad\"\xf1\xf78-\xaeqv\xb0\xb9[\x9c\x02\xdc-Nw\x8b\xb3\x06w\x8b\xd3\xdd\xe2\xac\xc1&\xd2\"E\xe6nqn\xc3HQ\x97aq\x17\x8b\xc8\xcb(\xb1\x97\xd1\xa3/\xda\xf8\xcb\x0e\"0\xbb\x8a\xc1\xec \nc\x12\x87\xb1\x8d\xc4(e\xb8.\x163b4\x06\x1b\x8f1\x8c\xc8\x8c\x1e\x93\xd1Ge\x06\xc7e\xdc-N\xed\xc8\xec\xe24\xbd\xa8\xdc-N\x9b\x88\x8d.f3N\xd4\x06\x19\x8a\xd0Fn\x0cb7\xda\xdbt\x86\xf1\x1bw\x8b\xd3\xdd\xe2\xc4Dv\xb4T5\x8d\xee\xe0\xe3;\xee\x16g\x07F\x8e\xf6\xb8[\x9cM\xb0\x8d\xfd\xf4\"s\xb78\x0d\"ACbA\xbd\xe8\xdc-\xce\xde\x06\xa8\xe8\x91\xbb\xc59^,\xc9\xdd\xe2\x1c\x1ci\x1a\x87\xe7\xd0\xd1&|\xbc w\x8b\xb3\xfb\xb4v\xe7\x14Y\xfc\xdc\xaa\x8a[\xfe-\x8b\x8bb\xaf\xf3x\xeb\xdaN\xc7\x19^\xdf\xdai\xbc_ \xfdGr\xd9\xcd\x9c\xde\x8b9|j\x8a'\x1dO\xf9\xef|\x9c\x01\x15\x0f:\xd6\xd4\xe8\xbfx\x93gK\xd1\xeaV9\xf6\x1bz\xf7\xa69\xf7&t*\x1bs\x02\xb4\xab\x1a\x97\x04(\xf5\x98x2x[\x91H\x07\x05\xda\x80\xd4\x8a\\MWt\x15O\xab\xf8\x89\"n\x85J\x98\x95V\xf7\xcd\xae\xa6i\xb0\x98\xf2K\x9b;\xed\xe33\x9dzq\x9a\xf1\xb7vg\x9blh\x06\xb0\xb436\x9b\x0b\x9a\x04\xf3\x8d\xe8\x8f\xfaG\x0f\x1e\x1c>\xb9\xae\xeeR\xea\xad\x8f\x1e<\xef\xe0s1o\x17\xf3\xd69|1>Sp1o\x17\xf3\x96~\xe9b\xde\x1c\\\xcc{\x1b\\\xcc\xdb\xc5\xbce\xe0b\xde.\xe6\xcd\xc1\xc5\xbc]\xcc\xdb\xc5\xbc]\xcc[\x80\x8by\xbb\x98\xb7\x8by\xbb\x98\xb7\x0c\\\xcc\xdb\xc5\xbc]\xcc\xdb\xc5\xbc\x1b0F\xfc\xd1\xc5\xbc9\xb8\x98\xf7\xb7\x12\xf3\xd6\xd6w\x9c\x91\xe8\xbc\n#\xcfHH\"\x8f\"\xeb;\x86\xe1\xb3\xe2\xfb*\xb0\xcc]\xb3\xe2\x8f\\\xde\x86!x1\x93Z\x8c\xd8\x04\xd2 Z\x84\xb4\xac\x96\xd8\x1fw\xae\xb1\x16?\xdf\xd8\xc0sI\xad\x9b\x11\x04\xf2i\x14\xaf\xac\xdd\x1fd\xd5_\xbfR\x80\xa69\xc6\xf9\xf0<\x0e\xeaG\x85 d\xf19\x8d\n\xc7\x81\x18zY\x86\x96\x89.\x12\x15\x03\x92\x9d\x93\x7f{{\xf6\xf2)\xd7\xf4\xe2\xbbBe\x06\xdc\xabq\x12e\x850\xa9\xc4\x94\xa2\xbd:\xcb4\x8d~\xa6\xfa\xba\xdba\xdc#\x8e\x0b\x86\xd9F\x1a\\0l\x87\xc4\xd5\x87q\\0l\x0c*\xba`\x98\x0b\x86q\xf8V\x83arO]:]\xd1\x8c\xf8$#r\x1f\xdd\x7fw|t\xe9\x9b\xa2I+\"\xe6\x85\\\xb8\x96\xe8*\xd7]B\x17A\x9aQv\xbaf\xfa\xbeB\xd5\xd4\xfb\xfde\xaa\xda\x9d\x15_\xdcX\xbf\\9\xf1\x1bbI6i\xd0\xfb\x01\xc2\x1c\x14\xae\xc6<\n2\x8ds\xaf\x7fj\x02\xa4\x13\x14\x80p\xa3\xe9'+@\xebJCL\xb9\x04\x8c\xa3\xa7\xf953m+\xdf\x8e\xd8\x10\xa2\x97V\x99\x97EpA\xe5\x05\x06\x9a\xb8\x18\xd1y\xd9\x15\xc8I\x16\xaf~\xecwQ\n\xa0W\xeb8\xa2j\xf7\x9f\xeeT\xd5\x84\xc6 Kr\x84/\xc1\x8cJ\xe58\x9b\x84Z\xc7\x97B\x9d\x1d\x1e\xd4\xbf\x0bWn$\xf7\xf0 \xe0O\xfck\xbeIHP\xdc\xa8\x9b\x91\x94N\xab\x88I\x10 \xc9\xcc\xfeM?\xe5$Tz\x14\x05\xf0\xd5\x13R\xe9C\x14d{iq\xfc\xd14;,\x96\xf4'8\xfc?\xd5\x14\xeb\xd1\xe8\x9a\xf3\xda;\xa5{\xb51\x89x.X\xa3.\"\xe3%\x94\xd9\x1c\xf2\")\x02\xaa 0\x14{\x0c\xc5\x9e\xa6\xc0\x84\x80j\xec?\xc1\xc3;\x90-\xf3\xf4)\x1c\x02k\xcf\xa6v\xf0\x7f\x1e\"X\x95\x84\x01I\xd5\xbb\x18#S\x04h$\x8b\x00\xf4\x8e\xd7\xb9\xa5J(\xa6 N)a\x90r2\x16{\xbd\xfc\xad\x0c\x90\xa3\xf7\xbb\xf4\x1b\xd5\xb1\xb3\x0d\xf5\xb26\xb6\x17)\\\xcf\xdd2\x0dD;\xb4\xd6\xb1\xc0\xc9\xacqct\xb8\x08\x9d2>g6/)'\x8d\x18\x99\xc3\xc6\xe5\xe4Q9\xed\x9c\xc6\x8e\xc8\xa9\xe2q\xda\xc1\xe0\x18\xc7*\x12\xc7G/A\x88\x8c\xc3\x99E\xe1\xa41\xb8\x91\xa80V\xf4\xcd&\xf6\xa6\x8e\xbc\x8d7\xc1\xf1bn\xa6\x117\xbbx\x9b^@\x0c\x8b\xb5)\"m\xd8@\xc0Hq\x00\x17\x06pa\x80\xaf&\x0c\xd0\xb5\x0e[\xdc'\xd4\xb1\xa2\x92\x03\xfb{3\x91\xba\xeb\xfe\x19p\xd5\xc9(E\xdc\xf0\xe9\xe1l\xeb\xe5\xdd+\x8e\xaf\xf3\xf8n\xa7\x0cRt\xfeu\xbfE<\xc0a\x93\xd2\xc8\x9f\xd2\x88\xccB\xea\xab\x14\xdb\xb7\xe0qQNS\x80\xccW\xd9\x05\x99\xfb\xb6\x0d8\x95\x0f\xf0\x9eF\xfeK18\xf1bb{G\x92\xd6*A\x9a\x91,W$Y].)\x7fW\x8dT\xbb\\Q\x81\x80F>\xc3\xda\x7fn\x10*l\x8a\xe5\x11\x151t\x04k\x91\xeaT\xf9\x9cvy@\xee\xd9\xd7=\xb8\xfa\xad\x82\xce\xfb\xc7\xcd\x9e\xb6m\x82*\xaa)dI\xdf\xa6l\xbdt\xee\x94\xbfS\xfe]\xd8\x81\xf27\xd2\xa3i\xbe^\x87\x1b\xb9\x1e=\x8b3\x12\xbe\xe7\x1f\xb5\x94\xa9\x08\xae\x89\xd6\xd0|s\xa1W\x956\xb0\x14?\xdfX]\xda$H\x13\xbe\x04w)\xd5\x9b\x969\xdc\xe3\nc>\xaeP\xb8\x86\n\x8e\x0fJ?V\xc9\xff\xa5\xbd\xdc\xd5\xbf.\xcb\x92\x83\xcb\xb2\xd4\xba\xb2\xbf\x9a,K\xd9D\xb8\x9eiHz{\xa7JS\xe9H]*\xd5\x1f\x9dQ\xd5\xfe\xcd\x19U;0\xaa\\b\xa5qf\x8fK\xact\x89\x95.\xb1\xb2\x06\x97X\xe9\x12+\xbf\xfa\xc4Jq\xe2A\xe4S\n\xf3\xed\xed\xbc\xe55h\xf8\x0b\x9aO\x13\xf4\xfa\x0cJ\x04\xb7\xca\xe9\xdeP\x87\x81\xec\x98=\xe04\xa68\xf7k\xac\x17\xf7\nA\x1b\xcc\xce\xf9\x08\x07q\xc9\x95\xa8\xc3Mq\x9c\xe9pr \xee\x1d\x02\x01\xee,s\x83\xce2\xc3\xa2\xc3\xd7\\\xe7\xbf\xd6P)\xdd\xcfh\xe4\xd3d\x15DY\xfd\xa6N\x18{\xe7\xe9~H2\x9afrU\xf5\x9af\xbf\xf2O\x9e\xb1\xef\x0b%]$\x11\xf2\xbf\x03G\xd4\xab\xa5\xdamo\x95s\xbb\xa1\xba\x8a\xcfc\x1a\xf4D\xeb\x06h\xab\x01\xb9O\x1a\xbf\xe1\x9a$\xd94\xa5\xd9tI\x89O{$\x11\xe8F\x0e\xda\xd13Px\xfe@+\xbeJ\xc0\xe4\xb0\xab\n4 \xc8\x05z\x92U\xee\xb9S\x92d)\xcd~\xe6\x94\xdb^n\xf1\x11g\xda\x93\x17}\\2.\x8b\xecv\xfd\x98\x01\xde\xeba/\xa1\x98\xae\xc8\x17\xe3\xd3\xe3\xe9}\x9a\x95\x18\xa5\xf4\x9b\x84\x98M@\xad;\xe0\xbc\xcc\x02\xc8z}\xbd]\xea\xcd\xc7\x12\x9e3\xd1\x16\xa5y\n\x1eY\x0b\xcbLh\x93\xf2\xcfI\x1e\x16\xd9\xee\xeb$f2Q=DR\xad\xa7\x08\xfe\xb3\xff\xe0 \x9fwT\xb7\x0d\xc4\xe1Y\xa4\xd7\x87\x8dF\xc0\xf3\x9a\xaaG\x11\xc4k\x03\xdc\xbec\xa3R ,\x0e\xdcd\xbd\x0e\xd9)>\x88\xa3=Ez\x05\xf0d\x0d\nYB\xa2\x94'\x9c\xc2\x8ax\xcb \xea\x89\xea\x08\xe0\xa3\xeb\x95\xdc% \x96tI\x83\xc5Rqa\x07\x81\x02'\xe7\xb2@^\x18\xc9\xb0\x1b\x9fd\xf4.\xc3'\xf92$i6\x95\xeb\xb5\x12F\xdc\xd1j!\x0e\xd8 \x02F\x98\x0b@\xe9\xc1\x12P3\x05\xf4lA\xaf\x1f\xab\xcfPz\xb2\x04\x0c\x1f\x95\xa0'9\x98\x90\x1d\xf0\xa4G\xea\xd3\xce\xc7\xfdz\xb5\x04\xce\xb2^\xbcZ\x05\x99\xb2d\x13rF\xa8\x99\x14\x03c\xddQ\x9e\xff(\xa4f\xe3Bj\x17\xd8O\xd74\xbc\x0b\x12\x06>\xc9\xe2$\xbd\xa6\x0e\xbb\xf4\x98'\xfc\x12\n\x97\xdf\x10\xe7\xd9:\xcf\xea\xbf\xad\x13z!\xc8%\xc1\xc6C4\xd7>\x87Jc^S\x7fd\xbd\xbe\xa6\x9e\xf8\xfe(\x9c\xa7\xd7\xd4%\xbd\x08|\x1ay\xf4\x9a\xba\xab\xf8\xaf6{\x14\xf6(\x13\xd4qJ\x93\xa9\xe69\xb3\xb1\xc6\xd72\xe6\x84\xc0k\xe5\xa4\xd4oFqG\xeeYu\xf0.\x84\x8a\xd0R\xbd\x99\xa3\xbd\xf7\xca\x01\xa3\xb5\xf4\xda*\xbb\xd2RF}\xefS{\xeb\x13E^\x04\x81\xc1\xc8b>\xbbJEL\x88\x87\xc6f\x85\x91)\x1c\x99\xc2\x8c\xfc\xdf\x85\x83\xe2gn\xdf\xfd\xe5p\xa2\xb2<\x85\xef5\x8a3Q<\xee*\x85%M(\x0fRp\x196\x01\xf8;\xddK(\xfc\x91\xa7\x19\x90EB\xa9z\xba\xb1\xb0\xbc\xc5%\xe7y\x90\xa4\x99\xb2\x7f~\xb1lEIT\xccJ\x0c\xfdx\xbd\xe6\xf7\x9b\xfc\x98\xa6|pEx\x8b\xa1NU\n:\xbb\x92\x14\xe7\xd4\xe5\xdb\xbc`\x96~\xeb\xf51\x1e\xc4\x9d\x0b\xa3\x9cxle\xd2r\x18\xbd\x11\x9b\x1ad\xda\xa1\x14+;\xe3yu\x070.\xe3kmJ\xfdx\x05\xf8\xb98%\xd1\xe9E\x9c\xd1\xa9~\x12\x02\x90\xa3\x00\x83\x910\xe0c\x90\x88\xa56\x18\x0c\x00\x0c\x07\x01%z\xd4\x97hQ\xd4\x04\x1a\xe5\x9a\x1a\xf4M\xb8\x0b\xefO^\xff\xf6\xf2\xc5\xf4\xcd\xfb\xd7\xd3\xb3\xff<}9\xfd\xf0\xdb/\xbf\xbd\xfd\xfbo\x030\x9c\xbe{\xf9\xfb\xdb\xb3\x97\xc30<\x7f\xfb\xe6\xcd\xc9\xd9 \x1coO\xdf\xbe?\xfe\x15\x89\xa2\x0c\xc9\x0c\xa4\x07^\xde\xb7\xe1}\xb0\x88\xa8\xff&]\x9cm\xd6T\xa4\xb9\xb0\xb5\xe7\x05\x02\xf8OhLE,\xa5\xf4\x94T\xa6\x87RZw@\xba\xa6O\xe1\xf78SzH: _\x97\xa7p\xca\x0d\x1e\x12\xe2\xd0\xe9\xbc\x1am\xb0\xd88&'U\x01I\x9cG\xca\xfbDM0;6\x0bP\xc5\xcc\xfaA\xef\"i\x83\xa1\xac\x03\x0by\x07\xe8\x93}\x0d\x16\xcb\x07X\x93\xac\x0bFn\x976XP\x0f,)\xc8\x00\xe9\xa0i\x83\x0d\xdf\x95`\xbe%J0]p\xb0_t\xb0]xC\xa7O\x1bP.\xa06d\xc1\x8a\xa6\x19Yi\x9c\xf65X\x10\x04\xebOmC\xe5\xd5\xd0\x9f=\xdb0`\x84\xe8\xa5\xaa\x07\x17D>\xbd2\x1b\x9a\x19\xdf\x9b\xcb\xdb*\xf3\xc4lX\xbb\xa4\x98\x8d \xc2\xb4z\xbb<\xc3:\xa1\xccb\xbe\xc3\xfe!\x9c\x98w \xc6\xd1Q|\xce\x0dn\xe1^\xab\x9dfl.8;\xa4a\xb7\xe8>\xe5\x96\xfd\x0c\xb3\x00\x86\xf2\xdaTN;\xcb\xbe\x03\xce\xb2w\x96\xbd\x1e\x9ce\xaf\xfb\x1a\x9ceo\xa6\x03\x058\xcb^\n\xe6[\xa2\x04\xd3\x05\x07\xfbE\x07\xdb\x85w\x96} \xce\xb2\x17`.o\x9de\xbf\x0d\xd7m\xd9s\xb18\xbd\x88\xb3 ZLyU_\xccb\x18.\x84\x99(\xacy\xf6f\x8c\xc7H\xf4X\x8e\x04+rL\xf9\xf3E\x19 bL\xfa\xb2\x08\x0f\xd5\xc1\xba2`\xc4\xe3\xcfZd\xd5\xc2\x14f5d\x971\xc35\x0f\x03\x8f\xf1\x0f\xe7Z\x0d\xcf\x85\xcc\x10\x9d\x8a\xa2\xa3S\x92e\xc4;\xff\xd2a\xab\xc6\x0c\xa6\x88$S\x01\x06c\x01\xc3\xf1@!\x1a\xa9ohU\x19\x8e ,\xc6\x05\x9a\x1c\xe4~\xb0\x18\x18X\x0e\x0e0Y\xcc\xfd`\x9a\xdb\xdc\x0f\x96s\x85\x01\xf3\x05\\vt?\x18\n\xac.\x94\x02L\x9bI\xdd\x0f\xda\xfc\xea~\xf8\x92\x836\x15\xc1]\xc0\xe5m\x1b\xa3m\xe7yw\xb2\xb9\x8d\xb1!\xb3\xbf\xfb\x01\x9b\x13n\x8c\xb8\x95Cn\x9c)\xde\x0f\xa6\xf9\xe3\xfd\xa0\xcf*\xef\x07kF6\xf3\xe8\x94`\xdd\x9d\xa9\xcd\xd4\x04u\x0e{?\x8c0P\xacI\xd5\x06d\x16|?|!\xd9o\xe3/\x80aD\x06\xf3\xa3U\x1b\x068\x8eJ\x18@m\x18Hq\xb0u(\x95`s\xc0\xee\x82\xfd\x8e,\xc1\x96q`8\xf3\xc0P\x06\x1a\xe4\x80*\xc1\xc2\x11U\x02\xfe\xeeA?\x0c\xa0\xdf\x00\xba\x99\xdf^\xe8\x07\xc4\x9d\x86~\xf8\x12\xd3F\xdf(\xe8\x87/1d}\xd6\xad\x1c\xb0W1\x8c\x11\xab\xaen\xf4\x83\xd9\x85\x8e~\xf8\x12\xe4\xc7^ \xe9\x87/1b\xfd\xa5\x92~\xf8\x12c5\xb8\x96\xd2\x0f_b\xd0\xc8\x8b-\xfd\xf0%\x06lv5\xa6\x1f\xf0\x17f\xfa\xe1\xfa\xe7=\xe4t\xae\xbd\xa1c\x84\xcd\xe06O?\x08\xe3\xc2\x84\xe4\x96\x16\xb1\xad%\xfc\x15\x9dA\x8d\xb2\x0dJ\x18b\xa4\x9bG\xc3Jp\x87O\x0cX\x8a\x07\x01\xee\xf0i\xcd\xd7%\xd8o\xc5\x12l\x19\x07\x863\x0f\x0ce\xa0/}\xf8\xac\xab\xb1\x99RPPN\xf7lg\x1fh\xef\xb6\xf5\xc3\xa0\x8d2l\x9b\x94\x92t:\x0f\x89\xf4\x95>5\x0cf4\xb3\x8c\xd26\xdc\x85g\xbf\xbe}\xfe\xcb\xf4\xe4\xc5\xf4\xd5\xaf\xc7\xaf\x0d\xb3)\xbb\xd0\xc5v\xfc\xec\xfd\xcb\xdf\xf0I\xa2m\xe8\"3\xcc8mC\x17\xd9o'\xd8\xc4\xd36Ti\xa8\xe3\x91\xcd\xfe\x14.@ln\xffUH\x16\x8d\x97;EQ\xc6g\xa1\x17\x9f\x9f\xbc\xb0\x8a\xcf\x08\xa8\xc4\x00\x04\";D\xd7`\x1b\xac\xb3\x97\xda0x\x9f\x0c\x16\xc7\x069\x1a\xdb0\xda\xf0\xed\x82\x0e\x02\x8c\xd3\xa1\xda0\xda\x1c\xac\x96`\xc8\xb9K\xc0s~\xdcy\x1f,D\x067\xb3\xd1\xca\x10\x1f\xcf\xb0*/\x90[\xa0\x0e\" \x05~\xfc\xf1k\xd8\x9cDo\xedk\xf1U\xb6\x0d\xbf\xaeov\x9a\x14G\xc8K\x92\x16\xc7\xc2\xe2mRR\xdc\xb57\xc2U;\xe4p\xd4\xa8eDJ\xd1\xc7=\x0b\xbdo\xa3\xed\xeb\xb9\xe0\xdb\xd8ZA\x16\x16\x90\x05\x15\x04\xd8\xd0B\x80\xb5\x1c\x1f$@\x06\x08\x8fu>\x93\xbf\x98\xa3\x02k\xe2\xc2 \x023\xa0\xfe\xd1\x83\x07\x87Ol\x9a\x0e$4\x0c#6\xf07 \xbd\xf5\xd1\x83\x87\xe7\x87_\xe3\xf0\x87Xd\xa7\xf9,\x0c\xbc_\xe8\xa6\xe5\xe3;\xa7\x9bN)\x7f\x0b\xd4yJE\x0d\xef\x86\xdb\xef\xf7J6\x19\"4M\xc7m\xc3\xa0\xf5\x19r\xae\xaf\xbc\xc5\xeb$\x88\x93 \xb3\xde\xd2\xd7:\xf6r\xd4&\x83\xb5\x94<\xb62\xc7R\xa4\x0f \xa6\xf5\x16\xb5\x14\xe6\x96\x04\x85\x01D\x85ab|\x00qa\x08\x81a\xa8\x00\xffr\x03\xb7\x17\xdd;\x13\xdc#\x8a\xed!B{\xc0\x9a\xd8 =\x18C\\_\xfb\xa8\xed.\xab\x94`9\\\xb3\xa1\xb2\xd3Y\x1cM\xf1\xa11\xc3Q\x99\x8df\xb6\xf9L\xa2,\x88\xe8\xd4\xec\x9cdv>28\x17\x19\xcbys\xe9n\xac,\x0dW@\x80\x85\x184V\x8d\xc6\xc4\x02+\x82\x81\xad\"\xb4\"\x1c\xd8\x11\x0f\xec\xd5\xde\xf5\x0e\xd3F\xc9\xed@\xbd\x8d\xa2\xd8\xec$\xad\x15\xbd\xcd\xe4\x9a\x80\x01\n\xec\x1a\xc6h\xa7\xac\x0c\x07f8$\x13/\xb9\xe5H\xb0\x1epS\xe7\xea\xafL\xa1>\xe7\xf7\x06\x8f\xf9\xb5\xc1\xa1\xb7\x19\x8b\"\xa5\x8d\xfb\xb5$\xcb\xe8j\xcdo2f1\xac\x824\xa4\xc4\x07\"\xee,j\xf1\x89;\x8d}\x1e\xd5F\xaap?\xe1\xb5\x82^/\xd4u\x06\x07j51\xdc\xa4\xc9\xa4\x11\xfd\xe8r\x0b0\xd91\xfa<\x18-\xd9\x00E:@%#\xa0\x08\x08x\xada\x94\x83\x82\x9a)\xa0g\x0b\x80\xce \xc1\xadg \x18\x06*AOr0!;\xe0Io\x98\xbd\x81\xca\xd3\xc0dd`\xacj\xad-\x8dd\x05,#\x18\xe5H\x18,\x06.\xef\xc16\xc3\xc12\x97\xc12k\xc1\xa8\xaa$\x93\xbcW\x86n\x9e\x87\xe1\x06>\xe5$d\x14\xf4\x05}\xcbg\xdf\x19%\x7f )\x04\x91\x1c\xc9G6\x94\xfdE\x1c/B:\xe14\x9b\xe5\xf3\xc9\x8b\\\xbcm\xfa\xf1G1\x13\x8eV\xbc>\x0f3\xda}!\xbe \x04<\x12\xc5Q\xe0\x91\x90\xef!y\xcf?\xd0\xc9br\x87\x91\x96W[\xb8=\xb9\xcd\x84\x17\x7f\x91\xc4\xf3\xe8:\xa3\xfe\x8f\xfd\xcfF\x0b8\x89`\xcd\x88\x1dx\xf4\x0ed\x94\xacR\xc8\xd3\x9c0r\x88\xc2U\xeb d#\xcdbN\x8cY\x10\x91Dn\xb9\xf2GP6k\x9aV\xef\xeeo\xe4]\x0bQ\x07\x01\x7f\xe6=O\x9b\x1573z\xc5\x97\xfa8\xdaL\xe0\xe7\xf8\x92^\xd0\xe4\x8e\xd2*\xf9\xf0\xee\xd7\xd2\xeaa\xa8\x98\x98\x96~\xcb%(\x85\x8f\xcb,[\x7f\xbc#\xfe7\xfdx\x07\xe2\x04\xa2\xb8\xf8\xf5\x0e\xe7F\x8fD\x10\xf3\xdd\xc9(\"GH3\xc8\xd7E\xc9QE\xbf4\xb9\xa0\x89 \xcd\x8a\xacS\xc1Z|\xe4Y\\\xd5\x1d\xe5\xee\xbf@<\x98B\xe4^\xbay\x1c\x86\xf1e\xfaT\xb1\xb6\xff\x06'\xf3zF\x8c-\xd6I\xcct\xad_M\x9a[\x04i\x9a\xaf\xa8\xaf\xa8o\xfaoL7\xfd|vv\n\xaf_\x9e\x95O\xd4|x\xf7\xab\xd8c\x1b\xfe\xdc\xb8\xdcp\xf8\xaf\xee\xb68\xdb\xac\xe9?\xff\xeb\x9f\xd2\x06\xc5;\xcd\x8c\x1f\x04\xbf\x15j\x84\xaf\xd0:\x89\xfd\xdc\xa3@\"\xa1\xc2\xe4\xe9k\xff\x06\xc7uY\x90\x94\xbf\xc9C\x18\xcd\xa8\xcf\xc8\xed\x11\x8f\xc9\x968>\xcf\xd7P\\D\x84\x19I\x15\xc9\x85\xb1\xae\x8e\xca\x87w\xbf\xf21.\xc9\x05g\xc1Uc\x0f\xf9b\x13\x91rJ\xec\xdf\x17q\xe0\x03\x89T\xf1\x151@.>\x12:\x8f\x13z\xa7D\xc0\xf0\x92,\x98\x05a\x90m \xa2\xd4\xe7l4\xe3\x17{9\xab\xa9\xd2$\xe3\x88\x89\xd9hAy#\xbeg'\xf0\xc3\x87\x94\x96\x95\x93\x18\x95\x18{2\x99%\xf8\x93Dd\xa1\x9a\xfd,\xa1\xe4\x9c\xc9\xa0\x02\xf1\xe4G9G\xfd\x16g\xf4)dL\x87\xcc\xf3\xc8\x13;\x8c\xcd\xa3\x90]^\x9e$4\xca\xc2M\xc3\xf9\xad\x10\x97\xfc\xc9\xa4\xf9<\xf0\x02\x12jt\xd9,\x9fCB\x99&\xa2wx1\x99 +;\xcdS\xea\x0b#\xaf\xdc\x97RT3\xba\x08\xa2\x88M\xf62\xc8\x96\n\xe5\xb2Y\xd3\x89\xe0\x7f\xb2\x0e\xd2\x89\x17\xafT\xd2\xf8=\xdf\xa9)\xc4\xd9R\x08\x8a\xa8+\xa5\xe0\x87\xe25|\xbaZg\x9bbk\xff(W\x82\xc1b\x99\xc1L!\x94\xf8\xa4y\x94 X\xadC\xca\x94,\xdf0\x90\xae\xa9\x17\xcc\x03\x0fR\xba\"Q\x16x\x92L\xd1\x1d\xbc\xa9\xde\x05\xac\x95\xf4\x86\x89\xa3\x19\x05\"\x0e\x03\x0d\x03g\xcb\x8e)\x0b\x07\xcd\xe2\x0b9O\x17$(\xb6B\xef\x1bl\x88\x91}<\x8e6\x1f\xeb\x13\x0f\x89\x80$\xb3 K\xd8&\x96\x8f\xb0\x17U\xa9#H\x18\x17\xac\x07\xa4\x7fi\xff\x7f\xf6\xde\xadIn#I\x13}\xe7\xaf\xf0\xe596\xa4v\x8aU#\xcd\x9e\x17\xcejl(\x92R\xd7\xac\x9a\xace\x91j\x1b\x1bkK\xa22#\xb3\xd0D\x02\xd9\x00\xb2.\xa3\xe9\xff~,n\xb8e\\<\x02\x91\xc5j\xc9\xfdET%\xe0\x88p\xc4\x0d\xf1}\xfe\x05\x1f\x9d\xc5D#Kx5^\x16N\x96\x7f\xdd\xaa\xce\xd24/t\xc7)\xf2+Ql5\x8f4\xd0\xecw\xbb\xaa\x163\xf8.[~9\xdb\x97\xfc?|\xde\x96\xed\xc2\xdc\x83\xd4Do_\xd8Tk\xd8\xb7r`\xd3\xc3C\xc3\x07\xd6l\xb5\xca\xe5X\x01\x1bV\xb2:kE\xe1\xf9w\x96\xd6\x822\xfa\xe3\xe5\x91\xaf\xd0\xfc\xbc\xb7w\x19o\xfc\xf0\xedK\xb8\xe0\xe5\xe7\xe3\x82\xaaJ6\x14\x04\x7f\xfd\x8f\xff\xe8\x98&\x7f\xac*XW\x15|\x0f\xa7\xa7\xa7\xffb\xbd\x8c\x17&+\xef\xed\x17d\xe5\xfd)/\xc6\x8fu\xb5}\xbe\xae\xaao\xec\x97\x9e\x9e\xda\xe7\xbf|\x0d\xcf\xb9\xabO\xa2\"\x1f\xab\xe7\xff\xc0}}\x03\xbf:\xc6p\x97\xbf\xbf\xb9c\xf7\x9d'v\xff\x9e\xddd\xc9\x82\x07\xdf\x8b\xb5!\x7fJ\x82\x08\xe5\xcd\xf3\x1f\xab\xeatYdM\xe3 \x90,\"\xbfI\xd6qp\xa3\xbd\x0c\x96\xc8u\xa1\xfbgO\xe8.\xee\xdb\xeb\xaat\x04O\x96\xea\xc7\xaaz~zzj\x9f\x0d\xba\xc0=w^#\x1a\x9f\x08klT\xb9\x93s\x19\xd47o/_\x7f8\xbf\xf8\xf8\xfe\xc37\xae]\xb2\xbe\xa1\xba\x1f,\x1f\xed\x0e\xe7\xff\xf2\x84\xf3\xa7\xca!\x11\xc7C\xf9\xf2{\xf8\x87\xdd\xd5\xe9\x8fU\xf5\xeb\xe9\xe9\xe9\xdf\xec\x17g\xe5\xfd _\x86\xf2;vr\x11\xf5\xc7\xacn\xae\xb3\x82\x07\xd9]\x11W\x08\xa7\xa5p\x14!_O\n\xf0\xa9\xdc\xf6E\x10\x05\x14\x1dD\\\xf5?\xbe\x872/\x9c\x0d\xdc].KK\xe6\x1f\xb7\"\xcez,\xd6\x1f\x1apu\xdf/\xbb\xf4\xec!\x8f\xde4\xafz\xd5&\x19_\x96\x98\x1f\xf5\xcc\xb0\xa4:\xe3\xdf\xef\xa7\xe2\x07\xbe\\}\x06\xd9`\xb6\xe33\xa1\x12\x0d4:\x94-\xc4\xfc\xb0nj)\x8b{\xfd]y\xb0Y\xd0-\x93![\xb7\xcc\xb4E(M\xecc<;{f~\x94\x9a\x13u\x91\xc5\xd7.0\xd5\xa2\x9f\xae\xab\xea\xf4*\xabEe\xef\xce\xeeO\xff\xeb\xa9\x8c\xa2\xf8\xf62\xfa\xb3\x7f\x8a\x8a\xa2>\xe5>\xf8th\xbc\xe4\xdf/\xdf\xbf3\xff\xf2\xfd\xf7\xdf\x7foo\x03\xfc\xbe~\xcfE\xae#+>\x1c\xa8E\x90\xfc\xae\xdb7Lo\xafn\xf6Ef\x11\xb4>t\xc3oY\xb1~\xd9r\x02l{\xc5V\xab~\x01s\"\x97\xe3&w\x99e\xf7f\xb0\xa4X\x8b\x0f\xd9\xcf\xff\xc6C\xf7Ym&\x8c6\xaa\xf5\xcb1w\x105\xfc\xbct|\x80d\xcb/|\x0c\xea?\x88\xd7y\xc1\xec\xf3\x86\x1e\xb3.X\xddT\xa5\xb3\xdb\xaa\x9d8qb\xecB\xbc\xe1\xef\xe1[\xbb\xe7\xee\x06\xc1KP\xd7\x7f\x17>\x83\x018K\xf5T\xc4\xf2\xe9Kxj\xea\xb5\xe30\x9c\xcaZ>=q\xf9\x13\xf5{\x97m\xb9\xcf\xff-\xab\xf0\xaf\xce\x1bx\xfd&\xd7\x87V\xf2|\xad>\xb8\xc6mM\xb6\x86\xbc\x81[V\x14/\xbe\x94\xd5m)\xc6\x99\xeb\xac\x81\x0c\x96\xfb\xa6\xad\xb6\x81\x9dk\xdc\xe4O\xe4\x02~\xd2\x0f\xf4\xb9\xc5]qx\x03\xb6|\\e\xb2I\x9b\x1f\xf6YtF\xdd\xce\xaf\xabb\xa5DhE\xc9eW\xce\xcb\xae\x7f\x80\xdc\x014\xbb\x92]\xc6\xfc\x1cQ\x84\xd3nr~\xce\xc75\x1d\xc2\x83\xad!\xbdc\xfa\xe7\xff\xfc\xf37\x8e\x8e\x94\xa2\xcd\x8d\x1f\xe8nv\"T\xdc\xe5\xb7\xa7\xdf}\xfb]\xf3\xd4\xd1\x84\xe4\x7f\xdbl3\x00\x0d^\xc0%\xabo\xf2%\x8f\xde\xb3\xb3e\xd5l\xab\xe6\xec*k\xd8Y\xdb1\xf3\xcen\xbe\xbdbm\xf6\xed\x99@\xbf\x9a\xb3_%\x9b\xe7o\xcf\xa4\x9bM\x9fu\xd9\xec\xb7\xdb\xac\xbe\x7f ?1\x896\xfdp/\xcf\xaa\x86\xbf\xeeY\x9d\xb3F\x01h<\xd0\x9b\xfc\x86\x95\x8a\x18\xa4G\xadj\xc7d\x9d\xcfW\x87>\xd45\x1aw\x1aT\xe2\xd9w\xff\xf4O\xcf\xec\xe0\x154\xfb\xe5\x925\xcdz_tw\x0f\xc7\xc9D\xb0\x95\x9d\x11du\x06^(\xc7NC\xf1\xee_xv/P\x0c\x1fg\xc9\xc1[z\xf03yZ\x14\x83\x07\xc3\xdcy\x88#\xfdQ\xcc\x1c'#\xc7\xa2\x84>\xa7\x89\x1c\xf7\xfdy\xe5\xeaC\x85\xe9\xbde\x02T\xb9\x00'+\x8fz\xef0x\xf7^\xd5u\xaf(|\xeaGbv\xf2\xa4\xe1\xc4\xdba,\xc6\xee\xaa\xeaH\xa6\x1d+\xbb\x8e\x15X\x1f\x0b\xa6;\x1c\x86J\xa9\x87\x8a\xa6\xfb\xe5\xd1\x11\xaf\xf4\xc1(\xaen\xc1\xf2\xa0\xc7\xf8\xb8DH\xb9\xf1\x84=\xdaO\xbbDU\x100\x83\xb94\xd4<\xa8\x0dUS@\xd7\x16\xfc\xf3cw\x19j\x9e\xd4\x86iG\xda\xfc!\x87\x90\xb0\x03>\xf4\xc8\xf9tr\xb1\x9b\xe9\x8a\x17\xbeF\xd5\x08U\x93p\xd9j\x84@u\xaa\xe2\xa1\xf5\x8dS=p\x1a\x0f\xaf\xd2\xb3S\xb99L\xa39U\x1d\xb0\n\xcb\xa9\x9e\xe7\xd7GN\xf5\xa4\x00u\xe3T\x8fDj\x13\xa7z\\\x98\xb20^C8M\xf9F\x8b9\xaf\xa4o\x88L/\x1fS\x8e\xf6\x15\xd0\xdey#\x93$s\xc0;\xc1x\x03\x0cA+\xe6\x8fw\x8a\x10\xa67\xaf\xc4\"S\xa2\x03r\x19\xf9o2\xf0\xa7r\x13\xe2\x1f\xbfu\x1e\xb6\xfcN\x1c\xa4,(nE\xc1\x83\x06\xd7\xacf\x82\xe0#\xc6\xb0S\x80?\xb1g5\x83\xbf\xec\x9b\x16\xb2M\xcd\x98\xbb\xba\x8a\xd1T\xd5\xbc\x9d\x88-F\xe7\xf3\x05\xf5q\xcb\xb2R\xd5J\x16\xfd\xd5n\xf7\x87\xac\xb9\x86U\xc5$\x9dD\xd1\xaa\xb9\xeb\xc65A\xb7w\x16f\x85/ \xe0\x0d_\xe9\x8f6\xa8\x15\x15Z,\xca3\x05\x9b\x0f\xd9\xddv\xfa\x92mvp\x9f\xcb\x97\xa0\xcd\xfb\x0f\xfeK\xd8\xf0\xbdkJ\x7fy\xa5\xad\xf4\x99\x8a\x0bq,\xbe\xbf\x12\xd2\x90\xa5\x80\x80\x92\x80>\x9a\xdf2,\x8d-\xa0\x00\x10X\x08\xd0\xeeQW\xa2\x87\xa2\xa1\xe1\x12\x8a\xb4\xd1\xd1\xfc\xca\xe8h\xfe\x81\xd1\xd1\xfc\xa8{\x82\xc4\xf2\xc3>\x9b\xa5\xb92C\xcc\xe6\xdf\"\x19[\xe0X\x07\x11\xe3\x1d\xa0\xbf\xec{\x8bx}\x80]\x92M-h\xdbel\x11\xd1\x83\xc8\x08rCn\xd0\x8c-\xa6\xddi\x0b\xef\x12\xdaB_8\xc4\xbft\x88}\xf1\x81\x9b>cCm\x01\x8d\x0d\x9d\x8b\xa9-\" \xd8\xfd\xd4\xb1\x05\xa7\xaaj\x9bQB\xf4\xab\xa2\xa3\xf9\xc3\"\x16\xb3\x04\xf9\xbb>\x9a_\xac\xec\xaf0/ p\xbc\x0e\x1d\xa7ie?1Z\xd9\xd3\xca\xdeo\xb4\xb2\xf7]\x0d\xb4\xb2\x0f\x9b\x03\xa5\xd1\xca\xdej\xe1]B[\xe8\x0b\x87\xf8\x97\x0e\xb1/\x9eV\xf6\xdahe/-|\xbc\xa5\x95\xfd\xa1=\xf4\xca\xfe\x11JC\xf6m\xf6q\x94'h\xe8\x89, v\xc8 m\x9fo4@\xc4\x1b\xe9\\\x99\xca\xee\xc5\xa8e5\xb4\xb7\x15\xf7\xb5.\xf2\xa5\x90\xaa\xe4\xad\xd6\xd3\xe6\x84\x80\xe5B\nT.2\xa1\x9e\xf9\xb5a\xabA\x0d\x16\x08\x92\xa9\xb4\x80\xb2@`y@\x0d\x8dl\x15\xb8\xaa\n,\x13D\x94\x0b<\x1cd\xb3E\x14\x0c\"\x0b\x07\x18\x16\xb3\xd9B\xb9\xcdf\x8b\xac+\xcc\xa8/\xe0\xd8\xd1f\x0b\x1c\xb0\xa6\xa6\x070/\x93\xdal^~\xb5\xd9\xbef\xa1C\x87\xe0\xa9\xe1x\xdb\xc1n\xc7<\xef \x9b;\xd8\x1b\x92\xfdm6,'<\xd8\xf1\x88C\x1e\xcc\x147[(\x7f\xdcl~V\xb9\xd9\xa2\x1br\xd8\x8e\x8e\xb6\xe8\xc7\x85\xae\x99\x86\xe6\xe6\xb0\x9b-AA\xb1K\xaa\xb1!Y\xf0f\xfbJc\x7f\xcc~\x01\xcc\x0b2\x84\x7fZ\x8dm\xc6\xc6\x91\xb6\x19\xd1\x86\x99\x11\x87\xd8\x0d%m1\x1f\xd8S\x8b\xef\x91\xdab\x1b\x0e\xcco<0\xb7\x01\xcd\xda\x80\xd2\x16\xb1\x11\xa5\x0d\x9f{`\xb6\x19\xf1\x9b\x11\xb7\xf0\xec\x05\xb3!r\x1a\xcc\xf65\xaa\x8d\xce(0\xdb\xd7(\xb2\x9fuk7l*F\xb0cW\xea\x86\xd9\xc2\x12:\xcc\xf65\xc2\x8fM 1\xdb\xd7(\xb1?\xa9\xc4l_\xa3\xac\x01i)f\xfb\x1a\x85F&\xb6\x98\xedk\x148,5\xc6l\xf8\x84\x19\xb3=|\xbd\xe7|\x9d{3t\x82\xbc\x05d\xf3\x98\xcduL\x8f\xd9\"W\xc4\xb1+\xe1\xbf\xa3o\xd0 \xb6\x81\xb69\x8b\xf4p4L\x1b}|b,rx\x90F\x1f\x9f\xd1\xedZ[|W\xd4\x16\xdbp`~\xe3\x81\xb9\x0d\xe8k\x7f|b\x8ex2\x9b\x8c\x1c\xf68\xd5\xa1ys\xdb\xcc6\xab\xa3\xcc\xeb&A\x07J\x99mvC\x0bc\x94\x8e-\xf6H*\xb3E\x1eTe\xb6\xc8\xe3\xab\xcc\x16~\xa8\x95\xd9f\x1due\xb6\xf8\xafpi\xa9\x8e\xc52[\xd0aYf\x8bf/\x8dmv?\x99=\x1c\x07p4\x0e-Y\xf1\xe3@\x07i\xc1t\xa8\xb1%\xabC\xd4+\x98\xf3\xdd%\x0d{\xae\xe3\x00\xbc\x82O\x1f~>\xabYS\xed\xeb\xa5:\xe6Y\xf4\x98}\x99\xffu\xcf\x8a{\xe0\xdd\xa8\xcd\xd79\x1b\x9c\x11\xec\xe0\x85\xc8c\x1a\xf4\x11\xc6\x8e\xb3\x82\xeb\xaa\xad\x96U\x01W\xfb\xf5\x9auG\xa6\x9e\xca\xd3'd\xdd`\xbbo\xban\x0d\x99}YR\xb0\xaci\xed\xcf\xaaJ\x06O\xcf\x9e\xc2\xf2:\xab\xb3e\xcb\xeaSq\x9a\xb38\xb0\xbaa\x9b-+\xbb\xb1\xeb\xd3\x87\x9f\x9f5\xb0\xcb,\xa7,s\x13\x85\xead\x99\xecOm\x0dgi\x8b\xf8\xaaG\x89H>\xcf\x1a\xc8-G7s\xfb\xcc\x8bb=\xd5\xf5\xf37\xb2&\xc2ms]\xed\x8b\x15\\\xf1\xb1\xd7\xea/\x83eVVe\xbe\xcc\n\xd1\x87\xecO~\xceN7\xa7'<\xb4Bq\xe1\xe9\xe9S>|\x89SI\x96K\xb6k\xd9\xea\x9bS\xcb\xf1\xda\xdc\xceK\xd8\xf1`\xe7Kv\x02-\xcb\xb6\x0d\xec\x9b}\xc6\xc3!\xc5\xabvy\xc1K*\x8f\xdd\x85\xab\xbc\xccj\xfb\xeaU\x1c\x84r\xbfc\xeaD\x92\xf6\x9a\xdd\xdb\x1f-\x87:\xc8[\xfe\xb5\xbdo\x86\xaa\x9b-\xbb\x13\xaf\xfaUy\x7f\n\x7f\xa8n\xd9\x0d\xabO\x9c+\x93O\x1f~\xd6+\x1fu@\xba\xfd\xc1b\x04e\xf0\xf9\xbamw\x9fO\xe4\x7f\x9b\xcf'P\xd5PV\xea\xd7\x13\xd1\x1a\x97Y \xd5N\x9e\xcb]\xd8\xab\xcdg\xa1\xfdN\xc9\x8e:\x9e\xcb\xea\x1bq0{\xd6\xc26\xdb5\xb2i\x89\x92\xb7U\xa7=*\xb6\x00syhJf\xdf\xa9[WEQ\xdd6/\x1d\xef\xf6\x7f\xc2\xf9\xba\xaf\x11o\x16\xfa<\xfc\xae\xd2bU\xd04\xfb-[94N\xff'\x9f\x9b\xfe\xf0\xf1\xe3\x05\xfc\xf4\xf6\xa3>\xa6\xe6\xd3\x87\x9fe\x1f\x13\x87\xbf;\x16\x0f\x07\xa7+\x7f\xbc\xdf\xb1?\xff\xe7\x9f\xad7\x80:\xa0=/U{S\xd3\x88xC\xbb\xbaZ\xed\x97\x0c\xb2RNav\n\xdb\xff\x84W\xbd4H#\xce\xe5\xc9x\xcc\xd8\x8a\x87{\x99-\xf9\xd8RU_\xf6;P\xc9\x88p\x955\x0e\x82a\xe5\xd3R\x11\x07\xe6W5\\g7\xa2 n\x07}h%;Q\xa6\xab\xc4\xff}S\xe5+\xc8J\x17\xc6\"\x0b(\x86\x8f\x9a\xad\xab\x9a\x9dh\x07\xdco\xd6\xe6Wy\x91\xb7\xf7P2\xb6\x12\xcd\xe8J$\xf7\x8a\xa6\xe6\xa2JV%\x1ff\xcb\x0d\x137\x89>{\n\xcf?5L\xab'\xf1(\xf1\xe6\xc9\xc7,\xd9>\xb32\xdb\xb8j\x7fU\xb3\xec\x0b\x1f\x83\x94\xe3\xd3o\xec-\xea]\xd5\xb2\x97\xd0\xf29d\xbd/\x97\xb2\x87\xf1z\xa8\xb1k\xb9\xafkV\xb6\xc5\xfd`\x03\xdc1\\\x8ac\x93\xd6\xeb|\x99g\x85g.\xbb\xda\xaf\xa1f|&b'BP&o\xf5C\xf7\x0d[\xc9e\x9e\xee\x97VWWl\x93\x97%\xaf\xac8\xe9\xdf^\xb0\xc3\xb3\xbf]\xa3\xf1\xa5\xe8\xa9\x0dT\xed\xb5\x1c(\xca\xe9(\x05\xcf\xe52\x14\xd8v\xd7\xde\xab\xae\xfd\x8d}\x12\x14\xab\xd1+\xc7\xa0$*-\x90\x82|\xbb+\xd8\xb6;\xe1\xbd\xd9\xb1e\xbe\xce\x97\xd0\xb0mV\xb6\xf9\xd2\xc2\x16\x15}u\xc6\x12\x08\xf1\xd1\x83]%\xfd\x91\x0fGW\x0c2\xf9A0X\xe0\x1c\xacc\xb4x\xd0Uuco\xd3*\x04\xaa+\x18\xcfaC\x94\xec\xf3\xab\xf2\xfes\xff\xd5\x93\x95\x90\xd5Wy[\xf3Nl/\xa1\xd1\x95\x9e#\xb2\xa2RM\x0f2\xf3\xab\xe5\xa3\xb3\x98hd \xaf\xc6\xcb\xc2\xc9\xf2\xaf[\xd5Y\x9a\xe6\x85\xee8E~%\x8a\xad\xe6\x91\x06\x9a\xfdnW\xd5b\x06\xdfe\xcb/g\xfb\x92\xff\x87\xcf\xdb\xb2]\x98{\x90\x9a\xe8\xed\x0b\x9bj\x0d\xfbV\x0elzxh\xf8\xc0\x9a\xadV\xb9\x1c+`\xc3JVg\xad(<\xff\xce\xd2zPF\x7f\xbc<\xf2\x15\x9a\x9f\xf7\xf6.\xe3\x8d\x1f\xbe} \x17\xbc\xfc|\\PU\xc9\x86\xa2\xe0\xaf\xff\xf1\x1f\x1d\xd3\xe4\x8fU\x05\xeb\xaa\x82\xef\xe1\xf4\xf4\xf4_\xac\x97\xf1\xc2d\xe5\xbd\xfd\x82\xac\xbc?\xe5\xc5\xf8\xb1\xae\xb6\xcf\xd7U\xf5\x8d\xfd\xd2\xd3S\xfb\xfc\x97\xaf\xe19w\xf5IT\xe4c\xf5\xfc\x1f\xb8\xafo\xe0W\xc7\x18\xee\xf2\xf77w\xec\xbe\xf3\xc4\xee\xdf\xb3\x9b,Y\xf0\xe0{\xb16\xe4OI\x10\xa1\xbcy\xfecU\x9d.\x8b\xaci<\x01\x92E\xe47\xc9:\x0en\xb4\x97\xc1\x12\xb9.t\xff\xec \xdd\xc5}{]\x95\x8e\xe0\xc9R\xfdXU\xcfOOO\xed\xb3A\x17\xb8\xe7\xcekD\xe3\x13a\x8d\x8d*wr.\x83\xfa\xe6\xed\xe5\xeb\x0f\xe7\x17\x1f\xdf\x7f\xf8\xc6\xb5S\xd67T\xf7\x83\xe5\xa3\xdd\xe1\xfc_\x9ep\xfeT9d\xe2x(_~\x0f\xff\xb0\xbb:\xfd\xb1\xaa~===\xfd\x9b\xfd\xe2\xac\xbc?\xe1\xcbP~\xc7N.\xa2\xfe\x98\xd5\xcduV\xf0 \xbb+\xe2\n\xe1\xb4\x14\x8e\"\xe4\xebI\x01>\x95\xdb\xbe\x08\xa2\x80\xa2\x83\x88\xab\xfe\xc7\xf7P\xe6\x85\xb3\x81\xbb\xcbei\xc9\xfc\xe3V\xc4Y\x8f\xc5\xfaC\x03\xae\xee\xfbe\x97\x9e=\xe4\xf1\x9b\xe6U\xaf\xda$\xe3\xcb\x12\xf3\xa3\x9e\x19\x96Tg\xfc\xfb\xfdT\xfc\xc0\x97\xab\xcf \x1b\xccv|&T\xc2\x81F\x87\xb2\x85\x98\x1f\xd6M-eq\xaf\xbf+\x0f6\x0b\xbae2d\xeb\x96\x996 \xa5\x89}\x8cgg\xcf\xcc\x8fRs\xa2.\xb2\xf8\xda\x05\xa6Z\xf4\xd3uU\x9d^e\xb5\xa8\xec\xdd\xd9\xfd\xe9\x7f=\x95Q\x14\xdf^F\x7f\xf6OQQ\xd4\xa7\xdc\x07\x9f\x0e\x8d\x97\xfc\xfb\xe5\xfbw\xe6_\xbe\xff\xfe\xfb\xef\xedm\x80\xdf\xd7\xef\xb9\xc8ud\xc5\x87\x03\xb5\x08\x92\xdfu\xfb\x86\xe9\x0d\xd6\xcd\xbe\xc8,\xa2\xd6\x87n\xf8-+\xd6/[N\x80m\xaf\xd8j\xd5/`N\xe4r\xdc\xe4.\xb3\xec\xde\x0c\x96\x14k\xf1!\xfb\xf9\xdfx\xe8>\xab\xcd\x84\xd1f\xb5~9\xe6\x0e\xa2\x86\x9f\x97\x8e\x0f\x90l\xf9\x85\x8fA\xfd\x07\xf1:/\x98}\xde\xd0c\xd6\x05\xab\x9b\xaatv[\xb5\x13'N\x8d]\x887\xfc=|k\xf7\xdc\xdd \xb8 \xea\xfa\xef\xc2g0\x00g\xa9\x9e\x8aX>} OM\xbdv\x1c\x86SY\xcb\xa7'.\x7f\xa2~\xef\xb2-\xf7\xf9\xbfe\x15\xfe\xd5y\x03\xaf\xdf\xe4\xfa\xd0J\x9e\xaf\xd5\x07\xd7\xb8\xad\xc9\xd6\x907p\xcb\x8a\xe2\xc5\x97\xb2\xba-\xc58s\x9d5\x90\xc1r\xdf\xb4\xd56\xb0s\x8d\x9b\xfc\x89\\\xc0O\xfa\x81>\xbb\xb8+\x0eo\xc0\x96\x8f\xabL6i\xf3\xc3>\x8b\xce\xa8\xdb\xf9uU\xac\x94\x10\xad(\xb9\xec\xcay\xd9\xf5\x0f\x90;\x80fW\xb2\xcb\x98\x9f#\x8ap\xdaM\xce\xcf\xf9\xb8\xa6Cx\xb05\xa4wL\xff\xfc\x9f\x7f\xfe\xc6\xd1\x91R\xb4\xb9\xf1\x03\xdd\xcdN\x84\x8a\xbb\xfc\xf6\xf4\xbbo\xbfk\x9e:\x9a\x90\xfc\xef.\xab\xb3-k\xd9\x90n\xfbB\x8c\xbc/\x15Ug\xe0\"/_N\xb7\xb2k\xf6\xd7}^\xb3\xd5Kh\xeb\xfd0\xe8\x96\x0fj\x13\xf1\xa2\xcd6\xa3\xa7_\xb2\xfa&_rgg\xcb\xaa\xd9V\xcd\xd9U\xd6\xb0\xb3\xb6#\x08\x9e\xdd|{\xc5\xda\xec\xdb\xb3\xb2Z\xb1E^\xae+y\xfb\xa6\xcf\xfal\xf6\xdbmV\xdf\xbf\x84\x9fX\xfb\xaeZ\xb1\xf3r]\xc1_\xf7\xac\xd6\xb8\x83\xda\xb8\x01\xeeB\xe8M\xe9\xb1\xb2\xda1\x19\xe9\xf3\xd5\xe8\xee'\xba\xc2\x12\xe8\x1a\x94\xf8\xd9w\xff\xf4O\xcf\xech\x194\xfb\xe5\x925\xcdz_tw\x0f\x07\xe6D8\x99Z\x90,&1\x19\x9a\xd5+xA$\xfd\xd1\xbfpj\x96;\x1f\x00\xde\x87\x88+\xbes@\xe5\x88]\x9a\xbe\x899E\xb3=2\xe4\xe9\x1e\xe4\x14\x0eO\xf3\x98\xf1\x9b\xb7\xf0\xd0<\x8f*\xf2\xa6e\xa5`JD\xdd_\xb2\xf6\xb6\xaa-\x11\xf5\xdc\x8bhR\xd6{\x97\xd7YY2\x13\xd0\x8a\xb8\xd9\xbb\xa7\xb7\xad\xca\xfc\x8b\x8d\xf3\xe6q.\xb6F\x8f\xd6M\xda;\xdfA9\xde\xba\x03\xd4\xbb\xa5\x9f\x1b\xe3\xf03P4\xb7\x8f\x0b3\x06\x1d1\x0d\xc5\xc4>\xdb\xed\x16\xd17\xcfi\x8e\x9b\x1cC\xa0\xb5\xde~\xb5\xcf\x8b\xd5b<\x1f\x06\xdc\xbe\xa90\xc3\xb3\xe7\xe9+\xb6s>\xddN\x0btR\x02\xbdm\xde\xd7\x18\xd45Y\xeb$c\"Z\xbd\xb8LR\xd7\xb6\xd5j_07<\x8f8\xa4#\xea\xa1\xca\xaf\xf5\xfa\xc6\xcdK\x0c{\xe6\xf2\x9a-\xbf4{\xf3:\xbf\xbb\xea\x8f\xb2d\xf9\xe0#\x92/\x82\x7f\x91%=7\x8br\xca%\xda\xa2Y}\x99\xd1\xf8F+\xa6\xc1\xf3\x0e\xca\xc2\xffg\xb0(\xeb\x98P\x1d0`\xf5jbU\x1d\xb8\xe9\x08U\x7f\xdd\xb3\xa6\x1d?\xb6cPMV\x84\xda\x88J%\x8d\xa8TD\xa5\xea\x8d\xa8TD\xa5\xea\x8d\xa8T-Q\xa9\xccFT*mD\xa5\"*\x15Q\xa9\x90\xab$\xa2RuFT\xaa\xa1\x11\x95\x8a\xa8T\x06#*\x95\xf1\x1a\xa2R\x11\x95\xcabD\xa5\"*\x15Q\xa9\x88J5\xb0\x14\xb4\x16\xa2R #*\xd5o\x85J\x15Ocj\xee\xcbe^*U\x13\x0b\x89\xe9R^\xd3q\x98\x04oI\xddh\xa3.\xa9{\xd4\xaf\x8f\x96\xb94\xaa\xfe\xd0\xa4\xaf\xab\xaa*Xv\xb8\x11\xd4m\"\x18~\xf7\"\x7f*4(%\x85\x1e\xf9\x1b\x07T\x1b\x01\x7f\xd2\x08\xf8#\xe0\xaf7\x02\xfe\x08\xf8\xeb\x8d\x80\xbf\x96\x80?\xb3\x11\xf0\xa7\x8d\x80?\x02\xfe\x08\xf8C\xae\x92\x08\xf8\xeb\x8c\x80\xbf\xa1\x11\xf0G\xc0\x9f\xc1\x08\xf83^C\xc0\x1f\x01\x7f\x16#\xe0\x8f\x80?\x02\xfe\x08\xf8\x1bX\n\x10\x86\x80?a\x04\xfc\x11\xf0\xd7\xcb\x81\xb3\xb69+\xb2\x965\xad\x13\x05\xfcY\\\xd2\x9d\x8ft\xc9\xda\x0e\x10\x94w\xf7\n\xe3/\x1a\xd6\xda\x80\xc1C7\xea\xc2G\x8b\x11\xca\xe3\x1fl\x87\xc78w\x1e\\g}\xb8N\x9bk\xbf\x02\xca\xe4\xc9\xc6\xf6\xee\xb0x\x8en\xf3\x94\x0e\x10%\x04\x04\x16\x06\x98\xa2J\xc3\xec\xa9h\x0b\xc5\xc5\x9c\xce\xcc\x9b#\x8eo\x85\xd4\xf8\x18\xf812\x88\xc0\xc9\xdc\x15\xc8\xdak4V\x06\xa9\xf02\x88\xc4\xcc\x9c\x0eyp\xd1\xb8\x19\xcc\xc7\xce \x18?s\xbaR\xfb\xfaA\x18\x1a\xa4\xc6\xd1 \x10K\x83P<\xcd\xdd\xb2;\xac\x0d\x8b\xa9Aj\\\x0dp\xd8\x1a\xa4\xc4\xd7`6\xc6\x06q8\x1b\xa4\xc2\xda \nosw\x87\xaca+?\xe6\x06\xc7\xc1\xdd\xe0\x88\xd8\x1b\x1c\x07\x7f\x83@\x0c\x0e\xe2p8\xdf\x10\x8c\xc3\xe2 -\x1e\x07\x01\x98\x1c\x84\xe3r\x10\x81\xcd!\x86\xcco\x10\xf8\x1c\xa4\xc0\xe8\xc0\x87\xd3\x01~y\x86\xc0\xeb p\x15\x17\x8c\xdb9\xbd L\x0f\x81\xddA@)\x13bx\x10\x84\xe3Aj,\x0f\"\xf1l\x0f\x92\xe1{\x80\x87\xa9\x00\x83\xf3A\x18\xd6\x07\xbe\xcd\xf9H\xcc\x0f\x10~\x1d\xfb\x7f\x89\xf0?\x88\n.\x1e\x07\x04D-#\xf0@\x88\xc5\x04\xc1\x1d\xd5t\xd8 \xe0\xf1A@b\x84\x80\xc6 \x01\x17\xf5p\xbc\x10\x820Cp\xe2\x86\x90\n;\x84P\xfc\x10fb\x88\x80\x08o\x00\x96\x08\xc7\xc0\x13\x01SFGOH\x87-\x02\x06_\x84\x19\x18\xa3\xd5!\xbf\xd0\x853Bj\xac\x11\xbcx#\xc4b\x8eVo\xf2\x1b\xd5\xfd\xb9\x8e\xc0\x1e\xc1 \x91\x80\x13\x83\x84(\x1c\xd2\xea\xca\x89OB,Fi\xf5&\xd7\x81\x8e]\xb3tX%\xa0\xf0J\x88\xc0,!\x0c\xb7\x84\x18\xec\x12\x82\xf1K\xf0\xcc\xb6\x1eL \x02p%,\x96 1x&\x84b\x9a\xe0\xaex\x0c\xb6iu6@\x0e\xb1]\x06\x87q:;D\xb9q\xe3\x9c\x90\x16\xeb\x04\x1f\xde n\xcc\xd3zO,\x16\n \xdbn\x00&\nA\xb8(\x0c\xb0\xd1\xb1\xddTm^n\x16\xbb\xea\xd6&\x8d\x8c\xda\x99\xf0\x9f\xde\xbf\xab\xab]\xd5\xb0z\xb1\xab\xf3\xaa\xce[\x0f\"6\xebic\xedR\x0d(\x1a\x95K\x8d\xe0\xac\xb6]\xb6\xc9K\xf1.\x0e\x0b;zF\x7f\xa1\xdc\xe7fb\x8fb\xf0W\xfd8\x13\x1e+\xadu\x01\x81\x1eQfv\xd7\xda1Fo<\xbd;JJ\x8b\xf6\xbfm\xfb3\xfa\xf9:\xc0\xfc\x9fj;6k\x1a\xb9\xff|\x91m\xd8\x07\xa9\xe1z*\x7f\xb78\xfb\xeb\x9e\xd5\xf7\xc2\x0dw\xcbc\xc8`[5-0\xb1\xa9)vC\x0d\xb7\xb6U\x9bY\xd0Ot\x00\x1c\xaa\xf1\xbe\x83\xf5\xc5\xe3E\xfd\xc5?\xca\xfd\xf6J\xee\x96\xe9\xd4\x96A\x1e\x85m?e\x18\xa2e\xb5/\xdb\x85pf\x1bzn\xb3\x06\x1a\xd6\x9e@\xde6\x1aEh`_\xca\x06\xb8\x92\x1b\xa5\xb7y3~\xa7\xde4\xdcC\"\x02*#w\xe2\xa8\xcb\xcf\x1d:\xa2#\xce'F\xe9\xb9\x94\x9e\xdb\x1b\xa5\xe7RznoIi\x05!\x94\x82 :\x01\xa5\xe7\xce\xa5\x0eD\xd0\x06\x92P\x06\xc2\xe9\x02\x94\x9e;\x87\x1e\x10B\x0d\x88\xa0\x05Pz.\xa5\xe7Rz.\x16\xd6O\n\xe9\xc7\xc0\xf9\x94\x9ek\xbb\xcc\x0b\xdb\x07@\xf6\x98\xe4\xd3\x10\xa8\x9e\xd2s)=\x17\x03\xbbSz\xae\xb09\xd0:\xa5\xe7\x9a\x9f\xe8(\x91\x16\x85\xb6\xf6+P*H\x8b\xc2a\xa1$\x10\xa733\x12\xe0\xd8\x18KM\x06\x01?!\x04\"H!\xee\n\x90\x16E,Q\x04\x82\xc9\"NW\xa4EAZ\x14\xb1\x84\x12\x88#\x95@*b D\x91K\xdc\xdd\x81\xb4(\xc2\xc8&\x10H8\x818\xd2\x89o\x08\xc6\x11O -\xf9\x04\x02\x08(\x10NB\x81\x08\"\nb\xc8$-\ni\xc1$\x15\xa77\xd2\xa2 -\x8a\x89\xa5!\xb3\x00\x9e\x93\x01\x18R\x0b\x84\x11[\xc0\x87DG\x12\\\x00\xe1\x97\xb4(\x1c\x16E\x80\x01\xd2\xa2P\x16E\x8e\x81 \x82\x0c\x90\x16\x05\x868\x03\xc7 \xcf\x00\xa6\x8c\xa4E\x91\x96X\x03^r\x0d\xc4\x12l\xac\xdeH\x8b\x02G\xc8\xb1z#-\n$Q\x07\x82\xc9:@Z\x14F\x8b!\xf2X\x9d\x91\x16\x856\xd2\xa20\x18iQ\x90\x16\x85\xf1\x02\xef\x8e\x12iQ\xfc\x8e\xb4(LT\x04R\xa3\xe8\xcc\xd1\x98H\x8d\xc2p;\xa9Q\x04\x10\x10H\x8d\x82\xd4(zKJ,\x08!\x15\x04\x11\nH\x8db.y \x828\x90\x844\x10N\x18 5\x8a9\x04\x81\x10r@\x041\x80\xd4(H\x8d\x82\xd4(\xb0\xc0~RP?\x06\xd0'5\n\xdbe^\xe0>\x00\xb4\xc7h-\x84\x80\xf5\xa4FAj\x14\x18\xe0\x9d\xd4(\x84\xcd\x01\xd7I\x8d\xc2\xe4\xc9\x0b\xa0\xc7\x82\xe7\xd6\xb9\x81\xd4(\x0e\x8d\xd4(\"@o?\xe0\x1d\nv\x07\x00\xdd\xc1 w\x18\xc0Mj\x14a 6\xa9QtFj\x14\xcat\"\xf3\xf50\xfd\x15T\xf2\xf0d+\xbb\xcf\x1dn\xeb}@Z\xbc7+\x9e\xf4/\xc0\x1fE\xd2\xbf8bp\xfd\xca\x0d\xa4\x7f\x91\"\x8a\xa4\x7fA\xfa\x17\xc2~\xbb\xfa\x17Z\xfeb\x95\xf3~r\xb5\xe7\xd5\xef\xb4/\x96\xd5v\xbb/\xf3\xf6~\xb1\xab*\x85\xd1\x9b$/^\xeb\xeb.\xaa\xaa\xe8\x84.$\x10\xa9~\x01\xee\x01\x96U^6F\x85\x8b\x91\x8b'\xba\xf6\x8fT\xd7\xa2\x8f\xc6\xd0\xda\xaf\xc0\x9fX\xb1\xb2\xdaF#\x07\xd9\x96\xf7\xf5\xc8\xdb1\xfb\xf6o\xd8\xf2u\x95\x0f\x18o\xd0V_X\xa9\xb6\xdde\xe9\xf5\xc0\xc4\x17\xfe\xfcO\xcb|\x9b\x99)\xec\xb2\xb8\xb6\x0d\xe8w\xef?\xbe})>\xa1\xe5u\xea[4\x17p\xc1\x1b\xb6T\xab\xf4\x0e\xa2\x19.\xd5\x8d\x0e\xe5\xce\x85\xf9aM\xbe)\xb3v_\xb3\xa6\xeb\xa3|\xce\xdaT\x9bJ\xac\x8b\x0f?o\xc7d@\xde\x19tP\xc6}\xe4Y3\xee%\x86\xbb\x0f\x82-\x88T\xa3\x1e\x14O\xc7\x1aw\xc4\xc9%\xc4\xc9\x92F\x9c,\xd7\xb0r\x048s:\x81\xfd_5Q>s\xce_+V\xb0\x8d\x10\n:\xfb\xb5\xfb\xf7B\xc9\xf5\xfc\xed\xacf\xb7Y\xbdj\x1cZN\x83\xef\xb97\xf2\xfe\xbc*?\xf2\xa5\xd1\x07y\xefh\xb2\x93k&\xe5\x15\xb2\xe5\xb2\xde\xcba!\x13\x8b\xd9\xceUG(6\xce\x84\xe6\x07\xa9+\x1f\xed\x94\xa8j\xfd8Zp\x17\xe0\xc5\\i&Y-\xf7\xed\xe6\xbaI\xb3\xd6P\x9a\xa7\x9e\xd2|\xb5\x95\xe6\\ H\xf3\xd6V\x9a{U \x0d\xe5\n\xb3B\x90\x16\xbcNp\x06B\xac <\xab\x05iQk\x06\x87?\xb5\xf1\xe7Z9H\x0b_?\xb8w\x9a\xb4\xf5\x83\xc7\x1b=\xde\xc9\x01\xa4\xdf\x03\x95cU\xdf\xa8\x8c~\xaa\xb5\x08\xbbr\xf1\xac\xd1\xff\xe6/@\xf6 \xcf\nG\x8f\x82\xdd\x1b-\n\xb5\x101\x8c\x8e\xdd\x83\xa6N-\x94\xfd\xaf1\xa6\xd0J\xbb\xb3\xa8^\xf3\x95V\xdarN\xd6Q\x11\x9c\x9d\xfdV4\xefq\x83t,\xb7\x0f\xba\x9aX|\x98\xa7\xe9\xf8u\xb7e}A+ni\xb4\xe2~\xe0\x15\xb7\x0b~9XK\xdbZ\xe2\xc1\x85\xa3\x9e\xd8\xfd\xaa\x154\xa1\xadTr\xd7\xba:\xd8\x1b\x9b\x01\xef\x1c\xf3\xeb\xe1\xec\xd7\x83\xd5\xa6K\x1d\xb6\xef\xe6\x81_\x10\xfd\x04\xec\xf9j\xa0\x0f\x86\xc3\x9f}\x1d\x90&\xf7\xce\xfe\x9e&\xf7\xe9\"\xd3\xb7\xc0\x1ct\x1e\x837\xdf<\x9fp\x8a\xa7\xd9}l4\xbb\xd3\xec\x1e=\xbb\xf7%?\x98\x89m%?\xb8pT\xf2\xee\xd7c\x97\xfc(\xeb\x92^\x1d\xdd\xbf\x0c\xa9\xea.\xf5z\xbc\x10\xe9\x9dL\xb6\x02\\\x8b\x8f\xa1\xb7':\x1a\x8ft\xf9q$\x0dyK?\xf4O\xf2\x83\x80\x1b\x9bb3| |\xea\xd1S\x9a\xb1\xd7\xaf\xa7[)\xf8\x89n\xf8\x12gOu\xa3\xf6E\x93\x9d4\x9a\xech\xb2{\\S\x06\xff\x8eX\xd5\xd9\xad\xfe\x0bf\xe2\xf8\x93\xba\xe7\x95\xaa\xaf\x9e=\xb4\xaf.\x10!\xf3\xc7\xc4\xe9\x13\x1d\x9fG:\x89L\xe3\x16\xd4m'e\x9e\xfa\x8al^aC\xfd$\xde \xc6\xfbi\xb3\xa0A_\x1a\x0d\xfa4\xe8'\x1f\xf4\x9dc\xbe\x08@c\x1f\xc9/\xc4\xef\xdd\xb8-/\xefr\x84\x06\x1ea[\xad\xf6\x053\x8f\xdc\x83\xeb\xa4\xc3'\xbaz\x8ft\xcc\x1e\x86ehc~\x96\x0c\xc6\xf0e\xf7\xedI\xc7h\x1c\x96\xde\x9c\x9d\xc9\xdd\x95z\xc2e\x9b\xdd\xd9\xfb\x9a\xa37\\e\x0d[tBz.\xfa\x82\xcfQU\xee\x9b$\x9eF3\xdb\x82\x95\xd9U\xc1\x9c\x9e\x0eY\xad\xbd\xd9(\xbe\xe0\xfd\xca\x12\x9dF\xb6Q\xd4<\xa7f6\xd5M>\\\xbc\x9e\xf8\xa3Y\x8df\xb5\x07\x9f\xd5\xe2\x96\xff\xfd.\x82 \xad\x124\xef\xbci\xf2\xaat,\xfc\xbb\x0f\xf9\xd7\xdd\xd5\xdd\xdc\x91-\x97\xfb\xed\xbe\x10R\x12\xbd3\xd1\x912\x0f\xdb\xcd\xe0V]\xf6hg\x90\xbe\x86\x9eYd\x10\x8a\xe1L\"\xff\x9c+\x0d\xa8~\xb3\xb1fK\x96\xdf0\x03\xb3f\xe6\x8cb+,x:\x16\xf8\x08l\x9e\x0e\x06\xde\xd2I\xf3R\xd7\x10}\xc5\x87\xc2\x01\xce\x8d\x7f\xa3NZ0\"\xe7\xa8<\x96\xae\x16\x85\xccY\xbd!\xa9ja\x08\x9dM\x06V\x0cS\x86\xae\x8e\x9a\x88M\xbe\xceL\xc3Q\xff\xad\xd9\xddB\x93\xf2\xf87\x9a\x94\x8f0)\xbb>5\x7f\x1f\x90\x94g\x81Q\xed\xdb\xa6\xcdD\xde\xdb\xc2O\xba\xef\xba\xf6\xfb\xfe\xb6)YF\xa3\xfcbs\xf1 8\xee\x95\xc6\xa1\xdb':N\x8ft\xc5\xe1\xe1\xcaD-\x0c\xac>\x81V\x05S\xa3U\xc1\xc4\xc2V\x05\x80\n\xa1\xab\xdb\x0f\xc8\xeb\x83\xb1\xc4\xe0\xe4\xf9\xbe|\xa1\xf7\x1b\xcaot#7Ud\xf2q\x02\xb9X\x06\x94M~\xc3d~o\xb6\xfcr\"\xd5N\x1bhD\xf8\xa0\xc9\xca\xdcxl\xe4\xf2\x9a-\xbf\x84\xa7\xec9\xaa\xec]\x19M\xfc\x19\xd4z'\x0b%CXis^\x1a\xad\x98h\xc5\xf4\xb8VLM\x915\xd7\x0c\xb5J\xba\x94\x97vK#q+\xb0\x1b9Z\xae\xf1;0\xca\xd1\x13\x1d\x82G\xba\x18R\xa1y\x1c\x9d\xab\x7fu;V\xe7\x95'S\x10\xd5M\x1cG\x8c\xac\x85\xcc\xbcm+\xc7\xfb\x14\xff\x1c\x0c\x93\xd6\xf0\x96\xb7\xa2\xe1\xec;\x9c1\x07\x0d\xcd\"'\xa9N\xf2\xc8\x1b\xb1\xfc\xc8\x97B\xfa\xa5\xbdV\xe21M[\xd5\xe2$\x18\xcb\xdd\xe2x\x84\xbc\x11\xba\xdcZp\xbcX\x8amF\xc8v\xfc\xcd\xd4\xb9\xf8\xf7V\xcb\xa14\xadP\xcf6z\x13+1\xe3J@\xae\x05z\x8a\xb0\x16\xc1\xcfj\xd6a\x17\xa5\x12&\xccT\xad\xaf-\xb2\xf2\xd5R\xc8n\xfb\xb2\xe3T\x1b\x1e\xe7%\xa9\xbf\xe16\x05\xe7\x9c;$\xe1\xac\x81\"\xcch\x85\x91t\xfb\x91\xce\x1d\xa2s\x87\xa2\xce\x1d\xf2l!\xaa\xb9\xca\xbbJ\xf6\xef\x1f\xea\xe9\x93\xd6\xc2\xd2h-Lk\xe1\xe8\xb5p_\xf2\xa6\xcdjql\xe0\x81T\xa3k\x152\xb9kT }\x88Lw\x91R\x81\xec\xeb2\xed\xebjF\x9d\xd6/Td\xeb\xe0\x85z\x04\xe4\xa4\xc0\xd7\x11*\xae\x94\xc3\x1ei\xb5I!3,\x8c\xa4\x90y\xc4\xe0\xfa\xdb()d\xa6\x88\")d\x92B\xa6\xb0\xdf\x9aB\xe6\x94b\xcbn\xf2\x15+\x97\xac\xdb\xc0\xd3\x7f\xb0\xef\xd0\xbd*\x8a\xb7\xea\xa2\x9e)U\x14\xa0\xef4\xee\xc6\x0dnz\xa2k\xf8H7\xe2\xc6\x11\x18\xda\xdf\xe5\xd2\x1e\xb7?\x06t\x92(\x9d$j\xbd\x92N\x12\x15F'\x89\x1e\x1a\x9d$J'\x89\xda\x8cN\x12\xa5\x93D\x85\xd1I\xa2\xf66M'\x89J\xa3\x93D\xe9$Q:IT\x18\x9d$*\x8cN\x12\x15F'\x89J\xa3\x93D\xe9$Q:I\x94N\x12\x9d\x1a\xf6TG:IT\x18\x9d$\xfa[9I\xb4\xb7\xd1\x17\xa2\xc6/\x14\x1e5\x06g\x0e\xbe\xaf\x89p)\x8c\x08\x97\xbfQ\xc2\xa59Ci\x00G\xc6s-\x87@\xe8\x87\x8b\xd7\xd3J\x10\xeb\x92X\x97\xbe}I\xcc\xd6\x1e\x104K\xd0\xac\xf5J\x82f\x85\x114{h\x04\xcd\x124k3\x82f \x9a\x15F\xd0,A\xb3\x04\xcd\x124+\x8d\xa0Y\x82f \x9a%h\xd6f\x04\xcd\x124K\xd0,A\xb3\x03K\x01\x93\x114+\x8c\xa0\xd9\xdf\n4\xeb\x12?\xa0\x84\xf2\xb0l]J(?bp\xfd\xa9\xd0\x94P\x9e\"\x8a\x94PN \xe5\xc2~\xab \xe5\xcf\xbc\x19\xe5g\xbf\xea\x7f-\xae\xb3\xe6\xdau\x9a\xfcA~y\xc7i\x12\x08\x0dTe\xff\x17\xee\xcb\x98r\xfe[\xc97\x8f\xe2K\xb5Nn\x82w[\x1e\xb3\xaf\x9d\x9c\x95\x80\xe3$\xc40\x12\xdc\xcc\x83(\xde\x81x\x84\xc5\xa1\x97u\x90\x80s\x10\xc98\xb0\xe2\xb48\xbe\xc1,\xb6A\x14\xd7\x00\xb2\xc2|\xdc?`\x99\x061<\x03\x17\xfa\x87b\x19$\xe6\x18\xa0\x18\x06 \xf9\x05^vA\"n\xc1\x1cfA0\xaf \x01\xab 1\xa7\xc0\xc3(H\xce'8\x0e\x9b 9\x97\x00\xcf$\x88\xe3\x118\x82\xeec\x11$\xe3\x10\xe0\x18\x04\x86-\x0c\xfb\xf8\x9a\x98=\xe0\xe3\x0e\xccd\x0e8x\x03\xde\xe5\x89\x973\x80[\xbf\xa4\xe5\x0b\xf8\xd8\x02\xfe2\xc51\x05\xf4\xc8np\xe8\xe3 $d \xcc\xe0\x08\x98\x99=.\x86@Z~\x80\x9b\x1d\x90\x82\x1b\x80\x02\xb7=\xbc\x004+\xc0\x0e\xe0\x853\x02\xec\xbe\x8c\x9b\xe5I\xb8\x00!\xc1\xc2\xf2\x00\xfc1As\x00\"\x18\x00f`!\x11\xfa\x8f\xc2\xfe\xfd\xc8?\x06\xf7wF1\x14\xf3\xc7\"\xfe6\xbc?\x01\xda\x1f\x80\xf5\xc7#\xfd\x0e<\x1d\x8b\xf2'\xc6\xf8\x1d%2\xb6\xd4(t_o\xca\x1a\xfcY\xb0\xfd\xc4\xc8\xbe\x1d\xd7\x8fE\xf5\xc5\x8e\x80\xa9\xe0fL?-\xa2o\xfb\xf0\xf3\xa2\xf96\xb8\xd1\x86\xe4\xa7\xc5\xf1\xe3Q|\x0bb\x1f\x85\xd7{\xb1\xf90d\x1e\x8d\xcb\x07\xa2\xf2!\x98\xbc\x15\x91\xb7\x97\x06\x8b\x8c\xe2\xd0\xf8@,>\x00\x897V--\no\xeb\x143\x10x\xe3>\x85\x15\x7f\x8fC\xdf]H{z\x9c}~KBc\xecX\x84}4&!\x1e\x83Ed\x021\x99\xe4\xa8\x8c\x1f\x97\x99\x8d\xccPN\xa7\xb7dqH\x8d\xd1\x15\xe5t\xc6`6>\xd4&\x0dn\x83\x04#\xbc\xd8M\x00z\xe3\xcd\xad\x0bDp(\xa7\x93r:1\xd8\x8e7\xaa\xa1\xf8\x0e\x1e\xe1\xa1\x9c\xce\x89%\xc6{(\xa7sh\xb1\xe8\x8f\xd1\x19\xe5t\x06`As\xd0 \xa3;\xca\xe94\xde\x80\xc2\x8f(\xa73\x1d\x9aD9\x9d\xb3\xb1\xa64m\x0e\x8d7\xe1\x11'\\N\xe7(\xb3e\xe0\xc9(\xcc+.\x1a\x89\xe8\x8a?\xa8\xd1\xb0\x96\xf2\xa8lup\xa0\"@\x82\x83\xac\x8d\x1f\xe7\xde\xa4\x9eMu\xd3\xe5\xf3\x8884g\xbf\xca\xff.\xf8S\\\xb9<\x17\xe2\xb2\xd1I\x91}$u\xa57\xd5\x0dl\xab\xd5\xbe0\x9f\x1e\xf9Su#\xdd<\xd1U~\xa4\xb9<7\x958\xedZ\x86\xe6pm<*\xd3\xe8\xda\x89\xa6r\x17\x9f\x9a\x15\xe2\x83\xb8\xad\xd4\xf5\x87\xf3\x94\xb5\x98\xe0\xc5\xbbt\x11X\x9dW\xabH.\xee\xa8N?\xb3r\xd3vMY\xba\x07\xe9~Z\xf0\x15\xdbUM\xde\xe2b5\xbe\x18\x11,uC\xd2hm\xf3r\xa1\xfc\xbabe\x06,\xc1\x05Z\x82\xaf`\xd2|\xe0%\x88\xb0\x95\xd5\xd6\xf5U\xe6}\xa1\xdc\xb2m\xb5/-\xb5\x94\x86p\x83\xd9H\xe3\xf6\xba\xca{M\xf1\x0c\xda\xea\x0b+\xd5F\x98\xac\x8eN8\xe5SqV\xaa\xc2\xb9\xf6\\\xdf\xbd\xff\xf8\xf6\xa5X\xbd\xcak\xd520\x17;u\xe7e\xab&\xc8nw\xb4q\x82\x00j\xf6\x94\x1f\x0e\xf6\x876\xf9\xa6\xcc\xda}\xcd\x9anH\xe6\x9fJ\x9bjS\x89\xa9\xc9\xbc\xc2\x1c\x05\xe9\x8fy\x99o\xf7[\xddz\xc5\xf7B&^{\xd5d\x05o\xd7\xac\xe4\x9f#\xce\x8e\xc5m\x9b\xdd-\xba>\x93\xacw\xdb\x89\xf4\xd9\x9d(\xb7|\x94(\xf6+\x1e2\xbe\x02\xe1\x1d\xb3\xef\x90\xc0_cW#\xdbW\xe9y\x99\xb7yV\xa8}h\x98\xb2\x0c:\xdbVe{}\xb0\x87\xddfEq\x8f\x1bW\x86\x97\"F\x15qy\xd21\xe5\xaf\xfb\xaa\xde[\xfa\xab\xf7\xe5x\xb7\xd9\x91oO\xb5\xba\x1d\xab\x97|M\xba\x91\xdb\xc9\"m\xbbi\xb3/L Q\xdd$$\xe926lPe\xa1\x0b\xd4\xca\xf6\xda\x96U\xd9\xe4+\xc6;\x88\xd8\xd475\x83\xf6\xbaf\x0do?\x8f$6\xbc\xc5\xd6\xfa\xab\xf5?X#\"\xd1\xc8\x94\xf8A\xff\xdce\x8d\x05S\x01x\xa3\xf6AT\xab\xfe\xa7\xd3\xff\xcf\x98\x17\xc3\xdaj\xf1\xc8j/\xbf\xf1\xab5\xfc\xc2T\x1b\x10}\xfa\xa3h\"\xf2\x7f\xc5b\xcd\x01\xe7\x0f\x83do\x19\xbc\xf2lu:\x0d\xd5\xb7g\xff<\x0e\x15\x82\xf9%\x17\x8c!\xbc/\xb5R\xfdp\xf1z\xe2\x8fX_\xc4\xfaJ\xb5\xd8!\xd6\x17\xb1\xbe\xccF\xac/a\xc4\xfa:4b}\x11\xeb\xcbf\xc4\xfa\"\xd6\x970b}\x11\xeb\x8bX_\xc4\xfa\x92F\xac/b}\x11\xeb\x8bX_6#\xd6\x17\xb1\xbe\x88\xf5E\xac\xaf\x81\xa5`\xe0\x10\xebK\x18\xb1\xbe~\x0f\xac\xaf\x01\x03j\xe0\xc7\xf5%9\xb8\xa3\x83\x9b\xe5k\x1b\x00\xcem\xa5N\x08_W\xf5\x89V\xa4\x97\xe2\xf1#gO%\x0d\xe0\xe9\xc98\xbcO\x05J\xcd\x7f\xe0\x1fZO\x15\xf0\xfe4!\x8b\xccF\x173\xb2\xc5\x14\xee\xa7n02\xc4\xf4%c\x92X\xf7\xd7N\xf3y\x93\xdf\xb0\x12\x9a6k\xf7\x8d\x91'\xd6yz\xa2+\xf5Hyb\x93\xa8\x0c\xad\xfd\n\xf8\x97.\xce\"\xb7\x00\xceA\xfb?\x8e3\xe6\x05\"`'\x16y\xaa\x01\x88\xaa\x00\x02\xce\x03\\}\x00\xb9-\xa4-\x14\xdas:3\xef\xef8>wRC|\xe0\x87\xf9 \x02\xeasW@\x0bkc\xe0>H\x05\xf9A$\xec\xe7t\xc8\x83\x8b\x86\xfe`>\xfc\x07\xc1\x10\xa0\xd3U/\xbe\x8d\x87\x01!5\x14\x08\x81p \x84B\x82\xee\x96\xdd\xc1\x85XX\x10RC\x83\x80\x83\x07!%D\x08\xb3aB\x88\x83\n!\x15\\\x08Q\x90\xa1\xbb;\xe8%\x88\xaf\xdf\x1c\x05:\x84#\xc2\x87p\x1c\x08\x11\x02aD\x88\x83\x12}C0\x0eN\x84\xb4\x90\"\x04\xc0\x8a\x10\x0e-B\x04\xbc\x88\x182\xbfA@\x8c\x90\x02f\x04\x1f\xd4\x08\xf8\xe5\x19\x02r\x84\xc0U\\0\xf4\xe8\xf4&`I\x04\xfc\x08\x01\xa5L\x08CB\x10\x14 \xa9\xe1H\x88\x84$\xdd\xed\xaa\xf1\xc3\x92\x10\x0fMZ\xfd\xf1'\xfa\xe0IH\x06Q\x02\x1ei\x03\x0cT ap%\xf8\xf0\x85H\xd8\x12\x10~\x1d[\x98\x89 L\x88\n.\x1e\xca\x04D-# M\x88\x855\xc1\x1d\xd5t\xf0&\xe0!N@\xc2\x9c\x80\x86:\x01\x17\xf5p\xc8\x13\x82`OpB\x9f\x90\n\xfe\x84P\x08\x14f\xc2\xa0\x80\x08o\x00\x1c\n\xc7\x80D\x01SFGOH\x07\x8f\x02\x06\"\x85\x190\xa9\xd5!\xbf\xd0\x05\x95Bj\xb8\x14\xbc\x90)\xc4\xc2\xa6Vo\xf2\x1b\xd5\xfd\xb9\x8e\x80O\xc1\x89\xf2\x80\x13F\x85((\xd5\xea\xca \xb1B,\xccj\xf5\xe6\x90`\x97\x96\x0en\x05\x14\xe4\n\x11\xb0+\x84A\xaf\x10\x03\xbfB0\x04\x0b\x9e\xd9\xd6\x03\x8bA\x004\x86\x85c!\x06\x92\x85PX\x16\xdc\x15\x8f\x81g\xad\xce\x06\xe0'\xb6\xcb\xe0`Zg\x87(7n\xa8\x16\xd2\xc2\xb5\xe0\x83l\xc1\x0d\xdbZ\xef\x89\x85s!a\xdb\x0d\x80u!\x08\xda\x85\x03!ym\x12Z\x9c\x01\x81\xb1\xd2\x96\xcc\x0b\x02)\xbd\xf8\xf0\xfe\xe2\xfd\xe5\xab\x9f\x17\x97\x1f_}\xfct\xb9\xf8\xf4\xee\xf2\xe2\xed\xeb\xf3\x1f\xcf\xdf\xbe \xb8\xeb\xcd\xdb\x8b\xf7\x97\xe7\x1f\x17\x17o?\x9c\xbf\x0f\xb9\xf1\x97\xf7\x1f\xcf\xdf\xfd\x14~\xdf\xc5\xab\xcb\xcb\xa0\x12~x\xfb\xefo_\x7f\x0c\xba\xe5\xc7W\xe7?[o\xd0\x19\x97\x11\x01\xc4\xee\xaah\xec\xf8R\xb4\x01\xf1&\xc5\xb7\xbf\xec\x9cj/H\xfc\xc6\x04C\xd9>\xf4\xf4\xd9\xed\xf6&\xe8l\n\xcej\x8e\xd2\xd4\xf5\nR|\xfc\xfb@\xa9\xa1\xcb\xe9\x95\x0f\x85\xd5^L\x83\xb2`\x82u`\x8f\x91U\xba@\x99\xa7\xf1\x1e\x96r\xf43\xae\x90\x92?\x91\xb2\x8c\xb2\xa3\x1c\x16N\xfe\xddQ*\xde\xa0\x069\xd2|\x1e\xbav\x00C\xbb\xaciXX\xd1t\x97<,\x9c\xfe%]\xf1\xae\x18+\xa1f\x7f\x11 \xd0A\xa5\x94\xa3\xc0a\x19\xe5\xdf\xd3\x95p\x9d\xe5\x85\xadh\xeb\xbc\xcc\x8a\x85\x94\x86\x90\xe0\xd0\x91\xf9\n\xcf\xeeY\xf3l\xf6nxv\xd5\xf0\x15\xf7l?\xcf\xcaj~a\xcaj\xc1\xbf \x167\xac\xadf:\xc3\x0e\xe0\x1f\xf9\x0b\xfb \xe5'\xfav\xd2\xb4Y\xb9\xca\xea\x95\xd4\xeeP\x8a*\x9b\xea\x86\xd5evx\xc6Kon\x89\x92f\x7f\xb5\xcd\xdbE\x9boS$L\xad\xb2\x96\xbd\xe0\xbe\x8c\xd7i\x1d\x17V\xae\x1e\xe6\x81B\xf9\xc3\xadt\xe4\xa6)Is\xaa\x1d\xa1\xfa\x0e\xae\xf7 4\x8fP\xc1\x01\x94\xee\x11\xd2\x15\xb6\xd1\x06\xab\x1fy\x0b\xef\x86\x0e\xd3*#\xa1\xb5\x91b\xd5\x91\x94@Y\xd3f\xf5\x03\xf56\xf5\xc4\x07\xeal\x98f\xa2\x17\xa6\xa3\x85\xdf\xb2\xaa\x99zw[\xfeeZ\xab\x19\xd03\xb2\xd9F\xb5]\xb6Q\xcd\xec\xb0\xc2\xa32\xf6\x17N\xe4\x92\xba?\xab}<\x13yR\x9a\xb3\xe3\xbb;|\xc9\xee\xda\xc5\x17vo~+\xdew\xe2E\x8b\xdb\xbc-\xd8K\xf8o[\x7f\xd5\xcf\xd7j2\xfc\x9f\x8aj!\x16d\xfc\x7f.\xb2\x0d\xfb 5\x1cO\xe5\xef\x16g\x92\xe3\xcb\xddp\xb7<\x84\x0c\xb6U\xd3\x02\x13\x84\x05\xc1t0\xdc*F\xe7\x99\x01p04U\x08\xacC\x96\x94\x85\xe2\xf5\x17\xff(\xf7\xbc\xf1\xf1\xb6\xa73\xef\x07i\xde6\xact\x18\xa2%\x1f\x85\x16\xc2\x99m\xf8\xb8\xcd\x1ahX{\x02y\xdbh\x86P\x03\xfbR6\xc0\x95$A\xdc\xe6\xcd\xf8\x9db$\x824\x0b\x17\xa5\x12d\xf2p\xd6s\x97?\\\xbc\x9eV\x80t\x83H7\xc87K`f\x00\x88 \x17\xcb\xa6K\xbaA\x08\"q\x12\x12q\x0c\x81\x98t\x83\x12\x92\x85C\x88\xc2A$a\xd2\x0d\x9aK\x08\x8e \x03'!\x02\x87\x93\x80I7h\x0e\xe97\x84\xf0\x1bA\xf6%\xdd \xd2\x0d\"\xdd ,Y7)Q7\x86\xa4K\xbaA\xb6\xcb\xbcd\xdc\x00\".F\x15'\x84\x80K\xbaA\xa4\x1b\x84!\xd3\x92n\x90\xb09\x84Y\xd2\x0d2y\xf2\x92bc \xb1\xd6\xb9\x81t\x83\x0e\x8dt\x83\"\x88\xac~\x12k(\x815\x80\xbc\x1aL\\\x0d#\xad\x92nP\x181\x95t\x83:#\xdd e\x9dn\x90\x96[\x91\xdc\xa5\x81\xaf\xd1\xd7\xe4\x04\x86\x9c\xdc5\xc2_{\x12\x94@c5(5]'=,\xeb\xf0\xeb1\x0d\x8d\xcc\xbd\xaf\xc4(D\x96\xe5\x98\xccA#[\xf0\xe1\x19\x82.V\xe0\xc32\x01\x0f\xd9\x7fy\xf9R\x02\xf2\x83\xbf\xf5\x92X\xeb\xach<\x9aX`d\x7f\xe3\x19\xdf\xbe\xce\xe2\xb9\xd8\xce\xecF\xb1\xb9\x91\x0cn\x04k;\x88\xa9\xad\x07\xc4\x9b\xaa\x1d\xedw\x8d\x86A\xf1\xe3h\xfc\x91\x7f\xc9V\xab\x9a5\x8d\x86\xe7\x87\xa3^\xef)\xc1{\xd5\x85T\x03Me-hw\xc1d\xb0\x94\x07\x9f\xa9\xe2\xb2\x06\xd6u\xb5}\x90\x12\xf7\xac\x9c\xd3/\xec\xdeV\xec\xc94\xa3\xe8-\x99Z\xaa\xd7\xac\xdd\xd7\xa5\x00/\x14oC\xf1z:.\x8c\x80\x1c6\x93\xbdyQ\x03=*\xda\xf9-\xa7\xf0\x9e\x7fXIq;\xa8\xd6\xeb\x86\xb5P\xd50..\x0c \xd3\x86\xb5\x89\xa3e\xd9\x806\x04Q\x96\xcf\x16\xc7\xc9\xe6\xaf\xaa\x8c\x08\xa5\xc8%\xc8\x97\xfaobLR\xba~r\xf7\xfd\x9a\x95:\xf0\xfb\xb2\x03<&\xd3\xf7\xb9\xf0V\xf06\xdf\x85PB\x04\xfb\x86\x87\xfa\x0b\x0b\x8c\xe7\xd8\xfd\x91\x83;\xe1\x1c\x19\xc2[\xe4\xdb\x1c\x1b]q\xad\xa6\xeb\xd8\xa8H\x12\x0c\x1b\xb6`\xf9\xcd\xc9\x7f\x1dy\xdb\xc9\xad\xef\xe1\x9f\xce\xd7P\xb0u\xabP\x96\xbc\x95\xcbn\xbd\xf2\x118\x9e\xec \xf2!<\xceW\xf7\xc0\xb2\xe55d\xbb\xddW\x8c\xe2\x90P\xd5\xdf\xef\x8a\xe5\xe0\x0e\x1eQ\xd1B+!\x03 \xfc\x1fy\xb9\xca\x97Y\xcb:D_\x9f\xf1\xc7/T\x0di\xe8./\x97\xc5~5\xd9z\xc8\xe4S:J\xc5\xe4\x8d \x82\xce\x00\xe9\x13\xc7\xea\x0d9\x85#g\x9f\xce\xa7+\xdbI\x15\xc4nM\xcd\x1a\xc5\xa4\x12\xdd\xab\xef\x8f\xbc\xcb\x9d\xaa\xde\x94o\xca\xaa\x9e\xe0\xa4\xba7\x8e\x1f!#3\xf7\xc5^UU\xc1F,\xden\xf0\x99\xfcbx\xb55\xbba\xf5\xc8\xa9\xeb\xb5\xaa\xab\xa7\xaf4\x1fP\xf5jf\xee##?\xfc\x19\xac\x14\xdc\x92\xaa^\xb1\xfa\xa1B\x10v(\xb5\x9eJ\xcf~\xdd\xf5b\x96\xces\xa9\xf5\nQ\x8b\x8e\xeez\x9e\xad\xa0\x98\xf5\xa2_\xfa\xd2\xf37\xba\xeeF\xd5\xd1'\xba\xfe\x8f\\t\xd4\xc6\x9d\x8b\xa2\xe4\x0e\xa2},R\xaaS4\xd4Yt\xf0\x16\x1f\x10,>D\x1d\x00\x89\x04K\x8b\xe2\xf29\xfc\x05\xc9\x84&\xe5\xf3y\x19}\xa99}xV_\"^_\x1c\xb3\xcf\xe1.P\x18t&\xbb/5\xbf/\x90\xe1\x97\x98\xe3\x17\xc6\xf2\x0b\xe4\xf9\xb9\xdap\x84\x14hR\xae\x1f\x8a\xed\x97\x90\xef7\x97\xf1\x17\xc5\xf9K\xc4\xfa\x8b\xe1\xfd9\x9c\xa1\xa5?\x8f\xc0\xfd;\x1e\xfb\xef(\xfc\xbf0\x06`r\x0e \x96\x05\x98\x94\x07\x88g\x02\x06s\x01\xc3\xd9\x80\xde\xa1\x10'\xf29\x9b\x11\xe8\x15\xf8D-\xa8\x10\xbc\xc0\x90UW07\xd05 \xa2e=q\xe5K\xc8\x10\x0c\xe1\x08&f \xc6\xf1\x04]-\x08%\xe5\x19\xc9\x15\xb4xkQ2\x9ei\xf8\x82h\xd2\x1b\x823\x18\xc4\x1a\xf4\xa9\xe0\xc50\x07}>\xad\x0c\x82D\xfc\xc1\xf0`\xe29\x84\xbe\xbaE\xf0\x08#\x99\x84.&F26!\x9aO\x88c\x14b9\x85\x88(\x87\xf3\nC\x98\x85na\xce$\xec\xc2@~\xe1<\x86\xa1/\xa0\x01,\xc3#\xf0\x0c\xbd\xa5\xb3\xb6\xf4tlC\x04\xdf0\x9eqhq\xd7z\x058\x93\xb2\x0e}\xbc\xc3H\xe6\xa1\xc5\x97_x\x13\xc1>t\x8bn\xba$7Ss\x10\x93\xb3\x10\xed<\xc4\x94LD\x0c\x171\x9c\x8d\x18\xc4G\x8c`$\x86r\x12=2\x9a\xee\xd2aYbXfb\x0471\x90\x9d\xe8\xa8n\x0cC\xd1\xe2\n!\x9c\x19\xc3Rt4y\xbfhfB\xa6\xa2W0\xf3\x18l\xc5Tm1\x80\xb1\x18\xc2Y4\xcba\xba\xc40\xbd\xdf\xef.!L<)\xcau\x0fJ\x043\x84(\xe5\xba\xcb)\x80\x89$O\xb9np\x88_\x06\x11\xaa\xc67bv\x1eR\xc9^\xf6\xcaB\xb6f\xf6\xb0\xe4S\xd7s\x1f\x8a\x86\xda\x9bGJ\xf2+QS{\x0b.\xdf1\xe9\xaa\xbdyd.\x1f\x9e\xc2\xda\x1bN\xe2\xf2ai\xad\xbd\xd9\xe5-\xb1\xe2\x96\xed|\\\xdd#k\xe9\x9dC\x10\x92\x96\x08\x1fn9K\x84\x03\x9c\x94\xa5\xd7\x11n8N)b\xd9\x0f\xc9\x87\xbfy\x05,\xbd\xf5\xc1\xc9\xdba\xa4+\x93<\n!Z\xd9:\x14\xa2\xc0'X\xe9\xed\x0f\x98\x1e\x81\x90\xaa\xf4\x06\x03P2\x95\x087\xb8\x06\x19,P\x89\x90\xa1L+B\x89\x94\xa0\x8c\x11\xa0D\xcaOz\x83\x8di\xc0(\xe1\xc9\x04O\xf2\xbf\xf6t\x82\x93\xe6\x11(@\x99\x0f%\xcc7\x91\xe2\x9b\xf8\xfbp\xf1\x9a\x84\xf8H\x88/\xd9p\x18E\xde#!>\x0ce/ a/\x86\xaeGB| Iz!\x14\xbd \x82\x1e \xf1\xcd\xa5\xe5E\x90\xf2\x92P\xf2\xc2 y$\xc47\x87\x88\x17B\xc3KL\xc2\xc3Q\xf0\x12\x12\xf0\xb0\xf4;\xc3\xce: \xf1\x8d\x0dA\xb8\xc3\xae\x92\x82\xc9v$\xc4\x87\xa2\xd8\xc5\x10\xecH\x88\xcfv\x99\x97T\x17@\xa9\xc3\xc8\xcc\x85\xd0\xe9H\x88\x8f\x84\xf80\xa49\x12\xe2\x136\x87&GB|&O^b\\,-\xce:7\x90\x10\xdf\xa1\x91\x10_\x04\xfd\xcdO~\x0b\xa5\xbe\x05\x10\xdf\x82ioa\xa47\x12\xe2\x0b\xa3\xb9\x91\x10_g\xc7\xa0\xb6\xa5hs\x01\xb46<\xa9-H\x88/\x1f\x8e\xdc\xe3\x03\xcf\xfaKFx\x98\xdc\xed\x87|5\x15\xdd\x1b\x8eH\xb981m4\x0c\xf6\xea\x18m\xbd\x8f\x15~I!\x8dq\xa6\xb0\xf2\xc6\xa1\x91\xf1F]\xd2iddB\x03G\xfdQ\xe0\x7fM^n\x8a\xc3\xda\x8f\x042\xb4\x9b':\x04\x8fT C\xd7\xecq`Z^e\x8d\xa0=\x1d\xc7\x91o\x9dnY\xf4c\xdc|\x04W\xf0\xa4\xd1Q\xa1\x88-\xb5`&\x86\xb7\xf0\xbf\xa1\xa3B1AT\xc3P\x1fA\xcdU\xd1=@>\x87\xffy)\xd5\xaa\xb4\xc4\xa0\xe5\x0cGqe\x9b\xdfXV\xf76\xfe\x15\x1d\xb6)\x8c\x0e\xdb\xfc]\x1d\xb6\xa9\x17\x01!\x94\x9e\xc9\xc2A\x1bQz\xa4\x11\xa5\x87(=\xbd\x11\xa5\x87(=\xbd\x11\xa5\xa7%J\x8f\xd9\x88\xd2\xa3\x8d(=D\xe9!J\x0fr\x95D\x94\x9e\xce\x88\xd234\xa2\xf4\x10\xa5\xc7`D\xe91^C\x94\x1e\xa2\xf4X\x8c(=D\xe9!J\x0fQz\x06\x96\x82^A\x94\x1eaD\xe9!J\xcf\xe3\xa5\xf4\xd0\xa9m\xb1Gb\xd1\xa9mG\x0c\xae\xbf\x8d\xd2\xa9m)\xa2H\xa7\xb6\xd1\xa9m\xc2\xe8\xd4\xb6\x015\xf5\xec\xd7\x8e\x9b\xe8:\xcam\x10B\xcd\xf1\xd2\x84UEO\xd5\x87\xb0\xe6\xa5,5o\x9e\xf2`\x17\xfd\xdc\xf37\xfd\x1aE]\xfdj\xb5\xaa]|V\xf5\xd3c\xa7\xb3\xda\xe8\x1cQ\xa40/)\xd5\x8bIxiQ\x1e:\xaa\xe7\x01.Zf\xeb!\xa2\x92\x00\x98\xd1\x02i\xa7\x08riZj)\x92X\x1aN+\xf5\x07(1\xa5\xd4I(\x8d\x16\xd3R\x85\x8c \xdeM\xbc\x11\xefN\x1a\xf1\xee\xd2\x0c,\xc4\xbb#\xde\x9d\xd9\x88w'\x8cxw\x87F\xbc;\xe2\xdd\xd9\x8cxw\xc4\xbb\x13F\xbc;\xe2\xdd\x11\xef\x8exw\xd2\x88wG\xbc;\xe2\xdd\x11\xef\xcef\xc4\xbb#\xde\x1d\xf1\xee\x88w7\xb0\x14\x1c(\xe2\xdd #\xde\x1d\xf1\xee\xfe\x1exw\x1d\xeel+\x7fw\xc1\xe4>\x89\xee\xa6j\x99\x91%1p\xf2D\xd7\xf3\x912%D\xbd\x92\xf2$\x1cg\xdfyv\x8f\x9cg\xdey\xee\xb5\x9fu\xe7\xb9\xd1\x7f\xc6\x9d\xd3\x81\x7f\xc3(\xd5\xb9v\xd1 \xf8\xa0\x00!@\xf8G\x03DB0\xb84\x82\xc1 \x06\xef\x8d`p\x82\xc1{#\x18\xbc%\x18\xdcl\x04\x83k#\x18\x9c`p\x82\xc1\x91\xab$\x82\xc1;#\x18|h\x04\x83\x13\x0cn0\x82\xc1\x8d\xd7\x10\x0cN0\xb8\xc5\x08\x06'\x18\x9c`p\x82\xc1\x07\x96\x02\x92$\x18\\\x18\xc1\xe0\x04\x83?^\x18< \xac|S\xb5\xccu\x9c\xd4/\xfc\xf7\x0eP\x16WK0y\x93\xdf\xb0\xf2\xa0\xbe#4Y\xdc\xfbD\xd7\xf8\x91\xe2\xc8\xa2J\x8f\x03\xbf\xf2&\xea\x07\xed\xdf8\xce0\xe1u\x8e?9Jn\xc0\xdbn\xc7\xec\xc0\x80L\xc3\xae\xd92ky'\xb8\xa8\xd9\x9a/\xd4$\xec\xf0Y>\xa0\xf9\x0cy\xd9\xb4,[)pkm][A\xa7\x1a\xc2GH\xd5X\xed\xa3\x95\xf8 Z\xc9Ed\xbe\x86\xcf\x05+\x9f\xabg~\x03\xdf\x7f\x0f\xdf~V\x0b\xd4\xacU\x95\xe5\x93\x88\xd5\xdd-\x13\x9bz\xdf\x9e\xc2y Y\xe1\xd8\xf0\x94\xdb\x88\xcb\xaca\xcd\x89\xdal\x15K\x9c\x89\xe2\x8d\xf5\xfe_\xde\x7f|\xbbx\x7f\xf1\xf1\xfc\xfd\xbb\xc5\xa7w\x97\x17o_\x9f\xffx\xfe\xf6\x8d\xed\xfb\xc0\xfb&\x01X\xb9w(\x1b\xbc\xb0=\x11y\xc7\x7f\xbc\xbdD^\xf9\xea\x87\xcb\x8f\xaf\xce\xdf!\xaf~\xf7\x1e}\xe1\xe2O\xe7\x1f\xff\xb0\xf8\xe5\xedG\xdb-\x9a\x05\x10TU\xd5Z\xdc]\xe8q\x9c\x9e\xe6\xee\xad\xd2\x10\x0dE\x9a\xbb\xb9H\x0bo4\xa6\xfb\\M\xc7t\xbd\xaf\x01\x99\xeeq4#\xf3\xe5\xde\xc6$-\xaaI\xf57\xe3\xc6Oi|\x8a}/\x87(&\xb4\xcf\xb2V-M\xe4\x8e;\x1f\xe9uk\x95\\\x1d\x8fC9\xad\xf7|\x9e\xc1\x0c\xef\xb9\xd3\xfe\xe2\xad\x81\x18\xd0\x8a\xca\xeaE\xb5\x1b\x16\xd7\xb1\xe9az\xdc\x7f\xbc\xbd|9\xfd\xc3\xc0\xfd\xbdZ\xbc\xc49W\x8d\xeb\xa5\xe9\x8f#\x1d\x11\xc9\x03\x9b\xf1\xa4w\xef_N\xfe\x7f\x14\xa3Y\x9e\xfb\xd6;}F\xff\xcb\xf8i\x02\xd0\xb8a-\xfa\xb9r*L0\xd8\xe0{\xc1\x9f\xc4#\xd9j\xd0\x13\xfa:\xec\xcb\\\xf0\x16D\xf1y\xf3\xe7\xffp8kvE\xde\xc6\xe2J\xbc\x04\x83g\xcb\x90\x95#v\x9c\xaf7\xbd\x92N\x96U\xd9\xe4\x8d>\xae\xb5\xa3m\x9e\xbf9\x91]\x9b/\xdfN\xf4&\x9a\xbdN\xb6\xf75\xaa\x8c\\\xd2\xeb\xa3\xe2\xb8?\xb9~\x92c\xc7\x01\xc6H\x07!\n\xa3\x83\x10\x7fW\x07!\x8a/\xd9\x10\x0e\xaa\xfcl\xfep\xf1z\xe2\x8d8\xa8\xc4A\xf5\xcd~\x98\xb9\x06\x88\x83J\x1cT\xeb\x95\xc4A\x15F\x1c\xd4C#\x0e*qPmF\x1cT\xe2\xa0\n#\x0e*qP\x89\x83J\x1cTi\xc4A%\x0e*qP\x89\x83j3\xe2\xa0\x12\x07\x958\xa8\xc4A\x1dX\n> qP\x85\x11\x07\x958\xa8\x8f\x97\x83j<=\x8b\x8e@\x04\x7f\x18\xe9\x08\xc4#\x06\xd7\xdfF\xe9\x08\xc4\x14Q\xa4#\x10\xe9\x08Dat\x04\xa2\xce\xa58\xfbU\xd0\xb3\\g\x1f>\x13$\xafaN\xc5\xcap\xcaa\xd5gW\x9c\xbf9\x91\xa4/q\xbc\xe13\xe5\xef \xd7\xe2\x89\x8e\xc9#N\xb5\xb0\xb14\xa2X^\xde\x84 /\xd4\xe0\xe599R%<\xce]\xc4k\x0cD\x10\x9d\"\x01\xb9\x0d\xa3\xc2%H$M\x8f\xc0&G\xccK\x8d\x08J\x8c\xf06\n\x17\xcb=\x94\xdd\x8ee\xb5\x87\xb0\xd9\x91,\xf6@\xf6z\x04k\xdd\x99\x06\xd1z\x92 \x1e\xe2\xe4N\x7f\xf2\x83\xb71H\xf3'>\x846\x0c\xd3]\xbe\xa4\x87\x90Fb\xba\xc3\x93\xf0\x10\xd8`\xa4E4\x9b\xfeV\xcc((-q\xa2Ct\x9a\xc3\x83&9\x1c1\xc5\xe1\xa1\x12\x1c\x8e\x95\xde\xf0\xe0\xc9\x0d\xfe\xd4\x06\xc4P\x82m\xf1 \x93\x1a,)\x0d\xfe\x92\xccNgH\x99\xcc`z;H\xdev(m\x9bX\xdb\xc4\xda6\xfd\x9e\xa8k\x13k\x9bX\xdbf#\xd6\xb60bm\x1f\x1a\xb1\xb6\x89\xb5m3bm\x13k[\x18\xb1\xb6\x89\xb5M\xacmbmK#\xd66\xb1\xb6\x89\xb5M\xacm\x9b\x11k\x9bX\xdb\xc4\xda&\xd6\xf6\xc0R0h\x89\xb5-\x8cX\xdb\xc4\xda\xfe{`m\x0b\xf4\xcdVv\xf1\xe3\xa8\xd4\xe2\x0f\xea\xd4\xdc\x0e:\xdb=\xe0\x91\xb9\x9a\x8e\xb7\xcd\xcb\xb6\xe3\xe3ee\xb9\xcf\x8a\x85X\xa94=!\xc5D\xbd{%.\xbd\xe8\xae\xd4\xdbS\xc0\x1d\xf2QT\xfa\x82\xde\x97\x9c\xe9t\xd5F\x9c\xbb\xa9\xb3'\xba\x9e\x8f\x94\x7fg\x89\xd3\xd0\x9c\xbb<\xce\xfd\x1d\xff\xfe\xc9\xc1\xe35\"\xeb}\x07\x06g\xa3\xb7\"\xcd\x95h\xa0\xf0\xe0\xe9\x1bCa\xc3&Gg\x07\x0d\x89N\x98\x95F8\xb1k\x93\xf4\x08[\xacACe^\xae\x8b\x81z\xa3i\x88<\xd7\x97(\xa2\xb6\xb9\x8fv\x8e\x1c\xe3c\xe7I\xfd\xf8h\x07\xc6IT\x86\x96h@\xec\xc3e\x19\xf3,\xf14\xb823]\xbaX\xc7\x0fi\xfd\x8b\xffp\xf1z\xbab\xa3\xa1\x8d\x86\xb6\xc7=\xb4\x89\x85\xbac\xe9w!~\x1f\x0dj2\x87G\xa4\xad\xad\xbb\x9e\xd8/\xf8\x8d\x83\xda\x1f\xf3\xb2\x95\xae\xd4\xaf\x8fvT\x1b\x06dh\xe3\xef\x13\x19\x95\xb1D\xaf\x0e\x80\xfe6\xd9V\xab}\x91V\xa0\x97G{\xb1bee\xa1U{\x1b\x8c\x92\x9fm\x15\x0c\xb6\xacr\xf1a\xcb\xfd\x1a\xae\xef\x86\xd7E\x9d\xb5l!q\xedyO\xdefw\xf9v\xbf\xd5\xabU\xe9\x92\x7fg\xf7C9\x7f\x96\xb30\xdb\xec.M!B\x9e\x99[\x08\xf1\xe8g\xe6%\xee\x99\x9b*+\x16WU\xb9b\xb1\xe99\xea\x89\xdc\x11\x7f\xc9;V/\xf9\xa4)}B\xd6V[\xd3\xb7\xc1UQ-\xbf4\x8b\x1d\xab\x17\xf7,\x8b\xcb\xdeA\xa4\x06u\xc5\xeb\xa69\xf9`^L\xe0\x0f\x1e\xdd\x83\x98\xc3\xe5\xb0\x82\x9a\xc0\xd5\x94\xad\xc64b\xac\xd2tm\xf8\xfd\xb1M\xd7r\xaeAO\xd8\x83Ox\xd5\xceu\xcad\xd6SZ\xba\xc9J\xd2\xcb\xe5Lu\xa2\xf2;\xf2\xb6\x81f\x7f\xd5\xec2A3\xeb7\xe9\xbe\xb0{\xe3\xe4\xfew4\xb1c\xe6\xf5\xd1\xb4\xaee\xfd\xbb\x88%\x9d\xcfu\x98\xa3\x06\xdbX\xa1~G\x1b\xb6\xde\x195\x0e\xd3\x18Lc\xb0\xf9\xf6\xc76\x06\xbb\xe0\n\xddGm\x0d\xb0\x1b*\x87\xc3\x86\x1cQ\xf9\xd2\xba?\x86\xa2\x1ft\xd7\xd5\xec\x14\xfdI\x0dua\x1d\"2_\xd8\xfd\xa8\x88\xfc\xff5\x8a\xd2\x95L\xa1\xf0\xbaNIK\xe9\x9b\xe8\x9a\"k\xae\xf3r\x83\x9e\xea&\xf3\xdb\xe1W\x98\xf6\xa8^\x87\xba\x7f4w]\xaaK\xfe\x8e\xe60k?\x8e\x9b\x82\xf2M\xc9V\x0b\xb5\xfa\xbf\xcd\xcbUu\x1b89h\x1b\x0c[\xc6\xa5\xff6/\x17\xeaq\xfc+#\xc9\xb3,\xac\xd9Uu[\xb6\xf9\x96-\xfe\x92\xe5\xc5b\xa5@\xce\xa8g\x89F\xb4X\x8b$\x91\xaa\\\xac\xaa\xfdU\xc1D=\xa2\xdcy\x8b~\xf0u\xdb?\n\x83?\xe8e\x1dg\xfcJ\x0er\xba\xcb\x99^\xbfa?\xc4v\x1c\xceq\xbe\xec\xba?\xd2\xa2b\xfc\x1b-*\x8e\xb0\xa8\x08\x9e\xef\xf8\x98\x92\x97\x9bE^\xae+\xc7\xb4w)/;\xe7Wu\x93\x9f\xbaW(\xe2\x88\x8f\xba\xa2\x90I\x00Y[\xd5z^\x1b\xcf|\x037\xea\xf7G;\xef\xf1Z=\x8e\x86\xa6h\x1c\xd1-\xa5i\xb3\xba]\\;\xd3\xe2\xbdN\xfcS-8\xc6\xd6\xde\xfe ef\xb2V\x91\xa0\xba\x06#\xce\x04\x13\\3\x99\x89\xb9\xe2\x7ff\xf0\xfe\x03\xff\xc1\xean_\xf2\xd9\xd6\x92v\x95\x97+v\xb7\x90\x12_G\xae\xb8\x7fZ\x93v\xce\x8b\xa4\xaa\x9e7\x90\x97\xcbZ\xe4\xff\xf0!?[^\x03\x9fv\xc5\xe42\x8e\x8b=\xd3O\xee\xb0\xdai[y \x99\xdc\xee\x14L\xb9mv/S\xe5\xe4\xa2H\xe4\xf9\xb3e\xb5\xdd\xe6\xad\xcc\xc5le\x9a\xb1\xcb\xdf\xb2*\xff\xa22Dd>\x8c3\xf3\xf3\xf3\xa5x\xd2\x0fb\xb1\xf7'\xb1\xfe\xfa\xdcmz\xb4\xac\xdev_\x07\xe2u\x99\xb4\xc6F\xee\xfe\x987\x8dv\xf7C\xde\xbe\xe2]\xf1\xb3\x99\x1d*\x9b\xc6b_\xb6y\xfc(\xdd\xbf\x7f\xde\x1e_\xf0\x174\xb3\x0d|\xcc\xb7\xaci\xb3\xed\x0eD\xc9Tk\x18\xbf\xf4\xbcQ\xa5\x87\x95P\x13\xb4:+\xf2\x1bV\xb2\xa6\xe9\x96\x9f\xe6P\xb4\xd5\xf6\xaai\xab\xd2\xb6\xc1\xaf\x03q(\xc364\x9b*\xdd\xd8\xb0q\xf8\xd35\x139w\xb2\xdd\xe9\x0c2Q\xfd\xeb\xac\x81+\xc6\xcaA\xb9\xe1\xf9\x97\xbc\xb0\xf5tn\xd5^\x8amtN\x1a\xd6~\xa3\x15\xfd\x1a\xe6L\x82_N;\x9d\xec\x12\"s\x8c\x7fo\xdeTKE\x89\x16_\xd2\xce\x04R%\x90U\x95\xeb|\xb3\xaf\xd9\n\xb6ys\xc5\xae\xf3\xec\xc6\x969\xbb\x15MZ\x7f\x0f \xd5\xc2\x19\xa7\xbe\xa7\x1d\xb0^\x81*\x0f|a\xbb\xb6O\xa1\xdd\x97%\xe3\xb3pV\xdf\xcb\xe9\x10j\x96\xad\xa6\n\x8cC{Wi\xb5\xc8\xcf\x97\xfb\xedsS?\xfe\xe63d\xc5mv\xdf\xf0\xa0g\x85}\x14\x1a\x8d\x02\xafe\x01\x8d\x83\x00\xa6\x9a\xbf\xe8\xb7>X\x9e\x0c\xf5T\xf4\xcf\xcf&K\x1e[n\xfc\xb6*\xf3\xb6\xaa\x95\xcemn\xe1\xdaw\x1d\x97\x7ft\xdd\xe4\xed\xbda\x97W\xce\xa6\xe2a\xeaK\x04\xb5\xe6\xd2\xe6:\x02v\xc6\xe7;\x1d\xd9JG\xb6b\x8fl\x05T\x1f\x1cJH\xcbZ\x8d\xe8\xf6y \x9b\x0f\x17\xaf\xfb\xcfp\xf5\xed\xd8\xc0\xed5\xabM\x8d\xc8\xb2\"YV\xb5\xf4!t;jY\xf9\x8e\x19\xcf'\x1d\xb1\xb70\x8c\x8c1\x1c\xfa\x8e\xcbj\xdb\x97\xdb\x99\xe1U\xb3\x1d\x13\x99\xb3?du\xf7\x92<\xe9\"\xe3\xb0\x88\x96iK\x18\x19'\xab9w8\x86\xdf`\xa8}\x0e\x93\x93\xb3\xd1\x07\xa1\x95\x85\xd6\xfd\x916?\xc6\xbf\xd1\xe6\xc7\x116?\x9c $z\xef\x05K\xc069\x93\xe8}\xda\xe0\xfa\xe5\xdaI\xf4>E\x14I\xf4\x9eD\xef\x85\xfd\xe6E\xef\xdd\xfb\xfag\xbf.\xab\xb2Y\xa8}d\x97\xe0\xfd\xf0\x0bx\x88qO?;%kk)4\xbe\xa4W\xe5\xc9\xb6\xdd\xffD\x07\xe4\x91\xee\xf6\xdfd\xc5b\x18\xb3\xa4\x1f\xcc\xce\x0d|\xcfZ\xc7\xbfy\xef],\xf9\xb7\x83|\x9f\x9bI7\xed\x1d[\xf6\xfe\x0d\xfb\x04\x95\xf5\x7f\x8eB\xfa\x8dz\xf76}\xe4&\xbd]\x9e-d\x8b>\xe9\x06=~{\xde\xbf9\x8f~\xd7\xee\x8dy\xdc\xfbN\xb8)\x8f\xda\x92\xf7m\xc8\xfb\xb7\xe31\x9b\xf1\xb8\xba\xc7m\xc4C\xb5\xb7\xc9\xce\xc6l\xc3\xa7\xdc\x84\x0f\xdd\x82\x0f\xd8\x80G7\xca\xb9\x03P\xaa\x8d\xf7t\xdb\xee\xc8Mw\x7f\xf5\xd2n\xb8c\xb6\xdb\xf1\x9b\xed\xc6\x02OW\x07\xb6\xddx\xb5\xa3\xc8V\xfc\x0e\xb1<28\x1b/\x98\xa4aw\xec\x92l\xd8\xd1~\x1d\xed\xd7\x99~\x7fL\xfbu\xc3\x0f\x16[#\x1c^\xa3;\x84\xfe\xdf\x8e\x05=\xe9\xa2\x03_G\x12>\xe9\xbf\xc9Z!\xcd\xdb}\x92\xadX\xc16b\x02k\xce~U\xffS\xd5\xa2\x02\xaeO\xb2\xc1\x98\xf0F\xdf\xf4\xa6w\xd5\xa7\xda\x88=\x99\xfe\xef\"\xcbF~\xa7u\x0f\xeb<\xa90\x19SkLOQ\xd7=\xda\xcf\xb7\xbe\xe2\x0bC\x19\xb5}\x8d\x8e\xd7\x97\xcc\xddyf\x9f\xa04nQ\x0e\xbe\x18\xe0:,\xa0\xa6\xf2\xe1\xb5\x93\xe7\xeb.y\xc5\x96\xd7\xff\xfc\xdd\x0bV\xf2Ay\xd5\xf5P\xc7A \xdcZ!<\xa7\\\x9ai\x13 \x87%\xb9V\xf8J\xb5>x\xfe\xfcZw.\xed\xb5n\xae\xb3\xda\xd5\x16\xe2\xaa*\xbd\xaa\x85\xd8\xf0\x05\x08ij\xf9c\xcd\x96,\xbfa+[\xd9\xb0\xb1\xeb\xc7\x96)\xd1\x9b\x7f)\xabo\xd6\xea\x0b+\x1b\xb8f\x85\xd0\xb4\xb4\xf2\x8d\x00\xb2\xa5X+\xab\xaf\x0c\x07\xd1\xe7\xb6\x94\xfa\x98U9h]J\x93\\\xa8\xf2W\xcb\\\xc0\xb4\xddG\xb3\xcd\xd5M%5\x08\xaa[\xb9m[\x95\x0e\x0e\x9c\xe7\x95^eEV\xda2\xf2\x12\x0e\x10\xd6\x1c~i\xa86\x93my\xa4g\xba\xc1\xb6\x92\xd7U>\x95\xb3B b\xd5\xb0\xa3\xb1\xbb\xa5\xf8\x92\xbc\xb6\x1c\x17\x93\xb7\x03\xc5tsmTK\x9d\x8a\x14\xaa\xc1\xa1\xdb-\xdbV5\x83f\x9f\xb7\x1a\xc10:[\x16\x02\xb6\xeb&\xec\x98OI\xd3\xc4\xdf\xb7\x98\xa2\x98\x0cc\xcd\xb3\x9e9e\xf7v\xd8O]L\xaaQ!\x07H\xcdX\xa9c\x00\xe0\x8c\xbe\xdc\x92\xe6\xf6\x123\x8b\x98YXf\x96\x8b\xf8\xa06\x0dL_\x02\xdedk\x93\xa33\xe3\x97\x0b \xf1I\xa3\x8d\x874\xab\x05:\xb0\x8d\x0el3\x1b\x1d\xd8&\x8c\x0el;4:\xb0\x8d\x0el\xb3\x19\x1d\xd8F\x07\xb6 \xa3\x03\xdb\xecm\x9a\x0el\x93F\x07\xb6\xd1\x81mt`\x9b0:\xb0M\x18\x1d\xd8&\x8c\x0el\x93F\x07\xb6\xd1\x81mt`\x1b\x1d\xd865\xec\xe1Yt`\x9b0:\xb0\xed\xf7p`\xdb\x98M4p5\xfa\x98\x1c_5B\\\xbb\x9f\x0e)\x81\x06)\xd4\x19<@\xca1\x8eM\xe0\xa4\x1c\xe3#\x06\xd7\x9f\x1dK9\xc6)\xa2H9\xc6\x94c,\xec\xb7\x9fcl\xe6\xb3W\xf5!\x9d\xfd\xacfC\xce\x95tk\"\xb7\x7f\x18^\xd7Q\xd9Gw\xf7\xe9\xc6.\xd2\xfa\xc8\xd1\x13\x1d\x99G\xcaV\x1f\xd6\xef\xb1\xf1\xd5\x87e;:!\xf5\xf7\xcdXo\xea\xe5W\xaa\xb9\xb1\x0c\xba\xf6}\xfe\xe5\xb0-8\xfd)\xc6\x8d\xec\x91\xfd\x92\x1b\x13\x84U\xd3~\xf5 \x0c\xca0#\x08+\xd6\xb4z\x06\xc5G\x82\x95m\xed\xec%\xeea\xa07\xeb\x80\xd0\x1b\xa2\xdfJ\xc3\xf4^i\xcb\x9a\xc9a\xcc-/\xdc\x1b\xf2EJ\xf3\xe7\xd2\x0e-\xe4\xe5K\x9b\x94\x1eF_\x90\xeao]\"8\xc2\xdf\xb0\xad@[U_`WL\x8e\xb40\xd9\xb2\xe2_\xfd\xa2 v\xd9\xfd\xa1E\x05\xd1'_\xdb[D \xc75\x98\x1e\xa0~'\xe5\x12\\\xdc\xa4\xdeFA\xec\x1d\xfb\x82(\xf8@Y\xb1\xf0$S\xf4\x16\x14\xc4\xf0\x90L\xca3\n\x89\xfaM\xd3\xe9\x11\xde\xc4\"y\x14\x19!\x0cbO\xc4\xd1&\xa9\xf9|\x88\xfb\xea\x11\xe9\x8b\xd2ekn\xd5W\n\xe2\xee\xc1\xf0\xfab . 3\x0fDG\x16H\n\xc2\xd30\x8c\xee\xf0\x85\xd5q\xb8\x06}[\xb6\xf5\xfd ue\xf4\xea\x10#0H\xe2B\xcd\nv\x93\x95-lY\x9b\xad\xb26s\x95wTZ5\xaf\xc8\x8f\x0e\xf1\x119(\x80\xfa\xd1\xe6\x0c[\xed\x0f\xe3\x9e:\x00\x01\x8a\xbcie\x06\xea.\xab\xdb|)\x10\x0c\x9b\x9bn\xd1\xf4l\xb8\xf4/7\"\x15\xcc\x91\xcd\xb5\xae\xab\xed\xe8 z\x1d\xd27\x0f\xb1q\x80*B?w{\x92\xb5<\x13\xb6\x7f\xb2\xf6L\xd4\xa8I\x1a7A\x8f\xbe3x\xb9-\x89!\xdaP\x8f\x06\xf4\xe3\x81\xd6\x07\x13\xa3\xf5\x01\xad\x0f\xb4\xd1\xfa`j\xb4>8\xee\xfa\x00\xd5\xf2Q\xef\x18_\xef\x83:\xdb3U\xed\xe4xS\xe8\x06\xc9\xac\x90;2W`@*\x0dI_u8\x1c&\xb6\xaa$V\xd7\xf3\x1d\xf9\xad\xb8H\x0e+\xef\x08\xdfx9&\xe3c\xf4\xa7b\xd6\xe8\xa5\x8c\xb9\xf0]\xaa\xd2\xec\xa8\xa1\xe3e\x8d\x14\xa5\xdf\n\xa3\xf4\xdb\xdfh\xfa\xedAu\x04\xf82\xc24\xe2\xf2n\xc7\xf8\x8aU\xf7\xab\xef\x05\x94\x7f;\xfe\x8d\xf2o}M\xb57\xca\xbf\xa5\xfc[\xb3Q\xfe\xad0\xca\xbf=4\xca\xbf\xa5\xfc[\x9bQ\xfe-\xe5\xdf\n\xa3\xfc[\xca\xbf\xa5\xfc[\xca\xbf\x95F\xf9\xb7\x94\x7fK\xf9\xb7\x94\x7fk3\xca\xbf\xa5\xfc[\xca\xbf5w\x10\xca\xbf=0l.$\xe5\xdf\n\xa3\xfc[\xca\xbf}\x9c\xf9\xb7M\xbd\\\x8c\xf5\xf8m\xe5>\xbcrT\xf6\x9e>2({\xc7\xd0`\x82x8\xadAhZ\x96\xa5\x0e\xab\xa6E\xd6\xe1\xf0\xca\xa0:\x8cU\xc7\x13\xd6\x80\xb2\xa01\xd1\xa2,hiG\x0e\xae?\x7f\x97\xb2\xa0SD\x91\xb2\xa0)\x0bZ\x18eA\x0f\xb2\xa0\xf7\xe5U%\xea\xb0\x18\xb0p\x02\x8f\xfa\xfa\xa4}\xd8\xce\xfc\xea\x1erp\xfaW\xe7L\xa4O\xf7\x0d\xeb`i\xa6\x83k>\x06\xccT\x02u\xc3\xa3\xcd\xb0\xee#\xff\xc8\xd2\xab\xc7M\xc4\x91\xf4\x8a\x00\xa50\xb8\x0e\x98\x9e\xe9\xcdsvB\xc8\x9d;+\xd4\x86;\x91+a\x0d\xc3O\xe1r\xd6\xf0\xb7\x93\x01\x14\x94~\x83x!\xd2\xf0i7\xd8\x17(m\x9an\x93\x9b\x13m\xfa\xde\xed\xf1\x87\xcb\xb0 \xca\xae \x8e\x11.\xab&0N\x93l\x9a\xdc\x90H\x83\x0e\x12.\x83&({\x06\x1d\xa4\xb0j\xbb2f\xd4Yq\xea\x12\x07\x0dJ\x1a\x9ffV\xfbB\xb2l\xd4\x99v\xc0\xbf\x8fP\xc1\xf8\x9aApT~T\x95\x04o\x1d_0\xc3\x12a\x92\xe0R\x0e\xd6)\xde\xf4\x96\xb0\xd4\x96\x95+\xed\xd5\xb4:r\xa5\xbfb\xeal\xa8-4mU\xab\x05\x99H{\xe5\xdf\xc6\x05\x1b\xa6\xb6\x1a]\xf5\xc5s\xe4\xba\x8a\xb3\xce\xb5\xc7\xc1i\xf4%\x0f+\xef\xef/\xc4\x12\x99\xadD\xda-\xe5N\x98=P\xee\xc4\xef)wb\xdaG\xf1g\x98M\xbc\x19H\xba2\xb5\xc2\xf9\x04:\xdbL\x19\xe5V\xa4\xf9\xc2\xa1\xdc\n\xca\xad0\x1b\xe5V\x08\xa3\xdc\x8aC\xa3\xdc\n\xca\xad\xb0\x19\xe5VPn\x850\xca\xad\xa0\xdc\n\xca\xad\xa0\xdc\ni\x94[A\xb9\x15\x94[A\xb9\x156\xa3\xdc\n\xca\xad\xa0\xdc\n\xca\xad\x18X\n\x9e;\xe5V\x08\xa3\xdc\n\xca\xadx\x9c\xb9\x15\xc4\xea\x0f\xa3L\x13\xab\xff\x88\xc1\xf5\xf3\xd1\x89\xd5\x9f\"\x8a\xc4\xea'V\xbf0b\xf5\x0fX\xfd\x1d\x03\xcbE\xe5\xffo\x03\x95\xff\x97\xee\xc6\x11\x81\xbf\xf7\x07y\xb9\xaeD\x83\x95\x07\x9euO\xee|\xb9\x08\xfb\x97\xb2\x0e\x86\xc7\xa9\xab\x1f-[\xbf\x8f\xc0\xe3\xe0u\xe8\xd3\x9b\x1e\x90\xc1>}\xe4h\xbd7\xa6\xad\xf7\xe1\xb2\x90\n\x87\xfe\xfeEP\xe0A\x13\xe0\xf3R\xac\xeb\xcd\xdf\xafK\xfez\xcbf\xdf,v\xfb++\x15\xcf\x1b]@D\x18\x10\xec\x19\xc0E\x18\x02\xa2\x0c\x11L\x1a\xa733\x9c\xe2\xd8]L\xcd\xa8\x01?\xab\x06\"\x985\xee\nd\xed5\x9a]\x03\xa9\x186\x10\xc9\xb2q:\x14\xfa\xe6X\xa6\x0d\xccg\xdb@0\xe3\xc6\xe9J1\x01\x82X7\x90\x9ay\x03\x81\xec\x1b\x08e\xe0\xb8[v\xc7\xce\xc1\xb2p 5\x13\x07pl\x1cH\xc9\xc8\x81\xd9\xac\x1c\x88c\xe6@*v\x0eD1t\xdc\xdd!\xe3_\xc0^\x96\x0e\x1c\x87\xa9\x03Gd\xeb\xc0q\x18;\x10\xc8\xda\x818\xe6\x8eo\x08\xc6\xb1w -\x83\x07\x02X<\x10\xce\xe4\x81\x086\x0fb\xc8\xfc\x06\xc1\xe8\x81\x14\xac\x1e\xf01{\x00\xbf~\xba\\|zwy\xf1\xf6\xf5\xf9\x8f\xe7o\xdf\xa0\xef\xe0\xff\x17x\xf9\xf9\xbb\x9f\x90\xd7;\x9dk\x01\x88\xa0*Hq\x9f\x07\x80\xa0\x95\x8a\x90l\xc60\xe0\x19\x8a\xddx\xf1\xdb\xf3\xbc\\\x16\xf6\xe5A\xc3\x8a\xf5\x8b^g\xc7\xd2\x08z>\x85\x9a\x18\x07\x7f\xeeS1\x8e<\xe5\xf5\xcf\\\xd4Y\xeb\x16f\xc5\xbe\x150\xf8\x1dUT)^\x0e.r\xfa\x92\x0e$\xf1\xa0\x03\xcb\xa5\xee\xaa\xf8*FL{\xa8x\x012f\xa0\xca\xe4\xdb\xb8Gt\x08m!\xa1\x05\xf5x\xfd\xe93h6\xe2\xcf\xcb\xeb\xac\xde\x885\xa1\xd7M\xbf\x1a<\x01\x91\x01\xb6\x16$/\xb7\x92(\xc06\xbb[|\xe5\x00\xe8\"\x8c\xda\xd56\xbb\xcb\xb7\xfb\xed4\"^grt\xec{\xfe2+\x81\xdd\xb0Z\x85286\x92\x95\xf2\x18B4(\x891R\xab,\xf7\xea\xce\x8a\x94\x86\x9ae\x0d; \xf3\x0e\"-\x83\xe4u\xe5\x0f\xe2~\xc7g\x07\xaf\xac12p\xd8\x19\x07\x02\x03<(\xa5\xee\x87\x02\x88\x10\x7f0\xf5\xca[\x0f\x19O\xbe\xa9\x959.\xdb\xbc\\\xf0\x0f\xd5\x81&\xff\x8cY\x18[O\xc3S\x0f\xb6[\x9e5\xe2\x0b\x1aVlYd\xd3L\x92\x893\xd1\xe2\xd4\xd5\xda\xa1\xa9\xbe\x98\xf2u\x89\x02\x83\xcf\xa6\xaeP'\xd0V\x1b\xb9\xa1%\xc0\x86V\xa7\xdc\x18]e\xdbAj\x8ey\x03\xf2\x97Au\xf9B@\x7f}\xab\x14\xfd\xbc\x06v'_\xa0|\xd9b\xe9\x90\x97\x96\xc9\xfb\xb2\xc8\x9ak>u\xe9D\x14\x1b\x858\xe3a\x95=OaX\xa3\xc7\x9cH\xe2\xa1\xe0\xc1Uum\x9b\xd8\x96Y\xb1\xdc\x17\x1dt\xb3\xde\xf3/,\xf3\x03\xf7\xe5\xf0<\x06\x1e\xbbj\xdfB\xde\x8a\x8c\x8dr\x03\xd5\x8d\xf8N\xed\xb6\x10\xe0O\xd7\xac\x94U5W\xa0\x1eo\xc8\x98\x9f:^\x96\x9eL\x86\x98\xbc\xe1s\xfd*o59,\x1b4\x1f\xa3\xbf\xdb\xeb\xaaa}v\x95\xf9\xa1\xc3\xd7\x987#\x1a\xe6\xa0E\x88\xaa\xf5U0zZ\xe5\x1dN+7\xdb\x05\x97\xd0\xfc\xd4\xd1\xfb;\x85_*\x11\xd6]u\xcbj\x9d\x11\xa9_\x17[ \xec\xd5\xdal\xf5~\xab\xa8\x82\xf9i\xdb}\xd1\xe6\xbb\"\x97\x85\x1b?\xfb\xe0\x86Q\xaf\x1b\xe4\xf7\x8cD\xbb\x87o\xa6y&s\x7f\x84v\xb4\xf5\x80\x05\x92r\x16FR\xce\xbfQ)\xe7\x837*\xf2\xf4\x0c mN\x01g\xc3\xd6\x9eTl6%\xe2\x91N\xb34\xd2iN\xb3\xce\x0b\xcd.\x93\xad\x96t\x9a\x11\x99dm\x8a,\xb2\x98\x0c2\xd2iN\x98-\x16\x92)\x16\x94%F:\xcds3\xc2\"\xb2\xc1\x92d\x82\x85g\x81\x91N\xf3\x9c\xac\xaf\x90\x8c\xaf\x88l/\xd2i&\x9df\xcf*)8{\x8bt\x9aQ\x99Z1YZ\xa4\xd3l\xbb\xcc\x9b\x8d\x15\x90\x89\x85Q!\x0e\xc9\xc0\"\x9df\xd2i\xc6dS\x91N\xb3\xb09\x19S\xa4\xd3l\xf2\xe4\xcd\x8a\x8a\xcd\x88\xb2\xce\x0d\xa4\xd3|h\xa4\xd3\x1c\x91\xc9\xe4\xcfb\n\xcd`\n\xc8^\n\xce\\\n\xcbZ\"\x9d\xe6\xb0\xcc$\xd2i\xee\x8ct\x9a\x95\x91N3\xe94\x93Ns\xff\xb7\xe8\xe0\xfa\x15\x86I\xa79E\x14I\xa7\x99t\x9a\x85\x91Nsf\xd2i>\xfb\xb5\xfb\xb7\xfc-V\xb8\xb9\xd3m\x1e\x9e\xc2o\x96l\xee/\xe9\xfc\xed\xb2\xbc\x8b\xe4H\xb9\xf9\xf0A\xea\xaa\xc7\xaf\xd8l#xD\x11\xc7p\xba\xcb^\xa8\x02\xb3\xd7\x9fZq9\\o\x19\xa7\xb6\xec\x8c&x#\n\x08\xf6\x0b\"\xa2\x80\x8e*\xc4r`\x1c\xfe\x82\xf4\x95\x93\xf2`\xbcL\x98\xd4\\\x18<\x1b&\x11\x1f&\x8e\x11\xe3p\x17\xa8\xa8<\x93\x15\x93\x9a\x17\x13\xc8\x8cI\xcc\x8d c\xc7\x04\xf2c\\m\xb8c\xce`\x192\x8992(\x96LB\x9e\xcc\\\xa6L\x14W&\x11[&\x86/\xe3p\x86\xd6L>\x02g\xe6x\xac\x99\xa3\xf0f\xc2\x983\xc9\xb93X\xf6LR\xfe\x0c\x9eA\x13\xcc\xa1 g\xd1x\x87B\x9c:\xf2l&\x8dW\x19\x19\xb5\xa0B\xf0iBV]\xc1\x9c\x1a\xd7$\x88\xd6C\xc6\x95/!\xb3&\x84[\x93\x98]\x13\xc7\xafq\xb5 \x94\x06r$\xc7\xc6\xe2\xadE\xe9\x1f\xa7\xe1\xd9\xa0\xc9\"\x08\xaeM\x10\xdb\xc6'\x1f\x1a\xc3\xb8\xf1\xf9\xb4\"o\x89x7\xe1\xc1\xc4so|u\x8b\xe0\xdfD2p\\\x08f2\x16\x0e\x9a\x87\x83c\xe2`\xb98\x88(\x87\xf3qB\x189nE\xe3$\xac\x9c@^\xce\x85U\x03\xed\xc4@\xe7(\x81\x92\x10\xa82\x12\x02%!\xd0\xdeH\x08\x94\x84@{K\x9a\xec\x10\x92\xea\x10\x94\xe8@B\xa0s\xd3\x1b\"\x92\x1b\x92\xa46\x84'6\x90\x10\xe8\x9c\x84\x86\x90t\x86\xc4\xc9\x0c-*\x95!a\"\x036\x8d\xa1\x0dKb\x08Ma !\xd0\x91\x05'-\x90\x10(*U!&Q\x81\x84@m\x97y\x93\x13\x02R\x1302\x97!i $\x04JB\xa0\x98\xe4\x03\x12\x02\x156'\xdd\x80\x84@M\x9e\xbc \x06\xb1\xe9\x05\xd6\xb9\x81\x84@\x0f\x8d\x84@#\xd2\x08\xfcI\x04\xa1)\x04\x01 \x04\xc1\xe9\x03a\xc9\x03$\x04\x1a\x96.@B\xa0\x9d\x1d#E E\x9b\x0bH\x0f\xc0'\x07\xfcV\x85@\xc7\x8ag\xb62\x8f\xaf\x1a\x95\xb9G;\x8f\\\xe6`\xd1\xb7\xeb\xbci\xab:_f\xc5\"/\xd7\xd5\xd9\xaf\x92\xe1\xe7Ru\xfbCw\xcby\xb9\xae:\x197^\xcf\xde\xdbT\xcbM\xba\xd55\x1d)\xb6\x8d\xfd=\xd1\x95~\xa4jm\xbc\x8a\x87K\xf9QQ\xf8%\xa3\xd7?\x0d\x8b\xd2\x814E\xa67k\xd9\xc0\x0b\xce]\xb3le\xa3\x8a;\xdd\x82\xd757\xb5G\xea`\xe5\xc8\x135\xaf\xb2&_\xc2UQ-\xbf\x88z\xdb\xaf\xf7\x95 P\xe5\xe2&\x9e\x96\x88B\x858;TZ\xb6\xdb=\xec#1\x1bo\xd2^ke\xdff\xcb\xeb\xbc\xb4\x08\xb1\x08>V^.rKJ\x1b\xe0^\xa9\x8b\xdd\x0d8\x17\x18\x967\xc0\x03r\xe4\xc4\x8aY\xbc@wt\xe4\x08\xb0\xab\xd9\xcd\x03\x0f\x00\xd7Ys\x9d\xb83:E\x85\xc4j\xa7]4\xac]\xb8\x86]m\xa8\x9a\x02\xba\xb6\xdc\x1c\xc7#\x8f.sRU\xa6\x86iv\xda\xfc!\x87\x90\xb0\x03>\xf4]C\xbb\xc8\xea\xb6a\xed\x1f\xc4\x1bp5]A\xcbl\x17\xee\"\xa3\x8a\x8a*\xa2*\x1e\x7f\x1c\x13{\xf4\xb23\xf0a\xcfr\x0f\xff\xe9\x81\x8a\xd7\x8b\xfa>\xd0\x03\xa7\xf1X\xd7\xd5V\x8f\xe3P\xed\xdb\xdd\xbe\xed\xff\xd6\x8f\x1d\x16oBA\xff\xc1\xeb\xd0K\xcd>\xcc\xf3\xb2\xdd\xee\x81\x9e$\xfa\x87\xe2\x02<\xd0#\xd9M\xbeb\xe5\x92=\xd0\xe3\xba\xf6\xd7/\x7f\x1c\xd3\x12\x1f\x81\xab\x86y\x14\x94!Y\xf9F\x8b:9\x92\x8d\xbe\"\xbae\x92\xd8T\x84\x8f\xac\\\xb1z\x9b\x97\xad\x1aT\xe4\xf4cZ\xd1\xdcdE\xc3\x9ciff\xea \xb8\xe8\x83\x80\x9b\xcd0\xf3\x18N\xabZ\x1a*\xd6!+\xe4 \xf5j\xa7\x9f!=>\\\xc3Z\x1aN\xc9Z\x1a\"\xfa\x80|\x03\xa0\xdc\xb9\xb5\xad\xfb\xeb\x10o\x00\x02\xdf\x02D\x10=\xbd\x0e[#\xe2\xef\xfaR\x90\x86&~z=\xf5\xc4P\x1f\x01T[(\x11\xd4\xebp\x97\xb5\xd7hB\xa86\x13\xd6\x13L\x0c\xd5\x86'\x88z]\x0d \xa4\x01DQm3 \xa3\xda\xc2\x88\xa3^w\x8a\xd4\x16D \xd5\x16J$\xf5:\\Wu\x10\xa1T[\x10\xb1\xd4\xeb-FG[\x1a\x8ah\xea\xf52&\xa2b\x08\xa7\xda\x92\x11O{\x87s\x08\xa8\xda\"\x88\xa8\xda\x92\x10R\xb5\xe1\x89\xa9^W#\xe2\xaa\x9f\xa0\xaa\xed\x08DUm\xc7\"\xacj;\x02qU[\x08\x81U\x1b\x9a\xc8\xea\xf54$\xba\x8a\xf6\xed'\xb4j\x0b\"\xb6z\xbd\x89q\x02Kp\xd5\xd6\x86\x11]\xb5\x85\x12^\xbd\x0eC\x94\xbb\xa5\xcd&\xc0j\xf3\xa8xK\x0bX:z?\x97z\x0b]e\x06\x11e\xbd\xdeZM\xa4E\x10f\xb5\x85\x948\x90@\xeb\xf45^\xcd\"\x88\xb4\xda\x82\x08\xb5NO^]pi1\xa4[\x7f\xfbDi\x84K\x8b!\xe1\xfa\x1c\xb6(\xbdpiiH\xb9\xda\x90\xfcRm^\x92\xae\xb6\x00\xb2\xae6\x8f\x90\xaf\xb0\x18\xf2\xae6\x8c\x7f\xa7\x16h2R\xaf\xb6\xb8\xe0\xe3I\xbe\xda05\x8f \xfdj\x8b\"\xffj\xf3D<\x1d\x19X\x1b\x92\x14\xac\x0dC\x0e\x1e\\\x8b kC\xbe\x95p\xd2\xb06\xe9\x8dNE\xd0\x16\x9a\xcc\xe6\xdc\xf1\x0cIb\x0bJ^\xa3S\x11\xe6&\xa5E$\xa3%IB\xc3'\x9f\xd1\xa9\x08)\x92\xcbB\x92\xca\xd0\xc9dt*\x02\x9d\x8a\x80^%\x05%{\xc9\xaf%:\x15\x81NEH\x95\x80\x85\xcc\xfd\xf1&\\\x05$Za4\xffC\x12\xab\xe8T\x04:\x15\x01\x93\xf0D\xa7\"\x08\x9b\x93\xb8D\xa7\"\x98\x84\xbcZ\xf0 \xc6\xbe\x88\x06A4\x08\x1f\x06\x80\xeb\xabD\x83 \x1a\x84\xedJ\xa2A\x08#\x1a\xc4\xa1\x11\x0d\x82h\x106#\x1a\x04\xd1 \x84\x11\x0d\x82h\x10D\x83 \x1a\x844\xa2A\x10\x0d\x82h\x10D\x83\xb0\x19\xd1 \x88\x06A4\x08\xa2A\x0c,\x05$M4\x08aD\x83\xf8\xad\xd0 \x82\xe9\x02UU8\xc8\x02UU\x8ch\x02\xfc\xf2\x11\xf3a\xc4\x0e\xe0\x97\xab\xbf?^R@W\xe1\xa1\x8d)\x01\xbc\x92C\x88\xef\xa0\xd6\xbdYK\x00^\x1c\xa7\xac\xda\x85L\xc5^\xb8\x94*=;\x19s<\x8cj-\x11\xc8\xaa*\xd0\xf8#\x8f\xca\x87\x8b\xd7\x847\x12\xde\xe8\xddl\xc3\xecW\x01\xe1\x8d\x847Z\xaf$\xbcQ\x18\xe1\x8d\x87Fx#\xe1\x8d6#\xbc\x91\xf0Fa\x847\x12\xdeHx#\xe1\x8d\xd2\x08o$\xbc\x91\xf0F\xc2\x1bmFx#\xe1\x8d\x847\x12\xde8\xb0\x14\xd8\x0f\xe1\x8d\xc2\x08o\xfc\xbd\xe2\x8d\xd3\xccR\x13\xea\xf8K\x9f\x08\xaa\xb1\xc7\xac(\x06\xb9\x9fzg\xb1]JU\xefM~\xc3Ju,\x9f\x11\x98\xec=\xaa_\x1f-<\xe9\xca\xbcm\xbf\x02\xf4#\xc3X\xd5\x8bl\xb5\xaaYc\xb9\n\xb5\xff\x81\xd9B\x00\xc3#GP\xac\xfe\xdb\xf4\xec\x82g\xf6-,\xed\xef_\xe0\x8a-\xaf\x81\x95\xcbj%v)E\xd77OqK\xfez\xcbf\xdf,v\xfb\xab/\xccz\xa8\x98'\xba\x80\x880 \x006\xc0E\x18\x02\xa2\x0c\x11`\x9b\xd3\x99y\xc7\xc5\xf1\x01\x92\x1at\x03?\xf0\x06\x11\xe0\x9b\xbb\x02Y{\x8d\x06\xe0 \x15\x08\x07\x91@\x9c\xd3!\x0f.\x1a\x8c\x83\xf9\x80\x1c\x04\x83rNW\n,\x08\x02\xe6 58\x07\x81\x00\x1d\x84\x82t\xee\x96\xdd\x01xX\xa0\x0eR\x83u\x80\x03\xec %h\x07\xb3\x81;\x88\x03\xef \x15\x80\x07Q \x9e\xbb;\x0cN\xa8\xf0T\xe1\x08`\x1e\x1c\x11\xd0\x83\xe3\x80z\x10\x08\xecA\x1c\xb8\xe7\x1b\x82q\x00\x1f\xa4\x05\xf9 \x00\xe8\x83p\xb0\x0f\"\x00?\xc4\x90\xf9\x0d\x02\xf4\x83\x14\xc0\x1f\xf8\xc0?\xc0/\xcf\x10 \x04\xae\xe2\x82\xc1@\xa77\x01\x14\"\x00A\x08(eB`\x10\x82\xc0AH\x0d\x10B$H\xe8nW\x8d\x1f(\x84x\xb0\xd0\xea\x8f?\xd1\x07\x18B2\xd0\x10\xf0\xd8\x17`\xc0C\x08\x03\x10\xc1\xb7\xe3\x1f $\x02\xc2\xafcS1\x11\xa8\x08Q\xc1\xc5\x83\x8b\x80\xa8e\x04\xc8\x08\xb1@#\xb8\xa3\x9a\x0ep\x04<\xe8\x08H\xe0\x11\xd0\xe0#\xe0\xa2\x1e\x0eBB\x10\x10 N0\x12R\x01\x92\x10\nJ\xc2L`\x12\x10\xe1\x0d\x00(\xe1\x18 %`\xca\xe8\xe8 \xe9\x00K\xc0\x80\x960\x03\xb8\xb4:\xe4\x17\xba\xc0KH\x0d`\x82\x17\xc4\x84X \xd3\xeaM~\xa3\xba?\xd7\x11\x80&8q\x17p\x02\x9b\x10\x05nZ]9AO\x88\x05>\xad\xde\xe4:\xd0unf2\x00\x14P (D\x00\xa1\x10\x06\x86B\x0c \n\xc1\xa0(xf[\x0fP\x05\x01`\x15\x16 \x85\x18\x90\x14B\x81RpW<\x060\xb5:\x1b\xc0\x91\xd8.\x83\x03N\x9d\x1dB\x1c\xed\xee\x00O!-\x80\n>\x10\x15\xdc@\xaa\xf5\x9eX\x80\x15\x12\xb6\xdd\x00\xa0\x15\x82\xc0V\x18\x00\xaec\xfbK\x96\x17l\xe5F\xa7\xae\xaa\xaa`\xd6\xad\xe3nC\xc2y\x15\xf6K_\x96G!v+\xb8\xbdfj\xbfgxV/\xef\x07W\x8c\x95\xeaj{;\xa8\xabmwX\xad\x00w\xe5\xa6\xb8Q\xeb\x15\xd4%\xb6X`k\xa0\x1e4=\xedZ\xfd\xddz\xdbsY\xce\xb3N\xcdW\xfdK\x80 \xe6[\x10;F\xac\xdc[\xa4kA\xa0\xed?\xbc\x7f\xf7fq\xf9\xf1\xd5\xc7O\x97\x8bO\xef./\xde\xbe>\xff\xf1\xfc\xed\x1b\xf4\x1d\xfc\xff\x02/?\x7f\xf7\x13\xf2z\xa7s\x9d#\x1aT\x05W\x92+*\x9e\xd8F \x1f\xa4\x9a\xb1Z\x95\xf4gT\x8b\xdf\x9e\xe7\xe5\xb2\xb0/\x0f\x1aV\xac_\xf4R\xcd\x96F\xd0\x1d\x96\xbd\x90\x871?@\xd5\xa6\x8f\xec\xd1\xf5\xaa\xcd\x8a\xfe\x8c\xebf/\x91\x07\xfb\x845< ~p\xea\xb7\xa5\xa2}\xe9fW\xa0\xbbn\xc4\x0c\x18\xfe\xbde\xf5\xb6\x01\xf3a\xd2\xbdu\x15p\xf7\xd0\xd9\xe8\xfe\xb6*\xf3/\xcc\x90\x83\xdc\x1b\xe2\x05C@\x8c\xa0\x7f\xea\xe0d\xfc\xeb\xfd6+_\xd4,\x93z\xd5b\xdd\xe7\x8b\x11`\xe2\x04\x8a'\xd0Zy\x12p\x9c:\xea\xc7\xf6\x95\xec\xd3\x18\xfb\x1f\x9b|Sf\xed\xbef\xf0\x9c\xdd\xb9?\xa5?]Tu\xcbg\x99\xff\xc3\xee\xaf\xb2\x86Y\x07o\x80[v\xd5\xe4m\nL`Tc\xe5\xd6X#\xfd[\x91\x97_\\C\xcfr_\xe7\xed\xfdB|\xd1,\xdb\xd4%\xf4\xbc\x93\xe9\xe3\x8d5a\xdb,/\xbcP\xbav\x05\xca\x95\xbd\xce\xd6t\xf9\xdeb\xaa\xaa\xdc\xea\x89@\x82W]%\xd4\xaf\xe6R\xf5G1\xc8sDf\x0c\xed~\xe5}\xfc\x1b\x9a\x16K\xbf\x9d\x13\xc8\x07\xe7B\x9c\x88\x11U]\xe1\xa0\xdc\xc8/\x02\x01\x80N\x97w\x9b}\xe9>g\x02w\xfeEP\x80VY\xcb^p_\xc9\x82$\x8f\xce\xb0\x87h\x9b\x97\xf2x\x0dWS\x1e/$\xdbJ\x00\xe0\x05k\x99/@\xcbj\xbb\xcd\x9b\x06;i\xf6\x97\x8f&\xc6\xc1\x9f\x0fOw\x99Z\xa2)\xaf\x7f\xe6\xa2\xceZ\xd7\x95\xf8\xb7\x02\x06\xbf\xa3\x8a\n\x82JV\x0c.r\xfa\x92\x0e$\xf1\xa0\x03\xcb\x975\xcbZ\xf9U\x8c\x98\xf6P\xf1\x02d\xcc@\x95\xc9\xb7q\x8f\xe8\x10\xdaBB\x0b\xea\xf1\xfa\xd3g\xd0l\xc4\x9f\x97\xd7Y\xbd\x11kB\xaf\x9b~5x\x02\x82$\xbe\x16$\xaf\xe9\x89\x18S\xdbfw\x8b\xaf\x1c\x00]\x84Q\xbb\xd2\xc7\xd0L\"\xe2u&G\xc7\xbe\xe7/\xb3\x12\xd8\x0d\xabU(\x83c#Y)\x8f!D\x83\x92\x18#\xb5\xcar\x87\x8a\x84\xb6\xbc\xe4\xbd\xada\x07d\xdeA\xa4e\x90\xbc\xae\xfcA\xdc\xef\xf8\xec\xe0\x9ci\x00\x1f8\xec\x8c\x03\x81\x01\x1e\x94R\xf7C\x01D\x88?\x98z\xe5\xad\x87\x8c'\xdf\xd4\xca\x1c\x97m^.\xf8\x87\xea\xa2\xffP\x9d1\x0bc\xebix\xea\xc1v\xcb\xb3F|A\xc3\x8a-\x8b\xacv\xec\x11m\xf3R\xb48u\xb5vh\xaa/\xa6|]\xa2\xc0\xe0\xb3\xa9+\xd4 \xb4\xd5Fnh \xb0A\x00\x05\xfc\xab\xd9\xe8*\xdbV\xfb\x8eJl\xde\x80\xfceP]\xbe\x10\xd0_\xdf*\x8b/\xaf\x81\xdd\xc9\x17(_\xb6X:\xe4\xa5e\xf2\xbe,\xb2\xe6\x9aO]Z\xe4\xc3F!\xcexXe\xcfS\x18\xd6\xe81'\x92x(xpU]\xdb&\xb6eV,\xf7E\x07\xdd\xac\xf7\xfc\x0b\xcb\xfc\xc0}\xd9\xbf\x99F\xc4\xae\xda\xb7\x90\xb7\"C\xa3\xdc@u#\xbeS\xbb-\x04\xf8\xd35+eU\xcd\x15\xa8\xc7\x1b2\xe6\xa7\x8e\x97\xa5'\x93!&o\xf8\\\xbf\xca[M\x0e\xcb\x06\xcd\xc7\xe8\xef\xf6\xbaj\x06\x87T\x99\x1f:|\x8dy3\xa2a\x0eZ\x84\xa8Z_\x05\xa3\xa7U\xde\xe1\xb4r\xb3]p \xcdO\x1d\xbd\xbfS\xf8\xa5\x12a\xddU\xb7L\xce:W\xac{]l%\xb0Wk\xb3\xd5\xfb\xad\xa2\n\xe6\xa7m\xf7E\x9b\xef\x8a\\\x16n\xfc\xec\x83\x1bF\xbdn\x90\xc2\xd3\xb3\xc1\xd4\x99{2\xd5g\x05\xf6#\xdev\xd9F\x9d\xacu8J\x8d\x1e\xd3_8\x96\xf1\xeb\xff\xac\xda\xbd)\x91G\x9as]\xe7\xd1\xf5cw\xed\xc2\x9a3\xe2\x1dH\xbd\x0c\xc16o\x0b\xf6\x12\xfe\xdb6\xc2\xea\xe7\xebA\x95\xffS\xd1k\xb3\xa6\x91\xbbz\x17\xd9\x86}`\x7f\xdd\xb3\xa6=\x95\xbf[\x9c\xf5G_r\xb7<\x84\x0c\xb6U\xd3\x02\x13$U\xc1n5\xdc*\xda\xd7\xcc\x00\xec\xed\xdf\xbb*\x04\xd6IF\xeee\xe6zS\xb3?XN\x0f\x8d\x03\xb1\x1d\x1b?n\x18\xa2%\xef\xb8\x0b\xd9i,\x97\xdff|\xcajO o\x1b\xcd\no\xc4\xc8'\xa1\x10\xb1wp\x9b7\xe3wj\xab\x88H\xa3\xeb\xb3\xd6\xb0\x92\x8c\x07yn\xdaz\x99\xc6\xee\x07Ri\x1c\xffF*\x8d\xb8%\x12D$\x8e\xc9\xb6J*\x8d\x88$\xb16E\x82XLr\x18\xa94&L\x04\x0bI\x02\x0bJ\x00#\x95\xc6\xb9\xc9^\x11\x89^I\x92\xbc\xc2\x13\xbcH\xa5qNBWH2WD\"\x17\xa94\x92J#\xa94b\x13\xb1\x92&a\xc5$`\x91J\xa3\xed2o\xa2U@\x92\x15F\x830$\xb9\x8aT\x1aI\xa5\x11\x93(E*\x8d\xc2\xe6$C\x91J\xa3\xc9\x937\xe1)6\xd9\xc9:7\x90J\xe3\xa1\x91JcD\x92\x92?A)49) 1)8)),!\x89T\x1a\xc3\x92\x8eH\xa5\xb1\xb3\xdf\xa5Jc\xcf\xfb\xeb\x17=/\xc4\xc8\xfb\xf20\xb1e\xf4\x11\xa9\xd2aX\x99]\x15r\xe3E\"\x82\x17\xde\n\xd64}\x08\xe5n\xd3\xbe\xe1\xa1\xfe\xc2\x02\xe39v\x7f\xe4\xe0N`jCx\x8b|\x9bc\xa3+\xae\xd5\xc8\xbd\x0d\xbd\x96\xfb\xaa\xc3\x16\xac\xc8\x0c\xfbb\x82\xb7\xca]\x94\xe1\x9f\xce\xd7P\xb0u\xab6\xec\xf2V\x8e\xe0z\x9d+\xb6\x84e\x07\x91\x0f\xe1q\xbe\xba\x07\x96-\xaf!\xdb\xed\xbeb\x14\x87\x18|\x7f\xbf+\x96\x83;xDE\x0b\xad\xa0\xad\xf7\x0c\xf8?\xf2r\x95/\x05\xadJ\x81C*\x82\xe2B\xd5\x90\x86\xee\xf2rY\xecW\x93Ul&\x9f\xd2\xa1s\x937&\xb0\xde\xc1\xa61\x1f6G4\x94\x91\xb3O\xe7\xcd\xe4mM\xaa \x16\xfe5k\x14(/\xbaW\xdf\x1fy\x97;U\xbd)\xdf\x94\xd5\x947\xa7{\xe3\xf8\x1122s_\xeca\xfa\xa8-\xb1\xd4\xf0jkv\xc3\xea\x91S\xd7kUWO_i>`w\xd4\xcc\xdcGF~\xf83\x98`\xdfCU\xafX\xfdP!\xb0I&?\xf3k&\x9f\xfd\xda\xfd[\xa8\xe3\xfeM \x16;U\x94;\x11\xe5\x01\xf9\xad\\W\xa2-\xca\xc9\xba\xffA\xc9\xeb\xeaP\x98E\x94\x9f\xe8xA\xcf\x18\xa2\x8c\xcf\xa7\x150KD\x97 \x0f&\x9e2\xe3\xab[\x04m&\x928\xe3\x02\x1e\x93\x91g\xd0\xf4\x19\x1c\x81\x06K\xa1AD9\x9cF\x13B\xa4qk\x0c'!\xd3\x04\xd2i\xe6\x11j|\x01\x0d \xd5\x1c\x81V\xe3-\x9d\xb5\xa5\xa7#\xd7 \xe85\xf1\x04\x1b\x8b\xbb\xd6\xab%\x9c\x94d\xe3\xa3\xd9D\x12m,\xbe\xfc\x1a\xc2\x08\xb2\x8d[?\xd8\xa5\x1e\x9c\x9ar\x93\x9ctc\xa7\xdd\xa4$\xde`\xa87\xe1\xe4\x9b \xfaM\x04\x01'\x94\x82\xe3Q\x04v\x97\x0eK\x8a\xc0\x12q\"\xa88\x81d\x1cGuc\x089\x16W\x08\x0d\xe0\x18R\x8e\xa3\xc9\xfb\xf5\x7f\x13\x12s\xbc\xda\xbf\xc7 \xe7\xa4j\x8b\x01\x04\x9d\x10\x8a\x8eY\xd9\xd7\xa5\xeb\xdbZ\xd0\xc6\xde0\x9a\xbe\xb8o\xe3\x18=_\xa1\xdbk\xf1\x87U\xf3ui\xf9\xe2J\x1e\xa5\xe3\x1b\xac\xe2\xeb\xddKq)\xf8\x86\xea\xf7\x06\xa9\xf7\x86i\xf7\xa2\x95{#t{]\xaa\xbd\xde\xf8\xe1^\xf6\\\xbd^\x8cZ/N\xab7Q\x85R\xa9\xf4\xe25z\x87\xe5\x9aU\xf0\xee\xaaY\xea\xbc\x1e\xf1\xbdv>\xf2\xecU\xe5\xf5\xbeJ@G\x05\x12\xea\xf1ze \xfdZ\xbc\x89k\x96X\x85\x17\xad\xc1\xebU\xe0\x0d\xaf\xe7\\\xf5]\xbc\xf6nx\xd9\x9c\xef \x99\xea.Vs\xd7\xab\xb8\x1b^\xc1h\xb5]\x9c\xd6\xae\xb7@~\x9d]\xdc\xfbH\xa9\xb1;Ga\x17\xa3\xaf\x8b\x0e\x8a[\xe9040!\xba\xba\x98Y\x02\xd0\xaa\xba>M\xddQM\xe6+\xea&\x98\xa8\xf0Z\xba\xb8\xb7\x00\xe1:\xbaR+\xd7\xe1o\x96\x8a\xae7F\x80\x8a\x13\xa0\xf4s\xbd\x0d^\x1b>\x98\x80V\xce\x1d*\xe3z\x1c\xa2\xb5aq\xaa\xb9G\xaav\x88^\xae\x1c\xcb<\x0eS\xa8\xe5\x06i\xe5\x1e10(\x95\xdcN\x05\xd7\xe3\xd0\xab\x91\xeb\x0d\x0dJ\x01\x17\x15\x0e\xdc\x9c\x00AAK\xac|\xeb\xd0\xbdE\xab\xdezc\x81\xab]B\xbd[\xb4\xda\xad\xbfdqJ\xb7J\xc3\xd4\xe0\xcf\xaes\x9bR\xe5\x16\xa9q\x1b\xacp;T\xb35W\xce\xaeo\x9bV\xdd\x16\xa3m\x9bV\xd9\x16\xa1k\x1b\xa5j\xab\x15lM\xfe\xbc\x9a\xb6q\x8a\xb6j\x7f\xd1\xe0\xcf\xaeg\x8bV\xb3\xc5iu\x06KuN\xbc\x91R\xa70R\xea$\xa5\xce\xdeH\xa9\x93\x94:{K\x9a\xd6\x10\x92\xd4\x10\x94\xd2@J\x9ds\x13\x19\"\xd2\x18\x92$1\x84\xa70\x90R\xe7\x9c\xd4\x85\x90\xc4\x85\xc4i\x0b-*i!a\xca\x026a\xa1\x0dKW\x08MV \xa5\xce\x91\x05\xa7'\x90R'*)!&%\x81\x94:m\x97y\xd3\x10\x02\x92\x100:\x94! \x08\xa4\xd4IJ\x9d\x984\x03R\xea\x146'\xb1\x80\x94:M\x9e\xbc\xa9\x04\xb1\x89\x04\xd6\xb9\x81\x94:\x0f\x8d\x94:#\x12\x06\xfc\xe9\x02\xa1\xc9\x02\x01\xa9\x02\xc1\x89\x02ai\x02\xa4\xd4\x19\x96\x18@J\x9d\x9d\x1d#\x19 E\x9b\x0bH\x04\xc0\xa7\x01`\x94:\xc7\xda_\x03W\xa3\x8f\xc9\xf1U#\xe2\xc1\x81\xce\xd7H\xcfs88\xe5\xe2\x14\xc5\xd1\x88\xd8\xcb\x9f\xb5\xf5\xde\xa3\xec\x97R\xe2\xecl\x80\xaeb\xe4\xce\xde\x0c\xc0X\xad|\xa61I\xab\xf0\x99\xae\xbbY\xf0l\xe0\xf2\x89\x0e\xc6#\xd5>\xeb\x83\xb50\x94Q[\xfb\x15@/\x1f\xdb\xc2\xfb\x00@<\x04F\xdcy\xa7R\x9b4\xc4>\x13 \xb7k\xfak'\xcf\xd7l\x8f+\xb6\xbc\xfe\xe7\xef^h\xf9\xb5^\xc6\xcd\xe9\xae\xed\xb3\x19\\\x9b\xd6\xe3^\xf3\xf0\xb5>x\xfe\xfcZ#\xa8\x83\xaeT\x0ci1U\x1d\xe5\\\x0c_\x80\xd8\xde\x94?\xd6l\xc9\xf2\x1b\xdb\xc9\xda\xf8\xd8\xf5cK?a\xab\xc0U\xa5\xda`U),\xd7|\x95yu\x0f\x0e\xb9\xacl)\x14C\x95\n\xa8}\x1e\xacnK\xf9\x8dU\x95\x83\xd6\xa5\xf6\xb5\x05\xb2S-\xf3\xacc\x90\xb8\xd0\x8b\x9b!5\xa3Zs\x8f\xf6\xe7z^\xe9UVd\xe5\xd2\xb3)\x9c`\x80(+kR\x16`\xdb\x8c\xe4\xbd\xcct\x83m%\xaf\xab\xbc\x1c\x10\xb5D\x83\xe8\xc9=e\xb5\xd5\x8a\xb2\xfc\x05f\xa5*\x9c\x0b1x\xf7\xfe\xe3\xdb\x97\xe2\xdbK\x11x\xe4GL.\xf6\x99\xcf\xcbV-\xef\xba\xbd\xfd\xc6\xd9\x08\xd4\xdaO\x11W\xec\xddU\xe7\x804\xddr\x827\xc2M\xb5\xa9\xc4\xc2*v\xa7\xbc\xefDC\xfa\x0d\x7f\xc2MV\x085\xe9j\xd8\xd1\xd8\xdd\x92\xed\xa4\\\xb5\xd1]\xde\x0ev\xdd\xcd\xb5Q-u\xba\xd0U\x83\x83\x8a]\x03\xdb\xaaf\xd0\xec\xf3V\xab\xff\x1a\x9d-\x0b!y\xddM\xd8\xd30\xd0\xc1\xd7\xc2\xe8\xe0\xeb\xdf\xdc\xc1\xd7\x07\xefrL\xa6\x1b,\xbc\xbd\xbc:\x93\xa33\xe3W\x01Q\xec\x84\x11\xc5.\xcd\xdcL\x14;\xa2\xd8\x99\x8d(v\xc2\x88bwhD\xb1#\x8a\x9d\xcd\x88bG\x14;aD\xb1#\x8a\x1dQ\xec\x88b'\x8d(vD\xb1#\x8a\x1dQ\xeclF\x14;\xa2\xd8\x11\xc5\x8e(v\x03KAw\"\x8a\x9d0\xa2\xd8\x11\xc5\xee1Q\xec\xe84\xec\xd8\xa3\x86\xe94\xec#\x06\xd7\x7f\x8e3\x9d\x86\x9d\"\x8at\x1a6\x9d\x86-\x8cN\xc36S\xc5\xcf~\x1d\xf3p]Ge\x0f\xa8ah\xc6x\xcf\x9a\x84]\x96\x9b \xe4o\xa6\xb2[\x7fO\xb4q\x1b\x8f#\x8a\x1a\xe6#\x7f;]\x83\xd7=\x84\xd1\xbe\x11\xc8\x07\x0e>\xd0W\x86\x12\xbe=X\xa5\x97\xee\x1d@\xf6N\\\xd7p\x9a\xb7\xa7\xae^\x92\xb7\x8f\xe2\x1d^\xc1\xf9\xf4n\\\xbcRR\xbbq\xc4\xeepZ\xb7\xa2o[\xfcaH\xdd\xce\x17\xe8$t'\xe9\xf4N*7\xa2m\xf8h\xdc^\x17\xb8\xb6\x90\x9a\xc0\x9d\x92\xbe\x8d\"o\x87S\xb7\xfd\x81\x89\xa7mCnj1n\xd2vB\xca\xb6\x9b\xb0\xed\xae\xb8X\xe0\x98k\xee\xd2\x8b\xd188.\xfeS\x8d\x03c3.\xa9\x8e\xcd\xbe\xcc\xef\xfa3\xeeq\x81\xe9]9\xf6D\xe4\xe9\xed\x0b\x8f\x96&\xe0\x03\x13R\xd9\xc9\xd3G\x13\xb3\xe2\xba\xa9K\x1c '\xa8!~\xb5/$\x82\xa6\xd8x\x90\xb5\xa8\x10\x1c\xa9\xea\x8e:\x85\x96\x11\x1bR\xc3\xa4\xfa\xb6l\xeb\xfb\x9eJV\x0e\xa6q\xcf\x11\xfab\x13\xbff\x05\xbb\xc9\xca\x16\xb6\xac\xcdVY\x9b!\x18\x8ej\x90\x94L\xf2a/\x1e\x12'\xd5E1<0\xd3\"\xa5i+qHtQ\x88\xcfzh\xf2rS\x0c\x16w\xcfL\xfb\xfd}\xc1\xf8\x7f\x8d4I\xde\xd9:o\xfdB\x87\x7f~\x94\xa2;\xbe\x10\xf4w\xb6\x82\"o\xdac\x12\xbbL\xb7\x9f\x99VQ\x93\x0b\x89\xf0%\x8d\x08_D\xf8\xea\x8d\x08_D\xf8\xea\x8d\x08_-\x11\xbe\xccF\x84/mD\xf8\"\xc2\x17\x11\xbe\x90\xab$\"|uF\x84\xaf\xa1\x11\xe1\x8b\x08_\x06#\xc2\x97\xf1\x1a\"|\x11\xe1\xcbbD\xf8\"\xc2\x17\x11\xbe\x88\xf05\xb0\x14\xe4\x1b\"| #\xc2\x17\x11\xbe\x88\xf05\xaf\xccI _&N\x97\xeb\x80\xe3\xc1\x0e@w\xaa\x99\x01-l\x0c\xf4\xae\xc1\x03\xc4\x94\xd99:\xa0\xc6\x98\xcf?6=F\xdd\xf0\xc8\xb9]<\xbc\x8f\xf3\x1cd\x1f\x93\n\xb5\xbf\x85\xd9\"\x82\xd4<1\x0fS\x0c\xcd\x15KZ\xc3\xa4\x8c1\xaf*\x95\x935\xe6\xe7\x8dy\x98c\xde&&\xcd\xd7\xd0\xa4\x05\xf0\xc7P/D\x1a\x96C\x86\x7f\x81\xd2\xd2\xf2\xc8pL\xb2 .YD\x8c0|\xb2\xe08\xa5\xe3\x94\xe1XeA\xbc\xb2\x80 \x85U;\x19\xbbl\x1e\xbf\x0c\xc50;Z\x10\xb04\xb4\x04o\x1d_\xb0\xa4D\xb50\xaaZR\xb2\x1a\xae\xce\xc9\x08k(\xca\xda<\xd2\x1a\x1d\x1f\xad\x8c\x8e\x8f\xfe\xed\x1c\x1f\x8d`b:\xbf^\x9c\xe4\xcc\x897\x03\xdfgr\xb8\xb4\xf13\x8ch\x9a\xd2\x88\xa6\x99\xe6\x0b\x87h\x9aD\xd34\x1b\xd14\x85\x11M\xf3\xd0\x88\xa6I4M\x9b\x11M\x93h\x9a\xc2\x88\xa6I4M\xa2i\x12MS\x1a\xd14\x89\xa6I4M\xa2i\xda\x8ch\x9aD\xd3$\x9a&\xd14\x07\x96\x822G4MaD\xd3$\x9a\xe6\xe3\xa4i\xd21\xd3ag\xf8\xd21\xd3G\x0c\xae\xff\x80d:f:E\x14\xe9\x98i:fZ\xd8o\xf5\x98i\xcd\xdco\xef:\xd2~\x93o\xf7E\xd6\xaa\x0d\xed]\xd5\x1cr\xf1/\xd5%\xa0\xafm\x80\xdd\xb1\xe5\xbe\xe5\xf5\xca\xa0\xad\xb3\xb2\xc9\xc4\x9e\xa5\xfc\x86k\xda|\x9b\x89\x1f7\x19o2b\x84\x90>G\x8c{\xed\xf7\x89\xae\xfc#%\xd7o\xb2f\x91\x97\xeb\xca\xc3'\xd3\x97\xe9\xa1\x95\xff\x9b\xbf\x1cq\xce\xe9U\xb5oU8\xfa\xe1T\xc5\xd3HJ\xb4\x96\x13\xbcD\x0d^\x90\xdb\xacl\x99A\xec\x150\x18\x05\x82[\x85\xc1\x01\x00~\xca\x9a?\x89\x82\xe8\x98l\xb3\xbb|\xbb\xdf\xc2\xbe\xcc[\xb1\x81}[\xd5_\xe0V\x01\x95\x12\x1fk\xef\xecD\xb3\x1d\xaby\xe1L\xdf\xa3\xbc\xd6<\xb8\x0fT\xe7\x9f\xb2\xe6S\xd3WL\x9dK[\xad\xc5K\xce\x96\xad\xa4\x14,\xabRa\xcdcWr\x18\xf14(5W\xe4\xcdp\xe6\xd0X\xc6q\x9a\xce*k\xb3\x99\x01\xb4\xc2Z\xb8&\xf3&k3\xb1\xf2+\xefEi\xfa\xf1u]\x8bc{\xe5\x87\x94\x00\x9d\xcbUa\xc1\x8d@\x8fPU)\xa6\xab?~\xba\xfc\xe8@\x05\x0bVn\xdak\xd8\xd5l\x9d\xdf\xc9\xfe)\xc6k>\xc47\x8c\x7f\xdb\xb4L\x96F\x16b_\xb4\xf9\xae\xb0\xe1h\xba\x8c]\x11\x8c@bQm\"#\x8d\x0b\xe4\xcf\xd5f\xbc\x99ST\x9b\xd1\x98\x14\x1bO\xc3\x05\xec\x86\x95\xed#\x96\x15\x16n\xac\xbf\"B\xce-k\xdb:\xbf\xda\xb7\xee\x0c\x14_u\xa5y2b\x00Wui\x98\x00H\xb3\xd2\x8d\x87\x86\x8a\x856o\xa7\xef\xcd \x9b\xf7v\xac\xc7\xe7\xe5\x8a\xdda\x1f\x7f\xb8\xce2\x9bm\x01j2\\\xaf\xd5\xf6\x96\xf7\xa8W\xba\xc5\xc9Oa\xc5\x88\xff\xc2\xee_\xc8\xef\xa7]\x96\xd7\xaem\x1cn\xd3S\xf0\xb3R\xf6VTv\x81\xa3\x98\xa2\x80r\xdan\xf8g\x9b\xe6\x1d\xc1\x8a\xdd\xb0\x82\xb7H\xf1\x11\x99\xb5\xad\xf8\xae\xeb6\x9d\xad\x0e\x87CS\xeb\x00\xac\xf4.\xca\x0fl\x93\x97?\x14\xd5\xf2\xcbI\xf7\xb7\xb7\xe5j\xf2\x97\xd7\xd7l\xf9\xe5\xe3\x9d\xbdS\x97\xab\xee\xda7\xac\xc8oX\xfd\xf1\xce\x01<\xfe\x9c\xb5\xac>\x19\xaey\x1b\xd8f\xf7\xfcC@f\xa2\xae\xd4\x8eB{\xcd\x1a\xa6\x06Fs\xacq\x91\x16qn\x06l\nh\x8a|)\xf6(\xe4+\x90#\x84\" \xde\xb2\x9a\x01\xdb\xe6mk%C\xad\xf6\x92\xc2*\x07~[M\xfb\xf9\xc06\xf2\xbb6\xc2\xa0[\xdb\x0f\xa9\xe7\xed \x97Bn&\x9b\xb5\x81/Y}\x93/\xd9i\xe7\x83\xb8\xe5\xc2\x88[N\xdc\xf2\xde\x88[N\xdc\xf2\xde\x88[\xde\x12\xb7\xdcl\xc4-\xd7F\xdcr\xe2\x96\x13\xb7\x1c\xb9J\"nyg\xc4-\x1f\x1aq\xcb\x89[n0\xe2\x96\x1b\xaf!n9q\xcb-F\xdcr\xe2\x96\x13\xb7\x9c\xb8\xe5\x03K\xc1\xf3%n\xb90\xe2\x96\xff\x1e\xb8\xe5W\xd5j8\xf7\xe5\xe5\xc1\x9f\xac\xfco\x13\xf6\xf3\xff\xd6l\xfd\x12\x9e\xfd?g\x83\x8dCE\x9a;m\xefN\x15i\xaeG\xa6\xa4\xf2\xd33\xe5cJ\xbbS@\x96\x99x\xd7\xde\xa9kM\xf2\xb7?\xb1\xf6\xe3]#\x01\xbe5k\x97\xd7|\x90\xbfk\x04Ov\x88\xde\x8e\xf8t\x83\x9b\xd4\xcf\x0fC\xa9C\x06mP<\x8d\n>{\xd2\x97\x82\xf0\xbc\xa1\x11\x9e\x87\xdb\x0f\x02\xc2\xf3\x08\xcf\xb3^Ix\x9e0\xc2\xf3\x0e\x8d\xf0<\xc2\xf3lFx\x1e\xe1y\xc2\x08\xcf#<\x8f\xf0<\xc2\xf3\xa4\x11\x9eGx\x1e\xe1y\x84\xe7\xd9\x8c\xf0<\xc2\xf3\x08\xcf#\xa41u\xc4\xe0\xfa\xd5\x91Hc*E\x14Ic\x8a4\xa6\x84\xfd\xbdkL\xf5!\x10\x8f]\\\xd9g\xb0\xef&{\xbf/\xe0\xfd\x877o?,~\xf8\x8f\xc5\xa7w\x97\x17o_\x9f\xffx\xfe\xf6\xcdK\xe3_\xbb}fu\xa8\xa2\\K6U\xdd\xf65\x86\xf7\xfc??\xdc\xeb\xfe/\x86\x96W\x97\xafe\xb8\xf2\x06\x96\xd9\xc1\xe9}\x832\xbc\xba|\xfdr\xf4\x7f\xfd1\x8e\xe3\xd0Z=\xbcy;r\xc1\xff\xb7\xf31}?3_\xcf\xc1\xd0\xc3\xca\xfdv\xbc,1\x87\xd7v\xc9\xab\xcb\xd7\xb6\x9fx=F/Urt\\\xee\xed\x14(\x8b\xb8\xd8\x0fu\x95\xad\x96Y\xd3~\xbc\x83+\xfd\xef\xe1\x92\xceHu\x1a\xdc\xa5~~\x18\xaaS\x1b\xce%j\xef\xba3\xb9m\xcc\x9c(\xa9&\xd7 \xc7^di@=r\x1f\x9e\xf8\xf1\x9a\xc1UQ-\xbf\xa8\xe7\x19\xaem\xef\xae\xb3\xe6:\xb2 \xa3W\xc2\x1f6\\\xccs\xbf\xa6\xed\x84e\xb5b\xcd.\xb3\x9dH\xeb}\xa8\xaa\x1b\xff\xf4\x15n\xb4\x0e\x05\xbc\xaeV\xa6\x8f83\xb9\x0b\xbc\x04/@Ez\x14\x82N/\x83?\xd3\x08\xaa\xc5+t\x8d\x1e\xf4\xec\x83\\%\xf0Eus\xa2\xf7\xa5\x9f\x19n\xac\xb3\xdb\xc5\xb1\xc5\xaa\xf8\x9b\xaf\xf6\xedn\xdf-A\x06\x922\xcf\x1a(\xaa\xcd\x86\xd5\xf0\xbc\xcen\xd5\xc3\xbe9\x85?Z%\x96\xec\x98nY\x95/V\xfc\xdbs\x9b\x97y\xd3\xe6KS\x8c\x8bj\xf3\x88\xc5\xac\xb6\xcdf\xe1U3\xf27Li\xfe\xe6 .\xad2i\xdeF\x00\x1e\x8d0i\xbe\xe0J\xfb:\xd2Y\xc2\xa5\xe7\x1ad \xa4\xe1\xd4\xc4\xa4\xe1\x02#\x0d\x11\x1ei\xe8 I\xc3\x87J\x1aJkLZ@\xd4\xa4!\xa5\xc4\xa4\x05z\xc7\x8dWc\xebu\xba\x06\xe7\x7fw/\x18n\xebl\xb7c5\xffp\xa9]\x1c\xa1\xdeZu sV\xae\xd4glV;h*C\x93\x15m /\x9b\x96e+\xf1\xbd\x9d\xdd\xcaa\xde\x81]\x05\xd7\xfcR\xdeu\xa44\x0f\xee[\xb3\x82\xddde\x0b\xed\x9d<-\xd1\xbc*\xd9\xb26\xe3?\x8b}FS\xd1\xdbl\xd3\x0c\x10|\xb9\x00Qi\xaa\xf2\x18\xc3F\xf6\xc2\x15[V\xab\xe9\xe9\x9a\xae\xec\x19\x182G\xe7\x9cM5\xa4\xad\xd2\xd9T\xa4e\xe7\xdb_\xf4w3iQ`-i\xd9a \xda$\x00m\x0c\x9b\xca\nb8\xb5GD>k\x10\xf4\xe2\xf9R\x1f} \xeb\x07t\x10Zv\xebJ\xad\xdb:\x90%KY\x0e\xe5m\xa4\xbd\x80\x1f>\xfc\xff\xec\xbd\xf9w\x1c7\x92 \xfc\xbb\xff\x8aX}\xdf\x1bI\xd3T\xe9\x96-\xedj\xdfR\x97\xcd\xb6e\xb1)\xca\xb33\xfd\xf5R\xa8,TU\x9aY\x99\xa5\xe1\x86gC\xe4\xb4=,;S7\xa2\xf2\xbc\x9c\xb8\n\xca\x8b\xff\xcc\xbdb\xf2\x12I\x9b\x87\xeb\xec-\xfeb\xbe\xaf\xea\xb6\xfe\xcd\xbe\xfb\xff\\\x93l\xfd/y\xaf\x94\xf1\xed\xbe\xf2\xd5>A\xd2]\xe3.\xa3\xee\xab}\xf2\x87\xeb\xb9\xc4\xca\xe7\xbd\xbe\xe9\xa5>\x98\xb2\x1b\x9c\xae}\xf7\x8e%`\xcan\x98\xb2\x1b\xf40e7p\x98\xb2\x1b\xba0e7L\xd9\x0d&\x98\xb2\x1b\xa6\xec\x06\x0eSv\xc3\x94\xdd0e7L\xd9\x0d\x02\xa6\xec\x86)\xbba\xcan\x98\xb2\x1bL0e7L\xd9\x0dSv\xc3\x94\xddP\x831\"\xcdSv\x03\x87)\xbb\xe1\xcf\x90\xdd\xb0&Y]E5\x1f\x97`?\x96\xcf\x7f]\xf1o\x19\xe5\xf9c7\x07@c^\xb6\x0b\x9c\xc5\xd6\xf4JJq\xe3\xf5\x890~\xd1v\x8c\x1b\xb3%4\xc7sD\\\xaf\xd8\xaeR\xb2\xa0ep\x8f\xdf\x18M\x17g\xdb\x88\xc4\xf7\xff\xc9&i\x8b\xf2\x1d\x8a\xaf\x8f#\x12\xf3i\xf1\x07\x8a\xca\x9a\xf2h\x07\x12\x1d\xc8n\x80\xa1evD\x98g\x9c\x82\xda``\x0d\xeb7j\xd2\xd7\x11\x12\xcc\xfd#o\xa6\xf7g\xac\xbe\x12\xfb\xfd\xcd\x8dy\xc8\xfav\xc9D\xf57h\x80\xe4R\xdc\xd9/\x9c\xae\x97\x8c\x95\x04\xed|\xc2\xce\x7fc\xfcX\xa3y\x9f\x8ap\x8e\xe3~\x9d\x1dN\x8e_\xb7e~*\x11\x9f\x82\xa8.\x0f\"\xc6 \x07S\x10u\n\xa2\x1a\xbf\x9c\x82\xa8\x1c\xa6 j\x17\xa6 \xea\x14D5\xc1\x14D\x9d\x82\xa8\x1c\xa6 \xea\x14D\x9d\x82\xa8S\x10U\xc0\x14D\x9d\x82\xa8S\x10u\n\xa2\x9a`\n\xa2NA\xd4)\x88:\x05Qk0F@k\n\xa2r\x98\x82\xa8\x7f\x86 *\xfb\xff5\x04\x8d#$\x97D\x19\x88\xaa;\xa1U`\x91\x07\xbeTP\x95m\x11uU4r\xf8\x94\x07\xb9\xbe\x010\xc5N\xa5\x8f\x86\xc7N\xcd1\xd3\xd7\xe2\xabF\xccT\xb0\x19\xff{#T\xaa\x0d\x8f\xd6\x10|\xa3&uC\xc3\xa3\x15%\xea\xd0\x18\n_\xc0\xd0M\x82\n\x8c\xe3\x00g\x88\x8a\xf3\x9b\x96W\x9d~\x19\x8cc\x03\xe0#\xcdk\xbc*c\xa5j>2F\xc4\x7fRZ\x8b{\x9b\x8c\x0f\xa5\xd4\x1a\x1bCR\xd2=Y:1\x92e~IR\xca\xfd\xa9\xdbm$N\x87\xdcqC\"\xb8\x95\xc4\xf7$B\x93\xcc\x06\xc9fC\xe2E&\x1f\xd86u\xcb\x0d?\xb6\xf9\xc0+\xba\n\xe3W<4-\xcc\xc3\xca\xec+W24D\xa6+8\xe2^G\x12e<\xf4a\x9cm\x9e\xc0\x82\xe6\xfc]\xf55\xe5NARMY\x91\" 1\xacI\xbc\x88(\x10X\x85\x17\xd4\xe4(-\x17\x86\xc7\x05L}\xaaI\x08\x94\xa9p3\xe5\xe5R\xb2\xfdmNi\xcc\xa3\x1e\xa1\xcd%\xae\x06z\x00a\xae8\xc0\xd4\xa9\x0cB\x94q\xa3j\x96a\x06I\x91\xdfK\x96\xf7\x16$\xe7u\xe9q\x9d\xd6\x06|\xe2\xd2\xff\x14~P\x19\x05\xa6\x8eSJ\x82u\xed\xaa\xf9\xb2_>`z\xa5\xbf\x90?\x0f{K\x96\xf2w\xb2\xd9\xdccx\x06\xc8\xdf\x1bf\x1b\x04$g\n\x9e\xcfX<%*I\x93\x89@\x04_\xacE\xf9\xe5\x8c\x7fi@\xd8h\x0fQ\xb2\n\x03\x13\xe1J>H\xe9&\xb9\xa0\x0bX\xa6\xc9\x86\x93\xf0\xe3\x9b\x1f\x8d\xbe\nnL\x85\x99\xb4\xb5\xa5\xe3\x9d\xfb\xb2\x0f\xca\x90N\xa9-\xf2u\x9a\\j\xdf\xea6%\xa2\x80\xcf\n \x1f\x14\xef<'\xa0\x80\x9dxt\xd9)\x8a|\x1b\xe9\x8e\xde\xd2\x94uiV\x06\x1f\xe4\xf1r\xc1N\xf3|\x1d%a2\xaa\xe5\xbe\x01\xef\xd0\xe7a\x1eQ\x0bGq\xffZ\x156\xab\xa2\x00\xa5j\x8b\x97\x89\x8c3\x85q\x10\x15\xe6\x87W\x92\xf8^\xb0&\xe6\xa8yV\x04k\x91\x0e\xb6\nsy#\x87\x90\x7f\xee\xbd'y\x92f\x10\xf0`9)\xf2dC\xf20\xb0\x84a\xd5\x00\xf3D\xf3\x81\xdaU\xce\xc4e\x16gYNr\xab\x00O\xcf\xbd#\x13DFN\x11q&\x89\x8c\x9d&\x82O\x14\x19)U\xa4_\xb2\x88\x05\xdd\xf4\xdc\xbb\xb0\xa6\xfb\xa4\x8d\xf8%\x8ex\xa6\x8e\xd8x\xb8L*\xc1&\x8f\x8c\x9c>\x82J \x191\x85dh\x12I\xaf4\x92\x91\x12I\xfa\xa4\x92X\x90M\xcf\xbd\xa3SJ\xfc\x92JFO+\xc1&\x96\x8c\x9aZ\x82O.\xf1N/\xf1O0q\xaa\xc2\xe9\xb9w\x8ft\x13\xdb&8=\xf7\xae\x85>\xa9'6\x0e\x9a\x9e{W\xe0LC\xf1JDq\xbd\xb4\xdc'\x19\xc5\x85sz\xee\xbd\x05\xbd\x92S\xa6\xe7\xde=SU|\x92U\xa6\xe7\xde-\xdf\x8e\x9e\xba\xe2\x1c\xdd\xf4\xdc\xfb\x18\x89,\xaeT\x96\x9e\xc9,\x06\\\xd3s\xef\xd3s\xef\x12\xbc\x93\\|\xd3\\\xa6\xe7\xde\x15\xf4Iz1\xa0\x9a\x9e{\x1f?\x01f,^\xf4H\x82\xf1I\x83i?\xf7\x8e\xa8\xc8\xae\xa5y\xf4\xaf\xc8\xae'\x9bL\x15\xd9SE\xb6\xee\xf7\xa9\"\xbb\x06SE\xf6T\x91]\xc1\xa8\xa15\x9f\xc0\x9aWXm\xaa\xc8\x1e\x1aL\xeb\x11J\x1b%\x90\xe6\x1fF\x9b*\xb2\x87\x84\xcf|\x82g#\x87\xcep\x81\xb3\x11\xc3f\xd8\xa0\x99\xc6\x1e\x9e*\xb2\x9b\x80\x08\x93a\xad$\xef\x10\xd9T\x91\x8d\n\x8c\xf5 \x8bM\x15\xd9\xa6\xcf\x9c\xa10\x8f@\x18\xa6\xde\xd8'\x086UdO\x15\xd9\x98P\xd7T\x91\xcdaHpk\xaa\xc8\xd6ar\x86\xb3\xfa\x06\xb3\x8c{\xc3T\x91\xdd\x85\xa9\"\xbbG\xd0\xca\x1d\xb2\xf2\x0dXy\x84\xab\xbc\x83U~\xa1\xaa\xa9\"\xdb/85Ud\x97\xb0\x8f\x80\xd4\x18<\xe7\x11\x8c\xc2\x87\xa2\xd4F\xed[\xdd\xbcI\x16ED\xcf\xa4\xef%3\x178\xbf\xe7\x1f\xfe\"\xbfk\xd48Ga\xc6\x9d\xa6\x02\x97\xf2\xe3d\xa2R\x8e\x97 i+\x9e\x9b\x18\xe5\x177\xb6\xe8YK\xa8:\xe4\xbfA \xc8\\\xf9\x8c\xf2\x80\xc8*\xb9V\x05\xbe\x9c\xaa\xb6\x8d\x9c\xfe\x80>\x95\xd7\xa50\x97%\x96\x03\x0b\xd8Z\xc6Y\x91\xb5\xcb\xa1\xad\xa3l\xb0G\x83\xc9j\xcf\x89\x13\xc5\xad\xc2\x13\x97u\xfb\xea\xee\xb5n\x9fK\x8bI\xb8\x93\xbb-\x1e\xc2\xaf)\xab\x8di\x98V=k\x10*L\xcd\xc1 \xe2\xccM\xe1\xea\x1fjn i\xeb\x9b\xee\xa3\xd3S\xb4y\x8a6w\xc1-9\x02\xa6h\xf3\x14m\xd6\xc3\x14m\xe60E\x9b\xbb0E\x9b\xa7h\xb3 \xa6h\xf3\x14m\xe60E\x9b\xa7h\xf3\x14m\x9e\xa2\xcd\x02\xa6h\xf3\x14m\x9e\xa2\xcdS\xb4\xd9\x04S\xb4y\x8a6O\xd1\xe6)\xda\\\x831\"\x7fS\xb4\x99\xc3\x14m\xfe\xa3D\x9bm\xf7\x7f\xcbXXl\xb9\x06\xbcu\xe5h\xad\x85\x88\x9c MU\xde\x03N\xaa\xc3\xba&\xf8\xd7\x0d\x16\xd6\xe2\xcf\xf0\x13%\x17L\x11p_\x8cp*t\x8a\xf1\x974\x97W\x9b\xb2\xbd\xcf#\xac\x0d\xf2V\xf2/2\xd8\xae\xa0\xba\x96|I\xa2FtK\xe300E\xee\x8d\x8f:W\x97}\xaa\x99\x8b\xfb>\xef\xff\x93k;qe\xab\xed\x9d\xe7\x1a\xf9?I\\\xaf\x15\xaa\x8f\x0cS\xf3&\xf3\x92\xbe\xbc\x17!\xb5\\L\xb9\x17\xaeD\xc5\xf5B\x9e\x16\x19;\xb4\x9e\xd34\xa6QyevL\xaf\xf2f,7\xcc\x80\xdf\x9e:\x83#\x89\x8d\x1b!\xb5\x9b \xb3\xc1\x19\xfc\x84\xbe\x01P#6\xf7K\xa6\xa8@(8^3\xb5\xbfg\xda'(jD\xe5x\xe9\xb4g\xc0\xd4\x88M\xd8\x81\x16\xaf\xd9x\x81S@\x05O\xa1G\x00\x15\xfc\x82\xa8\xd0'\x90\n\xde\xc1Tp\xbd}\xeazq\x12\x1f\xe4\xc2\x06V\xa1Op\x15|\x03\xac`\x9fx\x9f@\xab\x11\x19\xe2%\xd4~\x01W\xab@\xb8_C\x1d5\xf0\n\xae\xe0+\xd8\x03\xb0\xc66}\x03\xb30\"\xefz\x04h\xc1+H\x0b\x9d7S\x15\xd0\xabm\x98\"\"T\xa8\x84\xe6\x05\xc9\xe9\xbd<\xdc\xe8\xa8l\x8b\xf6*\xe01FX\x85\x174\x83-M7a&J\x7f\xf3\x04\xe8\x15\x0d\n\x83\xc7\x83\xb1\x92\xb4J\xe46.ty57`\x83\xea\xaab\xb7\xfb\xa1\x11\xc3k],,b\x8deL\x951Y\x15P\xd5\xe0R\xe1\xd5\xd6O[\xb2\nc\xc3\n4\x06X}(\x9c\xe9\x94;Bj\x7fU\xe5\xbe\xba\xf8\xaa\x80\xdc\x16m\xb4\xc7\x19cz\x95\x9f\x9d\xd3\x9d\xb90\xd0\xca$N\xb7\x95\xbc{\xda\xc0\x19U\xff*\x9a\xcf\xfe)}\xbe$\xcb\x84\x93\xfb\x98\xac\xe8\x89H\x04\x98\x89\xdf\x0d\xc8Da{\xaeJ\xa3\xb7L\xe7n\x92,\x07\xca=\xa7\xdc\xe5\xaai\x9a'91\x84X\xd1\x04\xb0\\\xc0-I`\xf4\x83\xf1\xee\xf9\xfc\xf9?\xe2b3\x17.9U\xccS\xab\x1c19m\xea$\n\x92\"\xce\xcf82\x93~\xbb$\x19d4?\xe0wu\xcbPE\xc6S(\x18\x03.\x847\xf62\xcc\xbc\x8b\x94E:A\xff\xa2\xe4\xc3\xa6`N\xd5\xc7\x02\xa6\xea\xe3\xa9\xfa\xb8\x82\xa9\xfax\xaa>\xae`\xd4D\x05\x9f$\x05\xaf\x04\x85\xa9\xfaxh2B\x8fD\x84Q\x92\x10\xfc\x13\x10\xa6\xea\xe3! \x07>\xc9\x06=\x12\x0d\xa6\xea\xe3\xa9\xfax\xaa>\xc6&\n\x8c\x9a$\xd0'A`\xaa>6}\xe6L\x04\xf0H\x02\xc0\xd4\xd6\xfa\x04\xff\xa7\xea\xe3\xa9\xfa\x18\x13\xc8\x9f\xaa\x8f9\x0c \xd6O\xd5\xc7:L\xce\x80|\xdf`\xbcqo\x98\xaa\x8f\xbb0U\x1f\xf7\x08\xa2\xbb\x03\xe8\xbe\xc1s\x8f\xc0\xb9w\xd0\xdc/`>U\x1f\xfb\x05\xc5\xa7\xea\xe3\x12\xa6\xeac \xaa\xfaX\xc6]k8\x06_\x1a\xddFN\xf7\x83|\x93\xad\xcer\x19\xf4\xa8\xb5\xb1\x1d\x82?H\xef\xe9A\xa3\xf1\x01\\\xaei,\"y\x9c\xa1E\x00\x94o\xb32\x8c\xbd!y\xb0n3\xf6*\xbc\xa01\xc3\xd49\x90\x8f8\xcb*\x82=;\xa7;\xd3<[\x81a\x19 &r\x8bKy\xe53w\xfa\xc9\x10\xa7\x0c\x81\x97ac\xee\xaa[\xb5|Z|\x06\xe2~r[(x\x06\x1f\x18\xa5\x92\x98\x9f\xe5\x93\xe52\xa39;\x1e7\x87\x0b\xb5PCF\xf3\x91\xa9ep\xdch\x88(\xc6\x87\xe4\x179\x19N\xca\xb8\xd8\xd04\x0c\xd4\xdf\xb86\x0cH\xcc\xe6#\xbcV\x8c\x87$\xe1\x8b\xb8t\x14\xb6\x8e\x07G\x1c[D\xb3\xac\"\xa1p\xad\x15\x19#\xf59\xf5\xa4g\x13\xfd\x9e\x89\xdb\n\xcfk\xc8\x1b\x85\x9b\x10K]\xfe\xad\nn\x9b\xa2\xf6\xc2\x89\\\xe7`\x19\n/\xa2VpY\xb8\x8c\xea\x7f:ZBD\x97\xb9\xf4N\x86\xf2.we\xd4s\xff\xb7\x10\x10\xd1 \xa3\xf3|\x07\x94\x04k \xdb\xedoH\xc5z\xeeA\xd5\xdeF\xcbZ\x0b~E\x03\xe5\xf3\xcb\xd3\x82\x02\xfbG\x18/\xc2\xa0\xbc \xbf\xa2 \xffP2R\x1d]\x18\x07Q\xb1h\x99\xecD\xf4R\x86\"[+\xc6\x03\xdb5\x0f9\xdbZk\xf97-\xe5\xf2\xe9(k\xadVk\n\\\xfd\xa64\x93\x19\x08\\\xbc*yd\"7\x93\xd2\x14\xae\xe2\xd6\x85\x14PJc\xb3\x0bA\x99\xa1\x0b;O\x92\x886\x8a\x85K\xe5\xd3\xfaE\xb3\xb4)\xbd\xa0i\x03\xa9mY\xe5\xd7\xed%\x0dkY-)\xd5\xcbH\x03\x0f\xeb\x83\xc6<&\x9b\xa4\x8bf\x9a\xd5>I\xe0|?bI)\xdfb\xcbk\xaf[_FM\x91r&I\x8d\x9d&\x85O\x94\x1a)U\xaa_\xb2\x94\x05\x9d\xe7=/\x03\x13\xa6\xc6N\x99\xf2L\x9a\x1a9m\xca/q\xca3u\xca\xc6\xc3=nv\x195}\n\x95@5b\n\xd5\xd0$\xaa^iT#%R\xf5I\xa5\xb2 C\xdf\xe4\xb2\x87t\xaa\xfd%T\xed%\xa5\xca/\xa9j\xf4\xb4*lb\xd5\xa8\xa9U\xf8\xe4*\xef\xf4*\xff\x04+\xa7*\xc4\xdd\xd928\xc9\xcay_\x0b\xca\xa0B\xa4Z\xf9X]\xde\xe9V\xb6M\x10uK\x8b\xad\"E\x14k\x95\x97e\xaam\xf1\xc7_>\xb2\xfff\xe2\xc6\x94G\xba\x00\"Lv\xb1\x1e\xcc\x9c\xd1 \x93\x9bi\xe3\x17D\x15Iy\x84\x1dPHR\x1a\xf3S\x0d\x89\x80\xa9\x86d\xaa!\xa9`\xaa!\x99jH*\x18\xf50\xe4s\x14\xf2:\x08M5$C\x8f?=\x0e?\xa3\x1c}\xfc\x0f>S\x0d\xc9\x90\x03\x8f\xcfqg\xe4\xc3\x0e\xee\xa83\xe2A\x07{\xcc\xf1<\xe4\xf8\x1eq\xa6\x1a\x92\x06x\x1fj\xa6\x1a\x92\xa9\x86\x04\xa6\x1a\x92\n\xa6\x1a\x92\xa9\x86d\xaa!\x99jHL0\xd5\x90L5$S\x0d\xc9TCR\x831\xf2\xf9\xa7\x1a\x12\x0eS\x0d\xc9\x9f\xb3\x86\xc4v\x8a\xec\x9b\xa0W\xa6\xe25\xb0ur\xd6\x06?Fg.^q\xcf\xca+C\xaf1\xb5\x062W^\xde\xc09\x0e\xc8\xca\xcd\xfc\x92q\xb32\x1b\x97;\xd2U\xcem\xc6m\x01I#{\xfa\xed\x8d\x7fT\xaf\"\xcd\xcd\x88\xe1YslQ\xfe+\x8c\x0b\x08\x06\x08\xb2\x11\xa1;\xd7\xd6\x91m\xbb\x87\xe9yI\xb4\x11W\xaf\xac[g\xde-~.~I\xb9n4\xa6\x03\x95\x83w\x01\xc1\xbf\x80\x88C\x03n\xa5\xc1\x83B\xd0#&mE\xa6wLZ\xce\xe9c\xc7\xa6\xc1\x1d\x9f\x86\x1e1j\xfb\x04\xa6\x07\x1b\xfb\xc6\xad\xc1;vmE5=\xd8\xd8+\xadw\xe4\x986\xe0\xe2\xda0fl\x1b\x06\xc7\xb7\xa1_\x8c\x1b\xc6\x8asC\xafX\xb7]\x1c\xb0i\xbe{\x89y\xc3\x1e\xe3\xde\xb0\x9f\xd87x\xc6\xbf\xa1_\x0c\xdc\xa5\x82qqp\x187\x16\x0e\x1e\xf1p\xf0\x8f\x89C\x8f\xb88Be\xe2\x92\x7fG\x88\x8f\x83+F\x0ex\xf3\x0c\x11+\x07O+\xce;fn\xc5\x86K\x05v]O?j:\xb0>!\x18\x8c\x85x5\xed\xc9\xfe\xf3\xb6\xe9U\x06S\xc9\xe7\xf4\x06\x03\x87\xe9\x0d\x86?\xd5\x1b\x0c\x95\x07j\x84\xf4\xf9\xe9\x0d\x06\x05S\xfe\xfc8\xde)__\x85\xf2G\x18\x11b\xfd\x14\xa3\xfa(\xa6\xfc\xf9)\x7f\xbe\x82Q}\x0f>~\x07/\x9f\xc3\x94??\xd4\xbf\xd0\xc3\xb70\x8a_\xc1\xdf\xa70\xe5\xcf\x0f\xf1!\xf8\xf8\x0fz\xf8\x0e\xa6\xfc\xf9)\x7f~\xca\x9f\x9f\xf2\xe7\xf3)\x7f\xbe\x02Lv\xf8\x94?o\xfam\xca\x9f\xd7~3\xe5\xcfO\xf9\xf3\x06\x98\xf2\xe7\xa7\xfc\xf9)\x7f~\xca\x9f\xaf\xc1\x18\xb9\xccS\xfe<\x87)\x7f\xfe\xcf\x93?_\xa7\xe4\xc0\x04\xef\xe9\xf9\x80\xbew\xb3O\xcf\x07\xec\x91\xb8\xee\x8b\xef\xa7\xe7\x03\xc6\xa0\xe2\xf4|\xc0\xf4|\x00\x87?\xe6\xf3\x01\xb5x\x18\xfb\x91\x9c\x93l=\x9b\x93\x8c\xced\xb9\xd2\xec0\xcf\xd3p^\xe4\xd2\x0b\x9d\xb7\xa3\xfa\xdd8~#oH#\x80-\x9fv\xe7\x0b\x99\x19Sv\\\x19i\x19\xd7\xeaBQl \xaf^\xd3\x8c\xf8\xf5\xf1'\xf4X\x8b8\xcc\xb3\xf6XZ9\x0b\xfaL\x85\x8bvr\x90\xd1\x1b\xaf\xdd\x0f\xe5$o\x7f\x8a\xc3\\d\xb2e\x10l\x8b\x03\xd8\xd0M\x92\xee\xb8\xb1\xcb\xfe\xcc\xb7y\x9a\xa7a\x90\xdd\x96\x8d\x89\"Lg\xe0\xcd\x0c\x8dNf\x86vv\xe6L\x0cM\xfe\x97q\x8e\xda8\x85\xe1k\xaf\xf5-?\x7f}\xfcI\xd1\xa9\xcc\xd4\xe0\xab\xc7I\x15l\x0bv\x9a\\\x86\xab\x1ay\xf4\xec\xf16^l\x930\xce\xd1\xfepx\xf2\xf6\xcd\xd9\x0f\xa7\xa7\xc7\x8d\xbf\x9f\x1c\xfe\xfc\xe6\xc3\xfb\xb3\xe3\x0f'\xa7\xe5\xdfU\xee\x92\xb6\x91\xd9\xb8lt\xf2\x02\xde\x94\xb1\x08\x12\x03\x95\x93\x14\xbb\xcc\x9c\x06\xc9\x86\xfd\x00?\x16s\x9a\xc64\xa7\x19\x1c\xc5\xab\x94f\x8d\x18Bcx\xfe\x18\x7fN\x16\xf48I\xf36\x9374)Om\xa9\xe2&\xeb\xe4R\x1c\x00\x15z\xb6\x8b\xa8X\x99\xdal\xd8\x07<\xa8\x08a}\xbc\x0b\xba\x8d\x92\x9d\xdcnd_juk]\x10\xd8\x16\xf3(\x0c\xa2\x1d\xcf\xda\xc8\xb2\x90\xed\x89G\xc7\x1fn\xa4\xb2\xa30\x9b$O:*\xa7B\x17M\xda+ \xf1n\xbfc\xecD\xfbE\x8f@r\x91\xe7(\xce\xe3\\\x95\xf090b\x0b\xc5\xa2\x9bD\x1bW{J\x7f2\x01\xd46Q,^\xd1B\xf2\xb8d\xf1\x1a\x8de\xfc\xa9!\xcdZ\x11\xd4K\xeb\x89\x14\xf5O\x95\xed\x8d\x90\xd2`[\xf4R\xeb-\x0b\xdf\xd8\xda\x8c\x01t\x9b\x03\xd8\xd6\x0el\x997\x036\n0\xf0*\xf4\x13?mn\xb6-/\xdbP\x11b\xa5\x831\x83\xc9\xd2\xaa??\xf7;%\x00\x0f\x07U\xa6\x06\xf8\xb1X\xd7\xec0\"0#\x81\x89\xcb$\xdc|.\xebk\xba\x00\x0f\x0dr\xa2\xefw\xa3\xe1\xbe.\xedjh(\xa1g\xdf\xde\xcb\xa7eb\xc7\xf2Y\x13\x15\x07\xb2\xb2\x99\x99\xcd\xecl,k\xb1\xd0\xc4U\xd2\xd2\xb7\x9c\xce\x92\x02jm\xd9\x83\xbd+\xc3W\x92\xd3\xca\xe1\x8a\xe6\x1d\x16W\xa7\xbf}[S\x0d\xbfL\x1d\x85\x96\"m\x1f\x8d\x00\x93\xa7F\xfd\xaa\xf3\xd7\x08\xb0zm\xd4'\xf6\x04\xd6a\xc7\xfb\x0e:\x8dGG\xf53\xde\xc1\xbf\x02s\x05\xe3P\xaf@\x07a\xc3\xd3#`\x90\xbf\xa7;\xf8\x86QZG\x16E\xb5@\x8a\x12\x04Q]\"\xae\xde\x12ccS\xb9\x1f'\x0b\xa5\xbch\x1e\xa8\x80G\xb8\x94\xc9/a\xc6\x13\xc4Ji\x92\x99\xf1R*U@M<\x85\xbf 9\xb9\x97\xe5i\x11\xb0\xd3\xa4\xdd\x90\xfe\xa5\xd2\x10\x08C\xba\xa1\x9f\xb5\xf2\xd2\xd1\xc5=5\xb0f\xc8\xeaD\x8d\x1em\xfb4\xec\xa1HZ\xb3\x1a\xe7\xf4\xdb>\xf9\x0e\x1eOC|\xc6:\xe5\xb6\x86\xdd\xee\xaa\xf4k\xd4\xb6\x04\x9e\xd4/\xe2\x83$\xe0\x01\xc0\x86\xa7\xa3<\x05\xd6=\x1ce\xc9\x98:\x11\xd6;\x96?\x1dF\xd1\x87%\xcf\xdb\xd9\xa64\xa0\x0b\xca\x9fM\x9e\xd1\x19\x93\x8b|MS\xf1\x88r9\xe3\x98\xe9\x89<\xdd\xc1a\xbc\xfb\xb0\xec\x06\x15S\xba\"\xe9\x82\x87\xed\xf3\x84\xab\x96\x0d\x89\xcb\xe0\"k*\xab4\xd32f\xca\xd7wN\xd7\xe4\"L\x8aT\xc6\xe8\x16a\x16\x14Yf\xf2<~\xac\x9bi\x08>mZ\\\x9a\x05\x9f|\x93\x1cn\xb8kd\xb0\xfd#X\xa9\xda\x13J\x86zS\xfe \xcdS\x15\x96\xb3\xb0\x13\x81B\xf1Mr\x19\xb7\xaf/4\xd0i\x91\xd1/\xa8\x0f\x8d\xc9\x13\x92t\xd5<\x8f\xde(\xfa\xf1a\x08\x9a\xd1/\x05\xd7\x00\"YA6\xcer\x92\xdb\xa5G\x17b\x0bc\xae\xb3\x1a\x7f#A\x1e6j\x8e\xeeA\x10%\xf5\xba\xc3\xd2lk77\x1bkeW/\xe08\xa5\xcb\xf0J%Pe9I\xe5\xfd\"\x0f\xd8F\xc2\xc68\x83\x8f ,h\x10\x116|X\x14\x9bM\xfdl\xc1\xa7Z'\xa7\x1as\x9dr\x87\xfc/\xb0\xa0q\xc2\xec/\xde\xa6ektgZN\xb5\x8e\xe95\xff\x8b\x1dS\x8b@\xa5\x08\xb0OCi#\x16\x1b\x99\xca\x98\xd2%M\xb9\xea\x15\xb8\x92e\x0d\x95\xc4!\x8b\x1c}\xad\x0c\x80 \xa5$\xa7\x8b3\x92#\xdbV\x1c\xa8T\\5u\xc5|\x8b\x1aC\x1e\xc8Q3V\x94\xa3T\xb7\x1e\xdc\xc6 \xef\xecc\xc5\xab\x9d\xa15\xe3\x81M\x06k\xf1f\x83/\xb5\x90\xd7r\x88\x9b:\xd8\\9?\xc8\x1bU\xf8\xe7\x95\xfd%\x11\xf1\xf8\xc8\xc7-\x0d\x14\"\x19k\x93\xb7\x05\x8b\xcb\xb6e\xa3\x11\x92%\xbe\x17\xd8\xeb]\x85\x8bz\x8eD\xb3\xe32\xbab\xcd\x95\xe0H\x07\xa4I\xd4B\\\xadP\x9f%\xccwc\xd2)\xfa\x04\xf2\x86\x05\xf1\xf6\x1c\xc0\xeb\x1d\xbc\xeb\x1d\xb8\xb3s\xd6\x0dHZhG\xe3\xf5\xbb\x84C\xec\x86E\xdd\xe5/nA\xfcX\xc6>\x11\x04s&\xb1\xea\xe3\x9c\xda\xedL\xbf\x89\x19b\x9b\x8aW\x06\x840\xbb\x01K\xe3.k\xde_MAJ\xdbQ\xc5\x11\xcd2l\xa5\xe3\x06%M\x01\xc9\xbd\x8d[\xbb\xf5\xf7\x0b>\xeak\xb4\xc1t\xc0\x9c*\x13\x8d~\x80Q\x83\x89\x88@\xa2&\x92\xa7[\x85\xa1\xa9\xe1\xc6\x80a\xcfU4\x04 \x07\x1a\xe5\xd6\xc0 \xc2S\xe1\xc2\x0fn\xef\xa2\xd3\xf4\x17\x80\xf0(\x8e\xe6Kt{\x11o\x94\x17\xc8\xe5'DR\x18\xe1\x1bDa\xea\xa9\x07\x1a\x8d\xc7\x08\xea\x99\x03z\x03\x85\xc6\xe5\xa7G\xac\xad\xab\x0b\x98\xe4F\x0f\x08\xda\xe2\xa8\xfb\xc7\x94\x9bq\x02p\x96\xe0\x9b}\x01-\x8b\xe7\\8\xf7\xa2\xd9\x03m\x08\x1a\xbb\x04\x171J@\x8d\x14\xdc\xe2\x8b\x1a\xb0\x00\x84\x08\x8f(\xc4\x181v\xf1\x81\x00g\xf0\x0cEm,\xbd\x11\x02\xedAs\x84P\xa3\xb1\x0d\x12\xec\x9aK\x02\x1f\xff\xb2 \xb75\xc2\xf5[\x8a\xb7=\x9a\x85\xa2\xb5+\x8a\x85\x8d`\xe1\xa2W^\x91+\x8c\x0fZ\x80w\xc4\xca\xf2\xd0\"xF\xab\xf6\x1d\xa9\xc2D\xa9\xfc\"T<\x06e\x13>ttj\xb4\xc8\x94y\x92\xe3E\xa4P\xd1\xa8Q\"Q\x96(\x946\x02%\x04U\x1f}2G\x9e\xb4Q\xa7\x9eGec\xa4\xc9\xaaC\xcc\x11&K3\x97T\x8f\x17U\x1a5\xa2d\x8a&\xf9D\x92F\x89\"yF\x90\x8c^c~/xU\x8f\xa7\x1e\xa8\x10\xab\xd9a\xa3.\xf3T(+\x06\xd0r\x9f\x9e\xef\x0c5\xefF,fL\xa0\xaf\xd1\x03\x07\x1bv\xea\xec\x1c\x0d,5{\xe5\xa2\xf8\x967*h\xd5\xd0\x81m$\xba\x0d[WO\x07\xb5\xaa\xdf\xce\x9f[\xb5W`\xab\x95\x03\xa7\xd0\x0e\x0e\xae\xb5\xf0u\xea\xe6\xa06\x97a\x15\xcc\x15\xb6\xc1\x95\xcc\n\xbc\xe3_\x9d:z\xd0\xd5\xd2\x83\x8d \x0c\xe7\x1b]\xa8\x18\x85G[A:\xac\xc6\x1eTY\xde\x9e\xbd\xc6\xdd\xda^+\x1a\x1b*0k\x12\x87j\xd0k\x13\xa7 n\xd1(\xa0\xad\x05\x16`\xb3\x17\xc0\x91\xadb\xb6\xb4\xfaG+;\xa8\xcc\x9aN\xab\xeb\xact2]\xe7\xa6\xd7x\xd0\xad#V\x7f\xeeT\x13\xab\x1f\xecE\xad\xf2#\x8d\xe0;t\xa6Kk\x0e\xd2\x9b]\x0e\xec&)\xd4;\xea\x93\xaePo?$q\xa1\x8eg\xaf)\x0c\xf5\x8ez&3T\xe0\xad\xd6\xbb\xa2\xa0\xabJ\x96\xc8\xfb)'\x93;\xcf\xaaf\xcc5\xcb\xf5\xc6\xbd]\xfb\x96*f\x01\xee\x03\xacw:\x80\x11\x93-M\xa0\x02\xa7\xe7\xc5=kpT:\x0b\xc0\xb8\xfc\x10N?\xe7>R~\xe6$5\x94\xe3F\xe6\"\xd81\xd93\xc3\xc1QB-\xe0\x86\x12\xc97\xc7\xc1\x8a\x0d\x95\xdc!\xc0\xedJv\x13l\x8a\x08\xf5t\x1cc\xb8\xa3O\xda\x85\x8d\xca\xdd\xdan\x01\x88\xc4\x8c\n\x10\xc5\xd6\xbf\x8d\x8b\xda:0\x01\xce^\x00\xd5\x13\xd8\xeb\xc2\x05\xa0\xfa\x02t\x7f\xe0J\x08\xa9\x00\xdd3x\xf5\x0e\x98\xb8\x99\x02\x94\x08\xd5\x01\x15GS0btT\xe4\x0b\xc0r\x1b\x8a\xd3<\xb8\xcc\x87\xc3\xdc\xf5\xfa\x02\xbc\x16\x1f\xaf\xf1\xbc\xe6\x05\x9es\x03\x1f\xbd\xe79E\x01^\xbao/\xda\xcfO\xff\xe1yR\x00\x8a3\x05x\xae\xa3\xffJzi\xc2^\xab\xe9\xa5\x0d{\xf40\x92F\xc4\xeb\xc4\xd1\xee \x10\x80\xd2\x8c\xce;\x03\x04`\xf9\x10\xc5\x81\x1e\xbc\xe7\xc3u\xee\x1b\x05\x04x2\x82+/\xab\x02l\x86V\x05\xb8\\\xad\n\xbc\xb2\xb6\xea\xcd\xb0\xf9[\x15\xa03\xb9P\xd80\x8f\xe5\xdaa\xdf\xd9]\x15\xe0\xc5\x15P\x19_(4\xe87{m\x80\x1f\xb9G\xa2\x98\x13\x97\xf9\x8a\x03\x01\x98Q\xf5J.\xb3\xe0\xd3<\x13d\xbe\xf4@\xc0( g\x158.@\x10`\xbc\x06A\x80\xd0T\xe6\xf0\xb2\x00\xfb\x95\x08\x02\x8c\x17#\x08@id\x9c.\xb6^\x95 \x00\xa9\x80\xed\xd7&\x08@\xa1\xc2\xab?\xcf\x947\xe7\xe0MW,\x08\xe8\x95\x16g\xc1'\x12\xe6\xac\xd7-\x08\xf0I\x95\xab`\x94\xa4\xb9\x0e:l\xfa\\\x05\xa6\xdc\x1a+7\x98\x84DMj\xc8\xc5\x0c\x0c\x18\x8b%\x97g\xf2!\xa7j`Z\xc9\xd2K\xd2\x08\xd9wY\x90l5bn\xa1\xcbU7_\xc7\xf2\xbd2\x89\xc5,\x8f\xde0^e\xcaPN\x1b\xc2\x05\x8d\xf3p\x196\xb4\x15\xfe\xda\xfe\xfde\xdfi\xb2)\x0c\x99$\xf7 \xb9\xa0\xe9\"%\x97\xcd\x06\xf8\xac\xbc\xffk\xc9\xca\x93\x94\xe3\xb9\x0cG\xe2\x8fR\xde\xe5'\xa6\x94;\x916\"\x9b\xf3\xc4\x11Iz\xc1\xa1\xdcd q\xb5\x10\x996\x81\xa4\xca\xc6\x90\x98d>\x86\x0b\x97\x96RuRUCS\x7fq\xe2\xd4\x93\xb9\x91\xec!\xc5\xb1\xca\x12a\xb6\x1e\x174\x85\xa8\xd6vN\"\x12\xb77\xb9\x1e2d\xd8\xc0,2d\xda\xa8\x8cM\xec\x1b\x92\xe7&d\xdcjzm/\xfa\xack\xfd\x96\xe2\xb3\x8d\xe4)\x89\xb3%MS:\\\xcbM+\xb4\x8f\x15\xcah\x9eG\xa3\xa5\xacJu\x80\x15\xe1\xf6\x19\xc1\x90\x13\xcfH\x93\xaa\x7f\xb3\x81q\x94\x8c(\xbc\xc1\xfdZ\x9e\xec\xc9\xf1k\x89K\x92\x06\x9f\x81\x9f\x0dH\xc1\xcf\xda[\xff\xb89\xb6\xba\\\x7f+\"\x1b2\xb0g\xff\x0bp\x1c\x0d\\\x87\x02c\x16/`\xacwS6/`\x1a;\xb3z\x07W\x0b\x08\xd0\xe6\xd1\x82{\x84f\xc7\x929\xa7\x16\xcc\xb5\x04\xeaG\xfd^\xed\xb2`\xd4'\xee\x93\xd2\x98\xb9\xb2\xe0\xca\x97\x85\xd1\xeb\x0d\x14\xce\xd1\xaa\x0e\x04x'\xa9jk\x0f\x04h+\x10d7v\x96\xb2\x068\xcc\xe7&\xc0c\xb6d\xb2\x0f\xafR\x10\xd0\xaeU\x90\x9d\x18=\xd0\x06\x9f\xb3Uq\xd9\xd5\x96\xa9\x92A\x80\xd3Y\xe2\xd2\x89\x0e\xad\xe8\\\x0bphF\x14\x02\x84v\x04K\xe5\x83\x00\xd1\xcfp\x07\x95\xcbE8bE\x84\x00\x97N\xb7hu\x04um!\x03\xbbn7VM\xa8\x1f\x0d\xb5\x13\xeagLJ\xbe\xfc\xd4\xa8\xcaP;\x05n\xaf\xe8\xb1[\x98\xf8\xddv d\x1b\x86VY(,\xe3\xd4Z(l\xd7Tq\xa1\xba\x1b\\w!\xc0{c3\x89\x9d\xb9\x06Cv4\\\xad\x0e\xbed\xc5U\xa1!\xc09R@\x8d\x1605\x1b\x02\\\xfaQ\xc1x\xf5\x1b\x02pU\x1c\x02PT\x014e\x00U\xd7!\xc0l\x1bt\x01\x15\xa1\x06\x1c\xbb\xd4>F.\x10\x8cZ\xf5!\xf1a\xe2\xfc\x80\xaa\x00\x11\xf0;#\xa7G}\x08\x02\x1d\xfe\n\xd0:`\xb3z\xb0\xa4E\x91\x15-q>2\x87\xce\xdb\xf1ZPt\xae\x8e\x07\xd6\x91\xf2s\xb0\xbc\xe6[m\xe2\x1a\xbd\xe9=\xc1\xc6G>\x95'\x02\xd0e\x1e7\xeb\xfe+\xc4\xb0\x05 \xfb\x05\x8f\xbe\x01S\xaf\"\xc0\xa3w\xf0\x1c\x01\xe0+X\x04x\x8e\x05z\x8c\x07\xfcR2\xc1O\x80\xeb\xe0\x99\x9a \x1e\x82[\x01\"\x91\x13\x8dK&|\xa2\xbe\xc7\xee\x0e\x15`D\xb4 N\x81mB\x0f\xe6\xe9\xc7>\xe8\xfd\xa4\x82\x9e,\x84\xdec*\xe8\xd5\xd3H\xfbN\x03\x19\x92\x89G*\xbf\x11\x802l\x04`Jq\x04x\xf2\x95/G\xf9\xa4\xaa\x83\xffp\xa0\xc7\x90`\xd2\x91&\x98t$\x16&\x1d\xe9F\x86d\xe2\xd1*\x8b\x04xhIT\x95\x91\x00?\xde\xf5\xe0[o\x9e\xf5\xe7Wl\x0d\x92\x80\x1e\xec\xe3\xab\xe4{\xcc\x1az\xcd\x1c\xfcU}/\x02\x08\xe8\xa1\xee}eE\xc0\x98*\xdfO\xe9\xf7Q\xfb\xbe\xc2#\xc0C\x84\x04\xf4b\xa9\xbeL\xd5c\x03\x18\xc0X=6\x81\xde\xbd\x8d\xba\x11\xf8\xb37\xa6\xa0\n\x89*s_O\xdd\x06dq\x95\x00?\xae\xf6\xe0goN\xf6\xe7al\xe9\x95\x80^\xac\x84/\xc3\x12\xe0_\x8c%\xc0\xb7$K@\xcf\xc2,\x01\xb8H\xaa\x0e0EZ\x1e\xe8\xcc\xe5S^\xa5Z\x02\xae\xaf`K\x80\xafj\x80\xf1\x8a\xb7\x04\x8cR\xc2%\xc0w.\xd8r.$:\xeb\xbb\xb5u\xc0\x8f\xd3\xb3\xc0\xcb\x89/W\xb7\x8b\xfb\x96y \xf0+\xf6r\xa2\xe3\xc5`\xb8\x92/\x01\x8e\xc2/\x01BO\xba\xb2k\x04\xb8sl\x148J\xc1\x04x\xec\x19>\xbb\x05\xa28L\x80\xd7\x16\x81)\x14\x13\xe0\x81\xd6W){\xe6\x84;\xf1a\n\xc8\x04\xe0\xb2\xc8\x9dh\xb4Y\xe6\x88b2\x01>\x99\xe6m\xc0i\x11\xbf\xb23+*%\xed\xda\x8fz\xd7\xa5 \xb0gY\"X\xd0.\xc9c\xd5\xab 0U\xad\xc9\xbe\xccJ\xc0&\xf4{\xc9#7T\xb6 p\xd2T[\xe5&\xc0\xd1\xb6W\xc5\x9b\x80~\x17X_\x7f6\xb91\x07\xce\x9a#h\xaa\x93\x13\x80\xc8 \xb4\xd7\xcc \x18^9\xa7\xf0\x8cS?\xa7\xb0\x8dYE\xa7p\x8e_K'\xa0\x7fE\x9d\x00m]\x9dD=L\xa6\xa7W\xf5\xfb\xd5z \x18\xf3U}K}\x9e\xfcyZ\xe9?\xcaJ\x9b\xea\xfc\x048\xa8\x89(\x03\xf1\xac\xfck\xb4m\xad\xcf\xe0*\xc0\x06\xb6\x93\xe3\xd7U- \x83-Y\xc9\x85\xad(\xa1et={\xc7\xf4*?\xeb\xf8m\x8d\x044\xba\xf3\xe5\xdc;[\xa0\xc2\xaf\xb4?\xfbg\x9e\xc0\x9c\xc2\x96dl\xbf\xc9\x138&+zB\xbf\x144\xcbg\xe2\xf7\x16\x92/\x8c\"\xbc9C\xc7\xa6La\x93d9P\x95G\x1e\xd5\xdd\x8d\xdc\x9c\xf6\x9c\x90\xf9\x15\x9e\x8e\xb8 k\x9d\xcd\x87\xffC\x16k\x88K\"\x8a(\xcfj\xae\x80\xb0m\xc2\xd7\xa7\xca\xd9\xe7\x8c#i\x8b\xc5%\xc9\x18\x8b\x1f@\x98g\xd2\xbb\x1c\xb2\xc3\x82\x10\xef\x05$\xf9\x9a\xa6\x97aV\xad\x81\xd9\x10\x11]VL'\xa8O7s\xbaX\xb0\xfd>\x86\x15c\xaa\x92\x1774\xcb\xc8\x8afl\x8bNi\xcbs\x10$\xa9\xf8p\x11\xc6+.\xac4\xcbU\x13X\x93\x0c\n\xb6\xa8\xf5i6\xe6\xa6\xbe\xfc\x98l\xaaA\xfdS\xa7\x14R\xba\xe5g\x10xE\xd2\x92\xb2/\xe1\xe1\x7f\xd7}\xdc\x98#g\x8f\x97\xf0\xa8\xf1\xe5\xbf\xf8\x7f\xb4\x97\xd4T3\x8b\x17\xce\xcc\xbfF\x97\x9fz\xbc\xabs\xf9\xc1\xa7\x97\x88\xeb\x0b\xc1\x8c\x9b\xa1y\x1b\xfc\xad\x9f\xc52\x15r\xd9]Lfmo\x12\xf0\xd1\n\xb5~\x8b'\xba\xb4\x97\x84h\x0b\xae\x10\x85V\xbf\xd3\xa7\xbd\x86\x14N\x8dS0uM\x85R\x83\x0b\xa4\x06\x17F\x99\n\xa2z\xa8\x17}J\x86EY\xd8\x0b\x9d\xac\xd6\xbe\xdd\xd6w\x144\xb9\\}c\x150a\n\x97\x9c>n\xd7\xa9\xc6]\xa0$\xba\x18%\xd3\xde\xe1\xb4v\x11\x16F,\xc2\xd5Bx,3Vwy\xcc\x06\xbcf\x04x\x0d\xe651\x01\x1eZl\x0fz\xccG\x93a\xf9N\x00\x82\xfb\x04x\xad\x9a\xef\xbay\xe8\xb4\x1ek\xe7\xa1\xd7\xbc\xb1\x8f\xa2\xdb\xb0\xda\x0dW\x16\x80,}A\xe88T\x19\x00\x8e\xdb\x10|\x86\xe60\xf6-\x95\xa1\xe9\xf9\xd7\x95\x96\x8f\x15E@\xa5\xe1\xd7\x93\xeb\x11\x08{\xa6\xdfc\xc7\x8cM\xb7w\xbf\x9ebO\xb3w\x8f\xc73\xad\x9e\xcb\xa8\x99M\xbc\xd3\xe9\xfd\xd2\xe8\x1do\xa6 \xd2\xe7\xadi\xf3B\xff\xd8\xd3\xe5\xddi\xf2\xd6\xf4x\x84n\xc5hUg\x1a0{\\b\xe9fd\xb8r?D\xb7\x8d<,c\xbe\x87\xa2\xb6\x98oG\xf0\xbab\xa6qTk\xc5U/\xa0\x1d\xf7\xb3Q\xd4\xcd\x02np*[\x95\x86]]\x18\x0fbN\xc9\xb6\x1e\xb4F8X\xd9\x0eR6Sv_a\n\xcb\xc1\xc7I+\xeb\xc1\xc6\xd1\xba\xe7\xc1e\x147\xab\xce\xb1\xda\x83m\xcd.\x87\x89sk0qn\xbd\x19\xdeC\xa8\xe7]\xad\xdf\xcfD~-\xe9-d\xb7\x91\xdc\xe4\xb1\xb3R\xcb\xe6\x95\x1b\xb8\xfc\x16_\x9bs\xf9\x9d\xfe\xb4\x11\xc4\xc5\xe53\xb3\xfb-,\xfe\n\xa7-\xed\xa2\x9c\xc3\xdb\x85\xa0\x9e\xc3\xa3\xe5\xc4\xd0S\x84j\xb9cx7\x94^\x8c\x0c\xae\xa5\xeb\x10$\x93S\xc8A5[\x9d\x9a\xcb\x0b\xe3r\xee \xdd9\x983\x0f\xdaeS\xb9I\xb4x\xb0N\x9a\xfd\xb9e\xecN\x04?\xd7K\xe9X\xd1\xe2r9[\xe4H<\xbc'\x1d\xff\x88n2\xbd| Ls\xd6p8\xbc\x1e}\xfc\x1cz\x7f\x86\xf6y\xc8\xb6\xcfBwxk\xf9%<\x8e6\x1ao\x83AFu\x1e\x05\xed\xa7\xe6\x92\x89\xde~\x82\nE/\xc7@\xcb\x01Pa\xc3\x9d\xf8G8\xe3\x8b\x93\xac\xa8p*O\xb1\x87\xf5\xca\xea\xce\x9au\xd7\xab^j\xe0\xb1\xc4\x9a\xeah\xc3\x12w*\xa1\xb5\xdf\xa9\x8d\x0d]\xf5\xdc\xaao\xd0 m\xa5\xedk\xbbm\xef\x0d\xbaT\xfdN\x9a\xbe&\xd1^W\x9blL\xbd7\xf3\xf2\xb0\xea\xe31j\x8e\xc7\xab4\x1e\xbb\xbe\xb8\xb4`\xbc\xaa\x8a;\xb5\xc4\x1e<>\xa91\xb7\x1a3\xd4\xf1NT\x1e\x99\xca\xba\x1aZ\xed\xdc\xbb;yS\xb5\xe2D\xc7\xb6\xb5\xcc>V\x8a\xb53\x84\xbaBm+\xd3\x86\"m)\xd1\xb6\x02\xd5*O\xfd\xba\xf6W\x9aC\x15\xe68\xcarLE\xe9\xaf$m+}\xf4\x06mF\xb4\xec\x01\x0dk^u-\x8d\xda\xef^\xfb\x7f\x90d\x9b$\x9b\xcdIFg\xbc\xdc\xb8\x1cx\xad\x96\x15=\xf4\xc6\x99\xde*S\x0d\x9f\x87Y\xc9\xc8\nj\"O\xe3)\xcd\x8b4\x16\xd5\xbb\xf5\xda\xd7YYn\xcd\xab|Wa}#\xe6\xd3\n\xe3\x95\xa3\x90z\x06\x1f\xe2h\x07ILE\x11\xc92\xa39$)\x1bB\x0d\x99\xac\xdb\x9bS\xa6F\x94F\x11\x1f#g\xde*\xf04\xcf]\x0e\x81O?.64\x0d\x03\xf57~\x96\x0cH\xcc\xc6\xc1\x0b\x8f97Kb\x15qyp\xaaG\xc4\x8e8\xaa\x88fY5k\x86(\x86\"c\xd49\xa76\x12\xc8\x89\xd7\xf05I\x10\x85\x9bp\x0c\n4\x0e\x87\x1c\xa9b_S\xd5\xb9\xa8\xeb\xaes\x06\xfbZ\xfcZ\xc3\xc5\xd6\xbc\xb1\xf9\x1c-!\xa2\xcb\x1c\xe8f\x9b\xef \xcc\xe12\x8c\"\xa5,\x19V\xc5t\xa2\x03F\x8a\xf9\x0e( \xd6@\xb6[5\xefZ1{{\xf6\xf3$\x89(\x89\x11\xf3\xac!a\xb3\xe5+\x9c@\x9e\x16\x14\xd8?\xc2x\x11\x06L\xf1\x88R\xbarv\xfc\xc3\xce\xba\x84q\x10\x15\x0bZ\x9f*\x91\xc7\x1fY\x19\xd5\xa6$w,\xd5N\xdbL\xbfU\xd7+0\x8a~:\xca\x1a\xb4k\x0d8a\\\x93\xd2lK\x83\xd2\xcfPq/c\xd0\x99d\xbfp\x15'\xa9\xfc\xa4)\xe6\x8d\x13{Vg\xad\x9a\xd2hP4\xa5\x174\xcd:\x9a\x12Ov\x89\xa0M\xf2\xb0v\xa3AJ\x0d\xfc\xc5\xb0R~\x1b@]b\xd3\x05M\xed\xc3\xd6\x8b{\xf3z\x00q\xb9@\xe7v\x80wI\x02Y\xb2\xa1g[\x92\x92\x0d\xcdi\xaa\xbd\x17\xa0\xa6\xb7\xeb\xabX\xbf\x18\xa0q)@9\x88zC\xdb} \x8d\xbb\x0f\xc45\x8e\xa5B\x91\xa8\xaa~g\xf0\xf6\xea\x05b\x9f\xf1\xbc\x15\xa0{}\x07~\xb7i\xcf\x1b\xc6\xb8\xae\xc3\xe3\xaa\x0e\xad\xb2\xc0\xa9J\xdd\xd0\xbd\xae\xe50^\xc4Q\xe1\xf3\xbb\x83C\xcf\xcf\xa3\xdd\xbd1\xe4\xde\x0d\xdc\x9d\x1b\xe8\xfb6\xecwm\xfc\xab\xc5\xe3\x8a\xbb\xd9) \xcd\xd5\xad\xf3\x9b\x863\xda\xe7\xb6\xce'\xfa\xf5\x18xV\x1b\xef\x9c\x869\xa3\xad\x92d\x15\xd1\x19\xff\xefy\xb1\x9c\x1d\xc6;4\x05\xd9'gE\xea\x12/\xf3\x9ep\x08\x9fN~\xba_\xba\x88c\xb2\x91\xdbn\x11\x87_\n\x1a\xed*\xf3Y\x9a%\xbb-\x95\x1bk\x0dMF\xd3\x90D\xe1W\xdaHg\xe2S\n\x92\x08\xe6\xc5rIS\xc5\xa13\xe1\xc8\x17c\x14E\xcaA\x12\xe7$\x8c\xcb\xba\xe6:\x16f\x9e\xdd\xba\x7f\x0b\x825II\x90\xd3t\xc6\x97&\"\x19\xb3\x08V\xfc\xa6\x0e\xb9\xd3\x7f:\xf9\xe9v\x06[\x92\xaf\x05\xda2\xc4U\xc7\xc7>\\\x16Q\xb4\x83/\x05\x89\xd8\xcc\x16b\xde\xca\\`3\xbcC2\x08\xe3z\xb3\xcf\x0c\xed\xfd\xf6b\xbd)R\xceI\x9f\xef\x8aQqD\x95\xd1\xcc\xa6\xc4\x0c\xd7$\x0e\x83\x86\xd6a\n\xaf\x8e\xfd\x0e\x9d\xadf\x07l\xf2\\\xf2o\xcdn\x81t\xd7\x93 \xa0\xdb\x9c.\xee6\xf3\xd3\x8eb\xd82r\x84\x01=\x80\x9c\x92\x0dS\x0d\x05a\xd3\xda\xa64H6\xdb\x90i\xc0\x98\xed\xf2k\n\xf30&\xe9\x8e\x87\x19r\x1eRhe\xf0\xe6\xeb\xa6I\"/.\x08\xb9\x99PdT\xd9\x01l\xa1\x98\xc2O\x96p\x18\xeff\xf0Cr\xc9\xac\x8a\x03\xbe-~:\xf9)\x93\xb2Qd\xb4\x89\xbd\x8e<\x0b\xd6tC\xe1\xf3:\xcf\xb7\x9f\x0f\xc4\xfff\x9f\x0f\x98\xe9\x1d'\xf2\xd7\x03\xbe\xee\xcc\xe6O8\xdf\xf2\x991\xb3\xa5\xd82\x89\xdem\x9b\x18izAS\xc1\xb9\x1b\xb2\x15q\x131\x9e<)5#\xd7\x08\xa1\xc8\x12#l'\x8f\xa2\xe42{\xd1\xa0\xeb\xbf3C\xb9\x1c\x05[\x04Y'\xbd(\x07\xca\x15A\x96\x15\x1b\xba\x985\x9b\x1e\xc6\xf0\xc3\xe9\xe91|\xff\xf6\x14\x92X\xb1\xa4\xe0\xc5\x1d\xd7!\x04\xfe\xdef\xa1\xd3\xdd\x96\xfe\xe3\xef\xff\xa8!\x02\xb5\x0f\xc5j\xdd\xc4\xfe\xc8)\xb4M\x93E\x11P~\"O\xd3$\x9d5G\xb0\xddFe&\x1c3\xe7\x08\x9b\xa3\xd8\xd0\x03\x120\xb9I\x92\xf3b[\xaa~\xa6\xbd\x17r\xb0\x8d!|:\xf9\x89\xf7\xc7\xafY\xc8\xd7tS\xe3\xab\x85`,\xa2\x86\xc7\xfe}\x91\x84L\x976c\xb8\xa23.\x1a)]&)=PM\x18&\x92\x87\xf30\n\xf3\x1d\xc4\x94.\xd4\xb6\xc9E6\xbdhE\xe4\x92\x98)\x80\x98m\x9a\x8c\xa5\x19\x0f\xcf\xe0\xce\xa7\x8c\xaa\xf7\xf9\xd9\x1c\xd9\xa23 \x14\xabN\xe2vE\xc4<\xa5\xe4\x9c\xc9\x97D5\xbb\xdbp\xcf%9}!n\x99X\x16q \xb8\x8e\x8dNJbP\xa4)7l\xea&\x86X\xe5\x84[=\xcd\x0b\xbe\xd4\x02CJy\xb0\xf1\x80\xef6\xe2\x80\xc7\xd0\xf1\x9d\x9c\xe7\x1c\x96\xbc\xca\x8f\xf21\x1b \xdb\xac\x1aJk\xb7\xa53\xc19d\x1bf\xb3 \xd94\xf5\xc1G\xce\xaf\x990W\xc49\xb7%_pG\xe67\x8a\x13\xa0`\xf0\xbb\xb0 W\xeb\x1c\xe6\x0dq\x12gl\xb6_\x96{\x9c\xd8/U\xaa%dtC\xe2<\x0c2\xc5~\xad\xf4\x04\xbcyj\xde\x9b\xde3\xb1\x99Sq0\x0d\x17\xb5M\xa6\xb3\xb3H\xd5M\xe6\xc9\x05U\x83l0\x10\xa7\xdf7\xe6\xfe>\x1f\xc6\xbb\xcfj\x1b\xe2\xfb{\x97$\xff\x9c\xcdf\xff\xfa\xa6\xd9\xfb\x01\xdb^\xd97[\xb1\xd9\xbc'i\xb6&\x11\x9bt{@\xcd \xb6q7\x10\x87\xcb\x16\xdaO\xf1\xa6B\xcc\xbb\xe5L\xc2\xbf\xfao/y\x02G\xeb\x0c\xd7\xea\xad\\if~\xf2y+\xb9U\x86\x0b;ql\xdbz\x84{\xff\xe6\xbb\xd2\x01\xc8\x0c6\x89\xe8\xb6f\xb3\xb9\xcf,\xe6\x19\xff\x81m\xb0\xb7\x99\xfdT\xea1\xa6\xe3\x18\xdd\xd9\x1f\x04\xed\x15\xaaR\x85\xc4\xd1\x8e\x9b\x91:\xe3\xbb\xdc\xb6\x81,s*\xf6(n\xdd\xdf\xbe\x7f[!\x92\xbaLu'\xecM*\xd7\xfe\xd62Ifs\x92\xf2\x81^\xdd\xdf\xcd\xbe\xde\x12\xf3\x136W\xddX\xe4\xdd\xdcb_05&\xff\xf8\xd7\x8f\x1f~V\xff~\xf9\xf2\xe5\xcb:E\xd9o\xd59B\xec\x82 ca\xb9e\x08K\xad\xc8\xa4^O\xe9\xaa\x88H\xaa0t\x1bJgZ\xa9\xf2\x0f*7\x81\xe4\xd6\x03yR-O\x1f5\xe5,\x0e\xa2\x9f\xff\x17\x9b\xd2gij\x97\x9bV\x9d@3%\x18/\x1a& \xce\x99=\x86\xe4\xe1\xec\xd1\xc3G\xd9\xad\xc6\xb2\x00\xac\xd2m0[\x91\x9c^\x92\xdd,-\xe2<\xdc\xd0\xd9[v\x02B{Kh\xf55\xe8m\xd4 Yt\x8cXK\xc2\xdb\xe3G\xf2\xaf\x92\x82V\xdc\x0b\x9a\x930\xca\xda\xdf4\x13_;I\xaf\x9di 0%\xbb\xe6\x1d\x87P\x1d\x8d6\xd1\xd5\x95a:\x92\x8bH\x80\xdeQ$`\x1cw\x91\x80\xfeN\xa3\x0e*\xad\x13I@OW\x92\x80\xde\x0e\xa5\x0e\xa6\xd2\xc1\xd4q+ \xf0v. \x18\xe8b\xd2PK\x84\xf3v\xdd\xae\x06\xba\x9b:\xf8\xa4\xa9\xd1\xedh\xa0\xeb\xa9\x83\xaf\xeb\x8a\x92\xfd\x8c\xe6\x90\x120\xc0-\xa5\x10\x8c\xe6\x9c\x12\xd0\xd3EU\x8ef4G\x95\x80Q\xdcU\x02\xc6sZ \x18\xc5u%\xc0\xee\xc0\x12\xd0\xdf\x8d\xd5\xd5\xa2\x1a\xb7\x96\x80!\xce\xad\x0e\xb2\xb6\xb3K\x80\xc6\x96\xd0i\xa9a\x8e\xaf\x0e\xba\xb9F\x98{\xb8\xc3\x04hkv,[\xb1\xa5B\xca\xb5K\xf7t\x96u\x15\x97r\x9e\xd5\\f\x02l#\x18\xc3}\xd6@(\x8e@\xcd\xa5\x18\xe8J\x130\xdc\xa1\xd6@\xd7\xddp\x07\xba\xd8\x1a\xb8\xf2\x86\xbbM@_\xa7\x9b\x00\xa3\xb7J\x80\xc6\x01'\xc0\xea\x86\x13\xd0\xf2Kp\xc0\xb9\xe4\xcc\xed\xff\xa5\x9f\xbb\xb7\x93N\x00n\xf26\x87\x9d\x00\xdbL\xad\xce;\x01H\x17\x9e\x80\x16\x05\x86\xb8\xf3\x04\x18\x9dz\x02\xf4\xae\xbd\xf27\xad\x83O\x80\x81*\x18g\x9f\x00\x9b\xcbO@\xdd\xf1'\xa0\xa7\xfbO\x80\xc3 (\xc0\xcf\x15(@G\n\xab[P\xc0\x08\xceA\x01\xda\xfe[\x9c4\x9a\xbbP\xc0\x88NC\x01\xa3\xb9\x0e\x05\x8c\xe5@\x14\xa0u#\n\xa8{\x7f\x04\xd4]\x8a\x02\x86;\x16\x05\x8c\xe2^\x140\x9e\x93Q\x80\xdb\xd5(\xc0\xeap\x14\x80p;6>4:\x1f\x05\xb45j\xc7\x9d%\x00\xeb\xd42\xbb#%\x1e\xb7SR~hwM\nh\x0d~,7\xa5\x80\x11\x9d\x95\x02\xc6qY\n\x18\xc7q)`\xc8z[\x9d\x98\x12\x95\xc5\x95)\xe0_\xa6\xf2\x89c\xc2\x0b{\xd1.MY\xe4p\xf6{\xad\xc5\xdc\x8a\xf9j\xc6\xdf\xc0\xfcG)\xd9\xfc\x9f\x86\x92M\xb9\xec\xed\xea\xa3\xbcY\xbe\x93\xf3-[\xbcM\xd5x\xed_\xf3B\x93*P\xaac6T)5\xd1Z\xea:\xeb\xb8\x8c\xf5J-l\x8e\xea\xce\xc6\xf0,\x95K\xed1\x9aj<%>Q\xc6$\x7fL5\x9c\x81\x92\x8e\xa9\xbe\xd0\x95\xbb\nS\x9d\xec5P\x98\x8dQ\xc8\xcbD\xe3\xfd\xd0\xb8\xa5=\xba\xe5\x8fJ\xf98\xf6\xed\x1b\\\xe0\xdag\x8bio,\xe3l*cn(\xe3o&\x86\x8dD\xac\xfa\x86\xa4\xe7\xb4\xba\xf7\xf1\x952[\x10\x96\xda<\\\xf4\xb5\xd24\x0fr\x1a$\xb8\xfb\x10\xa7\xe1Cc\xc9\x8d\xee\xf1\xcd\\\x1b\x07\x07\xcb\x15\xb5\xc9\x088\xd4\xfbT\x88\xf9\x98\xf5\xd1\xabp\xd1z\xe1Sh\x9e(\x92\x01\x83\x8c~\x915Du\x83\xea\x10\xb2\x82\xdf\xed\xb3,\"\xb6r\xb5\x8b\x8c~\xa2$\xa3w\x8e\xde\xdc-\xeb\xeb\xf7gy\x92 \x0f\x1b>\xfa{\x10%\x8d\x10u\xc7:\x1dh\x87\x0e}\xad\xd3x\xb3\xc8\xabpax\xa3\x93\x91\xb7ks\x8a\xa9\xf3v\xefI\x1e\xac\xb5\xef]\xea\x9b2\x12\xf1\x86?%Ynh\xd5\"cM'\xbd\n\x17\xc6\xf75Y\xcb\x16\xbd\x1be\xf3\x98\x975\xe7\xe5\x9aL\xb7$\xedsK\xd7\xdfC\xac\x9d\xbb\xf1\xe2\x8b\xdb\xaf\xc2\x85R\x1e\\\x93\x1c4\xd6\xb1\xba_\xe9\xb6e\x87\x18\xcb&h(\x83\x86\"h(\x81\x9e\xd6A/\xc1\xd7\xdf\x89\x81\x17\xf5\x9eb\xee/\xe2\xbd\xc4\xbb\xa7h\x9b\xf8\xe0]\x18\xe54\xcd\xd0\x06\x83\xdb\xe7\xd1\xdc\xed\xad\xac\xdd\xd8\xe5W\x9av\x98k\xdd\x92\x9e\xed\xba;y\x0f\x07\x8e\\\x8d\x8a\x90\xa5NZFd\x95U\xcb\x1efL\xbf\xb0O,\x8b\xe1q?\xc9\x9fj\x1d\xf4\x8a\xa2\x87\x15\x85\xb5\xa0\xb4\x0b\xc4\xbf@/\x10O@\x99lk\x1f\x1c\x1e\xb6\xb5\x94;\xbe$\x15\x13\xb0\x15\x95 \xadL\xf3\xf1%\x90M\\\x82\x0ch{Xc\xfeZ\xdfJ\xff\x1d\x18\xc3j\xbf\xe3\xe4<\xe4\xff\xa1\xd9\x88\xc4\xe5\xa4\x9d\xe9\x1b\x9e\x9b\x17K\x83xn^\xdeyj}n\xbe\xda)9Z\xe3^)p\x0d5\x86\xeb|3\x99\xc37\xde\x1c\xe6,\xa1T\x80\xd4\x08\x07\xad\xd5D\x18\xc5\xbc\xe5\x00\xb3\xb8e \x1b\x19\xfa\xc6\xd8\xc5\xfd\xa5~\xcf\x12\xdf[\xda{K\xba\x99!&\xfb\xd8:V\xd7\xb6Z\xdf\xa7\xcd\x16\xb2XH\x84\x8d,\xa5{Z\x0d\x17\xad\x9d6\x91\x96\xbc\x1f\xd2\xb2\x07\x0cq\xd9\xd7\x93\x85\x8b\xc7!\x17\x88S\xd9\xf7\xe4\xe2\x124@\xdb\xaf\x18\x7f\xee\x8d\xb7X\x85O\x87S\xd2\xe0\xd5\xe1\xdciq\xe1\xf2\xb6f\xef\x8eh\xbe\x11\xbf71\xa8\xcd\x89c0nN\x02A\xc3\xa3\xeb\xbd=q\x1c\x8a\x01\xb64\xe8%i\xdd\xe7Z\x0c\xf2#\xed4n\xdb\xe9\x1ah\xde\xb70\xbfn\xc1\xec?\xba8\x9b\xeb\xdeD\xb2<\xa7\xf0\x917{\xb5\x13\x9bA\xb2\x84s\xba\xcbd\x8d\x16\x8d \xb3:eUV\x9e\x88\xaa\x9a\xca\xd0\xd4\xa0[\xa6\xc9\xa6\xdb\xbfi6`\x9d\x11\x03\x12Eg\xc9R\xf7\x8bBk~~\xd6\xfa\xf0\xacQ\xa5\x95\x1f\x08\xa2\x89\x01pM\xc1)\xc3\x13H\xc3L\x90\x8b\x17M\x95D\xa1\x0b\xfb\xcb\xba$\xde\xfd\xb6s1\xbe\x95(FV\xd6QrI\x10)\x85|\xcelQENmc\xd2\x06d.RL\x8fY\xc9\x9fe\x92\x9c\xf7K<\x9a\xa6Jx+\xdaJ\xe9\x95\xc2[[Ce\xd7|\xa3Ax\x1c\x91\x80\xab\xa3\x93\x9af\xaa}\xa8y\xaf\x10,\xab6\xe6\xd3=\x86\xae\x05\x0c\xe4\x80\xceC\x8a\x1580\x03\x02;\x98\x9fY\xac\x00\xd1\x0f \xfb\x02\xdck\xf8N\xde\xae\xc0R\x8fV\x07\xe5\x1e\x18\xf4r\x97\x02\xdc\xab\xf7.\xb5)\xe07z\x81\x1c\xf3\xae\xbd\xc7* \xdf\xb2Gc\x1c\xa0\x7f\x1a\x08\x86=\x08Y\x81\xeei\xc8\n\x10\x0b\x84Y\x1a\xdb\xabx\n\x10]\x01\xb2;\x98d\xb1\x05\x93,j?\x1cI\x16\x87>qY\x81\xf6\xb1\xcb\n\xdc\x8b\xedXh\xd4\"\xe3\x16\xd8\xf4 2\xf0y\xf9\x13\xc5!\xda\x8f\x0c\xaf\x83V\xe0\xe6\x9c\xeb\xd3<\xa6\xf7D+@/\xa3\xf9\x8d\xd1\n\xdc\xaf\x8d\xd6\xbf\xb5\xbf;Z\x01\xf2\x05\xd2z\x03\xfb\x1d\x14M\xf0~\x95\xd4\x81\x8f\xa0\xdf'\xad`\x7f/\x95V\x80\x11!\xf0~\xbd\xd4\x81\xac\xcccw\xbdcZ\x81\x1c\xe7\x90\x17M;\xc8\x0c\x93\x1e\xe3\x95\xd3\n\x1c\xef\x9dV\xd0\xe7\xe5S}\x8f\xba\xd7P+\x08\xbaI\x04\x02\x84\xd0\xeb\xc2\x14\x02L\x01\x0f\x01\xad\x04\x88\n\x06z94\xe9\x11\x158\xf5\x94.e\xa2\x02Gs\x8c\xc6\xe8\x9dP\xa1\xc56$\xb7B\x8bP\xe6[h\x7f\xc3\xa6^(P6\xd7\x80\x97[\x1b\x88\xbeO\x93b\xfbqK\x03\x85h\xc5\xfeP^K$n\xd7\x92\x8dFH\xff\xe0a\x982\x98&bk\x07\xad\x18\n\x1f\xb9\x08\xad\xc9X\xa81\x0d\x84\xa3\x1b\x90\x06b\xcb\x8e\xbe!\x89\x1f}\x82g\xc3\x02g=\x83f\xbd\x03f\xe6\x95\xfd\xf3\xe6s\xb8\"\xc8\xf5\xe8\xb49UC\xae\x90;UCF\xb9\xfft\x84\xee\x1b\xe4\xd7\x12\xf1o\x05Mw\xaf\xc2\x85\xf7\xd3\\\xf3\x9ei\x19\xedz@cs3\n\xd0gw\x80}_\xeefy8\x1aX\xb2=@\x9b\xf1\x01NS\xc8f\x08u\xb3?`\x10>}\xae3\xd8\xe6l\xce\xfe\x84~\xd9\xf0\n\xb0Y\xf1\nZ\x9a\x04l\x83\xd6\x1d$uy)\xa0\xcbM\x01}~\x8a\xf8s\xbbXN\x97\xb8\x02\xb6\xe4\x15p\x9a\x82\x83w\xde\x16\xbeN\"\x0b\xd4\xf6c|\x81R\xd5\xb2W\xa1R\xd5\xdc\xb7`\xa9j\xd9\xa3pI\x81\xf7\xa6>o\xac\x99\xe6<\xd2CA\x19N\x1f\x16}c:q\xe0\xc4\xb5\xc3Zc\x9d/F\xa7 \x9d5\x0f6\x1aY\xf3\xe4\xbc\xea\x1c\x19\x88\xdb\x0f\xce\xe4\xb5>\xbd\xf6\xbf\x11\xf6>\xcd\xedE`g\xad\xce-F\xd6\xef\x95\x7f\x15}\x9b\x11x\xa5[^\xb3r\xd7(\x08\xd0^e\x04^\xaa\xbc\xb3=\xf6\x7fT\xbd\xc20\xecq\xf5\n\xcf\x18\x8f\xac\xd7F5\xdac\xeb\n\x1a\x1a\x1a\xf5\xe8\xba\x82\xce\xad;\xd0O\x86&\xf5\xbc\x0f\xf5\x9c\xa7$\xce\x964M\xe9p-7\xad\xd0>V(\xa3y\x1e\x8d\xb6\x81Ju\x80\x15a\xd9\xaa}\xe6d\xa4(\xdf\x08f\x03\xe1(\x18\x11\xf8\x97\xf7\xd9.}r\xfc\xba*\x01\xb3\x9ed\xb3>G\xd9\xac\xbd\x97\x8f\xfb<\xc9\xbc\xbb\xff\x1a%\xc2\xee\xd8\xd6\x1d\x9f\x05X\x10\x02\xc2[n8P\x0b\xb0\x9e\x92\xc1x\xb8\x16\xe0l\xec8h\x0b\xd0\x1f\xb7\x05\xd8\x0f\xc9\x02\xec1\x080\x1e\xc0\x05\x8c\xd3\x83\xf9H.\xc0A)\xbb\xfd!`\xc0!]\x80\xefQ]\x80\xc6\xa6\x13\xe0\x98\x929\nl\xb2\xf2\xd4\xaf:\xc3G\xfe\xa4=\xce\xab\x1fu\xa7M\xf9\x93\xde\xfeqY\x85\xea\x13w\xc4g\xc0a_/t]\xd7{\x13\xfa\x1f\xfcU\xfbA\xc7\x7f\x85\xa4\xaf\x13@\xb5\x1f\xe0\n\x100\xd0! `\nS\x0e\xb2\x82\x04\x8ch\x0b \x183Liv/\x08pP\xd3\xa6\xff\xfb:\x1c\x04\x98\xdc\x0e\x12w?Kb/V\x84\xc15!\xc0\xc9\xccZ7\x85\x00G\xdb^.\x0b\x01F\xc3\xc7\xda\xe5\x8d\xda\xf0\x8c\x8a\xcf\xec\xe8\x10\xe0\xbb\xb1\x19\x8c\x8e\xe1\xae\x0f\x85g\x1c\x07\x88\xc26\xa6\x1bD\xe1\x1c\xdf\x19\"\xa0\xbfKD\x80\xd61\"Q\x0f\x93\xe9i\x83\xba9\x1b\x94\xd1\xc1\"\x7f\x9eV\xfa\x8f\xb2\xd2&G\x8d\x80\xe1\xa6\x88\xa7\xeb\xa6\xd1v\xb0\x03\x87\xc1\x96\xac\xe4zU\x13\xd4\xf2\xaf\x9ekcz\x95\x9fu2\xd6\x9dn\xacN}\x80\x9cRggS\xf8\x95Rg\xff\x94o\x1e\x92,\x13\x0f6\x1e\x93\x15=\xa1_\n\x9a\xe53\xf1{\x0b\xc9\x176}\xde\x9c\xa1cS\xa6\xb0a\x87 \xaa\xee\xa5\x89\xea\x11\\\x9e \xe79!\x8d\xcb\xc4\x94\xa4*\x12\xed\xd8|\xf8?\x84\x17@&\xda\xf1\xb7&k\x0f#.[m\xebS\x15Oop$mn\xbf$\x19\xe3\xdc\x03\x08\xf3L=\x95\x99A\x11\x0b\xa9\x95\x19r\x97aV\xad\x81\xd9\xbe\x10]V\x1c&\xa8_>\xc0\x12\xc6\xb0bLU2\x9e|\x15%c;o*\xdeA\xad\x90\x05I*>\xe4\xaf\xb6\xa4b&\xe5C*k\x92\x89\xd7\x0e\xeb\xd3l\xccM}\xf91\xd9T\x83\xd2>B\x95\xd2-?D\xc0+\x92\x96\x945\xbc\xdc\xd3\x9c#g\x8f\xf6\xdb=\xe2\xbd\xac\x96\xe0e\x1e\x92\x97a}\xa7\xdc\xbd\xe3\xed<\x8d\xaa;\x0b\xb5-\xf4\xad@{\x7f\xa1\x11\x81\x19 L\xb9@\x12F\xce\x05\x92\x1c\x87\xbb\xebG\xc1\xfeB\xbb\x86\x14\x1d\xfb\xa5~\xa6\xc3\x11>\xca\xfb[%\xec\xf4\xbf9\xad\xc2\xb1\xd7\x1b\xd4\xaanz\xde\xa4\xa6\xc0\xdb7\xd7\xe6\xb9)]\xa7\x01#\x9a\xb5\xc3\xa3\x8d#\xa7\xeb\xf8\xdf\xc3\x08\x95\xf7l[\x7fb\x0c\xfc\xb6*\xddscF\x14f4pS\x93wt\xcf\x91Yz\xf9\xb3\xe5\xfaXw\x81\x1e\xef\xcb\xb4\xb0\x19\x9co\xe3\xbc:SaS\x8az\xf8\xeb3\xb5\x11\x8e\xfc\n\x8d\x02\xc9\xc5\xbag\xcd\xa0\xf3\xb4\x19\xf4\x93\xc4I\xe5\xefC\xe5O Z7yu4O\xaa\xc1\xb4>7e}ZZ\xaf\xeb\x9a\xab=\xc7\xd6\xf4 4\xce\xee.\xa7\x800\xa3|\xbc\x02\xfe9U\xdc\x16\xdbsVU\xcb\xf5`\xc5a\xc3\x03Fg\x84\x00\x0bJ@x\xd5\xa7\xcc\xaa\x1b\x9fY\xd5\xcb\xd9!\xe0\xfa\x03\xc1\xd6\xf4&\xf7\x89]~\xf8\x07Lv\x1a\xee4Q\x98\xae\xc5u\xa2:\x1b\xe8@\x110\xd8\x8d\"`Jr\x1adK\x08\x18\xd1\xa2\x100ndq\xefIN\xfd\xdc4\x02L\xce\x1a\xd9C\xbf\xcd\xdd\xe4\xbe\x110\x90\xb5\x7f\x87)O&w\x8fDl\xebw\xca\x96\x1aug\xf4u\x1ei\x11v\x1f,n\xc2\xb8\x8e$\x85s|w\x92\xc2\xbc/\xa7\x92\x00\x87kI@\xd7\xc1$\x1b\x0f\xd3\x15\xd36xs\xb6\xc1)a\xee\xcf\xb0\xca\x06\x87\x97\x80i\x9d\xff \xeb\xec\xe78k\xb4\x19\xc5}\x06S>\xdb\x94\xcf&`\xcag\xf3\xcdgkz\x98Q\xd2\x87\xcei\xe3\x97dy;\xaf\x93T\xf3\x0e\x1aJ\x8a\xbb/\x96\x19\x11\x98\x91\xc0\x94\xd3&\xc1\x8cO2\x90\xf7%h\n\xae91\xc1\x90\xbe\xf6\xbb\xccM\xebs\xb9c\xd5z\xc8%\x8f\x15\x96^\x97=*\xf0\xf6\x95\xd6_Ic\xd0|)\x0d\xfaI\xb8\xfe\x16\x7f\x8b\xbc\x9a_O\x03\x97-k\xb7d-/\xa9\x81e\xfbU\xe0\xfd\xa2\x9a\x01O\xcd\xe8\xd3\xbe\xaa\x06\xaeY\x82s\xa6\xe0xa\x0d\xca.\xec7\xf5;o\xe9wZ\xff\x80 ,\x94\xa3E>\xc7f\xc3c\xbf\x85\xde\xfeX\x1b\xdc<\xb2\x8c\xf9\x80\x1b\x80\xfb\x117@\xbc\xf5\xe0\"\x11\xe2M;\x0bgcx\xdb\xf9\x86\x03j\x01\x9co6 \xb0(\xeft\xcf7\x1a\\<\xd0\xe7%83U\xbb\xef\xc3A5\x06\xd7\x1bq`\x7f\xac\xcd\xc6\x14\xfbz\xe1\xcf\xfav\x1c\xb8\xf1\x03\xa2\x0f\xb0\xbf#\x07\xb8^\x00\xd9\x13`\xde\x94\x03|\x9f\xe0\xd1/`\x1f\xacA F\x1d\x8c\x87\xf8.\xa8\xd8\xdaH\xcf\xd6\xb8\x95Y\x05.\xb5V\x81S\xff\x0b\xf0X#\xbfUr\xaa\xbf\n\x8an\xc3j\xb7\xd1\x9e\xe3\x03\x9c\x8es>\xcb\x07hnC\xf0\x19\x9a\xc3\xf0\xbc\xe5~\xaa\x0f|\x97\x1c\xf3d\x1fp\xf7,\xf6e=\xf5=\xf6\xe9>\xa8;\xc8}:\xc1\xc4\xcb\x9b\x80~\xc6\x0f\x81K\xfb\xc8\x1e\xf2)?h\x13hO\xcf\xf9\x81\x87(\xc2\xd8\xcf\xfaA\xbf\xa7\xfd\xc0c\xcc\x1e\xef\xff90\x99_\x07\x04\xd4xz\xbd\x12h\xc4\xb6LR\xfcK\x810\xe6k\x81\x0c\x1c/\x06\x82\xed\xd5@(\xf5\xcf\xf0\xea\x0fC\xd6:\xe0t+F\xabZ\x93}\x00\xabJ\xedI?\x80C\x83Uf\xe3&\x00A\xdf$ #6\x91\x1cdM\x04\x82\x1e\xc9@P3C\x07\xbf8XC\xe6\xf3\xea \x8c\x7f\xf9A\xffW\x08\x9b\xe9\x16\x8d\x94\x08W\xb6\x85\xe8\xd4'\xd9\xc2\xbfT\x90\x8f\xbc&y:\xabjh\xa9\xa0>/\xc3\xaa\x1clJ\xa1_\x16\xbc\xa9\x94\xcf!\xf2\x8e\x12>S\xf9\x9eK\xb5\xda\xd5\xaa\xa9do\x08\xd6\xa19\x1b\x86:\x02\x0b\xf9\xf4\x16\xab\xb9v\xc0P7`\xac\xb93\x14\x138\n\x05\\\xfa{@\x1eG\x97\xe7les\xc3r9\xc6\xca\xe6\x18\x9c\xcf1BF\x87.\xa7\xa3\xb7v09\x98\xacrn\xcf\xeep\x9a1.\x13\xc6\x91\xe3\x81\xb1[\xc7\xca\xf3\xc0ez8g\x0c\x88Y\x03\"\xdfc\xf4c\xbc\xf34\xed&5\x8c\x98\xf9\x81rw\xb8\xb2?n,\x91|\xf3@\xac\xd8j\x04u\x11\xcd\xed\x94t\x13\xccA,\x04\xff\xe3$\x00\xe1bD.\n\xc2\x9d\x88\xc24\xd8u\xe8\xe6\x8e\x113D,9\"^Y\"\x8e\xc4\x0c;\xc3X\x98\xc5\xc9(n&qf\x8c z\x01TO\xe0\xce\x1bA\xf6\x05\xe8\xfe\x00\x9b=\xe2\xd13x\xf5\x0eS\x84F\x82[-V\x80\xd8M\x04x\xad\x9a\xef\xba!\xd4g\x05\xdek\x87P\xa9\x15xb\x1f\xacf\x1bh\x9c.Vl\x02\n\x9a\x9b,\x1f\xba\x13T<\xb8\x02\xcf\x0fS\xa8\xb7\x82I\x91x\xae\xdb\xa4H\x90\x8ad\xa4T\x16\xa4*A\xa4\xb3\xe0\xb9\x0d\xc5i\x1e\\\xe6\xc3a\xb8\xc4\x16\xcf\xc5\xc7k<\xafy\x81\xe7\xdc\xc0G\xefyNQ\x80\x97\xee\xdb\x8b\xf6\xf3\xd3\x7fx\x9e\x14\x80\xe2L\x01\x9e\xeb\xe8\xbf\x92^\x9a\xb0\xd7jzi\xc3\x1e=\x8c\xa4\x11\xf1:q\xd4\x04\x18\xa4fD%\xc1\xe0\xf9\x10\xc5\x81\x1e\xbc\xe7\xc3u\xb8t\x18oF\xc0\xa6\xc4\xf8'\xc5\xf8\xa6\xc5\xf4L\x8cqG#t0fr\xcc\xf0\xf4\x98\xebK\x90\xf1\x11W@%\xc9\xa0\xd0\xd4\x12i\xfa\xa6\xc9\xf8\x8c|\xbcT\x19W\xb2\x0cnT\xe3&\xcc\xf4H\x99\x199i\x06\x956\xe3H\x9cQ\x9a\xca\x9e:\xe3\x8a\xf2\n\xb0\xa6\xcf 52N\x17;\x93h\xd0\n\xd8\x9dH\x83D\x85W\x7f\x9e\xe94\xce\xc1\xdb\x12m\xc6N\xb5A'\xdb\xf4K\xb7\x199\xe1\xa6w\xca\x8d\xedrK\x0b7\x98\x84d\x8c\xd4\x9b\xe9b\xa0\xe9b \x0e\xd3\xc5@\xbe\x17\x035\xf3\xc9P\xa9j\xda\x8b\x81T\xf4\xae\xccV;n\xdc\x16\xde\x91EM\x8aZ3\xdfK\xc3\xab\xeb$\xcb\xcf\x8a4\xb4~\xa4;\xde\xeb\x0eOC\xb3\xdd4\x87k\xa3xi\x0f\xca\x86\xaf\xbd\x0f\xbda\xbcLz)=\xba!!NA\\\xd2y\x16\xa2\xae\xf2Q\x91Z\xb9\xf8G\xf12\xf9F\xf3\xf7n^\x1a[[\xa5\xd4\xddLuT\xce\x19\xc1X\xadyj\xc6\xdd\x99_\xe7\x1b\xfd\xbc\x0c\xa3\xe4\xb2\xa2>\xf5N\xd5\xec^\xb3\xef\xb1\xa6\xf8W\xa3\xba\xc2d\xf9\xd8\xe433y%\xb4^\x08\x8b\x8dk\xb3l\x0d^,\xab\xe1i\xf4LYZy\x0b\x1et\x84\x0fl\xb34\xcfQ#\x88`\x1f\xabV \xadmL\x82\xa9\xf9\xcd)\x9c\xcd\x1d\xa4\xcd\xe8\xae=\xa4\xec\x06\xb3\x8b4z\xf0O{V\xf8\xf6\xbc\x17hS\x95\x8dK\xa1\x97Z\xf9\xec#\xa1\xd3\x91h:\x12q\x98\x8eD\xbeG\xa2\xcev\x83\xdd\xd1Z\x07\xa3\xd7k\x1a\x9c\x9f^\x9d\xf0!\xa2\xb7\xac Yt\x0c\xd1\xa6\x03rAr\xd2\xfe\xa2\xc1\xc0+\x92\x9d1j\xdb\xd1\xb0\xaf.I\x9c\xbb\xbe\xd3\x9d/\x1a\xddE\xc9\xca\xfa{NV{\xde\x7f\xc7?\x8b\xd1+\xb2\xd9F\xb4\xb1(\xf0\xa0\xbe\x00\xfc\xff\xd7(\xc0\xfe_\x9b\xfe\xf0\xf4\xc1\x83\x07]r\xc3\xc3\x07\xd5\xdf9y\xf9\xff\xd7\x92\xeb\x1e\xdc\xbe\xdd\xfe\x8f74\n/h:\xb1\xd6\x1f\x87\xb5\x9e\xd6\x17\xe07d\xadWiB\x16\x01\xc9\xf2\xd3\xab\xd7\xc9f\x13\xe6\xbe,\xc6t\xdeY~\xd5^\x14\x94\xc9\xd1\xe4O00\x0dt\xf8\x14\xcc\x8b\xd2\xe5W\x1bZ\x1d\xdf\xda\xbe7\x9d\xfe:\xc3h\xf0\xb1\xe5\xbb\xe6\x02\x81\x81\xa7\xe1ww\xc2n\xf1{\xfb\xe0\xcd\x9b\xd7\x8f\xbf{w\xf8\xe6\xd9\xd3\x87\xef\x1e\xa8S\xd3\x9a\x86\xabu\xdeF^1\xdc\x8f\xbf\x1c\x93\x10\x1f(h,\xa8f\xa0\xad\xc5k}\xf1>[\xd5{*\xff~\xb8X\xa44\xcb\xb4\xbf\xb5NQs\x1a\xac\x1f?\x02\x1a\xb3U^\x00\x11-\xbfi\x90(H\xb2M\x92=\\\xd0\xed\xf9\xd3'AA~]\x9d\x7f\xa5\xe4\xd9\xd7\xed\xea\xfc\xcb\xe3gy\xfc\xeb\xe5\xe2\xeb\xc5\x13\xb2\x0c\x1e/\x1e}\xfb\x0d\xc0/$\n\x17$O\xd2\xbd\x8c\xe3\x82D\x8c\x8a\x0f\x9f]\xed\xe8fK7\xdb\xed\xf3GW\xcf\xd7\xbb\xaf_\x9f_\xa6\xab\xe5\xf3'\xe9\xb3_\x9f\xaf\x9f.\x1f]>\x89\x1fE\xdf\x888\x7f\xf8\xe0\xdbw\x0f\xdf=z\xfd\xe6\xed\x837\x8f\xbf=\xfc\xee\xdb\xd7o\x1f<{\xf2\xe4\xed\xa3\x87\xdf\xbe~\xf5\xee\xf1\xab'\xcf\x9f=}f\x95\x1f\xe1^\xe8v\xfa\xf8\xd9w\xf2\x8f=7\xaaM\xa6U\xe7^Z\xba\xa3W\x97T\xbb\xf9y\xf9\xc9WD\xa3\xde-z\xdc\xfe\x18\xfa\xf5^\x17=\xec\x1d+\x83\xfc4a\xd0cW\xa0\x914\x05\x1b\xba\xc1\x19\x02eZ\xcb\xe0\xa56`\x02\xd7D\xca)h\xb3\x8c\xde\xbf\xfd\xf4\xfa\xe8oo\x1e;\x7f\xa8i\xd7\xd7}\x0f\xf5\x1e\x0f/\xbe>x\xf2\xcb:\xff\xf1\xaf\xeb\xef\x0e_\xbf\xfe\xe5kt\xf4\x1d9M\xb2\xefw\x0f\xc2\xf3w\xff\xfb\xc7\xa3_~\xf8\xdb\xe3_\x7f|\x9f&\xd9\x0fm!\x96\xef\xca\nu\xd7\x97\x1dn?hg?e\xf4KA\xb5o\x13\xfabLkGd\xf0S\xb5X\xcb\xd9n\xbak\x86Z\x0d\xf3\x113\x15\x1b\xb3\xb7\x9d\x1a\xec\xa8\x9e=~\xfa\xa4\x8e\xe9\x8fg\xd0\x1f\x8b\xa0 ]p\xa3\xe0\xf4\xaaa\x87Y\xed\x02\xee\xae?\x0bt\x06\x8di\xa7V\xe2\xd6\xab\xd1\x96\xachG(<\x9a\xb6b!\xb8\x96Q\xb8 \xd1#}\xacN(\xf9U\xd6n3\xae\x93\xaei\x93\xd5Qh\xd9al\xfbL\x0e\xa2e\xa5\xd5\x87\xd1\"Qk\x18\x95\xc5&\xdb\\\x8d$)\x1dKN\x80\xcd\xfeA\\\x82`\x10\xb1\x8e\x85Wo\xd3\xdbn\xd2\xda|\x02\x9c\xdb\x0f\xc6 \xba\x19w\x87\x8c\x97\xb3\x8d\xb2\x14\x05\x8c\x96\xde\x0d\x16\xdbQ@\xd7\x82\x14`Eo\xb1\x01\x9d\xc4w\x91\xdd\x8a\x1b\\#\x13`\xb75\x05\\\xb3\xc5)\xc0hw\n@\xf0\xad\x8b|\xa0\xd0Xx\x02AA\xe8m\x95\np\x16 \xfa\x8ea\x80\x9d*\xc0e\xad\n@\x0c\xcbb\xb9\n0\xdb\xaf\x02\x86\xf4\xd1\xb6h\x05\xf4\xdc\x84:6\xae\x00\xeb\xf8L\xf6.\xa2\xa9\xdd\xf6\x15\xa0\xb7\x80\x05\xe0\x91\xb7\xada\xd9\xbec\x13\xcb\xbf\x0f\xdbt-\xe2\xea\x16Vk!0\x82Q\x1cr\xd6\xc2\xf01_\x9cJ\x0b\xa63\xf6\xeeX\x1b6\x8a\x87q\xd8\x18p\xc3\xf6\xd0\x12LO\xa4\x8eua \x86n\xab4-\xe8\x98G\x1d\xa3]\x80\xe5R\xbd\x0d`\xde\xf9\xb1xk\xbb|so\xd7 \xd0\xec\xb5\x1eKd\xf5)\xd9\x8e\xab\x9d]\xf9\x1a\xf7b\xed\x0el\xe4\x013\x07\xe8\xf7X\xeb\"\xf9\xef\xa7\x06\xe9\xc6\xf5\xd2s\xc7\xb4\xed\x93\xee\xa5m\xeeW\xfa\x9d\x10\x8b\xe5U\x94\x04\xe7Go\xd0\xfa\xca\xc7\xff\xef\x11\x86\xe0\x9d\x914\xef\x9c\x94QBbLl\xd4\x1c<\xcb\xd1\xd5\x03\x88\xdd\x13\xb4\x9b~\x1e\xb3\xe3D\xfe\x81\x12\x9fz\xa0`M\xc2\xb8q\x9d\xb4\x9d\xd8\"\xd2\xb5.\xe6\xf7\x1e\xa9\xa5\xf2\x8a\x9b(\xb1\xc8\xc3\x8d9z\xd8js\xfb\xd1\x83\x87\xdf\xde{\xf8\xe8\xde\xe3\x07\xa7\x0f\x9e\xbex\xfa\xf8\xc5\x83\xe7\xb3G\xdf}\xfb\x97\x07\x0f_T\x86G\\l\xce4>\x10\xd3@\xd4\xbaD$\xcb\xcf\xe6\x8cr\x1a*\xa0\xd8b\xcf\xabZv\xde\xe4[\xe8\xa9\xeb\xba<\x0c6>\x06\x13/\x83\xc1#\x84Ui\x9e\x14\x10\x8e?\x8f\xf5}\xfc\xb4\xbe\xc0\x01O\xb3:\xdb\xa3ZY\x90\x9c\xec\x13\xff\x85\n]g\xfb\xec\x85\xe7\x8b_OWA\x12g4\xce\x8a\xbdvB\xb6\xdb}\xa2\xe7\xbc%\xb3\xa3\xf7\xd9\x0f\xbd\x08\x17l\xf3\xddg\x1fLg$\x19M\xcfH=7\xc2\xd8\x0d6G\x02\xba\xbb\x07>_\x83\xc1\x05M\xb3\xbe\xe5\x15\\\xaf\xfb\xea\xe6\x87u5G\xb6[\xdf\xf6\x0f\xd4V\x8c\xde\x84\xd7\xb5=[\xdbD\xdf\x0c\xb4\xfb7\xa0\x06\xd9\xdd\xc7\xc1\xe0]w\x9b8uS\xb7\xb9\xaf\x03j,\xb8\xfd\x1dt{<\xa0\x06X_P\xc3~\x0f\xfd\xb6\xd3k\xdc\x01\x15h\xec\x00\xb0\x0d\x1e\x9c\xce\x0b\x83M\x00.\xbb\x00l\xb6\x01\x18\xa9\x03.\n\xc1@*il\x05@\xf1\xc9\xe3\xa7mF\xd1\xda\x0d\x80\xe2\xea\x1e\x03\xd7\xd8\x10{\xeb\xcb\xb8\xc9\xef\xadG\xbbm\xb1\xb7nMv\xc6\xde:\xec\xda\x1c{\xeb\xcab\x7f\xec\xadO\x83-\xb2\xb7\xfe\xccv\x89\xb5K\x1f\xfb\x04\x86\xda(\xa0\xb3S\xa0\xdf\x96\xa2\xb1Y\xc0\xa51\xf5\xb6\x0b\xe8\xec\x17@\xe3\x1a\x9aX\xd0\xc0\xaf\xb8f8\xa6\x9a^\xeee1M{\x7f\xa3\xe9\x1fl\xef\xdf\xa6T\xf0\x86VO\xec7\x8eP\xeemzU%\xc0:\xfb\nC\x18/h'A\xc5\xd9\xbenTk\"r\xfa\xe4\x19\x18\x885M\n\xfd\x8d\xa4C\x90\xb2sD\x96\x93\x8dF{y F\x1f,jx\x8d\xfd\x19%\xa1\xec\xefQ\xe7G\xbd\xb2\x11`\x95Z\x97\xdc\xda\x04\xccI \x18(d\x15\x18\x14\x92\x00\xc7\x04\x011I\xb0\xab(\xf9\x81KQ \xb0\xaa+\x016\x9a\x02\x8e\xae0\nm\x11Y9n\xf67d\xcc|[\x9c\xbe\xfe\xf6\xc9\xdf\xa2\xf3\xf8\xcb\x7f\xfe\xc7\xdb\xcb\xd5\xb7\xbf\xc4\xcf\xde\x7f\xf7a\xf3\xed\xbb\xe2\xbf\x1e\xbc\xfd\xf0d\xfe\xebE\xf1\xeb\xb3\xf4\xf2\x87\x87\x9b\xd3O\x7fMO\x8a\xf7\xef\xff\xeb\xe2\xf0\xf0\xcb\xe9\xf3_~\xfdyu\xfc\xe0\xe4\xf0\xfe\xe9\x9b\xed\xb3\xe2\xfe\xf3G\x87_\xd2\xffZ\xfe\xef\xbf~\xdc\xbe\xfa\xdb\xcb\x97\xca\xed\xe1W\xe9!$dC\xbb%\xd1\xa8\xdd\xbc\xed:167\xa3\x00\xa3\x1b\x05\\\xc4v\xb8S\xc0\xa2s\xadL\xabu\xad\x00\xe8\xdc+\x80\x1e\xa3\x9f6\xd4\xbaZ\x00=\xf0\xb6\x8cY\xdc.\xe0R\x15v%\xf1\x1b\x19\x1a\n,\x1a\xd0\xa9\xff\xdc\xda\xcf\xa1\xfbP\x9a\xcf\xa9\xf7\xecZ\xcfIE\x18\x81\x92\x06\x97\x0d\xb8\xe6\xa8w\xdd\x80\xd3}\x03\xae\x89\x0d\x9d\x90\xc1\x95\x03\xfb\xee\xd7\xea_\x81}\xf7\xeev\xf1\xc0\xbe\x87`s\xf7\xc0\xbe;\xd7\xbb~`\xdf\xdd:\xdc@\xb0\xef\xfe-.!\xd8w\xdfv\xf7\x10\xb8\xba\xf7u\x13Aw\xd7\xf7w\x15\x81\xc9]\x04\xae]\xc3\xbec\x18\\G\xe0\"\x02\x80\xcd\x85\x04&7\x12x\xe1\xad\xa3\x9d|0\x8d\xa6\x7f \x1fL\x8b\x05'K~\xb2\xe4k0Y\xf2\xfa\x1f\x11\x82\x0e.a\x87\xc9\x92\xdf\x8b\xbe\x9f,\xf9\xdfh\x08\x93%\x7f\xfd\xfdO\x96\xfcd\xc9;\xf1\xd6\xd1\x1a\xb2l\xbc\x02m\x9d>\xbb\xc1b\x18 \xb36x\x0c\xfd,\xcd\xc9\x06j\xc2d\x03)0\x05\xa1\xc1\xc2\xc5\xb0\xc7k\x91P\x81i\xc0P\x07\x11\xa0\x06\x0c\x9e\xfaa\xc6Pzk\x0eV\xc3H=\x18\x03\xd70R\x07\xd6 6\xf8v\xe2u\xe8\x13\xc0\xf1[\xfb\xb6J[\xd9w7\xb0\x0d\x8e\xe06\xb8\xb9\x16\x10\x9c\x0bN\x81F\x11\x11F\x10\xea\n\xacAo\xc0M\x1c\x90\x93\x07\xb7\xda\x94\x1f\xb9\x97S\x81S\x85\np\xd1\x1d\xf0\xb4\x87\xd1\xe8\x7f]WJ\xec1H\xfe\x86Ft\xc5\x9f\x8c\x90\xffJ\xd2\x13zIR)G\x1d\xe6\xe9\xb2\x89E\x9fk\xa7\xefc\x1a\xb7Lb\xef;-\x81\xdflPM\x07\x0c{\xde\xd0\xdb\x88\xb4E\xdb\x96\xc5/\xe7\xd5-\xd6\xd6\x17jcp\xc9\x02\xedr\x1dO\x99\xa4\x8a\xc5\xcc\xd0\xab\x99\xd6\xbf\x87=\x91\xcbi\x02X\xa6\xeb\xc3>\x02\xc6`\"\x01mV\x12`6\xa2\xc6\x7f\x91\xc7rk\x90S\xd7X\x98N\x80\xedv <\xf6\xda=\x01\xda\x0b\xc7\xc6e\xa5\x9b$y\xafHFO\xe8\x17\xb4\xac-S\xfc\x1d\xba\xd2'\xb0zN\xd6\xe9\xb3\xab\xf5:\x7f\x9an\xbe\\\xd0\xf8\xd9\xa3\xef\xe2\xf3\xe8**\xbe\xee.\xbe\xfb\xfa\xfc\xd7/\xbf\x06\x9b\xa0l\xde\x10\x96\x8f4\xe6\x0f\xaa\n!\x81$\x85\x1f\xe9nN2\n1\xd9P\xc8\x13X\xd1\x98\xa6$\xa7@ OI\x9c\x91\x80\xb5\x94\xd8\x9c\x97>\xd4F{\xeb#\x8ds\xb8\x08 \xbc\xe6\xe3\x86_\x92\x1dY\xd1\x14\xfe\xbfO\x0f\x1e\xcah\xb4<\xe3\xe6\xe8\xb5D\xcbo\x9a\xeb\xe5\x82?ze\xb2X\xff\xb8s?.\xe6Q\x18\xfcH\xf1\xe2\xcc?\xb1\xf1\xae\xfd\xdd\xda\x8f\xe1*\x0e\xe3\x95\x97\xe8\x08\xc7&b{\xe4)\x93g\xc9r\x99Q\xfb\x87\xe2\xb8}V\xc4y\xd8\x89\xe5\xb76\xdc,\xa3\x0bQ\x8d\x95\x99\x0ehe\x8bc\x92\x92\xcdk~Z\xc0O\xae\x98g[\x82\x0f\xd52&\xa8~\xf0\xf0d\xbc'W\xa5\xf6\xca\xaa\xce=0\xdc\xbem[\xe2r\x96\x1f\x8b\xed6\xf2`\xa8?WB\x85\xd0\xd13R\xe4\xeb\xd9\xc5\xc39\xcd\xc9\xc3\x19\xe7\x1b\xbc\x05\xca\xce\xa4\x1b\xbaI\xd8\xc14%ANS\xd7n\xb2L\xd2\x0d\xc9_@\x11\xc6\xf93\x95\xf7\x97_\x9de\xe1\xeaL\xfb\x18\x1e\xba\xfdWz\x16$Y~\xb6\xa5\xe9\xd9|\xd7\x8ddc\x10\xb1Q\\\xd04\\\xee\x04.\xbax\xf4\xf4\xe9\xc3\xe7c\xa0\xca\xd4c\x11\xfe\xc8\x1a;\xb0X!\xe0\x16\x12\xcd _S\xd8\xb2?QF|\x1e`g\x7fb\x8b\n\x9bdQDtfXj~w\xcf\xa1H\xef8\xa1\xd96\x893\xbc\xae\x90i!F\xc9\x13\xa0\x97\x02\xf6\xe9Y\x91j\x9fW\xd00\xae9\xb5\x80\xc1!|:\xf9\xe9~J\xb3\xa4H\x03\x95k\xb3&9\x14q\xf8\xa5\xa0\xd1N:\xf3\x96\xa1$\x16\xeb\x07\x92%\xfbw\x0bUF\xd3\x90D\xe1W\xba\xf8\xa6\xf5\xcb6M\xf2$H\"\x98\x17\xcb%MaC\xb3\x8c\xac\xe8\x0cN\xd7a&\xc7\x0c\x9b\"\xcb\x81\xfb\xf5\xc2\x18H\x0e\x11%Y\xde\xc6\x94\xc4\x14n\xdd\xbf\x05\xa5\xbc0\x1c\x94\xd7\xaa@FW\x1b\x1a\xe7rpl^\xb73\xd8\x12\xb6\x90E\x96\xb7\x10\xa5t\x9b\xd2\x8c\xc6\x9d\x1eX\xd3e\x11E;\xf8R\x90\x88\xcd{!\xa8\"\xd1\xf2\xf9\xdf!\x19\x84q\xbb\xe9g\xd6\xd9\xfdU\x92\xac\":\xe3s\x9e\x17\xcb\xd9\x9b\"\xe5V\xf3\xe7\xbbb\xac\x1cY\xb6N\x8ah\x01s\nl\xb2-<\x01\x89\x938\x0cH\xc4\x99\xb9\xdd\xcb\x1d:[\xcd\x0e\x18y\xd8\xe9\x10n\xcdnA\x98A\x9c\xe4\x8c\xa9\xe86\xa7\x8b\xbb\xb3o\xda\x8d\x8eb\xd82\x82\x85\x01=\x80\x9c2 (\xb2\x82\xb0i\x8a\n\x8cm\x18\xb1\xb1\xe4 \x9f\xe4<\x8cI\xba\x03\x12E|\xbe\xed\x9cE\xce \xf9\x9a\xee\xda\xdd\xd0\xab-\x0dr\x08s\xc8\x13(2>;\x86\x8f-+\xbd\xe2Ks\x18\xeff\xf0CrI/hz\xc0\xe5\xed\xd3\xc9O\x19\\\xae\xc3`\xdd\xc2\xc6\x1006k\xf3Y\xb0\xa6\x1b\n\x9f\xd7y\xbe\xfd| \xfe7\xfb|\x00I\nq\"\x7f=\xe0\x9c\x12\x90X\x86G\xf8L3\x9aC\xb1\xed\x90\x9b\xcd\xb0\xd3\x07M/h*&\xba!\xdbL,;\x1fi\x9e(\xfe\x85\xda1\x0bxvN\x14%\x97\xd9\x8b\x0e\xf5\xff\x1d\x8e\x96\xd5\xd8\xd8rm\xd3\xe4\"\\\xd0E9|\xf6G\x92e\xc5\x86.f\xdd\xe6\x871\xfcpzz\x0c\xdf\xbf=\x85$V\xec-Df\x17\xd2h\x01\x04\xfe\xdef\xbc\xd3\xdd\x96\xfe\xe3\xef\xffh!\x93{>[\x19\xb9\xcaBcr\xfam\xd3dQ\x04\x14H\x0c4M\x93t\xd6\x1d\xc9v\x1b\x85\x01\x91sN)\xe3\x91\xe4\x92.\x18Y\x02\x120YL\x92\xf3b+\x9fl\xcb`N2\xba\x90\x83\xee\x0c\xe5\xd3\xc9O\xbc\xdf5\xb9\xe0K\xbd\xa9q\xe3B\xb0#Q\xc3d\xff\xbeH\xc2\x05\x90\xb8[\x0e$:\xe5\x02\x96\xd2e\x92\xd2\x03\xd5\x8ca#y8\x0f\xa30\xdfAL\xe9\x82/\xe1\x9c\x02W\x00\xe9\x05]t\xb0%1\x08O1\xff\x94K\xc0\x0c\xee|\xca\xa8*`d\xf3e\x0c\xc1dYp\x04\x89\xc9\xaa;\xbfyJ\xb9\x8d\xa7\xd0\xcd\xee\xb6\xd7\xf6\xe7$\xa7/ gzp)\x93\xb6\x08\x1f\xa9\x94\xe9\xa0HS\x1a\xe7\xd1\x0e\xc8\x05 #2\x8f\x94P\xb55\xe3r\x19\x06!\x89\xb4\xbaw^,!\xa5L\xa3\xd2\x03 \xf1\x82I\xa8\xec\x80g\x8d\xf1m\xaf\xe4\xf09]\x851\xb3\xedE\xfa\x98F\\f\x82\xd7\xc86\xccfA\xb2\xe9\xea\x9b\x8f\x9c\xd33H\xf2\xb5\x10\xa3\xb8-\xafpGn\xb5t\xb3\xcdwR4\xee\xc2\x86\x1d\x0d`\xde\x11H>L6\x1c\x08\x99\x11\xc6\x14=gB\xc8\xb64\x08\x97a\x00\x19\xdd\x908\x0f\x83\xac\xce\xb4\x9a\xa7\xa4\x8c\x1b\xa5\xb2\x1c\x98\xf1\xd3\xf8\xc1\xbe\x83\xbegB8\xa7@\x84\x9b\xa7\xb6\x0dv\xf6=\xb9\x85\x90yrA\xd5\xc0;\xec\xc7\xe9\xfb\x8d\xbb\xef\xcf\x87\xf1\xee\xb3\xda03&\xb2$\x9d\x87y\xca\x98\xde2\x06\xa5\xbbH\x944\xe6\xcfiK\xeadg\x1a\x86+@1\x86y\xd7\x00\xa8\xf7\xa3\xf6\xf4\x06+\x1c+\xe6\x8b\xc29\x1f\x98\xd4{\x19d\xc5v\x9b\xa4|\x9f\xd8\x92\xe0\xfc~\x11\xb3\xffa\xbb\x83X\xb3\xac\xcb\xe5\xed\xcd0YB\x91\x0b\xb1V\xa2\xc3\xf3\x86\xc9b\x11\n9*\xf3\x1d\xd9\xf0\xf2u\xb2\xc8\xd4\xc0Y?\x82\xd0u\x8co\x85\x85\x0f\x0f\x99\x99\x18\x9csI\x91\x03#%\xe1\xc2\x18^\xff\xe5/\x1d%\xfd.I`\x99$\xf0\x12f\xb3\xd9\x7fo\xfd\xc8\xba#\xf1\xae\xfdg\x12\xeff\xac\xa3wi\xb2\xb9\xb3L\x92\xbb\xed\x0ff\xb3\xb6\x06\x0e\x97p\x875\xfb\xc4\x87u\x9a\xdc\xf97\xd6\xee.\xfc\xb3\xa3{\xbam\xff\xa5\x9b\xeb#\xc7\\\xffJ.H\xaf\xc9\xc2K\xbe\xd73\x8c\x9es\x0b\xb3;\xef\x92d\x16D$\xcb\xb4S\x13]\xb3O\xc5\x88k\x9f\xb7{i\xcc\xb9\x9c\xf4c\xc7\xa4\x8fw\xf9:\x89;\xd3\x16\xfd\xbeK\x92;\xb3\xd9\xecnw1\xc5\x94\xefh~\xe1\xcb\xcc\xc9\x80\xa1\x02kp$\x88\xf0\xe6\xed\xc7\xd7'G\xc7\xa7\x1fN\xee\xb6\x8f\xaa\x02\xb1`\x04\x1dj\x81\\7\xfd'\x8e\xe9\x7f\x9f\xb4g\xce\xa7\xfe\xe2%\xfc\xdbv>{\x97$\xff\x9c\xcdf\xffj\x7fB\xe2\xdd\x013\x1b\xd8w[\xb1i\xbe'i\xb6&\x11#\x8an\x80\xdd\xc9\xb7\xfb\xe9t\x12.[]|\x8a7U'|\x08\x9c\xd9\xf8W\xff\xed%\xc4a\xa4a ]\xcf\x0dN9\xe5\xc7\xc2\xe0\xbc\xd4\x1b\xca`\x83\xf9\xae\xdaR\x95V\xbb\x0c\xa3\x88\xfd\xb0\xa0KRD|O\xad#\xbb\xad\xd92\xef\xb33\xc6\x8c\xff\xc0\x8c\x88\xdb\xcc~,\xb5+\xd3\xbclm\xd8\x1f\xc4\xfa\xd4\xd1\x95\xaa,\x8ev\xcaF\xee\x1cYJ\xf3\x04\xc82\xa7b\xa7\xe5\xa7\xa4\xdb\xf7o\xd7\x91I\x03]u+,r\xe9\xe9\x80[\xcb$\x99\xcdI\xca\x07|u\x7f7\xfbzK\xccU\xd8\x9cm\xc3\x99ww\x8b}\xc5\xd4j\xed\x87\xbf~\xfc\xf0s\xfd\xbf_\xbe|\xf9\xb2Mm\xf6Mu*\x13{{\xc2DAnt\xc2j-2\xb9\x0b\xa5tUD$\xadc\xe96f\x1f.h\xb5I\x1d\x00\xdd\xcc\xe9bQmW\x07r\xdfk\x9c\xe5j\x1b\xc8\x92O\xf4\xf3\xffbS\xfd,\x0e)\xd5\x96['\xdcL \xd7\x8b\x8e\x01F\x82s&W\x95y\xbe\x0c#\xda\xd6SJ\xfa\x8ei\x9a%\xb1\x86e\xe5)y\x19\xa6Y~\xc6)\xfd\x12\x1e\xb6\xb1\x94\x9f\xf1\xcb\x1b\xe4W\x8f\xec:\x11@\xd3\xdb->\xe3[/\xe0\x96\x8ew\x9bS\x99\x891\xdf:\xe8b\xe1\xa3\xfd\x99l\x18\xa6\xff!\x86\xf6?5\x9f\xb1\xd1\xb6\xbe\xb2\x0d\xf9h)\x0d\xc7\xe6Z\x8a\xb5\x083\xb8\xa4Qt\xef\x86\x7f\xfc\xfd\x1fw;\x0c\xd8\x7fu\x9b\xc8u\x0b\xcc\xa7\xcb\x10=\x9c=z\xf8(\xbb\xd5Y60\xda\xb0:\xff\x19[=!\xdd\xf2\xbf\xf9\x92*\xa7\x1coq_6\x81\x93\xe3\xd7\x12\x93P\x88\x18?]\xd6\xd7Q\xb7\xe7 Z\xaeu\xe9Y\xbd\xd1\xf6C\xc9\xa8\x8e=\x9bkoL\xe7\xde\x88\xee=\x8b\x83o\x90\x8bo<'\x9f\xcb\xcd\xd7\xd3\xd17\xb6\xab\xcf\xe2\xec\x1b\xdb\xddgt\xf8\x0dv\xf9u\xf0\x11\xad\xd3ol\xb7\xdf`\xc7\xdf\xe8\xae\xbfA\xce\xbf\xf1\xdd\x7f#:\x00\xc7v\x01\x8e\xe8\x04\xc4\xb8\x01Gt\x04\x9a]\x81\xc3\x9c\x81\x1dd:\xe7 \xd2=8\xd4A\xd8A\xd7u\x18\xf6v\x19\x1a\xde\x9f\xb7l\xc5F\xc7\xa1{\x97\xee\xe9<\xec*.\xe5Ll\xb9\x0f\xed#\x18\xd9\x85\xa8s\"\x8e\xe2F\x1c\xd9\x91\xd8u%\x0ev&6p\xe5\x1d\xc7\xe20\xd7\xa2\xc3\xdfft/\"\x1c\x8cZO\x88\x87\x93Q\xdf\xfe_\xfa\xb9\xf7r5b'\xefr7\xdag\xeat9z9\x1d\xbbG\xec\x81\x8eG\x87\xeb\xd1\xe6|\xb4\xbb\x1f\x8dT\xc1\xba \xddN\xc8\xae\x1br\x90#\x12\xe5\x8a\xec\xe3\x8c\xd4\x93\xc2\xe9\x90\x1c\xcd%i\xe8\xbf\xc5I\xa3:&GwM\x8e\xec\x9c\x1c\xd7=iqPv]\x94]'\xe5Xn\xca\x11\x1d\x95c\xbb*\xb1\xceJ\x84\xbb\x12\xed\xb0\xc4\xb9,5NK\x9dc\x0b\xef\xda\xb2;.\xd1\xaeK\x94\xf3\xb23\xf81\x1d\x98\xa3\xbb0\xc7tb\x8e\xe9\xc6\x1c\xb6\xdeNW\xa6\xdb\x99\xa9\xdc\x99\x0c\xc4u'\xa5w\x90\x1f\x85\xf9\x92^\x85Y\xce +\x7f\x91-\xb6d\x15\xc6\xb5\xa2\x14h[\xe6\xd5\x07\xad\xd4\xc4\xf2\xcfR\x15*\xd7h\xb5Uh}\x8dzO#\xbf\xaa\xbe\x91'\x0c\xbd2\"\xe4\xf4\xffo\xfb@\xa3\xf0+?.\xfb\xa7L~;\x1f\x1b\xdc\xc3\x07\xd5\xefbIc*\xa2\x8c5\x0c) \xe5\xf1vN2z&\xa6\x91'\xccNK\xd2\x05;\xd5&@\xd9\x99\xb76\xd7\x92\xf8\xb731\xef:\xc2\x87\x92\x14/\xe1\xe1\xff)\xbb\xafp\xd7?\xe5\xa1A%Z\xb5\xee\x93\xa5 _\x15\x0b\xe35\xbb\x14H\xd55\xfb\xe86\xfb\xa8~\x9fE\xdb\x97_\xf6\xff\x12\x9e\xb1\x13E\x91\xbd\x80\x87\xc0Z\xb1\xe1=\xf8?\xcfZ\xcbD\xa2\x90d\xde\xf5\xcaZVR\xa6\xb5\xc0\xc8E\x1f\xa20\xe3\xe3\x96L\xa4~S\xda\xbf\xc6H.\x89\xe6\x14\xa8\xad9\x91R\xddvQ\x13\x81\xb4.\x02J{\x15\x92\x88r\xe9\xc3\xc0.p\xefiN\x16D\xbd\xd9\x8d\x927\xdcE\x89|Pgl4\xfd\xe8\x8e\xceN\xf0-\xbas\x05=\x06\xe9\x87\x0e\xb6&#\n\xe8j\x0d\x01z\xdd!@\xafA\x04\xb8f4\\\x9b\x08\x18\xa8S\xf4\x94\xeev\xe3\xa1i\x04\x0c\xd47\x1d|B\xff\x18\"\x88\xbe\xbaG@G\x03 \xd0\xc9\x83\x00\xeb\xf5\xe7Z\xbe\x1eA3 0\x9bP\x83\xb4\x94B\x8e\xd3U\x8d9\xd5tI[0\xd5\x0c\xeb{\x97\xb8\x87XL.HB5\x00\xc6\x19>\x86BC\x92\xf8]\xdf\xad\xbe\xf9\xdf\x04\xab\xdd\xa9\xb2i\xd8/\x15\x998W*\x9e\xa9\xe1{ \x0fJ\x16Y\x84\xd96\"\xae\xf2h\xf3\xb2\xc8\xf6\x10\xc6\x8b0 \xb9\xb4\xe5\xb3b\xb5\xa2\x19\xb3\xb8\xa4\xa0\xb2\xc5)\x87\xd9m.\xafg\x8eB6?54\xa6\xf0\x1c\xe3\x92kt\x9b\xeb\xc6\xfaa\xa2\x91\xb4\xc4\xad\xed;t\xa5.!\x87C&$\xe5\xe5\xab\xbb\xcd<\xb1W\xc8\xdb\x16G4Wg0\xd1\x97\xfc\x9bJ.\xca\xd6\xc9e\x0cI\x0c\xf4J\xe5M\xf0\xd1\x1c\x9e~x\x7fWd\x83\xd5\x10\x06MO\xb6\\\xd5\x8c\xc7\x04D'\x92h\x8aNE\x1a\xf6\x1e\xfd\xa7\x93#\x9e=\x02\x8b$(x\x12\xd9\x9d\x84iTH\x96\xcb{\xfc\x8a\xf7\xbbb\xf1\xaaPx\xe9W\xaf\xa1 c\xb1G\xb0\xb3\x19|\x90IF\xb5\xf1\xb5^\x02\xf4\x1f\xe4\x0f$[\x0b\xb5\x92\xad\xc9\xa3\xa7\xcf\xf8\xbb2<\xbcP\x8d|\x9b\xb0\xed\x8b\x9fc>\x9d\x1c\xb1\x93\xc3\xedL\xa4:4\x1ci\xe2t\xcegU\xa73'\xacB\xb5\x08\x17\xf1\xed\\&\xa5\xb4g\xa4\x17\x06e\xcc \x94\x93lA06\x92g\xd9|F\xe3\xc5\x19\x8d\xc9\\s\xd3\xe2oi\xfat\x86T\xff\xbe}\x13\xbc\x80\xd2\xc5\xda\xf9\xd5fs|\xa4\xf1\xe2\xad\xe8L\xe4\xa9\x05\xe2\xe8-\xcd\x05\xd2\xa0\x90\xbcn\x12\xee\\\xae)\xcf\xb6!\xdd)B\x9857b\x86\x80\xb5\xaeT\xa8\x08!\x9e\xd9h\xdf\x9e\x84nr\x8di\xe1\x8a\xf1\x19\xabt\x8b\xf1\x1b\x0c$\xdc\x9fQ\xf4J\x9c\x8a\xfd=\x93\xf28}\xa3,i\xaf\x1b*l6\xc5\x08\x8e\x99\xb1]3X\xe7Lgjj\xa1\xd4^T\xfe7S\x93\x910\x8c\x994\x94\x1b\xec\x14z\x99B/\xd7\x10z\xe9\xea\x1e\x8c\xc7\xba\xd6Lb;9~\xad\x06i\xf7as\x04\xb2q_u\xd7\xd6v(N\xd6(1\xc3\xaaO>e\x0d\xa7\xb4\x96\x0c\xc3%\xb2\x89-D\xd7e\x0d~BR\xf6\x9a7\x83l\x1a^+m#}\xc3\xf6\xec\xdd\x8bo\xf0d\x81a\x0f\x06\xd3\xd9\xdd\xb0\x17\x83e?\x06\xd3\x9e\x0c6U\xa6\xda\xd9}B0\xc0\xd3\xa5E\xa6\xf1\x8eW`\xf2xA9\x11\xbd\xd7\x0b\x1c\x9e/@\xcet,\x0f\x18\xf4\xf3\x82i\xf1X\xbd\xed\x15x{\xc3`\xa0GL\x8b\xb0\xf4\xca\x1b\xbcb\xd0\xdb3\x06f\xef\x18XdL\x80\xf1\x9de\xa7|\x8c\xe6-\x03\x87u\x0bcx\xcd\xc0\xdbs\x060\xb2\xf7\x0c:\x1e4\xb0Q\xd9.\x95C\xbci-T5\xae{\xd0`\xad\x8eW\x0d\xd0\xe3\xed,\xe1@\x0f\x1b8\xbcl\xd0\xf1\xb4\x81m\xaccx\xdc@\xe3u\xb3vj_\xd0\xc1\x1e\xb8\x16>^\x9d\x19\xb4\xf3I1\x9e8h{\xe3\xa0\xff\xacF\xf2\xcc\x81\xcb;\x07Z\x0f\x1d\x0c\x1a\xf8 o]\x0b]\x9e\x98\xc2:\x904.\xa4A3\x1c\xd1\x91\x84p%\x99\x9cIC\xa70\xa6K\xc9\xe5T\xf2u+\xd9\xc5\xb2\x9fkI\xeb\\\xeat\xd5\xa0\x95\xb2r\xab\x1b`\xf8y\x9b\xcbo}\xe1\x84*\x95 !)]\x85YN\xd3\x06\x91\xc4\x0b\xbb\xd3ar:L^\xf3a\xb2s\xc4\xf3t\x8ff=\xfd\xa3#\x15\xedzp\xb3>Y\x10,\x86\xe6o\x1f\xd97$qV\xed\xf4\x89\x9c`M\xe6\x04\x84\xfe\x1f3\xa9\x13\xca\xb3h;\xb1\x13t\xc9\x9d\xe2s[\x82'X\xa7o\x9axc\xca\xbd\x92=\xad\xd2\xd4\xaa\x10\xaec\xee\x8a\x12WZ\xec\x88qu\x9f\xf5Qgn>\x02\xab\xe8\x88\x97\xd0>,\xbd\x85\xa7\xed\xdd\xf6\x10\x1e\x0d\xfb\x1a\x18w\xca\xb3\xd20G{\xc90\x89V\xaa\x8d_\xa6\xd5)\xdb2DSo\xfe\xc8jO\xec\x81A/\x0e\xf7\xd8MY\xc7\npl\x05\x95\xb9!\x16H1\x8f\xfc/y\x98\xe3y\xc6\xb2\xc1d?N\xf6\xe3H\xf6c{\xa0&%\x83\xd1h\xb5f\x12[\xc7f4\xa8\xb6\x9a9\x82\xd6f-M\xa3Y\xa5\xb1*GJ\xc6\x1ch5UV\x92@\xd70\x8dJ\xb2dt\x96\xd3xA\xd3M\x18\xe7%\x85\xbe\xa7\xf9\xab( \xce_\xed~\xe0/\xdaz+\x7f\xfe\x18\xedY\xd8\xa1\x06J\xd2=RY\x0cR\xbe%)3\xf7\xf2\xb35%\x8b\xfac\xb8`\xb3\xb9\xcd\x16\xb7FN\xa1\xc4d\x8aC\xd8b\x10:\x07\x8b\xc3zw)\xb4c\x92\xe6\x19\xcd\x7f\xe03\xfe\xa6\xf5#_\xcd\xa37\xf5\xd5\xe9\xb74\xe3\xd0S\xde3\xad\xa1\x80\x18\xae\xf0\x9c\xf0ar\xcf\x87\x81R\xbdBe\xad\xc9\xd7\xc1J\x7f\xb0\xeb`\x01d\xbb\xdd\x0fj\xd7\x11\x8b\x19%qF\xe3\xac\xc8 [a\x07\x88\x9d\\\xfd9-\"\x19~\xd8\xa6I@\xb3L\\\x93\xc7\xe9\xa1\xc1'\xf7l\xfe3w3\x1e\xe8b6a\x1cD\x85\xb8p/\x8aj\x1f\x03?\xc5\x97)\x1aYy\xb5\xa6\x18\x85\xe15\x06N@u\x0d\xfbm\xcd\xf9\x8e?\xb4\x9dS\xc8S\x12g\xe2\x8e\xbe\x0d \xd6aL\xdbQ\n>\x8a\x86\x06R`Y\x8a\xf6\xfb\xdd\x88&v9\xcf\xc3\xae\xa3\x1d\x89nArz\x8f\xb5o}\xc1o\x93\xec\xeaW\x05\x03$C\xaf\x94\xc05`\xb0)'\x01V}\xac\xc0:rp\x8e\x1e\xccz\xba\xfc\xd9\xaa\xaf\x15\xb8c\xc76R\x01\x86\\\xe0&\x99C\xaf\xb7>j\xeaw\x05\x9cU\x82d\xb3 s\xadK\x1f\xc9\x89\xda\x11\xca\x8e\x19Z!\xcfB[3\xb1o}\xcb\xfe4r\xf7\x17\xe5#\xf1##n\xcfk\x99\xf2p\x1bez \x92\"\xdf\x16y\xf5\xb7mJ/\xb4\xea\x93\x1f%\xf66\xc6R\xa3\x8f\x8c\x97l\xb7#c\xe4\xfc'\xcf\x1a#\xa3\xa6\x17\xe1\x82\xc6\x01\x1d\x19m\xb9\xfe\xd5\xb6\xa9\xb1?\x98\"J2\x9a\x9e\x192^\xfb\xf6\xdf\xd8\xe4\x85\xc07N\xd4U\xc6#\x0f\x9c\x9d\x96\x86\xbb\x14>\xa1]\x1b\xae\xcfF\xa1\x1b\xf4\xb3\xd6\xf2+\xe3\x0c\xf5\xf9\x14\xc6\\\n\x87b\xb4.\x8c\xdb\x02:\xbd\x92\x89\xc2\xeaN`nL\x087\x880\x1b\xfe\x97 \xd4L\x9cj\xfe\xf2Ps\x1d\xbdr\xcc\xf0\xd7\x88\xa2\x88M\x1e\xd64\xa5\xfc\"\\.\xd33\x80\xff\xa0\xb7S\n\xbf\x16Y\x0ed\x95R\xca\xec\x1f\xe3K0\"\xb5\x87\xdf\xba\xac\xed\x8f\x07\x9c7\x94\xc4r\xf4b\x88\x87\xdb-\x8f\x99.\x12*^0\x11\x96\x16\x0fA\xb3\x03\xf1U+\xa4/\xf9\xf6\x0d3\xbb\x1a\x89\xaa\x19\x15I\x1d\xccb\"\xf2\xf9\x07\x89k\xd10\xf2j\xe8\x94t\x0df\x1d=\"\x18\xc6?F\x13\xc1e ,\na\\\xd2\xb3\x8b$\xa7g\xe6\xc1 p\x1a$\xee\x1e\x19\xf0\xbe\x88\xf9wTG\x80\xec\x0c\x14:\xeb\x17NI\xac\x03\x8d\x0bCja\x1d\xee\xc1\xc7\xa3\xef\x7f~\xfb\xe6\xec\xfd\xc7\xef\xcfN\xff\xf3\xf8\xed\xd9\xa7\x9f\x7f\xfc\xf9\xc3\x7f\xfc\xdc\xa3\xe5\xf1\xc9\xdb_>\x9c\xbe\xed\xd7\xf2\xf5\x87\xf7\xef\x8fN{\xb5\xfdp\xfc\xe1\xe3\xe1O\x8e\xa62\x9a\xf4\xa2\xe7|\xddj\xac \x1f\xc3UL\x17\xef\xb3\xd5\xa9\xbcB]\xbc\xf0\xc5\x13\xcb\xf8O\xf5W%\xf4\n\xa8 \xe5\xce\xa6UF-0\xae\xcd\x0b\xf8%\xc95o\xaa\xa10\x08:\xbf\x80c\xbe\x8f\x92\xc8\x8e\xc6t(k\x82\x07Cc\x0c|\x01iR\xc4\xdaxi\x1dp\xa7\n\x01\xb5\xae\x1f?\xb2~k>\xe15\x01\xa9;\xc0C\x7f\x80\xf3\x80S\x81\x07\xd9\xc1\xb5\xc3\xb7\x01ujl\x82\x075\xc0\x93\"\x0c\x1c\xe7\xcb&\xf8\xf0\x85\x02\xe7<\xe8G4\xc0\x9b\xe0M\xe8qPW\xd0\x83z\xd0\x93\x82\xe0{\x80W\xe0s\x80j\x83\xbfd(\xf0]p\xe8\xbf\xe8\xd0w\xe1{\x1d\xf8\x15x\x1c\xfc\x15\xb8S\x1e\xf5\xd0\x83.=\xe8\x81O\x9a\xd4\x83%\x95R\x0f\xd71-g\xa2\xa3\x1e\xaech\xe6\xd2(3`3?\xd1\x08M \xf6]\xc0\xe5\x8d\xea\xe1:\xc8\xe9\xca<\xd5\xc3u\x8c\xcc\x9c\xbb\xaa\x87\xeb\x18\x13\"\xfbU\x0f\xd718G\xfe\xac\x1e\xaec`\xb8\x0c\\=\xb8\xf3r\xf5\xb0\xffy\xf59\x9d\xf9$\x00\xa3\x10\x9a\x92\x84\xf5 6Q\x0c =-4_\xcb\xec\x06\x9eMPQ?\x05}\x8cC\xbc\x97]\xc1t(\xf1\x10G\x01\xd3\xa1\xc4\x08\xfe\"\xa1\xc0w\xc1\xa1\xff\xa2C\xdf\x85\xbf\xeeCIu5\x03\x962\x82\"\xe6\xdb*\xbb`\xbd\xbf\xb2\x0b\xbd\x18\xb8\x1f\xfb*\xcdt\xb6\x8c\x88\xe6\xda=\x1b\xf4f\x0c\\FR\x13\xee\xc1\xab\x9f>\xbc\xfe\xf1\xec\xe8\xcd\xd9\xbb\x9f\x0e\xbfGf\xeb\xb4\xa1\x8d\xe5\xf0\xd5\xc7\xb7?\xbb\x93\x8d\x9a\xd0F\x82\xccXjB\x1b\xc9\xcfG\xae\xc4\xa5&\x94iL\xc3\xc9\xe2\x7f\n\x13 \x84l\xf1.\"\xab\xda\x95\x98\xe2b\x94WQ\x90\x9c\x1f\xbd\xf1\xf2+\x0b(\xc5\x11B\x11\x9du5\xa8\xc0;\xba\xdf\x84\xde\xfc\xdc[\xcd!b\xa8]\x18\x93J\xfe2\xea<\x12x\xecq>;[5V\xf7\xb7\xbe;\xb9\xc7.\xee1;\x01>s\x14\xe0\xad\xe3z c\x0fA\xdc\x16\xf3\xeeUP6\xf0&\x16\xf4\"\x18\x03\xbax\xf4\xf4\xe9\xc3\xe7>Mz\x12\x0e\xfa\x11\x0f\xf8e@\xc1\xf6\xd1\xd3g\xe7\x0fo\xf20\xfbX\x0d\xc7\xc5<\n\x83\x1f\xe9\xae\xe179\xa7\xbb\xfaeW~{~\x91Qq\xb9[\xad\xde\xfa\x97R\x07 \x11aS\xb7\x9a\xd0\x8b\xde}\xcen\xa5\xe7l\x9b\x86I\x1a\xe6\xde\xa2\xb5\xd71\xaa\xd1a\x06\xe5)\xe9\xbe2\xee\xa9\x12{\x10\xc7[T<\x95\xa1'\x81\xa0\x07\x91\xa0\x9f\x1a\xecA,\xe8C0\xe8\xab\x00\xafo\x80\xfe\xaaot\xc57\x82\xda\xeb\xa3\xf4z\xd0\xd8O\x99\xc0\x10u\xb7\xf7\xd1\xf9%\xfa\x96\xad\xfc\x86\x85\x1b\x12\xb3\xd4\x93\xf8\xcc\xed~G\xf6\x8e\xebu\xbe\xfbJ\xe2<\x8c\xe9\x19\xce\xce\xc6\xd9\xd7\x08\xbb\x1a\xad\x17\xf1\xda\x10\xbdY )(\xc0C\x9d\xa0\xb7\x06\xf4\xe4\xc1\x8b\x00\xe0\xbb\x11x\x11\x02\xfc\x88\x01\xfej\x7f\xbf\xc3\xf1Q\xf2X\xf5\xce\xd46\x02]o\xc5\xee\xa7\x99\xbc\xe8\x87\xd3\x0f\x02z(\xf0=\x8c\xc5OY#\x07\x80\xec\x1a\xe3\xd9\xf3\xec\xd1\xe5\xb5\xc3:\x90~b\x1b\xc6k^\x9bp\xc8K\x13\\\x15\x12\xc2 d\xc4W\xab\xa5!yN7[^\x1d\x91'\xb0 \xb3\x88\x92\x05\x7fkk\xb5\xce\xe5[)u\x0fR-\x1d\xacI(\xa3\xc23+\xb7\xd1/\x874D\x91\x05>\xc4\xad\xb2\x9d\xc8\xf0t+\xa4\x16\xa6[!\x1b`\x8bF\xda\xac\xa9}\xdd\xca\x85\x8a\x0f\"\x88g\x8f\xf9\xf9F\xf7<\xe3x\x9e\x11;|l\xaeW\x14\xae\xb1\xfe\xce\xf0\x19. \x86\x0e}!\x96\n\xc1\xe5\x8e\xed\xcd\xa3\x13\xfb\xb6\xe6\x0c;y\xf4d\x98Nc\xdf\xc4\xc6\x81\xcc\xd1\x1d\xfb6\x8c\x8e\xd8\x18\xa21-t\x9a\xd8\x8c\xbe\x7f\xd3\x95\xf1\xf8\x17\xa0\xda\x18\xf8\xfb\xc3\x9aGJ\x8cW\xd6\xff\xc4\xd8[\xe0\x98.\xac\x9f.\xac\xe70\x12=\xa7\x0b\xeb;\xe0@\xed>,\xe0*\x0fa\xba\xb0\xde\xb2\x14\xa3\x9fI\xa6\x0b\xeb9LG\x93. \x8c\xb6\xa1G\x13w\xf5\x16\x8a\x13\xb5#\xc4\xd7^M\x17\xd6\x8f;FW\xd9P_\xbc\xd3\x85\xf5\x00\xb8r\x19waL\xbf\xfe\xa7\x0b\xeb-\x0b\xe3\xb6\x80\xa6\x0b\xeb\xa7\x0b\xeb\xad\x06\xc2ta}\xf3\x1b\x97\x89\"\x00\x97\xfc?]G\x8a\x9b\xaf[\x8d5a\xba\x8e\xd4\x9d1\x01~\x0c\x8d1\xf0\x05\xa0\n\x13q\xa7\n\x01\xb6pS\x13\xb0\x05\x88H\xdd\x01\x1e\xfa\x03\x9c\x07\x9c\n<\xc8\x0e\xae\x1d\xbe\x0d\xa8Sc\x13<\xa8\x01\x9e\x14a\xe0U8\xe8\xc3\x17\n\xf0\xac\xa9\x00\xbbP\xe0\xbfX\xe0\xbb`\xc83\xab\xb6 \xa6\x00\xd0\x19\xc6(?\xc4O\xd4\xe5ni\x02:j\xa3\xa0\xc7H\x9c\xa4\x9e\xae#\xc5o\xa1\xbf\x8b\xebH\xa7\x0b\xeb}[N\x16b\x05\x93\x858Y\x886@\xea\x0e\xf0\xd0\x1f\xe0axx\x90\x1d\xf0{\x80\x80\xc9BD\x00v\xa1\xc0\x7f\xb1\xc0w\xc1&\x0b\xb1\x03=F\xe2$\xf5d!\xe2\xb7\xd0\xdf\x85\x85\xf8\x1b\xa6FO\x17\xd6wa\xba\xb0~\xba\xb0\xde\xf5\x9d\xd7\x00\xc0s\x100]X/\x00\xa9\x00\xda\xa0\x14\x82\xd7\x9d\xf0\xd3\x85\xf5n\x98.\xac\xd7\x036mM\x0f\xd3\x85\xf5v\x180 \x97I\xd0\x84\xe9\xc2z\xac \xde\x84\x1e\x07u\x05=\xa8\x07=)\x08\xbe\x07x\x05>\x07\xa86\xf8K\x86\x02\xdf\x05\x87\xfe\x8b\x0e}\x17\xbe\xd7\x81_\x81\xc7\xc1_\x81;\xe5Q\x0f=\xe8\xd2\x83\x1e\xf8\xa4I=L\x17\xd6\xfb\x0d\xcd\xaf(\\\x006\xf3\x13\x8d\x10\x7f\xa1\x1b.oT\x0f\xd7ANW\xe6\xa9\x1e\xaecd\xd3\x85\xf5\x9e\x83\x9b.\xac\xaf\xc1\xfe\xe7\xd5\xe7t\xe6\x93\x00\x8cB8]X\xaf\x07\x7f\x0b\x0c\x15\xf5S\xd0\xc78\xc4{\xd9\x15L\x87\x12\x0fq\x140\x1dJ\x8c\xe0/\x12\n|\x17\x1c\xfa/:\xf4]\xf8\xeb>\x94L\x17\xd6;/\xa4\xd0Co\xc6\xc0e$5\xc1\xf7J\x0b=x^t\xa1\x07\xcf\xeb/\xf4\x80\xbf\x14C\x0f\xbd\xae\xca\xd0\x83\xff)L\x00\xf2\xc6\x0dO\xac\xa8\xfb9\xf4\xe0\x1d\xddoBo~\xee\xad\xe6\x101\xd4.\x0c\x1e\xa6\x9fSU\x00:]\xa0 \x83\xc7\xeaE\xd2>v\xbc\x00\xecE%\x1e(\xa7\x0b\xebm\x9fz\xedq>;\x1b\xee\"M\x05~;\xb9\xc7.\xee1;\x01>s\x14\xe0\xad\xe3z c\x0fAD_\xc4\xa9\xc0\x9bX\xd0\x8b`\xe0{A\xa7\x82^\x84\x83~\xc4\x03\xff\x8b;\x15\\\xef0\xfbX\x0d\xd8\x8b==P\x8eps\xb3\xefE\x9f\nz\xd1\xbb\xcf\xd9m\xeb\x7f\x01\xa8\x82k\x18\xe3v\xba\xb0\xde\x02\x9e\xca\xd0\x93@\xd0\x83H\xd0O\x0d\xf6 \x16\xf4!\x18\xf4U\x80\xd77@\x7f\xd57\xba\xe2\x1bA\xed\xf5Qz=h\xec\xa7L`\x88\xba\xdb\xfb\xe8\xfc\x12}\xcbV~\xc3\xc2\x0di\xba\xb0^\x0fxm\x88\xde,\x90\x14\x14\xe0\xa1N\xd0[\x03z\xf2\xe0E\x00\xf0\xdd\x08\xbc\x08\x01~\xc4\x00\x7f\xb5\xbf\xdf\xe1\xf8(y\xacz\x9f.\xac7\xc1\x1e\xc6\xe2\xa7\xac\x91\x03@v\x8d\xf1\xecy\xf6\xe8\xf2\xdaa\x1dH\xd3\x85\xf5\x15\xd8Vs\xba\xb0\x1e\x11\x7fu\xeeL\xee\xddh\xba\x15\xb2\x01\xd3\x85\xf5\x980\x96g\x1c\xcf3b\x87\x8f\xcd\xf5\x8a\xc2M\x17\xd6\xa3\xb75g\xd8\xc9\xa3'\xc3t\xfe,\x17\xd6k.\x8c\xb7^W_]T_k)\xd1\xf5\xbb\xac\xbe4c?\xd2\xbc\xe7\x9d\xf5\xed]^\xbb\xfc\xba\xcd@w\\\xd5\xa9\xd3\x8e\x1a5\xa8O\x93\xda4H\x9f\x91M\x0dg@\x8b\xd2\xb6)l\xd6\xec\xacH\xb5\xdb\xa9CR0\xe6\xe3!|:\xf9\xe9~J\xb3\xa4H\x03\n1\xd9H\xa6-\xe2\xf0KA\xa3\x1d0N\xce\xc3e(O@\xb9\xbc\xe9\xc4\x94\x05\x90\xd14$Q\xf8\x95.\xf4\xb5Z\xdb4\xc9\x93 \x89`^,\x974UW\xa5\xcc\xc4\xad\x9cb.\xb0)\xb2R\xa2\x80\xe4\x10Q\x92\xe5z|IL\xe1\xd6\xfd[\x10\xacIJ\x82\x9c\xa6\x0c\x13\xe5v(dt\xb5\xa1q)\xee\x9fN~\xba\x9d\xc1\x96\xe4k\xde\x81\x16]Y\x97\xae\xef\x8d\xa1Y\x16Q\xb4\x83/\x05\x89\x18U\x16\x82f\xb2\x0bN\x9d;$\x830\xd6#\xf8\xcc\xba\xbf\xbfJ\x92UDg\x9c\x16\xf3b9{S\xa4\xbc\xc0\xed\xf3]1z\x8e2['E\xb4\x809\xbfFF_\xae\x10\x908\x89\xc3\x80D\\@\xf4=\xde\xa1\xb3\xd5\xec\x80\x91\x90\x97\xea\xdd\x9a\xddb:\x82\xdf\xb6\x1a\x04t\x9b\xd3\xc5\xdd\xd97\xfa\xa6G1l\x19Q\xc3\x80\x1e@N\xc9&\x83\"+\x08\x9b\xbe\xa8\xd4\xdf\x86\x11\x1b]\x9e\x88KM\xc3\x98\xa4; Q\xa4\xa7\xddnK\xe5\x8d\xab\xf9\x9a\xee\xf4]\xd2\xab-\x0dr\x08sv\xdc(2u\x85\x0eg\x06z\xc5\x97\xf20\xde\xcd\xe0\x87\xe4\x92^\xd0\xf4\x80\xab\xb6O'?\xe9\x8f\xd1b\xe7eh\x18\xbb\xea\xf95X\xd3\x0d\x85\xcf\xeb<\xdf~>\x10\xff\x9b}\xe6\xf7\x0f\xc4\x89\xfc\xf5\x80sY@bH\xb84q\ntU\xb7\x80b+\xef\x032\xf4G\xd3\x0b\x9a\n2l\xc86\x13,\xc3f\xc0\x0fX\xf2\xe2 \xees\x08\xc5\xdd\xb1D?\xb7e\x12E\xc9e\xf6\xc2\xb0v\xff\x0eG\xcbj\x06l\xc9\xb7i\xc2\xb6\xa5E9I\xbe!fY\xb1\xa1\x0b\xc3\xc5C\xff\x0e\x871\xfcpzz\x0c\xdf\xbf=\x95\x17\xee\xb2\xb1\n\x01\xdd\x854Z\x188\xf3\xefm\x16?\xddm\xe9?\xfe\xfe\x0f\xed\xc7\\\x97\x17|\xad%\x0f }\xcfWa\x9b&\x8b\"\xa0@b\xa0i\x9a\x18\x12\xa9\xff\x1d\x0e\xab:\xd1\x8c\xdf\x1dL\x18}\xe8\x82\x915 \x01\xd3 Ir^lAV\x08\x00\xdb\xdc\x16\x90\xc4&A7\x0c\xf5\xd3\xc9O|\\kr\xc1\xd9jS\x93\x85\x85\x10\x06\xa2\xa6\xc1\xfe}\x91\x84\x0b \xb1\xc9Y*\x06\xc5\xc5>\xa5\xcb$\xa5\x07\xaa1\xc3I\xf2p\x1eFa\xbe\x83\x98\xd2\x05g\x919\xaf\x86\xe1ld\xca]Ib\xa6\x0e\xe3\x15\xe5\x0d\xb8\xdc\xcd\xe0\xce\xa7\x8c\xaa\x12vF\x15\xc6vL\xcf\x08\xbe#1Y\x99fb\xbd\xcdP)R\x14o\x8f\xc6\xf1\x13\x17\x1d\xd7L\xe3t\x18\n\x83\xa3\x1b\xe8\x0c\xf0\xeb\xe6\xce\xa3l\xc8\xae*v\x9ev3\xd6\x9a\x0f\xcf\xeb\xfb\x0f\xa3\xe2^\xd4P\xb4\xd7e\xdf\xf2\xc5\x17h\x95\x92\xd1\x0e\xb9\xa2j\xea\x1b9#\x85;e\\j\n\xa1/[u\xed\xaaSf\x9dZ+B\xd8\xecB3~U^\x8b\xa6*\xb9\xdeAw\xd8\xef\x9bV\xec\x9c\xfbb\xfd\xf1\xc9\xa1\xe6\xff\xf0\xfdR\xce\xb7\xd0J\xa6\xe4\x84F\x83*\x0f\xcd\x16\x0e\xbd\x14>z9w\\\xf0\x15\x9bM)\xd76\xdc\xb0\x9a\xb5E/\x1a\xcc\x8f\x0eC\xd2\xfesD\xde\xc9)r\xeby\xf5\xb9\xe0\x0c\x0c_?\x85\x0b\xde^\xbe\x8eU\xd3\x0b\x13I\xef\xc5o\x7f\xeb\xd9\xa6\xbek\x1a\xd86\x0d<\x83\xd5j\xf5\xaf\xe8+|\x10\x8a\xfa\x1e\x7fX\xd4\xf7+^\xf5wm\xb3{\xb4m\x9a\xc7\xf8k\xab\x15\xbe\xf7\x94[x\xc4I\xbc\x17\x8d\xbel\x1e\xfd\x9a\xd3x\x0c\xff\xe5\x91\xa7>:\x7f\xf7\x8f\xcd7\x91\xb1\xf9CqW,\x1e\x1cx&t+N}\xc1(\x94\xdd\xa3\xef\x9af\xb5\xae\x8a\xae\x0b\x0c\x82l\x12\xff@\xf6\xc7\xf8\x08\xaf\x17\x19\x9dax~\x17\x19\x9e\x8b\xfb\xfe\xb6\xa9=\x03$[\xf2]\xd3\x97\x83\xf6\xf2\xd5\xbb\x17o\xcf/.\xdf\xbc}\xec\xb3\x8e\x8c\x8c\xe6\xafLV\xe7\x1f\xae\x7f\x89\x0c\xd7\xf7\x8d\x07g\x83\x0f\xd5\xd3g\xf0\xeb\xfd\xf5\xea\xbb\xa6\xf9\xaf\xd5j\xf5w\xfc\xc5\xa2\xbe?\xe3\xea\x1a\x7f{/\x15\x90\x9f\x8a\xb6\xbb-*>\x88\xfe\x86\xfb\x86iZ\xb3\xa7\xdar;\xa9\xf4}\xbd\x1b\xab\x15\x8d\x12\x8c-\xde\xfa?\xcf\xa0.+/\x83\xfa\xdb\x82p\"?\xb4\x89q\xd4rP+\xdbp}?\xaa*Zb\xcb\xeb2\xee\xb5\xa9\xd1\xa1v\xe8\x90=\xff!\xa2\x86<\xe1g\xd1\x95x\xc0U\xb9\x87P\x18\xbb\n\xdfq\x14\xa2\x8a[\x83\x98u\xb7\x92A\x8c\xd7\xd5\xbd>79\x07\xdeAu\x84b\xdb3\xa9\xcd\xf0\xf3\xb6\xdb\xe4'\x0f\xdd*\xd4\x81N7Q\x9e\xe0\x98\xe2\xcc\x07\xdb\xa6Y]\x17\xad\xe8\xdc\xe7'\xf7\xab\xbf=\x90\xa3%\xcf\x1a\xf8\xb1J4\xe5\x01\x7f\x97o/\xce\xe3?\xbc{\xf3\xda\xfd\xf5\xd9\xb3g\xcf\xf0y\xe4\xef\x8fv\x00\xa9S5|\x99*\x85A\x9eU\x0e\x1d\xd3\x96\xb6\x9bCU \x88s. \xfe\xfa\x86\x8d\xdb\xfc\x19\xb0\xdd5\xdbl\xc6\x0d\xffL\xe9\x0f\x88\xf5\xc0\xd8v\xb7b0>\xfc;\x1f\x8e\x0f\xea\x90k\xd9\x1f\xf5\xe0\xae\xf4\x92\x7f\xeaQ\xa2\x8b\xf5G\xbe\xe6\xc7\xc3\xda\xb6\xac\x18.\x7f\xb5|\xb8`m\xd7\xd4\xdee\xa3,8\xe2\xf6\x95+13\xcf\xe0k\x9c\xe2\xf0\xb2p\x1a\xaaw\xbf\xa1K\x7f\x00o+\x1e\x88\xb1y\xf0\x14\x1e`\xab\xc6\xee\xeeJ\xf6\xe8\xc1\x99\x8f\x96\xe8\xcb\xebb\xc7\xe9\xfd\x9bl\xf2\xef\xbd/\xf3\xbeL\xde\xa5v\xe8|\xab\x0e\x066O\xc8\xd9,;\xf8\xc4\xaa\xea\xab\x8fu\xf3\xa9\x16\xeb\xfa\xb6\xe8\xa0\x80\xf5\xa1\xeb\x9b\x9d\x87\xc9m\x16<\x93\n\xe8\x84/\xf5\xdd=C\xb5\x9c\xd1\xea\x1b\xe4\\/\xd8\xce\xad\xe4\x83X\x10\x9a\x0fo\x9bj\xa3\x10\xad\xc6\x96 \x0b\x96\xe2_P\xd6\"\xc5\xbe.=Q\xcd\xc0\xb9\xf0\x88\xcb\x07=\x14\x8eYA[\xce\xfe\xfa\x97\xbf>\xf60\xf9R\x1e\xb1+\xf2\xb3\x89\x18\x06N\xee\xeb\xd57_\x7f\xd3=\xf0L\xbb\xf9W(\x92!p\x12\xf3\xbbF\xa3a\x1a3\xa8Z\xc7\xa8\xc1\xe0\xaf\x1d\x0d\xbd\xe9_\x18L\xf2_ulp\xa2\xec\x8b\x9b\xb2\x16c76\xc6\xa29\xbe0\xc4\xda\x14\xb5\xf9\xab&\xaf\x9d\x1a\xe3\xbe\xdccFu\xdc\x9c.\xb0>\x1c\xbb\xbcw<\xbc']\xe5\xea\xfb\xef\xe9yR\xd3\xd7\x03\xc3\xff\xab\xcc5E\xd7I;\xd4Eq\xc3\xde\xb2\x9f\x0f\xac\xebW\xf2\xf9\x84\xc8\xcf\x07\xd6\xde\x8b\xcf99>\x06\x0cvM\xd7\x03\x13\xc6\x10a=1>A\x1c\xed\xd1\x0e! w\xbe\xb8(A^\xf4G\xfc\xa7>\xec\xae\xe5\xa9\\\x9b\xd0\x0c;\xce4\x9a\xc4\xec\xea\xba9\xd4\xfd\x95 2]\xa2\x9f\x8a\x0e:\xd6\x9fA\xd9w\xda\n\xd8\xc1\xa1\x96\x8c\xb0\x91\x86\x94O\xa5\x8a\xb1\x8ax\xc20oT\xd2\xfd\xcd&\x81\xd9\xd78\xbfn6\xec\xbc\xde6\xc9\xfe0\xa5\x0e^\xd5\xcd\x86]\x95\xf5\xb6\x99\xfa\xb5H|\xae\xcd\x15W(\\%J\xc8OL<\xf9\x06q\n\x07\xedD\x01V\xf3\"N\xce'\x88bD\xce#g\xcf\xc0\x86\xb4\xb2\xaa\xb2\xebY-|\xf4\xa4\xf7k\xd6\x7fj\xda\x8f\xa4w\x03S\xe8\xbc\xbb\xbe-\xea\x9aU\x1d\xe9e\xaf|\xdb5u\xf9\x11\xbfp\xda!\"\xd6\xe6b\xf6\xea?\xfb0\xb3\x03s\xd8\xee\xd7IwA\x1a \x92\xee\xbaHX\\\\I%\x8dM\xb1\xdf_\x91_N\x99\xe6\x9b2\x14_\xe7\xbc~}(\xab\xcdU_\xdc\xd0\xf8\xe2\xa6 \x89\x0d\x0f\xf5\x0d\xdb\xa3\xd4\xdd\xa8&4\xa2\xc9\xcb3a\xc7\xf8\xbe\xe8\xd1\xd8\xaf\xe0\xca\x1f\xf6\xba]\xb39TL\x10q^\n\xe0\xfc&\x11Wt\x9c\xf7:`yS\xde\xe3]4_\xca\x93+E&\x88\xe5H!\xf9QqzH^T\x8aA\x1b\"\xf9PN\x03r\xe6A\x19\x0bd\xdd\xde\xef\xfbf5\xdc>A^\x1d\xce\xad\x1f\xc1En\x1c\xd7\x91\x1b:h\x9fj`\xf4\x84\x8b2\xc2\xd7`\x18\xc3\xb0\xfff\xbfz)\x15C=p\xe4\x91\xf0'@\xa3+\xc5\x93E=Mz\xf6r\xa0\xd7\x03\x87$:\xa7\x13q\x92\x9b\xd3Hx\x13\x9a\x112h\"3\xf2\x9e\x93\xc0\xa5\xd7o._=\x95\xe1;U\xc5;\x08\xb7\xace\"\xb4B\xac\xad\x15\xc0\x9f\xd8\xc3\x96\xc1\x7f\x1e\xba\x1e\x8a\x9b\x961\xbe\xd7\xa3\x01\x15M\xcb\xe7E\x18]\x9dzD\xa8\xd5\x8e\x15\xb5j\xb1l\xd6\xf3\xfd\xfe\x87\xa2\xbb\x85M\xc3d8\x80\xbaB\x88\x13\xef\x18o\x8e\x11\xca*\xf9\xed%W+,\x1b\xb8\xbc\x82Oj\x06\x85\xf2\xc3\x9aW\x11\x0d\n\x8c\"\xa5W\xc1,\x16p?\x86y|\x90\x0ct\xb19H\xe5\x88]\xdd5=\xbb\xc2\x1b\"KpC\x8em\xc9\xc2\\\xca\xae\n\xfcY\x948\x10*\x00M\xc6\xfb\x94\xb0E\xcb\x12\xbe9\x0d\xc4}e\xef\xce\xbf\x7f\xfd\xea\xe5\xd5O\xef\xbe\xbf\xba\xfc\xf3\xc5\xab\xe8\xfdi\xf8W\x17o_\xfd\xf1\xcd\xe5\xab\xf4\xaf\"\xf7\xa9\xf9\xbe{s\xf1\xe6\xdds\xdf\xd5j\x00\xc6\xf5j\xe9\xfd\x8be\xfe\x9a\xe5]yS\xb3\xcdO\xdd\xcd\xa5\xf2oH\xf4\x06\xbe\xe4:\xf1\xc8t\xdd\xfaa\x01d\x19v\x0bO\xae\xe1P\xbc\xe3\xffT\xdc5\x16\xb9\xeb\xd5?\x9eO\xe1B\xecKE\xe5'\xf1\x85\xaf\x8d\xf6\xdc\xa59\x96\xb8&,\x8bQ\x9ds\xbf\xe6X\xfc7m\x8e\x85\xb0\xc6\x81\xb8\xce!z\xb9\xa4,\xc4!\x85\x98rn\x96\xe8\xc9\xc5.\xc4^CB\xcfy\x89\xdc\xe1i\xbcH\x9cg]h\xec\xa5\x0be\x12 m\" e2\x08\xe7&\xf4u\xfc&P\xf3\xb5/\x7f\x9dp\xc2\x95\x92\x90^{p(\xc7\x8a=X\x8fc\xa1\xf2\x13MnDo\x9b\x84\xac=\xa5nQ\xe2\xe6\xc9\xc1c.\xee\xa5l\x19\xd7`\xceT0\xef\xae\x94\xc1\xc5\xf2\xbfB\xb9\xf1\x12\x13'N\xe3\xce\xe6m\x83\xe4\xad\xeab\xece\xd8c\xa1E]\x9f\xb4\xa8\x93\x16\x05'-\n-D\xe6\xa4ms'-\n\xe8C\n4\x19,\xcbI\x8b2\ne\x12 m\" e2NZ\x14\xb5\xf6\x93\x16\x95\xb0E\xfdb\xb5(\xb1\xec\xafB8\x00\xc3\x9b\xf1A\x8b/\xf5\x91/\x8e_Wt\xc9%\xd4\x12Zj\x14\x1ex\xa9\x8d\x8b\x9c\x11^\xe9;\xd7\x073\xebp\x0b\xbb0\xaf\x0f\x83\x84\x92R\xeaL\xff\xa9\xe1\xdfo\xabr\xcd\xe7Np\x0c2\xc7\x15W\x12\xae\xd6U\xc9\xea\xfe\xaa\xe8\xfbb\xfd\xf1\x98\xa6M\xa3EW\x1e\x1f\xbf,\x84],V\x17\x0c\x83A\xd89 \xf5\x01\xb1N@\xc2,\xf0B\xac\x14\x12*\x860\xea\xfb\xb4P\xc27<_\xd2\xdb\x0e\x89\xed\x07\x7f\x00\x08^\x08\x0buZ\xf4\xc2E\x83E\xf0\x82\x86\x90\xe0\xe5K4\x88\"V\xa6\x85\x1e\x9aB\"\x87\x86\xaf\xc4\x02V\xf0\x92\x12\xc6B\"8\x0du \x07\xb7\xe0\x85\x12\xf2\x82\x17<\x10\x06/I\xcc\x12?\xd5\xe9\x92D\x96\xb2_\x9a\xc5\x0d\xbb\xf1\xbc7\xaf\x11q\xcdU\x97@\xe0\x0e^\x8e,\xb7\xa8\xe7\x13H\x1f\x1c\xa0\xa9\x9cvI<<\xea\x928J0c\xa4 \xe5P\xa9\x0b\xf500-i\xdc\xadK\xcad\xc2\xbc \x859\x93\x9a|\x08\x9d|\x16;\x8c\xea\x12\x0e\x97\xc2K\xe2\x18$\xf6\x9d\x16p\x85\x17O\x18\x16^\x8e\xd9\x8d`\xd0\x14^\x8e\xd9\x1c?\xbe\x16^\xa8\x11c$b\xd3\xa82\xbc\xc4c\xcd\xf0r\xcca\x0bE\xab\xe1\xe5\x98\xad\xc1\xe3\xdd\xf0r\xccvD\"\xe6\xf0r\xcc\x06\x05b\xee\xf0r\xcc\xc6\xc4\xa3\xf6\xf0\x12\x8e\xe5\xc3\xcb\xf1\xfa\x91z\xf2H \x18\x8c\x12\xc3\x02\n\xf1\x82\xdd-\xe7\x96\x04M'E\xc3\xf9\x85\xe8\xe9Q\xaf\x8c.\xa9\x8a\x15\xcd\xda\xaa\xcbIA\xf7\x96\x93\x82.J\x1a[\xeb\x922\x990oBa\xce\xa4~)\x05}\xf0f\x90\xa6T\xf6\xde\x8d\x92\xc5\x0b\x1a;\x8b\x97dfLgE-A\xae\xb6UqC\xfdh\xe6\x84\xc7\xa31\xec\xf2\x15|\xfb\xe3\x9b\x17\xffqu\xfe\xf2\xea\xbb\x1f\x9f\x7fO\x88\\\x98\x96)\x85\xe7\xdf\xbe{\xf5:\x1cla\x97)\x01B\xb4\x86]\xa6\x04^\x9f\x87\x826\xec2\x84p,\x1b\x86\xb4S\x88,r\xa1l\xbe\xab\x8a\x1b(\xeb\x8dp\xa1(4I\xf8\xb6Z7\x1f\xcf_F\xa39\xec2,)(\xe9\x86\xd0DO\xaa]f\xf1\xe8,\x91Dp1\xdbeQ\xd3\xe8F\xafM\xd1\xc2\xdb\xabS$\x88\xe4\xca\x1a\nE3f~Nm\xaf\xa4j'u\x0c\x1eG\x91-\xa2\xad\xfb\x9f\xf4D\xd5z\xf2r\x18\xa2\x90\x8e\x1cN\xea\x11\xa9'\xe9\xd8\xe0\x04D\xf0\\\xcd#\x83W\xe7\xaap:\x1eQ\xb8\xee \x14w\x1a\x00w\xae>P!\xb6s\xd5\x17\x07\xd1\xceUS\x02Lv\xae*\x89@\xd8\xb9\xaa\x83$\xa8\xeb=\x19\xe0:O\xfb,e.\x05\x9f:\x8a?\x1dB\x9d\x8e\xee[\xf1\xfd\xea\x8b\xe97\x11\xe4h\xdaF\x18\xb2?\xe8rRl\xc6B\xea)\x90{\x0b'\xc5&\xb7bCA\\\x96} \xa3DF\xf1!\x89\xac@e\x84h\xee\xbdY\x12&\x83\x86\x95\x1cO\xf2\xa1}G\xc4E\x8e&\x04\xd1>\x8bc \x13\x93\x87\xf0BE\xd4\xc9\x87r\x1c\x85\x070\x0b\xc1\xaam\x97\x04\xaeIX\xc0D\xcc\xe2\x19\x95\xc7\x8e\xdd\xb2\x90Q\x89g\xb4 \xd2}\xba\xc5\x89\x8e6,\x12\xb2\x08\x94p#\x0d\xadE\xf33\x15=\x04 (\xc2\x11\xec\xe0\xa04\x0d\xcb\xd0\x18*[L\xda\x07%=A\xcaS$\x17\xe5\xc3\xb9=\xf9\xd4\xf8\xb3\xe2d\xa1\xe5\xc6)r\xf3\xcc\\\x91l9Y\x16\xea\xa1\x91\xfc9Y\x08;P\xac\x1e\x88d\xd4\xc9B\xa8\x08\x88\x95\x01%\xc7N\x96\xd4L;\xf5\x15\xad\xad\x90\xd0^\xa0\xe5\xde\xc9B\x90\x91f\xd1\x0b,\x9a\x87'K4\x1bO\x96c6\"\xb6\xe4\xa7\x85\x9e\xa5\x17%5f\xf1\xcd\xcc\xd5\x93%5c/JP\xf6 5oO\x96\xd4\xec=Y\xe29|\xb2\x90\x19!\x16\xef.\x0b\x99\\lO2K8\xc3O\xbd\x93^1-\xec\x90\x98\xf3'\xcb\x91d\x0bE\xff\x86\xb4A\x80\xb8*f\x97\x84\x83\x8f. \xa3\x01\x89#\x02\xd4\x03\x91.\x14\x05xZ\xe8\x1c\xaa\x0bu\xa2 }\xb2 u\xc2\x92\x0eP\x93O\xc2\xa1\xf7\xb2\xd03\x0beI\xe8oB?\xd3s\x0de!d\x1c\xcar\x8cf\x93\xf3\xf7d9F\x13\xf2f%\xca\x92\x96\x9b(\xcb1\xfaF\xcdV\x94\xe5\x18-\x88\xe7/\xcar\x8c\xba\x132\x1ae9F#\x889\x8e\xb2\x1c\xa3\x01iY\x8f\xb2\xd0s\x1fe\xc9\xdf\xee\x14\xd59=Y2H\xce\x9fH)K(\x9dR\x16\xe2vO\xdd\xe6\xff\x81\ng$\xe5R\x96\x14\x8d\"nZ\xd3\xe5\xa4i\x9e4\xcd\xd8\xdb\x900Q\x90>Y\x90:a\xc7\xd64)\xa9\x9e\xb2\xc8\x9e\x86\x13>e\x89\xa6}\xca\x92\xc4Xil\x95\x94\x08*K\xf2D\xd2\x92Be\x99\x9b\x1a*\xcb\xcc\x04QYf\xa6\x89\xca\x92\x9e,*\xcb\xa2\x94QY(\xb9\x06f\xc9\x95>*KR\x12\xa9,d\xd7\x94]\x92\xf9.Y|\x10\x93Ke\x99\xdd\x1c\x9a\xc5G\x96\xa8\xaf\xcb.\xb3\xdbD\x1a\xa2\x14\xbdP\x96|i\xa8&\xbd\x90\xcd1\xa5\x8dI\x89\xa9AJ\xe8\xf5\x9a\x81\xf4TY\"I\xaa\xb2\x10d?E\xe2\xc7\xd2Ve\xa1\xed\\\x84]\x8b\xd0jY(m\x97\x85,+\x92\x16A\xc2\x02\x88f\xca\xe9B\xee<$\x0d\x00\xc4\x13_\xec\x924\x10\x906\x18@I\x91\xb1\xcbq\x9b\x93\xb2\x0b\xa6\xa4\xd6\x10\xc8M\x92o\xe2\x19x\xba\xc4\xfc\xf5vI\x1a\xbf\x14]\x9e\x94\xa0c\x97#\xb4%\x9cR+\x0bqeQ\xd7\x14Q\xa4$t\x96\xcc\xb2DaB\xec0$t\x1a\xd2\xc4HB\xe7!e\x00 U\x80\x1c\xaf!t\xd1\x91Up\xcc\x14\x1b)B#a\xcch\x8b\x14\xe6\x88\x8b\xec\xad\xa0E;\x0do\xd3\xaa\x0fW\x1dH\xfa\x95%RK\x98z<\x0dX\x96\xb0~\x16\xd0\xcb\xa2r$.=\xa2\xc2\x924\xce\x84e\x19\x15\x8d\xd1\xce\x00\xa9C@\x15\x84\xa4\x8e\x01\xads@\x17{y\xab\xa5\x08\xb9\x14\xf1vB$\x18J\xb8N\x9a\xb0Z$>\xfe\x91\xa1\x933\x93\x99\x1d:F\x00\xec\xec\x94\xe6\x1f\x0cS\xbd#$\\\x81\xe0\x04\xf8\xc5B\xf9P\xc1\x83\x0b\x1a\xef\xfd\x04\xc8D\xe8)p\xe2\xda\x9c0\xbaT\x12\xfe\xc9\xa3\x87\xbb\xf9\xc3\xd9\xa6\xddu\x03\xdbRC\xd8\xac\x105{ \xf0`\xb5XX\x9a\x1b\x80\x86\x0c\xe1tSGG\x19[\x81vHX\xf0\xb3\xe9\xf2\xf2\x04t%p\x98\xeb{\x89r\xc7d\x83\x08\xba\xb8\xbc\x9b\xac\x7fc\xf58\xa8$%\xc2\x9d4\x8ed\xc3\xddKA\x81\xe6\xdd\x0b\x83\xce!\xd4\x0d\xe4\x0f-\n\xce\xb4Us<0\x08 \x01\xa2\x92\xf7\x06\xb9P ,\x0b\xbf \x07\xdaP\xdb\xe0\x0b\x93\xa1~\xef\x06\xb9P\xbf\x0c\x84\xa8PIx\x02L\xa8\x9f\x87\xc3C\xfc\x81 4\xfa\xf9@\xad\x9d\x8dVl\xfa\xdf\x8e[\x1ca\xb3\xf5\xa4\n\xa4\x08\xbcS\xcb\xf5J\xfd\x0c7\x0e,u\xad\x1a>O\xc4\xa5\x9a\xc3\x95\x8a\xbaPC\xae\xd3u\xd3\xed\x9anu]tlu\xf7\xf55\xeb\x8b\xafW/\xd9\xfaES\xd6\xe4\xa9\xd9\xb0\xba\xd9\x05\xc7\xb8\xd85\x87:$\x82q\xa6T\x0d\x19\x94\x9a\x02\xfa\xe6#\xab\xa5\x06S\xc8z\xcbZ\xf4V\x0c\n\xffi]\xee\x8aJU8\xec/\xaf\xc5.ry\xcb\xd4\x03\xd8\x96\xac\xda\x88\xbd\xaa\xe6\xb5(\x03]\xb9\xdbWl'\xf8_\xcc\xeb\xa1\xeb\x9b\x1d\xecX\x7f\xdbl\xa6\xcb\xae\x83\x96\xfd|([i\xf7\xb9in\x9a}\xdb\xf4\x8d1\xa6\x9b\x92w\xf0\xfa\xc0\x9bg\x8cm\xc5nD\x8b\xd5\xff\x9a\xf6-\xfbT\xb4\x1b\xf2h\xa7\x89\x9f\xd6 >\xbe\x92\xf7\x9c9\x99\x7f\x93\x06\"\xcd\xa7\xbc\x10|\xdd\xafud\xe4\x0eY\xf2\xf1\x88,\x14N\xf13\xbe\x87KL\x11-]\xa3zJ\xd4\x97\xc2\x01\xb6\xd1\x1f=\xec\xf4\xff\xf9 H^\x88q\xe8E\xd1\x16;\xba\\\xe6\xfb\xc1\xa1.\xfb\xfb\xab\xbep62k>\xb9\x8c\xb9\x1a\xd4\x7f\x9c1\xed\x0f\x9a\xfa\xd0%}\xc1\xa7~\xd3\x16\x9f\xc4\xd2\xb8b5?\xf78_\\7M\xc5\x8a1\xcee\xd8!\x8d\xdf\xadi\x91#b{\x1ce`\xd8^>\xe1\x02\x9f\xffj\x8e'\xec\x9a\xcd\xa1b\xb1\xd1\xfe\x7f\x0e\xac\xbd\x7f\xa1\xc7\xf0\xa2i\xaa\xb7\xac\xdb\xf3\x0d\x85<\x03\xfb\xa6q\x82\xc3N\x0b\xfc\x97\xb2\xc0\x9dN\xf2\xe9\x1a\xba4\xac\x1e\xf1\xf3C\xfeCYw\x88h\x18t\x10?\xc3\xf0\x9e\x08\xb5@\xff\xcd\x87\\\xf3\xa6\xf9\xf5\x13\xebs=Ho/^\xa8^\x92xv\x14QR2u\xc9|+\xd7\xf3\x91m\xa0'\xd6\xcd\xc8\xbaj\xc6,I\xa8\x7f+\xd6\xeb\xf6\xa0\x9d`\xe3\xa6\x13\xda\xe5\xc2|Dgg\x87\xc4|^\xbe\xe4G\xdd_4CG\xfd\xc2^\xe6\x9e\xee\x9f\xe6\xebXZ\x9f'\xa9\xcf\xd3^Y\xc2\x11\x1c\xe8b\x94\xc5\xdbjY\xf0\x85I\xf84\x9e\xad9{\xa9z\x9b\xb9\xfa\x15\x86\x0f\xb5d\x0d#\xe4\xd4\xaaF\x9e\xd0\x17wL\x86\xcdUBe\xa1\xa9\xa2H;\xa6b\x86\x1f\x87c\xa2\xa6\x19\xc2\xbb\xd0`\xf9\xbck\xf0\xb4\xa9d\xdcT\xc4|\xd9\xca\xf5a'\x98\xc7\x9e\xf6\x84\x9d\x04\x93\xe2s\xb6\x13\x93\xce\xcc=\xa5iG\x87J\xf2\x86\xb2\xd0Q\xf50\xcd\xf8\x82\xc58\xf2g\xfe\xab%\xf1\xa0ekV\xde\xb1\xcdl\x06\x9a6\x06\x02\xeau\xceh]\xafZ\x1d\xd4\x8c\xfd*u\xe0\xb3\x98:=[E\xf14\x0fS\xa5\x97\xe8-\x0e1\x9f\x1aMSf\x94\x7f\xd1\x96\xc8\x01\xde\xa6\x0bc\x84\x88\xb1\xc6\x92\x96\xd8\x9bC\xdf\xf5E\xbd)\xeb\x9b\xcc'[\xd2\xcap\xbe\x85\xd3\xb2\xf8'_\x16\x10\x1c\x92\x00c\x9a'\xcbf|\n\x8f\x0e\xf5Wz\xf7\xab\x1f\xbb\xcce6\x94\xaf\xa6\xc2\x10\xebe\xcd>\xefY\xdd\x95w\x8ckV}[\xac?\x9e\xf1\xc3E\xf3\xa9\x83N\x0c\x07t\x85\xb0\xc1\xaeo\xd9\xfac\xfc\xa0AXY3\x16:2\x1as7\xd5w\x95\xc8\xaaK^\xe6\x9d\xfcn\xba\xccI\x87\x0d\xf2\xe1y4`\xedY[6\x1e\x83\x14\xba\xccP\xff\xbez\xd4\x16\xeb\xde\xd9}g\x1d\xb3\xeda|u\xc7\xea\xde\x8e\x8c\x18yK\x0c\x18\xb0;\x95\xee?\x96\x1fD\xcc\x11\xe7\x02\xce`\xe5\xba\xec\xc5ZW\x01P]\xdf\xb4\"<\xcf\xfe\xe8\xf2\x96\xbf\xdfA\xcd\xd8\x86m8\xb3\xae\x8bj}\xa8\x8a^\xe4E\xb6\xcd\xbe-\xc5\xff\xe5\xfan\xb6\xd0\xf5\xc5G B\xf0\x91\xd5\xb6\xf5\x85\xf3\xdahp\xd1)(E\xcb\x065\xb2\x86b\xdb3\xbeXd7n\x8b\x0e\x9a\xf5\xfa\xd0\xb6\xccg\x99Q\x0cb\x9f\xd6\xd5oaej_\xdc(\x01\xe7\xd5\xf0\xf5\x0b\x13-\x7f\xf8Y\x0d\x9e^R\xb3\xd44\x915\xea\x89\x15EX.\x16u\xf4\xdfSQ\xaf\xe9\xeb\xf5\xcf\xff\xdb7p\xcd;\xd2urR/\x8a\x1b\xf6\x96\xfd|`]\xbf\x92\xcf'D\xe4\xe1\x8f\x7f\xce\xc9\xf1!\xe0g\x9b\xae\x07\xb6\xdd\x96\xeb\x92\xd5}e\xee\x9aHxV\xb4C\xc8\n\xf2\xc5\x96J\xfb\x0c\xef\x8f\xf8O}\xd8]\xb3\x963\x9fJL5\"L\xcb)\x80\xbe\xd9\xd55g\xda+Ad\xba\xaf|*:\xe8X\x7f\x06e\xdfq\x1e:\x08\xf9y\xa8%#l\xa0\xe9oY\xfb\xa9\xecB\x01LA 8C\x1c+\n 2x\xf8\xf4\xf9z}\xd8\x89e\xbby19\x16\x10\x840v\x928\x86\x1c>\x191\xe7\x1b1\xf1\x0e\x86\x19\xc0\xdaC\xc6\x17\x8c\xf9Vd\xa6\n\xccG\xb6\xef\xa1\xe0#\xd5\x1e\xea\x9a\x8b{\xb1\x94X{\x06\xeb\xa2\xe6\xb2\xc5\x90\xe8=\x14\xf5\xbd\x08q$\xb3\xab\xabx\x90y\xf5\x8bx\xbcN\x8cz4F\x9d\xab\x81\x0fz\xb7\xa4\x97E\xe5&\xf1\xea\xa8\x92\x91y\xd4\xafo\xa2L\x81\xee\x90\xaev\xe9|\x1b\x19\xe9Y\xbad\xa2\x16\x99I\x7f\\\xae9\xaa\xa9\xd49\xb3\xf6)\xe5yUi\xd8\xad\xe4\x03\n\xb3\xae\xbb\x82# \x1c\xfe\xfa\xd5\xa1uB\xde\x17\x18\x00\x9e\xc3\xfb\xb7?>iY\xd7\x1c\xda5\x83\xba\xd8\xa9L\xe2C]\xfe|`\xd5=\xf0\x8e\xf5\xe5\xb6Tzo\xaf2(\\\x94$\x80\x8e\xb5eQ\x95\x7fc\xc8\x01]\xac\xfduS\xc1\xf5a\xbbe\xadN\xbdXI\xe6\x90m\x87\xdd\xa1\x1b\xd2\x9b\xf9\x96Q\xb1\xa2\xeb]ZM\xcd\xe0\xc1\x93\x07\xb0\xbe-8\xff\xb3v%\xe4WUt=t\xec\x86K)mz\x7f\xff\xf6\xc7\x87\x1d\xec\x8b\xfeV\x10wH\x0d<\xef\xd6\xc2?\xdf\x1e\xaa\xea\x1e~>\x14\x15\x1f\x81\x8d\x1c\x1fEZ\x8c\xc4\xa3\xa2\x83\xb2v?\xfe\xc0\xab|r\xd347\x15[\x89\xbe_\x1f\xb6\xab\x97\x87V\xf0\xee\x87\xc7\xb2\xc5\x82\\w\xdb\x1c\xaa\x0d\xdf.y\xa7\x1dJ\xeb\xa2n\xear]TB\x02\xb85=b\xab\x9b\xd5\x19\x1f*!\x0f\x1f\xac\x1e\x88\xa5\xd6\xf4|3g\xfb\x9em\x1ecV\x99\xf3\x1a\xf6Bx\xac\xd9\x19\xf4\xac\xd8up\xe8\x0e\x05\xef\xae\x8c\xab\xdf\x97\\q\xae\xb9\x98\xbcep]\xd6E{/]\x9f\xf7{\xe6\"r\n\xa6\xe9o\xd9\xbd[\x15\x97\xb9\xeb\x1e\xca\x9e\xaf\xfcCg\xa6\xdb\xf4\xfc\x1c\xd1l\xe1y}\xbf\x82\x1f\x9aO\xec\x8ek\x0f|\xa1\xbf\x7f\xfb\xa3Z\xe1\x0e=N\x82\xb3\x9f\xcb\x7f\xeb[\xb6c\xf0\xe1\xb6\xef\xf7\x1f\xce\xe4\xbf\xdd\x07\x91\x1dP7\xea\xe9\x99\xe0\x1e\xae\x9f4bU\x88\x1ew\xac\x87\xc3\xde\xa1'\xf3\x85\x90zX{\xc7Z\xd9\xe5]\xb1\xef$+\x88\x16\xf7\xcd\x90T$\xf6\xe7R\x8a\xaa\xa2\x83m#\xb6\x99\xa7\xc8\\\xfc\x06\xce\xb7c\x0b\xf9\xf4\xed\xdb\x86K\x94\xcd\xd0 \xb1\x1fw\xdda\xc7\x05\x19B\xe0y\x0d?\\^^\xc0\xf7\xaf.A9\x10\xde\xbf\xfdQ.\xa8{\xb1\xa1\x17\xf0\x97);^\xde\xef\xd9_\xff\xf2W\x87\x1c\xe8\xb3N\xad\xe7]n>b$\xf7m\xb39\xac\x19\xd7\x0eX\xdb6\xce\xc5\"\xa25c\xb4\x7f'\x04\xb4\xd8b\xb5\xe8_\xf3\xb5\xda4\x1f\x0f\xfb\xe1\xa8v]\xf03hS\xa3b\x05xWD\xdd\xb7\xc5\x9d\x98\xfa\x9d\xc1\xa3\x1b\xc9\xa4\x85n*\xff\xff]Sn\xb8\xbe\x89\x90\x92\x15\x8b\xe5\xd7\xb2m\xd3\xb23\xfd!\xa7W\xf4\xe5uY\xf1\xfd\x9f\xefU\x9d>\"s\x11\xd1\xde\xb1\x0dB\xaf\xa9\xb9\x18\xaao\x98xY\xac\x8d\x15p\xeb\x9a\x8c\xc00\x04\xbf\x8b\x0c\xc1\xc5}\x7f\xdb\xd4\xc8 \xc8\xda\xbfk\x9aG\xab\xd5\xea16\xd1r\x00\x1e\xa1\xcf\x04\x13\x88a\xa1\x8e\n\xff\xe8\\\x0e\xca\xcbW\xef^\xbc=\xbf\xb8|\xf3\xf6\xf1T(\x82\"/\x19\x05\xaf@V\x81\x0f\xc7\xbfD\x86\xe3\xfb\xc6\x1d 1\x14O\x9f\xc1\xaf\xf7\xd7\xab\xef\x9a\xe6\xbfV\xab\xd5\xdf\xdd\x97\x8a\xfa\xfe\x8c\xab1\xfc\xcd\xbd\xdc\xbc\x7f*\xda\xee\xb6\xa8\xf8 \xe1\x0d\xc5\x86bZ\x1bRU\xb9\x9dT\xf4\xbe\xde\x8dU\x89\x86\x08\x86\x14o\xfd\x9fgP\x97\x15\xca`x\xfd\x13N\xba\x14\x1e\x8a\xf5\xc7A\x06i\x85\x12\xae\xef\xc7\xed]K\xc9OeU\xf1\x07*\xe7\x9eo\x896\xb9\x87\xc8v\xfd\x84\x9f\x8d\x04:\xc1\x8a\xab6\x0f\xb9\x8e;Hl.\xcdu6\xa8\x9c1\x9b\xe0 \x1a\xeb\xea^\xeb\xf3\xceakP\x9b\xd4\xa9\xbe\xd7g\xbc\x87O\x1e\xda\xe4\xd4\x81BW-O\x10Lq\xcf\x83m\xd3\xac\xae\x8bV4\xfa\xf3\x93\xfb\xd5\xdf\x1e\xc8\x1eK\xbd\xd8U\xf1E\x95\x0f\xf8{\\<[\x8f\xfe\xf0\xee\xcdk\xfb\x97g\xcf\x9e=s\xc7\x9e\xbf7\x9e-\xa5>\xd1\xf0\xe5\xa26S\xa9_\x1f\xba!W\xe1\xe6P\x15\xadM\xc7\xfd\xbc\x17Qy\xe36x\x06lw\xcd6\x9bqC\xd6\xcd'i\xe7\xbd\x15\xa6xe\x98u\x19\xd5f\xa73\xa9lMxL\n\x02\xa3J\xce8\"S\\\xb0\x8dM\xf0\x83`b\xcdC\xb7M\xb5\xb1L\xc3b \x94\xf5\xc0{\xa0, \x8a\xf5lZ\x82\xfc\xc0q\xf0\x88\xaf_\xdd]\xe7\xd8\xaa\xad(\x7f\xfd\xcb_\x1f#\xcc\xb9d\xbe\xed\n\xf0)\x17\xdd\xe6\xa4\xbe^}\xf3\xf57\xdd\x03d\x1a\xf5\xff,\xadz@\xeakY\x7fhk\x99>\xa0\x7f\xecN\xfe\xe8\x93?\xfa\x98\xfeh;O\x13\xb1uSbj\x8d\xcf\x14\xb5\xb7\x17/t#\x1dg4nf\xcfnc'\xf1s\x8f\x9a\xce\xbd\xd3\x1f>\x90g4\x9a\xfbM\xe6\xf9\x0c\xe6\xd9\xcc\xe5^c\xf9\x02Sy.Cy\xd8L>\xcbH\x9e\xd7D\xee5\x90\xe75\x8f{\x8c\xe3\x0bM\xe3\xcep\xbbZsn\xb3\xf8B\xa3xf\x93\xf8\x02\x83xnsx6cx^Sx6Cx\xdc\x0c\x9e\xcd\x08\xee3\x81/1\x80\xa3\x06oD\xebt\xe5\xcd2c7b\xdc\x9ei\xdaF\x0c\xdbQ=\xc9Q\xfc\xc2;\xe8L\x83\xf6h\xc0\xc6\xc6\xf7W\xf1\xba3\x9b\xb2]Cv\x063vV#\xf6t3\\h\xc0F\x8c\xd6KL\xd6A\x9b\xad\xc7\\\x1d5V\xbb\xf61\xba\xa1\xda\xfd\xf6\xefX_g\x99\xa8)\x9d\x8d\x99\xa7\xfd}\x8b\x9a\xa6\x13\x0c\xd3\xb6\x1db\xa1Q:h\x92\xf6\x1b\xa4C\xe6ht\x14\xa8\xa6\xe8\x98!zj\x86^`\x84&\x98\xa0\xd3\x0d\xd0\x88\xf97f|\xcedzFj\xb68%\xab\xd19\xb3\xc99\xab\xc19\xa7\xb9\xd9kl\x9eZ\xf0\xa6\x86\xe6\xfa^\x02\xf2\xcaY(\xec\x85a\xdb\x95\xe3'?\xce\xc9\x8fs\xf2\xe3\xe8r\xf2\xe3\xe8\xcfO~\x9c\x93\x1f\xe7\xe4\xc79\xf9qN~\x1c\xe3\xef\x93\x1f\xe7\xe4\xc79\xf9qN~\x9c\x93\x1f\xe7\xe4\xc7\x81\x93\x1f\xc7z\xed\xe4\xc79\xf9qt\x99?\xbb\x99\xfc8\xf2\x96\xbb\x83\x03E4\xd1\xc1\xdd\xfbX\xf5\xbd\xa1W\xef.\x9f_\xbe\x7fw\xf5\xfe\xf5\xbb\x8bW/\xce\xbf;\x7f\xf52\xf8\xde\xcbW\x17o\xde\x9d_^]\xbcz{\xfe&\xfc\xea\x1f\xdf\\\x9e\xbf\xfe\x9e\xf2\xe6\xc5\xf3w\xef\"\xf5\xbe}\xf5\x87W/.#/}\xf7\xfc\xfcG\xe3\x95\xe1\x92WJg\xfd\xb6nm\xc0|'FZ\x8c\xa5\xd0|\x0d\xec?5\x0b\xf2ZB\xc3.k\xf1Kp\xd0\x83\x8d\x9c\x00\xa7\xcb\x9dPT\xb2\xef\x8aJU\xbe\n\xd7eO\x9c[\x9d\xfd\xdc\xb0\xec\x0ffpY\x0dl\x0eB\x0c\xca\xa6\x08\x8b\xb0Q\xb1m\x1a\xf74\xc5b\x0c\xb7%\xd6cZC\xa4a>\xb5\x1d\x92\xed\xdc\x06\xc8\xdf\x035[\x93,\xe5\xdamaZ\xf2d\x96I\xa4z\xcd\xd2n\x03\xf4\x93%M\xb8f\xac\x86\x96\xfd'[\xf7\xd1\x96\xc8u\xe3\xb6C\xfe\xbe\xa4\x15\xdb\xa2\xac\xc6\xea\xb7e]TW}QU\xf7W\xd2\x885\xcbJ\xff\xf0\x9eu\x0fI\x96\x87\xe2\xba\xe3\xfa\x04\xe9\xdd\x87uC#Z7W\\\xb3\xb9\xbac}C\xf8\xc0\x12,\x97\xbc\xefoE\xd7\x8da\x15pcE\xbb\x0114\xca\xfd\x84\xb8X\xf48v\x87\xeb]\xd9_\xf5\xe5\x8ez\x0d\xee\xf42_\xed\xb0b\xf5f \x19y\x13\xf9\xc9\xcd\xf9\x0bus\xaa+\xe2\xbb\xbeh\x17q\x8b\xa2\xb3\x88Y\xacA\xd6[\xea\xe4\x82\x82\x96\xa9\x91\xd9q}\xb0U\xf2\xc5\xb3\x10\x02\xae\xc6w\x86N\xe44\xd1\xd4\x85(zPl+\xf5\xbe\x86\xe9?\x11\xdd'\xaa\xf7\x04u\x1e\xb2\xbe\x833|\x0e=\xe7K\xe98\xb1I9\x86~3\xd1)\xbe\xb8^\x13\xad\xff8\xfa\xccD\x97\xf9\x92z\x0c\xae\xc3|)\xfde\xd4]\x10Q\xa3.!\x12\xfc\x91\x9ck\xea\xd90I\xca\x0f\x1a\x1d\x01\x14\xe7\x8b\x93l\x8c\x84\xc5\x05\x08a[*\xb6\xd1\xc3?\xef}\x16\xb3\x95\x01\x87\xd2\x12\x8d\xc0!\x96\xf9\xd6\nK\x03\xca\x1ah\x07\x93`\xbb`\x1c\xeadqQ\xc2Puc\x89Q\xa8f5\xe9\xb7F\xe8p\xa8\xe3\xaa\xbd\xde\xe5\x1ed\xe4\x00\xbe\x80g\xd1\xcf\xd4\xa5\xff\x17_\xa0\x9aO\x18d\x16\x07G\xb9$\xf5\xf7S\x94\xf0Eb\xc1\xe6/)\"P\xb6\xd7\xed9\xe1\x96\x9cpK\x8e\x8f[2\xdd\x0b\x12\xf6\x9c.i\xd3\x99yW\xa4:\x87\x07\xaf\x8c\xb4\xdeqCy\xe5\xcd\x91-\x93\x970\xf4\x8dz\x7f\xd6j\xd0U!\xf7\x19y9\xc8j\xeb\x8f\xac\xbe\xe9o\xb5;\x11\x8d\xae\x1e\"\xabC}\xb6_\"tZ}0\xab\xd7h`?\x9c\x94\xe1\xf9\xfb_\xd6\xddo\xb92\x0c\xd3\xce/J\x0f\x80H\x8a\x00\x90W\x8b\x1b\x1e\x971]\x00<)\x030I\x1b\x00i\xa3\x0e\xafG\xf3\x15\xc2j\x14\xaf\xcfZ\x8b?\x1f\x9a\xf6\xb0#\x0e\xe6\xdc D5\xfb{\xd6\xaeY\xdd\xf3\xdd\x94\x0b,\xb1\x9bu}\xf1\x91\x19\x17O\xdc5=S\xec!\xb77ww\xbevBY\xd7M\xdd\x95\x1b\xc6\x19R\x18\xd9L\xce\xe9o[\xd6\xf1\xf9\xfcB}\xe4\x1c\xd2\xf6*\xc6\xe3\xcf\xac\x13=\x92\xe9\x1f&\xbfsmd\x05/\xa5\x95\x0e\xe7\xa2\xffk\xf5\x7f\x9b\x1d\xb9c}s\xf5\x85{#U\x81f\x0b\x7fdjn\xc4\x9a\x10\xd7\x9b\xab?\x85\xfb}\xda\xbd\xe8\x8c\xf1\xce\xb0\xcd0\x00\xba\xcb_?\xf9\x1dr\xaa=\xc2\x05\xc3\xae>\xa1\x1a\x9f\xacQ\xe8^?\x9d\xb3\xfa2\x9a\xa2\x9c\xa4\x1d\x08\xed\x91\xfe\x1d\xb2\xf7\xdca\xb2\xf8\xb4\x971\x99\x07\"w\x99\xe4L\xea\x81\x9c\x89=\x10\xbe\xd1dQ\x82\x0fdL\xf2\x81h\xa2\x0f\xccM\xf6\x81% ?\xd8\x88\xdd\xef\x05\xbfxo7Y\x90\xf8\x83\xd0\x92\x8a\x94\xf7\x86\x93e @\x08\xb9\xc3\xde{\xcbI\xeeD X\x9e\x0c\x04\xf9\x13\x82`YR\x10,K\x0c\xc2\x97(\xda\xc8l\xe9B\x90=e\x08r\xa6\x0d\x01)u\x08r\xa6\x0fA\xf06\x94eiD\xd8\x1aGoD\x91\xa2&\x9a\\\x04\x8b\x13\x8c\x10\x82\xd8\xbd(\xb3\xd3\x8e\xc0w7Jd\x8b\x0f\xdc\x8fB\xd9\xffg\xa6\"ab\xcf{KJ\xac\x1d\xcb\xd2\x92&\xc4D\x92\x12zWJ\x96\xf4$\xc8\x9d\xa2\x04H\x9a\x12,OU\x9aP\xeb\x91[S\x96%/A,\xa7\x07Bw\xa7\x10\x12\x99\xc0wiCBB\x93\x9f\x86\x13\xd0\xbe(\xb9 \x12\x06#\x96\xe4\x04\xd1~G\x93\x9d -\xe1 \xd0\x1b\x00\x16&>A,\xf9 \"7\xab\xc4\xeeV \x8c\x125\x19\n\x08 Q\x80\xde\xb1\xb2(1\nh\xc9Q0+A\n\xbc\x03\x13M\x94\x82|\xc9R\xe0o\x85\xc3iY\x13\xa7`a\xf2\xd4\x84\x14v\x0bK\xe6t*\xc8\x9cR\x05\xe1\xbbX\xb0\xdbX\xb0\xfbXr\xa5XA\xce4+\xc8\x9ej\x05@M\xb7\x02J\xca\x15\xd0\xd3\xae\x80\x98z\x05\xf8\xfd,\xf8\x8d\x1d\xf4D\x9d\xd8\x1d-\xe4T,\xa0\xa5c\x01\xd6\x8d\x9ciY\xb045kB\x0b\xb9\xbb%g\xb2\x16dM\xd8\x82\xc5\xfc\x10M\xdc\x02B\xf2\x16X\xf7\xb8\xb8I\\\x10:\xcdL\x93\xb9 \x16w\x1b}\xd7\x9b\xd4\x85\xbf\xeeK\xec\xc2\xdfv\x92\xbb\xf0\xd7\x90\x04/\xfc\xc5I\x92\x17\xa4\x04>\x8f\x1f\xf8#\xfe\xf3\x04B\xeb\xf2\xa5\x02\xa2\xfd\xf5\x1d?0Z\x17$\xe9\no\xd2\x91\x03\xa5\x93\xdbs\x9c\xc0\xe9\xa1\x19n2\x18\xde\x8c\xe3\x05R\xeb\xe2O\n\xc3[t\x9c\xc0j]\xec\xe40\x88$\x88\xc1<\x8f\x10\x92,\x06a[\x11\x9a4\x16\xf9\xc6M\x1e\x8b|\xe0O\"\x0b~x\x84d2\xf0%\x94\x05\x1b\xe2K\x15\x02#f\xc7\xcd\x17\x9aM\xd2\x93h\x06\xa7\xb0\x9b\x7f\xa2\xb0\x9b@\xba\x1a\xcce\x1co\xea\xdaL\x8a\xd9\xd3\xd8\x82\x01\x89S\xbf>)p@7*) Q}\x94\x1e\x93\xa8\xfb\xf2?-\x0e\x1e\x8d8\x98- zo\xdcADF\xc4\x17<\xe4\x8f>\x88\xc5\x1f\xe4\x8e@\xc8\x1c\x83\x10\x89BX\x1c\x87\x907\x12\x81\x12\x8b\xb0 \x1a!o<\x02)\"!oL\x02!*!{\\B$2a^l\x02J(\x18\xaf\x90%b\x81\x18\xb3\x80~\x99\x14\xc7\xb08\x92!w,\x83?\x9a!s<\xc31\"\x1a2\xc74P\xa3\x1a2\xc75\x84#\x1b\xb2\xc76\xf8\xa3\x1b\x12\xe2\x1b\xe6G8\xa0\xc4|\xb0\xaa\xb2,\x88r\xf0\xc69DU\x8a`\xac\x03M\xe3\xc8\x17\xef\x10\x8ex\x88\xb7&k\xd4C8\xee![\xe4\xc3\xd2\xd8\x07\x87\x9c\xd0hP\xe5!o\xfc\x83/\x02by\x0c\x04\xc1\xf1\x1f\x8c\x83 FBx\xdd\xa9\x89\xd1\x10~:\x88\x8fiqLD\xca\xe0P\xe2\"\xe2\xa3@\x8a\x8dH\x8e\x8e\xc0=p\x19\"$\x081\x12\xb1(\x89x\x9cDp\xd4Rb%h\xd1\x12x\xbc\xc4\xe2\x88 r\xcc\xc4\xdc\xa8 \xff0\x91\"'\xb2\xc6N\x04\xda\x82p\xe2\xa2\x08\n\x87\x1a\x12Q\x915\xa6\xc2\x17U\xb10\xae\xc2m\xb2\x1bg\x91?\xd2\"\x12k\x81G[\xe0\xf1\x169#.2\xc7\\\x1c#\xea\"%\xee\x82\x18y\x91\x14{A\x8f\xbe\xf0\xc4_\xf8<\xeet\x9f{<\x06#)\n\x83\x1c\x87\x81v(w,F\xdeh\x0cOj#>\xdd\xc7\x8c\xdb\xf0FJD\x99\xeax\xb1\x1bIm:n\xfc\x867\x82\xe3\x1f\x13\xc3\x11\x8b\xe2\xf8\xf2q\x1cX$G<\x96c\xb6\xaf\xcd\x13\xd1\x11s\xc6\xfb\xa2:\"\xdf\xe1\x91\x1d\x91\x8f\xc2\xd1\x1dt\xff\x7f\xbe\x08\x8f@\x8c\x07\xc9\x83\x8a\xf9\xd6c\x91\x1e\x0b\x08\x07\xe2=\xfc\x11\x1f'\xe8\xb1\xe4\x18\x90\xccQ \xb9\xa0\xc7\xa2\xb1 \x0bX+\x18\x112\x9b\xee\x11\xe2BN\xa8g'\xd4\xb3\xe3\xa0\x9e\xfd7\x1ad\x94\x06O\xa2?J\n32\xf6\xb3\xe4@#\xb1\xd9M\x83\x8cH\xfc\xfb\xbf\xfc\xbe\x80@|\x192\x1f\x94\xc9\x17\x9f%M\xfc\x1f\x9b\x9e%\xcf\xf8]\xd3;X\xf3\xa4 \xf7\x06\x8b\xa5/q\xde\x06\x1a>\xb2\x0c:\xb1_\x0do\xe5/\xd9\xbee\xeb\xa2g\x1b\xbee\xb0-ku8\xcd\x07I\xac\xfb\x00e\xdd\xf5\xac\xd8\xa8\xc0\xabao\xeeX\xef\xba \xb9\x08,Y7\x15\x14\xc2y\xb1\x91\xc6\xe2r\x0b\x1f*V?R\xf4\x1f\xc3\xb3g\xf0\xf5\x07e\x80.z\xd5 a\xb4\xfa\xc4\x84c\xfb\xeb\xe9\x01\xe3\xbc\x16\xb1C\x93_\xa5+}]t\xac;S\xc1\x05\xa2\xad\xc2n\xa5\xcf\xc1}\x03\x7f|s\xf9\xea\xea\xcd\xc5\xe5\xf9\x9b\xd7\xe6\xb1yE\x19a_\xea\x8b\x87f\xf0\xbd?\xbfz\x17|\xfe\xfc\xdbw\x97\xcf\xcf_\x07\xdfy\xfd&\xf2\xf8\xeaO\xe7\x97?\\\xfd\xf1\xd5\xe5\x9b W(\xf3G\xbc\xe1j\x9e0\x06i\xd8\x9b\xce\xd4\xe1/y&P\x96\x84i\x1c?\x89\xa9\xf6\x00\\T\xbe\x91\xcb\x10\xb5b \x8c9\xc5\x17Z\xf4\x97w\x0c\x0f\x90B7\x05\xf4M\xff\xf4x;h\xecHu\xf3U\xb37\x9b\xe6q\xca9\xb3\xfat\xfa\x83A\xf4^\xe1\xcf\xa5\x90T,\xf0\x14\xfb\x11L\xb4b\xb9\xd3'\xd3\x7f\xfd\xe6\xe9\xe4ok\x14f\xd0\x1bylJy|b\xd7!Nzw\x1a\xd3\xce[\x9b\x14\xe0\x89K\xd8\xe2\xd0? \nlc\xb0\xe4\xd8\x90C]\x8a@\xcf\x01\xf3P\xfc\xa7\xdbW&\xae\xaa\xdfl\xcbi\x1a\xd4dO\xea\xb8!\xe3\xb9\xfcR\x80&v\xfd\xd4Bu\xfe\xf2L\xdb\x14Y{6\xdc\xf4\xe9\x8c\x93\x8b\xd0gj(\x14\x1dH\xb4\x82\x86\xce\xc7_M\x0f\xac\x17\x00\x85S\xf5\xe7\x17\x1eT\x8fhK\x01R\xf8\x1e\x13\x93\x91\xcb\xb4&\x87\\Y\xfb\xf4\xa6\xec\x9a\x93Ow\xca\xac=\x05'\xcf\xe7\x9a\xa2\xeea\xf1m\x99\xb6%G\xb7c\xf2V\x9c\xb4\x0d\xa3\xfa\xd4\x97\xb5(\xfa5\xab\xa8n\x15\xd2\xaeR&\x11{\xdf\xa7aQ'\x14{\xd7\xa3e%L\xae,IS<~\x14\xd7\xb52k[I\xfa\xd6\x17\xd2\xb8\x8e\xa2s\x1d_\xeb\xca\xafw}A\xcd+\xa4{\xa5\x18\xff\x97\xeb_a\xc7\xf9\\\x1d,\x97\x16\xe6\xb4O\x822k\x0b&\xffF\xee\xcdr\x1dv'\xbb\xf8\xc9.~L\xbb\xb8\xab\xadSO\x02\x04\xa0na4\xbd0`\xf3 g\x80)\xbe=:\x15(_\xf9\x97\xfdR<\xfb \x1e\xba\x0f\xbd\x1e\xc1z\x9f\xd9\xfa\xdf\xa3\xadog \xd5\xbb 5\x06J\xbd\x0f\xa1~f\xab\xd11\x9f\x8bH?\x19\xf3$\xfcy\x83\xef&\xc2P\xfc$x\x99\xbfR\xd67\xaa M\x8dm\x00]\x88\xaf\xdf\x1a\x01\x1e\x04\xbe\x9exd\x90!v<1\xc8;\xb6\x07\x06y\x01\xf7\xbc8/f\xf6\xb8 c\xf4\xc7\xc1\x93A\x18\x1c\xf4T\x1e\xe4BK\x00O\xce\xe0\xc8\x87\xd3\x13\x88\x7f\xb5-;k\xdb\x1e\n\xe4\x94\xbd\xf4|\x0d\xe7f\x05\x93\x93u\xb635:\xf4\xd3\x83\x18\xe5\xf0\x15:p\xc5\x0eY\x81\x83\x15\xe10E<@9\xa7\xe3c\x18\x9d\xf0\xf3\xef\xc9dA\x8c}EN\xb2\xd9\xce\xb0\xc4\xd3\xeb\xd1\xcf\xad\x99O\xac\xc7<\xab\xe6<\xa5~\x91\xf3)~2\xf5,\xbf\x8c\xa7Q\\9\x9as\x02\xcdq\xf6\xf4\xec\xd1o\x0c\xd9\xe4\x0c\x89}q|x\xe9\xfadNH\xd2x\xe4KD\xaa\x90d .A\xe6\xca\x0dcr\x14%WZ\x1cIFd\x91\x0c\xf9\xe5\xc1r)p\xc4\xb5\x8f\xf3zY\xdf$\x1eF=\xd7=\xa2\xa2\xc3b\xb8\xe85\x8f\xd6\xdbf\xdb|\x07\x16E#\xed\xa0\xe2\xca/r\xd7\xa7:\xcb\xff\x1e\x950\xa4}\xe4\x93\x1f\x80\xca\x10\xb7'\xd9\xe4\x88Kz\xa6,q \xe5\x90'.\xd592\x05\xa3\x92Q\xae\x00\xa2M\x84\xcf\xd6K4\x08\xb5\xa0we\xdd\x0f+:Q\x80\xf1o\xaf&\x01\xfd\xe8JV\xd6\xcb^\xa1~\xac\x9bR\xe4C\xf2\xef\xd5;e\xbd\xad\x84!\xf9\x8a3\xfd\x95\x84\xdc\xa1Q\xdd\xa9[;\x8b\xba>\x14\x95B\xeb\x81\xb2\x1ei\x02\xa7\xe9T\xb4+>\xa7U\x10\xa3\x17\xb1\xae\x8c\xf4\x94\xf1\n\xa5w\xd3\x14\xd5\xd5uSoXlKP\xd4\xf8\x07|P\x95\xf9\x11\xe4\xb7P\xf4\xcdN\xe7\x15]W\xcd\xfac\xc77\x9a\xab{V\x84m\x19^+\xb4\xaaN\"\x95\xb1\x8d\"\xca\xab\x05N\xd4eN\xb5\xe3\xc8\xccX\xe3\xa2Rm\xec\xe5\xb3\x0f\xbbfs\xa8\x98\x8f\x1f\x85=\xf8\xb9\x98\xd7\x8b\xb6\xb9+;.\xf9\x92\x03?$c\\\xed\x07\n\xc4\x01\xf0\xdb\"\x1d\x8a\xda\xac\xad\xb0\x9eD\xdfD6\xb1\xe4I\xe3EaZ\x0ci\xf0\xc1>\x07\xcd\xe7&\x81'S\n\xb8=\xdd\x1d\xeds\xcd\x94\xc9\xc3<\xb0\xf3\xe2\xe1\x1d\x17\x86gX\xc7\x17h\xc3\xe9t\x8a\xe2\x86\x18>\n\x05f\xbb\x038\xf3*\xf2\xe0\xfd\xbf\xe1\x9b\x7f\x95\x1e8.%s\xf0I\x8e7L\x90C\xc8\x88\x14\x17\xe8\x10\x17\xea\x94\x1a\xd2\x84;\xf8\x05|Je\x14\xda\xc4\xa4\x06\x9a\xd0\x07\x9f\xe0\xa7P&l\x00\x10\xda\x04\x82u\xc4]\x92\xf4\x0d\xe1\x08\x17\xf7\xca\x85a\xeb//\x0c6#,\xbc\xeep\xdd\xed\x8buX\xd9\xb0\x9c\xd2\xc8\xf3\x89\x1f,\xac\xb5\x0d\xb2\xc9h\xae\xa9\xc8\x96\xf5\xa6\xbc+7b\xe3\xd0\xab\\q\xbe\x84\x8d\x91\x00\xa1&\x11\xfe\x8a$t\xe1:N&\x83\xb4XJ\x85\x84\x94%\xa3t\xac\xc1\xd0\x8bY\xc2\xc9\x9d \xf0s,5z\x00A\x02\x0cO\x9a\x87y\xe72nW\x15\xddmY\xdf\xccU\xbd\xbb\xf2\xa6f\x9b+\xb5\xa8?\x95\xf5\xa6\xf9D\xdcw\xcd\x95\xbc+\xeb+E\x8a\x0b\x86$:\xc6\xfe\xbdi>\xd5}\xb9cW\xffY\x94\xd5\xd5Fa\x86\x04\xe9\x88\x01\xb8\xda\n\x9c\xdd\xa6\xbe\xda4\x87\xeb\x8a\x89\xb6\xa4W\xef\xd0\x92\xadI%\x84i\xaf\x03j\x8c\xb3\xeb\x0eH\x9b\xd72\x1aD\xcf\xa8\xab\xd2:s\xbdx\x05:\x1a,m!\x05y\x06(\xdb\xc0t\x17\x88\xf0\x0f\x89\xe6$|'\xc6K\x01\x9a\x14\x9e\n|\xeemR\x94\xbf\xd2\x89f\xe7\xb5a?\xce\xb5\xcb\xc6\xf8\xf7]yS\x97\xf5\xcdy\xbdm\x92\x99\xf8\xae\xa8\xc4\xb4\x94\xf5\xcdUYo\x9dX\x02\x12;\x17\x9bM\xcb\xba\x8e4\x0b2\xed\xfd\x16q\xd5D\xa7\xcd\xab\xf8\xfc \xbd\xe6\x85\xce\xe8\x176\xba\xa2oZ\x111%\xd0\xb3\xa0\x80uQo\xf8\xcf\x0c\xde\xbc\x15\x0f\x0e\xf5\x7f\np\x0f\x83dYo\xd8\xe7\xabf\xbb\xed\xd8\xf2\xd6\x85\x9d\x9b\xe7\xbc*\x0dA\xd0AY\xaf[\x81B\xc06\xc0\x8a\xf5-p\xbe\x1e-\x8eCo\n\xa5U:\xa9\x905\x7f\xc4\x05\x8ap\x0c\xed\x8a{ \x10-e\x82p#\xb1u\xb3\xdb\x95\xbdD\x16\xefUT\x83\x93j\xb9n\xea\xffTh\xab\xd2@\x86 \x97\x7fx'\xa8~+\xe4\xd7\x9f\x84\xa8\xf90h\x1d=kw\x83\xe2!\x06\x14\x07Y\xfe\xf0S\xd9u\x9a\xc8\xb7e\xff\xbcm\x8b\xfb\x0f\xa6\x89ON\xcf\xd5\xa1\xee\xcb\xd4\xc0=\x1f\xa8GhF.\xcb\x1d\xeb\xfab\xb7\x07Q\xa3\x9a\x1b{\n\xcaN\xb5\n6\x07\xc6\x0fZUy\xc7j\xd6M\x81c\xb4d2\xbb\xd37\xbb\xeb\xaeoj\xfcXq\xdd4\x15+j\\`!\xcf\xc2}\xf9\xd3-\x13A\"r\xae5\xd6\xb1\xe8\xc2m\xd1I\x9c\x9d\xb1=\xf0\xe8cY\xf1N5\x87\x1e\x9ait\xe2\xf8i\xc7\xfa\xc7+8\xefu\xc6\xc9\xe4\xc5\xa6^OYV\xb2\x9cP\xa6\xd9\xcf\x87\xf2\xae\x91\x00\xe9\xbc]\xc2l^\xdf\xcbh\x16\x97 \xb7\xe5\xcd\xa1e\x1b\xd8\x95\xdd5\xbb-\x8b;\x1by}'\x98Go\xa1\"h\x92\x98\xcd<\x7f\xc9>\x07U\x0f|d\xfb~\x04W?\xd45[\xb3\xae\x13\x97\x0fp.\x86\x96\x15\x9b\xce 0x\xdd\xf4\xear\x8b\x0f\xef\x0e\xbbG\x18\xff?\xfe\x00E\xf5\xa9\xb8\xef\xf8p\x15\xd5\x94\xad\xac5\xf3B6\xc6X2\x01\x87\x86\x9e\x11c\xb30\xbd\xd3\xfa\xf1\xc3\x0e\xd4v\xc0\xcf\xc72Zo\xd7\xd4e\xdfLF\xb1\xbfe\xa5\x859\xa9\x17\x02\xf0\xbd\xf9\xae\xec\xef\x8d#\x86\x14\xd3\xd3\xbdFo\x86V\x85\"`VD\xc2\xca\xb0K\xe1\x0c\xd7;\xcc\xaf\x0cjv\xba?\xb2\x07R\xf6Z\xe33E\xed\xed\xc5\x0b\xdd\xab\xe4\xdd7]\x87\xc4\xb6\xdc\xbc1I\xe8\xde\x1cX\x1b\xfe\xfd9\xf0QhI\x1da\x97\x0e\xed\xd3\xb3[\x19\x0bE\xca\xbc_g\xdc\xb1i{v\xa6]\x9b\xb2o\x87vn\xd2\xfc\xe0\xbbw|\x8er\xee\xe0\xf8\x1e\xee\xdf\xc5C\xfbxx'\x8f\xf7+\xe7n\x9e\xb0\x9f\xe7\xdc\xd1){:iW'1\xd0\x9c\x05\xbetw\xcf\xb1\xbfGw\xf8p7\x16\xec\xf2\xf64\x0c;\xbe\xbb\xcfSv\xfa\xd0\xee^T\xd5\xd8\x10\xdd\x7f,\xed)\xe1\x00zJW\x8a\xf9\x06~\xf9\xe9J\xe05\xce\x8fU\x1a\x8a]cAF\x975\xdc\xbc\xbdx1\xeaz\n\xaf\xb9\x83O\xb7\xace\x93}l\xdd\xb4\xf2E\x813\xad\xd4\xcd\x01\xe2\x99KTa\xe61\xbbi\xf5M\xbf\xf9\xae\xd9\x8d\x8dBQ\x9e[\xb6g\xe2z\x92o\x8bv\x18Y\x1f\x1e\xb9\xd5G\xc1\x1eS4r \xde\x1cS\x80\x93\xacM\xe6w\x8a^\x8a\n\x8cI\x1c\xb2\xf6\xeb\xe8\xa6\x08\x83\xe3\xfa(\xba\x12p\xe1\x9fU\xfb\xc4\xf5\xce\x84\xd6\xf8\xa5wF\xfdr\xbefij\x92\x06AL\xa7\\\xacM\x86\xf5H\\\x83\x0c\x8et\xe4JSk\xb4si\x8aS\x1d\x11\xd3\x0eq\xbd\xd0\xa7\x11\xfa\xdb\x9cK\x0b$\xe9\x7f\x0b4?C\xd33\x08\":_D\xdb\xcb\xb2\xac\x96hu\xcb\xf4\xb9\x80&\xe7 Z\x9f\xaf\xbd\xb96\x1aKoC56-\xd2{q\xb7\xde \xd1\xbfm\xea\xcd;\xe3Z\x00g\x16\xecd\x81o\xdf\xbc~\xe9\xc7\xb8\x9f>\xe7\x7f\x05\x1f\x9e\xbf\xfe\x1e}j|8\x84\xf7\x86\xaa\xc65\x89\xb1o\x83vj\x80\x81\x0f\x03l\xc6\xfa{*y\nh\\n\x0de\xad\"\x84\xc7Ef\x03\xe3\xe3C\xc2\xe9\xc9\xffa3.\x99P],(\xe5}\x90\xde\xf9\xeb\xef5\xc1\xf3\xd7\xdf\x07)\x1e\xeak\xa9\x07y\x08\xea\xe6\x11\x1a76\xcc\xc3Z/\xb8\x00\xe9\xba2!<}=|\"\"\x97|aY\xd6\x92\x9f~cEB\x88[M\x85YQ\xbf\x04*\xb8[h\x94\xda\xbfg\x92kY!C\x08M\x0e\xd1O\x13N)\xbc\x1e\xa2Bou\xee!\xffp\x08\xc0\xb3\xdb-\xae\x1d\xbe\x91'\x90\x0d\xab\xd8\x8d8U\x9d\x81\xd0\x0c\xb4\x9ft\xf5\xd0 \xbe+>_\xcdm\x89s\x8a\xd0\xc4\xac!\xd6\xc1[\xd3\xa6N\x15\xaf\xb5c\x07aw2\xbe\xa6\xbda\xd3.Lz \x83p\xf2v\xc4\xa0\x89\xf6gS\x94\xd5\xbdT\xcc\x8a\xces\x07\xf5d\xb7\x14\xbd\xf7t\xe5\xb0\xe7\n\xcbUB|DD\xc11\x08jn\x11\xb7P\x0f\x9a\xa33!E\xa7\xa2\x99\xb0l\x95q\xb5\x0e\xa3a\x10\x98\x84\x11\xeb\xfc\x07k\x85D\xc5\xc0\xdbqI\x13d\x81=\xd9\xe8H\x1di\xdd\xb8k&^\xbb\xc5bK\xd7\x89X\x19\xa6L\n\xad\x11\xef\xfa\x98\xd1\xe8Ykbl\xbb\xd9\xe4\xf0z\xc0\x9b1a\x95\x05\x92\\Kq\xbd\xb5\x17$V})Y#e\xc7\x1a\xb8\xe9\x8ar\xbc\x9dt\xdc\xf9X\xb3\xef5[\xdf\xfe\xee\x9b\xafX\xbdn\xd4\x15Y\xe2\xe9p\xa7\x9b\xfaL\xb3\xc0\xd0\xb79\x8dp>\xa65\xc2\xd9\x1c\xbb\xdb\xa2eI5\xcb/\xd4,\x9b=\xe3\x93\xab\x1e\xb6l\xcd\xca;Tb\x0dz\xde8m\xd3P\x1e\xae\xa3\xa8\xe3l\xf3\x91\xd5\x1d\xdc\xb2J\\\xd6P\xd4P\xac\xc5QA\x1d\x88\x14\xa9\xe6S-oshjc\x9c\xd5e\xcf\xe2\xfa\xf2f]\n\x13\x8f>$\x0fi\x80\xcd'iQkj6\x9d\x16\x12\xcb%{\x137\x13nE?\xc3?\x850\xe7\x02yg\xcd\xc5\xc1\x10\xe6bz\x83rq3 \x1cMoE:g;$,{hF\x0e\x87\xdc\\\x0eSN\xe7\xe5\xba\xa8\x8a\xda\x8d\xed&2&5\x1f\x02\xbb\x99&.v\xac\x91\x9d}\x03\xcdHb\xc9\xc53\xa3\xc9U\x17\xda\xed21Ah\xda\x84\x85\xf5\xa6\xa8X-\xec!\x06+\xb1\xcfka$\x11\x07\xba\xde\xb8\x99\xdc\x9e\xc4\xe9m\x8a\x8a\x7f\x07\xdb\xe5\xaei\x19t\x87\xb2\x17\xee\x03\xae\x1e\xae\xab\x92\xd7\xa6\x0d\xd1]P\xfe\x8d\x1d\xa1\n\xbe]S\x97\x1f\xa3\xa6#k\x88\xd4'\xc6L\xdf\x1evE\xfdU\xcb\x8a\x8dh\xb6\xb8\x0eT\xdb\xca\x1dv.7\xac\xee\xcb>\x9c\x8b\x10R\xae4\x01\xd3v \x13P\x8bj|8\xcc=\xb4e\x7f\x7f%\xf8c\x1d3\x84\xdbrp\xf2-Z)\xdb\x15e%\xc6^\xbf\x0e\xeau\xdd\x84\x0d\xeb\x8b\xb2J\xd2-\xd4'Z\x04KK\xe5P\xa5z\x8a\xac%\x83\x1fQ\xeb\x87\xf1r\x80\xab\x7f(\xbb\xbei\xcbuQ%yHnY\xb1q\xf9\x9a$4\xefX\xdb\x95N\xb8\xb6t\x86\\\x17]\xb9V\x1e\x82r\x8c}\n\xd4\x01\x81\x10#\x95\xd14\xfd1\xb05B\xd8g P\xec\xf7\xf9\xc8\x85O\xfe/\xb8@\xaa\xbbC\x07\xebb/\xc5\xac\x03\xdea\x80\xd8P@x8\x86I\xbb(\xda\xbec\xfd\x0fbT\xa6\xd3-\xbdOWn\x13\xa2\x1c\xe4\x0b\xf3\xe0\xa4\xe4\xda\x92\x8c\xc2\x97\xa0\xf1\x1e\xff3Cuc\xacK\x06b\xd3\xb6o\xdbf'\xc4D\xb1\xdfCs\xe8\xf7\x87~\xfcm\\\x03\x06\x05\x11\xca\x92\xb5M\x83\xa4\xcc@\xab\xd8\xef3P\x11\xfc\xa2\xa2-2\x90cw\\\x1f[\xb3\x0c\xa4\x86\xf9\x1b\xb7\x97\x89x\x92X1,\xf5\xc8\x8b\xd6gm|rUY\x16\xb4a\xbb\x91\xfe\xafKVo\x84\xdf\xbeW\x0bB\x8a'\xc3\xa6\x84D=\xe4\x8dV\xe6\xbf\xfa\x0f\xfcA1\x13\xde\xe5]\xd2\xd6H\xf8\x0e\xff\x0f\xdd\x00=M\xe7_\x85\x01\x01\xb4\xf9\xa0\xac\xc5E\xf3+\xeb\xfdqi\xec\x0f\xd7N|ZP\xce\x87\xa4<\xff\xec\xea\xd0\xa2b>\"\x88c\xa3\x04\xc2e\xfe\xfe\xed\x8fOZ\xd65\x87v\xad\x0eB\xe2Hx\xa8\xcb\x9f\x0f\xac\xbaW\xe7\x93m\xa9F\xafW\xe0\x03X\xb40\x88\x03C[\x16U\xf97,\n\x1ad_\xfbf\xddTp}\xd8n\xd9p\xd9\xbe\x8aJ\x91}\x81\xdd\xa1\x1bN\xa4P\xf4P\xb1\xa2C\"VA\xc4.0x\xf0\xe4\x81\xb0\x92\x17\xeb\x9e\xb5+q\x18\x17\xce\x90\x8e\xdd\xf0#\xb7\x9e\xe9\xf7o\x7f|\xd8\xc1\xbe\xe8oE\x05(\xb9\xc1\xc0\x82\xd7\xc6\xc9l\x0fUu\x0f?\x1f\x8a\x8a\x8f\xcaF\x8e\x99\xaaB\x8c\xce\xa3B\x04n\xa3\x04>\xf0\xea\xbd\xf7\xfd\x7fx,[/Hv\xb7\xcd\xa1\xda\xc0\xb5<\x82\xa3\xd4\xd6E\xdd\xd4\xfc\xa0!d\x02^\xe3#\xb6\xbaY\x9d\xf1!\x14\xaa\xe8\x83\xd5\x03\xed\\.\xd6k\xb6\xef\xd9\xe61~\xa5\xae\xb8\xe7e/\x0c\xf7kv\x06=+v\x1d\x1c\xba\x83\x80\x0e\x96QE\xfb\xb2\xe2\xad\xeb\x1b\xa9\n\x97\xb5\x88\xb0\xa8*|\xec\xee\xf7\x82\x87\x8a\x9e\xbf}\x8fW)q\x0d\xa0\xec5B\xafB\xb8\xe7\xcc\xc0>\x8b\xa9|^\xdf\xaf\xe0\x87\xe6\x13\xbbc\xad\xcc\xcc\x7f\xff\xf6Gw\xed\xf2\"\xad\x14\x9c\x0c\x1a$\xcfK\xb7\xbee;\x06\x1fn\xfb~\xff\xe1L\xfe\xdb}8\x93\x817\xea\xe9\x99\xe0\xb2\xb5ql\xad\xee\xd1[x@\xb8\xfa\xa0\x10}\xf5\xd4\xc7\xda;\xa6\xfc\xe8\xbbb\xdfI\x96\xe1=\x10P\x1e*\xdaP\xc8+\xa1\xcbw\x80\\T\x0eb\x17\xa8\xaa\xe6S\xf7\xd43w\xbf\x81\xf3\xed\xd8\x03>\xe5\x02\x0eg\xc36C'\x95\xb5\xef\xb0c\x1b\xcf\xed\x1e\xbf\x81\xe75\xfcpyy\x01\xdf\xbf\xba\x84\xa6\xd6\xcbH.\xd0{a\xe9\xc29\xf3/S\x16\xbf\xbc\xdf\xb3\xbf\xfe\xe5\xaf\xe8\xcb\n\x18\x80\xcf\xb5\xe2!\xb9\xc5\x89Y\xd8\xb7\xcd\xe6\xb0f\"\x12\xa9m\xa7A\xe4\xba\xfc\x06\x9e\x8f'\xa4\x0e\x8a\x96q>l>I\xaf\xdf\xbaXs\x99\xd04\x1f\x0f\xfb!4\xf3\xba\xe8\xd8\x06\x1a\xfc\x0e\x14\x9fx\x03\xde}\xd1.\x11e\xd7\xdf\xb2\x9d\xb1\x166r1\x14\xba\x1bC\x04RQOo\xe4\xd1E6J,\xfb\x96m\x9b\x96\x9d\xe9\x8f9\xcd\xa2/\xaf\xcb\xaa\xec\xef\x05\x9a\xbdvw \x11\xd5\xdeM\xf2d\xc6\xd2\xd4\xca\xd5+>\x10\xebn\x05\x8f\xdewL\x1b\n\xf8\xa8p\xb6\xe3rF\xf2]Q\x177\xbe\x1e_\xb7L\x1884\xd1\xd5c\x9c[^7={\xaa0\xaaU\\a!\xda\xae\xe4\x8d\xc2\x13\xaa\xee\xcdxc<\xef\x84\x97F\x84J\xbb\xa1\xc6\xb2h\xc6\x82\x96\xf1\xdd\x81)\xfb\xf5\x1093$o\x8f\xeb\xeb\x9a\xdd\x94u\xed;\xb4|*\xfb[\x8f\xd0\xbf\xdf\xb3\x95\xe4\xe7b_v\xabu\xb3\xf3I\xccwb\xb5u\xca\xe2\xd4\xdf\x16\xf5T\xb2\xc0#efd\xbb}\x7f\xaf\x96\xe7c\x94\xd8ND\xb1^{\x04\x89\xe8\xa0\xb0U\x0f\xb6e\xe5a\xd8\xb3u\xb9-\xd7\xd0\xb1]Q\xf7\xe5\xbas\x97\x0c\x02\xc4!KD\xa5\x08\x9e\xech\x1a\xc7O\\t\\3mW3\x14\x06G7P\x9bjq\xdd\xdcy\x94\x0d\xd9U\xc5\xce\xd3n\xc6Z\xf3\xe1y}\xff\xc10|\xd7P\xb4\xd7e\xdf\xf2\xc5\x17h\x95\x92\xd1\x0e\xb9\xa2j\xea\x1b\xe5=p\xa7\x8cKM!\xf4e\xab\xae]u\xca\xacSkE\x08\x9b]h\xc6\xaf\xcak\xd1T%\xd7;\xe8\x0e\xfb}\xd3\xf6\xf2\xbe\x88\xf5\xc7'\x87\x9a\xff\xc3\xf7K9\xdfh:\x99\xd0hP\xe5\xa1\xd9\xc2\xa1\x97\xc2G/\xe7\x8e\x0b>\xed\x0d(*\xb8a\xb5\x80\xcb\xdc(O\xc6\xa0T?G\xe4\x9d\x9c\"\xb7\x9eW\x9f\x0b\xce\xc0\xf0\xf5S\xb8(T\x18\xb3jz1l\x88e\x0d/~\xfb[\xcf6\xf5]\xd3\xc0\xb6i\xe0\x19\xacV+4\xdc^\x0cBQ\xdf\xe3\x0f\x8b\xfa~\xc5\xab\xfe\xaemv\x8f\xb6M\xf3\x18\x7fm\xb5\xc2\xf7\x9er\x0b\x8f8\x89\xf7\xa2\xd1\x97\xcd\xa3_s\x1a\x8f\xf1,\x81\x00\x9d\xbf\xfb\xc7\xe6\x9b\xc8\xd8\xfc\xa1\xb8+\x16\x0f\x0e<\x13\xba\x15\xa7\xbe`\x14\xca\xee\xd1wM\xb3ZWE\xd7\x05\x06A6\x89\x7f \xfbc|\x84\xd7\x8b\x8c\xce0<\xbf\x8b\x0c\xcf\xc5}\x7f\xdb\xd4\x9e\x01\x92-\xf9\xaei\x1e\xadV+\\\x12\x0f\x83\xf3\xc8\xfb\\0\x90\x18\xb6\xd4Q\xe3\x1f\x9f\xcbA{\xf9\xea\xdd\x8b\xb7\xe7\x17\x97o\xde>\xc6Mo\xb2*\xc9h\xfe\xcadu\xfe\xe1\xfa\x97\xc8p}\xdf\xe0#%\x86\xea\xe93\xf8\xf5\xfez\xf5]\xd3\xfc\xd7j\xb5\xfa;\xfebQ\xdf\x9fqu\x8d\xbf\xbd\x97\n\xc8OE\xdb\xdd\x16\x15\x1fD\x7f\xc3}\xc34\xad\xd9Sm\xb9\x9dT\xfa\xbe\xde\x8d\xd5\x8aF \xc6\x16o\xfd\x9fgP\x97\x95\x97A\xfdmA8\xf1R \xc7\xac?\x0erP+\xdbp}?\xaa*Zb\x8b\xbb;\xae\xefut\xb3C\xed\xd0!{\xfeCD\x0dy\xc2\xcf\xa2+\xf1\x80\xabr\x0f\xa10v\x15\xbe\xe3(\xcf\x82[\x83\x98u\xb7\x92A\x8c\xd7\xd5\xbd>79\x07\xdeAu\x84b\xdb3\xa9\xcd\xf0\xf3\xb6\xdb\xe4'\x0f\xdd*\xd4\x81N7Q\x9e\xe0\x98\xe2\xcc\x07\xdb\xa6Y]\x17\xad\xe8\xdc\xe7'\xf7\xab\xbf=\x90\xa3%\xcf\x1a\xf8\xb1J4\xe5\x01\x7f\x97o/\xce\xe3?\xbc{\xf3\xda\xfd\xf5\xd9\xb3g\xcf\xf0y\xe4\xef\x8fv\x00\x95\xf6\xc0\x97\xa9R\x18\xe4Y\xe5\xd01\x9dpus\xa8\x8a\xd6\xa5\xe5\x92\x90\xa1 \xe36\x7f6&\xb5\xa9\xd5w\xa6\xf4\x07\xc4z`l\xbb2\xc4\xe0\xc3\xbf\xf3\xe1\xf8\xa0\x0e\xb9\x83\x1ac\x0e\xeeJ/\xf9\xa7\x1e%\xbaX\x7f\xe4k~<\xacm\xcb\x8a\xe1\xf2W\xcb\x87\x0b\xd6vM\xed]6\xca\x82#\x92\xac\xae\xc4\xcc\xf8R\xe0\xc6\x97\x85\x0dW\xbd\xfb\x0d]\xfa\x03x[\xf1@\x8c\xcd\x83\xa7\xf0\x00[5vwW\xb2G\x0f\xce|\xb4D_^\x17;N\xef\xdfd\x93\x7f\xef}\x99\xf7e\xf2.\xb5C\xe7[u0\xb0yB\xcef\xd9\xc1'VU_}\xac\x9bO2\x1e\xe5VDV\xaaH\x12\x9c\xc9m\x16<\x93\n\xe8\x84/\xa502\xaa\xe5\x8cV\xdf \xe7z\xc1vn%\x1f\xc4\x82\xd0|(\x81\x87\x8d\x18\x17\xb1\x9c&A$\xfc\xb1b_\x97\x9e\xa8f\xe0\\x$R^\xd4P8f\x05m9\xfb\xeb_\xfe\xfa\xd8\xc3\xe4Ky\xc4\xae\xc8\xcf&b\x188\xb9\xafW\xdf|\xfdM\xf7\xc03\xed\xe6_2\xe5\x0c\xb7\x14\x1f\x03[@\xa7\xb8\xa9\xa4\xdcO*\xc9\xcc2\x83\x8f\xf9e\xeam\xe1cR\x89\x87S\x82:\xa5Ff\x16\xfe\xca}4\xed\x9b\x1d b\xa5\xe7L\xb3h\xe0\x91\xac\xf4\xc9\x90\xb6\xa2\xfe',\x966\xd9\xc0\xb1\xd5w\xefR8\x99\xc9\xff\xa6\x95\xd6\x14~mLp\xf2\xbd\x87\x12#%=\xe9\"\x03\xff\xe6\xfaNT\xd8\xa0\x1b\xaa(\xecf\xe2\xd9\xa3\xb2^W+\xe8X\xb5\xfdj\x8cc\x9c\xcc\xc0\x18 \x8a\x85M\xd2\xdb\x83\xf0\xec\x94\xf4\xe8\xcb\x91w=\xca\x1f\xcb\xae;H[_\x11\xf4\xe8\x8c\xf1\xff\xd3\x0eL\"\xd1\xf0G\xe6\x1f\x96S\xc9\xfc\xbdg\xed\xae\xf3\x87\x93\xe9\xd2\xcfs\x089\xf1oc\x89\x18or\xc6\xc4\x8d\xc5\x8d\x8e\x1bKJ\x83<\xe6\xa2\xf9\xb1s(\xb9\xa6u\xa2\xe8\xc6\xe2\xc4\xd3\x8d%\xa5'\xa91vc\xf1G\xdb\x8d%\xa5%\x9e1\x9d\x19\x98\x87\xd2\x9a\x04\xeb\x8d\xc5 \xdb\x1bKJ\x17\x12B\xf9t\x19\xf6\x8b\xbc\xd0V\xb1\x91\x9dV\xabG\xf5\x8c\x1fK\x87\x87\xf2Z\xaf\xdb BA\x7f[\xba\xb2j\xba%\xdf\x1cj$\x85sR\xb7\x1buE\xea\xf0\\\x14&\xbb\xe2P\x97w\xfc\xe0W\xee\xa6\xf7&\x8c\xc5H2m\x84\xf3\xa3b=\xf3ux=I/\x1d\x8b\xd5\xe2\xb5\x9b\xd7\xd6\xdb bcn[&\xf9\xec\xcfb\x1dKlT1: \xf9P(\xbd\xc1!\x12\xceq\x1dK\xa0\xff\x10\x0dM\xc32`\xc7\x12\x11\x00@\x1c\"P\xd5\xcc\xc8\xfb\xf3\xd2\xc3\x92P\xc7\x82'\xd4\x8e%c\xc7\xd2\xd3\x08\xbd\xa4\xdc\xf4\xc2x\xe2\xedX\x82)\xb8c\xc9\xdc\xf5\xe4dD/\xb5\xde\x05\xb6\x08\xa5\xea\x8e\x05M\xda5\xe8\xd2\\e>\xc9\n\xc4\x01\x99\x93\xe9\x8b\x0b\x143\xfbW\x17\x01%\xce\xaa\xed\x15\x96O&\xcb\x02\xdd\x1d\xa1\xee\x9c\xf6\x1ev\xe2l\x01\x1b\xb6\xae\n \x18'\xee\xecp\x88\xa9\xb74!\xb3\x1f\xa1v\xfc\xd1\x88\xdew\"\xfa\xcf\xa0on\xe4!xHv\x92\xe7\n\x95\xcd\xa3\"\x9dp\x8a\x0f%\x0e\x82>\x83(ck\xd9\x02\xfb\xac\xaeL\x11\x13\"\xb6\xb3\xb2\xeeV\xf0NA*Y\xe4t<\xc24d\xa8\xe0C\"\xb9[\xd9L-\xb2g2\xc0A\xf8\xe5\x9b\xb6e\xeb\x1e\xd6E\xb5>T\xda\xdch\x11\xdb\x1e\xb8vlWp\xa8\xc7\xd1\xecD\xff\x9bC\x0fe\xcfZ\xb9?4w\xe2|0\x1c\x98\xe0O\xb7\xac\x96]\x81\xa2\xb5\xf9\xd9<6\xda\xb5\x88x\x00s\xc0\xa7\xb8;\xeb\x96m\xca!\xdd\xac0\x93\xe5>\xdd6\x9d]\xcf\x80]fWbNC9\x86v\x88\xca\xc6\x99\x94M\x1f\x9b*.\xfc\x906\xfa\xa9B\xa2b\x15\xecZ\xac\xf1_\xa9+\x1eUV\x1c\x97\xac\xd7l\x98\x02\xb6\x11\xb6x\xc1J\xeaj\x18\xd9<\x9b\xe2\xeeP\xf5\xe5\xbe*e#l\xfa\xe2E\x9c\xb3\xed\x0c\x93\xd1\xf6+\x838\x05#\x1aC\\KQ\xc4\x07t\xeb\\\x9b,\xa2?\x07g\x91\x82\x07\xea\x9bVv`_\xb4b\xe4T\x8a\x8bB\xbe\xe7K\xb6\x17,(\xb5\xd7=k\xe5\x1d\xb6\xc2\xaeW\x7fP\xc4v\xcd\x18\xb4\xd72qK\x8e\xddp\xfd\xf0\xd1\x87\xfa\x83\x82%\x1a\xb0\xf6\xa7\x15~\xb8\x1d>\xbdbu\xdf\x96\xac\xfb0*o\xe20\xe7I\xc7I\xbc\xe3\xc3\xa7J\xa3b\xd0\x9a\x9e\x89.\xac\x04\x9d\xd4\x8b\x95\xf5P8\xd5\xa7\x1a-\xdf\xee\xc6(\xedi\x8d\xd3\x18~\x02(\x92MP7D\xef\x9c#\xfc\xdf\xf8\x8e\xd9\x145\xba\x19\xda\xe1 \x0c(\xd2F\x8b@\xff$\xbc@\xa5\x90\xc4\xc3\x00\x99\xa2\xc0J\x84k\x99\xf1\xe4\xd1\x9e\xb5\xb0/\xca\xf6I\xdf\x96\xcdp\xacw\xf9%C\x8f\\\xa2\xba/\xe3\xa8\x8e\xef\x0c\x9d\xeb\x1b\xbdFt\xebx\x0fI\x978Z\xd5\x8f_Y:\x11\xffY\xd8l\xd62\x9fuL\\E\x84\x88\xefJZ\xfb\x9a@{\xfd\x85VW\xd3T\xe4\xb5U7\xbd\xbal\xebjj\xb7D:O}\xd3\xea\xdex\xcdS\xd3\x08\xcc\xcb1\x10\xac-\xd6\xa2OJ\x1es)Y7\xfdW\xeaO\x99\xfc\xdb\x1d\xf6\xfb\xea^;\xeb\xf8\xa3_\xe9y\xb0G\xd53\x1c\x02h1KZ\xffUk}\x8b~\x8f\xd3\xb0\xe9\xd8\xea\x9c\xf7P\xe7?\xceE\xa0\x02 \xa6\n\xc7\x94D\xa4\x06R\xda~\x88\xd0T\x99\x8f\xa0\x0b\xc0\xf2>\xcc\x83\x1e\x08\x11\x9a\xf6\x01\xb7\xac\xa74|\x1e0\x81C\xc6\xe9\xffb\x80\x82 \xbd\xd2\xc9p\\\x8eY0%X;\x81\x04\xe8\xc0;P\x060w\x119\xb0\x06\x10\x9e;\x0c\xde \xf8Ix\x8efC\x1dL\xe8,\xc1;\x98\x90R\xe8\x07S6'A @\xb0\xc3y\xa0\x10\x0c\x82V@\xe7Bd\x04\x83\x92\x85\x91\xe0\xeb\x90gK\x81\xc8=xF\xff\x027\xa9\x86\xf6\xaf\xa6\x1di\xa4_w\x81\xecd\xce&\x9e7\xa1,f\xc2H6\xe5\x12v\xbe\xa8\x19(\xbesd\xdc\xff\x02; i\x0f\xcc\xd2\x9bl;a`/\xf4\xef\x86i]\x98\xbf#\xc6\xc7b\xd9\xae\xe8\x90\x930>\xce\xcf\x0bwF\x97\xde\x16\xdb\x1b\xbdS\x81\xee\x8f\x0b\x16\x1c\xbaKF\xe6\xd4\xb7S.2]\xe6\xda/\xb3\xee\x98\xbe=3e\xd7\x0cw}\xd1\xceiQ2\x00\x850\x8e\xc9\xb0{:\xfb'L;\x87\xedA\xe3\xa4V\xd5d\xc5w\x0f\xc7\x9b+\\I\x8a\xdd[a\xd56\xbe09]\x0f?+;\xaen\xcb\xd8\xea\x84\x93\xdd\xe9\xfe\x0b/\xf8\xcb\xff\x98\xfb/p\x8bET\xf7\xf2\xaa|&\x81'\x18\x05\xcfu\xc8A\xe5\xef\xbd6\xc3-\xd1\x02G\x9b\xe8\x97U\x02\x8f\x02+\x90IO\xf3\xe8hQ\xfdlA\xcb3\xe9d\x1e%\xc0\xb1\xaf\xca\x82M\xaf,\xce$\x9b\x1f\xcc\x82\xc2\x91A\x0dM\xed \xf9\x91%\xa2\x19\xc61q\xe2\x03-\xcb\xa45z\xb0\xd5_\xe3\xfd\x13\xa3\xa5\xbbo\x9a\x8f\x1eb\xfb\xaaX;\xb9\x8d #D\xf6\x15\x13\xf5\xf8|\xd4 }\x0e\xf9\xa9'\xfd\x9eT\xac\xbbw\xa8\xcb\xcfc\x88\xcf\xd8\xb7\xf1u\xac\x17*\x94\xe5\xca\xa3I\xca\x12\xed\x05m^&uY\xdb\xb4R\xc5\xd5+\x95L\xcd\xdd\x1c*\xe9\xd2\xc4\xe9\xa9\xa3\x01\x14}\xa4\x93\x19;\x17h{\xdfP[\x14\x1f.D\xfa\xbf\xaa\xfb\xd6\x8a\xc3\x1c\xa7X\xaeY\x99C\xed\xd2jY\xc5\xee\x8a\xba\xe7;P\xb1)\xfa\"x\x94\xd2N\x93B\xde\xe5\x84\xbb\x83\xd4KT\xb5\x16\xe9\x8d\xf4rJ5P(|]Y\xdfT\xc6\x19\xea\xa1qa\x82E\x8c\xff69\x89I\xbf\xaa\xa2`\xba^\xf90\xf1%\xf1U\xd3n\x18W\xca+\xc3 t\xd2(O\x1a\xe5\xf15\xca)\xef/P-\x83\xa4\xe6\xe8\x98C(M\xb2b9,\xb2\xa9:Ib\xf90\xf6\x94\x97S\xc2bs&\xea\xd4\x8825\xa1\x17\xc3\x9c\n#Ny\x95)\xbf\"\xd5{\xb1\xa6\x82[T|3\xc9\x8c2\x15\xc6\x98\xca\x8b0\x95\x15_*\x88.\xd5/\xc3\x96\xca\x89,\x15\xc7\x95\x9a\x8d*\x95\x13S\xaa\x8f#J\xe5\xc4\x93\x8a\xa2Ie\xc6\x92\n\"I\xcd\xc1\x91\ncFe@\x8c\"\xe1E\xa5aC-D\x86\xca\x8b\x0b\xe5\xf3Sd\xc5\x84\xca\x8f\x08\x95\x15\x0f\x8a\x86\x06\x95\x15\x0b*\x84\x04\x95\x19\x07\xca\x87\x02\xd5S1\xa0\xe6\"@I\xb4'\x84 \x8e\xff\xb4\x00\xfd\xc9\x83\xfd\x14\xdc\xe2\x83\xb8O\xf1\xfd?\x1f\xe6S\x08\xf1)\xdc\x8e\xachO!\xac\xa7LHO\xcbp\x9e\x90\x95\x84m\xe5y1\x9ez\x14\xe1i)\xbeS\x14\xc0(\x80\xedDBv\xc2\x81^\xd2P\x9dp\x1a\x0e\xc8\xc3b<'\xea`P\xb0\x9c\xc2\xfd&\xe18%\xa28\xb9\xa0\x17\x19\x10\x9c\xa2\xf8Ma\xf4\xa6\x18v\x93w\x94Rp\x9b(\xa8M\x18f\xd3B\xc4&\"^\xd3<\xb4&\x0f>\x12\x05\xa9)#N\x93\xa7\x15\x0e\xa7-Bh\xc2\x10\x992\xe21\xe1hL\x8b\xb0\x980\xec\xa5\xdc\xc8KA\xdc%\x0c\x90\x06\xc3\\\xca\x87\xb8\x94\x15o)?\xda\x12\x1dk\x89\x84\xb4\xa4\xec\x18\x14\x9c%\xf5j\x14e \xc5X\xc2k\xa7b\xe7\xc4\xf1\x95\x12\xd0\x95\x88\xd8JN7r\xe3*\xe5DUB1\x95\xf2\"*\xe5\xc5SZ\xc6\x0f$,%\n\x92\x92\xb9\xad`(J\xf24\x83\xa1$\x85\x10\x94\xc2'\x88\xcc\xe8I^\xec$\x0c9\xc9\x8eZ\xcc\x84\x9b\xe4=\xf2a\x98IT\xc4$\x12^\x12\x0d-)\x8a\x95\x94\x80\x94\x84\xe1$y\xfbo\x8dv\x1e\x8c\xa41vd\xfe\xc5\x92\x0eGN\x89.\xc1F2\x12}\x7f\x85\xd7\xefo\x98\xf1\xc72T\xa4>\xddi\xe1\xc5C\n\x1a4\xac\xe6g\xc2B\xf2#!\xd1\x9b\x82\x9aO\xe6c \xd9i\x93\xba\xf8\x10\x90\xbc\xf8G\xf4\xf6\xcf\xc5>\x8a#\x1f\xd1\xdb\x80\x8ea>\xcc#\x0f\xe2\x91\x17\xef\x88\xde\xf0d\xac\xa30\xd2\x91\xb7b\x7f\x98Sx\x1c3#\x1cM7M/\xbeQ\x08\xdd(\xdaI<\xae\x89\xda\xd1\x85\xa8Fc\x17\xa3\x98F>D\xa3i\xe4\xd5L<\xa3\x19\x925\x8ed\x14_vyQ\x8c\x121\x8c\xbc}\x86h<\xa1\x1f\xe9&\xb8\x9c\x814(\x90\x1d\xb7(\x84\xe0\x13\xc6,\xca\xd4\x9dlhE\x06RO2V\x11 \xa9(c\x87\x931\x8a<\xfe-\xb0\xfbME(\n\xe2\x13\x05\xbb\x19\x8f\xf9\xb4\x06a\x0e\x04\x11\x067\x14\x05\x1b\x9a\xa9\x06/\x81\x19\x12\xbfN\xe8\x8dd\xc6\xd6\xfb[\x90\x1b`(+\xbc\x10\x0e.\x94\x11Z\xc8\x05\x16\xca\x07+d\x9e\xb3\xcc\x1arB\n\xa1\x80B\xd7y\xe1\x84\x100\xa1\xdcPBi@B\x9e\x94\x13'\x1a\x8f\x10\x12\xe8~\xbc(\x0e0=\xc3\xc4\x8f\x9c\x937\xb1$\x1c2\x18\x14\xb8\xb1\x1def\xe0\xa0\x97\xce\xe9\xbaJb a,\x940w0a\xe6p\xc2\xd3u\x95V\xc9\x19ZH\n.\xcc\x1b^H\x080\xcc\x1ebx\xba\xaeR\x96\xa4\x90\xc4\xc5A\x89\xb9\xc3\x12O\xd7U\x9a\x85\x16\xa0\x989D\xf1t]\xe5\xe9\xba\xca\xd3u\x95\xa7\xeb*\xe3\xe1\x8c\x84\x18\xbe\xd3u\x95\x94\xc1\xa1\x848\xc6G\x81\x14\xe6\x98\x1c\xe8x\xba\xaeR\x15J\xe0\xe3\xe9\xba\xca\xe5a\x90\xa7\xeb*\x93C$\xdd&\x9f\xae\xab\xcc\x15>y\x8c\x00\xca\x94\x10Jb\x10eR\x18%=\x90\xf2t]\xe5\x9c\xb0\xca\xbc\x81\x95\xa7\xeb*C!\x96\xb4 \xcb\xd3u\x95G \xbb\x0c\x1e[O\xd7UN\xa9g\x0f\xc5t\xe3&\xe7\xb6'\x88\x11\xb6<$\x13\x82@\x1cEX\x90{\xe7%\xd8[A\xe4\x9e\x18\xce\x999x^b\x81\xdc<\x98\x9b\x9f\xe7\xa5&\x1a\x15\xc9\xd1\x03\xc8\x90\xa7\x07\xf3s\xf5\xbc\xf4\nR\xbe\x1e,\xcb\xd9\x83\xb9y{\xfefW\x95\x18\xafh\xee\x1e\xcc\xcc\xdf\xf3\x12\x13Y;\x84\x1c>X\x90\xc7\xe7'\xc8\xfaX.\x1f\xe4\xcc\xe7\x83xN\x1f\xe4\xca\xeb\x83E\xb9}\x90\x9e\xdf\x079r\xfc`A\x9e_@>yN\xc7\xbad\xce\xf7\x83#\xe5\xfcA\xfe\xbc?H\xc8\xfd\x83\xd9\xf9\x7fA\x19\x1e\xce\x01\x84Yy\x80^RC~` \x17\x10\x94\n@\xcc\x07\x84\xdc9\x81\x10\xcd\x0b\x84\xa5\xb9\x81\x10\xca\x0f\x04\x9a\n\x14=I\xd3\xb5\xa4\x9c\xf9\x82\x10\xcd\x19\x04b\xcb\xe6\xe5\x0e\xa2\xa4\xf4\x1e\x11\xce\x1f\x84\x9c9\x84\xb0,\x8f\x10\xa5\xa76z\xbfb\xb3 \x9f\x10\xa5\xc7\xdb\xd3{r\n!K^!\xd0\xd2\xe7 \x96_\x08\xf4\x1cC\x08%\x1e\xcd\xc85\x84\x08=O^E\x86\xbcCH\x1e\xc8\x925\xb7\x11\x02\xf9\x8d\xb0 \xc7\x11%\xe6\xbb\x1aB\x96\x05\xb9\x8e(=\xffQ4\x92\x03 \xde!>^\xd6L\xe5\xca\xfd\x841\xfc\xd7\x9b\xff \x89m\xf3\xf0}r.(J\xc5\x0c=\xf7\xe5\x83\xc2\xa4E\xb1\x06\x1b\x7f,\xcd\x0b\x85\xe5N\xcc@\x8e(\xc4g\x02\xa6\x9d\xcb\x96+\n\x91|Q\x98\xd1\xb8\x80\xe9pN\xee\xa8\x97\x98\xbe\xfe#\x90?\n\xe1\x1cR\x98\xd1\xbb\xf9\xb9\xa4@\xcc'\x85\x19\xad\n\x8cy\xce\xdcR\x08\xe5\x97\x82h\x947\xc7\x14ftkF\xae)\x10\xf2M!\xde\x94X\x80\x1be\xf4\x17\xe4\x9f\xa2\xf4\xec\xc4\x8dx\x0e*D\xf3P\x81>\x10\x8b\xb3\xa6\xf2\xe5\xa5Bjn*\x04\xf3Sa\xda\x83%9\xaa\xb0|\xaf\xa0\xe4\xab\x02q\xd4aA\xde\xaa\x97\xe05K\xcf]\x85\xf8\xb8\x00al \x92\xc7\nq\x86\xd6\x85:|0+\xa75H\x8e\x90\xe3 \x84\xdcV8Ng3\xe6\xb9\xc2\xe2\\W\xa0\xe7\xbb\xc2\xf1\x86#-\xf75Hn\x1a\x88\x97\x92\xff\n\xf1\x1cX\xa0\x0d\x02E\xaaC\xc2@e\xcb\x89\x05_^,\xd0rc!\xde\x7fJ\x9f\xb2\xe6\xc9B8W\x16\x08mZ\x9a3\xeb\x10DC\xb7f\xe7\xd1:\x94t^\xad7\x97\x16r\xe7\xd3\x82'\xa7\x162\xe7\xd5\xc2x\xeaErk\xc1Q\xd3\x92\xf2k\x1dZ\"\xdf\xd6\x97c\x0b\x19\xf2l1\xc6\xc0smai\xbe\xadC\x0d\xcb\xbf\x05J\x0e.\xbeZ\x02i\x86\xde\x04G\x95\xdah\x7f\xa5\xe8\xbd\xbdx\xa1\xdbFKq\xbc\xe0Za\xfa\xf5.B\x994\xf4\x1d\xabw\xf2\xa12\x1c\x8b\xc0O\xe1\x04\xd4\xea\xa7\xdcN\xca\x0ev\xcd\xe6P\xcd\xcb\xfb\x9du\xf7\xa0\xd5\xc8\x89n\xaf\x04\xa5\xd4\xf3\x95\xe5W\x04\x9b`\xda9\xdf^\xc7,\x11\xacv,\x17\xc9\x7f<\xb3\xed$\x16q\xdd0\xbdk\x8f\xe9\xba\xe3;\xd3\xa6\xb1\xbao\x1dmtq\xbb\x1c oTe\xb4\x12\xf4O\xc2KY\n ?\x0c\xa2\x99\x96\xef\x84\xec\xb6\xccx\xfah\xcfZ\xd8\x17e\xfb\xa4o\xcb\xc62\x93\x8c\xa9\xb2G\xea\xa9[\x81\xee\xdf8\xfaF\xbe\xae~\xa7o`\xcf\xda\xae\xec,;\x03\xef\xf9\xd5\x86\xd5\xcdn\x0e\x97\x8e_[:\x1c\xffY\xd8\xcc\xb8\x90\x04\xf1\\e\xd5#\xc2\x06Y\xe71\xd9\"\xdfN\xc8\x94\xbeh\x9a*]\x884M\xe5\x13!MS\xd9\xb8\x01\xfc\x87\xb2\xde6\xb3\xc4E\xdd\xf4WR\xa0_%\xdc8\x9d\xf2\x052\xe2\xc6\x90D\xc7\x9b\xf7\x8e>\xdao\x8d\x95\x92.\xbb\xcduv\xa5[e\xf4O\x92\xc8{M\x97Y\xe7T\xfd\x0d\x1c\xb1CG\xeb\xd1\x8c\x7f\xdcT%\xa7\x1e-\x0c\xae\xd9\xfa\xf6w\xdf|\xa5\xf3\x8d\xec\xac\xa50)W\xf9\x1c\xa4\xf9U\xd7\xae\x8f\xdc#\xb4.\xd7\xd9f\xc9c\x99^\x84\x92\xd3\xf9Wz\x04B\x9d\xdbt\xfd\x17\xeb\x9cQW\xb8s\x9e\xb9\xeaz\x8dT\x12\xef!\xba\x11\xc9\x82-\xa7\xb1\xa0\xb9{\xe6\x87\x8b\xf2\xa6\xa5\xa5\xab\xa9\x036eY\x08\xc7\xef\xb8}Y\x16\xca$\xc92i\x1d\xd8\x80\x18\xf27\x8dl\x182PX\x8c\xda7\xcdG\xd8W\xc5\x1a\x8d\xca\x06i[\xdcWLT\x1c\xb2H$\x0eJ\xcc*\x9140v\x0b\xadq9\xd4\xe5\xe7\xd1\xd4\x1ce\xe3)A\xdf\xa0(\x9b\xea\xd5uQ\x15\xf5z\xe9\xa0\xd0\xbb:\xa9\x17\xb5\xf3\xeag\x9fnY\xa8\x93\xb6\xbc\xea\x8b\xb6\xc7\xec1\xb2\xc8c\x1c\x17\x11_\xac\xa7c\x95Z\x1a\x8dg]C\xd8|5\xc8\xa8(-\xb9\x80\xe4\x89\xd3\xec\xbc\xcf\xcdEi\xa9\xa9Z\xbc\xaa\xfb\xd6p{\xda\x03,\xe5\x92?\xaa\x0eD.\xcd]Q\xf7\\\xa9)6E_`\xed\xb2Z\xa55\xe9\xa2\x95\x068\xabB\xf50\xd5\nev\xc8\x8e\xd9\xab\xca\xae\x97\xf9\xd8\xfb\xa2\xed\xcb\xf5\xa1*\x0c\x8b\n\x92l<6\xa7\xbe\x11\xca!b\x07\x10\x18\x03\x16E\x95\x98k9\x7f&U\x0e\x93\xef\x90\xf3\xf8'<\xdb\x8d\x7f\xab\xf1l3\xc1-&r\x15\xbb\xa9E\xf2\xf6x|\xf1\xa7]\xec\xb4\x8b\x9dv\xb1\xd3.\xe6\xa5\xf5\xcf\xb0\x8b\x05\xf9-8\x03\xf1\xfe8}1\x8d\n\xec\xe7CyWT\xac\xee\xe5\xb6\xe2\xbc\x8c\x10d\x9f\xd7l\xdf\xcb\x10\xe2\x12\x85?\x183\x12\x07\xae\x9d\xc4\xfb\xaa\xa9\x93rM\x98r\x11\x97\x03@w({a\xa7\x12n\xf7\xaa\xf4\xc0-\x0cF\x08slC#cv\x93:\x1c\x93~\xdb\xdb\xbb\xdaP\xed\xc6\x0d\xb8\x15)\xa3`\xf5\xd9&\x87\xf4\xdf\xe9\xf9 W\xf3\x84\xaby\x0c\\M\xdb\xe3\x84\x1a\x10cFJ\xeb#E-\xd9\xdf\xf4^\xbb\x02^:\x0b\x98l\xc0\x94\xee\x84\xa9\xc1\x92\xc4\xd7\x11\xa3\xa1\x97\x1f\xac\xb1\x9cg\x11\xc4\xad\x7f\xa3\xb9jA\x83\x1c\"\xb4\x06\xa1\x87\x8b\x80K\xe5\xb8\xc8S\x04-?\xa2\xcb\xc44\xfb\xf8^\xebj\xf3%\xae\xc7\x1b.-\xae\xaa\xa3\xa4<\xea;Aq'\xf6\x93\x1c\xde8\xd5\xc4KL \x1f{\x14\xd2\xb3 \x1av\x06#nH\x9fVY\x05\xea\x95J\"]l\x0e\x95\x8cl\xc0\xa8\xb5l\xcd\xca;\x06E\x1f\xecZ\xa6.\x05\xda\xdc7\xb4\xb6\xc4\x86\x08\x11\xa2\x13-\xd7\x88\xaf\x0d\xea\xb8\x11\xed6h\x9dA\xbd\xba\x8e\x95\xc6\"a\xe9\x01H/\xa0\xeb\x1b\x11\xbcSU\xd22\xd3\x95\xf5M\xc5L\xab\x8cQ\xad4\xc1\x8c\x049\x17\x0f\x9f\x18\xd1+5\x1f\x0f\xce\xe7_5\xed\x86\xb5l#L?\x88\xa7\x14\x05\x9f\x9e\xa8\x98\xa1\x1d\x12\xe9\x91\"H\xf7\xed\x0d\xf1L/\xdd\x1d\x9a\xbcC\x1a\xa6\x99/\xe4\xe0\x1bk\xcc\xb4\x1dDvjYR\xd6\xe5/\xc4\xbdw\xdc\xde\xcc\xd3\x04\xc2\xa4\xdc\xde\xe4I\xcf\xb2\xb2\xafL\x0dI\x08\x02\xf9P\x89K\xc7\x02\x12\x1b\x0bC\xa4\x0cY\xb2c\xe8\x84\n9\x94B\xf9\x96U\xc2\xf6P\xd4P\xac\x85\xf2\xedv\xf8\x9c+\x02\xee\xc9\xb5\xf9TK\xbbES\x1b2J\x81G \xf8\xb4f]\x16C\xd4\x9c\xd0\xb9\x8c\xf03\x97\xde\x96Sr\xeb\xf1L\x85g\xc3\x9a\xbd\xe0\x9c\x18\x15Y\x82s*\xad?\x89\x9f\xc5f\xef\x85\x8cj\xd1\x16\x1b1Qc\xe0\xe1\x18\xec\"\x06\x9a\xcf\xdbNN\x9b;r\xaf\xdf\\\xbez*\x00\x08\x94\x99Jf\xf2\x97b\x8b<\xaf\xb5F7\x00\\I\x1e\xf1\xa4hK\x01\xeeV2\xe4~q~\xfd\xf9P\xb6\x92)n\x9a\x9bFd\x13S\xad\x1a\xf8\x86c\xdb4^\xfa\xec\x19\x16\xa5\xd1\x80\xf3+\x8cc\x92\xed\x18\xdava\xd2:\x99.N\xa6\x8bc\x99.\xa6c\x1f\xd5\x8c\xbc\x9a\x99I\xe0 F\xc1P\xcd\xa8\x9aY\xb2:6\xc8\xefY6\x8b0$3\xcdB\xe0L\xf9L\x00\xe6\x11lyB/\x06\xbd\x1c\x06]\xf6nY\xfe\x0d\xab\xf7B,\x07\xf7\xab\xd8\xd63\x1fP\xd9\xa3H\x85\xa1\x94\xe7\x80(\xfb\xc1\x92g\xc1$\x0b\xf2\x08\xb1 @r\xbf\x0c\x1ay&(2\x9a\x8a\x1f\x87C\x9e\x0d\x84<\x0b\x02\x99\x1f^\xb1\x11\x8b\x83\x1f\xcf\x81=\xf6\x81\x91F\x01\x8f\xe7B\x1ds)\x8e\x90\x0b\x82\x1c\xcf\x817\x0e\xc3\x18g\x000&A\x17\xa7A\x14/\x04'\x9e\x0bK\x0c\xa8\xd7\xdcw\xae\xcb\nE\x9c\x1f\x848+\xfc0\x0dxx\x1e\xe4\xb0g\x80C`\xc3\xe90\xc3#\x9c0\xb6\xc6=\x00\xc3=\x15Zx.\xa8\xb0\x04\x0fF\x08\xe2p\xc2\x0b\x80\x84=\x10\xc2\xc1->\x08\x1b\x1c\xdf\xff\xf3A\x05\x87@\x82\xc3\xed\x98\x07\x0c\xac%\xe9\x84X\x08\x128\x13\x18\xf0\x02\x18`|%a[\xf9\x02\xe8_^\xdf\x84Z\x8f\x82\xfe.\x85\xfb\x8db\xd5\x06 ~I\xe0\xbe8\x06g\x1a\xa0/N\xc3\xc1\xb8[\x0c\xdfK\x1d\x0c\ndo\xb8\xdf$\x98\xdeD\x80^\x17\xf3/\x03(o\x14\x8e7\x0c\xc4\x1b\x83\xe0\xf5\x8eR\n\xec.\x05p\x17\x83\xda]\x08\xb2K\x84\xd7\x9d\x07\xac\xeb\x81\xae\xa5\x80\xe9f\x84\xd1\xf5\xb4\xc2\xe1\xb4Y\xa0\xb9\x10\x00\xc8\xcd\x08\x8d\x8b\x83\xe2\xce\x85\xc3\xf5B\xdf.\x00\xbdE\x8f!Ah[\x0cw\x13\x83\xb3\xcd\x07d;\x1f\xc2\x16\x81\xab\x9d\x05T\x1b\x04\xa5\xa5\xc3\xd1\x92\x80h\x95\x1d\x83\x02A\xab^\x8d\x82\xcf\xa2\x88\xacx\xedT\xd8\xcf8\xd4l\x02\xc8,\x11^\xd6\xe9\xc6\x02HY\x94\x8d\x17\x00\xc7:\xd6\x16\x142v\x1eX\xac\x0f\x186/$\xec2~ \xc1\xc0R\x00`\xcdm\x05\x03}\x95\xa7\x19\x0c\xcc5\x04\xf4\x1a>A\xcc\x06w\xc5\x81/\xbc\xb0\xae\x18\xa0\xab\xed\xe5\xcd\x04\xe5\xea=\xf2a\xf0\xadT\xe0V\x12d+\x0d\xac5\n\xd3\x9a\x00\xd0J\xca8\x1f\xe9\x1a\xa3\x9d\x07\x8eu\x8c\x89\xc0<\xfd\xb4\x968\x1c9%:z\x1c<\xb0\xab\xa6\xdf\xc1G\xcb\x1b1\xeeo\x98\xf1\x87\xe5\xf40\x7f'\x81\xac\xf6\xe9N\x0b/\xa4j\xd0\xa0a5?\x13\x8c\xaa\x1f@\x95\xde\x14\xd4|2\x07.u\x80EE\xe8\xf9\x80R\xbd\x10\xa9\xf4\xf6\xcf\x85E\x8d\x03\xa2\xd2\xdb\x80\x8ea>\xf8S\x0f\xf0\xa9\x17\xf2\x94\xde\xf0d\x98\xd30\xc0\xa9\xb7b\"f\x8b3\x8e\x0b\x80L\x85)xBn\xbaiz!Lg!\x13\x85#z\xa9\x1d]\x08Rje\xa8\x86\xe1I}\xc0\xa4VK\xe7C\x92\xce\x90\xacq\x00\xd2\xf8\xb2\x9b\x0b:\n\xd7\x98\xf57\x11n\xd4\xdbg\x88\xe6\xc8\xfa\x01&\x83\xcb\x19H\x83\x02\xb3\xa0D\x05*\xa4\x87Z\x08+2\x0c\x1f\x9a\xa9;\xd9\xc0B\xc7\x15\x93\x0e\x13J\x02\x08\xcd\xd8\xe148\xd0P`\xa8\xd5o*\x10h\x10\x024\xd8\xcdx\xb6\x835\x08sP=1\xf4\xce(n\xe7L5x J\xa7\xf8uB\x0fK\x98\xf5\xb7`)&'L\xa2 f\xa3o\x0eh\x9b\x061\x1cw3#\xe2\xa6\x8b\xb5\x99\x0fe\xd3\n\xa4\xe4\x98\xe4\xf4\x18<\x04;C\x8a\x0c!I&\x96&\x13O\x94 \x8eZJ\xb2\x0c-]\x06O\x98Y\x9c2CN\x9a\x99\x9b6\xe3\x1f&R\xeaL\xd6\xe4\x99@[\x10N\\\x94B\xe3PCRj\xb2&\xd5\xf8\xd2j\x16&\xd6\xb8Mv\x13m\xf2\xa7\xdaD\x92m\xf0t\x1b<\xe1&g\xcaM\xe6\xa4\x9bc\xa4\xdd\xa4$\xde\x10So\x92\x92o\xe8\xe97\x9e\x04\x1c_\xca\x05=\xe9\"\x9e\x84\x93\x94\x86CN\xc4A;\x94;\x19'o:\x8e'!'wJN\xee\xa4\x9c\xe5\x83aI8\xe1\x14\x9d\xf8\x89's\x9aN Q\x07O\xd5\x99\xb40W\xb2N\xf0\xd8\x8a%\xec\xd0Sv\x88I;\xd4\xb4\x1dB\xe2\x0e\xa4\xa4\xee\xe0\xc9;t\xdfI\x9e\x04\x1e\x88\xa4\xf0\xd0\xdb\x13\x0c Z\x9e\xc8\x03\x9eT\x1e\xbb\x15\xa1\x06\x1a\x7f,K\xe7\x99\xed\x10\xf2&\xf5D\x8d7VG2%\xf6\x84R{\xd2\x1a\xe41\x17\xcdO\xf0A\xc95\xad7\xc5'\x90\xe4\x93\xd6\x93\xb9\x89>\x94T\x9f\xb4\x96x\xc64_\xc2\x8f7\xe5\x07\xfcI?i]HN\xfc\x89\xa5\xfe\x04\xab\x0f\x85\xa7\xc5F6s\nPB\x12P8\x0d\x88\xd4a_l\x1a\xbd\xd3\x0b\xd3\x81\x92\x12\x82\xfc)An\x1c\xdd\xcc\xa4\xa0\xd9\xf29\x9e\x1a\x14\x1fU\x8c\xce\xb2\xf4\xa0\xe4\x04\xa1H\xach,Z4\x94&\x14\x15\x00@\x1c\"\xc8\x9e,\x14N\x17\x8a%\x0ce\xedX\xb6\xb4\xa1e\x89C\xc4\xd4\xa1\xec]ON \xf2R\xb3\xcf\x16\xe4\x14\xa2H\x12Q\xb4\xc31\xc9\n\xc4\x01\x99\x93a\x84\x0b\x147\xeb\x88\x90w\xb4Hw_\x92}\xe4\x10So\xb9\xf9G\xe1v\xe4\xceA\xca\x9c\x85\xe4\xcbC\xca\x9a\x89\x84\xe5\"\xe5\xccF\x02o>R\xde\x8c$ONR\xf6\xac$4/)\x7ff\x12!7 \xa6\xdc=Fg\x1a\x9e\xeb\xaa\x12=\xfd\xf9\xc0ZNj|G\x139\xc5A\x9f\xe2\xa03\xc5AO\x1b\xea 7&\xe7\xcd\x89\xa8fE+\x96>g\xde (\x87\xdca>\xef\xedDX\xa01:Q\x93\xe3\xe7\x9c\x8447\x01mL\x0f\xeb\xda\xf5\x9c\x86X\x8c\x81Rs\xed\xa8\xf6\xe5\xbe2\xc2W\x874\x1b\xd4\xd4\xf7nS7]\x9f\xb1\xa9\x06\xb5HS\xf1+\xcau\xcb\xa7\xedur\xe3\xfa#\x04\xabG\xb2\xdf\x08'\xec9&\x85\xa4\xcb\xbe\xdd+\xbd\x1dzH\xa2[$\xc5\x8d\xd0\xb1\xb9\xa6\x83L\x17v\xfb\x92\xb0\"Yo\x0b\xb4\xda\xd4\xeb\xb7\xc3\xedG/\xdd\xf6_\xb5\xbd\xa0\xdd\xc9\x97iO\xae\xccv\x08\x06\xae\xd0\x0e\xb5e\xceu\xd9C\x86\x9bE\xc9\xcdv\xb3\xea\x9d\xe6\xb9Y\xc4\xad\xfc6\xbc\xb9\xd6}\xce\x96\x83\xbd*\xbb^\xe6\xb4\xed\x8b\xb6/\xb9\xca\xd7ZymcU\xc34YIm\xc2\xa9f}\xad\xe4\xb3e\x05\x9b\x90\x1f\xa6\xc86\xdc\x106K1\xcc\xe4\x1d\xd3+\xecP\xe6\xc3\x05\x9cm\x86[&\xc7l\xb9\xe5\x95X\xc1\xd6\xb9Rjj(\x9c!\x8c\x10\xe1\xe3\x15;\xf1}s\x91\\\x99\xca\x11L\x82\xc4\x9b`\xad\xd4\xa5\xf2\x02\xaeM=\xd9\x95\x14V\xcd\x8b\x84\x82%\x08\xa8\xcb!91\xcel\xc6\x15\x1bW\x14\xfa9N\x02b\xaaD\xf4\xe8\x90\nL\xb6p\xe9M\xa89\nDP}\x88v\x86\x00@\x96maBL'\xf0\xb66<\xc0\x8bV\xed\x84\x16\xa2\x0b\xf84\x81\x99\xad]\xba\xa6'\xe4\xbc\x1a\x80\xbf\x15\x8b\x16\xbaAg\xba\xf7\xc7\x05n|\x93\xb7\xe4\x028\xb7!\x16H\xe3\x8dk\x11\x15\xc1r\xb0\x1a\x8d\x06\x9a\xc5W!\x0e\"\xc8\xb8\x05\x91 \xe8\x16\xc9\xb8Y\xd2mP\x82\x96\xdc\x1f\xe7\x10\x99y\xea\x86\xf8\xc9\x9b\xde(g-\xcd?\x85O\x08\xf9N\xb6\x10?\x8dC\x8e\xe6/=\x99C\xa4\x0f\xa7K\xfegn\xc1(9W#6\xaa\x8a\x03\xd6\x10;\xbc\xd4m5o\xdf\x8e\x90r;L\xc0\xb6\x89t\x98\xd2\x99\xd4=\x1e%\x12\xd2\xd6\xc7\xe2?\xf9C\x9e\xbe\xcc\xd5\x00\xfc\xac-\x9d\x17>K\x00\x10\xda\x95K'\x90\x05\xc7\xc0\x99i\x19p>\xf5*3i\x16\x02\x83\x88i+p\xa1o\x96Y\n\x0cBN\xb0\xc7\x171\x9c\x86\x0eMA\x82!\xa2p\x92\xedsD\xddI\xb6#\xe5$\xdb\xff\xe7\xcb\xf64\x1b\x7f\x92m:\xe94h\x91\x9a\\\x98o=\xcbp2\xb4\xe9Y\xa7DY&7\xe6\xc7O\xbf\xd4\xaeNz\xa6\xb9Gm'\x93\xc3\xef\x82\x1e\xce8\xfb\"\xa8Y\xe4\xa3o\xe0\xe4\x1a7\x9c\xe6:\xb1\x8e\x87\xb2\x19\x8dp>\xa65\xe2\x1f\xa3\x18|\x01\x8f\xea<\x90\xd0\x7f\xa0\x974\x13\xec\xe7?\xc6\xf5\x99\x06\xefI\x80\xd1\\\xd8\xfc\x850\x9e\xa1\xa1\x98\x0d\xdd\x99\xc5\x8d\x19\x87\xeb\xb4>\x1f\xa2\xa4\x96Bt\xaa\xb3\x89$\x96\x8e\xc7I\x17\xd9\xbf0o\xe5\x1c\xb1\xf1E\x9c\x94\xc9\xe2a\x81s\xd2Z\x01\xb3\xc5\x80\xb1\xec\x0crnCg4p\xf6r\xc7\xbb\x99m\x89\x13\\\x93C,\x1c\x99\xe7\xfd\xd8\x99\xf1\x81\xb2fr&R\xe6\x04\x19\xd3 \xe8\xc1\xc8\xf4\xa3c\xa2j\x03\xae4\xf4(\x16\xa6w?\x08of\x19\x91/\xfd\x98\x97\xf9\xd0.\xb3\xe1\\z\x11.\xfb\xf9\xd8\x96\xb9P-\xc3x\x96\xb3\x90,gcX\x8a\xfeNO\xc6^\xf4\xca\xd9\xb8\x95h\xea\x8e\x07\xb1r V\xa5\xc0\xa5\x9c\xf6\x06\x81S\x99\x83O\xe9\xc7\xa2\\\x88BI\xc2\x9f\xa4cM.@\x99\\\x80/\x89\x08\x8c\x8c(\x92y\xf1#\xb3!G\xc61#\xb3\xa1E\xfap\"\x97 D\xa2h\x90=\x05\x07r.\x02\xa4\x17\xedq&\xce#\x82\xf0\xe8\xdd(\xbdy\x16\xe1\x1dt&\x92\xe3\x88\xda\x88\x8d\xef\xaf\xe2u/\xc3m\x948\x8d\x069\x17\xb11\x03V\xe32\x94\xc6 \x97O7\xc3\x85\xc8\x8cj\xa0M\x8aK0\x18\x83\x00\x83\x1e\xdc\xc5(\xe2\xa2\x0b\xbeFGYt\xbf\xfd;\xd6\xd7Y\x98\x8a\x94\xce\xc6p\x14\xfd}\x8bb'&\xa0&\xda\x00S\x0b\x91\x12\x83\x18\x89~t\xc4\x10.\":\nT,\xc4\x18\n\xe2\x14\xffp\x01\xf2!\x01\xf30\x1d\xed\x10\xc1\x16\x8c!\x1cf\xc26Dj\xb68e\x11\x92\xe1\x14\xb9p f!\x82Q\xb8\x08\x9dp\x8aF\x98\x13\x87\xd0\x8b@8\x85e\x9b\xa2\x0e\xe6\xc1\x1b\xcc\x864\x98\x17c\x90\x86.\x18\xc5\x15T\xa7\xe4\x18\xa2\xa0z-\x88%\xe8\x80\xee\xb9\xb5QQ\xe1\xc2\xc8\x81D\xcc@\x02Z\xa0\xd5\xe4\x9c\x08\x81\x8b\xb0\x01],\xc0|(\x80\xf9\xf0\xff\xe6\xcfn\x14\xf3/\x86\xf6\xa7\xc5\xf7\x14\xe1O\xea\xe0S\xf4>\x1f\xaa\x9f_\x07\xce\x88\xe4\x87b\xf8M\xd1\xfb\xac\x96\xe4\xc0\xedC\x0f#S\xac>\nJ_\x14\x9f/\x8e\xcc\x17\xc4\xe4#\xa2\xf1Mq\xf8\xd0\xfeY\xa3\xb8\x1c{ot:OQ\xf7\xe2\xb5[\xdc4%4Z\x81\xd30\xf6\x06:\xdd\xd8\xc4\xb1N\xbc!\xc6\x1f\x96\xf1\xd9\xfc=\x8a\xa8\xd7\xd3\x8d\xc8(~\x9e\xf7hl55\x03f\x1e\x8e\x96G\xab\xdeM=\x99\x8d\x8d\x07\x93\xf8\x11@Q\xf1P<\xc1\xbb{'h\xbc\xe2\xac5\xb4\x96\xd5 \x7f\xd0\x11iV\x835P\xe08\xfb\x16A\x1d\x83\xf4\x91\xdd?\x91V\xe7}Q\xb6\x9d4\x0drYEk\xb5\xbf\xcd\xa2i&p!tU\xb9\x16\x1b\xbc\xd9jU\xe3'\xded\xb6+{!}\x0e\xc2\xbc\xdb5\xd6\x1e\xcc>\xb3\xf5!\xb6/\xd9\x02\xc1\xd8\x9c\xba\xbe=\xac\xc5\xc9X\xb5H(\xb65\x081\xc0\xd5\xc3\xcf\xe2\xdb\xc9\x8d\x7fUs\x13\x96?zp\xc9\xa2\x07\x89\x87\xb3\x18x\xc2\xee\xce\x1b\xf8\x80/ce\x03\xe136\xeb\xde\x91\xf8\xbe\xe8\xce\xebmC\x1e\x87\x9b\xa2\xbb\xfaT\xd4\xbdk0\xf5\x1c\x1b\x0f\x81C\xf0\xf7E\xf7'AKk=Z\xb9<\xd4e/\xdc\xe1\x9f\x9a\xf6#|R\x81c\xf1\xee*\xc2'\x05\"\xab\x02\x11\x88y\x92e\xae\x86\x01q\xd2\x13%\xd3,\x924~\xb7\x93,>O\x91.q\x0dGl\xb4\xe3\xdePvc\x1a\xc7Gv\xff\xd5\xb8\xef\xf3\x83t\xd7\xac\xcbb\xab\x82d\xd0\xd2\xf2\xcc\xf8\xc9/a\xac&\xc9\xfd\xc1H/\x91\xe7^=*\xdf\x89\x99\x10\xaa\xc2d \x83\xbb\x8e\xa1\xae\x92\xb7\x1e[$!+\x0f\x13C\xc7\x90\x8d\x88\xa0\xf1\xca\x01Tvx\xde\x0e\xe9\xf7\xd9\x148Ybj\x9c\xaf1\x19\x8f\x19\x8b\x0f\x18^\xe6\xba\xfc\x9c\x0cu\xb5\xc0\xdb\xa20\xb0/o\x19\\s\x89\xa2hi\xa6\xfd|[t\xb7)z\x02'd\x08\x13\xe0\xdf\x8f.\x88\x0d\xeb\xf6E4\x19J\xb5\xe9u\xb1\x93\xaf\x0fN\x8f\x17\xcd\x86\x19\xb4\xa6d(\xe6\x0dW>\xc8DqNO\xb7\x93\xa0%ZD\x1e*)#\xe6\xf6L\x07\xff=T/\xb7\xc5\xa7\xabDe\xcbZ=|D\x9bC\xbf?\x0cY1\xc6n\xf3\xb0\xe3\x8a\xd8\x0dk\xe1\x11\xe7.I\xf4\xf1\n~\x12\"\xdc\xa0R7\xf5W\x1b\xd6\xb3vW\xd6e\xd7\x97kC\x0f<\xb2\xc0A\xccQ&\x9d\xe9\xac\xc9\xe2\xcf\x8c\xb6\xc6\xd2$\x84\xc8\xaf\xa9\xaei\xbe\xfee\xd4:L\x135\x9e\xf8\x95/\xbfVj~\x8euB\x16OWd vH\x96p\xb7d\xf1\xea\xac\xb2D\xd5K\x08\xab\xa7\xb2\x10\xa8\xc4UEY\xe6nC\xe1\xc6\xfb\x0cc\xb2\xc4\xf6\x01\xbb\xc4{2{\x0f\x0b\xf2\x18\xd6\xfe\xc5[\x9cYb\x1d\x9b\xaf.\xbach\xd8\xd7\x9c\x87\xceq\x14\"\x8d[jr\xb3\x88\xe9\xf3\xb12\xbc\xc5j\xa7\x8a~\xbeD6IR\xbf\x1c\x8cY@\xda\x91\x9e\xa3\xe7\x17]\xa3\xbf\x9ed;X`\xaf~n\x99\x98Zy\x1b\x88N|\x1aU\x8e\x99\xb6.r\xc5\xda\xa4%\xbcGn\xb5\xbd\xe3u!\x05G\xf4\xa7\x84\xe0SB\xf0)!\xf8\x94\x10|J\x08\x1e\xca)!\xf8\x94\x10|J\x08>%\x04\x9f\x12\x82\x03\xdf\x9e\x12\x82O \xc1\xa7\x84`QN \xc1\xaa\x9c\x12\x82O \xc1\x0bRFO \xc1\xa7\x84`BBp_\xeeX\xd7\x17\xbb}\x8a!\xd1\xb6o\x96\xa3 f\xdf\xb2\xbb\xb29t\xd2\x0d\xb9\x82\xef\xf8 R\xf8\";\xf8=|}\x06e\xffP\x0e\xfb'\xf1\xab`\x91Mi\x05r\xd8wi\x8b\x95\xac\xdbhC\xff\xc1]\xd3\x0f\xda\xa8\xaa\xf1\xc7\xa2\xeb_4\xbb]\xd9\x9b\x95[\x02\x0e\xbe>\xb3\xc4,o\x11\xd7F\xbb\xb2\x135!\xbe\xe7\xa1\xbf\xa3[7fC\x1e\xae\x82\xeb?\xcb\xe0.\xce\xefS`\xd5\xcb\xd1\x84\xd2\x177\x9da\x8f\x97[\x85\xdeiD\x98V'yt\xc3\x04\xa0\xa1\xe1}^\xb7\xf7\xfb\xbeY\x89\xc0\xb1\xae\x1ca\x1c_\xf0\xf3\xf5\xba\xff\xb6\xec\x9f\xb7mA\x070e\x9f\xfb\xb6\xb8\xba.\xfb\xeeJ\xc0\xb1:\xc6W\x8a\x8b\x96U\x96\xe7\n\xe5)\xe7X\x87\xfbO'\xfd\x90\x81z\xd3\xc3\xa6D\x8b\x15\x8e\xe6\xe1^l\xb8.{\xe9\\\x1b\x07\xbc\x14)\x06\x07u\xf96\xab\xbbC\xcb\x06\xab\xd9\x80\x16)f\xac/>\xb2N\x98\xa5d\x1e\x8a\x99\x1b\xa2\xe8\xc9\n\xe5>.V\xa5\xa4`d\xec\xe9\x1a\xf9\x81\xbe\xbfmY\xb1\x81\xae\xd8\xea\xb3\xbe\xfc\x9d\x8f\xa7H8\x10\x19mM\xad,\x0bp\x90\xc7\xb6a\xa2\xfb\xcf\xab\xae\xbc\xa9M\xa8\xcew\xe5M\xfd\xd3\xe0EwF\xd9L`\xff\n\xde\x9d\x7f\xff\xfa\xea\xa77/_!\xf9\xe2\xe6\xd3\x97\xe7o_\xbd\xb8D\x1e\\\xbe\xfa\x7f/\xdf?\xff\x11y\xf2\xe3\xab\xef\x9f\xbf\xf8\xf3\xd5\xf3\x9f\xce_\xbf\xb9\x12\x92\\\xce\xa7\xcaU\xf7\xd7\xec\x89\xf1P\xdd\x1a\xe5\xbd\x0c\x0b\x13\x9d\x87\x1d\x7f\"-\x0e}\x07|3\x19\xf2fo\x0eE[\xd4=c\xdd\xa8_{:\xeei\xd5p\xfaW\x90\xaar\xb7\xb2\xaa\xe6S\xa7v\x1eUG\xcb\xf8z\x1a\x0d\x06\xeeh>u~1+\x9atMlQB\xa1\xe2\x03\xf1\xb2Y+nQ\xe4\xefX+\xe5\x83\xc4w\xd5\xde:\x19\xbdy\xf9\x19k\x84\x9a\xb9\xa7\xeeO2\xe2N\xe6\x10\xd9\xcd\x90N:\xdeOQ\xe1\xbd\x19\xec>I4\xef\xd9\xe7\xfePT\x8e\xa2\xc7\xb7\xd1\xbd\x16\xda\xca\xecg\xbf\xa3\xe8\x89\xa6{80\xcchOC\x0fe\xe7\xae\x8b\xf5\xc7OE\xbb\xe9&&\xc7\xc9`\xab\xea\x9e\xef\xca\xba\x91\xb2\xd6\x98hh\xd9\xae\xb9\x93\xe1\xbbR\xab\x17IW\xe6\xda\x1c\x02\xee\x0f\xfdmR\x9c9\x1fu\xd6^\x95\xf5\xb6I\x8d\xe2\xf8\xff\xb7l\xfb\x14\x1e\xfe\xff\x9e\x18\x06\xef'n\x93\xde\x89\x1ax\xa3\x1e\x0e\x1f\xfbwt\xb3=V>\xa4\xc9\x1e#\xfeA\xcb~>\x94-\xdb\xa8\xef:a\xeb5\xc8\xa9\xac/\xe3\x17>\xae2\x06\xba\xd9\x8a\x9dB,pa3\xdf\x15\xfdp9\x8dMV\xb3\xf7\xb7\xcd\xe6\xfeag\x1f\xbb\x84\xf2%+\x96z\xb8\xa6\xaa\x83\x06\xf7m\xb9\x13\xe67Ak\xd8X\x9b\x9a9\xfe\x8d}q\xdfM5\x90-\x1b\x0c\x7f[fX-\xfdc\xf8\x1d\x1b\xd2.\xb7L\x8a\x8c\x9b\xa2\x83\xaa\xdc\x95\xfd0r\xa6\xe7\xd1h\xbbj\xa4\x95\xeb>\xf1\xb6\xc4\xfa#z14]\xd2fL\xe5\xbc\x19t\xc6\xec7\x93\xba\x95\x81\xb7n\xe4\xcdQ\x8ck\x942\x87P\xac\xe6f#\xa3\xfb6\x8dp\xd4kT\x07\x83\x8c\x94S\xd2%a\x92\xd7&\xca\x91]\xcaN\xa7\xe3\xb1\xae/w\xc2.xWr\xb1\xb8S\x89\x8e\xab\xc9\xba \xf9c\xe5v\x8d\x19\x99\x8f{\xcf\xdf\x86\xd5\xcd\xce\x1bH\xe4\x0b\x83\xc1Z\x1b\xfd,\x16\x92\xf1\xa2)kCW\x15@.c~f\xdd\xec\xf4\x15\xde|*\x8bZ5\xc2u\x1b\x00\xbc~s\xf9J\x86\x06*-H\x9e\xc0\xa56v^k\x8c\x86A/3\x8fW\x0e1i)q+\x19\xd8\xa8\x1b\xd7\xff\xf5=\xdc47\x8d\xd0\xafl\xdb\x90\x8a1T\xedq\x92Xd\xc6\xa8r)\x15\xe5Feb3\x93Go\x8a\xeeJ,\xcaDW\xc4\xc1\x8diS\xadq&a\xa8b\x9a\xf9sS\xa8H\x18\xc5\xfbB+\xe5\xfb\xcb(\x16\\\xa6[\xb3\xae\xe3\x8d\x9a<\xb9\x16\xbe5\x01+r\x18\xa2\x1c\x84\xa7\x10\x9a\xf5\xfa\xd0\x9a\xb2d_\xdc\xcf\x03\x9cq\x11_\xb6p\xa8;\xd6\xcbd\xe0\x89\xf4\xd27\xe4\x94\xfa\xfe\x9c}q\xaf\xa5\xc7\x96khp\xbe\x9d\xd0\x1bH\x0d.\x18(\xd6k1\x9fbw\xd8\x17\xf7\xe3\xe7\xd3!\x10r\x9ewM\xbe+\x1c?\xfdg\xdd\x9eGRF\x1e:\xe9\xd2\x14\xbfn\x94{O2\xf2t\xb0\xf5>\xfe\xd8\xa9\xa9c\xbd\x92\x83\xc3\xd7\x9b\x86u\xf0\x9b\xba\xe9\x7f\xa3<\x8aR\x1e\xf3MNd]o\x07~\x9e\xd2\xd2\xbb\x1b\xb2'\x98|*\xd4Z\xea\xac\xf9X\xb1\xdc\x8eC\xcc\xf7\x039\\\x8fX9\xa0uYs8\xc2\x94\x1c<\x91%\x92\x80\x18\x82\xc7:\x9aG\x07\x97\x89\x1aD\xbb\x07\x00\x8f\xe9\x8c5bF\xf9l\x9a\xf1gV\xeb\x1eJ\x0d_]\xa7\xc0y\xc6\xcd\xfb(\xf6\\\x1a\xb7e\xd13\xa3R1%\xfc|\xc5>\x8b\xcb\x0feg\xd6\xb7\x05\x97\x88\x8d\x1b.\xc7_\xd5\xce\xaf\x81Jw&gY\xa8\x81\xdb\xa2\xac\xc4G\xf8\xa9E3\xcc\xc4-\xa7\xf7\x7f5\xa8Ry\x1a\xe2\xef\xf4Q\x94?\x1d\x02 &L\xe0*t\xdf\xb6M\xb1Y\x17]O>\xfc}\xfb\xf6\xcd\xf3\x97/\x9e\xbf\xbb\xf4\x9f\x00'\xaf|\xfb\xe3\x9b\x17\xff\xe1{\xf8\xee\xcf\xaf_\xf8\x9e=\x1f\x1e\x8e`e\xe1\xdaq)cu\xd28. \xf5C?\x93Z\xbc^=\x97\x9f\xff?\xf6\xae\xa59n\x1cI\xdf\xfbWd\xf4\xc5\xb3\x11\xb6\x1c;\xb7\xf5M~\xac\xd71\xfd\xf0Z\xea\x99\x9d\x93\x86\xaa\x82$\x86\xaa\xc8j\x12\xb4K\x1d\xdb\xff}\x83H\x82\x04\x89\xc4\x83D\xaagc\x02\xb8\xd8\xaa*&\x01\x10\x8fD~\xdf\x97\xbc\x12\xcd\xd7r'\xa6\x1e\x82/\x9fuMq\xd71O\x86\xeez\xbd\x81\xdfDS\x0f\xfa#\x15\xe2\xeb\xef\xa3'\xb4\xd3\x82\xea4\xab\xbd\xeaSs\x1b>O\x0d0\x8e}\x9a\xb1\x8a/\x1a\x83oE\x7f\xbe\x9d\xde\xad\xa6\x96\x87\xf3\xb0\xa1\xa9\xf4\x1dJi\x83/5S\xe1/g\xb5\xfa'b\xd5\xaa\xff0\xb9R\x05h\xd5\xd2$\xfc\xd4\xafFS@\x88\xbbR\x97d\xad.7U\x0b\x15\x9bcv\x8d\xa3\n+J\x81\xb7\xf7\xcc\x9f\xeb\xf3\x17\\\xb5\xa2Ok\xf2|\xa3\x8e\xdbk\x83[\xb0\x1c\xe7\xda\x90v\x0b\xfa\x83<\xb1\xfa\x1f \x91\xc4\xe2^D\x9e\xc2\xd0l'\x7ff\xcex\xf2\x07\xc6\xac'\xbf\xbf\x9c\xfd v\xf6\x83\xd7\xcf\xe0Y\x05\x0c\x83_>\xbf\xb3V\x02\xb25\xabW\x03\xd2\xcas\xae\x08\xb0jU \xab\xf7|+\x03\xacZ\x1d\xc8\xca=\xdf\n\x01\xf6*\xe1\xda\xd6\xed\xb5b\x9c\xb1\xc3\x9f\n\xde\xd2\x83\xcf\x1az\xe3e\x83=s\xfc\x05\xd7\xa6\x95\"2y\xbeif\xd7\x90\xd7\xd1\xd7\x02!B\x83\x98\xb3\x90\xf3(\xe4\x10\xa4\xa9_,Di\x10}\x08\xf1\x89\xd3\x80\x16\xa8y\x8d\xc7\x08\xd5\xc0\x12\xabM&)\xe9\x93\xbbg\xc2\xc25\xf5\xab\x99x\x0d\xa2\xfb\xc6/b\x03J\xc8\x16o\xfc\x7f\x97\xa7\x89Xe\x83_\xd4\x06>\x89\x03X\xe26\xf8\x83b8N\xc1\x1bx\x9f<\x16\xf7\xf3\x07Z\xfc\x06\xfe(\x8fK\x04\x07\x9e\xce\xc0\xe2Q\x90y:\x06KX=\xa6L8\xbe\x0b4\x08KH \x07\xc1\x06b\xf1\n\xe5 \xa6\xb1X\xc2M\xc6\x12\x10\xcdA\\\xeb\xb1\x04\xc5s\x10o-\x14\x0e4\xcb\x16!\x9d\xd7\xe0\\\xeb\xed\xfd)6$Nu\x86%\xaee\x9c\xc2:\x08\x8a\xeb`\xbb\xc0\xcea\xcd\xd9\x011\xcdg\x94\xdf\xf5\xc5+\xc1\x03\x97\x0c\x0f\"*\xcb*\xc7\x03\x97$\x0f\x825\x89\xdd\xc0\xa4K\x9a\x07\xa1\xbdk.\xd1\x83\xe8\xbdv\xabT\x0f\x1cr=\xef\x9d#\xbd\x95\x95\xd2= \xe5{\xc0^\x91\x80\x94O\xdd\xf0LU\x80\xd8\x0c\xdc\xcb\xbf$\xa5}\x10Z\x99C3\x81U\xe6\x07^\xa9\x1f\xb0\xca\xfd\x80S\xf2\x07>\xd9\x1f@\x92\xf4\x0f\x18\xe5\x7f\x10\x94\x00\xc2V\x19 \xa4H\x01\xa9\x1e{:\xe9(3%\x07\x84\x14I akdQ\x00!\x0b\x84Di aN\xb1\xb2$!\x0f\x04v\x89 \xa4\xcb\x04\x81_*\x08irAH\x93\x0c\xd2S\x94\xac$\x9b\x90\x10\xd8\xc5\x84\xc0)(\x84(Q!p\n\x0b\xc1#.\x84D\x81!5\xc7 \xc9!\x0cKMPv\x08\xc9\xd2C\xc2\xa0-F\x84\xed\x82Dp\x1f\xc5\xbc[\xbc7\xbd^x\xff\xdf(R\xa4\x96\xbd\x113\x973\xa1\"\x04\xeb\x91&X\\\x18S\xf2EB\xb4\x08<\xc2E\xe0\x16/\x02!`\x84t\x11\xe3\xc2\x9a\xb4$\x8d\x90(k\x84\x90\xda\x0f\xdc\xf2F\x88\x918\x02\xad\xc6Z%ut\xdb\xb0\xa4.I\xb2GX\xd1\x19!\xf9#\x04\xdb\x1d\x94A\xc2:)$P\xfd\x91*\x89\x84\x90,\x12\xbc\xd2H\x08\xc8#\xc1\xd7K\xb12I\x88\x90J\x02!\x97\x844\xc9$\xc4\xc9&a\x93t\x12\x9c\x1d\x13\x94P\x02\x9f\x8c\x12\xdc\xb5\xb0F\x1a\xab\xa4\x12\x12e\x95\x0bS\xb6\xc8\x12\xb8\x85\x96\xc0,\xb6\x04\x9f\xe0\x12\x08\xd1%\x10\xc2K`\x13_\x02\xa7\x00\x13\xd8E\x98\x10-\xc4\x84\x181&\xc4\x0b2!R\x94 \xe4\xeaL\xca\xf7`\x85\x84\xcf/\xd0\x84x\x91&\xc4 5\x81j\x06\xa7`\x13RE\x9b\x0b[\x96\x84\x13Xe\x9c\xc0*\xe5\x84\xe4\xf1\x10\x94tB\x84\xac\x13\x0ci'\x00)\xef\x84\xe8 \xb4\x1d/O\x92zZk\xf8\xbe,\xaa\x85\xdc\x13 U\xf2\xb906\xbcB\xd0\x92}\x82[\xfa \xde~H\x93\x80\x1a\x86F1\xa8)\x03\xed\xcb\x16)h\x14we\xa8\xf6H^\x19\xfe\x96\x06{e\xb8\x8c\xe0\xb0x)+\xff)\xe2)*K\x99\x83$\xe0\xdd\xd4l\xb5\xa4\x00\xc39\xe8i\xe1\x85\xe3\xe7>J\xc4f\xb1\x85i$Eg\xa1u\x15\xa6\xbdxIE\xa2\x9c\x82\x90R\x90}\xe8\x90PP\x9cu&\xe9\x04-\x9b\x88\x95L,\xe4\x12d\x9b\xdc\xebE\xb2DB1\xf6\xcd\xa9\xb0A\x1e!\x19\xa5\x11\xb4,\"I\x12\xa1E\x10\x86=\x8f\x1c\xc2\x92B\x90O\x84\x1aN\xac\xf2\x87\xed\xd2\x87\xcd\xb2\x07S\xe8`\xf6\xd5&\xc9\xc3V\xb9\xc3\xd8\xa3J\xe2X\xed\x0e\xdd^\xd0K\x85Z$\xca\n\x1b\xaa7\xb0a\x06\x7f7-\x1a\xc6\x1b^\x87\x97\xf9\xd9\xc2H\xe5\x14\x81:o\xa9uP\xdc\xdd\x89\x9d,\xc78\xe8\xf7\xf7E{j\xca\x9d\xf8~\xdc\xe5q\x99\x1c\xc7;fv\xab\x8f\x02\x8e\xe5\xb1\xac\xba\xe3p[\x8d\xc9M\xb8\xdaQ\x1cOu}\xa0w\xba\x8fb\x1b-s\x1a\xad\x91\x92\xdd\xeb\xb3C\xaa+\xcfz1\xd4\xef\xf6 \x13\xd8f\x1eh\xe6\x81f\x1e\xa8\xf5\xe3\xcc\x03u\\\x98y\xa0f 7\x19K\xe6\x81\x12%\xf3@3\x0f\x14\xaf\xcc<\xd0\xa1d\x1eh\xe6\x81f\x1eh\xe6\x81f\x1eh\xe6\x81f\x1e(d\x1eh\xe6\x81f\x1e\xe8\xacd\x1eh\xe6\x81f\x1eh\xe6\x81f\x1eh\xe6\x81B\xe6\x81f\x1e\xe8T2\x0f\xd4*\x99\x07\x9ay\xa0\x99\x07\x9ay\xa0\x18\x00\xcb\xd1\xe4'N\xfa\x133\x01\xea9(PkHP\x914\xa8UD\xa8x*\x94\x83\x0c\xe5\xa2\xbf\xc4\x13`\xc2\x84\xa8U\x94\xa8hR\x14\xd9 nb\x14/5\xcaA\x8e\xe2\xa6Gq\x13\xa4\xd2\xc7H\x14I*\x8e&5'J9\xa9R\xf1a|\n{\xe0$Ly(S\xcc\xa4)?m\xcaK\x9c\xf2\xf7 \x1by\xcaC\x9f\xdaJ\xa0\xb2\xeanR\x82\\T\xa2\xa9A\xe3\xc1\xfeT\xdc\x0f\xe9\xde\xde\xd0v\xa7\x1f\x98\x98\xad\xf1\xa9\xe6\xc2\xe8\xbbO\xf5\x93\x14nA#\x16\x958\xcb\x1b\x0b\xebv\x8eeg0a`\xeaX\x9c\x13m_\xf7L\xff_\x9d#\xae\x1d\xdem\xfd\xb9\xb8\x17\xc3;0/\xf0\xfb\x85\x91\xbe\x1b1\xf3So\xae\xef\x03\x01\xc7\xba\x95 T\xbcI\x05\xa8\x8cKd-\x8b\xc3\xca\x06\xadxa\xbf2\xaf\xda\xa3\xfeSu\xc7[\x0c|\xe8(\xa5\x11*[\xbe\xc1\xdel\xaa\xca\xccv\xa3\x8c,\xe7\xce\xb7\xa2\xc5Td\xa5lu\xa0\xb5\x85\xae\xc2\x81\xb0\xc7X\xd5\xb7\xb2\xc5g@\xb3~\x08\x1e^\x1c\xc5\xef\xfa\xdc\xbe}B4y0\x15z%\xe9\x8f\xf5^|\x1a\x91Mk\xf4\xd9#\xaf-\xab\xfb\x83\x99z\n\xbb\x1a?\x9ev;5\xed\xf13\xcc\xb9\xb6e\x84\x1f\xed\x84Lx7\xf5\x1e\xd8\xa1Gz\xf3\xe3\xbbaul\x87\xbc3\xf8F\xd3\xf2M\xcb\xa0\xdeZ{\xf5\xe9\xe3O\xbe\x17-/\x7f\xf5\xfe\xd3\x97\x0f\xef\xae=?\xb8\xfe\xf0?\xd7\xbf\\\xfe\xe0\xf9\xc5\x0f\x1f>^\xbe\xfb\xfb\xcd\xe5\x8f\x9f~\xfa\xf9F9\x1a\xe6/\xc77/\x87k\xe6\xdf\xba\xae\xca\xfbJ\xbdwy\xf1\xc8\x8c\xce\xc4p\xa7\xc4|u\xad\xd8uM)\x97\x81\xa6\xfb\xaePI\xfb\x16i Uqt\x9f\xa3\xee\xc6\x0b\xa0\x8b\n\xba\n]\xafY\x85\xfa\x15~p\xa0\x16\xf7jD?\x9c\xec\x0d\xd5~6o\xacO\xcc\x1b/:@\x03Z\xad\xea\xae\xf7\xf5\x0e\xc3\xdeK\x88\xe8\xabhp\x0bR=6\xb2c\xe0\xae\xa9\x8fpmQ\x1e\x88\xf1\xf0\xc6\xfeH\xe1Ep\xd7\xa9}sV-d\x81\xf4\xfd\xa0n\xfc\x84<\x8f\xf9=\x1e\xbacQ\xbdjD\xb1W\xab\x99\x14g\xd9\x15\x07\xeb\x94\xd4\xfb\x87'=k\x10 \xb1z\xd6\xbcb\xf9\x8cU\x0b\x03\xc3\xdf?\xba\xdf\xf8\xbe\xc4>\xb8-v\x8f\xdf\x8af\xdf.@\x9a\xc53Z\xdc\xf6\xf2XV5z\x01\xc6\xb8\x81F\x1c\xeb\xafCJQu\xda\xee\xfbw\xb8\xf4\xd8\x1dd9-\x02\x91\x04e\xbd\x84^\xfc\xd8_\xfeb\xb92*\xa3\xf3YV!\xc3B}\xd3\x96\xf7\xe6:5\x9b\xb4\xda\xf2\"\x8a\xbd\\\xf1\xc6\x95\xb6n\x1c\xa6\xfdk?Vq\xb0\xf8\x8aA\xf7c\xe6O\xb9\xd7\xdcw\xfd\xd0\xdd\xc9\xb7\xa5\xbcT}\x84Y\x7f\x17`\x12>LE\x97\x1e\xfd\xa3\xbe[\x91h9[a\x15\x81\xa3\xf7,\x06OLTm\xd7\x88\x11\xf0\x07Q)\xcf\x17]kY<\x8a\x16\xb1\xf2cY\x95\xc7\xe20\xa4\xf44\x0c\xce\xcf\x1cX \x8c8\xa9S\x19\x1a,\xab{\xb2\x16U\xdd\xdf\xb5_n\xa0-\xee4<\x88\x9f\xf7\x0f\xa0\xda\x0f\xf8\xe0\xae\xae\x06`\x12:\xc4\\\xd0P?\x96o\xca\xea\xae^\xcb\xcd_9I\xad\xe99s{\xa7Zh\xefbW7\xe8r\xed\xf5\x8ck''C\xa5\xb6\xd5\x7f\xeaAm\x98\xd3\xb1\xa2Ne\xdaU\xf9T\xad z\xean\x0f\xe5NM\x91\xef\x8cj\xa9)9\xe6FV\xeeN\xbf\x10\xf4]XP\x17\xfb'\xf8\x95\xe1\xb4E\xcc\xf0\xb9\xdf\x95\xe4s\x91\xd3g\xe9k\x85\xfd,\xaf\x8f\xe5\xf7\xaf\xe2|\xabH\xbf\xca=\xbf\xb7\xfaSN\x0f\xea\x0f\xf2\x9e(\xcf\xe9\xf9\xbd\xa6\x15\x1e\xd3s{K,\x9e\x92\xdbK\nzH\x7f\xbcw\xb4\xda3Z.\x95\xb8\x9c\xb8V\xa7\xd9Bp\x01\x9f\x14Id\x0c\x01\x0d\xc9\xe5\xe7\xb0\xbe\xac\x91?\x84\x16\x16\xa1\xf7\x16\xdan\xf7\xd0_v\xa8w\xc5\x90N\x9d\x18\x00&\xb7e\xac\xbc\xbd(\xfe\xdc\xecE\xf3\xf6\xc9\\\x0c\x8d\xe5\xc9\\\x9a^\xc1\xcf_\xde\x7f\xf8r\xf3\xf6\xef\xc4Z`|yy\xf5\xce\xfe\xf0\xfd\x87\xe1\xd3qeq\x1a\xa3\x17\x15\xfa\xee\xb4\x19\xc7\xec\xaf\x1b9-\xbb*=\xfb\x05\x0c\xcd\xd7\xd5R|\xa4\xcb\xabw\xd8}e\x0b\xbb\xc2\x08G\xcd\x1b\xf9f\xf6\xd7\x14\xdajw\x02\xb7Gu\x0b\xe2\xda\xbe/\xde\xcc\xff\x1c\xaf\xee\x1bo]>\x0c8\xa3\xae\xea\xb7j\x9b\xc1F\x8d?\xb6\x1f\xf0\x95\x1ax\xab\x82\x1a\xb8\x8f\xce\x83i+\xfcPI\xb2\x86\x9d\x9e\xa3\xff`\xce\xc8\x11v\xb3\x83\xf9x\xc1l\x8c`'\x17Xng\x01s\xf1\x7f\xfd\xcc\xdfM\x9c\xdf\xcdl_\xd5\xde\xe5a\xd7\xc9\xf3\xdd\xcc\xf0\xc5\xadca\xcd\xc1\xedMa\xf5\xaaS\xc9\xb25\x04\xf0\xbc\x85\xc9\xebf\xed&\xf2u\xa3\x98\xba\xf1\xac\xdc\x04>n\x02\x13\x97X0\x18\xf9\xb6\xbcL[6\x8em\x98]\xcb\xc6\xabu1jS\xb8\xb4$o\x96\x00T\xed\xf5f+W\xd6\xc9\x8b\xdd\xc8\x88%\xb8\xb0\xebB,\x10\xdcA7r^'~+\xd5\xbf\xdf\x85\xef\x9d\xc6pEF\xaba\xce\xe6\xb62\xb0Z\xd3\xf8\xac\x8bQ\xbe\xdc\x0c\x139\xacCG\x9b\x16S\xd8\xaa^*\xa6\x83\xa1\x1a\xe4\xa6\xda4\xb5x>\xaa}\xed\xefT[7\xb1Oc\x1a\x1bb\x9c\xba\xdb\x16d\x99\xae\xe0\x97\xce\xa98\x89\x9cR/\x9b\xd4\xcd#\xf51H\xc9^\x88e\x8d\x86\xf8\xa2K\xa6h\x02G4\x82\x1d\xba\x9e\x17J\xb00C\\P&\x16(q\xe7\xdf\xe7\x91\xe6\x04\xce\xe7\x92\xe3\x99\xc2\xee$\xd8\x9cI<\xce%o\x93\x93\xb1\xe9\xe4j. lK~&\x0f3\x93\x8d\x93\xc9\xcb\xc6\x8c\xe3a\x06\x19\x98\x91\xdc\xcb\x18\xd6\xa5EO\xb4\xef\x16\xcb\x9f\xf3s,#\xd9\x95\x11\xbc\xcaY\x959\xb9\x94I,J\x9b5\xc9\xc7\x97\xe4cJn\x7f\xbaAvd\x88\x17\xa9\x97\xef\x11\xe9\xda\x0cwG\"i\x01\xecZ\x8e@\x9a\x86\x0c5\x90\xf5\xe9\xd5A|\x15Z\x8f\xee\xa3\x1e\\\x95\xc7\xeePHM\xa8\x8b\x0e\xd4r\xbenq6^\xa7w/\x9a\xa9\xd0\xfa\xe16\xd4\xd4\xf4N\xde\xf7\xab\xd1\xae?\xc5\\\xc0\x95\xa8\xf6\n\xc0\x92\xe7\x01\xc3\x1a\xb2\xc6\\\x8cU\xbeQ\x9fG\x0eD7\x9d@\x1b\x1a\xa9\x80\xfdM\x97\x191\\\xcfv\xd6\xdd\x13\x99\x10\xff\x94\x14\x97P_3\x98\x08\x11 \xa7[\xacL\x1cx_\xb4\x8b\x85h\xd6\x06\xfd\xb5\xae\xb3\x91?\xa5?\xb6wRe \x19\xdf\x12\xac\x96\x13U\x93Y\x92\x10\xab\x1et] \xe5\xe5J\x04\x0f\xd5\x1f\xa7\xf8X\xb4\x7fS7\x82\xc5;\x90\xbbJ\xa1\xc4w\xf0\xadn\x1e\xe1\xdb\x10\xd2\xc3\x98\x94<\xdb$\xdb\x93h\xfaJ\\,Z\xb1\xe1\xbdL\xa16|,\xda_\xda\xa9\xc2\xc5,UK\xb1\x93\x18\xc0\xd69[t\x850\xf2\xe8x\xc0\xf8\xa5\xc1o\xed\xff\x1aw\x86\xa4G\xb9\xe2%\x9b\x1bCM\xef\x0bY \x95\xe7 \x996\x8d\x90]\xd3\xaf\xdb\n\xf7\xd5\xee\x81\n\xa8V\xfb\x83h\x8c\xbcK\xf0i \x81\xfc\xf8\xcb\xd55\x11i;\x88\xea^>\xf4K\xfa]y\xc6q\xae\xd0/\xb5<\x89S\xd1\x14R\xe0\xdd\xf1\xa6\xfd\x8e\xd8{(\xb4tz\xac\xc0,,\xb7\xf1\x8d\xa1V\x87\xfcP\xdf\xcf\xddq\xc5\xc67\xe6\xac\xa3_\\\x954\xebH\xa5\xdf\x93\x04G\x08\x98_\x14\xaa.\xb3>\xf5t\x11\x04\xd3\xe8\xb9\xaa\x8d\xe5y_\xe9\xe9M\x8f\xe7m\x93.\x81\xbc\x04\x10\xce\x99\xc7u\x1bO\x9aH\x18os[\xd7\x07Q\xd0\x99G\xc0\xbc\x8f\xe7w!\x1d\x10\x16E\xbd\x9f\x12\xf6\x95\x06\x0b\xfeQ<\xbd\x9a\x92\xcd\xbd\x84\xa2m\xeb]\xa9\"\xa1*\xa6O\x1b,*\x1c\xf5\xcb\xd8H\xa8:\x986Nm\x1b\xad\x99\x0d\x0d\xf6\xbd\x83\xd6\x8f\x10\x05\x92(\xb7\xf0\xc18^[\x86\xcc\xa9+ \xa1\xb2\xde\xee\xdf\x8a\xfb\xb2z{\xa8w\x8f/\xc7\xcf>T\xfb\xc5'\xef\x1e\xc4\xee\xf1\xfalI}LK\xef\xc5\xa1\xfc*\x9a\xeb3\xa1\xa9\xfe\xa1\x90\xa2y9\xf7\x93\x8f\x98CM\xebu\xba\xbe\xbf\xfb\x95\xa7\x15\xc3\x821\xef;\x7f\xcfm\xcf\xc47\xe4\xdc[\xd8\xd3K\xf0\xe2cr?P\xbf \xf9o\x11j\x10}\xcd\xc2\x8f\x0b9p\xd7\xe7h\x97\xed\xb6\xde\x13\xec\xdfz?J\x85NM\xbd\xeb[~{\x18\x90\xe6\x89\x04`<\xbb\xc9B\xfc\x96>t\xe8?i\x17\xc8\xa9\xe1rj8\xd2ZN\x0d\x0795\x1c}\x9fD\xaa\x896\x12A8!\xaf\x8c&\xa1`I\xa0\xa2`I \xa4\xb8&\xba\xa3\xaalT\x15,\xbc\x84\x15,l\xb4\x15,a\xf2\n\x166\n\x0b\x96\x9c\x1a.\xa7\x86\xc3pON\x0dg\x944*\x8deN\xe6\xd4pa\xfa\x0d\x96PR\xb40\x15\x07KN\x0d\xb7\x8e\xba\x83%\xa7\x86S%D\xf5\xc1\x92S\xc3\xc9\x04R\x10\x96\x9c\x1an%\xa5\xc8\xaerN\x0d\xc7AC\xc2\xc2KF\xc2\x12GI\xc2\x12$&a\x89\xa4'\xcd~\x9cS\xc3\xa9\xc2Ig\xc2\x92Dj\xb2\xac\xe5\xd4p\xdc\xa9\xe1\xfc'\x14\x1dtF@Gg\x08\x1b?\xc5X\x00\x06\xf2\xc5\x1e\x03\x87\x8d\xf8\xb5+\x1b+00\xe5\x0cXv\x91|\xa8[1\xd9D\xc9\xa3z>\x03S\xa8\x1fi\x08\xfb\xd6w*Q\x85B*\xac\x83\xc4e'\x1f\x14=\xcbz\x01\x12\xde{Ho\xd0[\xbb>\xbf@\x9aQ!\xbbF\xb4\x17\xf0\xa1\xd8=\x8c5\x1fiY\xc8:\xb2\xb3\xde\x14j\x90\xda\xa0\x90\x1c\xb3\xa8\xf5{\x97\xda\xb7\xfay\xab\xd2\xc8A)\xa1\xde\xed\xba\xc6N\x17\xf4V\xf1\x06\xbe\x8aJ\xcf\x10}\xdd\xb2B\x7f\xd2\xa1O\x05%\x8f\xbf\xa3\x9f\x99\x15!)[h\xc4\x9dh\x1a\x0cH\x15\x1a\xb0(\x8f\xea\xb49Q\xd1N\xc5\x13~w'\x96\xd0\x8a.\xdf\x1e\xea\x83\xb5\x0d:^Rs\x14\xc7\x9a\x05a\xef\x0di\xca\xc1tL\xaej)^\xef\xea\xa3\n\xb3\xe3\x80\xd4\xcf\x07\x16\xb0\x8b\xd5\xf3\x7f\xbb\xfc\xf2\xd3\xa7\x9f>\xbe\xe9\x17\x87\xdd\xa1\xec\xc7\xd5Ke\x1e\x99_\x87'\x10\xe7S\xad\xf2\x8c\x88\xb3\xd4\xe1\xf0\xaa\x96v\x1e\xa6]q8\xa8\x05\xf3X[Y\x05o;i\x84\xd2\x87_\xfe\xa3\xaf\xf8?\xc67m\xfd\xa9\x15V&#)O\xed\x9b\xd7\xaf\xefK\xf9\xd0\xdd\xaa%\x01\xc1\xab\xe1\x9fW\xed\xfe\xf1u\xd9\xb6\x9dh_\xff\xc7\xbf\xff\xf9\xcf\xfff\xf6z?\xe6\xeaN\xdeP\xaf\xe4t\xf6\x7f8\xb1\x9c\x95+o\xb8\x8f\xc6\xbf\xcc7u\x0e\xbe\x19.\xcaH\xe11\x18fj\xd1\xaf\xea\xe5\xe8\xbd\x1d1\xb4\xe1\xcdG\xfd2\xfeP\xccf\xbb8KQ\xb5e]\xdd`0\x1fB\x9dr\xf70\xec\x98C\xe6\xcbQ\xfad\x98\x9b+\xa8&\xd5\xd3\\\xe64\xbeXpWW\x95\xd8\xa97\xc7\x8d7\xec}\x98\xc2\xccpg\x18<\x94\x8f3\xff\xc1\x97\x04\xb9w\xdc\xeaV\x8d\x0d\"\x89\xdb\xf5\x98Y\xb8\x95E\xb5/\x9a\xc1-\x1a\xc3N\xb7M]\xecwE\xab*g\xa6\xb6s\xe5i{;\xa6_\x93\xe1\\mZQ\xb6\xe9\x99[\x18\x94\x0b\x7f\x92\x0e\xec\xc9\x13$\n\xc5\\X\xf1&\x1f\xd6\xc4\x8931bL\x1e|) [\xe2\xc3\x95B\x98\xd2F\xdc\xc4\x8f\x998z%\x1e+ \xe3$6F\x92\x84\x8fDa#[p\x11\x12\x87\x08\xe3!lX\x08y\xff\xc5HJ\xc2?l\xbc#\x05\xeb \xb1\x8d$\\\xc3\xc61x1\x0c\x0f~a\x87um\xdc\x82\x0b\xb3`\xc4+\xb8\xb1\x8aX\x9c\"\x02\xa3\x88\xc6'\xe2\xb0 \"\x8cO\xdd56\xd6\x1c\xc2#\xa2\xb1\x88(\x1cbQy^\xfc! {\xa0\xb0\x06N\x9c\x81\x13cHy\xde\x11\xd8B\x18W\x98\x16\x7f\xb7W\xad\x03\x86\x1b\x92]9\xd2[mNm\xe5Hf\xc5\x99\xc8\x8aJb%\xd7'\xb0bL^5\xf4\xd3\xec\x84\x9d\x94\xb4\xcaNSE\xa4\xa8\x9a\xa7\xa7\"\xcf\x8a\xbe!\xc3\x99\x92*%\x1d\xd5\x90VjQ\xb7Y*\xaa\x0di\xa86\xa7\xa0r\xa5\x9f\"\xfb\xd7\x91v\x8a\x02\x928\xd3M\x85RMy\x94-2# \xb3\x92\x91\x84\x8c$d$!# \x19I\xc8HBF\x12\x16_\x85v\xe9\x8c$\xc8\x8c$d$!# \x19I\xc8HBF\x122\x92\x90\x91\x84\x8c$d$\xe1\xff=\x92@)\x13RT \x84\x0e\x81Q\x83@D\xc2\x92\x12\x01\xc5&\x01\x929T:+9T\x9aC\xa59T\x9aC\xa59T\x9aC\xa59T\xba\xf8*\xb4K\xe7Pi\x0e\x95\xe6Pi\x0e\x95\xe6Pi\x0e\x95\xe6Pi\x0e\x95\xe6Pi\x0e\x95\xe6Pi\x0e\x95\xfe\xf3B\xa5t\x9a\x16\xe6\x14-RT{\xd1\x1c\xcbJ^\x14\xb7\xbb\xf2\xe2\xc3WQ\xc9\xe8D\x18\xea'\xd3\xa3\xb0\x0ff\x85\x94My\xdb\xc9\xe7\xce\x95\xf1(\x9e8\x8e\x89l\xe7\xcd\xb2\xda\x8b3m\xe8\xb6\xae\x0f\xa2X\xa6\x02\x1d-Y\xdf\xce\x1e\xf8\x0b\xf5|.u\xaf\xa2\x9e\xa0-\xab\xfb\x83\xe8\xfb\xe0\x15nz\xa7\xa2l^B\xd1\xb6\xf5\xaeT\xc7\xa4a\xc7\x02\xd1_}\xf1\xc2\x1eH\xe3\xf4Q\xf61\x96\xd4B1\xc5\x98`/\xbe\x8aC\xdf\xf9\x98\x00F\xcab\xf7`nzF\xca\x17\x83\xfa\xffE\xb4\xa7\xbaj\xc5[q_Vo\x0f\xf5\xee\xf1\xe5\xf8\xd9\x87j\xbf\xf8\xe4\xdd\x83\xd8=^\x9f\xfb)\xb1\xb8\xfe\xbd8\x94_Es}\x1e\xfd\xd7\x1f\n)\x9a\x97\xb3\xdc.p,\x9e\xfa\xe9\xf2k'\x9a\xde\xb9\xe9Z\x95\xfdEMC\xd5\xf2\xd69\xe2\xc7\x1e\x8d\x1e\xfa\xb3\x11G\x0e\x11bp,\xc6W\xece\x8b\xd1D\x8f#j\x04=\xcf\xd8\x19\xf2\xe7t\xa7\xfb\xa6\xd8\x8b1\x89\xce\x8f\xf5\xbe;\x88\xbfbH.\xba\x1f{?#\xd0#\xc3\x12o\x02\x03\xc5\xe9\x04Gu?\xdd\xb3\xe6m\x9d\x96\xfcr\x80]?\xd2\xaa\xb6k\xb55\xc7\xddf\xbd:k\xf5\x18\xfd\xe9\xbb\x16\xaf\x18\xe2z\xadm\xfd\xc2\xdd\x95\x9f\x0f\x05k\x0f\xbaCOWB\xe2\xe6\xa1zW\xab[t}\x109R_\xe9\xbd\xa83$\x0d\xc3\xcffN\xcb\xa2\xeb\xda\xfaN~\xeb\xf7\xc9~\xd18\x9d\x0e\x18!P\xddT\x1c\xe0\xfb\xbaz5\x18\xf9\x1ev\xf5\xf1XT{\x13\xf7\xd8w\xaa\x19\xc6'rT\x01MK\xcap\xd41\x8e0\x83M5\xc4\xfb5L\xec/\xe0\x93\x8a\xad\x16\x87\xb66\xcc\xf5\xad\x99\x99\xafa/\xa4\xd8\xc9~\xd3W\x01\xd1bj\x82nZ\xef1\xe0F\x0d\x05\xdc\x97_E5u\x98B\x19L\x8b\xba*xA\x83\xd3I\x8e\xdd\xda{\x94\xb7BT\n\x1f\x19\xceX\xfa\x86/\xa1\x94\xaa\xdf\x0ds\xf3\xf0\xea\x00W\x8c\xc8\xd0T\xd7\xb2\x85\xba\x93\xaf\xea\xbbW\xfbB\x8a\xc9\x85\xd1\xd5\xb9.\xfb\xc9d&\xff\xfa/\x94\xba\x943\xd7\xa7\x11\xc5\xee\xa1wR\x87\x83\xe6h_\x0d\x07q.\xa5)\xcb\x89\x9c}}\x8d^\xf5\xbf\x8f\x18\x9f\xef{\xefy\xd7/Do\xb0\xce\x08c\x0c\xcdh\x11\xaeP\x1d\xb8\x1f\x7fya\xfc\x92x\x12\x87\xfa\xbe\xdc\x99\x8d\x1c\x9fA#\x8e\xf5W\xb1\x9ftdW\xef\xff2\x0b\x98\xa8\xe3B\xd9\x0e'\xbc!T\xaf\xa2\xe2/G\xb0f\x9c)\xf2\xa1\xa9\xbf\x8db\xb0Ur\xa5\xf9\xf24\xeb\x9d\x99f\xa9?\x07k\x89\x92\x1c\xf5I\xd3S>\x0eA\xed\x93hz\xd3bo\x865~\x1e\x02\x03{(\xef\xb0\xc7\x86\x06\xb5b|\xaa\xf3\xc4}\xbe\xd5yV/\x15 4\x9c\x871\xce?N\xcc\xea\xae\x1e\x90\x9f\xb2\xda\x1d\xba\xbd\x82\xa6^-_\xc7\xdfv\xbd\x93\xd1\xaai&\xd5\x02QJ\x1c\xec*H_\xc8\xba\xe9\x17\xd6\xee\xb0\x87\xa2\x93u\xef~`\xee>}\x1f\xa9'\xbb^\xaanP\xfdv\xd3\xcaBZ\xe3u\xe1n\xd2\xce\xa6$\x19\x02N'\xd1\x8f;0r\x03\xdc\xcc\x00>^\x00\x1b+\xc0\xc9 \xa0\x82T\x91\x8c\x00.>\x80\x9f\x0d\xb0\x89\x0b\xc0\xcb\x04p\xf2\x00xY\x00\x0e\x0e@\"\x03\xc0\xeanI\xe0\xff\xbc\xe8\x7f\"\xf6\xcf\x8c\xfc'\xe0\xfe\xdc\xa8?\x1b\xe6\xcf\x8b\xf8\xb3\xe1\xfda\xb4\x9f\x0d\xebw!\xfd)8?\x89\xeb\x13\xc15{\xbdI\xc3\xf4 \x0c\x7f#\x82O\xc4S\x9c\x1b\xa53\x96\xe2\xdfA7\xe2\xf6\x13NO\xf5\xefw\xe1{3#\xf66^\xcf\x80\xd6\xb3b\xf5\xcb\xcd0\x11\xa7\x1f:\xda\xb4\x98\x82\xcc{\xa1i\x07*\x1f\xc4\xe4m\x180\x1e\x8f\xb7\xaf\xfd\x9dj\xeb&$>\xa6\xb1!\x14\xde\xdd\xb6 \x02\xbf\x02\x7f\x9f\xc3-\x89\xd8\xbb\x17yw\xe3\xee>\xd4\x9d\xec\x85X\xc4=\x84\xb7/\xd1\xf6\x04\xac=\x02i_\x8f\xb3\x13(w\x08cgB\xd8\x89;\xcfF\n+\xb6\xce\x8c\xac\xb3\xe2\xea\x9c\xa8\xba\x13S_\x02\x95K<\x9d\x07Mg\xc3\xd2y\x91\xf48\x1c=\x88\xa2Gb\xe81\x08\xba\x85\x9f\xdbw\x8b\xc5R\xfd\xd8y$r\x1e\x81\x9b\xcf\xaa\xcc\x89\x993#\xe6|x9\x1fZ\xbe\xfd\xe9\x06\x91\xf2\x10N\x8e\xcb7\xed\xc3~>\x14&\\a\xc2w\xc5m\xddI(\xe0t(\xaaj\n\xb6\xaa\xa7\xa9\x02\xc9\xa5\xce\xf64\xd8R\xc9\xbb\xfbq\x909\xef\xe0\xce\xbb\xd8\xd2\xf1\x81\xd50\x7f>:x>\xfc8\x1cB\xc7B4\x883\x9c\x8e%)\xa8nY#\xb9\xf4\x9c\xa1v\xe36,\x01w,\xa9c$\x18|\x1f\xccE\xb0\xea\xcdW|\x81#\x1c\x8f\xc5s\x0e\xf3\xa5\xda\xf1\xa5\x8a\x89\x0e\xd3cY\x11\xac'\xee=\x0b\x85/\xf8\xda\x18\x8a\xc7\x7f\x86C:\xfe_\xf4\x9b\"\xfew\x0c\xf3\x9c\x8a\xfb\xb2Zt\xd1<\xa7\xd7\xf8\x03\x8c\x9a u\x923>\xd5\x02\x04\xcd@\x9ej,\xe3\xb9\xbe\x958\xcb\x1b\xeb}\\\xce\xa7\xe4<'S\xef\x95\x00\xc3\xbe\xa6K\xf7\xff\x1d\x82=E\xdbb\x14\xebsq/\xbe\x88_;\xd1\xca\x0b\xfc~a\xe4\xd7N4\xf8\x0e\x9b\xde\\\xdf\x07\x02\x8eu+A\xe87\xb9\x1d\xccc\x99\xace\x11K^\xf6\xa8\x07\\\xc9~\x94y\xd5\x1e\xf5\x9f\xaa;\xde\xe2\x99^\x07\xe0\x8c(\xd0\xdd\xe2Z\xb3\xa9\xbb\xba\xab\xe4\x8d2\xb2\x9c\xe0\xdf\x8a\x16Z!_*a\xc1\x10Cl\xa1\xabp \xec1\x0c\xf3\xadl\x83\x1c\xf69\xa8\x14#d\xb9\x9c\x0f\xf0/\x9f\xdf\x0d\xf6,\x92\xfa\x9d\x10jLo\xe4\xa9\x0f\xf3!\x80\xd7\xb9c\x1d\xc3\xf5\xbaM\xc5~\xdf\x88v<\xa8w\xad\x18f\x9fZ\xf3+\x8c\x9a\x16\xd5NG%J3\xb7\xd8]W\xed\xc7h\xd20g\x13+&|\x15\xbb\x15}\xad\xf4B\xb1\xa8\x9da\xaa\xa80\xe0\xd6_\xf4\xa2\x9dWs\xbc\xc4\xb1~L&\xf5;\x13\xf1E\x87\xb7E[\xee\xd4F{W\x1e\xa4h\xfa\x95J\x88\xe9\xe7\x9b\x96\x11\x99%\x03\xe9H]\x96\x0c\xc4\xa1p\x18\xf9\xb7\xfa(K\x06\xb2d`\x1dBF\x86\x10\xd8p0^\x04\x8c\x0d\xfb\n\xa3^lxW\x96\x0c\xfc\xcbI\x06\x06\xa7\x18\xcf\\j\xa3\xac\x1b5-\x94\x95\xbf\xfc\xf5\xaa\xff\xbb\x1f}\xfd\x9ci\xfa5@y9\xd8M\xfd\x1e\xa6\xd7]\x8f\x1f\x899\x9a\xb5?\xb2\x9a\x11\x15\xef\x18\xa9\xd3\xdb\xf4g\xdc\xc1m\x95_d9\xb9\xb0\xdd-\xe2txa\xe9\xf4\x02\xe5\xf8BjeY\x9c`\x088\xc2@?s\xe0w\x88\xc1\xf5\xf0!\xa7G]\xe10\x03\xa7\xd3\x0c!r[\x82\xf3\x0c\x8c\x0e4\x04\x9dh\xd8\xeaHC\x8a3M\xf5X\x98\xd0\xb6\xd9\xa9&l\x05\xc9l)\xce5a.\xa7GMs\xb8!\xcd\xe9\xa6\xa7(YI6W\x1c\xd8\xddq\xe0t\xc9!\xca-\x07N\xd7\x1crzT\xea6\x1b]z\xf8WM\x8f\xca\xe9\xee{\x03\xd5\x96\xbb\x1f\x15\xab\x1e=\xba5a\xea\xf9\xfd\xd6+.F\xc7\xf0\x99U\x17\xe4\xd9\xc1;\xa0B#&\xe1\x04a\x8fk\x95\x8a\xc8r\xc4\x1d\xa7\x08\x86j\xb3\x9d%\xc2\xa7 \xe7y\xe2YN\x14\x9e3E\x96\xd0l?a0\x9f1\xb2\x84fV8\xcf\x1bQ'\x0e\xde3G\xc4\xa9\x83\xfd\xdc\x91%4XV\x9dS\x92O*\xdcg\x95,\xa11K\xdc\xa9\x85\xf9\xdc\x92%4YB\x93 \xa1\xe1=\xd3\x80\xd3)4\x96\x9a\xfe\xcf\x17\x99\x196+\x99\x196+\x7f43\xcc>\x00\xaf:qS\xcc\xb0V\xec\xba\xa6\x94O\xef'\x0f\xa5\xef\xebG}\n\xc6\xaeV\x87\xa3\xef\xfe/\x00\x00\xff\xffPK\x07\x08\xff\xfa\x85\x02\xc0\xe9\x01\x00\x0e\x07\x19\x00PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\xd4`4t\xc7\x01\x00\x00\xbd\x01\x00\x00\x11\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x00\x00\x00\x00favicon-16x16.pngUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(6B\xc8\xd7\x7f\x04\x00\x00u\x04\x00\x00\x11\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x0f\x02\x00\x00favicon-32x32.pngUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\x8e\x10\x9f\xf1}\x02\x00\x00\xe3\x05\x00\x00\n\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\xd6\x06\x00\x00index.htmlUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(]\x12r 9\x03\x00\x00T \x00\x00\x14\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x94 \x00\x00oauth2-redirect.htmlUT\x05\x00\x01\x80Cm8PK\x01\x02\x14\x03\x14\x00\x08\x00\x08\x00\x00\x00!(\xff\xfa\x85\x02\xc0\xe9\x01\x00\x0e\x07\x19\x00\x0c\x00 \x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x81\x18\x0d\x00\x00swagger.yamlUT\x05\x00\x01\x80Cm8PK\x05\x06\x00\x00\x00\x00\x05\x00\x05\x00_\x01\x00\x00\x1b\xf7\x01\x00\x00\x00" fs.Register(data) } diff --git a/client/docs/swagger-ui/swagger.yaml b/client/docs/swagger-ui/swagger.yaml index 614425587d..41709b2f07 100644 --- a/client/docs/swagger-ui/swagger.yaml +++ b/client/docs/swagger-ui/swagger.yaml @@ -183,30 +183,34 @@ paths: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: >- - Unit stores cpu, memory and storage - metrics - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: + val: type: string - value: - type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and - storage attributes + format: byte + title: >- + Unit stores cpu, memory and storage + metrics + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and + storage attributes endpoints: type: array items: @@ -545,30 +549,34 @@ paths: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: >- - Unit stores cpu, memory and storage - metrics - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and - storage attributes + format: byte + title: >- + Unit stores cpu, memory and storage + metrics + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and + storage attributes endpoints: type: array items: @@ -957,30 +965,34 @@ paths: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: >- - Unit stores cpu, memory and storage - metrics - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: >- + Unit stores cpu, memory and storage + metrics + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and + storage attributes endpoints: type: array items: @@ -2146,30 +2158,34 @@ paths: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: >- - Unit stores cpu, memory and storage - metrics - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: >- + Unit stores cpu, memory and storage + metrics + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and + storage attributes endpoints: type: array items: @@ -2415,30 +2431,34 @@ paths: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: >- - Unit stores cpu, memory and storage - metrics - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and - storage attributes + format: byte + title: >- + Unit stores cpu, memory and storage + metrics + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and + storage attributes endpoints: type: array items: @@ -26404,26 +26424,30 @@ definitions: title: Attribute represents key value pair title: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: + val: type: string - value: - type: string - title: Attribute represents key value pair - title: Storage stores resource quantity and storage attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: Storage stores resource quantity and storage attributes endpoints: type: array items: @@ -26483,6 +26507,8 @@ definitions: akash.base.v1beta1.Storage: type: object properties: + name: + type: string quantity: type: object properties: @@ -26688,44 +26714,50 @@ definitions: title: Attribute represents key value pair title: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: - type: object - properties: - key: - type: string - value: - type: string - title: Attribute represents key value pair - title: Storage stores resource quantity and storage attributes - endpoints: type: array items: type: object properties: - kind: + name: type: string - enum: - - SHARED_HTTP - - RANDOM_PORT - default: SHARED_HTTP - description: >- - - SHARED_HTTP: Describes an endpoint that becomes - a Kubernetes Ingress - - RANDOM_PORT: Describes an endpoint that becomes a Kubernetes NodePort - title: >- - This describes how the endpoint is implemented - when the lease is deployed + quantity: + type: object + properties: + val: + type: string + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and storage + attributes + endpoints: + type: array + items: + type: object + properties: + kind: + type: string + enum: + - SHARED_HTTP + - RANDOM_PORT + default: SHARED_HTTP + description: >- + - SHARED_HTTP: Describes an endpoint that becomes + a Kubernetes Ingress + - RANDOM_PORT: Describes an endpoint that becomes a Kubernetes NodePort + title: >- + This describes how the endpoint is implemented + when the lease is deployed title: Endpoint describes a publicly accessible IP service title: >- ResourceUnits describes all available resources types for @@ -26872,26 +26904,30 @@ definitions: title: Attribute represents key value pair title: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: + val: type: string - value: - type: string - title: Attribute represents key value pair - title: Storage stores resource quantity and storage attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: Storage stores resource quantity and storage attributes endpoints: type: array items: @@ -27105,28 +27141,32 @@ definitions: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and storage + attributes endpoints: type: array items: @@ -27420,30 +27460,34 @@ definitions: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: >- - Unit stores cpu, memory and storage - metrics - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: >- + Unit stores cpu, memory and storage + metrics + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and + storage attributes endpoints: type: array items: @@ -27722,28 +27766,32 @@ definitions: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and storage + attributes endpoints: type: array items: @@ -27845,26 +27893,30 @@ definitions: title: Attribute represents key value pair title: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: + val: type: string - value: - type: string - title: Attribute represents key value pair - title: Storage stores resource quantity and storage attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: Storage stores resource quantity and storage attributes endpoints: type: array items: @@ -28811,26 +28863,32 @@ definitions: title: Attribute represents key value pair title: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: Storage stores resource quantity and storage attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and storage + attributes endpoints: type: array items: @@ -29633,28 +29691,32 @@ definitions: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and storage + attributes endpoints: type: array items: @@ -29842,28 +29904,32 @@ definitions: Memory stores resource quantity and memory attributes storage: - type: object - properties: - quantity: - type: object - properties: - val: - type: string - format: byte - title: 'Unit stores cpu, memory and storage metrics' - attributes: - type: array - items: + type: array + items: + type: object + properties: + name: + type: string + quantity: type: object properties: - key: - type: string - value: + val: type: string - title: Attribute represents key value pair - title: >- - Storage stores resource quantity and storage - attributes + format: byte + title: 'Unit stores cpu, memory and storage metrics' + attributes: + type: array + items: + type: object + properties: + key: + type: string + value: + type: string + title: Attribute represents key value pair + title: >- + Storage stores resource quantity and storage + attributes endpoints: type: array items: diff --git a/go.sum b/go.sum index c8183f603e..326369df02 100644 --- a/go.sum +++ b/go.sum @@ -5,7 +5,6 @@ cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxK cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc= cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0= cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To= -cloud.google.com/go v0.51.0/go.mod h1:hWtGJ6gnXH+KgDv+V0zFGDvpi07n3z8ZNj3T1RW0Gcw= cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4= cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M= cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc= @@ -48,18 +47,23 @@ github.com/Azure/azure-pipeline-go v0.2.2/go.mod h1:4rQ/NZncSvGqNkkOsNpOU1tgoNuI github.com/Azure/azure-storage-blob-go v0.7.0/go.mod h1:f9YQKtsG1nMisotuTPpO0tjNuEjKRYAcJU8/ydDI++4= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78 h1:w+iIsaOQNcT7OZ575w+acHgRric5iCyQh+xv+KJ4HB8= github.com/Azure/go-ansiterm v0.0.0-20170929234023-d6e3b3328b78/go.mod h1:LmzpDX56iTiv29bbRTIsUNlaFfuhWRQBWjQdVyAevI8= +github.com/Azure/go-autorest v14.2.0+incompatible/go.mod h1:r+4oMnoxhatjLLJ6zxSWATqVooLgysK6ZNox3g/xq24= github.com/Azure/go-autorest/autorest v0.9.0/go.mod h1:xyHB1BMZT0cuDHU7I0+g046+BFDTQ8rEZB0s4Yfa6bI= -github.com/Azure/go-autorest/autorest v0.9.6/go.mod h1:/FALq9T/kS7b5J5qsQ+RSTUdAmGFqi0vUdVNNx8q630= +github.com/Azure/go-autorest/autorest v0.11.12/go.mod h1:eipySxLmqSyC5s5k1CLupqet0PSENBEDP93LQ9a8QYw= github.com/Azure/go-autorest/autorest/adal v0.5.0/go.mod h1:8Z9fGy2MpX0PvDjB1pEgQTmVqjGhiHBW7RJJEciWzS0= github.com/Azure/go-autorest/autorest/adal v0.8.0/go.mod h1:Z6vX6WXXuyieHAXwMj0S6HY6e6wcHn37qQMBQlvY3lc= -github.com/Azure/go-autorest/autorest/adal v0.8.2/go.mod h1:ZjhuQClTqx435SRJ2iMlOxPYt3d2C/T/7TiQCVZSn3Q= +github.com/Azure/go-autorest/autorest/adal v0.9.5/go.mod h1:B7KF7jKIeC9Mct5spmyCB/A8CG/sEz1vwIRGv/bbw7A= github.com/Azure/go-autorest/autorest/date v0.1.0/go.mod h1:plvfp3oPSKwf2DNjlBjWF/7vwR+cUD/ELuzDCXwHUVA= github.com/Azure/go-autorest/autorest/date v0.2.0/go.mod h1:vcORJHLJEh643/Ioh9+vPmf1Ij9AEBM5FuBIXLmIy0g= +github.com/Azure/go-autorest/autorest/date v0.3.0/go.mod h1:BI0uouVdmngYNUzGWeSYnokU+TrmwEsOqdt8Y6sso74= github.com/Azure/go-autorest/autorest/mocks v0.1.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= github.com/Azure/go-autorest/autorest/mocks v0.2.0/go.mod h1:OTyCOPRA2IgIlWxVYxBee2F5Gr4kF2zd2J5cFRaIDN0= github.com/Azure/go-autorest/autorest/mocks v0.3.0/go.mod h1:a8FDP3DYzQ4RYfVAxAN3SVSiiO77gL2j2ronKKP0syM= +github.com/Azure/go-autorest/autorest/mocks v0.4.1/go.mod h1:LTp+uSrOhSkaKrUy935gNZuuIPPVsHlr9DSOxSayd+k= github.com/Azure/go-autorest/logger v0.1.0/go.mod h1:oExouG+K6PryycPJfVSxi/koC6LSNgds39diKLz7Vrc= +github.com/Azure/go-autorest/logger v0.2.0/go.mod h1:T9E3cAhj2VqvPOtCYAvby9aBXkZmbF5NWuPV8+WeEW8= github.com/Azure/go-autorest/tracing v0.5.0/go.mod h1:r/s2XiOKccPW3HrqB+W0TQzfbtp2fGCgRFtBroKn4Dk= +github.com/Azure/go-autorest/tracing v0.6.0/go.mod h1:+vhtPC754Xsa23ID7GlGsrdKBpUA79WCAKPPZVC2DeU= github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo= @@ -74,10 +78,9 @@ github.com/MakeNowJust/heredoc v0.0.0-20170808103936-bb23615498cd/go.mod h1:64YH github.com/NYTimes/gziphandler v0.0.0-20170623195520-56545f4a5d46/go.mod h1:3wb06e3pkSAbeQ52E9H9iFoQsEEwGN64994WTCIhntQ= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= -github.com/PuerkitoBio/purell v1.0.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= +github.com/PuerkitoBio/purell v1.1.0/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= github.com/PuerkitoBio/purell v1.1.1 h1:WEQqlqaGbrPkxLJWfBwQmfEAE1Z7ONdDLqrN38tNFfI= github.com/PuerkitoBio/purell v1.1.1/go.mod h1:c11w/QuzBsJSee3cPx9rAFu61PvFxuPbtSwDGJws/X0= -github.com/PuerkitoBio/urlesc v0.0.0-20160726150825-5bd2802263f2/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578 h1:d+Bc7a5rLufV/sSk/8dngufqelfh6jnri85riMAaF/M= github.com/PuerkitoBio/urlesc v0.0.0-20170810143723-de5bf2ad4578/go.mod h1:uGdkoq3SwY9Y+13GIhn11/XLaGBb4BfwItxLd5jeuXE= github.com/Shopify/sarama v1.19.0/go.mod h1:FVkBWblsNy7DGZRfXLU0O9RCGt5g3g3yEuWXgklEdEo= @@ -91,6 +94,7 @@ github.com/Workiva/go-datastructures v1.0.52/go.mod h1:Z+F2Rca0qCsVYDS8z7bAGm8f3 github.com/Zilliqa/gozilliqa-sdk v1.2.1-0.20201201074141-dd0ecada1be6/go.mod h1:eSYp2T6f0apnuW8TzhV3f6Aff2SE8Dwio++U4ha4yEM= github.com/aead/siphash v1.0.1/go.mod h1:Nywa3cDsYNNK3gaciGTWPwHt0wlpNV15vwmswBAUSII= github.com/afex/hystrix-go v0.0.0-20180502004556-fa1af6a1f4f5/go.mod h1:SkGFH1ia65gfNATL8TAiHDNxPzPdmEL5uirI2Uyuz6c= +github.com/agnivade/levenshtein v1.0.1/go.mod h1:CURSv5d9Uaml+FovSIICkLbAUZ9S4RqaHDIsdSBg7lM= github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= @@ -99,6 +103,7 @@ github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d/go.mod h1:rBZYJk5 github.com/alessio/shellescape v1.4.1 h1:V7yhSDDn8LP4lc4jS8pFkt0zCnzVJlG5JXy9BVKJUX0= github.com/alessio/shellescape v1.4.1/go.mod h1:PZAiSCk0LJaZkiCSkPv8qIobYglO3FPpyFjDCtHLS30= github.com/allegro/bigcache v1.2.1-0.20190218064605-e24eb225f156/go.mod h1:Cb/ax3seSYIx7SuZdm2G2xzfwmv3TPSk2ucNfQESPXM= +github.com/andreyvit/diff v0.0.0-20170406064948-c7f18ee00883/go.mod h1:rCTlJbsFo29Kk6CurOXKm700vrz8f0KW0JNfpkRJY/8= github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY= github.com/apache/thrift v0.12.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= github.com/apache/thrift v0.13.0/go.mod h1:cp2SuWMxlEZw2r+iP2GNCdIi4C1qmUzdZFSVb+bacwQ= @@ -110,6 +115,7 @@ github.com/armon/go-metrics v0.3.9 h1:O2sNqxBdvq8Eq5xmzljcYzAORli6RWCvEym4cJf9m1 github.com/armon/go-metrics v0.3.9/go.mod h1:4O98XIr/9W0sxpJ8UaYkvjk10Iff7SnFrb4QAOwNTFc= github.com/armon/go-radix v0.0.0-20180808171621-7fddfc383310/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8= github.com/aryann/difflib v0.0.0-20170710044230-e206f873d14a/go.mod h1:DAHtR1m6lCRdSC2Tm3DSWRPvIPr6xNKyeHdqDQSQT+A= +github.com/asaskevich/govalidator v0.0.0-20180720115003-f9ffefc3facf/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= github.com/asaskevich/govalidator v0.0.0-20190424111038-f61b66f89f4a/go.mod h1:lB+ZfQJz7igIIfQNfa7Ml4HSf2uFQQRzpGGRXenZAgY= github.com/avast/retry-go v2.7.0+incompatible h1:XaGnzl7gESAideSjr+I8Hki/JBi+Yb9baHlMRPeSC84= github.com/avast/retry-go v2.7.0+incompatible/go.mod h1:XtSnn+n/sHqQIpZ10K1qAevBhOOCWBLXXy3hyiqqBrY= @@ -125,7 +131,6 @@ github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQ github.com/bgentry/speakeasy v0.1.0/go.mod h1:+zsyZBPWlz7T6j88CTgSN5bM796AkVf0kBD4zp0CCIs= github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c/go.mod h1:MKsuJmJgSg28kpZDP6UIiPt0e0Oz0kqKNGyRaWEPv84= github.com/bketelsen/crypt v0.0.4/go.mod h1:aI6NrJ0pMGgvZKL1iVgXLnfIFJtfV+bKCoqOes/6LfM= -github.com/blang/semver v3.5.0+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= github.com/blang/semver v3.5.1+incompatible h1:cQNTCjp13qL8KC3Nbxr/y2Bqb63oX6wdnnjpJbkM4JQ= github.com/blang/semver v3.5.1+incompatible/go.mod h1:kRBLl5iJ+tD4TcOOxsy/0fnwebNt5EWlYSAyrTnjyyk= github.com/boz/go-lifecycle v0.1.1-0.20190620234137-5139c86739b8 h1:0SsyL78bVw6RwFKVKFHv8kdREXxuGbQKDlo7FVy7Zss= @@ -206,6 +211,9 @@ github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:ma github.com/cpuguy83/go-md2man/v2 v2.0.0 h1:EoUDS0afbrsXAZ9YQ9jdu/mZ2sXgT1/2yyNng4PGlyM= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= +github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= +github.com/creack/pty v1.1.11 h1:07n33Z8lZxZ2qwegKbObQohDhXDQxiMMz1NOUGYlesw= +github.com/creack/pty v1.1.11/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/danieljoos/wincred v1.0.2 h1:zf4bhty2iLuwgjgpraD2E9UbvO+fe54XXGJbOwe23fU= github.com/danieljoos/wincred v1.0.2/go.mod h1:SnuYRW9lp1oJrZX/dXJqr0cPK5gYXqx3EJbmjhLdK9U= github.com/davecgh/go-spew v0.0.0-20171005155431-ecdeabc65495/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -231,7 +239,8 @@ github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8 github.com/dlclark/regexp2 v1.2.0/go.mod h1:2pZnwuY/m+8K6iRw6wQdMtk+rH5tNGR1i55kozfMjCc= github.com/docker/distribution v2.7.1+incompatible/go.mod h1:J2gT2udsDAN96Uj4KfcMRqY0/ypR+oyYUYmja8H+y+w= github.com/docker/docker v1.4.2-0.20180625184442-8e610b2b55bf/go.mod h1:eEKB0N0r5NX/I1kEveEz05bcu8tLC/8azJZsviup8Sk= -github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96 h1:cenwrSVm+Z7QLSV/BsnenAOcDXdX4cMv4wP0B/5QbPg= +github.com/docker/go-units v0.3.3/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= +github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk= github.com/docker/spdystream v0.0.0-20160310174837-449fdfce4d96/go.mod h1:Qh8CwZgvJUkLughtfhJv5dyTYa91l1fOUCrgjqmcifM= github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/dop251/goja v0.0.0-20200721192441-a695b0cdd498/go.mod h1:Mw6PkjjMXWbTj+nnj4s3QPXq1jaT0s5pC0iFD4+BOAA= @@ -256,6 +265,7 @@ github.com/enigmampc/btcutil v1.0.3-0.20200723161021-e2fb6adb2a25/go.mod h1:hTr8 github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98= github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c= github.com/ethereum/go-ethereum v1.9.25/go.mod h1:vMkFiYLHI4tgPw4k2j4MHKoovchFE8plZ0M9VMk4/oM= +github.com/evanphx/json-patch v4.5.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch v4.9.0+incompatible h1:kLcOMZeuLAJvL2BPWLMIj5oaZQobrkAqrL+WFZwQses= github.com/evanphx/json-patch v4.9.0+incompatible/go.mod h1:50XU6AFN0ol/bzJsmQLiYLvXMP4fmwYFNcr97nuDLSk= github.com/evanphx/json-patch/v5 v5.2.0 h1:8ozOH5xxoMYDt5/u+yMTsVXydVCbTORFnOOoq2lumco= @@ -274,6 +284,7 @@ github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGE github.com/felixge/httpsnoop v1.0.1 h1:lvB5Jl89CsZtGIWuTcDM1E/vkVs49/Ml7JJe07l8SPQ= github.com/felixge/httpsnoop v1.0.1/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/fjl/memsize v0.0.0-20180418122429-ca190fb6ffbc/go.mod h1:VvhXpOYNQvB+uIk2RvXzuaQtkQJzzIx6lSBe1xv7hi0= +github.com/form3tech-oss/jwt-go v3.2.2+incompatible/go.mod h1:pbq4aXjuKjdthFRnoDwaVPLA+WlJuPGy+QneDUgJi2k= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= github.com/fortytw2/leaktest v1.3.0/go.mod h1:jDsjWgpAGjm2CA7WthBh/CdZYEPF31XHquHwclZch5g= github.com/franela/goblin v0.0.0-20200105215937-c9ffbefa60db/go.mod h1:7dvUGVsVBjqR7JHJk0brhHOZYGmfBYOrK0ZhYMEtBr4= @@ -281,6 +292,7 @@ github.com/franela/goreq v0.0.0-20171204163338-bcd34c9993f8/go.mod h1:ZhphrRTfi2 github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4= github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= +github.com/fvbommel/sortorder v1.0.1/go.mod h1:uk88iVf1ovNn1iLfgUVU2F9o5eO30ui720w+kxuqRs0= github.com/gballet/go-libpcsclite v0.0.0-20190607065134-2772fd86a8ff/go.mod h1:x7DCsMOv1taUwEWCzT4cmDeAkigA5/QCwUodaVOe8Ww= github.com/ghodss/yaml v0.0.0-20150909031657-73d445a93680/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= @@ -288,6 +300,9 @@ github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= github.com/gin-gonic/gin v1.6.3 h1:ahKqKTFpO5KTPHxWZjEdPScmYaGtLo8Y4DMHoEsnp14= github.com/gin-gonic/gin v1.6.3/go.mod h1:75u5sXoLsGZoRN5Sgbi1eraJ4GU3++wFwWzhwvtwp4M= +github.com/globalsign/mgo v0.0.0-20180905125535-1ca0a4f7cbcb/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= +github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q= +github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q= github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8= @@ -301,24 +316,55 @@ github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V github.com/go-logfmt/logfmt v0.5.0 h1:TrB8swr/68K7m9CcGut2g3UOihhbcbiMAYiuTXdEih4= github.com/go-logfmt/logfmt v0.5.0/go.mod h1:wCYkCAKZfumFQihp8CzCvQ3paCTfi41vtzG1KdI/P7A= github.com/go-logr/logr v0.1.0/go.mod h1:ixOQHD9gLJUVQQ2ZOR7zLEifBX6tGkNJF4QyIY7sIas= -github.com/go-logr/logr v0.2.0 h1:QvGt2nLcHH0WK9orKa+ppBPAxREcH364nPUedEpK0TY= github.com/go-logr/logr v0.2.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= +github.com/go-logr/logr v0.4.0 h1:K7/B1jt6fIBQVd4Owv2MqGQClcgf0R266+7C/QjRcLc= +github.com/go-logr/logr v0.4.0/go.mod h1:z6/tIYblkpsD+a4lm/fGIIU9mZ+XfAiaFtq7xTgseGU= github.com/go-ole/go-ole v1.2.1/go.mod h1:7FAglXiTm7HKlQRDeOQ6ZNUHidzCWXuZWq/1dTyBNF8= -github.com/go-openapi/jsonpointer v0.0.0-20160704185906-46af16f9f7b1/go.mod h1:+35s3my2LFTysnkMfxsJBAMHj/DoqoB9knIWoYG/Vk0= +github.com/go-openapi/analysis v0.0.0-20180825180245-b006789cd277/go.mod h1:k70tL6pCuVxPJOHXQ+wIac1FUrvNkHolPie/cLEU6hI= +github.com/go-openapi/analysis v0.17.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= +github.com/go-openapi/analysis v0.18.0/go.mod h1:IowGgpVeD0vNm45So8nr+IcQ3pxVtpRoBWb8PVZO0ik= +github.com/go-openapi/analysis v0.19.2/go.mod h1:3P1osvZa9jKjb8ed2TPng3f0i/UY9snX6gxi44djMjk= +github.com/go-openapi/analysis v0.19.5/go.mod h1:hkEAkxagaIvIP7VTn8ygJNkd4kAYON2rCu0v0ObL0AU= +github.com/go-openapi/errors v0.17.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0= +github.com/go-openapi/errors v0.18.0/go.mod h1:LcZQpmvG4wyF5j4IhA73wkLFQg+QJXOQHVjmcZxhka0= +github.com/go-openapi/errors v0.19.2/go.mod h1:qX0BLWsyaKfvhluLejVpVNwNRdXZhEbTA4kxxpKBC94= +github.com/go-openapi/jsonpointer v0.17.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M= +github.com/go-openapi/jsonpointer v0.18.0/go.mod h1:cOnomiV+CVVwFLk0A/MExoFMjwdsUdVpsRhURCKh+3M= github.com/go-openapi/jsonpointer v0.19.2/go.mod h1:3akKfEdA7DF1sugOqz1dVQHBcuDBPKZGEoHC/NkiQRg= github.com/go-openapi/jsonpointer v0.19.3 h1:gihV7YNZK1iK6Tgwwsxo2rJbD1GTbdm72325Bq8FI3w= github.com/go-openapi/jsonpointer v0.19.3/go.mod h1:Pl9vOtqEWErmShwVjC8pYs9cog34VGT37dQOVbmoatg= -github.com/go-openapi/jsonreference v0.0.0-20160704190145-13c6e3589ad9/go.mod h1:W3Z9FmVs9qj+KR4zFKmDPGiLdk1D9Rlm7cyMvf57TTg= +github.com/go-openapi/jsonreference v0.17.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I= +github.com/go-openapi/jsonreference v0.18.0/go.mod h1:g4xxGn04lDIRh0GJb5QlpE3HfopLOL6uZrK/VgnsK9I= github.com/go-openapi/jsonreference v0.19.2/go.mod h1:jMjeRr2HHw6nAVajTXJ4eiUwohSTlpa0o73RUL1owJc= github.com/go-openapi/jsonreference v0.19.3 h1:5cxNfTy0UVC3X8JL5ymxzyoUZmo8iZb+jeTWn7tUa8o= github.com/go-openapi/jsonreference v0.19.3/go.mod h1:rjx6GuL8TTa9VaixXglHmQmIL98+wF9xc8zWvFonSJ8= -github.com/go-openapi/spec v0.0.0-20160808142527-6aced65f8501/go.mod h1:J8+jY1nAiCcj+friV/PDoE1/3eeccG9LYBs0tYvLOWc= -github.com/go-openapi/spec v0.19.3 h1:0XRyw8kguri6Yw4SxhsQA/atC88yqrk0+G4YhI2wabc= +github.com/go-openapi/loads v0.17.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= +github.com/go-openapi/loads v0.18.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= +github.com/go-openapi/loads v0.19.0/go.mod h1:72tmFy5wsWx89uEVddd0RjRWPZm92WRLhf7AC+0+OOU= +github.com/go-openapi/loads v0.19.2/go.mod h1:QAskZPMX5V0C2gvfkGZzJlINuP7Hx/4+ix5jWFxsNPs= +github.com/go-openapi/loads v0.19.4/go.mod h1:zZVHonKd8DXyxyw4yfnVjPzBjIQcLt0CCsn0N0ZrQsk= +github.com/go-openapi/runtime v0.0.0-20180920151709-4f900dc2ade9/go.mod h1:6v9a6LTXWQCdL8k1AO3cvqx5OtZY/Y9wKTgaoP6YRfA= +github.com/go-openapi/runtime v0.19.0/go.mod h1:OwNfisksmmaZse4+gpV3Ne9AyMOlP1lt4sK4FXt0O64= +github.com/go-openapi/runtime v0.19.4/go.mod h1:X277bwSUBxVlCYR3r7xgZZGKVvBd/29gLDlFGtJ8NL4= +github.com/go-openapi/spec v0.17.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI= +github.com/go-openapi/spec v0.18.0/go.mod h1:XkF/MOi14NmjsfZ8VtAKf8pIlbZzyoTvZsdfssdxcBI= +github.com/go-openapi/spec v0.19.2/go.mod h1:sCxk3jxKgioEJikev4fgkNmwS+3kuYdJtcsZsD5zxMY= github.com/go-openapi/spec v0.19.3/go.mod h1:FpwSN1ksY1eteniUU7X0N/BgJ7a4WvBFVA8Lj9mJglo= -github.com/go-openapi/swag v0.0.0-20160704191624-1d0bd113de87/go.mod h1:DXUve3Dpr1UfpPtxFw+EFuQ41HhCWZfha5jSVRG7C7I= +github.com/go-openapi/spec v0.19.5 h1:Xm0Ao53uqnk9QE/LlYV5DEU09UAgpliA85QoT9LzqPw= +github.com/go-openapi/spec v0.19.5/go.mod h1:Hm2Jr4jv8G1ciIAo+frC/Ft+rR2kQDh8JHKHb3gWUSk= +github.com/go-openapi/strfmt v0.17.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU= +github.com/go-openapi/strfmt v0.18.0/go.mod h1:P82hnJI0CXkErkXi8IKjPbNBM6lV6+5pLP5l494TcyU= +github.com/go-openapi/strfmt v0.19.0/go.mod h1:+uW+93UVvGGq2qGaZxdDeJqSAqBqBdl+ZPMF/cC8nDY= +github.com/go-openapi/strfmt v0.19.3/go.mod h1:0yX7dbo8mKIvc3XSKp7MNfxw4JytCfCD6+bY1AVL9LU= +github.com/go-openapi/strfmt v0.19.5/go.mod h1:eftuHTlB/dI8Uq8JJOyRlieZf+WkkxUuk0dgdHXr2Qk= +github.com/go-openapi/swag v0.17.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg= +github.com/go-openapi/swag v0.18.0/go.mod h1:AByQ+nYG6gQg71GINrmuDXCPWdL640yX49/kXLo40Tg= github.com/go-openapi/swag v0.19.2/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= github.com/go-openapi/swag v0.19.5 h1:lTz6Ys4CmqqCQmZPBlbQENR1/GucA2bzYTE12Pw4tFY= github.com/go-openapi/swag v0.19.5/go.mod h1:POnQmlKehdgb5mhVOsnJFsivZCEZ/vjK9gh66Z9tfKk= +github.com/go-openapi/validate v0.18.0/go.mod h1:Uh4HdOzKt19xGIGm1qHf/ofbX1YQ4Y+MYsct2VUrAJ4= +github.com/go-openapi/validate v0.19.2/go.mod h1:1tRCw7m3jtI8eNWEEliiAqUIcBztB2KDnRCRMUi7GTA= +github.com/go-openapi/validate v0.19.8/go.mod h1:8DJv2CVJQ6kGNpFW6eV9N3JviE1C85nY1c2z52x1Gk4= github.com/go-playground/assert/v2 v2.0.1/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4= github.com/go-playground/locales v0.13.0 h1:HyWk6mgj5qFqCT5fjGBuRArbVDfE4hi8+e8ceBS/t7Q= github.com/go-playground/locales v0.13.0/go.mod h1:taPMhCMXrRLJO55olJkUXHZBHCxTMfnGwq/HNwmWNS8= @@ -330,6 +376,7 @@ github.com/go-sourcemap/sourcemap v2.1.2+incompatible/go.mod h1:F8jJfvm2KbVjc5Nq github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk= github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/gobuffalo/here v0.6.0/go.mod h1:wAG085dHOYqUpf+Ap+WOdrPTp5IYcDAs/x7PLa8Y5fM= github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0= github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo= github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8= @@ -380,8 +427,6 @@ github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8l github.com/golang/snappy v0.0.1/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= github.com/golang/snappy v0.0.3-0.20201103224600-674baa8c7fc3 h1:ur2rms48b3Ep1dxh7aUV2FZEQ8jEVO2F6ILKx8ofkAg= github.com/golang/snappy v0.0.3-0.20201103224600-674baa8c7fc3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q= -github.com/golangplus/bytes v0.0.0-20160111154220-45c989fe5450/go.mod h1:Bk6SMAONeMXrxql8uvOKuAZSu8aM5RUGv+1C6IJaEho= -github.com/golangplus/fmt v0.0.0-20150411045040-2a5d6d7d2995/go.mod h1:lJgMEyOkYFkPcDKwRXegd+iM6E7matEszMG5HhwytU8= github.com/golangplus/testing v0.0.0-20180327235837-af21d9c3145e/go.mod h1:0AA//k/eakGydO4jKRoRL2j92ZKSzTgj9tclaCrvXHk= github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo= @@ -420,6 +465,7 @@ github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLe github.com/google/pprof v0.0.0-20210122040257-d980be63207e/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/pprof v0.0.0-20210226084205-cbba55b83ad5/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE= github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI= +github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510/go.mod h1:pupxD2MaaD3pAXIBCelhxNneeOaAeabZDe5s4K6zSpQ= github.com/google/uuid v1.0.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= @@ -548,17 +594,16 @@ github.com/kkdai/bstream v1.0.0/go.mod h1:FDnDOHt5Yx4p3FaHcioFT0QjDOtgUpvjeZqAs+ github.com/klauspost/compress v1.10.3 h1:OP96hzwJVBIHYU52pVTI6CczrxPvrGfgqF9N5eTO0Q8= github.com/klauspost/compress v1.10.3/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= -github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/pty v1.1.5/go.mod h1:9r2w37qlBe7rQ6e1fg1S/9xpWHSnaqNdHD3WcMdbPDA= -github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= +github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/leodido/go-urn v1.2.0 h1:hpXL4XnriNwQ/ABnpepYM/1vCLWNDfUNts8dX3xTG6Y= github.com/leodido/go-urn v1.2.0/go.mod h1:+8+nEpDfqqsY+g338gtMEUOtuK+4dEMhiQEgxpxOKII= @@ -574,11 +619,13 @@ github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czP github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= github.com/magiconair/properties v1.8.5 h1:b6kJs+EmPFMYGkow9GiUyCyOvIwYetYJ3fSaWak/Gls= github.com/magiconair/properties v1.8.5/go.mod h1:y3VJvCyxH9uVvJTWEGAELF3aiYNyPKd5NZ3oSwXrF60= -github.com/mailru/easyjson v0.0.0-20160728113105-d5b7844b561a/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20180823135443-60711f1a8329/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= +github.com/mailru/easyjson v0.0.0-20190312143242-1de009706dbe/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.0.0-20190614124828-94de47d64c63/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.0.0-20190626092158-b2ccc519800e/go.mod h1:C1wdFJiN94OJF2b5HbByQZoLdCWB1Yqtg26g4irojpc= github.com/mailru/easyjson v0.7.0 h1:aizVhC/NAAcKWb+5QsU1iNOZb4Yws5UO2I+aIprQITM= github.com/mailru/easyjson v0.7.0/go.mod h1:KAzv3t3aY1NaHWoQz1+4F1ccyAH66Jk7yos7ldAVICs= +github.com/markbates/pkger v0.17.1/go.mod h1:0JoVlrol20BSywW79rN3kdFFsE5xYM+rSCQDXbLhiuI= github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-colorable v0.1.0/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc= @@ -593,6 +640,7 @@ github.com/mattn/go-isatty v0.0.13/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Ky github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.3/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= +github.com/mattn/go-runewidth v0.0.7/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 h1:I0XW9+e1XWDxdcEniV4rQAIOPUGDq67JSCiRCgGCZLI= github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369/go.mod h1:BSXmuO+STAnVfrANrmjBb36TMTDstsz7MSK+HVaYKv4= @@ -615,14 +663,17 @@ github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh github.com/mitchellh/mapstructure v1.3.3/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag= github.com/mitchellh/mapstructure v1.4.1/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo= -github.com/moby/term v0.0.0-20200312100748-672ec06f55cd h1:aY7OQNf2XqY/JQ6qREWamhI/81os/agb2BAGpcx5yWI= -github.com/moby/term v0.0.0-20200312100748-672ec06f55cd/go.mod h1:DdlQx2hp0Ss5/fLikoLlEeIYiATotOjgB//nb973jeo= +github.com/moby/spdystream v0.2.0 h1:cjW1zVyyoiM0T7b6UoySUFqzXMoqRckQtXwGPiBhOM8= +github.com/moby/spdystream v0.2.0/go.mod h1:f7i0iNDQJ059oMTcWxx8MA/zKFIuD/lY+0GqbN2Wy8c= +github.com/moby/term v0.0.0-20201216013528-df9cb8a40635 h1:rzf0wL0CHVc8CEsgyygG0Mn9CNCCPZqOPaz8RiiHYQk= +github.com/moby/term v0.0.0-20201216013528-df9cb8a40635/go.mod h1:FBS0z0QWA44HXygs7VXDUOGoN/1TV3RuWkLO04am3wc= github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/monochromegane/go-gitignore v0.0.0-20200626010858-205db1a8cc00/go.mod h1:Pm3mSP3c5uWn86xMLZ5Sa7JB9GsEZySvHYXCTK4E9q4= github.com/mtibben/percent v0.2.1 h1:5gssi8Nqo8QU/r2pynCm+hBQHpkB/uNK7BJCFogWdzs= github.com/mtibben/percent v0.2.1/go.mod h1:KG9uO+SZkUp+VkRHsCdYQV3XSZrrSpR3O9ibNBTZrns= github.com/munnerz/goautoneg v0.0.0-20120707110453-a547fc61f48d/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= @@ -640,6 +691,8 @@ github.com/nats-io/nkeys v0.1.0/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxzi github.com/nats-io/nkeys v0.1.3/go.mod h1:xpnFELMwJABBLVhffcfd1MZx6VsNRFpEugbxziKVo7w= github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= github.com/neilotoole/errgroup v0.1.5/go.mod h1:Q2nLGf+594h0CLBs/Mbg6qOr7GtqDK7C2S41udRnToE= +github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= +github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= github.com/nishanths/predeclared v0.0.0-20200524104333-86fad755b4d3/go.mod h1:nt3d53pc1VYcphSCIaYAJtnPYnr3Zyn8fMq2wvPGPso= github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= @@ -649,6 +702,7 @@ github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn github.com/olekukonko/tablewriter v0.0.0-20170122224234-a0225b3f23b5/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/olekukonko/tablewriter v0.0.1/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= github.com/olekukonko/tablewriter v0.0.2-0.20190409134802-7e037d187b0c/go.mod h1:vsDQFd/mU46D+Z4whnwzcISnGGzXWMclvtLoiIKAKIo= +github.com/olekukonko/tablewriter v0.0.4/go.mod h1:zq6QwlOf5SlnkVbMSr5EoBv3636FWnp+qbPhuoO21uA= github.com/onsi/ginkgo v0.0.0-20170829012221-11459a886d9c/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= @@ -664,7 +718,7 @@ github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7J github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE= github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo= github.com/op/go-logging v0.0.0-20160315200505-970db520ece7/go.mod h1:HzydrMdWErDVzsI23lYNej1Htcns9BCg93Dk0bBINWk= -github.com/opencontainers/go-digest v1.0.0-rc1/go.mod h1:cMLVZDEM3+U2I4VmLI6N8jQYUd2OVphdqWwCJHrFt2s= +github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM= github.com/opentracing-contrib/go-observer v0.0.0-20170622124052-a52f23424492/go.mod h1:Ngi6UdF0k5OKD5t5wlmGhe/EDKPoUM3BXZSSfIuJbis= github.com/opentracing/basictracer-go v1.0.0/go.mod h1:QfBfYuafItcjQuMwinw9GhYKwFXS9KnPs5lxoYwgW74= github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o= @@ -780,6 +834,8 @@ github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww= github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0= github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529/go.mod h1:DxrIzT+xaE7yg65j358z/aeFdxmN0P9QXhEzd20vsDc= github.com/segmentio/fasthash v1.0.3/go.mod h1:waKX8l2N8yckOgmSsXJi7x1ZfdKZ4x7KRMzBtS3oedY= +github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo= +github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM= github.com/shirou/gopsutil v2.20.5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA= github.com/shopspring/decimal v1.2.0 h1:abSATXmQEYyShuxI4/vyW3tV1MrKAJzCZ/0zLUXYbsQ= github.com/shopspring/decimal v1.2.0/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= @@ -787,7 +843,6 @@ github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5I github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc= github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I= github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM= github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc= @@ -862,6 +917,7 @@ github.com/tendermint/tm-db v0.6.4 h1:3N2jlnYQkXNQclQwd/eKV/NzlqPlfK21cpRRIx80XX github.com/tendermint/tm-db v0.6.4/go.mod h1:dptYhIpJ2M5kUuenLr+Yyf3zQOv1SgBZcl8/BmWlMBw= github.com/tidwall/gjson v1.6.7/go.mod h1:zeFuBCIqD4sN/gmqBzZ4j7Jd6UcA2Fc56x7QFsv+8fI= github.com/tidwall/match v1.0.3/go.mod h1:eRSPERbgtNPcGhD8UCthc6PmLEQXEWd3PRB5JTxsfmM= +github.com/tidwall/pretty v1.0.0/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= github.com/tidwall/pretty v1.0.2/go.mod h1:XNkn88O1ChpSDQmQeStsy+sBenx6DDtFZJxhVysOjyk= github.com/tidwall/sjson v1.1.4/go.mod h1:wXpKXu8CtDjKAZ+3DrKY5ROCorDFahq8l0tey/Lx1fg= github.com/tmc/grpc-websocket-proxy v0.0.0-20170815181823-89b8d40f7ca8/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= @@ -877,11 +933,12 @@ github.com/ugorji/go/codec v1.1.7 h1:2SvQaVZ1ouYrrKKwoSk2pzd4A9evlKJb9oTL+OaLUSs github.com/ugorji/go/codec v1.1.7/go.mod h1:Ax+UKWsSmolVDwsd+7N3ZtXu+yMGCf907BLYF3GoBXY= github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA= github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= +github.com/vektah/gqlparser v1.1.2/go.mod h1:1ycwN7Ij5njmMkPPAOaRFY4rET2Enx7IkVv3vaXspKw= github.com/vmihailenco/msgpack/v5 v5.1.4/go.mod h1:C5gboKD0TJPqWDTVTtrQNfRbiBwHZGo8UTqP/9/XvLI= github.com/vmihailenco/tagparser v0.1.2/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI= github.com/wsddn/go-ecdh v0.0.0-20161211032359-48726bab9208/go.mod h1:IotVbo4F+mw0EzQ08zFqg7pK3FebNXpaMsRy2RT+Ees= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= -github.com/xlab/handysort v0.0.0-20150421192137-fb3537ed64a1/go.mod h1:QcJo0QPSfTONNIgpN5RA8prR7fF8nkF6cTWTcNerRO8= +github.com/xlab/treeprint v0.0.0-20181112141820-a009c3971eca/go.mod h1:ce1O1j6UtZfjr22oyGxGLbauSBp2YVXpARAosm7dHBg= github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= github.com/ybbus/jsonrpc v2.1.2+incompatible/go.mod h1:XJrh1eMSzdIYFbM08flv0wp5G35eRniyeGut1z+LSiE= github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= @@ -899,6 +956,9 @@ go.etcd.io/etcd v0.0.0-20191023171146-3cf2f69b5738/go.mod h1:dnLIgRNXwCJa5e+c6mI go.etcd.io/etcd/api/v3 v3.5.0/go.mod h1:cbVKeC6lCfl7j/8jBhAK6aIYO9XOjdptoxU/nLQcPvs= go.etcd.io/etcd/client/pkg/v3 v3.5.0/go.mod h1:IJHfcCEKxYu1Os13ZdwCwIUTUVGYTSAM3YSwc9/Ac1g= go.etcd.io/etcd/client/v2 v2.305.0/go.mod h1:h9puh54ZTgAKtEbut2oe9P4L/oqKCVB6xsXlzd7alYQ= +go.mongodb.org/mongo-driver v1.0.3/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= +go.mongodb.org/mongo-driver v1.1.1/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= +go.mongodb.org/mongo-driver v1.1.2/go.mod h1:u7ryQJ+DOzQmeO7zB6MHyr8jkEQvC8vH7qLUO4lqsUM= go.opencensus.io v0.20.1/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.20.2/go.mod h1:6WKK9ahsWS3RSO+PY9ZHZUfv2irvY6gN279GOPZjmmk= go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU= @@ -908,6 +968,7 @@ go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw= go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk= go.opencensus.io v0.23.0/go.mod h1:XItmlyltB5F7CS4xOC1DcqMoFqwtC6OG2xF7mCv7P7E= +go.starlark.net v0.0.0-20200306205701-8dd3e2ee1dd5/go.mod h1:nmDLcffg48OtT/PSW0Hg7FvpRQsQh5OSqIylirxKC7o= go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= go.uber.org/atomic v1.5.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ= @@ -924,10 +985,12 @@ golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnf golang.org/x/crypto v0.0.0-20181029021203-45a5f77698d3/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190320223903-b7391e95e576/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190611184440-5c40567a22f8/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= +golang.org/x/crypto v0.0.0-20190617133340-57b3e21c3d56/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190820162420-60c769a6c586/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20190909091759-094676da4a83/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= @@ -939,9 +1002,11 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20200709230013-948cd5f35899/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200728195943-123391ffb6de/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20200820211705-5c72a883971a/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= +golang.org/x/crypto v0.0.0-20201002170205-7f63de1d35b0/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20201117144127-c1f2f97bffc9/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= -golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad h1:DN0cp81fZ3njFcrLCytUHRSUkqBjfTo4Tx9RJTWs0EY= golang.org/x/crypto v0.0.0-20201221181555-eec23a3978ad/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= +golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83 h1:/ZScEX8SfEmUGRHs0gxpqteO5nfNW6axyZbBdw9A12g= +golang.org/x/crypto v0.0.0-20210220033148-5ea612d1eb83/go.mod h1:jdWPYTVW3xRLrWPugEBEK3UY2ZEsg3UU495nc5E+M+I= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -977,6 +1042,7 @@ golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzB golang.org/x/mod v0.1.1-0.20191209134235-331c550502dd/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= +golang.org/x/mod v0.3.1-0.20200828183125-ce943fd02449/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2 h1:Gz96sIWK3OalVv/I/qNygP42zyoKp3xptRVCWRFEBvo= @@ -984,6 +1050,7 @@ golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20180719180050-a680a1efc54d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181005035420-146acd28ed58/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181011144130-49bb7cea24b1/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181023162649-9b4f9f5ad519/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -993,6 +1060,7 @@ golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73r golang.org/x/net v0.0.0-20190125091013-d26f9f9a57f3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190320064053-1272bf9dcd53/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= @@ -1027,6 +1095,7 @@ golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210119194325-5f4716e94777/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= +golang.org/x/net v0.0.0-20210224082022-3d97a244fca7/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210316092652-d523dce5a7f4/go.mod h1:RBQZq4jEuRlivfhVLdyRGr576XBO4/greRjx4P4O3yc= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= @@ -1069,6 +1138,7 @@ golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20190130150945-aca44879d564/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190321052220-f7bb7a8bee54/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1082,6 +1152,7 @@ golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20190826190057-c7b8b68b1456/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20191002063906-3421d5a6bb1c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191026070338-33540a1f6037/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1105,11 +1176,11 @@ golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200615200032-f1bc736245b1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20200622214017-ed371f2e16b4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200625212154-ddb9806d33ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200814200057-3d37ad5750ed/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200824131525-c12d262b63d8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20200831180312-196b9ba8737a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200909081042-eff7692f9009/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= @@ -1127,12 +1198,14 @@ golang.org/x/sys v0.0.0-20210320140829-1e4c9ba3b0c4/go.mod h1:h1NjWce9XRLGQEsW7w golang.org/x/sys v0.0.0-20210330210617-4fbd30eecc44/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210403161142-5e06dd20ab57/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20210426230700-d19ff857e887/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20210510120138-977fb7262007/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40 h1:JWgyZ1qgdTaF3N3oxC+MdTV7qvEEgHo3otj+HB5CM7Q= golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= +golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d h1:SZxvLBoTP5yHO3Frd4z4vrF+DBX9vMVanchswa69toE= +golang.org/x/term v0.0.0-20210220032956-6a3ed077a48d/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1145,10 +1218,11 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= -golang.org/x/time v0.0.0-20191024005414-555d28b269f0 h1:/5xXl8Y5W96D+TtHSlonuFqGHIWVuyCkGJLwGh9JJFs= golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba h1:O8mE0/t419eoIwhTFpKVkHiTs/Igowgfkj25AcZrtiE= +golang.org/x/time v0.0.0-20210220033141-f8bda1e9f3ba/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20181011042414-1f849cf54d09/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190125232054-d66bd3c5d5a6/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY= golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= @@ -1159,6 +1233,7 @@ golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBn golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q= golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190614205625-5aca471b1d59/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= +golang.org/x/tools v0.0.0-20190617190820-da514acc4774/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190624222133-a101b041ded4/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= @@ -1189,10 +1264,10 @@ golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjs golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw= golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8= golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= +golang.org/x/tools v0.0.0-20200505023115-26f46d2f7ef8/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200522201501-cb1345f3a375/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= -golang.org/x/tools v0.0.0-20200616133436-c1934b75d054/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20200717024301-6ddee64345a6/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA= @@ -1311,8 +1386,9 @@ google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQ gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= -gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15 h1:YR8cESwS4TdDjEe65xsg0ogRM/Nc3DYOhEAlW+xobZo= gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU= +gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/cheggaaa/pb.v1 v1.0.25/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= @@ -1335,6 +1411,7 @@ gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.5/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.7/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= @@ -1345,6 +1422,8 @@ gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C gotest.tools v2.2.0+incompatible h1:VsBPFP1AI068pPrMxtb/S8Zkgf9xEmTLJjfM+P5UIEo= gotest.tools v2.2.0+incompatible/go.mod h1:DsYFclhRJ6vuDpmuTbkuFWG+y2sxOXAzmJt81HFBacw= gotest.tools/v3 v3.0.2/go.mod h1:3SzNCllyD9/Y+b5r9JIKQ474KzkZyqLqEfYqMsX94Bk= +gotest.tools/v3 v3.0.3 h1:4AuOwCGf4lLR9u3YOe2awrHygurzhO/HeQ6laiA6Sx0= +gotest.tools/v3 v3.0.3/go.mod h1:Z7Lb0S5l+klDB31fvDQX8ss/FlKDxtlFlw3Oa8Ymbl8= honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= @@ -1352,33 +1431,35 @@ honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWh honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg= honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k= -k8s.io/api v0.19.3 h1:GN6ntFnv44Vptj/b+OnMW7FmzkpDoIDLZRvKX3XH9aU= -k8s.io/api v0.19.3/go.mod h1:VF+5FT1B74Pw3KxMdKyinLo+zynBaMBiAfGMuldcNDs= -k8s.io/apimachinery v0.19.3/go.mod h1:DnPGDnARWFvYa3pMHgSxtbZb7gpzzAZ1pTfaUNDVlmA= -k8s.io/apimachinery v0.20.2 h1:hFx6Sbt1oG0n6DZ+g4bFt5f6BoMkOjKWsQFu077M3Vg= +k8s.io/api v0.21.3 h1:cblWILbLO8ar+Fj6xdDGr603HRsf8Wu9E9rngJeprZQ= +k8s.io/api v0.21.3/go.mod h1:hUgeYHUbBp23Ue4qdX9tR8/ANi/g3ehylAqDn9NWVOg= k8s.io/apimachinery v0.20.2/go.mod h1:WlLqWAHZGg07AeltaI0MV5uk1Omp8xaN0JGLY6gkRpU= -k8s.io/cli-runtime v0.19.3/go.mod h1:q+l845i5/uWzcUpCrl+L4f3XLaJi8ZeLVQ/decwty0A= -k8s.io/client-go v0.19.3 h1:ctqR1nQ52NUs6LpI0w+a5U+xjYwflFwA13OJKcicMxg= -k8s.io/client-go v0.19.3/go.mod h1:+eEMktZM+MG0KO+PTkci8xnbCZHvj9TqR6Q1XDUIJOM= -k8s.io/code-generator v0.19.3 h1:fTrTpJ8PZog5oo6MmeZtveo89emjQZHiw0ieybz1RSs= -k8s.io/code-generator v0.19.3/go.mod h1:moqLn7w0t9cMs4+5CQyxnfA/HV8MF6aAVENF+WZZhgk= -k8s.io/component-base v0.19.3/go.mod h1:WhLWSIefQn8W8jxSLl5WNiR6z8oyMe/8Zywg7alOkRc= +k8s.io/apimachinery v0.21.3 h1:3Ju4nvjCngxxMYby0BimUk+pQHPOQp3eCGChk5kfVII= +k8s.io/apimachinery v0.21.3/go.mod h1:H/IM+5vH9kZRNJ4l3x/fXP/5bOPJaVP/guptnZPeCFI= +k8s.io/cli-runtime v0.21.3/go.mod h1:h65y0uXIXDnNjd5J+F3CvQU3ZNplH4+rjqbII7JkD4A= +k8s.io/client-go v0.21.3 h1:J9nxZTOmvkInRDCzcSNQmPJbDYN/PjlxXT9Mos3HcLg= +k8s.io/client-go v0.21.3/go.mod h1:+VPhCgTsaFmGILxR/7E1N0S+ryO010QBeNCv5JwRGYU= +k8s.io/code-generator v0.21.3 h1:K2Onrjuve/31D4Y5DpR9ngWM2BiiKUxrGaCxSEJS/Y8= +k8s.io/code-generator v0.21.3/go.mod h1:K3y0Bv9Cz2cOW2vXUrNZlFbflhuPvuadW6JdnN6gGKo= +k8s.io/component-base v0.21.3/go.mod h1:kkuhtfEHeZM6LkX0saqSK8PbdO7A0HigUngmhhrwfGQ= +k8s.io/component-helpers v0.21.3/go.mod h1:FJCpEhM9fkKvNN0QAl33ozmMj+Bx8R64wcOBqhng0oQ= k8s.io/gengo v0.0.0-20200413195148-3a45101e95ac/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= -k8s.io/gengo v0.0.0-20200428234225-8167cfdcfc14 h1:t4L10Qfx/p7ASH3gXCdIUtPbbIuegCoUJf3TMSFekjw= -k8s.io/gengo v0.0.0-20200428234225-8167cfdcfc14/go.mod h1:ezvh/TsK7cY6rbqRK0oQQ8IAqLxYwwyPxAX1Pzy0ii0= +k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027 h1:Uusb3oh8XcdzDF/ndlI4ToKTYVlkCSJP39SRY2mfRAw= +k8s.io/gengo v0.0.0-20201214224949-b6c5ce23f027/go.mod h1:FiNAH4ZV3gBg2Kwh89tzAEV2be7d5xI0vBa/VySYy3E= k8s.io/klog/v2 v2.0.0/go.mod h1:PBfzABfn139FHAV07az/IF9Wp1bkk3vpT2XSJ76fSDE= k8s.io/klog/v2 v2.2.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= -k8s.io/klog/v2 v2.4.0 h1:7+X0fUguPyrKEC4WjH8iGDg3laWgMo5tMnRTIGTTxGQ= k8s.io/klog/v2 v2.4.0/go.mod h1:Od+F08eJP+W3HUb4pSrPpgp9DGU4GzlpG/TmITuYh/Y= -k8s.io/kube-openapi v0.0.0-20200805222855-6aeccd4b50c6/go.mod h1:UuqjUnNftUyPE5H64/qeyjQoUZhGpeFDVdxjTeEVN2o= -k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd h1:sOHNzJIkytDF6qadMNKhhDRpc6ODik8lVC6nOur7B2c= +k8s.io/klog/v2 v2.8.0 h1:Q3gmuM9hKEjefWFFYF0Mat+YyFJvsUyYuwyNNJ5C9Ts= +k8s.io/klog/v2 v2.8.0/go.mod h1:hy9LJ/NvuK+iVyP4Ehqva4HxZG/oXyIS3n3Jmire4Ec= k8s.io/kube-openapi v0.0.0-20201113171705-d219536bb9fd/go.mod h1:WOJ3KddDSol4tAGcJo0Tvi+dK12EcqSLqcWsryKMpfM= -k8s.io/kubectl v0.19.3 h1:T8IHHpg+uRIfn34wqJ8wHG5bbH+VV5FNPtJ+jKcho1U= -k8s.io/kubectl v0.19.3/go.mod h1:t5cscfrAuHUvEGNyNJjPKt+rGlaJzk8jrKYHXxEsANE= -k8s.io/metrics v0.19.3 h1:p/goUqtdCslX76mSNowzZkNxiKzNRQW4bUP02U34+QQ= -k8s.io/metrics v0.19.3/go.mod h1:Eap/Lk1FiAIjkaArFuv41v+ph6dbDpVGwAg7jMI+4vg= -k8s.io/utils v0.0.0-20200729134348-d5654de09c73 h1:uJmqzgNWG7XyClnU/mLPBWwfKKF1K8Hf8whTseBgJcg= -k8s.io/utils v0.0.0-20200729134348-d5654de09c73/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= +k8s.io/kube-openapi v0.0.0-20210305001622-591a79e4bda7 h1:vEx13qjvaZ4yfObSSXW7BrMc/KQBBT/Jyee8XtLf4x0= +k8s.io/kube-openapi v0.0.0-20210305001622-591a79e4bda7/go.mod h1:wXW5VT87nVfh/iLV8FpR2uDvrFyomxbtb1KivDbvPTE= +k8s.io/kubectl v0.21.3 h1:RmHvvz7tLnFmVqUzJuR44D8oE5zv1iyDojxSQllY+II= +k8s.io/kubectl v0.21.3/go.mod h1:/x/kzrhfL1h1W07z6a1UTbd8SWZUYAWXskigkG4OBCg= +k8s.io/metrics v0.21.3 h1:BXLcDFR/2XUNOcFDyNI6//9pK+WIDCbQ0+uEkIjcHEc= +k8s.io/metrics v0.21.3/go.mod h1:mN3Klf203Lw1hOsfg1MG7DR/kKUhwiyu8GSFCXZdz+o= +k8s.io/utils v0.0.0-20201110183641-67b214c5f920 h1:CbnUZsM497iRC5QMVkHwyl8s2tB3g7yaSHkYPkpgelw= +k8s.io/utils v0.0.0-20201110183641-67b214c5f920/go.mod h1:jPW/WVKK9YHAvNhRxK0md/EJ228hCsBRufyofKtW8HA= nhooyr.io/websocket v1.8.6 h1:s+C3xAMLwGmlI31Nyn/eAehUlZPwfYZu2JXM621Q5/k= nhooyr.io/websocket v1.8.6/go.mod h1:B70DZP8IakI65RVQ51MsWP/8jndNma26DVA/nFSCgW0= rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8= @@ -1386,12 +1467,14 @@ rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0= rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA= sigs.k8s.io/kind v0.11.1 h1:pVzOkhUwMBrCB0Q/WllQDO3v14Y+o2V0tFgjTqIUjwA= sigs.k8s.io/kind v0.11.1/go.mod h1:fRpgVhtqAWrtLB9ED7zQahUimpUXuG/iHT88xYqEGIA= -sigs.k8s.io/kustomize v2.0.3+incompatible/go.mod h1:MkjgH3RdOWrievjo6c9T245dYlB5QeXV4WCbnt/PEpU= -sigs.k8s.io/structured-merge-diff/v4 v4.0.1/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= -sigs.k8s.io/structured-merge-diff/v4 v4.0.2 h1:YHQV7Dajm86OuqnIR6zAelnDWBRjo+YhYV9PmGrh1s8= +sigs.k8s.io/kustomize/api v0.8.8/go.mod h1:He1zoK0nk43Pc6NlV085xDXDXTNprtcyKZVm3swsdNY= +sigs.k8s.io/kustomize/cmd/config v0.9.10/go.mod h1:Mrby0WnRH7hA6OwOYnYpfpiY0WJIMgYrEDfwOeFdMK0= +sigs.k8s.io/kustomize/kustomize/v4 v4.1.2/go.mod h1:PxBvo4WGYlCLeRPL+ziT64wBXqbgfcalOS/SXa/tcyo= +sigs.k8s.io/kustomize/kyaml v0.10.17/go.mod h1:mlQFagmkm1P+W4lZJbJ/yaxMd8PqMRSC4cPcfUVt5Hg= sigs.k8s.io/structured-merge-diff/v4 v4.0.2/go.mod h1:bJZC9H9iH24zzfZ/41RGcq60oK1F7G282QMXDPYydCw= +sigs.k8s.io/structured-merge-diff/v4 v4.1.2 h1:Hr/htKFmJEbtMgS/UD0N+gtgctAqz81t3nu+sPzynno= +sigs.k8s.io/structured-merge-diff/v4 v4.1.2/go.mod h1:j/nl6xW8vLS49O8YvXW1ocPhZawJtm+Yrr7PPRQ0Vg4= sigs.k8s.io/yaml v1.1.0/go.mod h1:UJmg0vDUVViEyp3mgSv9WPwZCDxu4rQW1olrI1uml+o= sigs.k8s.io/yaml v1.2.0 h1:kr/MCeFWJWTwyaHoR9c8EjH9OumOmoF9YGiZd7lFm/Q= sigs.k8s.io/yaml v1.2.0/go.mod h1:yfXDCHCao9+ENCvLSE62v9VSji2MKu5jeNfTrofGhJc= sourcegraph.com/sourcegraph/appdash v0.0.0-20190731080439-ebfcffb1b5c0/go.mod h1:hI742Nqp5OhwiqlzhgfbWU4mW4yO10fP+LoT9WOswdU= -vbom.ml/util v0.0.0-20160121211510-db5cfe13f5cc/go.mod h1:so/NYdZXCz+E3ZpW0uAoCj6uzU2+8OWDFv/HxUSs7kI= diff --git a/pkg/apis/akash.network/v1/types.go b/pkg/apis/akash.network/v1/types.go index bec36b403d..08e777dd27 100644 --- a/pkg/apis/akash.network/v1/types.go +++ b/pkg/apis/akash.network/v1/types.go @@ -2,10 +2,11 @@ package v1 import ( "fmt" - ctypes "github.com/ovrclk/akash/provider/cluster/types" "math" "strconv" + ctypes "github.com/ovrclk/akash/provider/cluster/types" + "github.com/pkg/errors" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -92,7 +93,7 @@ func (d deployment) ManifestGroup() manifest.Group { return d.group } -// NewManifest creates new manifest with provided details. Returns error incase of failure. +// NewManifest creates new manifest with provided details. Returns error in case of failure. func NewManifest(name string, lid mtypes.LeaseID, mgroup *manifest.Group) (*Manifest, error) { group, err := manifestGroupFromAkash(mgroup) if err != nil { @@ -351,9 +352,9 @@ func manifestServiceExposeFromAkash(amse manifest.ServiceExpose) ManifestService // ResourceUnits stores cpu, memory and storage details type ResourceUnits struct { - CPU uint32 `json:"cpu,omitempty"` - Memory string `json:"memory,omitempty"` - Storage string `json:"storage,omitempty"` + CPU uint32 `json:"cpu,omitempty"` + Memory string `json:"memory,omitempty"` + Storage []string `json:"storage,omitempty"` } func (ru ResourceUnits) toAkash() (types.ResourceUnits, error) { @@ -361,9 +362,18 @@ func (ru ResourceUnits) toAkash() (types.ResourceUnits, error) { if err != nil { return types.ResourceUnits{}, err } - storage, err := strconv.ParseUint(ru.Storage, 10, 64) - if err != nil { - return types.ResourceUnits{}, err + + storage := make([]types.Storage, 0, len(ru.Storage)) + + for _, st := range ru.Storage { + size, err := strconv.ParseUint(st, 10, 64) + if err != nil { + return types.ResourceUnits{}, err + } + + storage = append(storage, types.Storage{ + Quantity: types.NewResourceValue(size), + }) } return types.ResourceUnits{ @@ -373,9 +383,7 @@ func (ru ResourceUnits) toAkash() (types.ResourceUnits, error) { Memory: &types.Memory{ Quantity: types.NewResourceValue(memory), }, - Storage: &types.Storage{ - Quantity: types.NewResourceValue(storage), - }, + Storage: storage, }, nil } @@ -391,8 +399,9 @@ func resourceUnitsFromAkash(aru types.ResourceUnits) (ResourceUnits, error) { res.Memory = strconv.FormatUint(aru.Memory.Quantity.Value(), 10) } - if aru.Storage != nil { - res.Storage = strconv.FormatUint(aru.Storage.Quantity.Value(), 10) + res.Storage = make([]string, 0, len(aru.Storage)) + for _, size := range aru.Storage { + res.Storage = append(res.Storage, strconv.FormatUint(size.Quantity.Value(), 10)) } return res, nil diff --git a/pkg/apis/akash.network/v1/zz_generated.deepcopy.go b/pkg/apis/akash.network/v1/zz_generated.deepcopy.go index 5c747c0761..86185f7bc5 100644 --- a/pkg/apis/akash.network/v1/zz_generated.deepcopy.go +++ b/pkg/apis/akash.network/v1/zz_generated.deepcopy.go @@ -21,6 +21,7 @@ limitations under the License. package v1 import ( + manifest "github.com/ovrclk/akash/manifest" runtime "k8s.io/apimachinery/pkg/runtime" ) @@ -137,7 +138,7 @@ func (in *ManifestService) DeepCopyInto(out *ManifestService) { *out = make([]string, len(*in)) copy(*out, *in) } - out.Resources = in.Resources + in.Resources.DeepCopyInto(&out.Resources) if in.Expose != nil { in, out := &in.Expose, &out.Expose *out = make([]ManifestServiceExpose, len(*in)) @@ -145,6 +146,11 @@ func (in *ManifestService) DeepCopyInto(out *ManifestService) { (*in)[i].DeepCopyInto(&(*out)[i]) } } + if in.Params != nil { + in, out := &in.Params, &out.Params + *out = new(ManifestServiceParams) + (*in).DeepCopyInto(*out) + } return } @@ -179,6 +185,27 @@ func (in *ManifestServiceExpose) DeepCopy() *ManifestServiceExpose { return out } +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *ManifestServiceParams) DeepCopyInto(out *ManifestServiceParams) { + *out = *in + if in.Storage != nil { + in, out := &in.Storage, &out.Storage + *out = make([]manifest.StorageParams, len(*in)) + copy(*out, *in) + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new ManifestServiceParams. +func (in *ManifestServiceParams) DeepCopy() *ManifestServiceParams { + if in == nil { + return nil + } + out := new(ManifestServiceParams) + in.DeepCopyInto(out) + return out +} + // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ManifestSpec) DeepCopyInto(out *ManifestSpec) { *out = *in @@ -216,6 +243,11 @@ func (in *ManifestStatus) DeepCopy() *ManifestStatus { // DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. func (in *ResourceUnits) DeepCopyInto(out *ResourceUnits) { *out = *in + if in.Storage != nil { + in, out := &in.Storage, &out.Storage + *out = make([]string, len(*in)) + copy(*out, *in) + } return } @@ -228,3 +260,96 @@ func (in *ResourceUnits) DeepCopy() *ResourceUnits { in.DeepCopyInto(out) return out } + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StorageClassState) DeepCopyInto(out *StorageClassState) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ObjectMeta.DeepCopyInto(&out.ObjectMeta) + out.Spec = in.Spec + out.Status = in.Status + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageClassState. +func (in *StorageClassState) DeepCopy() *StorageClassState { + if in == nil { + return nil + } + out := new(StorageClassState) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *StorageClassState) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StorageClassStateList) DeepCopyInto(out *StorageClassStateList) { + *out = *in + out.TypeMeta = in.TypeMeta + in.ListMeta.DeepCopyInto(&out.ListMeta) + if in.Items != nil { + in, out := &in.Items, &out.Items + *out = make([]StorageClassState, len(*in)) + for i := range *in { + (*in)[i].DeepCopyInto(&(*out)[i]) + } + } + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageClassStateList. +func (in *StorageClassStateList) DeepCopy() *StorageClassStateList { + if in == nil { + return nil + } + out := new(StorageClassStateList) + in.DeepCopyInto(out) + return out +} + +// DeepCopyObject is an autogenerated deepcopy function, copying the receiver, creating a new runtime.Object. +func (in *StorageClassStateList) DeepCopyObject() runtime.Object { + if c := in.DeepCopy(); c != nil { + return c + } + return nil +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StorageClassStateSpec) DeepCopyInto(out *StorageClassStateSpec) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageClassStateSpec. +func (in *StorageClassStateSpec) DeepCopy() *StorageClassStateSpec { + if in == nil { + return nil + } + out := new(StorageClassStateSpec) + in.DeepCopyInto(out) + return out +} + +// DeepCopyInto is an autogenerated deepcopy function, copying the receiver, writing into out. in must be non-nil. +func (in *StorageClassStateStatus) DeepCopyInto(out *StorageClassStateStatus) { + *out = *in + return +} + +// DeepCopy is an autogenerated deepcopy function, copying the receiver, creating a new StorageClassStateStatus. +func (in *StorageClassStateStatus) DeepCopy() *StorageClassStateStatus { + if in == nil { + return nil + } + out := new(StorageClassStateStatus) + in.DeepCopyInto(out) + return out +} diff --git a/pkg/client/clientset/versioned/typed/akash.network/v1/akash.network_client.go b/pkg/client/clientset/versioned/typed/akash.network/v1/akash.network_client.go index e704cc0066..953740566f 100644 --- a/pkg/client/clientset/versioned/typed/akash.network/v1/akash.network_client.go +++ b/pkg/client/clientset/versioned/typed/akash.network/v1/akash.network_client.go @@ -27,6 +27,7 @@ import ( type AkashV1Interface interface { RESTClient() rest.Interface ManifestsGetter + StorageClassStatesGetter } // AkashV1Client is used to interact with features provided by the akash.network group. @@ -38,6 +39,10 @@ func (c *AkashV1Client) Manifests(namespace string) ManifestInterface { return newManifests(c, namespace) } +func (c *AkashV1Client) StorageClassStates() StorageClassStateInterface { + return newStorageClassStates(c) +} + // NewForConfig creates a new AkashV1Client for the given config. func NewForConfig(c *rest.Config) (*AkashV1Client, error) { config := *c diff --git a/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_akash.network_client.go b/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_akash.network_client.go index f6e057df06..021263173f 100644 --- a/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_akash.network_client.go +++ b/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_akash.network_client.go @@ -32,6 +32,10 @@ func (c *FakeAkashV1) Manifests(namespace string) v1.ManifestInterface { return &FakeManifests{c, namespace} } +func (c *FakeAkashV1) StorageClassStates() v1.StorageClassStateInterface { + return &FakeStorageClassStates{c} +} + // RESTClient returns a RESTClient that is used to communicate // with API server by this client implementation. func (c *FakeAkashV1) RESTClient() rest.Interface { diff --git a/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_storageclassstate.go b/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_storageclassstate.go new file mode 100644 index 0000000000..5d424a2c8f --- /dev/null +++ b/pkg/client/clientset/versioned/typed/akash.network/v1/fake/fake_storageclassstate.go @@ -0,0 +1,133 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package fake + +import ( + "context" + + akashnetworkv1 "github.com/ovrclk/akash/pkg/apis/akash.network/v1" + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + labels "k8s.io/apimachinery/pkg/labels" + schema "k8s.io/apimachinery/pkg/runtime/schema" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + testing "k8s.io/client-go/testing" +) + +// FakeStorageClassStates implements StorageClassStateInterface +type FakeStorageClassStates struct { + Fake *FakeAkashV1 +} + +var storageclassstatesResource = schema.GroupVersionResource{Group: "akash.network", Version: "v1", Resource: "storageclassstates"} + +var storageclassstatesKind = schema.GroupVersionKind{Group: "akash.network", Version: "v1", Kind: "StorageClassState"} + +// Get takes name of the storageClassState, and returns the corresponding storageClassState object, and an error if there is any. +func (c *FakeStorageClassStates) Get(ctx context.Context, name string, options v1.GetOptions) (result *akashnetworkv1.StorageClassState, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootGetAction(storageclassstatesResource, name), &akashnetworkv1.StorageClassState{}) + if obj == nil { + return nil, err + } + return obj.(*akashnetworkv1.StorageClassState), err +} + +// List takes label and field selectors, and returns the list of StorageClassStates that match those selectors. +func (c *FakeStorageClassStates) List(ctx context.Context, opts v1.ListOptions) (result *akashnetworkv1.StorageClassStateList, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootListAction(storageclassstatesResource, storageclassstatesKind, opts), &akashnetworkv1.StorageClassStateList{}) + if obj == nil { + return nil, err + } + + label, _, _ := testing.ExtractFromListOptions(opts) + if label == nil { + label = labels.Everything() + } + list := &akashnetworkv1.StorageClassStateList{ListMeta: obj.(*akashnetworkv1.StorageClassStateList).ListMeta} + for _, item := range obj.(*akashnetworkv1.StorageClassStateList).Items { + if label.Matches(labels.Set(item.Labels)) { + list.Items = append(list.Items, item) + } + } + return list, err +} + +// Watch returns a watch.Interface that watches the requested storageClassStates. +func (c *FakeStorageClassStates) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + return c.Fake. + InvokesWatch(testing.NewRootWatchAction(storageclassstatesResource, opts)) +} + +// Create takes the representation of a storageClassState and creates it. Returns the server's representation of the storageClassState, and an error, if there is any. +func (c *FakeStorageClassStates) Create(ctx context.Context, storageClassState *akashnetworkv1.StorageClassState, opts v1.CreateOptions) (result *akashnetworkv1.StorageClassState, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootCreateAction(storageclassstatesResource, storageClassState), &akashnetworkv1.StorageClassState{}) + if obj == nil { + return nil, err + } + return obj.(*akashnetworkv1.StorageClassState), err +} + +// Update takes the representation of a storageClassState and updates it. Returns the server's representation of the storageClassState, and an error, if there is any. +func (c *FakeStorageClassStates) Update(ctx context.Context, storageClassState *akashnetworkv1.StorageClassState, opts v1.UpdateOptions) (result *akashnetworkv1.StorageClassState, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateAction(storageclassstatesResource, storageClassState), &akashnetworkv1.StorageClassState{}) + if obj == nil { + return nil, err + } + return obj.(*akashnetworkv1.StorageClassState), err +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *FakeStorageClassStates) UpdateStatus(ctx context.Context, storageClassState *akashnetworkv1.StorageClassState, opts v1.UpdateOptions) (*akashnetworkv1.StorageClassState, error) { + obj, err := c.Fake. + Invokes(testing.NewRootUpdateSubresourceAction(storageclassstatesResource, "status", storageClassState), &akashnetworkv1.StorageClassState{}) + if obj == nil { + return nil, err + } + return obj.(*akashnetworkv1.StorageClassState), err +} + +// Delete takes name of the storageClassState and deletes it. Returns an error if one occurs. +func (c *FakeStorageClassStates) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + _, err := c.Fake. + Invokes(testing.NewRootDeleteAction(storageclassstatesResource, name), &akashnetworkv1.StorageClassState{}) + return err +} + +// DeleteCollection deletes a collection of objects. +func (c *FakeStorageClassStates) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + action := testing.NewRootDeleteCollectionAction(storageclassstatesResource, listOpts) + + _, err := c.Fake.Invokes(action, &akashnetworkv1.StorageClassStateList{}) + return err +} + +// Patch applies the patch and returns the patched storageClassState. +func (c *FakeStorageClassStates) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *akashnetworkv1.StorageClassState, err error) { + obj, err := c.Fake. + Invokes(testing.NewRootPatchSubresourceAction(storageclassstatesResource, name, pt, data, subresources...), &akashnetworkv1.StorageClassState{}) + if obj == nil { + return nil, err + } + return obj.(*akashnetworkv1.StorageClassState), err +} diff --git a/pkg/client/clientset/versioned/typed/akash.network/v1/generated_expansion.go b/pkg/client/clientset/versioned/typed/akash.network/v1/generated_expansion.go index 00c6a97719..d573f076a3 100644 --- a/pkg/client/clientset/versioned/typed/akash.network/v1/generated_expansion.go +++ b/pkg/client/clientset/versioned/typed/akash.network/v1/generated_expansion.go @@ -19,3 +19,5 @@ limitations under the License. package v1 type ManifestExpansion interface{} + +type StorageClassStateExpansion interface{} diff --git a/pkg/client/clientset/versioned/typed/akash.network/v1/storageclassstate.go b/pkg/client/clientset/versioned/typed/akash.network/v1/storageclassstate.go new file mode 100644 index 0000000000..d7af787f11 --- /dev/null +++ b/pkg/client/clientset/versioned/typed/akash.network/v1/storageclassstate.go @@ -0,0 +1,184 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by client-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + "time" + + v1 "github.com/ovrclk/akash/pkg/apis/akash.network/v1" + scheme "github.com/ovrclk/akash/pkg/client/clientset/versioned/scheme" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + types "k8s.io/apimachinery/pkg/types" + watch "k8s.io/apimachinery/pkg/watch" + rest "k8s.io/client-go/rest" +) + +// StorageClassStatesGetter has a method to return a StorageClassStateInterface. +// A group's client should implement this interface. +type StorageClassStatesGetter interface { + StorageClassStates() StorageClassStateInterface +} + +// StorageClassStateInterface has methods to work with StorageClassState resources. +type StorageClassStateInterface interface { + Create(ctx context.Context, storageClassState *v1.StorageClassState, opts metav1.CreateOptions) (*v1.StorageClassState, error) + Update(ctx context.Context, storageClassState *v1.StorageClassState, opts metav1.UpdateOptions) (*v1.StorageClassState, error) + UpdateStatus(ctx context.Context, storageClassState *v1.StorageClassState, opts metav1.UpdateOptions) (*v1.StorageClassState, error) + Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error + DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error + Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.StorageClassState, error) + List(ctx context.Context, opts metav1.ListOptions) (*v1.StorageClassStateList, error) + Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) + Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.StorageClassState, err error) + StorageClassStateExpansion +} + +// storageClassStates implements StorageClassStateInterface +type storageClassStates struct { + client rest.Interface +} + +// newStorageClassStates returns a StorageClassStates +func newStorageClassStates(c *AkashV1Client) *storageClassStates { + return &storageClassStates{ + client: c.RESTClient(), + } +} + +// Get takes name of the storageClassState, and returns the corresponding storageClassState object, and an error if there is any. +func (c *storageClassStates) Get(ctx context.Context, name string, options metav1.GetOptions) (result *v1.StorageClassState, err error) { + result = &v1.StorageClassState{} + err = c.client.Get(). + Resource("storageclassstates"). + Name(name). + VersionedParams(&options, scheme.ParameterCodec). + Do(ctx). + Into(result) + return +} + +// List takes label and field selectors, and returns the list of StorageClassStates that match those selectors. +func (c *storageClassStates) List(ctx context.Context, opts metav1.ListOptions) (result *v1.StorageClassStateList, err error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + result = &v1.StorageClassStateList{} + err = c.client.Get(). + Resource("storageclassstates"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Do(ctx). + Into(result) + return +} + +// Watch returns a watch.Interface that watches the requested storageClassStates. +func (c *storageClassStates) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) { + var timeout time.Duration + if opts.TimeoutSeconds != nil { + timeout = time.Duration(*opts.TimeoutSeconds) * time.Second + } + opts.Watch = true + return c.client.Get(). + Resource("storageclassstates"). + VersionedParams(&opts, scheme.ParameterCodec). + Timeout(timeout). + Watch(ctx) +} + +// Create takes the representation of a storageClassState and creates it. Returns the server's representation of the storageClassState, and an error, if there is any. +func (c *storageClassStates) Create(ctx context.Context, storageClassState *v1.StorageClassState, opts metav1.CreateOptions) (result *v1.StorageClassState, err error) { + result = &v1.StorageClassState{} + err = c.client.Post(). + Resource("storageclassstates"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(storageClassState). + Do(ctx). + Into(result) + return +} + +// Update takes the representation of a storageClassState and updates it. Returns the server's representation of the storageClassState, and an error, if there is any. +func (c *storageClassStates) Update(ctx context.Context, storageClassState *v1.StorageClassState, opts metav1.UpdateOptions) (result *v1.StorageClassState, err error) { + result = &v1.StorageClassState{} + err = c.client.Put(). + Resource("storageclassstates"). + Name(storageClassState.Name). + VersionedParams(&opts, scheme.ParameterCodec). + Body(storageClassState). + Do(ctx). + Into(result) + return +} + +// UpdateStatus was generated because the type contains a Status member. +// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus(). +func (c *storageClassStates) UpdateStatus(ctx context.Context, storageClassState *v1.StorageClassState, opts metav1.UpdateOptions) (result *v1.StorageClassState, err error) { + result = &v1.StorageClassState{} + err = c.client.Put(). + Resource("storageclassstates"). + Name(storageClassState.Name). + SubResource("status"). + VersionedParams(&opts, scheme.ParameterCodec). + Body(storageClassState). + Do(ctx). + Into(result) + return +} + +// Delete takes name of the storageClassState and deletes it. Returns an error if one occurs. +func (c *storageClassStates) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + return c.client.Delete(). + Resource("storageclassstates"). + Name(name). + Body(&opts). + Do(ctx). + Error() +} + +// DeleteCollection deletes a collection of objects. +func (c *storageClassStates) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + var timeout time.Duration + if listOpts.TimeoutSeconds != nil { + timeout = time.Duration(*listOpts.TimeoutSeconds) * time.Second + } + return c.client.Delete(). + Resource("storageclassstates"). + VersionedParams(&listOpts, scheme.ParameterCodec). + Timeout(timeout). + Body(&opts). + Do(ctx). + Error() +} + +// Patch applies the patch and returns the patched storageClassState. +func (c *storageClassStates) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (result *v1.StorageClassState, err error) { + result = &v1.StorageClassState{} + err = c.client.Patch(pt). + Resource("storageclassstates"). + Name(name). + SubResource(subresources...). + VersionedParams(&opts, scheme.ParameterCodec). + Body(data). + Do(ctx). + Into(result) + return +} diff --git a/pkg/client/informers/externalversions/akash.network/v1/interface.go b/pkg/client/informers/externalversions/akash.network/v1/interface.go index 684459ee38..b38a8b6931 100644 --- a/pkg/client/informers/externalversions/akash.network/v1/interface.go +++ b/pkg/client/informers/externalversions/akash.network/v1/interface.go @@ -26,6 +26,8 @@ import ( type Interface interface { // Manifests returns a ManifestInformer. Manifests() ManifestInformer + // StorageClassStates returns a StorageClassStateInformer. + StorageClassStates() StorageClassStateInformer } type version struct { @@ -43,3 +45,8 @@ func New(f internalinterfaces.SharedInformerFactory, namespace string, tweakList func (v *version) Manifests() ManifestInformer { return &manifestInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions} } + +// StorageClassStates returns a StorageClassStateInformer. +func (v *version) StorageClassStates() StorageClassStateInformer { + return &storageClassStateInformer{factory: v.factory, tweakListOptions: v.tweakListOptions} +} diff --git a/pkg/client/informers/externalversions/akash.network/v1/storageclassstate.go b/pkg/client/informers/externalversions/akash.network/v1/storageclassstate.go new file mode 100644 index 0000000000..d087dd431a --- /dev/null +++ b/pkg/client/informers/externalversions/akash.network/v1/storageclassstate.go @@ -0,0 +1,89 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by informer-gen. DO NOT EDIT. + +package v1 + +import ( + "context" + time "time" + + akashnetworkv1 "github.com/ovrclk/akash/pkg/apis/akash.network/v1" + versioned "github.com/ovrclk/akash/pkg/client/clientset/versioned" + internalinterfaces "github.com/ovrclk/akash/pkg/client/informers/externalversions/internalinterfaces" + v1 "github.com/ovrclk/akash/pkg/client/listers/akash.network/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + runtime "k8s.io/apimachinery/pkg/runtime" + watch "k8s.io/apimachinery/pkg/watch" + cache "k8s.io/client-go/tools/cache" +) + +// StorageClassStateInformer provides access to a shared informer and lister for +// StorageClassStates. +type StorageClassStateInformer interface { + Informer() cache.SharedIndexInformer + Lister() v1.StorageClassStateLister +} + +type storageClassStateInformer struct { + factory internalinterfaces.SharedInformerFactory + tweakListOptions internalinterfaces.TweakListOptionsFunc +} + +// NewStorageClassStateInformer constructs a new informer for StorageClassState type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewStorageClassStateInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers) cache.SharedIndexInformer { + return NewFilteredStorageClassStateInformer(client, resyncPeriod, indexers, nil) +} + +// NewFilteredStorageClassStateInformer constructs a new informer for StorageClassState type. +// Always prefer using an informer factory to get a shared informer instead of getting an independent +// one. This reduces memory footprint and number of connections to the server. +func NewFilteredStorageClassStateInformer(client versioned.Interface, resyncPeriod time.Duration, indexers cache.Indexers, tweakListOptions internalinterfaces.TweakListOptionsFunc) cache.SharedIndexInformer { + return cache.NewSharedIndexInformer( + &cache.ListWatch{ + ListFunc: func(options metav1.ListOptions) (runtime.Object, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.AkashV1().StorageClassStates().List(context.TODO(), options) + }, + WatchFunc: func(options metav1.ListOptions) (watch.Interface, error) { + if tweakListOptions != nil { + tweakListOptions(&options) + } + return client.AkashV1().StorageClassStates().Watch(context.TODO(), options) + }, + }, + &akashnetworkv1.StorageClassState{}, + resyncPeriod, + indexers, + ) +} + +func (f *storageClassStateInformer) defaultInformer(client versioned.Interface, resyncPeriod time.Duration) cache.SharedIndexInformer { + return NewFilteredStorageClassStateInformer(client, resyncPeriod, cache.Indexers{cache.NamespaceIndex: cache.MetaNamespaceIndexFunc}, f.tweakListOptions) +} + +func (f *storageClassStateInformer) Informer() cache.SharedIndexInformer { + return f.factory.InformerFor(&akashnetworkv1.StorageClassState{}, f.defaultInformer) +} + +func (f *storageClassStateInformer) Lister() v1.StorageClassStateLister { + return v1.NewStorageClassStateLister(f.Informer().GetIndexer()) +} diff --git a/pkg/client/informers/externalversions/generic.go b/pkg/client/informers/externalversions/generic.go index b549aac4a4..65a2acd98f 100644 --- a/pkg/client/informers/externalversions/generic.go +++ b/pkg/client/informers/externalversions/generic.go @@ -55,6 +55,8 @@ func (f *sharedInformerFactory) ForResource(resource schema.GroupVersionResource // Group=akash.network, Version=v1 case v1.SchemeGroupVersion.WithResource("manifests"): return &genericInformer{resource: resource.GroupResource(), informer: f.Akash().V1().Manifests().Informer()}, nil + case v1.SchemeGroupVersion.WithResource("storageclassstates"): + return &genericInformer{resource: resource.GroupResource(), informer: f.Akash().V1().StorageClassStates().Informer()}, nil } diff --git a/pkg/client/listers/akash.network/v1/expansion_generated.go b/pkg/client/listers/akash.network/v1/expansion_generated.go index 63e44a3a49..af775ba96e 100644 --- a/pkg/client/listers/akash.network/v1/expansion_generated.go +++ b/pkg/client/listers/akash.network/v1/expansion_generated.go @@ -25,3 +25,7 @@ type ManifestListerExpansion interface{} // ManifestNamespaceListerExpansion allows custom methods to be added to // ManifestNamespaceLister. type ManifestNamespaceListerExpansion interface{} + +// StorageClassStateListerExpansion allows custom methods to be added to +// StorageClassStateLister. +type StorageClassStateListerExpansion interface{} diff --git a/pkg/client/listers/akash.network/v1/storageclassstate.go b/pkg/client/listers/akash.network/v1/storageclassstate.go new file mode 100644 index 0000000000..94075f94ea --- /dev/null +++ b/pkg/client/listers/akash.network/v1/storageclassstate.go @@ -0,0 +1,68 @@ +/* +Copyright The Kubernetes Authors. + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +*/ + +// Code generated by lister-gen. DO NOT EDIT. + +package v1 + +import ( + v1 "github.com/ovrclk/akash/pkg/apis/akash.network/v1" + "k8s.io/apimachinery/pkg/api/errors" + "k8s.io/apimachinery/pkg/labels" + "k8s.io/client-go/tools/cache" +) + +// StorageClassStateLister helps list StorageClassStates. +// All objects returned here must be treated as read-only. +type StorageClassStateLister interface { + // List lists all StorageClassStates in the indexer. + // Objects returned here must be treated as read-only. + List(selector labels.Selector) (ret []*v1.StorageClassState, err error) + // Get retrieves the StorageClassState from the index for a given name. + // Objects returned here must be treated as read-only. + Get(name string) (*v1.StorageClassState, error) + StorageClassStateListerExpansion +} + +// storageClassStateLister implements the StorageClassStateLister interface. +type storageClassStateLister struct { + indexer cache.Indexer +} + +// NewStorageClassStateLister returns a new StorageClassStateLister. +func NewStorageClassStateLister(indexer cache.Indexer) StorageClassStateLister { + return &storageClassStateLister{indexer: indexer} +} + +// List lists all StorageClassStates in the indexer. +func (s *storageClassStateLister) List(selector labels.Selector) (ret []*v1.StorageClassState, err error) { + err = cache.ListAll(s.indexer, selector, func(m interface{}) { + ret = append(ret, m.(*v1.StorageClassState)) + }) + return ret, err +} + +// Get retrieves the StorageClassState from the index for a given name. +func (s *storageClassStateLister) Get(name string) (*v1.StorageClassState, error) { + obj, exists, err := s.indexer.GetByKey(name) + if err != nil { + return nil, err + } + if !exists { + return nil, errors.NewNotFound(v1.Resource("storageclassstate"), name) + } + return obj.(*v1.StorageClassState), nil +} diff --git a/provider/cluster/inventory.go b/provider/cluster/inventory.go index 3a3b2ab6ac..cb38a53172 100644 --- a/provider/cluster/inventory.go +++ b/provider/cluster/inventory.go @@ -29,7 +29,7 @@ import ( ) var ( - // errNotFound is the new error with message "not found" + // errReservationNotFound is the new error with message "not found" errReservationNotFound = errors.New("reservation not found") ) diff --git a/provider/cluster/mocks/client.go b/provider/cluster/mocks/client.go index 31caacf613..15ceed5012 100644 --- a/provider/cluster/mocks/client.go +++ b/provider/cluster/mocks/client.go @@ -23,6 +23,29 @@ type Client struct { mock.Mock } +// ActiveStorageClasses provides a mock function with given fields: _a0 +func (_m *Client) ActiveStorageClasses(_a0 context.Context) ([]string, error) { + ret := _m.Called(_a0) + + var r0 []string + if rf, ok := ret.Get(0).(func(context.Context) []string); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Deploy provides a mock function with given fields: _a0, _a1, _a2 func (_m *Client) Deploy(_a0 context.Context, _a1 types.LeaseID, _a2 *manifest.Group) error { ret := _m.Called(_a0, _a1, _a2) @@ -84,15 +107,15 @@ func (_m *Client) Exec(ctx context.Context, lID types.LeaseID, service string, p } // Inventory provides a mock function with given fields: _a0 -func (_m *Client) Inventory(_a0 context.Context) ([]clustertypes.Node, error) { +func (_m *Client) Inventory(_a0 context.Context) (clustertypes.Inventory, error) { ret := _m.Called(_a0) - var r0 []clustertypes.Node - if rf, ok := ret.Get(0).(func(context.Context) []clustertypes.Node); ok { + var r0 clustertypes.Inventory + if rf, ok := ret.Get(0).(func(context.Context) clustertypes.Inventory); ok { r0 = rf(_a0) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).([]clustertypes.Node) + r0 = ret.Get(0).(clustertypes.Inventory) } } diff --git a/provider/cluster/mocks/read_client.go b/provider/cluster/mocks/read_client.go index 828dec71a4..f6b4a47b73 100644 --- a/provider/cluster/mocks/read_client.go +++ b/provider/cluster/mocks/read_client.go @@ -5,7 +5,7 @@ package mocks import ( context "context" - cluster "github.com/ovrclk/akash/provider/cluster/types" + clustertypes "github.com/ovrclk/akash/provider/cluster/types" mock "github.com/stretchr/testify/mock" @@ -17,16 +17,39 @@ type ReadClient struct { mock.Mock } +// ActiveStorageClasses provides a mock function with given fields: _a0 +func (_m *ReadClient) ActiveStorageClasses(_a0 context.Context) ([]string, error) { + ret := _m.Called(_a0) + + var r0 []string + if rf, ok := ret.Get(0).(func(context.Context) []string); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // LeaseEvents provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *ReadClient) LeaseEvents(_a0 context.Context, _a1 types.LeaseID, _a2 string, _a3 bool) (cluster.EventsWatcher, error) { +func (_m *ReadClient) LeaseEvents(_a0 context.Context, _a1 types.LeaseID, _a2 string, _a3 bool) (clustertypes.EventsWatcher, error) { ret := _m.Called(_a0, _a1, _a2, _a3) - var r0 cluster.EventsWatcher - if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID, string, bool) cluster.EventsWatcher); ok { + var r0 clustertypes.EventsWatcher + if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID, string, bool) clustertypes.EventsWatcher); ok { r0 = rf(_a0, _a1, _a2, _a3) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(cluster.EventsWatcher) + r0 = ret.Get(0).(clustertypes.EventsWatcher) } } @@ -41,15 +64,15 @@ func (_m *ReadClient) LeaseEvents(_a0 context.Context, _a1 types.LeaseID, _a2 st } // LeaseLogs provides a mock function with given fields: _a0, _a1, _a2, _a3, _a4 -func (_m *ReadClient) LeaseLogs(_a0 context.Context, _a1 types.LeaseID, _a2 string, _a3 bool, _a4 *int64) ([]*cluster.ServiceLog, error) { +func (_m *ReadClient) LeaseLogs(_a0 context.Context, _a1 types.LeaseID, _a2 string, _a3 bool, _a4 *int64) ([]*clustertypes.ServiceLog, error) { ret := _m.Called(_a0, _a1, _a2, _a3, _a4) - var r0 []*cluster.ServiceLog - if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID, string, bool, *int64) []*cluster.ServiceLog); ok { + var r0 []*clustertypes.ServiceLog + if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID, string, bool, *int64) []*clustertypes.ServiceLog); ok { r0 = rf(_a0, _a1, _a2, _a3, _a4) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).([]*cluster.ServiceLog) + r0 = ret.Get(0).([]*clustertypes.ServiceLog) } } @@ -64,15 +87,15 @@ func (_m *ReadClient) LeaseLogs(_a0 context.Context, _a1 types.LeaseID, _a2 stri } // LeaseStatus provides a mock function with given fields: _a0, _a1 -func (_m *ReadClient) LeaseStatus(_a0 context.Context, _a1 types.LeaseID) (*cluster.LeaseStatus, error) { +func (_m *ReadClient) LeaseStatus(_a0 context.Context, _a1 types.LeaseID) (*clustertypes.LeaseStatus, error) { ret := _m.Called(_a0, _a1) - var r0 *cluster.LeaseStatus - if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID) *cluster.LeaseStatus); ok { + var r0 *clustertypes.LeaseStatus + if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID) *clustertypes.LeaseStatus); ok { r0 = rf(_a0, _a1) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cluster.LeaseStatus) + r0 = ret.Get(0).(*clustertypes.LeaseStatus) } } @@ -87,15 +110,15 @@ func (_m *ReadClient) LeaseStatus(_a0 context.Context, _a1 types.LeaseID) (*clus } // ServiceStatus provides a mock function with given fields: _a0, _a1, _a2 -func (_m *ReadClient) ServiceStatus(_a0 context.Context, _a1 types.LeaseID, _a2 string) (*cluster.ServiceStatus, error) { +func (_m *ReadClient) ServiceStatus(_a0 context.Context, _a1 types.LeaseID, _a2 string) (*clustertypes.ServiceStatus, error) { ret := _m.Called(_a0, _a1, _a2) - var r0 *cluster.ServiceStatus - if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID, string) *cluster.ServiceStatus); ok { + var r0 *clustertypes.ServiceStatus + if rf, ok := ret.Get(0).(func(context.Context, types.LeaseID, string) *clustertypes.ServiceStatus); ok { r0 = rf(_a0, _a1, _a2) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*cluster.ServiceStatus) + r0 = ret.Get(0).(*clustertypes.ServiceStatus) } } diff --git a/provider/cluster/mocks/reservation.go b/provider/cluster/mocks/reservation.go index 349562653a..ab699e5ec3 100644 --- a/provider/cluster/mocks/reservation.go +++ b/provider/cluster/mocks/reservation.go @@ -15,6 +15,20 @@ type Reservation struct { mock.Mock } +// Allocated provides a mock function with given fields: +func (_m *Reservation) Allocated() bool { + ret := _m.Called() + + var r0 bool + if rf, ok := ret.Get(0).(func() bool); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(bool) + } + + return r0 +} + // OrderID provides a mock function with given fields: func (_m *Reservation) OrderID() types.OrderID { ret := _m.Called() diff --git a/provider/manifest/mocks/client.go b/provider/manifest/mocks/client.go index 269cb7444c..8fcdd72469 100644 --- a/provider/manifest/mocks/client.go +++ b/provider/manifest/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery v2.5.1. DO NOT EDIT. package mocks diff --git a/provider/manifest/mocks/status_client.go b/provider/manifest/mocks/status_client.go index a0f549fdb7..02d86fea18 100644 --- a/provider/manifest/mocks/status_client.go +++ b/provider/manifest/mocks/status_client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery v2.5.1. DO NOT EDIT. package mocks diff --git a/provider/mocks/client.go b/provider/mocks/client.go index 84c4b5e079..cc85db65c3 100644 --- a/provider/mocks/client.go +++ b/provider/mocks/client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery v2.5.1. DO NOT EDIT. package mocks diff --git a/provider/mocks/status_client.go b/provider/mocks/status_client.go index 17fab3c8d9..5793ccff0d 100644 --- a/provider/mocks/status_client.go +++ b/provider/mocks/status_client.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery v2.5.1. DO NOT EDIT. package mocks diff --git a/testutil/kubernetes_mock/interface.go b/testutil/kubernetes_mock/interface.go index 6eafef260a..4c1849d54e 100644 --- a/testutil/kubernetes_mock/interface.go +++ b/testutil/kubernetes_mock/interface.go @@ -3,7 +3,9 @@ package kubernetes_mocks import ( + apiserverinternalv1alpha1 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1" appsv1 "k8s.io/client-go/kubernetes/typed/apps/v1" + appsv1beta1 "k8s.io/client-go/kubernetes/typed/apps/v1beta1" authenticationv1 "k8s.io/client-go/kubernetes/typed/authentication/v1" @@ -32,6 +34,8 @@ import ( discovery "k8s.io/client-go/discovery" + discoveryv1 "k8s.io/client-go/kubernetes/typed/discovery/v1" + discoveryv1beta1 "k8s.io/client-go/kubernetes/typed/discovery/v1beta1" eventsv1 "k8s.io/client-go/kubernetes/typed/events/v1" @@ -40,7 +44,7 @@ import ( extensionsv1beta1 "k8s.io/client-go/kubernetes/typed/extensions/v1beta1" - flowcontrolv1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1" + flowcontrolv1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" mock "github.com/stretchr/testify/mock" @@ -48,10 +52,14 @@ import ( networkingv1beta1 "k8s.io/client-go/kubernetes/typed/networking/v1beta1" + nodev1 "k8s.io/client-go/kubernetes/typed/node/v1" + nodev1alpha1 "k8s.io/client-go/kubernetes/typed/node/v1alpha1" nodev1beta1 "k8s.io/client-go/kubernetes/typed/node/v1beta1" + policyv1 "k8s.io/client-go/kubernetes/typed/policy/v1" + policyv1beta1 "k8s.io/client-go/kubernetes/typed/policy/v1beta1" rbacv1 "k8s.io/client-go/kubernetes/typed/rbac/v1" @@ -66,8 +74,6 @@ import ( schedulingv1beta1 "k8s.io/client-go/kubernetes/typed/scheduling/v1beta1" - settingsv1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1" - storagev1 "k8s.io/client-go/kubernetes/typed/storage/v1" storagev1alpha1 "k8s.io/client-go/kubernetes/typed/storage/v1alpha1" @@ -76,14 +82,12 @@ import ( v1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1" - v1alpha1 "k8s.io/client-go/kubernetes/typed/discovery/v1alpha1" + v1alpha1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1alpha1" v1beta1 "k8s.io/client-go/kubernetes/typed/admissionregistration/v1beta1" v1beta2 "k8s.io/client-go/kubernetes/typed/apps/v1beta2" - v2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1" - v2beta1 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta1" v2beta2 "k8s.io/client-go/kubernetes/typed/autoscaling/v2beta2" @@ -318,22 +322,6 @@ func (_m *Interface) BatchV1beta1() batchv1beta1.BatchV1beta1Interface { return r0 } -// BatchV2alpha1 provides a mock function with given fields: -func (_m *Interface) BatchV2alpha1() v2alpha1.BatchV2alpha1Interface { - ret := _m.Called() - - var r0 v2alpha1.BatchV2alpha1Interface - if rf, ok := ret.Get(0).(func() v2alpha1.BatchV2alpha1Interface); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(v2alpha1.BatchV2alpha1Interface) - } - } - - return r0 -} - // CertificatesV1 provides a mock function with given fields: func (_m *Interface) CertificatesV1() certificatesv1.CertificatesV1Interface { ret := _m.Called() @@ -430,16 +418,16 @@ func (_m *Interface) Discovery() discovery.DiscoveryInterface { return r0 } -// DiscoveryV1alpha1 provides a mock function with given fields: -func (_m *Interface) DiscoveryV1alpha1() v1alpha1.DiscoveryV1alpha1Interface { +// DiscoveryV1 provides a mock function with given fields: +func (_m *Interface) DiscoveryV1() discoveryv1.DiscoveryV1Interface { ret := _m.Called() - var r0 v1alpha1.DiscoveryV1alpha1Interface - if rf, ok := ret.Get(0).(func() v1alpha1.DiscoveryV1alpha1Interface); ok { + var r0 discoveryv1.DiscoveryV1Interface + if rf, ok := ret.Get(0).(func() discoveryv1.DiscoveryV1Interface); ok { r0 = rf() } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(v1alpha1.DiscoveryV1alpha1Interface) + r0 = ret.Get(0).(discoveryv1.DiscoveryV1Interface) } } @@ -511,15 +499,47 @@ func (_m *Interface) ExtensionsV1beta1() extensionsv1beta1.ExtensionsV1beta1Inte } // FlowcontrolV1alpha1 provides a mock function with given fields: -func (_m *Interface) FlowcontrolV1alpha1() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface { +func (_m *Interface) FlowcontrolV1alpha1() v1alpha1.FlowcontrolV1alpha1Interface { + ret := _m.Called() + + var r0 v1alpha1.FlowcontrolV1alpha1Interface + if rf, ok := ret.Get(0).(func() v1alpha1.FlowcontrolV1alpha1Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1alpha1.FlowcontrolV1alpha1Interface) + } + } + + return r0 +} + +// FlowcontrolV1beta1 provides a mock function with given fields: +func (_m *Interface) FlowcontrolV1beta1() flowcontrolv1beta1.FlowcontrolV1beta1Interface { + ret := _m.Called() + + var r0 flowcontrolv1beta1.FlowcontrolV1beta1Interface + if rf, ok := ret.Get(0).(func() flowcontrolv1beta1.FlowcontrolV1beta1Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(flowcontrolv1beta1.FlowcontrolV1beta1Interface) + } + } + + return r0 +} + +// InternalV1alpha1 provides a mock function with given fields: +func (_m *Interface) InternalV1alpha1() apiserverinternalv1alpha1.InternalV1alpha1Interface { ret := _m.Called() - var r0 flowcontrolv1alpha1.FlowcontrolV1alpha1Interface - if rf, ok := ret.Get(0).(func() flowcontrolv1alpha1.FlowcontrolV1alpha1Interface); ok { + var r0 apiserverinternalv1alpha1.InternalV1alpha1Interface + if rf, ok := ret.Get(0).(func() apiserverinternalv1alpha1.InternalV1alpha1Interface); ok { r0 = rf() } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(flowcontrolv1alpha1.FlowcontrolV1alpha1Interface) + r0 = ret.Get(0).(apiserverinternalv1alpha1.InternalV1alpha1Interface) } } @@ -558,6 +578,22 @@ func (_m *Interface) NetworkingV1beta1() networkingv1beta1.NetworkingV1beta1Inte return r0 } +// NodeV1 provides a mock function with given fields: +func (_m *Interface) NodeV1() nodev1.NodeV1Interface { + ret := _m.Called() + + var r0 nodev1.NodeV1Interface + if rf, ok := ret.Get(0).(func() nodev1.NodeV1Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(nodev1.NodeV1Interface) + } + } + + return r0 +} + // NodeV1alpha1 provides a mock function with given fields: func (_m *Interface) NodeV1alpha1() nodev1alpha1.NodeV1alpha1Interface { ret := _m.Called() @@ -590,6 +626,22 @@ func (_m *Interface) NodeV1beta1() nodev1beta1.NodeV1beta1Interface { return r0 } +// PolicyV1 provides a mock function with given fields: +func (_m *Interface) PolicyV1() policyv1.PolicyV1Interface { + ret := _m.Called() + + var r0 policyv1.PolicyV1Interface + if rf, ok := ret.Get(0).(func() policyv1.PolicyV1Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(policyv1.PolicyV1Interface) + } + } + + return r0 +} + // PolicyV1beta1 provides a mock function with given fields: func (_m *Interface) PolicyV1beta1() policyv1beta1.PolicyV1beta1Interface { ret := _m.Called() @@ -702,22 +754,6 @@ func (_m *Interface) SchedulingV1beta1() schedulingv1beta1.SchedulingV1beta1Inte return r0 } -// SettingsV1alpha1 provides a mock function with given fields: -func (_m *Interface) SettingsV1alpha1() settingsv1alpha1.SettingsV1alpha1Interface { - ret := _m.Called() - - var r0 settingsv1alpha1.SettingsV1alpha1Interface - if rf, ok := ret.Get(0).(func() settingsv1alpha1.SettingsV1alpha1Interface); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(settingsv1alpha1.SettingsV1alpha1Interface) - } - } - - return r0 -} - // StorageV1 provides a mock function with given fields: func (_m *Interface) StorageV1() storagev1.StorageV1Interface { ret := _m.Called() diff --git a/testutil/kubernetes_mock/typed/admissionregistration/v1/mutating_webhook_configuration_interface.go b/testutil/kubernetes_mock/typed/admissionregistration/v1/mutating_webhook_configuration_interface.go index d94e8d7bea..b0e76d65ed 100644 --- a/testutil/kubernetes_mock/typed/admissionregistration/v1/mutating_webhook_configuration_interface.go +++ b/testutil/kubernetes_mock/typed/admissionregistration/v1/mutating_webhook_configuration_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + admissionregistrationv1 "k8s.io/api/admissionregistration/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/admissionregistration/v1" + v1 "k8s.io/client-go/applyconfigurations/admissionregistration/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type MutatingWebhookConfigurationInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, mutatingWebhookConfiguration, opts +func (_m *MutatingWebhookConfigurationInterface) Apply(ctx context.Context, mutatingWebhookConfiguration *v1.MutatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (*admissionregistrationv1.MutatingWebhookConfiguration, error) { + ret := _m.Called(ctx, mutatingWebhookConfiguration, opts) + + var r0 *admissionregistrationv1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1.MutatingWebhookConfigurationApplyConfiguration, metav1.ApplyOptions) *admissionregistrationv1.MutatingWebhookConfiguration); ok { + r0 = rf(ctx, mutatingWebhookConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admissionregistrationv1.MutatingWebhookConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.MutatingWebhookConfigurationApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, mutatingWebhookConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, mutatingWebhookConfiguration, opts -func (_m *MutatingWebhookConfigurationInterface) Create(ctx context.Context, mutatingWebhookConfiguration *v1.MutatingWebhookConfiguration, opts metav1.CreateOptions) (*v1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Create(ctx context.Context, mutatingWebhookConfiguration *admissionregistrationv1.MutatingWebhookConfiguration, opts metav1.CreateOptions) (*admissionregistrationv1.MutatingWebhookConfiguration, error) { ret := _m.Called(ctx, mutatingWebhookConfiguration, opts) - var r0 *v1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1.MutatingWebhookConfiguration, metav1.CreateOptions) *v1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1.MutatingWebhookConfiguration, metav1.CreateOptions) *admissionregistrationv1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, mutatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.MutatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.MutatingWebhookConfiguration, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1.MutatingWebhookConfiguration, metav1.CreateOptions) error); ok { r1 = rf(ctx, mutatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *MutatingWebhookConfigurationInterface) DeleteCollection(ctx context.Co } // Get provides a mock function with given fields: ctx, name, opts -func (_m *MutatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*admissionregistrationv1.MutatingWebhookConfiguration, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *admissionregistrationv1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.MutatingWebhookConfiguration) } } @@ -95,15 +121,15 @@ func (_m *MutatingWebhookConfigurationInterface) Get(ctx context.Context, name s } // List provides a mock function with given fields: ctx, opts -func (_m *MutatingWebhookConfigurationInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.MutatingWebhookConfigurationList, error) { +func (_m *MutatingWebhookConfigurationInterface) List(ctx context.Context, opts metav1.ListOptions) (*admissionregistrationv1.MutatingWebhookConfigurationList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.MutatingWebhookConfigurationList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.MutatingWebhookConfigurationList); ok { + var r0 *admissionregistrationv1.MutatingWebhookConfigurationList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *admissionregistrationv1.MutatingWebhookConfigurationList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.MutatingWebhookConfigurationList) + r0 = ret.Get(0).(*admissionregistrationv1.MutatingWebhookConfigurationList) } } @@ -118,7 +144,7 @@ func (_m *MutatingWebhookConfigurationInterface) List(ctx context.Context, opts } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*admissionregistrationv1.MutatingWebhookConfiguration, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *admissionregistrationv1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.MutatingWebhookConfiguration) } } @@ -148,20 +174,20 @@ func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name } // Update provides a mock function with given fields: ctx, mutatingWebhookConfiguration, opts -func (_m *MutatingWebhookConfigurationInterface) Update(ctx context.Context, mutatingWebhookConfiguration *v1.MutatingWebhookConfiguration, opts metav1.UpdateOptions) (*v1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Update(ctx context.Context, mutatingWebhookConfiguration *admissionregistrationv1.MutatingWebhookConfiguration, opts metav1.UpdateOptions) (*admissionregistrationv1.MutatingWebhookConfiguration, error) { ret := _m.Called(ctx, mutatingWebhookConfiguration, opts) - var r0 *v1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1.MutatingWebhookConfiguration, metav1.UpdateOptions) *v1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1.MutatingWebhookConfiguration, metav1.UpdateOptions) *admissionregistrationv1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, mutatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.MutatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.MutatingWebhookConfiguration, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1.MutatingWebhookConfiguration, metav1.UpdateOptions) error); ok { r1 = rf(ctx, mutatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/admissionregistration/v1/validating_webhook_configuration_interface.go b/testutil/kubernetes_mock/typed/admissionregistration/v1/validating_webhook_configuration_interface.go index 1dadf26d17..9b94513b08 100644 --- a/testutil/kubernetes_mock/typed/admissionregistration/v1/validating_webhook_configuration_interface.go +++ b/testutil/kubernetes_mock/typed/admissionregistration/v1/validating_webhook_configuration_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + admissionregistrationv1 "k8s.io/api/admissionregistration/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/admissionregistration/v1" + v1 "k8s.io/client-go/applyconfigurations/admissionregistration/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type ValidatingWebhookConfigurationInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, validatingWebhookConfiguration, opts +func (_m *ValidatingWebhookConfigurationInterface) Apply(ctx context.Context, validatingWebhookConfiguration *v1.ValidatingWebhookConfigurationApplyConfiguration, opts metav1.ApplyOptions) (*admissionregistrationv1.ValidatingWebhookConfiguration, error) { + ret := _m.Called(ctx, validatingWebhookConfiguration, opts) + + var r0 *admissionregistrationv1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1.ValidatingWebhookConfigurationApplyConfiguration, metav1.ApplyOptions) *admissionregistrationv1.ValidatingWebhookConfiguration); ok { + r0 = rf(ctx, validatingWebhookConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admissionregistrationv1.ValidatingWebhookConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ValidatingWebhookConfigurationApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, validatingWebhookConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, validatingWebhookConfiguration, opts -func (_m *ValidatingWebhookConfigurationInterface) Create(ctx context.Context, validatingWebhookConfiguration *v1.ValidatingWebhookConfiguration, opts metav1.CreateOptions) (*v1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Create(ctx context.Context, validatingWebhookConfiguration *admissionregistrationv1.ValidatingWebhookConfiguration, opts metav1.CreateOptions) (*admissionregistrationv1.ValidatingWebhookConfiguration, error) { ret := _m.Called(ctx, validatingWebhookConfiguration, opts) - var r0 *v1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1.ValidatingWebhookConfiguration, metav1.CreateOptions) *v1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1.ValidatingWebhookConfiguration, metav1.CreateOptions) *admissionregistrationv1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, validatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.ValidatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ValidatingWebhookConfiguration, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1.ValidatingWebhookConfiguration, metav1.CreateOptions) error); ok { r1 = rf(ctx, validatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *ValidatingWebhookConfigurationInterface) DeleteCollection(ctx context. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ValidatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*admissionregistrationv1.ValidatingWebhookConfiguration, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *admissionregistrationv1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.ValidatingWebhookConfiguration) } } @@ -95,15 +121,15 @@ func (_m *ValidatingWebhookConfigurationInterface) Get(ctx context.Context, name } // List provides a mock function with given fields: ctx, opts -func (_m *ValidatingWebhookConfigurationInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ValidatingWebhookConfigurationList, error) { +func (_m *ValidatingWebhookConfigurationInterface) List(ctx context.Context, opts metav1.ListOptions) (*admissionregistrationv1.ValidatingWebhookConfigurationList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ValidatingWebhookConfigurationList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ValidatingWebhookConfigurationList); ok { + var r0 *admissionregistrationv1.ValidatingWebhookConfigurationList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *admissionregistrationv1.ValidatingWebhookConfigurationList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ValidatingWebhookConfigurationList) + r0 = ret.Get(0).(*admissionregistrationv1.ValidatingWebhookConfigurationList) } } @@ -118,7 +144,7 @@ func (_m *ValidatingWebhookConfigurationInterface) List(ctx context.Context, opt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*admissionregistrationv1.ValidatingWebhookConfiguration, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, na _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *admissionregistrationv1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.ValidatingWebhookConfiguration) } } @@ -148,20 +174,20 @@ func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, na } // Update provides a mock function with given fields: ctx, validatingWebhookConfiguration, opts -func (_m *ValidatingWebhookConfigurationInterface) Update(ctx context.Context, validatingWebhookConfiguration *v1.ValidatingWebhookConfiguration, opts metav1.UpdateOptions) (*v1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Update(ctx context.Context, validatingWebhookConfiguration *admissionregistrationv1.ValidatingWebhookConfiguration, opts metav1.UpdateOptions) (*admissionregistrationv1.ValidatingWebhookConfiguration, error) { ret := _m.Called(ctx, validatingWebhookConfiguration, opts) - var r0 *v1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1.ValidatingWebhookConfiguration, metav1.UpdateOptions) *v1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1.ValidatingWebhookConfiguration, metav1.UpdateOptions) *admissionregistrationv1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, validatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1.ValidatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ValidatingWebhookConfiguration, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1.ValidatingWebhookConfiguration, metav1.UpdateOptions) error); ok { r1 = rf(ctx, validatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/mutating_webhook_configuration_interface.go b/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/mutating_webhook_configuration_interface.go index a783939616..bfa7c9c2cb 100644 --- a/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/mutating_webhook_configuration_interface.go +++ b/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/mutating_webhook_configuration_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/admissionregistration/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/admissionregistration/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type MutatingWebhookConfigurationInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, mutatingWebhookConfiguration, opts +func (_m *MutatingWebhookConfigurationInterface) Apply(ctx context.Context, mutatingWebhookConfiguration *v1beta1.MutatingWebhookConfigurationApplyConfiguration, opts v1.ApplyOptions) (*admissionregistrationv1beta1.MutatingWebhookConfiguration, error) { + ret := _m.Called(ctx, mutatingWebhookConfiguration, opts) + + var r0 *admissionregistrationv1beta1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.MutatingWebhookConfigurationApplyConfiguration, v1.ApplyOptions) *admissionregistrationv1beta1.MutatingWebhookConfiguration); ok { + r0 = rf(ctx, mutatingWebhookConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admissionregistrationv1beta1.MutatingWebhookConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.MutatingWebhookConfigurationApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, mutatingWebhookConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, mutatingWebhookConfiguration, opts -func (_m *MutatingWebhookConfigurationInterface) Create(ctx context.Context, mutatingWebhookConfiguration *v1beta1.MutatingWebhookConfiguration, opts v1.CreateOptions) (*v1beta1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Create(ctx context.Context, mutatingWebhookConfiguration *admissionregistrationv1beta1.MutatingWebhookConfiguration, opts v1.CreateOptions) (*admissionregistrationv1beta1.MutatingWebhookConfiguration, error) { ret := _m.Called(ctx, mutatingWebhookConfiguration, opts) - var r0 *v1beta1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.MutatingWebhookConfiguration, v1.CreateOptions) *v1beta1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1beta1.MutatingWebhookConfiguration, v1.CreateOptions) *admissionregistrationv1beta1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, mutatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.MutatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.MutatingWebhookConfiguration, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1beta1.MutatingWebhookConfiguration, v1.CreateOptions) error); ok { r1 = rf(ctx, mutatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *MutatingWebhookConfigurationInterface) DeleteCollection(ctx context.Co } // Get provides a mock function with given fields: ctx, name, opts -func (_m *MutatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*admissionregistrationv1beta1.MutatingWebhookConfiguration, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *admissionregistrationv1beta1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.MutatingWebhookConfiguration) } } @@ -95,15 +121,15 @@ func (_m *MutatingWebhookConfigurationInterface) Get(ctx context.Context, name s } // List provides a mock function with given fields: ctx, opts -func (_m *MutatingWebhookConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.MutatingWebhookConfigurationList, error) { +func (_m *MutatingWebhookConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*admissionregistrationv1beta1.MutatingWebhookConfigurationList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.MutatingWebhookConfigurationList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.MutatingWebhookConfigurationList); ok { + var r0 *admissionregistrationv1beta1.MutatingWebhookConfigurationList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *admissionregistrationv1beta1.MutatingWebhookConfigurationList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.MutatingWebhookConfigurationList) + r0 = ret.Get(0).(*admissionregistrationv1beta1.MutatingWebhookConfigurationList) } } @@ -118,7 +144,7 @@ func (_m *MutatingWebhookConfigurationInterface) List(ctx context.Context, opts } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*admissionregistrationv1beta1.MutatingWebhookConfiguration, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *admissionregistrationv1beta1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.MutatingWebhookConfiguration) } } @@ -148,20 +174,20 @@ func (_m *MutatingWebhookConfigurationInterface) Patch(ctx context.Context, name } // Update provides a mock function with given fields: ctx, mutatingWebhookConfiguration, opts -func (_m *MutatingWebhookConfigurationInterface) Update(ctx context.Context, mutatingWebhookConfiguration *v1beta1.MutatingWebhookConfiguration, opts v1.UpdateOptions) (*v1beta1.MutatingWebhookConfiguration, error) { +func (_m *MutatingWebhookConfigurationInterface) Update(ctx context.Context, mutatingWebhookConfiguration *admissionregistrationv1beta1.MutatingWebhookConfiguration, opts v1.UpdateOptions) (*admissionregistrationv1beta1.MutatingWebhookConfiguration, error) { ret := _m.Called(ctx, mutatingWebhookConfiguration, opts) - var r0 *v1beta1.MutatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.MutatingWebhookConfiguration, v1.UpdateOptions) *v1beta1.MutatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.MutatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1beta1.MutatingWebhookConfiguration, v1.UpdateOptions) *admissionregistrationv1beta1.MutatingWebhookConfiguration); ok { r0 = rf(ctx, mutatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.MutatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.MutatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.MutatingWebhookConfiguration, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1beta1.MutatingWebhookConfiguration, v1.UpdateOptions) error); ok { r1 = rf(ctx, mutatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/validating_webhook_configuration_interface.go b/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/validating_webhook_configuration_interface.go index 07233986c7..850c3bb82b 100644 --- a/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/validating_webhook_configuration_interface.go +++ b/testutil/kubernetes_mock/typed/admissionregistration/v1beta1/validating_webhook_configuration_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + admissionregistrationv1beta1 "k8s.io/api/admissionregistration/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/admissionregistration/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/admissionregistration/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type ValidatingWebhookConfigurationInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, validatingWebhookConfiguration, opts +func (_m *ValidatingWebhookConfigurationInterface) Apply(ctx context.Context, validatingWebhookConfiguration *v1beta1.ValidatingWebhookConfigurationApplyConfiguration, opts v1.ApplyOptions) (*admissionregistrationv1beta1.ValidatingWebhookConfiguration, error) { + ret := _m.Called(ctx, validatingWebhookConfiguration, opts) + + var r0 *admissionregistrationv1beta1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ValidatingWebhookConfigurationApplyConfiguration, v1.ApplyOptions) *admissionregistrationv1beta1.ValidatingWebhookConfiguration); ok { + r0 = rf(ctx, validatingWebhookConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*admissionregistrationv1beta1.ValidatingWebhookConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ValidatingWebhookConfigurationApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, validatingWebhookConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, validatingWebhookConfiguration, opts -func (_m *ValidatingWebhookConfigurationInterface) Create(ctx context.Context, validatingWebhookConfiguration *v1beta1.ValidatingWebhookConfiguration, opts v1.CreateOptions) (*v1beta1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Create(ctx context.Context, validatingWebhookConfiguration *admissionregistrationv1beta1.ValidatingWebhookConfiguration, opts v1.CreateOptions) (*admissionregistrationv1beta1.ValidatingWebhookConfiguration, error) { ret := _m.Called(ctx, validatingWebhookConfiguration, opts) - var r0 *v1beta1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ValidatingWebhookConfiguration, v1.CreateOptions) *v1beta1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1beta1.ValidatingWebhookConfiguration, v1.CreateOptions) *admissionregistrationv1beta1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, validatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.ValidatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ValidatingWebhookConfiguration, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1beta1.ValidatingWebhookConfiguration, v1.CreateOptions) error); ok { r1 = rf(ctx, validatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *ValidatingWebhookConfigurationInterface) DeleteCollection(ctx context. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ValidatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*admissionregistrationv1beta1.ValidatingWebhookConfiguration, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *admissionregistrationv1beta1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.ValidatingWebhookConfiguration) } } @@ -95,15 +121,15 @@ func (_m *ValidatingWebhookConfigurationInterface) Get(ctx context.Context, name } // List provides a mock function with given fields: ctx, opts -func (_m *ValidatingWebhookConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.ValidatingWebhookConfigurationList, error) { +func (_m *ValidatingWebhookConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*admissionregistrationv1beta1.ValidatingWebhookConfigurationList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.ValidatingWebhookConfigurationList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.ValidatingWebhookConfigurationList); ok { + var r0 *admissionregistrationv1beta1.ValidatingWebhookConfigurationList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *admissionregistrationv1beta1.ValidatingWebhookConfigurationList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ValidatingWebhookConfigurationList) + r0 = ret.Get(0).(*admissionregistrationv1beta1.ValidatingWebhookConfigurationList) } } @@ -118,7 +144,7 @@ func (_m *ValidatingWebhookConfigurationInterface) List(ctx context.Context, opt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*admissionregistrationv1beta1.ValidatingWebhookConfiguration, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, na _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *admissionregistrationv1beta1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.ValidatingWebhookConfiguration) } } @@ -148,20 +174,20 @@ func (_m *ValidatingWebhookConfigurationInterface) Patch(ctx context.Context, na } // Update provides a mock function with given fields: ctx, validatingWebhookConfiguration, opts -func (_m *ValidatingWebhookConfigurationInterface) Update(ctx context.Context, validatingWebhookConfiguration *v1beta1.ValidatingWebhookConfiguration, opts v1.UpdateOptions) (*v1beta1.ValidatingWebhookConfiguration, error) { +func (_m *ValidatingWebhookConfigurationInterface) Update(ctx context.Context, validatingWebhookConfiguration *admissionregistrationv1beta1.ValidatingWebhookConfiguration, opts v1.UpdateOptions) (*admissionregistrationv1beta1.ValidatingWebhookConfiguration, error) { ret := _m.Called(ctx, validatingWebhookConfiguration, opts) - var r0 *v1beta1.ValidatingWebhookConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ValidatingWebhookConfiguration, v1.UpdateOptions) *v1beta1.ValidatingWebhookConfiguration); ok { + var r0 *admissionregistrationv1beta1.ValidatingWebhookConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *admissionregistrationv1beta1.ValidatingWebhookConfiguration, v1.UpdateOptions) *admissionregistrationv1beta1.ValidatingWebhookConfiguration); ok { r0 = rf(ctx, validatingWebhookConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ValidatingWebhookConfiguration) + r0 = ret.Get(0).(*admissionregistrationv1beta1.ValidatingWebhookConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ValidatingWebhookConfiguration, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *admissionregistrationv1beta1.ValidatingWebhookConfiguration, v1.UpdateOptions) error); ok { r1 = rf(ctx, validatingWebhookConfiguration, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/internal_v1alpha1_interface.go b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/internal_v1alpha1_interface.go new file mode 100644 index 0000000000..c4dd0d84b7 --- /dev/null +++ b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/internal_v1alpha1_interface.go @@ -0,0 +1,47 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + rest "k8s.io/client-go/rest" + + v1alpha1 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1" +) + +// InternalV1alpha1Interface is an autogenerated mock type for the InternalV1alpha1Interface type +type InternalV1alpha1Interface struct { + mock.Mock +} + +// RESTClient provides a mock function with given fields: +func (_m *InternalV1alpha1Interface) RESTClient() rest.Interface { + ret := _m.Called() + + var r0 rest.Interface + if rf, ok := ret.Get(0).(func() rest.Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(rest.Interface) + } + } + + return r0 +} + +// StorageVersions provides a mock function with given fields: +func (_m *InternalV1alpha1Interface) StorageVersions() v1alpha1.StorageVersionInterface { + ret := _m.Called() + + var r0 v1alpha1.StorageVersionInterface + if rf, ok := ret.Get(0).(func() v1alpha1.StorageVersionInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1alpha1.StorageVersionInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_version_expansion.go b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_version_expansion.go new file mode 100644 index 0000000000..aa88eebab6 --- /dev/null +++ b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_version_expansion.go @@ -0,0 +1,10 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import mock "github.com/stretchr/testify/mock" + +// StorageVersionExpansion is an autogenerated mock type for the StorageVersionExpansion type +type StorageVersionExpansion struct { + mock.Mock +} diff --git a/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_version_interface.go b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_version_interface.go new file mode 100644 index 0000000000..f0f4859828 --- /dev/null +++ b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_version_interface.go @@ -0,0 +1,266 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + apiserverinternalv1alpha1 "k8s.io/api/apiserverinternal/v1alpha1" + + mock "github.com/stretchr/testify/mock" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + v1alpha1 "k8s.io/client-go/applyconfigurations/apiserverinternal/v1alpha1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// StorageVersionInterface is an autogenerated mock type for the StorageVersionInterface type +type StorageVersionInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, storageVersion, opts +func (_m *StorageVersionInterface) Apply(ctx context.Context, storageVersion *v1alpha1.StorageVersionApplyConfiguration, opts v1.ApplyOptions) (*apiserverinternalv1alpha1.StorageVersion, error) { + ret := _m.Called(ctx, storageVersion, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.StorageVersionApplyConfiguration, v1.ApplyOptions) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, storageVersion, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.StorageVersionApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, storageVersion, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, storageVersion, opts +func (_m *StorageVersionInterface) ApplyStatus(ctx context.Context, storageVersion *v1alpha1.StorageVersionApplyConfiguration, opts v1.ApplyOptions) (*apiserverinternalv1alpha1.StorageVersion, error) { + ret := _m.Called(ctx, storageVersion, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.StorageVersionApplyConfiguration, v1.ApplyOptions) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, storageVersion, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.StorageVersionApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, storageVersion, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, storageVersion, opts +func (_m *StorageVersionInterface) Create(ctx context.Context, storageVersion *apiserverinternalv1alpha1.StorageVersion, opts v1.CreateOptions) (*apiserverinternalv1alpha1.StorageVersion, error) { + ret := _m.Called(ctx, storageVersion, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, *apiserverinternalv1alpha1.StorageVersion, v1.CreateOptions) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, storageVersion, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *apiserverinternalv1alpha1.StorageVersion, v1.CreateOptions) error); ok { + r1 = rf(ctx, storageVersion, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *StorageVersionInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *StorageVersionInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *StorageVersionInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*apiserverinternalv1alpha1.StorageVersion, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *StorageVersionInterface) List(ctx context.Context, opts v1.ListOptions) (*apiserverinternalv1alpha1.StorageVersionList, error) { + ret := _m.Called(ctx, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersionList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *apiserverinternalv1alpha1.StorageVersionList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersionList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *StorageVersionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*apiserverinternalv1alpha1.StorageVersion, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, storageVersion, opts +func (_m *StorageVersionInterface) Update(ctx context.Context, storageVersion *apiserverinternalv1alpha1.StorageVersion, opts v1.UpdateOptions) (*apiserverinternalv1alpha1.StorageVersion, error) { + ret := _m.Called(ctx, storageVersion, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, *apiserverinternalv1alpha1.StorageVersion, v1.UpdateOptions) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, storageVersion, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *apiserverinternalv1alpha1.StorageVersion, v1.UpdateOptions) error); ok { + r1 = rf(ctx, storageVersion, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateStatus provides a mock function with given fields: ctx, storageVersion, opts +func (_m *StorageVersionInterface) UpdateStatus(ctx context.Context, storageVersion *apiserverinternalv1alpha1.StorageVersion, opts v1.UpdateOptions) (*apiserverinternalv1alpha1.StorageVersion, error) { + ret := _m.Called(ctx, storageVersion, opts) + + var r0 *apiserverinternalv1alpha1.StorageVersion + if rf, ok := ret.Get(0).(func(context.Context, *apiserverinternalv1alpha1.StorageVersion, v1.UpdateOptions) *apiserverinternalv1alpha1.StorageVersion); ok { + r0 = rf(ctx, storageVersion, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*apiserverinternalv1alpha1.StorageVersion) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *apiserverinternalv1alpha1.StorageVersion, v1.UpdateOptions) error); ok { + r1 = rf(ctx, storageVersion, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *StorageVersionInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_versions_getter.go b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_versions_getter.go new file mode 100644 index 0000000000..5f945f8bcd --- /dev/null +++ b/testutil/kubernetes_mock/typed/apiserverinternal/v1alpha1/storage_versions_getter.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + v1alpha1 "k8s.io/client-go/kubernetes/typed/apiserverinternal/v1alpha1" +) + +// StorageVersionsGetter is an autogenerated mock type for the StorageVersionsGetter type +type StorageVersionsGetter struct { + mock.Mock +} + +// StorageVersions provides a mock function with given fields: +func (_m *StorageVersionsGetter) StorageVersions() v1alpha1.StorageVersionInterface { + ret := _m.Called() + + var r0 v1alpha1.StorageVersionInterface + if rf, ok := ret.Get(0).(func() v1alpha1.StorageVersionInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1alpha1.StorageVersionInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/apps/v1/controller_revision_interface.go b/testutil/kubernetes_mock/typed/apps/v1/controller_revision_interface.go index 0c6f43da2a..918963a008 100644 --- a/testutil/kubernetes_mock/typed/apps/v1/controller_revision_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1/controller_revision_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + appsv1 "k8s.io/api/apps/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/apps/v1" + v1 "k8s.io/client-go/applyconfigurations/apps/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type ControllerRevisionInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, controllerRevision, opts +func (_m *ControllerRevisionInterface) Apply(ctx context.Context, controllerRevision *v1.ControllerRevisionApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.ControllerRevision, error) { + ret := _m.Called(ctx, controllerRevision, opts) + + var r0 *appsv1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *v1.ControllerRevisionApplyConfiguration, metav1.ApplyOptions) *appsv1.ControllerRevision); ok { + r0 = rf(ctx, controllerRevision, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.ControllerRevision) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ControllerRevisionApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, controllerRevision, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, controllerRevision, opts -func (_m *ControllerRevisionInterface) Create(ctx context.Context, controllerRevision *v1.ControllerRevision, opts metav1.CreateOptions) (*v1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Create(ctx context.Context, controllerRevision *appsv1.ControllerRevision, opts metav1.CreateOptions) (*appsv1.ControllerRevision, error) { ret := _m.Called(ctx, controllerRevision, opts) - var r0 *v1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, *v1.ControllerRevision, metav1.CreateOptions) *v1.ControllerRevision); ok { + var r0 *appsv1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.ControllerRevision, metav1.CreateOptions) *appsv1.ControllerRevision); ok { r0 = rf(ctx, controllerRevision, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ControllerRevision) + r0 = ret.Get(0).(*appsv1.ControllerRevision) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ControllerRevision, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.ControllerRevision, metav1.CreateOptions) error); ok { r1 = rf(ctx, controllerRevision, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *ControllerRevisionInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*appsv1.ControllerRevision, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ControllerRevision); ok { + var r0 *appsv1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *appsv1.ControllerRevision); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ControllerRevision) + r0 = ret.Get(0).(*appsv1.ControllerRevision) } } @@ -95,15 +121,15 @@ func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *ControllerRevisionInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ControllerRevisionList, error) { +func (_m *ControllerRevisionInterface) List(ctx context.Context, opts metav1.ListOptions) (*appsv1.ControllerRevisionList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ControllerRevisionList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ControllerRevisionList); ok { + var r0 *appsv1.ControllerRevisionList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *appsv1.ControllerRevisionList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ControllerRevisionList) + r0 = ret.Get(0).(*appsv1.ControllerRevisionList) } } @@ -118,7 +144,7 @@ func (_m *ControllerRevisionInterface) List(ctx context.Context, opts metav1.Lis } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*appsv1.ControllerRevision, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ControllerRevision); ok { + var r0 *appsv1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *appsv1.ControllerRevision); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ControllerRevision) + r0 = ret.Get(0).(*appsv1.ControllerRevision) } } @@ -148,20 +174,20 @@ func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, controllerRevision, opts -func (_m *ControllerRevisionInterface) Update(ctx context.Context, controllerRevision *v1.ControllerRevision, opts metav1.UpdateOptions) (*v1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Update(ctx context.Context, controllerRevision *appsv1.ControllerRevision, opts metav1.UpdateOptions) (*appsv1.ControllerRevision, error) { ret := _m.Called(ctx, controllerRevision, opts) - var r0 *v1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, *v1.ControllerRevision, metav1.UpdateOptions) *v1.ControllerRevision); ok { + var r0 *appsv1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.ControllerRevision, metav1.UpdateOptions) *appsv1.ControllerRevision); ok { r0 = rf(ctx, controllerRevision, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ControllerRevision) + r0 = ret.Get(0).(*appsv1.ControllerRevision) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ControllerRevision, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.ControllerRevision, metav1.UpdateOptions) error); ok { r1 = rf(ctx, controllerRevision, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1/daemon_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1/daemon_set_interface.go index a46d8590c5..2342674d33 100644 --- a/testutil/kubernetes_mock/typed/apps/v1/daemon_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1/daemon_set_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + appsv1 "k8s.io/api/apps/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/apps/v1" + v1 "k8s.io/client-go/applyconfigurations/apps/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type DaemonSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, daemonSet, opts +func (_m *DaemonSetInterface) Apply(ctx context.Context, daemonSet *v1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.DaemonSet, error) { + ret := _m.Called(ctx, daemonSet, opts) + + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *v1.DaemonSetApplyConfiguration, metav1.ApplyOptions) *appsv1.DaemonSet); ok { + r0 = rf(ctx, daemonSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.DaemonSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.DaemonSetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, daemonSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, daemonSet, opts +func (_m *DaemonSetInterface) ApplyStatus(ctx context.Context, daemonSet *v1.DaemonSetApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.DaemonSet, error) { + ret := _m.Called(ctx, daemonSet, opts) + + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *v1.DaemonSetApplyConfiguration, metav1.ApplyOptions) *appsv1.DaemonSet); ok { + r0 = rf(ctx, daemonSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.DaemonSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.DaemonSetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, daemonSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) Create(ctx context.Context, daemonSet *v1.DaemonSet, opts metav1.CreateOptions) (*v1.DaemonSet, error) { +func (_m *DaemonSetInterface) Create(ctx context.Context, daemonSet *appsv1.DaemonSet, opts metav1.CreateOptions) (*appsv1.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.DaemonSet, metav1.CreateOptions) *v1.DaemonSet); ok { + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.DaemonSet, metav1.CreateOptions) *appsv1.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DaemonSet) + r0 = ret.Get(0).(*appsv1.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.DaemonSet, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.DaemonSet, metav1.CreateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *DaemonSetInterface) DeleteCollection(ctx context.Context, opts metav1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.DaemonSet, error) { +func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*appsv1.DaemonSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.DaemonSet); ok { + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *appsv1.DaemonSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DaemonSet) + r0 = ret.Get(0).(*appsv1.DaemonSet) } } @@ -95,15 +144,15 @@ func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts metav1. } // List provides a mock function with given fields: ctx, opts -func (_m *DaemonSetInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.DaemonSetList, error) { +func (_m *DaemonSetInterface) List(ctx context.Context, opts metav1.ListOptions) (*appsv1.DaemonSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.DaemonSetList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.DaemonSetList); ok { + var r0 *appsv1.DaemonSetList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *appsv1.DaemonSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DaemonSetList) + r0 = ret.Get(0).(*appsv1.DaemonSetList) } } @@ -118,7 +167,7 @@ func (_m *DaemonSetInterface) List(ctx context.Context, opts metav1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.DaemonSet, error) { +func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*appsv1.DaemonSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.DaemonSet); ok { + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *appsv1.DaemonSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DaemonSet) + r0 = ret.Get(0).(*appsv1.DaemonSet) } } @@ -148,20 +197,20 @@ func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *v1.DaemonSet, opts metav1.UpdateOptions) (*v1.DaemonSet, error) { +func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *appsv1.DaemonSet, opts metav1.UpdateOptions) (*appsv1.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.DaemonSet, metav1.UpdateOptions) *v1.DaemonSet); ok { + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.DaemonSet, metav1.UpdateOptions) *appsv1.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DaemonSet) + r0 = ret.Get(0).(*appsv1.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.DaemonSet, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.DaemonSet, metav1.UpdateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *v1.DaemonSe } // UpdateStatus provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) UpdateStatus(ctx context.Context, daemonSet *v1.DaemonSet, opts metav1.UpdateOptions) (*v1.DaemonSet, error) { +func (_m *DaemonSetInterface) UpdateStatus(ctx context.Context, daemonSet *appsv1.DaemonSet, opts metav1.UpdateOptions) (*appsv1.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.DaemonSet, metav1.UpdateOptions) *v1.DaemonSet); ok { + var r0 *appsv1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.DaemonSet, metav1.UpdateOptions) *appsv1.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DaemonSet) + r0 = ret.Get(0).(*appsv1.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.DaemonSet, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.DaemonSet, metav1.UpdateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1/deployment_interface.go b/testutil/kubernetes_mock/typed/apps/v1/deployment_interface.go index 27416c7c44..58ffce0ef6 100644 --- a/testutil/kubernetes_mock/typed/apps/v1/deployment_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1/deployment_interface.go @@ -3,17 +3,18 @@ package kubernetes_mocks import ( - context "context" - + appsv1 "k8s.io/api/apps/v1" autoscalingv1 "k8s.io/api/autoscaling/v1" + context "context" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/apps/v1" + v1 "k8s.io/client-go/applyconfigurations/apps/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -23,21 +24,67 @@ type DeploymentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) Apply(ctx context.Context, deployment *v1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1.DeploymentApplyConfiguration, metav1.ApplyOptions) *appsv1.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.DeploymentApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) ApplyStatus(ctx context.Context, deployment *v1.DeploymentApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1.DeploymentApplyConfiguration, metav1.ApplyOptions) *appsv1.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.DeploymentApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Create(ctx context.Context, deployment *v1.Deployment, opts metav1.CreateOptions) (*v1.Deployment, error) { +func (_m *DeploymentInterface) Create(ctx context.Context, deployment *appsv1.Deployment, opts metav1.CreateOptions) (*appsv1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1.Deployment, metav1.CreateOptions) *v1.Deployment); ok { + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.Deployment, metav1.CreateOptions) *appsv1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Deployment) + r0 = ret.Get(0).(*appsv1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Deployment, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.Deployment, metav1.CreateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -75,15 +122,15 @@ func (_m *DeploymentInterface) DeleteCollection(ctx context.Context, opts metav1 } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Deployment, error) { +func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*appsv1.Deployment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Deployment); ok { + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *appsv1.Deployment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Deployment) + r0 = ret.Get(0).(*appsv1.Deployment) } } @@ -121,15 +168,15 @@ func (_m *DeploymentInterface) GetScale(ctx context.Context, deploymentName stri } // List provides a mock function with given fields: ctx, opts -func (_m *DeploymentInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.DeploymentList, error) { +func (_m *DeploymentInterface) List(ctx context.Context, opts metav1.ListOptions) (*appsv1.DeploymentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.DeploymentList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.DeploymentList); ok { + var r0 *appsv1.DeploymentList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *appsv1.DeploymentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.DeploymentList) + r0 = ret.Get(0).(*appsv1.DeploymentList) } } @@ -144,7 +191,7 @@ func (_m *DeploymentInterface) List(ctx context.Context, opts metav1.ListOptions } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Deployment, error) { +func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*appsv1.Deployment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -154,12 +201,12 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Deployment); ok { + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *appsv1.Deployment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Deployment) + r0 = ret.Get(0).(*appsv1.Deployment) } } @@ -174,20 +221,20 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1.Deployment, opts metav1.UpdateOptions) (*v1.Deployment, error) { +func (_m *DeploymentInterface) Update(ctx context.Context, deployment *appsv1.Deployment, opts metav1.UpdateOptions) (*appsv1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1.Deployment, metav1.UpdateOptions) *v1.Deployment); ok { + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.Deployment, metav1.UpdateOptions) *appsv1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Deployment) + r0 = ret.Get(0).(*appsv1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Deployment, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.Deployment, metav1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -220,20 +267,20 @@ func (_m *DeploymentInterface) UpdateScale(ctx context.Context, deploymentName s } // UpdateStatus provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *v1.Deployment, opts metav1.UpdateOptions) (*v1.Deployment, error) { +func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *appsv1.Deployment, opts metav1.UpdateOptions) (*appsv1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1.Deployment, metav1.UpdateOptions) *v1.Deployment); ok { + var r0 *appsv1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.Deployment, metav1.UpdateOptions) *appsv1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Deployment) + r0 = ret.Get(0).(*appsv1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Deployment, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.Deployment, metav1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1/replica_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1/replica_set_interface.go index cfc05e5cf0..56523b8cf6 100644 --- a/testutil/kubernetes_mock/typed/apps/v1/replica_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1/replica_set_interface.go @@ -3,17 +3,18 @@ package kubernetes_mocks import ( - context "context" - + appsv1 "k8s.io/api/apps/v1" autoscalingv1 "k8s.io/api/autoscaling/v1" + context "context" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/apps/v1" + v1 "k8s.io/client-go/applyconfigurations/apps/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -23,21 +24,67 @@ type ReplicaSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, replicaSet, opts +func (_m *ReplicaSetInterface) Apply(ctx context.Context, replicaSet *v1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.ReplicaSet, error) { + ret := _m.Called(ctx, replicaSet, opts) + + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicaSetApplyConfiguration, metav1.ApplyOptions) *appsv1.ReplicaSet); ok { + r0 = rf(ctx, replicaSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.ReplicaSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicaSetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, replicaSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, replicaSet, opts +func (_m *ReplicaSetInterface) ApplyStatus(ctx context.Context, replicaSet *v1.ReplicaSetApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.ReplicaSet, error) { + ret := _m.Called(ctx, replicaSet, opts) + + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicaSetApplyConfiguration, metav1.ApplyOptions) *appsv1.ReplicaSet); ok { + r0 = rf(ctx, replicaSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.ReplicaSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicaSetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, replicaSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) Create(ctx context.Context, replicaSet *v1.ReplicaSet, opts metav1.CreateOptions) (*v1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Create(ctx context.Context, replicaSet *appsv1.ReplicaSet, opts metav1.CreateOptions) (*appsv1.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicaSet, metav1.CreateOptions) *v1.ReplicaSet); ok { + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.ReplicaSet, metav1.CreateOptions) *appsv1.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicaSet) + r0 = ret.Get(0).(*appsv1.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicaSet, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.ReplicaSet, metav1.CreateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) @@ -75,15 +122,15 @@ func (_m *ReplicaSetInterface) DeleteCollection(ctx context.Context, opts metav1 } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*appsv1.ReplicaSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ReplicaSet); ok { + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *appsv1.ReplicaSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicaSet) + r0 = ret.Get(0).(*appsv1.ReplicaSet) } } @@ -121,15 +168,15 @@ func (_m *ReplicaSetInterface) GetScale(ctx context.Context, replicaSetName stri } // List provides a mock function with given fields: ctx, opts -func (_m *ReplicaSetInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ReplicaSetList, error) { +func (_m *ReplicaSetInterface) List(ctx context.Context, opts metav1.ListOptions) (*appsv1.ReplicaSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ReplicaSetList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ReplicaSetList); ok { + var r0 *appsv1.ReplicaSetList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *appsv1.ReplicaSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicaSetList) + r0 = ret.Get(0).(*appsv1.ReplicaSetList) } } @@ -144,7 +191,7 @@ func (_m *ReplicaSetInterface) List(ctx context.Context, opts metav1.ListOptions } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*appsv1.ReplicaSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -154,12 +201,12 @@ func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ReplicaSet); ok { + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *appsv1.ReplicaSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicaSet) + r0 = ret.Get(0).(*appsv1.ReplicaSet) } } @@ -174,20 +221,20 @@ func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *v1.ReplicaSet, opts metav1.UpdateOptions) (*v1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *appsv1.ReplicaSet, opts metav1.UpdateOptions) (*appsv1.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicaSet, metav1.UpdateOptions) *v1.ReplicaSet); ok { + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.ReplicaSet, metav1.UpdateOptions) *appsv1.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicaSet) + r0 = ret.Get(0).(*appsv1.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicaSet, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.ReplicaSet, metav1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) @@ -220,20 +267,20 @@ func (_m *ReplicaSetInterface) UpdateScale(ctx context.Context, replicaSetName s } // UpdateStatus provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) UpdateStatus(ctx context.Context, replicaSet *v1.ReplicaSet, opts metav1.UpdateOptions) (*v1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) UpdateStatus(ctx context.Context, replicaSet *appsv1.ReplicaSet, opts metav1.UpdateOptions) (*appsv1.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicaSet, metav1.UpdateOptions) *v1.ReplicaSet); ok { + var r0 *appsv1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.ReplicaSet, metav1.UpdateOptions) *appsv1.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicaSet) + r0 = ret.Get(0).(*appsv1.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicaSet, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.ReplicaSet, metav1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1/stateful_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1/stateful_set_interface.go index 089f24f136..914f0edc93 100644 --- a/testutil/kubernetes_mock/typed/apps/v1/stateful_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1/stateful_set_interface.go @@ -3,17 +3,18 @@ package kubernetes_mocks import ( - context "context" - + appsv1 "k8s.io/api/apps/v1" autoscalingv1 "k8s.io/api/autoscaling/v1" + context "context" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/apps/v1" + v1 "k8s.io/client-go/applyconfigurations/apps/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -23,21 +24,67 @@ type StatefulSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, statefulSet, opts +func (_m *StatefulSetInterface) Apply(ctx context.Context, statefulSet *v1.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.StatefulSet, error) { + ret := _m.Called(ctx, statefulSet, opts) + + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *v1.StatefulSetApplyConfiguration, metav1.ApplyOptions) *appsv1.StatefulSet); ok { + r0 = rf(ctx, statefulSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.StatefulSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.StatefulSetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, statefulSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, statefulSet, opts +func (_m *StatefulSetInterface) ApplyStatus(ctx context.Context, statefulSet *v1.StatefulSetApplyConfiguration, opts metav1.ApplyOptions) (*appsv1.StatefulSet, error) { + ret := _m.Called(ctx, statefulSet, opts) + + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *v1.StatefulSetApplyConfiguration, metav1.ApplyOptions) *appsv1.StatefulSet); ok { + r0 = rf(ctx, statefulSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1.StatefulSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.StatefulSetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, statefulSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) Create(ctx context.Context, statefulSet *v1.StatefulSet, opts metav1.CreateOptions) (*v1.StatefulSet, error) { +func (_m *StatefulSetInterface) Create(ctx context.Context, statefulSet *appsv1.StatefulSet, opts metav1.CreateOptions) (*appsv1.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.StatefulSet, metav1.CreateOptions) *v1.StatefulSet); ok { + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.StatefulSet, metav1.CreateOptions) *appsv1.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StatefulSet) + r0 = ret.Get(0).(*appsv1.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.StatefulSet, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.StatefulSet, metav1.CreateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) @@ -75,15 +122,15 @@ func (_m *StatefulSetInterface) DeleteCollection(ctx context.Context, opts metav } // Get provides a mock function with given fields: ctx, name, opts -func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.StatefulSet, error) { +func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*appsv1.StatefulSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.StatefulSet); ok { + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *appsv1.StatefulSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StatefulSet) + r0 = ret.Get(0).(*appsv1.StatefulSet) } } @@ -121,15 +168,15 @@ func (_m *StatefulSetInterface) GetScale(ctx context.Context, statefulSetName st } // List provides a mock function with given fields: ctx, opts -func (_m *StatefulSetInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.StatefulSetList, error) { +func (_m *StatefulSetInterface) List(ctx context.Context, opts metav1.ListOptions) (*appsv1.StatefulSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.StatefulSetList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.StatefulSetList); ok { + var r0 *appsv1.StatefulSetList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *appsv1.StatefulSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StatefulSetList) + r0 = ret.Get(0).(*appsv1.StatefulSetList) } } @@ -144,7 +191,7 @@ func (_m *StatefulSetInterface) List(ctx context.Context, opts metav1.ListOption } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.StatefulSet, error) { +func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*appsv1.StatefulSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -154,12 +201,12 @@ func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.StatefulSet); ok { + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *appsv1.StatefulSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StatefulSet) + r0 = ret.Get(0).(*appsv1.StatefulSet) } } @@ -174,20 +221,20 @@ func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *v1.StatefulSet, opts metav1.UpdateOptions) (*v1.StatefulSet, error) { +func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *appsv1.StatefulSet, opts metav1.UpdateOptions) (*appsv1.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.StatefulSet, metav1.UpdateOptions) *v1.StatefulSet); ok { + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.StatefulSet, metav1.UpdateOptions) *appsv1.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StatefulSet) + r0 = ret.Get(0).(*appsv1.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.StatefulSet, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.StatefulSet, metav1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) @@ -220,20 +267,20 @@ func (_m *StatefulSetInterface) UpdateScale(ctx context.Context, statefulSetName } // UpdateStatus provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) UpdateStatus(ctx context.Context, statefulSet *v1.StatefulSet, opts metav1.UpdateOptions) (*v1.StatefulSet, error) { +func (_m *StatefulSetInterface) UpdateStatus(ctx context.Context, statefulSet *appsv1.StatefulSet, opts metav1.UpdateOptions) (*appsv1.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1.StatefulSet, metav1.UpdateOptions) *v1.StatefulSet); ok { + var r0 *appsv1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1.StatefulSet, metav1.UpdateOptions) *appsv1.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StatefulSet) + r0 = ret.Get(0).(*appsv1.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.StatefulSet, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1.StatefulSet, metav1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta1/controller_revision_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta1/controller_revision_interface.go index 986660c438..5c6124ebc5 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta1/controller_revision_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta1/controller_revision_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta1 "k8s.io/api/apps/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/apps/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/apps/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type ControllerRevisionInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, controllerRevision, opts +func (_m *ControllerRevisionInterface) Apply(ctx context.Context, controllerRevision *v1beta1.ControllerRevisionApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta1.ControllerRevision, error) { + ret := _m.Called(ctx, controllerRevision, opts) + + var r0 *appsv1beta1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ControllerRevisionApplyConfiguration, v1.ApplyOptions) *appsv1beta1.ControllerRevision); ok { + r0 = rf(ctx, controllerRevision, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta1.ControllerRevision) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ControllerRevisionApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, controllerRevision, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, controllerRevision, opts -func (_m *ControllerRevisionInterface) Create(ctx context.Context, controllerRevision *v1beta1.ControllerRevision, opts v1.CreateOptions) (*v1beta1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Create(ctx context.Context, controllerRevision *appsv1beta1.ControllerRevision, opts v1.CreateOptions) (*appsv1beta1.ControllerRevision, error) { ret := _m.Called(ctx, controllerRevision, opts) - var r0 *v1beta1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ControllerRevision, v1.CreateOptions) *v1beta1.ControllerRevision); ok { + var r0 *appsv1beta1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.ControllerRevision, v1.CreateOptions) *appsv1beta1.ControllerRevision); ok { r0 = rf(ctx, controllerRevision, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta1.ControllerRevision) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ControllerRevision, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.ControllerRevision, v1.CreateOptions) error); ok { r1 = rf(ctx, controllerRevision, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *ControllerRevisionInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta1.ControllerRevision, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.ControllerRevision); ok { + var r0 *appsv1beta1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta1.ControllerRevision); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta1.ControllerRevision) } } @@ -95,15 +121,15 @@ func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *ControllerRevisionInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.ControllerRevisionList, error) { +func (_m *ControllerRevisionInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta1.ControllerRevisionList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.ControllerRevisionList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.ControllerRevisionList); ok { + var r0 *appsv1beta1.ControllerRevisionList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta1.ControllerRevisionList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ControllerRevisionList) + r0 = ret.Get(0).(*appsv1beta1.ControllerRevisionList) } } @@ -118,7 +144,7 @@ func (_m *ControllerRevisionInterface) List(ctx context.Context, opts v1.ListOpt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta1.ControllerRevision, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.ControllerRevision); ok { + var r0 *appsv1beta1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta1.ControllerRevision); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta1.ControllerRevision) } } @@ -148,20 +174,20 @@ func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, controllerRevision, opts -func (_m *ControllerRevisionInterface) Update(ctx context.Context, controllerRevision *v1beta1.ControllerRevision, opts v1.UpdateOptions) (*v1beta1.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Update(ctx context.Context, controllerRevision *appsv1beta1.ControllerRevision, opts v1.UpdateOptions) (*appsv1beta1.ControllerRevision, error) { ret := _m.Called(ctx, controllerRevision, opts) - var r0 *v1beta1.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ControllerRevision, v1.UpdateOptions) *v1beta1.ControllerRevision); ok { + var r0 *appsv1beta1.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.ControllerRevision, v1.UpdateOptions) *appsv1beta1.ControllerRevision); ok { r0 = rf(ctx, controllerRevision, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta1.ControllerRevision) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ControllerRevision, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.ControllerRevision, v1.UpdateOptions) error); ok { r1 = rf(ctx, controllerRevision, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta1/deployment_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta1/deployment_interface.go index 126e8ee530..3095ab5e1b 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta1/deployment_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta1/deployment_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta1 "k8s.io/api/apps/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/apps/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/apps/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type DeploymentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) Apply(ctx context.Context, deployment *v1beta1.DeploymentApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta1.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) *appsv1beta1.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta1.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) ApplyStatus(ctx context.Context, deployment *v1beta1.DeploymentApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta1.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) *appsv1beta1.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta1.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Create(ctx context.Context, deployment *v1beta1.Deployment, opts v1.CreateOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Create(ctx context.Context, deployment *appsv1beta1.Deployment, opts v1.CreateOptions) (*appsv1beta1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Deployment, v1.CreateOptions) *v1beta1.Deployment); ok { + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.Deployment, v1.CreateOptions) *appsv1beta1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*appsv1beta1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Deployment, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.Deployment, v1.CreateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *DeploymentInterface) DeleteCollection(ctx context.Context, opts v1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta1.Deployment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Deployment); ok { + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta1.Deployment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*appsv1beta1.Deployment) } } @@ -95,15 +144,15 @@ func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.Get } // List provides a mock function with given fields: ctx, opts -func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.DeploymentList, error) { +func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta1.DeploymentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.DeploymentList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.DeploymentList); ok { + var r0 *appsv1beta1.DeploymentList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta1.DeploymentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DeploymentList) + r0 = ret.Get(0).(*appsv1beta1.DeploymentList) } } @@ -118,7 +167,7 @@ func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta1.Deployment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Deployment); ok { + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta1.Deployment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*appsv1beta1.Deployment) } } @@ -148,20 +197,20 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1beta1.Deployment, opts v1.UpdateOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Update(ctx context.Context, deployment *appsv1beta1.Deployment, opts v1.UpdateOptions) (*appsv1beta1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) *v1beta1.Deployment); ok { + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.Deployment, v1.UpdateOptions) *appsv1beta1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*appsv1beta1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.Deployment, v1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1beta1.D } // UpdateStatus provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *v1beta1.Deployment, opts v1.UpdateOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *appsv1beta1.Deployment, opts v1.UpdateOptions) (*appsv1beta1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) *v1beta1.Deployment); ok { + var r0 *appsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.Deployment, v1.UpdateOptions) *appsv1beta1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*appsv1beta1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.Deployment, v1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta1/stateful_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta1/stateful_set_interface.go index bea07fdcad..1f0a1e0302 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta1/stateful_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta1/stateful_set_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta1 "k8s.io/api/apps/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/apps/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/apps/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type StatefulSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, statefulSet, opts +func (_m *StatefulSetInterface) Apply(ctx context.Context, statefulSet *v1beta1.StatefulSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta1.StatefulSet, error) { + ret := _m.Called(ctx, statefulSet, opts) + + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StatefulSetApplyConfiguration, v1.ApplyOptions) *appsv1beta1.StatefulSet); ok { + r0 = rf(ctx, statefulSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StatefulSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, statefulSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, statefulSet, opts +func (_m *StatefulSetInterface) ApplyStatus(ctx context.Context, statefulSet *v1beta1.StatefulSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta1.StatefulSet, error) { + ret := _m.Called(ctx, statefulSet, opts) + + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StatefulSetApplyConfiguration, v1.ApplyOptions) *appsv1beta1.StatefulSet); ok { + r0 = rf(ctx, statefulSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StatefulSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, statefulSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) Create(ctx context.Context, statefulSet *v1beta1.StatefulSet, opts v1.CreateOptions) (*v1beta1.StatefulSet, error) { +func (_m *StatefulSetInterface) Create(ctx context.Context, statefulSet *appsv1beta1.StatefulSet, opts v1.CreateOptions) (*appsv1beta1.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1beta1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StatefulSet, v1.CreateOptions) *v1beta1.StatefulSet); ok { + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.StatefulSet, v1.CreateOptions) *appsv1beta1.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StatefulSet) + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StatefulSet, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.StatefulSet, v1.CreateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *StatefulSetInterface) DeleteCollection(ctx context.Context, opts v1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.StatefulSet, error) { +func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta1.StatefulSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.StatefulSet); ok { + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta1.StatefulSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StatefulSet) + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) } } @@ -95,15 +144,15 @@ func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts v1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *StatefulSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.StatefulSetList, error) { +func (_m *StatefulSetInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta1.StatefulSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.StatefulSetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.StatefulSetList); ok { + var r0 *appsv1beta1.StatefulSetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta1.StatefulSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StatefulSetList) + r0 = ret.Get(0).(*appsv1beta1.StatefulSetList) } } @@ -118,7 +167,7 @@ func (_m *StatefulSetInterface) List(ctx context.Context, opts v1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.StatefulSet, error) { +func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta1.StatefulSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.StatefulSet); ok { + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta1.StatefulSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StatefulSet) + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) } } @@ -148,20 +197,20 @@ func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *v1beta1.StatefulSet, opts v1.UpdateOptions) (*v1beta1.StatefulSet, error) { +func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *appsv1beta1.StatefulSet, opts v1.UpdateOptions) (*appsv1beta1.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1beta1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StatefulSet, v1.UpdateOptions) *v1beta1.StatefulSet); ok { + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.StatefulSet, v1.UpdateOptions) *appsv1beta1.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StatefulSet) + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StatefulSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.StatefulSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *v1beta1 } // UpdateStatus provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) UpdateStatus(ctx context.Context, statefulSet *v1beta1.StatefulSet, opts v1.UpdateOptions) (*v1beta1.StatefulSet, error) { +func (_m *StatefulSetInterface) UpdateStatus(ctx context.Context, statefulSet *appsv1beta1.StatefulSet, opts v1.UpdateOptions) (*appsv1beta1.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1beta1.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StatefulSet, v1.UpdateOptions) *v1beta1.StatefulSet); ok { + var r0 *appsv1beta1.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta1.StatefulSet, v1.UpdateOptions) *appsv1beta1.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StatefulSet) + r0 = ret.Get(0).(*appsv1beta1.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StatefulSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta1.StatefulSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta2/controller_revision_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta2/controller_revision_interface.go index 64a96ce6ef..28be52b722 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta2/controller_revision_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta2/controller_revision_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta2 "k8s.io/api/apps/v1beta2" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta2 "k8s.io/api/apps/v1beta2" + v1beta2 "k8s.io/client-go/applyconfigurations/apps/v1beta2" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,44 @@ type ControllerRevisionInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, controllerRevision, opts +func (_m *ControllerRevisionInterface) Apply(ctx context.Context, controllerRevision *v1beta2.ControllerRevisionApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.ControllerRevision, error) { + ret := _m.Called(ctx, controllerRevision, opts) + + var r0 *appsv1beta2.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ControllerRevisionApplyConfiguration, v1.ApplyOptions) *appsv1beta2.ControllerRevision); ok { + r0 = rf(ctx, controllerRevision, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.ControllerRevision) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ControllerRevisionApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, controllerRevision, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, controllerRevision, opts -func (_m *ControllerRevisionInterface) Create(ctx context.Context, controllerRevision *v1beta2.ControllerRevision, opts v1.CreateOptions) (*v1beta2.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Create(ctx context.Context, controllerRevision *appsv1beta2.ControllerRevision, opts v1.CreateOptions) (*appsv1beta2.ControllerRevision, error) { ret := _m.Called(ctx, controllerRevision, opts) - var r0 *v1beta2.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ControllerRevision, v1.CreateOptions) *v1beta2.ControllerRevision); ok { + var r0 *appsv1beta2.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.ControllerRevision, v1.CreateOptions) *appsv1beta2.ControllerRevision); ok { r0 = rf(ctx, controllerRevision, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta2.ControllerRevision) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ControllerRevision, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.ControllerRevision, v1.CreateOptions) error); ok { r1 = rf(ctx, controllerRevision, opts) } else { r1 = ret.Error(1) @@ -72,15 +98,15 @@ func (_m *ControllerRevisionInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta2.ControllerRevision, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta2.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta2.ControllerRevision); ok { + var r0 *appsv1beta2.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta2.ControllerRevision); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta2.ControllerRevision) } } @@ -95,15 +121,15 @@ func (_m *ControllerRevisionInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *ControllerRevisionInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta2.ControllerRevisionList, error) { +func (_m *ControllerRevisionInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta2.ControllerRevisionList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta2.ControllerRevisionList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta2.ControllerRevisionList); ok { + var r0 *appsv1beta2.ControllerRevisionList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta2.ControllerRevisionList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ControllerRevisionList) + r0 = ret.Get(0).(*appsv1beta2.ControllerRevisionList) } } @@ -118,7 +144,7 @@ func (_m *ControllerRevisionInterface) List(ctx context.Context, opts v1.ListOpt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta2.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta2.ControllerRevision, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +154,12 @@ func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta2.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta2.ControllerRevision); ok { + var r0 *appsv1beta2.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta2.ControllerRevision); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta2.ControllerRevision) } } @@ -148,20 +174,20 @@ func (_m *ControllerRevisionInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, controllerRevision, opts -func (_m *ControllerRevisionInterface) Update(ctx context.Context, controllerRevision *v1beta2.ControllerRevision, opts v1.UpdateOptions) (*v1beta2.ControllerRevision, error) { +func (_m *ControllerRevisionInterface) Update(ctx context.Context, controllerRevision *appsv1beta2.ControllerRevision, opts v1.UpdateOptions) (*appsv1beta2.ControllerRevision, error) { ret := _m.Called(ctx, controllerRevision, opts) - var r0 *v1beta2.ControllerRevision - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ControllerRevision, v1.UpdateOptions) *v1beta2.ControllerRevision); ok { + var r0 *appsv1beta2.ControllerRevision + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.ControllerRevision, v1.UpdateOptions) *appsv1beta2.ControllerRevision); ok { r0 = rf(ctx, controllerRevision, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ControllerRevision) + r0 = ret.Get(0).(*appsv1beta2.ControllerRevision) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ControllerRevision, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.ControllerRevision, v1.UpdateOptions) error); ok { r1 = rf(ctx, controllerRevision, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta2/daemon_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta2/daemon_set_interface.go index df1f6fd928..59c961de48 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta2/daemon_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta2/daemon_set_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta2 "k8s.io/api/apps/v1beta2" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta2 "k8s.io/api/apps/v1beta2" + v1beta2 "k8s.io/client-go/applyconfigurations/apps/v1beta2" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type DaemonSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, daemonSet, opts +func (_m *DaemonSetInterface) Apply(ctx context.Context, daemonSet *v1beta2.DaemonSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.DaemonSet, error) { + ret := _m.Called(ctx, daemonSet, opts) + + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DaemonSetApplyConfiguration, v1.ApplyOptions) *appsv1beta2.DaemonSet); ok { + r0 = rf(ctx, daemonSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DaemonSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, daemonSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, daemonSet, opts +func (_m *DaemonSetInterface) ApplyStatus(ctx context.Context, daemonSet *v1beta2.DaemonSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.DaemonSet, error) { + ret := _m.Called(ctx, daemonSet, opts) + + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DaemonSetApplyConfiguration, v1.ApplyOptions) *appsv1beta2.DaemonSet); ok { + r0 = rf(ctx, daemonSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DaemonSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, daemonSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) Create(ctx context.Context, daemonSet *v1beta2.DaemonSet, opts v1.CreateOptions) (*v1beta2.DaemonSet, error) { +func (_m *DaemonSetInterface) Create(ctx context.Context, daemonSet *appsv1beta2.DaemonSet, opts v1.CreateOptions) (*appsv1beta2.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1beta2.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DaemonSet, v1.CreateOptions) *v1beta2.DaemonSet); ok { + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.DaemonSet, v1.CreateOptions) *appsv1beta2.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DaemonSet) + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DaemonSet, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.DaemonSet, v1.CreateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *DaemonSetInterface) DeleteCollection(ctx context.Context, opts v1.Dele } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.DaemonSet, error) { +func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta2.DaemonSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta2.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta2.DaemonSet); ok { + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta2.DaemonSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DaemonSet) + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) } } @@ -95,15 +144,15 @@ func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts v1.GetO } // List provides a mock function with given fields: ctx, opts -func (_m *DaemonSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta2.DaemonSetList, error) { +func (_m *DaemonSetInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta2.DaemonSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta2.DaemonSetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta2.DaemonSetList); ok { + var r0 *appsv1beta2.DaemonSetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta2.DaemonSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DaemonSetList) + r0 = ret.Get(0).(*appsv1beta2.DaemonSetList) } } @@ -118,7 +167,7 @@ func (_m *DaemonSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta2.DaemonSet, error) { +func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta2.DaemonSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta2.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta2.DaemonSet); ok { + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta2.DaemonSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DaemonSet) + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) } } @@ -148,20 +197,20 @@ func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *v1beta2.DaemonSet, opts v1.UpdateOptions) (*v1beta2.DaemonSet, error) { +func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *appsv1beta2.DaemonSet, opts v1.UpdateOptions) (*appsv1beta2.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1beta2.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DaemonSet, v1.UpdateOptions) *v1beta2.DaemonSet); ok { + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.DaemonSet, v1.UpdateOptions) *appsv1beta2.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DaemonSet) + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DaemonSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.DaemonSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *v1beta2.Dae } // UpdateStatus provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) UpdateStatus(ctx context.Context, daemonSet *v1beta2.DaemonSet, opts v1.UpdateOptions) (*v1beta2.DaemonSet, error) { +func (_m *DaemonSetInterface) UpdateStatus(ctx context.Context, daemonSet *appsv1beta2.DaemonSet, opts v1.UpdateOptions) (*appsv1beta2.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1beta2.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DaemonSet, v1.UpdateOptions) *v1beta2.DaemonSet); ok { + var r0 *appsv1beta2.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.DaemonSet, v1.UpdateOptions) *appsv1beta2.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DaemonSet) + r0 = ret.Get(0).(*appsv1beta2.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DaemonSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.DaemonSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta2/deployment_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta2/deployment_interface.go index 971727a2af..ec6358bddb 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta2/deployment_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta2/deployment_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta2 "k8s.io/api/apps/v1beta2" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta2 "k8s.io/api/apps/v1beta2" + v1beta2 "k8s.io/client-go/applyconfigurations/apps/v1beta2" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type DeploymentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) Apply(ctx context.Context, deployment *v1beta2.DeploymentApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DeploymentApplyConfiguration, v1.ApplyOptions) *appsv1beta2.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DeploymentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) ApplyStatus(ctx context.Context, deployment *v1beta2.DeploymentApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.DeploymentApplyConfiguration, v1.ApplyOptions) *appsv1beta2.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.DeploymentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Create(ctx context.Context, deployment *v1beta2.Deployment, opts v1.CreateOptions) (*v1beta2.Deployment, error) { +func (_m *DeploymentInterface) Create(ctx context.Context, deployment *appsv1beta2.Deployment, opts v1.CreateOptions) (*appsv1beta2.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta2.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.Deployment, v1.CreateOptions) *v1beta2.Deployment); ok { + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.Deployment, v1.CreateOptions) *appsv1beta2.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Deployment) + r0 = ret.Get(0).(*appsv1beta2.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.Deployment, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.Deployment, v1.CreateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *DeploymentInterface) DeleteCollection(ctx context.Context, opts v1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.Deployment, error) { +func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta2.Deployment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta2.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta2.Deployment); ok { + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta2.Deployment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Deployment) + r0 = ret.Get(0).(*appsv1beta2.Deployment) } } @@ -95,15 +144,15 @@ func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.Get } // List provides a mock function with given fields: ctx, opts -func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta2.DeploymentList, error) { +func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta2.DeploymentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta2.DeploymentList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta2.DeploymentList); ok { + var r0 *appsv1beta2.DeploymentList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta2.DeploymentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.DeploymentList) + r0 = ret.Get(0).(*appsv1beta2.DeploymentList) } } @@ -118,7 +167,7 @@ func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta2.Deployment, error) { +func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta2.Deployment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta2.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta2.Deployment); ok { + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta2.Deployment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Deployment) + r0 = ret.Get(0).(*appsv1beta2.Deployment) } } @@ -148,20 +197,20 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1beta2.Deployment, opts v1.UpdateOptions) (*v1beta2.Deployment, error) { +func (_m *DeploymentInterface) Update(ctx context.Context, deployment *appsv1beta2.Deployment, opts v1.UpdateOptions) (*appsv1beta2.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta2.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.Deployment, v1.UpdateOptions) *v1beta2.Deployment); ok { + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.Deployment, v1.UpdateOptions) *appsv1beta2.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Deployment) + r0 = ret.Get(0).(*appsv1beta2.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.Deployment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.Deployment, v1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1beta2.D } // UpdateStatus provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *v1beta2.Deployment, opts v1.UpdateOptions) (*v1beta2.Deployment, error) { +func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *appsv1beta2.Deployment, opts v1.UpdateOptions) (*appsv1beta2.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta2.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.Deployment, v1.UpdateOptions) *v1beta2.Deployment); ok { + var r0 *appsv1beta2.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.Deployment, v1.UpdateOptions) *appsv1beta2.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Deployment) + r0 = ret.Get(0).(*appsv1beta2.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.Deployment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.Deployment, v1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta2/replica_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta2/replica_set_interface.go index f79be40a5e..bd7f03d135 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta2/replica_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta2/replica_set_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta2 "k8s.io/api/apps/v1beta2" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta2 "k8s.io/api/apps/v1beta2" + v1beta2 "k8s.io/client-go/applyconfigurations/apps/v1beta2" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type ReplicaSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, replicaSet, opts +func (_m *ReplicaSetInterface) Apply(ctx context.Context, replicaSet *v1beta2.ReplicaSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.ReplicaSet, error) { + ret := _m.Called(ctx, replicaSet, opts) + + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ReplicaSetApplyConfiguration, v1.ApplyOptions) *appsv1beta2.ReplicaSet); ok { + r0 = rf(ctx, replicaSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ReplicaSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, replicaSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, replicaSet, opts +func (_m *ReplicaSetInterface) ApplyStatus(ctx context.Context, replicaSet *v1beta2.ReplicaSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.ReplicaSet, error) { + ret := _m.Called(ctx, replicaSet, opts) + + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ReplicaSetApplyConfiguration, v1.ApplyOptions) *appsv1beta2.ReplicaSet); ok { + r0 = rf(ctx, replicaSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ReplicaSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, replicaSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) Create(ctx context.Context, replicaSet *v1beta2.ReplicaSet, opts v1.CreateOptions) (*v1beta2.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Create(ctx context.Context, replicaSet *appsv1beta2.ReplicaSet, opts v1.CreateOptions) (*appsv1beta2.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1beta2.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ReplicaSet, v1.CreateOptions) *v1beta2.ReplicaSet); ok { + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.ReplicaSet, v1.CreateOptions) *appsv1beta2.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ReplicaSet) + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ReplicaSet, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.ReplicaSet, v1.CreateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *ReplicaSetInterface) DeleteCollection(ctx context.Context, opts v1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta2.ReplicaSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta2.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta2.ReplicaSet); ok { + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta2.ReplicaSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ReplicaSet) + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) } } @@ -95,15 +144,15 @@ func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts v1.Get } // List provides a mock function with given fields: ctx, opts -func (_m *ReplicaSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta2.ReplicaSetList, error) { +func (_m *ReplicaSetInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta2.ReplicaSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta2.ReplicaSetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta2.ReplicaSetList); ok { + var r0 *appsv1beta2.ReplicaSetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta2.ReplicaSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ReplicaSetList) + r0 = ret.Get(0).(*appsv1beta2.ReplicaSetList) } } @@ -118,7 +167,7 @@ func (_m *ReplicaSetInterface) List(ctx context.Context, opts v1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta2.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta2.ReplicaSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta2.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta2.ReplicaSet); ok { + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta2.ReplicaSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ReplicaSet) + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) } } @@ -148,20 +197,20 @@ func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *v1beta2.ReplicaSet, opts v1.UpdateOptions) (*v1beta2.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *appsv1beta2.ReplicaSet, opts v1.UpdateOptions) (*appsv1beta2.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1beta2.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ReplicaSet, v1.UpdateOptions) *v1beta2.ReplicaSet); ok { + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.ReplicaSet, v1.UpdateOptions) *appsv1beta2.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ReplicaSet) + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ReplicaSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.ReplicaSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *v1beta2.R } // UpdateStatus provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) UpdateStatus(ctx context.Context, replicaSet *v1beta2.ReplicaSet, opts v1.UpdateOptions) (*v1beta2.ReplicaSet, error) { +func (_m *ReplicaSetInterface) UpdateStatus(ctx context.Context, replicaSet *appsv1beta2.ReplicaSet, opts v1.UpdateOptions) (*appsv1beta2.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1beta2.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.ReplicaSet, v1.UpdateOptions) *v1beta2.ReplicaSet); ok { + var r0 *appsv1beta2.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.ReplicaSet, v1.UpdateOptions) *appsv1beta2.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.ReplicaSet) + r0 = ret.Get(0).(*appsv1beta2.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.ReplicaSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.ReplicaSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/apps/v1beta2/stateful_set_interface.go b/testutil/kubernetes_mock/typed/apps/v1beta2/stateful_set_interface.go index 1db587bfde..0cbc4e26c3 100644 --- a/testutil/kubernetes_mock/typed/apps/v1beta2/stateful_set_interface.go +++ b/testutil/kubernetes_mock/typed/apps/v1beta2/stateful_set_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + appsv1beta2 "k8s.io/api/apps/v1beta2" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta2 "k8s.io/api/apps/v1beta2" + v1beta2 "k8s.io/client-go/applyconfigurations/apps/v1beta2" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type StatefulSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, statefulSet, opts +func (_m *StatefulSetInterface) Apply(ctx context.Context, statefulSet *v1beta2.StatefulSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.StatefulSet, error) { + ret := _m.Called(ctx, statefulSet, opts) + + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.StatefulSetApplyConfiguration, v1.ApplyOptions) *appsv1beta2.StatefulSet); ok { + r0 = rf(ctx, statefulSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.StatefulSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, statefulSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, statefulSet, opts +func (_m *StatefulSetInterface) ApplyStatus(ctx context.Context, statefulSet *v1beta2.StatefulSetApplyConfiguration, opts v1.ApplyOptions) (*appsv1beta2.StatefulSet, error) { + ret := _m.Called(ctx, statefulSet, opts) + + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.StatefulSetApplyConfiguration, v1.ApplyOptions) *appsv1beta2.StatefulSet); ok { + r0 = rf(ctx, statefulSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.StatefulSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, statefulSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) Create(ctx context.Context, statefulSet *v1beta2.StatefulSet, opts v1.CreateOptions) (*v1beta2.StatefulSet, error) { +func (_m *StatefulSetInterface) Create(ctx context.Context, statefulSet *appsv1beta2.StatefulSet, opts v1.CreateOptions) (*appsv1beta2.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1beta2.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.StatefulSet, v1.CreateOptions) *v1beta2.StatefulSet); ok { + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.StatefulSet, v1.CreateOptions) *appsv1beta2.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.StatefulSet) + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.StatefulSet, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.StatefulSet, v1.CreateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *StatefulSetInterface) DeleteCollection(ctx context.Context, opts v1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta2.StatefulSet, error) { +func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*appsv1beta2.StatefulSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta2.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta2.StatefulSet); ok { + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta2.StatefulSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.StatefulSet) + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) } } @@ -95,15 +144,15 @@ func (_m *StatefulSetInterface) Get(ctx context.Context, name string, opts v1.Ge } // GetScale provides a mock function with given fields: ctx, statefulSetName, options -func (_m *StatefulSetInterface) GetScale(ctx context.Context, statefulSetName string, options v1.GetOptions) (*v1beta2.Scale, error) { +func (_m *StatefulSetInterface) GetScale(ctx context.Context, statefulSetName string, options v1.GetOptions) (*appsv1beta2.Scale, error) { ret := _m.Called(ctx, statefulSetName, options) - var r0 *v1beta2.Scale - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta2.Scale); ok { + var r0 *appsv1beta2.Scale + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *appsv1beta2.Scale); ok { r0 = rf(ctx, statefulSetName, options) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Scale) + r0 = ret.Get(0).(*appsv1beta2.Scale) } } @@ -118,15 +167,15 @@ func (_m *StatefulSetInterface) GetScale(ctx context.Context, statefulSetName st } // List provides a mock function with given fields: ctx, opts -func (_m *StatefulSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta2.StatefulSetList, error) { +func (_m *StatefulSetInterface) List(ctx context.Context, opts v1.ListOptions) (*appsv1beta2.StatefulSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta2.StatefulSetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta2.StatefulSetList); ok { + var r0 *appsv1beta2.StatefulSetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *appsv1beta2.StatefulSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.StatefulSetList) + r0 = ret.Get(0).(*appsv1beta2.StatefulSetList) } } @@ -141,7 +190,7 @@ func (_m *StatefulSetInterface) List(ctx context.Context, opts v1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta2.StatefulSet, error) { +func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*appsv1beta2.StatefulSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -151,12 +200,12 @@ func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta2.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta2.StatefulSet); ok { + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *appsv1beta2.StatefulSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.StatefulSet) + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) } } @@ -171,20 +220,20 @@ func (_m *StatefulSetInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *v1beta2.StatefulSet, opts v1.UpdateOptions) (*v1beta2.StatefulSet, error) { +func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *appsv1beta2.StatefulSet, opts v1.UpdateOptions) (*appsv1beta2.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1beta2.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.StatefulSet, v1.UpdateOptions) *v1beta2.StatefulSet); ok { + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.StatefulSet, v1.UpdateOptions) *appsv1beta2.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.StatefulSet) + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.StatefulSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.StatefulSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) @@ -194,20 +243,20 @@ func (_m *StatefulSetInterface) Update(ctx context.Context, statefulSet *v1beta2 } // UpdateScale provides a mock function with given fields: ctx, statefulSetName, scale, opts -func (_m *StatefulSetInterface) UpdateScale(ctx context.Context, statefulSetName string, scale *v1beta2.Scale, opts v1.UpdateOptions) (*v1beta2.Scale, error) { +func (_m *StatefulSetInterface) UpdateScale(ctx context.Context, statefulSetName string, scale *appsv1beta2.Scale, opts v1.UpdateOptions) (*appsv1beta2.Scale, error) { ret := _m.Called(ctx, statefulSetName, scale, opts) - var r0 *v1beta2.Scale - if rf, ok := ret.Get(0).(func(context.Context, string, *v1beta2.Scale, v1.UpdateOptions) *v1beta2.Scale); ok { + var r0 *appsv1beta2.Scale + if rf, ok := ret.Get(0).(func(context.Context, string, *appsv1beta2.Scale, v1.UpdateOptions) *appsv1beta2.Scale); ok { r0 = rf(ctx, statefulSetName, scale, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.Scale) + r0 = ret.Get(0).(*appsv1beta2.Scale) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, *v1beta2.Scale, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, *appsv1beta2.Scale, v1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSetName, scale, opts) } else { r1 = ret.Error(1) @@ -217,20 +266,20 @@ func (_m *StatefulSetInterface) UpdateScale(ctx context.Context, statefulSetName } // UpdateStatus provides a mock function with given fields: ctx, statefulSet, opts -func (_m *StatefulSetInterface) UpdateStatus(ctx context.Context, statefulSet *v1beta2.StatefulSet, opts v1.UpdateOptions) (*v1beta2.StatefulSet, error) { +func (_m *StatefulSetInterface) UpdateStatus(ctx context.Context, statefulSet *appsv1beta2.StatefulSet, opts v1.UpdateOptions) (*appsv1beta2.StatefulSet, error) { ret := _m.Called(ctx, statefulSet, opts) - var r0 *v1beta2.StatefulSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta2.StatefulSet, v1.UpdateOptions) *v1beta2.StatefulSet); ok { + var r0 *appsv1beta2.StatefulSet + if rf, ok := ret.Get(0).(func(context.Context, *appsv1beta2.StatefulSet, v1.UpdateOptions) *appsv1beta2.StatefulSet); ok { r0 = rf(ctx, statefulSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta2.StatefulSet) + r0 = ret.Get(0).(*appsv1beta2.StatefulSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta2.StatefulSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *appsv1beta2.StatefulSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, statefulSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/autoscaling/v1/horizontal_pod_autoscaler_interface.go b/testutil/kubernetes_mock/typed/autoscaling/v1/horizontal_pod_autoscaler_interface.go index 094915f7b7..0082318629 100644 --- a/testutil/kubernetes_mock/typed/autoscaling/v1/horizontal_pod_autoscaler_interface.go +++ b/testutil/kubernetes_mock/typed/autoscaling/v1/horizontal_pod_autoscaler_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + autoscalingv1 "k8s.io/api/autoscaling/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/autoscaling/v1" + v1 "k8s.io/client-go/applyconfigurations/autoscaling/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type HorizontalPodAutoscalerInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts +func (_m *HorizontalPodAutoscalerInterface) Apply(ctx context.Context, horizontalPodAutoscaler *v1.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) { + ret := _m.Called(ctx, horizontalPodAutoscaler, opts) + + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *v1.HorizontalPodAutoscalerApplyConfiguration, metav1.ApplyOptions) *autoscalingv1.HorizontalPodAutoscaler); ok { + r0 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.HorizontalPodAutoscalerApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts +func (_m *HorizontalPodAutoscalerInterface) ApplyStatus(ctx context.Context, horizontalPodAutoscaler *v1.HorizontalPodAutoscalerApplyConfiguration, opts metav1.ApplyOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) { + ret := _m.Called(ctx, horizontalPodAutoscaler, opts) + + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *v1.HorizontalPodAutoscalerApplyConfiguration, metav1.ApplyOptions) *autoscalingv1.HorizontalPodAutoscaler); ok { + r0 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.HorizontalPodAutoscalerApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) Create(ctx context.Context, horizontalPodAutoscaler *v1.HorizontalPodAutoscaler, opts metav1.CreateOptions) (*v1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Create(ctx context.Context, horizontalPodAutoscaler *autoscalingv1.HorizontalPodAutoscaler, opts metav1.CreateOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v1.HorizontalPodAutoscaler, metav1.CreateOptions) *v1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv1.HorizontalPodAutoscaler, metav1.CreateOptions) *autoscalingv1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.HorizontalPodAutoscaler, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv1.HorizontalPodAutoscaler, metav1.CreateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *HorizontalPodAutoscalerInterface) DeleteCollection(ctx context.Context } // Get provides a mock function with given fields: ctx, name, opts -func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *autoscalingv1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) } } @@ -95,15 +144,15 @@ func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string } // List provides a mock function with given fields: ctx, opts -func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.HorizontalPodAutoscalerList, error) { +func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts metav1.ListOptions) (*autoscalingv1.HorizontalPodAutoscalerList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.HorizontalPodAutoscalerList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.HorizontalPodAutoscalerList); ok { + var r0 *autoscalingv1.HorizontalPodAutoscalerList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *autoscalingv1.HorizontalPodAutoscalerList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.HorizontalPodAutoscalerList) + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscalerList) } } @@ -118,7 +167,7 @@ func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts metav } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*autoscalingv1.HorizontalPodAutoscaler, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name stri _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *autoscalingv1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) } } @@ -148,20 +197,20 @@ func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name stri } // Update provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizontalPodAutoscaler *v1.HorizontalPodAutoscaler, opts metav1.UpdateOptions) (*v1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizontalPodAutoscaler *autoscalingv1.HorizontalPodAutoscaler, opts metav1.UpdateOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v1.HorizontalPodAutoscaler, metav1.UpdateOptions) *v1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv1.HorizontalPodAutoscaler, metav1.UpdateOptions) *autoscalingv1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.HorizontalPodAutoscaler, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv1.HorizontalPodAutoscaler, metav1.UpdateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizont } // UpdateStatus provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *v1.HorizontalPodAutoscaler, opts metav1.UpdateOptions) (*v1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *autoscalingv1.HorizontalPodAutoscaler, opts metav1.UpdateOptions) (*autoscalingv1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v1.HorizontalPodAutoscaler, metav1.UpdateOptions) *v1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv1.HorizontalPodAutoscaler, metav1.UpdateOptions) *autoscalingv1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv1.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.HorizontalPodAutoscaler, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv1.HorizontalPodAutoscaler, metav1.UpdateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/autoscaling/v2beta1/horizontal_pod_autoscaler_interface.go b/testutil/kubernetes_mock/typed/autoscaling/v2beta1/horizontal_pod_autoscaler_interface.go index a7f871a5c6..8af1ec2598 100644 --- a/testutil/kubernetes_mock/typed/autoscaling/v2beta1/horizontal_pod_autoscaler_interface.go +++ b/testutil/kubernetes_mock/typed/autoscaling/v2beta1/horizontal_pod_autoscaler_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + autoscalingv2beta1 "k8s.io/api/autoscaling/v2beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v2beta1 "k8s.io/api/autoscaling/v2beta1" + v2beta1 "k8s.io/client-go/applyconfigurations/autoscaling/v2beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type HorizontalPodAutoscalerInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts +func (_m *HorizontalPodAutoscalerInterface) Apply(ctx context.Context, horizontalPodAutoscaler *v2beta1.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { + ret := _m.Called(ctx, horizontalPodAutoscaler, opts) + + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *v2beta1.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { + r0 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v2beta1.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts +func (_m *HorizontalPodAutoscalerInterface) ApplyStatus(ctx context.Context, horizontalPodAutoscaler *v2beta1.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { + ret := _m.Called(ctx, horizontalPodAutoscaler, opts) + + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *v2beta1.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { + r0 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v2beta1.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) Create(ctx context.Context, horizontalPodAutoscaler *v2beta1.HorizontalPodAutoscaler, opts v1.CreateOptions) (*v2beta1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Create(ctx context.Context, horizontalPodAutoscaler *autoscalingv2beta1.HorizontalPodAutoscaler, opts v1.CreateOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v2beta1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v2beta1.HorizontalPodAutoscaler, v1.CreateOptions) *v2beta1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv2beta1.HorizontalPodAutoscaler, v1.CreateOptions) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2beta1.HorizontalPodAutoscaler, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv2beta1.HorizontalPodAutoscaler, v1.CreateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *HorizontalPodAutoscalerInterface) DeleteCollection(ctx context.Context } // Get provides a mock function with given fields: ctx, name, opts -func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v2beta1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, name, opts) - var r0 *v2beta1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v2beta1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) } } @@ -95,15 +144,15 @@ func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string } // List provides a mock function with given fields: ctx, opts -func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts v1.ListOptions) (*v2beta1.HorizontalPodAutoscalerList, error) { +func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts v1.ListOptions) (*autoscalingv2beta1.HorizontalPodAutoscalerList, error) { ret := _m.Called(ctx, opts) - var r0 *v2beta1.HorizontalPodAutoscalerList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v2beta1.HorizontalPodAutoscalerList); ok { + var r0 *autoscalingv2beta1.HorizontalPodAutoscalerList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *autoscalingv2beta1.HorizontalPodAutoscalerList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta1.HorizontalPodAutoscalerList) + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscalerList) } } @@ -118,7 +167,7 @@ func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts v1.Li } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v2beta1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name stri _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v2beta1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v2beta1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) } } @@ -148,20 +197,20 @@ func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name stri } // Update provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizontalPodAutoscaler *v2beta1.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*v2beta1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizontalPodAutoscaler *autoscalingv2beta1.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v2beta1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) *v2beta1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizont } // UpdateStatus provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *v2beta1.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*v2beta1.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *autoscalingv2beta1.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*autoscalingv2beta1.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v2beta1.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) *v2beta1.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta1.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) *autoscalingv2beta1.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta1.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta1.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv2beta1.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/autoscaling/v2beta2/horizontal_pod_autoscaler_interface.go b/testutil/kubernetes_mock/typed/autoscaling/v2beta2/horizontal_pod_autoscaler_interface.go index 9faf150cc8..6b327614c7 100644 --- a/testutil/kubernetes_mock/typed/autoscaling/v2beta2/horizontal_pod_autoscaler_interface.go +++ b/testutil/kubernetes_mock/typed/autoscaling/v2beta2/horizontal_pod_autoscaler_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + autoscalingv2beta2 "k8s.io/api/autoscaling/v2beta2" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v2beta2 "k8s.io/api/autoscaling/v2beta2" + v2beta2 "k8s.io/client-go/applyconfigurations/autoscaling/v2beta2" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type HorizontalPodAutoscalerInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts +func (_m *HorizontalPodAutoscalerInterface) Apply(ctx context.Context, horizontalPodAutoscaler *v2beta2.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { + ret := _m.Called(ctx, horizontalPodAutoscaler, opts) + + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *v2beta2.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { + r0 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v2beta2.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts +func (_m *HorizontalPodAutoscalerInterface) ApplyStatus(ctx context.Context, horizontalPodAutoscaler *v2beta2.HorizontalPodAutoscalerApplyConfiguration, opts v1.ApplyOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { + ret := _m.Called(ctx, horizontalPodAutoscaler, opts) + + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *v2beta2.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { + r0 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v2beta2.HorizontalPodAutoscalerApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, horizontalPodAutoscaler, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) Create(ctx context.Context, horizontalPodAutoscaler *v2beta2.HorizontalPodAutoscaler, opts v1.CreateOptions) (*v2beta2.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Create(ctx context.Context, horizontalPodAutoscaler *autoscalingv2beta2.HorizontalPodAutoscaler, opts v1.CreateOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v2beta2.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v2beta2.HorizontalPodAutoscaler, v1.CreateOptions) *v2beta2.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv2beta2.HorizontalPodAutoscaler, v1.CreateOptions) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta2.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2beta2.HorizontalPodAutoscaler, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv2beta2.HorizontalPodAutoscaler, v1.CreateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *HorizontalPodAutoscalerInterface) DeleteCollection(ctx context.Context } // Get provides a mock function with given fields: ctx, name, opts -func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v2beta2.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, name, opts) - var r0 *v2beta2.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v2beta2.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta2.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) } } @@ -95,15 +144,15 @@ func (_m *HorizontalPodAutoscalerInterface) Get(ctx context.Context, name string } // List provides a mock function with given fields: ctx, opts -func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts v1.ListOptions) (*v2beta2.HorizontalPodAutoscalerList, error) { +func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts v1.ListOptions) (*autoscalingv2beta2.HorizontalPodAutoscalerList, error) { ret := _m.Called(ctx, opts) - var r0 *v2beta2.HorizontalPodAutoscalerList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v2beta2.HorizontalPodAutoscalerList); ok { + var r0 *autoscalingv2beta2.HorizontalPodAutoscalerList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *autoscalingv2beta2.HorizontalPodAutoscalerList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta2.HorizontalPodAutoscalerList) + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscalerList) } } @@ -118,7 +167,7 @@ func (_m *HorizontalPodAutoscalerInterface) List(ctx context.Context, opts v1.Li } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v2beta2.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name stri _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v2beta2.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v2beta2.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta2.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) } } @@ -148,20 +197,20 @@ func (_m *HorizontalPodAutoscalerInterface) Patch(ctx context.Context, name stri } // Update provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizontalPodAutoscaler *v2beta2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*v2beta2.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizontalPodAutoscaler *autoscalingv2beta2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v2beta2.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) *v2beta2.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta2.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *HorizontalPodAutoscalerInterface) Update(ctx context.Context, horizont } // UpdateStatus provides a mock function with given fields: ctx, horizontalPodAutoscaler, opts -func (_m *HorizontalPodAutoscalerInterface) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *v2beta2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*v2beta2.HorizontalPodAutoscaler, error) { +func (_m *HorizontalPodAutoscalerInterface) UpdateStatus(ctx context.Context, horizontalPodAutoscaler *autoscalingv2beta2.HorizontalPodAutoscaler, opts v1.UpdateOptions) (*autoscalingv2beta2.HorizontalPodAutoscaler, error) { ret := _m.Called(ctx, horizontalPodAutoscaler, opts) - var r0 *v2beta2.HorizontalPodAutoscaler - if rf, ok := ret.Get(0).(func(context.Context, *v2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) *v2beta2.HorizontalPodAutoscaler); ok { + var r0 *autoscalingv2beta2.HorizontalPodAutoscaler + if rf, ok := ret.Get(0).(func(context.Context, *autoscalingv2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) *autoscalingv2beta2.HorizontalPodAutoscaler); ok { r0 = rf(ctx, horizontalPodAutoscaler, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2beta2.HorizontalPodAutoscaler) + r0 = ret.Get(0).(*autoscalingv2beta2.HorizontalPodAutoscaler) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *autoscalingv2beta2.HorizontalPodAutoscaler, v1.UpdateOptions) error); ok { r1 = rf(ctx, horizontalPodAutoscaler, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/batch/v1/batch_v1_interface.go b/testutil/kubernetes_mock/typed/batch/v1/batch_v1_interface.go index ab94745dc8..00ee40f3d5 100644 --- a/testutil/kubernetes_mock/typed/batch/v1/batch_v1_interface.go +++ b/testutil/kubernetes_mock/typed/batch/v1/batch_v1_interface.go @@ -14,6 +14,22 @@ type BatchV1Interface struct { mock.Mock } +// CronJobs provides a mock function with given fields: namespace +func (_m *BatchV1Interface) CronJobs(namespace string) v1.CronJobInterface { + ret := _m.Called(namespace) + + var r0 v1.CronJobInterface + if rf, ok := ret.Get(0).(func(string) v1.CronJobInterface); ok { + r0 = rf(namespace) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1.CronJobInterface) + } + } + + return r0 +} + // Jobs provides a mock function with given fields: namespace func (_m *BatchV1Interface) Jobs(namespace string) v1.JobInterface { ret := _m.Called(namespace) diff --git a/testutil/kubernetes_mock/typed/batch/v2alpha1/cron_job_expansion.go b/testutil/kubernetes_mock/typed/batch/v1/cron_job_expansion.go similarity index 100% rename from testutil/kubernetes_mock/typed/batch/v2alpha1/cron_job_expansion.go rename to testutil/kubernetes_mock/typed/batch/v1/cron_job_expansion.go diff --git a/testutil/kubernetes_mock/typed/batch/v1/cron_job_interface.go b/testutil/kubernetes_mock/typed/batch/v1/cron_job_interface.go new file mode 100644 index 0000000000..478e016d3d --- /dev/null +++ b/testutil/kubernetes_mock/typed/batch/v1/cron_job_interface.go @@ -0,0 +1,266 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + batchv1 "k8s.io/api/batch/v1" + + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + mock "github.com/stretchr/testify/mock" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/client-go/applyconfigurations/batch/v1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// CronJobInterface is an autogenerated mock type for the CronJobInterface type +type CronJobInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) Apply(ctx context.Context, cronJob *v1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (*batchv1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *v1.CronJobApplyConfiguration, metav1.ApplyOptions) *batchv1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.CronJobApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) ApplyStatus(ctx context.Context, cronJob *v1.CronJobApplyConfiguration, opts metav1.ApplyOptions) (*batchv1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *v1.CronJobApplyConfiguration, metav1.ApplyOptions) *batchv1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.CronJobApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) Create(ctx context.Context, cronJob *batchv1.CronJob, opts metav1.CreateOptions) (*batchv1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *batchv1.CronJob, metav1.CreateOptions) *batchv1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *batchv1.CronJob, metav1.CreateOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *CronJobInterface) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *CronJobInterface) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, metav1.DeleteOptions, metav1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *CronJobInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*batchv1.CronJob, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *batchv1.CronJob); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, metav1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *CronJobInterface) List(ctx context.Context, opts metav1.ListOptions) (*batchv1.CronJobList, error) { + ret := _m.Called(ctx, opts) + + var r0 *batchv1.CronJobList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *batchv1.CronJobList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJobList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *CronJobInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*batchv1.CronJob, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *batchv1.CronJob); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) Update(ctx context.Context, cronJob *batchv1.CronJob, opts metav1.UpdateOptions) (*batchv1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *batchv1.CronJob, metav1.UpdateOptions) *batchv1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *batchv1.CronJob, metav1.UpdateOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateStatus provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) UpdateStatus(ctx context.Context, cronJob *batchv1.CronJob, opts metav1.UpdateOptions) (*batchv1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *batchv1.CronJob, metav1.UpdateOptions) *batchv1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *batchv1.CronJob, metav1.UpdateOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *CronJobInterface) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/batch/v2alpha1/cron_jobs_getter.go b/testutil/kubernetes_mock/typed/batch/v1/cron_jobs_getter.go similarity index 58% rename from testutil/kubernetes_mock/typed/batch/v2alpha1/cron_jobs_getter.go rename to testutil/kubernetes_mock/typed/batch/v1/cron_jobs_getter.go index 9c7bfc3097..6f5b450706 100644 --- a/testutil/kubernetes_mock/typed/batch/v2alpha1/cron_jobs_getter.go +++ b/testutil/kubernetes_mock/typed/batch/v1/cron_jobs_getter.go @@ -4,7 +4,7 @@ package kubernetes_mocks import ( mock "github.com/stretchr/testify/mock" - v2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1" + v1 "k8s.io/client-go/kubernetes/typed/batch/v1" ) // CronJobsGetter is an autogenerated mock type for the CronJobsGetter type @@ -13,15 +13,15 @@ type CronJobsGetter struct { } // CronJobs provides a mock function with given fields: namespace -func (_m *CronJobsGetter) CronJobs(namespace string) v2alpha1.CronJobInterface { +func (_m *CronJobsGetter) CronJobs(namespace string) v1.CronJobInterface { ret := _m.Called(namespace) - var r0 v2alpha1.CronJobInterface - if rf, ok := ret.Get(0).(func(string) v2alpha1.CronJobInterface); ok { + var r0 v1.CronJobInterface + if rf, ok := ret.Get(0).(func(string) v1.CronJobInterface); ok { r0 = rf(namespace) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(v2alpha1.CronJobInterface) + r0 = ret.Get(0).(v1.CronJobInterface) } } diff --git a/testutil/kubernetes_mock/typed/batch/v1/job_interface.go b/testutil/kubernetes_mock/typed/batch/v1/job_interface.go index 5381310420..5712ea9704 100644 --- a/testutil/kubernetes_mock/typed/batch/v1/job_interface.go +++ b/testutil/kubernetes_mock/typed/batch/v1/job_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + batchv1 "k8s.io/api/batch/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/batch/v1" + v1 "k8s.io/client-go/applyconfigurations/batch/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type JobInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, job, opts +func (_m *JobInterface) Apply(ctx context.Context, job *v1.JobApplyConfiguration, opts metav1.ApplyOptions) (*batchv1.Job, error) { + ret := _m.Called(ctx, job, opts) + + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, *v1.JobApplyConfiguration, metav1.ApplyOptions) *batchv1.Job); ok { + r0 = rf(ctx, job, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.Job) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.JobApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, job, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, job, opts +func (_m *JobInterface) ApplyStatus(ctx context.Context, job *v1.JobApplyConfiguration, opts metav1.ApplyOptions) (*batchv1.Job, error) { + ret := _m.Called(ctx, job, opts) + + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, *v1.JobApplyConfiguration, metav1.ApplyOptions) *batchv1.Job); ok { + r0 = rf(ctx, job, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1.Job) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.JobApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, job, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, job, opts -func (_m *JobInterface) Create(ctx context.Context, job *v1.Job, opts metav1.CreateOptions) (*v1.Job, error) { +func (_m *JobInterface) Create(ctx context.Context, job *batchv1.Job, opts metav1.CreateOptions) (*batchv1.Job, error) { ret := _m.Called(ctx, job, opts) - var r0 *v1.Job - if rf, ok := ret.Get(0).(func(context.Context, *v1.Job, metav1.CreateOptions) *v1.Job); ok { + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, *batchv1.Job, metav1.CreateOptions) *batchv1.Job); ok { r0 = rf(ctx, job, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Job) + r0 = ret.Get(0).(*batchv1.Job) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Job, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *batchv1.Job, metav1.CreateOptions) error); ok { r1 = rf(ctx, job, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *JobInterface) DeleteCollection(ctx context.Context, opts metav1.Delete } // Get provides a mock function with given fields: ctx, name, opts -func (_m *JobInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Job, error) { +func (_m *JobInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*batchv1.Job, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Job - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Job); ok { + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *batchv1.Job); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Job) + r0 = ret.Get(0).(*batchv1.Job) } } @@ -95,15 +144,15 @@ func (_m *JobInterface) Get(ctx context.Context, name string, opts metav1.GetOpt } // List provides a mock function with given fields: ctx, opts -func (_m *JobInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.JobList, error) { +func (_m *JobInterface) List(ctx context.Context, opts metav1.ListOptions) (*batchv1.JobList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.JobList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.JobList); ok { + var r0 *batchv1.JobList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *batchv1.JobList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.JobList) + r0 = ret.Get(0).(*batchv1.JobList) } } @@ -118,7 +167,7 @@ func (_m *JobInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1. } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *JobInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Job, error) { +func (_m *JobInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*batchv1.Job, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *JobInterface) Patch(ctx context.Context, name string, pt types.PatchTy _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Job - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Job); ok { + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *batchv1.Job); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Job) + r0 = ret.Get(0).(*batchv1.Job) } } @@ -148,20 +197,20 @@ func (_m *JobInterface) Patch(ctx context.Context, name string, pt types.PatchTy } // Update provides a mock function with given fields: ctx, job, opts -func (_m *JobInterface) Update(ctx context.Context, job *v1.Job, opts metav1.UpdateOptions) (*v1.Job, error) { +func (_m *JobInterface) Update(ctx context.Context, job *batchv1.Job, opts metav1.UpdateOptions) (*batchv1.Job, error) { ret := _m.Called(ctx, job, opts) - var r0 *v1.Job - if rf, ok := ret.Get(0).(func(context.Context, *v1.Job, metav1.UpdateOptions) *v1.Job); ok { + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, *batchv1.Job, metav1.UpdateOptions) *batchv1.Job); ok { r0 = rf(ctx, job, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Job) + r0 = ret.Get(0).(*batchv1.Job) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Job, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *batchv1.Job, metav1.UpdateOptions) error); ok { r1 = rf(ctx, job, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *JobInterface) Update(ctx context.Context, job *v1.Job, opts metav1.Upd } // UpdateStatus provides a mock function with given fields: ctx, job, opts -func (_m *JobInterface) UpdateStatus(ctx context.Context, job *v1.Job, opts metav1.UpdateOptions) (*v1.Job, error) { +func (_m *JobInterface) UpdateStatus(ctx context.Context, job *batchv1.Job, opts metav1.UpdateOptions) (*batchv1.Job, error) { ret := _m.Called(ctx, job, opts) - var r0 *v1.Job - if rf, ok := ret.Get(0).(func(context.Context, *v1.Job, metav1.UpdateOptions) *v1.Job); ok { + var r0 *batchv1.Job + if rf, ok := ret.Get(0).(func(context.Context, *batchv1.Job, metav1.UpdateOptions) *batchv1.Job); ok { r0 = rf(ctx, job, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Job) + r0 = ret.Get(0).(*batchv1.Job) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Job, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *batchv1.Job, metav1.UpdateOptions) error); ok { r1 = rf(ctx, job, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/batch/v1beta1/cron_job_interface.go b/testutil/kubernetes_mock/typed/batch/v1beta1/cron_job_interface.go index ed2fec644d..f6fb9fa2ee 100644 --- a/testutil/kubernetes_mock/typed/batch/v1beta1/cron_job_interface.go +++ b/testutil/kubernetes_mock/typed/batch/v1beta1/cron_job_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + batchv1beta1 "k8s.io/api/batch/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/batch/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/batch/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type CronJobInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) Apply(ctx context.Context, cronJob *v1beta1.CronJobApplyConfiguration, opts v1.ApplyOptions) (*batchv1beta1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CronJobApplyConfiguration, v1.ApplyOptions) *batchv1beta1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1beta1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CronJobApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, cronJob, opts +func (_m *CronJobInterface) ApplyStatus(ctx context.Context, cronJob *v1beta1.CronJobApplyConfiguration, opts v1.ApplyOptions) (*batchv1beta1.CronJob, error) { + ret := _m.Called(ctx, cronJob, opts) + + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CronJobApplyConfiguration, v1.ApplyOptions) *batchv1beta1.CronJob); ok { + r0 = rf(ctx, cronJob, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*batchv1beta1.CronJob) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CronJobApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, cronJob, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, cronJob, opts -func (_m *CronJobInterface) Create(ctx context.Context, cronJob *v1beta1.CronJob, opts v1.CreateOptions) (*v1beta1.CronJob, error) { +func (_m *CronJobInterface) Create(ctx context.Context, cronJob *batchv1beta1.CronJob, opts v1.CreateOptions) (*batchv1beta1.CronJob, error) { ret := _m.Called(ctx, cronJob, opts) - var r0 *v1beta1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CronJob, v1.CreateOptions) *v1beta1.CronJob); ok { + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *batchv1beta1.CronJob, v1.CreateOptions) *batchv1beta1.CronJob); ok { r0 = rf(ctx, cronJob, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CronJob) + r0 = ret.Get(0).(*batchv1beta1.CronJob) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CronJob, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *batchv1beta1.CronJob, v1.CreateOptions) error); ok { r1 = rf(ctx, cronJob, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *CronJobInterface) DeleteCollection(ctx context.Context, opts v1.Delete } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CronJobInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.CronJob, error) { +func (_m *CronJobInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*batchv1beta1.CronJob, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.CronJob); ok { + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *batchv1beta1.CronJob); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CronJob) + r0 = ret.Get(0).(*batchv1beta1.CronJob) } } @@ -95,15 +144,15 @@ func (_m *CronJobInterface) Get(ctx context.Context, name string, opts v1.GetOpt } // List provides a mock function with given fields: ctx, opts -func (_m *CronJobInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.CronJobList, error) { +func (_m *CronJobInterface) List(ctx context.Context, opts v1.ListOptions) (*batchv1beta1.CronJobList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.CronJobList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.CronJobList); ok { + var r0 *batchv1beta1.CronJobList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *batchv1beta1.CronJobList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CronJobList) + r0 = ret.Get(0).(*batchv1beta1.CronJobList) } } @@ -118,7 +167,7 @@ func (_m *CronJobInterface) List(ctx context.Context, opts v1.ListOptions) (*v1b } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CronJobInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.CronJob, error) { +func (_m *CronJobInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*batchv1beta1.CronJob, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *CronJobInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.CronJob); ok { + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *batchv1beta1.CronJob); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CronJob) + r0 = ret.Get(0).(*batchv1beta1.CronJob) } } @@ -148,20 +197,20 @@ func (_m *CronJobInterface) Patch(ctx context.Context, name string, pt types.Pat } // Update provides a mock function with given fields: ctx, cronJob, opts -func (_m *CronJobInterface) Update(ctx context.Context, cronJob *v1beta1.CronJob, opts v1.UpdateOptions) (*v1beta1.CronJob, error) { +func (_m *CronJobInterface) Update(ctx context.Context, cronJob *batchv1beta1.CronJob, opts v1.UpdateOptions) (*batchv1beta1.CronJob, error) { ret := _m.Called(ctx, cronJob, opts) - var r0 *v1beta1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CronJob, v1.UpdateOptions) *v1beta1.CronJob); ok { + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *batchv1beta1.CronJob, v1.UpdateOptions) *batchv1beta1.CronJob); ok { r0 = rf(ctx, cronJob, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CronJob) + r0 = ret.Get(0).(*batchv1beta1.CronJob) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CronJob, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *batchv1beta1.CronJob, v1.UpdateOptions) error); ok { r1 = rf(ctx, cronJob, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *CronJobInterface) Update(ctx context.Context, cronJob *v1beta1.CronJob } // UpdateStatus provides a mock function with given fields: ctx, cronJob, opts -func (_m *CronJobInterface) UpdateStatus(ctx context.Context, cronJob *v1beta1.CronJob, opts v1.UpdateOptions) (*v1beta1.CronJob, error) { +func (_m *CronJobInterface) UpdateStatus(ctx context.Context, cronJob *batchv1beta1.CronJob, opts v1.UpdateOptions) (*batchv1beta1.CronJob, error) { ret := _m.Called(ctx, cronJob, opts) - var r0 *v1beta1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CronJob, v1.UpdateOptions) *v1beta1.CronJob); ok { + var r0 *batchv1beta1.CronJob + if rf, ok := ret.Get(0).(func(context.Context, *batchv1beta1.CronJob, v1.UpdateOptions) *batchv1beta1.CronJob); ok { r0 = rf(ctx, cronJob, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CronJob) + r0 = ret.Get(0).(*batchv1beta1.CronJob) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CronJob, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *batchv1beta1.CronJob, v1.UpdateOptions) error); ok { r1 = rf(ctx, cronJob, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/batch/v2alpha1/batch_v2alpha1_interface.go b/testutil/kubernetes_mock/typed/batch/v2alpha1/batch_v2alpha1_interface.go deleted file mode 100644 index 9d8bf9b458..0000000000 --- a/testutil/kubernetes_mock/typed/batch/v2alpha1/batch_v2alpha1_interface.go +++ /dev/null @@ -1,47 +0,0 @@ -// Code generated by mockery v2.5.1. DO NOT EDIT. - -package kubernetes_mocks - -import ( - mock "github.com/stretchr/testify/mock" - rest "k8s.io/client-go/rest" - - v2alpha1 "k8s.io/client-go/kubernetes/typed/batch/v2alpha1" -) - -// BatchV2alpha1Interface is an autogenerated mock type for the BatchV2alpha1Interface type -type BatchV2alpha1Interface struct { - mock.Mock -} - -// CronJobs provides a mock function with given fields: namespace -func (_m *BatchV2alpha1Interface) CronJobs(namespace string) v2alpha1.CronJobInterface { - ret := _m.Called(namespace) - - var r0 v2alpha1.CronJobInterface - if rf, ok := ret.Get(0).(func(string) v2alpha1.CronJobInterface); ok { - r0 = rf(namespace) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(v2alpha1.CronJobInterface) - } - } - - return r0 -} - -// RESTClient provides a mock function with given fields: -func (_m *BatchV2alpha1Interface) RESTClient() rest.Interface { - ret := _m.Called() - - var r0 rest.Interface - if rf, ok := ret.Get(0).(func() rest.Interface); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(rest.Interface) - } - } - - return r0 -} diff --git a/testutil/kubernetes_mock/typed/batch/v2alpha1/cron_job_interface.go b/testutil/kubernetes_mock/typed/batch/v2alpha1/cron_job_interface.go deleted file mode 100644 index 35fd519c13..0000000000 --- a/testutil/kubernetes_mock/typed/batch/v2alpha1/cron_job_interface.go +++ /dev/null @@ -1,217 +0,0 @@ -// Code generated by mockery v2.5.1. DO NOT EDIT. - -package kubernetes_mocks - -import ( - context "context" - - mock "github.com/stretchr/testify/mock" - types "k8s.io/apimachinery/pkg/types" - - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - v2alpha1 "k8s.io/api/batch/v2alpha1" - - watch "k8s.io/apimachinery/pkg/watch" -) - -// CronJobInterface is an autogenerated mock type for the CronJobInterface type -type CronJobInterface struct { - mock.Mock -} - -// Create provides a mock function with given fields: ctx, cronJob, opts -func (_m *CronJobInterface) Create(ctx context.Context, cronJob *v2alpha1.CronJob, opts v1.CreateOptions) (*v2alpha1.CronJob, error) { - ret := _m.Called(ctx, cronJob, opts) - - var r0 *v2alpha1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, *v2alpha1.CronJob, v1.CreateOptions) *v2alpha1.CronJob); ok { - r0 = rf(ctx, cronJob, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2alpha1.CronJob) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2alpha1.CronJob, v1.CreateOptions) error); ok { - r1 = rf(ctx, cronJob, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Delete provides a mock function with given fields: ctx, name, opts -func (_m *CronJobInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { - ret := _m.Called(ctx, name, opts) - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { - r0 = rf(ctx, name, opts) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts -func (_m *CronJobInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { - ret := _m.Called(ctx, opts, listOpts) - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { - r0 = rf(ctx, opts, listOpts) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// Get provides a mock function with given fields: ctx, name, opts -func (_m *CronJobInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v2alpha1.CronJob, error) { - ret := _m.Called(ctx, name, opts) - - var r0 *v2alpha1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v2alpha1.CronJob); ok { - r0 = rf(ctx, name, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2alpha1.CronJob) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { - r1 = rf(ctx, name, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// List provides a mock function with given fields: ctx, opts -func (_m *CronJobInterface) List(ctx context.Context, opts v1.ListOptions) (*v2alpha1.CronJobList, error) { - ret := _m.Called(ctx, opts) - - var r0 *v2alpha1.CronJobList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v2alpha1.CronJobList); ok { - r0 = rf(ctx, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2alpha1.CronJobList) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { - r1 = rf(ctx, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CronJobInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v2alpha1.CronJob, error) { - _va := make([]interface{}, len(subresources)) - for _i := range subresources { - _va[_i] = subresources[_i] - } - var _ca []interface{} - _ca = append(_ca, ctx, name, pt, data, opts) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - - var r0 *v2alpha1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v2alpha1.CronJob); ok { - r0 = rf(ctx, name, pt, data, opts, subresources...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2alpha1.CronJob) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { - r1 = rf(ctx, name, pt, data, opts, subresources...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Update provides a mock function with given fields: ctx, cronJob, opts -func (_m *CronJobInterface) Update(ctx context.Context, cronJob *v2alpha1.CronJob, opts v1.UpdateOptions) (*v2alpha1.CronJob, error) { - ret := _m.Called(ctx, cronJob, opts) - - var r0 *v2alpha1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, *v2alpha1.CronJob, v1.UpdateOptions) *v2alpha1.CronJob); ok { - r0 = rf(ctx, cronJob, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2alpha1.CronJob) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2alpha1.CronJob, v1.UpdateOptions) error); ok { - r1 = rf(ctx, cronJob, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// UpdateStatus provides a mock function with given fields: ctx, cronJob, opts -func (_m *CronJobInterface) UpdateStatus(ctx context.Context, cronJob *v2alpha1.CronJob, opts v1.UpdateOptions) (*v2alpha1.CronJob, error) { - ret := _m.Called(ctx, cronJob, opts) - - var r0 *v2alpha1.CronJob - if rf, ok := ret.Get(0).(func(context.Context, *v2alpha1.CronJob, v1.UpdateOptions) *v2alpha1.CronJob); ok { - r0 = rf(ctx, cronJob, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v2alpha1.CronJob) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v2alpha1.CronJob, v1.UpdateOptions) error); ok { - r1 = rf(ctx, cronJob, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Watch provides a mock function with given fields: ctx, opts -func (_m *CronJobInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { - ret := _m.Called(ctx, opts) - - var r0 watch.Interface - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { - r0 = rf(ctx, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(watch.Interface) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { - r1 = rf(ctx, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} diff --git a/testutil/kubernetes_mock/typed/certificates/v1/certificate_signing_request_interface.go b/testutil/kubernetes_mock/typed/certificates/v1/certificate_signing_request_interface.go index a4a6803287..024582e121 100644 --- a/testutil/kubernetes_mock/typed/certificates/v1/certificate_signing_request_interface.go +++ b/testutil/kubernetes_mock/typed/certificates/v1/certificate_signing_request_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" - mock "github.com/stretchr/testify/mock" + certificatesv1 "k8s.io/api/certificates/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/certificates/v1" + v1 "k8s.io/client-go/applyconfigurations/certificates/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type CertificateSigningRequestInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, certificateSigningRequest, opts +func (_m *CertificateSigningRequestInterface) Apply(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequestApplyConfiguration, opts metav1.ApplyOptions) (*certificatesv1.CertificateSigningRequest, error) { + ret := _m.Called(ctx, certificateSigningRequest, opts) + + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *v1.CertificateSigningRequestApplyConfiguration, metav1.ApplyOptions) *certificatesv1.CertificateSigningRequest); ok { + r0 = rf(ctx, certificateSigningRequest, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.CertificateSigningRequestApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, certificateSigningRequest, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, certificateSigningRequest, opts +func (_m *CertificateSigningRequestInterface) ApplyStatus(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequestApplyConfiguration, opts metav1.ApplyOptions) (*certificatesv1.CertificateSigningRequest, error) { + ret := _m.Called(ctx, certificateSigningRequest, opts) + + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *v1.CertificateSigningRequestApplyConfiguration, metav1.ApplyOptions) *certificatesv1.CertificateSigningRequest); ok { + r0 = rf(ctx, certificateSigningRequest, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.CertificateSigningRequestApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, certificateSigningRequest, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) Create(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.CreateOptions) (*v1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Create(ctx context.Context, certificateSigningRequest *certificatesv1.CertificateSigningRequest, opts metav1.CreateOptions) (*certificatesv1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1.CertificateSigningRequest, metav1.CreateOptions) *v1.CertificateSigningRequest); ok { + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1.CertificateSigningRequest, metav1.CreateOptions) *certificatesv1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CertificateSigningRequest, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1.CertificateSigningRequest, metav1.CreateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *CertificateSigningRequestInterface) DeleteCollection(ctx context.Conte } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CertificateSigningRequestInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*certificatesv1.CertificateSigningRequest, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.CertificateSigningRequest); ok { + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *certificatesv1.CertificateSigningRequest); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) } } @@ -95,15 +144,15 @@ func (_m *CertificateSigningRequestInterface) Get(ctx context.Context, name stri } // List provides a mock function with given fields: ctx, opts -func (_m *CertificateSigningRequestInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.CertificateSigningRequestList, error) { +func (_m *CertificateSigningRequestInterface) List(ctx context.Context, opts metav1.ListOptions) (*certificatesv1.CertificateSigningRequestList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.CertificateSigningRequestList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.CertificateSigningRequestList); ok { + var r0 *certificatesv1.CertificateSigningRequestList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *certificatesv1.CertificateSigningRequestList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequestList) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequestList) } } @@ -118,7 +167,7 @@ func (_m *CertificateSigningRequestInterface) List(ctx context.Context, opts met } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*certificatesv1.CertificateSigningRequest, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name st _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.CertificateSigningRequest); ok { + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *certificatesv1.CertificateSigningRequest); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) } } @@ -148,20 +197,20 @@ func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name st } // Update provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) Update(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (*v1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Update(ctx context.Context, certificateSigningRequest *certificatesv1.CertificateSigningRequest, opts metav1.UpdateOptions) (*certificatesv1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1.CertificateSigningRequest, metav1.UpdateOptions) *v1.CertificateSigningRequest); ok { + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1.CertificateSigningRequest, metav1.UpdateOptions) *certificatesv1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CertificateSigningRequest, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1.CertificateSigningRequest, metav1.UpdateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *CertificateSigningRequestInterface) Update(ctx context.Context, certif } // UpdateApproval provides a mock function with given fields: ctx, certificateSigningRequestName, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) UpdateApproval(ctx context.Context, certificateSigningRequestName string, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (*v1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) UpdateApproval(ctx context.Context, certificateSigningRequestName string, certificateSigningRequest *certificatesv1.CertificateSigningRequest, opts metav1.UpdateOptions) (*certificatesv1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequestName, certificateSigningRequest, opts) - var r0 *v1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, string, *v1.CertificateSigningRequest, metav1.UpdateOptions) *v1.CertificateSigningRequest); ok { + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, string, *certificatesv1.CertificateSigningRequest, metav1.UpdateOptions) *certificatesv1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequestName, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, *v1.CertificateSigningRequest, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, *certificatesv1.CertificateSigningRequest, metav1.UpdateOptions) error); ok { r1 = rf(ctx, certificateSigningRequestName, certificateSigningRequest, opts) } else { r1 = ret.Error(1) @@ -194,20 +243,20 @@ func (_m *CertificateSigningRequestInterface) UpdateApproval(ctx context.Context } // UpdateStatus provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) UpdateStatus(ctx context.Context, certificateSigningRequest *v1.CertificateSigningRequest, opts metav1.UpdateOptions) (*v1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) UpdateStatus(ctx context.Context, certificateSigningRequest *certificatesv1.CertificateSigningRequest, opts metav1.UpdateOptions) (*certificatesv1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1.CertificateSigningRequest, metav1.UpdateOptions) *v1.CertificateSigningRequest); ok { + var r0 *certificatesv1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1.CertificateSigningRequest, metav1.UpdateOptions) *certificatesv1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CertificateSigningRequest, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1.CertificateSigningRequest, metav1.UpdateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/certificates/v1beta1/certificate_signing_request_interface.go b/testutil/kubernetes_mock/typed/certificates/v1beta1/certificate_signing_request_interface.go index 952711d50e..87e4ec88e0 100644 --- a/testutil/kubernetes_mock/typed/certificates/v1beta1/certificate_signing_request_interface.go +++ b/testutil/kubernetes_mock/typed/certificates/v1beta1/certificate_signing_request_interface.go @@ -5,12 +5,15 @@ package kubernetes_mocks import ( context "context" + certificatesv1beta1 "k8s.io/api/certificates/v1beta1" + mock "github.com/stretchr/testify/mock" + types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/certificates/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/certificates/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +23,67 @@ type CertificateSigningRequestInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, certificateSigningRequest, opts +func (_m *CertificateSigningRequestInterface) Apply(ctx context.Context, certificateSigningRequest *v1beta1.CertificateSigningRequestApplyConfiguration, opts v1.ApplyOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { + ret := _m.Called(ctx, certificateSigningRequest, opts) + + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CertificateSigningRequestApplyConfiguration, v1.ApplyOptions) *certificatesv1beta1.CertificateSigningRequest); ok { + r0 = rf(ctx, certificateSigningRequest, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CertificateSigningRequestApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, certificateSigningRequest, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, certificateSigningRequest, opts +func (_m *CertificateSigningRequestInterface) ApplyStatus(ctx context.Context, certificateSigningRequest *v1beta1.CertificateSigningRequestApplyConfiguration, opts v1.ApplyOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { + ret := _m.Called(ctx, certificateSigningRequest, opts) + + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CertificateSigningRequestApplyConfiguration, v1.ApplyOptions) *certificatesv1beta1.CertificateSigningRequest); ok { + r0 = rf(ctx, certificateSigningRequest, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CertificateSigningRequestApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, certificateSigningRequest, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) Create(ctx context.Context, certificateSigningRequest *v1beta1.CertificateSigningRequest, opts v1.CreateOptions) (*v1beta1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Create(ctx context.Context, certificateSigningRequest *certificatesv1beta1.CertificateSigningRequest, opts v1.CreateOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1beta1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.CreateOptions) *v1beta1.CertificateSigningRequest); ok { + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.CreateOptions) *certificatesv1beta1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.CreateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) @@ -72,15 +121,15 @@ func (_m *CertificateSigningRequestInterface) DeleteCollection(ctx context.Conte } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CertificateSigningRequestInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.CertificateSigningRequest); ok { + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *certificatesv1beta1.CertificateSigningRequest); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) } } @@ -95,15 +144,15 @@ func (_m *CertificateSigningRequestInterface) Get(ctx context.Context, name stri } // List provides a mock function with given fields: ctx, opts -func (_m *CertificateSigningRequestInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.CertificateSigningRequestList, error) { +func (_m *CertificateSigningRequestInterface) List(ctx context.Context, opts v1.ListOptions) (*certificatesv1beta1.CertificateSigningRequestList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.CertificateSigningRequestList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.CertificateSigningRequestList); ok { + var r0 *certificatesv1beta1.CertificateSigningRequestList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *certificatesv1beta1.CertificateSigningRequestList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequestList) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequestList) } } @@ -118,7 +167,7 @@ func (_m *CertificateSigningRequestInterface) List(ctx context.Context, opts v1. } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*certificatesv1beta1.CertificateSigningRequest, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +177,12 @@ func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name st _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.CertificateSigningRequest); ok { + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *certificatesv1beta1.CertificateSigningRequest); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) } } @@ -148,20 +197,20 @@ func (_m *CertificateSigningRequestInterface) Patch(ctx context.Context, name st } // Update provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) Update(ctx context.Context, certificateSigningRequest *v1beta1.CertificateSigningRequest, opts v1.UpdateOptions) (*v1beta1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) Update(ctx context.Context, certificateSigningRequest *certificatesv1beta1.CertificateSigningRequest, opts v1.UpdateOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1beta1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.UpdateOptions) *v1beta1.CertificateSigningRequest); ok { + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.UpdateOptions) *certificatesv1beta1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.UpdateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) @@ -171,20 +220,20 @@ func (_m *CertificateSigningRequestInterface) Update(ctx context.Context, certif } // UpdateApproval provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) UpdateApproval(ctx context.Context, certificateSigningRequest *v1beta1.CertificateSigningRequest, opts v1.UpdateOptions) (*v1beta1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) UpdateApproval(ctx context.Context, certificateSigningRequest *certificatesv1beta1.CertificateSigningRequest, opts v1.UpdateOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1beta1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.UpdateOptions) *v1beta1.CertificateSigningRequest); ok { + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.UpdateOptions) *certificatesv1beta1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.UpdateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) @@ -194,20 +243,20 @@ func (_m *CertificateSigningRequestInterface) UpdateApproval(ctx context.Context } // UpdateStatus provides a mock function with given fields: ctx, certificateSigningRequest, opts -func (_m *CertificateSigningRequestInterface) UpdateStatus(ctx context.Context, certificateSigningRequest *v1beta1.CertificateSigningRequest, opts v1.UpdateOptions) (*v1beta1.CertificateSigningRequest, error) { +func (_m *CertificateSigningRequestInterface) UpdateStatus(ctx context.Context, certificateSigningRequest *certificatesv1beta1.CertificateSigningRequest, opts v1.UpdateOptions) (*certificatesv1beta1.CertificateSigningRequest, error) { ret := _m.Called(ctx, certificateSigningRequest, opts) - var r0 *v1beta1.CertificateSigningRequest - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.UpdateOptions) *v1beta1.CertificateSigningRequest); ok { + var r0 *certificatesv1beta1.CertificateSigningRequest + if rf, ok := ret.Get(0).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.UpdateOptions) *certificatesv1beta1.CertificateSigningRequest); ok { r0 = rf(ctx, certificateSigningRequest, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CertificateSigningRequest) + r0 = ret.Get(0).(*certificatesv1beta1.CertificateSigningRequest) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CertificateSigningRequest, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *certificatesv1beta1.CertificateSigningRequest, v1.UpdateOptions) error); ok { r1 = rf(ctx, certificateSigningRequest, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/coordination/v1/lease_interface.go b/testutil/kubernetes_mock/typed/coordination/v1/lease_interface.go index 62e1880a54..6b8625bbf1 100644 --- a/testutil/kubernetes_mock/typed/coordination/v1/lease_interface.go +++ b/testutil/kubernetes_mock/typed/coordination/v1/lease_interface.go @@ -5,13 +5,14 @@ package kubernetes_mocks import ( context "context" + coordinationv1 "k8s.io/api/coordination/v1" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/coordination/v1" + v1 "k8s.io/client-go/applyconfigurations/coordination/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type LeaseInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, lease, opts +func (_m *LeaseInterface) Apply(ctx context.Context, lease *v1.LeaseApplyConfiguration, opts metav1.ApplyOptions) (*coordinationv1.Lease, error) { + ret := _m.Called(ctx, lease, opts) + + var r0 *coordinationv1.Lease + if rf, ok := ret.Get(0).(func(context.Context, *v1.LeaseApplyConfiguration, metav1.ApplyOptions) *coordinationv1.Lease); ok { + r0 = rf(ctx, lease, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*coordinationv1.Lease) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.LeaseApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, lease, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, lease, opts -func (_m *LeaseInterface) Create(ctx context.Context, lease *v1.Lease, opts metav1.CreateOptions) (*v1.Lease, error) { +func (_m *LeaseInterface) Create(ctx context.Context, lease *coordinationv1.Lease, opts metav1.CreateOptions) (*coordinationv1.Lease, error) { ret := _m.Called(ctx, lease, opts) - var r0 *v1.Lease - if rf, ok := ret.Get(0).(func(context.Context, *v1.Lease, metav1.CreateOptions) *v1.Lease); ok { + var r0 *coordinationv1.Lease + if rf, ok := ret.Get(0).(func(context.Context, *coordinationv1.Lease, metav1.CreateOptions) *coordinationv1.Lease); ok { r0 = rf(ctx, lease, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Lease) + r0 = ret.Get(0).(*coordinationv1.Lease) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Lease, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *coordinationv1.Lease, metav1.CreateOptions) error); ok { r1 = rf(ctx, lease, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *LeaseInterface) DeleteCollection(ctx context.Context, opts metav1.Dele } // Get provides a mock function with given fields: ctx, name, opts -func (_m *LeaseInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Lease, error) { +func (_m *LeaseInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*coordinationv1.Lease, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Lease - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Lease); ok { + var r0 *coordinationv1.Lease + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *coordinationv1.Lease); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Lease) + r0 = ret.Get(0).(*coordinationv1.Lease) } } @@ -96,15 +120,15 @@ func (_m *LeaseInterface) Get(ctx context.Context, name string, opts metav1.GetO } // List provides a mock function with given fields: ctx, opts -func (_m *LeaseInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.LeaseList, error) { +func (_m *LeaseInterface) List(ctx context.Context, opts metav1.ListOptions) (*coordinationv1.LeaseList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.LeaseList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.LeaseList); ok { + var r0 *coordinationv1.LeaseList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *coordinationv1.LeaseList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.LeaseList) + r0 = ret.Get(0).(*coordinationv1.LeaseList) } } @@ -119,7 +143,7 @@ func (_m *LeaseInterface) List(ctx context.Context, opts metav1.ListOptions) (*v } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Lease, error) { +func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*coordinationv1.Lease, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.Patch _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Lease - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Lease); ok { + var r0 *coordinationv1.Lease + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *coordinationv1.Lease); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Lease) + r0 = ret.Get(0).(*coordinationv1.Lease) } } @@ -149,20 +173,20 @@ func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.Patch } // Update provides a mock function with given fields: ctx, lease, opts -func (_m *LeaseInterface) Update(ctx context.Context, lease *v1.Lease, opts metav1.UpdateOptions) (*v1.Lease, error) { +func (_m *LeaseInterface) Update(ctx context.Context, lease *coordinationv1.Lease, opts metav1.UpdateOptions) (*coordinationv1.Lease, error) { ret := _m.Called(ctx, lease, opts) - var r0 *v1.Lease - if rf, ok := ret.Get(0).(func(context.Context, *v1.Lease, metav1.UpdateOptions) *v1.Lease); ok { + var r0 *coordinationv1.Lease + if rf, ok := ret.Get(0).(func(context.Context, *coordinationv1.Lease, metav1.UpdateOptions) *coordinationv1.Lease); ok { r0 = rf(ctx, lease, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Lease) + r0 = ret.Get(0).(*coordinationv1.Lease) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Lease, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *coordinationv1.Lease, metav1.UpdateOptions) error); ok { r1 = rf(ctx, lease, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/coordination/v1beta1/lease_interface.go b/testutil/kubernetes_mock/typed/coordination/v1beta1/lease_interface.go index 95155ffdf4..70d0fe5307 100644 --- a/testutil/kubernetes_mock/typed/coordination/v1beta1/lease_interface.go +++ b/testutil/kubernetes_mock/typed/coordination/v1beta1/lease_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + coordinationv1beta1 "k8s.io/api/coordination/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/coordination/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/coordination/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type LeaseInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, lease, opts +func (_m *LeaseInterface) Apply(ctx context.Context, lease *v1beta1.LeaseApplyConfiguration, opts v1.ApplyOptions) (*coordinationv1beta1.Lease, error) { + ret := _m.Called(ctx, lease, opts) + + var r0 *coordinationv1beta1.Lease + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.LeaseApplyConfiguration, v1.ApplyOptions) *coordinationv1beta1.Lease); ok { + r0 = rf(ctx, lease, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*coordinationv1beta1.Lease) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.LeaseApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, lease, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, lease, opts -func (_m *LeaseInterface) Create(ctx context.Context, lease *v1beta1.Lease, opts v1.CreateOptions) (*v1beta1.Lease, error) { +func (_m *LeaseInterface) Create(ctx context.Context, lease *coordinationv1beta1.Lease, opts v1.CreateOptions) (*coordinationv1beta1.Lease, error) { ret := _m.Called(ctx, lease, opts) - var r0 *v1beta1.Lease - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Lease, v1.CreateOptions) *v1beta1.Lease); ok { + var r0 *coordinationv1beta1.Lease + if rf, ok := ret.Get(0).(func(context.Context, *coordinationv1beta1.Lease, v1.CreateOptions) *coordinationv1beta1.Lease); ok { r0 = rf(ctx, lease, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Lease) + r0 = ret.Get(0).(*coordinationv1beta1.Lease) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Lease, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *coordinationv1beta1.Lease, v1.CreateOptions) error); ok { r1 = rf(ctx, lease, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *LeaseInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOp } // Get provides a mock function with given fields: ctx, name, opts -func (_m *LeaseInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Lease, error) { +func (_m *LeaseInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*coordinationv1beta1.Lease, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Lease - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Lease); ok { + var r0 *coordinationv1beta1.Lease + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *coordinationv1beta1.Lease); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Lease) + r0 = ret.Get(0).(*coordinationv1beta1.Lease) } } @@ -96,15 +120,15 @@ func (_m *LeaseInterface) Get(ctx context.Context, name string, opts v1.GetOptio } // List provides a mock function with given fields: ctx, opts -func (_m *LeaseInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.LeaseList, error) { +func (_m *LeaseInterface) List(ctx context.Context, opts v1.ListOptions) (*coordinationv1beta1.LeaseList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.LeaseList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.LeaseList); ok { + var r0 *coordinationv1beta1.LeaseList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *coordinationv1beta1.LeaseList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.LeaseList) + r0 = ret.Get(0).(*coordinationv1beta1.LeaseList) } } @@ -119,7 +143,7 @@ func (_m *LeaseInterface) List(ctx context.Context, opts v1.ListOptions) (*v1bet } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Lease, error) { +func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*coordinationv1beta1.Lease, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.Patch _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Lease - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Lease); ok { + var r0 *coordinationv1beta1.Lease + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *coordinationv1beta1.Lease); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Lease) + r0 = ret.Get(0).(*coordinationv1beta1.Lease) } } @@ -149,20 +173,20 @@ func (_m *LeaseInterface) Patch(ctx context.Context, name string, pt types.Patch } // Update provides a mock function with given fields: ctx, lease, opts -func (_m *LeaseInterface) Update(ctx context.Context, lease *v1beta1.Lease, opts v1.UpdateOptions) (*v1beta1.Lease, error) { +func (_m *LeaseInterface) Update(ctx context.Context, lease *coordinationv1beta1.Lease, opts v1.UpdateOptions) (*coordinationv1beta1.Lease, error) { ret := _m.Called(ctx, lease, opts) - var r0 *v1beta1.Lease - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Lease, v1.UpdateOptions) *v1beta1.Lease); ok { + var r0 *coordinationv1beta1.Lease + if rf, ok := ret.Get(0).(func(context.Context, *coordinationv1beta1.Lease, v1.UpdateOptions) *coordinationv1beta1.Lease); ok { r0 = rf(ctx, lease, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Lease) + r0 = ret.Get(0).(*coordinationv1beta1.Lease) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Lease, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *coordinationv1beta1.Lease, v1.UpdateOptions) error); ok { r1 = rf(ctx, lease, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/component_status_interface.go b/testutil/kubernetes_mock/typed/core/v1/component_status_interface.go index cd0c2b34a2..15d6da3616 100644 --- a/testutil/kubernetes_mock/typed/core/v1/component_status_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/component_status_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type ComponentStatusInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, componentStatus, opts +func (_m *ComponentStatusInterface) Apply(ctx context.Context, componentStatus *v1.ComponentStatusApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ComponentStatus, error) { + ret := _m.Called(ctx, componentStatus, opts) + + var r0 *corev1.ComponentStatus + if rf, ok := ret.Get(0).(func(context.Context, *v1.ComponentStatusApplyConfiguration, metav1.ApplyOptions) *corev1.ComponentStatus); ok { + r0 = rf(ctx, componentStatus, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ComponentStatus) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ComponentStatusApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, componentStatus, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, componentStatus, opts -func (_m *ComponentStatusInterface) Create(ctx context.Context, componentStatus *v1.ComponentStatus, opts metav1.CreateOptions) (*v1.ComponentStatus, error) { +func (_m *ComponentStatusInterface) Create(ctx context.Context, componentStatus *corev1.ComponentStatus, opts metav1.CreateOptions) (*corev1.ComponentStatus, error) { ret := _m.Called(ctx, componentStatus, opts) - var r0 *v1.ComponentStatus - if rf, ok := ret.Get(0).(func(context.Context, *v1.ComponentStatus, metav1.CreateOptions) *v1.ComponentStatus); ok { + var r0 *corev1.ComponentStatus + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ComponentStatus, metav1.CreateOptions) *corev1.ComponentStatus); ok { r0 = rf(ctx, componentStatus, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ComponentStatus) + r0 = ret.Get(0).(*corev1.ComponentStatus) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ComponentStatus, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ComponentStatus, metav1.CreateOptions) error); ok { r1 = rf(ctx, componentStatus, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *ComponentStatusInterface) DeleteCollection(ctx context.Context, opts m } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ComponentStatusInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ComponentStatus, error) { +func (_m *ComponentStatusInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.ComponentStatus, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ComponentStatus - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ComponentStatus); ok { + var r0 *corev1.ComponentStatus + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.ComponentStatus); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ComponentStatus) + r0 = ret.Get(0).(*corev1.ComponentStatus) } } @@ -96,15 +121,15 @@ func (_m *ComponentStatusInterface) Get(ctx context.Context, name string, opts m } // List provides a mock function with given fields: ctx, opts -func (_m *ComponentStatusInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ComponentStatusList, error) { +func (_m *ComponentStatusInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ComponentStatusList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ComponentStatusList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ComponentStatusList); ok { + var r0 *corev1.ComponentStatusList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ComponentStatusList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ComponentStatusList) + r0 = ret.Get(0).(*corev1.ComponentStatusList) } } @@ -119,7 +144,7 @@ func (_m *ComponentStatusInterface) List(ctx context.Context, opts metav1.ListOp } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ComponentStatusInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ComponentStatus, error) { +func (_m *ComponentStatusInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.ComponentStatus, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *ComponentStatusInterface) Patch(ctx context.Context, name string, pt t _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ComponentStatus - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ComponentStatus); ok { + var r0 *corev1.ComponentStatus + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.ComponentStatus); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ComponentStatus) + r0 = ret.Get(0).(*corev1.ComponentStatus) } } @@ -149,20 +174,20 @@ func (_m *ComponentStatusInterface) Patch(ctx context.Context, name string, pt t } // Update provides a mock function with given fields: ctx, componentStatus, opts -func (_m *ComponentStatusInterface) Update(ctx context.Context, componentStatus *v1.ComponentStatus, opts metav1.UpdateOptions) (*v1.ComponentStatus, error) { +func (_m *ComponentStatusInterface) Update(ctx context.Context, componentStatus *corev1.ComponentStatus, opts metav1.UpdateOptions) (*corev1.ComponentStatus, error) { ret := _m.Called(ctx, componentStatus, opts) - var r0 *v1.ComponentStatus - if rf, ok := ret.Get(0).(func(context.Context, *v1.ComponentStatus, metav1.UpdateOptions) *v1.ComponentStatus); ok { + var r0 *corev1.ComponentStatus + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ComponentStatus, metav1.UpdateOptions) *corev1.ComponentStatus); ok { r0 = rf(ctx, componentStatus, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ComponentStatus) + r0 = ret.Get(0).(*corev1.ComponentStatus) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ComponentStatus, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ComponentStatus, metav1.UpdateOptions) error); ok { r1 = rf(ctx, componentStatus, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/config_map_interface.go b/testutil/kubernetes_mock/typed/core/v1/config_map_interface.go index 4938a3582c..87bf3556b5 100644 --- a/testutil/kubernetes_mock/typed/core/v1/config_map_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/config_map_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type ConfigMapInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, configMap, opts +func (_m *ConfigMapInterface) Apply(ctx context.Context, configMap *v1.ConfigMapApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ConfigMap, error) { + ret := _m.Called(ctx, configMap, opts) + + var r0 *corev1.ConfigMap + if rf, ok := ret.Get(0).(func(context.Context, *v1.ConfigMapApplyConfiguration, metav1.ApplyOptions) *corev1.ConfigMap); ok { + r0 = rf(ctx, configMap, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ConfigMap) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ConfigMapApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, configMap, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, configMap, opts -func (_m *ConfigMapInterface) Create(ctx context.Context, configMap *v1.ConfigMap, opts metav1.CreateOptions) (*v1.ConfigMap, error) { +func (_m *ConfigMapInterface) Create(ctx context.Context, configMap *corev1.ConfigMap, opts metav1.CreateOptions) (*corev1.ConfigMap, error) { ret := _m.Called(ctx, configMap, opts) - var r0 *v1.ConfigMap - if rf, ok := ret.Get(0).(func(context.Context, *v1.ConfigMap, metav1.CreateOptions) *v1.ConfigMap); ok { + var r0 *corev1.ConfigMap + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ConfigMap, metav1.CreateOptions) *corev1.ConfigMap); ok { r0 = rf(ctx, configMap, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ConfigMap) + r0 = ret.Get(0).(*corev1.ConfigMap) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ConfigMap, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ConfigMap, metav1.CreateOptions) error); ok { r1 = rf(ctx, configMap, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *ConfigMapInterface) DeleteCollection(ctx context.Context, opts metav1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ConfigMapInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ConfigMap, error) { +func (_m *ConfigMapInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.ConfigMap, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ConfigMap - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ConfigMap); ok { + var r0 *corev1.ConfigMap + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.ConfigMap); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ConfigMap) + r0 = ret.Get(0).(*corev1.ConfigMap) } } @@ -96,15 +121,15 @@ func (_m *ConfigMapInterface) Get(ctx context.Context, name string, opts metav1. } // List provides a mock function with given fields: ctx, opts -func (_m *ConfigMapInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ConfigMapList, error) { +func (_m *ConfigMapInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ConfigMapList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ConfigMapList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ConfigMapList); ok { + var r0 *corev1.ConfigMapList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ConfigMapList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ConfigMapList) + r0 = ret.Get(0).(*corev1.ConfigMapList) } } @@ -119,7 +144,7 @@ func (_m *ConfigMapInterface) List(ctx context.Context, opts metav1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ConfigMapInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ConfigMap, error) { +func (_m *ConfigMapInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.ConfigMap, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *ConfigMapInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ConfigMap - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ConfigMap); ok { + var r0 *corev1.ConfigMap + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.ConfigMap); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ConfigMap) + r0 = ret.Get(0).(*corev1.ConfigMap) } } @@ -149,20 +174,20 @@ func (_m *ConfigMapInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, configMap, opts -func (_m *ConfigMapInterface) Update(ctx context.Context, configMap *v1.ConfigMap, opts metav1.UpdateOptions) (*v1.ConfigMap, error) { +func (_m *ConfigMapInterface) Update(ctx context.Context, configMap *corev1.ConfigMap, opts metav1.UpdateOptions) (*corev1.ConfigMap, error) { ret := _m.Called(ctx, configMap, opts) - var r0 *v1.ConfigMap - if rf, ok := ret.Get(0).(func(context.Context, *v1.ConfigMap, metav1.UpdateOptions) *v1.ConfigMap); ok { + var r0 *corev1.ConfigMap + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ConfigMap, metav1.UpdateOptions) *corev1.ConfigMap); ok { r0 = rf(ctx, configMap, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ConfigMap) + r0 = ret.Get(0).(*corev1.ConfigMap) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ConfigMap, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ConfigMap, metav1.UpdateOptions) error); ok { r1 = rf(ctx, configMap, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/endpoints_interface.go b/testutil/kubernetes_mock/typed/core/v1/endpoints_interface.go index dd030a714f..c36d44c17d 100644 --- a/testutil/kubernetes_mock/typed/core/v1/endpoints_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/endpoints_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type EndpointsInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, endpoints, opts +func (_m *EndpointsInterface) Apply(ctx context.Context, endpoints *v1.EndpointsApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Endpoints, error) { + ret := _m.Called(ctx, endpoints, opts) + + var r0 *corev1.Endpoints + if rf, ok := ret.Get(0).(func(context.Context, *v1.EndpointsApplyConfiguration, metav1.ApplyOptions) *corev1.Endpoints); ok { + r0 = rf(ctx, endpoints, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Endpoints) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.EndpointsApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, endpoints, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, endpoints, opts -func (_m *EndpointsInterface) Create(ctx context.Context, endpoints *v1.Endpoints, opts metav1.CreateOptions) (*v1.Endpoints, error) { +func (_m *EndpointsInterface) Create(ctx context.Context, endpoints *corev1.Endpoints, opts metav1.CreateOptions) (*corev1.Endpoints, error) { ret := _m.Called(ctx, endpoints, opts) - var r0 *v1.Endpoints - if rf, ok := ret.Get(0).(func(context.Context, *v1.Endpoints, metav1.CreateOptions) *v1.Endpoints); ok { + var r0 *corev1.Endpoints + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Endpoints, metav1.CreateOptions) *corev1.Endpoints); ok { r0 = rf(ctx, endpoints, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Endpoints) + r0 = ret.Get(0).(*corev1.Endpoints) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Endpoints, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Endpoints, metav1.CreateOptions) error); ok { r1 = rf(ctx, endpoints, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *EndpointsInterface) DeleteCollection(ctx context.Context, opts metav1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *EndpointsInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Endpoints, error) { +func (_m *EndpointsInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Endpoints, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Endpoints - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Endpoints); ok { + var r0 *corev1.Endpoints + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Endpoints); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Endpoints) + r0 = ret.Get(0).(*corev1.Endpoints) } } @@ -96,15 +121,15 @@ func (_m *EndpointsInterface) Get(ctx context.Context, name string, opts metav1. } // List provides a mock function with given fields: ctx, opts -func (_m *EndpointsInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.EndpointsList, error) { +func (_m *EndpointsInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.EndpointsList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.EndpointsList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.EndpointsList); ok { + var r0 *corev1.EndpointsList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.EndpointsList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.EndpointsList) + r0 = ret.Get(0).(*corev1.EndpointsList) } } @@ -119,7 +144,7 @@ func (_m *EndpointsInterface) List(ctx context.Context, opts metav1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *EndpointsInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Endpoints, error) { +func (_m *EndpointsInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Endpoints, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *EndpointsInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Endpoints - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Endpoints); ok { + var r0 *corev1.Endpoints + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Endpoints); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Endpoints) + r0 = ret.Get(0).(*corev1.Endpoints) } } @@ -149,20 +174,20 @@ func (_m *EndpointsInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, endpoints, opts -func (_m *EndpointsInterface) Update(ctx context.Context, endpoints *v1.Endpoints, opts metav1.UpdateOptions) (*v1.Endpoints, error) { +func (_m *EndpointsInterface) Update(ctx context.Context, endpoints *corev1.Endpoints, opts metav1.UpdateOptions) (*corev1.Endpoints, error) { ret := _m.Called(ctx, endpoints, opts) - var r0 *v1.Endpoints - if rf, ok := ret.Get(0).(func(context.Context, *v1.Endpoints, metav1.UpdateOptions) *v1.Endpoints); ok { + var r0 *corev1.Endpoints + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Endpoints, metav1.UpdateOptions) *corev1.Endpoints); ok { r0 = rf(ctx, endpoints, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Endpoints) + r0 = ret.Get(0).(*corev1.Endpoints) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Endpoints, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Endpoints, metav1.UpdateOptions) error); ok { r1 = rf(ctx, endpoints, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/event_interface.go b/testutil/kubernetes_mock/typed/core/v1/event_interface.go index b5fea92bcc..e2840d6840 100644 --- a/testutil/kubernetes_mock/typed/core/v1/event_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/event_interface.go @@ -5,6 +5,8 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + fields "k8s.io/apimachinery/pkg/fields" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -15,7 +17,7 @@ import ( types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -25,21 +27,44 @@ type EventInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, event, opts +func (_m *EventInterface) Apply(ctx context.Context, event *v1.EventApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Event, error) { + ret := _m.Called(ctx, event, opts) + + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(context.Context, *v1.EventApplyConfiguration, metav1.ApplyOptions) *corev1.Event); ok { + r0 = rf(ctx, event, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Event) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.EventApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, event, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, event, opts -func (_m *EventInterface) Create(ctx context.Context, event *v1.Event, opts metav1.CreateOptions) (*v1.Event, error) { +func (_m *EventInterface) Create(ctx context.Context, event *corev1.Event, opts metav1.CreateOptions) (*corev1.Event, error) { ret := _m.Called(ctx, event, opts) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, *v1.Event, metav1.CreateOptions) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Event, metav1.CreateOptions) *corev1.Event); ok { r0 = rf(ctx, event, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Event, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Event, metav1.CreateOptions) error); ok { r1 = rf(ctx, event, opts) } else { r1 = ret.Error(1) @@ -49,20 +74,20 @@ func (_m *EventInterface) Create(ctx context.Context, event *v1.Event, opts meta } // CreateWithEventNamespace provides a mock function with given fields: event -func (_m *EventInterface) CreateWithEventNamespace(event *v1.Event) (*v1.Event, error) { +func (_m *EventInterface) CreateWithEventNamespace(event *corev1.Event) (*corev1.Event, error) { ret := _m.Called(event) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(*v1.Event) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(*corev1.Event) *corev1.Event); ok { r0 = rf(event) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(*v1.Event) error); ok { + if rf, ok := ret.Get(1).(func(*corev1.Event) error); ok { r1 = rf(event) } else { r1 = ret.Error(1) @@ -100,15 +125,15 @@ func (_m *EventInterface) DeleteCollection(ctx context.Context, opts metav1.Dele } // Get provides a mock function with given fields: ctx, name, opts -func (_m *EventInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Event, error) { +func (_m *EventInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Event, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Event); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } @@ -139,15 +164,15 @@ func (_m *EventInterface) GetFieldSelector(involvedObjectName *string, involvedO } // List provides a mock function with given fields: ctx, opts -func (_m *EventInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.EventList, error) { +func (_m *EventInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.EventList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.EventList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.EventList); ok { + var r0 *corev1.EventList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.EventList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.EventList) + r0 = ret.Get(0).(*corev1.EventList) } } @@ -162,7 +187,7 @@ func (_m *EventInterface) List(ctx context.Context, opts metav1.ListOptions) (*v } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Event, error) { +func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Event, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -172,12 +197,12 @@ func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.Patch _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Event); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } @@ -192,20 +217,20 @@ func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.Patch } // PatchWithEventNamespace provides a mock function with given fields: event, data -func (_m *EventInterface) PatchWithEventNamespace(event *v1.Event, data []byte) (*v1.Event, error) { +func (_m *EventInterface) PatchWithEventNamespace(event *corev1.Event, data []byte) (*corev1.Event, error) { ret := _m.Called(event, data) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(*v1.Event, []byte) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(*corev1.Event, []byte) *corev1.Event); ok { r0 = rf(event, data) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(*v1.Event, []byte) error); ok { + if rf, ok := ret.Get(1).(func(*corev1.Event, []byte) error); ok { r1 = rf(event, data) } else { r1 = ret.Error(1) @@ -215,15 +240,15 @@ func (_m *EventInterface) PatchWithEventNamespace(event *v1.Event, data []byte) } // Search provides a mock function with given fields: scheme, objOrRef -func (_m *EventInterface) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*v1.EventList, error) { +func (_m *EventInterface) Search(scheme *runtime.Scheme, objOrRef runtime.Object) (*corev1.EventList, error) { ret := _m.Called(scheme, objOrRef) - var r0 *v1.EventList - if rf, ok := ret.Get(0).(func(*runtime.Scheme, runtime.Object) *v1.EventList); ok { + var r0 *corev1.EventList + if rf, ok := ret.Get(0).(func(*runtime.Scheme, runtime.Object) *corev1.EventList); ok { r0 = rf(scheme, objOrRef) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.EventList) + r0 = ret.Get(0).(*corev1.EventList) } } @@ -238,20 +263,20 @@ func (_m *EventInterface) Search(scheme *runtime.Scheme, objOrRef runtime.Object } // Update provides a mock function with given fields: ctx, event, opts -func (_m *EventInterface) Update(ctx context.Context, event *v1.Event, opts metav1.UpdateOptions) (*v1.Event, error) { +func (_m *EventInterface) Update(ctx context.Context, event *corev1.Event, opts metav1.UpdateOptions) (*corev1.Event, error) { ret := _m.Called(ctx, event, opts) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, *v1.Event, metav1.UpdateOptions) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Event, metav1.UpdateOptions) *corev1.Event); ok { r0 = rf(ctx, event, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Event, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Event, metav1.UpdateOptions) error); ok { r1 = rf(ctx, event, opts) } else { r1 = ret.Error(1) @@ -261,20 +286,20 @@ func (_m *EventInterface) Update(ctx context.Context, event *v1.Event, opts meta } // UpdateWithEventNamespace provides a mock function with given fields: event -func (_m *EventInterface) UpdateWithEventNamespace(event *v1.Event) (*v1.Event, error) { +func (_m *EventInterface) UpdateWithEventNamespace(event *corev1.Event) (*corev1.Event, error) { ret := _m.Called(event) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(*v1.Event) *v1.Event); ok { + var r0 *corev1.Event + if rf, ok := ret.Get(0).(func(*corev1.Event) *corev1.Event); ok { r0 = rf(event) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*corev1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(*v1.Event) error); ok { + if rf, ok := ret.Get(1).(func(*corev1.Event) error); ok { r1 = rf(event) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/limit_range_interface.go b/testutil/kubernetes_mock/typed/core/v1/limit_range_interface.go index 8c15d04510..47fdb38535 100644 --- a/testutil/kubernetes_mock/typed/core/v1/limit_range_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/limit_range_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type LimitRangeInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, limitRange, opts +func (_m *LimitRangeInterface) Apply(ctx context.Context, limitRange *v1.LimitRangeApplyConfiguration, opts metav1.ApplyOptions) (*corev1.LimitRange, error) { + ret := _m.Called(ctx, limitRange, opts) + + var r0 *corev1.LimitRange + if rf, ok := ret.Get(0).(func(context.Context, *v1.LimitRangeApplyConfiguration, metav1.ApplyOptions) *corev1.LimitRange); ok { + r0 = rf(ctx, limitRange, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.LimitRange) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.LimitRangeApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, limitRange, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, limitRange, opts -func (_m *LimitRangeInterface) Create(ctx context.Context, limitRange *v1.LimitRange, opts metav1.CreateOptions) (*v1.LimitRange, error) { +func (_m *LimitRangeInterface) Create(ctx context.Context, limitRange *corev1.LimitRange, opts metav1.CreateOptions) (*corev1.LimitRange, error) { ret := _m.Called(ctx, limitRange, opts) - var r0 *v1.LimitRange - if rf, ok := ret.Get(0).(func(context.Context, *v1.LimitRange, metav1.CreateOptions) *v1.LimitRange); ok { + var r0 *corev1.LimitRange + if rf, ok := ret.Get(0).(func(context.Context, *corev1.LimitRange, metav1.CreateOptions) *corev1.LimitRange); ok { r0 = rf(ctx, limitRange, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.LimitRange) + r0 = ret.Get(0).(*corev1.LimitRange) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.LimitRange, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.LimitRange, metav1.CreateOptions) error); ok { r1 = rf(ctx, limitRange, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *LimitRangeInterface) DeleteCollection(ctx context.Context, opts metav1 } // Get provides a mock function with given fields: ctx, name, opts -func (_m *LimitRangeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.LimitRange, error) { +func (_m *LimitRangeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.LimitRange, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.LimitRange - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.LimitRange); ok { + var r0 *corev1.LimitRange + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.LimitRange); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.LimitRange) + r0 = ret.Get(0).(*corev1.LimitRange) } } @@ -96,15 +121,15 @@ func (_m *LimitRangeInterface) Get(ctx context.Context, name string, opts metav1 } // List provides a mock function with given fields: ctx, opts -func (_m *LimitRangeInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.LimitRangeList, error) { +func (_m *LimitRangeInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.LimitRangeList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.LimitRangeList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.LimitRangeList); ok { + var r0 *corev1.LimitRangeList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.LimitRangeList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.LimitRangeList) + r0 = ret.Get(0).(*corev1.LimitRangeList) } } @@ -119,7 +144,7 @@ func (_m *LimitRangeInterface) List(ctx context.Context, opts metav1.ListOptions } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *LimitRangeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.LimitRange, error) { +func (_m *LimitRangeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.LimitRange, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *LimitRangeInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.LimitRange - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.LimitRange); ok { + var r0 *corev1.LimitRange + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.LimitRange); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.LimitRange) + r0 = ret.Get(0).(*corev1.LimitRange) } } @@ -149,20 +174,20 @@ func (_m *LimitRangeInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, limitRange, opts -func (_m *LimitRangeInterface) Update(ctx context.Context, limitRange *v1.LimitRange, opts metav1.UpdateOptions) (*v1.LimitRange, error) { +func (_m *LimitRangeInterface) Update(ctx context.Context, limitRange *corev1.LimitRange, opts metav1.UpdateOptions) (*corev1.LimitRange, error) { ret := _m.Called(ctx, limitRange, opts) - var r0 *v1.LimitRange - if rf, ok := ret.Get(0).(func(context.Context, *v1.LimitRange, metav1.UpdateOptions) *v1.LimitRange); ok { + var r0 *corev1.LimitRange + if rf, ok := ret.Get(0).(func(context.Context, *corev1.LimitRange, metav1.UpdateOptions) *corev1.LimitRange); ok { r0 = rf(ctx, limitRange, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.LimitRange) + r0 = ret.Get(0).(*corev1.LimitRange) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.LimitRange, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.LimitRange, metav1.UpdateOptions) error); ok { r1 = rf(ctx, limitRange, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/namespace_interface.go b/testutil/kubernetes_mock/typed/core/v1/namespace_interface.go index ec4cdb97a9..d3aa1b7629 100644 --- a/testutil/kubernetes_mock/typed/core/v1/namespace_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/namespace_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,67 @@ type NamespaceInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, namespace, opts +func (_m *NamespaceInterface) Apply(ctx context.Context, namespace *v1.NamespaceApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Namespace, error) { + ret := _m.Called(ctx, namespace, opts) + + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, *v1.NamespaceApplyConfiguration, metav1.ApplyOptions) *corev1.Namespace); ok { + r0 = rf(ctx, namespace, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Namespace) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.NamespaceApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, namespace, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, namespace, opts +func (_m *NamespaceInterface) ApplyStatus(ctx context.Context, namespace *v1.NamespaceApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Namespace, error) { + ret := _m.Called(ctx, namespace, opts) + + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, *v1.NamespaceApplyConfiguration, metav1.ApplyOptions) *corev1.Namespace); ok { + r0 = rf(ctx, namespace, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Namespace) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.NamespaceApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, namespace, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, namespace, opts -func (_m *NamespaceInterface) Create(ctx context.Context, namespace *v1.Namespace, opts metav1.CreateOptions) (*v1.Namespace, error) { +func (_m *NamespaceInterface) Create(ctx context.Context, namespace *corev1.Namespace, opts metav1.CreateOptions) (*corev1.Namespace, error) { ret := _m.Called(ctx, namespace, opts) - var r0 *v1.Namespace - if rf, ok := ret.Get(0).(func(context.Context, *v1.Namespace, metav1.CreateOptions) *v1.Namespace); ok { + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Namespace, metav1.CreateOptions) *corev1.Namespace); ok { r0 = rf(ctx, namespace, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Namespace) + r0 = ret.Get(0).(*corev1.Namespace) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Namespace, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Namespace, metav1.CreateOptions) error); ok { r1 = rf(ctx, namespace, opts) } else { r1 = ret.Error(1) @@ -59,20 +107,20 @@ func (_m *NamespaceInterface) Delete(ctx context.Context, name string, opts meta } // Finalize provides a mock function with given fields: ctx, item, opts -func (_m *NamespaceInterface) Finalize(ctx context.Context, item *v1.Namespace, opts metav1.UpdateOptions) (*v1.Namespace, error) { +func (_m *NamespaceInterface) Finalize(ctx context.Context, item *corev1.Namespace, opts metav1.UpdateOptions) (*corev1.Namespace, error) { ret := _m.Called(ctx, item, opts) - var r0 *v1.Namespace - if rf, ok := ret.Get(0).(func(context.Context, *v1.Namespace, metav1.UpdateOptions) *v1.Namespace); ok { + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Namespace, metav1.UpdateOptions) *corev1.Namespace); ok { r0 = rf(ctx, item, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Namespace) + r0 = ret.Get(0).(*corev1.Namespace) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Namespace, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Namespace, metav1.UpdateOptions) error); ok { r1 = rf(ctx, item, opts) } else { r1 = ret.Error(1) @@ -82,15 +130,15 @@ func (_m *NamespaceInterface) Finalize(ctx context.Context, item *v1.Namespace, } // Get provides a mock function with given fields: ctx, name, opts -func (_m *NamespaceInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Namespace, error) { +func (_m *NamespaceInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Namespace, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Namespace - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Namespace); ok { + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Namespace); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Namespace) + r0 = ret.Get(0).(*corev1.Namespace) } } @@ -105,15 +153,15 @@ func (_m *NamespaceInterface) Get(ctx context.Context, name string, opts metav1. } // List provides a mock function with given fields: ctx, opts -func (_m *NamespaceInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.NamespaceList, error) { +func (_m *NamespaceInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.NamespaceList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.NamespaceList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.NamespaceList); ok { + var r0 *corev1.NamespaceList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.NamespaceList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NamespaceList) + r0 = ret.Get(0).(*corev1.NamespaceList) } } @@ -128,7 +176,7 @@ func (_m *NamespaceInterface) List(ctx context.Context, opts metav1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *NamespaceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Namespace, error) { +func (_m *NamespaceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Namespace, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -138,12 +186,12 @@ func (_m *NamespaceInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Namespace - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Namespace); ok { + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Namespace); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Namespace) + r0 = ret.Get(0).(*corev1.Namespace) } } @@ -158,20 +206,20 @@ func (_m *NamespaceInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, namespace, opts -func (_m *NamespaceInterface) Update(ctx context.Context, namespace *v1.Namespace, opts metav1.UpdateOptions) (*v1.Namespace, error) { +func (_m *NamespaceInterface) Update(ctx context.Context, namespace *corev1.Namespace, opts metav1.UpdateOptions) (*corev1.Namespace, error) { ret := _m.Called(ctx, namespace, opts) - var r0 *v1.Namespace - if rf, ok := ret.Get(0).(func(context.Context, *v1.Namespace, metav1.UpdateOptions) *v1.Namespace); ok { + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Namespace, metav1.UpdateOptions) *corev1.Namespace); ok { r0 = rf(ctx, namespace, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Namespace) + r0 = ret.Get(0).(*corev1.Namespace) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Namespace, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Namespace, metav1.UpdateOptions) error); ok { r1 = rf(ctx, namespace, opts) } else { r1 = ret.Error(1) @@ -181,20 +229,20 @@ func (_m *NamespaceInterface) Update(ctx context.Context, namespace *v1.Namespac } // UpdateStatus provides a mock function with given fields: ctx, namespace, opts -func (_m *NamespaceInterface) UpdateStatus(ctx context.Context, namespace *v1.Namespace, opts metav1.UpdateOptions) (*v1.Namespace, error) { +func (_m *NamespaceInterface) UpdateStatus(ctx context.Context, namespace *corev1.Namespace, opts metav1.UpdateOptions) (*corev1.Namespace, error) { ret := _m.Called(ctx, namespace, opts) - var r0 *v1.Namespace - if rf, ok := ret.Get(0).(func(context.Context, *v1.Namespace, metav1.UpdateOptions) *v1.Namespace); ok { + var r0 *corev1.Namespace + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Namespace, metav1.UpdateOptions) *corev1.Namespace); ok { r0 = rf(ctx, namespace, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Namespace) + r0 = ret.Get(0).(*corev1.Namespace) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Namespace, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Namespace, metav1.UpdateOptions) error); ok { r1 = rf(ctx, namespace, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/node_interface.go b/testutil/kubernetes_mock/typed/core/v1/node_interface.go index 5cf270274a..a66bafad61 100644 --- a/testutil/kubernetes_mock/typed/core/v1/node_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/node_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,67 @@ type NodeInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, node, opts +func (_m *NodeInterface) Apply(ctx context.Context, node *v1.NodeApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Node, error) { + ret := _m.Called(ctx, node, opts) + + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, *v1.NodeApplyConfiguration, metav1.ApplyOptions) *corev1.Node); ok { + r0 = rf(ctx, node, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Node) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.NodeApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, node, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, node, opts +func (_m *NodeInterface) ApplyStatus(ctx context.Context, node *v1.NodeApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Node, error) { + ret := _m.Called(ctx, node, opts) + + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, *v1.NodeApplyConfiguration, metav1.ApplyOptions) *corev1.Node); ok { + r0 = rf(ctx, node, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Node) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.NodeApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, node, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, node, opts -func (_m *NodeInterface) Create(ctx context.Context, node *v1.Node, opts metav1.CreateOptions) (*v1.Node, error) { +func (_m *NodeInterface) Create(ctx context.Context, node *corev1.Node, opts metav1.CreateOptions) (*corev1.Node, error) { ret := _m.Called(ctx, node, opts) - var r0 *v1.Node - if rf, ok := ret.Get(0).(func(context.Context, *v1.Node, metav1.CreateOptions) *v1.Node); ok { + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Node, metav1.CreateOptions) *corev1.Node); ok { r0 = rf(ctx, node, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Node) + r0 = ret.Get(0).(*corev1.Node) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Node, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Node, metav1.CreateOptions) error); ok { r1 = rf(ctx, node, opts) } else { r1 = ret.Error(1) @@ -73,15 +121,15 @@ func (_m *NodeInterface) DeleteCollection(ctx context.Context, opts metav1.Delet } // Get provides a mock function with given fields: ctx, name, opts -func (_m *NodeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Node, error) { +func (_m *NodeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Node, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Node - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Node); ok { + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Node); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Node) + r0 = ret.Get(0).(*corev1.Node) } } @@ -96,15 +144,15 @@ func (_m *NodeInterface) Get(ctx context.Context, name string, opts metav1.GetOp } // List provides a mock function with given fields: ctx, opts -func (_m *NodeInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.NodeList, error) { +func (_m *NodeInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.NodeList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.NodeList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.NodeList); ok { + var r0 *corev1.NodeList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.NodeList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NodeList) + r0 = ret.Get(0).(*corev1.NodeList) } } @@ -119,7 +167,7 @@ func (_m *NodeInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1 } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *NodeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Node, error) { +func (_m *NodeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Node, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +177,12 @@ func (_m *NodeInterface) Patch(ctx context.Context, name string, pt types.PatchT _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Node - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Node); ok { + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Node); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Node) + r0 = ret.Get(0).(*corev1.Node) } } @@ -149,15 +197,15 @@ func (_m *NodeInterface) Patch(ctx context.Context, name string, pt types.PatchT } // PatchStatus provides a mock function with given fields: ctx, nodeName, data -func (_m *NodeInterface) PatchStatus(ctx context.Context, nodeName string, data []byte) (*v1.Node, error) { +func (_m *NodeInterface) PatchStatus(ctx context.Context, nodeName string, data []byte) (*corev1.Node, error) { ret := _m.Called(ctx, nodeName, data) - var r0 *v1.Node - if rf, ok := ret.Get(0).(func(context.Context, string, []byte) *v1.Node); ok { + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, string, []byte) *corev1.Node); ok { r0 = rf(ctx, nodeName, data) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Node) + r0 = ret.Get(0).(*corev1.Node) } } @@ -172,20 +220,20 @@ func (_m *NodeInterface) PatchStatus(ctx context.Context, nodeName string, data } // Update provides a mock function with given fields: ctx, node, opts -func (_m *NodeInterface) Update(ctx context.Context, node *v1.Node, opts metav1.UpdateOptions) (*v1.Node, error) { +func (_m *NodeInterface) Update(ctx context.Context, node *corev1.Node, opts metav1.UpdateOptions) (*corev1.Node, error) { ret := _m.Called(ctx, node, opts) - var r0 *v1.Node - if rf, ok := ret.Get(0).(func(context.Context, *v1.Node, metav1.UpdateOptions) *v1.Node); ok { + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Node, metav1.UpdateOptions) *corev1.Node); ok { r0 = rf(ctx, node, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Node) + r0 = ret.Get(0).(*corev1.Node) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Node, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Node, metav1.UpdateOptions) error); ok { r1 = rf(ctx, node, opts) } else { r1 = ret.Error(1) @@ -195,20 +243,20 @@ func (_m *NodeInterface) Update(ctx context.Context, node *v1.Node, opts metav1. } // UpdateStatus provides a mock function with given fields: ctx, node, opts -func (_m *NodeInterface) UpdateStatus(ctx context.Context, node *v1.Node, opts metav1.UpdateOptions) (*v1.Node, error) { +func (_m *NodeInterface) UpdateStatus(ctx context.Context, node *corev1.Node, opts metav1.UpdateOptions) (*corev1.Node, error) { ret := _m.Called(ctx, node, opts) - var r0 *v1.Node - if rf, ok := ret.Get(0).(func(context.Context, *v1.Node, metav1.UpdateOptions) *v1.Node); ok { + var r0 *corev1.Node + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Node, metav1.UpdateOptions) *corev1.Node); ok { r0 = rf(ctx, node, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Node) + r0 = ret.Get(0).(*corev1.Node) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Node, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Node, metav1.UpdateOptions) error); ok { r1 = rf(ctx, node, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/persistent_volume_claim_interface.go b/testutil/kubernetes_mock/typed/core/v1/persistent_volume_claim_interface.go index 868f6ee715..00074304d3 100644 --- a/testutil/kubernetes_mock/typed/core/v1/persistent_volume_claim_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/persistent_volume_claim_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,67 @@ type PersistentVolumeClaimInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, persistentVolumeClaim, opts +func (_m *PersistentVolumeClaimInterface) Apply(ctx context.Context, persistentVolumeClaim *v1.PersistentVolumeClaimApplyConfiguration, opts metav1.ApplyOptions) (*corev1.PersistentVolumeClaim, error) { + ret := _m.Called(ctx, persistentVolumeClaim, opts) + + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeClaimApplyConfiguration, metav1.ApplyOptions) *corev1.PersistentVolumeClaim); ok { + r0 = rf(ctx, persistentVolumeClaim, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeClaimApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, persistentVolumeClaim, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, persistentVolumeClaim, opts +func (_m *PersistentVolumeClaimInterface) ApplyStatus(ctx context.Context, persistentVolumeClaim *v1.PersistentVolumeClaimApplyConfiguration, opts metav1.ApplyOptions) (*corev1.PersistentVolumeClaim, error) { + ret := _m.Called(ctx, persistentVolumeClaim, opts) + + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeClaimApplyConfiguration, metav1.ApplyOptions) *corev1.PersistentVolumeClaim); ok { + r0 = rf(ctx, persistentVolumeClaim, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeClaimApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, persistentVolumeClaim, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, persistentVolumeClaim, opts -func (_m *PersistentVolumeClaimInterface) Create(ctx context.Context, persistentVolumeClaim *v1.PersistentVolumeClaim, opts metav1.CreateOptions) (*v1.PersistentVolumeClaim, error) { +func (_m *PersistentVolumeClaimInterface) Create(ctx context.Context, persistentVolumeClaim *corev1.PersistentVolumeClaim, opts metav1.CreateOptions) (*corev1.PersistentVolumeClaim, error) { ret := _m.Called(ctx, persistentVolumeClaim, opts) - var r0 *v1.PersistentVolumeClaim - if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeClaim, metav1.CreateOptions) *v1.PersistentVolumeClaim); ok { + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PersistentVolumeClaim, metav1.CreateOptions) *corev1.PersistentVolumeClaim); ok { r0 = rf(ctx, persistentVolumeClaim, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeClaim) + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeClaim, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PersistentVolumeClaim, metav1.CreateOptions) error); ok { r1 = rf(ctx, persistentVolumeClaim, opts) } else { r1 = ret.Error(1) @@ -73,15 +121,15 @@ func (_m *PersistentVolumeClaimInterface) DeleteCollection(ctx context.Context, } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PersistentVolumeClaimInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.PersistentVolumeClaim, error) { +func (_m *PersistentVolumeClaimInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.PersistentVolumeClaim, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.PersistentVolumeClaim - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.PersistentVolumeClaim); ok { + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.PersistentVolumeClaim); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeClaim) + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) } } @@ -96,15 +144,15 @@ func (_m *PersistentVolumeClaimInterface) Get(ctx context.Context, name string, } // List provides a mock function with given fields: ctx, opts -func (_m *PersistentVolumeClaimInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.PersistentVolumeClaimList, error) { +func (_m *PersistentVolumeClaimInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.PersistentVolumeClaimList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.PersistentVolumeClaimList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.PersistentVolumeClaimList); ok { + var r0 *corev1.PersistentVolumeClaimList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.PersistentVolumeClaimList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeClaimList) + r0 = ret.Get(0).(*corev1.PersistentVolumeClaimList) } } @@ -119,7 +167,7 @@ func (_m *PersistentVolumeClaimInterface) List(ctx context.Context, opts metav1. } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PersistentVolumeClaimInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.PersistentVolumeClaim, error) { +func (_m *PersistentVolumeClaimInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.PersistentVolumeClaim, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +177,12 @@ func (_m *PersistentVolumeClaimInterface) Patch(ctx context.Context, name string _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.PersistentVolumeClaim - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.PersistentVolumeClaim); ok { + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.PersistentVolumeClaim); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeClaim) + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) } } @@ -149,20 +197,20 @@ func (_m *PersistentVolumeClaimInterface) Patch(ctx context.Context, name string } // Update provides a mock function with given fields: ctx, persistentVolumeClaim, opts -func (_m *PersistentVolumeClaimInterface) Update(ctx context.Context, persistentVolumeClaim *v1.PersistentVolumeClaim, opts metav1.UpdateOptions) (*v1.PersistentVolumeClaim, error) { +func (_m *PersistentVolumeClaimInterface) Update(ctx context.Context, persistentVolumeClaim *corev1.PersistentVolumeClaim, opts metav1.UpdateOptions) (*corev1.PersistentVolumeClaim, error) { ret := _m.Called(ctx, persistentVolumeClaim, opts) - var r0 *v1.PersistentVolumeClaim - if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeClaim, metav1.UpdateOptions) *v1.PersistentVolumeClaim); ok { + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PersistentVolumeClaim, metav1.UpdateOptions) *corev1.PersistentVolumeClaim); ok { r0 = rf(ctx, persistentVolumeClaim, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeClaim) + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeClaim, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PersistentVolumeClaim, metav1.UpdateOptions) error); ok { r1 = rf(ctx, persistentVolumeClaim, opts) } else { r1 = ret.Error(1) @@ -172,20 +220,20 @@ func (_m *PersistentVolumeClaimInterface) Update(ctx context.Context, persistent } // UpdateStatus provides a mock function with given fields: ctx, persistentVolumeClaim, opts -func (_m *PersistentVolumeClaimInterface) UpdateStatus(ctx context.Context, persistentVolumeClaim *v1.PersistentVolumeClaim, opts metav1.UpdateOptions) (*v1.PersistentVolumeClaim, error) { +func (_m *PersistentVolumeClaimInterface) UpdateStatus(ctx context.Context, persistentVolumeClaim *corev1.PersistentVolumeClaim, opts metav1.UpdateOptions) (*corev1.PersistentVolumeClaim, error) { ret := _m.Called(ctx, persistentVolumeClaim, opts) - var r0 *v1.PersistentVolumeClaim - if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeClaim, metav1.UpdateOptions) *v1.PersistentVolumeClaim); ok { + var r0 *corev1.PersistentVolumeClaim + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PersistentVolumeClaim, metav1.UpdateOptions) *corev1.PersistentVolumeClaim); ok { r0 = rf(ctx, persistentVolumeClaim, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeClaim) + r0 = ret.Get(0).(*corev1.PersistentVolumeClaim) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeClaim, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PersistentVolumeClaim, metav1.UpdateOptions) error); ok { r1 = rf(ctx, persistentVolumeClaim, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/persistent_volume_interface.go b/testutil/kubernetes_mock/typed/core/v1/persistent_volume_interface.go index b4f5a68f89..c5494acddb 100644 --- a/testutil/kubernetes_mock/typed/core/v1/persistent_volume_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/persistent_volume_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,67 @@ type PersistentVolumeInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, persistentVolume, opts +func (_m *PersistentVolumeInterface) Apply(ctx context.Context, persistentVolume *v1.PersistentVolumeApplyConfiguration, opts metav1.ApplyOptions) (*corev1.PersistentVolume, error) { + ret := _m.Called(ctx, persistentVolume, opts) + + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeApplyConfiguration, metav1.ApplyOptions) *corev1.PersistentVolume); ok { + r0 = rf(ctx, persistentVolume, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.PersistentVolume) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, persistentVolume, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, persistentVolume, opts +func (_m *PersistentVolumeInterface) ApplyStatus(ctx context.Context, persistentVolume *v1.PersistentVolumeApplyConfiguration, opts metav1.ApplyOptions) (*corev1.PersistentVolume, error) { + ret := _m.Called(ctx, persistentVolume, opts) + + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolumeApplyConfiguration, metav1.ApplyOptions) *corev1.PersistentVolume); ok { + r0 = rf(ctx, persistentVolume, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.PersistentVolume) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolumeApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, persistentVolume, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, persistentVolume, opts -func (_m *PersistentVolumeInterface) Create(ctx context.Context, persistentVolume *v1.PersistentVolume, opts metav1.CreateOptions) (*v1.PersistentVolume, error) { +func (_m *PersistentVolumeInterface) Create(ctx context.Context, persistentVolume *corev1.PersistentVolume, opts metav1.CreateOptions) (*corev1.PersistentVolume, error) { ret := _m.Called(ctx, persistentVolume, opts) - var r0 *v1.PersistentVolume - if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolume, metav1.CreateOptions) *v1.PersistentVolume); ok { + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PersistentVolume, metav1.CreateOptions) *corev1.PersistentVolume); ok { r0 = rf(ctx, persistentVolume, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolume) + r0 = ret.Get(0).(*corev1.PersistentVolume) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolume, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PersistentVolume, metav1.CreateOptions) error); ok { r1 = rf(ctx, persistentVolume, opts) } else { r1 = ret.Error(1) @@ -73,15 +121,15 @@ func (_m *PersistentVolumeInterface) DeleteCollection(ctx context.Context, opts } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PersistentVolumeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.PersistentVolume, error) { +func (_m *PersistentVolumeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.PersistentVolume, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.PersistentVolume - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.PersistentVolume); ok { + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.PersistentVolume); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolume) + r0 = ret.Get(0).(*corev1.PersistentVolume) } } @@ -96,15 +144,15 @@ func (_m *PersistentVolumeInterface) Get(ctx context.Context, name string, opts } // List provides a mock function with given fields: ctx, opts -func (_m *PersistentVolumeInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.PersistentVolumeList, error) { +func (_m *PersistentVolumeInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.PersistentVolumeList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.PersistentVolumeList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.PersistentVolumeList); ok { + var r0 *corev1.PersistentVolumeList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.PersistentVolumeList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolumeList) + r0 = ret.Get(0).(*corev1.PersistentVolumeList) } } @@ -119,7 +167,7 @@ func (_m *PersistentVolumeInterface) List(ctx context.Context, opts metav1.ListO } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PersistentVolumeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.PersistentVolume, error) { +func (_m *PersistentVolumeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.PersistentVolume, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +177,12 @@ func (_m *PersistentVolumeInterface) Patch(ctx context.Context, name string, pt _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.PersistentVolume - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.PersistentVolume); ok { + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.PersistentVolume); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolume) + r0 = ret.Get(0).(*corev1.PersistentVolume) } } @@ -149,20 +197,20 @@ func (_m *PersistentVolumeInterface) Patch(ctx context.Context, name string, pt } // Update provides a mock function with given fields: ctx, persistentVolume, opts -func (_m *PersistentVolumeInterface) Update(ctx context.Context, persistentVolume *v1.PersistentVolume, opts metav1.UpdateOptions) (*v1.PersistentVolume, error) { +func (_m *PersistentVolumeInterface) Update(ctx context.Context, persistentVolume *corev1.PersistentVolume, opts metav1.UpdateOptions) (*corev1.PersistentVolume, error) { ret := _m.Called(ctx, persistentVolume, opts) - var r0 *v1.PersistentVolume - if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolume, metav1.UpdateOptions) *v1.PersistentVolume); ok { + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PersistentVolume, metav1.UpdateOptions) *corev1.PersistentVolume); ok { r0 = rf(ctx, persistentVolume, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolume) + r0 = ret.Get(0).(*corev1.PersistentVolume) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolume, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PersistentVolume, metav1.UpdateOptions) error); ok { r1 = rf(ctx, persistentVolume, opts) } else { r1 = ret.Error(1) @@ -172,20 +220,20 @@ func (_m *PersistentVolumeInterface) Update(ctx context.Context, persistentVolum } // UpdateStatus provides a mock function with given fields: ctx, persistentVolume, opts -func (_m *PersistentVolumeInterface) UpdateStatus(ctx context.Context, persistentVolume *v1.PersistentVolume, opts metav1.UpdateOptions) (*v1.PersistentVolume, error) { +func (_m *PersistentVolumeInterface) UpdateStatus(ctx context.Context, persistentVolume *corev1.PersistentVolume, opts metav1.UpdateOptions) (*corev1.PersistentVolume, error) { ret := _m.Called(ctx, persistentVolume, opts) - var r0 *v1.PersistentVolume - if rf, ok := ret.Get(0).(func(context.Context, *v1.PersistentVolume, metav1.UpdateOptions) *v1.PersistentVolume); ok { + var r0 *corev1.PersistentVolume + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PersistentVolume, metav1.UpdateOptions) *corev1.PersistentVolume); ok { r0 = rf(ctx, persistentVolume, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PersistentVolume) + r0 = ret.Get(0).(*corev1.PersistentVolume) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PersistentVolume, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PersistentVolume, metav1.UpdateOptions) error); ok { r1 = rf(ctx, persistentVolume, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/pod_interface.go b/testutil/kubernetes_mock/typed/core/v1/pod_interface.go index 845f2de9a4..f383ddd39c 100644 --- a/testutil/kubernetes_mock/typed/core/v1/pod_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/pod_interface.go @@ -5,6 +5,8 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" @@ -13,7 +15,7 @@ import ( types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" v1beta1 "k8s.io/api/policy/v1beta1" @@ -25,12 +27,58 @@ type PodInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, pod, opts +func (_m *PodInterface) Apply(ctx context.Context, pod *v1.PodApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Pod, error) { + ret := _m.Called(ctx, pod, opts) + + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, *v1.PodApplyConfiguration, metav1.ApplyOptions) *corev1.Pod); ok { + r0 = rf(ctx, pod, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Pod) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PodApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, pod, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, pod, opts +func (_m *PodInterface) ApplyStatus(ctx context.Context, pod *v1.PodApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Pod, error) { + ret := _m.Called(ctx, pod, opts) + + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, *v1.PodApplyConfiguration, metav1.ApplyOptions) *corev1.Pod); ok { + r0 = rf(ctx, pod, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Pod) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PodApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, pod, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Bind provides a mock function with given fields: ctx, binding, opts -func (_m *PodInterface) Bind(ctx context.Context, binding *v1.Binding, opts metav1.CreateOptions) error { +func (_m *PodInterface) Bind(ctx context.Context, binding *corev1.Binding, opts metav1.CreateOptions) error { ret := _m.Called(ctx, binding, opts) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *v1.Binding, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Binding, metav1.CreateOptions) error); ok { r0 = rf(ctx, binding, opts) } else { r0 = ret.Error(0) @@ -40,20 +88,20 @@ func (_m *PodInterface) Bind(ctx context.Context, binding *v1.Binding, opts meta } // Create provides a mock function with given fields: ctx, pod, opts -func (_m *PodInterface) Create(ctx context.Context, pod *v1.Pod, opts metav1.CreateOptions) (*v1.Pod, error) { +func (_m *PodInterface) Create(ctx context.Context, pod *corev1.Pod, opts metav1.CreateOptions) (*corev1.Pod, error) { ret := _m.Called(ctx, pod, opts) - var r0 *v1.Pod - if rf, ok := ret.Get(0).(func(context.Context, *v1.Pod, metav1.CreateOptions) *v1.Pod); ok { + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Pod, metav1.CreateOptions) *corev1.Pod); ok { r0 = rf(ctx, pod, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Pod) + r0 = ret.Get(0).(*corev1.Pod) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Pod, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Pod, metav1.CreateOptions) error); ok { r1 = rf(ctx, pod, opts) } else { r1 = ret.Error(1) @@ -105,15 +153,15 @@ func (_m *PodInterface) Evict(ctx context.Context, eviction *v1beta1.Eviction) e } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PodInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Pod, error) { +func (_m *PodInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Pod, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Pod - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Pod); ok { + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Pod); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Pod) + r0 = ret.Get(0).(*corev1.Pod) } } @@ -128,15 +176,15 @@ func (_m *PodInterface) Get(ctx context.Context, name string, opts metav1.GetOpt } // GetEphemeralContainers provides a mock function with given fields: ctx, podName, options -func (_m *PodInterface) GetEphemeralContainers(ctx context.Context, podName string, options metav1.GetOptions) (*v1.EphemeralContainers, error) { +func (_m *PodInterface) GetEphemeralContainers(ctx context.Context, podName string, options metav1.GetOptions) (*corev1.EphemeralContainers, error) { ret := _m.Called(ctx, podName, options) - var r0 *v1.EphemeralContainers - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.EphemeralContainers); ok { + var r0 *corev1.EphemeralContainers + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.EphemeralContainers); ok { r0 = rf(ctx, podName, options) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.EphemeralContainers) + r0 = ret.Get(0).(*corev1.EphemeralContainers) } } @@ -151,11 +199,11 @@ func (_m *PodInterface) GetEphemeralContainers(ctx context.Context, podName stri } // GetLogs provides a mock function with given fields: name, opts -func (_m *PodInterface) GetLogs(name string, opts *v1.PodLogOptions) *rest.Request { +func (_m *PodInterface) GetLogs(name string, opts *corev1.PodLogOptions) *rest.Request { ret := _m.Called(name, opts) var r0 *rest.Request - if rf, ok := ret.Get(0).(func(string, *v1.PodLogOptions) *rest.Request); ok { + if rf, ok := ret.Get(0).(func(string, *corev1.PodLogOptions) *rest.Request); ok { r0 = rf(name, opts) } else { if ret.Get(0) != nil { @@ -167,15 +215,15 @@ func (_m *PodInterface) GetLogs(name string, opts *v1.PodLogOptions) *rest.Reque } // List provides a mock function with given fields: ctx, opts -func (_m *PodInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.PodList, error) { +func (_m *PodInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.PodList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.PodList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.PodList); ok { + var r0 *corev1.PodList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.PodList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PodList) + r0 = ret.Get(0).(*corev1.PodList) } } @@ -190,7 +238,7 @@ func (_m *PodInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1. } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PodInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Pod, error) { +func (_m *PodInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Pod, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -200,12 +248,12 @@ func (_m *PodInterface) Patch(ctx context.Context, name string, pt types.PatchTy _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Pod - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Pod); ok { + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Pod); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Pod) + r0 = ret.Get(0).(*corev1.Pod) } } @@ -236,20 +284,20 @@ func (_m *PodInterface) ProxyGet(scheme string, name string, port string, path s } // Update provides a mock function with given fields: ctx, pod, opts -func (_m *PodInterface) Update(ctx context.Context, pod *v1.Pod, opts metav1.UpdateOptions) (*v1.Pod, error) { +func (_m *PodInterface) Update(ctx context.Context, pod *corev1.Pod, opts metav1.UpdateOptions) (*corev1.Pod, error) { ret := _m.Called(ctx, pod, opts) - var r0 *v1.Pod - if rf, ok := ret.Get(0).(func(context.Context, *v1.Pod, metav1.UpdateOptions) *v1.Pod); ok { + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Pod, metav1.UpdateOptions) *corev1.Pod); ok { r0 = rf(ctx, pod, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Pod) + r0 = ret.Get(0).(*corev1.Pod) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Pod, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Pod, metav1.UpdateOptions) error); ok { r1 = rf(ctx, pod, opts) } else { r1 = ret.Error(1) @@ -259,20 +307,20 @@ func (_m *PodInterface) Update(ctx context.Context, pod *v1.Pod, opts metav1.Upd } // UpdateEphemeralContainers provides a mock function with given fields: ctx, podName, ephemeralContainers, opts -func (_m *PodInterface) UpdateEphemeralContainers(ctx context.Context, podName string, ephemeralContainers *v1.EphemeralContainers, opts metav1.UpdateOptions) (*v1.EphemeralContainers, error) { +func (_m *PodInterface) UpdateEphemeralContainers(ctx context.Context, podName string, ephemeralContainers *corev1.EphemeralContainers, opts metav1.UpdateOptions) (*corev1.EphemeralContainers, error) { ret := _m.Called(ctx, podName, ephemeralContainers, opts) - var r0 *v1.EphemeralContainers - if rf, ok := ret.Get(0).(func(context.Context, string, *v1.EphemeralContainers, metav1.UpdateOptions) *v1.EphemeralContainers); ok { + var r0 *corev1.EphemeralContainers + if rf, ok := ret.Get(0).(func(context.Context, string, *corev1.EphemeralContainers, metav1.UpdateOptions) *corev1.EphemeralContainers); ok { r0 = rf(ctx, podName, ephemeralContainers, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.EphemeralContainers) + r0 = ret.Get(0).(*corev1.EphemeralContainers) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, *v1.EphemeralContainers, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, *corev1.EphemeralContainers, metav1.UpdateOptions) error); ok { r1 = rf(ctx, podName, ephemeralContainers, opts) } else { r1 = ret.Error(1) @@ -282,20 +330,20 @@ func (_m *PodInterface) UpdateEphemeralContainers(ctx context.Context, podName s } // UpdateStatus provides a mock function with given fields: ctx, pod, opts -func (_m *PodInterface) UpdateStatus(ctx context.Context, pod *v1.Pod, opts metav1.UpdateOptions) (*v1.Pod, error) { +func (_m *PodInterface) UpdateStatus(ctx context.Context, pod *corev1.Pod, opts metav1.UpdateOptions) (*corev1.Pod, error) { ret := _m.Called(ctx, pod, opts) - var r0 *v1.Pod - if rf, ok := ret.Get(0).(func(context.Context, *v1.Pod, metav1.UpdateOptions) *v1.Pod); ok { + var r0 *corev1.Pod + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Pod, metav1.UpdateOptions) *corev1.Pod); ok { r0 = rf(ctx, pod, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Pod) + r0 = ret.Get(0).(*corev1.Pod) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Pod, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Pod, metav1.UpdateOptions) error); ok { r1 = rf(ctx, pod, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/pod_template_interface.go b/testutil/kubernetes_mock/typed/core/v1/pod_template_interface.go index 947918be12..eaa55ab836 100644 --- a/testutil/kubernetes_mock/typed/core/v1/pod_template_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/pod_template_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type PodTemplateInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, podTemplate, opts +func (_m *PodTemplateInterface) Apply(ctx context.Context, podTemplate *v1.PodTemplateApplyConfiguration, opts metav1.ApplyOptions) (*corev1.PodTemplate, error) { + ret := _m.Called(ctx, podTemplate, opts) + + var r0 *corev1.PodTemplate + if rf, ok := ret.Get(0).(func(context.Context, *v1.PodTemplateApplyConfiguration, metav1.ApplyOptions) *corev1.PodTemplate); ok { + r0 = rf(ctx, podTemplate, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.PodTemplate) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PodTemplateApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, podTemplate, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, podTemplate, opts -func (_m *PodTemplateInterface) Create(ctx context.Context, podTemplate *v1.PodTemplate, opts metav1.CreateOptions) (*v1.PodTemplate, error) { +func (_m *PodTemplateInterface) Create(ctx context.Context, podTemplate *corev1.PodTemplate, opts metav1.CreateOptions) (*corev1.PodTemplate, error) { ret := _m.Called(ctx, podTemplate, opts) - var r0 *v1.PodTemplate - if rf, ok := ret.Get(0).(func(context.Context, *v1.PodTemplate, metav1.CreateOptions) *v1.PodTemplate); ok { + var r0 *corev1.PodTemplate + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PodTemplate, metav1.CreateOptions) *corev1.PodTemplate); ok { r0 = rf(ctx, podTemplate, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PodTemplate) + r0 = ret.Get(0).(*corev1.PodTemplate) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PodTemplate, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PodTemplate, metav1.CreateOptions) error); ok { r1 = rf(ctx, podTemplate, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *PodTemplateInterface) DeleteCollection(ctx context.Context, opts metav } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PodTemplateInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.PodTemplate, error) { +func (_m *PodTemplateInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.PodTemplate, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.PodTemplate - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.PodTemplate); ok { + var r0 *corev1.PodTemplate + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.PodTemplate); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PodTemplate) + r0 = ret.Get(0).(*corev1.PodTemplate) } } @@ -96,15 +121,15 @@ func (_m *PodTemplateInterface) Get(ctx context.Context, name string, opts metav } // List provides a mock function with given fields: ctx, opts -func (_m *PodTemplateInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.PodTemplateList, error) { +func (_m *PodTemplateInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.PodTemplateList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.PodTemplateList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.PodTemplateList); ok { + var r0 *corev1.PodTemplateList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.PodTemplateList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PodTemplateList) + r0 = ret.Get(0).(*corev1.PodTemplateList) } } @@ -119,7 +144,7 @@ func (_m *PodTemplateInterface) List(ctx context.Context, opts metav1.ListOption } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PodTemplateInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.PodTemplate, error) { +func (_m *PodTemplateInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.PodTemplate, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *PodTemplateInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.PodTemplate - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.PodTemplate); ok { + var r0 *corev1.PodTemplate + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.PodTemplate); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PodTemplate) + r0 = ret.Get(0).(*corev1.PodTemplate) } } @@ -149,20 +174,20 @@ func (_m *PodTemplateInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, podTemplate, opts -func (_m *PodTemplateInterface) Update(ctx context.Context, podTemplate *v1.PodTemplate, opts metav1.UpdateOptions) (*v1.PodTemplate, error) { +func (_m *PodTemplateInterface) Update(ctx context.Context, podTemplate *corev1.PodTemplate, opts metav1.UpdateOptions) (*corev1.PodTemplate, error) { ret := _m.Called(ctx, podTemplate, opts) - var r0 *v1.PodTemplate - if rf, ok := ret.Get(0).(func(context.Context, *v1.PodTemplate, metav1.UpdateOptions) *v1.PodTemplate); ok { + var r0 *corev1.PodTemplate + if rf, ok := ret.Get(0).(func(context.Context, *corev1.PodTemplate, metav1.UpdateOptions) *corev1.PodTemplate); ok { r0 = rf(ctx, podTemplate, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PodTemplate) + r0 = ret.Get(0).(*corev1.PodTemplate) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PodTemplate, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.PodTemplate, metav1.UpdateOptions) error); ok { r1 = rf(ctx, podTemplate, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/replication_controller_interface.go b/testutil/kubernetes_mock/typed/core/v1/replication_controller_interface.go index 1ce60daff5..d67495e614 100644 --- a/testutil/kubernetes_mock/typed/core/v1/replication_controller_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/replication_controller_interface.go @@ -7,13 +7,15 @@ import ( autoscalingv1 "k8s.io/api/autoscaling/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -23,21 +25,67 @@ type ReplicationControllerInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, replicationController, opts +func (_m *ReplicationControllerInterface) Apply(ctx context.Context, replicationController *v1.ReplicationControllerApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ReplicationController, error) { + ret := _m.Called(ctx, replicationController, opts) + + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicationControllerApplyConfiguration, metav1.ApplyOptions) *corev1.ReplicationController); ok { + r0 = rf(ctx, replicationController, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ReplicationController) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicationControllerApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, replicationController, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, replicationController, opts +func (_m *ReplicationControllerInterface) ApplyStatus(ctx context.Context, replicationController *v1.ReplicationControllerApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ReplicationController, error) { + ret := _m.Called(ctx, replicationController, opts) + + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicationControllerApplyConfiguration, metav1.ApplyOptions) *corev1.ReplicationController); ok { + r0 = rf(ctx, replicationController, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ReplicationController) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicationControllerApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, replicationController, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, replicationController, opts -func (_m *ReplicationControllerInterface) Create(ctx context.Context, replicationController *v1.ReplicationController, opts metav1.CreateOptions) (*v1.ReplicationController, error) { +func (_m *ReplicationControllerInterface) Create(ctx context.Context, replicationController *corev1.ReplicationController, opts metav1.CreateOptions) (*corev1.ReplicationController, error) { ret := _m.Called(ctx, replicationController, opts) - var r0 *v1.ReplicationController - if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicationController, metav1.CreateOptions) *v1.ReplicationController); ok { + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ReplicationController, metav1.CreateOptions) *corev1.ReplicationController); ok { r0 = rf(ctx, replicationController, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicationController) + r0 = ret.Get(0).(*corev1.ReplicationController) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicationController, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ReplicationController, metav1.CreateOptions) error); ok { r1 = rf(ctx, replicationController, opts) } else { r1 = ret.Error(1) @@ -75,15 +123,15 @@ func (_m *ReplicationControllerInterface) DeleteCollection(ctx context.Context, } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ReplicationControllerInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ReplicationController, error) { +func (_m *ReplicationControllerInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.ReplicationController, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ReplicationController - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ReplicationController); ok { + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.ReplicationController); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicationController) + r0 = ret.Get(0).(*corev1.ReplicationController) } } @@ -121,15 +169,15 @@ func (_m *ReplicationControllerInterface) GetScale(ctx context.Context, replicat } // List provides a mock function with given fields: ctx, opts -func (_m *ReplicationControllerInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ReplicationControllerList, error) { +func (_m *ReplicationControllerInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ReplicationControllerList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ReplicationControllerList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ReplicationControllerList); ok { + var r0 *corev1.ReplicationControllerList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ReplicationControllerList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicationControllerList) + r0 = ret.Get(0).(*corev1.ReplicationControllerList) } } @@ -144,7 +192,7 @@ func (_m *ReplicationControllerInterface) List(ctx context.Context, opts metav1. } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ReplicationControllerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ReplicationController, error) { +func (_m *ReplicationControllerInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.ReplicationController, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -154,12 +202,12 @@ func (_m *ReplicationControllerInterface) Patch(ctx context.Context, name string _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ReplicationController - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ReplicationController); ok { + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.ReplicationController); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicationController) + r0 = ret.Get(0).(*corev1.ReplicationController) } } @@ -174,20 +222,20 @@ func (_m *ReplicationControllerInterface) Patch(ctx context.Context, name string } // Update provides a mock function with given fields: ctx, replicationController, opts -func (_m *ReplicationControllerInterface) Update(ctx context.Context, replicationController *v1.ReplicationController, opts metav1.UpdateOptions) (*v1.ReplicationController, error) { +func (_m *ReplicationControllerInterface) Update(ctx context.Context, replicationController *corev1.ReplicationController, opts metav1.UpdateOptions) (*corev1.ReplicationController, error) { ret := _m.Called(ctx, replicationController, opts) - var r0 *v1.ReplicationController - if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicationController, metav1.UpdateOptions) *v1.ReplicationController); ok { + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ReplicationController, metav1.UpdateOptions) *corev1.ReplicationController); ok { r0 = rf(ctx, replicationController, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicationController) + r0 = ret.Get(0).(*corev1.ReplicationController) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicationController, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ReplicationController, metav1.UpdateOptions) error); ok { r1 = rf(ctx, replicationController, opts) } else { r1 = ret.Error(1) @@ -220,20 +268,20 @@ func (_m *ReplicationControllerInterface) UpdateScale(ctx context.Context, repli } // UpdateStatus provides a mock function with given fields: ctx, replicationController, opts -func (_m *ReplicationControllerInterface) UpdateStatus(ctx context.Context, replicationController *v1.ReplicationController, opts metav1.UpdateOptions) (*v1.ReplicationController, error) { +func (_m *ReplicationControllerInterface) UpdateStatus(ctx context.Context, replicationController *corev1.ReplicationController, opts metav1.UpdateOptions) (*corev1.ReplicationController, error) { ret := _m.Called(ctx, replicationController, opts) - var r0 *v1.ReplicationController - if rf, ok := ret.Get(0).(func(context.Context, *v1.ReplicationController, metav1.UpdateOptions) *v1.ReplicationController); ok { + var r0 *corev1.ReplicationController + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ReplicationController, metav1.UpdateOptions) *corev1.ReplicationController); ok { r0 = rf(ctx, replicationController, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ReplicationController) + r0 = ret.Get(0).(*corev1.ReplicationController) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ReplicationController, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ReplicationController, metav1.UpdateOptions) error); ok { r1 = rf(ctx, replicationController, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/resource_quota_interface.go b/testutil/kubernetes_mock/typed/core/v1/resource_quota_interface.go index 672898e96e..7871f05464 100644 --- a/testutil/kubernetes_mock/typed/core/v1/resource_quota_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/resource_quota_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,67 @@ type ResourceQuotaInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, resourceQuota, opts +func (_m *ResourceQuotaInterface) Apply(ctx context.Context, resourceQuota *v1.ResourceQuotaApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ResourceQuota, error) { + ret := _m.Called(ctx, resourceQuota, opts) + + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, *v1.ResourceQuotaApplyConfiguration, metav1.ApplyOptions) *corev1.ResourceQuota); ok { + r0 = rf(ctx, resourceQuota, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ResourceQuota) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ResourceQuotaApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, resourceQuota, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, resourceQuota, opts +func (_m *ResourceQuotaInterface) ApplyStatus(ctx context.Context, resourceQuota *v1.ResourceQuotaApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ResourceQuota, error) { + ret := _m.Called(ctx, resourceQuota, opts) + + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, *v1.ResourceQuotaApplyConfiguration, metav1.ApplyOptions) *corev1.ResourceQuota); ok { + r0 = rf(ctx, resourceQuota, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ResourceQuota) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ResourceQuotaApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, resourceQuota, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, resourceQuota, opts -func (_m *ResourceQuotaInterface) Create(ctx context.Context, resourceQuota *v1.ResourceQuota, opts metav1.CreateOptions) (*v1.ResourceQuota, error) { +func (_m *ResourceQuotaInterface) Create(ctx context.Context, resourceQuota *corev1.ResourceQuota, opts metav1.CreateOptions) (*corev1.ResourceQuota, error) { ret := _m.Called(ctx, resourceQuota, opts) - var r0 *v1.ResourceQuota - if rf, ok := ret.Get(0).(func(context.Context, *v1.ResourceQuota, metav1.CreateOptions) *v1.ResourceQuota); ok { + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ResourceQuota, metav1.CreateOptions) *corev1.ResourceQuota); ok { r0 = rf(ctx, resourceQuota, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ResourceQuota) + r0 = ret.Get(0).(*corev1.ResourceQuota) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ResourceQuota, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ResourceQuota, metav1.CreateOptions) error); ok { r1 = rf(ctx, resourceQuota, opts) } else { r1 = ret.Error(1) @@ -73,15 +121,15 @@ func (_m *ResourceQuotaInterface) DeleteCollection(ctx context.Context, opts met } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ResourceQuotaInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ResourceQuota, error) { +func (_m *ResourceQuotaInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.ResourceQuota, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ResourceQuota - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ResourceQuota); ok { + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.ResourceQuota); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ResourceQuota) + r0 = ret.Get(0).(*corev1.ResourceQuota) } } @@ -96,15 +144,15 @@ func (_m *ResourceQuotaInterface) Get(ctx context.Context, name string, opts met } // List provides a mock function with given fields: ctx, opts -func (_m *ResourceQuotaInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ResourceQuotaList, error) { +func (_m *ResourceQuotaInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ResourceQuotaList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ResourceQuotaList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ResourceQuotaList); ok { + var r0 *corev1.ResourceQuotaList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ResourceQuotaList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ResourceQuotaList) + r0 = ret.Get(0).(*corev1.ResourceQuotaList) } } @@ -119,7 +167,7 @@ func (_m *ResourceQuotaInterface) List(ctx context.Context, opts metav1.ListOpti } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ResourceQuotaInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ResourceQuota, error) { +func (_m *ResourceQuotaInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.ResourceQuota, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +177,12 @@ func (_m *ResourceQuotaInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ResourceQuota - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ResourceQuota); ok { + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.ResourceQuota); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ResourceQuota) + r0 = ret.Get(0).(*corev1.ResourceQuota) } } @@ -149,20 +197,20 @@ func (_m *ResourceQuotaInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, resourceQuota, opts -func (_m *ResourceQuotaInterface) Update(ctx context.Context, resourceQuota *v1.ResourceQuota, opts metav1.UpdateOptions) (*v1.ResourceQuota, error) { +func (_m *ResourceQuotaInterface) Update(ctx context.Context, resourceQuota *corev1.ResourceQuota, opts metav1.UpdateOptions) (*corev1.ResourceQuota, error) { ret := _m.Called(ctx, resourceQuota, opts) - var r0 *v1.ResourceQuota - if rf, ok := ret.Get(0).(func(context.Context, *v1.ResourceQuota, metav1.UpdateOptions) *v1.ResourceQuota); ok { + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ResourceQuota, metav1.UpdateOptions) *corev1.ResourceQuota); ok { r0 = rf(ctx, resourceQuota, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ResourceQuota) + r0 = ret.Get(0).(*corev1.ResourceQuota) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ResourceQuota, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ResourceQuota, metav1.UpdateOptions) error); ok { r1 = rf(ctx, resourceQuota, opts) } else { r1 = ret.Error(1) @@ -172,20 +220,20 @@ func (_m *ResourceQuotaInterface) Update(ctx context.Context, resourceQuota *v1. } // UpdateStatus provides a mock function with given fields: ctx, resourceQuota, opts -func (_m *ResourceQuotaInterface) UpdateStatus(ctx context.Context, resourceQuota *v1.ResourceQuota, opts metav1.UpdateOptions) (*v1.ResourceQuota, error) { +func (_m *ResourceQuotaInterface) UpdateStatus(ctx context.Context, resourceQuota *corev1.ResourceQuota, opts metav1.UpdateOptions) (*corev1.ResourceQuota, error) { ret := _m.Called(ctx, resourceQuota, opts) - var r0 *v1.ResourceQuota - if rf, ok := ret.Get(0).(func(context.Context, *v1.ResourceQuota, metav1.UpdateOptions) *v1.ResourceQuota); ok { + var r0 *corev1.ResourceQuota + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ResourceQuota, metav1.UpdateOptions) *corev1.ResourceQuota); ok { r0 = rf(ctx, resourceQuota, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ResourceQuota) + r0 = ret.Get(0).(*corev1.ResourceQuota) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ResourceQuota, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ResourceQuota, metav1.UpdateOptions) error); ok { r1 = rf(ctx, resourceQuota, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/secret_interface.go b/testutil/kubernetes_mock/typed/core/v1/secret_interface.go index 4c296d8c3a..097f9a8a3c 100644 --- a/testutil/kubernetes_mock/typed/core/v1/secret_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/secret_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type SecretInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, secret, opts +func (_m *SecretInterface) Apply(ctx context.Context, secret *v1.SecretApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Secret, error) { + ret := _m.Called(ctx, secret, opts) + + var r0 *corev1.Secret + if rf, ok := ret.Get(0).(func(context.Context, *v1.SecretApplyConfiguration, metav1.ApplyOptions) *corev1.Secret); ok { + r0 = rf(ctx, secret, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Secret) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.SecretApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, secret, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, secret, opts -func (_m *SecretInterface) Create(ctx context.Context, secret *v1.Secret, opts metav1.CreateOptions) (*v1.Secret, error) { +func (_m *SecretInterface) Create(ctx context.Context, secret *corev1.Secret, opts metav1.CreateOptions) (*corev1.Secret, error) { ret := _m.Called(ctx, secret, opts) - var r0 *v1.Secret - if rf, ok := ret.Get(0).(func(context.Context, *v1.Secret, metav1.CreateOptions) *v1.Secret); ok { + var r0 *corev1.Secret + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Secret, metav1.CreateOptions) *corev1.Secret); ok { r0 = rf(ctx, secret, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Secret) + r0 = ret.Get(0).(*corev1.Secret) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Secret, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Secret, metav1.CreateOptions) error); ok { r1 = rf(ctx, secret, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *SecretInterface) DeleteCollection(ctx context.Context, opts metav1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *SecretInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Secret, error) { +func (_m *SecretInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Secret, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Secret - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Secret); ok { + var r0 *corev1.Secret + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Secret); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Secret) + r0 = ret.Get(0).(*corev1.Secret) } } @@ -96,15 +121,15 @@ func (_m *SecretInterface) Get(ctx context.Context, name string, opts metav1.Get } // List provides a mock function with given fields: ctx, opts -func (_m *SecretInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.SecretList, error) { +func (_m *SecretInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.SecretList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.SecretList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.SecretList); ok { + var r0 *corev1.SecretList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.SecretList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.SecretList) + r0 = ret.Get(0).(*corev1.SecretList) } } @@ -119,7 +144,7 @@ func (_m *SecretInterface) List(ctx context.Context, opts metav1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *SecretInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Secret, error) { +func (_m *SecretInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Secret, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *SecretInterface) Patch(ctx context.Context, name string, pt types.Patc _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Secret - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Secret); ok { + var r0 *corev1.Secret + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Secret); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Secret) + r0 = ret.Get(0).(*corev1.Secret) } } @@ -149,20 +174,20 @@ func (_m *SecretInterface) Patch(ctx context.Context, name string, pt types.Patc } // Update provides a mock function with given fields: ctx, secret, opts -func (_m *SecretInterface) Update(ctx context.Context, secret *v1.Secret, opts metav1.UpdateOptions) (*v1.Secret, error) { +func (_m *SecretInterface) Update(ctx context.Context, secret *corev1.Secret, opts metav1.UpdateOptions) (*corev1.Secret, error) { ret := _m.Called(ctx, secret, opts) - var r0 *v1.Secret - if rf, ok := ret.Get(0).(func(context.Context, *v1.Secret, metav1.UpdateOptions) *v1.Secret); ok { + var r0 *corev1.Secret + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Secret, metav1.UpdateOptions) *corev1.Secret); ok { r0 = rf(ctx, secret, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Secret) + r0 = ret.Get(0).(*corev1.Secret) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Secret, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Secret, metav1.UpdateOptions) error); ok { r1 = rf(ctx, secret, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/service_account_interface.go b/testutil/kubernetes_mock/typed/core/v1/service_account_interface.go index 77d66fb92c..c23e442ac8 100644 --- a/testutil/kubernetes_mock/typed/core/v1/service_account_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/service_account_interface.go @@ -7,13 +7,15 @@ import ( authenticationv1 "k8s.io/api/authentication/v1" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -23,21 +25,44 @@ type ServiceAccountInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, serviceAccount, opts +func (_m *ServiceAccountInterface) Apply(ctx context.Context, serviceAccount *v1.ServiceAccountApplyConfiguration, opts metav1.ApplyOptions) (*corev1.ServiceAccount, error) { + ret := _m.Called(ctx, serviceAccount, opts) + + var r0 *corev1.ServiceAccount + if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceAccountApplyConfiguration, metav1.ApplyOptions) *corev1.ServiceAccount); ok { + r0 = rf(ctx, serviceAccount, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.ServiceAccount) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceAccountApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, serviceAccount, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, serviceAccount, opts -func (_m *ServiceAccountInterface) Create(ctx context.Context, serviceAccount *v1.ServiceAccount, opts metav1.CreateOptions) (*v1.ServiceAccount, error) { +func (_m *ServiceAccountInterface) Create(ctx context.Context, serviceAccount *corev1.ServiceAccount, opts metav1.CreateOptions) (*corev1.ServiceAccount, error) { ret := _m.Called(ctx, serviceAccount, opts) - var r0 *v1.ServiceAccount - if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceAccount, metav1.CreateOptions) *v1.ServiceAccount); ok { + var r0 *corev1.ServiceAccount + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ServiceAccount, metav1.CreateOptions) *corev1.ServiceAccount); ok { r0 = rf(ctx, serviceAccount, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ServiceAccount) + r0 = ret.Get(0).(*corev1.ServiceAccount) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceAccount, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ServiceAccount, metav1.CreateOptions) error); ok { r1 = rf(ctx, serviceAccount, opts) } else { r1 = ret.Error(1) @@ -98,15 +123,15 @@ func (_m *ServiceAccountInterface) DeleteCollection(ctx context.Context, opts me } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ServiceAccountInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ServiceAccount, error) { +func (_m *ServiceAccountInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.ServiceAccount, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ServiceAccount - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ServiceAccount); ok { + var r0 *corev1.ServiceAccount + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.ServiceAccount); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ServiceAccount) + r0 = ret.Get(0).(*corev1.ServiceAccount) } } @@ -121,15 +146,15 @@ func (_m *ServiceAccountInterface) Get(ctx context.Context, name string, opts me } // List provides a mock function with given fields: ctx, opts -func (_m *ServiceAccountInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ServiceAccountList, error) { +func (_m *ServiceAccountInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ServiceAccountList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ServiceAccountList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ServiceAccountList); ok { + var r0 *corev1.ServiceAccountList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ServiceAccountList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ServiceAccountList) + r0 = ret.Get(0).(*corev1.ServiceAccountList) } } @@ -144,7 +169,7 @@ func (_m *ServiceAccountInterface) List(ctx context.Context, opts metav1.ListOpt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ServiceAccountInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ServiceAccount, error) { +func (_m *ServiceAccountInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.ServiceAccount, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -154,12 +179,12 @@ func (_m *ServiceAccountInterface) Patch(ctx context.Context, name string, pt ty _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ServiceAccount - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ServiceAccount); ok { + var r0 *corev1.ServiceAccount + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.ServiceAccount); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ServiceAccount) + r0 = ret.Get(0).(*corev1.ServiceAccount) } } @@ -174,20 +199,20 @@ func (_m *ServiceAccountInterface) Patch(ctx context.Context, name string, pt ty } // Update provides a mock function with given fields: ctx, serviceAccount, opts -func (_m *ServiceAccountInterface) Update(ctx context.Context, serviceAccount *v1.ServiceAccount, opts metav1.UpdateOptions) (*v1.ServiceAccount, error) { +func (_m *ServiceAccountInterface) Update(ctx context.Context, serviceAccount *corev1.ServiceAccount, opts metav1.UpdateOptions) (*corev1.ServiceAccount, error) { ret := _m.Called(ctx, serviceAccount, opts) - var r0 *v1.ServiceAccount - if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceAccount, metav1.UpdateOptions) *v1.ServiceAccount); ok { + var r0 *corev1.ServiceAccount + if rf, ok := ret.Get(0).(func(context.Context, *corev1.ServiceAccount, metav1.UpdateOptions) *corev1.ServiceAccount); ok { r0 = rf(ctx, serviceAccount, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ServiceAccount) + r0 = ret.Get(0).(*corev1.ServiceAccount) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceAccount, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.ServiceAccount, metav1.UpdateOptions) error); ok { r1 = rf(ctx, serviceAccount, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/core/v1/service_interface.go b/testutil/kubernetes_mock/typed/core/v1/service_interface.go index c9c8329b35..b7c5bdea15 100644 --- a/testutil/kubernetes_mock/typed/core/v1/service_interface.go +++ b/testutil/kubernetes_mock/typed/core/v1/service_interface.go @@ -5,6 +5,8 @@ package kubernetes_mocks import ( context "context" + corev1 "k8s.io/api/core/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" @@ -13,7 +15,7 @@ import ( types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/core/v1" + v1 "k8s.io/client-go/applyconfigurations/core/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -23,21 +25,67 @@ type ServiceInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, service, opts +func (_m *ServiceInterface) Apply(ctx context.Context, service *v1.ServiceApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Service, error) { + ret := _m.Called(ctx, service, opts) + + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) *corev1.Service); ok { + r0 = rf(ctx, service, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Service) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, service, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, service, opts +func (_m *ServiceInterface) ApplyStatus(ctx context.Context, service *v1.ServiceApplyConfiguration, opts metav1.ApplyOptions) (*corev1.Service, error) { + ret := _m.Called(ctx, service, opts) + + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) *corev1.Service); ok { + r0 = rf(ctx, service, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*corev1.Service) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ServiceApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, service, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, service, opts -func (_m *ServiceInterface) Create(ctx context.Context, service *v1.Service, opts metav1.CreateOptions) (*v1.Service, error) { +func (_m *ServiceInterface) Create(ctx context.Context, service *corev1.Service, opts metav1.CreateOptions) (*corev1.Service, error) { ret := _m.Called(ctx, service, opts) - var r0 *v1.Service - if rf, ok := ret.Get(0).(func(context.Context, *v1.Service, metav1.CreateOptions) *v1.Service); ok { + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.CreateOptions) *corev1.Service); ok { r0 = rf(ctx, service, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Service) + r0 = ret.Get(0).(*corev1.Service) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Service, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Service, metav1.CreateOptions) error); ok { r1 = rf(ctx, service, opts) } else { r1 = ret.Error(1) @@ -61,15 +109,15 @@ func (_m *ServiceInterface) Delete(ctx context.Context, name string, opts metav1 } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ServiceInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Service, error) { +func (_m *ServiceInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*corev1.Service, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Service - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Service); ok { + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *corev1.Service); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Service) + r0 = ret.Get(0).(*corev1.Service) } } @@ -84,15 +132,15 @@ func (_m *ServiceInterface) Get(ctx context.Context, name string, opts metav1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *ServiceInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ServiceList, error) { +func (_m *ServiceInterface) List(ctx context.Context, opts metav1.ListOptions) (*corev1.ServiceList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ServiceList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ServiceList); ok { + var r0 *corev1.ServiceList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *corev1.ServiceList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ServiceList) + r0 = ret.Get(0).(*corev1.ServiceList) } } @@ -107,7 +155,7 @@ func (_m *ServiceInterface) List(ctx context.Context, opts metav1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ServiceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Service, error) { +func (_m *ServiceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*corev1.Service, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -117,12 +165,12 @@ func (_m *ServiceInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Service - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Service); ok { + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *corev1.Service); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Service) + r0 = ret.Get(0).(*corev1.Service) } } @@ -153,20 +201,20 @@ func (_m *ServiceInterface) ProxyGet(scheme string, name string, port string, pa } // Update provides a mock function with given fields: ctx, service, opts -func (_m *ServiceInterface) Update(ctx context.Context, service *v1.Service, opts metav1.UpdateOptions) (*v1.Service, error) { +func (_m *ServiceInterface) Update(ctx context.Context, service *corev1.Service, opts metav1.UpdateOptions) (*corev1.Service, error) { ret := _m.Called(ctx, service, opts) - var r0 *v1.Service - if rf, ok := ret.Get(0).(func(context.Context, *v1.Service, metav1.UpdateOptions) *v1.Service); ok { + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.UpdateOptions) *corev1.Service); ok { r0 = rf(ctx, service, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Service) + r0 = ret.Get(0).(*corev1.Service) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Service, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Service, metav1.UpdateOptions) error); ok { r1 = rf(ctx, service, opts) } else { r1 = ret.Error(1) @@ -176,20 +224,20 @@ func (_m *ServiceInterface) Update(ctx context.Context, service *v1.Service, opt } // UpdateStatus provides a mock function with given fields: ctx, service, opts -func (_m *ServiceInterface) UpdateStatus(ctx context.Context, service *v1.Service, opts metav1.UpdateOptions) (*v1.Service, error) { +func (_m *ServiceInterface) UpdateStatus(ctx context.Context, service *corev1.Service, opts metav1.UpdateOptions) (*corev1.Service, error) { ret := _m.Called(ctx, service, opts) - var r0 *v1.Service - if rf, ok := ret.Get(0).(func(context.Context, *v1.Service, metav1.UpdateOptions) *v1.Service); ok { + var r0 *corev1.Service + if rf, ok := ret.Get(0).(func(context.Context, *corev1.Service, metav1.UpdateOptions) *corev1.Service); ok { r0 = rf(ctx, service, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Service) + r0 = ret.Get(0).(*corev1.Service) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Service, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *corev1.Service, metav1.UpdateOptions) error); ok { r1 = rf(ctx, service, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/discovery/v1alpha1/discovery_v1alpha1_interface.go b/testutil/kubernetes_mock/typed/discovery/v1/discovery_v1_interface.go similarity index 52% rename from testutil/kubernetes_mock/typed/discovery/v1alpha1/discovery_v1alpha1_interface.go rename to testutil/kubernetes_mock/typed/discovery/v1/discovery_v1_interface.go index 4dd8da77ab..f0f5a59183 100644 --- a/testutil/kubernetes_mock/typed/discovery/v1alpha1/discovery_v1alpha1_interface.go +++ b/testutil/kubernetes_mock/typed/discovery/v1/discovery_v1_interface.go @@ -6,24 +6,24 @@ import ( mock "github.com/stretchr/testify/mock" rest "k8s.io/client-go/rest" - v1alpha1 "k8s.io/client-go/kubernetes/typed/discovery/v1alpha1" + v1 "k8s.io/client-go/kubernetes/typed/discovery/v1" ) -// DiscoveryV1alpha1Interface is an autogenerated mock type for the DiscoveryV1alpha1Interface type -type DiscoveryV1alpha1Interface struct { +// DiscoveryV1Interface is an autogenerated mock type for the DiscoveryV1Interface type +type DiscoveryV1Interface struct { mock.Mock } // EndpointSlices provides a mock function with given fields: namespace -func (_m *DiscoveryV1alpha1Interface) EndpointSlices(namespace string) v1alpha1.EndpointSliceInterface { +func (_m *DiscoveryV1Interface) EndpointSlices(namespace string) v1.EndpointSliceInterface { ret := _m.Called(namespace) - var r0 v1alpha1.EndpointSliceInterface - if rf, ok := ret.Get(0).(func(string) v1alpha1.EndpointSliceInterface); ok { + var r0 v1.EndpointSliceInterface + if rf, ok := ret.Get(0).(func(string) v1.EndpointSliceInterface); ok { r0 = rf(namespace) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(v1alpha1.EndpointSliceInterface) + r0 = ret.Get(0).(v1.EndpointSliceInterface) } } @@ -31,7 +31,7 @@ func (_m *DiscoveryV1alpha1Interface) EndpointSlices(namespace string) v1alpha1. } // RESTClient provides a mock function with given fields: -func (_m *DiscoveryV1alpha1Interface) RESTClient() rest.Interface { +func (_m *DiscoveryV1Interface) RESTClient() rest.Interface { ret := _m.Called() var r0 rest.Interface diff --git a/testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slice_expansion.go b/testutil/kubernetes_mock/typed/discovery/v1/endpoint_slice_expansion.go similarity index 100% rename from testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slice_expansion.go rename to testutil/kubernetes_mock/typed/discovery/v1/endpoint_slice_expansion.go diff --git a/testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slice_interface.go b/testutil/kubernetes_mock/typed/discovery/v1/endpoint_slice_interface.go similarity index 50% rename from testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slice_interface.go rename to testutil/kubernetes_mock/typed/discovery/v1/endpoint_slice_interface.go index 56d1514a0f..e329091ed5 100644 --- a/testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slice_interface.go +++ b/testutil/kubernetes_mock/typed/discovery/v1/endpoint_slice_interface.go @@ -5,13 +5,14 @@ package kubernetes_mocks import ( context "context" + discoveryv1 "k8s.io/api/discovery/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - v1alpha1 "k8s.io/api/discovery/v1alpha1" + v1 "k8s.io/client-go/applyconfigurations/discovery/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type EndpointSliceInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, endpointSlice, opts +func (_m *EndpointSliceInterface) Apply(ctx context.Context, endpointSlice *v1.EndpointSliceApplyConfiguration, opts metav1.ApplyOptions) (*discoveryv1.EndpointSlice, error) { + ret := _m.Called(ctx, endpointSlice, opts) + + var r0 *discoveryv1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, *v1.EndpointSliceApplyConfiguration, metav1.ApplyOptions) *discoveryv1.EndpointSlice); ok { + r0 = rf(ctx, endpointSlice, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*discoveryv1.EndpointSlice) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.EndpointSliceApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, endpointSlice, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, endpointSlice, opts -func (_m *EndpointSliceInterface) Create(ctx context.Context, endpointSlice *v1alpha1.EndpointSlice, opts v1.CreateOptions) (*v1alpha1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Create(ctx context.Context, endpointSlice *discoveryv1.EndpointSlice, opts metav1.CreateOptions) (*discoveryv1.EndpointSlice, error) { ret := _m.Called(ctx, endpointSlice, opts) - var r0 *v1alpha1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.EndpointSlice, v1.CreateOptions) *v1alpha1.EndpointSlice); ok { + var r0 *discoveryv1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, *discoveryv1.EndpointSlice, metav1.CreateOptions) *discoveryv1.EndpointSlice); ok { r0 = rf(ctx, endpointSlice, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1.EndpointSlice) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.EndpointSlice, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *discoveryv1.EndpointSlice, metav1.CreateOptions) error); ok { r1 = rf(ctx, endpointSlice, opts) } else { r1 = ret.Error(1) @@ -45,11 +69,11 @@ func (_m *EndpointSliceInterface) Create(ctx context.Context, endpointSlice *v1a } // Delete provides a mock function with given fields: ctx, name, opts -func (_m *EndpointSliceInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { +func (_m *EndpointSliceInterface) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { ret := _m.Called(ctx, name, opts) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.DeleteOptions) error); ok { r0 = rf(ctx, name, opts) } else { r0 = ret.Error(0) @@ -59,11 +83,11 @@ func (_m *EndpointSliceInterface) Delete(ctx context.Context, name string, opts } // DeleteCollection provides a mock function with given fields: ctx, opts, listOpts -func (_m *EndpointSliceInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { +func (_m *EndpointSliceInterface) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { ret := _m.Called(ctx, opts, listOpts) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { + if rf, ok := ret.Get(0).(func(context.Context, metav1.DeleteOptions, metav1.ListOptions) error); ok { r0 = rf(ctx, opts, listOpts) } else { r0 = ret.Error(0) @@ -73,20 +97,20 @@ func (_m *EndpointSliceInterface) DeleteCollection(ctx context.Context, opts v1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *EndpointSliceInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*discoveryv1.EndpointSlice, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.EndpointSlice); ok { + var r0 *discoveryv1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *discoveryv1.EndpointSlice); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1.EndpointSlice) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, metav1.GetOptions) error); ok { r1 = rf(ctx, name, opts) } else { r1 = ret.Error(1) @@ -96,20 +120,20 @@ func (_m *EndpointSliceInterface) Get(ctx context.Context, name string, opts v1. } // List provides a mock function with given fields: ctx, opts -func (_m *EndpointSliceInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.EndpointSliceList, error) { +func (_m *EndpointSliceInterface) List(ctx context.Context, opts metav1.ListOptions) (*discoveryv1.EndpointSliceList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.EndpointSliceList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.EndpointSliceList); ok { + var r0 *discoveryv1.EndpointSliceList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *discoveryv1.EndpointSliceList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.EndpointSliceList) + r0 = ret.Get(0).(*discoveryv1.EndpointSliceList) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { r1 = rf(ctx, opts) } else { r1 = ret.Error(1) @@ -119,7 +143,7 @@ func (_m *EndpointSliceInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*discoveryv1.EndpointSlice, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,17 +153,17 @@ func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.EndpointSlice); ok { + var r0 *discoveryv1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *discoveryv1.EndpointSlice); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1.EndpointSlice) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) error); ok { r1 = rf(ctx, name, pt, data, opts, subresources...) } else { r1 = ret.Error(1) @@ -149,20 +173,20 @@ func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, endpointSlice, opts -func (_m *EndpointSliceInterface) Update(ctx context.Context, endpointSlice *v1alpha1.EndpointSlice, opts v1.UpdateOptions) (*v1alpha1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Update(ctx context.Context, endpointSlice *discoveryv1.EndpointSlice, opts metav1.UpdateOptions) (*discoveryv1.EndpointSlice, error) { ret := _m.Called(ctx, endpointSlice, opts) - var r0 *v1alpha1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.EndpointSlice, v1.UpdateOptions) *v1alpha1.EndpointSlice); ok { + var r0 *discoveryv1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, *discoveryv1.EndpointSlice, metav1.UpdateOptions) *discoveryv1.EndpointSlice); ok { r0 = rf(ctx, endpointSlice, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1.EndpointSlice) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.EndpointSlice, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *discoveryv1.EndpointSlice, metav1.UpdateOptions) error); ok { r1 = rf(ctx, endpointSlice, opts) } else { r1 = ret.Error(1) @@ -172,11 +196,11 @@ func (_m *EndpointSliceInterface) Update(ctx context.Context, endpointSlice *v1a } // Watch provides a mock function with given fields: ctx, opts -func (_m *EndpointSliceInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { +func (_m *EndpointSliceInterface) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) { ret := _m.Called(ctx, opts) var r0 watch.Interface - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) watch.Interface); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { @@ -185,7 +209,7 @@ func (_m *EndpointSliceInterface) Watch(ctx context.Context, opts v1.ListOptions } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { r1 = rf(ctx, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slices_getter.go b/testutil/kubernetes_mock/typed/discovery/v1/endpoint_slices_getter.go similarity index 65% rename from testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slices_getter.go rename to testutil/kubernetes_mock/typed/discovery/v1/endpoint_slices_getter.go index e148f1233a..3d7380bdab 100644 --- a/testutil/kubernetes_mock/typed/discovery/v1alpha1/endpoint_slices_getter.go +++ b/testutil/kubernetes_mock/typed/discovery/v1/endpoint_slices_getter.go @@ -4,7 +4,7 @@ package kubernetes_mocks import ( mock "github.com/stretchr/testify/mock" - v1alpha1 "k8s.io/client-go/kubernetes/typed/discovery/v1alpha1" + v1 "k8s.io/client-go/kubernetes/typed/discovery/v1" ) // EndpointSlicesGetter is an autogenerated mock type for the EndpointSlicesGetter type @@ -13,15 +13,15 @@ type EndpointSlicesGetter struct { } // EndpointSlices provides a mock function with given fields: namespace -func (_m *EndpointSlicesGetter) EndpointSlices(namespace string) v1alpha1.EndpointSliceInterface { +func (_m *EndpointSlicesGetter) EndpointSlices(namespace string) v1.EndpointSliceInterface { ret := _m.Called(namespace) - var r0 v1alpha1.EndpointSliceInterface - if rf, ok := ret.Get(0).(func(string) v1alpha1.EndpointSliceInterface); ok { + var r0 v1.EndpointSliceInterface + if rf, ok := ret.Get(0).(func(string) v1.EndpointSliceInterface); ok { r0 = rf(namespace) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(v1alpha1.EndpointSliceInterface) + r0 = ret.Get(0).(v1.EndpointSliceInterface) } } diff --git a/testutil/kubernetes_mock/typed/discovery/v1beta1/endpoint_slice_interface.go b/testutil/kubernetes_mock/typed/discovery/v1beta1/endpoint_slice_interface.go index 2b0fee7c3a..f4dfd5e8c8 100644 --- a/testutil/kubernetes_mock/typed/discovery/v1beta1/endpoint_slice_interface.go +++ b/testutil/kubernetes_mock/typed/discovery/v1beta1/endpoint_slice_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + discoveryv1beta1 "k8s.io/api/discovery/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/discovery/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/discovery/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type EndpointSliceInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, endpointSlice, opts +func (_m *EndpointSliceInterface) Apply(ctx context.Context, endpointSlice *v1beta1.EndpointSliceApplyConfiguration, opts v1.ApplyOptions) (*discoveryv1beta1.EndpointSlice, error) { + ret := _m.Called(ctx, endpointSlice, opts) + + var r0 *discoveryv1beta1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.EndpointSliceApplyConfiguration, v1.ApplyOptions) *discoveryv1beta1.EndpointSlice); ok { + r0 = rf(ctx, endpointSlice, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*discoveryv1beta1.EndpointSlice) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.EndpointSliceApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, endpointSlice, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, endpointSlice, opts -func (_m *EndpointSliceInterface) Create(ctx context.Context, endpointSlice *v1beta1.EndpointSlice, opts v1.CreateOptions) (*v1beta1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Create(ctx context.Context, endpointSlice *discoveryv1beta1.EndpointSlice, opts v1.CreateOptions) (*discoveryv1beta1.EndpointSlice, error) { ret := _m.Called(ctx, endpointSlice, opts) - var r0 *v1beta1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.EndpointSlice, v1.CreateOptions) *v1beta1.EndpointSlice); ok { + var r0 *discoveryv1beta1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, *discoveryv1beta1.EndpointSlice, v1.CreateOptions) *discoveryv1beta1.EndpointSlice); ok { r0 = rf(ctx, endpointSlice, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1beta1.EndpointSlice) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.EndpointSlice, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *discoveryv1beta1.EndpointSlice, v1.CreateOptions) error); ok { r1 = rf(ctx, endpointSlice, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *EndpointSliceInterface) DeleteCollection(ctx context.Context, opts v1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *EndpointSliceInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*discoveryv1beta1.EndpointSlice, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.EndpointSlice); ok { + var r0 *discoveryv1beta1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *discoveryv1beta1.EndpointSlice); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1beta1.EndpointSlice) } } @@ -96,15 +120,15 @@ func (_m *EndpointSliceInterface) Get(ctx context.Context, name string, opts v1. } // List provides a mock function with given fields: ctx, opts -func (_m *EndpointSliceInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.EndpointSliceList, error) { +func (_m *EndpointSliceInterface) List(ctx context.Context, opts v1.ListOptions) (*discoveryv1beta1.EndpointSliceList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.EndpointSliceList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.EndpointSliceList); ok { + var r0 *discoveryv1beta1.EndpointSliceList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *discoveryv1beta1.EndpointSliceList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.EndpointSliceList) + r0 = ret.Get(0).(*discoveryv1beta1.EndpointSliceList) } } @@ -119,7 +143,7 @@ func (_m *EndpointSliceInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*discoveryv1beta1.EndpointSlice, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.EndpointSlice); ok { + var r0 *discoveryv1beta1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *discoveryv1beta1.EndpointSlice); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1beta1.EndpointSlice) } } @@ -149,20 +173,20 @@ func (_m *EndpointSliceInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, endpointSlice, opts -func (_m *EndpointSliceInterface) Update(ctx context.Context, endpointSlice *v1beta1.EndpointSlice, opts v1.UpdateOptions) (*v1beta1.EndpointSlice, error) { +func (_m *EndpointSliceInterface) Update(ctx context.Context, endpointSlice *discoveryv1beta1.EndpointSlice, opts v1.UpdateOptions) (*discoveryv1beta1.EndpointSlice, error) { ret := _m.Called(ctx, endpointSlice, opts) - var r0 *v1beta1.EndpointSlice - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.EndpointSlice, v1.UpdateOptions) *v1beta1.EndpointSlice); ok { + var r0 *discoveryv1beta1.EndpointSlice + if rf, ok := ret.Get(0).(func(context.Context, *discoveryv1beta1.EndpointSlice, v1.UpdateOptions) *discoveryv1beta1.EndpointSlice); ok { r0 = rf(ctx, endpointSlice, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.EndpointSlice) + r0 = ret.Get(0).(*discoveryv1beta1.EndpointSlice) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.EndpointSlice, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *discoveryv1beta1.EndpointSlice, v1.UpdateOptions) error); ok { r1 = rf(ctx, endpointSlice, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/events/v1/event_interface.go b/testutil/kubernetes_mock/typed/events/v1/event_interface.go index 534e050cf6..ac591205be 100644 --- a/testutil/kubernetes_mock/typed/events/v1/event_interface.go +++ b/testutil/kubernetes_mock/typed/events/v1/event_interface.go @@ -5,13 +5,15 @@ package kubernetes_mocks import ( context "context" + eventsv1 "k8s.io/api/events/v1" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" mock "github.com/stretchr/testify/mock" types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/events/v1" + v1 "k8s.io/client-go/applyconfigurations/events/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +23,44 @@ type EventInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, event, opts +func (_m *EventInterface) Apply(ctx context.Context, event *v1.EventApplyConfiguration, opts metav1.ApplyOptions) (*eventsv1.Event, error) { + ret := _m.Called(ctx, event, opts) + + var r0 *eventsv1.Event + if rf, ok := ret.Get(0).(func(context.Context, *v1.EventApplyConfiguration, metav1.ApplyOptions) *eventsv1.Event); ok { + r0 = rf(ctx, event, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*eventsv1.Event) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.EventApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, event, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, event, opts -func (_m *EventInterface) Create(ctx context.Context, event *v1.Event, opts metav1.CreateOptions) (*v1.Event, error) { +func (_m *EventInterface) Create(ctx context.Context, event *eventsv1.Event, opts metav1.CreateOptions) (*eventsv1.Event, error) { ret := _m.Called(ctx, event, opts) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, *v1.Event, metav1.CreateOptions) *v1.Event); ok { + var r0 *eventsv1.Event + if rf, ok := ret.Get(0).(func(context.Context, *eventsv1.Event, metav1.CreateOptions) *eventsv1.Event); ok { r0 = rf(ctx, event, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*eventsv1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Event, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *eventsv1.Event, metav1.CreateOptions) error); ok { r1 = rf(ctx, event, opts) } else { r1 = ret.Error(1) @@ -73,15 +98,15 @@ func (_m *EventInterface) DeleteCollection(ctx context.Context, opts metav1.Dele } // Get provides a mock function with given fields: ctx, name, opts -func (_m *EventInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Event, error) { +func (_m *EventInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*eventsv1.Event, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Event); ok { + var r0 *eventsv1.Event + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *eventsv1.Event); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*eventsv1.Event) } } @@ -96,15 +121,15 @@ func (_m *EventInterface) Get(ctx context.Context, name string, opts metav1.GetO } // List provides a mock function with given fields: ctx, opts -func (_m *EventInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.EventList, error) { +func (_m *EventInterface) List(ctx context.Context, opts metav1.ListOptions) (*eventsv1.EventList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.EventList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.EventList); ok { + var r0 *eventsv1.EventList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *eventsv1.EventList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.EventList) + r0 = ret.Get(0).(*eventsv1.EventList) } } @@ -119,7 +144,7 @@ func (_m *EventInterface) List(ctx context.Context, opts metav1.ListOptions) (*v } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Event, error) { +func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*eventsv1.Event, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +154,12 @@ func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.Patch _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Event); ok { + var r0 *eventsv1.Event + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *eventsv1.Event); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*eventsv1.Event) } } @@ -149,20 +174,20 @@ func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.Patch } // Update provides a mock function with given fields: ctx, event, opts -func (_m *EventInterface) Update(ctx context.Context, event *v1.Event, opts metav1.UpdateOptions) (*v1.Event, error) { +func (_m *EventInterface) Update(ctx context.Context, event *eventsv1.Event, opts metav1.UpdateOptions) (*eventsv1.Event, error) { ret := _m.Called(ctx, event, opts) - var r0 *v1.Event - if rf, ok := ret.Get(0).(func(context.Context, *v1.Event, metav1.UpdateOptions) *v1.Event); ok { + var r0 *eventsv1.Event + if rf, ok := ret.Get(0).(func(context.Context, *eventsv1.Event, metav1.UpdateOptions) *eventsv1.Event); ok { r0 = rf(ctx, event, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Event) + r0 = ret.Get(0).(*eventsv1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Event, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *eventsv1.Event, metav1.UpdateOptions) error); ok { r1 = rf(ctx, event, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/events/v1beta1/event_interface.go b/testutil/kubernetes_mock/typed/events/v1beta1/event_interface.go index a6ee0a0aa8..d669adeb28 100644 --- a/testutil/kubernetes_mock/typed/events/v1beta1/event_interface.go +++ b/testutil/kubernetes_mock/typed/events/v1beta1/event_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + eventsv1beta1 "k8s.io/api/events/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/events/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/events/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type EventInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, event, opts +func (_m *EventInterface) Apply(ctx context.Context, event *v1beta1.EventApplyConfiguration, opts v1.ApplyOptions) (*eventsv1beta1.Event, error) { + ret := _m.Called(ctx, event, opts) + + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.EventApplyConfiguration, v1.ApplyOptions) *eventsv1beta1.Event); ok { + r0 = rf(ctx, event, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*eventsv1beta1.Event) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.EventApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, event, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, event, opts -func (_m *EventInterface) Create(ctx context.Context, event *v1beta1.Event, opts v1.CreateOptions) (*v1beta1.Event, error) { +func (_m *EventInterface) Create(ctx context.Context, event *eventsv1beta1.Event, opts v1.CreateOptions) (*eventsv1beta1.Event, error) { ret := _m.Called(ctx, event, opts) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Event, v1.CreateOptions) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(context.Context, *eventsv1beta1.Event, v1.CreateOptions) *eventsv1beta1.Event); ok { r0 = rf(ctx, event, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Event, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *eventsv1beta1.Event, v1.CreateOptions) error); ok { r1 = rf(ctx, event, opts) } else { r1 = ret.Error(1) @@ -45,20 +69,20 @@ func (_m *EventInterface) Create(ctx context.Context, event *v1beta1.Event, opts } // CreateWithEventNamespace provides a mock function with given fields: event -func (_m *EventInterface) CreateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) { +func (_m *EventInterface) CreateWithEventNamespace(event *eventsv1beta1.Event) (*eventsv1beta1.Event, error) { ret := _m.Called(event) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(*v1beta1.Event) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(*eventsv1beta1.Event) *eventsv1beta1.Event); ok { r0 = rf(event) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(*v1beta1.Event) error); ok { + if rf, ok := ret.Get(1).(func(*eventsv1beta1.Event) error); ok { r1 = rf(event) } else { r1 = ret.Error(1) @@ -96,15 +120,15 @@ func (_m *EventInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOp } // Get provides a mock function with given fields: ctx, name, opts -func (_m *EventInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Event, error) { +func (_m *EventInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*eventsv1beta1.Event, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *eventsv1beta1.Event); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } @@ -119,15 +143,15 @@ func (_m *EventInterface) Get(ctx context.Context, name string, opts v1.GetOptio } // List provides a mock function with given fields: ctx, opts -func (_m *EventInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.EventList, error) { +func (_m *EventInterface) List(ctx context.Context, opts v1.ListOptions) (*eventsv1beta1.EventList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.EventList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.EventList); ok { + var r0 *eventsv1beta1.EventList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *eventsv1beta1.EventList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.EventList) + r0 = ret.Get(0).(*eventsv1beta1.EventList) } } @@ -142,7 +166,7 @@ func (_m *EventInterface) List(ctx context.Context, opts v1.ListOptions) (*v1bet } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Event, error) { +func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*eventsv1beta1.Event, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -152,12 +176,12 @@ func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.Patch _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *eventsv1beta1.Event); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } @@ -172,20 +196,20 @@ func (_m *EventInterface) Patch(ctx context.Context, name string, pt types.Patch } // PatchWithEventNamespace provides a mock function with given fields: event, data -func (_m *EventInterface) PatchWithEventNamespace(event *v1beta1.Event, data []byte) (*v1beta1.Event, error) { +func (_m *EventInterface) PatchWithEventNamespace(event *eventsv1beta1.Event, data []byte) (*eventsv1beta1.Event, error) { ret := _m.Called(event, data) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(*v1beta1.Event, []byte) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(*eventsv1beta1.Event, []byte) *eventsv1beta1.Event); ok { r0 = rf(event, data) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(*v1beta1.Event, []byte) error); ok { + if rf, ok := ret.Get(1).(func(*eventsv1beta1.Event, []byte) error); ok { r1 = rf(event, data) } else { r1 = ret.Error(1) @@ -195,20 +219,20 @@ func (_m *EventInterface) PatchWithEventNamespace(event *v1beta1.Event, data []b } // Update provides a mock function with given fields: ctx, event, opts -func (_m *EventInterface) Update(ctx context.Context, event *v1beta1.Event, opts v1.UpdateOptions) (*v1beta1.Event, error) { +func (_m *EventInterface) Update(ctx context.Context, event *eventsv1beta1.Event, opts v1.UpdateOptions) (*eventsv1beta1.Event, error) { ret := _m.Called(ctx, event, opts) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Event, v1.UpdateOptions) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(context.Context, *eventsv1beta1.Event, v1.UpdateOptions) *eventsv1beta1.Event); ok { r0 = rf(ctx, event, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Event, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *eventsv1beta1.Event, v1.UpdateOptions) error); ok { r1 = rf(ctx, event, opts) } else { r1 = ret.Error(1) @@ -218,20 +242,20 @@ func (_m *EventInterface) Update(ctx context.Context, event *v1beta1.Event, opts } // UpdateWithEventNamespace provides a mock function with given fields: event -func (_m *EventInterface) UpdateWithEventNamespace(event *v1beta1.Event) (*v1beta1.Event, error) { +func (_m *EventInterface) UpdateWithEventNamespace(event *eventsv1beta1.Event) (*eventsv1beta1.Event, error) { ret := _m.Called(event) - var r0 *v1beta1.Event - if rf, ok := ret.Get(0).(func(*v1beta1.Event) *v1beta1.Event); ok { + var r0 *eventsv1beta1.Event + if rf, ok := ret.Get(0).(func(*eventsv1beta1.Event) *eventsv1beta1.Event); ok { r0 = rf(event) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Event) + r0 = ret.Get(0).(*eventsv1beta1.Event) } } var r1 error - if rf, ok := ret.Get(1).(func(*v1beta1.Event) error); ok { + if rf, ok := ret.Get(1).(func(*eventsv1beta1.Event) error); ok { r1 = rf(event) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/extensions/v1beta1/daemon_set_interface.go b/testutil/kubernetes_mock/typed/extensions/v1beta1/daemon_set_interface.go index 0bb1047804..5c7c411fbd 100644 --- a/testutil/kubernetes_mock/typed/extensions/v1beta1/daemon_set_interface.go +++ b/testutil/kubernetes_mock/typed/extensions/v1beta1/daemon_set_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/extensions/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/extensions/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type DaemonSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, daemonSet, opts +func (_m *DaemonSetInterface) Apply(ctx context.Context, daemonSet *v1beta1.DaemonSetApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.DaemonSet, error) { + ret := _m.Called(ctx, daemonSet, opts) + + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DaemonSetApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.DaemonSet); ok { + r0 = rf(ctx, daemonSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DaemonSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, daemonSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, daemonSet, opts +func (_m *DaemonSetInterface) ApplyStatus(ctx context.Context, daemonSet *v1beta1.DaemonSetApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.DaemonSet, error) { + ret := _m.Called(ctx, daemonSet, opts) + + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DaemonSetApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.DaemonSet); ok { + r0 = rf(ctx, daemonSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DaemonSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, daemonSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) Create(ctx context.Context, daemonSet *v1beta1.DaemonSet, opts v1.CreateOptions) (*v1beta1.DaemonSet, error) { +func (_m *DaemonSetInterface) Create(ctx context.Context, daemonSet *extensionsv1beta1.DaemonSet, opts v1.CreateOptions) (*extensionsv1beta1.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1beta1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DaemonSet, v1.CreateOptions) *v1beta1.DaemonSet); ok { + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.DaemonSet, v1.CreateOptions) *extensionsv1beta1.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DaemonSet) + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DaemonSet, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.DaemonSet, v1.CreateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *DaemonSetInterface) DeleteCollection(ctx context.Context, opts v1.Dele } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.DaemonSet, error) { +func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*extensionsv1beta1.DaemonSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.DaemonSet); ok { + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.DaemonSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DaemonSet) + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) } } @@ -96,15 +143,15 @@ func (_m *DaemonSetInterface) Get(ctx context.Context, name string, opts v1.GetO } // List provides a mock function with given fields: ctx, opts -func (_m *DaemonSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.DaemonSetList, error) { +func (_m *DaemonSetInterface) List(ctx context.Context, opts v1.ListOptions) (*extensionsv1beta1.DaemonSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.DaemonSetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.DaemonSetList); ok { + var r0 *extensionsv1beta1.DaemonSetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *extensionsv1beta1.DaemonSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DaemonSetList) + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSetList) } } @@ -119,7 +166,7 @@ func (_m *DaemonSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.DaemonSet, error) { +func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*extensionsv1beta1.DaemonSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.DaemonSet); ok { + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *extensionsv1beta1.DaemonSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DaemonSet) + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) } } @@ -149,20 +196,20 @@ func (_m *DaemonSetInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *v1beta1.DaemonSet, opts v1.UpdateOptions) (*v1beta1.DaemonSet, error) { +func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *extensionsv1beta1.DaemonSet, opts v1.UpdateOptions) (*extensionsv1beta1.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1beta1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DaemonSet, v1.UpdateOptions) *v1beta1.DaemonSet); ok { + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.DaemonSet, v1.UpdateOptions) *extensionsv1beta1.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DaemonSet) + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DaemonSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.DaemonSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *DaemonSetInterface) Update(ctx context.Context, daemonSet *v1beta1.Dae } // UpdateStatus provides a mock function with given fields: ctx, daemonSet, opts -func (_m *DaemonSetInterface) UpdateStatus(ctx context.Context, daemonSet *v1beta1.DaemonSet, opts v1.UpdateOptions) (*v1beta1.DaemonSet, error) { +func (_m *DaemonSetInterface) UpdateStatus(ctx context.Context, daemonSet *extensionsv1beta1.DaemonSet, opts v1.UpdateOptions) (*extensionsv1beta1.DaemonSet, error) { ret := _m.Called(ctx, daemonSet, opts) - var r0 *v1beta1.DaemonSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DaemonSet, v1.UpdateOptions) *v1beta1.DaemonSet); ok { + var r0 *extensionsv1beta1.DaemonSet + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.DaemonSet, v1.UpdateOptions) *extensionsv1beta1.DaemonSet); ok { r0 = rf(ctx, daemonSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DaemonSet) + r0 = ret.Get(0).(*extensionsv1beta1.DaemonSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DaemonSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.DaemonSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, daemonSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/extensions/v1beta1/deployment_interface.go b/testutil/kubernetes_mock/typed/extensions/v1beta1/deployment_interface.go index 429783901e..348f73adfb 100644 --- a/testutil/kubernetes_mock/typed/extensions/v1beta1/deployment_interface.go +++ b/testutil/kubernetes_mock/typed/extensions/v1beta1/deployment_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/extensions/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/extensions/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type DeploymentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) Apply(ctx context.Context, deployment *v1beta1.DeploymentApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, deployment, opts +func (_m *DeploymentInterface) ApplyStatus(ctx context.Context, deployment *v1beta1.DeploymentApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.Deployment, error) { + ret := _m.Called(ctx, deployment, opts) + + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.Deployment); ok { + r0 = rf(ctx, deployment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.DeploymentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, deployment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Create(ctx context.Context, deployment *v1beta1.Deployment, opts v1.CreateOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Create(ctx context.Context, deployment *extensionsv1beta1.Deployment, opts v1.CreateOptions) (*extensionsv1beta1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Deployment, v1.CreateOptions) *v1beta1.Deployment); ok { + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.Deployment, v1.CreateOptions) *extensionsv1beta1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Deployment, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.Deployment, v1.CreateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *DeploymentInterface) DeleteCollection(ctx context.Context, opts v1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*extensionsv1beta1.Deployment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Deployment); ok { + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.Deployment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) } } @@ -96,15 +143,15 @@ func (_m *DeploymentInterface) Get(ctx context.Context, name string, opts v1.Get } // GetScale provides a mock function with given fields: ctx, deploymentName, options -func (_m *DeploymentInterface) GetScale(ctx context.Context, deploymentName string, options v1.GetOptions) (*v1beta1.Scale, error) { +func (_m *DeploymentInterface) GetScale(ctx context.Context, deploymentName string, options v1.GetOptions) (*extensionsv1beta1.Scale, error) { ret := _m.Called(ctx, deploymentName, options) - var r0 *v1beta1.Scale - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Scale); ok { + var r0 *extensionsv1beta1.Scale + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.Scale); ok { r0 = rf(ctx, deploymentName, options) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Scale) + r0 = ret.Get(0).(*extensionsv1beta1.Scale) } } @@ -119,15 +166,15 @@ func (_m *DeploymentInterface) GetScale(ctx context.Context, deploymentName stri } // List provides a mock function with given fields: ctx, opts -func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.DeploymentList, error) { +func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (*extensionsv1beta1.DeploymentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.DeploymentList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.DeploymentList); ok { + var r0 *extensionsv1beta1.DeploymentList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *extensionsv1beta1.DeploymentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.DeploymentList) + r0 = ret.Get(0).(*extensionsv1beta1.DeploymentList) } } @@ -142,7 +189,7 @@ func (_m *DeploymentInterface) List(ctx context.Context, opts v1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*extensionsv1beta1.Deployment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -152,12 +199,12 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Deployment); ok { + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *extensionsv1beta1.Deployment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) } } @@ -172,11 +219,11 @@ func (_m *DeploymentInterface) Patch(ctx context.Context, name string, pt types. } // Rollback provides a mock function with given fields: _a0, _a1, _a2 -func (_m *DeploymentInterface) Rollback(_a0 context.Context, _a1 *v1beta1.DeploymentRollback, _a2 v1.CreateOptions) error { +func (_m *DeploymentInterface) Rollback(_a0 context.Context, _a1 *extensionsv1beta1.DeploymentRollback, _a2 v1.CreateOptions) error { ret := _m.Called(_a0, _a1, _a2) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.DeploymentRollback, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.DeploymentRollback, v1.CreateOptions) error); ok { r0 = rf(_a0, _a1, _a2) } else { r0 = ret.Error(0) @@ -186,20 +233,20 @@ func (_m *DeploymentInterface) Rollback(_a0 context.Context, _a1 *v1beta1.Deploy } // Update provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1beta1.Deployment, opts v1.UpdateOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) Update(ctx context.Context, deployment *extensionsv1beta1.Deployment, opts v1.UpdateOptions) (*extensionsv1beta1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) *v1beta1.Deployment); ok { + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.Deployment, v1.UpdateOptions) *extensionsv1beta1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.Deployment, v1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) @@ -209,20 +256,20 @@ func (_m *DeploymentInterface) Update(ctx context.Context, deployment *v1beta1.D } // UpdateScale provides a mock function with given fields: ctx, deploymentName, scale, opts -func (_m *DeploymentInterface) UpdateScale(ctx context.Context, deploymentName string, scale *v1beta1.Scale, opts v1.UpdateOptions) (*v1beta1.Scale, error) { +func (_m *DeploymentInterface) UpdateScale(ctx context.Context, deploymentName string, scale *extensionsv1beta1.Scale, opts v1.UpdateOptions) (*extensionsv1beta1.Scale, error) { ret := _m.Called(ctx, deploymentName, scale, opts) - var r0 *v1beta1.Scale - if rf, ok := ret.Get(0).(func(context.Context, string, *v1beta1.Scale, v1.UpdateOptions) *v1beta1.Scale); ok { + var r0 *extensionsv1beta1.Scale + if rf, ok := ret.Get(0).(func(context.Context, string, *extensionsv1beta1.Scale, v1.UpdateOptions) *extensionsv1beta1.Scale); ok { r0 = rf(ctx, deploymentName, scale, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Scale) + r0 = ret.Get(0).(*extensionsv1beta1.Scale) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, *v1beta1.Scale, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, *extensionsv1beta1.Scale, v1.UpdateOptions) error); ok { r1 = rf(ctx, deploymentName, scale, opts) } else { r1 = ret.Error(1) @@ -232,20 +279,20 @@ func (_m *DeploymentInterface) UpdateScale(ctx context.Context, deploymentName s } // UpdateStatus provides a mock function with given fields: ctx, deployment, opts -func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *v1beta1.Deployment, opts v1.UpdateOptions) (*v1beta1.Deployment, error) { +func (_m *DeploymentInterface) UpdateStatus(ctx context.Context, deployment *extensionsv1beta1.Deployment, opts v1.UpdateOptions) (*extensionsv1beta1.Deployment, error) { ret := _m.Called(ctx, deployment, opts) - var r0 *v1beta1.Deployment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) *v1beta1.Deployment); ok { + var r0 *extensionsv1beta1.Deployment + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.Deployment, v1.UpdateOptions) *extensionsv1beta1.Deployment); ok { r0 = rf(ctx, deployment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Deployment) + r0 = ret.Get(0).(*extensionsv1beta1.Deployment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Deployment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.Deployment, v1.UpdateOptions) error); ok { r1 = rf(ctx, deployment, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/extensions/v1beta1/ingress_interface.go b/testutil/kubernetes_mock/typed/extensions/v1beta1/ingress_interface.go index e34d22dd75..7a504ba3fc 100644 --- a/testutil/kubernetes_mock/typed/extensions/v1beta1/ingress_interface.go +++ b/testutil/kubernetes_mock/typed/extensions/v1beta1/ingress_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/extensions/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/extensions/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type IngressInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, ingress, opts +func (_m *IngressInterface) Apply(ctx context.Context, ingress *v1beta1.IngressApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.Ingress, error) { + ret := _m.Called(ctx, ingress, opts) + + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.Ingress); ok { + r0 = rf(ctx, ingress, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, ingress, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, ingress, opts +func (_m *IngressInterface) ApplyStatus(ctx context.Context, ingress *v1beta1.IngressApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.Ingress, error) { + ret := _m.Called(ctx, ingress, opts) + + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.Ingress); ok { + r0 = rf(ctx, ingress, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, ingress, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) Create(ctx context.Context, ingress *v1beta1.Ingress, opts v1.CreateOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Create(ctx context.Context, ingress *extensionsv1beta1.Ingress, opts v1.CreateOptions) (*extensionsv1beta1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Ingress, v1.CreateOptions) *v1beta1.Ingress); ok { + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.Ingress, v1.CreateOptions) *extensionsv1beta1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Ingress, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.Ingress, v1.CreateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *IngressInterface) DeleteCollection(ctx context.Context, opts v1.Delete } // Get provides a mock function with given fields: ctx, name, opts -func (_m *IngressInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*extensionsv1beta1.Ingress, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Ingress); ok { + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.Ingress); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) } } @@ -96,15 +143,15 @@ func (_m *IngressInterface) Get(ctx context.Context, name string, opts v1.GetOpt } // List provides a mock function with given fields: ctx, opts -func (_m *IngressInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.IngressList, error) { +func (_m *IngressInterface) List(ctx context.Context, opts v1.ListOptions) (*extensionsv1beta1.IngressList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.IngressList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.IngressList); ok { + var r0 *extensionsv1beta1.IngressList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *extensionsv1beta1.IngressList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressList) + r0 = ret.Get(0).(*extensionsv1beta1.IngressList) } } @@ -119,7 +166,7 @@ func (_m *IngressInterface) List(ctx context.Context, opts v1.ListOptions) (*v1b } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*extensionsv1beta1.Ingress, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Ingress); ok { + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *extensionsv1beta1.Ingress); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) } } @@ -149,20 +196,20 @@ func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.Pat } // Update provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) Update(ctx context.Context, ingress *v1beta1.Ingress, opts v1.UpdateOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Update(ctx context.Context, ingress *extensionsv1beta1.Ingress, opts v1.UpdateOptions) (*extensionsv1beta1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) *v1beta1.Ingress); ok { + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.Ingress, v1.UpdateOptions) *extensionsv1beta1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.Ingress, v1.UpdateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *IngressInterface) Update(ctx context.Context, ingress *v1beta1.Ingress } // UpdateStatus provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) UpdateStatus(ctx context.Context, ingress *v1beta1.Ingress, opts v1.UpdateOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) UpdateStatus(ctx context.Context, ingress *extensionsv1beta1.Ingress, opts v1.UpdateOptions) (*extensionsv1beta1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) *v1beta1.Ingress); ok { + var r0 *extensionsv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.Ingress, v1.UpdateOptions) *extensionsv1beta1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*extensionsv1beta1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.Ingress, v1.UpdateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/extensions/v1beta1/network_policy_interface.go b/testutil/kubernetes_mock/typed/extensions/v1beta1/network_policy_interface.go index 5dd32b5ae9..1445eca691 100644 --- a/testutil/kubernetes_mock/typed/extensions/v1beta1/network_policy_interface.go +++ b/testutil/kubernetes_mock/typed/extensions/v1beta1/network_policy_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/extensions/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/extensions/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type NetworkPolicyInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, networkPolicy, opts +func (_m *NetworkPolicyInterface) Apply(ctx context.Context, networkPolicy *v1beta1.NetworkPolicyApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.NetworkPolicy, error) { + ret := _m.Called(ctx, networkPolicy, opts) + + var r0 *extensionsv1beta1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.NetworkPolicyApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.NetworkPolicy); ok { + r0 = rf(ctx, networkPolicy, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.NetworkPolicy) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.NetworkPolicyApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, networkPolicy, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, networkPolicy, opts -func (_m *NetworkPolicyInterface) Create(ctx context.Context, networkPolicy *v1beta1.NetworkPolicy, opts v1.CreateOptions) (*v1beta1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Create(ctx context.Context, networkPolicy *extensionsv1beta1.NetworkPolicy, opts v1.CreateOptions) (*extensionsv1beta1.NetworkPolicy, error) { ret := _m.Called(ctx, networkPolicy, opts) - var r0 *v1beta1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.NetworkPolicy, v1.CreateOptions) *v1beta1.NetworkPolicy); ok { + var r0 *extensionsv1beta1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.NetworkPolicy, v1.CreateOptions) *extensionsv1beta1.NetworkPolicy); ok { r0 = rf(ctx, networkPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.NetworkPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.NetworkPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.NetworkPolicy, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.NetworkPolicy, v1.CreateOptions) error); ok { r1 = rf(ctx, networkPolicy, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *NetworkPolicyInterface) DeleteCollection(ctx context.Context, opts v1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *NetworkPolicyInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*extensionsv1beta1.NetworkPolicy, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.NetworkPolicy); ok { + var r0 *extensionsv1beta1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.NetworkPolicy); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.NetworkPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.NetworkPolicy) } } @@ -96,15 +120,15 @@ func (_m *NetworkPolicyInterface) Get(ctx context.Context, name string, opts v1. } // List provides a mock function with given fields: ctx, opts -func (_m *NetworkPolicyInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.NetworkPolicyList, error) { +func (_m *NetworkPolicyInterface) List(ctx context.Context, opts v1.ListOptions) (*extensionsv1beta1.NetworkPolicyList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.NetworkPolicyList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.NetworkPolicyList); ok { + var r0 *extensionsv1beta1.NetworkPolicyList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *extensionsv1beta1.NetworkPolicyList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.NetworkPolicyList) + r0 = ret.Get(0).(*extensionsv1beta1.NetworkPolicyList) } } @@ -119,7 +143,7 @@ func (_m *NetworkPolicyInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*extensionsv1beta1.NetworkPolicy, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.NetworkPolicy); ok { + var r0 *extensionsv1beta1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *extensionsv1beta1.NetworkPolicy); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.NetworkPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.NetworkPolicy) } } @@ -149,20 +173,20 @@ func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, networkPolicy, opts -func (_m *NetworkPolicyInterface) Update(ctx context.Context, networkPolicy *v1beta1.NetworkPolicy, opts v1.UpdateOptions) (*v1beta1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Update(ctx context.Context, networkPolicy *extensionsv1beta1.NetworkPolicy, opts v1.UpdateOptions) (*extensionsv1beta1.NetworkPolicy, error) { ret := _m.Called(ctx, networkPolicy, opts) - var r0 *v1beta1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.NetworkPolicy, v1.UpdateOptions) *v1beta1.NetworkPolicy); ok { + var r0 *extensionsv1beta1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.NetworkPolicy, v1.UpdateOptions) *extensionsv1beta1.NetworkPolicy); ok { r0 = rf(ctx, networkPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.NetworkPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.NetworkPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.NetworkPolicy, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.NetworkPolicy, v1.UpdateOptions) error); ok { r1 = rf(ctx, networkPolicy, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/extensions/v1beta1/pod_security_policy_interface.go b/testutil/kubernetes_mock/typed/extensions/v1beta1/pod_security_policy_interface.go index 211390d26d..6970e454d3 100644 --- a/testutil/kubernetes_mock/typed/extensions/v1beta1/pod_security_policy_interface.go +++ b/testutil/kubernetes_mock/typed/extensions/v1beta1/pod_security_policy_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/extensions/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/extensions/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type PodSecurityPolicyInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, podSecurityPolicy, opts +func (_m *PodSecurityPolicyInterface) Apply(ctx context.Context, podSecurityPolicy *v1beta1.PodSecurityPolicyApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.PodSecurityPolicy, error) { + ret := _m.Called(ctx, podSecurityPolicy, opts) + + var r0 *extensionsv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodSecurityPolicyApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.PodSecurityPolicy); ok { + r0 = rf(ctx, podSecurityPolicy, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.PodSecurityPolicy) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodSecurityPolicyApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, podSecurityPolicy, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, podSecurityPolicy, opts -func (_m *PodSecurityPolicyInterface) Create(ctx context.Context, podSecurityPolicy *v1beta1.PodSecurityPolicy, opts v1.CreateOptions) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Create(ctx context.Context, podSecurityPolicy *extensionsv1beta1.PodSecurityPolicy, opts v1.CreateOptions) (*extensionsv1beta1.PodSecurityPolicy, error) { ret := _m.Called(ctx, podSecurityPolicy, opts) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.CreateOptions) *v1beta1.PodSecurityPolicy); ok { + var r0 *extensionsv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.PodSecurityPolicy, v1.CreateOptions) *extensionsv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, podSecurityPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.PodSecurityPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.PodSecurityPolicy, v1.CreateOptions) error); ok { r1 = rf(ctx, podSecurityPolicy, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *PodSecurityPolicyInterface) DeleteCollection(ctx context.Context, opts } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PodSecurityPolicyInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*extensionsv1beta1.PodSecurityPolicy, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.PodSecurityPolicy); ok { + var r0 *extensionsv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.PodSecurityPolicy) } } @@ -96,15 +120,15 @@ func (_m *PodSecurityPolicyInterface) Get(ctx context.Context, name string, opts } // List provides a mock function with given fields: ctx, opts -func (_m *PodSecurityPolicyInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.PodSecurityPolicyList, error) { +func (_m *PodSecurityPolicyInterface) List(ctx context.Context, opts v1.ListOptions) (*extensionsv1beta1.PodSecurityPolicyList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.PodSecurityPolicyList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.PodSecurityPolicyList); ok { + var r0 *extensionsv1beta1.PodSecurityPolicyList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *extensionsv1beta1.PodSecurityPolicyList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicyList) + r0 = ret.Get(0).(*extensionsv1beta1.PodSecurityPolicyList) } } @@ -119,7 +143,7 @@ func (_m *PodSecurityPolicyInterface) List(ctx context.Context, opts v1.ListOpti } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*extensionsv1beta1.PodSecurityPolicy, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.PodSecurityPolicy); ok { + var r0 *extensionsv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *extensionsv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.PodSecurityPolicy) } } @@ -149,20 +173,20 @@ func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt } // Update provides a mock function with given fields: ctx, podSecurityPolicy, opts -func (_m *PodSecurityPolicyInterface) Update(ctx context.Context, podSecurityPolicy *v1beta1.PodSecurityPolicy, opts v1.UpdateOptions) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Update(ctx context.Context, podSecurityPolicy *extensionsv1beta1.PodSecurityPolicy, opts v1.UpdateOptions) (*extensionsv1beta1.PodSecurityPolicy, error) { ret := _m.Called(ctx, podSecurityPolicy, opts) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.UpdateOptions) *v1beta1.PodSecurityPolicy); ok { + var r0 *extensionsv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.PodSecurityPolicy, v1.UpdateOptions) *extensionsv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, podSecurityPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*extensionsv1beta1.PodSecurityPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.PodSecurityPolicy, v1.UpdateOptions) error); ok { r1 = rf(ctx, podSecurityPolicy, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/extensions/v1beta1/replica_set_interface.go b/testutil/kubernetes_mock/typed/extensions/v1beta1/replica_set_interface.go index 14a64cde13..dc76bb7189 100644 --- a/testutil/kubernetes_mock/typed/extensions/v1beta1/replica_set_interface.go +++ b/testutil/kubernetes_mock/typed/extensions/v1beta1/replica_set_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + extensionsv1beta1 "k8s.io/api/extensions/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/extensions/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/extensions/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type ReplicaSetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, replicaSet, opts +func (_m *ReplicaSetInterface) Apply(ctx context.Context, replicaSet *v1beta1.ReplicaSetApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.ReplicaSet, error) { + ret := _m.Called(ctx, replicaSet, opts) + + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ReplicaSetApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.ReplicaSet); ok { + r0 = rf(ctx, replicaSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ReplicaSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, replicaSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, replicaSet, opts +func (_m *ReplicaSetInterface) ApplyStatus(ctx context.Context, replicaSet *v1beta1.ReplicaSetApplyConfiguration, opts v1.ApplyOptions) (*extensionsv1beta1.ReplicaSet, error) { + ret := _m.Called(ctx, replicaSet, opts) + + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ReplicaSetApplyConfiguration, v1.ApplyOptions) *extensionsv1beta1.ReplicaSet); ok { + r0 = rf(ctx, replicaSet, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ReplicaSetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, replicaSet, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) Create(ctx context.Context, replicaSet *v1beta1.ReplicaSet, opts v1.CreateOptions) (*v1beta1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Create(ctx context.Context, replicaSet *extensionsv1beta1.ReplicaSet, opts v1.CreateOptions) (*extensionsv1beta1.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1beta1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ReplicaSet, v1.CreateOptions) *v1beta1.ReplicaSet); ok { + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.ReplicaSet, v1.CreateOptions) *extensionsv1beta1.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ReplicaSet) + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ReplicaSet, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.ReplicaSet, v1.CreateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *ReplicaSetInterface) DeleteCollection(ctx context.Context, opts v1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*extensionsv1beta1.ReplicaSet, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.ReplicaSet); ok { + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.ReplicaSet); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ReplicaSet) + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) } } @@ -96,15 +143,15 @@ func (_m *ReplicaSetInterface) Get(ctx context.Context, name string, opts v1.Get } // GetScale provides a mock function with given fields: ctx, replicaSetName, options -func (_m *ReplicaSetInterface) GetScale(ctx context.Context, replicaSetName string, options v1.GetOptions) (*v1beta1.Scale, error) { +func (_m *ReplicaSetInterface) GetScale(ctx context.Context, replicaSetName string, options v1.GetOptions) (*extensionsv1beta1.Scale, error) { ret := _m.Called(ctx, replicaSetName, options) - var r0 *v1beta1.Scale - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Scale); ok { + var r0 *extensionsv1beta1.Scale + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *extensionsv1beta1.Scale); ok { r0 = rf(ctx, replicaSetName, options) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Scale) + r0 = ret.Get(0).(*extensionsv1beta1.Scale) } } @@ -119,15 +166,15 @@ func (_m *ReplicaSetInterface) GetScale(ctx context.Context, replicaSetName stri } // List provides a mock function with given fields: ctx, opts -func (_m *ReplicaSetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.ReplicaSetList, error) { +func (_m *ReplicaSetInterface) List(ctx context.Context, opts v1.ListOptions) (*extensionsv1beta1.ReplicaSetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.ReplicaSetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.ReplicaSetList); ok { + var r0 *extensionsv1beta1.ReplicaSetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *extensionsv1beta1.ReplicaSetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ReplicaSetList) + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSetList) } } @@ -142,7 +189,7 @@ func (_m *ReplicaSetInterface) List(ctx context.Context, opts v1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*extensionsv1beta1.ReplicaSet, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -152,12 +199,12 @@ func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.ReplicaSet); ok { + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *extensionsv1beta1.ReplicaSet); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ReplicaSet) + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) } } @@ -172,20 +219,20 @@ func (_m *ReplicaSetInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *v1beta1.ReplicaSet, opts v1.UpdateOptions) (*v1beta1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *extensionsv1beta1.ReplicaSet, opts v1.UpdateOptions) (*extensionsv1beta1.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1beta1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ReplicaSet, v1.UpdateOptions) *v1beta1.ReplicaSet); ok { + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.ReplicaSet, v1.UpdateOptions) *extensionsv1beta1.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ReplicaSet) + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ReplicaSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.ReplicaSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) @@ -195,20 +242,20 @@ func (_m *ReplicaSetInterface) Update(ctx context.Context, replicaSet *v1beta1.R } // UpdateScale provides a mock function with given fields: ctx, replicaSetName, scale, opts -func (_m *ReplicaSetInterface) UpdateScale(ctx context.Context, replicaSetName string, scale *v1beta1.Scale, opts v1.UpdateOptions) (*v1beta1.Scale, error) { +func (_m *ReplicaSetInterface) UpdateScale(ctx context.Context, replicaSetName string, scale *extensionsv1beta1.Scale, opts v1.UpdateOptions) (*extensionsv1beta1.Scale, error) { ret := _m.Called(ctx, replicaSetName, scale, opts) - var r0 *v1beta1.Scale - if rf, ok := ret.Get(0).(func(context.Context, string, *v1beta1.Scale, v1.UpdateOptions) *v1beta1.Scale); ok { + var r0 *extensionsv1beta1.Scale + if rf, ok := ret.Get(0).(func(context.Context, string, *extensionsv1beta1.Scale, v1.UpdateOptions) *extensionsv1beta1.Scale); ok { r0 = rf(ctx, replicaSetName, scale, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Scale) + r0 = ret.Get(0).(*extensionsv1beta1.Scale) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, *v1beta1.Scale, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, string, *extensionsv1beta1.Scale, v1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSetName, scale, opts) } else { r1 = ret.Error(1) @@ -218,20 +265,20 @@ func (_m *ReplicaSetInterface) UpdateScale(ctx context.Context, replicaSetName s } // UpdateStatus provides a mock function with given fields: ctx, replicaSet, opts -func (_m *ReplicaSetInterface) UpdateStatus(ctx context.Context, replicaSet *v1beta1.ReplicaSet, opts v1.UpdateOptions) (*v1beta1.ReplicaSet, error) { +func (_m *ReplicaSetInterface) UpdateStatus(ctx context.Context, replicaSet *extensionsv1beta1.ReplicaSet, opts v1.UpdateOptions) (*extensionsv1beta1.ReplicaSet, error) { ret := _m.Called(ctx, replicaSet, opts) - var r0 *v1beta1.ReplicaSet - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ReplicaSet, v1.UpdateOptions) *v1beta1.ReplicaSet); ok { + var r0 *extensionsv1beta1.ReplicaSet + if rf, ok := ret.Get(0).(func(context.Context, *extensionsv1beta1.ReplicaSet, v1.UpdateOptions) *extensionsv1beta1.ReplicaSet); ok { r0 = rf(ctx, replicaSet, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ReplicaSet) + r0 = ret.Get(0).(*extensionsv1beta1.ReplicaSet) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ReplicaSet, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *extensionsv1beta1.ReplicaSet, v1.UpdateOptions) error); ok { r1 = rf(ctx, replicaSet, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/flow_schema_interface.go b/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/flow_schema_interface.go index c969d96c86..83b02dcef0 100644 --- a/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/flow_schema_interface.go +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/flow_schema_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/flowcontrol/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/flowcontrol/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type FlowSchemaInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) Apply(ctx context.Context, flowSchema *v1alpha1.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1alpha1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.FlowSchemaApplyConfiguration, v1.ApplyOptions) *flowcontrolv1alpha1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.FlowSchemaApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) ApplyStatus(ctx context.Context, flowSchema *v1alpha1.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1alpha1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.FlowSchemaApplyConfiguration, v1.ApplyOptions) *flowcontrolv1alpha1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.FlowSchemaApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, flowSchema, opts -func (_m *FlowSchemaInterface) Create(ctx context.Context, flowSchema *v1alpha1.FlowSchema, opts v1.CreateOptions) (*v1alpha1.FlowSchema, error) { +func (_m *FlowSchemaInterface) Create(ctx context.Context, flowSchema *flowcontrolv1alpha1.FlowSchema, opts v1.CreateOptions) (*flowcontrolv1alpha1.FlowSchema, error) { ret := _m.Called(ctx, flowSchema, opts) - var r0 *v1alpha1.FlowSchema - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.FlowSchema, v1.CreateOptions) *v1alpha1.FlowSchema); ok { + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1alpha1.FlowSchema, v1.CreateOptions) *flowcontrolv1alpha1.FlowSchema); ok { r0 = rf(ctx, flowSchema, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.FlowSchema) + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.FlowSchema, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1alpha1.FlowSchema, v1.CreateOptions) error); ok { r1 = rf(ctx, flowSchema, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *FlowSchemaInterface) DeleteCollection(ctx context.Context, opts v1.Del } // Get provides a mock function with given fields: ctx, name, opts -func (_m *FlowSchemaInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.FlowSchema, error) { +func (_m *FlowSchemaInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*flowcontrolv1alpha1.FlowSchema, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.FlowSchema - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.FlowSchema); ok { + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *flowcontrolv1alpha1.FlowSchema); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.FlowSchema) + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) } } @@ -96,15 +143,15 @@ func (_m *FlowSchemaInterface) Get(ctx context.Context, name string, opts v1.Get } // List provides a mock function with given fields: ctx, opts -func (_m *FlowSchemaInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.FlowSchemaList, error) { +func (_m *FlowSchemaInterface) List(ctx context.Context, opts v1.ListOptions) (*flowcontrolv1alpha1.FlowSchemaList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.FlowSchemaList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.FlowSchemaList); ok { + var r0 *flowcontrolv1alpha1.FlowSchemaList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *flowcontrolv1alpha1.FlowSchemaList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.FlowSchemaList) + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchemaList) } } @@ -119,7 +166,7 @@ func (_m *FlowSchemaInterface) List(ctx context.Context, opts v1.ListOptions) (* } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *FlowSchemaInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.FlowSchema, error) { +func (_m *FlowSchemaInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*flowcontrolv1alpha1.FlowSchema, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *FlowSchemaInterface) Patch(ctx context.Context, name string, pt types. _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.FlowSchema - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.FlowSchema); ok { + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *flowcontrolv1alpha1.FlowSchema); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.FlowSchema) + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) } } @@ -149,20 +196,20 @@ func (_m *FlowSchemaInterface) Patch(ctx context.Context, name string, pt types. } // Update provides a mock function with given fields: ctx, flowSchema, opts -func (_m *FlowSchemaInterface) Update(ctx context.Context, flowSchema *v1alpha1.FlowSchema, opts v1.UpdateOptions) (*v1alpha1.FlowSchema, error) { +func (_m *FlowSchemaInterface) Update(ctx context.Context, flowSchema *flowcontrolv1alpha1.FlowSchema, opts v1.UpdateOptions) (*flowcontrolv1alpha1.FlowSchema, error) { ret := _m.Called(ctx, flowSchema, opts) - var r0 *v1alpha1.FlowSchema - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.FlowSchema, v1.UpdateOptions) *v1alpha1.FlowSchema); ok { + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1alpha1.FlowSchema, v1.UpdateOptions) *flowcontrolv1alpha1.FlowSchema); ok { r0 = rf(ctx, flowSchema, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.FlowSchema) + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.FlowSchema, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1alpha1.FlowSchema, v1.UpdateOptions) error); ok { r1 = rf(ctx, flowSchema, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *FlowSchemaInterface) Update(ctx context.Context, flowSchema *v1alpha1. } // UpdateStatus provides a mock function with given fields: ctx, flowSchema, opts -func (_m *FlowSchemaInterface) UpdateStatus(ctx context.Context, flowSchema *v1alpha1.FlowSchema, opts v1.UpdateOptions) (*v1alpha1.FlowSchema, error) { +func (_m *FlowSchemaInterface) UpdateStatus(ctx context.Context, flowSchema *flowcontrolv1alpha1.FlowSchema, opts v1.UpdateOptions) (*flowcontrolv1alpha1.FlowSchema, error) { ret := _m.Called(ctx, flowSchema, opts) - var r0 *v1alpha1.FlowSchema - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.FlowSchema, v1.UpdateOptions) *v1alpha1.FlowSchema); ok { + var r0 *flowcontrolv1alpha1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1alpha1.FlowSchema, v1.UpdateOptions) *flowcontrolv1alpha1.FlowSchema); ok { r0 = rf(ctx, flowSchema, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.FlowSchema) + r0 = ret.Get(0).(*flowcontrolv1alpha1.FlowSchema) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.FlowSchema, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1alpha1.FlowSchema, v1.UpdateOptions) error); ok { r1 = rf(ctx, flowSchema, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/priority_level_configuration_interface.go b/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/priority_level_configuration_interface.go index 504efb2464..4615853597 100644 --- a/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/priority_level_configuration_interface.go +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1alpha1/priority_level_configuration_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + flowcontrolv1alpha1 "k8s.io/api/flowcontrol/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/flowcontrol/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/flowcontrol/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type PriorityLevelConfigurationInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) Apply(ctx context.Context, priorityLevelConfiguration *v1alpha1.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) ApplyStatus(ctx context.Context, priorityLevelConfiguration *v1alpha1.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, priorityLevelConfiguration, opts -func (_m *PriorityLevelConfigurationInterface) Create(ctx context.Context, priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration, opts v1.CreateOptions) (*v1alpha1.PriorityLevelConfiguration, error) { +func (_m *PriorityLevelConfigurationInterface) Create(ctx context.Context, priorityLevelConfiguration *flowcontrolv1alpha1.PriorityLevelConfiguration, opts v1.CreateOptions) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { ret := _m.Called(ctx, priorityLevelConfiguration, opts) - var r0 *v1alpha1.PriorityLevelConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityLevelConfiguration, v1.CreateOptions) *v1alpha1.PriorityLevelConfiguration); ok { + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1alpha1.PriorityLevelConfiguration, v1.CreateOptions) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { r0 = rf(ctx, priorityLevelConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityLevelConfiguration) + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityLevelConfiguration, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1alpha1.PriorityLevelConfiguration, v1.CreateOptions) error); ok { r1 = rf(ctx, priorityLevelConfiguration, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *PriorityLevelConfigurationInterface) DeleteCollection(ctx context.Cont } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PriorityLevelConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.PriorityLevelConfiguration, error) { +func (_m *PriorityLevelConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.PriorityLevelConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.PriorityLevelConfiguration); ok { + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityLevelConfiguration) + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) } } @@ -96,15 +143,15 @@ func (_m *PriorityLevelConfigurationInterface) Get(ctx context.Context, name str } // List provides a mock function with given fields: ctx, opts -func (_m *PriorityLevelConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.PriorityLevelConfigurationList, error) { +func (_m *PriorityLevelConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*flowcontrolv1alpha1.PriorityLevelConfigurationList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.PriorityLevelConfigurationList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.PriorityLevelConfigurationList); ok { + var r0 *flowcontrolv1alpha1.PriorityLevelConfigurationList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *flowcontrolv1alpha1.PriorityLevelConfigurationList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityLevelConfigurationList) + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfigurationList) } } @@ -119,7 +166,7 @@ func (_m *PriorityLevelConfigurationInterface) List(ctx context.Context, opts v1 } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PriorityLevelConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.PriorityLevelConfiguration, error) { +func (_m *PriorityLevelConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *PriorityLevelConfigurationInterface) Patch(ctx context.Context, name s _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.PriorityLevelConfiguration - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.PriorityLevelConfiguration); ok { + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityLevelConfiguration) + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) } } @@ -149,20 +196,20 @@ func (_m *PriorityLevelConfigurationInterface) Patch(ctx context.Context, name s } // Update provides a mock function with given fields: ctx, priorityLevelConfiguration, opts -func (_m *PriorityLevelConfigurationInterface) Update(ctx context.Context, priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration, opts v1.UpdateOptions) (*v1alpha1.PriorityLevelConfiguration, error) { +func (_m *PriorityLevelConfigurationInterface) Update(ctx context.Context, priorityLevelConfiguration *flowcontrolv1alpha1.PriorityLevelConfiguration, opts v1.UpdateOptions) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { ret := _m.Called(ctx, priorityLevelConfiguration, opts) - var r0 *v1alpha1.PriorityLevelConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) *v1alpha1.PriorityLevelConfiguration); ok { + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { r0 = rf(ctx, priorityLevelConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityLevelConfiguration) + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) error); ok { r1 = rf(ctx, priorityLevelConfiguration, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *PriorityLevelConfigurationInterface) Update(ctx context.Context, prior } // UpdateStatus provides a mock function with given fields: ctx, priorityLevelConfiguration, opts -func (_m *PriorityLevelConfigurationInterface) UpdateStatus(ctx context.Context, priorityLevelConfiguration *v1alpha1.PriorityLevelConfiguration, opts v1.UpdateOptions) (*v1alpha1.PriorityLevelConfiguration, error) { +func (_m *PriorityLevelConfigurationInterface) UpdateStatus(ctx context.Context, priorityLevelConfiguration *flowcontrolv1alpha1.PriorityLevelConfiguration, opts v1.UpdateOptions) (*flowcontrolv1alpha1.PriorityLevelConfiguration, error) { ret := _m.Called(ctx, priorityLevelConfiguration, opts) - var r0 *v1alpha1.PriorityLevelConfiguration - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) *v1alpha1.PriorityLevelConfiguration); ok { + var r0 *flowcontrolv1alpha1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) *flowcontrolv1alpha1.PriorityLevelConfiguration); ok { r0 = rf(ctx, priorityLevelConfiguration, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityLevelConfiguration) + r0 = ret.Get(0).(*flowcontrolv1alpha1.PriorityLevelConfiguration) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1alpha1.PriorityLevelConfiguration, v1.UpdateOptions) error); ok { r1 = rf(ctx, priorityLevelConfiguration, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_preset_expansion.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schema_expansion.go similarity index 53% rename from testutil/kubernetes_mock/typed/settings/v1alpha1/pod_preset_expansion.go rename to testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schema_expansion.go index 6e474e8f60..757c72cac3 100644 --- a/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_preset_expansion.go +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schema_expansion.go @@ -4,7 +4,7 @@ package kubernetes_mocks import mock "github.com/stretchr/testify/mock" -// PodPresetExpansion is an autogenerated mock type for the PodPresetExpansion type -type PodPresetExpansion struct { +// FlowSchemaExpansion is an autogenerated mock type for the FlowSchemaExpansion type +type FlowSchemaExpansion struct { mock.Mock } diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schema_interface.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schema_interface.go new file mode 100644 index 0000000000..15edac3b10 --- /dev/null +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schema_interface.go @@ -0,0 +1,265 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + flowcontrolv1beta1 "k8s.io/api/flowcontrol/v1beta1" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + v1beta1 "k8s.io/client-go/applyconfigurations/flowcontrol/v1beta1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// FlowSchemaInterface is an autogenerated mock type for the FlowSchemaInterface type +type FlowSchemaInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) Apply(ctx context.Context, flowSchema *v1beta1.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1beta1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.FlowSchemaApplyConfiguration, v1.ApplyOptions) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.FlowSchemaApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) ApplyStatus(ctx context.Context, flowSchema *v1beta1.FlowSchemaApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1beta1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.FlowSchemaApplyConfiguration, v1.ApplyOptions) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.FlowSchemaApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) Create(ctx context.Context, flowSchema *flowcontrolv1beta1.FlowSchema, opts v1.CreateOptions) (*flowcontrolv1beta1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1beta1.FlowSchema, v1.CreateOptions) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1beta1.FlowSchema, v1.CreateOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *FlowSchemaInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *FlowSchemaInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *FlowSchemaInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*flowcontrolv1beta1.FlowSchema, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *FlowSchemaInterface) List(ctx context.Context, opts v1.ListOptions) (*flowcontrolv1beta1.FlowSchemaList, error) { + ret := _m.Called(ctx, opts) + + var r0 *flowcontrolv1beta1.FlowSchemaList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *flowcontrolv1beta1.FlowSchemaList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchemaList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *FlowSchemaInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*flowcontrolv1beta1.FlowSchema, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) Update(ctx context.Context, flowSchema *flowcontrolv1beta1.FlowSchema, opts v1.UpdateOptions) (*flowcontrolv1beta1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1beta1.FlowSchema, v1.UpdateOptions) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1beta1.FlowSchema, v1.UpdateOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateStatus provides a mock function with given fields: ctx, flowSchema, opts +func (_m *FlowSchemaInterface) UpdateStatus(ctx context.Context, flowSchema *flowcontrolv1beta1.FlowSchema, opts v1.UpdateOptions) (*flowcontrolv1beta1.FlowSchema, error) { + ret := _m.Called(ctx, flowSchema, opts) + + var r0 *flowcontrolv1beta1.FlowSchema + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1beta1.FlowSchema, v1.UpdateOptions) *flowcontrolv1beta1.FlowSchema); ok { + r0 = rf(ctx, flowSchema, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.FlowSchema) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1beta1.FlowSchema, v1.UpdateOptions) error); ok { + r1 = rf(ctx, flowSchema, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *FlowSchemaInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schemas_getter.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schemas_getter.go new file mode 100644 index 0000000000..94dda218f5 --- /dev/null +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flow_schemas_getter.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + v1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" +) + +// FlowSchemasGetter is an autogenerated mock type for the FlowSchemasGetter type +type FlowSchemasGetter struct { + mock.Mock +} + +// FlowSchemas provides a mock function with given fields: +func (_m *FlowSchemasGetter) FlowSchemas() v1beta1.FlowSchemaInterface { + ret := _m.Called() + + var r0 v1beta1.FlowSchemaInterface + if rf, ok := ret.Get(0).(func() v1beta1.FlowSchemaInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1beta1.FlowSchemaInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flowcontrol_v1beta1_interface.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flowcontrol_v1beta1_interface.go new file mode 100644 index 0000000000..c099bc9311 --- /dev/null +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/flowcontrol_v1beta1_interface.go @@ -0,0 +1,63 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + rest "k8s.io/client-go/rest" + + v1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" +) + +// FlowcontrolV1beta1Interface is an autogenerated mock type for the FlowcontrolV1beta1Interface type +type FlowcontrolV1beta1Interface struct { + mock.Mock +} + +// FlowSchemas provides a mock function with given fields: +func (_m *FlowcontrolV1beta1Interface) FlowSchemas() v1beta1.FlowSchemaInterface { + ret := _m.Called() + + var r0 v1beta1.FlowSchemaInterface + if rf, ok := ret.Get(0).(func() v1beta1.FlowSchemaInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1beta1.FlowSchemaInterface) + } + } + + return r0 +} + +// PriorityLevelConfigurations provides a mock function with given fields: +func (_m *FlowcontrolV1beta1Interface) PriorityLevelConfigurations() v1beta1.PriorityLevelConfigurationInterface { + ret := _m.Called() + + var r0 v1beta1.PriorityLevelConfigurationInterface + if rf, ok := ret.Get(0).(func() v1beta1.PriorityLevelConfigurationInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1beta1.PriorityLevelConfigurationInterface) + } + } + + return r0 +} + +// RESTClient provides a mock function with given fields: +func (_m *FlowcontrolV1beta1Interface) RESTClient() rest.Interface { + ret := _m.Called() + + var r0 rest.Interface + if rf, ok := ret.Get(0).(func() rest.Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(rest.Interface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configuration_expansion.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configuration_expansion.go new file mode 100644 index 0000000000..63dc218ded --- /dev/null +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configuration_expansion.go @@ -0,0 +1,10 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import mock "github.com/stretchr/testify/mock" + +// PriorityLevelConfigurationExpansion is an autogenerated mock type for the PriorityLevelConfigurationExpansion type +type PriorityLevelConfigurationExpansion struct { + mock.Mock +} diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configuration_interface.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configuration_interface.go new file mode 100644 index 0000000000..8a28d7c1de --- /dev/null +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configuration_interface.go @@ -0,0 +1,265 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + flowcontrolv1beta1 "k8s.io/api/flowcontrol/v1beta1" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + v1beta1 "k8s.io/client-go/applyconfigurations/flowcontrol/v1beta1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// PriorityLevelConfigurationInterface is an autogenerated mock type for the PriorityLevelConfigurationInterface type +type PriorityLevelConfigurationInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) Apply(ctx context.Context, priorityLevelConfiguration *v1beta1.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) ApplyStatus(ctx context.Context, priorityLevelConfiguration *v1beta1.PriorityLevelConfigurationApplyConfiguration, opts v1.ApplyOptions) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PriorityLevelConfigurationApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) Create(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta1.PriorityLevelConfiguration, opts v1.CreateOptions) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1beta1.PriorityLevelConfiguration, v1.CreateOptions) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1beta1.PriorityLevelConfiguration, v1.CreateOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *PriorityLevelConfigurationInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *PriorityLevelConfigurationInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *PriorityLevelConfigurationInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *PriorityLevelConfigurationInterface) List(ctx context.Context, opts v1.ListOptions) (*flowcontrolv1beta1.PriorityLevelConfigurationList, error) { + ret := _m.Called(ctx, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfigurationList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *flowcontrolv1beta1.PriorityLevelConfigurationList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfigurationList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *PriorityLevelConfigurationInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) Update(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta1.PriorityLevelConfiguration, opts v1.UpdateOptions) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1beta1.PriorityLevelConfiguration, v1.UpdateOptions) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1beta1.PriorityLevelConfiguration, v1.UpdateOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateStatus provides a mock function with given fields: ctx, priorityLevelConfiguration, opts +func (_m *PriorityLevelConfigurationInterface) UpdateStatus(ctx context.Context, priorityLevelConfiguration *flowcontrolv1beta1.PriorityLevelConfiguration, opts v1.UpdateOptions) (*flowcontrolv1beta1.PriorityLevelConfiguration, error) { + ret := _m.Called(ctx, priorityLevelConfiguration, opts) + + var r0 *flowcontrolv1beta1.PriorityLevelConfiguration + if rf, ok := ret.Get(0).(func(context.Context, *flowcontrolv1beta1.PriorityLevelConfiguration, v1.UpdateOptions) *flowcontrolv1beta1.PriorityLevelConfiguration); ok { + r0 = rf(ctx, priorityLevelConfiguration, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*flowcontrolv1beta1.PriorityLevelConfiguration) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *flowcontrolv1beta1.PriorityLevelConfiguration, v1.UpdateOptions) error); ok { + r1 = rf(ctx, priorityLevelConfiguration, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *PriorityLevelConfigurationInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configurations_getter.go b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configurations_getter.go new file mode 100644 index 0000000000..69c09cc2cf --- /dev/null +++ b/testutil/kubernetes_mock/typed/flowcontrol/v1beta1/priority_level_configurations_getter.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + v1beta1 "k8s.io/client-go/kubernetes/typed/flowcontrol/v1beta1" +) + +// PriorityLevelConfigurationsGetter is an autogenerated mock type for the PriorityLevelConfigurationsGetter type +type PriorityLevelConfigurationsGetter struct { + mock.Mock +} + +// PriorityLevelConfigurations provides a mock function with given fields: +func (_m *PriorityLevelConfigurationsGetter) PriorityLevelConfigurations() v1beta1.PriorityLevelConfigurationInterface { + ret := _m.Called() + + var r0 v1beta1.PriorityLevelConfigurationInterface + if rf, ok := ret.Get(0).(func() v1beta1.PriorityLevelConfigurationInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1beta1.PriorityLevelConfigurationInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/networking/v1/ingress_class_interface.go b/testutil/kubernetes_mock/typed/networking/v1/ingress_class_interface.go index 45a5cd4000..e119f9d2a6 100644 --- a/testutil/kubernetes_mock/typed/networking/v1/ingress_class_interface.go +++ b/testutil/kubernetes_mock/typed/networking/v1/ingress_class_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + networkingv1 "k8s.io/api/networking/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/networking/v1" + v1 "k8s.io/client-go/applyconfigurations/networking/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type IngressClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, ingressClass, opts +func (_m *IngressClassInterface) Apply(ctx context.Context, ingressClass *v1.IngressClassApplyConfiguration, opts metav1.ApplyOptions) (*networkingv1.IngressClass, error) { + ret := _m.Called(ctx, ingressClass, opts) + + var r0 *networkingv1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, *v1.IngressClassApplyConfiguration, metav1.ApplyOptions) *networkingv1.IngressClass); ok { + r0 = rf(ctx, ingressClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1.IngressClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.IngressClassApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, ingressClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, ingressClass, opts -func (_m *IngressClassInterface) Create(ctx context.Context, ingressClass *v1.IngressClass, opts metav1.CreateOptions) (*v1.IngressClass, error) { +func (_m *IngressClassInterface) Create(ctx context.Context, ingressClass *networkingv1.IngressClass, opts metav1.CreateOptions) (*networkingv1.IngressClass, error) { ret := _m.Called(ctx, ingressClass, opts) - var r0 *v1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, *v1.IngressClass, metav1.CreateOptions) *v1.IngressClass); ok { + var r0 *networkingv1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.IngressClass, metav1.CreateOptions) *networkingv1.IngressClass); ok { r0 = rf(ctx, ingressClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.IngressClass) + r0 = ret.Get(0).(*networkingv1.IngressClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.IngressClass, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.IngressClass, metav1.CreateOptions) error); ok { r1 = rf(ctx, ingressClass, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *IngressClassInterface) DeleteCollection(ctx context.Context, opts meta } // Get provides a mock function with given fields: ctx, name, opts -func (_m *IngressClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.IngressClass, error) { +func (_m *IngressClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*networkingv1.IngressClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.IngressClass); ok { + var r0 *networkingv1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *networkingv1.IngressClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.IngressClass) + r0 = ret.Get(0).(*networkingv1.IngressClass) } } @@ -95,15 +120,15 @@ func (_m *IngressClassInterface) Get(ctx context.Context, name string, opts meta } // List provides a mock function with given fields: ctx, opts -func (_m *IngressClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.IngressClassList, error) { +func (_m *IngressClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*networkingv1.IngressClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.IngressClassList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.IngressClassList); ok { + var r0 *networkingv1.IngressClassList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *networkingv1.IngressClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.IngressClassList) + r0 = ret.Get(0).(*networkingv1.IngressClassList) } } @@ -118,7 +143,7 @@ func (_m *IngressClassInterface) List(ctx context.Context, opts metav1.ListOptio } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.IngressClass, error) { +func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*networkingv1.IngressClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt type _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.IngressClass); ok { + var r0 *networkingv1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *networkingv1.IngressClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.IngressClass) + r0 = ret.Get(0).(*networkingv1.IngressClass) } } @@ -148,20 +173,20 @@ func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt type } // Update provides a mock function with given fields: ctx, ingressClass, opts -func (_m *IngressClassInterface) Update(ctx context.Context, ingressClass *v1.IngressClass, opts metav1.UpdateOptions) (*v1.IngressClass, error) { +func (_m *IngressClassInterface) Update(ctx context.Context, ingressClass *networkingv1.IngressClass, opts metav1.UpdateOptions) (*networkingv1.IngressClass, error) { ret := _m.Called(ctx, ingressClass, opts) - var r0 *v1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, *v1.IngressClass, metav1.UpdateOptions) *v1.IngressClass); ok { + var r0 *networkingv1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.IngressClass, metav1.UpdateOptions) *networkingv1.IngressClass); ok { r0 = rf(ctx, ingressClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.IngressClass) + r0 = ret.Get(0).(*networkingv1.IngressClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.IngressClass, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.IngressClass, metav1.UpdateOptions) error); ok { r1 = rf(ctx, ingressClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/networking/v1/ingress_interface.go b/testutil/kubernetes_mock/typed/networking/v1/ingress_interface.go index 4518bde37b..50bf25d1f2 100644 --- a/testutil/kubernetes_mock/typed/networking/v1/ingress_interface.go +++ b/testutil/kubernetes_mock/typed/networking/v1/ingress_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + networkingv1 "k8s.io/api/networking/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/networking/v1" + v1 "k8s.io/client-go/applyconfigurations/networking/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,67 @@ type IngressInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, ingress, opts +func (_m *IngressInterface) Apply(ctx context.Context, ingress *v1.IngressApplyConfiguration, opts metav1.ApplyOptions) (*networkingv1.Ingress, error) { + ret := _m.Called(ctx, ingress, opts) + + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *v1.IngressApplyConfiguration, metav1.ApplyOptions) *networkingv1.Ingress); ok { + r0 = rf(ctx, ingress, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1.Ingress) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.IngressApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, ingress, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, ingress, opts +func (_m *IngressInterface) ApplyStatus(ctx context.Context, ingress *v1.IngressApplyConfiguration, opts metav1.ApplyOptions) (*networkingv1.Ingress, error) { + ret := _m.Called(ctx, ingress, opts) + + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *v1.IngressApplyConfiguration, metav1.ApplyOptions) *networkingv1.Ingress); ok { + r0 = rf(ctx, ingress, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1.Ingress) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.IngressApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, ingress, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) Create(ctx context.Context, ingress *v1.Ingress, opts metav1.CreateOptions) (*v1.Ingress, error) { +func (_m *IngressInterface) Create(ctx context.Context, ingress *networkingv1.Ingress, opts metav1.CreateOptions) (*networkingv1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1.Ingress, metav1.CreateOptions) *v1.Ingress); ok { + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.Ingress, metav1.CreateOptions) *networkingv1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Ingress) + r0 = ret.Get(0).(*networkingv1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Ingress, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.Ingress, metav1.CreateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) @@ -72,15 +120,15 @@ func (_m *IngressInterface) DeleteCollection(ctx context.Context, opts metav1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *IngressInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Ingress, error) { +func (_m *IngressInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*networkingv1.Ingress, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Ingress); ok { + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *networkingv1.Ingress); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Ingress) + r0 = ret.Get(0).(*networkingv1.Ingress) } } @@ -95,15 +143,15 @@ func (_m *IngressInterface) Get(ctx context.Context, name string, opts metav1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *IngressInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.IngressList, error) { +func (_m *IngressInterface) List(ctx context.Context, opts metav1.ListOptions) (*networkingv1.IngressList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.IngressList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.IngressList); ok { + var r0 *networkingv1.IngressList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *networkingv1.IngressList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.IngressList) + r0 = ret.Get(0).(*networkingv1.IngressList) } } @@ -118,7 +166,7 @@ func (_m *IngressInterface) List(ctx context.Context, opts metav1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Ingress, error) { +func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*networkingv1.Ingress, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +176,12 @@ func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Ingress); ok { + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *networkingv1.Ingress); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Ingress) + r0 = ret.Get(0).(*networkingv1.Ingress) } } @@ -148,20 +196,20 @@ func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.Pat } // Update provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) Update(ctx context.Context, ingress *v1.Ingress, opts metav1.UpdateOptions) (*v1.Ingress, error) { +func (_m *IngressInterface) Update(ctx context.Context, ingress *networkingv1.Ingress, opts metav1.UpdateOptions) (*networkingv1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1.Ingress, metav1.UpdateOptions) *v1.Ingress); ok { + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.Ingress, metav1.UpdateOptions) *networkingv1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Ingress) + r0 = ret.Get(0).(*networkingv1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Ingress, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.Ingress, metav1.UpdateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) @@ -171,20 +219,20 @@ func (_m *IngressInterface) Update(ctx context.Context, ingress *v1.Ingress, opt } // UpdateStatus provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) UpdateStatus(ctx context.Context, ingress *v1.Ingress, opts metav1.UpdateOptions) (*v1.Ingress, error) { +func (_m *IngressInterface) UpdateStatus(ctx context.Context, ingress *networkingv1.Ingress, opts metav1.UpdateOptions) (*networkingv1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1.Ingress, metav1.UpdateOptions) *v1.Ingress); ok { + var r0 *networkingv1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.Ingress, metav1.UpdateOptions) *networkingv1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Ingress) + r0 = ret.Get(0).(*networkingv1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Ingress, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.Ingress, metav1.UpdateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/networking/v1/network_policy_interface.go b/testutil/kubernetes_mock/typed/networking/v1/network_policy_interface.go index 00a66b6649..7c5d379982 100644 --- a/testutil/kubernetes_mock/typed/networking/v1/network_policy_interface.go +++ b/testutil/kubernetes_mock/typed/networking/v1/network_policy_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + networkingv1 "k8s.io/api/networking/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/networking/v1" + v1 "k8s.io/client-go/applyconfigurations/networking/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type NetworkPolicyInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, networkPolicy, opts +func (_m *NetworkPolicyInterface) Apply(ctx context.Context, networkPolicy *v1.NetworkPolicyApplyConfiguration, opts metav1.ApplyOptions) (*networkingv1.NetworkPolicy, error) { + ret := _m.Called(ctx, networkPolicy, opts) + + var r0 *networkingv1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, *v1.NetworkPolicyApplyConfiguration, metav1.ApplyOptions) *networkingv1.NetworkPolicy); ok { + r0 = rf(ctx, networkPolicy, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1.NetworkPolicy) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.NetworkPolicyApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, networkPolicy, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, networkPolicy, opts -func (_m *NetworkPolicyInterface) Create(ctx context.Context, networkPolicy *v1.NetworkPolicy, opts metav1.CreateOptions) (*v1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Create(ctx context.Context, networkPolicy *networkingv1.NetworkPolicy, opts metav1.CreateOptions) (*networkingv1.NetworkPolicy, error) { ret := _m.Called(ctx, networkPolicy, opts) - var r0 *v1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1.NetworkPolicy, metav1.CreateOptions) *v1.NetworkPolicy); ok { + var r0 *networkingv1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.NetworkPolicy, metav1.CreateOptions) *networkingv1.NetworkPolicy); ok { r0 = rf(ctx, networkPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NetworkPolicy) + r0 = ret.Get(0).(*networkingv1.NetworkPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.NetworkPolicy, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.NetworkPolicy, metav1.CreateOptions) error); ok { r1 = rf(ctx, networkPolicy, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *NetworkPolicyInterface) DeleteCollection(ctx context.Context, opts met } // Get provides a mock function with given fields: ctx, name, opts -func (_m *NetworkPolicyInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*networkingv1.NetworkPolicy, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.NetworkPolicy); ok { + var r0 *networkingv1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *networkingv1.NetworkPolicy); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NetworkPolicy) + r0 = ret.Get(0).(*networkingv1.NetworkPolicy) } } @@ -95,15 +120,15 @@ func (_m *NetworkPolicyInterface) Get(ctx context.Context, name string, opts met } // List provides a mock function with given fields: ctx, opts -func (_m *NetworkPolicyInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.NetworkPolicyList, error) { +func (_m *NetworkPolicyInterface) List(ctx context.Context, opts metav1.ListOptions) (*networkingv1.NetworkPolicyList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.NetworkPolicyList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.NetworkPolicyList); ok { + var r0 *networkingv1.NetworkPolicyList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *networkingv1.NetworkPolicyList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NetworkPolicyList) + r0 = ret.Get(0).(*networkingv1.NetworkPolicyList) } } @@ -118,7 +143,7 @@ func (_m *NetworkPolicyInterface) List(ctx context.Context, opts metav1.ListOpti } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*networkingv1.NetworkPolicy, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.NetworkPolicy); ok { + var r0 *networkingv1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *networkingv1.NetworkPolicy); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NetworkPolicy) + r0 = ret.Get(0).(*networkingv1.NetworkPolicy) } } @@ -148,20 +173,20 @@ func (_m *NetworkPolicyInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, networkPolicy, opts -func (_m *NetworkPolicyInterface) Update(ctx context.Context, networkPolicy *v1.NetworkPolicy, opts metav1.UpdateOptions) (*v1.NetworkPolicy, error) { +func (_m *NetworkPolicyInterface) Update(ctx context.Context, networkPolicy *networkingv1.NetworkPolicy, opts metav1.UpdateOptions) (*networkingv1.NetworkPolicy, error) { ret := _m.Called(ctx, networkPolicy, opts) - var r0 *v1.NetworkPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1.NetworkPolicy, metav1.UpdateOptions) *v1.NetworkPolicy); ok { + var r0 *networkingv1.NetworkPolicy + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1.NetworkPolicy, metav1.UpdateOptions) *networkingv1.NetworkPolicy); ok { r0 = rf(ctx, networkPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.NetworkPolicy) + r0 = ret.Get(0).(*networkingv1.NetworkPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.NetworkPolicy, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1.NetworkPolicy, metav1.UpdateOptions) error); ok { r1 = rf(ctx, networkPolicy, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_class_interface.go b/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_class_interface.go index 6c1586278b..6dda6d0257 100644 --- a/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_class_interface.go +++ b/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_class_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + networkingv1beta1 "k8s.io/api/networking/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/networking/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/networking/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type IngressClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, ingressClass, opts +func (_m *IngressClassInterface) Apply(ctx context.Context, ingressClass *v1beta1.IngressClassApplyConfiguration, opts v1.ApplyOptions) (*networkingv1beta1.IngressClass, error) { + ret := _m.Called(ctx, ingressClass, opts) + + var r0 *networkingv1beta1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressClassApplyConfiguration, v1.ApplyOptions) *networkingv1beta1.IngressClass); ok { + r0 = rf(ctx, ingressClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1beta1.IngressClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressClassApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, ingressClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, ingressClass, opts -func (_m *IngressClassInterface) Create(ctx context.Context, ingressClass *v1beta1.IngressClass, opts v1.CreateOptions) (*v1beta1.IngressClass, error) { +func (_m *IngressClassInterface) Create(ctx context.Context, ingressClass *networkingv1beta1.IngressClass, opts v1.CreateOptions) (*networkingv1beta1.IngressClass, error) { ret := _m.Called(ctx, ingressClass, opts) - var r0 *v1beta1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressClass, v1.CreateOptions) *v1beta1.IngressClass); ok { + var r0 *networkingv1beta1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1beta1.IngressClass, v1.CreateOptions) *networkingv1beta1.IngressClass); ok { r0 = rf(ctx, ingressClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressClass) + r0 = ret.Get(0).(*networkingv1beta1.IngressClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressClass, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1beta1.IngressClass, v1.CreateOptions) error); ok { r1 = rf(ctx, ingressClass, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *IngressClassInterface) DeleteCollection(ctx context.Context, opts v1.D } // Get provides a mock function with given fields: ctx, name, opts -func (_m *IngressClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.IngressClass, error) { +func (_m *IngressClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*networkingv1beta1.IngressClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.IngressClass); ok { + var r0 *networkingv1beta1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *networkingv1beta1.IngressClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressClass) + r0 = ret.Get(0).(*networkingv1beta1.IngressClass) } } @@ -96,15 +120,15 @@ func (_m *IngressClassInterface) Get(ctx context.Context, name string, opts v1.G } // List provides a mock function with given fields: ctx, opts -func (_m *IngressClassInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.IngressClassList, error) { +func (_m *IngressClassInterface) List(ctx context.Context, opts v1.ListOptions) (*networkingv1beta1.IngressClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.IngressClassList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.IngressClassList); ok { + var r0 *networkingv1beta1.IngressClassList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *networkingv1beta1.IngressClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressClassList) + r0 = ret.Get(0).(*networkingv1beta1.IngressClassList) } } @@ -119,7 +143,7 @@ func (_m *IngressClassInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.IngressClass, error) { +func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*networkingv1beta1.IngressClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt type _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.IngressClass); ok { + var r0 *networkingv1beta1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *networkingv1beta1.IngressClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressClass) + r0 = ret.Get(0).(*networkingv1beta1.IngressClass) } } @@ -149,20 +173,20 @@ func (_m *IngressClassInterface) Patch(ctx context.Context, name string, pt type } // Update provides a mock function with given fields: ctx, ingressClass, opts -func (_m *IngressClassInterface) Update(ctx context.Context, ingressClass *v1beta1.IngressClass, opts v1.UpdateOptions) (*v1beta1.IngressClass, error) { +func (_m *IngressClassInterface) Update(ctx context.Context, ingressClass *networkingv1beta1.IngressClass, opts v1.UpdateOptions) (*networkingv1beta1.IngressClass, error) { ret := _m.Called(ctx, ingressClass, opts) - var r0 *v1beta1.IngressClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressClass, v1.UpdateOptions) *v1beta1.IngressClass); ok { + var r0 *networkingv1beta1.IngressClass + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1beta1.IngressClass, v1.UpdateOptions) *networkingv1beta1.IngressClass); ok { r0 = rf(ctx, ingressClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressClass) + r0 = ret.Get(0).(*networkingv1beta1.IngressClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressClass, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1beta1.IngressClass, v1.UpdateOptions) error); ok { r1 = rf(ctx, ingressClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_interface.go b/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_interface.go index 8b4db6fb08..f52b50538e 100644 --- a/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_interface.go +++ b/testutil/kubernetes_mock/typed/networking/v1beta1/ingress_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + networkingv1beta1 "k8s.io/api/networking/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/networking/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/networking/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type IngressInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, ingress, opts +func (_m *IngressInterface) Apply(ctx context.Context, ingress *v1beta1.IngressApplyConfiguration, opts v1.ApplyOptions) (*networkingv1beta1.Ingress, error) { + ret := _m.Called(ctx, ingress, opts) + + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) *networkingv1beta1.Ingress); ok { + r0 = rf(ctx, ingress, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1beta1.Ingress) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, ingress, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, ingress, opts +func (_m *IngressInterface) ApplyStatus(ctx context.Context, ingress *v1beta1.IngressApplyConfiguration, opts v1.ApplyOptions) (*networkingv1beta1.Ingress, error) { + ret := _m.Called(ctx, ingress, opts) + + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) *networkingv1beta1.Ingress); ok { + r0 = rf(ctx, ingress, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*networkingv1beta1.Ingress) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.IngressApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, ingress, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) Create(ctx context.Context, ingress *v1beta1.Ingress, opts v1.CreateOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Create(ctx context.Context, ingress *networkingv1beta1.Ingress, opts v1.CreateOptions) (*networkingv1beta1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Ingress, v1.CreateOptions) *v1beta1.Ingress); ok { + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1beta1.Ingress, v1.CreateOptions) *networkingv1beta1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*networkingv1beta1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Ingress, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1beta1.Ingress, v1.CreateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *IngressInterface) DeleteCollection(ctx context.Context, opts v1.Delete } // Get provides a mock function with given fields: ctx, name, opts -func (_m *IngressInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*networkingv1beta1.Ingress, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Ingress); ok { + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *networkingv1beta1.Ingress); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*networkingv1beta1.Ingress) } } @@ -96,15 +143,15 @@ func (_m *IngressInterface) Get(ctx context.Context, name string, opts v1.GetOpt } // List provides a mock function with given fields: ctx, opts -func (_m *IngressInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.IngressList, error) { +func (_m *IngressInterface) List(ctx context.Context, opts v1.ListOptions) (*networkingv1beta1.IngressList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.IngressList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.IngressList); ok { + var r0 *networkingv1beta1.IngressList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *networkingv1beta1.IngressList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.IngressList) + r0 = ret.Get(0).(*networkingv1beta1.IngressList) } } @@ -119,7 +166,7 @@ func (_m *IngressInterface) List(ctx context.Context, opts v1.ListOptions) (*v1b } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*networkingv1beta1.Ingress, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Ingress); ok { + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *networkingv1beta1.Ingress); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*networkingv1beta1.Ingress) } } @@ -149,20 +196,20 @@ func (_m *IngressInterface) Patch(ctx context.Context, name string, pt types.Pat } // Update provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) Update(ctx context.Context, ingress *v1beta1.Ingress, opts v1.UpdateOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) Update(ctx context.Context, ingress *networkingv1beta1.Ingress, opts v1.UpdateOptions) (*networkingv1beta1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) *v1beta1.Ingress); ok { + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1beta1.Ingress, v1.UpdateOptions) *networkingv1beta1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*networkingv1beta1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1beta1.Ingress, v1.UpdateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *IngressInterface) Update(ctx context.Context, ingress *v1beta1.Ingress } // UpdateStatus provides a mock function with given fields: ctx, ingress, opts -func (_m *IngressInterface) UpdateStatus(ctx context.Context, ingress *v1beta1.Ingress, opts v1.UpdateOptions) (*v1beta1.Ingress, error) { +func (_m *IngressInterface) UpdateStatus(ctx context.Context, ingress *networkingv1beta1.Ingress, opts v1.UpdateOptions) (*networkingv1beta1.Ingress, error) { ret := _m.Called(ctx, ingress, opts) - var r0 *v1beta1.Ingress - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) *v1beta1.Ingress); ok { + var r0 *networkingv1beta1.Ingress + if rf, ok := ret.Get(0).(func(context.Context, *networkingv1beta1.Ingress, v1.UpdateOptions) *networkingv1beta1.Ingress); ok { r0 = rf(ctx, ingress, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Ingress) + r0 = ret.Get(0).(*networkingv1beta1.Ingress) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Ingress, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *networkingv1beta1.Ingress, v1.UpdateOptions) error); ok { r1 = rf(ctx, ingress, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/node/v1/node_v1_interface.go b/testutil/kubernetes_mock/typed/node/v1/node_v1_interface.go new file mode 100644 index 0000000000..c68f286776 --- /dev/null +++ b/testutil/kubernetes_mock/typed/node/v1/node_v1_interface.go @@ -0,0 +1,47 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + rest "k8s.io/client-go/rest" + + v1 "k8s.io/client-go/kubernetes/typed/node/v1" +) + +// NodeV1Interface is an autogenerated mock type for the NodeV1Interface type +type NodeV1Interface struct { + mock.Mock +} + +// RESTClient provides a mock function with given fields: +func (_m *NodeV1Interface) RESTClient() rest.Interface { + ret := _m.Called() + + var r0 rest.Interface + if rf, ok := ret.Get(0).(func() rest.Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(rest.Interface) + } + } + + return r0 +} + +// RuntimeClasses provides a mock function with given fields: +func (_m *NodeV1Interface) RuntimeClasses() v1.RuntimeClassInterface { + ret := _m.Called() + + var r0 v1.RuntimeClassInterface + if rf, ok := ret.Get(0).(func() v1.RuntimeClassInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1.RuntimeClassInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/node/v1/runtime_class_expansion.go b/testutil/kubernetes_mock/typed/node/v1/runtime_class_expansion.go new file mode 100644 index 0000000000..afc06e4ef2 --- /dev/null +++ b/testutil/kubernetes_mock/typed/node/v1/runtime_class_expansion.go @@ -0,0 +1,10 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import mock "github.com/stretchr/testify/mock" + +// RuntimeClassExpansion is an autogenerated mock type for the RuntimeClassExpansion type +type RuntimeClassExpansion struct { + mock.Mock +} diff --git a/testutil/kubernetes_mock/typed/node/v1/runtime_class_interface.go b/testutil/kubernetes_mock/typed/node/v1/runtime_class_interface.go new file mode 100644 index 0000000000..799cd3bd9e --- /dev/null +++ b/testutil/kubernetes_mock/typed/node/v1/runtime_class_interface.go @@ -0,0 +1,219 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + nodev1 "k8s.io/api/node/v1" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/client-go/applyconfigurations/node/v1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// RuntimeClassInterface is an autogenerated mock type for the RuntimeClassInterface type +type RuntimeClassInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, runtimeClass, opts +func (_m *RuntimeClassInterface) Apply(ctx context.Context, runtimeClass *v1.RuntimeClassApplyConfiguration, opts metav1.ApplyOptions) (*nodev1.RuntimeClass, error) { + ret := _m.Called(ctx, runtimeClass, opts) + + var r0 *nodev1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *v1.RuntimeClassApplyConfiguration, metav1.ApplyOptions) *nodev1.RuntimeClass); ok { + r0 = rf(ctx, runtimeClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.RuntimeClassApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, runtimeClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, runtimeClass, opts +func (_m *RuntimeClassInterface) Create(ctx context.Context, runtimeClass *nodev1.RuntimeClass, opts metav1.CreateOptions) (*nodev1.RuntimeClass, error) { + ret := _m.Called(ctx, runtimeClass, opts) + + var r0 *nodev1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *nodev1.RuntimeClass, metav1.CreateOptions) *nodev1.RuntimeClass); ok { + r0 = rf(ctx, runtimeClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *nodev1.RuntimeClass, metav1.CreateOptions) error); ok { + r1 = rf(ctx, runtimeClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *RuntimeClassInterface) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *RuntimeClassInterface) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, metav1.DeleteOptions, metav1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*nodev1.RuntimeClass, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *nodev1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *nodev1.RuntimeClass); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, metav1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *RuntimeClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*nodev1.RuntimeClassList, error) { + ret := _m.Called(ctx, opts) + + var r0 *nodev1.RuntimeClassList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *nodev1.RuntimeClassList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1.RuntimeClassList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*nodev1.RuntimeClass, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *nodev1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *nodev1.RuntimeClass); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, runtimeClass, opts +func (_m *RuntimeClassInterface) Update(ctx context.Context, runtimeClass *nodev1.RuntimeClass, opts metav1.UpdateOptions) (*nodev1.RuntimeClass, error) { + ret := _m.Called(ctx, runtimeClass, opts) + + var r0 *nodev1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *nodev1.RuntimeClass, metav1.UpdateOptions) *nodev1.RuntimeClass); ok { + r0 = rf(ctx, runtimeClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *nodev1.RuntimeClass, metav1.UpdateOptions) error); ok { + r1 = rf(ctx, runtimeClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *RuntimeClassInterface) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/node/v1/runtime_classes_getter.go b/testutil/kubernetes_mock/typed/node/v1/runtime_classes_getter.go new file mode 100644 index 0000000000..801c1d3672 --- /dev/null +++ b/testutil/kubernetes_mock/typed/node/v1/runtime_classes_getter.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + v1 "k8s.io/client-go/kubernetes/typed/node/v1" +) + +// RuntimeClassesGetter is an autogenerated mock type for the RuntimeClassesGetter type +type RuntimeClassesGetter struct { + mock.Mock +} + +// RuntimeClasses provides a mock function with given fields: +func (_m *RuntimeClassesGetter) RuntimeClasses() v1.RuntimeClassInterface { + ret := _m.Called() + + var r0 v1.RuntimeClassInterface + if rf, ok := ret.Get(0).(func() v1.RuntimeClassInterface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1.RuntimeClassInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/node/v1alpha1/runtime_class_interface.go b/testutil/kubernetes_mock/typed/node/v1alpha1/runtime_class_interface.go index c37fea9ab2..377118978c 100644 --- a/testutil/kubernetes_mock/typed/node/v1alpha1/runtime_class_interface.go +++ b/testutil/kubernetes_mock/typed/node/v1alpha1/runtime_class_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + nodev1alpha1 "k8s.io/api/node/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/node/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/node/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type RuntimeClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, runtimeClass, opts +func (_m *RuntimeClassInterface) Apply(ctx context.Context, runtimeClass *v1alpha1.RuntimeClassApplyConfiguration, opts v1.ApplyOptions) (*nodev1alpha1.RuntimeClass, error) { + ret := _m.Called(ctx, runtimeClass, opts) + + var r0 *nodev1alpha1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RuntimeClassApplyConfiguration, v1.ApplyOptions) *nodev1alpha1.RuntimeClass); ok { + r0 = rf(ctx, runtimeClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1alpha1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RuntimeClassApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, runtimeClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, runtimeClass, opts -func (_m *RuntimeClassInterface) Create(ctx context.Context, runtimeClass *v1alpha1.RuntimeClass, opts v1.CreateOptions) (*v1alpha1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Create(ctx context.Context, runtimeClass *nodev1alpha1.RuntimeClass, opts v1.CreateOptions) (*nodev1alpha1.RuntimeClass, error) { ret := _m.Called(ctx, runtimeClass, opts) - var r0 *v1alpha1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RuntimeClass, v1.CreateOptions) *v1alpha1.RuntimeClass); ok { + var r0 *nodev1alpha1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *nodev1alpha1.RuntimeClass, v1.CreateOptions) *nodev1alpha1.RuntimeClass); ok { r0 = rf(ctx, runtimeClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RuntimeClass) + r0 = ret.Get(0).(*nodev1alpha1.RuntimeClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RuntimeClass, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *nodev1alpha1.RuntimeClass, v1.CreateOptions) error); ok { r1 = rf(ctx, runtimeClass, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *RuntimeClassInterface) DeleteCollection(ctx context.Context, opts v1.D } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*nodev1alpha1.RuntimeClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.RuntimeClass); ok { + var r0 *nodev1alpha1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *nodev1alpha1.RuntimeClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RuntimeClass) + r0 = ret.Get(0).(*nodev1alpha1.RuntimeClass) } } @@ -96,15 +120,15 @@ func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts v1.G } // List provides a mock function with given fields: ctx, opts -func (_m *RuntimeClassInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.RuntimeClassList, error) { +func (_m *RuntimeClassInterface) List(ctx context.Context, opts v1.ListOptions) (*nodev1alpha1.RuntimeClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.RuntimeClassList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.RuntimeClassList); ok { + var r0 *nodev1alpha1.RuntimeClassList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *nodev1alpha1.RuntimeClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RuntimeClassList) + r0 = ret.Get(0).(*nodev1alpha1.RuntimeClassList) } } @@ -119,7 +143,7 @@ func (_m *RuntimeClassInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*nodev1alpha1.RuntimeClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt type _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.RuntimeClass); ok { + var r0 *nodev1alpha1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *nodev1alpha1.RuntimeClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RuntimeClass) + r0 = ret.Get(0).(*nodev1alpha1.RuntimeClass) } } @@ -149,20 +173,20 @@ func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt type } // Update provides a mock function with given fields: ctx, runtimeClass, opts -func (_m *RuntimeClassInterface) Update(ctx context.Context, runtimeClass *v1alpha1.RuntimeClass, opts v1.UpdateOptions) (*v1alpha1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Update(ctx context.Context, runtimeClass *nodev1alpha1.RuntimeClass, opts v1.UpdateOptions) (*nodev1alpha1.RuntimeClass, error) { ret := _m.Called(ctx, runtimeClass, opts) - var r0 *v1alpha1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RuntimeClass, v1.UpdateOptions) *v1alpha1.RuntimeClass); ok { + var r0 *nodev1alpha1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *nodev1alpha1.RuntimeClass, v1.UpdateOptions) *nodev1alpha1.RuntimeClass); ok { r0 = rf(ctx, runtimeClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RuntimeClass) + r0 = ret.Get(0).(*nodev1alpha1.RuntimeClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RuntimeClass, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *nodev1alpha1.RuntimeClass, v1.UpdateOptions) error); ok { r1 = rf(ctx, runtimeClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/node/v1beta1/runtime_class_interface.go b/testutil/kubernetes_mock/typed/node/v1beta1/runtime_class_interface.go index f0e323da0d..fd7cf4c4a8 100644 --- a/testutil/kubernetes_mock/typed/node/v1beta1/runtime_class_interface.go +++ b/testutil/kubernetes_mock/typed/node/v1beta1/runtime_class_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + nodev1beta1 "k8s.io/api/node/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/node/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/node/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type RuntimeClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, runtimeClass, opts +func (_m *RuntimeClassInterface) Apply(ctx context.Context, runtimeClass *v1beta1.RuntimeClassApplyConfiguration, opts v1.ApplyOptions) (*nodev1beta1.RuntimeClass, error) { + ret := _m.Called(ctx, runtimeClass, opts) + + var r0 *nodev1beta1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RuntimeClassApplyConfiguration, v1.ApplyOptions) *nodev1beta1.RuntimeClass); ok { + r0 = rf(ctx, runtimeClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*nodev1beta1.RuntimeClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RuntimeClassApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, runtimeClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, runtimeClass, opts -func (_m *RuntimeClassInterface) Create(ctx context.Context, runtimeClass *v1beta1.RuntimeClass, opts v1.CreateOptions) (*v1beta1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Create(ctx context.Context, runtimeClass *nodev1beta1.RuntimeClass, opts v1.CreateOptions) (*nodev1beta1.RuntimeClass, error) { ret := _m.Called(ctx, runtimeClass, opts) - var r0 *v1beta1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RuntimeClass, v1.CreateOptions) *v1beta1.RuntimeClass); ok { + var r0 *nodev1beta1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *nodev1beta1.RuntimeClass, v1.CreateOptions) *nodev1beta1.RuntimeClass); ok { r0 = rf(ctx, runtimeClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RuntimeClass) + r0 = ret.Get(0).(*nodev1beta1.RuntimeClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RuntimeClass, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *nodev1beta1.RuntimeClass, v1.CreateOptions) error); ok { r1 = rf(ctx, runtimeClass, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *RuntimeClassInterface) DeleteCollection(ctx context.Context, opts v1.D } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*nodev1beta1.RuntimeClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.RuntimeClass); ok { + var r0 *nodev1beta1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *nodev1beta1.RuntimeClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RuntimeClass) + r0 = ret.Get(0).(*nodev1beta1.RuntimeClass) } } @@ -96,15 +120,15 @@ func (_m *RuntimeClassInterface) Get(ctx context.Context, name string, opts v1.G } // List provides a mock function with given fields: ctx, opts -func (_m *RuntimeClassInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.RuntimeClassList, error) { +func (_m *RuntimeClassInterface) List(ctx context.Context, opts v1.ListOptions) (*nodev1beta1.RuntimeClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.RuntimeClassList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.RuntimeClassList); ok { + var r0 *nodev1beta1.RuntimeClassList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *nodev1beta1.RuntimeClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RuntimeClassList) + r0 = ret.Get(0).(*nodev1beta1.RuntimeClassList) } } @@ -119,7 +143,7 @@ func (_m *RuntimeClassInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*nodev1beta1.RuntimeClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt type _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.RuntimeClass); ok { + var r0 *nodev1beta1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *nodev1beta1.RuntimeClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RuntimeClass) + r0 = ret.Get(0).(*nodev1beta1.RuntimeClass) } } @@ -149,20 +173,20 @@ func (_m *RuntimeClassInterface) Patch(ctx context.Context, name string, pt type } // Update provides a mock function with given fields: ctx, runtimeClass, opts -func (_m *RuntimeClassInterface) Update(ctx context.Context, runtimeClass *v1beta1.RuntimeClass, opts v1.UpdateOptions) (*v1beta1.RuntimeClass, error) { +func (_m *RuntimeClassInterface) Update(ctx context.Context, runtimeClass *nodev1beta1.RuntimeClass, opts v1.UpdateOptions) (*nodev1beta1.RuntimeClass, error) { ret := _m.Called(ctx, runtimeClass, opts) - var r0 *v1beta1.RuntimeClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RuntimeClass, v1.UpdateOptions) *v1beta1.RuntimeClass); ok { + var r0 *nodev1beta1.RuntimeClass + if rf, ok := ret.Get(0).(func(context.Context, *nodev1beta1.RuntimeClass, v1.UpdateOptions) *nodev1beta1.RuntimeClass); ok { r0 = rf(ctx, runtimeClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RuntimeClass) + r0 = ret.Get(0).(*nodev1beta1.RuntimeClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RuntimeClass, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *nodev1beta1.RuntimeClass, v1.UpdateOptions) error); ok { r1 = rf(ctx, runtimeClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budget_expansion.go b/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budget_expansion.go new file mode 100644 index 0000000000..e7a8b74924 --- /dev/null +++ b/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budget_expansion.go @@ -0,0 +1,10 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import mock "github.com/stretchr/testify/mock" + +// PodDisruptionBudgetExpansion is an autogenerated mock type for the PodDisruptionBudgetExpansion type +type PodDisruptionBudgetExpansion struct { + mock.Mock +} diff --git a/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budget_interface.go b/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budget_interface.go new file mode 100644 index 0000000000..c946046259 --- /dev/null +++ b/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budget_interface.go @@ -0,0 +1,265 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + policyv1 "k8s.io/api/policy/v1" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/client-go/applyconfigurations/policy/v1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// PodDisruptionBudgetInterface is an autogenerated mock type for the PodDisruptionBudgetInterface type +type PodDisruptionBudgetInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) Apply(ctx context.Context, podDisruptionBudget *v1.PodDisruptionBudgetApplyConfiguration, opts metav1.ApplyOptions) (*policyv1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *v1.PodDisruptionBudgetApplyConfiguration, metav1.ApplyOptions) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PodDisruptionBudgetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) ApplyStatus(ctx context.Context, podDisruptionBudget *v1.PodDisruptionBudgetApplyConfiguration, opts metav1.ApplyOptions) (*policyv1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *v1.PodDisruptionBudgetApplyConfiguration, metav1.ApplyOptions) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PodDisruptionBudgetApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) Create(ctx context.Context, podDisruptionBudget *policyv1.PodDisruptionBudget, opts metav1.CreateOptions) (*policyv1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *policyv1.PodDisruptionBudget, metav1.CreateOptions) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *policyv1.PodDisruptionBudget, metav1.CreateOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *PodDisruptionBudgetInterface) Delete(ctx context.Context, name string, opts metav1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *PodDisruptionBudgetInterface) DeleteCollection(ctx context.Context, opts metav1.DeleteOptions, listOpts metav1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, metav1.DeleteOptions, metav1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *PodDisruptionBudgetInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*policyv1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, metav1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *PodDisruptionBudgetInterface) List(ctx context.Context, opts metav1.ListOptions) (*policyv1.PodDisruptionBudgetList, error) { + ret := _m.Called(ctx, opts) + + var r0 *policyv1.PodDisruptionBudgetList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *policyv1.PodDisruptionBudgetList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudgetList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *PodDisruptionBudgetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*policyv1.PodDisruptionBudget, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) Update(ctx context.Context, podDisruptionBudget *policyv1.PodDisruptionBudget, opts metav1.UpdateOptions) (*policyv1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *policyv1.PodDisruptionBudget, metav1.UpdateOptions) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *policyv1.PodDisruptionBudget, metav1.UpdateOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UpdateStatus provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) UpdateStatus(ctx context.Context, podDisruptionBudget *policyv1.PodDisruptionBudget, opts metav1.UpdateOptions) (*policyv1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *policyv1.PodDisruptionBudget, metav1.UpdateOptions) *policyv1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *policyv1.PodDisruptionBudget, metav1.UpdateOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *PodDisruptionBudgetInterface) Watch(ctx context.Context, opts metav1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, metav1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budgets_getter.go b/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budgets_getter.go new file mode 100644 index 0000000000..97387b6a49 --- /dev/null +++ b/testutil/kubernetes_mock/typed/policy/v1/pod_disruption_budgets_getter.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + v1 "k8s.io/client-go/kubernetes/typed/policy/v1" +) + +// PodDisruptionBudgetsGetter is an autogenerated mock type for the PodDisruptionBudgetsGetter type +type PodDisruptionBudgetsGetter struct { + mock.Mock +} + +// PodDisruptionBudgets provides a mock function with given fields: namespace +func (_m *PodDisruptionBudgetsGetter) PodDisruptionBudgets(namespace string) v1.PodDisruptionBudgetInterface { + ret := _m.Called(namespace) + + var r0 v1.PodDisruptionBudgetInterface + if rf, ok := ret.Get(0).(func(string) v1.PodDisruptionBudgetInterface); ok { + r0 = rf(namespace) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1.PodDisruptionBudgetInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/policy/v1/policy_v1_interface.go b/testutil/kubernetes_mock/typed/policy/v1/policy_v1_interface.go new file mode 100644 index 0000000000..8526565758 --- /dev/null +++ b/testutil/kubernetes_mock/typed/policy/v1/policy_v1_interface.go @@ -0,0 +1,47 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + rest "k8s.io/client-go/rest" + + v1 "k8s.io/client-go/kubernetes/typed/policy/v1" +) + +// PolicyV1Interface is an autogenerated mock type for the PolicyV1Interface type +type PolicyV1Interface struct { + mock.Mock +} + +// PodDisruptionBudgets provides a mock function with given fields: namespace +func (_m *PolicyV1Interface) PodDisruptionBudgets(namespace string) v1.PodDisruptionBudgetInterface { + ret := _m.Called(namespace) + + var r0 v1.PodDisruptionBudgetInterface + if rf, ok := ret.Get(0).(func(string) v1.PodDisruptionBudgetInterface); ok { + r0 = rf(namespace) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1.PodDisruptionBudgetInterface) + } + } + + return r0 +} + +// RESTClient provides a mock function with given fields: +func (_m *PolicyV1Interface) RESTClient() rest.Interface { + ret := _m.Called() + + var r0 rest.Interface + if rf, ok := ret.Get(0).(func() rest.Interface); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(rest.Interface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/policy/v1beta1/pod_disruption_budget_interface.go b/testutil/kubernetes_mock/typed/policy/v1beta1/pod_disruption_budget_interface.go index dac39c1b18..18c6cc5b8a 100644 --- a/testutil/kubernetes_mock/typed/policy/v1beta1/pod_disruption_budget_interface.go +++ b/testutil/kubernetes_mock/typed/policy/v1beta1/pod_disruption_budget_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + policyv1beta1 "k8s.io/api/policy/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/policy/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/policy/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type PodDisruptionBudgetInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) Apply(ctx context.Context, podDisruptionBudget *v1beta1.PodDisruptionBudgetApplyConfiguration, opts v1.ApplyOptions) (*policyv1beta1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodDisruptionBudgetApplyConfiguration, v1.ApplyOptions) *policyv1beta1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodDisruptionBudgetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, podDisruptionBudget, opts +func (_m *PodDisruptionBudgetInterface) ApplyStatus(ctx context.Context, podDisruptionBudget *v1beta1.PodDisruptionBudgetApplyConfiguration, opts v1.ApplyOptions) (*policyv1beta1.PodDisruptionBudget, error) { + ret := _m.Called(ctx, podDisruptionBudget, opts) + + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodDisruptionBudgetApplyConfiguration, v1.ApplyOptions) *policyv1beta1.PodDisruptionBudget); ok { + r0 = rf(ctx, podDisruptionBudget, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodDisruptionBudgetApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, podDisruptionBudget, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, podDisruptionBudget, opts -func (_m *PodDisruptionBudgetInterface) Create(ctx context.Context, podDisruptionBudget *v1beta1.PodDisruptionBudget, opts v1.CreateOptions) (*v1beta1.PodDisruptionBudget, error) { +func (_m *PodDisruptionBudgetInterface) Create(ctx context.Context, podDisruptionBudget *policyv1beta1.PodDisruptionBudget, opts v1.CreateOptions) (*policyv1beta1.PodDisruptionBudget, error) { ret := _m.Called(ctx, podDisruptionBudget, opts) - var r0 *v1beta1.PodDisruptionBudget - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodDisruptionBudget, v1.CreateOptions) *v1beta1.PodDisruptionBudget); ok { + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *policyv1beta1.PodDisruptionBudget, v1.CreateOptions) *policyv1beta1.PodDisruptionBudget); ok { r0 = rf(ctx, podDisruptionBudget, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodDisruptionBudget) + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodDisruptionBudget, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *policyv1beta1.PodDisruptionBudget, v1.CreateOptions) error); ok { r1 = rf(ctx, podDisruptionBudget, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *PodDisruptionBudgetInterface) DeleteCollection(ctx context.Context, op } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PodDisruptionBudgetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.PodDisruptionBudget, error) { +func (_m *PodDisruptionBudgetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*policyv1beta1.PodDisruptionBudget, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.PodDisruptionBudget - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.PodDisruptionBudget); ok { + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *policyv1beta1.PodDisruptionBudget); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodDisruptionBudget) + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) } } @@ -96,15 +143,15 @@ func (_m *PodDisruptionBudgetInterface) Get(ctx context.Context, name string, op } // List provides a mock function with given fields: ctx, opts -func (_m *PodDisruptionBudgetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.PodDisruptionBudgetList, error) { +func (_m *PodDisruptionBudgetInterface) List(ctx context.Context, opts v1.ListOptions) (*policyv1beta1.PodDisruptionBudgetList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.PodDisruptionBudgetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.PodDisruptionBudgetList); ok { + var r0 *policyv1beta1.PodDisruptionBudgetList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *policyv1beta1.PodDisruptionBudgetList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodDisruptionBudgetList) + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudgetList) } } @@ -119,7 +166,7 @@ func (_m *PodDisruptionBudgetInterface) List(ctx context.Context, opts v1.ListOp } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PodDisruptionBudgetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.PodDisruptionBudget, error) { +func (_m *PodDisruptionBudgetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*policyv1beta1.PodDisruptionBudget, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *PodDisruptionBudgetInterface) Patch(ctx context.Context, name string, _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.PodDisruptionBudget - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.PodDisruptionBudget); ok { + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *policyv1beta1.PodDisruptionBudget); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodDisruptionBudget) + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) } } @@ -149,20 +196,20 @@ func (_m *PodDisruptionBudgetInterface) Patch(ctx context.Context, name string, } // Update provides a mock function with given fields: ctx, podDisruptionBudget, opts -func (_m *PodDisruptionBudgetInterface) Update(ctx context.Context, podDisruptionBudget *v1beta1.PodDisruptionBudget, opts v1.UpdateOptions) (*v1beta1.PodDisruptionBudget, error) { +func (_m *PodDisruptionBudgetInterface) Update(ctx context.Context, podDisruptionBudget *policyv1beta1.PodDisruptionBudget, opts v1.UpdateOptions) (*policyv1beta1.PodDisruptionBudget, error) { ret := _m.Called(ctx, podDisruptionBudget, opts) - var r0 *v1beta1.PodDisruptionBudget - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodDisruptionBudget, v1.UpdateOptions) *v1beta1.PodDisruptionBudget); ok { + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *policyv1beta1.PodDisruptionBudget, v1.UpdateOptions) *policyv1beta1.PodDisruptionBudget); ok { r0 = rf(ctx, podDisruptionBudget, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodDisruptionBudget) + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodDisruptionBudget, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *policyv1beta1.PodDisruptionBudget, v1.UpdateOptions) error); ok { r1 = rf(ctx, podDisruptionBudget, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *PodDisruptionBudgetInterface) Update(ctx context.Context, podDisruptio } // UpdateStatus provides a mock function with given fields: ctx, podDisruptionBudget, opts -func (_m *PodDisruptionBudgetInterface) UpdateStatus(ctx context.Context, podDisruptionBudget *v1beta1.PodDisruptionBudget, opts v1.UpdateOptions) (*v1beta1.PodDisruptionBudget, error) { +func (_m *PodDisruptionBudgetInterface) UpdateStatus(ctx context.Context, podDisruptionBudget *policyv1beta1.PodDisruptionBudget, opts v1.UpdateOptions) (*policyv1beta1.PodDisruptionBudget, error) { ret := _m.Called(ctx, podDisruptionBudget, opts) - var r0 *v1beta1.PodDisruptionBudget - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodDisruptionBudget, v1.UpdateOptions) *v1beta1.PodDisruptionBudget); ok { + var r0 *policyv1beta1.PodDisruptionBudget + if rf, ok := ret.Get(0).(func(context.Context, *policyv1beta1.PodDisruptionBudget, v1.UpdateOptions) *policyv1beta1.PodDisruptionBudget); ok { r0 = rf(ctx, podDisruptionBudget, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodDisruptionBudget) + r0 = ret.Get(0).(*policyv1beta1.PodDisruptionBudget) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodDisruptionBudget, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *policyv1beta1.PodDisruptionBudget, v1.UpdateOptions) error); ok { r1 = rf(ctx, podDisruptionBudget, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/policy/v1beta1/pod_security_policy_interface.go b/testutil/kubernetes_mock/typed/policy/v1beta1/pod_security_policy_interface.go index 574e20bbe2..ae79c11a33 100644 --- a/testutil/kubernetes_mock/typed/policy/v1beta1/pod_security_policy_interface.go +++ b/testutil/kubernetes_mock/typed/policy/v1beta1/pod_security_policy_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + policyv1beta1 "k8s.io/api/policy/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/policy/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/policy/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type PodSecurityPolicyInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, podSecurityPolicy, opts +func (_m *PodSecurityPolicyInterface) Apply(ctx context.Context, podSecurityPolicy *v1beta1.PodSecurityPolicyApplyConfiguration, opts v1.ApplyOptions) (*policyv1beta1.PodSecurityPolicy, error) { + ret := _m.Called(ctx, podSecurityPolicy, opts) + + var r0 *policyv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodSecurityPolicyApplyConfiguration, v1.ApplyOptions) *policyv1beta1.PodSecurityPolicy); ok { + r0 = rf(ctx, podSecurityPolicy, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*policyv1beta1.PodSecurityPolicy) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodSecurityPolicyApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, podSecurityPolicy, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, podSecurityPolicy, opts -func (_m *PodSecurityPolicyInterface) Create(ctx context.Context, podSecurityPolicy *v1beta1.PodSecurityPolicy, opts v1.CreateOptions) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Create(ctx context.Context, podSecurityPolicy *policyv1beta1.PodSecurityPolicy, opts v1.CreateOptions) (*policyv1beta1.PodSecurityPolicy, error) { ret := _m.Called(ctx, podSecurityPolicy, opts) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.CreateOptions) *v1beta1.PodSecurityPolicy); ok { + var r0 *policyv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, *policyv1beta1.PodSecurityPolicy, v1.CreateOptions) *policyv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, podSecurityPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*policyv1beta1.PodSecurityPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *policyv1beta1.PodSecurityPolicy, v1.CreateOptions) error); ok { r1 = rf(ctx, podSecurityPolicy, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *PodSecurityPolicyInterface) DeleteCollection(ctx context.Context, opts } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PodSecurityPolicyInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*policyv1beta1.PodSecurityPolicy, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.PodSecurityPolicy); ok { + var r0 *policyv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *policyv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*policyv1beta1.PodSecurityPolicy) } } @@ -96,15 +120,15 @@ func (_m *PodSecurityPolicyInterface) Get(ctx context.Context, name string, opts } // List provides a mock function with given fields: ctx, opts -func (_m *PodSecurityPolicyInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.PodSecurityPolicyList, error) { +func (_m *PodSecurityPolicyInterface) List(ctx context.Context, opts v1.ListOptions) (*policyv1beta1.PodSecurityPolicyList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.PodSecurityPolicyList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.PodSecurityPolicyList); ok { + var r0 *policyv1beta1.PodSecurityPolicyList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *policyv1beta1.PodSecurityPolicyList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicyList) + r0 = ret.Get(0).(*policyv1beta1.PodSecurityPolicyList) } } @@ -119,7 +143,7 @@ func (_m *PodSecurityPolicyInterface) List(ctx context.Context, opts v1.ListOpti } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*policyv1beta1.PodSecurityPolicy, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.PodSecurityPolicy); ok { + var r0 *policyv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *policyv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*policyv1beta1.PodSecurityPolicy) } } @@ -149,20 +173,20 @@ func (_m *PodSecurityPolicyInterface) Patch(ctx context.Context, name string, pt } // Update provides a mock function with given fields: ctx, podSecurityPolicy, opts -func (_m *PodSecurityPolicyInterface) Update(ctx context.Context, podSecurityPolicy *v1beta1.PodSecurityPolicy, opts v1.UpdateOptions) (*v1beta1.PodSecurityPolicy, error) { +func (_m *PodSecurityPolicyInterface) Update(ctx context.Context, podSecurityPolicy *policyv1beta1.PodSecurityPolicy, opts v1.UpdateOptions) (*policyv1beta1.PodSecurityPolicy, error) { ret := _m.Called(ctx, podSecurityPolicy, opts) - var r0 *v1beta1.PodSecurityPolicy - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.UpdateOptions) *v1beta1.PodSecurityPolicy); ok { + var r0 *policyv1beta1.PodSecurityPolicy + if rf, ok := ret.Get(0).(func(context.Context, *policyv1beta1.PodSecurityPolicy, v1.UpdateOptions) *policyv1beta1.PodSecurityPolicy); ok { r0 = rf(ctx, podSecurityPolicy, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PodSecurityPolicy) + r0 = ret.Get(0).(*policyv1beta1.PodSecurityPolicy) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PodSecurityPolicy, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *policyv1beta1.PodSecurityPolicy, v1.UpdateOptions) error); ok { r1 = rf(ctx, podSecurityPolicy, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_binding_interface.go b/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_binding_interface.go index d75ce45b81..252e90700c 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_binding_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_binding_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + rbacv1 "k8s.io/api/rbac/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/rbac/v1" + v1 "k8s.io/client-go/applyconfigurations/rbac/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type ClusterRoleBindingInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, clusterRoleBinding, opts +func (_m *ClusterRoleBindingInterface) Apply(ctx context.Context, clusterRoleBinding *v1.ClusterRoleBindingApplyConfiguration, opts metav1.ApplyOptions) (*rbacv1.ClusterRoleBinding, error) { + ret := _m.Called(ctx, clusterRoleBinding, opts) + + var r0 *rbacv1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *v1.ClusterRoleBindingApplyConfiguration, metav1.ApplyOptions) *rbacv1.ClusterRoleBinding); ok { + r0 = rf(ctx, clusterRoleBinding, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1.ClusterRoleBinding) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ClusterRoleBindingApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, clusterRoleBinding, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, clusterRoleBinding, opts -func (_m *ClusterRoleBindingInterface) Create(ctx context.Context, clusterRoleBinding *v1.ClusterRoleBinding, opts metav1.CreateOptions) (*v1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Create(ctx context.Context, clusterRoleBinding *rbacv1.ClusterRoleBinding, opts metav1.CreateOptions) (*rbacv1.ClusterRoleBinding, error) { ret := _m.Called(ctx, clusterRoleBinding, opts) - var r0 *v1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1.ClusterRoleBinding, metav1.CreateOptions) *v1.ClusterRoleBinding); ok { + var r0 *rbacv1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.ClusterRoleBinding, metav1.CreateOptions) *rbacv1.ClusterRoleBinding); ok { r0 = rf(ctx, clusterRoleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1.ClusterRoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ClusterRoleBinding, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.ClusterRoleBinding, metav1.CreateOptions) error); ok { r1 = rf(ctx, clusterRoleBinding, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *ClusterRoleBindingInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*rbacv1.ClusterRoleBinding, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ClusterRoleBinding); ok { + var r0 *rbacv1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *rbacv1.ClusterRoleBinding); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1.ClusterRoleBinding) } } @@ -95,15 +120,15 @@ func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ClusterRoleBindingList, error) { +func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts metav1.ListOptions) (*rbacv1.ClusterRoleBindingList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ClusterRoleBindingList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ClusterRoleBindingList); ok { + var r0 *rbacv1.ClusterRoleBindingList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *rbacv1.ClusterRoleBindingList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRoleBindingList) + r0 = ret.Get(0).(*rbacv1.ClusterRoleBindingList) } } @@ -118,7 +143,7 @@ func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts metav1.Lis } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*rbacv1.ClusterRoleBinding, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ClusterRoleBinding); ok { + var r0 *rbacv1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *rbacv1.ClusterRoleBinding); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1.ClusterRoleBinding) } } @@ -148,20 +173,20 @@ func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, clusterRoleBinding, opts -func (_m *ClusterRoleBindingInterface) Update(ctx context.Context, clusterRoleBinding *v1.ClusterRoleBinding, opts metav1.UpdateOptions) (*v1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Update(ctx context.Context, clusterRoleBinding *rbacv1.ClusterRoleBinding, opts metav1.UpdateOptions) (*rbacv1.ClusterRoleBinding, error) { ret := _m.Called(ctx, clusterRoleBinding, opts) - var r0 *v1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1.ClusterRoleBinding, metav1.UpdateOptions) *v1.ClusterRoleBinding); ok { + var r0 *rbacv1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.ClusterRoleBinding, metav1.UpdateOptions) *rbacv1.ClusterRoleBinding); ok { r0 = rf(ctx, clusterRoleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1.ClusterRoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ClusterRoleBinding, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.ClusterRoleBinding, metav1.UpdateOptions) error); ok { r1 = rf(ctx, clusterRoleBinding, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_interface.go b/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_interface.go index 7cbec743a5..8b8a480ab2 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1/cluster_role_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + rbacv1 "k8s.io/api/rbac/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/rbac/v1" + v1 "k8s.io/client-go/applyconfigurations/rbac/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type ClusterRoleInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, clusterRole, opts +func (_m *ClusterRoleInterface) Apply(ctx context.Context, clusterRole *v1.ClusterRoleApplyConfiguration, opts metav1.ApplyOptions) (*rbacv1.ClusterRole, error) { + ret := _m.Called(ctx, clusterRole, opts) + + var r0 *rbacv1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *v1.ClusterRoleApplyConfiguration, metav1.ApplyOptions) *rbacv1.ClusterRole); ok { + r0 = rf(ctx, clusterRole, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1.ClusterRole) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.ClusterRoleApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, clusterRole, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, clusterRole, opts -func (_m *ClusterRoleInterface) Create(ctx context.Context, clusterRole *v1.ClusterRole, opts metav1.CreateOptions) (*v1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Create(ctx context.Context, clusterRole *rbacv1.ClusterRole, opts metav1.CreateOptions) (*rbacv1.ClusterRole, error) { ret := _m.Called(ctx, clusterRole, opts) - var r0 *v1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, *v1.ClusterRole, metav1.CreateOptions) *v1.ClusterRole); ok { + var r0 *rbacv1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.ClusterRole, metav1.CreateOptions) *rbacv1.ClusterRole); ok { r0 = rf(ctx, clusterRole, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRole) + r0 = ret.Get(0).(*rbacv1.ClusterRole) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ClusterRole, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.ClusterRole, metav1.CreateOptions) error); ok { r1 = rf(ctx, clusterRole, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *ClusterRoleInterface) DeleteCollection(ctx context.Context, opts metav } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*rbacv1.ClusterRole, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.ClusterRole); ok { + var r0 *rbacv1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *rbacv1.ClusterRole); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRole) + r0 = ret.Get(0).(*rbacv1.ClusterRole) } } @@ -95,15 +120,15 @@ func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts metav } // List provides a mock function with given fields: ctx, opts -func (_m *ClusterRoleInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.ClusterRoleList, error) { +func (_m *ClusterRoleInterface) List(ctx context.Context, opts metav1.ListOptions) (*rbacv1.ClusterRoleList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.ClusterRoleList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.ClusterRoleList); ok { + var r0 *rbacv1.ClusterRoleList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *rbacv1.ClusterRoleList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRoleList) + r0 = ret.Get(0).(*rbacv1.ClusterRoleList) } } @@ -118,7 +143,7 @@ func (_m *ClusterRoleInterface) List(ctx context.Context, opts metav1.ListOption } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*rbacv1.ClusterRole, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.ClusterRole); ok { + var r0 *rbacv1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *rbacv1.ClusterRole); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRole) + r0 = ret.Get(0).(*rbacv1.ClusterRole) } } @@ -148,20 +173,20 @@ func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, clusterRole, opts -func (_m *ClusterRoleInterface) Update(ctx context.Context, clusterRole *v1.ClusterRole, opts metav1.UpdateOptions) (*v1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Update(ctx context.Context, clusterRole *rbacv1.ClusterRole, opts metav1.UpdateOptions) (*rbacv1.ClusterRole, error) { ret := _m.Called(ctx, clusterRole, opts) - var r0 *v1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, *v1.ClusterRole, metav1.UpdateOptions) *v1.ClusterRole); ok { + var r0 *rbacv1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.ClusterRole, metav1.UpdateOptions) *rbacv1.ClusterRole); ok { r0 = rf(ctx, clusterRole, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.ClusterRole) + r0 = ret.Get(0).(*rbacv1.ClusterRole) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.ClusterRole, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.ClusterRole, metav1.UpdateOptions) error); ok { r1 = rf(ctx, clusterRole, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1/role_binding_interface.go b/testutil/kubernetes_mock/typed/rbac/v1/role_binding_interface.go index d1340dafdd..41dc37e9e8 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1/role_binding_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1/role_binding_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + rbacv1 "k8s.io/api/rbac/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/rbac/v1" + v1 "k8s.io/client-go/applyconfigurations/rbac/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type RoleBindingInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, roleBinding, opts +func (_m *RoleBindingInterface) Apply(ctx context.Context, roleBinding *v1.RoleBindingApplyConfiguration, opts metav1.ApplyOptions) (*rbacv1.RoleBinding, error) { + ret := _m.Called(ctx, roleBinding, opts) + + var r0 *rbacv1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *v1.RoleBindingApplyConfiguration, metav1.ApplyOptions) *rbacv1.RoleBinding); ok { + r0 = rf(ctx, roleBinding, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1.RoleBinding) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.RoleBindingApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, roleBinding, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, roleBinding, opts -func (_m *RoleBindingInterface) Create(ctx context.Context, roleBinding *v1.RoleBinding, opts metav1.CreateOptions) (*v1.RoleBinding, error) { +func (_m *RoleBindingInterface) Create(ctx context.Context, roleBinding *rbacv1.RoleBinding, opts metav1.CreateOptions) (*rbacv1.RoleBinding, error) { ret := _m.Called(ctx, roleBinding, opts) - var r0 *v1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1.RoleBinding, metav1.CreateOptions) *v1.RoleBinding); ok { + var r0 *rbacv1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.RoleBinding, metav1.CreateOptions) *rbacv1.RoleBinding); ok { r0 = rf(ctx, roleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.RoleBinding) + r0 = ret.Get(0).(*rbacv1.RoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.RoleBinding, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.RoleBinding, metav1.CreateOptions) error); ok { r1 = rf(ctx, roleBinding, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *RoleBindingInterface) DeleteCollection(ctx context.Context, opts metav } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.RoleBinding, error) { +func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*rbacv1.RoleBinding, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.RoleBinding); ok { + var r0 *rbacv1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *rbacv1.RoleBinding); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.RoleBinding) + r0 = ret.Get(0).(*rbacv1.RoleBinding) } } @@ -95,15 +120,15 @@ func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts metav } // List provides a mock function with given fields: ctx, opts -func (_m *RoleBindingInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.RoleBindingList, error) { +func (_m *RoleBindingInterface) List(ctx context.Context, opts metav1.ListOptions) (*rbacv1.RoleBindingList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.RoleBindingList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.RoleBindingList); ok { + var r0 *rbacv1.RoleBindingList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *rbacv1.RoleBindingList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.RoleBindingList) + r0 = ret.Get(0).(*rbacv1.RoleBindingList) } } @@ -118,7 +143,7 @@ func (_m *RoleBindingInterface) List(ctx context.Context, opts metav1.ListOption } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.RoleBinding, error) { +func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*rbacv1.RoleBinding, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.RoleBinding); ok { + var r0 *rbacv1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *rbacv1.RoleBinding); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.RoleBinding) + r0 = ret.Get(0).(*rbacv1.RoleBinding) } } @@ -148,20 +173,20 @@ func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, roleBinding, opts -func (_m *RoleBindingInterface) Update(ctx context.Context, roleBinding *v1.RoleBinding, opts metav1.UpdateOptions) (*v1.RoleBinding, error) { +func (_m *RoleBindingInterface) Update(ctx context.Context, roleBinding *rbacv1.RoleBinding, opts metav1.UpdateOptions) (*rbacv1.RoleBinding, error) { ret := _m.Called(ctx, roleBinding, opts) - var r0 *v1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1.RoleBinding, metav1.UpdateOptions) *v1.RoleBinding); ok { + var r0 *rbacv1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.RoleBinding, metav1.UpdateOptions) *rbacv1.RoleBinding); ok { r0 = rf(ctx, roleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.RoleBinding) + r0 = ret.Get(0).(*rbacv1.RoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.RoleBinding, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.RoleBinding, metav1.UpdateOptions) error); ok { r1 = rf(ctx, roleBinding, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1/role_interface.go b/testutil/kubernetes_mock/typed/rbac/v1/role_interface.go index 42adf462ac..702444e657 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1/role_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1/role_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + rbacv1 "k8s.io/api/rbac/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/rbac/v1" + v1 "k8s.io/client-go/applyconfigurations/rbac/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type RoleInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, role, opts +func (_m *RoleInterface) Apply(ctx context.Context, role *v1.RoleApplyConfiguration, opts metav1.ApplyOptions) (*rbacv1.Role, error) { + ret := _m.Called(ctx, role, opts) + + var r0 *rbacv1.Role + if rf, ok := ret.Get(0).(func(context.Context, *v1.RoleApplyConfiguration, metav1.ApplyOptions) *rbacv1.Role); ok { + r0 = rf(ctx, role, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1.Role) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.RoleApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, role, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, role, opts -func (_m *RoleInterface) Create(ctx context.Context, role *v1.Role, opts metav1.CreateOptions) (*v1.Role, error) { +func (_m *RoleInterface) Create(ctx context.Context, role *rbacv1.Role, opts metav1.CreateOptions) (*rbacv1.Role, error) { ret := _m.Called(ctx, role, opts) - var r0 *v1.Role - if rf, ok := ret.Get(0).(func(context.Context, *v1.Role, metav1.CreateOptions) *v1.Role); ok { + var r0 *rbacv1.Role + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.Role, metav1.CreateOptions) *rbacv1.Role); ok { r0 = rf(ctx, role, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Role) + r0 = ret.Get(0).(*rbacv1.Role) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Role, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.Role, metav1.CreateOptions) error); ok { r1 = rf(ctx, role, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *RoleInterface) DeleteCollection(ctx context.Context, opts metav1.Delet } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RoleInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.Role, error) { +func (_m *RoleInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*rbacv1.Role, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.Role - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.Role); ok { + var r0 *rbacv1.Role + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *rbacv1.Role); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Role) + r0 = ret.Get(0).(*rbacv1.Role) } } @@ -95,15 +120,15 @@ func (_m *RoleInterface) Get(ctx context.Context, name string, opts metav1.GetOp } // List provides a mock function with given fields: ctx, opts -func (_m *RoleInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.RoleList, error) { +func (_m *RoleInterface) List(ctx context.Context, opts metav1.ListOptions) (*rbacv1.RoleList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.RoleList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.RoleList); ok { + var r0 *rbacv1.RoleList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *rbacv1.RoleList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.RoleList) + r0 = ret.Get(0).(*rbacv1.RoleList) } } @@ -118,7 +143,7 @@ func (_m *RoleInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1 } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.Role, error) { +func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*rbacv1.Role, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchT _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.Role - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.Role); ok { + var r0 *rbacv1.Role + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *rbacv1.Role); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Role) + r0 = ret.Get(0).(*rbacv1.Role) } } @@ -148,20 +173,20 @@ func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchT } // Update provides a mock function with given fields: ctx, role, opts -func (_m *RoleInterface) Update(ctx context.Context, role *v1.Role, opts metav1.UpdateOptions) (*v1.Role, error) { +func (_m *RoleInterface) Update(ctx context.Context, role *rbacv1.Role, opts metav1.UpdateOptions) (*rbacv1.Role, error) { ret := _m.Called(ctx, role, opts) - var r0 *v1.Role - if rf, ok := ret.Get(0).(func(context.Context, *v1.Role, metav1.UpdateOptions) *v1.Role); ok { + var r0 *rbacv1.Role + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1.Role, metav1.UpdateOptions) *rbacv1.Role); ok { r0 = rf(ctx, role, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.Role) + r0 = ret.Get(0).(*rbacv1.Role) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.Role, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1.Role, metav1.UpdateOptions) error); ok { r1 = rf(ctx, role, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_binding_interface.go b/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_binding_interface.go index c2c2a3a3dd..3f15ec7b0d 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_binding_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_binding_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1alpha1 "k8s.io/api/rbac/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/rbac/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/rbac/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type ClusterRoleBindingInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, clusterRoleBinding, opts +func (_m *ClusterRoleBindingInterface) Apply(ctx context.Context, clusterRoleBinding *v1alpha1.ClusterRoleBindingApplyConfiguration, opts v1.ApplyOptions) (*rbacv1alpha1.ClusterRoleBinding, error) { + ret := _m.Called(ctx, clusterRoleBinding, opts) + + var r0 *rbacv1alpha1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.ClusterRoleBindingApplyConfiguration, v1.ApplyOptions) *rbacv1alpha1.ClusterRoleBinding); ok { + r0 = rf(ctx, clusterRoleBinding, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleBinding) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.ClusterRoleBindingApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, clusterRoleBinding, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, clusterRoleBinding, opts -func (_m *ClusterRoleBindingInterface) Create(ctx context.Context, clusterRoleBinding *v1alpha1.ClusterRoleBinding, opts v1.CreateOptions) (*v1alpha1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Create(ctx context.Context, clusterRoleBinding *rbacv1alpha1.ClusterRoleBinding, opts v1.CreateOptions) (*rbacv1alpha1.ClusterRoleBinding, error) { ret := _m.Called(ctx, clusterRoleBinding, opts) - var r0 *v1alpha1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.ClusterRoleBinding, v1.CreateOptions) *v1alpha1.ClusterRoleBinding); ok { + var r0 *rbacv1alpha1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.ClusterRoleBinding, v1.CreateOptions) *rbacv1alpha1.ClusterRoleBinding); ok { r0 = rf(ctx, clusterRoleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.ClusterRoleBinding, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.ClusterRoleBinding, v1.CreateOptions) error); ok { r1 = rf(ctx, clusterRoleBinding, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *ClusterRoleBindingInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1alpha1.ClusterRoleBinding, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.ClusterRoleBinding); ok { + var r0 *rbacv1alpha1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1alpha1.ClusterRoleBinding); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleBinding) } } @@ -96,15 +120,15 @@ func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.ClusterRoleBindingList, error) { +func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1alpha1.ClusterRoleBindingList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.ClusterRoleBindingList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.ClusterRoleBindingList); ok { + var r0 *rbacv1alpha1.ClusterRoleBindingList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1alpha1.ClusterRoleBindingList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRoleBindingList) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleBindingList) } } @@ -119,7 +143,7 @@ func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts v1.ListOpt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1alpha1.ClusterRoleBinding, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.ClusterRoleBinding); ok { + var r0 *rbacv1alpha1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1alpha1.ClusterRoleBinding); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleBinding) } } @@ -149,20 +173,20 @@ func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, clusterRoleBinding, opts -func (_m *ClusterRoleBindingInterface) Update(ctx context.Context, clusterRoleBinding *v1alpha1.ClusterRoleBinding, opts v1.UpdateOptions) (*v1alpha1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Update(ctx context.Context, clusterRoleBinding *rbacv1alpha1.ClusterRoleBinding, opts v1.UpdateOptions) (*rbacv1alpha1.ClusterRoleBinding, error) { ret := _m.Called(ctx, clusterRoleBinding, opts) - var r0 *v1alpha1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.ClusterRoleBinding, v1.UpdateOptions) *v1alpha1.ClusterRoleBinding); ok { + var r0 *rbacv1alpha1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.ClusterRoleBinding, v1.UpdateOptions) *rbacv1alpha1.ClusterRoleBinding); ok { r0 = rf(ctx, clusterRoleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.ClusterRoleBinding, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.ClusterRoleBinding, v1.UpdateOptions) error); ok { r1 = rf(ctx, clusterRoleBinding, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_interface.go b/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_interface.go index 5a65dc3d08..ad8a64aabd 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1alpha1/cluster_role_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1alpha1 "k8s.io/api/rbac/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/rbac/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/rbac/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type ClusterRoleInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, clusterRole, opts +func (_m *ClusterRoleInterface) Apply(ctx context.Context, clusterRole *v1alpha1.ClusterRoleApplyConfiguration, opts v1.ApplyOptions) (*rbacv1alpha1.ClusterRole, error) { + ret := _m.Called(ctx, clusterRole, opts) + + var r0 *rbacv1alpha1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.ClusterRoleApplyConfiguration, v1.ApplyOptions) *rbacv1alpha1.ClusterRole); ok { + r0 = rf(ctx, clusterRole, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRole) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.ClusterRoleApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, clusterRole, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, clusterRole, opts -func (_m *ClusterRoleInterface) Create(ctx context.Context, clusterRole *v1alpha1.ClusterRole, opts v1.CreateOptions) (*v1alpha1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Create(ctx context.Context, clusterRole *rbacv1alpha1.ClusterRole, opts v1.CreateOptions) (*rbacv1alpha1.ClusterRole, error) { ret := _m.Called(ctx, clusterRole, opts) - var r0 *v1alpha1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.ClusterRole, v1.CreateOptions) *v1alpha1.ClusterRole); ok { + var r0 *rbacv1alpha1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.ClusterRole, v1.CreateOptions) *rbacv1alpha1.ClusterRole); ok { r0 = rf(ctx, clusterRole, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRole) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRole) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.ClusterRole, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.ClusterRole, v1.CreateOptions) error); ok { r1 = rf(ctx, clusterRole, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *ClusterRoleInterface) DeleteCollection(ctx context.Context, opts v1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1alpha1.ClusterRole, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.ClusterRole); ok { + var r0 *rbacv1alpha1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1alpha1.ClusterRole); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRole) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRole) } } @@ -96,15 +120,15 @@ func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts v1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *ClusterRoleInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.ClusterRoleList, error) { +func (_m *ClusterRoleInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1alpha1.ClusterRoleList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.ClusterRoleList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.ClusterRoleList); ok { + var r0 *rbacv1alpha1.ClusterRoleList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1alpha1.ClusterRoleList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRoleList) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRoleList) } } @@ -119,7 +143,7 @@ func (_m *ClusterRoleInterface) List(ctx context.Context, opts v1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1alpha1.ClusterRole, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.ClusterRole); ok { + var r0 *rbacv1alpha1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1alpha1.ClusterRole); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRole) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRole) } } @@ -149,20 +173,20 @@ func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, clusterRole, opts -func (_m *ClusterRoleInterface) Update(ctx context.Context, clusterRole *v1alpha1.ClusterRole, opts v1.UpdateOptions) (*v1alpha1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Update(ctx context.Context, clusterRole *rbacv1alpha1.ClusterRole, opts v1.UpdateOptions) (*rbacv1alpha1.ClusterRole, error) { ret := _m.Called(ctx, clusterRole, opts) - var r0 *v1alpha1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.ClusterRole, v1.UpdateOptions) *v1alpha1.ClusterRole); ok { + var r0 *rbacv1alpha1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.ClusterRole, v1.UpdateOptions) *rbacv1alpha1.ClusterRole); ok { r0 = rf(ctx, clusterRole, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.ClusterRole) + r0 = ret.Get(0).(*rbacv1alpha1.ClusterRole) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.ClusterRole, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.ClusterRole, v1.UpdateOptions) error); ok { r1 = rf(ctx, clusterRole, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_binding_interface.go b/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_binding_interface.go index 771268934c..47e678d3cb 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_binding_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_binding_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1alpha1 "k8s.io/api/rbac/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/rbac/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/rbac/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type RoleBindingInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, roleBinding, opts +func (_m *RoleBindingInterface) Apply(ctx context.Context, roleBinding *v1alpha1.RoleBindingApplyConfiguration, opts v1.ApplyOptions) (*rbacv1alpha1.RoleBinding, error) { + ret := _m.Called(ctx, roleBinding, opts) + + var r0 *rbacv1alpha1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RoleBindingApplyConfiguration, v1.ApplyOptions) *rbacv1alpha1.RoleBinding); ok { + r0 = rf(ctx, roleBinding, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1alpha1.RoleBinding) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RoleBindingApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, roleBinding, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, roleBinding, opts -func (_m *RoleBindingInterface) Create(ctx context.Context, roleBinding *v1alpha1.RoleBinding, opts v1.CreateOptions) (*v1alpha1.RoleBinding, error) { +func (_m *RoleBindingInterface) Create(ctx context.Context, roleBinding *rbacv1alpha1.RoleBinding, opts v1.CreateOptions) (*rbacv1alpha1.RoleBinding, error) { ret := _m.Called(ctx, roleBinding, opts) - var r0 *v1alpha1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RoleBinding, v1.CreateOptions) *v1alpha1.RoleBinding); ok { + var r0 *rbacv1alpha1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.RoleBinding, v1.CreateOptions) *rbacv1alpha1.RoleBinding); ok { r0 = rf(ctx, roleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.RoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RoleBinding, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.RoleBinding, v1.CreateOptions) error); ok { r1 = rf(ctx, roleBinding, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *RoleBindingInterface) DeleteCollection(ctx context.Context, opts v1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.RoleBinding, error) { +func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1alpha1.RoleBinding, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.RoleBinding); ok { + var r0 *rbacv1alpha1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1alpha1.RoleBinding); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.RoleBinding) } } @@ -96,15 +120,15 @@ func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts v1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *RoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.RoleBindingList, error) { +func (_m *RoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1alpha1.RoleBindingList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.RoleBindingList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.RoleBindingList); ok { + var r0 *rbacv1alpha1.RoleBindingList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1alpha1.RoleBindingList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RoleBindingList) + r0 = ret.Get(0).(*rbacv1alpha1.RoleBindingList) } } @@ -119,7 +143,7 @@ func (_m *RoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.RoleBinding, error) { +func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1alpha1.RoleBinding, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.RoleBinding); ok { + var r0 *rbacv1alpha1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1alpha1.RoleBinding); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.RoleBinding) } } @@ -149,20 +173,20 @@ func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, roleBinding, opts -func (_m *RoleBindingInterface) Update(ctx context.Context, roleBinding *v1alpha1.RoleBinding, opts v1.UpdateOptions) (*v1alpha1.RoleBinding, error) { +func (_m *RoleBindingInterface) Update(ctx context.Context, roleBinding *rbacv1alpha1.RoleBinding, opts v1.UpdateOptions) (*rbacv1alpha1.RoleBinding, error) { ret := _m.Called(ctx, roleBinding, opts) - var r0 *v1alpha1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RoleBinding, v1.UpdateOptions) *v1alpha1.RoleBinding); ok { + var r0 *rbacv1alpha1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.RoleBinding, v1.UpdateOptions) *rbacv1alpha1.RoleBinding); ok { r0 = rf(ctx, roleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RoleBinding) + r0 = ret.Get(0).(*rbacv1alpha1.RoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RoleBinding, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.RoleBinding, v1.UpdateOptions) error); ok { r1 = rf(ctx, roleBinding, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_interface.go b/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_interface.go index 411604cfb8..77beabbe27 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1alpha1/role_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1alpha1 "k8s.io/api/rbac/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/rbac/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/rbac/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type RoleInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, role, opts +func (_m *RoleInterface) Apply(ctx context.Context, role *v1alpha1.RoleApplyConfiguration, opts v1.ApplyOptions) (*rbacv1alpha1.Role, error) { + ret := _m.Called(ctx, role, opts) + + var r0 *rbacv1alpha1.Role + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.RoleApplyConfiguration, v1.ApplyOptions) *rbacv1alpha1.Role); ok { + r0 = rf(ctx, role, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1alpha1.Role) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.RoleApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, role, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, role, opts -func (_m *RoleInterface) Create(ctx context.Context, role *v1alpha1.Role, opts v1.CreateOptions) (*v1alpha1.Role, error) { +func (_m *RoleInterface) Create(ctx context.Context, role *rbacv1alpha1.Role, opts v1.CreateOptions) (*rbacv1alpha1.Role, error) { ret := _m.Called(ctx, role, opts) - var r0 *v1alpha1.Role - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.Role, v1.CreateOptions) *v1alpha1.Role); ok { + var r0 *rbacv1alpha1.Role + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.Role, v1.CreateOptions) *rbacv1alpha1.Role); ok { r0 = rf(ctx, role, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.Role) + r0 = ret.Get(0).(*rbacv1alpha1.Role) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.Role, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.Role, v1.CreateOptions) error); ok { r1 = rf(ctx, role, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *RoleInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOpt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.Role, error) { +func (_m *RoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1alpha1.Role, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.Role - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.Role); ok { + var r0 *rbacv1alpha1.Role + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1alpha1.Role); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.Role) + r0 = ret.Get(0).(*rbacv1alpha1.Role) } } @@ -96,15 +120,15 @@ func (_m *RoleInterface) Get(ctx context.Context, name string, opts v1.GetOption } // List provides a mock function with given fields: ctx, opts -func (_m *RoleInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.RoleList, error) { +func (_m *RoleInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1alpha1.RoleList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.RoleList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.RoleList); ok { + var r0 *rbacv1alpha1.RoleList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1alpha1.RoleList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.RoleList) + r0 = ret.Get(0).(*rbacv1alpha1.RoleList) } } @@ -119,7 +143,7 @@ func (_m *RoleInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alph } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.Role, error) { +func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1alpha1.Role, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchT _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.Role - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.Role); ok { + var r0 *rbacv1alpha1.Role + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1alpha1.Role); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.Role) + r0 = ret.Get(0).(*rbacv1alpha1.Role) } } @@ -149,20 +173,20 @@ func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchT } // Update provides a mock function with given fields: ctx, role, opts -func (_m *RoleInterface) Update(ctx context.Context, role *v1alpha1.Role, opts v1.UpdateOptions) (*v1alpha1.Role, error) { +func (_m *RoleInterface) Update(ctx context.Context, role *rbacv1alpha1.Role, opts v1.UpdateOptions) (*rbacv1alpha1.Role, error) { ret := _m.Called(ctx, role, opts) - var r0 *v1alpha1.Role - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.Role, v1.UpdateOptions) *v1alpha1.Role); ok { + var r0 *rbacv1alpha1.Role + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1alpha1.Role, v1.UpdateOptions) *rbacv1alpha1.Role); ok { r0 = rf(ctx, role, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.Role) + r0 = ret.Get(0).(*rbacv1alpha1.Role) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.Role, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1alpha1.Role, v1.UpdateOptions) error); ok { r1 = rf(ctx, role, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_binding_interface.go b/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_binding_interface.go index 39ee987fb6..16a060163f 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_binding_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_binding_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1beta1 "k8s.io/api/rbac/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/rbac/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/rbac/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type ClusterRoleBindingInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, clusterRoleBinding, opts +func (_m *ClusterRoleBindingInterface) Apply(ctx context.Context, clusterRoleBinding *v1beta1.ClusterRoleBindingApplyConfiguration, opts v1.ApplyOptions) (*rbacv1beta1.ClusterRoleBinding, error) { + ret := _m.Called(ctx, clusterRoleBinding, opts) + + var r0 *rbacv1beta1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ClusterRoleBindingApplyConfiguration, v1.ApplyOptions) *rbacv1beta1.ClusterRoleBinding); ok { + r0 = rf(ctx, clusterRoleBinding, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleBinding) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ClusterRoleBindingApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, clusterRoleBinding, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, clusterRoleBinding, opts -func (_m *ClusterRoleBindingInterface) Create(ctx context.Context, clusterRoleBinding *v1beta1.ClusterRoleBinding, opts v1.CreateOptions) (*v1beta1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Create(ctx context.Context, clusterRoleBinding *rbacv1beta1.ClusterRoleBinding, opts v1.CreateOptions) (*rbacv1beta1.ClusterRoleBinding, error) { ret := _m.Called(ctx, clusterRoleBinding, opts) - var r0 *v1beta1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ClusterRoleBinding, v1.CreateOptions) *v1beta1.ClusterRoleBinding); ok { + var r0 *rbacv1beta1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.ClusterRoleBinding, v1.CreateOptions) *rbacv1beta1.ClusterRoleBinding); ok { r0 = rf(ctx, clusterRoleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ClusterRoleBinding, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.ClusterRoleBinding, v1.CreateOptions) error); ok { r1 = rf(ctx, clusterRoleBinding, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *ClusterRoleBindingInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1beta1.ClusterRoleBinding, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.ClusterRoleBinding); ok { + var r0 *rbacv1beta1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1beta1.ClusterRoleBinding); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleBinding) } } @@ -96,15 +120,15 @@ func (_m *ClusterRoleBindingInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.ClusterRoleBindingList, error) { +func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1beta1.ClusterRoleBindingList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.ClusterRoleBindingList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.ClusterRoleBindingList); ok { + var r0 *rbacv1beta1.ClusterRoleBindingList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1beta1.ClusterRoleBindingList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRoleBindingList) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleBindingList) } } @@ -119,7 +143,7 @@ func (_m *ClusterRoleBindingInterface) List(ctx context.Context, opts v1.ListOpt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1beta1.ClusterRoleBinding, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.ClusterRoleBinding); ok { + var r0 *rbacv1beta1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1beta1.ClusterRoleBinding); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleBinding) } } @@ -149,20 +173,20 @@ func (_m *ClusterRoleBindingInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, clusterRoleBinding, opts -func (_m *ClusterRoleBindingInterface) Update(ctx context.Context, clusterRoleBinding *v1beta1.ClusterRoleBinding, opts v1.UpdateOptions) (*v1beta1.ClusterRoleBinding, error) { +func (_m *ClusterRoleBindingInterface) Update(ctx context.Context, clusterRoleBinding *rbacv1beta1.ClusterRoleBinding, opts v1.UpdateOptions) (*rbacv1beta1.ClusterRoleBinding, error) { ret := _m.Called(ctx, clusterRoleBinding, opts) - var r0 *v1beta1.ClusterRoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ClusterRoleBinding, v1.UpdateOptions) *v1beta1.ClusterRoleBinding); ok { + var r0 *rbacv1beta1.ClusterRoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.ClusterRoleBinding, v1.UpdateOptions) *rbacv1beta1.ClusterRoleBinding); ok { r0 = rf(ctx, clusterRoleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ClusterRoleBinding, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.ClusterRoleBinding, v1.UpdateOptions) error); ok { r1 = rf(ctx, clusterRoleBinding, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_interface.go b/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_interface.go index 7fc92c4b6f..e6e63dbc6e 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1beta1/cluster_role_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1beta1 "k8s.io/api/rbac/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/rbac/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/rbac/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type ClusterRoleInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, clusterRole, opts +func (_m *ClusterRoleInterface) Apply(ctx context.Context, clusterRole *v1beta1.ClusterRoleApplyConfiguration, opts v1.ApplyOptions) (*rbacv1beta1.ClusterRole, error) { + ret := _m.Called(ctx, clusterRole, opts) + + var r0 *rbacv1beta1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ClusterRoleApplyConfiguration, v1.ApplyOptions) *rbacv1beta1.ClusterRole); ok { + r0 = rf(ctx, clusterRole, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1beta1.ClusterRole) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ClusterRoleApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, clusterRole, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, clusterRole, opts -func (_m *ClusterRoleInterface) Create(ctx context.Context, clusterRole *v1beta1.ClusterRole, opts v1.CreateOptions) (*v1beta1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Create(ctx context.Context, clusterRole *rbacv1beta1.ClusterRole, opts v1.CreateOptions) (*rbacv1beta1.ClusterRole, error) { ret := _m.Called(ctx, clusterRole, opts) - var r0 *v1beta1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ClusterRole, v1.CreateOptions) *v1beta1.ClusterRole); ok { + var r0 *rbacv1beta1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.ClusterRole, v1.CreateOptions) *rbacv1beta1.ClusterRole); ok { r0 = rf(ctx, clusterRole, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRole) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRole) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ClusterRole, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.ClusterRole, v1.CreateOptions) error); ok { r1 = rf(ctx, clusterRole, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *ClusterRoleInterface) DeleteCollection(ctx context.Context, opts v1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1beta1.ClusterRole, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.ClusterRole); ok { + var r0 *rbacv1beta1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1beta1.ClusterRole); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRole) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRole) } } @@ -96,15 +120,15 @@ func (_m *ClusterRoleInterface) Get(ctx context.Context, name string, opts v1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *ClusterRoleInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.ClusterRoleList, error) { +func (_m *ClusterRoleInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1beta1.ClusterRoleList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.ClusterRoleList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.ClusterRoleList); ok { + var r0 *rbacv1beta1.ClusterRoleList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1beta1.ClusterRoleList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRoleList) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRoleList) } } @@ -119,7 +143,7 @@ func (_m *ClusterRoleInterface) List(ctx context.Context, opts v1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1beta1.ClusterRole, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.ClusterRole); ok { + var r0 *rbacv1beta1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1beta1.ClusterRole); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRole) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRole) } } @@ -149,20 +173,20 @@ func (_m *ClusterRoleInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, clusterRole, opts -func (_m *ClusterRoleInterface) Update(ctx context.Context, clusterRole *v1beta1.ClusterRole, opts v1.UpdateOptions) (*v1beta1.ClusterRole, error) { +func (_m *ClusterRoleInterface) Update(ctx context.Context, clusterRole *rbacv1beta1.ClusterRole, opts v1.UpdateOptions) (*rbacv1beta1.ClusterRole, error) { ret := _m.Called(ctx, clusterRole, opts) - var r0 *v1beta1.ClusterRole - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.ClusterRole, v1.UpdateOptions) *v1beta1.ClusterRole); ok { + var r0 *rbacv1beta1.ClusterRole + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.ClusterRole, v1.UpdateOptions) *rbacv1beta1.ClusterRole); ok { r0 = rf(ctx, clusterRole, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.ClusterRole) + r0 = ret.Get(0).(*rbacv1beta1.ClusterRole) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.ClusterRole, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.ClusterRole, v1.UpdateOptions) error); ok { r1 = rf(ctx, clusterRole, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1beta1/role_binding_interface.go b/testutil/kubernetes_mock/typed/rbac/v1beta1/role_binding_interface.go index acfbbec708..19853ca378 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1beta1/role_binding_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1beta1/role_binding_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1beta1 "k8s.io/api/rbac/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/rbac/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/rbac/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type RoleBindingInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, roleBinding, opts +func (_m *RoleBindingInterface) Apply(ctx context.Context, roleBinding *v1beta1.RoleBindingApplyConfiguration, opts v1.ApplyOptions) (*rbacv1beta1.RoleBinding, error) { + ret := _m.Called(ctx, roleBinding, opts) + + var r0 *rbacv1beta1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RoleBindingApplyConfiguration, v1.ApplyOptions) *rbacv1beta1.RoleBinding); ok { + r0 = rf(ctx, roleBinding, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1beta1.RoleBinding) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RoleBindingApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, roleBinding, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, roleBinding, opts -func (_m *RoleBindingInterface) Create(ctx context.Context, roleBinding *v1beta1.RoleBinding, opts v1.CreateOptions) (*v1beta1.RoleBinding, error) { +func (_m *RoleBindingInterface) Create(ctx context.Context, roleBinding *rbacv1beta1.RoleBinding, opts v1.CreateOptions) (*rbacv1beta1.RoleBinding, error) { ret := _m.Called(ctx, roleBinding, opts) - var r0 *v1beta1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RoleBinding, v1.CreateOptions) *v1beta1.RoleBinding); ok { + var r0 *rbacv1beta1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.RoleBinding, v1.CreateOptions) *rbacv1beta1.RoleBinding); ok { r0 = rf(ctx, roleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.RoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RoleBinding, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.RoleBinding, v1.CreateOptions) error); ok { r1 = rf(ctx, roleBinding, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *RoleBindingInterface) DeleteCollection(ctx context.Context, opts v1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.RoleBinding, error) { +func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1beta1.RoleBinding, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.RoleBinding); ok { + var r0 *rbacv1beta1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1beta1.RoleBinding); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.RoleBinding) } } @@ -96,15 +120,15 @@ func (_m *RoleBindingInterface) Get(ctx context.Context, name string, opts v1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *RoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.RoleBindingList, error) { +func (_m *RoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1beta1.RoleBindingList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.RoleBindingList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.RoleBindingList); ok { + var r0 *rbacv1beta1.RoleBindingList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1beta1.RoleBindingList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RoleBindingList) + r0 = ret.Get(0).(*rbacv1beta1.RoleBindingList) } } @@ -119,7 +143,7 @@ func (_m *RoleBindingInterface) List(ctx context.Context, opts v1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.RoleBinding, error) { +func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1beta1.RoleBinding, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.RoleBinding); ok { + var r0 *rbacv1beta1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1beta1.RoleBinding); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.RoleBinding) } } @@ -149,20 +173,20 @@ func (_m *RoleBindingInterface) Patch(ctx context.Context, name string, pt types } // Update provides a mock function with given fields: ctx, roleBinding, opts -func (_m *RoleBindingInterface) Update(ctx context.Context, roleBinding *v1beta1.RoleBinding, opts v1.UpdateOptions) (*v1beta1.RoleBinding, error) { +func (_m *RoleBindingInterface) Update(ctx context.Context, roleBinding *rbacv1beta1.RoleBinding, opts v1.UpdateOptions) (*rbacv1beta1.RoleBinding, error) { ret := _m.Called(ctx, roleBinding, opts) - var r0 *v1beta1.RoleBinding - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RoleBinding, v1.UpdateOptions) *v1beta1.RoleBinding); ok { + var r0 *rbacv1beta1.RoleBinding + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.RoleBinding, v1.UpdateOptions) *rbacv1beta1.RoleBinding); ok { r0 = rf(ctx, roleBinding, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RoleBinding) + r0 = ret.Get(0).(*rbacv1beta1.RoleBinding) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RoleBinding, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.RoleBinding, v1.UpdateOptions) error); ok { r1 = rf(ctx, roleBinding, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/rbac/v1beta1/role_interface.go b/testutil/kubernetes_mock/typed/rbac/v1beta1/role_interface.go index 830cc1fd3b..9977552b9b 100644 --- a/testutil/kubernetes_mock/typed/rbac/v1beta1/role_interface.go +++ b/testutil/kubernetes_mock/typed/rbac/v1beta1/role_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + rbacv1beta1 "k8s.io/api/rbac/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/rbac/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/rbac/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type RoleInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, role, opts +func (_m *RoleInterface) Apply(ctx context.Context, role *v1beta1.RoleApplyConfiguration, opts v1.ApplyOptions) (*rbacv1beta1.Role, error) { + ret := _m.Called(ctx, role, opts) + + var r0 *rbacv1beta1.Role + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.RoleApplyConfiguration, v1.ApplyOptions) *rbacv1beta1.Role); ok { + r0 = rf(ctx, role, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*rbacv1beta1.Role) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.RoleApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, role, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, role, opts -func (_m *RoleInterface) Create(ctx context.Context, role *v1beta1.Role, opts v1.CreateOptions) (*v1beta1.Role, error) { +func (_m *RoleInterface) Create(ctx context.Context, role *rbacv1beta1.Role, opts v1.CreateOptions) (*rbacv1beta1.Role, error) { ret := _m.Called(ctx, role, opts) - var r0 *v1beta1.Role - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Role, v1.CreateOptions) *v1beta1.Role); ok { + var r0 *rbacv1beta1.Role + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.Role, v1.CreateOptions) *rbacv1beta1.Role); ok { r0 = rf(ctx, role, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Role) + r0 = ret.Get(0).(*rbacv1beta1.Role) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Role, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.Role, v1.CreateOptions) error); ok { r1 = rf(ctx, role, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *RoleInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOpt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *RoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.Role, error) { +func (_m *RoleInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*rbacv1beta1.Role, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.Role - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.Role); ok { + var r0 *rbacv1beta1.Role + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *rbacv1beta1.Role); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Role) + r0 = ret.Get(0).(*rbacv1beta1.Role) } } @@ -96,15 +120,15 @@ func (_m *RoleInterface) Get(ctx context.Context, name string, opts v1.GetOption } // List provides a mock function with given fields: ctx, opts -func (_m *RoleInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.RoleList, error) { +func (_m *RoleInterface) List(ctx context.Context, opts v1.ListOptions) (*rbacv1beta1.RoleList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.RoleList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.RoleList); ok { + var r0 *rbacv1beta1.RoleList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *rbacv1beta1.RoleList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.RoleList) + r0 = ret.Get(0).(*rbacv1beta1.RoleList) } } @@ -119,7 +143,7 @@ func (_m *RoleInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.Role, error) { +func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*rbacv1beta1.Role, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchT _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.Role - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.Role); ok { + var r0 *rbacv1beta1.Role + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *rbacv1beta1.Role); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Role) + r0 = ret.Get(0).(*rbacv1beta1.Role) } } @@ -149,20 +173,20 @@ func (_m *RoleInterface) Patch(ctx context.Context, name string, pt types.PatchT } // Update provides a mock function with given fields: ctx, role, opts -func (_m *RoleInterface) Update(ctx context.Context, role *v1beta1.Role, opts v1.UpdateOptions) (*v1beta1.Role, error) { +func (_m *RoleInterface) Update(ctx context.Context, role *rbacv1beta1.Role, opts v1.UpdateOptions) (*rbacv1beta1.Role, error) { ret := _m.Called(ctx, role, opts) - var r0 *v1beta1.Role - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.Role, v1.UpdateOptions) *v1beta1.Role); ok { + var r0 *rbacv1beta1.Role + if rf, ok := ret.Get(0).(func(context.Context, *rbacv1beta1.Role, v1.UpdateOptions) *rbacv1beta1.Role); ok { r0 = rf(ctx, role, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.Role) + r0 = ret.Get(0).(*rbacv1beta1.Role) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.Role, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *rbacv1beta1.Role, v1.UpdateOptions) error); ok { r1 = rf(ctx, role, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/scheduling/v1/priority_class_interface.go b/testutil/kubernetes_mock/typed/scheduling/v1/priority_class_interface.go index 90f7f8bc28..cda0b3bf91 100644 --- a/testutil/kubernetes_mock/typed/scheduling/v1/priority_class_interface.go +++ b/testutil/kubernetes_mock/typed/scheduling/v1/priority_class_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + schedulingv1 "k8s.io/api/scheduling/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/scheduling/v1" + v1 "k8s.io/client-go/applyconfigurations/scheduling/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type PriorityClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, priorityClass, opts +func (_m *PriorityClassInterface) Apply(ctx context.Context, priorityClass *v1.PriorityClassApplyConfiguration, opts metav1.ApplyOptions) (*schedulingv1.PriorityClass, error) { + ret := _m.Called(ctx, priorityClass, opts) + + var r0 *schedulingv1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *v1.PriorityClassApplyConfiguration, metav1.ApplyOptions) *schedulingv1.PriorityClass); ok { + r0 = rf(ctx, priorityClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*schedulingv1.PriorityClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.PriorityClassApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, priorityClass, opts -func (_m *PriorityClassInterface) Create(ctx context.Context, priorityClass *v1.PriorityClass, opts metav1.CreateOptions) (*v1.PriorityClass, error) { +func (_m *PriorityClassInterface) Create(ctx context.Context, priorityClass *schedulingv1.PriorityClass, opts metav1.CreateOptions) (*schedulingv1.PriorityClass, error) { ret := _m.Called(ctx, priorityClass, opts) - var r0 *v1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, *v1.PriorityClass, metav1.CreateOptions) *v1.PriorityClass); ok { + var r0 *schedulingv1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *schedulingv1.PriorityClass, metav1.CreateOptions) *schedulingv1.PriorityClass); ok { r0 = rf(ctx, priorityClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1.PriorityClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PriorityClass, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *schedulingv1.PriorityClass, metav1.CreateOptions) error); ok { r1 = rf(ctx, priorityClass, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *PriorityClassInterface) DeleteCollection(ctx context.Context, opts met } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.PriorityClass, error) { +func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*schedulingv1.PriorityClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.PriorityClass); ok { + var r0 *schedulingv1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *schedulingv1.PriorityClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1.PriorityClass) } } @@ -95,15 +120,15 @@ func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts met } // List provides a mock function with given fields: ctx, opts -func (_m *PriorityClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.PriorityClassList, error) { +func (_m *PriorityClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*schedulingv1.PriorityClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.PriorityClassList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.PriorityClassList); ok { + var r0 *schedulingv1.PriorityClassList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *schedulingv1.PriorityClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PriorityClassList) + r0 = ret.Get(0).(*schedulingv1.PriorityClassList) } } @@ -118,7 +143,7 @@ func (_m *PriorityClassInterface) List(ctx context.Context, opts metav1.ListOpti } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.PriorityClass, error) { +func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*schedulingv1.PriorityClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.PriorityClass); ok { + var r0 *schedulingv1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *schedulingv1.PriorityClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1.PriorityClass) } } @@ -148,20 +173,20 @@ func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, priorityClass, opts -func (_m *PriorityClassInterface) Update(ctx context.Context, priorityClass *v1.PriorityClass, opts metav1.UpdateOptions) (*v1.PriorityClass, error) { +func (_m *PriorityClassInterface) Update(ctx context.Context, priorityClass *schedulingv1.PriorityClass, opts metav1.UpdateOptions) (*schedulingv1.PriorityClass, error) { ret := _m.Called(ctx, priorityClass, opts) - var r0 *v1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, *v1.PriorityClass, metav1.UpdateOptions) *v1.PriorityClass); ok { + var r0 *schedulingv1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *schedulingv1.PriorityClass, metav1.UpdateOptions) *schedulingv1.PriorityClass); ok { r0 = rf(ctx, priorityClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1.PriorityClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.PriorityClass, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *schedulingv1.PriorityClass, metav1.UpdateOptions) error); ok { r1 = rf(ctx, priorityClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/scheduling/v1alpha1/priority_class_interface.go b/testutil/kubernetes_mock/typed/scheduling/v1alpha1/priority_class_interface.go index c9d05073e6..f211af5355 100644 --- a/testutil/kubernetes_mock/typed/scheduling/v1alpha1/priority_class_interface.go +++ b/testutil/kubernetes_mock/typed/scheduling/v1alpha1/priority_class_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + schedulingv1alpha1 "k8s.io/api/scheduling/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/scheduling/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/scheduling/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type PriorityClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, priorityClass, opts +func (_m *PriorityClassInterface) Apply(ctx context.Context, priorityClass *v1alpha1.PriorityClassApplyConfiguration, opts v1.ApplyOptions) (*schedulingv1alpha1.PriorityClass, error) { + ret := _m.Called(ctx, priorityClass, opts) + + var r0 *schedulingv1alpha1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityClassApplyConfiguration, v1.ApplyOptions) *schedulingv1alpha1.PriorityClass); ok { + r0 = rf(ctx, priorityClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*schedulingv1alpha1.PriorityClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityClassApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, priorityClass, opts -func (_m *PriorityClassInterface) Create(ctx context.Context, priorityClass *v1alpha1.PriorityClass, opts v1.CreateOptions) (*v1alpha1.PriorityClass, error) { +func (_m *PriorityClassInterface) Create(ctx context.Context, priorityClass *schedulingv1alpha1.PriorityClass, opts v1.CreateOptions) (*schedulingv1alpha1.PriorityClass, error) { ret := _m.Called(ctx, priorityClass, opts) - var r0 *v1alpha1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityClass, v1.CreateOptions) *v1alpha1.PriorityClass); ok { + var r0 *schedulingv1alpha1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *schedulingv1alpha1.PriorityClass, v1.CreateOptions) *schedulingv1alpha1.PriorityClass); ok { r0 = rf(ctx, priorityClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1alpha1.PriorityClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityClass, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *schedulingv1alpha1.PriorityClass, v1.CreateOptions) error); ok { r1 = rf(ctx, priorityClass, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *PriorityClassInterface) DeleteCollection(ctx context.Context, opts v1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.PriorityClass, error) { +func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*schedulingv1alpha1.PriorityClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.PriorityClass); ok { + var r0 *schedulingv1alpha1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *schedulingv1alpha1.PriorityClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1alpha1.PriorityClass) } } @@ -96,15 +120,15 @@ func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts v1. } // List provides a mock function with given fields: ctx, opts -func (_m *PriorityClassInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.PriorityClassList, error) { +func (_m *PriorityClassInterface) List(ctx context.Context, opts v1.ListOptions) (*schedulingv1alpha1.PriorityClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.PriorityClassList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.PriorityClassList); ok { + var r0 *schedulingv1alpha1.PriorityClassList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *schedulingv1alpha1.PriorityClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityClassList) + r0 = ret.Get(0).(*schedulingv1alpha1.PriorityClassList) } } @@ -119,7 +143,7 @@ func (_m *PriorityClassInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.PriorityClass, error) { +func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*schedulingv1alpha1.PriorityClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.PriorityClass); ok { + var r0 *schedulingv1alpha1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *schedulingv1alpha1.PriorityClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1alpha1.PriorityClass) } } @@ -149,20 +173,20 @@ func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, priorityClass, opts -func (_m *PriorityClassInterface) Update(ctx context.Context, priorityClass *v1alpha1.PriorityClass, opts v1.UpdateOptions) (*v1alpha1.PriorityClass, error) { +func (_m *PriorityClassInterface) Update(ctx context.Context, priorityClass *schedulingv1alpha1.PriorityClass, opts v1.UpdateOptions) (*schedulingv1alpha1.PriorityClass, error) { ret := _m.Called(ctx, priorityClass, opts) - var r0 *v1alpha1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PriorityClass, v1.UpdateOptions) *v1alpha1.PriorityClass); ok { + var r0 *schedulingv1alpha1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *schedulingv1alpha1.PriorityClass, v1.UpdateOptions) *schedulingv1alpha1.PriorityClass); ok { r0 = rf(ctx, priorityClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1alpha1.PriorityClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PriorityClass, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *schedulingv1alpha1.PriorityClass, v1.UpdateOptions) error); ok { r1 = rf(ctx, priorityClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/scheduling/v1beta1/priority_class_interface.go b/testutil/kubernetes_mock/typed/scheduling/v1beta1/priority_class_interface.go index bc4649659d..5950542cd7 100644 --- a/testutil/kubernetes_mock/typed/scheduling/v1beta1/priority_class_interface.go +++ b/testutil/kubernetes_mock/typed/scheduling/v1beta1/priority_class_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + schedulingv1beta1 "k8s.io/api/scheduling/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/scheduling/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/scheduling/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type PriorityClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, priorityClass, opts +func (_m *PriorityClassInterface) Apply(ctx context.Context, priorityClass *v1beta1.PriorityClassApplyConfiguration, opts v1.ApplyOptions) (*schedulingv1beta1.PriorityClass, error) { + ret := _m.Called(ctx, priorityClass, opts) + + var r0 *schedulingv1beta1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PriorityClassApplyConfiguration, v1.ApplyOptions) *schedulingv1beta1.PriorityClass); ok { + r0 = rf(ctx, priorityClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*schedulingv1beta1.PriorityClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PriorityClassApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, priorityClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, priorityClass, opts -func (_m *PriorityClassInterface) Create(ctx context.Context, priorityClass *v1beta1.PriorityClass, opts v1.CreateOptions) (*v1beta1.PriorityClass, error) { +func (_m *PriorityClassInterface) Create(ctx context.Context, priorityClass *schedulingv1beta1.PriorityClass, opts v1.CreateOptions) (*schedulingv1beta1.PriorityClass, error) { ret := _m.Called(ctx, priorityClass, opts) - var r0 *v1beta1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PriorityClass, v1.CreateOptions) *v1beta1.PriorityClass); ok { + var r0 *schedulingv1beta1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *schedulingv1beta1.PriorityClass, v1.CreateOptions) *schedulingv1beta1.PriorityClass); ok { r0 = rf(ctx, priorityClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1beta1.PriorityClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PriorityClass, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *schedulingv1beta1.PriorityClass, v1.CreateOptions) error); ok { r1 = rf(ctx, priorityClass, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *PriorityClassInterface) DeleteCollection(ctx context.Context, opts v1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.PriorityClass, error) { +func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*schedulingv1beta1.PriorityClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.PriorityClass); ok { + var r0 *schedulingv1beta1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *schedulingv1beta1.PriorityClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1beta1.PriorityClass) } } @@ -96,15 +120,15 @@ func (_m *PriorityClassInterface) Get(ctx context.Context, name string, opts v1. } // List provides a mock function with given fields: ctx, opts -func (_m *PriorityClassInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.PriorityClassList, error) { +func (_m *PriorityClassInterface) List(ctx context.Context, opts v1.ListOptions) (*schedulingv1beta1.PriorityClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.PriorityClassList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.PriorityClassList); ok { + var r0 *schedulingv1beta1.PriorityClassList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *schedulingv1beta1.PriorityClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PriorityClassList) + r0 = ret.Get(0).(*schedulingv1beta1.PriorityClassList) } } @@ -119,7 +143,7 @@ func (_m *PriorityClassInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.PriorityClass, error) { +func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*schedulingv1beta1.PriorityClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt typ _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.PriorityClass); ok { + var r0 *schedulingv1beta1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *schedulingv1beta1.PriorityClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1beta1.PriorityClass) } } @@ -149,20 +173,20 @@ func (_m *PriorityClassInterface) Patch(ctx context.Context, name string, pt typ } // Update provides a mock function with given fields: ctx, priorityClass, opts -func (_m *PriorityClassInterface) Update(ctx context.Context, priorityClass *v1beta1.PriorityClass, opts v1.UpdateOptions) (*v1beta1.PriorityClass, error) { +func (_m *PriorityClassInterface) Update(ctx context.Context, priorityClass *schedulingv1beta1.PriorityClass, opts v1.UpdateOptions) (*schedulingv1beta1.PriorityClass, error) { ret := _m.Called(ctx, priorityClass, opts) - var r0 *v1beta1.PriorityClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.PriorityClass, v1.UpdateOptions) *v1beta1.PriorityClass); ok { + var r0 *schedulingv1beta1.PriorityClass + if rf, ok := ret.Get(0).(func(context.Context, *schedulingv1beta1.PriorityClass, v1.UpdateOptions) *schedulingv1beta1.PriorityClass); ok { r0 = rf(ctx, priorityClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.PriorityClass) + r0 = ret.Get(0).(*schedulingv1beta1.PriorityClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.PriorityClass, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *schedulingv1beta1.PriorityClass, v1.UpdateOptions) error); ok { r1 = rf(ctx, priorityClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_preset_interface.go b/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_preset_interface.go deleted file mode 100644 index 38398471d7..0000000000 --- a/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_preset_interface.go +++ /dev/null @@ -1,195 +0,0 @@ -// Code generated by mockery v2.5.1. DO NOT EDIT. - -package kubernetes_mocks - -import ( - context "context" - - mock "github.com/stretchr/testify/mock" - - types "k8s.io/apimachinery/pkg/types" - - v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - v1alpha1 "k8s.io/api/settings/v1alpha1" - - watch "k8s.io/apimachinery/pkg/watch" -) - -// PodPresetInterface is an autogenerated mock type for the PodPresetInterface type -type PodPresetInterface struct { - mock.Mock -} - -// Create provides a mock function with given fields: ctx, podPreset, opts -func (_m *PodPresetInterface) Create(ctx context.Context, podPreset *v1alpha1.PodPreset, opts v1.CreateOptions) (*v1alpha1.PodPreset, error) { - ret := _m.Called(ctx, podPreset, opts) - - var r0 *v1alpha1.PodPreset - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PodPreset, v1.CreateOptions) *v1alpha1.PodPreset); ok { - r0 = rf(ctx, podPreset, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PodPreset) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PodPreset, v1.CreateOptions) error); ok { - r1 = rf(ctx, podPreset, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Delete provides a mock function with given fields: ctx, name, opts -func (_m *PodPresetInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { - ret := _m.Called(ctx, name, opts) - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { - r0 = rf(ctx, name, opts) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts -func (_m *PodPresetInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { - ret := _m.Called(ctx, opts, listOpts) - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { - r0 = rf(ctx, opts, listOpts) - } else { - r0 = ret.Error(0) - } - - return r0 -} - -// Get provides a mock function with given fields: ctx, name, opts -func (_m *PodPresetInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.PodPreset, error) { - ret := _m.Called(ctx, name, opts) - - var r0 *v1alpha1.PodPreset - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.PodPreset); ok { - r0 = rf(ctx, name, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PodPreset) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { - r1 = rf(ctx, name, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// List provides a mock function with given fields: ctx, opts -func (_m *PodPresetInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.PodPresetList, error) { - ret := _m.Called(ctx, opts) - - var r0 *v1alpha1.PodPresetList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.PodPresetList); ok { - r0 = rf(ctx, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PodPresetList) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { - r1 = rf(ctx, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *PodPresetInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.PodPreset, error) { - _va := make([]interface{}, len(subresources)) - for _i := range subresources { - _va[_i] = subresources[_i] - } - var _ca []interface{} - _ca = append(_ca, ctx, name, pt, data, opts) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - - var r0 *v1alpha1.PodPreset - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.PodPreset); ok { - r0 = rf(ctx, name, pt, data, opts, subresources...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PodPreset) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { - r1 = rf(ctx, name, pt, data, opts, subresources...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Update provides a mock function with given fields: ctx, podPreset, opts -func (_m *PodPresetInterface) Update(ctx context.Context, podPreset *v1alpha1.PodPreset, opts v1.UpdateOptions) (*v1alpha1.PodPreset, error) { - ret := _m.Called(ctx, podPreset, opts) - - var r0 *v1alpha1.PodPreset - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.PodPreset, v1.UpdateOptions) *v1alpha1.PodPreset); ok { - r0 = rf(ctx, podPreset, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.PodPreset) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.PodPreset, v1.UpdateOptions) error); ok { - r1 = rf(ctx, podPreset, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// Watch provides a mock function with given fields: ctx, opts -func (_m *PodPresetInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { - ret := _m.Called(ctx, opts) - - var r0 watch.Interface - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { - r0 = rf(ctx, opts) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(watch.Interface) - } - } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { - r1 = rf(ctx, opts) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} diff --git a/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_presets_getter.go b/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_presets_getter.go deleted file mode 100644 index d7973d11c4..0000000000 --- a/testutil/kubernetes_mock/typed/settings/v1alpha1/pod_presets_getter.go +++ /dev/null @@ -1,29 +0,0 @@ -// Code generated by mockery v2.5.1. DO NOT EDIT. - -package kubernetes_mocks - -import ( - mock "github.com/stretchr/testify/mock" - v1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1" -) - -// PodPresetsGetter is an autogenerated mock type for the PodPresetsGetter type -type PodPresetsGetter struct { - mock.Mock -} - -// PodPresets provides a mock function with given fields: namespace -func (_m *PodPresetsGetter) PodPresets(namespace string) v1alpha1.PodPresetInterface { - ret := _m.Called(namespace) - - var r0 v1alpha1.PodPresetInterface - if rf, ok := ret.Get(0).(func(string) v1alpha1.PodPresetInterface); ok { - r0 = rf(namespace) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(v1alpha1.PodPresetInterface) - } - } - - return r0 -} diff --git a/testutil/kubernetes_mock/typed/settings/v1alpha1/settings_v1alpha1_interface.go b/testutil/kubernetes_mock/typed/settings/v1alpha1/settings_v1alpha1_interface.go deleted file mode 100644 index 8e0ce9914e..0000000000 --- a/testutil/kubernetes_mock/typed/settings/v1alpha1/settings_v1alpha1_interface.go +++ /dev/null @@ -1,47 +0,0 @@ -// Code generated by mockery v2.5.1. DO NOT EDIT. - -package kubernetes_mocks - -import ( - mock "github.com/stretchr/testify/mock" - rest "k8s.io/client-go/rest" - - v1alpha1 "k8s.io/client-go/kubernetes/typed/settings/v1alpha1" -) - -// SettingsV1alpha1Interface is an autogenerated mock type for the SettingsV1alpha1Interface type -type SettingsV1alpha1Interface struct { - mock.Mock -} - -// PodPresets provides a mock function with given fields: namespace -func (_m *SettingsV1alpha1Interface) PodPresets(namespace string) v1alpha1.PodPresetInterface { - ret := _m.Called(namespace) - - var r0 v1alpha1.PodPresetInterface - if rf, ok := ret.Get(0).(func(string) v1alpha1.PodPresetInterface); ok { - r0 = rf(namespace) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(v1alpha1.PodPresetInterface) - } - } - - return r0 -} - -// RESTClient provides a mock function with given fields: -func (_m *SettingsV1alpha1Interface) RESTClient() rest.Interface { - ret := _m.Called() - - var r0 rest.Interface - if rf, ok := ret.Get(0).(func() rest.Interface); ok { - r0 = rf() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(rest.Interface) - } - } - - return r0 -} diff --git a/testutil/kubernetes_mock/typed/storage/v1/csi_driver_interface.go b/testutil/kubernetes_mock/typed/storage/v1/csi_driver_interface.go index fda5e51c51..e03d0f8b8d 100644 --- a/testutil/kubernetes_mock/typed/storage/v1/csi_driver_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1/csi_driver_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + storagev1 "k8s.io/api/storage/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/storage/v1" + v1 "k8s.io/client-go/applyconfigurations/storage/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type CSIDriverInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, cSIDriver, opts +func (_m *CSIDriverInterface) Apply(ctx context.Context, cSIDriver *v1.CSIDriverApplyConfiguration, opts metav1.ApplyOptions) (*storagev1.CSIDriver, error) { + ret := _m.Called(ctx, cSIDriver, opts) + + var r0 *storagev1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, *v1.CSIDriverApplyConfiguration, metav1.ApplyOptions) *storagev1.CSIDriver); ok { + r0 = rf(ctx, cSIDriver, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1.CSIDriver) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.CSIDriverApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, cSIDriver, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, cSIDriver, opts -func (_m *CSIDriverInterface) Create(ctx context.Context, cSIDriver *v1.CSIDriver, opts metav1.CreateOptions) (*v1.CSIDriver, error) { +func (_m *CSIDriverInterface) Create(ctx context.Context, cSIDriver *storagev1.CSIDriver, opts metav1.CreateOptions) (*storagev1.CSIDriver, error) { ret := _m.Called(ctx, cSIDriver, opts) - var r0 *v1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, *v1.CSIDriver, metav1.CreateOptions) *v1.CSIDriver); ok { + var r0 *storagev1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.CSIDriver, metav1.CreateOptions) *storagev1.CSIDriver); ok { r0 = rf(ctx, cSIDriver, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSIDriver) + r0 = ret.Get(0).(*storagev1.CSIDriver) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CSIDriver, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.CSIDriver, metav1.CreateOptions) error); ok { r1 = rf(ctx, cSIDriver, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *CSIDriverInterface) DeleteCollection(ctx context.Context, opts metav1. } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CSIDriverInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.CSIDriver, error) { +func (_m *CSIDriverInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*storagev1.CSIDriver, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.CSIDriver); ok { + var r0 *storagev1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *storagev1.CSIDriver); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSIDriver) + r0 = ret.Get(0).(*storagev1.CSIDriver) } } @@ -95,15 +120,15 @@ func (_m *CSIDriverInterface) Get(ctx context.Context, name string, opts metav1. } // List provides a mock function with given fields: ctx, opts -func (_m *CSIDriverInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.CSIDriverList, error) { +func (_m *CSIDriverInterface) List(ctx context.Context, opts metav1.ListOptions) (*storagev1.CSIDriverList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.CSIDriverList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.CSIDriverList); ok { + var r0 *storagev1.CSIDriverList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *storagev1.CSIDriverList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSIDriverList) + r0 = ret.Get(0).(*storagev1.CSIDriverList) } } @@ -118,7 +143,7 @@ func (_m *CSIDriverInterface) List(ctx context.Context, opts metav1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.CSIDriver, error) { +func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*storagev1.CSIDriver, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.CSIDriver); ok { + var r0 *storagev1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *storagev1.CSIDriver); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSIDriver) + r0 = ret.Get(0).(*storagev1.CSIDriver) } } @@ -148,20 +173,20 @@ func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, cSIDriver, opts -func (_m *CSIDriverInterface) Update(ctx context.Context, cSIDriver *v1.CSIDriver, opts metav1.UpdateOptions) (*v1.CSIDriver, error) { +func (_m *CSIDriverInterface) Update(ctx context.Context, cSIDriver *storagev1.CSIDriver, opts metav1.UpdateOptions) (*storagev1.CSIDriver, error) { ret := _m.Called(ctx, cSIDriver, opts) - var r0 *v1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, *v1.CSIDriver, metav1.UpdateOptions) *v1.CSIDriver); ok { + var r0 *storagev1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.CSIDriver, metav1.UpdateOptions) *storagev1.CSIDriver); ok { r0 = rf(ctx, cSIDriver, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSIDriver) + r0 = ret.Get(0).(*storagev1.CSIDriver) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CSIDriver, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.CSIDriver, metav1.UpdateOptions) error); ok { r1 = rf(ctx, cSIDriver, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1/csi_node_interface.go b/testutil/kubernetes_mock/typed/storage/v1/csi_node_interface.go index 46b0850a54..7417490aa1 100644 --- a/testutil/kubernetes_mock/typed/storage/v1/csi_node_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1/csi_node_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + storagev1 "k8s.io/api/storage/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/storage/v1" + v1 "k8s.io/client-go/applyconfigurations/storage/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type CSINodeInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, cSINode, opts +func (_m *CSINodeInterface) Apply(ctx context.Context, cSINode *v1.CSINodeApplyConfiguration, opts metav1.ApplyOptions) (*storagev1.CSINode, error) { + ret := _m.Called(ctx, cSINode, opts) + + var r0 *storagev1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, *v1.CSINodeApplyConfiguration, metav1.ApplyOptions) *storagev1.CSINode); ok { + r0 = rf(ctx, cSINode, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1.CSINode) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.CSINodeApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, cSINode, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, cSINode, opts -func (_m *CSINodeInterface) Create(ctx context.Context, cSINode *v1.CSINode, opts metav1.CreateOptions) (*v1.CSINode, error) { +func (_m *CSINodeInterface) Create(ctx context.Context, cSINode *storagev1.CSINode, opts metav1.CreateOptions) (*storagev1.CSINode, error) { ret := _m.Called(ctx, cSINode, opts) - var r0 *v1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, *v1.CSINode, metav1.CreateOptions) *v1.CSINode); ok { + var r0 *storagev1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.CSINode, metav1.CreateOptions) *storagev1.CSINode); ok { r0 = rf(ctx, cSINode, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSINode) + r0 = ret.Get(0).(*storagev1.CSINode) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CSINode, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.CSINode, metav1.CreateOptions) error); ok { r1 = rf(ctx, cSINode, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *CSINodeInterface) DeleteCollection(ctx context.Context, opts metav1.De } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CSINodeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.CSINode, error) { +func (_m *CSINodeInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*storagev1.CSINode, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.CSINode); ok { + var r0 *storagev1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *storagev1.CSINode); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSINode) + r0 = ret.Get(0).(*storagev1.CSINode) } } @@ -95,15 +120,15 @@ func (_m *CSINodeInterface) Get(ctx context.Context, name string, opts metav1.Ge } // List provides a mock function with given fields: ctx, opts -func (_m *CSINodeInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.CSINodeList, error) { +func (_m *CSINodeInterface) List(ctx context.Context, opts metav1.ListOptions) (*storagev1.CSINodeList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.CSINodeList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.CSINodeList); ok { + var r0 *storagev1.CSINodeList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *storagev1.CSINodeList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSINodeList) + r0 = ret.Get(0).(*storagev1.CSINodeList) } } @@ -118,7 +143,7 @@ func (_m *CSINodeInterface) List(ctx context.Context, opts metav1.ListOptions) ( } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.CSINode, error) { +func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*storagev1.CSINode, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.CSINode); ok { + var r0 *storagev1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *storagev1.CSINode); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSINode) + r0 = ret.Get(0).(*storagev1.CSINode) } } @@ -148,20 +173,20 @@ func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.Pat } // Update provides a mock function with given fields: ctx, cSINode, opts -func (_m *CSINodeInterface) Update(ctx context.Context, cSINode *v1.CSINode, opts metav1.UpdateOptions) (*v1.CSINode, error) { +func (_m *CSINodeInterface) Update(ctx context.Context, cSINode *storagev1.CSINode, opts metav1.UpdateOptions) (*storagev1.CSINode, error) { ret := _m.Called(ctx, cSINode, opts) - var r0 *v1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, *v1.CSINode, metav1.UpdateOptions) *v1.CSINode); ok { + var r0 *storagev1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.CSINode, metav1.UpdateOptions) *storagev1.CSINode); ok { r0 = rf(ctx, cSINode, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.CSINode) + r0 = ret.Get(0).(*storagev1.CSINode) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.CSINode, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.CSINode, metav1.UpdateOptions) error); ok { r1 = rf(ctx, cSINode, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1/storage_class_interface.go b/testutil/kubernetes_mock/typed/storage/v1/storage_class_interface.go index 63c40c9faf..55dba82aa1 100644 --- a/testutil/kubernetes_mock/typed/storage/v1/storage_class_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1/storage_class_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + storagev1 "k8s.io/api/storage/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/storage/v1" + v1 "k8s.io/client-go/applyconfigurations/storage/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,44 @@ type StorageClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, storageClass, opts +func (_m *StorageClassInterface) Apply(ctx context.Context, storageClass *v1.StorageClassApplyConfiguration, opts metav1.ApplyOptions) (*storagev1.StorageClass, error) { + ret := _m.Called(ctx, storageClass, opts) + + var r0 *storagev1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, *v1.StorageClassApplyConfiguration, metav1.ApplyOptions) *storagev1.StorageClass); ok { + r0 = rf(ctx, storageClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1.StorageClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.StorageClassApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, storageClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, storageClass, opts -func (_m *StorageClassInterface) Create(ctx context.Context, storageClass *v1.StorageClass, opts metav1.CreateOptions) (*v1.StorageClass, error) { +func (_m *StorageClassInterface) Create(ctx context.Context, storageClass *storagev1.StorageClass, opts metav1.CreateOptions) (*storagev1.StorageClass, error) { ret := _m.Called(ctx, storageClass, opts) - var r0 *v1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, *v1.StorageClass, metav1.CreateOptions) *v1.StorageClass); ok { + var r0 *storagev1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.StorageClass, metav1.CreateOptions) *storagev1.StorageClass); ok { r0 = rf(ctx, storageClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StorageClass) + r0 = ret.Get(0).(*storagev1.StorageClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.StorageClass, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.StorageClass, metav1.CreateOptions) error); ok { r1 = rf(ctx, storageClass, opts) } else { r1 = ret.Error(1) @@ -72,15 +97,15 @@ func (_m *StorageClassInterface) DeleteCollection(ctx context.Context, opts meta } // Get provides a mock function with given fields: ctx, name, opts -func (_m *StorageClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.StorageClass, error) { +func (_m *StorageClassInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*storagev1.StorageClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.StorageClass); ok { + var r0 *storagev1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *storagev1.StorageClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StorageClass) + r0 = ret.Get(0).(*storagev1.StorageClass) } } @@ -95,15 +120,15 @@ func (_m *StorageClassInterface) Get(ctx context.Context, name string, opts meta } // List provides a mock function with given fields: ctx, opts -func (_m *StorageClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.StorageClassList, error) { +func (_m *StorageClassInterface) List(ctx context.Context, opts metav1.ListOptions) (*storagev1.StorageClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.StorageClassList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.StorageClassList); ok { + var r0 *storagev1.StorageClassList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *storagev1.StorageClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StorageClassList) + r0 = ret.Get(0).(*storagev1.StorageClassList) } } @@ -118,7 +143,7 @@ func (_m *StorageClassInterface) List(ctx context.Context, opts metav1.ListOptio } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.StorageClass, error) { +func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*storagev1.StorageClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +153,12 @@ func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt type _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.StorageClass); ok { + var r0 *storagev1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *storagev1.StorageClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StorageClass) + r0 = ret.Get(0).(*storagev1.StorageClass) } } @@ -148,20 +173,20 @@ func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt type } // Update provides a mock function with given fields: ctx, storageClass, opts -func (_m *StorageClassInterface) Update(ctx context.Context, storageClass *v1.StorageClass, opts metav1.UpdateOptions) (*v1.StorageClass, error) { +func (_m *StorageClassInterface) Update(ctx context.Context, storageClass *storagev1.StorageClass, opts metav1.UpdateOptions) (*storagev1.StorageClass, error) { ret := _m.Called(ctx, storageClass, opts) - var r0 *v1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, *v1.StorageClass, metav1.UpdateOptions) *v1.StorageClass); ok { + var r0 *storagev1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.StorageClass, metav1.UpdateOptions) *storagev1.StorageClass); ok { r0 = rf(ctx, storageClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.StorageClass) + r0 = ret.Get(0).(*storagev1.StorageClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.StorageClass, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.StorageClass, metav1.UpdateOptions) error); ok { r1 = rf(ctx, storageClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1/volume_attachment_interface.go b/testutil/kubernetes_mock/typed/storage/v1/volume_attachment_interface.go index 6241c3b678..f9207a43ba 100644 --- a/testutil/kubernetes_mock/typed/storage/v1/volume_attachment_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1/volume_attachment_interface.go @@ -8,9 +8,11 @@ import ( mock "github.com/stretchr/testify/mock" metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" + storagev1 "k8s.io/api/storage/v1" + types "k8s.io/apimachinery/pkg/types" - v1 "k8s.io/api/storage/v1" + v1 "k8s.io/client-go/applyconfigurations/storage/v1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -20,21 +22,67 @@ type VolumeAttachmentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, volumeAttachment, opts +func (_m *VolumeAttachmentInterface) Apply(ctx context.Context, volumeAttachment *v1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (*storagev1.VolumeAttachment, error) { + ret := _m.Called(ctx, volumeAttachment, opts) + + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *v1.VolumeAttachmentApplyConfiguration, metav1.ApplyOptions) *storagev1.VolumeAttachment); ok { + r0 = rf(ctx, volumeAttachment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1.VolumeAttachment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.VolumeAttachmentApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, volumeAttachment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, volumeAttachment, opts +func (_m *VolumeAttachmentInterface) ApplyStatus(ctx context.Context, volumeAttachment *v1.VolumeAttachmentApplyConfiguration, opts metav1.ApplyOptions) (*storagev1.VolumeAttachment, error) { + ret := _m.Called(ctx, volumeAttachment, opts) + + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *v1.VolumeAttachmentApplyConfiguration, metav1.ApplyOptions) *storagev1.VolumeAttachment); ok { + r0 = rf(ctx, volumeAttachment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1.VolumeAttachment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1.VolumeAttachmentApplyConfiguration, metav1.ApplyOptions) error); ok { + r1 = rf(ctx, volumeAttachment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) Create(ctx context.Context, volumeAttachment *v1.VolumeAttachment, opts metav1.CreateOptions) (*v1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Create(ctx context.Context, volumeAttachment *storagev1.VolumeAttachment, opts metav1.CreateOptions) (*storagev1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1.VolumeAttachment, metav1.CreateOptions) *v1.VolumeAttachment); ok { + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.VolumeAttachment, metav1.CreateOptions) *storagev1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.VolumeAttachment, metav1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.VolumeAttachment, metav1.CreateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) @@ -72,15 +120,15 @@ func (_m *VolumeAttachmentInterface) DeleteCollection(ctx context.Context, opts } // Get provides a mock function with given fields: ctx, name, opts -func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*v1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts metav1.GetOptions) (*storagev1.VolumeAttachment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *v1.VolumeAttachment); ok { + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, string, metav1.GetOptions) *storagev1.VolumeAttachment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1.VolumeAttachment) } } @@ -95,15 +143,15 @@ func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts } // List provides a mock function with given fields: ctx, opts -func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts metav1.ListOptions) (*v1.VolumeAttachmentList, error) { +func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts metav1.ListOptions) (*storagev1.VolumeAttachmentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1.VolumeAttachmentList - if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *v1.VolumeAttachmentList); ok { + var r0 *storagev1.VolumeAttachmentList + if rf, ok := ret.Get(0).(func(context.Context, metav1.ListOptions) *storagev1.VolumeAttachmentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.VolumeAttachmentList) + r0 = ret.Get(0).(*storagev1.VolumeAttachmentList) } } @@ -118,7 +166,7 @@ func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts metav1.ListO } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*v1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts metav1.PatchOptions, subresources ...string) (*storagev1.VolumeAttachment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -128,12 +176,12 @@ func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *v1.VolumeAttachment); ok { + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, metav1.PatchOptions, ...string) *storagev1.VolumeAttachment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1.VolumeAttachment) } } @@ -148,20 +196,20 @@ func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt } // Update provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachment *v1.VolumeAttachment, opts metav1.UpdateOptions) (*v1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachment *storagev1.VolumeAttachment, opts metav1.UpdateOptions) (*storagev1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1.VolumeAttachment, metav1.UpdateOptions) *v1.VolumeAttachment); ok { + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.VolumeAttachment, metav1.UpdateOptions) *storagev1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.VolumeAttachment, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.VolumeAttachment, metav1.UpdateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) @@ -171,20 +219,20 @@ func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachmen } // UpdateStatus provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) UpdateStatus(ctx context.Context, volumeAttachment *v1.VolumeAttachment, opts metav1.UpdateOptions) (*v1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) UpdateStatus(ctx context.Context, volumeAttachment *storagev1.VolumeAttachment, opts metav1.UpdateOptions) (*storagev1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1.VolumeAttachment, metav1.UpdateOptions) *v1.VolumeAttachment); ok { + var r0 *storagev1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1.VolumeAttachment, metav1.UpdateOptions) *storagev1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1.VolumeAttachment, metav1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1.VolumeAttachment, metav1.UpdateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1alpha1/csi_storage_capacity_interface.go b/testutil/kubernetes_mock/typed/storage/v1alpha1/csi_storage_capacity_interface.go index 3dbf0fd794..0c8cefde9c 100644 --- a/testutil/kubernetes_mock/typed/storage/v1alpha1/csi_storage_capacity_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1alpha1/csi_storage_capacity_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + storagev1alpha1 "k8s.io/api/storage/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/storage/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/storage/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type CSIStorageCapacityInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, cSIStorageCapacity, opts +func (_m *CSIStorageCapacityInterface) Apply(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacityApplyConfiguration, opts v1.ApplyOptions) (*storagev1alpha1.CSIStorageCapacity, error) { + ret := _m.Called(ctx, cSIStorageCapacity, opts) + + var r0 *storagev1alpha1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.CSIStorageCapacityApplyConfiguration, v1.ApplyOptions) *storagev1alpha1.CSIStorageCapacity); ok { + r0 = rf(ctx, cSIStorageCapacity, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1alpha1.CSIStorageCapacity) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.CSIStorageCapacityApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, cSIStorageCapacity, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, cSIStorageCapacity, opts -func (_m *CSIStorageCapacityInterface) Create(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacity, opts v1.CreateOptions) (*v1alpha1.CSIStorageCapacity, error) { +func (_m *CSIStorageCapacityInterface) Create(ctx context.Context, cSIStorageCapacity *storagev1alpha1.CSIStorageCapacity, opts v1.CreateOptions) (*storagev1alpha1.CSIStorageCapacity, error) { ret := _m.Called(ctx, cSIStorageCapacity, opts) - var r0 *v1alpha1.CSIStorageCapacity - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.CSIStorageCapacity, v1.CreateOptions) *v1alpha1.CSIStorageCapacity); ok { + var r0 *storagev1alpha1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, *storagev1alpha1.CSIStorageCapacity, v1.CreateOptions) *storagev1alpha1.CSIStorageCapacity); ok { r0 = rf(ctx, cSIStorageCapacity, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.CSIStorageCapacity) + r0 = ret.Get(0).(*storagev1alpha1.CSIStorageCapacity) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.CSIStorageCapacity, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1alpha1.CSIStorageCapacity, v1.CreateOptions) error); ok { r1 = rf(ctx, cSIStorageCapacity, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *CSIStorageCapacityInterface) DeleteCollection(ctx context.Context, opt } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CSIStorageCapacityInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.CSIStorageCapacity, error) { +func (_m *CSIStorageCapacityInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1alpha1.CSIStorageCapacity, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.CSIStorageCapacity - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.CSIStorageCapacity); ok { + var r0 *storagev1alpha1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1alpha1.CSIStorageCapacity); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.CSIStorageCapacity) + r0 = ret.Get(0).(*storagev1alpha1.CSIStorageCapacity) } } @@ -96,15 +120,15 @@ func (_m *CSIStorageCapacityInterface) Get(ctx context.Context, name string, opt } // List provides a mock function with given fields: ctx, opts -func (_m *CSIStorageCapacityInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.CSIStorageCapacityList, error) { +func (_m *CSIStorageCapacityInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1alpha1.CSIStorageCapacityList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.CSIStorageCapacityList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.CSIStorageCapacityList); ok { + var r0 *storagev1alpha1.CSIStorageCapacityList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1alpha1.CSIStorageCapacityList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.CSIStorageCapacityList) + r0 = ret.Get(0).(*storagev1alpha1.CSIStorageCapacityList) } } @@ -119,7 +143,7 @@ func (_m *CSIStorageCapacityInterface) List(ctx context.Context, opts v1.ListOpt } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CSIStorageCapacityInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.CSIStorageCapacity, error) { +func (_m *CSIStorageCapacityInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1alpha1.CSIStorageCapacity, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *CSIStorageCapacityInterface) Patch(ctx context.Context, name string, p _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.CSIStorageCapacity - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.CSIStorageCapacity); ok { + var r0 *storagev1alpha1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1alpha1.CSIStorageCapacity); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.CSIStorageCapacity) + r0 = ret.Get(0).(*storagev1alpha1.CSIStorageCapacity) } } @@ -149,20 +173,20 @@ func (_m *CSIStorageCapacityInterface) Patch(ctx context.Context, name string, p } // Update provides a mock function with given fields: ctx, cSIStorageCapacity, opts -func (_m *CSIStorageCapacityInterface) Update(ctx context.Context, cSIStorageCapacity *v1alpha1.CSIStorageCapacity, opts v1.UpdateOptions) (*v1alpha1.CSIStorageCapacity, error) { +func (_m *CSIStorageCapacityInterface) Update(ctx context.Context, cSIStorageCapacity *storagev1alpha1.CSIStorageCapacity, opts v1.UpdateOptions) (*storagev1alpha1.CSIStorageCapacity, error) { ret := _m.Called(ctx, cSIStorageCapacity, opts) - var r0 *v1alpha1.CSIStorageCapacity - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.CSIStorageCapacity, v1.UpdateOptions) *v1alpha1.CSIStorageCapacity); ok { + var r0 *storagev1alpha1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, *storagev1alpha1.CSIStorageCapacity, v1.UpdateOptions) *storagev1alpha1.CSIStorageCapacity); ok { r0 = rf(ctx, cSIStorageCapacity, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.CSIStorageCapacity) + r0 = ret.Get(0).(*storagev1alpha1.CSIStorageCapacity) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.CSIStorageCapacity, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1alpha1.CSIStorageCapacity, v1.UpdateOptions) error); ok { r1 = rf(ctx, cSIStorageCapacity, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1alpha1/volume_attachment_interface.go b/testutil/kubernetes_mock/typed/storage/v1alpha1/volume_attachment_interface.go index 8604b803f1..19c330cb12 100644 --- a/testutil/kubernetes_mock/typed/storage/v1alpha1/volume_attachment_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1alpha1/volume_attachment_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + storagev1alpha1 "k8s.io/api/storage/v1alpha1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1alpha1 "k8s.io/api/storage/v1alpha1" + v1alpha1 "k8s.io/client-go/applyconfigurations/storage/v1alpha1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type VolumeAttachmentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, volumeAttachment, opts +func (_m *VolumeAttachmentInterface) Apply(ctx context.Context, volumeAttachment *v1alpha1.VolumeAttachmentApplyConfiguration, opts v1.ApplyOptions) (*storagev1alpha1.VolumeAttachment, error) { + ret := _m.Called(ctx, volumeAttachment, opts) + + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) *storagev1alpha1.VolumeAttachment); ok { + r0 = rf(ctx, volumeAttachment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, volumeAttachment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, volumeAttachment, opts +func (_m *VolumeAttachmentInterface) ApplyStatus(ctx context.Context, volumeAttachment *v1alpha1.VolumeAttachmentApplyConfiguration, opts v1.ApplyOptions) (*storagev1alpha1.VolumeAttachment, error) { + ret := _m.Called(ctx, volumeAttachment, opts) + + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) *storagev1alpha1.VolumeAttachment); ok { + r0 = rf(ctx, volumeAttachment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, volumeAttachment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) Create(ctx context.Context, volumeAttachment *v1alpha1.VolumeAttachment, opts v1.CreateOptions) (*v1alpha1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Create(ctx context.Context, volumeAttachment *storagev1alpha1.VolumeAttachment, opts v1.CreateOptions) (*storagev1alpha1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1alpha1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.VolumeAttachment, v1.CreateOptions) *v1alpha1.VolumeAttachment); ok { + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1alpha1.VolumeAttachment, v1.CreateOptions) *storagev1alpha1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.VolumeAttachment, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1alpha1.VolumeAttachment, v1.CreateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *VolumeAttachmentInterface) DeleteCollection(ctx context.Context, opts } // Get provides a mock function with given fields: ctx, name, opts -func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1alpha1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1alpha1.VolumeAttachment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1alpha1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1alpha1.VolumeAttachment); ok { + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1alpha1.VolumeAttachment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) } } @@ -96,15 +143,15 @@ func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts } // List provides a mock function with given fields: ctx, opts -func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts v1.ListOptions) (*v1alpha1.VolumeAttachmentList, error) { +func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1alpha1.VolumeAttachmentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1alpha1.VolumeAttachmentList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1alpha1.VolumeAttachmentList); ok { + var r0 *storagev1alpha1.VolumeAttachmentList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1alpha1.VolumeAttachmentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.VolumeAttachmentList) + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachmentList) } } @@ -119,7 +166,7 @@ func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts v1.ListOptio } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1alpha1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1alpha1.VolumeAttachment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1alpha1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1alpha1.VolumeAttachment); ok { + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1alpha1.VolumeAttachment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) } } @@ -149,20 +196,20 @@ func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt } // Update provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachment *v1alpha1.VolumeAttachment, opts v1.UpdateOptions) (*v1alpha1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachment *storagev1alpha1.VolumeAttachment, opts v1.UpdateOptions) (*storagev1alpha1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1alpha1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.VolumeAttachment, v1.UpdateOptions) *v1alpha1.VolumeAttachment); ok { + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1alpha1.VolumeAttachment, v1.UpdateOptions) *storagev1alpha1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.VolumeAttachment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1alpha1.VolumeAttachment, v1.UpdateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachmen } // UpdateStatus provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) UpdateStatus(ctx context.Context, volumeAttachment *v1alpha1.VolumeAttachment, opts v1.UpdateOptions) (*v1alpha1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) UpdateStatus(ctx context.Context, volumeAttachment *storagev1alpha1.VolumeAttachment, opts v1.UpdateOptions) (*storagev1alpha1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1alpha1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1alpha1.VolumeAttachment, v1.UpdateOptions) *v1alpha1.VolumeAttachment); ok { + var r0 *storagev1alpha1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1alpha1.VolumeAttachment, v1.UpdateOptions) *storagev1alpha1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1alpha1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1alpha1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1alpha1.VolumeAttachment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1alpha1.VolumeAttachment, v1.UpdateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_driver_interface.go b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_driver_interface.go index 44a84c18a3..1903434968 100644 --- a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_driver_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_driver_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + storagev1beta1 "k8s.io/api/storage/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/storage/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/storage/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type CSIDriverInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, cSIDriver, opts +func (_m *CSIDriverInterface) Apply(ctx context.Context, cSIDriver *v1beta1.CSIDriverApplyConfiguration, opts v1.ApplyOptions) (*storagev1beta1.CSIDriver, error) { + ret := _m.Called(ctx, cSIDriver, opts) + + var r0 *storagev1beta1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSIDriverApplyConfiguration, v1.ApplyOptions) *storagev1beta1.CSIDriver); ok { + r0 = rf(ctx, cSIDriver, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIDriver) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSIDriverApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, cSIDriver, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, cSIDriver, opts -func (_m *CSIDriverInterface) Create(ctx context.Context, cSIDriver *v1beta1.CSIDriver, opts v1.CreateOptions) (*v1beta1.CSIDriver, error) { +func (_m *CSIDriverInterface) Create(ctx context.Context, cSIDriver *storagev1beta1.CSIDriver, opts v1.CreateOptions) (*storagev1beta1.CSIDriver, error) { ret := _m.Called(ctx, cSIDriver, opts) - var r0 *v1beta1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSIDriver, v1.CreateOptions) *v1beta1.CSIDriver); ok { + var r0 *storagev1beta1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.CSIDriver, v1.CreateOptions) *storagev1beta1.CSIDriver); ok { r0 = rf(ctx, cSIDriver, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSIDriver) + r0 = ret.Get(0).(*storagev1beta1.CSIDriver) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSIDriver, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.CSIDriver, v1.CreateOptions) error); ok { r1 = rf(ctx, cSIDriver, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *CSIDriverInterface) DeleteCollection(ctx context.Context, opts v1.Dele } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CSIDriverInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.CSIDriver, error) { +func (_m *CSIDriverInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1beta1.CSIDriver, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.CSIDriver); ok { + var r0 *storagev1beta1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1beta1.CSIDriver); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSIDriver) + r0 = ret.Get(0).(*storagev1beta1.CSIDriver) } } @@ -96,15 +120,15 @@ func (_m *CSIDriverInterface) Get(ctx context.Context, name string, opts v1.GetO } // List provides a mock function with given fields: ctx, opts -func (_m *CSIDriverInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.CSIDriverList, error) { +func (_m *CSIDriverInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1beta1.CSIDriverList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.CSIDriverList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.CSIDriverList); ok { + var r0 *storagev1beta1.CSIDriverList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1beta1.CSIDriverList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSIDriverList) + r0 = ret.Get(0).(*storagev1beta1.CSIDriverList) } } @@ -119,7 +143,7 @@ func (_m *CSIDriverInterface) List(ctx context.Context, opts v1.ListOptions) (*v } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.CSIDriver, error) { +func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1beta1.CSIDriver, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.P _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.CSIDriver); ok { + var r0 *storagev1beta1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1beta1.CSIDriver); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSIDriver) + r0 = ret.Get(0).(*storagev1beta1.CSIDriver) } } @@ -149,20 +173,20 @@ func (_m *CSIDriverInterface) Patch(ctx context.Context, name string, pt types.P } // Update provides a mock function with given fields: ctx, cSIDriver, opts -func (_m *CSIDriverInterface) Update(ctx context.Context, cSIDriver *v1beta1.CSIDriver, opts v1.UpdateOptions) (*v1beta1.CSIDriver, error) { +func (_m *CSIDriverInterface) Update(ctx context.Context, cSIDriver *storagev1beta1.CSIDriver, opts v1.UpdateOptions) (*storagev1beta1.CSIDriver, error) { ret := _m.Called(ctx, cSIDriver, opts) - var r0 *v1beta1.CSIDriver - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSIDriver, v1.UpdateOptions) *v1beta1.CSIDriver); ok { + var r0 *storagev1beta1.CSIDriver + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.CSIDriver, v1.UpdateOptions) *storagev1beta1.CSIDriver); ok { r0 = rf(ctx, cSIDriver, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSIDriver) + r0 = ret.Get(0).(*storagev1beta1.CSIDriver) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSIDriver, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.CSIDriver, v1.UpdateOptions) error); ok { r1 = rf(ctx, cSIDriver, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_node_interface.go b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_node_interface.go index 4b62996ece..65b6b62e7f 100644 --- a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_node_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_node_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + storagev1beta1 "k8s.io/api/storage/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/storage/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/storage/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type CSINodeInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, cSINode, opts +func (_m *CSINodeInterface) Apply(ctx context.Context, cSINode *v1beta1.CSINodeApplyConfiguration, opts v1.ApplyOptions) (*storagev1beta1.CSINode, error) { + ret := _m.Called(ctx, cSINode, opts) + + var r0 *storagev1beta1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSINodeApplyConfiguration, v1.ApplyOptions) *storagev1beta1.CSINode); ok { + r0 = rf(ctx, cSINode, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSINode) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSINodeApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, cSINode, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, cSINode, opts -func (_m *CSINodeInterface) Create(ctx context.Context, cSINode *v1beta1.CSINode, opts v1.CreateOptions) (*v1beta1.CSINode, error) { +func (_m *CSINodeInterface) Create(ctx context.Context, cSINode *storagev1beta1.CSINode, opts v1.CreateOptions) (*storagev1beta1.CSINode, error) { ret := _m.Called(ctx, cSINode, opts) - var r0 *v1beta1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSINode, v1.CreateOptions) *v1beta1.CSINode); ok { + var r0 *storagev1beta1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.CSINode, v1.CreateOptions) *storagev1beta1.CSINode); ok { r0 = rf(ctx, cSINode, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSINode) + r0 = ret.Get(0).(*storagev1beta1.CSINode) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSINode, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.CSINode, v1.CreateOptions) error); ok { r1 = rf(ctx, cSINode, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *CSINodeInterface) DeleteCollection(ctx context.Context, opts v1.Delete } // Get provides a mock function with given fields: ctx, name, opts -func (_m *CSINodeInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.CSINode, error) { +func (_m *CSINodeInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1beta1.CSINode, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.CSINode); ok { + var r0 *storagev1beta1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1beta1.CSINode); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSINode) + r0 = ret.Get(0).(*storagev1beta1.CSINode) } } @@ -96,15 +120,15 @@ func (_m *CSINodeInterface) Get(ctx context.Context, name string, opts v1.GetOpt } // List provides a mock function with given fields: ctx, opts -func (_m *CSINodeInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.CSINodeList, error) { +func (_m *CSINodeInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1beta1.CSINodeList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.CSINodeList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.CSINodeList); ok { + var r0 *storagev1beta1.CSINodeList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1beta1.CSINodeList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSINodeList) + r0 = ret.Get(0).(*storagev1beta1.CSINodeList) } } @@ -119,7 +143,7 @@ func (_m *CSINodeInterface) List(ctx context.Context, opts v1.ListOptions) (*v1b } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.CSINode, error) { +func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1beta1.CSINode, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.Pat _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.CSINode); ok { + var r0 *storagev1beta1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1beta1.CSINode); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSINode) + r0 = ret.Get(0).(*storagev1beta1.CSINode) } } @@ -149,20 +173,20 @@ func (_m *CSINodeInterface) Patch(ctx context.Context, name string, pt types.Pat } // Update provides a mock function with given fields: ctx, cSINode, opts -func (_m *CSINodeInterface) Update(ctx context.Context, cSINode *v1beta1.CSINode, opts v1.UpdateOptions) (*v1beta1.CSINode, error) { +func (_m *CSINodeInterface) Update(ctx context.Context, cSINode *storagev1beta1.CSINode, opts v1.UpdateOptions) (*storagev1beta1.CSINode, error) { ret := _m.Called(ctx, cSINode, opts) - var r0 *v1beta1.CSINode - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSINode, v1.UpdateOptions) *v1beta1.CSINode); ok { + var r0 *storagev1beta1.CSINode + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.CSINode, v1.UpdateOptions) *storagev1beta1.CSINode); ok { r0 = rf(ctx, cSINode, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.CSINode) + r0 = ret.Get(0).(*storagev1beta1.CSINode) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSINode, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.CSINode, v1.UpdateOptions) error); ok { r1 = rf(ctx, cSINode, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacities_getter.go b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacities_getter.go new file mode 100644 index 0000000000..f0d21a3da0 --- /dev/null +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacities_getter.go @@ -0,0 +1,29 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + mock "github.com/stretchr/testify/mock" + v1beta1 "k8s.io/client-go/kubernetes/typed/storage/v1beta1" +) + +// CSIStorageCapacitiesGetter is an autogenerated mock type for the CSIStorageCapacitiesGetter type +type CSIStorageCapacitiesGetter struct { + mock.Mock +} + +// CSIStorageCapacities provides a mock function with given fields: namespace +func (_m *CSIStorageCapacitiesGetter) CSIStorageCapacities(namespace string) v1beta1.CSIStorageCapacityInterface { + ret := _m.Called(namespace) + + var r0 v1beta1.CSIStorageCapacityInterface + if rf, ok := ret.Get(0).(func(string) v1beta1.CSIStorageCapacityInterface); ok { + r0 = rf(namespace) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1beta1.CSIStorageCapacityInterface) + } + } + + return r0 +} diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacity_expansion.go b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacity_expansion.go new file mode 100644 index 0000000000..f6590a80e8 --- /dev/null +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacity_expansion.go @@ -0,0 +1,10 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import mock "github.com/stretchr/testify/mock" + +// CSIStorageCapacityExpansion is an autogenerated mock type for the CSIStorageCapacityExpansion type +type CSIStorageCapacityExpansion struct { + mock.Mock +} diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacity_interface.go b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacity_interface.go new file mode 100644 index 0000000000..fabb1e9cab --- /dev/null +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/csi_storage_capacity_interface.go @@ -0,0 +1,219 @@ +// Code generated by mockery v2.5.1. DO NOT EDIT. + +package kubernetes_mocks + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + storagev1beta1 "k8s.io/api/storage/v1beta1" + + types "k8s.io/apimachinery/pkg/types" + + v1 "k8s.io/apimachinery/pkg/apis/meta/v1" + + v1beta1 "k8s.io/client-go/applyconfigurations/storage/v1beta1" + + watch "k8s.io/apimachinery/pkg/watch" +) + +// CSIStorageCapacityInterface is an autogenerated mock type for the CSIStorageCapacityInterface type +type CSIStorageCapacityInterface struct { + mock.Mock +} + +// Apply provides a mock function with given fields: ctx, cSIStorageCapacity, opts +func (_m *CSIStorageCapacityInterface) Apply(ctx context.Context, cSIStorageCapacity *v1beta1.CSIStorageCapacityApplyConfiguration, opts v1.ApplyOptions) (*storagev1beta1.CSIStorageCapacity, error) { + ret := _m.Called(ctx, cSIStorageCapacity, opts) + + var r0 *storagev1beta1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.CSIStorageCapacityApplyConfiguration, v1.ApplyOptions) *storagev1beta1.CSIStorageCapacity); ok { + r0 = rf(ctx, cSIStorageCapacity, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIStorageCapacity) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.CSIStorageCapacityApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, cSIStorageCapacity, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Create provides a mock function with given fields: ctx, cSIStorageCapacity, opts +func (_m *CSIStorageCapacityInterface) Create(ctx context.Context, cSIStorageCapacity *storagev1beta1.CSIStorageCapacity, opts v1.CreateOptions) (*storagev1beta1.CSIStorageCapacity, error) { + ret := _m.Called(ctx, cSIStorageCapacity, opts) + + var r0 *storagev1beta1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.CSIStorageCapacity, v1.CreateOptions) *storagev1beta1.CSIStorageCapacity); ok { + r0 = rf(ctx, cSIStorageCapacity, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIStorageCapacity) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.CSIStorageCapacity, v1.CreateOptions) error); ok { + r1 = rf(ctx, cSIStorageCapacity, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Delete provides a mock function with given fields: ctx, name, opts +func (_m *CSIStorageCapacityInterface) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error { + ret := _m.Called(ctx, name, opts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, string, v1.DeleteOptions) error); ok { + r0 = rf(ctx, name, opts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// DeleteCollection provides a mock function with given fields: ctx, opts, listOpts +func (_m *CSIStorageCapacityInterface) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error { + ret := _m.Called(ctx, opts, listOpts) + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, v1.DeleteOptions, v1.ListOptions) error); ok { + r0 = rf(ctx, opts, listOpts) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Get provides a mock function with given fields: ctx, name, opts +func (_m *CSIStorageCapacityInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1beta1.CSIStorageCapacity, error) { + ret := _m.Called(ctx, name, opts) + + var r0 *storagev1beta1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1beta1.CSIStorageCapacity); ok { + r0 = rf(ctx, name, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIStorageCapacity) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, v1.GetOptions) error); ok { + r1 = rf(ctx, name, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// List provides a mock function with given fields: ctx, opts +func (_m *CSIStorageCapacityInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1beta1.CSIStorageCapacityList, error) { + ret := _m.Called(ctx, opts) + + var r0 *storagev1beta1.CSIStorageCapacityList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1beta1.CSIStorageCapacityList); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIStorageCapacityList) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources +func (_m *CSIStorageCapacityInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1beta1.CSIStorageCapacity, error) { + _va := make([]interface{}, len(subresources)) + for _i := range subresources { + _va[_i] = subresources[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, name, pt, data, opts) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + var r0 *storagev1beta1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1beta1.CSIStorageCapacity); ok { + r0 = rf(ctx, name, pt, data, opts, subresources...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIStorageCapacity) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) error); ok { + r1 = rf(ctx, name, pt, data, opts, subresources...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Update provides a mock function with given fields: ctx, cSIStorageCapacity, opts +func (_m *CSIStorageCapacityInterface) Update(ctx context.Context, cSIStorageCapacity *storagev1beta1.CSIStorageCapacity, opts v1.UpdateOptions) (*storagev1beta1.CSIStorageCapacity, error) { + ret := _m.Called(ctx, cSIStorageCapacity, opts) + + var r0 *storagev1beta1.CSIStorageCapacity + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.CSIStorageCapacity, v1.UpdateOptions) *storagev1beta1.CSIStorageCapacity); ok { + r0 = rf(ctx, cSIStorageCapacity, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.CSIStorageCapacity) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.CSIStorageCapacity, v1.UpdateOptions) error); ok { + r1 = rf(ctx, cSIStorageCapacity, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Watch provides a mock function with given fields: ctx, opts +func (_m *CSIStorageCapacityInterface) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) { + ret := _m.Called(ctx, opts) + + var r0 watch.Interface + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) watch.Interface); ok { + r0 = rf(ctx, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(watch.Interface) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, v1.ListOptions) error); ok { + r1 = rf(ctx, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/storage_class_interface.go b/testutil/kubernetes_mock/typed/storage/v1beta1/storage_class_interface.go index 2189cd5c52..74b92b88de 100644 --- a/testutil/kubernetes_mock/typed/storage/v1beta1/storage_class_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/storage_class_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + storagev1beta1 "k8s.io/api/storage/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/storage/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/storage/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,44 @@ type StorageClassInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, storageClass, opts +func (_m *StorageClassInterface) Apply(ctx context.Context, storageClass *v1beta1.StorageClassApplyConfiguration, opts v1.ApplyOptions) (*storagev1beta1.StorageClass, error) { + ret := _m.Called(ctx, storageClass, opts) + + var r0 *storagev1beta1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StorageClassApplyConfiguration, v1.ApplyOptions) *storagev1beta1.StorageClass); ok { + r0 = rf(ctx, storageClass, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.StorageClass) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StorageClassApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, storageClass, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, storageClass, opts -func (_m *StorageClassInterface) Create(ctx context.Context, storageClass *v1beta1.StorageClass, opts v1.CreateOptions) (*v1beta1.StorageClass, error) { +func (_m *StorageClassInterface) Create(ctx context.Context, storageClass *storagev1beta1.StorageClass, opts v1.CreateOptions) (*storagev1beta1.StorageClass, error) { ret := _m.Called(ctx, storageClass, opts) - var r0 *v1beta1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StorageClass, v1.CreateOptions) *v1beta1.StorageClass); ok { + var r0 *storagev1beta1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.StorageClass, v1.CreateOptions) *storagev1beta1.StorageClass); ok { r0 = rf(ctx, storageClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StorageClass) + r0 = ret.Get(0).(*storagev1beta1.StorageClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StorageClass, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.StorageClass, v1.CreateOptions) error); ok { r1 = rf(ctx, storageClass, opts) } else { r1 = ret.Error(1) @@ -73,15 +97,15 @@ func (_m *StorageClassInterface) DeleteCollection(ctx context.Context, opts v1.D } // Get provides a mock function with given fields: ctx, name, opts -func (_m *StorageClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.StorageClass, error) { +func (_m *StorageClassInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1beta1.StorageClass, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.StorageClass); ok { + var r0 *storagev1beta1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1beta1.StorageClass); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StorageClass) + r0 = ret.Get(0).(*storagev1beta1.StorageClass) } } @@ -96,15 +120,15 @@ func (_m *StorageClassInterface) Get(ctx context.Context, name string, opts v1.G } // List provides a mock function with given fields: ctx, opts -func (_m *StorageClassInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.StorageClassList, error) { +func (_m *StorageClassInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1beta1.StorageClassList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.StorageClassList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.StorageClassList); ok { + var r0 *storagev1beta1.StorageClassList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1beta1.StorageClassList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StorageClassList) + r0 = ret.Get(0).(*storagev1beta1.StorageClassList) } } @@ -119,7 +143,7 @@ func (_m *StorageClassInterface) List(ctx context.Context, opts v1.ListOptions) } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.StorageClass, error) { +func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1beta1.StorageClass, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +153,12 @@ func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt type _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.StorageClass); ok { + var r0 *storagev1beta1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1beta1.StorageClass); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StorageClass) + r0 = ret.Get(0).(*storagev1beta1.StorageClass) } } @@ -149,20 +173,20 @@ func (_m *StorageClassInterface) Patch(ctx context.Context, name string, pt type } // Update provides a mock function with given fields: ctx, storageClass, opts -func (_m *StorageClassInterface) Update(ctx context.Context, storageClass *v1beta1.StorageClass, opts v1.UpdateOptions) (*v1beta1.StorageClass, error) { +func (_m *StorageClassInterface) Update(ctx context.Context, storageClass *storagev1beta1.StorageClass, opts v1.UpdateOptions) (*storagev1beta1.StorageClass, error) { ret := _m.Called(ctx, storageClass, opts) - var r0 *v1beta1.StorageClass - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.StorageClass, v1.UpdateOptions) *v1beta1.StorageClass); ok { + var r0 *storagev1beta1.StorageClass + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.StorageClass, v1.UpdateOptions) *storagev1beta1.StorageClass); ok { r0 = rf(ctx, storageClass, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.StorageClass) + r0 = ret.Get(0).(*storagev1beta1.StorageClass) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.StorageClass, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.StorageClass, v1.UpdateOptions) error); ok { r1 = rf(ctx, storageClass, opts) } else { r1 = ret.Error(1) diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/storage_v1beta1_interface.go b/testutil/kubernetes_mock/typed/storage/v1beta1/storage_v1beta1_interface.go index 2d220e4a3d..8c3460d84b 100644 --- a/testutil/kubernetes_mock/typed/storage/v1beta1/storage_v1beta1_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/storage_v1beta1_interface.go @@ -46,6 +46,22 @@ func (_m *StorageV1beta1Interface) CSINodes() v1beta1.CSINodeInterface { return r0 } +// CSIStorageCapacities provides a mock function with given fields: namespace +func (_m *StorageV1beta1Interface) CSIStorageCapacities(namespace string) v1beta1.CSIStorageCapacityInterface { + ret := _m.Called(namespace) + + var r0 v1beta1.CSIStorageCapacityInterface + if rf, ok := ret.Get(0).(func(string) v1beta1.CSIStorageCapacityInterface); ok { + r0 = rf(namespace) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(v1beta1.CSIStorageCapacityInterface) + } + } + + return r0 +} + // RESTClient provides a mock function with given fields: func (_m *StorageV1beta1Interface) RESTClient() rest.Interface { ret := _m.Called() diff --git a/testutil/kubernetes_mock/typed/storage/v1beta1/volume_attachment_interface.go b/testutil/kubernetes_mock/typed/storage/v1beta1/volume_attachment_interface.go index 7551eb6f35..be69c5f994 100644 --- a/testutil/kubernetes_mock/typed/storage/v1beta1/volume_attachment_interface.go +++ b/testutil/kubernetes_mock/typed/storage/v1beta1/volume_attachment_interface.go @@ -6,12 +6,13 @@ import ( context "context" mock "github.com/stretchr/testify/mock" + storagev1beta1 "k8s.io/api/storage/v1beta1" types "k8s.io/apimachinery/pkg/types" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" - v1beta1 "k8s.io/api/storage/v1beta1" + v1beta1 "k8s.io/client-go/applyconfigurations/storage/v1beta1" watch "k8s.io/apimachinery/pkg/watch" ) @@ -21,21 +22,67 @@ type VolumeAttachmentInterface struct { mock.Mock } +// Apply provides a mock function with given fields: ctx, volumeAttachment, opts +func (_m *VolumeAttachmentInterface) Apply(ctx context.Context, volumeAttachment *v1beta1.VolumeAttachmentApplyConfiguration, opts v1.ApplyOptions) (*storagev1beta1.VolumeAttachment, error) { + ret := _m.Called(ctx, volumeAttachment, opts) + + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) *storagev1beta1.VolumeAttachment); ok { + r0 = rf(ctx, volumeAttachment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, volumeAttachment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// ApplyStatus provides a mock function with given fields: ctx, volumeAttachment, opts +func (_m *VolumeAttachmentInterface) ApplyStatus(ctx context.Context, volumeAttachment *v1beta1.VolumeAttachmentApplyConfiguration, opts v1.ApplyOptions) (*storagev1beta1.VolumeAttachment, error) { + ret := _m.Called(ctx, volumeAttachment, opts) + + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) *storagev1beta1.VolumeAttachment); ok { + r0 = rf(ctx, volumeAttachment, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) + } + } + + var r1 error + if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.VolumeAttachmentApplyConfiguration, v1.ApplyOptions) error); ok { + r1 = rf(ctx, volumeAttachment, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + // Create provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) Create(ctx context.Context, volumeAttachment *v1beta1.VolumeAttachment, opts v1.CreateOptions) (*v1beta1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Create(ctx context.Context, volumeAttachment *storagev1beta1.VolumeAttachment, opts v1.CreateOptions) (*storagev1beta1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1beta1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.VolumeAttachment, v1.CreateOptions) *v1beta1.VolumeAttachment); ok { + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.VolumeAttachment, v1.CreateOptions) *storagev1beta1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.VolumeAttachment, v1.CreateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.VolumeAttachment, v1.CreateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) @@ -73,15 +120,15 @@ func (_m *VolumeAttachmentInterface) DeleteCollection(ctx context.Context, opts } // Get provides a mock function with given fields: ctx, name, opts -func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*v1beta1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts v1.GetOptions) (*storagev1beta1.VolumeAttachment, error) { ret := _m.Called(ctx, name, opts) - var r0 *v1beta1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *v1beta1.VolumeAttachment); ok { + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, string, v1.GetOptions) *storagev1beta1.VolumeAttachment); ok { r0 = rf(ctx, name, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) } } @@ -96,15 +143,15 @@ func (_m *VolumeAttachmentInterface) Get(ctx context.Context, name string, opts } // List provides a mock function with given fields: ctx, opts -func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts v1.ListOptions) (*v1beta1.VolumeAttachmentList, error) { +func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts v1.ListOptions) (*storagev1beta1.VolumeAttachmentList, error) { ret := _m.Called(ctx, opts) - var r0 *v1beta1.VolumeAttachmentList - if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *v1beta1.VolumeAttachmentList); ok { + var r0 *storagev1beta1.VolumeAttachmentList + if rf, ok := ret.Get(0).(func(context.Context, v1.ListOptions) *storagev1beta1.VolumeAttachmentList); ok { r0 = rf(ctx, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.VolumeAttachmentList) + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachmentList) } } @@ -119,7 +166,7 @@ func (_m *VolumeAttachmentInterface) List(ctx context.Context, opts v1.ListOptio } // Patch provides a mock function with given fields: ctx, name, pt, data, opts, subresources -func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*v1beta1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (*storagev1beta1.VolumeAttachment, error) { _va := make([]interface{}, len(subresources)) for _i := range subresources { _va[_i] = subresources[_i] @@ -129,12 +176,12 @@ func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt _ca = append(_ca, _va...) ret := _m.Called(_ca...) - var r0 *v1beta1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *v1beta1.VolumeAttachment); ok { + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, string, types.PatchType, []byte, v1.PatchOptions, ...string) *storagev1beta1.VolumeAttachment); ok { r0 = rf(ctx, name, pt, data, opts, subresources...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) } } @@ -149,20 +196,20 @@ func (_m *VolumeAttachmentInterface) Patch(ctx context.Context, name string, pt } // Update provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachment *v1beta1.VolumeAttachment, opts v1.UpdateOptions) (*v1beta1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachment *storagev1beta1.VolumeAttachment, opts v1.UpdateOptions) (*storagev1beta1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1beta1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.VolumeAttachment, v1.UpdateOptions) *v1beta1.VolumeAttachment); ok { + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.VolumeAttachment, v1.UpdateOptions) *storagev1beta1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.VolumeAttachment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.VolumeAttachment, v1.UpdateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) @@ -172,20 +219,20 @@ func (_m *VolumeAttachmentInterface) Update(ctx context.Context, volumeAttachmen } // UpdateStatus provides a mock function with given fields: ctx, volumeAttachment, opts -func (_m *VolumeAttachmentInterface) UpdateStatus(ctx context.Context, volumeAttachment *v1beta1.VolumeAttachment, opts v1.UpdateOptions) (*v1beta1.VolumeAttachment, error) { +func (_m *VolumeAttachmentInterface) UpdateStatus(ctx context.Context, volumeAttachment *storagev1beta1.VolumeAttachment, opts v1.UpdateOptions) (*storagev1beta1.VolumeAttachment, error) { ret := _m.Called(ctx, volumeAttachment, opts) - var r0 *v1beta1.VolumeAttachment - if rf, ok := ret.Get(0).(func(context.Context, *v1beta1.VolumeAttachment, v1.UpdateOptions) *v1beta1.VolumeAttachment); ok { + var r0 *storagev1beta1.VolumeAttachment + if rf, ok := ret.Get(0).(func(context.Context, *storagev1beta1.VolumeAttachment, v1.UpdateOptions) *storagev1beta1.VolumeAttachment); ok { r0 = rf(ctx, volumeAttachment, opts) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*v1beta1.VolumeAttachment) + r0 = ret.Get(0).(*storagev1beta1.VolumeAttachment) } } var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *v1beta1.VolumeAttachment, v1.UpdateOptions) error); ok { + if rf, ok := ret.Get(1).(func(context.Context, *storagev1beta1.VolumeAttachment, v1.UpdateOptions) error); ok { r1 = rf(ctx, volumeAttachment, opts) } else { r1 = ret.Error(1) diff --git a/types/resource.pb.go b/types/resource.pb.go index d57d658466..97a7d7e6a4 100644 --- a/types/resource.pb.go +++ b/types/resource.pb.go @@ -26,7 +26,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package // CPU stores resource units and cpu config attributes type CPU struct { Units ResourceValue `protobuf:"bytes,1,opt,name=units,proto3" json:"units"` - Attributes []Attribute `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" yaml:"cpu,omitempty"` + Attributes Attributes `protobuf:"bytes,2,rep,name=attributes,proto3,castrepeated=Attributes" json:"attributes,omitempty" yaml:"attributes,omitempty"` } func (m *CPU) Reset() { *m = CPU{} } @@ -69,7 +69,7 @@ func (m *CPU) GetUnits() ResourceValue { return ResourceValue{} } -func (m *CPU) GetAttributes() []Attribute { +func (m *CPU) GetAttributes() Attributes { if m != nil { return m.Attributes } @@ -79,7 +79,7 @@ func (m *CPU) GetAttributes() []Attribute { // Memory stores resource quantity and memory attributes type Memory struct { Quantity ResourceValue `protobuf:"bytes,1,opt,name=quantity,proto3" json:"size" yaml:"size"` - Attributes []Attribute `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" yaml:"cpu,omitempty"` + Attributes Attributes `protobuf:"bytes,2,rep,name=attributes,proto3,castrepeated=Attributes" json:"attributes,omitempty" yaml:"attributes,omitempty"` } func (m *Memory) Reset() { *m = Memory{} } @@ -122,7 +122,7 @@ func (m *Memory) GetQuantity() ResourceValue { return ResourceValue{} } -func (m *Memory) GetAttributes() []Attribute { +func (m *Memory) GetAttributes() Attributes { if m != nil { return m.Attributes } @@ -131,8 +131,9 @@ func (m *Memory) GetAttributes() []Attribute { // Storage stores resource quantity and storage attributes type Storage struct { - Quantity ResourceValue `protobuf:"bytes,1,opt,name=quantity,proto3" json:"size" yaml:"size"` - Attributes []Attribute `protobuf:"bytes,2,rep,name=attributes,proto3" json:"attributes,omitempty" yaml:"cpu,omitempty"` + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name" yaml:"name"` + Quantity ResourceValue `protobuf:"bytes,2,opt,name=quantity,proto3" json:"size" yaml:"size"` + Attributes Attributes `protobuf:"bytes,3,rep,name=attributes,proto3,castrepeated=Attributes" json:"attributes,omitempty" yaml:"attributes,omitempty"` } func (m *Storage) Reset() { *m = Storage{} } @@ -168,6 +169,13 @@ func (m *Storage) XXX_DiscardUnknown() { var xxx_messageInfo_Storage proto.InternalMessageInfo +func (m *Storage) GetName() string { + if m != nil { + return m.Name + } + return "" +} + func (m *Storage) GetQuantity() ResourceValue { if m != nil { return m.Quantity @@ -175,7 +183,7 @@ func (m *Storage) GetQuantity() ResourceValue { return ResourceValue{} } -func (m *Storage) GetAttributes() []Attribute { +func (m *Storage) GetAttributes() Attributes { if m != nil { return m.Attributes } @@ -185,10 +193,10 @@ func (m *Storage) GetAttributes() []Attribute { // ResourceUnits describes all available resources types for deployment/node etc // if field is nil resource is not present in the given data-structure type ResourceUnits struct { - CPU *CPU `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty" yaml:"cpu,omitempty"` - Memory *Memory `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty" yaml:"memory,omitempty"` - Storage *Storage `protobuf:"bytes,3,opt,name=storage,proto3" json:"storage,omitempty" yaml:"storage,omitempty"` - Endpoints []Endpoint `protobuf:"bytes,4,rep,name=endpoints,proto3" json:"endpoints" yaml:"endpoints"` + CPU *CPU `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty" yaml:"cpu,omitempty"` + Memory *Memory `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty" yaml:"memory,omitempty"` + Storage Volumes `protobuf:"bytes,3,rep,name=storage,proto3,castrepeated=Volumes" json:"storage,omitempty" yaml:"storage,omitempty"` + Endpoints Endpoints `protobuf:"bytes,4,rep,name=endpoints,proto3,castrepeated=Endpoints" json:"endpoints" yaml:"endpoints"` } func (m *ResourceUnits) Reset() { *m = ResourceUnits{} } @@ -238,14 +246,14 @@ func (m *ResourceUnits) GetMemory() *Memory { return nil } -func (m *ResourceUnits) GetStorage() *Storage { +func (m *ResourceUnits) GetStorage() Volumes { if m != nil { return m.Storage } return nil } -func (m *ResourceUnits) GetEndpoints() []Endpoint { +func (m *ResourceUnits) GetEndpoints() Endpoints { if m != nil { return m.Endpoints } @@ -262,39 +270,42 @@ func init() { func init() { proto.RegisterFile("akash/base/v1beta1/resource.proto", fileDescriptor_c018ae61a1e1b59b) } var fileDescriptor_c018ae61a1e1b59b = []byte{ - // 504 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x94, 0x41, 0x6b, 0xd4, 0x40, - 0x14, 0xc7, 0x77, 0x9a, 0x75, 0xab, 0xb3, 0x14, 0x6a, 0x58, 0x68, 0xd8, 0xda, 0x4c, 0x3b, 0xa0, - 0xf4, 0x20, 0x09, 0x6d, 0x15, 0xa1, 0xe0, 0xc1, 0x14, 0x8f, 0x42, 0x89, 0xac, 0x87, 0x5e, 0x64, - 0x12, 0x87, 0x34, 0x74, 0xb3, 0x13, 0x33, 0x93, 0x85, 0xf8, 0x29, 0xfc, 0x08, 0x7e, 0x04, 0xbf, - 0x81, 0xd7, 0x1e, 0x7b, 0xf4, 0x14, 0xcb, 0xee, 0x45, 0xf6, 0xb8, 0x9f, 0x40, 0x32, 0x33, 0xd9, - 0x75, 0xd7, 0x28, 0xde, 0x04, 0x6f, 0xc9, 0xbc, 0xff, 0x7b, 0xbf, 0xf7, 0xf8, 0xbf, 0x19, 0x78, - 0x40, 0xae, 0x08, 0xbf, 0x74, 0x03, 0xc2, 0xa9, 0x3b, 0x3e, 0x0a, 0xa8, 0x20, 0x47, 0x6e, 0x46, - 0x39, 0xcb, 0xb3, 0x90, 0x3a, 0x69, 0xc6, 0x04, 0x33, 0x4d, 0x29, 0x71, 0x2a, 0x89, 0xa3, 0x25, - 0xfd, 0x5e, 0xc4, 0x22, 0x26, 0xc3, 0x6e, 0xf5, 0xa5, 0x94, 0x7d, 0xdc, 0x50, 0x8c, 0x08, 0x91, - 0xc5, 0x41, 0x2e, 0x74, 0xb5, 0xfe, 0xa3, 0x3f, 0x00, 0xc7, 0x64, 0x98, 0xd7, 0xba, 0xa6, 0xc6, - 0xe8, 0xe8, 0x5d, 0xca, 0xe2, 0x91, 0x50, 0x12, 0xfc, 0x05, 0x40, 0xe3, 0xec, 0x7c, 0x60, 0x3e, - 0x87, 0x77, 0xf2, 0x51, 0x2c, 0xb8, 0x05, 0xf6, 0xc1, 0x61, 0xf7, 0xf8, 0xc0, 0xf9, 0xb5, 0x61, - 0xc7, 0xd7, 0x88, 0x37, 0x15, 0xc2, 0x6b, 0x5f, 0x97, 0xa8, 0xe5, 0xab, 0x2c, 0x93, 0x43, 0xb8, - 0x68, 0x92, 0x5b, 0x1b, 0xfb, 0xc6, 0x61, 0xf7, 0x78, 0xaf, 0xa9, 0xc6, 0x8b, 0x5a, 0xe5, 0x3d, - 0xa9, 0xf2, 0x67, 0x25, 0xea, 0x2d, 0x13, 0x1f, 0xb3, 0x24, 0x16, 0x34, 0x49, 0x45, 0x31, 0x2f, - 0x51, 0xaf, 0x20, 0xc9, 0xf0, 0x14, 0x87, 0x69, 0xbe, 0x3c, 0xc6, 0xfe, 0x4f, 0x98, 0xd3, 0xf6, - 0xf7, 0x4f, 0x08, 0xe0, 0x6f, 0x00, 0x76, 0x5e, 0xd1, 0x84, 0x65, 0x85, 0x79, 0x01, 0xef, 0xbe, - 0xcf, 0xc9, 0x48, 0xc4, 0xa2, 0xf8, 0xfb, 0x39, 0x76, 0x75, 0x1f, 0x6d, 0x1e, 0x7f, 0xa0, 0xf3, - 0x12, 0x75, 0x15, 0xb7, 0xfa, 0xc3, 0xfe, 0xa2, 0xde, 0xbf, 0x9c, 0xf0, 0x16, 0xc0, 0xcd, 0xd7, - 0x82, 0x65, 0x24, 0xa2, 0xff, 0xeb, 0x88, 0x9f, 0x0d, 0xb8, 0x55, 0xf7, 0x3c, 0x90, 0x1b, 0xf5, - 0x16, 0x1a, 0x61, 0x9a, 0xeb, 0x19, 0x77, 0x9a, 0xba, 0x38, 0x3b, 0x1f, 0x48, 0x3e, 0x98, 0x94, - 0xa8, 0xda, 0xe1, 0x59, 0x89, 0xb6, 0x56, 0x40, 0xbf, 0xe5, 0x57, 0x95, 0xcd, 0x08, 0x76, 0x12, - 0xb9, 0x36, 0xd6, 0x86, 0x64, 0xf4, 0x9b, 0x18, 0x6a, 0xb1, 0xbc, 0x93, 0x0a, 0x33, 0x2b, 0xd1, - 0xb6, 0xca, 0x58, 0x41, 0xec, 0x28, 0xc4, 0x7a, 0x04, 0xfb, 0xba, 0xbc, 0x39, 0x84, 0x9b, 0x5c, - 0xb9, 0x67, 0x19, 0x92, 0xb4, 0xdb, 0x44, 0xd2, 0x06, 0x7b, 0x4f, 0x35, 0xea, 0xbe, 0xce, 0x59, - 0x61, 0x59, 0xda, 0xb8, 0xf5, 0x10, 0xf6, 0x6b, 0x84, 0x49, 0xe0, 0xbd, 0xfa, 0x8a, 0x73, 0xab, - 0x2d, 0x3d, 0x7c, 0xd0, 0xc4, 0x7b, 0xa9, 0x45, 0xde, 0x43, 0x6d, 0xe1, 0x32, 0x6d, 0x5e, 0xa2, - 0x6d, 0x05, 0x5a, 0x1c, 0x61, 0x7f, 0x19, 0x56, 0x96, 0x79, 0xcf, 0xae, 0x27, 0x36, 0xb8, 0x99, - 0xd8, 0xe0, 0x76, 0x62, 0x83, 0x8f, 0x53, 0xbb, 0x75, 0x33, 0xb5, 0x5b, 0x5f, 0xa7, 0x76, 0xeb, - 0x62, 0x2f, 0x8a, 0xc5, 0x65, 0x1e, 0x38, 0x21, 0x4b, 0x5c, 0x36, 0xce, 0xc2, 0xe1, 0x95, 0xab, - 0x1e, 0x22, 0x51, 0xa4, 0x94, 0x07, 0x1d, 0xf9, 0xf2, 0x9c, 0xfc, 0x08, 0x00, 0x00, 0xff, 0xff, - 0xb4, 0x98, 0x5e, 0xf5, 0x37, 0x05, 0x00, 0x00, + // 560 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x94, 0x41, 0x8b, 0xd3, 0x40, + 0x14, 0xc7, 0x3b, 0xdb, 0xda, 0xda, 0x29, 0x0b, 0x6b, 0x28, 0xb4, 0xb4, 0x6e, 0x66, 0x37, 0x07, + 0x59, 0x50, 0x12, 0xb6, 0x2b, 0x08, 0x0b, 0x82, 0x66, 0xf1, 0xe0, 0x41, 0x58, 0x22, 0xdd, 0xc3, + 0x5e, 0x64, 0x5a, 0x87, 0x6c, 0xd8, 0x26, 0x13, 0x33, 0x93, 0x4a, 0xfc, 0x04, 0x1e, 0xfd, 0x08, + 0x82, 0x37, 0x3f, 0x49, 0x8f, 0x7b, 0x11, 0x3c, 0x45, 0x69, 0x2f, 0xd2, 0x63, 0xc1, 0xbb, 0x4c, + 0x66, 0xd2, 0x9a, 0x35, 0x88, 0x17, 0xd1, 0x5b, 0x67, 0xde, 0xff, 0xbd, 0xdf, 0xff, 0xbd, 0xbc, + 0x0e, 0xdc, 0xc7, 0x97, 0x98, 0x5d, 0x58, 0x23, 0xcc, 0x88, 0x35, 0x3d, 0x1c, 0x11, 0x8e, 0x0f, + 0xad, 0x88, 0x30, 0x1a, 0x47, 0x63, 0x62, 0x86, 0x11, 0xe5, 0x54, 0xd3, 0x32, 0x89, 0x29, 0x24, + 0xa6, 0x92, 0xf4, 0xda, 0x2e, 0x75, 0x69, 0x16, 0xb6, 0xc4, 0x2f, 0xa9, 0xec, 0x19, 0x25, 0xc5, + 0x30, 0xe7, 0x91, 0x37, 0x8a, 0xb9, 0xaa, 0xd6, 0xbb, 0xf3, 0x1b, 0xe0, 0x14, 0x4f, 0xe2, 0x5c, + 0x57, 0x66, 0x8c, 0x04, 0x2f, 0x43, 0xea, 0x05, 0x5c, 0x4a, 0x8c, 0x4f, 0x00, 0x56, 0x4f, 0x4e, + 0x87, 0xda, 0x43, 0x78, 0x23, 0x0e, 0x3c, 0xce, 0xba, 0x60, 0x0f, 0x1c, 0xb4, 0x06, 0xfb, 0xe6, + 0xaf, 0x86, 0x4d, 0x47, 0x21, 0xce, 0x04, 0xc2, 0xae, 0xcd, 0x52, 0x54, 0x71, 0x64, 0x96, 0xf6, + 0x16, 0x40, 0xb8, 0x76, 0xc9, 0xba, 0x5b, 0x7b, 0xd5, 0x83, 0xd6, 0x60, 0xb7, 0xac, 0xc8, 0xe3, + 0x5c, 0x65, 0x3f, 0x15, 0x05, 0x96, 0x29, 0x6a, 0x6f, 0x12, 0xef, 0x51, 0xdf, 0xe3, 0xc4, 0x0f, + 0x79, 0xb2, 0x4a, 0x51, 0x3f, 0xc1, 0xfe, 0xe4, 0xd8, 0x28, 0x8b, 0x1a, 0x1f, 0xbf, 0x20, 0xb8, + 0xae, 0xc4, 0x9c, 0x9f, 0xd8, 0xc7, 0xb5, 0x6f, 0xef, 0x11, 0x30, 0xbe, 0x03, 0x58, 0x7f, 0x46, + 0x7c, 0x1a, 0x25, 0xda, 0x39, 0xbc, 0xf9, 0x2a, 0xc6, 0x01, 0xf7, 0x78, 0xf2, 0xe7, 0xdd, 0xf5, + 0x95, 0xb9, 0x1a, 0xf3, 0xde, 0x90, 0x55, 0x8a, 0x5a, 0xd2, 0x8c, 0x38, 0x19, 0xce, 0xba, 0xde, + 0xff, 0xd7, 0xf7, 0x87, 0x2d, 0xd8, 0x78, 0xce, 0x69, 0x84, 0x5d, 0xa2, 0xdd, 0x85, 0xb5, 0x00, + 0xfb, 0x24, 0x6b, 0xba, 0x69, 0x77, 0x44, 0x37, 0xe2, 0xbc, 0xe9, 0x46, 0x9c, 0x0c, 0x27, 0xbb, + 0x2c, 0x4c, 0x69, 0xeb, 0xef, 0x4e, 0xa9, 0xfa, 0xcf, 0xa7, 0x34, 0xab, 0xc2, 0xed, 0xbc, 0x93, + 0x61, 0xb6, 0xc0, 0x2f, 0x60, 0x75, 0x1c, 0xc6, 0x6a, 0x3f, 0x3a, 0x65, 0xd6, 0x4e, 0x4e, 0x87, + 0xf6, 0xfd, 0x59, 0x8a, 0xc0, 0x3c, 0x45, 0xe2, 0x2f, 0xb3, 0x4c, 0xd1, 0xf6, 0x38, 0x8c, 0x0b, + 0xa6, 0xda, 0xd2, 0x54, 0xe1, 0xda, 0x70, 0x44, 0x65, 0xcd, 0x85, 0x75, 0x3f, 0xdb, 0x47, 0x35, + 0xdd, 0x5e, 0x19, 0x43, 0x6e, 0xac, 0x7d, 0x24, 0x30, 0xcb, 0x14, 0xed, 0xc8, 0x8c, 0x02, 0xa2, + 0x23, 0x11, 0xd7, 0x23, 0x86, 0xa3, 0xca, 0x6b, 0xaf, 0x61, 0x83, 0xc9, 0x05, 0x50, 0x83, 0xee, + 0x97, 0x91, 0xd4, 0x8e, 0xd8, 0x8f, 0xd4, 0x98, 0x6f, 0xa9, 0x9c, 0x02, 0xab, 0xab, 0x3e, 0xe7, + 0xf5, 0x90, 0x18, 0x70, 0xe3, 0x8c, 0x4e, 0x62, 0x9f, 0x30, 0x27, 0xa7, 0x69, 0x01, 0x6c, 0xe6, + 0x8f, 0x0b, 0xeb, 0xd6, 0x32, 0xf4, 0xed, 0x32, 0xf4, 0x13, 0x25, 0xb2, 0x07, 0x8a, 0xbd, 0x49, + 0x5b, 0xa5, 0x68, 0x47, 0x32, 0xd7, 0x57, 0x82, 0xd5, 0xcc, 0x53, 0x98, 0xb3, 0xd1, 0xca, 0x4f, + 0x69, 0x3f, 0x98, 0xcd, 0x75, 0x70, 0x35, 0xd7, 0xc1, 0xd7, 0xb9, 0x0e, 0xde, 0x2d, 0xf4, 0xca, + 0xd5, 0x42, 0xaf, 0x7c, 0x5e, 0xe8, 0x95, 0xf3, 0x5d, 0xd7, 0xe3, 0x17, 0xf1, 0xc8, 0x1c, 0x53, + 0xdf, 0xa2, 0xd3, 0x68, 0x3c, 0xb9, 0xb4, 0xe4, 0x7b, 0xc8, 0x93, 0x90, 0xb0, 0x51, 0x3d, 0x7b, + 0x00, 0x8f, 0x7e, 0x04, 0x00, 0x00, 0xff, 0xff, 0xcb, 0x4f, 0x45, 0xa4, 0xbe, 0x05, 0x00, 0x00, } func (this *CPU) Equal(that interface{}) bool { @@ -380,6 +391,9 @@ func (this *Storage) Equal(that interface{}) bool { } else if this == nil { return false } + if this.Name != that1.Name { + return false + } if !this.Quantity.Equal(&that1.Quantity) { return false } @@ -418,9 +432,14 @@ func (this *ResourceUnits) Equal(that interface{}) bool { if !this.Memory.Equal(that1.Memory) { return false } - if !this.Storage.Equal(that1.Storage) { + if len(this.Storage) != len(that1.Storage) { return false } + for i := range this.Storage { + if !this.Storage[i].Equal(&that1.Storage[i]) { + return false + } + } if len(this.Endpoints) != len(that1.Endpoints) { return false } @@ -556,7 +575,7 @@ func (m *Storage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintResource(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0x12 + dAtA[i] = 0x1a } } { @@ -568,7 +587,14 @@ func (m *Storage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i = encodeVarintResource(dAtA, i, uint64(size)) } i-- - dAtA[i] = 0xa + dAtA[i] = 0x12 + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintResource(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } return len(dAtA) - i, nil } @@ -606,17 +632,19 @@ func (m *ResourceUnits) MarshalToSizedBuffer(dAtA []byte) (int, error) { dAtA[i] = 0x22 } } - if m.Storage != nil { - { - size, err := m.Storage.MarshalToSizedBuffer(dAtA[:i]) - if err != nil { - return 0, err + if len(m.Storage) > 0 { + for iNdEx := len(m.Storage) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.Storage[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintResource(dAtA, i, uint64(size)) } - i -= size - i = encodeVarintResource(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x1a } - i-- - dAtA[i] = 0x1a } if m.Memory != nil { { @@ -696,6 +724,10 @@ func (m *Storage) Size() (n int) { } var l int _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovResource(uint64(l)) + } l = m.Quantity.Size() n += 1 + l + sovResource(uint64(l)) if len(m.Attributes) > 0 { @@ -721,9 +753,11 @@ func (m *ResourceUnits) Size() (n int) { l = m.Memory.Size() n += 1 + l + sovResource(uint64(l)) } - if m.Storage != nil { - l = m.Storage.Size() - n += 1 + l + sovResource(uint64(l)) + if len(m.Storage) > 0 { + for _, e := range m.Storage { + l = e.Size() + n += 1 + l + sovResource(uint64(l)) + } } if len(m.Endpoints) > 0 { for _, e := range m.Endpoints { @@ -1004,6 +1038,38 @@ func (m *Storage) Unmarshal(dAtA []byte) error { } switch fieldNum { case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowResource + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthResource + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthResource + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Quantity", wireType) } @@ -1036,7 +1102,7 @@ func (m *Storage) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - case 2: + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attributes", wireType) } @@ -1221,10 +1287,8 @@ func (m *ResourceUnits) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Storage == nil { - m.Storage = &Storage{} - } - if err := m.Storage.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Storage = append(m.Storage, Storage{}) + if err := m.Storage[len(m.Storage)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/x/escrow/keeper/mocks/bank_keeper.go b/x/escrow/keeper/mocks/bank_keeper.go index a608282113..2901d8eaca 100644 --- a/x/escrow/keeper/mocks/bank_keeper.go +++ b/x/escrow/keeper/mocks/bank_keeper.go @@ -1,4 +1,4 @@ -// Code generated by mockery 2.9.0. DO NOT EDIT. +// Code generated by mockery v2.5.1. DO NOT EDIT. package mocks