From endofunctor@yahoo.com Thu Feb 2 22:14:21 2006 From: endofunctor@yahoo.com (Lee Perry) Date: Thu, 2 Feb 2006 14:14:21 -0800 (PST) Subject: [MLton] x86-64 port Message-ID: <20060202221421.84828.qmail@web35707.mail.mud.yahoo.com> --0-151450105-1138918461=:81599 Content-Type: text/plain; charset=iso-8859-1 Content-Transfer-Encoding: 8bit Can the x86-64 port of MLton be compiled from full 64-bit mode or does it have to be bootstrapped by cross-compiling from 64-bit mode with 32-bit compatibility enabled? --------------------------------- What are the most popular cars? Find out at Yahoo! Autos --0-151450105-1138918461=:81599 Content-Type: text/html; charset=iso-8859-1 Content-Transfer-Encoding: 8bit Can the x86-64 port of MLton be compiled from full 64-bit mode or does it have to be bootstrapped by cross-compiling from 64-bit mode with 32-bit compatibility enabled?


What are the most popular cars? Find out at Yahoo! Autos --0-151450105-1138918461=:81599-- From fluet@cs.cornell.edu Thu Feb 2 23:49:20 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Thu, 2 Feb 2006 18:49:20 -0500 (EST) Subject: [MLton] x86-64 port In-Reply-To: <20060202221421.84828.qmail@web35707.mail.mud.yahoo.com> References: <20060202221421.84828.qmail@web35707.mail.mud.yahoo.com> Message-ID: > Can the x86-64 port of MLton Well, no such beast exists currently. > be compiled from full 64-bit mode or does it have to be bootstrapped by > cross-compiling from 64-bit mode with 32-bit compatibility enabled? The plan will be to have a self-compiling 64-bit port. Ultimately, the first bootstrap will come from either a 32-bit compiler cross-compiling to a 64-bit target, or such a 32-bit compiler running on a 64-bit platform with 32-bit compatibility enabled, but once one such bootstrap has been released, future releases should be compiled by previous releases. From fluet@cs.cornell.edu Sat Feb 4 16:00:00 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Sat, 4 Feb 2006 11:00:00 -0500 (EST) Subject: [MLton] Elaborator bug Message-ID: This message is in MIME format. The first part should be readable text, while the remaining parts are likely unreadable without MIME-aware tools. --1417689696-1732033131-1139068800=:15050 Content-Type: TEXT/PLAIN; charset=US-ASCII; format=flowed The attached source exhibits the following bug: ElaborateEnv.functorClosure: firstTycons I note that the bug is sensitive to the _number_ of structure/functor bindings made. That is, if you eliminiate some bindings in c-types.sml but increase the number of times c-types.sml is included in sources.mlb, then you maintain the bug. Likewise, if you increase the number of bindings in c-types.sml and decrease the number of times c-types.sml is included in sources.mlb, then you maintain the bug. --1417689696-1732033131-1139068800=:15050 Content-Type: APPLICATION/x-gzip; name=z.tgz Content-Transfer-Encoding: BASE64 Content-ID: Content-Description: Content-Disposition: attachment; filename=z.tgz H4sIAPTN5EMAA+1XX0/bMBDnuZ/ihCYNEHRJG8JA6gMUNphKkcgqHiPTuiRb cFjiwNin39lJSZq4Tdq1MKTcQw25s3/3z3fn0I+CIQ2b997txrpIQzJNQ64H uRVJ17TWhq61D3TdME1T29D0VgvZoK1NowxFIScBwMbYiyifI1fGf6dEGANo AMBmSH9FlA1p32cD5nJ4IgHblBzmM/rbIegp95FeEj50YiZsBnQUsRFhPPO1 4TKx68OWddmzexcn259uSeiG8a/IM8EdOr4f0mZ478n/9vjzg0jCdqv+9Jqf KBs13joDa3pLSi/i+jBK6n973zhI63/bEPVfb7Xr+v8atLUDXf/hOXDvHA5b 3W3QDw8P91oYMDinLHiGLv3BXbYLWOG5Q5/gi/DDLlhRQEOnATtYVeAbucM+ QrhDUJCwEVicPjiUwQ2lP8MmSgnByx73GbghBNSjJKQjwN5BAyBwYp3uhfzZ o+C5Q8owH4W8RSkgJIxdZMjNe72L7lnfOoOxH8CIcuJ68vTtRiN071ABVAq6 51dX1pl90f/et4+vv0JHFD5kiwVJFED4SIAn/z8SD8YXjH8+AvHbdBkv8HRT MnVTyW23JBdLqoprGpJrGilXVN3GOGJDjmZ05QVEib4t8GHrGI7yNmzjp8SK +FzIKHvc5OJE6MQiPIiGPJHqIFPaJiHViLq5CGTiggqYeO5s0HZrEdDEsxVA 8dzZoKaxCGgSsAqgeK6MaCEFr8+Oe9Vz8JoST6RSvDYDXIoCIpviNSOgyCch 07fjo6asftFJZXYWuszw5Oyiu1PonMNLoSdGVYGe6fSbq+vT6k6/8YMR3ny5 NJ/wt8gWlz9eZwiIoMXrDAERtHjNCCiCJmT6ttRlynEvJqkcl1G9zG/xycWI pbi5YlAKPPFJFWRlQUihc3laCj3xdhVoZZ6m0Lk8LYWexLEKdJKnb93mZ1Lu RbAWDDn/adqs+c84MMx0/jN0Mf+Z+n49/70GFeY/HP2Mdzj/NYQh4q/4GsqG YHcdDG1ncjP9B9RITkOyFXDkiA4/VRnkFjudG7AwKAaGjmJqm0a2loC2VoQ9 UGDHpf8FXJavafRBBl2Wxix8piR2lM0qZ73jB7xoPXaAeeaLTQubLztWDn05 +JXhD1T4SQecG4GsBouFQKEF6lZ0ATbCOS5AgYXtl2075/8loK0VYQ+K2MkA MNfzKfpifldo0PPZ3aLWiz0r8fwy4Naq0AcK9CrOz+CvxPtqJ+AgVhKBpfwg Z0dFFJZRwlqlFoMZWiRDaWlElo6KQpcvnk/y1zJ5P77oIV9+03rIbXbmVZnV IfOa7KgfvdM6nPrRLc4RRSWyzlAoEe9bSgtVbrh/8jpUuCJi17/ckP/3+VFT TTXVVFNNNdVUU001vSL9BWrlnJkAKAAA --1417689696-1732033131-1139068800=:15050-- From fluet@cs.cornell.edu Sat Feb 4 16:15:20 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Sat, 4 Feb 2006 11:15:20 -0500 (EST) Subject: [MLton] Elaborator bug In-Reply-To: References: Message-ID: This message is in MIME format. The first part should be readable text, while the remaining parts are likely unreadable without MIME-aware tools. --1417689696-313439160-1139069720=:15050 Content-Type: TEXT/PLAIN; charset=US-ASCII; format=flowed > The attached source exhibits the following bug: > ElaborateEnv.functorClosure: firstTycons > > I note that the bug is sensitive to the _number_ of structure/functor > bindings made. That is, if you eliminiate some bindings in c-types.sml but > increase the number of times c-types.sml is included in sources.mlb, then you > maintain the bug. Likewise, if you increase the number of bindings in > c-types.sml and decrease the number of times c-types.sml is included in > sources.mlb, then you maintain the bug. Here is a single, self-contained .sml file the exhibits the bug. --1417689696-313439160-1139069720=:15050 Content-Type: TEXT/PLAIN; charset=US-ASCII; name=z.sml Content-Transfer-Encoding: BASE64 Content-ID: Content-Description: Content-Disposition: attachment; filename=z.sml c2lnbmF0dXJlIENIT09TRV9JTlROX0FSRyA9DQogICBzaWcNCiAgICAgIHR5 cGUgJ2EgdA0KICAgICAgdmFsIGZJbnQ4OiBJbnQ4LmludCB0DQogICAgICB2 YWwgZkludDE2OiBJbnQxNi5pbnQgdA0KICAgICAgdmFsIGZJbnQzMjogSW50 MzIuaW50IHQNCiAgICAgIHZhbCBmSW50NjQ6IEludDY0LmludCB0DQogICBl bmQNCg0KZnVuY3RvciBDaG9vc2VJbnROX0ludDggKEEgOiBDSE9PU0VfSU5U Tl9BUkcpIDogDQogICBzaWcgdmFsIGYgOiBJbnQ4LmludCBBLnQgZW5kID0g DQogICBzdHJ1Y3QgdmFsIGYgPSBBLmZJbnQ4IGVuZA0KZnVuY3RvciBDaG9v c2VJbnROX0ludDE2IChBIDogQ0hPT1NFX0lOVE5fQVJHKSA6IA0KICAgc2ln IHZhbCBmIDogSW50MTYuaW50IEEudCBlbmQgPSANCiAgIHN0cnVjdCB2YWwg ZiA9IEEuZkludDE2IGVuZA0KZnVuY3RvciBDaG9vc2VJbnROX0ludDMyIChB IDogQ0hPT1NFX0lOVE5fQVJHKSA6IA0KICAgc2lnIHZhbCBmIDogSW50MzIu aW50IEEudCBlbmQgPSANCiAgIHN0cnVjdCB2YWwgZiA9IEEuZkludDMyIGVu ZA0KZnVuY3RvciBDaG9vc2VJbnROX0ludDY0IChBIDogQ0hPT1NFX0lOVE5f QVJHKSA6IA0KICAgc2lnIHZhbCBmIDogSW50NjQuaW50IEEudCBlbmQgPSAN CiAgIHN0cnVjdCB2YWwgZiA9IEEuZkludDY0IGVuZA0KDQpzaWduYXR1cmUg Q0hPT1NFX1JFQUxOX0FSRyA9DQogICBzaWcNCiAgICAgIHR5cGUgJ2EgdA0K ICAgICAgdmFsIGZSZWFsMzI6IFJlYWwzMi5yZWFsIHQNCiAgICAgIHZhbCBm UmVhbDY0OiBSZWFsNjQucmVhbCB0DQogICBlbmQNCg0KZnVuY3RvciBDaG9v c2VSZWFsTl9SZWFsMzIgKEEgOiBDSE9PU0VfUkVBTE5fQVJHKSA6IA0KICAg c2lnIHZhbCBmIDogUmVhbDMyLnJlYWwgQS50IGVuZCA9IA0KICAgc3RydWN0 IHZhbCBmID0gQS5mUmVhbDMyIGVuZA0KZnVuY3RvciBDaG9vc2VSZWFsTl9S ZWFsNjQgKEEgOiBDSE9PU0VfUkVBTE5fQVJHKSA6IA0KICAgc2lnIHZhbCBm IDogUmVhbDY0LnJlYWwgQS50IGVuZCA9IA0KICAgc3RydWN0IHZhbCBmID0g QS5mUmVhbDY0IGVuZA0KDQpzaWduYXR1cmUgQ0hPT1NFX1dPUkROX0FSRyA9 DQogICBzaWcNCiAgICAgIHR5cGUgJ2EgdA0KICAgICAgdmFsIGZXb3JkODog V29yZDgud29yZCB0DQogICAgICB2YWwgZldvcmQxNjogV29yZDE2LndvcmQg dA0KICAgICAgdmFsIGZXb3JkMzI6IFdvcmQzMi53b3JkIHQNCiAgICAgIHZh bCBmV29yZDY0OiBXb3JkNjQud29yZCB0DQogICBlbmQNCg0KZnVuY3RvciBD aG9vc2VXb3JkTl9Xb3JkOCAoQSA6IENIT09TRV9XT1JETl9BUkcpIDogDQog ICBzaWcgdmFsIGYgOiBXb3JkOC53b3JkIEEudCBlbmQgPSANCiAgIHN0cnVj dCB2YWwgZiA9IEEuZldvcmQ4IGVuZA0KZnVuY3RvciBDaG9vc2VXb3JkTl9X b3JkMTYgKEEgOiBDSE9PU0VfV09SRE5fQVJHKSA6IA0KICAgc2lnIHZhbCBm IDogV29yZDE2LndvcmQgQS50IGVuZCA9IA0KICAgc3RydWN0IHZhbCBmID0g QS5mV29yZDE2IGVuZA0KZnVuY3RvciBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEg OiBDSE9PU0VfV09SRE5fQVJHKSA6IA0KICAgc2lnIHZhbCBmIDogV29yZDMy LndvcmQgQS50IGVuZCA9IA0KICAgc3RydWN0IHZhbCBmID0gQS5mV29yZDMy IGVuZA0KZnVuY3RvciBDaG9vc2VXb3JkTl9Xb3JkNjQgKEEgOiBDSE9PU0Vf V09SRE5fQVJHKSA6IA0KICAgc2lnIHZhbCBmIDogV29yZDY0LndvcmQgQS50 IGVuZCA9IA0KICAgc3RydWN0IHZhbCBmID0gQS5mV29yZDY0IGVuZA0KDQoo KiBDICopDQpzdHJ1Y3R1cmUgQzBfQ2hhciA9IHN0cnVjdCBvcGVuIEludDgg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMF9DaGFyX0Nob29zZUludE4g KEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDggKEEpDQpz dHJ1Y3R1cmUgQzBfU0NoYXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9 IGludCBlbmQNCmZ1bmN0b3IgQzBfU0NoYXJfQ2hvb3NlSW50TiAoQTogQ0hP T1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0cnVjdHVy ZSBDMF9VQ2hhciA9IHN0cnVjdCBvcGVuIFdvcmQ4IHR5cGUgdCA9IHdvcmQg ZW5kDQpmdW5jdG9yIEMwX1VDaGFyX0Nob29zZVdvcmROIChBOiBDSE9PU0Vf V09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ4IChBKQ0Kc3RydWN0dXJl IEMwX1Nob3J0ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVu ZA0KZnVuY3RvciBDMF9TaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5U Tl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMF9T U2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpm dW5jdG9yIEMwX1NTaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9B UkcpID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMF9VU2hv cnQgPSBzdHJ1Y3Qgb3BlbiBXb3JkMTYgdHlwZSB0ID0gd29yZCBlbmQNCmZ1 bmN0b3IgQzBfVVNob3J0X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5f QVJHKSA9IENob29zZVdvcmROX1dvcmQxNiAoQSkNCnN0cnVjdHVyZSBDMF9J bnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEMwX0ludF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0g Q2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDMF9TSW50ID0gc3Ry dWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMF9T SW50X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJ bnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMwX1VJbnQgPSBzdHJ1Y3Qgb3Bl biBXb3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzBfVUludF9D aG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3Jk Tl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzBfTG9uZyA9IHN0cnVjdCBvcGVu IEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzBfTG9uZ19DaG9v c2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQz MiAoQSkNCnN0cnVjdHVyZSBDMF9TTG9uZyA9IHN0cnVjdCBvcGVuIEludDMy IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzBfU0xvbmdfQ2hvb3NlSW50 TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEp DQpzdHJ1Y3R1cmUgQzBfVUxvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlw ZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzBfVUxvbmdfQ2hvb3NlV29yZE4g KEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChB KQ0Kc3RydWN0dXJlIEMwX0xvbmdMb25nID0gc3RydWN0IG9wZW4gSW50NjQg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMF9Mb25nTG9uZ19DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAo QSkNCnN0cnVjdHVyZSBDMF9TTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2 NCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMwX1NMb25nTG9uZ19DaG9v c2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2 NCAoQSkNCnN0cnVjdHVyZSBDMF9VTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBX b3JkNjQgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzBfVUxvbmdMb25n X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdv cmROX1dvcmQ2NCAoQSkNCnN0cnVjdHVyZSBDMF9GbG9hdCA9IHN0cnVjdCBv cGVuIFJlYWwzMiB0eXBlIHQgPSByZWFsIGVuZA0KZnVuY3RvciBDMF9GbG9h dF9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9vc2VS ZWFsTl9SZWFsMzIgKEEpDQpzdHJ1Y3R1cmUgQzBfRG91YmxlID0gc3RydWN0 IG9wZW4gUmVhbDY0IHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMwX0Rv dWJsZV9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9v c2VSZWFsTl9SZWFsNjQgKEEpDQpzdHJ1Y3R1cmUgQzBfU2l6ZSA9IHN0cnVj dCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMF9T aXplX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29z ZVdvcmROX1dvcmQzMiAoQSkNCg0KKCogQyAqKQ0Kc3RydWN0dXJlIEMyX0No YXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzJfQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0g Q2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEMyX1NDaGFyID0gc3Ry dWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMyX1ND aGFyX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJ bnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzJfVUNoYXIgPSBzdHJ1Y3Qgb3Bl biBXb3JkOCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMl9VQ2hhcl9D aG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3Jk Tl9Xb3JkOCAoQSkNCnN0cnVjdHVyZSBDMl9TaG9ydCA9IHN0cnVjdCBvcGVu IEludDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzJfU2hvcnRfQ2hv b3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50 MTYgKEEpDQpzdHJ1Y3R1cmUgQzJfU1Nob3J0ID0gc3RydWN0IG9wZW4gSW50 MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMl9TU2hvcnRfQ2hvb3Nl SW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYg KEEpDQpzdHJ1Y3R1cmUgQzJfVVNob3J0ID0gc3RydWN0IG9wZW4gV29yZDE2 IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMyX1VTaG9ydF9DaG9vc2VX b3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3Jk MTYgKEEpDQpzdHJ1Y3R1cmUgQzJfSW50ID0gc3RydWN0IG9wZW4gSW50MzIg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMl9JbnRfQ2hvb3NlSW50TiAo QTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpz dHJ1Y3R1cmUgQzJfU0ludCA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9 IGludCBlbmQNCmZ1bmN0b3IgQzJfU0ludF9DaG9vc2VJbnROIChBOiBDSE9P U0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVy ZSBDMl9VSW50ID0gc3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQg ZW5kDQpmdW5jdG9yIEMyX1VJbnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9X T1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0Kc3RydWN0dXJl IEMyX0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5k DQpmdW5jdG9yIEMyX0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5f QVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzJfU0xv bmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEMyX1NMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykg PSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMyX1VMb25nID0g c3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9y IEMyX1VMb25nX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9 IENob29zZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDMl9Mb25nTG9u ZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzJfTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJH KSA9IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzJfU0xvbmdM b25nID0gc3RydWN0IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVu Y3RvciBDMl9TTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5f QVJHKSA9IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzJfVUxv bmdMb25nID0gc3RydWN0IG9wZW4gV29yZDY0IHR5cGUgdCA9IHdvcmQgZW5k DQpmdW5jdG9yIEMyX1VMb25nTG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NF X1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1 cmUgQzJfRmxvYXQgPSBzdHJ1Y3Qgb3BlbiBSZWFsMzIgdHlwZSB0ID0gcmVh bCBlbmQNCmZ1bmN0b3IgQzJfRmxvYXRfQ2hvb3NlUmVhbE4gKEE6IENIT09T RV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDMyIChBKQ0Kc3RydWN0 dXJlIEMyX0RvdWJsZSA9IHN0cnVjdCBvcGVuIFJlYWw2NCB0eXBlIHQgPSBy ZWFsIGVuZA0KZnVuY3RvciBDMl9Eb3VibGVfQ2hvb3NlUmVhbE4gKEE6IENI T09TRV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDY0IChBKQ0Kc3Ry dWN0dXJlIEMyX1NpemUgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0ID0g d29yZCBlbmQNCmZ1bmN0b3IgQzJfU2l6ZV9DaG9vc2VXb3JkTiAoQTogQ0hP T1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQoNCigq IEMgKikNCnN0cnVjdHVyZSBDM19DaGFyID0gc3RydWN0IG9wZW4gSW50OCB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMzX0NoYXJfQ2hvb3NlSW50TiAo QTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0 cnVjdHVyZSBDM19TQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0ID0g aW50IGVuZA0KZnVuY3RvciBDM19TQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9P U0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJl IEMzX1VDaGFyID0gc3RydWN0IG9wZW4gV29yZDggdHlwZSB0ID0gd29yZCBl bmQNCmZ1bmN0b3IgQzNfVUNoYXJfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9X T1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDggKEEpDQpzdHJ1Y3R1cmUg QzNfU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5k DQpmdW5jdG9yIEMzX1Nob3J0X0Nob29zZUludE4gKEE6IENIT09TRV9JTlRO X0FSRykgPSBDaG9vc2VJbnROX0ludDE2IChBKQ0Kc3RydWN0dXJlIEMzX1NT aG9ydCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1 bmN0b3IgQzNfU1Nob3J0X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FS RykgPSBDaG9vc2VJbnROX0ludDE2IChBKQ0Kc3RydWN0dXJlIEMzX1VTaG9y dCA9IHN0cnVjdCBvcGVuIFdvcmQxNiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVu Y3RvciBDM19VU2hvcnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9B UkcpID0gQ2hvb3NlV29yZE5fV29yZDE2IChBKQ0Kc3RydWN0dXJlIEMzX0lu dCA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzNfSW50X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBD aG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMzX1NJbnQgPSBzdHJ1 Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMzX1NJ bnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUlu dE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzNfVUludCA9IHN0cnVjdCBvcGVu IFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDM19VSW50X0No b29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmRO X1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDM19Mb25nID0gc3RydWN0IG9wZW4g SW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDM19Mb25nX0Nob29z ZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMy IChBKQ0Kc3RydWN0dXJlIEMzX1NMb25nID0gc3RydWN0IG9wZW4gSW50MzIg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDM19TTG9uZ19DaG9vc2VJbnRO IChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkN CnN0cnVjdHVyZSBDM19VTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBl IHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDM19VTG9uZ19DaG9vc2VXb3JkTiAo QTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEp DQpzdHJ1Y3R1cmUgQzNfTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMzX0xvbmdMb25nX0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChB KQ0Kc3RydWN0dXJlIEMzX1NMb25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0 IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzNfU0xvbmdMb25nX0Nob29z ZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0 IChBKQ0Kc3RydWN0dXJlIEMzX1VMb25nTG9uZyA9IHN0cnVjdCBvcGVuIFdv cmQ2NCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDM19VTG9uZ0xvbmdf Q2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29y ZE5fV29yZDY0IChBKQ0Kc3RydWN0dXJlIEMzX0Zsb2F0ID0gc3RydWN0IG9w ZW4gUmVhbDMyIHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMzX0Zsb2F0 X0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29zZVJl YWxOX1JlYWwzMiAoQSkNCnN0cnVjdHVyZSBDM19Eb3VibGUgPSBzdHJ1Y3Qg b3BlbiBSZWFsNjQgdHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzNfRG91 YmxlX0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29z ZVJlYWxOX1JlYWw2NCAoQSkNCnN0cnVjdHVyZSBDM19TaXplID0gc3RydWN0 IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMzX1Np emVfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3Nl V29yZE5fV29yZDMyIChBKQ0KDQooKiBDICopDQpzdHJ1Y3R1cmUgQzRfQ2hh ciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDNF9DaGFyX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBD aG9vc2VJbnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzRfU0NoYXIgPSBzdHJ1 Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzRfU0No YXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUlu dE5fSW50OCAoQSkNCnN0cnVjdHVyZSBDNF9VQ2hhciA9IHN0cnVjdCBvcGVu IFdvcmQ4IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM0X1VDaGFyX0No b29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmRO X1dvcmQ4IChBKQ0Kc3RydWN0dXJlIEM0X1Nob3J0ID0gc3RydWN0IG9wZW4g SW50MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDNF9TaG9ydF9DaG9v c2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQx NiAoQSkNCnN0cnVjdHVyZSBDNF9TU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQx NiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM0X1NTaG9ydF9DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQxNiAo QSkNCnN0cnVjdHVyZSBDNF9VU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBXb3JkMTYg dHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzRfVVNob3J0X0Nob29zZVdv cmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQx NiAoQSkNCnN0cnVjdHVyZSBDNF9JbnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM0X0ludF9DaG9vc2VJbnROIChB OiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0 cnVjdHVyZSBDNF9TSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0g aW50IGVuZA0KZnVuY3RvciBDNF9TSW50X0Nob29zZUludE4gKEE6IENIT09T RV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJl IEM0X1VJbnQgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0ID0gd29yZCBl bmQNCmZ1bmN0b3IgQzRfVUludF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dP UkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUg QzRfTG9uZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQN CmZ1bmN0b3IgQzRfTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9B UkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDNF9TTG9u ZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzRfU0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9 IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzRfVUxvbmcgPSBz dHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3Ig QzRfVUxvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0g Q2hvb3NlV29yZE5fV29yZDMyIChBKQ0Kc3RydWN0dXJlIEM0X0xvbmdMb25n ID0gc3RydWN0IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDNF9Mb25nTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcp ID0gQ2hvb3NlSW50Tl9JbnQ2NCAoQSkNCnN0cnVjdHVyZSBDNF9TTG9uZ0xv bmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEM0X1NMb25nTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9B UkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAoQSkNCnN0cnVjdHVyZSBDNF9VTG9u Z0xvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3JkNjQgdHlwZSB0ID0gd29yZCBlbmQN CmZ1bmN0b3IgQzRfVUxvbmdMb25nX0Nob29zZVdvcmROIChBOiBDSE9PU0Vf V09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ2NCAoQSkNCnN0cnVjdHVy ZSBDNF9GbG9hdCA9IHN0cnVjdCBvcGVuIFJlYWwzMiB0eXBlIHQgPSByZWFs IGVuZA0KZnVuY3RvciBDNF9GbG9hdF9DaG9vc2VSZWFsTiAoQTogQ0hPT1NF X1JFQUxOX0FSRykgPSBDaG9vc2VSZWFsTl9SZWFsMzIgKEEpDQpzdHJ1Y3R1 cmUgQzRfRG91YmxlID0gc3RydWN0IG9wZW4gUmVhbDY0IHR5cGUgdCA9IHJl YWwgZW5kDQpmdW5jdG9yIEM0X0RvdWJsZV9DaG9vc2VSZWFsTiAoQTogQ0hP T1NFX1JFQUxOX0FSRykgPSBDaG9vc2VSZWFsTl9SZWFsNjQgKEEpDQpzdHJ1 Y3R1cmUgQzRfU2l6ZSA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3 b3JkIGVuZA0KZnVuY3RvciBDNF9TaXplX0Nob29zZVdvcmROIChBOiBDSE9P U0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkNCg0KKCog QyAqKQ0Kc3RydWN0dXJlIEM1X0NoYXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzVfQ2hhcl9DaG9vc2VJbnROIChB OiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3Ry dWN0dXJlIEM1X1NDaGFyID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBp bnQgZW5kDQpmdW5jdG9yIEM1X1NDaGFyX0Nob29zZUludE4gKEE6IENIT09T RV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDggKEEpDQpzdHJ1Y3R1cmUg QzVfVUNoYXIgPSBzdHJ1Y3Qgb3BlbiBXb3JkOCB0eXBlIHQgPSB3b3JkIGVu ZA0KZnVuY3RvciBDNV9VQ2hhcl9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dP UkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkOCAoQSkNCnN0cnVjdHVyZSBD NV9TaG9ydCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9IGludCBlbmQN CmZ1bmN0b3IgQzVfU2hvcnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5f QVJHKSA9IENob29zZUludE5fSW50MTYgKEEpDQpzdHJ1Y3R1cmUgQzVfU1No b3J0ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVu Y3RvciBDNV9TU2hvcnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJH KSA9IENob29zZUludE5fSW50MTYgKEEpDQpzdHJ1Y3R1cmUgQzVfVVNob3J0 ID0gc3RydWN0IG9wZW4gV29yZDE2IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5j dG9yIEM1X1VTaG9ydF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FS RykgPSBDaG9vc2VXb3JkTl9Xb3JkMTYgKEEpDQpzdHJ1Y3R1cmUgQzVfSW50 ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDNV9JbnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENo b29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzVfU0ludCA9IHN0cnVj dCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzVfU0lu dF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50 Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDNV9VSW50ID0gc3RydWN0IG9wZW4g V29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM1X1VJbnRfQ2hv b3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5f V29yZDMyIChBKQ0Kc3RydWN0dXJlIEM1X0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJ bnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM1X0xvbmdfQ2hvb3Nl SW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIg KEEpDQpzdHJ1Y3R1cmUgQzVfU0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM1X1NMb25nX0Nob29zZUludE4g KEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0K c3RydWN0dXJlIEM1X1VMb25nID0gc3RydWN0IG9wZW4gV29yZDMyIHR5cGUg dCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM1X1VMb25nX0Nob29zZVdvcmROIChB OiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkN CnN0cnVjdHVyZSBDNV9Mb25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzVfTG9uZ0xvbmdfQ2hvb3NlSW50 TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50NjQgKEEp DQpzdHJ1Y3R1cmUgQzVfU0xvbmdMb25nID0gc3RydWN0IG9wZW4gSW50NjQg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDNV9TTG9uZ0xvbmdfQ2hvb3Nl SW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50NjQg KEEpDQpzdHJ1Y3R1cmUgQzVfVUxvbmdMb25nID0gc3RydWN0IG9wZW4gV29y ZDY0IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM1X1VMb25nTG9uZ19D aG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3Jk Tl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1cmUgQzVfRmxvYXQgPSBzdHJ1Y3Qgb3Bl biBSZWFsMzIgdHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzVfRmxvYXRf Q2hvb3NlUmVhbE4gKEE6IENIT09TRV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVh bE5fUmVhbDMyIChBKQ0Kc3RydWN0dXJlIEM1X0RvdWJsZSA9IHN0cnVjdCBv cGVuIFJlYWw2NCB0eXBlIHQgPSByZWFsIGVuZA0KZnVuY3RvciBDNV9Eb3Vi bGVfQ2hvb3NlUmVhbE4gKEE6IENIT09TRV9SRUFMTl9BUkcpID0gQ2hvb3Nl UmVhbE5fUmVhbDY0IChBKQ0Kc3RydWN0dXJlIEM1X1NpemUgPSBzdHJ1Y3Qg b3BlbiBXb3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzVfU2l6 ZV9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VX b3JkTl9Xb3JkMzIgKEEpDQoNCigqIEMgKikNCnN0cnVjdHVyZSBDNl9DaGFy ID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9y IEM2X0NoYXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENo b29zZUludE5fSW50OCAoQSkNCnN0cnVjdHVyZSBDNl9TQ2hhciA9IHN0cnVj dCBvcGVuIEludDggdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDNl9TQ2hh cl9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50 Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEM2X1VDaGFyID0gc3RydWN0IG9wZW4g V29yZDggdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzZfVUNoYXJfQ2hv b3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5f V29yZDggKEEpDQpzdHJ1Y3R1cmUgQzZfU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJ bnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM2X1Nob3J0X0Nob29z ZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDE2 IChBKQ0Kc3RydWN0dXJlIEM2X1NTaG9ydCA9IHN0cnVjdCBvcGVuIEludDE2 IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzZfU1Nob3J0X0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDE2IChB KQ0Kc3RydWN0dXJlIEM2X1VTaG9ydCA9IHN0cnVjdCBvcGVuIFdvcmQxNiB0 eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDNl9VU2hvcnRfQ2hvb3NlV29y ZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDE2 IChBKQ0Kc3RydWN0dXJlIEM2X0ludCA9IHN0cnVjdCBvcGVuIEludDMyIHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzZfSW50X0Nob29zZUludE4gKEE6 IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3Ry dWN0dXJlIEM2X1NJbnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBp bnQgZW5kDQpmdW5jdG9yIEM2X1NJbnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NF X0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUg QzZfVUludCA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVu ZA0KZnVuY3RvciBDNl9VSW50X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09S RE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBD Nl9Mb25nID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0K ZnVuY3RvciBDNl9Mb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FS RykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEM2X1NMb25n ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDNl9TTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0g Q2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDNl9VTG9uZyA9IHN0 cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBD Nl9VTG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBD aG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzZfTG9uZ0xvbmcg PSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9y IEM2X0xvbmdMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykg PSBDaG9vc2VJbnROX0ludDY0IChBKQ0Kc3RydWN0dXJlIEM2X1NMb25nTG9u ZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzZfU0xvbmdMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FS RykgPSBDaG9vc2VJbnROX0ludDY0IChBKQ0Kc3RydWN0dXJlIEM2X1VMb25n TG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQ2NCB0eXBlIHQgPSB3b3JkIGVuZA0K ZnVuY3RvciBDNl9VTG9uZ0xvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9X T1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDY0IChBKQ0Kc3RydWN0dXJl IEM2X0Zsb2F0ID0gc3RydWN0IG9wZW4gUmVhbDMyIHR5cGUgdCA9IHJlYWwg ZW5kDQpmdW5jdG9yIEM2X0Zsb2F0X0Nob29zZVJlYWxOIChBOiBDSE9PU0Vf UkVBTE5fQVJHKSA9IENob29zZVJlYWxOX1JlYWwzMiAoQSkNCnN0cnVjdHVy ZSBDNl9Eb3VibGUgPSBzdHJ1Y3Qgb3BlbiBSZWFsNjQgdHlwZSB0ID0gcmVh bCBlbmQNCmZ1bmN0b3IgQzZfRG91YmxlX0Nob29zZVJlYWxOIChBOiBDSE9P U0VfUkVBTE5fQVJHKSA9IENob29zZVJlYWxOX1JlYWw2NCAoQSkNCnN0cnVj dHVyZSBDNl9TaXplID0gc3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdv cmQgZW5kDQpmdW5jdG9yIEM2X1NpemVfQ2hvb3NlV29yZE4gKEE6IENIT09T RV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0KDQooKiBD ICopDQpzdHJ1Y3R1cmUgQzdfQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDN19DaGFyX0Nob29zZUludE4gKEE6 IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDggKEEpDQpzdHJ1 Y3R1cmUgQzdfU0NoYXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGlu dCBlbmQNCmZ1bmN0b3IgQzdfU0NoYXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NF X0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0cnVjdHVyZSBD N19VQ2hhciA9IHN0cnVjdCBvcGVuIFdvcmQ4IHR5cGUgdCA9IHdvcmQgZW5k DQpmdW5jdG9yIEM3X1VDaGFyX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09S RE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ4IChBKQ0Kc3RydWN0dXJlIEM3 X1Nob3J0ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVuZA0K ZnVuY3RvciBDN19TaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9B UkcpID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDN19TU2hv cnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEM3X1NTaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcp ID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDN19VU2hvcnQg PSBzdHJ1Y3Qgb3BlbiBXb3JkMTYgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0 b3IgQzdfVVNob3J0X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJH KSA9IENob29zZVdvcmROX1dvcmQxNiAoQSkNCnN0cnVjdHVyZSBDN19JbnQg PSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9y IEM3X0ludF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hv b3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDN19TSW50ID0gc3RydWN0 IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDN19TSW50 X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnRO X0ludDMyIChBKQ0Kc3RydWN0dXJlIEM3X1VJbnQgPSBzdHJ1Y3Qgb3BlbiBX b3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzdfVUludF9DaG9v c2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9X b3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzdfTG9uZyA9IHN0cnVjdCBvcGVuIElu dDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzdfTG9uZ19DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAo QSkNCnN0cnVjdHVyZSBDN19TTG9uZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzdfU0xvbmdfQ2hvb3NlSW50TiAo QTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpz dHJ1Y3R1cmUgQzdfVUxvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0 ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzdfVUxvbmdfQ2hvb3NlV29yZE4gKEE6 IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0K c3RydWN0dXJlIEM3X0xvbmdMb25nID0gc3RydWN0IG9wZW4gSW50NjQgdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDN19Mb25nTG9uZ19DaG9vc2VJbnRO IChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAoQSkN CnN0cnVjdHVyZSBDN19TTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM3X1NMb25nTG9uZ19DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAo QSkNCnN0cnVjdHVyZSBDN19VTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3Jk NjQgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzdfVUxvbmdMb25nX0No b29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmRO X1dvcmQ2NCAoQSkNCnN0cnVjdHVyZSBDN19GbG9hdCA9IHN0cnVjdCBvcGVu IFJlYWwzMiB0eXBlIHQgPSByZWFsIGVuZA0KZnVuY3RvciBDN19GbG9hdF9D aG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9vc2VSZWFs Tl9SZWFsMzIgKEEpDQpzdHJ1Y3R1cmUgQzdfRG91YmxlID0gc3RydWN0IG9w ZW4gUmVhbDY0IHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEM3X0RvdWJs ZV9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9vc2VS ZWFsTl9SZWFsNjQgKEEpDQpzdHJ1Y3R1cmUgQzdfU2l6ZSA9IHN0cnVjdCBv cGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDN19TaXpl X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdv cmROX1dvcmQzMiAoQSkNCg0KKCogQyAqKQ0Kc3RydWN0dXJlIEM4X0NoYXIg PSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3Ig QzhfQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hv b3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEM4X1NDaGFyID0gc3RydWN0 IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM4X1NDaGFy X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnRO X0ludDggKEEpDQpzdHJ1Y3R1cmUgQzhfVUNoYXIgPSBzdHJ1Y3Qgb3BlbiBX b3JkOCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDOF9VQ2hhcl9DaG9v c2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9X b3JkOCAoQSkNCnN0cnVjdHVyZSBDOF9TaG9ydCA9IHN0cnVjdCBvcGVuIElu dDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzhfU2hvcnRfQ2hvb3Nl SW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYg KEEpDQpzdHJ1Y3R1cmUgQzhfU1Nob3J0ID0gc3RydWN0IG9wZW4gSW50MTYg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDOF9TU2hvcnRfQ2hvb3NlSW50 TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYgKEEp DQpzdHJ1Y3R1cmUgQzhfVVNob3J0ID0gc3RydWN0IG9wZW4gV29yZDE2IHR5 cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM4X1VTaG9ydF9DaG9vc2VXb3Jk TiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMTYg KEEpDQpzdHJ1Y3R1cmUgQzhfSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDOF9JbnRfQ2hvb3NlSW50TiAoQTog Q0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1 Y3R1cmUgQzhfU0ludCA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGlu dCBlbmQNCmZ1bmN0b3IgQzhfU0ludF9DaG9vc2VJbnROIChBOiBDSE9PU0Vf SU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBD OF9VSW50ID0gc3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5k DQpmdW5jdG9yIEM4X1VJbnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JE Tl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0Kc3RydWN0dXJlIEM4 X0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpm dW5jdG9yIEM4X0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJH KSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzhfU0xvbmcg PSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9y IEM4X1NMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBD aG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEM4X1VMb25nID0gc3Ry dWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM4 X1VMb25nX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENo b29zZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDOF9Mb25nTG9uZyA9 IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3Ig QzhfTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9 IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzhfU0xvbmdMb25n ID0gc3RydWN0IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDOF9TTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJH KSA9IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzhfVUxvbmdM b25nID0gc3RydWN0IG9wZW4gV29yZDY0IHR5cGUgdCA9IHdvcmQgZW5kDQpm dW5jdG9yIEM4X1VMb25nTG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dP UkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1cmUg QzhfRmxvYXQgPSBzdHJ1Y3Qgb3BlbiBSZWFsMzIgdHlwZSB0ID0gcmVhbCBl bmQNCmZ1bmN0b3IgQzhfRmxvYXRfQ2hvb3NlUmVhbE4gKEE6IENIT09TRV9S RUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDMyIChBKQ0Kc3RydWN0dXJl IEM4X0RvdWJsZSA9IHN0cnVjdCBvcGVuIFJlYWw2NCB0eXBlIHQgPSByZWFs IGVuZA0KZnVuY3RvciBDOF9Eb3VibGVfQ2hvb3NlUmVhbE4gKEE6IENIT09T RV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDY0IChBKQ0Kc3RydWN0 dXJlIEM4X1NpemUgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0ID0gd29y ZCBlbmQNCmZ1bmN0b3IgQzhfU2l6ZV9DaG9vc2VXb3JkTiAoQTogQ0hPT1NF X1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQoNCigqIEMg KikNCnN0cnVjdHVyZSBDOV9DaGFyID0gc3RydWN0IG9wZW4gSW50OCB0eXBl IHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM5X0NoYXJfQ2hvb3NlSW50TiAoQTog Q0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0cnVj dHVyZSBDOV9TQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0ID0gaW50 IGVuZA0KZnVuY3RvciBDOV9TQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0Vf SU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEM5 X1VDaGFyID0gc3RydWN0IG9wZW4gV29yZDggdHlwZSB0ID0gd29yZCBlbmQN CmZ1bmN0b3IgQzlfVUNoYXJfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JE Tl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDggKEEpDQpzdHJ1Y3R1cmUgQzlf U2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpm dW5jdG9yIEM5X1Nob3J0X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FS RykgPSBDaG9vc2VJbnROX0ludDE2IChBKQ0Kc3RydWN0dXJlIEM5X1NTaG9y dCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzlfU1Nob3J0X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykg PSBDaG9vc2VJbnROX0ludDE2IChBKQ0Kc3RydWN0dXJlIEM5X1VTaG9ydCA9 IHN0cnVjdCBvcGVuIFdvcmQxNiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3Rv ciBDOV9VU2hvcnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcp ID0gQ2hvb3NlV29yZE5fV29yZDE2IChBKQ0Kc3RydWN0dXJlIEM5X0ludCA9 IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3Ig QzlfSW50X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9v c2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEM5X1NJbnQgPSBzdHJ1Y3Qg b3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM5X1NJbnRf Q2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5f SW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzlfVUludCA9IHN0cnVjdCBvcGVuIFdv cmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDOV9VSW50X0Nob29z ZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dv cmQzMiAoQSkNCnN0cnVjdHVyZSBDOV9Mb25nID0gc3RydWN0IG9wZW4gSW50 MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDOV9Mb25nX0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChB KQ0Kc3RydWN0dXJlIEM5X1NMb25nID0gc3RydWN0IG9wZW4gSW50MzIgdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDOV9TTG9uZ19DaG9vc2VJbnROIChB OiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0 cnVjdHVyZSBDOV9VTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQg PSB3b3JkIGVuZA0KZnVuY3RvciBDOV9VTG9uZ19DaG9vc2VXb3JkTiAoQTog Q0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpz dHJ1Y3R1cmUgQzlfTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBl IHQgPSBpbnQgZW5kDQpmdW5jdG9yIEM5X0xvbmdMb25nX0Nob29zZUludE4g KEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChBKQ0K c3RydWN0dXJlIEM5X1NMb25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzlfU0xvbmdMb25nX0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChB KQ0Kc3RydWN0dXJlIEM5X1VMb25nTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQ2 NCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDOV9VTG9uZ0xvbmdfQ2hv b3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5f V29yZDY0IChBKQ0Kc3RydWN0dXJlIEM5X0Zsb2F0ID0gc3RydWN0IG9wZW4g UmVhbDMyIHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEM5X0Zsb2F0X0No b29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29zZVJlYWxO X1JlYWwzMiAoQSkNCnN0cnVjdHVyZSBDOV9Eb3VibGUgPSBzdHJ1Y3Qgb3Bl biBSZWFsNjQgdHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzlfRG91Ymxl X0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29zZVJl YWxOX1JlYWw2NCAoQSkNCnN0cnVjdHVyZSBDOV9TaXplID0gc3RydWN0IG9w ZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEM5X1NpemVf Q2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29y ZE5fV29yZDMyIChBKQ0KDQooKiBDICopDQpzdHJ1Y3R1cmUgQzEwX0NoYXIg PSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3Ig QzEwX0NoYXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENo b29zZUludE5fSW50OCAoQSkNCnN0cnVjdHVyZSBDMTBfU0NoYXIgPSBzdHJ1 Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEwX1ND aGFyX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJ bnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzEwX1VDaGFyID0gc3RydWN0IG9w ZW4gV29yZDggdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzEwX1VDaGFy X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdv cmROX1dvcmQ4IChBKQ0Kc3RydWN0dXJlIEMxMF9TaG9ydCA9IHN0cnVjdCBv cGVuIEludDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEwX1Nob3J0 X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnRO X0ludDE2IChBKQ0Kc3RydWN0dXJlIEMxMF9TU2hvcnQgPSBzdHJ1Y3Qgb3Bl biBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxMF9TU2hvcnRf Q2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5f SW50MTYgKEEpDQpzdHJ1Y3R1cmUgQzEwX1VTaG9ydCA9IHN0cnVjdCBvcGVu IFdvcmQxNiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTBfVVNob3J0 X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdv cmROX1dvcmQxNiAoQSkNCnN0cnVjdHVyZSBDMTBfSW50ID0gc3RydWN0IG9w ZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTBfSW50X0No b29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0lu dDMyIChBKQ0Kc3RydWN0dXJlIEMxMF9TSW50ID0gc3RydWN0IG9wZW4gSW50 MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTBfU0ludF9DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAo QSkNCnN0cnVjdHVyZSBDMTBfVUludCA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0 eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTBfVUludF9DaG9vc2VXb3Jk TiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIg KEEpDQpzdHJ1Y3R1cmUgQzEwX0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxMF9Mb25nX0Nob29zZUludE4g KEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0K c3RydWN0dXJlIEMxMF9TTG9uZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUg dCA9IGludCBlbmQNCmZ1bmN0b3IgQzEwX1NMb25nX0Nob29zZUludE4gKEE6 IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3Ry dWN0dXJlIEMxMF9VTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQg PSB3b3JkIGVuZA0KZnVuY3RvciBDMTBfVUxvbmdfQ2hvb3NlV29yZE4gKEE6 IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0K c3RydWN0dXJlIEMxMF9Mb25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEwX0xvbmdMb25nX0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChB KQ0Kc3RydWN0dXJlIEMxMF9TTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2 NCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxMF9TTG9uZ0xvbmdfQ2hv b3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50 NjQgKEEpDQpzdHJ1Y3R1cmUgQzEwX1VMb25nTG9uZyA9IHN0cnVjdCBvcGVu IFdvcmQ2NCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTBfVUxvbmdM b25nX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29z ZVdvcmROX1dvcmQ2NCAoQSkNCnN0cnVjdHVyZSBDMTBfRmxvYXQgPSBzdHJ1 Y3Qgb3BlbiBSZWFsMzIgdHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzEw X0Zsb2F0X0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENo b29zZVJlYWxOX1JlYWwzMiAoQSkNCnN0cnVjdHVyZSBDMTBfRG91YmxlID0g c3RydWN0IG9wZW4gUmVhbDY0IHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9y IEMxMF9Eb3VibGVfQ2hvb3NlUmVhbE4gKEE6IENIT09TRV9SRUFMTl9BUkcp ID0gQ2hvb3NlUmVhbE5fUmVhbDY0IChBKQ0Kc3RydWN0dXJlIEMxMF9TaXpl ID0gc3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5j dG9yIEMxMF9TaXplX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJH KSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkNCg0KKCogQyAqKQ0Kc3RydWN0 dXJlIEMxMV9DaGFyID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQg ZW5kDQpmdW5jdG9yIEMxMV9DaGFyX0Nob29zZUludE4gKEE6IENIT09TRV9J TlROX0FSRykgPSBDaG9vc2VJbnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzEx X1NDaGFyID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpm dW5jdG9yIEMxMV9TQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9B UkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEMxMV9VQ2hh ciA9IHN0cnVjdCBvcGVuIFdvcmQ4IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5j dG9yIEMxMV9VQ2hhcl9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FS RykgPSBDaG9vc2VXb3JkTl9Xb3JkOCAoQSkNCnN0cnVjdHVyZSBDMTFfU2hv cnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEMxMV9TaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcp ID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMTFfU1Nob3J0 ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDMTFfU1Nob3J0X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykg PSBDaG9vc2VJbnROX0ludDE2IChBKQ0Kc3RydWN0dXJlIEMxMV9VU2hvcnQg PSBzdHJ1Y3Qgb3BlbiBXb3JkMTYgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0 b3IgQzExX1VTaG9ydF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FS RykgPSBDaG9vc2VXb3JkTl9Xb3JkMTYgKEEpDQpzdHJ1Y3R1cmUgQzExX0lu dCA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzExX0ludF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0g Q2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDMTFfU0ludCA9IHN0 cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEx X1NJbnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29z ZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzExX1VJbnQgPSBzdHJ1Y3Qg b3BlbiBXb3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzExX1VJ bnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3Nl V29yZE5fV29yZDMyIChBKQ0Kc3RydWN0dXJlIEMxMV9Mb25nID0gc3RydWN0 IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTFfTG9u Z19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50 Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDMTFfU0xvbmcgPSBzdHJ1Y3Qgb3Bl biBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxMV9TTG9uZ19D aG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9J bnQzMiAoQSkNCnN0cnVjdHVyZSBDMTFfVUxvbmcgPSBzdHJ1Y3Qgb3BlbiBX b3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzExX1VMb25nX0No b29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmRO X1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDMTFfTG9uZ0xvbmcgPSBzdHJ1Y3Qg b3BlbiBJbnQ2NCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxMV9Mb25n TG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3Nl SW50Tl9JbnQ2NCAoQSkNCnN0cnVjdHVyZSBDMTFfU0xvbmdMb25nID0gc3Ry dWN0IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTFf U0xvbmdMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBD aG9vc2VJbnROX0ludDY0IChBKQ0Kc3RydWN0dXJlIEMxMV9VTG9uZ0xvbmcg PSBzdHJ1Y3Qgb3BlbiBXb3JkNjQgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0 b3IgQzExX1VMb25nTG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkRO X0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1cmUgQzEx X0Zsb2F0ID0gc3RydWN0IG9wZW4gUmVhbDMyIHR5cGUgdCA9IHJlYWwgZW5k DQpmdW5jdG9yIEMxMV9GbG9hdF9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JF QUxOX0FSRykgPSBDaG9vc2VSZWFsTl9SZWFsMzIgKEEpDQpzdHJ1Y3R1cmUg QzExX0RvdWJsZSA9IHN0cnVjdCBvcGVuIFJlYWw2NCB0eXBlIHQgPSByZWFs IGVuZA0KZnVuY3RvciBDMTFfRG91YmxlX0Nob29zZVJlYWxOIChBOiBDSE9P U0VfUkVBTE5fQVJHKSA9IENob29zZVJlYWxOX1JlYWw2NCAoQSkNCnN0cnVj dHVyZSBDMTFfU2l6ZSA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3 b3JkIGVuZA0KZnVuY3RvciBDMTFfU2l6ZV9DaG9vc2VXb3JkTiAoQTogQ0hP T1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQoNCigq IEMgKikNCnN0cnVjdHVyZSBDMTJfQ2hhciA9IHN0cnVjdCBvcGVuIEludDgg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTJfQ2hhcl9DaG9vc2VJbnRO IChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0K c3RydWN0dXJlIEMxMl9TQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0 ID0gaW50IGVuZA0KZnVuY3RvciBDMTJfU0NoYXJfQ2hvb3NlSW50TiAoQTog Q0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0cnVj dHVyZSBDMTJfVUNoYXIgPSBzdHJ1Y3Qgb3BlbiBXb3JkOCB0eXBlIHQgPSB3 b3JkIGVuZA0KZnVuY3RvciBDMTJfVUNoYXJfQ2hvb3NlV29yZE4gKEE6IENI T09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDggKEEpDQpzdHJ1 Y3R1cmUgQzEyX1Nob3J0ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0g aW50IGVuZA0KZnVuY3RvciBDMTJfU2hvcnRfQ2hvb3NlSW50TiAoQTogQ0hP T1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYgKEEpDQpzdHJ1Y3R1 cmUgQzEyX1NTaG9ydCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9IGlu dCBlbmQNCmZ1bmN0b3IgQzEyX1NTaG9ydF9DaG9vc2VJbnROIChBOiBDSE9P U0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVy ZSBDMTJfVVNob3J0ID0gc3RydWN0IG9wZW4gV29yZDE2IHR5cGUgdCA9IHdv cmQgZW5kDQpmdW5jdG9yIEMxMl9VU2hvcnRfQ2hvb3NlV29yZE4gKEE6IENI T09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDE2IChBKQ0Kc3Ry dWN0dXJlIEMxMl9JbnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBp bnQgZW5kDQpmdW5jdG9yIEMxMl9JbnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NF X0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUg QzEyX1NJbnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5k DQpmdW5jdG9yIEMxMl9TSW50X0Nob29zZUludE4gKEE6IENIT09TRV9JTlRO X0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMxMl9V SW50ID0gc3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpm dW5jdG9yIEMxMl9VSW50X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5f QVJHKSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDMTJf TG9uZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1 bmN0b3IgQzEyX0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJH KSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzEyX1NMb25n ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3Rv ciBDMTJfU0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9 IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzEyX1VMb25nID0g c3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9y IEMxMl9VTG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykg PSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzEyX0xvbmdM b25nID0gc3RydWN0IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVu Y3RvciBDMTJfTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5f QVJHKSA9IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzEyX1NM b25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQN CmZ1bmN0b3IgQzEyX1NMb25nTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0Vf SU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAoQSkNCnN0cnVjdHVyZSBD MTJfVUxvbmdMb25nID0gc3RydWN0IG9wZW4gV29yZDY0IHR5cGUgdCA9IHdv cmQgZW5kDQpmdW5jdG9yIEMxMl9VTG9uZ0xvbmdfQ2hvb3NlV29yZE4gKEE6 IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDY0IChBKQ0K c3RydWN0dXJlIEMxMl9GbG9hdCA9IHN0cnVjdCBvcGVuIFJlYWwzMiB0eXBl IHQgPSByZWFsIGVuZA0KZnVuY3RvciBDMTJfRmxvYXRfQ2hvb3NlUmVhbE4g KEE6IENIT09TRV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDMyIChB KQ0Kc3RydWN0dXJlIEMxMl9Eb3VibGUgPSBzdHJ1Y3Qgb3BlbiBSZWFsNjQg dHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzEyX0RvdWJsZV9DaG9vc2VS ZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9vc2VSZWFsTl9SZWFs NjQgKEEpDQpzdHJ1Y3R1cmUgQzEyX1NpemUgPSBzdHJ1Y3Qgb3BlbiBXb3Jk MzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzEyX1NpemVfQ2hvb3Nl V29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29y ZDMyIChBKQ0KDQooKiBDICopDQpzdHJ1Y3R1cmUgQzEzX0NoYXIgPSBzdHJ1 Y3Qgb3BlbiBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEzX0No YXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUlu dE5fSW50OCAoQSkNCnN0cnVjdHVyZSBDMTNfU0NoYXIgPSBzdHJ1Y3Qgb3Bl biBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEzX1NDaGFyX0No b29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0lu dDggKEEpDQpzdHJ1Y3R1cmUgQzEzX1VDaGFyID0gc3RydWN0IG9wZW4gV29y ZDggdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzEzX1VDaGFyX0Nob29z ZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dv cmQ4IChBKQ0Kc3RydWN0dXJlIEMxM19TaG9ydCA9IHN0cnVjdCBvcGVuIElu dDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzEzX1Nob3J0X0Nob29z ZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDE2 IChBKQ0Kc3RydWN0dXJlIEMxM19TU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQx NiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxM19TU2hvcnRfQ2hvb3Nl SW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYg KEEpDQpzdHJ1Y3R1cmUgQzEzX1VTaG9ydCA9IHN0cnVjdCBvcGVuIFdvcmQx NiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTNfVVNob3J0X0Nob29z ZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dv cmQxNiAoQSkNCnN0cnVjdHVyZSBDMTNfSW50ID0gc3RydWN0IG9wZW4gSW50 MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTNfSW50X0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChB KQ0Kc3RydWN0dXJlIEMxM19TSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTNfU0ludF9DaG9vc2VJbnROIChB OiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0 cnVjdHVyZSBDMTNfVUludCA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQg PSB3b3JkIGVuZA0KZnVuY3RvciBDMTNfVUludF9DaG9vc2VXb3JkTiAoQTog Q0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpz dHJ1Y3R1cmUgQzEzX0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQg PSBpbnQgZW5kDQpmdW5jdG9yIEMxM19Mb25nX0Nob29zZUludE4gKEE6IENI T09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0 dXJlIEMxM19TTG9uZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGlu dCBlbmQNCmZ1bmN0b3IgQzEzX1NMb25nX0Nob29zZUludE4gKEE6IENIT09T RV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJl IEMxM19VTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3Jk IGVuZA0KZnVuY3RvciBDMTNfVUxvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09T RV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0Kc3RydWN0 dXJlIEMxM19Mb25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9 IGludCBlbmQNCmZ1bmN0b3IgQzEzX0xvbmdMb25nX0Nob29zZUludE4gKEE6 IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChBKQ0Kc3Ry dWN0dXJlIEMxM19TTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBl IHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxM19TTG9uZ0xvbmdfQ2hvb3NlSW50 TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50NjQgKEEp DQpzdHJ1Y3R1cmUgQzEzX1VMb25nTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQ2 NCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTNfVUxvbmdMb25nX0No b29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmRO X1dvcmQ2NCAoQSkNCnN0cnVjdHVyZSBDMTNfRmxvYXQgPSBzdHJ1Y3Qgb3Bl biBSZWFsMzIgdHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzEzX0Zsb2F0 X0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29zZVJl YWxOX1JlYWwzMiAoQSkNCnN0cnVjdHVyZSBDMTNfRG91YmxlID0gc3RydWN0 IG9wZW4gUmVhbDY0IHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMxM19E b3VibGVfQ2hvb3NlUmVhbE4gKEE6IENIT09TRV9SRUFMTl9BUkcpID0gQ2hv b3NlUmVhbE5fUmVhbDY0IChBKQ0Kc3RydWN0dXJlIEMxM19TaXplID0gc3Ry dWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMx M19TaXplX0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENo b29zZVdvcmROX1dvcmQzMiAoQSkNCg0KKCogQyAqKQ0Kc3RydWN0dXJlIEMx NF9DaGFyID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpm dW5jdG9yIEMxNF9DaGFyX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FS RykgPSBDaG9vc2VJbnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzE0X1NDaGFy ID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9y IEMxNF9TQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0g Q2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEMxNF9VQ2hhciA9IHN0 cnVjdCBvcGVuIFdvcmQ4IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMx NF9VQ2hhcl9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBD aG9vc2VXb3JkTl9Xb3JkOCAoQSkNCnN0cnVjdHVyZSBDMTRfU2hvcnQgPSBz dHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMx NF9TaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hv b3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMTRfU1Nob3J0ID0gc3Ry dWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTRf U1Nob3J0X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9v c2VJbnROX0ludDE2IChBKQ0Kc3RydWN0dXJlIEMxNF9VU2hvcnQgPSBzdHJ1 Y3Qgb3BlbiBXb3JkMTYgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE0 X1VTaG9ydF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBD aG9vc2VXb3JkTl9Xb3JkMTYgKEEpDQpzdHJ1Y3R1cmUgQzE0X0ludCA9IHN0 cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE0 X0ludF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3Nl SW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDMTRfU0ludCA9IHN0cnVjdCBv cGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE0X1NJbnRf Q2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5f SW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE0X1VJbnQgPSBzdHJ1Y3Qgb3BlbiBX b3JkMzIgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE0X1VJbnRfQ2hv b3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5f V29yZDMyIChBKQ0Kc3RydWN0dXJlIEMxNF9Mb25nID0gc3RydWN0IG9wZW4g SW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTRfTG9uZ19DaG9v c2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQz MiAoQSkNCnN0cnVjdHVyZSBDMTRfU0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQz MiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxNF9TTG9uZ19DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAo QSkNCnN0cnVjdHVyZSBDMTRfVUxvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIg dHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE0X1VMb25nX0Nob29zZVdv cmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQz MiAoQSkNCnN0cnVjdHVyZSBDMTRfTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJ bnQ2NCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxNF9Mb25nTG9uZ19D aG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9J bnQ2NCAoQSkNCnN0cnVjdHVyZSBDMTRfU0xvbmdMb25nID0gc3RydWN0IG9w ZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTRfU0xvbmdM b25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJ bnROX0ludDY0IChBKQ0Kc3RydWN0dXJlIEMxNF9VTG9uZ0xvbmcgPSBzdHJ1 Y3Qgb3BlbiBXb3JkNjQgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE0 X1VMb25nTG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykg PSBDaG9vc2VXb3JkTl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1cmUgQzE0X0Zsb2F0 ID0gc3RydWN0IG9wZW4gUmVhbDMyIHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5j dG9yIEMxNF9GbG9hdF9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FS RykgPSBDaG9vc2VSZWFsTl9SZWFsMzIgKEEpDQpzdHJ1Y3R1cmUgQzE0X0Rv dWJsZSA9IHN0cnVjdCBvcGVuIFJlYWw2NCB0eXBlIHQgPSByZWFsIGVuZA0K ZnVuY3RvciBDMTRfRG91YmxlX0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVB TE5fQVJHKSA9IENob29zZVJlYWxOX1JlYWw2NCAoQSkNCnN0cnVjdHVyZSBD MTRfU2l6ZSA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVu ZA0KZnVuY3RvciBDMTRfU2l6ZV9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dP UkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQoNCigqIEMgKikN CnN0cnVjdHVyZSBDMTVfQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0 ID0gaW50IGVuZA0KZnVuY3RvciBDMTVfQ2hhcl9DaG9vc2VJbnROIChBOiBD SE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0 dXJlIEMxNV9TQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0ID0gaW50 IGVuZA0KZnVuY3RvciBDMTVfU0NoYXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NF X0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0cnVjdHVyZSBD MTVfVUNoYXIgPSBzdHJ1Y3Qgb3BlbiBXb3JkOCB0eXBlIHQgPSB3b3JkIGVu ZA0KZnVuY3RvciBDMTVfVUNoYXJfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9X T1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDggKEEpDQpzdHJ1Y3R1cmUg QzE1X1Nob3J0ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVu ZA0KZnVuY3RvciBDMTVfU2hvcnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lO VE5fQVJHKSA9IENob29zZUludE5fSW50MTYgKEEpDQpzdHJ1Y3R1cmUgQzE1 X1NTaG9ydCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9IGludCBlbmQN CmZ1bmN0b3IgQzE1X1NTaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5U Tl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMTVf VVNob3J0ID0gc3RydWN0IG9wZW4gV29yZDE2IHR5cGUgdCA9IHdvcmQgZW5k DQpmdW5jdG9yIEMxNV9VU2hvcnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9X T1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDE2IChBKQ0Kc3RydWN0dXJl IEMxNV9JbnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5k DQpmdW5jdG9yIEMxNV9JbnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5f QVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE1X1NJ bnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEMxNV9TSW50X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykg PSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMxNV9VSW50ID0g c3RydWN0IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9y IEMxNV9VSW50X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9 IENob29zZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDMTVfTG9uZyA9 IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3Ig QzE1X0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENo b29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE1X1NMb25nID0gc3Ry dWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTVf U0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29z ZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE1X1VMb25nID0gc3RydWN0 IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMxNV9V TG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9v c2VXb3JkTl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzE1X0xvbmdMb25nID0g c3RydWN0IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBD MTVfTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9 IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzE1X1NMb25nTG9u ZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzE1X1NMb25nTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9B UkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAoQSkNCnN0cnVjdHVyZSBDMTVfVUxv bmdMb25nID0gc3RydWN0IG9wZW4gV29yZDY0IHR5cGUgdCA9IHdvcmQgZW5k DQpmdW5jdG9yIEMxNV9VTG9uZ0xvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09T RV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDY0IChBKQ0Kc3RydWN0 dXJlIEMxNV9GbG9hdCA9IHN0cnVjdCBvcGVuIFJlYWwzMiB0eXBlIHQgPSBy ZWFsIGVuZA0KZnVuY3RvciBDMTVfRmxvYXRfQ2hvb3NlUmVhbE4gKEE6IENI T09TRV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDMyIChBKQ0Kc3Ry dWN0dXJlIEMxNV9Eb3VibGUgPSBzdHJ1Y3Qgb3BlbiBSZWFsNjQgdHlwZSB0 ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzE1X0RvdWJsZV9DaG9vc2VSZWFsTiAo QTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9vc2VSZWFsTl9SZWFsNjQgKEEp DQpzdHJ1Y3R1cmUgQzE1X1NpemUgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlw ZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE1X1NpemVfQ2hvb3NlV29yZE4g KEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChB KQ0KDQooKiBDICopDQpzdHJ1Y3R1cmUgQzE2X0NoYXIgPSBzdHJ1Y3Qgb3Bl biBJbnQ4IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE2X0NoYXJfQ2hv b3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50 OCAoQSkNCnN0cnVjdHVyZSBDMTZfU0NoYXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4 IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE2X1NDaGFyX0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDggKEEp DQpzdHJ1Y3R1cmUgQzE2X1VDaGFyID0gc3RydWN0IG9wZW4gV29yZDggdHlw ZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE2X1VDaGFyX0Nob29zZVdvcmRO IChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ4IChB KQ0Kc3RydWN0dXJlIEMxNl9TaG9ydCA9IHN0cnVjdCBvcGVuIEludDE2IHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE2X1Nob3J0X0Nob29zZUludE4g KEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDE2IChBKQ0K c3RydWN0dXJlIEMxNl9TU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBl IHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxNl9TU2hvcnRfQ2hvb3NlSW50TiAo QTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYgKEEpDQpz dHJ1Y3R1cmUgQzE2X1VTaG9ydCA9IHN0cnVjdCBvcGVuIFdvcmQxNiB0eXBl IHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTZfVVNob3J0X0Nob29zZVdvcmRO IChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQxNiAo QSkNCnN0cnVjdHVyZSBDMTZfSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTZfSW50X0Nob29zZUludE4gKEE6 IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3Ry dWN0dXJlIEMxNl9TSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0g aW50IGVuZA0KZnVuY3RvciBDMTZfU0ludF9DaG9vc2VJbnROIChBOiBDSE9P U0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVy ZSBDMTZfVUludCA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3Jk IGVuZA0KZnVuY3RvciBDMTZfVUludF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NF X1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1 cmUgQzE2X0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQg ZW5kDQpmdW5jdG9yIEMxNl9Mb25nX0Nob29zZUludE4gKEE6IENIT09TRV9J TlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMx Nl9TTG9uZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQN CmZ1bmN0b3IgQzE2X1NMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlRO X0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMxNl9V TG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0K ZnVuY3RvciBDMTZfVUxvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JE Tl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0Kc3RydWN0dXJlIEMx Nl9Mb25nTG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBl bmQNCmZ1bmN0b3IgQzE2X0xvbmdMb25nX0Nob29zZUludE4gKEE6IENIT09T RV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChBKQ0Kc3RydWN0dXJl IEMxNl9TTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBlIHQgPSBp bnQgZW5kDQpmdW5jdG9yIEMxNl9TTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTog Q0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1 Y3R1cmUgQzE2X1VMb25nTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQ2NCB0eXBl IHQgPSB3b3JkIGVuZA0KZnVuY3RvciBDMTZfVUxvbmdMb25nX0Nob29zZVdv cmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ2 NCAoQSkNCnN0cnVjdHVyZSBDMTZfRmxvYXQgPSBzdHJ1Y3Qgb3BlbiBSZWFs MzIgdHlwZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzE2X0Zsb2F0X0Nob29z ZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29zZVJlYWxOX1Jl YWwzMiAoQSkNCnN0cnVjdHVyZSBDMTZfRG91YmxlID0gc3RydWN0IG9wZW4g UmVhbDY0IHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMxNl9Eb3VibGVf Q2hvb3NlUmVhbE4gKEE6IENIT09TRV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVh bE5fUmVhbDY0IChBKQ0Kc3RydWN0dXJlIEMxNl9TaXplID0gc3RydWN0IG9w ZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMxNl9TaXpl X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdv cmROX1dvcmQzMiAoQSkNCg0KKCogQyAqKQ0Kc3RydWN0dXJlIEMxN19DaGFy ID0gc3RydWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9y IEMxN19DaGFyX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBD aG9vc2VJbnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzE3X1NDaGFyID0gc3Ry dWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxN19T Q2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3Nl SW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEMxN19VQ2hhciA9IHN0cnVjdCBv cGVuIFdvcmQ4IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMxN19VQ2hh cl9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VX b3JkTl9Xb3JkOCAoQSkNCnN0cnVjdHVyZSBDMTdfU2hvcnQgPSBzdHJ1Y3Qg b3BlbiBJbnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxN19TaG9y dF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50 Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMTdfU1Nob3J0ID0gc3RydWN0IG9w ZW4gSW50MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTdfU1Nob3J0 X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnRO X0ludDE2IChBKQ0Kc3RydWN0dXJlIEMxN19VU2hvcnQgPSBzdHJ1Y3Qgb3Bl biBXb3JkMTYgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE3X1VTaG9y dF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VX b3JkTl9Xb3JkMTYgKEEpDQpzdHJ1Y3R1cmUgQzE3X0ludCA9IHN0cnVjdCBv cGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE3X0ludF9D aG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9J bnQzMiAoQSkNCnN0cnVjdHVyZSBDMTdfU0ludCA9IHN0cnVjdCBvcGVuIElu dDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE3X1NJbnRfQ2hvb3Nl SW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIg KEEpDQpzdHJ1Y3R1cmUgQzE3X1VJbnQgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIg dHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE3X1VJbnRfQ2hvb3NlV29y ZE4gKEE6IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMy IChBKQ0Kc3RydWN0dXJlIEMxN19Mb25nID0gc3RydWN0IG9wZW4gSW50MzIg dHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTdfTG9uZ19DaG9vc2VJbnRO IChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkN CnN0cnVjdHVyZSBDMTdfU0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBl IHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxN19TTG9uZ19DaG9vc2VJbnROIChB OiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0 cnVjdHVyZSBDMTdfVUxvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0 ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE3X1VMb25nX0Nob29zZVdvcmROIChB OiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkN CnN0cnVjdHVyZSBDMTdfTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0 eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMxN19Mb25nTG9uZ19DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAo QSkNCnN0cnVjdHVyZSBDMTdfU0xvbmdMb25nID0gc3RydWN0IG9wZW4gSW50 NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMTdfU0xvbmdMb25nX0No b29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0lu dDY0IChBKQ0Kc3RydWN0dXJlIEMxN19VTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3Bl biBXb3JkNjQgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzE3X1VMb25n TG9uZ19DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9v c2VXb3JkTl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1cmUgQzE3X0Zsb2F0ID0gc3Ry dWN0IG9wZW4gUmVhbDMyIHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMx N19GbG9hdF9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBD aG9vc2VSZWFsTl9SZWFsMzIgKEEpDQpzdHJ1Y3R1cmUgQzE3X0RvdWJsZSA9 IHN0cnVjdCBvcGVuIFJlYWw2NCB0eXBlIHQgPSByZWFsIGVuZA0KZnVuY3Rv ciBDMTdfRG91YmxlX0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJH KSA9IENob29zZVJlYWxOX1JlYWw2NCAoQSkNCnN0cnVjdHVyZSBDMTdfU2l6 ZSA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVu Y3RvciBDMTdfU2l6ZV9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FS RykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQoNCigqIEMgKikNCnN0cnVj dHVyZSBDMThfQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0ID0gaW50 IGVuZA0KZnVuY3RvciBDMThfQ2hhcl9DaG9vc2VJbnROIChBOiBDSE9PU0Vf SU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ4IChBKQ0Kc3RydWN0dXJlIEMx OF9TQ2hhciA9IHN0cnVjdCBvcGVuIEludDggdHlwZSB0ID0gaW50IGVuZA0K ZnVuY3RvciBDMThfU0NoYXJfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5f QVJHKSA9IENob29zZUludE5fSW50OCAoQSkNCnN0cnVjdHVyZSBDMThfVUNo YXIgPSBzdHJ1Y3Qgb3BlbiBXb3JkOCB0eXBlIHQgPSB3b3JkIGVuZA0KZnVu Y3RvciBDMThfVUNoYXJfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9B UkcpID0gQ2hvb3NlV29yZE5fV29yZDggKEEpDQpzdHJ1Y3R1cmUgQzE4X1No b3J0ID0gc3RydWN0IG9wZW4gSW50MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVu Y3RvciBDMThfU2hvcnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJH KSA9IENob29zZUludE5fSW50MTYgKEEpDQpzdHJ1Y3R1cmUgQzE4X1NTaG9y dCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzE4X1NTaG9ydF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcp ID0gQ2hvb3NlSW50Tl9JbnQxNiAoQSkNCnN0cnVjdHVyZSBDMThfVVNob3J0 ID0gc3RydWN0IG9wZW4gV29yZDE2IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5j dG9yIEMxOF9VU2hvcnRfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9B UkcpID0gQ2hvb3NlV29yZE5fV29yZDE2IChBKQ0Kc3RydWN0dXJlIEMxOF9J bnQgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5j dG9yIEMxOF9JbnRfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9 IENob29zZUludE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE4X1NJbnQgPSBz dHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMx OF9TSW50X0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9v c2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMxOF9VSW50ID0gc3RydWN0 IG9wZW4gV29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMxOF9V SW50X0Nob29zZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29z ZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVjdHVyZSBDMThfTG9uZyA9IHN0cnVj dCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE4X0xv bmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUlu dE5fSW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE4X1NMb25nID0gc3RydWN0IG9w ZW4gSW50MzIgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMThfU0xvbmdf Q2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5f SW50MzIgKEEpDQpzdHJ1Y3R1cmUgQzE4X1VMb25nID0gc3RydWN0IG9wZW4g V29yZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMxOF9VTG9uZ19D aG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3Jk Tl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzE4X0xvbmdMb25nID0gc3RydWN0 IG9wZW4gSW50NjQgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMThfTG9u Z0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29z ZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUgQzE4X1NMb25nTG9uZyA9IHN0 cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE4 X1NMb25nTG9uZ19DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0g Q2hvb3NlSW50Tl9JbnQ2NCAoQSkNCnN0cnVjdHVyZSBDMThfVUxvbmdMb25n ID0gc3RydWN0IG9wZW4gV29yZDY0IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5j dG9yIEMxOF9VTG9uZ0xvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JE Tl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDY0IChBKQ0Kc3RydWN0dXJlIEMx OF9GbG9hdCA9IHN0cnVjdCBvcGVuIFJlYWwzMiB0eXBlIHQgPSByZWFsIGVu ZA0KZnVuY3RvciBDMThfRmxvYXRfQ2hvb3NlUmVhbE4gKEE6IENIT09TRV9S RUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVhbDMyIChBKQ0Kc3RydWN0dXJl IEMxOF9Eb3VibGUgPSBzdHJ1Y3Qgb3BlbiBSZWFsNjQgdHlwZSB0ID0gcmVh bCBlbmQNCmZ1bmN0b3IgQzE4X0RvdWJsZV9DaG9vc2VSZWFsTiAoQTogQ0hP T1NFX1JFQUxOX0FSRykgPSBDaG9vc2VSZWFsTl9SZWFsNjQgKEEpDQpzdHJ1 Y3R1cmUgQzE4X1NpemUgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0ID0g d29yZCBlbmQNCmZ1bmN0b3IgQzE4X1NpemVfQ2hvb3NlV29yZE4gKEE6IENI T09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0KDQoo KiBDICopDQpzdHJ1Y3R1cmUgQzE5X0NoYXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4 IHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzE5X0NoYXJfQ2hvb3NlSW50 TiAoQTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50OCAoQSkN CnN0cnVjdHVyZSBDMTlfU0NoYXIgPSBzdHJ1Y3Qgb3BlbiBJbnQ4IHR5cGUg dCA9IGludCBlbmQNCmZ1bmN0b3IgQzE5X1NDaGFyX0Nob29zZUludE4gKEE6 IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDggKEEpDQpzdHJ1 Y3R1cmUgQzE5X1VDaGFyID0gc3RydWN0IG9wZW4gV29yZDggdHlwZSB0ID0g d29yZCBlbmQNCmZ1bmN0b3IgQzE5X1VDaGFyX0Nob29zZVdvcmROIChBOiBD SE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ4IChBKQ0Kc3Ry dWN0dXJlIEMxOV9TaG9ydCA9IHN0cnVjdCBvcGVuIEludDE2IHR5cGUgdCA9 IGludCBlbmQNCmZ1bmN0b3IgQzE5X1Nob3J0X0Nob29zZUludE4gKEE6IENI T09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDE2IChBKQ0Kc3RydWN0 dXJlIEMxOV9TU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJbnQxNiB0eXBlIHQgPSBp bnQgZW5kDQpmdW5jdG9yIEMxOV9TU2hvcnRfQ2hvb3NlSW50TiAoQTogQ0hP T1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MTYgKEEpDQpzdHJ1Y3R1 cmUgQzE5X1VTaG9ydCA9IHN0cnVjdCBvcGVuIFdvcmQxNiB0eXBlIHQgPSB3 b3JkIGVuZA0KZnVuY3RvciBDMTlfVVNob3J0X0Nob29zZVdvcmROIChBOiBD SE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQxNiAoQSkNCnN0 cnVjdHVyZSBDMTlfSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0g aW50IGVuZA0KZnVuY3RvciBDMTlfSW50X0Nob29zZUludE4gKEE6IENIT09T RV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJl IEMxOV9TSW50ID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0ID0gaW50IGVu ZA0KZnVuY3RvciBDMTlfU0ludF9DaG9vc2VJbnROIChBOiBDSE9PU0VfSU5U Tl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVyZSBDMTlf VUludCA9IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0K ZnVuY3RvciBDMTlfVUludF9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkRO X0FSRykgPSBDaG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQpzdHJ1Y3R1cmUgQzE5 X0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBpbnQgZW5kDQpm dW5jdG9yIEMxOV9Mb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FS RykgPSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMxOV9TTG9u ZyA9IHN0cnVjdCBvcGVuIEludDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0 b3IgQzE5X1NMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykg PSBDaG9vc2VJbnROX0ludDMyIChBKQ0Kc3RydWN0dXJlIEMxOV9VTG9uZyA9 IHN0cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3Rv ciBDMTlfVUxvbmdfQ2hvb3NlV29yZE4gKEE6IENIT09TRV9XT1JETl9BUkcp ID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0Kc3RydWN0dXJlIEMxOV9Mb25n TG9uZyA9IHN0cnVjdCBvcGVuIEludDY0IHR5cGUgdCA9IGludCBlbmQNCmZ1 bmN0b3IgQzE5X0xvbmdMb25nX0Nob29zZUludE4gKEE6IENIT09TRV9JTlRO X0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChBKQ0Kc3RydWN0dXJlIEMxOV9T TG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBlIHQgPSBpbnQgZW5k DQpmdW5jdG9yIEMxOV9TTG9uZ0xvbmdfQ2hvb3NlSW50TiAoQTogQ0hPT1NF X0lOVE5fQVJHKSA9IENob29zZUludE5fSW50NjQgKEEpDQpzdHJ1Y3R1cmUg QzE5X1VMb25nTG9uZyA9IHN0cnVjdCBvcGVuIFdvcmQ2NCB0eXBlIHQgPSB3 b3JkIGVuZA0KZnVuY3RvciBDMTlfVUxvbmdMb25nX0Nob29zZVdvcmROIChB OiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQ2NCAoQSkN CnN0cnVjdHVyZSBDMTlfRmxvYXQgPSBzdHJ1Y3Qgb3BlbiBSZWFsMzIgdHlw ZSB0ID0gcmVhbCBlbmQNCmZ1bmN0b3IgQzE5X0Zsb2F0X0Nob29zZVJlYWxO IChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENob29zZVJlYWxOX1JlYWwzMiAo QSkNCnN0cnVjdHVyZSBDMTlfRG91YmxlID0gc3RydWN0IG9wZW4gUmVhbDY0 IHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMxOV9Eb3VibGVfQ2hvb3Nl UmVhbE4gKEE6IENIT09TRV9SRUFMTl9BUkcpID0gQ2hvb3NlUmVhbE5fUmVh bDY0IChBKQ0Kc3RydWN0dXJlIEMxOV9TaXplID0gc3RydWN0IG9wZW4gV29y ZDMyIHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMxOV9TaXplX0Nob29z ZVdvcmROIChBOiBDSE9PU0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dv cmQzMiAoQSkNCg0KKCogQyAqKQ0Kc3RydWN0dXJlIEMyMF9DaGFyID0gc3Ry dWN0IG9wZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMyMF9D aGFyX0Nob29zZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJ bnROX0ludDggKEEpDQpzdHJ1Y3R1cmUgQzIwX1NDaGFyID0gc3RydWN0IG9w ZW4gSW50OCB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMyMF9TQ2hhcl9D aG9vc2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9J bnQ4IChBKQ0Kc3RydWN0dXJlIEMyMF9VQ2hhciA9IHN0cnVjdCBvcGVuIFdv cmQ4IHR5cGUgdCA9IHdvcmQgZW5kDQpmdW5jdG9yIEMyMF9VQ2hhcl9DaG9v c2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9X b3JkOCAoQSkNCnN0cnVjdHVyZSBDMjBfU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBJ bnQxNiB0eXBlIHQgPSBpbnQgZW5kDQpmdW5jdG9yIEMyMF9TaG9ydF9DaG9v c2VJbnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQx NiAoQSkNCnN0cnVjdHVyZSBDMjBfU1Nob3J0ID0gc3RydWN0IG9wZW4gSW50 MTYgdHlwZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMjBfU1Nob3J0X0Nob29z ZUludE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDE2 IChBKQ0Kc3RydWN0dXJlIEMyMF9VU2hvcnQgPSBzdHJ1Y3Qgb3BlbiBXb3Jk MTYgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzIwX1VTaG9ydF9DaG9v c2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3JkTl9X b3JkMTYgKEEpDQpzdHJ1Y3R1cmUgQzIwX0ludCA9IHN0cnVjdCBvcGVuIElu dDMyIHR5cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzIwX0ludF9DaG9vc2VJ bnROIChBOiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAo QSkNCnN0cnVjdHVyZSBDMjBfU0ludCA9IHN0cnVjdCBvcGVuIEludDMyIHR5 cGUgdCA9IGludCBlbmQNCmZ1bmN0b3IgQzIwX1NJbnRfQ2hvb3NlSW50TiAo QTogQ0hPT1NFX0lOVE5fQVJHKSA9IENob29zZUludE5fSW50MzIgKEEpDQpz dHJ1Y3R1cmUgQzIwX1VJbnQgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0 ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzIwX1VJbnRfQ2hvb3NlV29yZE4gKEE6 IENIT09TRV9XT1JETl9BUkcpID0gQ2hvb3NlV29yZE5fV29yZDMyIChBKQ0K c3RydWN0dXJlIEMyMF9Mb25nID0gc3RydWN0IG9wZW4gSW50MzIgdHlwZSB0 ID0gaW50IGVuZA0KZnVuY3RvciBDMjBfTG9uZ19DaG9vc2VJbnROIChBOiBD SE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVj dHVyZSBDMjBfU0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQzMiB0eXBlIHQgPSBp bnQgZW5kDQpmdW5jdG9yIEMyMF9TTG9uZ19DaG9vc2VJbnROIChBOiBDSE9P U0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQzMiAoQSkNCnN0cnVjdHVy ZSBDMjBfVUxvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3JkMzIgdHlwZSB0ID0gd29y ZCBlbmQNCmZ1bmN0b3IgQzIwX1VMb25nX0Nob29zZVdvcmROIChBOiBDSE9P U0VfV09SRE5fQVJHKSA9IENob29zZVdvcmROX1dvcmQzMiAoQSkNCnN0cnVj dHVyZSBDMjBfTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBJbnQ2NCB0eXBlIHQg PSBpbnQgZW5kDQpmdW5jdG9yIEMyMF9Mb25nTG9uZ19DaG9vc2VJbnROIChB OiBDSE9PU0VfSU5UTl9BUkcpID0gQ2hvb3NlSW50Tl9JbnQ2NCAoQSkNCnN0 cnVjdHVyZSBDMjBfU0xvbmdMb25nID0gc3RydWN0IG9wZW4gSW50NjQgdHlw ZSB0ID0gaW50IGVuZA0KZnVuY3RvciBDMjBfU0xvbmdMb25nX0Nob29zZUlu dE4gKEE6IENIT09TRV9JTlROX0FSRykgPSBDaG9vc2VJbnROX0ludDY0IChB KQ0Kc3RydWN0dXJlIEMyMF9VTG9uZ0xvbmcgPSBzdHJ1Y3Qgb3BlbiBXb3Jk NjQgdHlwZSB0ID0gd29yZCBlbmQNCmZ1bmN0b3IgQzIwX1VMb25nTG9uZ19D aG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBDaG9vc2VXb3Jk Tl9Xb3JkNjQgKEEpDQpzdHJ1Y3R1cmUgQzIwX0Zsb2F0ID0gc3RydWN0IG9w ZW4gUmVhbDMyIHR5cGUgdCA9IHJlYWwgZW5kDQpmdW5jdG9yIEMyMF9GbG9h dF9DaG9vc2VSZWFsTiAoQTogQ0hPT1NFX1JFQUxOX0FSRykgPSBDaG9vc2VS ZWFsTl9SZWFsMzIgKEEpDQpzdHJ1Y3R1cmUgQzIwX0RvdWJsZSA9IHN0cnVj dCBvcGVuIFJlYWw2NCB0eXBlIHQgPSByZWFsIGVuZA0KZnVuY3RvciBDMjBf RG91YmxlX0Nob29zZVJlYWxOIChBOiBDSE9PU0VfUkVBTE5fQVJHKSA9IENo b29zZVJlYWxOX1JlYWw2NCAoQSkNCnN0cnVjdHVyZSBDMjBfU2l6ZSA9IHN0 cnVjdCBvcGVuIFdvcmQzMiB0eXBlIHQgPSB3b3JkIGVuZA0KZnVuY3RvciBD MjBfU2l6ZV9DaG9vc2VXb3JkTiAoQTogQ0hPT1NFX1dPUkROX0FSRykgPSBD aG9vc2VXb3JkTl9Xb3JkMzIgKEEpDQoNCg== --1417689696-313439160-1139069720=:15050-- From fluet@cs.cornell.edu Sat Feb 4 22:58:34 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Sat, 4 Feb 2006 17:58:34 -0500 (EST) Subject: [MLton] IntInf implementation questions Message-ID: I have a few questions/suggestions for the IntInf implemenation: 1) Why does the fill function in IntInf.c require space for 2 limbs, rather than just space for 1 limb? It seems that we only use one limb. 2) Is there a reason that IntInf_{quot,rem} have such complicated implementations, rather than simply using mpz_tdiv_{q,r}? Those GMP functions appear to have the right semantics. 3) Why does the bigMul function in int-inf.sml make use of an _import-ed multiplication function for small multiplication? Wouldn't it be more efficient to perform the multiplication with Int.* and handle the overflow? Even on the C-codegen, overflow checking primitives are inlined, and with the x86-codegen I see a considerable speed up on an IntInf.int factorial benchmark that is dominated by small multiplications. From MLton@mlton.org Sun Feb 5 00:07:22 2006 From: MLton@mlton.org (Stephen Weeks) Date: Sat, 4 Feb 2006 16:07:22 -0800 Subject: [MLton] IntInf implementation questions In-Reply-To: References: Message-ID: <17381.16826.232463.731288@eponym.sweeks.com> > 3) Why does the bigMul function in int-inf.sml make use of an _import-ed > multiplication function for small multiplication? I think this is an artefact of the long-gone days before MLton supported overflow. It seems fine to replace as you suggest. From MLton@mlton.org Sun Feb 5 01:20:41 2006 From: MLton@mlton.org (Stephen Weeks) Date: Sat, 4 Feb 2006 17:20:41 -0800 Subject: [MLton] IntInf implementation questions In-Reply-To: <17381.16826.232463.731288@eponym.sweeks.com> References: <17381.16826.232463.731288@eponym.sweeks.com> Message-ID: <17381.21225.65616.365374@eponym.sweeks.com> > I think this is an artefact of the long-gone days before MLton > supported overflow. It seems fine to replace as you suggest. In fact, since the IntInf implementation has not been substantially revised since those days, it probably has a number of similar artefacts that would benefit from rewriting to take advantage of overflow. From MLton@mlton.org Sun Feb 5 01:56:40 2006 From: MLton@mlton.org (Stephen Weeks) Date: Sat, 4 Feb 2006 17:56:40 -0800 Subject: [MLton] Elaborator bug In-Reply-To: References: Message-ID: <17381.23384.491880.866559@eponym.sweeks.com> > The attached source exhibits the following bug: > ElaborateEnv.functorClosure: firstTycons > > I note that the bug is sensitive to the _number_ of structure/functor > bindings made. That was the key observation. I made a simple example, to be evaluated in the _prim environment, that shows the problem. ------------------------------------------------------------ structure S = struct end functor F () = S ... (* 84 F's in total *) functor F () = S ------------------------------------------------------------ As soon as I saw how dependent it was on the number, I began to think "what is so special about 84?". Somehow, my brain managed to guess that that was about the number of primitive type constructors that MLton supports. And in fact, mlton -show-basis reveals that there are exactly 84 primitive tycons. From there, it was easy to see that the functorClosure code was mistakenly removing one element from the allTycons list for each functor definition. I've committed a fix. From henry.cejtin@sbcglobal.net Sun Feb 5 04:19:32 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Sat, 04 Feb 2006 22:19:32 -0600 Subject: [MLton] IntInf implementation questions In-Reply-To: Message-ID: Re point 3, certainly the reason is that originally overflow wasn't handled. It was just an error (or ignored). From vesa.karvonen@cs.helsinki.fi Mon Feb 6 01:04:45 2006 From: vesa.karvonen@cs.helsinki.fi (Vesa Karvonen) Date: Mon, 6 Feb 2006 03:04:45 +0200 Subject: [MLton] MLB file tree Message-ID: <1139187885.43e6a0ad98fe7@www2.helsinki.fi> This message is in MIME format. ---MOQ1139187885e2f93701c5dc816d180674dbc4be8769 Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: 7bit Attached is a draft patch for a new option "-stop ft" to print the "MLB file tree". Also attached is the output (compressed with gzip) produced by running mlton -stop ft ~/work/sml/mlton/mlton/mlton/mlton.mlb on my machine. The file tree is useful for analyzing the (dependency) structure of a project. Using standard text processing commands (grep, sed, ...) you can fairly easily extract information from the file tree, such as a list of all MLB files used by a project or the same output as produced by "-stop f". I implemented the option, because I wanted to know which MLB-files are actually used when MLton is compiled, so that I can go through them to better understand how much work it might require to get MLton to compile under MLKit. Known caveats: The "-stop ft" option is only handled properly when the input to the compiler is a MLB-file. -Vesa Karvonen ---MOQ1139187885e2f93701c5dc816d180674dbc4be8769 Content-Type: text/x-patch; name="stop-ft.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="stop-ft.patch" SW5kZXg6IG1sdG9uL21haW4vY29tcGlsZS5mdW4KPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbWx0b24vbWFpbi9j b21waWxlLmZ1bgkocmV2aXNpb24gNDM0NykKKysrIG1sdG9uL21haW4vY29tcGlsZS5mdW4JKHdv cmtpbmcgY29weSkKQEAgLTM0NSw2ICszNDUsOSBAQAogICAgICAgYXN0CiAgICBlbmQKIAorZnVu IGZvckZpbGVUcmVlTUxCICh7aW5wdXR9LCBjYWxsYmFja3MpID0KKyAgIEFzdC5CYXNkZWMuZm9y RmlsZVRyZWUgKGxleEFuZFBhcnNlTUxCIChNTEJTdHJpbmcuZnJvbUZpbGUgaW5wdXQpLCBjYWxs YmFja3MpCisKIGZ1biBzb3VyY2VGaWxlc01MQiB7aW5wdXR9ID0KICAgIEFzdC5CYXNkZWMuc291 cmNlRmlsZXMgKGxleEFuZFBhcnNlTUxCIChNTEJTdHJpbmcuZnJvbUZpbGUgaW5wdXQpKQogCklu ZGV4OiBtbHRvbi9tYWluL2NvbXBpbGUuc2lnCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIG1sdG9uL21haW4vY29t cGlsZS5zaWcJKHJldmlzaW9uIDQzNDcpCisrKyBtbHRvbi9tYWluL2NvbXBpbGUuc2lnCSh3b3Jr aW5nIGNvcHkpCkBAIC0zMCw2ICszMCwxMCBAQAogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBkb25lOiB1bml0IC0+IHVuaXR9fSAtPiB1bml0CiAgICAgICB2YWwgZWxh Ym9yYXRlTUxCOiB7aW5wdXQ6IEZpbGUudH0gLT4gdW5pdAogICAgICAgdmFsIGVsYWJvcmF0ZVNN TDoge2lucHV0OiBGaWxlLnQgbGlzdH0gLT4gdW5pdAorICAgICAgdmFsIGZvckZpbGVUcmVlTUxC OiB7aW5wdXQ6IEZpbGUudH0gKgorICAgICAgICAgICAgICAgICAgICAgICAgICB7c3RhcnRNTEI6 IEZpbGUudCAtPiB7bmVzdDogYm9vbH0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICBmaW5p c2hNTEI6IEZpbGUudCAtPiB1bml0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgc291cmNl RmlsZTogRmlsZS50IC0+IHVuaXR9IC0+IHVuaXQKICAgICAgIHZhbCBzZXRDb21tYW5kTGluZUNv bnN0YW50OiB7bmFtZTogc3RyaW5nLCB2YWx1ZTogc3RyaW5nfSAtPiB1bml0CiAgICAgICB2YWwg c291cmNlRmlsZXNNTEI6IHtpbnB1dDogRmlsZS50fSAtPiBGaWxlLnQgdmVjdG9yCiAgICAgICAo KiBvdXRwdXQgYSBDIGZpbGUgdG8gcHJpbnQgb3V0IHRoZSBiYXNpcyBjb25zdGFudHMuICopCklu ZGV4OiBtbHRvbi9tYWluL21haW4uZnVuCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIG1sdG9uL21haW4vbWFpbi5m dW4JKHJldmlzaW9uIDQzNDcpCisrKyBtbHRvbi9tYWluL21haW4uZnVuCSh3b3JraW5nIGNvcHkp CkBAIC0xNSwxMSArMTUsMTIgQEAKIAogc3RydWN0dXJlIFBsYWNlID0KICAgIHN0cnVjdAotICAg ICAgZGF0YXR5cGUgdCA9IENNIHwgRmlsZXMgfCBHZW5lcmF0ZWQgfCBNTEIgfCBPIHwgT1VUIHwg U01MIHwgVHlwZUNoZWNrCisgICAgICBkYXRhdHlwZSB0ID0gQ00gfCBGaWxlcyB8IEdlbmVyYXRl ZCB8IE1MQiB8IE8gfCBPVVQgfCBTTUwgfCBUcmVlIHwgVHlwZUNoZWNrCiAKICAgICAgIHZhbCB0 b0ludDogdCAtPiBpbnQgPQogICAgICAgICAgZm4gTUxCID0+IDEKICAgICAgICAgICB8IENNID0+ IDEKKyAgICAgICAgICB8IFRyZWUgPT4gMgogICAgICAgICAgIHwgRmlsZXMgPT4gMgogICAgICAg ICAgIHwgU01MID0+IDMKICAgICAgICAgICB8IFR5cGVDaGVjayA9PiA0CkBAIC0yOSw2ICszMCw3 IEBACiAKICAgICAgIHZhbCB0b1N0cmluZyA9CiAgICAgICAgICBmbiBDTSA9PiAiY20iCisgICAg ICAgICAgfCBUcmVlID0+ICJ0cmVlIgogICAgICAgICAgIHwgRmlsZXMgPT4gImZpbGVzIgogICAg ICAgICAgIHwgU01MID0+ICJzbWwiCiAgICAgICAgICAgfCBNTEIgPT4gIm1sYiIKQEAgLTQyNywx MiArNDI5LDEzIEBACiAgICAgICAgICBjYXNlICFDb250cm9sLnNzYTJQYXNzZXNTZXQgKE9wdFBh c3Nlc0N1c3RvbSBzKSBvZgogICAgICAgICAgICAgUmVzdWx0LlllcyAoKSA9PiAoKQogICAgICAg ICAgIHwgUmVzdWx0Lk5vIHMnID0+IHVzYWdlIChjb25jYXQgWyJpbnZhbGlkIC1zc2EyLXBhc3Mg YXJnOiAiLCBzJ10pKSksCi0gICAgICAgKE5vcm1hbCwgInN0b3AiLCAiIHtmfGd8b3xzbWx8dGN9 IiwgIndoZW4gdG8gc3RvcCIsCisgICAgICAgKE5vcm1hbCwgInN0b3AiLCAiIHtmfGZ0fGd8b3xz bWx8dGN9IiwgIndoZW4gdG8gc3RvcCIsCiAgICAgICAgIFNwYWNlU3RyaW5nCiAgICAgICAgIChm biBzID0+CiAgICAgICAgICBzdG9wIDo9IChjYXNlIHMgb2YKICAgICAgICAgICAgICAgICAgICAg ICJmIiA9PiBQbGFjZS5GaWxlcwotICAgICAgICAgICAgICAgICAgIHwgImciID0+IFBsYWNlLkdl bmVyYXRlZCAgICAgCisgICAgICAgICAgICAgICAgICAgfCAiZnQiID0+IFBsYWNlLlRyZWUKKyAg ICAgICAgICAgICAgICAgICB8ICJnIiA9PiBQbGFjZS5HZW5lcmF0ZWQKICAgICAgICAgICAgICAg ICAgICB8ICJvIiA9PiBQbGFjZS5PCiAgICAgICAgICAgICAgICAgICAgfCAic21sIiA9PiBQbGFj ZS5TTUwKICAgICAgICAgICAgICAgICAgICB8ICJ0YyIgPT4gUGxhY2UuVHlwZUNoZWNrCkBAIC05 ODgsNiArOTkxLDQ2IEBACiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQbGFjZS5GaWxl cyA9PgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc2hvd0ZpbGVzCiAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAoQ29tcGlsZS5zb3VyY2VGaWxlc01MQiB7aW5wdXQg PSBmaWxlfSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB8IFBsYWNlLlRyZWUgPT4KKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxldAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdmFsIHBzaTogRmlsZS50IC0+IGJvb2wgcmVmID0KKyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIFN0cmluZy5tZW1vaXplIChmbiBfID0+IHJlZiBm YWxzZSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZhbCBzdGVwID0gMgor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdmFsIGluZGVudCA9IHJlZiAwCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmdW4gc3BhY2VzIG4gPQorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ2hhclZlY3Rvci50YWJ1bGF0ZSAobiwg Zm4gXyA9PiAjIiAiKQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZnVuIHBy aW50TG4gdGV4dCA9CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwcmlu dCAoY29uY2F0IFtzcGFjZXMgKCFpbmRlbnQpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgdGV4dCwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJcbiJdKQorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgZnVuIHN0YXJ0TUxCIG5hbWUgPQorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgbGV0CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB2YWwgYiA9IHBzaSBuYW1lCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBpbgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg cHJpbnRMbiBuYW1lCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA7 IGluZGVudCA6PSAhaW5kZW50ICsgc3RlcAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgOyBwcmludExuICJ7IgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgOyBpbmRlbnQgOj0gIWluZGVudCArIHN0ZXAKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIDsgaWYgIWIKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdGhlbiAocHJpbnRMbiAiW2FscmVhZHkgc2hvd25dIgor ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA7IHtu ZXN0ID0gZmFsc2V9KQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBlbHNlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChi IDo9IHRydWUKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IDsge25lc3QgPSB0cnVlfSkKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGVuZAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZnVuIGZpbmlzaE1MQiBf ID0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChpbmRlbnQgOj0gIWlu ZGVudCAtIHN0ZXAKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA7IHBy aW50TG4gIn0iCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOyBpbmRl bnQgOj0gIWluZGVudCAtIHN0ZXApCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBmdW4gc291cmNlRmlsZSBuYW1lID0KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHByaW50TG4gbmFtZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW4K KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBpbGUuZm9yRmlsZVRyZWVN TEIKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICh7aW5wdXQgPSBmaWxlfSwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7c3RhcnRNTEIgPSBzdGFydE1M QiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmluaXNoTUxCID0gZmlu aXNoTUxCLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzb3VyY2VGaWxl ID0gc291cmNlRmlsZX0pCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbmQKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICB8IFBsYWNlLlNNTCA9PiBzYXZlU01MIChtYXliZU91 dCAiLnNtbCIpCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCBQbGFjZS5UeXBlQ2hlY2sg PT4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRyYWNlIChUb3AsICJUeXBlIENo ZWNrIFNNTCIpCkBAIC0xMDAyLDYgKzEwNDUsNyBAQAogICAgICAgICAgICAgICAgICAgICAgaW4K ICAgICAgICAgICAgICAgICAgICAgICAgIGNhc2Ugc3RvcCBvZgogICAgICAgICAgICAgICAgICAg ICAgICAgICAgUGxhY2UuRmlsZXMgPT4gKCkKKyAgICAgICAgICAgICAgICAgICAgICAgICB8IFBs YWNlLlRyZWUgPT4gKCkKICAgICAgICAgICAgICAgICAgICAgICAgICB8IFBsYWNlLlNNTCA9PiAo KQogICAgICAgICAgICAgICAgICAgICAgICAgIHwgUGxhY2UuVHlwZUNoZWNrID0+ICgpCiAgICAg ICAgICAgICAgICAgICAgICAgICAgfCBQbGFjZS5HZW5lcmF0ZWQgPT4gKCkKSW5kZXg6IG1sdG9u L2FzdC9hc3QtbWxicy5zaWcKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gbWx0b24vYXN0L2FzdC1tbGJzLnNpZwko cmV2aXNpb24gNDM0NykKKysrIG1sdG9uL2FzdC9hc3QtbWxicy5zaWcJKHdvcmtpbmcgY29weSkK QEAgLTU3LDYgKzU3LDkgQEAKICAgICAgICAgICAgIHZhbCBiYXNpczoge25hbWU6IEJhc2lkLnQs IGRlZjogQmFzZXhwLnR9IHZlY3RvciAtPiB0CiAgICAgICAgICAgICB2YWwgZGVmczogTW9kSWRC aW5kLnQgLT4gdAogICAgICAgICAgICAgdmFsIGVtcHR5OiB0CisgICAgICAgICAgICB2YWwgZm9y RmlsZVRyZWU6IHQgKiB7c3RhcnRNTEI6IEZpbGUudCAtPiB7bmVzdDogYm9vbH0sCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgZmluaXNoTUxCOiBGaWxlLnQgLT4gdW5pdCwKKyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzb3VyY2VGaWxlOiBGaWxlLnQgLT4gdW5p dH0gLT4gdW5pdAogICAgICAgICAgICAgdmFsIGxvY2FsbDogdCAqIHQgLT4gdAogICAgICAgICAg ICAgdmFsIG1sYjoge2ZpbGVBYnM6IEZpbGUudCwgZmlsZVVzZTogRmlsZS50fSAqIHQgUHJvbWlz ZS50IC0+IHQKICAgICAgICAgICAgIHZhbCBvcGVubjogQmFzaWQudCB2ZWN0b3IgLT4gdApJbmRl eDogbWx0b24vYXN0L2FzdC1tbGJzLmZ1bgo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBtbHRvbi9hc3QvYXN0LW1s YnMuZnVuCShyZXZpc2lvbiA0MzQ3KQorKysgbWx0b24vYXN0L2FzdC1tbGJzLmZ1bgkod29ya2lu ZyBjb3B5KQpAQCAtMTMsNyArMTMsNyBAQAogCiBzdHJ1Y3R1cmUgQXN0UHJvZ3JhbXMgPSBBc3RQ cm9ncmFtcyAoUykKIAotb3BlbiBBc3RQcm9ncmFtcyBMYXlvdXQKK29wZW4gQXN0UHJvZ3JhbXMK ICAgIAogdmFsIGxheW91dHMgPSBMaXN0Lm1hcAogc3RydWN0dXJlIFdyYXAgPSBSZWdpb24uV3Jh cApAQCAtNDAsMzQgKzQwLDM4IEBACiB3aXRodHlwZSBiYXNleHAgPSBiYXNleHBOb2RlIFdyYXAu dAogICAgICBhbmQgYmFzZGVjID0gYmFzZGVjTm9kZSBXcmFwLnQKIAotZnVuIGxheW91dEJhc2V4 cCBleHAgPQotICAgY2FzZSBub2RlIGV4cCBvZgotICAgICAgQmFzIGRlYyA9PiBhbGlnbiBbc3Ry ICJiYXMiLCBpbmRlbnQgKGxheW91dEJhc2RlYyBkZWMsIDMpLCBzdHIgImVuZCJdCi0gICAgfCBM ZXQgKGRlYywgZXhwKSA9PiBQcmV0dHkubGV0dCAobGF5b3V0QmFzZGVjIGRlYywgbGF5b3V0QmFz ZXhwIGV4cCkKLSAgICB8IFZhciBiYXNpZCA9PiBCYXNpZC5sYXlvdXQgYmFzaWQgCi1hbmQgbGF5 b3V0QmFzZGVjIGRlYyA9Ci0gICBjYXNlIG5vZGUgZGVjIG9mCi0gICAgICBBbm4gKGFubnMsXywg ZGVjKSA9PgotICAgICAgICAgYWxpZ24gW3N0ciAiYW5uIiwgCi0gICAgICAgICAgICAgICAgaW5k ZW50IChzZXEgW3N0ciBTdHJpbmcuZHF1b3RlLCBzdHIgYW5ucywgc3RyIFN0cmluZy5kcXVvdGVd LCAzKSwKLSAgICAgICAgICAgICAgICBzdHIgImluIiwgCi0gICAgICAgICAgICAgICAgaW5kZW50 IChsYXlvdXRCYXNkZWMgZGVjLCAzKSwgCi0gICAgICAgICAgICAgICAgc3RyICJlbmQiXQotICAg IHwgQmFzaXMgYmFzYm5kcyA9PgotICAgICAgICAgbGF5b3V0QW5kc0JpbmQKLSAgICAgICAgICgi YmFzaXMiLCAiPSIsIGJhc2JuZHMsIGZuIHtuYW1lLCBkZWZ9ID0+Ci0gICAgICAgICAgKGNhc2Ug bm9kZSBkZWYgb2YgVmFyIF8gPT4gT25lTGluZSB8IF8gPT4gU3BsaXQgMywKLSAgICAgICAgICAg QmFzaWQubGF5b3V0IG5hbWUsIGxheW91dEJhc2V4cCBkZWYpKQotICAgIHwgRGVmcyBkZWYgPT4g TW9kSWRCaW5kLmxheW91dCBkZWYKLSAgICB8IExvY2FsIChkZWMxLCBkZWMyKSA9PiBQcmV0dHku bG9jYWxsIChsYXlvdXRCYXNkZWMgZGVjMSwgbGF5b3V0QmFzZGVjIGRlYzIpIAotICAgIHwgTUxC ICh7ZmlsZVVzZSwgLi4ufSwgXykgPT4gRmlsZS5sYXlvdXQgZmlsZVVzZQotICAgIHwgT3BlbiBi cyA9PiBzZXEgW3N0ciAib3BlbiAiLAotICAgICAgICAgICAgICAgICAgICAgIHNlcSAoc2VwYXJh dGUgKFZlY3Rvci50b0xpc3RNYXAgKGJzLCBCYXNpZC5sYXlvdXQpLAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICIgIikpXSAKLSAgICB8IFByaW0gPT4gc3RyICJfcHJpbSIK LSAgICB8IFByb2cgKHtmaWxlVXNlLCAuLi59LCBfKSA9PiBGaWxlLmxheW91dCBmaWxlVXNlCi0g ICAgfCBTZXEgZGVjcyA9PiBhbGlnbiAobGF5b3V0QmFzZGVjcyBkZWNzKQotYW5kIGxheW91dEJh c2RlY3MgZGVjcyA9IGxheW91dHMgKGRlY3MsIGxheW91dEJhc2RlYykKK2xvY2FsCisgICBvcGVu IExheW91dAoraW4KKyAgIGZ1biBsYXlvdXRCYXNleHAgZXhwID0KKyAgICAgIGNhc2Ugbm9kZSBl eHAgb2YKKyAgICAgICAgIEJhcyBkZWMgPT4gYWxpZ24gW3N0ciAiYmFzIiwgaW5kZW50IChsYXlv dXRCYXNkZWMgZGVjLCAzKSwgc3RyICJlbmQiXQorICAgICAgIHwgTGV0IChkZWMsIGV4cCkgPT4g UHJldHR5LmxldHQgKGxheW91dEJhc2RlYyBkZWMsIGxheW91dEJhc2V4cCBleHApCisgICAgICAg fCBWYXIgYmFzaWQgPT4gQmFzaWQubGF5b3V0IGJhc2lkIAorICAgYW5kIGxheW91dEJhc2RlYyBk ZWMgPQorICAgICAgY2FzZSBub2RlIGRlYyBvZgorICAgICAgICAgQW5uIChhbm5zLF8sIGRlYykg PT4KKyAgICAgICAgICAgIGFsaWduIFtzdHIgImFubiIsIAorICAgICAgICAgICAgICAgICAgIGlu ZGVudCAoc2VxIFtzdHIgU3RyaW5nLmRxdW90ZSwgc3RyIGFubnMsIHN0ciBTdHJpbmcuZHF1b3Rl XSwgMyksCisgICAgICAgICAgICAgICAgICAgc3RyICJpbiIsIAorICAgICAgICAgICAgICAgICAg IGluZGVudCAobGF5b3V0QmFzZGVjIGRlYywgMyksIAorICAgICAgICAgICAgICAgICAgIHN0ciAi ZW5kIl0KKyAgICAgICB8IEJhc2lzIGJhc2JuZHMgPT4KKyAgICAgICAgICAgIGxheW91dEFuZHNC aW5kCisgICAgICAgICAgICAoImJhc2lzIiwgIj0iLCBiYXNibmRzLCBmbiB7bmFtZSwgZGVmfSA9 PgorICAgICAgICAgICAgIChjYXNlIG5vZGUgZGVmIG9mIFZhciBfID0+IE9uZUxpbmUgfCBfID0+ IFNwbGl0IDMsCisgICAgICAgICAgICAgIEJhc2lkLmxheW91dCBuYW1lLCBsYXlvdXRCYXNleHAg ZGVmKSkKKyAgICAgICB8IERlZnMgZGVmID0+IE1vZElkQmluZC5sYXlvdXQgZGVmCisgICAgICAg fCBMb2NhbCAoZGVjMSwgZGVjMikgPT4gUHJldHR5LmxvY2FsbCAobGF5b3V0QmFzZGVjIGRlYzEs IGxheW91dEJhc2RlYyBkZWMyKSAKKyAgICAgICB8IE1MQiAoe2ZpbGVVc2UsIC4uLn0sIF8pID0+ IEZpbGUubGF5b3V0IGZpbGVVc2UKKyAgICAgICB8IE9wZW4gYnMgPT4gc2VxIFtzdHIgIm9wZW4g IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBzZXEgKHNlcGFyYXRlIChWZWN0b3IudG9MaXN0 TWFwIChicywgQmFzaWQubGF5b3V0KSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAiICIpKV0gCisgICAgICAgfCBQcmltID0+IHN0ciAiX3ByaW0iCisgICAgICAgfCBQ cm9nICh7ZmlsZVVzZSwgLi4ufSwgXykgPT4gRmlsZS5sYXlvdXQgZmlsZVVzZQorICAgICAgIHwg U2VxIGRlY3MgPT4gYWxpZ24gKGxheW91dEJhc2RlY3MgZGVjcykKKyAgIGFuZCBsYXlvdXRCYXNk ZWNzIGRlY3MgPSBsYXlvdXRzIChkZWNzLCBsYXlvdXRCYXNkZWMpCitlbmQKIAogZnVuIGNoZWNr U3ludGF4QmFzZXhwIChlOiBiYXNleHApOiB1bml0ID0KICAgIGNhc2Ugbm9kZSBlIG9mCkBAIC05 Niw0OSArMTAwLDYzIEBACiAgICAgfCBQcm9nIF8gPT4gKCkKICAgICB8IFNlcSBkZWNzID0+IExp c3QuZm9yZWFjaCAoZGVjcywgY2hlY2tTeW50YXhCYXNkZWMpCiAKLWZ1biBzb3VyY2VGaWxlcyAo ZDogYmFzZGVjKTogRmlsZS50IHZlY3RvciA9CitmdW4gZm9yRmlsZVRyZWUgKGQsIHtzdGFydE1M QiwgZmluaXNoTUxCLCBzb3VyY2VGaWxlfSkgPQogICAgbGV0Ci0gICAgICB2YWwgc291cmNlRmls ZXMgOiBGaWxlLnQgQnVmZmVyLnQgPQotICAgICAgICAgQnVmZmVyLm5ldyB7ZHVtbXkgPSAiPGR1 bW15PiJ9Ci0gICAgICB2YWwgcHNpIDogRmlsZS50IC0+IGJvb2wgcmVmID0KLSAgICAgICAgIFN0 cmluZy5tZW1vaXplIChmbiBfID0+IHJlZiBmYWxzZSkKLQotICAgICAgZnVuIHNvdXJjZUZpbGVz QmFzZXhwIChlOiBiYXNleHApOiB1bml0ID0KKyAgICAgIGZ1biByZWNCYXNleHAgZSA9CiAgICAg ICAgICBjYXNlIG5vZGUgZSBvZgotICAgICAgICAgICAgQmFzIGRlYyA9PiBzb3VyY2VGaWxlc0Jh c2RlYyBkZWMKLSAgICAgICAgICB8IExldCAoZGVjLCBleHApID0+IChzb3VyY2VGaWxlc0Jhc2Rl YyBkZWMKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA7IHNvdXJjZUZpbGVzQmFzZXhw IGV4cCkKKyAgICAgICAgICAgIEJhcyBkZWMgPT4gcmVjQmFzZGVjIGRlYworICAgICAgICAgIHwg TGV0IChkZWMsIGV4cCkgPT4gKHJlY0Jhc2RlYyBkZWMKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICA7IHJlY0Jhc2V4cCBleHApCiAgICAgICAgICAgfCBWYXIgXyA9PiAoKQotICAgICAg YW5kIHNvdXJjZUZpbGVzQmFzZGVjIChkOiBiYXNkZWMpOiB1bml0ID0KKyAgICAgIGFuZCByZWNC YXNkZWMgZCA9CiAgICAgICAgICBjYXNlIG5vZGUgZCBvZgotICAgICAgICAgICAgQW5uIChfLCBf LCBkZWMpID0+IHNvdXJjZUZpbGVzQmFzZGVjIGRlYworICAgICAgICAgICAgQW5uIChfLCBfLCBk ZWMpID0+IHJlY0Jhc2RlYyBkZWMKICAgICAgICAgICB8IEJhc2lzIGJhc2JuZHMgPT4KICAgICAg ICAgICAgICAgIFZlY3Rvci5mb3JlYWNoCiAgICAgICAgICAgICAgICAoYmFzYm5kcywgZm4ge2Rl ZiwgLi4ufSA9PgotICAgICAgICAgICAgICAgIHNvdXJjZUZpbGVzQmFzZXhwIGRlZikKKyAgICAg ICAgICAgICAgICByZWNCYXNleHAgZGVmKQogICAgICAgICAgIHwgRGVmcyBfID0+ICgpCi0gICAg ICAgICAgfCBMb2NhbCAoZGVjMSwgZGVjMikgPT4gKHNvdXJjZUZpbGVzQmFzZGVjIGRlYzEKLSAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgOyBzb3VyY2VGaWxlc0Jhc2RlYyBkZWMy KQorICAgICAgICAgIHwgTG9jYWwgKGRlYzEsIGRlYzIpID0+IChyZWNCYXNkZWMgZGVjMQorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA7IHJlY0Jhc2RlYyBkZWMyKQogICAgICAg ICAgIHwgTUxCICh7ZmlsZUFicywgLi4ufSwgZGVjKSA9PgotICAgICAgICAgICAgICAgbGV0Ci0g ICAgICAgICAgICAgICAgICB2YWwgYiA9IHBzaSBmaWxlQWJzCi0gICAgICAgICAgICAgICBpbgot ICAgICAgICAgICAgICAgICAgaWYgIWIKLSAgICAgICAgICAgICAgICAgICAgIHRoZW4gKCkKLSAg ICAgICAgICAgICAgICAgICAgIGVsc2UgbGV0Ci0gICAgICAgICAgICAgICAgICAgICAgICAgICAg IHZhbCAoKSA9IGIgOj0gdHJ1ZQotICAgICAgICAgICAgICAgICAgICAgICAgICBpbgotICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBzb3VyY2VGaWxlc0Jhc2RlYyAoUHJvbWlzZS5mb3JjZSBk ZWMpCi0gICAgICAgICAgICAgICAgICAgICAgICAgIGVuZAotICAgICAgICAgICAgICAgZW5kCisg ICAgICAgICAgICAoaWYge25lc3QgPSB0cnVlfSA9IHN0YXJ0TUxCIGZpbGVBYnMKKyAgICAgICAg ICAgICAgICB0aGVuIHJlY0Jhc2RlYyAoUHJvbWlzZS5mb3JjZSBkZWMpCisgICAgICAgICAgICAg ZWxzZSAoKQorICAgICAgICAgICAgIDsgZmluaXNoTUxCIGZpbGVBYnMpCiAgICAgICAgICAgfCBP cGVuIF8gPT4gKCkKICAgICAgICAgICB8IFByaW0gPT4gKCkKLSAgICAgICAgICB8IFByb2cgKHtm aWxlVXNlLCAuLi59LCBfKSA9PiBCdWZmZXIuYWRkIChzb3VyY2VGaWxlcywgZmlsZVVzZSkKLSAg ICAgICAgICB8IFNlcSBkZWNzID0+IExpc3QuZm9yZWFjaCAoZGVjcywgc291cmNlRmlsZXNCYXNk ZWMpCi0gICAgICB2YWwgKCkgPSBzb3VyY2VGaWxlc0Jhc2RlYyBkCisgICAgICAgICAgfCBQcm9n ICh7ZmlsZVVzZSwgLi4ufSwgXykgPT4gc291cmNlRmlsZSBmaWxlVXNlCisgICAgICAgICAgfCBT ZXEgZGVjcyA9PiBMaXN0LmZvcmVhY2ggKGRlY3MsIHJlY0Jhc2RlYykKICAgIGluCi0gICAgICBC dWZmZXIudG9WZWN0b3Igc291cmNlRmlsZXMKKyAgICAgIHJlY0Jhc2RlYyBkCiAgICBlbmQKKwor ZnVuIHNvdXJjZUZpbGVzIChkOiBiYXNkZWMpOiBGaWxlLnQgdmVjdG9yID0KKyAgIGxldAorICAg ICAgdmFsIHNvdXJjZUZpbGVzIDogRmlsZS50IEJ1ZmZlci50ID0KKyAgICAgICAgIEJ1ZmZlci5u ZXcge2R1bW15ID0gIjxkdW1teT4ifQorICAgICAgdmFsIHBzaSA6IEZpbGUudCAtPiBib29sIHJl ZiA9CisgICAgICAgICBTdHJpbmcubWVtb2l6ZSAoZm4gXyA9PiByZWYgZmFsc2UpCisKKyAgICAg IGZ1biBzdGFydE1MQiBmaWxlQWJzID0KKyAgICAgICAgIGxldAorICAgICAgICAgICAgdmFsIGIg PSBwc2kgZmlsZUFicworICAgICAgICAgaW4KKyAgICAgICAgICAgIGlmICFiCisgICAgICAgICAg ICAgICB0aGVuIHtuZXN0ID0gZmFsc2V9CisgICAgICAgICAgICBlbHNlCisgICAgICAgICAgICAg ICAoYiA6PSB0cnVlCisgICAgICAgICAgICAgICAgOyB7bmVzdCA9IHRydWV9KQorICAgICAgICAg ZW5kCisKKyAgICAgIGZ1biBzb3VyY2VGaWxlIGZpbGVVc2UgPQorICAgICAgICAgQnVmZmVyLmFk ZCAoc291cmNlRmlsZXMsIGZpbGVVc2UpCisgICBpbgorICAgICAgZm9yRmlsZVRyZWUgKGQsIHtz dGFydE1MQiA9IHN0YXJ0TUxCLAorICAgICAgICAgICAgICAgICAgICAgICBmaW5pc2hNTEIgPSBp Z25vcmUsCisgICAgICAgICAgICAgICAgICAgICAgIHNvdXJjZUZpbGUgPSBzb3VyY2VGaWxlfSkK KyAgICAgIDsgQnVmZmVyLnRvVmVjdG9yIHNvdXJjZUZpbGVzCisgICBlbmQKIHZhbCBzb3VyY2VG aWxlcyA9CiAgICBUcmFjZS50cmFjZSAKICAgICgiQXN0TUxCcy5zb3VyY2VGaWxlcyIsIExheW91 dC5pZ25vcmUsIFZlY3Rvci5sYXlvdXQgRmlsZS5sYXlvdXQpCkBAIC0xODMsNiArMjAxLDcgQEAK ICAgICAgIHZhbCBwcm9nID0gbWFrZSBvIFByb2cKICAgICAgIHZhbCBjaGVja1N5bnRheCA9IGNo ZWNrU3ludGF4QmFzZGVjCiAgICAgICB2YWwgbGF5b3V0ID0gbGF5b3V0QmFzZGVjCisgICAgICB2 YWwgZm9yRmlsZVRyZWUgPSBmb3JGaWxlVHJlZQogICAgICAgdmFsIHNvdXJjZUZpbGVzID0gc291 cmNlRmlsZXMKICAgIGVuZAogZW5kCg== ---MOQ1139187885e2f93701c5dc816d180674dbc4be8769 Content-Type: application/gzip; name="stop-ft-example.txt.gz" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="stop-ft-example.txt.gz" H4sICP6Y5kMCA3N0b3AtZnQtZXhhbXBsZS50eHQA7V3bktu4EX3fr/APYMfRplLJc2of8g2pPEAk JMEDAjQAaiS7/O8BSEoiNSIlopvNsVdb69GML6dPN7pxaQCNl50pxMv+9eXN2NcXV6iXQnmj33/9 vVDr3z59+h5+ffr08sC/cqaymXDtv4v/fW8/H/v3BZe3QPpA98GUXA8Suo03BXPNncxGkG+j35cg tfNcqZfK2a4G4W9Fia75OiBvWCaSXLb6/Hk1InycAJxE+L0TE3Hwlne/v0PrPjUkeqWVhfRyLx4g 9BgpOLFCuqxDLPwBgdDSOHmYLPXHzG3kTcmU2AsV/uZGHkLsPsILwfx1h0ElLD9qXsiMvUmd/+7k ll7m7HpuhRaWq9MngZbvJNK0ZeWlIrSnKb0Mgz6dOU8CZ9dQSefrLwTKdWTR6cVKLi2lcq3A2TXk 1vKjY1znbC8yb6x7cUpmgkDXW6LF10roxaVvKk0vvflkC1q/+VxW9hIOX//Wkoavf2tR0YuZfbWg 2qtl9C6MNmz5aO/QWJ7AIj1uTWDx4L+wWFz+wq2wWtoAq+UsQNAVeXHwL85bqbefqcRlO24/Uy3n rOC5sFSL8pM0ynZj2Z5iifVOItkSeW0MZb6hETe7dlJ7sRX29EmgYEciZahT+WYjiyjyqnUTCmSB dxFI2bfQ9itUY8K/qYaDfxP2I+Ef54SdSCOOspdkUm9oe8lG4uw6hkmDevnPn3/+yeJ3BCpeC6TR sOB+R6UcpSFrWfOvEU5+WfLslREH+1nmHyuq8Wd99IJq9Glk0egVv1Dp1ciiie7aRSjDriOQRsP4 hcT/z9L+8XfCEbbkPtsRyhPFWuSMZi3Sl0k0dbkcfeBW+l0hPN2BhEwJrunSHmdxs2vnjs6L4qW0 ghlHJ8/LgmI06kmj0i3nnlC3Rtr8EW/C/xQzpEYOhT7xaBejUuokjGBea17WUrOzdhSmjBMjQonN 0TxhLcmuWk8akW7OV2tWSL19IxO5UXzryMzZSqMyp9xqkpl0XxyRdqU1GRN6T6bfRSCVb0olWBjw 6NzzLJBIQ5Jx6CKK0DOFc6SOWcuj6leOjuVrun6lFUeknfdHMtVqWVReGb/S+WQjbX7dFPcbY4uX 7Lh9k5pm4ue8FZxuFn0RRzKPlkUpLI+3P8g07IskWy0Qt2MUSS2LbB1EbMtaJrkwssQUzSZXTxqV boSz2ncSqXTMTFHEY3hKasKkWF8q2cGq8Dv/+kx4sqqVN38KvP65NDHtT5ID78sj0i8LfyV03jx7 JVOxK5JIS3GQnlCYJrNlLYtIL7+LB1PJVDuJI9KOLFvWF0fVjZHlJK7kEem3zchU22ZkWtnK8a0g 0+wkjm7/lcoprwVSaUiyQunIotLLEDYa5Q59pUlyZD1plKcPLO3xA4pprBY+/iJQ7CyJSie2M87T pNrfSSTTMfTJxDqeJZLp6ITd0+p4lkiiozPZK1kInoSRaFYnHWTGolAi/foiSbSUtcvQqdiRR6Jf HGgp9evII1opUN3ybjM4RntiYVQrLq5zU9CtuFpxRNqRLEfOoubfx2sTRWR7QW0VSap9vPZvUU3c ++KIXHKzkWSq1bKoQo3sqmGbcGsPQiwgkDCFSXTg71ognYZxr5JSwUYe1eCqYllRusG1FUe1gUC1 COqLo9Lu6JTZ0mnXiiPSjqxYVfPzm+CvxMKohnOpuZLf+JqwG+vJJNKT6Or0WZgil0ZkyKZaPZVu rbT5U+6FYvpL+0GRc+/Lo9Kv0o5vBJ1+J3kE1XmvatZfruE2tfwp6vXeo7C4FViwwofgsQmOsSyP 83cP0PhB89hCfPbh8Rcg4n/fqe037SWIxyjG//7LVTw7dPzkduZN/+8DvGBw3S6L9ie3GXwov02K 8HkpPNTZzUXh8f5lLgaPvrwxl3yzF1YZnt9jMOSlP36baVK5wLs+gI50vAN9vOOkNHM7rX3aeWY7 t9Prp52Bdr6oWAq7D6rsxZ1Hx+Y07r3HxyismGKx83cjHT6sdZrn4MYraiRhDfCdiHXQn5GgTOWb +3lYgIofAyaS0axQPL4mhEVuvDL4xLcC7xQ1TzMbDrW71YOn4XHnhPXIYDhmG3v+aRrUxoxkUhOg hs44pCiIYqvRxPR0qH8i0vpjhUSs4AdWmje2Yn7HPcvlXuZhaMVpi9G6fimdx9/w4x13UEBqlQ4e Cr/TsIA8ymBZz+bCfsYynR17XWIa1miRwRQoFHPFSSqir42+CDARyhRl5TE9LSxaMqwmGLtLmoCE 0pajpR5ToFBYlRJr3LvzmGYaGJ6OSPHohS1ELkMDMPwQOIX759npIg7UrOAlkv5dQBSGWPPfSktc KBztmh4TBWv0nZ8UKLQ1Kaqz4jkq3qhcWlNIJ7DRsKyGODXFa4C6n3iTfsfCGkZ7OVJ9buJ4X2Uq QHLNENnee2YKRBFn/YYIVU/LRY5pwB4kDsuwEhYW0bGvvBGH5Mlx0NDQFpkca7TYSIGXW6qxcL0Y k18fEylwx17hmAg1fosrDQyF2Z2DxklgOOa/80z2xPTv6HXEFCwcJcffpJ44O5Sa2yNzgttshzXj 7GOi8NxxtwuIWNP+CxzqbBY5y4QCN3oZJwUKx2LjlaMmT7JHS/BMTOdIi4mE04iVzhAzGxc4NBdj uXAZop+1eLj+gTMslKWoC1Si7ef1ELE0LoX1R0yWVmwwkXCGBeFZvFrPpUZb0PVthzNk93kiLZla nshqI7HLTdRYoU3GAh5Wr2zwMn5CoG3gVKMVWhPRENXESoGPXihPRMPJbob4tGhp1xMaTjR9rUSF tiH6ZuqujbWgeGulFeZiaYV1Am3ksv10JJzmrLQMxmdom30XPBx+8RFDG6+iMtxs+A1clDb+Ujkv N1gj4RkNZ+CSVmRe5GxrebnDW1n0QJEO9tmtYIhHh75WMntlzqAdyAtL4zBFCQuXOUHRVUcBbEMc LwXSAcTpNOLNmpzVpd/R1oEdRBQrFkYbhppxtMJVCm+J1YAh7QpsxaFEY9aA4axOTYllsQYKJyWF Zy2HZ6tsZ2QWxkvuw4Reo50864PiTLRcxku0I2MtGE6Su9ps0NZWJzAcZtyJ+LQ5DrMW7Caz95dM HgV3dbnSsYs/32e4xnXvws/wZZ/HLvpgXLqBXIeiYBlbLpfuC8qQ3AODjp21TwkcUpVuN3JRWJ02 he9Oj9IDKqwjnwH1UwZUbLl6ComRVIhgtdoRjfkGFOrCPYYYYBuppRcMbQMqYpZGHVnGs53AhsMJ 1bvvdZ4vddKF71km88dykSu4yVVZlr6X+1DP+Csocq/4R+M5Y1Va5pJ/7b24l6Efjx1x0M/QeYbO 9NCpHWfZyGkoLBQ4e66egfMMnOmBUzvOsoHTUCANnFOdqeUjZkrtqzksIb5WXD17jmfPMX3IrT1n 4TG34UAaMZcacQuVWfq1neuREnw/Hkgi9H8eZ9s+b+TGEunf0xP0CbnE+y00NWlyeefIGjVDfvNR fZfKEvb1X0ufet64D9R+so3i29QT7qOICBybBmGlwSHYhUNgZ8U2PXF5GwrNZoj2wvQ2TD/DsVb9 HCuOtVooBFalFT75/PVtKJS928tww/MidETNNGboVnYq1q1c+6NYbzbeechhfFx9pn7gfsN0FIg+ 7lisB8JmIgSERdRFwo06cIz0UYjhK7rTECAcYqUK5uQ3AeJxQYFwiafUwVTOIBAmyugt0D9aCAiL 0sqiDjkQkQsKhEu8rg1vnAsKqE80NodzuaBAuPhjMC17lRrmLR0YsMfUWAg+0+LAvCYbKlA5EQLW RvuB+nHTEKAjDvemcOBBp0GBcglGFQjTASvATAqTV0rA7XLCgfIprdlajtBQZyCwhdQawTwRBMgE SuKG/ITkUPT/Xz49NJ4C+7nSVbPZqPYEyDztBJAcFzVAHLqBHGoIGIt6bnUA8mhBYEzqmRWUSQuC wYSNlOFJxQJ6TH26B+ozDQiMieJrocBERg89JgGBIzIMeRg2vgAhMMIgA+QRZ/ZAGjUEjMXQM/DT EIAcgqsBSWyFFlZmzGU7UQhcMGgz1299M4zw7mPBeLU7FlJvDJBVFwnHVkO32tKQYJzqtTeQTYMB 5VEKZkoHptLCwNhUTjDNwcEBygacEWAcgLmADgaMR13fDWGgvOBgrPHWPHsVOn+u8hZZUT3XneOc nON/2WMbj3jIxzhY8pE5Rg+K28M+lngBbYtfIQH26muvdpwBanW9B1qhISXe0btFCYrU1JRh6VUQ bkJBWXHN1fEbvOlanBUWEJZi8HarZ6FhdZW9gnW7QK0QsRA1hFurtKKM7/o5sIJnpBUeFJ56cEu5 nZUa7lMNzAoJB0kruHU2insWfnmZwTunHhiUWWaKwmjG7RbMqwOFxGqtDEI/1QNDYuaqNcbQ10eD ctsqs+YKTKqFAffDb6apxoXm+O8RoRyLSnkJ5tWgwD0r3lLQ9Z55ybeQt8nugCIwBRRQfI8DnosK UcYD6t4LuMV6YBj9PgYpLD5SK6nhgdjCwNmERWpeZYIpM5RfheBB+Wnk/ksj915+F5Zy2H3sDUwo TyucHzpqlYID5fOqzZtmGXdwSh0oKKswPeEKrRvro+FwS6/pfwsJzsmUTOo9t5InVywbhAMvrWKZ ofFLqQlQ8EjMK53H+YAPseQQIrKPh8YPjxkCpw1aVHax4LwKsxes0pUTOQKzDtoKFw5XVYRchSxK FSaed0ocJcJB2QUdVfr7RO9xoHy+GYQZYw2C1W5oLbZCQ0LTbYWR48fYcEDZtcBQZoWz62EYllJn LJz6gf3dfluFNTHgHNU1TurJiBNOvRIQlsEO49xGg3Iz6y9x4wh0cuN8yiJMS7FQoHpZUeIodQaC MnJv0g+8+JgAA2Uj7O2K2pNMM9RNTgZBaO2wsBXac9Dp4XOIxc+cXaGCHaDp9lCs1sWC8oqjpiiC mmzHda6EdWB6NyChLJUspB/ZdU3FArdq/a4mErEeGJRZwbPdUKYyBQc8DDanWuHR2eLAPWovEFxp D2fCVUzpeMFiuRPnMSLwBiR4yPhayX0Ym3UmRp5WgiFCOWa7Sr8OLW+SgMBez21oC6FYXH4jjExd NCi39hPM6oSDcWQ3U8ZVVsRKA3thf/36Xc+jsnMelZ2Lz6FQz6O7z6O7AI7Rg8Kv4UXqZCDoedse ECRfFIGQzkheQUFZuay+GurAnM5AYEZ4efQbcGB28BOJHRgom+icKPnrd2AIzDAIwdsrajVaOf9R pPikTWFsuZNO4IKh6IjS2V2yFOKQiTImedw8oFCdL6Cu2mzkAZFlCwhlGDfYm33/DN4wPTAUf0Hr Nhxqv+EwOg433HMkLgCulmB87bzlmY91/av0Newd2NTF7DVsc/QWUtVtGBGLo+LFOudsM9SLQTGx eF79jMb1GhclcVA8a30vwal4UeIg0m/CXwASt6MCQMmtExAGLUA6g6yAiM9ulUdOCAGTi63QiHHQ x83YfQmpuY9nbgGD48+RQbpfluEjtPO1z5+/A9YfH8ZFncS16OujF/H7v2y68udwto+fsJw6CHwM tmf3P32DErzvUecI3cM//zHjgPvcbPjrxO7POeD+DGy7MVoKUe6MwulibgJD8k23gMP36GQj5gw8 WelElZs56LL6T1n9NPzs+HOYJh5C0tD7DnfB52Be/+l8Np+F84OntWYQM4c2IoxeR+Yt124zkMVB FjGHFl+qohyuBoqHPkv0NrcmZ+J+QZ+r5zm37Hz9T0fEHFrUJXNjqM2ryQ0xc2iDstd1F3wO5rVd VLDQLNQv6HNw33Ml87mon8HnYI6Z1RrCfmx5nJLxvrf4er9EGF8apHCwghUKPev+LOr6c+2HfdQ9 w8Y728/0XaornOQt5hYnD8qywYRcGhLGNnIu6rcjjJXfxHNDeUGH/UicCu6zXfCxopRKPHOxz1ws gGPfl7QIS/uclRxWrmUQFDJh7IP2fkIk28fF3Ec5fLBepDe0dH9IHgKHETGGQqH42sQF6/P9hOdU +zlTmBgzucjSr/FewaROti8w9SUaofcIjM5QcFZ1JZMNzwQCrQsWnNf5OyST9fHg/EorMpHX96Zh Rx9HIOEsXWZKDGoNDmargl4tHgTEZBjIQd4RG4HEZAl9c3kME5Mn+C3mUVBUi0LeaB4ERGSISQ5l lrqxJl62+qVf+Wr4HHmWtR8s/A5i/kHGCudKvVTOdnUPfyseWnDN1w951Lm2yTq9DHEH5YuROvHl ow6KspAnlDpAzgfDFXCcejS3qwGg56vic3G69EuF+n1r0++HvAeafE3lXnxX2vGN+HhmU+KQfCnn AnT+DqEJLlipY2pXwTWaY6wTPeMWEo7VAxLDtHwfD2PmMF5UZv6N40Ox7MZ1waWONdtfq5KdHjl5 11DJQNct9DDQUIp5MkAyg/glXXz9r4Gye9F3atnm86HxMHT2rIP047f/A8293eEDUAEA ---MOQ1139187885e2f93701c5dc816d180674dbc4be8769-- From wesley@terpstra.ca Mon Feb 6 15:48:23 2006 From: wesley@terpstra.ca (Wesley W. Terpstra) Date: Mon, 6 Feb 2006 16:48:23 +0100 Subject: [MLton] Paging friendly GC? Message-ID: <50258B57-DDD8-4784-9FB7-370DAD5F24C8@terpstra.ca> Obviously, I'm no garbage collector expert. However, I seem to recall that MLton uses a 'generational mark-sweep' algorithm...? I know that MLton performs very poorly once the heap size exceeds physical memory. The system thrashes to death. So, when I saw this, I thought maybe those of you with a clue might care: http://www.cs.umass.edu/~emery/pubs/f034-hertz.pdf Is this relevant / useful for MLton? Could something like this make a self-compile feasible with < 512MB RAM? From fluet@cs.cornell.edu Mon Feb 6 19:07:59 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Mon, 6 Feb 2006 14:07:59 -0500 (EST) Subject: [MLton] IntInf implementation questions In-Reply-To: <17381.21225.65616.365374@eponym.sweeks.com> References: <17381.16826.232463.731288@eponym.sweeks.com> <17381.21225.65616.365374@eponym.sweeks.com> Message-ID: >> I think this is an artefact of the long-gone days before MLton >> supported overflow. It seems fine to replace as you suggest. > > In fact, since the IntInf implementation has not been substantially > revised since those days, it probably has a number of similar > artefacts that would benefit from rewriting to take advantage of > overflow. I don't see any others. Given two IntInf integers represented as small integers (say, 32 bits == 31 bits data + 1 bit tag), then the small integer + and - (say, Int32.+ and Int32.-) can't overflow, although the resulting value may not be expressible as a small integer with a tag bit. Of course, we could use overflow checking if we don't completely convert the small integer into it's 32 bit representation. That is, consider bigPlus: (* Coercion to/from 32-bit representation. *) fun stripTag (arg: bigInt): Word.word = Word.~>> (Prim.toWord arg, 0w1) fun addTag (argw: Word.word): Word.word = Word.orb (Word.<< (argw, 0w1), 0w1) fun zeroTag (arg: bigInt): Word.word = Word.andb (Prim.toWord arg, 0wxFFFFFFFE) fun incTag (argw: Word.word): Word.word = Word.orb (argw, 0w1) (* Check if two words have the same sign bit. *) fun sameSign (lhs: Word.word, rhs: Word.word): bool = Word.toIntX (Word.xorb (lhs, rhs)) >= 0 fun bigPlus (lhs: bigInt, rhs: bigInt): bigInt = let val res = if areSmall (lhs, rhs) then let val ansv = Word.+ (stripTag lhs, stripTag rhs) val ans = addTag ansv in if sameSign (ans, ansv) then SOME (Prim.fromWord ans) else NONE end else NONE in case res of NONE => dontInline (fn () => Prim.+ (lhs, rhs, reserve (Int.max (size lhs, size rhs), 1))) | SOME i => i end On the small fast path, I count 6 bitops and one comparison test. (Note that Word.{fromInt,toIntX} are the identity functions.) I think the following is equivalent: fun bigPlus (lhs: bigInt, rhs: bigInt): bigInt = let val res = if areSmall (lhs, rhs) then let val ansv = Int.+ (Word.toIntX (Prim.toWord lhs), Word.toIntX (zeroTag rhs)) in SOME (Prim.fromWord (Word.fromInt ansv)) end handle Overflow => NONE else NONE in case res of NONE => dontInline (fn () => Prim.+ (lhs, rhs, reserve (Int.max (size lhs, size rhs), 1))) | SOME i => i end On the small fast path, I count 2 bitops and one overflow test. I think you can do the same thing for bigMinus. From henry.cejtin@sbcglobal.net Mon Feb 6 19:33:17 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Mon, 06 Feb 2006 13:33:17 -0600 Subject: [MLton] IntInf implementation questions In-Reply-To: Message-ID: Re IntInf multiply, as I recall, the time it takes for a 32*32->64 multiply is the same as for a 32*32->32 multiply on the x86, so if it could be done inline (no call to a C routine), it might still be faster to do the big digit multiply and then check for the right kind of overflow. Probably not a big win unless you are frequently multiplying smalls with a product that doesn't fit. Re dontInline, is this exported to any thing any where? There are definitely times when it would be a useful hack for speed. The particular case I know where I did something like this by `hand' was in a kind of TextIO version where I did not want the buffer under/over-flow case to be inlined because then it would inline all the input1 calls. From MLton@mlton.org Mon Feb 6 21:58:37 2006 From: MLton@mlton.org (Stephen Weeks) Date: Mon, 6 Feb 2006 13:58:37 -0800 Subject: [MLton] IntInf implementation questions In-Reply-To: References: <17381.16826.232463.731288@eponym.sweeks.com> <17381.21225.65616.365374@eponym.sweeks.com> Message-ID: <17383.50829.134663.320998@eponym.sweeks.com> > fun bigPlus (lhs: bigInt, rhs: bigInt): bigInt = > let > val res = > if areSmall (lhs, rhs) > then let val ansv = Word.+ (stripTag lhs, stripTag rhs) > val ans = addTag ansv > in if sameSign (ans, ansv) > then SOME (Prim.fromWord ans) > else NONE > end > else NONE ... > On the small fast path, I count 6 bitops and one comparison test. Yep. I'd say that makes sense to count areSmall as being on the path too, so you get 8 bitops and two tests. func bitops tests -------- ---------- ----- areSmall andb, andb <> stripTag ~>> stripTag ~>> Word.+ + addTag <<, orb sameSign xorb >= > I think the following is equivalent: > > fun bigPlus (lhs: bigInt, rhs: bigInt): bigInt = > let > val res = > if areSmall (lhs, rhs) > then let val ansv = Int.+ (Word.toIntX (Prim.toWord lhs), > Word.toIntX (zeroTag rhs)) > in SOME (Prim.fromWord (Word.fromInt ansv)) > end handle Overflow => NONE > else NONE ... > On the small fast path, I count 2 bitops and one overflow test. I think > you can do the same thing for bigMinus. Yes, this is a good trick. Again, counting areSmall, this gives 4 bitops, one test, and one overflow check. So we can hope for maybe even a factor of two speedup. Nice. BTW, this trick is pretty well known. It is what SML/NJ does (at least did) and is described on page 162 of Appel's book, Compiling With Continuations (http://mlton.org/References#Appel92). Appel also explains there how to do multiplication, and points out that one can do subtraction and division too. I think the same tricks work in our situation. Another nice observation that Appel makes is that if one of the arguments is constant, the zeroTag can be done at compile time. Unfortunately, since this is user code, we have to get lucky and hope that rhs is the constant. Hmmm, I wonder if we could add a primitive: val isConstant: 'a -> bool The semantics of isConstant is that it returns false, unless the optimizer is able to prove that its argument is a constant. Obviously, one can only use isConstant sensibly in symmetric situations where the behavior of the program (other than performance) doesn't depend on whether it returns true or false. For example, we could then write something like: if areSmall (lhs, rhs) then let val (x, c) = if isConstant lhs then (rhs, lhs) else (lhs, rhs) in SOME (Prim.fromWord (Word.fromInt (Int.+ (Word.toIntX (Prim.toWord x), Word.toIntX (zeroTag c))))) handle Overflow => NONE end else NONE Now, if either lhs or rhs is constant, the zeroTag will happen at compile time and we will save one (of four) bitops. That seems worth it. From MLton@mlton.org Mon Feb 6 22:12:08 2006 From: MLton@mlton.org (Stephen Weeks) Date: Mon, 6 Feb 2006 14:12:08 -0800 Subject: [MLton] IntInf implementation questions In-Reply-To: References: Message-ID: <17383.51640.757282.146887@eponym.sweeks.com> > Re IntInf multiply, as I recall, the time it takes for a 32*32->64 > multiply is the same as for a 32*32->32 multiply on the x86, so if > it could be done inline (no call to a C routine), it might still be > faster to do the big digit multiply and then check for the right > kind of overflow. Probably not a big win unless you are frequently > multiplying smalls with a product that doesn't fit. We don't have the primitive support to do the smallMul inline, so I guess that the right thing is to do the trick Appel mentions, which is fast when multiplying 2 smalls to get a small. For completeness, here is the trick. If i' = 2i + 1 j' = 2j + 1 then (i' - 1) * floor(j' / 2) + 1 = 2 (ij) + 1 So, one can multiply two smalls using 4 bitops: zero tag (or sub1), shift (/2), mul, and add 1. And as with plus, the zero tag can be simplified at compile time if one argument is a constant. Counting areSmall and the overflow check, that gives 6 bitops, one test, and one overflow check. That should be a big win over our current approach. > Re dontInline, is this exported to any thing any where? mlton -show-basis shows that it is not. However, it is a small piece of code and doesn't rely on any privileged primitives, so you can easily put it in your own code. val dontInline: (unit -> 'a) -> 'a = fn f => let val rec recur: int -> 'a = fn i => if i = 0 then f () else (ignore (recur (i - 1)) ; recur (i - 2)) in recur 0 end From henry.cejtin@sbcglobal.net Mon Feb 6 22:33:07 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Mon, 06 Feb 2006 16:33:07 -0600 Subject: [MLton] IntInf implementation questions In-Reply-To: <17383.51640.757282.146887@eponym.sweeks.com> Message-ID: Re dontInLine, it may not use any primitives, but it certainly relies on a lot of things about MLton (that recursive functions aren't unrolled, that the simplitier will get rid of the junk, etc.). Any way, I quite agree that the hack for small*small->small should be quite a win. It really is a shame (for IntInf any way) that the tag for non-pointers isn't 0, but 1. Especially for + and -. From wesley@terpstra.ca Mon Feb 6 22:37:15 2006 From: wesley@terpstra.ca (Wesley W. Terpstra) Date: Mon, 6 Feb 2006 23:37:15 +0100 Subject: [MLton] IntInf implementation questions In-Reply-To: <17383.51640.757282.146887@eponym.sweeks.com> References: <17383.51640.757282.146887@eponym.sweeks.com> Message-ID: On Feb 6, 2006, at 11:12 PM, Stephen Weeks wrote: >> Re IntInf multiply, as I recall, the time it takes for a 32*32->64 >> multiply is the same as for a 32*32->32 multiply on the x86 > > We don't have the primitive support to do the smallMul inline Do I need to beg? :-) From henry.cejtin@sbcglobal.net Mon Feb 6 22:17:33 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Mon, 06 Feb 2006 16:17:33 -0600 Subject: [MLton] IntInf implementation questions In-Reply-To: <17383.47755.508746.209651@eponym.sweeks.com> Message-ID: As to why fill() in IntInf.c requires at least 2 limbs, my guess looking at my old code is that it was (is?) to make sure that you can always fit any 32-bit int in it. I remember one had to be a bit cautious because of things that were small but whose negation were not. Sadly, I don't really remember what the reason for the restriction was. Re quot and rem, I remember trying to use the mpn stuff (instead of the mpz things) when ever possible because they didn't do as many internal allocations. If you look at atleast the old (GMP 2.0.2) source for mpz_tdiv_[qr], they do pretty much the same as IntInf_quot/rem do, and they have all kinds of conditions under which they allocate. You have to be sure that these routines do NOT allocate, or else you will end up with things pointing in the malloc heap instead of the MLton one. From MLton@mlton.org Mon Feb 6 22:41:15 2006 From: MLton@mlton.org (Stephen Weeks) Date: Mon, 6 Feb 2006 14:41:15 -0800 Subject: [MLton] IntInf implementation questions In-Reply-To: References: <17383.51640.757282.146887@eponym.sweeks.com> Message-ID: <17383.53387.318011.256951@eponym.sweeks.com> > Re dontInLine, it may not use any primitives, but it certainly > relies on a lot of things about MLton (that recursive functions > aren't unrolled, that the simplitier will get rid of the junk, > etc.). True. That is a good argument for putting it in the (or some) basis, since it may change occasionally. From henry.cejtin@sbcglobal.net Mon Feb 6 22:45:51 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Mon, 06 Feb 2006 16:45:51 -0600 Subject: [MLton] IntInf implementation questions In-Reply-To: Message-ID: Do you really have code where 32*32->64 would be a big win compared to the Appel hack which would avoid the expensive call to C? It can only be a win if you have things that fit in 31 bits and are frequently multiplying them together and the product often does NOT fit in 31 bits. Obviously one can construct bad cases, but I would think that it would be VERY rare in practice. From wesley@terpstra.ca Mon Feb 6 23:27:00 2006 From: wesley@terpstra.ca (Wesley W. Terpstra) Date: Tue, 7 Feb 2006 00:27:00 +0100 Subject: [MLton] IntInf implementation questions In-Reply-To: References: Message-ID: <6B8C581D-B223-48D5-BD72-C16707673569@terpstra.ca> On Feb 6, 2006, at 11:45 PM, Henry Cejtin wrote: > Do you really have code where 32*32->64 would be a big win compared > to the > Appel hack which would avoid the expensive call to C? It can only > be a win > if you have things that fit in 31 bits and are frequently > multiplying them > together and the product often does NOT fit in 31 bits. Obviously > one can > construct bad cases, but I would think that it would be VERY rare > in practice. Might you be asking for a link to my very first post on this list? I think you might be! ;-) http://terpstra.ca/lurker/message/20041021.222851.4139646f.en.html Admittedly, in my case I wanted to store the thing in a Word32. However, since it is modulo 2^31-1, I could have stored it in an 'int'. Of course, I don't really expect normal int*int multiplication to do this. I just heard Stephen say 'primitive' near the words 32*32->64 mul, and my heart jumped into my throat. ;-) There is still no way to get MLton to output the pretty 'MUL:' assembler that I detailed in my post. I've been hoping for some time. From henry.cejtin@sbcglobal.net Mon Feb 6 23:43:00 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Mon, 06 Feb 2006 17:43:00 -0600 Subject: [MLton] IntInf implementation questions In-Reply-To: <6B8C581D-B223-48D5-BD72-C16707673569@terpstra.ca> Message-ID: I remember your code (I think), but I gather from your mail that it isn't really a matter of a faster IntInf.* (which I think the Appel hack will do), but to expose some kind of Int32.int * Int32.int -> Int64.int which turns into the instruction. (I agree, if you need this it is a big win.) From MLton@mlton.org Tue Feb 7 00:18:41 2006 From: MLton@mlton.org (Stephen Weeks) Date: Mon, 6 Feb 2006 16:18:41 -0800 Subject: [MLton] IntInf implementation questions In-Reply-To: <6B8C581D-B223-48D5-BD72-C16707673569@terpstra.ca> References: <6B8C581D-B223-48D5-BD72-C16707673569@terpstra.ca> Message-ID: <17383.59233.105857.565406@eponym.sweeks.com> > Of course, I don't really expect normal int*int multiplication to do > this. > I just heard Stephen say 'primitive' near the words 32*32->64 mul, > and my heart jumped into my throat. ;-) > > There is still no way to get MLton to output the pretty 'MUL:' assembler > that I detailed in my post. I've been hoping for some time. It still seems to me like it shouldn't be that hard for someone to add (mind you, I don't have the time). Wesley, you're clearly the one to do it since you have the need, and now you have more than a year's experience subscribed to the list, so you know you will get help if you need it. I can state with certainty that there is no problem defining such a primitive, exposing it in the basis, treating it correctly in the optimizer, and pushing it through all the ILs to the codegen. Matthew can comment on how easy it would be to tell the x86 codegen about it. If that's not problematic, why not spend a day a put it in? From fluet@cs.cornell.edu Tue Feb 7 02:58:38 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Mon, 6 Feb 2006 21:58:38 -0500 (EST) Subject: [MLton] IntInf implementation questions In-Reply-To: References: Message-ID: > As to why fill() in IntInf.c requires at least 2 limbs, my guess looking at > my old code is that it was (is?) to make sure that you can always fit any > 32-bit int in it. I remember one had to be a bit cautious because of things > that were small but whose negation were not. O.k. > Re quot and rem, I remember trying to use the mpn stuff (instead of the mpz > things) when ever possible because they didn't do as many internal > allocations. If you look at atleast the old (GMP 2.0.2) source for > mpz_tdiv_[qr], they do pretty much the same as IntInf_quot/rem do, and they > have all kinds of conditions under which they allocate. You have to be sure > that these routines do NOT allocate, or else you will end up with things > pointing in the malloc heap instead of the MLton one. That's a good reason. I guess I'll try browsing the GMP source a little. I don't think it is that bad if GMP does some internal mallocs/frees, but certainly we want the final answer to go in the buffer we've allocated. I've not seen any problems using the mpz_tdiv_{q,r}, but I haven't really stress tested it. From fluet@cs.cornell.edu Tue Feb 7 03:02:17 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Mon, 6 Feb 2006 22:02:17 -0500 (EST) Subject: [MLton] IntInf implementation questions In-Reply-To: <17383.59233.105857.565406@eponym.sweeks.com> References: <6B8C581D-B223-48D5-BD72-C16707673569@terpstra.ca> <17383.59233.105857.565406@eponym.sweeks.com> Message-ID: >> Of course, I don't really expect normal int*int multiplication to do >> this. >> I just heard Stephen say 'primitive' near the words 32*32->64 mul, >> and my heart jumped into my throat. ;-) >> >> There is still no way to get MLton to output the pretty 'MUL:' assembler >> that I detailed in my post. I've been hoping for some time. > > It still seems to me like it shouldn't be that hard for someone to add > (mind you, I don't have the time). Wesley, you're clearly the one to > do it since you have the need, and now you have more than a year's > experience subscribed to the list, so you know you will get help if > you need it. I can state with certainty that there is no problem > defining such a primitive, exposing it in the basis, treating it > correctly in the optimizer, and pushing it through all the ILs to the > codegen. Matthew can comment on how easy it would be to tell the x86 > codegen about it. If that's not problematic, why not spend a day a > put it in? It would be pretty trivial to tell the x86 codegen about a new primitive. From fluet@cs.cornell.edu Wed Feb 8 16:37:55 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Wed, 8 Feb 2006 11:37:55 -0500 (EST) Subject: [MLton] MLB file tree In-Reply-To: <1139187885.43e6a0ad98fe7@www2.helsinki.fi> References: <1139187885.43e6a0ad98fe7@www2.helsinki.fi> Message-ID: > Attached is a draft patch for a new option "-stop ft" to print the "MLB > file tree". That looks generally useful. I wonder, though, whether the format could be improved. Only one of the '{ }' and the indenting are necessary to capture the nesting; the '{ }' would seem easier to handle by text processing. > The file tree is useful for analyzing the (dependency) structure of a > project. Using standard text processing commands (grep, sed, ...) you can > fairly easily extract information from the file tree, such as a list of > all MLB files used by a project or the same output as produced by "-stop f". The fact that the mlb files aren't part of the output of "-stop f" is probably not the right choice. We usually use "-stop f" to extract dependencies for a Makefile; technically, you could change a mlb file in a manner that changes the meaning of a program without changing the list of source .sml files. > I implemented the option, because I wanted to know which MLB-files are > actually used when MLton is compiled, so that I can go through them to > better understand how much work it might require to get MLton to compile > under MLKit. That would be very cool. Keep us posted. I saw your comp.lang.functional posting, and it sounded like the annotations are the issue. From fluet@cs.cornell.edu Thu Feb 9 00:16:09 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Wed, 8 Feb 2006 19:16:09 -0500 (EST) Subject: [MLton] available ram Message-ID: [Moving to MLton@mlton.org, as this is a suggestion for development.] >> Which ever is used, I would expect that to be the maximum that the >> machine would ever ask for. > > ram-slop is not for specifying a maximum; it is for specifying how > much RAM is expected to be available before paging occurs. You may > want the program to run beyond that limit, but to take paging into > account (in the very limited way that MLton does). max-heap is indeed > for specifying a maximum. ram-slop and max-heap make sense each on > their own as well as together. I think a point of confusion is that s->ram = align (s->ramSlop * s->totalRam, s->pageSize); is a rather poor way of estimating the available ram. For systems where we use sysconf(_SC_PHYS_PAGES) to determine the total ram, we might well use sysconf(_SC_AVPHYS_PAGES) to determine the available ram. In fact, we ought to periodically recompute s->ram from _SC_AVPHYS_PAGES. I imagine that this would give somewhat better dynamic behavior than the current situation. We might well have an availRamSlop parameter for further customization. From henry.cejtin@sbcglobal.net Thu Feb 9 00:51:34 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Wed, 08 Feb 2006 18:51:34 -0600 Subject: [MLton] available ram In-Reply-To: Message-ID: I am pretty sure that _SC_AVPHYS_PAGES won't include memory used for buffers and disk cache (and an experiment on my machine seems to confirm that), so it is pretty worthless I would say. Sad. Besides, I think that the amount of memory available without swapping any other process would be too low a threshold. From MLton@mlton.org Thu Feb 9 06:50:13 2006 From: MLton@mlton.org (Stephen Weeks) Date: Wed, 8 Feb 2006 22:50:13 -0800 Subject: [MLton] MLB file tree In-Reply-To: References: <1139187885.43e6a0ad98fe7@www2.helsinki.fi> Message-ID: <17386.58917.995583.715795@eponym.sweeks.com> > I wonder, though, whether the format could be improved. Only one of > the '{ }' and the indenting are necessary to capture the nesting; > the '{ }' would seem easier to handle by text processing. Having both {} and nesting has the benefit for humans that the nesting is both visually apparent and the output is easily navigable by {back,for}ward-sexp. > The fact that the mlb files aren't part of the output of "-stop f" is > probably not the right choice. We usually use "-stop f" to extract > dependencies for a Makefile; technically, you could change a mlb file in a > manner that changes the meaning of a program without changing the list of > source .sml files. Good point. For example, one could reorder the files, changing the order of side effects. We did sometimes use -stop f to produce a list of SML files so that one could feed the list to SML/NJ or concatenate all the code together. But it's easy enough grep -v out the MLBs to obtain this behavior. So, if people want, it seems reasonable to me to change the meaning of -stop f to include MLB files. From MLton@mlton.org Thu Feb 9 07:01:49 2006 From: MLton@mlton.org (Stephen Weeks) Date: Wed, 8 Feb 2006 23:01:49 -0800 Subject: [MLton] available ram In-Reply-To: References: Message-ID: <17386.59613.63621.788061@eponym.sweeks.com> > I think a point of confusion is that > > s->ram = align (s->ramSlop * s->totalRam, s->pageSize); > > is a rather poor way of estimating the available ram. Agreed that it is a poor estimate. But it does have the benefit of being simple to understand and the same across all machines. > For systems where we use sysconf(_SC_PHYS_PAGES) to determine the > total ram, we might well use sysconf(_SC_AVPHYS_PAGES) to determine > the available ram. In fact, we ought to periodically recompute > s->ram from _SC_AVPHYS_PAGES. I imagine that this would give > somewhat better dynamic behavior than the current situation. There is the accuracy problem that Henry mentioned. And, I am wary that the lack of predictability of such solutions is worse than the lack of dynamic responsiveness of our simplistic approach. The truth is that making a GC play nice with paging is hard, as papers like the one Wesley mentioned show. It's better to clearly not solve the problem, as MLton does, then to make a sometimes right, sometimes wrong, attempt at solving it. > We might well have an availRamSlop parameter for further > customization. Why would one need both ramSlop and availRamSlop? From vesa.karvonen@cs.helsinki.fi Thu Feb 9 08:39:29 2006 From: vesa.karvonen@cs.helsinki.fi (Vesa Karvonen) Date: Thu, 9 Feb 2006 10:39:29 +0200 Subject: [MLton] MLB file tree Message-ID: <1139474369.43eaffc12f173@www2.helsinki.fi> Quoting Matthew Fluet : > > Attached is a draft patch for a new option "-stop ft" to print the "MLB > > file tree". > > That looks generally useful. I wonder, though, whether the format could > be improved. I'm personally not entirely happy with the format, but I'm uncertain on how to improve it. Let me elaborate on my requirements. > Only one of the '{ }' and the indenting are necessary to > capture the nesting; the '{ }' would seem easier to handle by text > processing. I want the format to be immediately useful for two purposes: - visual examination to understand the dependency structure of a project, and - processing by *simple* scripts to extract useful information, such as getting lists of files. The indentation and braces are there mainly to support visual examination. The braces, specifically, allow you to skip blocks quickly in an editor like Emacs that supports moving by sexp's. Using keywords (e.g. begin - end) would already make it more complicated to browse the output. So, I'm uncertain on whether I want the output to be more MLish. To support simple scripts, the filenames are not printed as string literals. If they were printed as string literals, then it would be much more difficult to extract useful information out of the file tree using standard text processing tools like grep and sed. (The simplest approach would probably be to implement a simple program to parse a SML string literal and print the resulting string.) Although I think that supporting "special characters" (like spaces) in filenames is a good feature to have, I also think that actually using them, for anything but legacy code, is asking for trouble. A third, but IMO less important requirement, is that the format should be suitable for more complicated automated processing, such as converting the output to be processed by Graphviz/DOT or simply computing a transitive closure of the dependencies. The braces should support that, by allowing a somewhat simpler parser to be written to extract the tree (or DAG) from the output. I think that the main problem with the current format is that it prints both relative and absolute paths. I think that it would be best to only print absolute paths. Further requirements and specific formatting proposals are welcome. ... BTW, while checking the output of the "-stop ft" option I noticed that some files were elaborated twice when compiling MLton. I recall that when I started using MLBs, I had a problem with having some files being elaborated more than once. So, IMO, by default, MLton should give a warning when a specific SML source file is elaborated more than once. I think that in most cases it is not intentional. An annotation could then be implemented to allow that warning to be disabled in specific cases. For example: ann "ignoreMultipleElaboration" in infixes.sml end > The fact that the mlb files aren't part of the output of "-stop f" is > probably not the right choice. We usually use "-stop f" to extract > dependencies for a Makefile; technically, you could change a mlb file in a > manner that changes the meaning of a program without changing the list of > source .sml files. I agree that MLB files should also be considered when computing dependencies for make. > > I implemented the option, because I wanted to know which MLB-files are > > actually used when MLton is compiled, so that I can go through them to > > better understand how much work it might require to get MLton to compile > > under MLKit. > > That would be very cool. Keep us posted. I saw your comp.lang.functional > posting, and it sounded like the annotations are the issue. Annotations are one of the issues. I already made a quick hack to MLKit to get past non-supported annotations, but then I ran into another issue. MLKit doesn't currently support export filters. Supporting them probably requires much more work, so before I try to implement export filters, I plan to workaround them and try to get MLton to compile first (to see how much work beyond supporting export filters might be required). I plan to transform (either manually or with the help of some scripts) MLB code of the form <--- foo.mlb ---> local foo-bar-and-baz-and-more.sml in signature FOO structure Bar = Baz functor FooBar end <--- foo.mlb ---> to <--- foo.mlb ---> local foo-bar-and-baz-and-more.sml in foo-filter.sml end <--- foo.mlb ---> <--- foo-filter.sml ---> signature FOO = FOO structure Bar = Baz functor FooBar (S: FOO) = FooBar (S) <--- foo-filter.sml ---> Which, AFAIU, should give the same meaning (or maybe there is some complication that I can't see?). This makes me wonder about the importance of the export filter feature. -Vesa Karvonen From vesa.karvonen@cs.helsinki.fi Thu Feb 9 09:35:29 2006 From: vesa.karvonen@cs.helsinki.fi (Vesa Karvonen) Date: Thu, 9 Feb 2006 11:35:29 +0200 Subject: [MLton] MLB file tree Message-ID: <1139477729.43eb0ce1125f9@www1.helsinki.fi> Quoting Vesa Karvonen : > An annotation could then be implemented to allow that > warning to be disabled in specific cases. For example: > > ann > "ignoreMultipleElaboration" > in > infixes.sml > end [I was in a hurry to get to work when I wrote that.] A better annotation would be something like multipleElaboration {warn|error|ignore} and it would be used like: ann "multipleElaboration ignore" in infixes.sml end If this sounds like a useful feature (diagnostic on multiple elaboration) to have, I could look into implementing it during the weekend. (I also have another draft patch (the printing of types with fewer parentheses) waiting, that I haven't had time to complete in the past few months.) -Vesa Karvonen From fluet@cs.cornell.edu Thu Feb 9 14:14:07 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Thu, 9 Feb 2006 09:14:07 -0500 (EST) Subject: [MLton] MLB file tree In-Reply-To: <1139477729.43eb0ce1125f9@www1.helsinki.fi> References: <1139477729.43eb0ce1125f9@www1.helsinki.fi> Message-ID: > A better annotation would be something like > > multipleElaboration {warn|error|ignore} > > and it would be used like: > > ann > "multipleElaboration ignore" > in > infixes.sml > end Interestingly, I am aggressively using elaboration of the same source file multiple times to refactor the Basis Library implementation to be agnostic to the sizes of C types. Essentially, I have <--- config/c/x86-linux/c-types.sml ---> structure C_Int = Int32 structure C_Long = Int32 structure C_LongLong = Int64 ... <--- config/c/x86-linux/c-types.sml ---> <--- config/c/amd64-linux/c-types.sml ---> structure C_Int = Int32 structure C_Long = Int64 structure C_LongLong = Int64 ... <--- config/c/x86-linux/c-types.sml ---> And I reference them via config/c/$(TARGET_ARCH)-$(TARGET_OS)/c-types.sml. I elaborate them multiple times, once with little more than the primitive integer types and primops in Int{32,64} and then once again when Int{32,64} have been redefined with more operations. The first binding gives me the types C_Long.int for use in the definitions of primitives and _import-ed functions. In any case, this isn't an argument against the annotation. > If this sounds like a useful feature (diagnostic on multiple > elaboration) to have, I could look into implementing it during the > weekend. (I also have another draft patch (the printing of types with > fewer parentheses) waiting, that I haven't had time to complete in the > past few months.) Feel free. As you've pointed out elsewhere, most annotations do not change the meaning of the program, but simply what warnings/errors are reported. So, I think it is alright to experiment a bit with different annotation choices. From fluet@cs.cornell.edu Thu Feb 9 14:36:14 2006 From: fluet@cs.cornell.edu (Matthew Fluet) Date: Thu, 9 Feb 2006 09:36:14 -0500 (EST) Subject: [MLton] MLB file tree In-Reply-To: <1139474369.43eaffc12f173@www2.helsinki.fi> References: <1139474369.43eaffc12f173@www2.helsinki.fi> Message-ID: On Thu, 9 Feb 2006, Vesa Karvonen wrote: > Quoting Matthew Fluet : >>> Attached is a draft patch for a new option "-stop ft" to print the "MLB >>> file tree". >> >> That looks generally useful. I wonder, though, whether the format could >> be improved. > > I'm personally not entirely happy with the format, but I'm uncertain on > how to improve it. Let me elaborate on my requirements. You and Stephen have made decent arguments for including both '{ }' and indenting. > I think that the main problem with the current format is that it prints > both relative and absolute paths. I think that it would be best to only > print absolute paths. That ought to be quite easy to achieve. Although, I didn't see any relative paths in the sample output. >>> I implemented the option, because I wanted to know which MLB-files are >>> actually used when MLton is compiled, so that I can go through them to >>> better understand how much work it might require to get MLton to compile >>> under MLKit. >> >> That would be very cool. Keep us posted. I saw your comp.lang.functional >> posting, and it sounded like the annotations are the issue. > > Annotations are one of the issues. I already made a quick hack to MLKit > to get past non-supported annotations, but then I ran into another issue. > MLKit doesn't currently support export filters. Supporting them probably > requires much more work, so before I try to implement export filters, I > plan to workaround them and try to get MLton to compile first (to see how > much work beyond supporting export filters might be required). I haven't looked at the MLKit's implementation of MLBs in any depth, but export filters are pretty trivial to support in MLton's implementation. > I plan to transform (either manually or with the help of some scripts) MLB > code of the form > > <--- foo.mlb ---> > local > foo-bar-and-baz-and-more.sml > in > signature FOO > structure Bar = Baz > functor FooBar > end > <--- foo.mlb ---> > > to > > <--- foo.mlb ---> > local > foo-bar-and-baz-and-more.sml > in > foo-filter.sml > end > <--- foo.mlb ---> > > <--- foo-filter.sml ---> > signature FOO = FOO > structure Bar = Baz > functor FooBar (S: FOO) = FooBar (S) > <--- foo-filter.sml ---> > > Which, AFAIU, should give the same meaning (or maybe there is some > complication that I can't see?). This makes me wonder about the > importance of the export filter feature. It should have the same meaning in most cases. Functors are really the complication, as the argument signature need not be bound to a signature identifier and it is not necessarily true that the signature argument can be expressed with the basis in scope. For example: <--- a.sml ---> structure A = struct type t = A end <--- a.sml ---> <--- f.sml ---> functor F(val x: A.t) = struct ... end <--- f.sml ---> <--- foo.mlb ---> local local a.sml in f.sml end in functor F end <--- foo.mlb ---> You can't transform this in the manner described above, since the functor argument includes the type A.t, which isn't in scope at the point of the export filter. On the other hand, it would be a stylistic error if any functors in the mlton source tree did not have their argument signature bound to a signature identifier, and hiding the types of functor argument components would generally make the functor unusable, so I doubt that this will be an issue. As to the utility of export filters (and, more generally, module identifier binding), they are there for convenience, not expressiveness. But, if you look at the MLB system as namespace management, then it makes sense to not have to drop down to a .sml file to do such renamings. Essentially, if with nearly every z.mlb file you have a z-filter.sml file, then there is a redundancy. From fluet@mlton.org Fri Feb 10 00:38:31 2006 From: fluet@mlton.org (Matthew Fluet) Date: Thu, 9 Feb 2006 16:38:31 -0800 Subject: [MLton] commit r4349: preliminary support for compiler specific annotations Message-ID: <200602100038.k1A0cVi15008@mlton.org> Added very simple support for compiler specific annotations. If an annotation contains ":", then the text preceding the ":" is meant to denote a compiler. For MLton, if the text preceding the ":" is equal to "mlton", then the remaining annotation is scanned as a normal annotation. If the text preceding the ":" is not-equal to "mlton", then the annotation is ignored, and no warning is issued. ---------------------------------------------------------------------- U mlton/trunk/mlton/control/control-flags.sig U mlton/trunk/mlton/control/control-flags.sml U mlton/trunk/mlton/elaborate/elaborate-mlbs.fun U mlton/trunk/mlton/main/main.fun From MLton@mlton.org Fri Feb 10 02:26:14 2006 From: MLton@mlton.org (Stephen Weeks) Date: Thu, 9 Feb 2006 18:26:14 -0800 Subject: [MLton] Paging friendly GC? In-Reply-To: <50258B57-DDD8-4784-9FB7-370DAD5F24C8@terpstra.ca> References: <50258B57-DDD8-4784-9FB7-370DAD5F24C8@terpstra.ca> Message-ID: <17387.63942.291617.117084@eponym.sweeks.com> > However, I seem to recall that MLton uses a 'generational mark-sweep' > algorithm...? Yes, that is what MLton uses when memory gets tight. > I know that MLton performs very poorly once the heap size exceeds > physical memory. The system thrashes to death. So, when I saw this, > I thought maybe those of you with a clue might care: > > http://www.cs.umass.edu/~emery/pubs/f034-hertz.pdf > > Is this relevant / useful for MLton? Yes. It is a nice idea that could be applied to MLton's collector. My guess is that it would be a one to two month project. For those who haven't read the paper, the idea is to add to the collector an additional (oldest) generation consisting of all the pages that are not resident in memory. The garbage collector doesn't visit this oldest generation, and hence doesn't cause page faults. A single bit in the header of each object (a "bookmark") is used to keep track of the existence of an intergenerational pointer from the oldest generation to the object. As pages are moved between memory and disk, the runtime maintains the bookmarks (this requires OS cooperation to inform of the movement). Applying the technique to MLton would require a substantial rewrite because of MLton's use of a monolithic heap. There are also changes due to the fact that the runtime can't move objects pointed to by objects in the oldest generation, since you don't want to visit the out-of-RAM page to update the pointer. There's also the problem of avoiding space leaks from keeping dead off-disk objects alive too long. None of those problems is insurmountable; they just take work. The main problem in practice is that the technique requires cooperation from the OS that doesn't seem to be available in stock kernels. They have a 600 line kernel mod for Linux. I don't know how much, if any, of the benefit can be achieved on a stock kernel. > Could something like this make a self-compile feasible with < 512MB RAM? I doubt it would help much. In self compiles, there really is that much live data, and it's all touched by the mutator frequently. From MLton@mlton.org Fri Feb 10 15:34:58 2006 From: MLton@mlton.org (Stephen Weeks) Date: Fri, 10 Feb 2006 07:34:58 -0800 Subject: [MLton] using fold to write numeric constants Message-ID: <17388.45730.227626.857357@eponym.sweeks.com> The following code shows how to use fold to conveniently write numeric constants in any base of various types. For example, N i 10 `1`2`3 $ denotes 123:int in base 10, while N ii 8 `2`3 $ denotes 19:IntInf.int in base 8. Digits are checked dynamically to ensure they are valid for the base, but of course MLton will simplify everything away at compile time. I can imagine using phantom types to statically ensure validity, at the expense of (perhaps too much) extra verbiage. -------------------------------------------------------------------------------- fun $ (a, f) = f a fun curry f x y = f (x, y) fun id x = x fun pass x f = f x structure Fold = struct val fold = pass fun step0 h (a1, f) = fold (h a1, f) fun step1 h $ x = step0 (curry h x) $ end structure Num = struct fun N ty base = Fold.fold (ty base, fn (n, _) => n) local fun make (zero, op *, op +, op <, op <=, i2x, x2s) base = let val base = i2x base in (zero, fn (i, n) => let val i = i2x i in if zero <= i andalso i < base then n * base + i else raise Fail (concat ["Num: ", x2s i, " is not a valid digit in base ", x2s base]) end) end in val i = make (0, op *, op +, op <, op <=, id, Int.toString) val ii = make (0, op *, op +, op <, op <=, IntInf.fromInt, IntInf.toString) val w = make (0w0, op *, op +, op <, op <=, Word.fromInt, Word.toString) end fun ` z = Fold.step1 (fn (i, (ac, step)) => (step (i, ac), step)) z val a = 10 val b = 11 val c = 12 val d = 13 val e = 14 val f = 15 end local fun make x2s x = print (concat [x2s x, "\n"]) in val pi = make Int.toString val pii = make IntInf.toString val pw = make Word.toString end local open Num in val () = pi (N i 10 `1`2`3 $) val () = pii (N ii 10 `1`2`3`4`5`6`7`8`9`0`1`2 $) val () = pw (N w 16 `1`b $) val () = pi (N i 12 `1`a $) val () = pii (N ii 8 `2`3 $) val () = pw (N w 2 `1`1`0 $) end From vesa.karvonen@cs.helsinki.fi Fri Feb 10 16:24:09 2006 From: vesa.karvonen@cs.helsinki.fi (Vesa Karvonen) Date: Fri, 10 Feb 2006 18:24:09 +0200 Subject: [MLton] using fold to write numeric constants Message-ID: <1139588649.43ecbe297be32@www1.helsinki.fi> Quoting Stephen Weeks : > The following code shows how to use fold to conveniently write numeric > constants in any base of various types. For example, > > N i 10 `1`2`3 $ > > denotes 123:int in base 10, while > > N ii 8 `2`3 $ > > denotes 19:IntInf.int in base 8. Neat! (((Here is how one can do similar things with the C99 preprocessor: http://cvs.sourceforge.net/viewcvs.py/chaos-pp/order-pp/example/binary.h?view=markup Warning: Not to be taken too seriously!))) Looking briefly at the code, I noticed a minor simplification: > fun make (zero, op *, op +, op <, op <=, i2x, x2s) base = ^^^^ ^^^^^ Only one of those is needed. For example, using only `op <' you could write if not (i < zero) andalso i < base then instead of > if zero <= i andalso i < base then This would be a useful simplification (from the user's point-of-view) if the `make' function would not be local. The `zero' could also be eliminated easily. Instead of passing 0 to `make', you can compute a zero using the expression `i2x 0'. Of course, you could also implement `op *' in terms of `op +' and `op <', but that is likely to be inefficient (or maybe I'm underestimating MLton ;-)). (These issues are fresh on my mind, because I've been thinking about using higher-order functions, like `make', to implement a benchmark http://shootout.alioth.debian.org/gp4/benchmark.php?test=recursive&lang=all for MLton.) -Vesa Karvonen From MLton@mlton.org Fri Feb 10 18:08:18 2006 From: MLton@mlton.org (Stephen Weeks) Date: Fri, 10 Feb 2006 10:08:18 -0800 Subject: [MLton] using fold to write numeric constants In-Reply-To: <1139588649.43ecbe297be32@www1.helsinki.fi> References: <1139588649.43ecbe297be32@www1.helsinki.fi> Message-ID: <17388.54930.735083.688570@eponym.sweeks.com> > Looking briefly at the code, I noticed a minor simplification: > > > fun make (zero, op *, op +, op <, op <=, i2x, x2s) base = > ^^^^ ^^^^^ > > Only one of those is needed. ... > The `zero' could also be eliminated easily. ... > This would be a useful simplification (from the user's point-of-view) if the > `make' function would not be local. Good catches. It does make sense for "make" to be exported, so that the code can be used for user-specified types. -------------------------------------------------------------------------------- fun $ (a, f) = f a fun curry f x y = f (x, y) fun id x = x fun pass x f = f x structure Fold = struct val fold = pass fun step0 h (a1, f) = fold (h a1, f) fun step1 h $ x = step0 (curry h x) $ end structure Num = struct fun N ty base = Fold.fold (ty base, fn (n, _) => n) fun make (op *, op +, op <, i2x, x2s) base = let val zero = i2x 0 val base = i2x base in (zero, fn (i, n) => let val i = i2x i in if not (i < zero) andalso i < base then n * base + i else raise Fail (concat ["Num: ", x2s i, " is not a valid digit in base ", x2s base]) end) end val i = make (op *, op +, op <, id, Int.toString) val ii = make (op *, op +, op <, IntInf.fromInt, IntInf.toString) val w = make (op *, op +, op <, Word.fromInt, Word.toString) fun ` z = Fold.step1 (fn (i, (ac, step)) => (step (i, ac), step)) z val a = 10 val b = 11 val c = 12 val d = 13 val e = 14 val f = 15 end local fun make x2s x = print (concat [x2s x, "\n"]) in val pi = make Int.toString val pii = make IntInf.toString val pw = make Word.toString end local open Num in val () = pi (N i 10 `1`2`3 $) val () = pii (N ii 10 `1`2`3`4`5`6`7`8`9`0`1`2 $) val () = pw (N w 16 `1`b $) val () = pi (N i 12 `1`a $) val () = pii (N ii 8 `2`3 $) val () = pw (N w 2 `1`1`0 $) end From twm@andrew.cmu.edu Mon Feb 13 21:14:30 2006 From: twm@andrew.cmu.edu (Tom 7) Date: Mon, 13 Feb 2006 16:14:30 -0500 (EST) Subject: [MLton] patch for CM cc variable support? Message-ID: May I request this small change to the way that CM works in mlton? Right now, there are no defined symbols whatsoever, which (as far as I can tell) makes it impossible to use the conditional compilation system to make a CM file that works with both mlton and the newest sml/nj. file mlton/cm/parse.sml line 37: -- old -- val lex = Lexer.lexer {strdef = no, sigdef = no, fctdef = no, fsigdef = no, symval = fn _ => NONE} (cmfile, ins) -- new -- fun symval "MLTON" = SOME 1 | symval _ = NONE val lex = Lexer.lexer {strdef = no, sigdef = no, fctdef = no, fsigdef = no, symval = symval} (cmfile, ins) With this, I can write CM files like group is #if MLTON < 1 $/basis.cm #endif file.sml etc.sml that compile with both compilers. (Also, if anyone can think of a way to achieve this without any change to mlton, I'm all ears!) It might also make sense to modify line 408 of lexer.sml to return SOME 0 for undefined symbols, as SML/NJ apparently does. I do understand the desire to avoid the slippery and infinite slope of CM compatibility hacks, however! Thanks as always, Tom [ NEW! : http://tom7.org/ ] [ OLD! : http://fonts.tom7.com/ ] From MLton@mlton.org Mon Feb 13 22:38:08 2006 From: MLton@mlton.org (Stephen Weeks) Date: Mon, 13 Feb 2006 14:38:08 -0800 Subject: [MLton] patch for CM cc variable support? In-Reply-To: References: Message-ID: <17393.2640.587176.365960@eponym.sweeks.com> > May I request this small change to the way that CM works in mlton? > Right now, there are no defined symbols whatsoever, . which (as far > as I can tell) makes it impossible to use the conditional > compilation system to make a CM file that works with both mlton and > the newest sml/nj. According to http://mlton.org/CompilationManager, the following should work. I just checked, and indeed it does. In SML/NJ, the preprocessor defines the symbol SMLNJ_VERSION. In MLton, no symbols are defined. So, to conditionally include foo.sml when compiling under SML/NJ, one can use the following pattern. # if (defined(SMLNJ_VERSION)) foo.sml # endif To conditionally include foo.sml when compiling under MLton, one can negate the test. # if (! defined(SMLNJ_VERSION)) foo.sml # endif > It might also make sense to modify line 408 of lexer.sml to return > SOME 0 for undefined symbols, as SML/NJ apparently does. I guess you mean line 404? I have no strong objection to such a change, if that's what people in the CM world would expect. But I worry that such a change would cause more confusion than reporting an error, as conditionals would be silently taken (or not). Since MLton doesn't define any variables, I don't really see the use for such a thing, or any useful overlap with SML/NJ. Also, with the above idiom, it should be possible to wrap stuff that uses SML/NJ CM variables so that it only runs under SML/NJ, right? Anyone else have any thoughts? From twm@andrew.cmu.edu Mon Feb 13 22:47:01 2006 From: twm@andrew.cmu.edu (Tom 7) Date: Mon, 13 Feb 2006 17:47:01 -0500 (EST) Subject: [MLton] patch for CM cc variable support? In-Reply-To: <17393.2640.587176.365960@eponym.sweeks.com> References: <17393.2640.587176.365960@eponym.sweeks.com> Message-ID: This works fine, thanks! Somehow I led myself to believe that the defined() mechanism was only for SML identifiers, and missed the use for CM variables (and the mlton page describing this). Oops.. I don't care about CM compatibility, I just wanted some way to maintain fewer files for small projects. Since that already exists, I withdraw my requests! =) Tom > >> May I request this small change to the way that CM works in mlton? >> Right now, there are no defined symbols whatsoever, . which (as far >> as I can tell) makes it impossible to use the conditional >> compilation system to make a CM file that works with both mlton and >> the newest sml/nj. > > According to http://mlton.org/CompilationManager, the following should > work. I just checked, and indeed it does. > > In SML/NJ, the preprocessor defines the symbol SMLNJ_VERSION. In > MLton, no symbols are defined. So, to conditionally include foo.sml > when compiling under SML/NJ, one can use the following pattern. > > # if (defined(SMLNJ_VERSION)) > foo.sml > # endif > > To conditionally include foo.sml when compiling under MLton, one can > negate the test. > > # if (! defined(SMLNJ_VERSION)) > foo.sml > # endif > >> It might also make sense to modify line 408 of lexer.sml to return >> SOME 0 for undefined symbols, as SML/NJ apparently does. > > I guess you mean line 404? I have no strong objection to such a > change, if that's what people in the CM world would expect. But I > worry that such a change would cause more confusion than reporting an > error, as conditionals would be silently taken (or not). Since MLton > doesn't define any variables, I don't really see the use for such a > thing, or any useful overlap with SML/NJ. Also, with the above idiom, > it should be possible to wrap stuff that uses SML/NJ CM variables so > that it only runs under SML/NJ, right? Anyone else have any thoughts? > > [ NEW! : http://tom7.org/ ] [ OLD! : http://fonts.tom7.com/ ] From henry.cejtin@sbcglobal.net Tue Feb 14 15:47:48 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Tue, 14 Feb 2006 09:47:48 -0600 Subject: [MLton] patch for CM cc variable support? In-Reply-To: <17393.2640.587176.365960@eponym.sweeks.com> Message-ID: I agree with Stephen that it is better to report the error about symbols not being defined than it is to try to be compatible and have such symbols have an assumed value of 0. From MLton@mlton.org Tue Feb 21 16:44:13 2006 From: MLton@mlton.org (Stephen Weeks) Date: Tue, 21 Feb 2006 08:44:13 -0800 Subject: [MLton] Welcome to Immanuel Litzroth Message-ID: <17403.17245.580381.986103@eponym.sweeks.com> Welcome to Immanuel Litzroth, who has joined the MLton mailing list. Immanuel is a professional C++ programmer with an interest in functional languages, and is new to MLton/SML. He is interested in reading the SML Definition and Commentary and learning about MLton's compilation model and MLB files. He is currently developing a PDF parser in SML. Immanuel, there are a number of readers of this list who are intimately familiar with the Definition, and so if you have a question about it you can almost certainly find an answer. Also, I am not aware of any existing PDF parsing library in SML, so if you are able to contribute your code to the community, it would be much appreciated. Welcome! From geoffw@cis.upenn.edu Wed Feb 22 05:30:37 2006 From: geoffw@cis.upenn.edu (Geoffrey Alan Washburn) Date: Wed, 22 Feb 2006 00:30:37 -0500 Subject: [MLton] Re: Welcome to Immanuel Litzroth In-Reply-To: <17403.17245.580381.986103@eponym.sweeks.com> References: <17403.17245.580381.986103@eponym.sweeks.com> Message-ID: <43FBF6FD.8050501@cis.upenn.edu> Stephen Weeks wrote: > Welcome to Immanuel Litzroth, who has joined the MLton mailing list. > Immanuel is a professional C++ programmer with an interest in > functional languages, and is new to MLton/SML. He is interested in > reading the SML Definition and Commentary and learning about MLton's > compilation model and MLB files. He is currently developing a PDF > parser in SML. > > Immanuel, there are a number of readers of this list who are > intimately familiar with the Definition, and so if you have a question > about it you can almost certainly find an answer. Also, I am not > aware of any existing PDF parsing library in SML, so if you are able > to contribute your code to the community, it would be much > appreciated. If I remember correctly, Jason Reed has written some of a library for writing PDFs via SML, I don't know whether it has any parsing capabilities. From geoffw@cis.upenn.edu Wed Feb 22 05:30:37 2006 From: geoffw@cis.upenn.edu (Geoffrey Alan Washburn) Date: Wed, 22 Feb 2006 00:30:37 -0500 Subject: [MLton] Re: Welcome to Immanuel Litzroth In-Reply-To: <17403.17245.580381.986103@eponym.sweeks.com> References: <17403.17245.580381.986103@eponym.sweeks.com> Message-ID: <43FBF6FD.8050501@cis.upenn.edu> Stephen Weeks wrote: > Welcome to Immanuel Litzroth, who has joined the MLton mailing list. > Immanuel is a professional C++ programmer with an interest in > functional languages, and is new to MLton/SML. He is interested in > reading the SML Definition and Commentary and learning about MLton's > compilation model and MLB files. He is currently developing a PDF > parser in SML. > > Immanuel, there are a number of readers of this list who are > intimately familiar with the Definition, and so if you have a question > about it you can almost certainly find an answer. Also, I am not > aware of any existing PDF parsing library in SML, so if you are able > to contribute your code to the community, it would be much > appreciated. If I remember correctly, Jason Reed has written some of a library for writing PDFs via SML, I don't know whether it has any parsing capabilities. From wesley@terpstra.ca Sun Feb 26 18:26:00 2006 From: wesley@terpstra.ca (Wesley W. Terpstra) Date: Sun, 26 Feb 2006 19:26:00 +0100 Subject: [MLton] GUI toolkits (was: mingwows) Message-ID: On 2005-11-15 03:17, Henry Cejtin wrote: > [...] working on a GTK binding [...] > > Sorry, no CVS although I talked to Stephen about it and it will go into the > MLton one when it is at least vaguely presentable. My estimate (notoriously > inaccurate) is 1 month or so. Just curious if the status has changed...? I'm still very interested in a nice MLton binding of GTK. From henry.cejtin@sbcglobal.net Sun Feb 26 18:41:39 2006 From: henry.cejtin@sbcglobal.net (Henry Cejtin) Date: Sun, 26 Feb 2006 12:41:39 -0600 Subject: [MLton] GUI toolkits (was: mingwows) In-Reply-To: Message-ID: Sadly, my usual inaccuracy on estimating how long things take is still holding up, but it will go in, hopefully shortly.