735 2013-05-14 17:54:01 +0200 Screen is not updated when using invoke() method on OSX 2013-06-17 13:19:48 +0200 1 1 3 JogAmp Jogl macosx 2 pc_all macosx RESOLVED FIXED --- major --- 753 1 andres.colubri sgothel jeffgemail xerxes --- jogl 4fe6cf06f74085cc90d1f5b003fd717234d43ced jogl 05d8a9490497413df11fd2faf07e34d648130966 jogl 24b63b18e6ca3f657350d6c80e4914eadce60164 jogl c24f44036971bf58b5c47a6e1f7d9f186c67e789 jogl d846b04928ecfcfb319e75d7ed114d357edbeb89 --- oldest_to_newest 2592 0 andres.colubri 2013-05-14 17:54:01 +0200 I wrote an application that uses (GLCanvas/GLWindow).invoke() to run my frame rendering code through a GLRunnable. It works without any issues on Windows 7 (with Java 7), but it doesn't properly update the screen on OSX. The frame starts by clearing the color buffer to red, and it then runs a raymarching shader. Only the red color filling the entire screen is the visible output of this application. Even if the shader is modified to simply output a constant color for all pixels, the result continues to be the red color from the clear command. The application can switch between AWT and NEWT as the toolkit, the uploaded test case is set to use NEWT at the moment. In that case, and if the following two lines in the initGL() method: applet.setLayout(new BorderLayout()); applet.add(newtCanvas, BorderLayout.CENTER); are replaced by: newtWindow.setSize(applet.width, applet.height); newtWindow.setVisible(true); then the output of the rendering is properly displayed in a separate window. This issue is consistent across 10.6, 10.7 and 10.8, with the same output described above across all cases. The following test configurations were used: * Macbook Pro 2010, NVidia Geforce 320M, OSX 10.6.8 * iMac 2009, NVidia Geforce GT 130, OSX 10.7.5 * Macbook Pro 2011, AMD Radeon HD 6490M, Intel HD Graphics 3000, OSX 10.8.3 On the OSX 10.7 and 10.8 systems, Java 6 and 7 were used, with identical results. 2593 1 465 andres.colubri 2013-05-14 17:58:33 +0200 Created attachment 465 Eclipse project with test case. Jogl jars removed due to size limitation in bugzilla. Tested with jogl 2.0-b982 and gluegen 2.0-b667. 2607 2 xerxes 2013-05-21 12:59:33 +0200 Try add applet.validate(); after adding the newtCanvas to the applet. AWT require you to call to the validate() method on the last line is necessary to repaint the applet and to ensure that the applet is correctly displayed by the layout manager. Since JOGL do lazy initialization the GL canvas is only initialized if it have been displayed properly, thus a missing validate may prevent JOGL to initialize. 2608 3 andres.colubri 2013-05-21 16:05:56 +0200 Hello Xerxes, thanks for your suggestion. I added the call applet.validate() right after applet.add(newtCanvas, BorderLayout.CENTER) but doesn't seem to make any difference, either on Windows or OSX (tested on 10.6 and 10.8). On the former, the program renders correctly, on the later, it only shows a red screen as I reported originally. I wonder if this is really a bug (either in JOGL or at the level of the OS), or whether I'm doing something fundamentally wrong in the setup of JOGL. The fact that rendering occurs normally on Windows makes me think that this is indeed due to a bug somewhere in the OSX implementation of JOGL or in the OS itself (maybe all the recent NSView/CALayer changes have something to to with this problem?). Since we are trying to reach the final release of Processing 2.0 in the near future, I'd need to be able to determine if this is due to some error on my side, to a fixable bug in JOGL, or to a more fundamental issue in OSX. Depending on the answer to this question, I will have to handle this issue differently in the Processing code. Ideally, it is something we can fix entirely, otherwise I'd need to do add some kind of workaround. Hopefully Sven will be able to take a look at this and give us his opinion. Andres 2666 4 sgothel 2013-06-15 02:05:38 +0200 .. working on it now, finally. 2667 5 sgothel 2013-06-15 07:53:22 +0200 .. I love the landscape shader .. will adopt it in demos for sure - THX for picking this one ! :) Reproduced lack of drawing .. Looking at your code .. your looping and draw code looks quite complicated at 1st glance .. well. Dunno why you don't use a simple GLEventListener style w/ Animator, however - it's your valid choice I do respect. Will analyze reason for failure. 2668 6 andres.colubri 2013-06-15 21:37:23 +0200 The reason for the complexity of the looping/drawing code is to reproduce Processing's architecture, where an animation thread started from the main process drives the rendering loop, and also is designed to support different renderers (JAVA2D-based, OpenGL-based, etc). At some point in the development of the OpenGL renderer in Processing, I used an animator object in combination with the GLEventListener, but the animator seemed superflous since the framerate was directed by the animation thread I mentioned above. From some discussions on the jogamp forum (http://forum.jogamp.org/synchronization-issues-tt4029115.html), it seemed to me that the most correct way to trigger the rendering of individual frames from the animation loop was through the use of the invoke() method, which is what lead to the issue I reported here. 2669 7 sgothel 2013-06-16 00:30:01 +0200 (In reply to comment #6) > The reason for the complexity of the looping/drawing code is to reproduce > Processing's architecture, where an animation thread started from the main > process drives the rendering loop, and also is designed to support different > renderers (JAVA2D-based, OpenGL-based, etc). ok, sorry .. I should have know - was more about the below issues (invoke, animator). > > At some point in the development of the OpenGL renderer in Processing, I > used an animator object in combination with the GLEventListener, Yes .. and this [should] work well .. and does here .. > but the > animator seemed superflous since the framerate was directed by the animation > thread I mentioned above. that can be handled .. Pls note that the GLAnimatorControl interface API duty is not only to manage refresh, but to orchestrate refresh w/ toolkit refresh - and also allows the exclusive context thread feature (ECT). I see that both latter features are attempted manually in your test code, however - I doubt this is sufficient. > > From some discussions on the jogamp forum > (http://forum.jogamp.org/synchronization-issues-tt4029115.html), it seemed > to me that the most correct way to trigger the rendering of individual > frames from the animation loop was through the use of the invoke() method, > which is what lead to the issue I reported here. This is more like an abuse of the invoke(..) feature. I.e. invoke was intended to add a GLRunnable to the renderer queue to be executed when rendering (display) _from_ a different thread, e.g. UI. invoke() does trigger display(), if no GLAnimatorControl is set in the GLAutoDrawable. Hence it simply complicates things, where you just could call 'display()' w/ an GLEventListener attached. My first attempt to clarify code was to add an [LandscapeES2 implements GLEventlistener', and replace your invoke() w/ a simple GLAutoDrawable.display() call, where GLAutoDrawable is either GLCanvas or GLWindow. I will go into the details of this design w/ a few variations, besides I still have to find the actual culprit of the 'now show' in your orig. test case. Long story short: - Sure it should work w/ invoke() .. but it's like a bit overkill. - The GLAnimatorControl issues you might had are solvable. .. stay tuned :) 2670 8 sgothel 2013-06-16 04:31:31 +0200 See <http://jogamp.org/git/?p=jogl.git;a=commit;h=4fe6cf06f74085cc90d1f5b003fd717234d43ced> All below test cases work fine w/ GNU/Linux. If not mentioned, same behavior w/ java6 and java7 on OSX. Bug735Inv0AppletAWT: /** * Original test case. * <br/> * OSX Results: * <pre> * - Only RED Clear Color * </pre> */ Bug735Inv1AppletAWT: /** * Difference to orig. Bug735Inv0AppletAWT: * <pre> * - MANUAL_FRAME_HANDLING false * - MANUAL_FRAME_HANDLING: impl using pass through GLContext instead of static * </pre> * OSX Results: * <pre> * - Only RED Clear Color * </pre> */ Bug735Inv2AppletAWT: /** * Difference to orig. Bug735Inv0AppletAWT: * <pre> * - Use GLEventListener * - Add GLEventListener to GLAutoDrawable * - Use GLAutoDrawable.display() instead of GLAutoDrawable.invoke(true, GLRunnable { init / render }) * - Removed MANUAL_FRAME_HANDLING, obsolete due to GLAutoDrawable/GLEventListener * </pre> * OSX Results: * <pre> * - Visible content * - Stuttering, non-fluent and slow animation * </pre> */ Bug735Inv3AppletAWT: /** * Difference to orig. Bug735Inv0AppletAWT: * <pre> * - Use GLEventListener * - Add GLEventListener to GLAutoDrawable * - Use GLAutoDrawable.display() instead of GLAutoDrawable.invoke(true, GLRunnable { init / render }) * - Removed MANUAL_FRAME_HANDLING, obsolete due to GLAutoDrawable/GLEventListener * - Use Animator * - Remove applet, component sizes, use frame based size via validate * - Run frame validation/visibility on AWT-EDT * - Add Wait-For-Key after init (perf-test) * </pre> * OSX Results: * <pre> * - Visible content * - Stuttering, non-fluent and slow animation * </pre> */ Bug735Inv4AppletAWT: /** * Difference to orig. Bug735Inv0AppletAWT: * <pre> * - Use GLEventListener * - Add GLEventListener to GLAutoDrawable * - Use GLAutoDrawable.display() instead of GLAutoDrawable.invoke(true, GLRunnable { init / render }) * - Removed MANUAL_FRAME_HANDLING, obsolete due to GLAutoDrawable/GLEventListener * - Use Animator * - Remove component sizes, use frame based size via validate * - Run frame validation/visibility on AWT-EDT * - Add Wait-For-Key after init (perf-test) * - Remove intermediate applet! * </pre> * OSX Results: * <pre> * - Visible content * - Java6: Fluent animation * - Java7: Stuttering, non-fluent and slow animation * </pre> */ 2671 9 sgothel 2013-06-16 04:41:18 +0200 Note that 'TestLandscapeES2NewtCanvasAWT' and 'Bug735Inv4AWT' expose same behavior, i.e. java6: fluent java7: stuttering Note: if running same tests w/ GearsES2 instead of LandscapeES2, no stuttering appeared. See TestGearsES2NewtCanvasAWT vs TestLandscapeES2NewtCanvasAWT. Stuttering: Maybe .. there is a correlation of the rendering period, since we may block the CALayer animation ? This needs to be investigated for sure. ++ Still need to resolve why Bug735Inv0AppletAWT and Bug735Inv1AppletAWT don't show the content at all. .. ? 2674 10 sgothel 2013-06-16 16:23:35 +0200 (In reply to comment #9) > > Stuttering: Maybe .. there is a correlation of the rendering period, > since we may block the CALayer animation ? > Yes, on the OSX mini w/ NV .. the GPU utilization is maxed out w/ the shader itself. If I increase the swap-interval to 5, fluent animation appears. It seems that we need to adapt to this situation, i.e. if rendering is 'slower' increase the wait period to not hog the GPU. Otherwise .. no GPU cycles left for the CALayer thread. Too bad that multithreading doesn't work well here. Note: It's not the context locking which blocks CALayer .. simply the GPU utilization. 2675 11 andres.colubri 2013-06-16 19:41:36 +0200 Hi Sven, thanks for looking into this. I'm also glad to see that you were able to reproduce the stuttering issue, which was in fact the problem I faced originally. My use of invoke was basically an attempt to solve the stuttering. So far, the only way I was able to reduce the stuttering was by adding a glFinish() call at the end of the frame rendering, which of course shouldn't be done, at least from my understanding of glFinish. I will take a look at GLAnimatorControl, thanks for pointing that out. (In reply to comment #10) > (In reply to comment #9) > > > > Stuttering: Maybe .. there is a correlation of the rendering period, > > since we may block the CALayer animation ? > > > Yes, on the OSX mini w/ NV .. the GPU utilization is maxed out w/ the shader > itself. > If I increase the swap-interval to 5, fluent animation appears. > It seems that we need to adapt to this situation, i.e. if rendering is > 'slower' increase the > wait period to not hog the GPU. Otherwise .. no GPU cycles left for the > CALayer thread. > Too bad that multithreading doesn't work well here. > Note: It's not the context locking which blocks CALayer .. simply the GPU > utilization. 2677 12 sgothel 2013-06-16 19:59:46 +0200 (In reply to comment #11) > Hi Sven, thanks for looking into this. > > I'm also glad to see that you were able to reproduce the stuttering issue, > which was in fact the problem I faced originally. My use of invoke was > basically an attempt to solve the stuttering. So far, the only way I was > able to reduce the stuttering was by adding a glFinish() call at the end of > the frame rendering, which of course shouldn't be done, at least from my > understanding of glFinish. I have moved the stuttering issue to it's own bug, Bug 753. Thank you for the hint glFinish(), maybe it gives a 'timeout', allowing the CALayer thread to utilize the GPU. I will copy this dialog to Bug 753 .. > > I will take a look at GLAnimatorControl, thanks for pointing that out. If you read the variations and their changes, it should be 'easy' to use our Animator. After Bug 753, I will have a 2nd look into it .. but till now, I couldn't find the 'gotcha' lines .. :( 2681 13 sgothel 2013-06-17 06:24:42 +0200 (In reply to comment #12) > After Bug 753, I will have a 2nd look into it .. but till now, I couldn't > find the > 'gotcha' lines .. :( Solved this mystery: glViewport(..) was missing - duh :) How did I find it ? Enabled property jogl.debug.TraceGL .. Since this was not a JOGL bug, marked INVALID. 2682 14 sgothel 2013-06-17 07:34:26 +0200 Re-opened: glViewport should have been set by GLAutoDrawable, i.e. GLDrawableHelper. It was not, due to no GLEventListener attached .. but we should expose same behavior! 2684 15 sgothel 2013-06-17 13:19:48 +0200 GLAutoDrawable must issue glViewport(..) even w/o GLEventListener - Same behavior w/ or w/o GLEventListener requires to issue glViewport, always. - No glViewport(..) required in user code. 465 2013-05-14 17:58:33 +0200 2013-05-14 17:58:33 +0200 Eclipse project with test case. jogl2-invoke-bug.zip application/octet-stream 10421 andres.colubri UEsDBAoAAAAAAEJbrkIAAAAAAAAAAAAAAAARABAAam9nbDItaW52b2tlLWJ1Zy9VWAwAmFeSUYxX klH1ARQAUEsDBBQACAAIAJRsrUIAAAAAAAAAAAAAAAAbABAAam9nbDItaW52b2tlLWJ1Zy8uY2xh c3NwYXRoVVgMAHJWklGoJJFR9QEUAI2RTWvDMAyGz+uvML7HXi9jh6RljAxWWAttBrsN1TGuU1U2 /ijtfv3SjbCyL3qT9L56JKFyetgh2+sQraOKj8U1Z5qUay2Zij83D8Utn05GpUKI0UPaTEZXX4mm FI5sa6mteAyKs1PxM5R/GpWjweiCEVqh9VGLrk0CIZPa9KPFbFm/3i/mzd3jvF7K7z5LSQcCPGvY gXLxIJ5ALVYvzdFrOYM9sFXNbv7ZBe162KUPpcGsjaYiJNFB4Cy6HJT+qXc9uuivFG/WX07vnMEC EH9nf6gXgl1OPqeBvbZ08pby7EnvUEsHCB4t8ozjAAAA2AEAAFBLAwQUAAgACADhWq5CAAAAAAAA AAAAAAAAGQAQAGpvZ2wyLWludm9rZS1idWcvLnByb2plY3RVWAwAl1eSUdVWklH1ARQAdZBBDsIg FETX9hRN9wV15YK2C40XUA9A4YdQCzRAG48vtNhYE3cz8+fzANK8VJ9PYJ00uioOaF/koJnhUouq eNyv5alo6owM1nTA/AUcs3LwoVxnO6Kpgrozoj+WUk/mCWU7CoLnOIyZUQq0rwn+qBCmk1zU+Nu0 o+z5bQAWTHLnsEY1j0GCGSsQsF4ODlDHPWLGBkEnOvfBrvCwQK0YI9UtFm88wT+EFKQLBJofLSzV Rf9nL/OInnvxrHV9fePm695QSwcIYzDoPcIAAAB3AQAAUEsDBAoAAAAAADpfrkIAAAAAAAAAAAAA AAAJABAAX19NQUNPU1gvVVgMAABfklEAX5JR9QEUAFBLAwQKAAAAAAA6X65CAAAAAAAAAAAAAAAA GgAQAF9fTUFDT1NYL2pvZ2wyLWludm9rZS1idWcvVVgMAABfklEAX5JR9QEUAFBLAwQUAAgACADh Wq5CAAAAAAAAAAAAAAAAJAAQAF9fTUFDT1NYL2pvZ2wyLWludm9rZS1idWcvLl8ucHJvamVjdFVY DACXV5JR1VaSUfUBFABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbAXElEIP4q4GYIcQ1IoQBL3AM CQmCMkE65gAxP5oSRoS4eHJ+rl5iQUFOql5IakWJa15yfkpmXjpQMjTETdfC2tDYxMjQ3NLCBABQ SwcI4o87z2MAAACrAAAAUEsDBAoAAAAAAJRsrUIAAAAAAAAAAAAAAAAbABAAam9nbDItaW52b2tl LWJ1Zy8uc2V0dGluZ3MvVVgMAJdXklGoJJFR9QEUAFBLAwQUAAgACACUbK1CAAAAAAAAAAAAAAAA NQAQAGpvZ2wyLWludm9rZS1idWcvLnNldHRpbmdzL29yZy5lY2xpcHNlLmpkdC5jb3JlLnByZWZz VVgMAJdXklGoJJFR9QEUAJWQTUsDMRCG7/0VAe/BLFilkItgwVJEsHjPJu+uI/lYJknBf2/Wj3PT yzAM8/B+3Jw+qthjFGorlNrdPeyGe/H0dhLDrRo2sJ6WDLkwJjCiRZZncKYUtdoknuX/x6cr0iZG G2EhD26Lw4woKXqKOGR+/CpYjxrRjB6uky+GZ5RXb8qUOGglt51gjTXDHZM1XrcAGXzGRTQsnkzL 2aHjMNZZruFeahjBuomCTbkk8setvt4N09rFdWhOlS321M8tnJpKkCa3FsqzQyw0UbMM5sSdMGIN V6K/Tn+6/AZQSwcIsvvGP9wAAABpAgAAUEsDBAoAAAAAACRfrkIAAAAAAAAAAAAAAAAVABAAam9n bDItaW52b2tlLWJ1Zy9saWIvVVgMAJhXklHUXpJR9QEUAFBLAwQUAAgACAAkX65CAAAAAAAAAAAA AAAAHgAQAGpvZ2wyLWludm9rZS1idWcvbGliLy5EU19TdG9yZVVYDADUXpJR1F6SUfUBFADtmDsO wjAQRGeNC0s0LindcABuYEXJCbgABVeg99Eh2hGyFFJQJYJ5kvVWin9pHE8A2PC4X4AMIMGNMz6S 2BaErjbOIYQQQoh9Y6503HYbQogdMp8Pha50cxufBzp2YzJd6Eo3t7FfoCOd6EwXutLNzUPLGD6M KxsTijGFWKHrV68sxN9wcOX5+z9hNf8LIX4Yi+N1HPAOBMsOr3br6ob1S0Dwn4WnbmyhK93cuggI sRVPUEsHCGoAiG2yAAAABBgAAFBLAwQKAAAAAAA6X65CAAAAAAAAAAAAAAAAHgAQAF9fTUFDT1NY L2pvZ2wyLWludm9rZS1idWcvbGliL1VYDAAAX5JRAF+SUfUBFABQSwMEFAAIAAgAJF+uQgAAAAAA AAAAAAAAACkAEABfX01BQ09TWC9qb2dsMi1pbnZva2UtYnVnL2xpYi8uXy5EU19TdG9yZVVYDADU XpJR1F6SUfUBFABjYBVjZ2BiYPBNTFbwD1aIUIACkBgDJxAbAbECEIP4QQwgDkyFAANWAABQSwcI vkOKICoAAABSAAAAUEsDBAoAAAAAAJRsrUIAAAAAAAAAAAAAAAAVABAAam9nbDItaW52b2tlLWJ1 Zy9zcmMvVVgMAJhXklGoJJFR9QEUAFBLAwQKAAAAAAD0Wq5CAAAAAAAAAAAAAAAAGgAQAGpvZ2wy LWludm9rZS1idWcvc3JjL3Rlc3QvVVgMAJhXklH7VpJR9QEUAFBLAwQKAAAAAAD0Wq5CAAAAAAAA AAAAAAAAIQAQAGpvZ2wyLWludm9rZS1idWcvc3JjL3Rlc3QvYXBwbGV0L1VYDACYV5JR+1aSUfUB FABQSwMEFAAIAAgAeVGuQgAAAAAAAAAAAAAAAC8AEABqb2dsMi1pbnZva2UtYnVnL3NyYy90ZXN0 L2FwcGxldC9JbnZBcHBsZXQuamF2YVVYDAD/XpJRJUaSUfUBFAC9G2lzIsf1u35FmypXDRGaZdfe VCVYG7MCsVTQEUCWXakU1RoaGGuYJnPosGv/e97ru2cGtNo44YNgpl+/fvfR3drR6J6uGSlYXoR0 t0tY0Ts6irc7nhXkV/pA1cuwr8a8occi/MizJcsm9JmXDaNnPOFZ/fUg3rI0j3laHxo+sLT4R8lK Vh87z+i24fUoo7tNHOUD9hBHB8aH6UOc8RSWbqB0nOasyOvvpywqaLpOGvAyJDW8jdMlf+wv6a5g Day6QII3HySNeXiecFp8LFer6vyyiJMw4mlUZhliOeNlWgz4YzqhRbQ5DDsHEd+kcUWbT+GWLWMa 8h0DnsLRpHdw9N1w9u4wRL8s+CCjj/SuIqEa5Bnd0bs4iYuY5S9A8rRgT8VhoOFTxHZF1YRqYNcZ X8UvkTYt0/RlBkCaK55tB7SghwCFxQG36QM9yOc6KRGp1U/Et+GvfE23uzBlgAQRXcIPiap/O+/t gzQkSjNrglMgwkpAa1lGn5GRGcseHKvbM2Gd5Ek421Bw9DO+ZK8AB/GvwWlfMWNW0AJWOPpxVu52 GcvzW5qlcbrOg1bOspgmrfbRrrxL4ohECc1zMk4fZGwiYDMsXeZEPcKSCUNnz4lWMPn9iJAcVoDZ CkmcFgRkS8gp6fYaRy+HMHxK3uJo8/Tr68lwvrgdD+afEM/77h5MCvDTcDz6hCjf/WUP4Lw/HQHg +fWMEMT49t0+wKuryd/HcyI/p4LWOuQd5wmjKbnoX970J4vzaf9iuPjUvxxMxpcjmFVkGG0Fd2/+ 0I8vsSx+AN0SEcXJSsby2qhVp85GxIxptyJUe4U/Ks2foE9oT7DDnisJmDoKjGTGVpbOQ4UKGaDA mlWgcgdvCHi2kqZ+i6p6jJfFpld5uWHxeuMhmG8yRpekEF8VNFqPS56yMcR2UN2KJrlHnQszY0W5 c4EcuISna6mEKTxeg2vxJVpaV38m5I1jh73q1G2cJHF+tVrlvo6QK4FWJCt3ZIVpzi5ZoceGFwIR qZCPvWYAwLHeB6AiDsnNUx1GxBgFoeKNp0Eb6AlEIJ6UMs/sgykg1fY8ZmoRVvAExUkOcKRuG6sI hYUhqEMgqBVbEY3qYLEAetvDATkqHfyBx0uAiIugLUIceBUrZvFvLHBjU8cPQO2ehrzOGNQeGVuK KeAaxBRoBxEoDMKygS4XVI5I87ZDch6OfT6q0Q+BILMMSAeAqUiOdIqg2MR5h7T6abylqBL1vqXo kFNChaenRNSwUlamuI4CIEK2KR+whD7nOg9gKCSX5fYOlMdX0mxzYBU4pWSJoPi6S7Y5uWNgClBC b5ieRw2Fio3nmCWQmQpOOIBlSAEmNTWch2IiqJcmMuVcLQbDSf+X2eJ6OF38Mh5OBqj3970K3Hx8 Mby6mS9mw7Ory8EMU0rvyLAl/FQSh9UgjM6e84Jtw5SmHN8ESnACkIOJzhLGdgq2O3FQud5u8aha EydcCACN0AYAnTjBSjZQh5FAqsxMlYptk9NTJQutf82mX/OCd+BfaRX+UPBWLU7Aaf9dQj+D0TwQ E8xIkT0b/EQigzqLguNURNkhuoAO1RuD4zOJBBHBGKJ/lpVQ9y9NNUpY21mAheC+aQExJrqfZzQy EpdmacQLJrgigSs1EJuLyHZFYZw+8HsGLLNMuKpOUYEL32jvzqiR0TmPynycynRpqXMphF8O7y7R 6kuYD10BQYfNTEFiuBzEqxUA2kknjqF60LljkkE1X50YZG347VlwryZei+kD6Qr3B0/NOTwjEpKw FdSM6LFxTqLnKGGGf99qiAo7oUDooH2js+ekQwJQe9td81sz2Pak7MUdQdKIF5IsMbkDEIUMOBgw aPq8BTFZ1Rw2xifk0yqy6uNBTVMgRqMUfDAMWAtgUEzI4InyM9h+EAxAdJPeD7GO3wsVQrgrNjQV Qzuht7306JjjCub42L5DNRqBfWgKk+0mRYnoKzMCkLyOHxjIUQZiFZ8piYDECKlGb9mnHyv2Rn/4 klj7eU9KckJWU8jTfKEEvtH1n2UWc7+Y66yikxvM0G0ChBUoflXqM2SbalrFlgD7gY5X/7Zdd1Im UEGMrYfGrBDbQvxLMftky2D/DUT7MkksszJsR1pKhmc1V0tXFU6yS/Qqe6cztM2/Ql+to8FOzmSu ctLhj1dguFm8lH5Y6bIw2vobI4JhwaxVGLDX2I65Bryl90z1GooGVdZoATckEVP3u4hw/UATEa5Z MZoEbfmNWzxBu111bzM1R1xfOtclJtqw6H40GWYZz/IaAjPpNfLIH+lO7pPlbqrKGMg9Z0pESmB7 M20GDGWp6Xk9o9PKFy7ZJH3H4Qpop39eQGkwH/48X4ym/Y+L/nw+vLiez0Qf5QZ5h0nVM4ZxbpC6 LFpzc/u2Rs14oJYdTd0DTUqMQ6ZdDTWtl1fzxdnNdDq8nPtTaAERa1f4oW7JvZBazYXELKQ5E3Iz 5uqBqpjIy0IWRkkatC6gC9NziSoLW34honOcrAidvT9otVm1sIFX+6suiU7gSap8KO7dfKOVZgRz ul/pVTpEPyJ3I7BGwxrD0B20zilUw0tMNxCf4i252rF0NDEybFUE9/mo+XddG15t8v6QHF8uX/Hz kjDrVo4LqWJfmcYLRugFkIMu6QWASqMA0lsnnr1DqFF2iBFHLyK2Xs+TMt/Yd01zdJDTQRye/fjj ML2P3j2RycsC1o1d0VcVqw1DYfSV0ORWUwm41DNdi3qNQ73gTk2FkFviuNLAIgU1ofCbzXmAkt+n 9h3KfsBWtExMEPGPEICFXa4aQX8kUOjUNIQLIYt9BPLXGRQNy6sdhWJL1CIVmKs0jzLG0qaxGcWq QatfhOa2UxI0llnVAsuhFx8DxG2EacswpBYJzYNuB7eE1BGc2GcxT3JvZc9sw2sgG+WEZ0H36fz8 THw6Il20m+eKjlAYvBRCpdlTqwOgPPMTC7iHgE5uV7B0uQzMEh0PODwD/x9Ov6oa8Kger1Movads R8FUXfXVILEwmxlHvuBLppWpwb264eVit17tCkNWhS/YEziA0nQN3jMLb4c6sOgMJ3bGV5lIZfrr bMSfXDWSo//OOizyP848fIIP2ofTp3yFgRyIdrIlc1q3FyMEEvBTnMeOaCUENK7nPIvENiPkFZrE v4kdxhqCZZzvoGG1QVoUMGZYxNWErYHOpZPa4nwqcLKlX4/CslPZmsrWHvVOoHGGDjonMRRsNMX9 iUee3UPSZ7LLf5ReEOdi7+JBstPgje4elJtUdDV4Sjy665W9o46Dftpow18jZsdSGuXsdrz/P4k6 fL0sUofERplWCxq3WVeBym2mAzcJOgdTuiFpcg3ZU8r+EQoM10H+3CU/OMdOVnAgtkEsQk5OHvLn NLLlHCZn8FdRz0LFGXTbPa8uWyelSbw3Hr32pAk3bMwBkw7a66RDJJXhaLL4aTiFynUx+9QfDKcd sU8oJIj7C0G7Q1ryQClvdYzU9as3d3HaAoiEQsSGVMBaKrya7fL1F5MBEW90AWHxf0GIPTRTAvPO 1IIalAjeSJ4VZEdXo9Bb7Ie3HPvwxOrGOZ7ziBFvfFLEqxCaNBptfIpxLbu8x6v4Y4/3rIXYk72g FU8NAEjquw5x7uqEjxndiQQnTjb/+S/yu0q/Mu9CXv7cbqCTP6ZqjcAu3wBXKiDkwQU0xIs/hdxt bKJ9lPA7muDmI9DeDburw8QgJidiGAfBY0tR0VTONJV5jiazCSyW/gSg7AlWeofWKix1ctWfd+Qu Rod8r1/P5v35+GwxmPZv1XJ6lXBXFqvg5K0gtfltA/zxK+Gb8R+/En8jfA4RX+ir5lNG2v2iyOK7 EkxYz6pbpXt2b+NoNYqKTb1aEBXt7Rn0fpmq6ML3K9T+W/NXn5NZyMBGl7OrydV08fHm/HwIX+O5 S5ZnnDlzfUy1CjXLxNgsrDHYf2RITrzjxbY6R2m2V9cpHIM1GmAiKUkHrWpCMIy5Sxhy7nA9n477 l9AGg21Ox9eioP7+Rcy1FvCAfGqwkM7O+BYsiek9L3lskqF6ITgT0XNjCawzhDoaPD52uwh1ceDY nLLiNh7eHlDnT18u9Z5JwVsYkpcQPghFkD+JiwfOfos+hRNHchj72oEkBHWHsDqK2HsN+o2+3bB1 9uwtO5VT0G/di1BQzXUtDU1bHudm5l9Jixy7p9DH8OJEvHS2NiofOR/5cqbjY/V8wRq554/+hrfY jjKVDZAA+Q34FjY4YoWAChyp4/A3PosQKNI1zlO/cHaJ9wbFZPkysGm2UShmdvMhiX9PTG17x2kg 50BKo9k6d69KNNylJcz5fWoF3ACKZcqERzRpGDPbPN5tXqLKbPV06i7m7BHNxLaNBAp0OyrPIWVu FLoNPGTOdKiCV/G6zESpb1pUMf9Aq4xNsv1bmzWPCyiPW2Nx8qUuJbbcGODu8Yni7Ye/fSARENx8 R8Ip1wX0hGO4gfeOSYMzLmUdaO7RheIADCdfogiq/Tf6sIFtkwhvlI5TsIvUbvSZ/cLGfeID29xV 19FRS4tIbxLg8Z4rPbFjJClyX+9AD0FVzFChQY+GnUgtyKodBnkxynkv73qDV4qvU4ULJCQHjFuK W3vYKd1iK+rssEB0kJNDcWvAPGX6Np87+ZOdrO5DGfiC7+zDHS8Kvq1wJ25kKSI6GmE105o76kRu X+IzLPqF1o4jai/JQWx1BP4qAC3u8Amodp+lUE48GWEueGc7EAf6uTJbSeWksm2F86ucolTlxtOt ka2W8okr1ZMmqdrdKcWvlmyV9DcO4d7H01vgU1Klfy+Sl/fqdIkwx7soNEn4Yy6PinjO7BWL0PcY ScckhhyQqrtB3v8mOOcObryXIjgD1JhOnH9U8M+CdJf2BL7Ure4WVNsGx/Hs0YuxqIaNF62Z6tW9 z0f/AVBLBwg9RiUbVw4AAKEyAABQSwMECgAAAAAAlGytQgAAAAAAAAAAAAAAACkAEABqb2dsMi1p bnZva2UtYnVnL3NyYy90ZXN0L2FwcGxldC9zaGFkZXJzL1VYDACYV5JRqCSRUfUBFABQSwMEFAAI AAgAlGytQgAAAAAAAAAAAAAAADUAEABqb2dsMi1pbnZva2UtYnVnL3NyYy90ZXN0L2FwcGxldC9z aGFkZXJzL2xhbmRzY2FwZS5mcFVYDACYV5JRqCSRUfUBFADVWeuP27gR/yz9FTzki0TJsh6WvVtn AxxyuX5pL4dcCvRbIVtSpEQWHUn22nvY/70zQ1IPezePBmhRI2tT5MyQ85snlfmcvamyY9JlKWuL JM0acz5nRdft27/M5/f3956c7cTZ24rd/Fhm9/O/p/+M3jVsc2ZlXX4Q7POhrLIH0zzUZS6aHTtm 24iV77JWVIeuFPW6X8krkXSs/GslNkn1vtxlaxP3e91kdIILiWzGys/z0A8iJPpbuc3qNpPE5REG YrcTdct+7rqm3NBOs99EjdNZsy2TavZHkTTZz1X5KWOR57N/1HvR4D5KlIebt13WZIJ1RVJ/alkn QL74fMi6jKB4kWZ5WWfsj/dv3r15y0xzl3QR27E7hgOL+Z7vuwx+buTP0ndNNvnM+rVo6eLT4uYJ EuBTayRlwWxARqJVJG1hKeRqZpt/EneTdYemZnmTbDurLWurtvkiWsU3XryIoyCMQMCjqWXUomwz C8CVtjn1YuhxD+oAnWisE3D10zlOk3ycpnma4jm3AM5Z6Pk871fU+e7Y3jsxB77PPF4B6A4LAqDm e+9hQtpkLaJYniz9JzWtHUTAt93hMcDH3DvZl8ANnwk/7jviB0w0f+6dnxFyeQg69CAkCBbfd4hg NVEiWAXTQ+Teg8JaWRLwkBYzTUKfTJZqm4VTm4VP2yx8ymY0f/huw02WE1ieWGc9WtyMF4OLxe1o kewyXkzHize0aCg4EAMrcazNLLH5wTs51laOzo6VzDazrZPSPM64pgGfyEe1UEf8h0raDp6GW4gA CnJRxIT9fLIRh8cn4+QHMP/+OPlCbPyncfEdMaF2v3BFeZh8s7N0ntBwqBU4pD8cnTn4GPu+zxWO wLAm1HZ8zwGGcD2mDOPnKaMJZQCkz1EGE0p/GcZjyole+dz3biFHknKQv0O2C2UmD63AW7qzwAtd +bdEV7wAIPwRAMJvRyD8dgjCH8NAagEFsEmggly4vUFj2ufEsc5F64uMQKpP80CAU4oTo5tCb5Qw IHbKGjqAO39dvozXrHQcm1b+7F1YZj/gVRlwr3jxk6KGtXd+GKYSnNrw2jvNwYi+k4rOSt0U49ow NoyTSQby/d3T5uZ7SfM4QStYYFJJrsEK//toBYv/DVzh16FR2OyS/dBjyFgxVA8D59NuBnnvgaJL rbWtBAcA09RIXvC27Wfyos+xRWH302XRZ2Q1Xai8ydrPTWflBaS8vHBZuxOiK6DV21sxbOXS4d3C xugwkMcqCweo57TnWE3Iz9CGFiMPAC3Dr6sZaj3/HxXdCFGxj+B60Bq3cBStbPPW7RVvfnGZOHRD xXp/kRyLa5/v9JSBrs3Qtz+Cb7OPL4MQfxwHZBiDb8/nZW6x7lUIKRVaSZttoPf/hJ5qGr3vY8g1 b6GUdrz5ZW0iB+jyKpqyaJGEG/qpzIyGgfTFS0iwuDXsDZ0EKQOWXDP5RPh0zSHDnR/hr8Mg2iUn iNXAhXjhBckC5JS4GLdWgWpIkJVI/TiW+dh3PXlStdnI19qv2eACc9k4BN+Kevwl0INL0J9DvOcc 7P51hEldeSqCVLc8UIZg6LJgCdmlmHfkuBLwQmOsuLdVstsrcvRy1JvJaw8dc5tU29/g1plUo3AV QKxhGUVuJjHCSmr0Y96NbkMs27cyRUdW5uJ+Q6JWDXsjn2AArd2dTBSwoQOc3ul8tiG+9NxMzw0s 50uW8+maBecGlocrFmhor1jOultVuNWESfmQWTCa4LX7Pen6u2YH1/Pr/neJTsGpULGtaKGGLBy4 2q44kkMSevZyRNSRFyJ1IKmlf4wbfmyKlTExH6nDiTIFlcA1cDQ50QlBmwV0zcQ2+0P1r1+b5MNr SJQpwMvm49cQMIH7ESOa8nSWegTeKnblvcU0XpQ5XPnVfb9Pv+3rc4I1didSa7oHbHw1eXbx8kFf EvgXWZ2Wucq3I3Tvxq9CuBfE6nwRq8oPRRdQVdfGUggBOguEKAzlqwImc/vAFWovxRcKK39FePry /QI8EuiKHiwOXgL0veml0dfDepc0V+sOvU1BKimAXLfvItXc6QFOBpf/mGJcSiJCzcOp0dAQN6Kq KO4Cjo6Cv+Qj/VHuJ2BIeTMpayDaa93xjQiKBI9EcXIoA1aRHqbyGtG21vbe3e7tgeb4FM3B3d4P NE06NRIozkG2w1BDEAAIeEsOp3/KuxT+kNvQebcHLh1tDTkYvOqYIVZZk+Bbqa7IWIPmhfCmcYqK dqIB52RtVwJ6H4RIx+7W9x2HGro8RJ4SJnZ8TepKDyNQlPMrpUU1KR7yAXP4T6OOQJ7cBTmdzSYt qQECyJC3nCwBg5Xr3d668i4O3+CHEccwodSO5PIypOlv4EwrLKvQlIt7S53fZQvldFAuMiiTJpUS ndV7x5JlKR2VJZ2diWQoCVQKOlWj1PuIMg96nBgCpQLRJX57WmdGXOHABYrAEUALPvCHX+Rvi/4q QLUST/GKChBEEFZLIhi1Apjt5bl4iAKVKWVfJBFBGUcdDPhAq3KW6/zQYsMI7WeBoehgH9PPTGBp 9O3CYit8k6eiewSxtLnVcLzTgqQV2A49gDpUZdaAKmaMXxEgoWcjVy/dYLASiMMlixI0bejKpLHA Fxf2PPRVBSa3Yr0nqaYYhoh1sNI+FbteiDv5C/BBvKOjuj5vbHfUMWN+BJpbl8oxSZ0qOJHta9mh 60V0Fp9kKwCuZN9SkZnINrRounatRvcuzABtLe77CcgcLOgtQg4xavUhybo3iIbMxlAMY3zptNnh bTJQFpsoNLQ9IzkyOKGddeUogJE87yWjoBCPyNNXfKInQhEQ28kpqDOesrZ058m4GBba6TEQXYT4 Fpzxy0ZYaBssYdMl+tbKvmDqk2EfG5smzRmTOVd7Ieab4Ba+QjCidEJSfJweyVqSGxLWUnMH+F8A ZF58029zCrIr8tFmoe/2X0QeUqwpP0AGFcnqSihkephlp701w4xIuSHmHRwslhd3+b5+K3TEIw5k m+W3JtWr6AFpLu4tM66p1um2CUO776QOR9lKqRSyNo3BoekIEW1I/fzhiC9sjxDG5Gr4aPfDM9Yi ylOmcvihVMopJVgmL1kqKZnOrsdwbECw77uMvj+rRHMHAhaohDLso/lvUEsHCOAlr50oCQAABhsA AFBLAwQUAAgACACUbK1CAAAAAAAAAAAAAAAANQAQAGpvZ2wyLWludm9rZS1idWcvc3JjL3Rlc3Qv YXBwbGV0L3NoYWRlcnMvbGFuZHNjYXBlLnZwVVgMAJhXklGoJJFR9QEUAEssKSnKTCotSVUoS002 UsjMC0stKkmtsOYqy89MUchNzMzT0FSo5lJQSM+JD8gvzizJzM9TsAUpNtGAKdZRMNBRMNS05qoF AFBLBwh4ofNDSAAAAE4AAABQSwECFQMKAAAAAABCW65CAAAAAAAAAAAAAAAAEQAMAAAAAAAAAABA 7UEAAAAAam9nbDItaW52b2tlLWJ1Zy9VWAgAmFeSUYxXklFQSwECFQMUAAgACACUbK1CHi3yjOMA AADYAQAAGwAMAAAAAAAAAABApIE/AAAAam9nbDItaW52b2tlLWJ1Zy8uY2xhc3NwYXRoVVgIAHJW klGoJJFRUEsBAhUDFAAIAAgA4VquQmMw6D3CAAAAdwEAABkADAAAAAAAAAAAQKSBewEAAGpvZ2wy LWludm9rZS1idWcvLnByb2plY3RVWAgAl1eSUdVWklFQSwECFQMKAAAAAAA6X65CAAAAAAAAAAAA AAAACQAMAAAAAAAAAABA/UGUAgAAX19NQUNPU1gvVVgIAABfklEAX5JRUEsBAhUDCgAAAAAAOl+u QgAAAAAAAAAAAAAAABoADAAAAAAAAAAAQP1BywIAAF9fTUFDT1NYL2pvZ2wyLWludm9rZS1idWcv VVgIAABfklEAX5JRUEsBAhUDFAAIAAgA4VquQuKPO89jAAAAqwAAACQADAAAAAAAAAAAQKSBEwMA AF9fTUFDT1NYL2pvZ2wyLWludm9rZS1idWcvLl8ucHJvamVjdFVYCACXV5JR1VaSUVBLAQIVAwoA AAAAAJRsrUIAAAAAAAAAAAAAAAAbAAwAAAAAAAAAAEDtQdgDAABqb2dsMi1pbnZva2UtYnVnLy5z ZXR0aW5ncy9VWAgAl1eSUagkkVFQSwECFQMUAAgACACUbK1CsvvGP9wAAABpAgAANQAMAAAAAAAA AABApIEhBAAAam9nbDItaW52b2tlLWJ1Zy8uc2V0dGluZ3Mvb3JnLmVjbGlwc2UuamR0LmNvcmUu cHJlZnNVWAgAl1eSUagkkVFQSwECFQMKAAAAAAAkX65CAAAAAAAAAAAAAAAAFQAMAAAAAAAAAABA 7UFwBQAAam9nbDItaW52b2tlLWJ1Zy9saWIvVVgIAJhXklHUXpJRUEsBAhUDFAAIAAgAJF+uQmoA iG2yAAAABBgAAB4ADAAAAAAAAAAAQKSBswUAAGpvZ2wyLWludm9rZS1idWcvbGliLy5EU19TdG9y ZVVYCADUXpJR1F6SUVBLAQIVAwoAAAAAADpfrkIAAAAAAAAAAAAAAAAeAAwAAAAAAAAAAED9QcEG AABfX01BQ09TWC9qb2dsMi1pbnZva2UtYnVnL2xpYi9VWAgAAF+SUQBfklFQSwECFQMUAAgACAAk X65CvkOKICoAAABSAAAAKQAMAAAAAAAAAABApIENBwAAX19NQUNPU1gvam9nbDItaW52b2tlLWJ1 Zy9saWIvLl8uRFNfU3RvcmVVWAgA1F6SUdReklFQSwECFQMKAAAAAACUbK1CAAAAAAAAAAAAAAAA FQAMAAAAAAAAAABA7UGeBwAAam9nbDItaW52b2tlLWJ1Zy9zcmMvVVgIAJhXklGoJJFRUEsBAhUD CgAAAAAA9FquQgAAAAAAAAAAAAAAABoADAAAAAAAAAAAQO1B4QcAAGpvZ2wyLWludm9rZS1idWcv c3JjL3Rlc3QvVVgIAJhXklH7VpJRUEsBAhUDCgAAAAAA9FquQgAAAAAAAAAAAAAAACEADAAAAAAA AAAAQO1BKQgAAGpvZ2wyLWludm9rZS1idWcvc3JjL3Rlc3QvYXBwbGV0L1VYCACYV5JR+1aSUVBL AQIVAxQACAAIAHlRrkI9RiUbVw4AAKEyAAAvAAwAAAAAAAAAAECkgXgIAABqb2dsMi1pbnZva2Ut YnVnL3NyYy90ZXN0L2FwcGxldC9JbnZBcHBsZXQuamF2YVVYCAD/XpJRJUaSUVBLAQIVAwoAAAAA AJRsrUIAAAAAAAAAAAAAAAApAAwAAAAAAAAAAEDtQTwXAABqb2dsMi1pbnZva2UtYnVnL3NyYy90 ZXN0L2FwcGxldC9zaGFkZXJzL1VYCACYV5JRqCSRUVBLAQIVAxQACAAIAJRsrULgJa+dKAkAAAYb AAA1AAwAAAAAAAAAAECkgZMXAABqb2dsMi1pbnZva2UtYnVnL3NyYy90ZXN0L2FwcGxldC9zaGFk ZXJzL2xhbmRzY2FwZS5mcFVYCACYV5JRqCSRUVBLAQIVAxQACAAIAJRsrUJ4ofNDSAAAAE4AAAA1 AAwAAAAAAAAAAECkgS4hAABqb2dsMi1pbnZva2UtYnVnL3NyYy90ZXN0L2FwcGxldC9zaGFkZXJz L2xhbmRzY2FwZS52cFVYCACYV5JRqCSRUVBLBQYAAAAAEwATALYGAADpIQAAAAA=