From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.1.3 (2006-06-01) on yquem.inria.fr X-Spam-Level: * X-Spam-Status: No, score=1.3 required=5.0 tests=AWL,HTML_MESSAGE,SPF_NEUTRAL autolearn=disabled version=3.1.3 X-Original-To: caml-list@yquem.inria.fr Delivered-To: caml-list@yquem.inria.fr Received: from discorde.inria.fr (discorde.inria.fr [192.93.2.38]) by yquem.inria.fr (Postfix) with ESMTP id 6B43FBC0C for ; Thu, 18 Jan 2007 17:23:30 +0100 (CET) Received: from nf-out-0910.google.com (nf-out-0910.google.com [64.233.182.188]) by discorde.inria.fr (8.13.6/8.13.6) with ESMTP id l0IGNTlF024869 for ; Thu, 18 Jan 2007 17:23:29 +0100 Received: by nf-out-0910.google.com with SMTP id q29so238540nfc for ; Thu, 18 Jan 2007 08:23:29 -0800 (PST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gmail.com; s=beta; h=received:message-id:date:from:to:subject:in-reply-to:mime-version:content-type:references; b=F/ndrRKMfQfCjmWXInc6IueqtuFLw/YmwvZa/wEiij5t0QtURsoVBieiAuGfAqg7iJrfpugnx/pbxAZ7yltyZysyX2c9XwvksDzIGneALUjJwOOB9bWL9uVKVdK8+TbzTAFxdHS3qQAGx3dNA6dzDibmF2uOSo/psaUpdCc8P54= Received: by 10.82.135.13 with SMTP id i13mr277008bud.1169137408717; Thu, 18 Jan 2007 08:23:28 -0800 (PST) Received: by 10.82.100.16 with HTTP; Thu, 18 Jan 2007 08:23:28 -0800 (PST) Message-ID: Date: Thu, 18 Jan 2007 17:23:28 +0100 From: Tom To: caml-list Subject: Fwd: [Caml-list] Polymorphic Variants In-Reply-To: MIME-Version: 1.0 Content-Type: multipart/alternative; boundary="----=_Part_182020_9748721.1169137408166" References: <200701172253.13837.jon@ffconsultancy.com> <200701172349.53331.jon@ffconsultancy.com> X-j-chkmail-Score: MSGID : 45AF9F01.001 on discorde : j-chkmail score : XX : 0/20 2 0.000 -> 2 X-Miltered: at discorde with ID 45AF9F01.001 by Joe's j-chkmail (http://j-chkmail . ensmp . fr)! X-Spam: no; 0.00; variants:01 variants:01 sqrt:01 compiler:01 infers:01 inference:01 infers:01 sqrt:01 ocaml:01 ocaml:01 compiler:01 optimise:01 subtypes:01 subtyping:01 subtyping:01 X-Attachments: cset="UTF-8" cset="UTF-8" ------=_Part_182020_9748721.1169137408166 Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 7bit Content-Disposition: inline ---------- Forwarded message ---------- From: Tom Date: 18-Jan-2007 13:07 Subject: Re: [Caml-list] Polymorphic Variants To: Jon Harrop On 18/01/07, Jon Harrop wrote: > On Wednesday 17 January 2007 23:07, you wrote: > > 3 solutions: > > * sqrt has type of float -> float and the compiler infers float > arguments > > Type inference starts at the leaf subexpressions. In the absence of other > type > information, it gets to x*x and infers x to be the default type parameter > of > + and then fails when it gets to sqrt of an int. No... i rather thought it that way: x is anything x * x is either int or float, so x is either int or float x * x + x * x is either int or float, so the two (x * x) are either both int or both float sqrt accepts a float argument, so x * x + x * x must be float, so (x * x) must be float, so x must be float. > > * you write +. and *. (at least once) (those operators could be still > > available, don't you think so?) > > Yes. Then you have complicated the language without improving upon OCaml. Hm... well, I must say that I agree. Actually, I am against this option (for purposes other that compatibility with original OCaml) > You could even add a float literal: > > x +. 0. and have it optimized away > > > And the records could be > > optimised so that type information is only added when it is needed by > the > > programm. > > Then you acquire the poor optimisability of Lisp, where you are forced to > plough through reams of optimisation-related compiler warnings in order to > find exactly where you must annotate the code to recover the lost > performance. Well... I guess it's quite simple. If it's only one record, than optimise it. If it has "subrecords" (=subtypes), than don't. You see, I am not against OCaml. No! I love it. And I am not trying to change it. You seem to be a priori against my ideas, just because they are not what is generally accepted. All I want to do is write my own language, both for the sake of writing one (they say it's good practice) and for the sake of correcting things that I have found bother me when I program OCaml. As pointed out a number of times, you should design a language for yourself, not for others, not for the "general public" [1]. So what I want is something that will enable me to program in a fast, yet efficient manner, and to be able to express many things as naturally as possible. Therefore, most of the features I suggested are not "evil" or "mean", they are just my solutions to what I think are the most common problems - actually, one biggest problem: too much typing. No, actually, the nominal subtyping of records is because it's faster than structural subtyping of objects, as implemented by OCaml. If anyone has any idea, how to make structural subtyping faster, I would love to incorporate it. > > * let the compiler overload your function ( length : (int * int) -> > > float; length : (float * float) -> float) and then drop the "int" one as > > > you never ever used it in your code. > > What happens at code boundaries? e.g. to compile a DLL, the compiler must > generate all possible permutation of type variables for every function. > Then > you end up with a compiler that's 2,000x slower than OCaml's, like the > Stalin > scheme compiler. In addition to what I have written in the previous remark, I think you are overly concerned with performance only. It's great you think about many things, but these things have quite simple answers. Either, one could write an incremental compiler (similar to the way OCaml provides separate compilation, but somehow more refined is what I have in mind), or write interfaces - again what OCaml does (to optimise say, the min function (let min (x: int) y = if x > y then y else x) so that it is faster) - it's just that what you would actually need to do is DELETE interfaces, because the compiler would infer the whole interface for you, and you would just delete the entries you don't want to have in it. All in all, I believe that optimizations (compile-time evaluation (and don't say I forgot that some functions have side effects)), incremental compilation and a smart and powerful IDE, along with OCaml's already existent debugger and profiler should keep one from being stopped by implementation issues. Idea, ideas, ideas are important, ideas are what matters. [1] http://www.paulgraham.com/langdes.html (2. Design for Yourself and Your Friends. ) By the way, do you think I can send this message to others too? (I think it significantly clarifies my position) - Tom ------=_Part_182020_9748721.1169137408166 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: base64 Content-Disposition: inline PGJyPjxicj4tLS0tLS0tLS0tIEZvcndhcmRlZCBtZXNzYWdlIC0tLS0tLS0tLS08YnI+PHNwYW4g Y2xhc3M9ImdtYWlsX3F1b3RlIj5Gcm9tOiA8YiBjbGFzcz0iZ21haWxfc2VuZGVybmFtZSI+VG9t PC9iPiAmbHQ7PGEgaHJlZj0ibWFpbHRvOnRvbS5wcmltb3ppY0BnbWFpbC5jb20iPnRvbS5wcmlt b3ppY0BnbWFpbC5jb208L2E+Jmd0Ozxicj5EYXRlOiAxOC1KYW4tMjAwNyAxMzowNzxicj4KU3Vi amVjdDogUmU6IFtDYW1sLWxpc3RdIFBvbHltb3JwaGljIFZhcmlhbnRzPGJyPlRvOiBKb24gSGFy cm9wICZsdDs8YSBocmVmPSJtYWlsdG86am9uQGZmY29uc3VsdGFuY3kuY29tIj5qb25AZmZjb25z dWx0YW5jeS5jb208L2E+Jmd0Ozxicj48YnI+PC9zcGFuPjxzcGFuIGNsYXNzPSJxIj48YnI+PGJy Pgo8ZGl2PjxzcGFuIGNsYXNzPSJnbWFpbF9xdW90ZSI+T24gMTgvMDEvMDcsIDxiIGNsYXNzPSJn bWFpbF9zZW5kZXJuYW1lIj5Kb24gSGFycm9wPC9iPiAmbHQ7PGEgaHJlZj0ibWFpbHRvOmpvbkBm ZmNvbnN1bHRhbmN5LmNvbSIgdGFyZ2V0PSJfYmxhbmsiIG9uY2xpY2s9InJldHVybiB0b3AuanMu T3BlbkV4dExpbmsod2luZG93LGV2ZW50LHRoaXMpIj5qb25AZmZjb25zdWx0YW5jeS5jb20KPC9h PiZndDsgd3JvdGU6PC9zcGFuPjwvZGl2Pgo8YmxvY2txdW90ZSBjbGFzcz0iZ21haWxfcXVvdGUi IHN0eWxlPSJib3JkZXItbGVmdDogMXB4IHNvbGlkIHJnYigyMDQsIDIwNCwgMjA0KTsgbWFyZ2lu OiAwcHggMHB4IDBweCAwLjhleDsgcGFkZGluZy1sZWZ0OiAxZXg7Ij5PbiBXZWRuZXNkYXkgMTcg SmFudWFyeSAyMDA3IDIzOjA3LCB5b3Ugd3JvdGU6PGJyPiZndDsgMyBzb2x1dGlvbnM6PGJyPiZn dDsmbmJzcDsmbmJzcDsgKiBzcXJ0IGhhcyB0eXBlIG9mIGZsb2F0IC0mZ3Q7IGZsb2F0IGFuZCB0 aGUgY29tcGlsZXIgaW5mZXJzIGZsb2F0IGFyZ3VtZW50cwo8YnI+PGJyPlR5cGUgaW5mZXJlbmNl IHN0YXJ0cyBhdCB0aGUgbGVhZiBzdWJleHByZXNzaW9ucy4gSW4gdGhlIGFic2VuY2Ugb2Ygb3Ro ZXIgdHlwZTxicj5pbmZvcm1hdGlvbiwgaXQgZ2V0cyB0byB4KnggYW5kIGluZmVycyB4IHRvIGJl IHRoZSBkZWZhdWx0IHR5cGUgcGFyYW1ldGVyIG9mPGJyPisgYW5kIHRoZW4gZmFpbHMgd2hlbiBp dCBnZXRzIHRvIHNxcnQgb2YgYW4gaW50LjwvYmxvY2txdW90ZT4KCgo8ZGl2PiZuYnNwOzwvZGl2 Pjwvc3Bhbj4KPGRpdj5Oby4uLiBpIHJhdGhlciB0aG91Z2h0IGl0IHRoYXQgd2F5OjwvZGl2Pgo8 ZGl2PiZuYnNwOyZuYnNwOyZuYnNwOyAmbmJzcDt4IGlzIGFueXRoaW5nPC9kaXY+CjxkaXY+Jm5i c3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7IHggKiB4IGlzIGVpdGhlciBpbnQgb3IgZmxvYXQsIHNvIHgg aXMgZWl0aGVyIGludCBvciBmbG9hdDwvZGl2Pgo8ZGl2PiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNw OyZuYnNwO3ggKiB4Jm5ic3A7KyZuYnNwO3ggKiB4Jm5ic3A7aXMgZWl0aGVyIGludCBvciBmbG9h dCwgc28gdGhlIHR3byAoeCAqIHgpIGFyZSBlaXRoZXIgYm90aCBpbnQgb3IgYm90aCBmbG9hdDwv ZGl2Pgo8ZGl2PiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyBzcXJ0IGFjY2VwdHMgYSBmbG9hdCBh cmd1bWVudCwgc28mbmJzcDt4ICogeCArJm5ic3A7eCAqIHgmbmJzcDttdXN0IGJlIGZsb2F0LCBz byAoeCAqIHgpIG11c3QgYmUgZmxvYXQsIHNvIHggbXVzdCBiZSBmbG9hdC4gPC9kaXY+PHNwYW4g Y2xhc3M9InEiPgo8ZGl2Pjxicj4mbmJzcDs8L2Rpdj4KPGJsb2NrcXVvdGUgY2xhc3M9ImdtYWls X3F1b3RlIiBzdHlsZT0iYm9yZGVyLWxlZnQ6IDFweCBzb2xpZCByZ2IoMjA0LCAyMDQsIDIwNCk7 IG1hcmdpbjogMHB4IDBweCAwcHggMC44ZXg7IHBhZGRpbmctbGVmdDogMWV4OyI+Jmd0OyZuYnNw OyZuYnNwOyAqIHlvdSB3cml0ZSArLiBhbmQgKi4gKGF0IGxlYXN0IG9uY2UpICh0aG9zZSBvcGVy YXRvcnMgY291bGQgYmUgc3RpbGw8YnI+Jmd0OyBhdmFpbGFibGUsIGRvbiYjMzk7dCB5b3UgdGhp bmsgc28/KQo8YnI+PGJyPlllcy4gVGhlbiB5b3UgaGF2ZSBjb21wbGljYXRlZCB0aGUgbGFuZ3Vh Z2Ugd2l0aG91dCBpbXByb3ZpbmcgdXBvbiBPQ2FtbC48L2Jsb2NrcXVvdGU+CjxkaXY+Jm5ic3A7 PC9kaXY+PC9zcGFuPgo8ZGl2PkhtLi4uIHdlbGwsIEkgbXVzdCBzYXkgdGhhdCBJIGFncmVlLiBB Y3R1YWxseSwgSSBhbSBhZ2FpbnN0IHRoaXMgb3B0aW9uIChmb3IgcHVycG9zZXMgb3RoZXIgdGhh dCBjb21wYXRpYmlsaXR5IHdpdGggb3JpZ2luYWwgT0NhbWwpPC9kaXY+PHNwYW4gY2xhc3M9InEi Pgo8ZGl2Pjxicj4mbmJzcDs8L2Rpdj4KPGJsb2NrcXVvdGUgY2xhc3M9ImdtYWlsX3F1b3RlIiBz dHlsZT0iYm9yZGVyLWxlZnQ6IDFweCBzb2xpZCByZ2IoMjA0LCAyMDQsIDIwNCk7IG1hcmdpbjog MHB4IDBweCAwcHggMC44ZXg7IHBhZGRpbmctbGVmdDogMWV4OyI+WW91IGNvdWxkIGV2ZW4gYWRk IGEgZmxvYXQgbGl0ZXJhbDo8YnI+PGJyPnggKy4gMC48L2Jsb2NrcXVvdGU+CjxkaXY+Jm5ic3A7 PC9kaXY+PC9zcGFuPgo8ZGl2PmFuZCBoYXZlIGl0IG9wdGltaXplZCBhd2F5PC9kaXY+PHNwYW4g Y2xhc3M9InEiPgo8ZGl2PiZuYnNwOzwvZGl2Pgo8YmxvY2txdW90ZSBjbGFzcz0iZ21haWxfcXVv dGUiIHN0eWxlPSJib3JkZXItbGVmdDogMXB4IHNvbGlkIHJnYigyMDQsIDIwNCwgMjA0KTsgbWFy Z2luOiAwcHggMHB4IDBweCAwLjhleDsgcGFkZGluZy1sZWZ0OiAxZXg7Ij48YnI+Jmd0OyBBbmQg dGhlIHJlY29yZHMgY291bGQgYmU8YnI+Jmd0OyBvcHRpbWlzZWQgc28gdGhhdCB0eXBlIGluZm9y bWF0aW9uIGlzIG9ubHkgYWRkZWQgd2hlbiBpdCBpcyBuZWVkZWQgYnkgdGhlCjxicj4mZ3Q7IHBy b2dyYW1tLjxicj48YnI+VGhlbiB5b3UgYWNxdWlyZSB0aGUgcG9vciBvcHRpbWlzYWJpbGl0eSBv ZiBMaXNwLCB3aGVyZSB5b3UgYXJlIGZvcmNlZCB0bzxicj5wbG91Z2ggdGhyb3VnaCByZWFtcyBv ZiBvcHRpbWlzYXRpb24tcmVsYXRlZCBjb21waWxlciB3YXJuaW5ncyBpbiBvcmRlciB0bzxicj5m aW5kIGV4YWN0bHkgd2hlcmUgeW91IG11c3QgYW5ub3RhdGUgdGhlIGNvZGUgdG8gcmVjb3ZlciB0 aGUgbG9zdAo8YnI+cGVyZm9ybWFuY2UuPC9ibG9ja3F1b3RlPgo8ZGl2PiZuYnNwOzwvZGl2Pjwv c3Bhbj4KPGRpdj5XZWxsLi4uIEkgZ3Vlc3MgaXQmIzM5O3MgcXVpdGUgc2ltcGxlLiBJZiBpdCYj Mzk7cyBvbmx5IG9uZSByZWNvcmQsIHRoYW4gb3B0aW1pc2UgaXQuIElmIGl0IGhhcyAmcXVvdDtz dWJyZWNvcmRzJnF1b3Q7ICg9c3VidHlwZXMpLCB0aGFuIGRvbiYjMzk7dC48L2Rpdj4KPGRpdj4m bmJzcDs8L2Rpdj4KPGRpdj5Zb3Ugc2VlLCBJIGFtIG5vdCBhZ2FpbnN0IE9DYW1sLiBObyEgSSBs b3ZlIGl0LiBBbmQgSSBhbSBub3QgdHJ5aW5nIHRvIGNoYW5nZSBpdC4gWW91IHNlZW0gdG8gYmUg YSBwcmlvcmkgYWdhaW5zdCBteSBpZGVhcywganVzdCBiZWNhdXNlIHRoZXkgYXJlIG5vdCB3aGF0 IGlzIGdlbmVyYWxseSBhY2NlcHRlZC4gQWxsIEkgd2FudCB0byBkbyBpcyB3cml0ZSBteSBvd24g bGFuZ3VhZ2UsIGJvdGggZm9yIHRoZSBzYWtlIG9mIHdyaXRpbmcgb25lICh0aGV5IHNheSBpdCYj Mzk7cyBnb29kIHByYWN0aWNlKSBhbmQgZm9yIHRoZSBzYWtlIG9mIGNvcnJlY3RpbmcgdGhpbmdz IHRoYXQgSSBoYXZlIGZvdW5kIGJvdGhlciBtZSB3aGVuIEkgcHJvZ3JhbSBPQ2FtbC4gQXMgcG9p bnRlZCBvdXQgYSBudW1iZXIgb2YgdGltZXMsIHlvdSBzaG91bGQgZGVzaWduIGEgbGFuZ3VhZ2Ug Zm9yIHlvdXJzZWxmLCBub3QgZm9yIG90aGVycywgbm90IGZvciB0aGUgJnF1b3Q7Z2VuZXJhbCBw dWJsaWMmcXVvdDsgWzFdLiBTbyB3aGF0IEkgd2FudCBpcyBzb21ldGhpbmcgdGhhdCB3aWxsIGVu YWJsZSBtZSB0byBwcm9ncmFtIGluIGEgZmFzdCwgeWV0IGVmZmljaWVudCBtYW5uZXIsIGFuZCB0 byBiZSBhYmxlIHRvIGV4cHJlc3MgbWFueSB0aGluZ3MgYXMgbmF0dXJhbGx5IGFzIHBvc3NpYmxl LiBUaGVyZWZvcmUsIG1vc3Qgb2YgdGhlIGZlYXR1cmVzIEkgc3VnZ2VzdGVkIGFyZSBub3QgJnF1 b3Q7ZXZpbCZxdW90OyBvciAmcXVvdDttZWFuJnF1b3Q7LCB0aGV5IGFyZSBqdXN0IG15IHNvbHV0 aW9ucyB0byB3aGF0IEkgdGhpbmsgYXJlIHRoZSBtb3N0IGNvbW1vbiBwcm9ibGVtcyAtIGFjdHVh bGx5LCBvbmUgYmlnZ2VzdCBwcm9ibGVtOiB0b28gbXVjaCB0eXBpbmcuIE5vLCBhY3R1YWxseSwg dGhlIG5vbWluYWwgc3VidHlwaW5nIG9mIHJlY29yZHMgaXMgYmVjYXVzZSBpdCYjMzk7cyBmYXN0 ZXIgdGhhbiBzdHJ1Y3R1cmFsIHN1YnR5cGluZyBvZiBvYmplY3RzLCBhcyBpbXBsZW1lbnRlZCBi eSBPQ2FtbC4gSWYgYW55b25lIGhhcyBhbnkgaWRlYSwgaG93IHRvIG1ha2Ugc3RydWN0dXJhbCBz dWJ0eXBpbmcgZmFzdGVyLCBJIHdvdWxkIGxvdmUgdG8gaW5jb3Jwb3JhdGUgaXQuIAo8L2Rpdj48 c3BhbiBjbGFzcz0icSI+CjxkaXY+Jm5ic3A7PC9kaXY+CjxkaXY+Jm5ic3A7PC9kaXY+CjxibG9j a3F1b3RlIGNsYXNzPSJnbWFpbF9xdW90ZSIgc3R5bGU9ImJvcmRlci1sZWZ0OiAxcHggc29saWQg cmdiKDIwNCwgMjA0LCAyMDQpOyBtYXJnaW46IDBweCAwcHggMHB4IDAuOGV4OyBwYWRkaW5nLWxl ZnQ6IDFleDsiPiZndDsmbmJzcDsmbmJzcDsgKiBsZXQgdGhlIGNvbXBpbGVyIG92ZXJsb2FkIHlv dXIgZnVuY3Rpb24gKCBsZW5ndGggOiAoaW50ICogaW50KSAtJmd0Ozxicj4mZ3Q7IGZsb2F0OyBs ZW5ndGggOiAoZmxvYXQgKiBmbG9hdCkgLSZndDsgZmxvYXQpIGFuZCB0aGVuIGRyb3AgdGhlICZx dW90O2ludCZxdW90OyBvbmUgYXMKPGJyPiZndDsgeW91IG5ldmVyIGV2ZXIgdXNlZCBpdCBpbiB5 b3VyIGNvZGUuPGJyPjxicj5XaGF0IGhhcHBlbnMgYXQgY29kZSBib3VuZGFyaWVzPyBlLmcuIHRv IGNvbXBpbGUgYSBETEwsIHRoZSBjb21waWxlciBtdXN0PGJyPmdlbmVyYXRlIGFsbCBwb3NzaWJs ZSBwZXJtdXRhdGlvbiBvZiB0eXBlIHZhcmlhYmxlcyBmb3IgZXZlcnkgZnVuY3Rpb24uIFRoZW48 YnI+eW91IGVuZCB1cCB3aXRoIGEgY29tcGlsZXIgdGhhdCYjMzk7cyAyLDAwMHggc2xvd2VyIHRo YW4gT0NhbWwmIzM5O3MsIGxpa2UgdGhlIFN0YWxpbgo8YnI+c2NoZW1lIGNvbXBpbGVyLjwvYmxv Y2txdW90ZT4KPGRpdj4mbmJzcDs8L2Rpdj48L3NwYW4+CjxkaXY+SW4gYWRkaXRpb24gdG8gd2hh dCBJIGhhdmUgd3JpdHRlbiBpbiB0aGUgcHJldmlvdXMgcmVtYXJrLCBJIHRoaW5rIHlvdSBhcmUg b3Zlcmx5IGNvbmNlcm5lZCB3aXRoIHBlcmZvcm1hbmNlIG9ubHkuIEl0JiMzOTtzIGdyZWF0IHlv dSB0aGluayBhYm91dCBtYW55IHRoaW5ncywgYnV0IHRoZXNlIHRoaW5ncyBoYXZlIHF1aXRlIHNp bXBsZSBhbnN3ZXJzLiBFaXRoZXIsIG9uZSBjb3VsZCB3cml0ZSBhbiBpbmNyZW1lbnRhbCBjb21w aWxlciAoc2ltaWxhciB0byB0aGUgd2F5IE9DYW1sIHByb3ZpZGVzIHNlcGFyYXRlIGNvbXBpbGF0 aW9uLCBidXQgc29tZWhvdyBtb3JlIHJlZmluZWQgaXMgd2hhdCBJIGhhdmUgaW4gbWluZCksIG9y IHdyaXRlIGludGVyZmFjZXMgLSBhZ2FpbiB3aGF0IE9DYW1sIGRvZXMgKHRvIG9wdGltaXNlIHNh eSwgdGhlIG1pbiBmdW5jdGlvbiAobGV0IG1pbiAoeDogaW50KSZuYnNwO3kgPSBpZiB4ICZndDsg eSB0aGVuIHkgZWxzZSB4KSBzbyB0aGF0IGl0IGlzIGZhc3RlcikgLSBpdCYjMzk7cyBqdXN0IHRo YXQgd2hhdCB5b3Ugd291bGQgYWN0dWFsbHkgbmVlZCB0byBkbyBpcyBERUxFVEUgaW50ZXJmYWNl cywgYmVjYXVzZSB0aGUgY29tcGlsZXIgd291bGQgaW5mZXIgdGhlIHdob2xlIGludGVyZmFjZSBm b3IgeW91LCBhbmQgeW91IHdvdWxkIGp1c3QgZGVsZXRlIHRoZSBlbnRyaWVzIHlvdSBkb24mIzM5 O3Qgd2FudCB0byBoYXZlIGluIGl0LiAKPC9kaXY+CjxkaXY+Jm5ic3A7PC9kaXY+CjxkaXY+QWxs IGluIGFsbCwgSSBiZWxpZXZlIHRoYXQgb3B0aW1pemF0aW9ucyAoY29tcGlsZS10aW1lIGV2YWx1 YXRpb24mbmJzcDsoYW5kIGRvbiYjMzk7dCBzYXkgSSBmb3Jnb3QgdGhhdCBzb21lIGZ1bmN0aW9u cyBoYXZlIHNpZGUgZWZmZWN0cykpLCBpbmNyZW1lbnRhbCBjb21waWxhdGlvbiBhbmQgYSBzbWFy dCBhbmQgcG93ZXJmdWwgSURFLCBhbG9uZyB3aXRoIE9DYW1sJiMzOTtzIGFscmVhZHkgZXhpc3Rl bnQgZGVidWdnZXIgYW5kIHByb2ZpbGVyIHNob3VsZCBrZWVwIG9uZSBmcm9tIGJlaW5nIHN0b3Bw ZWQgYnkgaW1wbGVtZW50YXRpb24gaXNzdWVzLiBJZGVhLCBpZGVhcywgaWRlYXMgYXJlIGltcG9y dGFudCwgaWRlYXMgYXJlIHdoYXQgbWF0dGVycy4gCjwvZGl2Pgo8ZGl2PiZuYnNwOzwvZGl2Pgo8 ZGl2PlsxXSA8YSBocmVmPSJodHRwOi8vd3d3LnBhdWxncmFoYW0uY29tL2xhbmdkZXMuaHRtbCIg dGFyZ2V0PSJfYmxhbmsiIG9uY2xpY2s9InJldHVybiB0b3AuanMuT3BlbkV4dExpbmsod2luZG93 LGV2ZW50LHRoaXMpIj5odHRwOi8vd3d3LnBhdWxncmFoYW0uY29tL2xhbmdkZXMuaHRtbDwvYT4m bmJzcDsoMi4gRGVzaWduIGZvciBZb3Vyc2VsZiBhbmQgWW91ciBGcmllbmRzLiApPC9kaXY+Cgo8 ZGl2PiZuYnNwOzwvZGl2Pgo8ZGl2PiZuYnNwOzwvZGl2Pgo8ZGl2PkJ5IHRoZSB3YXksIGRvIHlv dSB0aGluayBJIGNhbiBzZW5kIHRoaXMgbWVzc2FnZSB0byBvdGhlcnMgdG9vPyAoSSB0aGluayBp dCBzaWduaWZpY2FudGx5IGNsYXJpZmllcyBteSBwb3NpdGlvbik8L2Rpdj48c3BhbiBjbGFzcz0i c2ciPgo8ZGl2PiZuYnNwOzwvZGl2Pgo8ZGl2Pi0gVG9tPC9kaXY+Cjwvc3Bhbj4K ------=_Part_182020_9748721.1169137408166--