Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S966750AbcLVTzp (ORCPT ); Thu, 22 Dec 2016 14:55:45 -0500 Received: from mga05.intel.com ([192.55.52.43]:36551 "EHLO mga05.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S966097AbcLVTzl (ORCPT ); Thu, 22 Dec 2016 14:55:41 -0500 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.33,390,1477983600"; d="gz'50?scan'50,208,50";a="46167503" Date: Fri, 23 Dec 2016 03:55:30 +0800 From: kbuild test robot To: Davidlohr Bueso Cc: kbuild-all@01.org, mingo@kernel.org, peterz@infradead.org, oleg@redhat.com, linux-kernel@vger.kernel.org, dave@stgolabs.net, Davidlohr Bueso Subject: Re: [PATCH 1/2] sched: Introduce rcuwait machinery Message-ID: <201612230319.WEHjJWcM%fengguang.wu@intel.com> MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="5vNYLRcllDrimb99" Content-Disposition: inline In-Reply-To: <1482426096-12792-2-git-send-email-dave@stgolabs.net> User-Agent: Mutt/1.5.23 (2014-03-12) X-SA-Exim-Connect-IP: X-SA-Exim-Mail-From: fengguang.wu@intel.com X-SA-Exim-Scanned: No (on bee); SAEximRunCond expanded to false Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Length: 27510 Lines: 464 --5vNYLRcllDrimb99 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Hi Davidlohr, [auto build test ERROR on tip/auto-latest] [also build test ERROR on v4.9 next-20161222] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system] url: https://github.com/0day-ci/linux/commits/Davidlohr-Bueso/sched-Introduce-rcuwait/20161223-020109 config: m68k-sun3_defconfig (attached as .config) compiler: m68k-linux-gcc (GCC) 4.9.0 reproduce: wget https://git.kernel.org/cgit/linux/kernel/git/wfg/lkp-tests.git/plain/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree make.cross ARCH=m68k Note: the linux-review/Davidlohr-Bueso/sched-Introduce-rcuwait/20161223-020109 HEAD 9e9d238f94d5aa8e348e7e70585533fe0dbd373b builds fine. It only hurts bisectibility. All error/warnings (new ones prefixed by >>): >> kernel/exit.c:285:29: warning: 'struct rcuwait' declared inside parameter list void rcuwait_trywake(struct rcuwait *w) ^ >> kernel/exit.c:285:29: warning: its scope is only this definition or declaration, which is probably not what you want In file included from include/linux/srcu.h:33:0, from include/linux/notifier.h:15, from include/linux/memory_hotplug.h:6, from include/linux/mmzone.h:751, from include/linux/gfp.h:5, from include/linux/mm.h:9, from kernel/exit.c:7: kernel/exit.c: In function 'rcuwait_trywake': >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/rcupdate.h:606:10: note: in definition of macro '__rcu_dereference_check' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/rcupdate.h:606:36: note: in definition of macro '__rcu_dereference_check' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ In file included from include/asm-generic/bug.h:4:0, from arch/m68k/include/asm/bug.h:28, from include/linux/bug.h:4, from include/linux/mmdebug.h:4, from include/linux/mm.h:8, from kernel/exit.c:7: >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/compiler.h:563:9: note: in definition of macro 'lockless_dereference' typeof(p) _________p1 = READ_ONCE(p); \ ^ include/linux/rcupdate.h:727:2: note: in expansion of macro '__rcu_dereference_check' __rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu) ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ In file included from include/asm-generic/bug.h:4:0, from arch/m68k/include/asm/bug.h:28, from include/linux/bug.h:4, from include/linux/mmdebug.h:4, from include/linux/mm.h:8, from kernel/exit.c:7: >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/compiler.h:305:17: note: in definition of macro '__READ_ONCE' union { typeof(x) __val; char __c[1]; } __u; \ ^ >> include/linux/compiler.h:563:26: note: in expansion of macro 'READ_ONCE' typeof(p) _________p1 = READ_ONCE(p); \ ^ >> include/linux/rcupdate.h:606:48: note: in expansion of macro 'lockless_dereference' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:727:2: note: in expansion of macro '__rcu_dereference_check' __rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu) ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/compiler.h:307:22: note: in definition of macro '__READ_ONCE' __read_once_size(&(x), __u.__c, sizeof(x)); \ ^ >> include/linux/compiler.h:563:26: note: in expansion of macro 'READ_ONCE' typeof(p) _________p1 = READ_ONCE(p); \ ^ >> include/linux/rcupdate.h:606:48: note: in expansion of macro 'lockless_dereference' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:727:2: note: in expansion of macro '__rcu_dereference_check' __rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu) ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/compiler.h:307:42: note: in definition of macro '__READ_ONCE' __read_once_size(&(x), __u.__c, sizeof(x)); \ ^ >> include/linux/compiler.h:563:26: note: in expansion of macro 'READ_ONCE' typeof(p) _________p1 = READ_ONCE(p); \ ^ >> include/linux/rcupdate.h:606:48: note: in expansion of macro 'lockless_dereference' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:727:2: note: in expansion of macro '__rcu_dereference_check' __rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu) ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/compiler.h:309:30: note: in definition of macro '__READ_ONCE' __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \ ^ >> include/linux/compiler.h:563:26: note: in expansion of macro 'READ_ONCE' typeof(p) _________p1 = READ_ONCE(p); \ ^ >> include/linux/rcupdate.h:606:48: note: in expansion of macro 'lockless_dereference' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:727:2: note: in expansion of macro '__rcu_dereference_check' __rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu) ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ >> kernel/exit.c:308:26: error: dereferencing pointer to incomplete type task = rcu_dereference(w->task); ^ include/linux/compiler.h:309:50: note: in definition of macro '__READ_ONCE' __read_once_size_nocheck(&(x), __u.__c, sizeof(x)); \ ^ >> include/linux/compiler.h:563:26: note: in expansion of macro 'READ_ONCE' typeof(p) _________p1 = READ_ONCE(p); \ ^ >> include/linux/rcupdate.h:606:48: note: in expansion of macro 'lockless_dereference' typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \ ^ include/linux/rcupdate.h:727:2: note: in expansion of macro '__rcu_dereference_check' __rcu_dereference_check((p), (c) || rcu_read_lock_held(), __rcu) ^ include/linux/rcupdate.h:786:28: note: in expansion of macro 'rcu_dereference_check' #define rcu_dereference(p) rcu_dereference_check(p, 0) ^ kernel/exit.c:308:9: note: in expansion of macro 'rcu_dereference' task = rcu_dereference(w->task); ^ In file included from include/asm-generic/bug.h:4:0, from arch/m68k/include/asm/bug.h:28, from include/linux/bug.h:4, from include/linux/mmdebug.h:4, from include/linux/mm.h:8, from kernel/exit.c:7: vim +308 kernel/exit.c 279 if (!sighand) 280 return NULL; 281 282 return task; 283 } 284 > 285 void rcuwait_trywake(struct rcuwait *w) 286 { 287 struct task_struct *task; 288 289 rcu_read_lock(); 290 291 /* 292 * Order condition vs @task, such that everything prior to the load 293 * of @task is visible. This is the condition as to why the user called 294 * rcuwait_trywake() in the first place. Pairs with set_current_state() 295 * barrier (A) in rcuwait_wait_event(). 296 * 297 * WAIT WAKE 298 * [S] tsk = current [S] cond = true 299 * MB (A) MB (B) 300 * [L] cond [L] tsk 301 */ 302 smp_rmb(); /* (B) */ 303 304 /* 305 * Avoid using task_rcu_dereference() magic as long as we are careful, 306 * see comment in rcuwait_wait_event() regarding ->exit_state. 307 */ > 308 task = rcu_dereference(w->task); 309 if (task) 310 wake_up_process(task); 311 rcu_read_unlock(); --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/pipermail/kbuild-all Intel Corporation --5vNYLRcllDrimb99 Content-Type: application/gzip Content-Disposition: attachment; filename=".config.gz" Content-Transfer-Encoding: base64 H4sICOosXFgAAy5jb25maWcAlDxdc9u2su/9FZr0PvTMnDaOnWrSe8cPIAhKOCIJBgBlOS8c xVFST2M7x5Lb5v76uwuSIkAupHNfbHF3sfha7Bc+fvzhxxl7OTw9bA/3d9uvX7/Pvuwed8/b w+7T7PP9193/zFI1K5WdiVTaX4A4v398+fv1w/zdH7O3v/z2y8VstXt+3H2d8afHz/dfXqDk /dPjDz/+wFWZyUVTzN+trr/3X/rGiKJZiFJoyRtTyTJX3MP3mOWNkIulnSI4y2WimRVNKnJ2 OxBYWYgmVzeNFmaAlqqRqlLaNgWrAnBasOH7gypFCFl+uH5zcdF/VQvLkhz4i7XIzfVlD09F 1v3KpbHXr15/vf/4+uHp08vX3f71f9UlgzZpkQtmxOtf7twAverLSv2+uVEaOw+j9eNs4Yb9 62y/O7x8G8Yv0WolykaVjSm8HshS2kaU64ZprLyQ9vrq2CyulTENV0Ulc3H96hVw7zEtrLHC 2Nn9fvb4dMAK+4IwGSxfC22kKq9f/bx/ebx6ReEaVls1NAaGgdW5bZbKWOzz9aufHp8ed/84 ljU3/uibW7OWFZ8A8D+3+QCvlJGbpnhfi1rQ0EmRtuuFKJS+bZi1jC8HZLZkZZp7rGojQJzg +zhArAYx90fGzQ3M1Wz/8nH/fX/YPQxz0wslTqVZqpuBMdN8idwN0FgUTZVlRth+rnlVv7bb /R+zw/3DbrZ9/DTbH7aH/Wx7d/f08ni4f/wyVGIlXzVQoGGcq7q0slwM9SQmbSqtuIBOA97G Mc36yu+nZWZlLLNm0lfN65mZ9hXqvW0A5zOBz0ZsKqEpWTIjYlcjFvFpA1bQnjxHES1USRJZ LYSjtJpxEeWDTYJZFE2ilCWpklrmaZPI8pKTeLlqf5BLBItnMN8ys9dv5t7aWmhVV4ZkyJeC ryolS4v6ySotCNa4dEwFPTP+uNXWNCXNFddMBAWyp2O4SqYxVClsDGWgD6lb+K6fNM2tyQyo g0oLDjo6pacIFTfR/SRfQdG1U206DVWdZgUwNqrW3Cm0nlXaLD5IT7UAIAHAZQDJP/iaHQCb DyO8Gn2/pWpH3QmT1+rGX778r69WeaMqWObyg2gypRtYEvCvYCWn5nlMbeBHoAwDjcZK0Ley VKlv15ZsLZpapm/m3oqvMl9uogtzVKwAzS1RXLwmgNIqYLm6tsCaDBqH83AE+zMPre4xRK2t 1kZVqL1+rIDY3BaBwPewhiVG5TWsY+gIKECC6ZE0AQvrBMvKtW8qNKw4z71Iak93ijyDOdUe ueOS1X6HM6h/Mxp3B2t4UW340udXqWCo5KJkeeYJsuu8DwBvorQ+AKaQGPMlmDNPHqQnrSxd SyP6Mt7A4oQ6o+yzBz4J01q6uR4EpUhEmoaL1VmCzrGrds+fn54fto93u5n4c/cIdoqBxeJo qXbP+8FErIu2R42zU8E849phFpwZbzJMzgLTa/I6obUKEDYZ6H50shoNNlwVMfVjwb1MmWUN eCoyk6CFZMSYgHHMZA7WlJIrsRG8F45jCTf587cJeF7ghS5KVIccDSzBwTkANwwGA5V0xTTM Uu9YfQ8UB1g9MA1aWcHBLhCsXLWFSluephIcO+bNqkrrHDwNmHIn07gMTmInfXKMl8wsaStj GCwcWI6VJFqnwJCCqJsaGlamV0PFHYJxO+4z+DLggIsMeiFRXMA1Iise2rYG770dqImQLrha //xxu4dw5Y9WXr89P0Hg0vpQg1/XdbFB+m7ugXmoqsKae+8O4gIQhaXQ0FbKzwHplGXmmxCI NlBF+ArbqRZT4MK+GE2NPzYtCK0Cx2iGpUSFHU1dIj5auEWTvQO6ThTpce/4gAN3dPcj49RT hp7SGN0bzohPJwtoLIhn2qxQl5OeQRAk5knKMm9oO78hMQsS2Hr4EyfDioWW9tYfwB6J4SA9 dEjBixTUhmgXtY6S3STTOKLaPh/uMT6e2e/fdp7qBF5WWjfU6RrdhmBiGWiicqAhq2RgXU9T KJPRFD2HAlbrQOEZGcu0pBAF4yTYpMpQCIxJUmlWsGKEZ+AK8LE2jakTogh4AFC5aTbv5hTH GkreMC0Ctsce52lxZkzMQp6hABOqY0PbM6nLoG2eJwM+4Bn+Iou0YLBp6/k7mr8nidPybeCq Zubu9x0mJHxLLVXrzZdK+TmFDpoK5vheP4wxPHs/jfpb4LFRPRh5E/3p0R3L61d3n/999OeZ Kd94tZaud5glcuoM4mCItH3X3OE1NLfDn8KRZW80xomRwj6yK33sJbojHwRlroui9kS7qFE8 PLPoXAtvSUCIitbDxep9eqD6uj2gy3XMBbXQ56e73X7/9OyUR5hh4zmDwIQHwgEGOJNkoAkl Li4vjrUd+Zpvu7v7z/d3M/UNldTeN6BYSwaWWxR0AN/rLUqEwckCM9AlZfiyLleBdkPTDOsX Pq1cAFUjSsy2UZETNACNOEtTNCjNMVruZ6Wq+14V27vf7x93R0U7VIdqju4C6jnakDE6T8DQ 5Vckal3QCYpldXVxQesikJMNiXn/9oJWO1d9b5OX/cy8fPv29Hzw+3pMUIELB25MzMPPdtvD y7NvjzKIpIKoAwENBqE4jaNkqgDN4KLICma5D1RDXwrFHAs6UUcSqj9VDp51Zd1yg5k212/D xGXrStLO/PK2lYrGth465UVAVMK9aG8twVGzCn3bQGmb4oTaKtATBYPlKrt+e/HbPBgGiFSd kK68oeO5gJXBQNuFCgTEHfOiRGUfKqVy0INH4g9JTfsjH64yWOY0ynmbKpLgSnM0GwvhUmmr URTkZEP8vbt7OWw/ft25fYCZiwEPnoyg11tYDCqCmHocNeF3k9ZFdRxDDEOWoJjBuaSmqWVr uJaVDbyzFoGSGIuSmKr9FGhbwAEfRsAC9M0AxDZiE32htsEHSO4CVU6/4Mrd4a+n5z8gypg9 HZXl0ZnjK794+w0qji2GKtFzCf2YEcEm054Q4Re44Qvlj4gD1jEn1GHBq2pASUlOZdwcBahD 3E+Z8MXsMMTbklOT5CggsoVVObQYh2klAo+6A/WVEJxkO9JeTrPVJZwZOncLBL2taTRMLWmE gcjhmtYw+tnEqqnKavzdpEs+BaLWmkI109VINio5GgZZLVDqwVhuxojG1mUpcoJ+AJnbEmRS rWSwl+Xo1laGReuUZpmpegIYqvf44gw0bOn7XQAQphpBxtPtgE4QxtU7DAlsJQ7NCOid0uDO XJziNINEiHHZcAG1reAVBcZB68CDYCFCsxuHoEWvrwRm1litbkkqrBJ+nnSJjjS8TvxcTq8i ezy4xy8f7+9ehdyL9FdDbk6AeMy9nsJXt0TAvRRZuMx6nLPJkZUGNG2mGvVAk5LpCByU+UR+ 5lMBmg8SFFZRyGoe6UwjczbmEhW5eQR6VujmZ6RuPhW7QCZ8vBvTLr0/ST76PQsWsoMYaSdj A7BmrslxR3SJfrNzqOxtJXxVtSZGA4GBnnGQQFH0kKHwaK56P89tiMe2pZDQDUQcb8Ri3uQ3 bTVnyJYx/xvGHrfQgYoXTK+IUcIVW9mqswPZ2Di50uA8utw8WLyiohPCQJrJ3IaJ8yMQlm1S nyzmp3V6R0TLFPyvgfNDtzf89LxD9wKcrsPuOXasYuA8OCYTFPyCQHYVmIEQ1W4an8C3e+8n CHLl6dYSd1TK0vmUARR3TduNXV+iOgSwSsWaGj6PXYMT7HXSR2G+LvDhAyxG1pEMc0Dn9i7+ Azq3nV/TzsmE0MnUua65xNWkAxZbDvFJynmMQ08SLGofYbjvwPgYsIAQbonIiLKClSmjJ7bJ bBXBLK8uryIoqXkEk2jFUnT3IngQj0Qq3ASPEJiyiDWoqqJtNawUMZSMFbJt30fz1K2FqEQc KSjZGehKFg5BiSE3RJW+1ujA8TkcsJO5RxQxsQgeTynCxjOGsPHIIMxShSGeklrQugW8W2jh 5jYo1NoTAtRGCAS8VRs+BrzWjV2mOoQVwrJwzqB59BTAeNfFQpQhg6AX8G3QT0zwMMoUjrto o9LtZmgIHGlN2x3hCtvNzPsQ4gY1BLUyE/RNJf8CZy/Sv7E+dyBl2biif4lxr1vYZDZst7cb wsbD0KR1RU5YDJ7dpFP4UYI2R2lxJnPj0hT72d3Tw8f7x92nWXcEjzKXG9taEpKrW+kn0Mb1 PajzsH3+sjvEqrJML0Aq3PEfUxcRtj1V76OcpjrdxJ6KXHkDPjW8Ok2xzM/gzzcCs0zu0MNp snAxEAQnagp1JlG2xKMsZ7paZmebUGZRT8gjUmPPhyDCPIgwZ1p9Sn0OVFacaZAd61mKBs/S nSHhVWHMWRqIeiAqdhYiWCIP28Pd7ydWo+VLl051IQxdSUuEJ5xO4XleGxuVto4GvFDw887Q lGVya0WsywNVu+V4lmqk3GmqE1I+EPUCRgQhAx15VoogRM/yZI2gft1hv9NEcVXSEghensab 0+XRmJwfwqXIqzNzH1VpLZrIZ05JNCsXp6U0v7SnmeSiXNjlaZKz3YWQ+Az+jDS1kXyQCyGo yiwWIR5JlDm9KtVNeWZe2gT1aZLlrYk6Az3Nyp5VIWNnZ0pxWj93NILlMWPeU/BzWsb55ycJ LOblz1G43NwZKo2Hxk+RnNTwHQkY8pME9dWln0fqnKXgGyg315e/zkfQRKKNbvzYYowJxD1E jvJ51dEPpxh28HB1hLhT/BAX54rYcpQeHFXL6c2KIw3VT4cAvgN7Gh9FnMLFewtImQW+QYd1 xzDNpJ/r6V0CWf33f5DKyjDtrZnL+L2NpQ9alB9WG+W21RBDx9N9/Djiiu44k2Wf/Z5g+0Bn gsBYZdoOiFVkcr4VuGk0Dogm/cVs2JgQYRPCSBvbuD3SXwrngBho1kKzlBoNRJKDBA4qzQ7T MXjeUU7TB3S2ymHGiRoEhukkEDGAy2qcKWjhnRu5pOGBC+IjdHXMvhJYa/MxgiY/uu1h3Bwg p2mPFh2EMEGJYWIiBOPgZtSYcQzRdw2P40QKdS60jDElBrIPAKZjpdnNGATSTc8fi80EIIYm d1rlz/n/V6/MA+EK9Mo8qleoXalAr8ypdXbUK/PxkunX7AjRqYJRO456JdIKrxSlF0J4p0Tm kyUW6wSFI5TFqGyvLCY975RFsDk5jy3neWw9ewhRy/nbCA7nPILCEDWCWuYRBLa7Pa4SIShi jaRE2kfbCYLIvXSYCKeo4vGxlOaZ06pgTqzbOaGlfPa0mvIpyorM4LZbYKGsdNtiXdJ2ipim JtsreSNW/e5a1ohkLGEdDhC491DbaTFE2cmQB8hgPDzMu4vL5orEsEL5XriP8U2+B5cx8JyE j4JGDxO6ux5iEjJ5OGPp6tc5K2Pd0KLKb0lkGhswbFtDo6YWzG9ejGGQy/PgoywfWJcw/9Ge 7uDDgRFnbNzuG+cy3U/sjO/8unJIdjndDCbpriKBAA83mPC7SZMFZvU5ff/EUfRnsd2hIbdh jqdEgutVMTqzZG8iNz4jJUpVkgc4kX7aghgW6x2dQmprDI7r6NQEHxiq+gOEoPiIQ7AWOblr qVOeXepmuEAA382amipicUyETi7AETZ4Dj64s+1OKjpZM8yfIFxXqD7evCdbnILrJchL+zkP 2pzzy4j0bYjSzLI8SCjiBRhWVblABH2w8PJXEp6zir7AVy0V3fR5rm4qX5t0gKZcchLoDl7R GLT6YWbXxy5VRSNCr8THFCqROd4QIrFoOIKsio+sU6K2BSDEBox7qunmLE6VlLwgW+pzpQfH pwhdI4qiN4iD2AghUCp/fUvvb7tlu4zcl0p5Qkx7Whq8Bq/wOQn/ihwEM+4ClF/9AO1/UidF fCr/9qMHT5kl4SUnwYU7keAtT1WJcm1uJHhu9IH/Nm6gTsv2u/+hZiuqfHS6EyHNwqiQZipq Dgqe8+SI1tLQR4HdJLmmRw7aYFbnCh259jTTenyGt+SGvhlh3GF9t0ng7t1GmOsNHrO/bcIr 0sn7fHSeenbY7Q+jq5vuCNfKLgR99H/JCnA9JX2EkTO6kNQpfQckoc/1MHCKN7qisneAWnEv GWysFqzobgf6k3Mj8SmYyDXIG1kw+vKHzlYycv0SR+Y3+iUGzmRGI0SF2wu0oi4zqof9KT3v BmYH6d4c6Je1ATehu+fgtRDEKTyFVrBbdx15QLSe1u7P+7vdLH2+/7O9rDY8i3N/14Gpm0l1 e+m83f8hr26sbVFlxj9l20JAxdelpxWMxcMxORgr/wmBln0mdeFuGrq3Q7yLMTfunm54MvBI DJH0SujRCceOCDSuZkfS4JmeI9P2HY+2a03G8jwZ3YHuhTDHp4/QdHtXGQYvCOxCwyAKBPup 5dodB1YJfTjT3JpmCSGBXktDXkc/vsRU1VihHD1XgrelwbODRuAzKVk4I8e7Sp/cXHtbwvCv dBfg/RVTWNqqKFq0YclhNpu8QLwaa7X+rm9Z5zl+RO/xtoN6Q7xLMyLKg8uUPtRdGHLngK7f jfFc31ZWubIPY1yqkzRwzeC76a5PlhgG08eLj11zpUdAzYppIwHYte/NnMK5F0r8y0481apA rczTtVdJAO7m30CfB+0TENw4bUE7pY1CORVun3QyH8v47WzX5ITGl+tCdCmJiVQW9/s7TyyH 9SBKWAcGNz2u8vXFJXUUG9ZbcetuiHptFSXPlalBCRhcTDxyWNrA+NKK+nIszO21LAFrt5jt p5f9Wkzz2xXfzCfF7O7v7X4mH/eH55cH94bH/vft8+7T7PC8fdwjq9lXvC75CYbh/hv+7BUw wxzrdpZVCzb7fP/88BcUm316+uvx69O2P2nV08rHw+7rrJDcLfJWZfc4w8EiTcFrVRHQgdHy aX+IIvn2+RNVTZT+6dtw2fWwPexmxfZx+2WHIzL7iStT/GNsf7B9R3bDWPNlxOHY5O6thyiS ZXWvhFVFOYsuPJRpcCFLhhcmu46CS9YKrCcNvVQBEu8jeI9SMJnig2jaC6eRKkwRQKnRPdEQ eeqka1vn+z5jQCYIgAKPYzfZ8SKd60bX/tnh+7fd7CeQwT/+OTtsv+3+OePpzyDU//BuHXZr 3Hh940vdwrzop4cp40OPpfVUCRrdgKVPlSYYBxeFjtAwEvA7Cb/RmbBmMry5WixGdwxCAsMx AkFjTU+57RfsfjTdppLdBI/rzHiLiLVWur+EcDQGL1t38FEzGerEBP6d6IquTlcMTot7UtFL Azm4DfJyDoR38drnpyZNid2+wAvSERmnQziHUyZ1j35JRj/HU6RT0Sk8G1ikDb4ewHQAwuV3 MYG8mUKmRG9/DXaGiv6yNbN0L4rOR6BvpwG22+OjTWjMJB99ksJ5wBCQTochLQJvpYhoA58i NneumkyqEUNH3r4Hg5sXbAFqFD/oWzvIROLTCuDKekkmfBUEH7aBQQDHHqPWAOc8sgBiSlaZ pQqBdglOHSgz8JPBDWvjc7+psYEElNBhjYXUOvR8AYi7Guj9uzcOaD4oHQGjD0KrkHMvKeOJ 6eHNezq0DGgiN3HdfNBv+QGqDcvC0AAvb68ELZiAxTe7ImKLszDJvYSD5Z7r8BTY8by0f9zA 8qKR7XtCAQyfg5IqhFVOd/ipVfDSE3cNZOJDDqa6VWATgiEgHoImL0ge35pPVJlGhBqdzaGh 4n3NcnDPwxN2EPKxYgrprjASF24CAg2hADjqiSyjFO4RthgWH2pYCxyp0dFRjwbj24TleCnO zwzwcHcJATY84RASrDfBJwana4/hwk/TAzMjwqNyaKdVLihYk96WrPAv57rTUn7+ymWmlHuz tLQafoRZAFtHnjGty2btJt09Vku+dLIeRT5lXhDP+/xfY0/S3Max8/37FayckqrPiUhRFHXw oWch2eZsnoWLLlOyxFisWKKKpOpF//4B3bP0gqZeVRybAHqdXgA0FqHl6Tn4J511DfbA7e9/ vGMo5+I/+/Pj84AdH5/3590jhvtQyNu1VC5QWWFEPpBMUQ3fyscdJgLqaiqoliBm96Q8qtEo tyfez3IBqNFg4ILazL1Q8sGh73T87KrMPyep4HiluVrxGVgQJo54skHi2OdK9eG9v+Cki15P g/HGInJe+XR0s9nos1IDbDpxzHPMcmCZ3BrBloz7ucOzVqFKWFmEMa3bVclCWN9J6ohpoxDi aYSaks/octioLt5RJUOdulun3VAVLIZZo3lqlSwM6ac1labEeaNlO5XMsbVVkm0CAt720yGu uHtlNiRrfu9ahtliayhzW0SmnHzwA4Ov6ebtCATuLNKMjBHYeTorsDjLtFchAUMGwRQHe3yq VVvqLae6lTxWJ2QeHSRUlqX6BFdEqlFEEanvhIjrgg2qTpMCUcC+KQ2YuInwX5NWHEV1w5fT /mk3qAqvk0txfLvdE4bEPxwFpn2vYE8Pb2iDRuhj1hGzT+zwVUTUWe9R3f+7HUXmj8H5ANS7 wfm5peqP6b5q17NGERAx4F7f3s9OTQFPskoPwIKAejbDQE/O5wpJhHef8aBkUBTiGWQZM/qV QhLFDEPsmUSi79Vpd/yF8dH3GGv27wdNZ9yUTjF2pFDuknBg41i1cWILOCXDpN58HV6Nxpdp tl9vJ1Oz89/SLf2mJtHhSnotGKXClSH2KF/KegfRSgL77KUs1+JDtjAQtpcO1WdHEi0/JUnC demIs9XR4Gso8qz08ujIijJdszUpIvQ0VQJdIsezMcdjfx+1nADA9x4RRSQO5CnOtCdTCZcG D2nleNuVRJ4f39zd0s/gkmJVbDYbRp/nTQeAqcwwqFKNp4h7T8CyQr8OWtMmSYRZm0MIkQQ4 Hrl2L+0+kFjoh8eYj4VcYq3TxcPxSaiB+V/pwFRFwQwrsXDFT/y/8DNQ9TACAXeX8bkMgpyt L2AZXlTM/OIGEWBjlwaiqSb3HaumksNR1sucxSGpmPefH44Pj3gXWI9bZakkKlkpl1Araoi4 NJEIF1OolC2BYjy0tmFA14MxwFmg2RthbLG7aZ2VW00zGIVz5m8F2Dk1LEJbL/ksmjveVOp5 QXN7wrEUgz9S/AGcijK+YM9ph6slgGyl5+64f/hF3YJND4FXvrJKJYfXLwJxksXFNU5c0k0d FfAGGErh0kwUvp9sHHkPJEWzHL+VbI4V/g+kn5I5hBuexbyW2Uxo7hgWxIVA6fn13YQ+x0T8 K/E8QX9TH/5k9kfiI5+aXe7Ir1FkDmuSzCGKLHTzExm3NCtsdgaAOptKWAe2K7fMBPlHX93j r718G7OHgjX5kYhXvhQ+7STT29FEgQwwSJWfZ7q1Std8k3npcFR7ILFlBp07PP5DjBiGMbyZ TqF2qdVS+cxGPEAOKnFFO1IYzoenJxGeGjaMaO30pxZNFPrtshxZ0yakWbrG4EcrRyISgQUm wiXcCHxRweVMawUXa2eqmEWYx4wWf9dofR+kNv8Vv/867/9+f30UIbobjpk4eOJZYF2MfZ9K DIpdcP+aRGPZZRhnjqidiI7LyfXdrRNdxDdX9Gwzb3NzdeXumii9xUC7TnTJaxZfX99s6rLw WUBvX0EYO0yu8nBeRebbSV80DDgTn5S6Q+fHh7fn/aO1/JmfDX5n70/7w8A/dPGK/7AssgXx 7Pjwshv8eP/7b7iLA/Munmk5JzpDHegWxWjOvDbItmLx42GgByOWGAADx2wBSjxercKCHLlK 6MMfEL8jtHq/ROOn2Ra6TXOaDQ2P2Tz0In6xohwFJL4J0aAwqTHogYsaDYM+6xrSfNY1pPm0 azNYwnye1CHwMg5Zt+1S6ki5hPjVnLkOLEDHzEcFgLM4KrAjTEPnrADVB9I4y1lJySMx0pKK sast1eeWqyZOHKiowvXjHOkwGF6D7OHCcy+u55tyfOOIPQ0kGA65cpyYONaLGkCcLXxVKBah 4ywHClal9XJ4d+XsZcHhXKQb6L5FHfnBxV0E31w4ztsM+uH1dPglTFzefj18NNNsX6jSmsfi sjUwRlevYmDWp1c0Pk/XxdfRTXdm5CA2SHsopeZ+7DYa2BbMCIOPlzHL6euPKpanpSvsZJTO FckMf+FLdbWBdZzQCJhLNVWUgvGjqhyNxppEh69GtqwI56o1xQuu2bXBTzS9Bo54K8xnMTwG 0X8gQ8+0XrAhqmmsE20pAkPbA1uD3bHePbAgG4unDaM65ucV5TUhcKgzsApUGBvCUcILo6X6 poYwHxiVfGvCOPzamnX74vJ01O1vhdrTLAMzNk+TnDsskpAkjOEUpS0qBToK/ZRylhHIewz4 bH2D2OMOcVHgZzktliAS6nPrYQTB1j2UNYhVKS2iiYa3uTsfFBJwfApyYss1TxaM2lmy4wkm Oij1EJeIiXzByDrrjcIkXaWOamHPcWpltvA6+OauuKWBHxk9LR2JYwUgPq9iLwozFowuUc3v xleX8Gu4GqKLKw2YAu4LNdkFku0sMhJVqWh8uynSWanvJzjf4GyxF6p4wLi82uCWCWklHGIz lqCgEaUXVnuGjlTbhL70BAFsdrjU3PiI4etyYkRi12lyp/8AogvGLw3j0vuZwGdhGDjt/gRF iR8XTl4HNyVoqiSLKjc+d8n+uHNRiQlCFc0Aidrxeedbur3YRMlXtNAikMBJhg4/JoFf5FVR Sh8ZJ1GFV1SdFbTwJ88o36GVQeyGJ7G7i2jfc3GA99sArqwLJ5w0Z64XjlR74gqLSLvUqvDq dOHzGplZYDQka67cxoBv+DId2KVeW/ialt9QgMv3HoBRpgwIz54/TpiiehA9fKCW1eaSsbVs QfNKSZoJ/MYPOf1ihdg5C1yGPYiuooyjIxNNsKbnNI4dUjRcvE4VfxKu4V4I6JZk1kEu3ROJ T5WXfq1lPUOAiC6pgxZ+mRZbGtj4dnz97Xh+vPpNJcAsi7AQ9FIN0CjVKwVK39bDiU8HGPJx D0vwpJw1Np8fFrxJmGSCDTcPFV5XPMT8RbSMI7qYr6zU2J1+E3tqLEvUYzrAqHJzlOrSO+k4 qydBMRxNJxc7CyQ3Q1oZpJLc0MeRQjKZ3tQzFnOHok2hvB3Tjy09yWh85VAuNyRFuRzelmx6 kSgeT8tPRo8k17Qvskpyc3eZpIgno08G5X0fT68uk+TZje/Qy7Ukq+urkf1UcXj9ghEb9cVg lGzEmla7i1JMsXtFNwZifQUxA6FQyUvTi2hoT4GmjvSxUm0CXmSGRWd/vjkUfiKPknwzsCOA rfZH6IXZw3j/eDycDn+fB4uPt93xy2rw8313OpMPNCUz7eX1N8jibf8qNOOUopbxyEtpvoin MjkbrYnMdy+H8w69Rcy+528vp5/Wjk/9we+FSJk+SF8H/vP+7Y/BqU2nZriUeMfDw9Pj4WVQ HMj9D4zShrsdg6AtYGRIVIYWuatZ7rBzCjdo3Oi6jFKHloE7vnu2pqRClsc1sPEY6a9O8q9D pZ5MRHt33J7iFUAxpKQVHrEt2eOFr+ar74hbR0UXR4APIdmG1aNpEuMDE31La1TAA9CHgOfH 9TJNmKBwt4hioO+whYl9mx1SUy+/HF735wNpaZQze+Ox16fjYf+kkjE06uVu1zjHcivt5z7h DKYp36nsc4LKGlJ7+Vmv5MIxaMHyQLjDfrhf1WUXMCeZ/Oiqdr/Afc0071dY9SC40qsOcNcG rseMa5XxEAA04cCU7Vin0QZSN1nOmU+zGC1VEfqV09JdEIWJ8EJwJg1FGte75jcv0PqGv53E 6ATtGU7becgxe3hR6742HVhEM3ds4oZEfEtnYiGlgXqDDkLUKKz2v306v98+m1skcAeLEcUv Zz0z+4QQEVKWrHDzaY+RwqHHRhTsBHoBbC4OZD4rzBXfYDATykiOwYDU6cj3CHDngqJE1+4a klTSKQcE42WU0h1S6Rw70SvlgqBPJx7ZQ+rPmZG7JM4TozS46qdRNzlyA7NC39sS1rgd0V6b Ip1444nUVyeSbZSY9ZTGQ6X9Tu8nf1Z0D4wNJDABXALE51HqYyadjHes/+zikaBRei5CvCrD zXIAN4S4/lzOipLCda5IbJMjoy+DqRdXNJMscZQRlqjLL5XPxKoynRVjbSHPxNmsAHy0DuwX NLCnwNka+7eHdsHGavjLurX8hyaCvbKwLAcviRYOq38Fq0BcUdYNxYv0bjK50q6Wb2nEVa+L eyBS8VUw00aGv5Oos1wJ0uKvGSv/Skq6yRkmeFGKy/zcKmRlkuDvPvJXEGKq0K/j61sKz1N/ gVa+5dff9qfDdHpz92WoxrJQSKtyRgt9SWltYcktnHbvTweRgNQaVu9IrAKWjSeVCkObB3X5 CKDIfhqnCS9Vj1+B8hc8CvJQUW5hEA+1KUMp0cYX6cYjw4tcPvsljXX/9bq4ag771BMdJXaF /Gumf0g05hRnDepjwljpYioC11sXGAusiW8xM6PuUBxUNAjkh6IQgppiqmiUh9+ouzQ60EM/ mS4vdJ/ynhtll2rnD+QrtXvF94oVCwoiD28rg6+OlocH0U5HFuA7WtZkwyYraijEswTNi1OU 6MxqpHywC7jYrI7gXlMYduDofkxCU3IAm/vLvRgLP2F0F8aIIpdpw9gLg4BOKN7NfBPzTX4c GabkWtFMbFwfP+aYcFffORJSe7hohG67Hk48jqFWgnCjupOksbmyMwPwPdmMbdDE2n0N0M3J 5U1btDhZlCmZ3x02/0q/MKyWJUT6zNLaHqpf7WndmBKSB00i29J+r0bG72vNt01AzI2vIrUg 48Ckr3UJT9LUQ6J4jpZXyawwyZFZaCygg4SM2dYQyfBNSKQNIdB6FNgjCoghGXgqYPxcGE1n aHWurDhkHM2fOCvapDb5FVVHwjzzzd/1XM3z0MCaCW3nLEM/WSSsl7l3o8VbkPTuBSvCi9Hn LddXIP4W4ha9uAV6HbJlna1FPgI3VZX5zOEPKfDuK1agLwxGoP+HForYoRdK/MwxG2nAzKvY dVglWpzAqGjZKY3fUtAtw1YDw6YX7DC3gHmhMbc3Dsz05sqJGTkx7tpcPZhOnO1Mhk6MsweT aydm7MQ4ez2ZODF3DszdtavMnXNG765d47kbu9qZ3hrjASkCV0c9dRQYjpztA8qYalb4nNP1 D/VF1oJHNPU1DXb0/YYGT2jwLQ2+c/Tb0ZWhoy9DozPLlE/rnIBVOgyDHcNFrsYpaMF+GOnZ ezo4iOaVGsyjw+QpKzlZ1zbnUUTVNmchDQfxfGmDOfSKJQGBSCotK5U6NrJLZZUvuZYJEhAo BPaQINKDxkRETBghCi53x9fdr8Hzw+M/MkCogL4d96/nf8Rr69PL7vSTevUSGg2Ze5WWo4Th ZJTORSyi7nTthF0p2xAU49aw9OUNBNQv5/3LbvD4vHv85yQ69CjhR6VPrVCSoO+eUK9AZRlI DqxUOcwGH1dFkztSUfGgzacoKT1WFT19ztGJOgb2L3ZYKCTo0Ip4L41oEkpH13K5IgdC0XXI KFPIeIQogor0BjR3bxDJKUiTiDJjEPZgyMzm31WVWgfs1Apyur5e/Ts0O2UH35Tvj7uXw/Fj EOx+vP/8aYSbFedfuCnRnM+hfhckWYpRhRwxWqRGVLypiWBSnaoGWxxEh8d/3t/kIlk8vP7U VyvsJR+mpE5pTaOGr1csqmDkOrLJMgzgfuIxRLNbIy87jOWWYWjmQBe9wz73Ezb4/dQ8u57+ f/Dyft79u4N/7M6Pf/75pxKsTcTwaGI2VfNVmHtpoZpU2xj5xOpXjm+Tp1AhosnFJZzNEY0f J3GZaYHQVGJYRtLQI39/Fdu4tOMQszKNuT8ZwyKOZmbhlka8sGNcpomovz/nRAzWRbgRsVl1 qMzP1joSGMglYMt0Y0DFkTYzgDIfmgGsKjVGlADlyE4L72Gze1rWXgGKlrFZYSGszbOt2Xpm 9qcLbWtUIIJGWXMAt5qP1r8aT4zrA5Y6xuhCt6a8cr+JFQydBxwGU7k4apISbh+vwCDtqQj8 Sp+SSEGrmUCYhDXGKCfVx/fj/vxhH/ViRKp6vY88Bij88A69lXwXCIVFtNPLvg4wp00ozZpd frzyQawO4B4T7+yw3BwuPBcfz1okfTngTsfH2zCBLuMawSUi4hL7TNOwtod23y/mu7EYFrlB bdJcPsEoW0TuNz3El4TB4eura1RCN2lugrLvJkRuX7iUUyXfpIzT2z1LHz/ezge44Y+7weE4 eN79ehMBQjViGP2cZVxx91bBIxsOF6zZoADapF609Hm2UKN+mRi7kNjeFNAmzdVw8z2MJOzY Iavrzp4wV++XWWZTL9VQNm0NqP8kulMwizRYWKDQJ4BNPEGrzgZuN1YVxAjaqIQBLwQPh6db YRWdz4ajaVxFVnE8lUig3Tyq4GRSahMj/rKXUuyAs6pchGronQbeXGDSnOT9/LyDq/HxAaOJ ha+PuAHQ7uM/+/PzgJ1Oh8e9QAUP5wdrI/hqgPx2CgiYv2Dw3+gqS6Pt8PrqxiIowu/c2pQY jZcBl7VqO+sJe7CXw5MWYbxpwrMH6pf2d/TVRGFdO54Fi/K1BcuoRjZEhXCCr3PWJcxePJye Xd3WEoO2e5cCbqjGV5JS8qD7n8Dc2C3k/vXIV68qFUE+oLTocngV8Jm9yHV+op0c17eNgzEB I+g4fG6QwmJujzOPA9hYJFjVKvXg0c2EAl+PbGqRr4gAUlUA+GY4osDX9jab58M7m3adyRrk fbN/e9YMQ7vbwT5bWFJ53F5rwAPZ8wv36XrGia/UIlqtsrU9QAqNIm6fthhX0l2oKO3viVB7 BoPQHsLMCM3a7qIFuyduzoJFBSO+Y3vIEIdLSNQS5pmWVag7HO2xl+uUnMwG3k9LpzY47k4n LWllN3ojLlt72tynFmw6thcPPtsRsEV3COQgex5eBsn7y4/dUSbZMNJndqsJw1lnFEMQ5B4K uUlFY8TpZC5OiaEYEYHBk5hCWC184+guGqK1qMrlKTdzjayXC1GTR1OHLVz8SUdBzUeHbBg5 8yBd0KGMgOmM0btaij815uOzrUp2xzOaEsMVexIx6E77n68PIoqnUDgZoqrHE5ZvGynRFuX3 P44Px4/B8fAOMq7mdCE4X5UjBpkSE6DkeqAtwe0LoarHU49ZjQUuSBwJMOP1DPMT6BZLKkkU Jg4sxkKsSq6+g3TWvT7vTD4NlBOsLjEfs/GV2v72VZ9npLDvN6ilrGq91PVIvzwBcElV0BBE 3A+97ZQoKjG0J0VDwvI1c7zfSgrPEWIBsLdEnyLuNWyAtnp92miHVQEv5TJAbpyVlPe1YqSM 4YguzwkcZV0Ax35uESoNHnQ4miygSkuclB8a1Do/4eAkakaoUnP/wHo/JqnhAKXhZC2bewSb v+vNdGLBhGV4ZtNyNhlbQJbHFKxcVLFnIVApZtfr+d8smK6v6gdUz++5so0UhAeIEYmJ7mNG Ijb3DvrUAVeGX4bAQ4e43ihYvdQVax3ci0nwrFDgrChSnzMMWw1TmTPFghI9F+EkCZU5D76r oXwjfF62j5lWXaisqrxqrIj6YyO6xzh+2u5P88CxhYKA1mjy/LuIxUnp0DOOhj1dgyk62oZz Duetcm3O0qRUnDd72z2Ak9auSD/9d6o8S0jIUAtaXKBO1ojy0qOyNI1U6s5PFHBCoKOKNTrO j//7L77jYbu4tAAA --5vNYLRcllDrimb99--