Mailman 3 December 2001 - Cplusplus-sig

Re: boost::python, returning new PyObject references
by David Abrahams Dec. 29, 2001

Dec. 29, 2001

On Saturday, December 29, 2001, at 12:05 PM, Arnaldur Gylfason wrote: Hi Arnaldur, > I'ts not just testing if it compiles though. By printing data and > returning > data, I can verify things visually by loading the module in python and > calling the functions there. OK. > > * There are no tests for the generic sequence and mapping. Is that > intentional? > > It's mostly tested through the proxies for the moment. I don't understand what you mean by that. > I'll stress that this is mostly for seeing if the design works. Unit > tests > have to be added. Understood. > * It seems to me that "callback" is an insufficiently descriptive > name. > Maybe "set_function" or "assignment_action" would be better... if > that's > what it does. What is the purpose of the callback? > > It is used if the ref has a Null PyObject*. And when does that occur? > It is true that it is just used > for mapping. > (Should be used for dictionary also). The reason for it in those cases > is > detecting illegal key access > but allowing setting new key-value pair. Normally a proxy would only do the access on demand. I can't think of any reason to hold a reference to an object other than the underlying sequence or mapping in the proxy. Oh, well I guess in the mapping case the proxy should hold a reference to the key object and the underlying sequence. > You're right that it is probably better to override the get() and > reference > () methods for mapping > (dictionary later) instead of putting it in object_base. Did I suggest that? I'm not sure what you're referring to. > * Why does sequence::append call PyListe_Append? That doesn't seem > like > the generic interface for sequence we had in mind. > > That is a mistake on my part. OK. > * Why are there separate sequence and mapping proxies if they both > carry a > callback to do the work? It looks to me like a single proxy class > would be > more appropriate. > > The mapping proxy sets a callback to grab illegal key access. > Maybe they can be combined though (?). It seems to me that a less-effortful proxy design using callbacks would take a pair of function objects, get() and set(), which are responsible for extracting an object from or inserting the object into the container at the appropriate index or key. That design could be reused for any mutable python container that might come along. > * What is the point of having objects.hpp and objects_b.hpp? Are > there > advantages/disadvantages to one or the other? > > By using callbacks we can save us some proxy classes. > But the callback version is maybe harder to understand. I guess I still don't have a good overall picture of what you're doing. > * Shouldn't sequence inherit privately from object? I don't think > that > a > sequence in general has a __call__ operation. What we discussed > was > a fully-generic class "object" which supplies the full Python > object > interface, with privately derived classes for more-restrictive > interfaces, > using using-declarations to expose public access to the > appropriate > functions. > > The object interface is general but has some methods that might not be > implemented (i.e. __call__ (PyObject_CallObject)). > That goes for all objects. The user has to know if the object supports > it > or not. What's the point of having different C++ types, then? You could just use the generic object for everything. I suppose there would be a very minor speed improvement if you know that an object is in fact a list rather than some generic sequence, but I don't think too many people are concerned about the speed of code operating at the C++/Python boundary. > I think we should think about this part and decide between > public/private > inheritance. I think these are fundamental questions, and they have less to do with inheritance per-se than the intended meaning of the type system. > I'll clean things up and send you again (with the number interface). > Are you happy with the virtual inheritance? Sure, why not? > What do you think about the use of callbacks? There's nothing wrong with it in principle, but I'm not sure you've taken the best advantage of them. > I think we can use the iterator_proxy for list (the iterator support) > for > item access. > What do you think about that? I think I'll need you to clarify what you're doing a bit more before I can form a useful answer. Thanks, Dave

1 0

Re: boost::python, returning new PyObject references
by Arnaldur Gylfason Dec. 29, 2001

Dec. 29, 2001

Hi Dave, Some answers/comments to your remarks: * (Trivial) please use spaces instead of tabs - this applies to all of your files. Sorry. I use textpad and supposedly have all tabs changed to spaces when saved (must check that now!). * It doesn't test anything other than that certain constructs compile. There should be assertions or other semantic checks that verify the behavior. That's right there isn't any real testing there. I mean to add unit tests when we've settled on the design. I'ts not just testing if it compiles though. By printing data and returning data, I can verify things visually by loading the module in python and calling the functions there. * What is the purpose of the large commented-out section at the top? It has nothing to do with what we're adding now so it's best to delete it altogether * There are no tests for the generic sequence and mapping. Is that intentional? It's mostly tested through the proxies for the moment. I'll stress that this is mostly for seeing if the design works. Unit tests have to be added. * It seems to me that "callback" is an insufficiently descriptive name. Maybe "set_function" or "assignment_action" would be better... if that's what it does. What is the purpose of the callback? It is used if the ref has a Null PyObject*. It is true that it is just used for mapping. (Should be used for dictionary also). The reason for it in those cases is detecting illegal key access but allowing setting new key-value pair. You're right that it is probably better to override the get() and reference () methods for mapping (dictionary later) instead of putting it in object_base. * Why does sequence::append call PyListe_Append? That doesn't seem like the generic interface for sequence we had in mind. That is a mistake on my part. * Why are there separate sequence and mapping proxies if they both carry a callback to do the work? It looks to me like a single proxy class would be more appropriate. The mapping proxy sets a callback to grab illegal key access. Maybe they can be combined though (?). * The lack of comments in the code makes it hard to understand what you're aiming at. I'll add some * Some of your lines are so long that they're difficult to understand, Guilty there. I've never set up any working rule regarding that. I'll try to change that. * Lots of commented-out code in this file obscures your intention also. Sorry, remains of some experimentations. It'sstill there because I haven't decided the final design yet. * What is the point of having objects.hpp and objects_b.hpp? Are there advantages/disadvantages to one or the other? By using callbacks we can save us some proxy classes. But the callback version is maybe harder to understand. * Shouldn't sequence inherit privately from object? I don't think that a sequence in general has a __call__ operation. What we discussed was a fully-generic class "object" which supplies the full Python object interface, with privately derived classes for more-restrictive interfaces, using using-declarations to expose public access to the appropriate functions. The object interface is general but has some methods that might not be implemented (i.e. __call__ (PyObject_CallObject)). That goes for all objects. The user has to know if the object supports it or not. I think we should think about this part and decide between public/private inheritance. I'll clean things up and send you again (with the number interface). Are you happy with the virtual inheritance? What do you think about the use of callbacks? I think we can use the iterator_proxy for list (the iterator support) for item access. What do you think about that? Cheers Arnaldur

1 0

Re: boost::python, returning new PyObject references
by David Abrahams Dec. 28, 2001

Dec. 28, 2001

Remarks: tmodule.cpp - * (Trivial) please use spaces instead of tabs - this applies to all of your files. * It doesn't test anything other than that certain constructs compile. There should be assertions or other semantic checks that verify the behavior. * What is the purpose of the large commented-out section at the top? * The reason you get a compile error from handle_exception() is that the interface for using it has changed in CVS (the documentation hasn't been updated yet). It now takes a boost::function0<void> parameter which represents the operation whose exceptions should be handled, returning true if there was an exception and false otherwise. This was done to account for the many compilers with buggy EH mechanisms that don't handle the catch-all-and-rethrow idiom correctly. * There are no tests for the generic sequence and mapping. Is that intentional? objects_b.hpp - * It seems to me that "callback" is an insufficiently descriptive name. Maybe "set_function" or "assignment_action" would be better... if that's what it does. What is the purpose of the callback? * It seems to me that the callback is misplaced in object_base, since only the mapping_proxy makes any use of it. * Why does sequence::append call PyListe_Append? That doesn't seem like the generic interface for sequence we had in mind. * Shouldn't sequence inherit privately from object? I don't think that a sequence in general has a __call__ operation. What we discussed was a fully-generic class "object" which supplies the full Python object interface, with privately derived classes for more-restrictive interfaces, using using-declarations to expose public access to the appropriate functions. * The lack of comments in the code makes it hard to understand what you're aiming at. objects.hpp - * Why are there separate sequence and mapping proxies if they both carry a callback to do the work? It looks to me like a single proxy class would be more appropriate. * Some of your lines are so long that they're difficult to understand, e.g.: explicit proxy(ref item, boost::function<void,ref> s_callback, boost::function<ref> get_callback): object(item) , sequence::proxy(object::reference(),s_callback). The following would be easier: explicit proxy( ref item , boost::function<void,ref> s_callback , boost::function<ref> get_callback) : object(item) , sequence::proxy(object::reference(),s_callback) I usually use 70-80 columns as a guideline, FWIW. * Lots of commented-out code in this file obscures your intention also. * What is the point of having objects.hpp and objects_b.hpp? Are there advantages/disadvantages to one or the other? ----- Original Message ----- From: "Arnaldur Gylfason" <arnaldur(a)decode.is> To: "David Abrahams" <david.abrahams(a)rcn.com> Cc: "Xavier Defrang" <xavier(a)perceval.net>; "Ullrich Koethe" <koethe(a)informatik.uni-hamburg.de>; "Ralf W. Grosse-Kunstleve" <rwgk(a)cci.lbl.gov>; "Niklas Blomberg" <niklas_blomberg(a)telia.com>; "Martin Casado" <casado2(a)llnl.gov>; "Mark Evans" <evans(a)kandctech.com>; "Lyle Johnson" <ljohnson(a)resgen.com>; "Barry Scott" <barry(a)scottb.demon.co.uk>; "Anton Gluck" <gluc(a)midway.uchicago.edu>; "Alex Martelli" <aleaxit(a)yahoo.com>; "Martin Casado" <mcasado(a)gmx.net>; "scott snyder" <snyder(a)fnal.gov> Sent: Wednesday, December 19, 2001 8:24 AM Subject: Re: boost::python, returning new PyObject references > > > Here is the code. > objects.hpp and objects.cpp > > Next step is making final (for the moment) decision regarding design and > the going on from there. > Adding the operators to be able to do m["k"] += 3 etc. is probably next. > Changing all proxies/ op[] in other classes should be done. > > > objects_b.hpp has the proxies that do not use the callbacks. > tmodule.cpp is a test module. > (See attached file: objects.hpp)(See attached file: objects_b.hpp)(See > attached file: objects.cpp)(See attached file: tmodule.cpp) > > Comments: > > object is a virtual base class for sequence and mapping. > seqmap inherits from both. > The proxies inherit from seqmap and thus provide both a sequence and > mapping interface. > > If a non-existent key is accessed, a Null ref (default constructed) is > stored in the proxies object_base. > Then the mapping::proxy stores a callback in the object_base that will call > PyObject_GetItem when used in > any way other than setting a new key-value pair. > > The proxies call reset after setting a new item to reflect the change. > That means the behaviour of multiple assignment is as would be expected: > python::sequence seq2 = seq[2] = 5; > I.e. seq2 gets 5 (instead of 3 which was the old value). > > const correctness is respected: If items are accessed for const > sequences/mappings, > only const methods in object, sequence or mapping can be used. > All methods that can possibly change the underlying PyObject are non-const. > > Constructors for seqmap and proxies call the object constructor directly > because it is a virtual base class. > There is no default constructor for the virtual base class. > Many consider that bad practice but a default constructor wouldn't make > sense in this case I think. > > Implicit Copy constructor and destructor respect virtual base classes. > According to the version of the Draft standard I found, the operator= could > assign the virtual base class > more than once - unspecified behaviour. => seqmap::operator= is defined. > > The copy constructor is specified in the object_base because of strange > behaviour. > When the ref holds a NULL object a Segmentation Fault occurs if it is used > to copy construct another one. > (Since the ref copy constructor calls Py_XINCREF it should handle NULL , > any ideas?). > Any way, by directly passing reference() in this case the callback is used. > In case of illegal key access > the Key Error is thrown here. > > > I believe all concrete object interfaces (like tuple, list, dictionary, > ...)should inherit from object_base. > If their interface has all relevant member functions there is no need to > inherit from object or sequence. > The idea of list<>, list<object>, list<sequence> , ...: > template<class ObjectType = object_bas> > list : public ObjectType > is interesting. > When ObjectType is sequence or other class that inherits virtually, a > problem arises. > The constructor would have to call the object constructor directly. > Hard if inherited fdrom a template parameter. > For now I believe just inheriting from object_base is good. > What do you think? > > Cheers > > Arnaldur >

1 0

python::list iterator support
by Arnaldur Gylfason Dec. 20, 2001

Dec. 20, 2001

--0__=00256B280043C4358f9e8a93df938690918c00256B280043C435 Content-type: text/plain; charset=us-ascii Hi I have added iterator support for list. Here is the code (list_iter.hpp) (See attached file: list_iter.hpp) It has just the additions. All previous stuff in list has been deleted. Add this to objects.hpp. I have tested it using: python::ref test_listiter() { python::list mylist; for(int i = 0;i < 10;++i) mylist.append(i); int sum = 0; for(python::list::iterator it = mylist.begin();it != mylist.end ();++it) { sum += static_cast<int>(*it); } //cout << typeid(python::list::iterator::reference).name(); cout << "Sum: " << sum; for(python::list::iterator it = mylist.begin();it != mylist.end ();++it) { *it = static_cast<int>(*it)*10; } return mylist; } which worked correctly. When number has been added, it will be easier to use. (e.g. could not use std::accumulate. Would have to explicitly type cast it.) Will work on that later. Note. If operator[] returns iterator_proxy it will probably be a bit faster. Cheers Arnaldur --0__=00256B280043C4358f9e8a93df938690918c00256B280043C435 Content-type: application/octet-stream; name="list_iter.hpp" Content-Disposition: attachment; filename="list_iter.hpp" Content-transfer-encoding: base64 CgpzdHJ1Y3QgbGlzdF9pdGVyYXRvcl9wb2xpY2llcyA6IHB1YmxpYyBib29zdDo6ZGVmYXVsdF9p dGVyYXRvcl9wb2xpY2llcwp7Cgl0ZW1wbGF0ZTwgY2xhc3MgSXRlcmF0b3JBZGFwdG9yPgoJdHlw ZW5hbWUgSXRlcmF0b3JBZGFwdG9yOjpyZWZlcmVuY2UgZGVyZWZlcmVuY2UoY29uc3QgSXRlcmF0 b3JBZGFwdG9yJiBpdGVyKSBjb25zdAoJewoJCXR5cGVkZWYgdHlwZW5hbWUgSXRlcmF0b3JBZGFw dG9yOjpyZWZlcmVuY2UgcmVzdWx0X3Q7CgkJcmV0dXJuIHJlc3VsdF90KGl0ZXIuYmFzZSgpKTsK CX0KICAKfTsKCgpjbGFzcyBsaXN0IDogcHVibGljIG9iamVjdF9iYXNlCnsKCSBzdHJ1Y3QgaXRl cmF0b3JfcHJveHkgOiBwdWJsaWMgc2VxbWFwCgkgewoJCSBleHBsaWNpdCBpdGVyYXRvcl9wcm94 eShQeU9iamVjdCoqIF9iYXNlKSA6IG9iamVjdChyZWYoKl9iYXNlKSkgLCBzZXFtYXAob2JqZWN0 OjpyZWZlcmVuY2UoKSkgLCBiYXNlKF9iYXNlKSB7IH0KCQkgCgkJdGVtcGxhdGU8Y2xhc3MgVD4K CQlpdGVyYXRvcl9wcm94eSYgb3BlcmF0b3I9KGNvbnN0IFQmIHJocykKCQl7CgkJCXJlc2V0KG1h a2VfcmVmKHJocykpOwoJCQkqYmFzZSA9IGdldCgpOwoJCQlyZXR1cm4gKnRoaXM7CgkJfQoKCQlp dGVyYXRvcl9wcm94eSYgb3BlcmF0b3I9KGNvbnN0IGl0ZXJhdG9yX3Byb3h5JiByaHMpCgkJewoJ CQlyZXNldChyaHMucmVmZXJlbmNlKCkpOwoJCQkqYmFzZSA9IGdldCgpOwoJCQlyZXR1cm4gKnRo aXM7CgkJfQoJCQoJCXByaXZhdGU6CgkJCVB5T2JqZWN0KiogYmFzZTsKCSB9OwoJIAogcHVibGlj OgogCiAJIHR5cGVkZWYgYm9vc3Q6Oml0ZXJhdG9yX2FkYXB0b3I8UHlPYmplY3QqKixsaXN0X2l0 ZXJhdG9yX3BvbGljaWVzLAogCSAJCQkJCQkJCQkJCWJvb3N0OjppdGVyYXRvcl9jYXRlZ29yeV9p czxzdGQ6OmlucHV0X2l0ZXJhdG9yX3RhZz4sCiAJIAkJCQkJCQkJCQkJYm9vc3Q6OnZhbHVlX3R5 cGVfaXM8aXRlcmF0b3JfcHJveHk+LAogCSAJCQkJCQkJCQkJCWJvb3N0OjpyZWZlcmVuY2VfaXM8 aXRlcmF0b3JfcHJveHk+ID4gaXRlcmF0b3I7CgogCSB0eXBlZGVmIGJvb3N0OjppdGVyYXRvcl9h ZGFwdG9yPFB5T2JqZWN0KiosbGlzdF9pdGVyYXRvcl9wb2xpY2llcywKIAkgCQkJCQkJCQkJCQli b29zdDo6aXRlcmF0b3JfY2F0ZWdvcnlfaXM8c3RkOjppbnB1dF9pdGVyYXRvcl90YWc+LAogCSAJ CQkJCQkJCQkJCWJvb3N0Ojp2YWx1ZV90eXBlX2lzPGNvbnN0IGl0ZXJhdG9yX3Byb3h5PiwKIAkg CQkJCQkJCQkJCQlib29zdDo6cmVmZXJlbmNlX2lzPGNvbnN0IGl0ZXJhdG9yX3Byb3h5PiA+IGNv bnN0X2l0ZXJhdG9yOwogCgogICAgCiAgICBpdGVyYXRvciBiZWdpbigpCiAgICB7CgkJIHJldHVy biBpdGVyYXRvcihyZWludGVycHJldF9jYXN0PFB5TGlzdE9iamVjdCo+KGdldCgpKS0+b2JfaXRl bSk7CgkgfQoKICAgIGNvbnN0X2l0ZXJhdG9yIGJlZ2luKCkgY29uc3QKICAgIHsKCQkgcmV0dXJu IGNvbnN0X2l0ZXJhdG9yKHJlaW50ZXJwcmV0X2Nhc3Q8UHlMaXN0T2JqZWN0Kj4oZ2V0KCkpLT5v Yl9pdGVtKTsKCSB9CgogICAgaXRlcmF0b3IgZW5kKCkKICAgIHsKCQkgUHlMaXN0T2JqZWN0KiBw dHJfbGlzdCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UHlMaXN0T2JqZWN0Kj4oZ2V0KCkpOwoJCSByZXR1 cm4gaXRlcmF0b3IocHRyX2xpc3QtPm9iX2l0ZW0gKyBwdHJfbGlzdC0+b2Jfc2l6ZSk7CgkgfQoK ICAgIGNvbnN0X2l0ZXJhdG9yIGVuZCgpIGNvbnN0CiAgICB7CgkJIFB5TGlzdE9iamVjdCogcHRy X2xpc3QgPSByZWludGVycHJldF9jYXN0PFB5TGlzdE9iamVjdCo+KGdldCgpKTsKCQkgcmV0dXJu IGNvbnN0X2l0ZXJhdG9yKHB0cl9saXN0LT5vYl9pdGVtICsgcHRyX2xpc3QtPm9iX3NpemUpOwoJ IH0KCn07 --0__=00256B280043C4358f9e8a93df938690918c00256B280043C435--

1 0

[Boost.Python] Preview and design document
by David Abrahams Dec. 19, 2001

Dec. 19, 2001

Hi, A design document describing the new type conversion mechanism is checked into Boost cvs at libs/python/doc/new-conversions.html. A preview of the code is also availabe: ------------- Go to boost-root and: cvs update -d -f -rnewbpl boost/python libs/python cvs update -d -rmpl-development boost/mpl libs/mpl You'll find a Jamfile in libs/python which builds and runs some tests of the new system. ------------- -Dave =================================================== David Abrahams, C++ library designer for hire resume: http://users.rcn.com/abrahams/resume.html C++ Booster (http://www.boost.org) email: david.abrahams(a)rcn.com ===================================================

1 0

Re: boost::python, returning new PyObject references
by David Abrahams Dec. 19, 2001

Dec. 19, 2001

It sounds a bit like you want something like Andrei's GenScatterHierarchy. The idea is to make a new type which inherits from everything in a given type list. If you've been following the MPL/Loki discussions on boost you know we have a lot of implementations of that floating around. However, be careful not to generalize so much that it's impossible to make progress ;-) -Dave ----- Original Message ----- From: "Arnaldur Gylfason" <arnaldur(a)decode.is> To: "David Abrahams" <david.abrahams(a)rcn.com> Cc: "Alex Martelli" <aleaxit(a)yahoo.com>; "Barry Scott" <barry(a)scottb.demon.co.uk>; "Martin Casado" <casado2(a)llnl.gov>; "Mark Evans" <evans(a)kandctech.com>; "Anton Gluck" <gluc(a)midway.uchicago.edu>; "Ullrich Koethe" <koethe(a)informatik.uni-hamburg.de>; "Lyle Johnson" <ljohnson(a)resgen.com>; "Martin Casado" <mcasado(a)gmx.net>; "Niklas Blomberg" <niklas_blomberg(a)telia.com>; "Ralf W. Grosse-Kunstleve" <rwgk(a)cci.lbl.gov>; "scott snyder" <snyder(a)fnal.gov>; "Xavier Defrang" <xavier(a)perceval.net> Sent: Wednesday, December 19, 2001 11:25 AM Subject: Re: boost::python, returning new PyObject references > > Having a generic_object that inherits from several interfaces would be > helpful. > Something similar to boost::function maybe > ( > template<class OT1, class OT2> > generic_object2 : public OT1, public OT2 > { > public: > explicit generic_object2(ref r) : object(r) , OT1(r) , OT2(r) { } > > ... > > }; > > Similar for generic_object3 etc. > > Then have generic_object<OT1,OT2> and generic_object<OT1,OT2,OT3> etc. > > (generic_objectN -- functionN > generic_object -- function) > > Often something has to be redefined when two interfaces intersect ( e.g. in > seqmap ). > If it were possible to have a > INTERSECT(OT1,OT2) > that were some kind of macro that gives the correct definitions for OT1,OT2 > (or INTERSECT<OT1,OT2>) > we could have: > > template<class OT1, class OT2> > generic_object2 : public OT1, public OT2 > { > public: > explicit generic_object2(ref r) : object(r) , OT1(r) , OT2(r) { } > > INTERSECT(OT1,OT2) > > }; > > template<class OT1, class OT2,class OT3> > generic_object2 : public OT1, public OT2, public OT3 > { > public: > explicit generic_object2(ref r) : object(r) , OT1(r) , OT2(r) , OT3(r) > { } > > INTERSECT(OT1,OT2) > INTERSECT(OT1,OT3) > INTERSECT(OT2,OT3) > > }; > > > The proxies might then inherit from generic_object<sequence,mapping,number>

1 0

Re: boost::python, returning new PyObject references
by Arnaldur Gylfason Dec. 19, 2001

Dec. 19, 2001

Having a generic_object that inherits from several interfaces would be helpful. Something similar to boost::function maybe ( template<class OT1, class OT2> generic_object2 : public OT1, public OT2 { public: explicit generic_object2(ref r) : object(r) , OT1(r) , OT2(r) { } ... }; Similar for generic_object3 etc. Then have generic_object<OT1,OT2> and generic_object<OT1,OT2,OT3> etc. (generic_objectN -- functionN generic_object -- function) Often something has to be redefined when two interfaces intersect ( e.g. in seqmap ). If it were possible to have a INTERSECT(OT1,OT2) that were some kind of macro that gives the correct definitions for OT1,OT2 (or INTERSECT<OT1,OT2>) we could have: template<class OT1, class OT2> generic_object2 : public OT1, public OT2 { public: explicit generic_object2(ref r) : object(r) , OT1(r) , OT2(r) { } INTERSECT(OT1,OT2) }; template<class OT1, class OT2,class OT3> generic_object2 : public OT1, public OT2, public OT3 { public: explicit generic_object2(ref r) : object(r) , OT1(r) , OT2(r) , OT3(r) { } INTERSECT(OT1,OT2) INTERSECT(OT1,OT3) INTERSECT(OT2,OT3) }; The proxies might then inherit from generic_object<sequence,mapping,number>

1 0

Re: boost::python, returning new PyObject references
by Arnaldur Gylfason Dec. 19, 2001

Dec. 19, 2001

--0__=00256B270048BEB98f9e8a93df938690918c00256B270048BEB9 Content-type: text/plain; charset=us-ascii Here is the code. objects.hpp and objects.cpp Next step is making final (for the moment) decision regarding design and the going on from there. Adding the operators to be able to do m["k"] += 3 etc. is probably next. Changing all proxies/ op[] in other classes should be done. objects_b.hpp has the proxies that do not use the callbacks. tmodule.cpp is a test module. (See attached file: objects.hpp)(See attached file: objects_b.hpp)(See attached file: objects.cpp)(See attached file: tmodule.cpp) Comments: object is a virtual base class for sequence and mapping. seqmap inherits from both. The proxies inherit from seqmap and thus provide both a sequence and mapping interface. If a non-existent key is accessed, a Null ref (default constructed) is stored in the proxies object_base. Then the mapping::proxy stores a callback in the object_base that will call PyObject_GetItem when used in any way other than setting a new key-value pair. The proxies call reset after setting a new item to reflect the change. That means the behaviour of multiple assignment is as would be expected: python::sequence seq2 = seq[2] = 5; I.e. seq2 gets 5 (instead of 3 which was the old value). const correctness is respected: If items are accessed for const sequences/mappings, only const methods in object, sequence or mapping can be used. All methods that can possibly change the underlying PyObject are non-const. Constructors for seqmap and proxies call the object constructor directly because it is a virtual base class. There is no default constructor for the virtual base class. Many consider that bad practice but a default constructor wouldn't make sense in this case I think. Implicit Copy constructor and destructor respect virtual base classes. According to the version of the Draft standard I found, the operator= could assign the virtual base class more than once - unspecified behaviour. => seqmap::operator= is defined. The copy constructor is specified in the object_base because of strange behaviour. When the ref holds a NULL object a Segmentation Fault occurs if it is used to copy construct another one. (Since the ref copy constructor calls Py_XINCREF it should handle NULL , any ideas?). Any way, by directly passing reference() in this case the callback is used. In case of illegal key access the Key Error is thrown here. I believe all concrete object interfaces (like tuple, list, dictionary, ...)should inherit from object_base. If their interface has all relevant member functions there is no need to inherit from object or sequence. The idea of list<>, list<object>, list<sequence> , ...: template<class ObjectType = object_bas> list : public ObjectType is interesting. When ObjectType is sequence or other class that inherits virtually, a problem arises. The constructor would have to call the object constructor directly. Hard if inherited fdrom a template parameter. For now I believe just inheriting from object_base is good. What do you think? Cheers Arnaldur --0__=00256B270048BEB98f9e8a93df938690918c00256B270048BEB9 Content-type: application/octet-stream; name="objects.hpp" Content-Disposition: attachment; filename="objects.hpp" Content-transfer-encoding: base64 Ly8gIChDKSBDb3B5cmlnaHQgRGF2aWQgQWJyYWhhbXMgMjAwMC4gUGVybWlzc2lvbiB0byBjb3B5 LCB1c2UsIG1vZGlmeSwgc2VsbCBhbmQKLy8gIGRpc3RyaWJ1dGUgdGhpcyBzb2Z0d2FyZSBpcyBn cmFudGVkIHByb3ZpZGVkIHRoaXMgY29weXJpZ2h0IG5vdGljZSBhcHBlYXJzCi8vICBpbiBhbGwg Y29waWVzLiBUaGlzIHNvZnR3YXJlIGlzIHByb3ZpZGVkICJhcyBpcyIgd2l0aG91dCBleHByZXNz IG9yIGltcGxpZWQKLy8gIHdhcnJhbnR5LCBhbmQgd2l0aCBubyBjbGFpbSBhcyB0byBpdHMgc3Vp dGFiaWxpdHkgZm9yIGFueSBwdXJwb3NlLgovLwovLyAgVGhlIGF1dGhvciBncmF0ZWZ1bGx5IGFj a25vd2xlZ2VzIHRoZSBzdXBwb3J0IG9mIERyYWdvbiBTeXN0ZW1zLCBJbmMuLCBpbgovLyAgcHJv ZHVjaW5nIHRoaXMgd29yay4KCiNpZm5kZWYgT0JKRUNUU19EV0EwNTExMDBfSF8KIyBkZWZpbmUg T0JKRUNUU19EV0EwNTExMDBfSF8KCiMgaW5jbHVkZSA8Ym9vc3QvcHl0aG9uL2RldGFpbC93cmFw X3B5dGhvbi5ocHA+CiMgaW5jbHVkZSA8Ym9vc3QvcHl0aG9uL2RldGFpbC9jb25maWcuaHBwPgoj IGluY2x1ZGUgPGJvb3N0L3B5dGhvbi9yZWZlcmVuY2UuaHBwPgojIGluY2x1ZGUgImJvb3N0L29w ZXJhdG9ycy5ocHAiCiMgaW5jbHVkZSAiYm9vc3QvZnVuY3Rpb24uaHBwIgojIGluY2x1ZGUgImJv b3N0L2JpbmQuaHBwIgojIGluY2x1ZGUgPHV0aWxpdHk+CiNpbmNsdWRlIDxpb3N0cmVhbT4KCm5h bWVzcGFjZSBib29zdCB7IG5hbWVzcGFjZSBweXRob24gewoKCnRlbXBsYXRlPGNsYXNzIFQ+ClQg aWRlbnRpdHkoVCB4KQp7CglyZXR1cm4geDsKfQoKCmNsYXNzIG9iamVjdF9iYXNlCnsKIHB1Ymxp YzoKICAgIGV4cGxpY2l0IG9iamVjdF9iYXNlKHJlZiBwKSA6IG1fcChwKSAsIHJlZl9jYWxsYmFj ayhib29zdDo6YmluZChpZGVudGl0eTxyZWY+LG1fcCkpIHsgfQogICAgCiAgICAvLyBJZiBtX3Au Z2V0KCkgaXMgMCwgYSBzZWdtZW50YXRpb24gZmF1bHQgb2NjdXJzIGlmIHRoZSBkZWZhdWx0IGNv cHkgY29uc3RydWN0b3IgaXMgdXNlZCAKICAgIC8vIChwZWN1bGlhciBzaW5jZSBQeV9YSU5DUkVG IGlzIHVzZWQgaW4gcmVmIGNvcHkgY29uc3RydWN0b3IpCiAgICAvLyBXZSBtdXN0IGNhbGwgcmhz LnJlZmVyZW5jZSgpIHRvIGNhbGwgdGhlIGNhbGxiYWNrIGZ1bmN0aW9uIGluIHRoYXQgY2FzZS4K ICAgIG9iamVjdF9iYXNlKGNvbnN0IG9iamVjdF9iYXNlJiByaHMpIDogbV9wKHJocy5yZWZlcmVu Y2UoKSkgLCByZWZfY2FsbGJhY2socmhzLnJlZl9jYWxsYmFjaykgeyB9CgkgCgkgLy8gU2ltaWxh ciB0byB0aGUgY29weSBjb25zdHJ1Y3RvcgoJIG9iamVjdF9iYXNlJiBvcGVyYXRvcj0oY29uc3Qg b2JqZWN0X2Jhc2UmIHJocykKCSB7CgkJIGlmICh0aGlzID09ICZyaHMpIHJldHVybiAqdGhpczsK CQkgbV9wID0gcmhzLnJlZmVyZW5jZSgpOwoJCSByZWZfY2FsbGJhY2sgPSByaHMucmVmX2NhbGxi YWNrOwoJCSByZXR1cm4gKnRoaXM7CgkgfQogICAgCgkgLy8gUmV0dXJuIGEgcmVmZXJlbmNlIHRv IHRoZSBoZWxkIG9iamVjdAoJIHJlZiBvYmplY3RfYmFzZTo6cmVmZXJlbmNlKCkgY29uc3QKCSB7 CgkJIGlmICghbV9wLmdldCgpKQoJCQkgbV9wID0gcmVmX2NhbGxiYWNrKCk7CgoJICAgIHJldHVy biBtX3A7CgkgfQoKCSAvLyBSZXR1cm4gYSByYXcgcG9pbnRlciB0byB0aGUgaGVsZCBvYmplY3QK CSBQeU9iamVjdCogb2JqZWN0X2Jhc2U6OmdldCgpIGNvbnN0CgkgewoJICAgIGlmICghbV9wLmdl dCgpKQoJICAgIAkgbV9wID0gcmVmX2NhbGxiYWNrKCk7CgkJICAgIC8vcmV0dXJuIHJlZl9jYWxs YmFjaygpLmdldCgpOyAvLyBDaGVjayEsIElmIG5vdCBlcnJvciA9PiByZWYgZGVzdHJveWVkIGFu ZCByZXR1cm5lZCBvYmplY3QgY291bGQgYmUgZGVzdHJveWVkIQoJICAgIHJldHVybiBtX3AuZ2V0 KCk7CgkgfQoJIAoJIHZvaWQgcmVzZXQocmVmIG5ld19yZWYpCgkgewoJCSBtX3AgPSBuZXdfcmVm OwoJIH0KIAogCSB2b2lkIHNldF9jYWxsYmFjayhjb25zdCBib29zdDo6ZnVuY3Rpb248cmVmPiAm IHJlZl9mdW5jKQogCSB7CgkJIHJlZl9jYWxsYmFjayA9IHJlZl9mdW5jOwoJIH0KCgkgb3BlcmF0 b3IgcmVmKCkgY29uc3QKCSB7CgkJIHJldHVybiByZWZlcmVuY2UoKTsgLy8gcmVmZXJlbmNlKCkg dXNlZCBpbnN0ZWFkIG9mIG1fcCBkaXJlY3RseSBiZWNhdXNlIG9mIGNhbGxiYWNrIGluIHJlZmVy ZW5jZSgpCgkgfQoJIAogcHJpdmF0ZToKICAgIG11dGFibGUgcmVmIG1fcDsKICAgIGJvb3N0Ojpm dW5jdGlvbjxyZWY+IHJlZl9jYWxsYmFjazsKfTsKCgoKCgpjbGFzcyBvYmplY3QgOiBwdWJsaWMg b2JqZWN0X2Jhc2UKewoJCQpwdWJsaWM6CglzdGF0aWMgYm9vbCBhY2NlcHRzKHJlZiBwKQoJewoJ CXJldHVybiBwLmdldCgpOwoJfQoJCglleHBsaWNpdCBvYmplY3QocmVmIHBvYmopOiBvYmplY3Rf YmFzZShwb2JqKSB7IH0KCgl0ZW1wbGF0ZTx0eXBlbmFtZSBUPgoJdm9pZCBzZXRhdHRyKGNoYXIq IGF0dHJfbmFtZSxUIHZhbCkKCXsKCQlQeU9iamVjdF9TZXRBdHRyU3RyaW5nKGdldCgpLGF0dHJf bmFtZSxtYWtlX3JlZih2YWwpLmdldCgpKTsKCX0KCgl0ZW1wbGF0ZTx0eXBlbmFtZSBUPgoJdm9p ZCBnZXRhdHRyKGNoYXIqIGF0dHJfbmFtZSxUICYgdmFsKSBjb25zdAoJewoJCXZhbCA9IGZyb21f cHl0aG9uKHJlZihQeU9iamVjdF9HZXRBdHRyU3RyaW5nKGdldCgpLGF0dHJfbmFtZSkpLmdldCgp LHB5dGhvbjo6dHlwZTxUPigpKTsKCX0KCglvYmplY3QgZ2V0YXR0cihjaGFyKiBhdHRyX25hbWUp IGNvbnN0Cgl7CgkJcmV0dXJuIG9iamVjdChyZWYoUHlPYmplY3RfR2V0QXR0clN0cmluZyhnZXQo KSxhdHRyX25hbWUpKSk7Cgl9CgkKCglib29sIGhhc2F0dHIoY2hhciogYXR0cl9uYW1lKSBjb25z dAoJewoJCXJldHVybiBQeU9iamVjdF9IYXNBdHRyU3RyaW5nKGdldCgpLGF0dHJfbmFtZSkgIT0g MDsKCX0KCQoJaW50IGxlbigpIGNvbnN0Cgl7CgkJcmV0dXJuIFB5T2JqZWN0X0xlbmd0aChnZXQo KSk7Cgl9CgkKCXN0ZDo6c3RyaW5nIHN0cigpIGNvbnN0Cgl7CgkJcmVmIHN0cihQeU9iamVjdF9T dHIoZ2V0KCkpKTsKCQlyZXR1cm4gZnJvbV9weXRob24oc3RyLmdldCgpLHB5dGhvbjo6dHlwZTxz dGQ6OnN0cmluZz4oKSk7Cgl9CgoJb2JqZWN0IG9wZXJhdG9yKCkoKQoJewoJCXJldHVybiBvYmpl Y3QocmVmKFB5T2JqZWN0X0NhbGxGdW5jdGlvbihnZXQoKSwiKCkiKSkpOwoJfQoKCW9iamVjdCBj YWxsX21ldGhvZChjaGFyKiBtZXRob2RfbmFtZSkKCXsKCQlyZXR1cm4gb2JqZWN0KHJlZihQeU9i amVjdF9DYWxsTWV0aG9kKGdldCgpLG1ldGhvZF9uYW1lLCIoKSIpKSk7Cgl9CgoJdGVtcGxhdGUg PGNsYXNzIEExPgoJb2JqZWN0IG9wZXJhdG9yKCkoY29uc3QgQTEmIGExKQoJewoJCXJldHVybiBv YmplY3QocmVmKFB5T2JqZWN0X0NhbGxGdW5jdGlvbihnZXQoKSwiKE8pIixtYWtlX3JlZihhMSku Z2V0KCkpKSk7Cgl9CgoJdGVtcGxhdGUgPGNsYXNzIEExPgoJb2JqZWN0IGNhbGxfbWV0aG9kKGNo YXIqIG1ldGhvZF9uYW1lLGNvbnN0IEExJiBhMSkKCXsKCQlyZXR1cm4gb2JqZWN0KHJlZihQeU9i amVjdF9DYWxsTWV0aG9kKGdldCgpLG1ldGhvZF9uYW1lLCIoTykiLG1ha2VfcmVmKGExKS5nZXQo KSkpKTsKCX0KCgl0ZW1wbGF0ZSA8Y2xhc3MgQTEsIGNsYXNzIEEyPgoJb2JqZWN0IG9wZXJhdG9y KCkoY29uc3QgQTEmIGExLCBjb25zdCBBMiYgYTIpCgl7CgkJcmV0dXJuIG9iamVjdChyZWYoUHlP YmplY3RfQ2FsbEZ1bmN0aW9uKGdldCgpLCIoT08pIixtYWtlX3JlZihhMSkuZ2V0KCksbWFrZV9y ZWYoYTIpLmdldCgpKSkpOwoJfQoKCXRlbXBsYXRlIDxjbGFzcyBBMSwgY2xhc3MgQTI+CglvYmpl Y3QgY2FsbF9tZXRob2QoY2hhciogbWV0aG9kX25hbWUsY29uc3QgQTEmIGExLCBjb25zdCBBMiYg YTIpCgl7CgkJcmV0dXJuIG9iamVjdChyZWYoUHlPYmplY3RfQ2FsbE1ldGhvZChnZXQoKSxtZXRo b2RfbmFtZSwiKE9PKSIsbWFrZV9yZWYoYTEpLmdldCgpLG1ha2VfcmVmKGEyKS5nZXQoKSkpKTsK CX0KCQoJdGVtcGxhdGU8Y2xhc3MgVD4KCW9wZXJhdG9yIFQoKSBjb25zdAoJewoJCXJldHVybiBm cm9tX3B5dGhvbihnZXQoKSx0eXBlPFQ+KCkpOwoJfQoJCn07CgoKY2xhc3Mgc2VxdWVuY2UgOiBw dWJsaWMgdmlydHVhbCBvYmplY3QKewpwdWJsaWM6CgljbGFzcyBjcHJveHk7CgljbGFzcyBwcm94 eTsKCQpwdWJsaWM6CglzdGF0aWMgYm9vbCBhY2NlcHRzKHJlZiBwKQoJewoJCXJldHVybiBQeVNl cXVlbmNlX0NoZWNrKHAuZ2V0KCkpOwoJfQoKCWV4cGxpY2l0IHNlcXVlbmNlKGNvbnN0IG9iamVj dCAmIG9iaik6IG9iamVjdChvYmopIHt9CgkKCWV4cGxpY2l0IHNlcXVlbmNlKGNvbnN0IHJlZiYg cmhzKTogb2JqZWN0KHJocykge30KCQoJY29uc3QgcHJveHkgb3BlcmF0b3JbXShpbnQgaSkgY29u c3Q7CgoJcHJveHkgb3BlcmF0b3JbXShpbnQgaSk7CgkKCXRlbXBsYXRlPGNsYXNzIFQ+Cgl2b2lk IGFwcGVuZChjb25zdCBUJiB2YWwpCgl7CgkJUHlMaXN0X0FwcGVuZChnZXQoKSxtYWtlX3JlZih2 YWwpLmdldCgpKTsKCX0KCQoJaW50IHNpemUoKSBjb25zdAoJewoJCXJldHVybiBQeVNlcXVlbmNl X1NpemUoZ2V0KCkpOwoJfQoJCglyZWYgZ2V0X2l0ZW0oaW50IGkpIGNvbnN0Cgl7CgkJcmV0dXJu IHJlZihQeVNlcXVlbmNlX0dldEl0ZW0oZ2V0KCksaSkpOwoJfQoKCXRlbXBsYXRlPGNsYXNzIFQ+ Cgl2b2lkIHNldF9pdGVtKGludCBpLGNvbnN0IFQmIHZhbCkKCXsKCQlzZXRfaXRlbShpLG1ha2Vf cmVmKHZhbCkpOwoJfQoKCXZvaWQgc2V0X2l0ZW0oaW50IGkscmVmIHJ2YWwpCgl7CgkJUHlTZXF1 ZW5jZV9TZXRJdGVtKGdldCgpLGkscnZhbC5nZXQoKSk7Cgl9CQoKCXZvaWQgcnNldF9pdGVtKGlu dCBpLHJlZiBydmFsKQoJewoJCVB5U2VxdWVuY2VfU2V0SXRlbShnZXQoKSxpLHJ2YWwuZ2V0KCkp OwoJfQkKCn07CgoKY2xhc3MgbWFwcGluZyA6IHB1YmxpYyB2aXJ0dWFsIG9iamVjdAp7CnB1Ymxp YzoKCWNsYXNzIHByb3h5OwoJCQpwdWJsaWM6CgoJc3RhdGljIGJvb2wgYWNjZXB0cyhyZWYgcCkK CXsKCQlyZXR1cm4gUHlNYXBwaW5nX0NoZWNrKHAuZ2V0KCkpOwoJfQoJCglleHBsaWNpdCBtYXBw aW5nKGNvbnN0IG9iamVjdCAmIG9iaik6IG9iamVjdChvYmopIHt9CgkKCWV4cGxpY2l0IG1hcHBp bmcoY29uc3QgcmVmJiByaHMpOiBvYmplY3QocmhzKSB7fQoKCXRlbXBsYXRlPGNsYXNzIFQ+Cglw cm94eSBvcGVyYXRvcltdKGNvbnN0IFQgJiBrZXkpOwoKCXRlbXBsYXRlPGNsYXNzIFQ+Cgljb25z dCBwcm94eSBvcGVyYXRvcltdKGNvbnN0IFQgJiBrZXkpIGNvbnN0OwoKCXRlbXBsYXRlPGNsYXNz IFQ+Cglib29sIGhhc19rZXkoY29uc3QgVCAmIGtleSkgY29uc3QKCXsKCQlyZXR1cm4gaGFzX2tl eShtYWtlX3JlZihrZXkpKTsKCX0KCglib29sIGhhc19rZXkoY29uc3QgcmVmICYga2V5KSBjb25z dAoJewoJCXJldHVybiBQeU1hcHBpbmdfSGFzS2V5KGdldCgpLGtleS5nZXQoKSk7Cgl9CgkKCXNl cXVlbmNlIGtleXMoKSBjb25zdAoJewoJCXJldHVybiBzZXF1ZW5jZShyZWYoUHlNYXBwaW5nX0tl eXMoZ2V0KCkpKSk7Cgl9CgoJc2VxdWVuY2UgdmFsdWVzKCkgY29uc3QKCXsKCQlyZXR1cm4gc2Vx dWVuY2UocmVmKFB5TWFwcGluZ19WYWx1ZXMoZ2V0KCkpKSk7Cgl9CgoJc2VxdWVuY2UgaXRlbXMo KSBjb25zdAoJewoJCXJldHVybiBzZXF1ZW5jZShyZWYoUHlNYXBwaW5nX0l0ZW1zKGdldCgpKSkp OwoJfQoKCXRlbXBsYXRlIDxjbGFzcyBLZXk+CglyZWYgZ2V0X2l0ZW0oY29uc3QgS2V5JiBrZXkp IGNvbnN0Cgl7IAoJCXJldHVybiB0aGlzLT5nZXRfaXRlbShtYWtlX3JlZihrZXkpKTsgCgl9CgoJ cmVmIGdldF9pdGVtKHJlZiBrZXkpIGNvbnN0Cgl7CgkJcmV0dXJuIHJlZihQeU9iamVjdF9HZXRJ dGVtKGdldCgpLGtleS5nZXQoKSkpOwoJfQoKCXJlZiByZ2V0X2l0ZW0ocmVmIGtleSkgY29uc3QK CXsKCQlyZXR1cm4gcmVmKFB5T2JqZWN0X0dldEl0ZW0oZ2V0KCksa2V5LmdldCgpKSk7Cgl9CgoK CXRlbXBsYXRlIDxjbGFzcyBLZXksIGNsYXNzIFZhbHVlPgoJdm9pZCBzZXRfaXRlbShjb25zdCBL ZXkmIGtleSwgY29uc3QgVmFsdWUmIHZhbHVlKQoJewoJCXRoaXMtPnNldF9pdGVtKG1ha2VfcmVm KGtleSksIG1ha2VfcmVmKHZhbHVlKSk7IAoJfQoKCXZvaWQgc2V0X2l0ZW0ocmVmIGtleSwgcmVm IHZhbHVlKQoJewoJCVB5T2JqZWN0X1NldEl0ZW0oZ2V0KCksa2V5LmdldCgpLHZhbHVlLmdldCgp KTsKCX0KCgl2b2lkIHJzZXRfaXRlbShyZWYga2V5LCByZWYgdmFsdWUpCgl7CgkJUHlPYmplY3Rf U2V0SXRlbShnZXQoKSxrZXkuZ2V0KCksdmFsdWUuZ2V0KCkpOwoJfQoKfTsKCgoKY2xhc3Mgc2Vx bWFwIDogcHVibGljIHNlcXVlbmNlICwgcHVibGljIG1hcHBpbmcKewpwdWJsaWM6CgoJc3RhdGlj IGJvb2wgYWNjZXB0cyhyZWYgcCkKCXsKCQlyZXR1cm4gc2VxdWVuY2U6OmFjY2VwdHMocCkgJiYg bWFwcGluZzo6YWNjZXB0cyhwKTsKCX0KCglleHBsaWNpdCBzZXFtYXAoY29uc3Qgb2JqZWN0ICYg b2JqKTogb2JqZWN0KG9iaikgLCBzZXF1ZW5jZShvYmplY3Q6OnJlZmVyZW5jZSgpKSAsIG1hcHBp bmcob2JqZWN0OjpyZWZlcmVuY2UoKSkge30KCQoJZXhwbGljaXQgc2VxbWFwKGNvbnN0IHJlZiYg cmhzKTogb2JqZWN0KHJocykgLCBzZXF1ZW5jZShvYmplY3Q6OnJlZmVyZW5jZSgpKSAsIG1hcHBp bmcob2JqZWN0OjpyZWZlcmVuY2UoKSkge30KCgljb25zdCBzZXF1ZW5jZTo6cHJveHkgb3BlcmF0 b3JbXShpbnQgaSkgY29uc3Q7CglzZXF1ZW5jZTo6cHJveHkgb3BlcmF0b3JbXShpbnQgaSk7CgoJ dGVtcGxhdGU8Y2xhc3MgVD4KCW1hcHBpbmc6OnByb3h5IG9wZXJhdG9yW10oY29uc3QgVCAmIGtl eSk7CgkKCXRlbXBsYXRlPGNsYXNzIFQ+Cgljb25zdCBtYXBwaW5nOjpwcm94eSBvcGVyYXRvcltd KGNvbnN0IFQgJiBrZXkpIGNvbnN0OwoJCgkvLyBEZWZpbmVkIGJlY2F1c2UgdGhlIGRlZmF1bHQg aW1wbGVtZW50YXRpb24gaXMgdW5zcGVjaWZpZWQgcmVnYXJkaW5nIGhvdyBvZnRlbiBhIHZpcnR1 YWwgYmFzZSBjbGFzcyBpcyBhc3NpZ25lZAoJc2VxbWFwJiBvcGVyYXRvcj0oY29uc3Qgc2VxbWFw JiByaHMpCgl7CgkJdGhpcy0+b2JqZWN0X2Jhc2U6Om9wZXJhdG9yPShyaHMpOwoJCXJldHVybiAq dGhpczsKCX0KCQp9OwoKCgpjbGFzcyBzZXF1ZW5jZTo6Y3Byb3h5IDogcHVibGljIHNlcW1hcCAv LyBOb3QgdXNlZCBub3cuIG9wZXJhdG9yW10oaW50KSBjb25zdCB3b3VsZCB1c2UgaXQuCnsJCQkJ CQkJCQkJCQkJLy8gTm93IGFuIGVtcHR5IGNhbGxiYWNrIGlzIHVzZWQgaW5zdGVhZCBpbiBhIGNv bnN0IHByb3h5CnB1YmxpYzoKCWNwcm94eShyZWYgaXRlbSkgOiBvYmplY3QoaXRlbSkgLCBzZXFt YXAob2JqZWN0OjpyZWZlcmVuY2UoKSkge30KCnByaXZhdGU6CgljcHJveHkmIG9wZXJhdG9yPShj b25zdCBjcHJveHkmKTsKfTsJCgoKCmNsYXNzIHNlcXVlbmNlOjpwcm94eSA6IHB1YmxpYyBzZXFt YXAKewpwdWJsaWM6CglleHBsaWNpdCBwcm94eShyZWYgaXRlbSkgOiBvYmplY3QoaXRlbSkgLCBz ZXFtYXAob2JqZWN0OjpyZWZlcmVuY2UoKSkge30KCWV4cGxpY2l0IHByb3h5KHJlZiBpdGVtLCBi b29zdDo6ZnVuY3Rpb248dm9pZCxyZWY+IHNfY2FsbGJhY2spIDogb2JqZWN0KGl0ZW0pICwgc2Vx bWFwKG9iamVjdDo6cmVmZXJlbmNlKCkpICwgYXNzaWduX2NhbGxiYWNrKHNfY2FsbGJhY2spIHt9 CgoJdGVtcGxhdGU8Y2xhc3MgVD4KCXByb3h5JiBvcGVyYXRvcj0oY29uc3QgVCYgcmhzKQoJewoJ CWNvdXQgPDwgInoiOwoJCXJlZiB2YWwobWFrZV9yZWYocmhzKSk7CgkJaWYgKGFzc2lnbl9jYWxs YmFjay5lbXB0eSgpKQoJCQl0aHJvdyBydW50aW1lX2Vycm9yKCJBc3NpZ25tZW50IG5vdCBwb3Nz aWJsZSEiKTsKCQlhc3NpZ25fY2FsbGJhY2sodmFsKTsKCQlyZXNldCh2YWwpOwoJCXJldHVybiAq dGhpczsKCX0KCglwcm94eSYgb3BlcmF0b3I9KGNvbnN0IHByb3h5JiByaHMpCgl7CgkJaWYgKHRo aXMgPT0gJnJocykgcmV0dXJuICp0aGlzOwoJCWNvdXQgPDwgIngiOwoJCWlmIChhc3NpZ25fY2Fs bGJhY2suZW1wdHkoKSkKCQkJdGhyb3cgcnVudGltZV9lcnJvcigiQXNzaWdubWVudCBub3QgcG9z c2libGUhIik7CgkJYXNzaWduX2NhbGxiYWNrKHJocy5yZWZlcmVuY2UoKSk7CgkJcmVzZXQocmhz LnJlZmVyZW5jZSgpKTsKCQlyZXR1cm4gKnRoaXM7Cgl9CgoKcHJpdmF0ZToKCWJvb3N0OjpmdW5j dGlvbjx2b2lkLHJlZj4gYXNzaWduX2NhbGxiYWNrOwp9OwoKCmlubGluZSBzZXF1ZW5jZTo6cHJv eHkgc2VxdWVuY2U6Om9wZXJhdG9yW10oaW50IGkpCnsKCXJldHVybiBwcm94eShnZXRfaXRlbShp KSwgYm9vc3Q6OmJpbmQoJnNlcXVlbmNlOjpyc2V0X2l0ZW0sdGhpcyxpLF8xKSk7Cn0KCmlubGlu ZSBjb25zdCBzZXF1ZW5jZTo6cHJveHkgc2VxdWVuY2U6Om9wZXJhdG9yW10oaW50IGkpIGNvbnN0 CnsKCXJldHVybiBwcm94eShnZXRfaXRlbShpKSk7CgkvL3JldHVybiBjcHJveHkoZ2V0X2l0ZW0o aSkpOwp9CgoKCgpjbGFzcyBtYXBwaW5nOjpwcm94eSA6IHB1YmxpYyBzZXF1ZW5jZTo6cHJveHkK ewpwdWJsaWM6CglleHBsaWNpdCBwcm94eShyZWYgaXRlbSk6ICBvYmplY3QoaXRlbSkgLCBzZXF1 ZW5jZTo6cHJveHkob2JqZWN0OjpyZWZlcmVuY2UoKSkgeyB9CglleHBsaWNpdCBwcm94eShyZWYg aXRlbSwgYm9vc3Q6OmZ1bmN0aW9uPHZvaWQscmVmPiBzX2NhbGxiYWNrLCBib29zdDo6ZnVuY3Rp b248cmVmPiBnZXRfY2FsbGJhY2spOiAgb2JqZWN0KGl0ZW0pICwgc2VxdWVuY2U6OnByb3h5KG9i amVjdDo6cmVmZXJlbmNlKCksc19jYWxsYmFjaykgCgl7IAoJCWNvdXQgPDwgJ2InOwoJCWlmICgh aXRlbS5nZXQoKSkKCQkJc2V0X2NhbGxiYWNrKGdldF9jYWxsYmFjayk7IAoJfQoKCgl0ZW1wbGF0 ZTxjbGFzcyBUPgoJcHJveHkmIG9wZXJhdG9yPShjb25zdCBUJiByaHMpCgl7CgkJdGhpcy0+c2Vx dWVuY2U6OnByb3h5OjpvcGVyYXRvcj0ocmhzKTsKCQlyZXR1cm4gKnRoaXM7Cgl9CgoJcHJveHkm IG9wZXJhdG9yPShjb25zdCBwcm94eSYgcmhzKQoJewoJCXRoaXMtPnNlcXVlbmNlOjpwcm94eTo6 b3BlcmF0b3I9KHJocyk7CgkJcmV0dXJuICp0aGlzOwoJCS8qaWYgKHRoaXMgPT0gJnJocykgcmV0 dXJuICp0aGlzOwoJCQoJCVB5T2JqZWN0X1NldEl0ZW0oX21hcC5nZXQoKSxfa2V5LmdldCgpLHJo cy5nZXQoKSk7CgkJcmVzZXQocmhzLnJlZmVyZW5jZSgpKTsKCQlyZXR1cm4gKnRoaXM7Ki8KCX0K Cn07CQoKdGVtcGxhdGU8Y2xhc3MgVD4KaW5saW5lIG1hcHBpbmc6OnByb3h5IG1hcHBpbmc6Om9w ZXJhdG9yW10oY29uc3QgVCAmIGtleSkKewoJcmVmIGtleXJlZih0b19weXRob24oa2V5KSk7Cgly ZWYgcml0ZW07CglpZiAoaGFzX2tleShrZXlyZWYpKQoJCXJpdGVtID0gcmVmKFB5T2JqZWN0X0dl dEl0ZW0oZ2V0KCksa2V5cmVmLmdldCgpKSk7CglyZXR1cm4gcHJveHkocml0ZW0sIGJvb3N0Ojpi aW5kKCZtYXBwaW5nOjpyc2V0X2l0ZW0sdGhpcyxrZXlyZWYsXzEpICwgYm9vc3Q6OmJpbmQoJm1h cHBpbmc6OnJnZXRfaXRlbSx0aGlzLGtleXJlZikpOwoJLy9yZXR1cm4gcHJveHkoKnRoaXMsa2V5 cmVmLHJpdGVtKTsgCn0KCgp0ZW1wbGF0ZTxjbGFzcyBUPgppbmxpbmUgY29uc3QgbWFwcGluZzo6 cHJveHkgbWFwcGluZzo6b3BlcmF0b3JbXShjb25zdCBUICYga2V5KSBjb25zdAp7CglyZWYga2V5 cmVmKHRvX3B5dGhvbihrZXkpKTsKCXJlZiByaXRlbShQeU9iamVjdF9HZXRJdGVtKGdldCgpLGtl eXJlZi5nZXQoKSkpOwoJcmV0dXJuIHByb3h5KHJpdGVtKTsvLywgYm9vc3Q6OmJpbmQoJm1hcHBp bmc6OnJzZXRfaXRlbSx0aGlzLGtleXJlZixfMSkgLCBib29zdDo6YmluZCgmbWFwcGluZzo6cmdl dF9pdGVtLHRoaXMsa2V5cmVmKSk7CgkvL3JldHVybiBwcm94eSgqdGhpcyxrZXlyZWYscml0ZW0p OyAKfQoKCmlubGluZSBzZXF1ZW5jZTo6cHJveHkgc2VxbWFwOjpvcGVyYXRvcltdKGludCBpKQp7 CglyZXR1cm4gc2VxdWVuY2U6Om9wZXJhdG9yW10oaSk7Cn0KCmlubGluZSBjb25zdCBzZXF1ZW5j ZTo6cHJveHkgc2VxbWFwOjpvcGVyYXRvcltdKGludCBpKSBjb25zdAp7CglyZXR1cm4gc2VxdWVu Y2U6Om9wZXJhdG9yW10oaSk7Cn0KCgp0ZW1wbGF0ZTxjbGFzcyBUPgppbmxpbmUgbWFwcGluZzo6 cHJveHkgc2VxbWFwOjpvcGVyYXRvcltdKGNvbnN0IFQgJiBrZXkpCnsKCXJldHVybiBtYXBwaW5n OjpvcGVyYXRvcltdKGtleSk7Cn0KCnRlbXBsYXRlPGNsYXNzIFQ+CmlubGluZSBjb25zdCBtYXBw aW5nOjpwcm94eSBzZXFtYXA6Om9wZXJhdG9yW10oY29uc3QgVCAmIGtleSkgY29uc3QKewoJcmV0 dXJuIG1hcHBpbmc6Om9wZXJhdG9yW10oa2V5KTsKfQoJCgkKCmNsYXNzIHR1cGxlIDogcHVibGlj IG9iamVjdF9iYXNlCnsKIHB1YmxpYzoKICAgIGV4cGxpY2l0IHR1cGxlKHN0ZDo6c2l6ZV90IG4g PSAwKTsKICAgIGV4cGxpY2l0IHR1cGxlKHJlZiBwKTsKCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgRmly c3QsIGNsYXNzIFNlY29uZD4KICAgIHR1cGxlKGNvbnN0IHN0ZDo6cGFpcjxGaXJzdCxTZWNvbmQ+ JiB4KQogICAgICAgIDogb2JqZWN0X2Jhc2UocmVmKFB5VHVwbGVfTmV3KDIpKSkKICAgIHsKICAg ICAgICBzZXRfaXRlbSgwLCB4LmZpcnN0KTsKICAgICAgICBzZXRfaXRlbSgxLCB4LnNlY29uZCk7 CiAgICB9CiAgICAKICAgIHRlbXBsYXRlIDxjbGFzcyBGaXJzdCwgY2xhc3MgU2Vjb25kPgogICAg dHVwbGUoY29uc3QgRmlyc3QmIGZpcnN0LCBjb25zdCBTZWNvbmQmIHNlY29uZCkKICAgICAgICA6 IG9iamVjdF9iYXNlKHJlZihQeVR1cGxlX05ldygyKSkpCiAgICB7CiAgICAgICAgc2V0X2l0ZW0o MCwgZmlyc3QpOwogICAgICAgIHNldF9pdGVtKDEsIHNlY29uZCk7CiAgICB9CiAgICAKICAgIHRl bXBsYXRlIDxjbGFzcyBGaXJzdCwgY2xhc3MgU2Vjb25kLCBjbGFzcyBUaGlyZD4KICAgIHR1cGxl KGNvbnN0IEZpcnN0JiBmaXJzdCwgY29uc3QgU2Vjb25kJiBzZWNvbmQsIGNvbnN0IFRoaXJkJiB0 aGlyZCkKICAgICAgICA6IG9iamVjdF9iYXNlKHJlZihQeVR1cGxlX05ldygzKSkpCiAgICB7CiAg ICAgICAgc2V0X2l0ZW0oMCwgZmlyc3QpOwogICAgICAgIHNldF9pdGVtKDEsIHNlY29uZCk7CiAg ICAgICAgc2V0X2l0ZW0oMiwgdGhpcmQpOwogICAgfQogICAgCiAgICB0ZW1wbGF0ZSA8Y2xhc3Mg Rmlyc3QsIGNsYXNzIFNlY29uZCwgY2xhc3MgVGhpcmQsIGNsYXNzIEZvdXJ0aD4KICAgIHR1cGxl KGNvbnN0IEZpcnN0JiBmaXJzdCwgY29uc3QgU2Vjb25kJiBzZWNvbmQsIGNvbnN0IFRoaXJkJiB0 aGlyZCwgY29uc3QgRm91cnRoJiBmb3VydGgpCiAgICAgICAgOiBvYmplY3RfYmFzZShyZWYoUHlU dXBsZV9OZXcoNCkpKQogICAgewogICAgICAgIHNldF9pdGVtKDAsIGZpcnN0KTsKICAgICAgICBz ZXRfaXRlbSgxLCBzZWNvbmQpOwogICAgICAgIHNldF9pdGVtKDIsIHRoaXJkKTsKICAgICAgICBz ZXRfaXRlbSgzLCBmb3VydGgpOwogICAgfQogICAgCiAgICBzdGF0aWMgUHlUeXBlT2JqZWN0KiB0 eXBlX29iaigpOwogICAgc3RhdGljIGJvb2wgYWNjZXB0cyhyZWYgcCk7CiAgICBzdGQ6OnNpemVf dCBzaXplKCkgY29uc3Q7CiAgICByZWYgb3BlcmF0b3JbXShzdGQ6OnNpemVfdCBwb3MpIGNvbnN0 OwoKICAgIHRlbXBsYXRlIDxjbGFzcyBUPgogICAgdm9pZCBzZXRfaXRlbShzdGQ6OnNpemVfdCBw b3MsIGNvbnN0IFQmIHJocykKICAgIHsKICAgICAgICB0aGlzLT5zZXRfaXRlbShwb3MsIG1ha2Vf cmVmKHJocykpOwogICAgfQogICAgCiAgICB2b2lkIHNldF9pdGVtKHN0ZDo6c2l6ZV90IHBvcywg Y29uc3QgcmVmJiByaHMpOwogICAgCiAgICB0dXBsZSBzbGljZShpbnQgbG93LCBpbnQgaGlnaCkg Y29uc3Q7CgogICAgZnJpZW5kIHR1cGxlIG9wZXJhdG9yKyhjb25zdCB0dXBsZSYsIGNvbnN0IHR1 cGxlJik7CiAgICB0dXBsZSYgb3BlcmF0b3IrPShjb25zdCB0dXBsZSYgcmhzKTsKfTsKCmNsYXNz IGxpc3QgOiBwdWJsaWMgb2JqZWN0X2Jhc2UKewogICAgc3RydWN0IHByb3h5OwogICAgc3RydWN0 IHNsaWNlX3Byb3h5OwogcHVibGljOgogICAgZXhwbGljaXQgbGlzdChjb25zdCBvYmplY3QgJiBv KTogb2JqZWN0X2Jhc2Uoby5yZWZlcmVuY2UoKSkge30KICAgIGV4cGxpY2l0IGxpc3QocmVmIHAp OwogICAgZXhwbGljaXQgbGlzdChzdGQ6OnNpemVfdCBzeiA9IDApOwogICAgc3RhdGljIFB5VHlw ZU9iamVjdCogdHlwZV9vYmooKTsKICAgIHN0YXRpYyBib29sIGFjY2VwdHMocmVmIHApOwogICAg c3RkOjpzaXplX3Qgc2l6ZSgpIGNvbnN0OwogICAgc2VxdWVuY2Ugb3BlcmF0b3JbXShzdGQ6OnNp emVfdCBwb3MpIGNvbnN0OwogICAgcHJveHkgb3BlcmF0b3JbXShzdGQ6OnNpemVfdCBwb3MpOwog ICAgcmVmIGdldF9pdGVtKHN0ZDo6c2l6ZV90IHBvcykgY29uc3Q7CgogICAgdGVtcGxhdGUgPGNs YXNzIFQ+CiAgICB2b2lkIHNldF9pdGVtKHN0ZDo6c2l6ZV90IHBvcywgY29uc3QgVCYgeCkKICAg ICAgICB7IHRoaXMtPnNldF9pdGVtKHBvcywgbWFrZV9yZWYoeCkpOyB9CiAgICB2b2lkIHNldF9p dGVtKHN0ZDo6c2l6ZV90IHBvcywgY29uc3QgcmVmJiApOwogICAgCgogICAgdGVtcGxhdGUgPGNs YXNzIFQ+CiAgICB2b2lkIGluc2VydChzdGQ6OnNpemVfdCBpbmRleCwgY29uc3QgVCYgeCkKICAg ICAgICB7IHRoaXMtPmluc2VydChpbmRleCwgbWFrZV9yZWYoeCkpOyB9CiAgICB2b2lkIGluc2Vy dChzdGQ6OnNpemVfdCBpbmRleCwgY29uc3QgcmVmJiBpdGVtKTsKCiAgICB0ZW1wbGF0ZSA8Y2xh c3MgVD4KICAgIHZvaWQgcHVzaF9iYWNrKGNvbnN0IFQmIGl0ZW0pCiAgICAgICAgeyB0aGlzLT5w dXNoX2JhY2sobWFrZV9yZWYoaXRlbSkpOyB9CiAgICB2b2lkIHB1c2hfYmFjayhjb25zdCByZWYm IGl0ZW0pOwogICAgCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgVD4KICAgIHZvaWQgYXBwZW5kKGNvbnN0 IFQmIGl0ZW0pCiAgICAgICAgeyB0aGlzLT5hcHBlbmQobWFrZV9yZWYoaXRlbSkpOyB9CiAgICB2 b2lkIGFwcGVuZChjb25zdCByZWYmIGl0ZW0pOwogICAgCiAgICBsaXN0IHNsaWNlKGludCBsb3cs IGludCBoaWdoKSBjb25zdDsKICAgIHNsaWNlX3Byb3h5IHNsaWNlKGludCBsb3csIGludCBoaWdo KTsKICAgIHZvaWQgc29ydCgpOwogICAgdm9pZCByZXZlcnNlKCk7CiAgICB0dXBsZSBhc190dXBs ZSgpIGNvbnN0Owp9OwoKY2xhc3Mgc3RyaW5nCiAgICA6IHB1YmxpYyBvYmplY3RfYmFzZSwgcHVi bGljIGJvb3N0OjptdWx0aXBsaWFibGUyPHN0cmluZywgdW5zaWduZWQgaW50Pgp7CiBwdWJsaWM6 CiAgICAvLyBDb25zdHJ1Y3QgZnJvbSBhbiBvd25lZCBQeU9iamVjdCouCiAgICAvLyBQcmVjb25k aXRpb246IHAgbXVzdCBwb2ludCB0byBhIHB5dGhvbiBzdHJpbmcuCiAgICBleHBsaWNpdCBzdHJp bmcocmVmIHApOwogICAgZXhwbGljaXQgc3RyaW5nKGNvbnN0IGNoYXIqIHMpOwogICAgc3RyaW5n KGNvbnN0IGNoYXIqIHMsIHN0ZDo6c2l6ZV90IGxlbmd0aCk7CiAgICBzdHJpbmcoY29uc3Qgc3Ry aW5nJiByaHMpOwoKICAgIGVudW0gaW50ZXJuZWRfdCB7IGludGVybmVkIH07CiAgICBzdHJpbmco Y29uc3QgY2hhciogcywgaW50ZXJuZWRfdCk7CiAgICAKICAgIC8vIEdldCB0aGUgdHlwZSBvYmpl Y3QgZm9yIFN0cmluZ3MKICAgIHN0YXRpYyBQeVR5cGVPYmplY3QqIHR5cGVfb2JqKCk7CgogICAg Ly8gUmV0dXJuIHRydWUgaWYgdGhlIGdpdmVuIG9iamVjdCBpcyBhIHB5dGhvbiBzdHJpbmcKICAg IHN0YXRpYyBib29sIGFjY2VwdHMocmVmIG8pOwoKICAgIC8vIFJldHVybiB0aGUgbGVuZ3RoIG9m IHRoZSBzdHJpbmcuCiAgICBzdGQ6OnNpemVfdCBzaXplKCkgY29uc3Q7CgogICAgLy8gUmV0dXJu cyBhIG51bGwtdGVybWluYXRlZCByZXByZXNlbnRhdGlvbiBvZiB0aGUgY29udGVudHMgb2Ygc3Ry aW5nLgogICAgLy8gVGhlIHBvaW50ZXIgcmVmZXJzIHRvIHRoZSBpbnRlcm5hbCBidWZmZXIgb2Yg c3RyaW5nLCBub3QgYSBjb3B5LgogICAgLy8gVGhlIGRhdGEgbXVzdCBub3QgYmUgbW9kaWZpZWQg aW4gYW55IHdheS4gSXQgbXVzdCBub3QgYmUgZGUtYWxsb2NhdGVkLiAKICAgIGNvbnN0IGNoYXIq IGNfc3RyKCkgY29uc3Q7CgogICAgc3RyaW5nJiBvcGVyYXRvcio9KHVuc2lnbmVkIGludCByZXBl YXRfY291bnQpOwogICAgc3RyaW5nJiBvcGVyYXRvcis9KGNvbnN0IHN0cmluZyYgcmhzKTsKICAg IGZyaWVuZCBzdHJpbmcgb3BlcmF0b3IrKHN0cmluZyB4LCBzdHJpbmcgeSk7CiAgICBzdHJpbmcm IG9wZXJhdG9yKz0oY29uc3QgY2hhciogcmhzKTsKICAgIGZyaWVuZCBzdHJpbmcgb3BlcmF0b3Ir KHN0cmluZyB4LCBjb25zdCBjaGFyKiB5KTsKICAgIGZyaWVuZCBzdHJpbmcgb3BlcmF0b3IrKGNv bnN0IGNoYXIqIHgsIHN0cmluZyB5KTsKCiAgICB2b2lkIGludGVybigpOwoKICAgIGZyaWVuZCBz dHJpbmcgb3BlcmF0b3IlKGNvbnN0IHN0cmluZyYgZm9ybWF0LCBjb25zdCB0dXBsZSYgYXJncyk7 Cn07CgpjbGFzcyBkaWN0aW9uYXJ5IDogcHVibGljIG9iamVjdF9iYXNlCnsKIHByaXZhdGU6CiAg ICBzdHJ1Y3QgcHJveHk7CiAgICAKIHB1YmxpYzoKICAgIGV4cGxpY2l0IGRpY3Rpb25hcnkoY29u c3Qgb2JqZWN0ICYgbyk6IG9iamVjdF9iYXNlKG8ucmVmZXJlbmNlKCkpIHt9CiAgICBleHBsaWNp dCBkaWN0aW9uYXJ5KHJlZiBwKTsKICAgIGRpY3Rpb25hcnkoKTsKICAgIHZvaWQgY2xlYXIoKTsK CiAgICBzdGF0aWMgUHlUeXBlT2JqZWN0KiB0eXBlX29iaigpOwogICAgc3RhdGljIGJvb2wgYWNj ZXB0cyhyZWYgcCk7CiAgICAKIHB1YmxpYzoKICAgIHRlbXBsYXRlIDxjbGFzcyBLZXk+CiAgICBw cm94eSBvcGVyYXRvcltdKGNvbnN0IEtleSYga2V5KQogICAgICAgIHsgcmV0dXJuIHRoaXMtPm9w ZXJhdG9yW10obWFrZV9yZWYoa2V5KSk7IH0KICAgIHByb3h5IG9wZXJhdG9yW10ocmVmIGtleSk7 CiAgICAKICAgIHRlbXBsYXRlIDxjbGFzcyBLZXk+CiAgICByZWYgb3BlcmF0b3JbXShjb25zdCBL ZXkmIGtleSkgY29uc3QKICAgICAgICB7IHJldHVybiB0aGlzLT5vcGVyYXRvcltdKG1ha2VfcmVm KGtleSkpOyB9CiAgICByZWYgb3BlcmF0b3JbXShyZWYga2V5KSBjb25zdDsKCiAgICB0ZW1wbGF0 ZSA8Y2xhc3MgS2V5PgogICAgcmVmIGdldF9pdGVtKGNvbnN0IEtleSYga2V5KSBjb25zdAogICAg ICAgIHsgcmV0dXJuIHRoaXMtPmdldF9pdGVtKG1ha2VfcmVmKGtleSkpOyB9CiAgICByZWYgZ2V0 X2l0ZW0oY29uc3QgcmVmJiBrZXkpIGNvbnN0OwogICAgCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgS2V5 LCBjbGFzcyBEZWZhdWx0PgogICAgcmVmIGdldF9pdGVtKGNvbnN0IEtleSYga2V5LCBjb25zdCBE ZWZhdWx0JiBkZWZhdWx0XykgY29uc3QKICAgICAgICB7IHJldHVybiB0aGlzLT5nZXRfaXRlbSht YWtlX3JlZihrZXkpLCBtYWtlX3JlZihkZWZhdWx0XykpOyB9CiAgICByZWYgZ2V0X2l0ZW0oY29u c3QgcmVmJiBrZXksIGNvbnN0IHJlZiYgZGVmYXVsdF8pIGNvbnN0OwogICAgCiAgICB0ZW1wbGF0 ZSA8Y2xhc3MgS2V5LCBjbGFzcyBWYWx1ZT4KICAgIHZvaWQgc2V0X2l0ZW0oY29uc3QgS2V5JiBr ZXksIGNvbnN0IFZhbHVlJiB2YWx1ZSkKICAgICAgICB7IHRoaXMtPnNldF9pdGVtKG1ha2VfcmVm KGtleSksIG1ha2VfcmVmKHZhbHVlKSk7IH0KICAgIHZvaWQgc2V0X2l0ZW0oY29uc3QgcmVmJiBr ZXksIGNvbnN0IHJlZiYgdmFsdWUpOwoKICAgIHRlbXBsYXRlIDxjbGFzcyBLZXk+CiAgICB2b2lk IGVyYXNlKGNvbnN0IEtleSYga2V5KQogICAgICAgIHsgdGhpcy0+ZXJhc2UobWFrZV9yZWYoa2V5 KSk7IH0KICAgIHZvaWQgZXJhc2UocmVmIGtleSk7CgovLyAgICBwcm94eSBvcGVyYXRvcltdKGNv bnN0IG9iamVjdCYga2V5KTsKLy8gICAgcmVmIG9wZXJhdG9yW10oY29uc3Qgb2JqZWN0JiBrZXkp IGNvbnN0OwoKLy8gICAgcmVmIGdldF9pdGVtKGNvbnN0IG9iamVjdCYga2V5LCByZWYgZGVmYXVs dF8gPSByZWYoKSkgY29uc3Q7Ci8vICAgIHZvaWQgc2V0X2l0ZW0oY29uc3Qgb2JqZWN0JiBrZXks IGNvbnN0IHJlZiYgdmFsdWUpOwogICAgICAgIAovLyAgICB2b2lkIGVyYXNlKGNvbnN0IG9iamVj dCYga2V5KTsKCiAgICBsaXN0IGl0ZW1zKCkgY29uc3Q7CiAgICBsaXN0IGtleXMoKSBjb25zdDsK ICAgIGxpc3QgdmFsdWVzKCkgY29uc3Q7CgogICAgc3RkOjpzaXplX3Qgc2l6ZSgpIGNvbnN0Owog ICAgLy8gVE9ETzogaXRlcmF0b3Igc3VwcG9ydAp9OwoKc3RydWN0IGRpY3Rpb25hcnk6OnByb3h5 CnsKICAgIHRlbXBsYXRlIDxjbGFzcyBUPgogICAgY29uc3QgcmVmJiBvcGVyYXRvcj0oY29uc3Qg VCYgcmhzKQogICAgICAgIHsgcmV0dXJuICgqdGhpcykgPSBtYWtlX3JlZihyaHMpOyB9CiAgICBj b25zdCByZWYmIG9wZXJhdG9yPShjb25zdCByZWYmIHJocyk7CgogICAgb3BlcmF0b3IgcmVmKCkg Y29uc3Q7CiBwcml2YXRlOgogICAgZnJpZW5kIGNsYXNzIGRpY3Rpb25hcnk7CiAgICBwcm94eShj b25zdCByZWYmIGRpY3QsIGNvbnN0IHJlZiYga2V5KTsKCiAgICAvLyBUaGlzIGlzIG5lZWRlZCB0 byB3b3JrIGFyb3VuZCB0aGUgdmVyeSBzdHJhbmdlIE1TVkMgZXJyb3IgcmVwb3J0IHRoYXQgdGhl CiAgICAvLyByZXR1cm4gdHlwZSBvZiB0aGUgYnVpbHQtaW4gb3BlcmF0b3I9IGRpZmZlcnMgZnJv bSB0aGF0IG9mIHRoZSBvbmVzCiAgICAvLyBkZWZpbmVkIGFib3ZlLiBDb3VsZG4ndCBodXJ0IHRv IG1ha2UgdGhlc2UgdW4tYXNzaWduYWJsZSBhbnl3YXksIHRob3VnaC4KICAgIGNvbnN0IHJlZiYg b3BlcmF0b3I9KGNvbnN0IHByb3h5Jik7IC8vIE5vdCBhY3R1YWxseSBpbXBsZW1lbnRlZAogcHJp dmF0ZToKICAgIHJlZiBtX2RpY3Q7CiAgICByZWYgbV9rZXk7Cn07CgpzdHJ1Y3QgbGlzdDo6cHJv eHkgOiBwdWJsaWMgc2VxbWFwCnsKICAgIHRlbXBsYXRlIDxjbGFzcyBUPgogICAgY29uc3QgcmVm JiBvcGVyYXRvcj0oY29uc3QgVCYgcmhzKQogICAgICAgIHsgcmV0dXJuICgqdGhpcykgPSBtYWtl X3JlZihyaHMpOyB9CiAgICBjb25zdCByZWYmIG9wZXJhdG9yPShjb25zdCByZWYmIHJocyk7CiAg ICAKICAgIC8vb3BlcmF0b3IgcmVmKCkgY29uc3Q7CiAgICAKIHByaXZhdGU6CgkgcHJveHkoY29u c3QgcHJveHkmIHJocykgOiBvYmplY3QocmhzKSwgc2VxbWFwKG9iamVjdDo6cmVmZXJlbmNlKCkp ICwgbV9saXN0KHJocy5tX2xpc3QpICwgbV9pbmRleChyaHMubV9pbmRleCkge30KICAgIGZyaWVu ZCBjbGFzcyBsaXN0OwogICAgcHJveHkoY29uc3QgcmVmJiBsaXN0LCBzdGQ6OnNpemVfdCBpbmRl eCk7CiAgICAKICAgIC8vIFRoaXMgaXMgbmVlZGVkIHRvIHdvcmsgYXJvdW5kIHRoZSB2ZXJ5IHN0 cmFuZ2UgTVNWQyBlcnJvciByZXBvcnQgdGhhdCB0aGUKICAgIC8vIHJldHVybiB0eXBlIG9mIHRo ZSBidWlsdC1pbiBvcGVyYXRvcj0gZGlmZmVycyBmcm9tIHRoYXQgb2YgdGhlIG9uZXMKICAgIC8v IGRlZmluZWQgYWJvdmUuIENvdWxkbid0IGh1cnQgdG8gbWFrZSB0aGVzZSB1bi1hc3NpZ25hYmxl IGFueXdheSwgdGhvdWdoLgogICAgY29uc3QgcmVmJiBvcGVyYXRvcj0oY29uc3QgcHJveHkmKTsg Ly8gTm90IGFjdHVhbGx5IGltcGxlbWVudGVkCiBwcml2YXRlOgogICAgbGlzdCBtX2xpc3Q7CiAg ICBzdGQ6OnNpemVfdCBtX2luZGV4Owp9OwoKc3RydWN0IGxpc3Q6OnNsaWNlX3Byb3h5CnsKICAg IGNvbnN0IGxpc3QmIG9wZXJhdG9yPShjb25zdCBsaXN0JiByaHMpOwogICAgb3BlcmF0b3IgcmVm KCkgY29uc3Q7CiAgICBvcGVyYXRvciBsaXN0KCkgY29uc3Q7CiAgICBzdGQ6OnNpemVfdCBzaXpl KCkgY29uc3Q7CiAgICByZWYgb3BlcmF0b3JbXShzdGQ6OnNpemVfdCBwb3MpIGNvbnN0OwogcHJp dmF0ZToKICAgIGZyaWVuZCBjbGFzcyBsaXN0OwogICAgc2xpY2VfcHJveHkoY29uc3QgcmVmJiBs aXN0LCBpbnQgbG93LCBpbnQgaGlnaCk7CiBwcml2YXRlOgogICAgcmVmIG1fbGlzdDsKICAgIGlu dCBtX2xvdywgbV9oaWdoOwp9OwoKfX0gLy8gbmFtZXNwYWNlIGJvb3N0OjpweXRob24KCkJPT1NU X1BZVEhPTl9CRUdJTl9DT05WRVJTSU9OX05BTUVTUEFDRQoKLy8gR2VuZXJpYyBvYmplY3RzCgpQ eU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246Om9iamVjdCYpOwpib29zdDo6 cHl0aG9uOjpvYmplY3QgZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5 cGU8Ym9vc3Q6OnB5dGhvbjo6b2JqZWN0Pik7CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6b2JqZWN0 IGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGNvbnN0IGJvb3N0 OjpweXRob246Om9iamVjdCY+KQp7CiAgICByZXR1cm4gZnJvbV9weXRob24ocCwgYm9vc3Q6OnB5 dGhvbjo6dHlwZTxib29zdDo6cHl0aG9uOjpvYmplY3Q+KCkpOwp9CgpQeU9iamVjdCogdG9fcHl0 aG9uKGNvbnN0IGJvb3N0OjpweXRob246OnNlcXVlbmNlJik7CmJvb3N0OjpweXRob246OnNlcXVl bmNlIGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0Ojpw eXRob246OnNlcXVlbmNlPik7CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6c2VxdWVuY2UgZnJvbV9w eXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Y29uc3QgYm9vc3Q6OnB5dGhv bjo6c2VxdWVuY2UmPikKewogICAgcmV0dXJuIGZyb21fcHl0aG9uKHAsIGJvb3N0OjpweXRob246 OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6c2VxdWVuY2U+KCkpOwp9CgpQeU9iamVjdCogdG9fcHl0aG9u KGNvbnN0IGJvb3N0OjpweXRob246Om1hcHBpbmcmKTsKYm9vc3Q6OnB5dGhvbjo6bWFwcGluZyBm cm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29zdDo6cHl0aG9u OjptYXBwaW5nPik7CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6bWFwcGluZyBmcm9tX3B5dGhvbihQ eU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxjb25zdCBib29zdDo6cHl0aG9uOjptYXBw aW5nJj4pCnsKICAgIHJldHVybiBmcm9tX3B5dGhvbihwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJv b3N0OjpweXRob246Om1hcHBpbmc+KCkpOwp9CgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJv b3N0OjpweXRob246OnNlcW1hcCYpOwpib29zdDo6cHl0aG9uOjpzZXFtYXAgZnJvbV9weXRob24o UHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6c2VxbWFwPik7 CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6c2VxbWFwIGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBi b29zdDo6cHl0aG9uOjp0eXBlPGNvbnN0IGJvb3N0OjpweXRob246OnNlcW1hcCY+KQp7CiAgICBy ZXR1cm4gZnJvbV9weXRob24ocCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29zdDo6cHl0aG9uOjpz ZXFtYXA+KCkpOwp9CgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246OnNl cXVlbmNlOjpwcm94eSYpOwoKClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhv bjo6bWFwcGluZzo6cHJveHkmKTsKCgoKLy8gQ29uY3JldGUgb2JqZWN0cwoKClB5T2JqZWN0KiB0 b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhvbjo6dHVwbGUmKTsKYm9vc3Q6OnB5dGhvbjo6dHVw bGUgZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5 dGhvbjo6dHVwbGU+KTsKCmlubGluZSBib29zdDo6cHl0aG9uOjp0dXBsZSBmcm9tX3B5dGhvbihQ eU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxjb25zdCBib29zdDo6cHl0aG9uOjp0dXBs ZSY+KQp7CiAgICByZXR1cm4gZnJvbV9weXRob24ocCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29z dDo6cHl0aG9uOjp0dXBsZT4oKSk7Cn0KClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6 OnB5dGhvbjo6bGlzdCYpOwpib29zdDo6cHl0aG9uOjpsaXN0IGZyb21fcHl0aG9uKFB5T2JqZWN0 KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0OjpweXRob246Omxpc3Q+KTsKCmlubGluZSBi b29zdDo6cHl0aG9uOjpsaXN0IGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9u Ojp0eXBlPGNvbnN0IGJvb3N0OjpweXRob246Omxpc3QmPikKewogICAgcmV0dXJuIGZyb21fcHl0 aG9uKHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6bGlzdD4oKSk7Cn0KClB5 T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhvbjo6c3RyaW5nJik7CmJvb3N0Ojpw eXRob246OnN0cmluZyBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlw ZTxib29zdDo6cHl0aG9uOjpzdHJpbmc+KTsKCmlubGluZSBib29zdDo6cHl0aG9uOjpzdHJpbmcg ZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Y29uc3QgYm9vc3Q6 OnB5dGhvbjo6c3RyaW5nJj4pCnsKICAgIHJldHVybiBmcm9tX3B5dGhvbihwLCBib29zdDo6cHl0 aG9uOjp0eXBlPGJvb3N0OjpweXRob246OnN0cmluZz4oKSk7Cn0KClB5T2JqZWN0KiB0b19weXRo b24oY29uc3QgYm9vc3Q6OnB5dGhvbjo6ZGljdGlvbmFyeSYpOwpib29zdDo6cHl0aG9uOjpkaWN0 aW9uYXJ5IGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0 OjpweXRob246OmRpY3Rpb25hcnk+KTsKCmlubGluZSBib29zdDo6cHl0aG9uOjpkaWN0aW9uYXJ5 IGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGNvbnN0IGJvb3N0 OjpweXRob246OmRpY3Rpb25hcnkmPikKewogICAgcmV0dXJuIGZyb21fcHl0aG9uKHAsIGJvb3N0 OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6ZGljdGlvbmFyeT4oKSk7Cn0KCkJPT1NUX1BZ VEhPTl9FTkRfQ09OVkVSU0lPTl9OQU1FU1BBQ0UKCiNlbmRpZiAvLyBPQkpFQ1RTX0RXQTA1MTEw MF9IXwo= --0__=00256B270048BEB98f9e8a93df938690918c00256B270048BEB9 Content-type: application/octet-stream; name="objects_b.hpp" Content-Disposition: attachment; filename="objects_b.hpp" Content-transfer-encoding: base64 Ly8gIChDKSBDb3B5cmlnaHQgRGF2aWQgQWJyYWhhbXMgMjAwMC4gUGVybWlzc2lvbiB0byBjb3B5 LCB1c2UsIG1vZGlmeSwgc2VsbCBhbmQKLy8gIGRpc3RyaWJ1dGUgdGhpcyBzb2Z0d2FyZSBpcyBn cmFudGVkIHByb3ZpZGVkIHRoaXMgY29weXJpZ2h0IG5vdGljZSBhcHBlYXJzCi8vICBpbiBhbGwg Y29waWVzLiBUaGlzIHNvZnR3YXJlIGlzIHByb3ZpZGVkICJhcyBpcyIgd2l0aG91dCBleHByZXNz IG9yIGltcGxpZWQKLy8gIHdhcnJhbnR5LCBhbmQgd2l0aCBubyBjbGFpbSBhcyB0byBpdHMgc3Vp dGFiaWxpdHkgZm9yIGFueSBwdXJwb3NlLgovLwovLyAgVGhlIGF1dGhvciBncmF0ZWZ1bGx5IGFj a25vd2xlZ2VzIHRoZSBzdXBwb3J0IG9mIERyYWdvbiBTeXN0ZW1zLCBJbmMuLCBpbgovLyAgcHJv ZHVjaW5nIHRoaXMgd29yay4KCiNpZm5kZWYgT0JKRUNUU19EV0EwNTExMDBfSF8KIyBkZWZpbmUg T0JKRUNUU19EV0EwNTExMDBfSF8KCiMgaW5jbHVkZSA8Ym9vc3QvcHl0aG9uL2RldGFpbC93cmFw X3B5dGhvbi5ocHA+CiMgaW5jbHVkZSA8Ym9vc3QvcHl0aG9uL2RldGFpbC9jb25maWcuaHBwPgoj IGluY2x1ZGUgPGJvb3N0L3B5dGhvbi9yZWZlcmVuY2UuaHBwPgojIGluY2x1ZGUgImJvb3N0L29w ZXJhdG9ycy5ocHAiCiMgaW5jbHVkZSAiYm9vc3QvZnVuY3Rpb24uaHBwIgojIGluY2x1ZGUgImJv b3N0L2JpbmQuaHBwIgojIGluY2x1ZGUgPHV0aWxpdHk+CiNpbmNsdWRlIDxpb3N0cmVhbT4KCm5h bWVzcGFjZSBib29zdCB7IG5hbWVzcGFjZSBweXRob24gewoKCnRlbXBsYXRlPGNsYXNzIFQ+ClQg aWRlbnRpdHkoVCB4KQp7CglyZXR1cm4geDsKfQoKCmNsYXNzIG9iamVjdF9iYXNlCnsKIHB1Ymxp YzoKICAgIGV4cGxpY2l0IG9iamVjdF9iYXNlKHJlZiBwKSA6IG1fcChwKSAsIHJlZl9jYWxsYmFj ayhib29zdDo6YmluZChpZGVudGl0eTxyZWY+LG1fcCkpIHsgfQogICAgCiAgICAvLyBJZiBtX3Au Z2V0KCkgaXMgMCwgYSBzZWdtZW50YXRpb24gZmF1bHQgb2NjdXJzIGlmIHRoZSBkZWZhdWx0IGNv cHkgY29uc3RydWN0b3IgaXMgdXNlZCAKICAgIC8vIChwZWN1bGlhciBzaW5jZSBQeV9YSU5DUkVG IGlzIHVzZWQgaW4gcmVmIGNvcHkgY29uc3RydWN0b3IpCiAgICAvLyBXZSBtdXN0IGNhbGwgcmhz LnJlZmVyZW5jZSgpIHRvIGNhbGwgdGhlIGNhbGxiYWNrIGZ1bmN0aW9uIGluIHRoYXQgY2FzZS4K ICAgIG9iamVjdF9iYXNlKGNvbnN0IG9iamVjdF9iYXNlJiByaHMpIDogbV9wKHJocy5yZWZlcmVu Y2UoKSkgLCByZWZfY2FsbGJhY2socmhzLnJlZl9jYWxsYmFjaykgeyB9CgkgCgkgLy8gU2ltaWxh ciB0byB0aGUgY29weSBjb25zdHJ1Y3RvcgoJIG9iamVjdF9iYXNlJiBvcGVyYXRvcj0oY29uc3Qg b2JqZWN0X2Jhc2UmIHJocykKCSB7CgkJIGlmICh0aGlzID09ICZyaHMpIHJldHVybiAqdGhpczsK CQkgbV9wID0gcmhzLnJlZmVyZW5jZSgpOwoJCSByZWZfY2FsbGJhY2sgPSByaHMucmVmX2NhbGxi YWNrOwoJCSByZXR1cm4gKnRoaXM7CgkgfQogICAgCgkgLy8gUmV0dXJuIGEgcmVmZXJlbmNlIHRv IHRoZSBoZWxkIG9iamVjdAoJIHJlZiBvYmplY3RfYmFzZTo6cmVmZXJlbmNlKCkgY29uc3QKCSB7 CgkJIGlmICghbV9wLmdldCgpKQoJCQkgbV9wID0gcmVmX2NhbGxiYWNrKCk7CgoJICAgIHJldHVy biBtX3A7CgkgfQoKCSAvLyBSZXR1cm4gYSByYXcgcG9pbnRlciB0byB0aGUgaGVsZCBvYmplY3QK CSBQeU9iamVjdCogb2JqZWN0X2Jhc2U6OmdldCgpIGNvbnN0CgkgewoJICAgIGlmICghbV9wLmdl dCgpKQoJICAgIAkgbV9wID0gcmVmX2NhbGxiYWNrKCk7CgkJICAgIC8vcmV0dXJuIHJlZl9jYWxs YmFjaygpLmdldCgpOyAvLyBDaGVjayEsIElmIG5vdCBlcnJvciA9PiByZWYgZGVzdHJveWVkIGFu ZCByZXR1cm5lZCBvYmplY3QgY291bGQgYmUgZGVzdHJveWVkIQoJICAgIHJldHVybiBtX3AuZ2V0 KCk7CgkgfQoJIAoJIHZvaWQgcmVzZXQocmVmIG5ld19yZWYpCgkgewoJCSBtX3AgPSBuZXdfcmVm OwoJIH0KIAogCSB2b2lkIHNldF9jYWxsYmFjayhjb25zdCBib29zdDo6ZnVuY3Rpb248cmVmPiAm IHJlZl9mdW5jKQogCSB7CgkJIHJlZl9jYWxsYmFjayA9IHJlZl9mdW5jOwoJIH0KCgkgb3BlcmF0 b3IgcmVmKCkgY29uc3QKCSB7CgkJIHJldHVybiByZWZlcmVuY2UoKTsgLy8gcmVmZXJlbmNlKCkg dXNlZCBpbnN0ZWFkIG9mIG1fcCBkaXJlY3RseSBiZWNhdXNlIG9mIGNhbGxiYWNrIGluIHJlZmVy ZW5jZSgpCgkgfQoJIAogcHJpdmF0ZToKICAgIG11dGFibGUgcmVmIG1fcDsKICAgIGJvb3N0Ojpm dW5jdGlvbjxyZWY+IHJlZl9jYWxsYmFjazsKfTsKCgoKCgpjbGFzcyBvYmplY3QgOiBwdWJsaWMg b2JqZWN0X2Jhc2UKewoJCQpwdWJsaWM6CglzdGF0aWMgYm9vbCBhY2NlcHRzKHJlZiBwKQoJewoJ CXJldHVybiBwLmdldCgpOwoJfQoJCglleHBsaWNpdCBvYmplY3QocmVmIHBvYmopOiBvYmplY3Rf YmFzZShwb2JqKSB7IH0KCgl0ZW1wbGF0ZTx0eXBlbmFtZSBUPgoJdm9pZCBzZXRhdHRyKGNoYXIq IGF0dHJfbmFtZSxUIHZhbCkKCXsKCQlQeU9iamVjdF9TZXRBdHRyU3RyaW5nKGdldCgpLGF0dHJf bmFtZSxtYWtlX3JlZih2YWwpLmdldCgpKTsKCX0KCgl0ZW1wbGF0ZTx0eXBlbmFtZSBUPgoJdm9p ZCBnZXRhdHRyKGNoYXIqIGF0dHJfbmFtZSxUICYgdmFsKSBjb25zdAoJewoJCXZhbCA9IGZyb21f cHl0aG9uKHJlZihQeU9iamVjdF9HZXRBdHRyU3RyaW5nKGdldCgpLGF0dHJfbmFtZSkpLmdldCgp LHB5dGhvbjo6dHlwZTxUPigpKTsKCX0KCglvYmplY3QgZ2V0YXR0cihjaGFyKiBhdHRyX25hbWUp IGNvbnN0Cgl7CgkJcmV0dXJuIG9iamVjdChyZWYoUHlPYmplY3RfR2V0QXR0clN0cmluZyhnZXQo KSxhdHRyX25hbWUpKSk7Cgl9CgkKCglib29sIGhhc2F0dHIoY2hhciogYXR0cl9uYW1lKSBjb25z dAoJewoJCXJldHVybiBQeU9iamVjdF9IYXNBdHRyU3RyaW5nKGdldCgpLGF0dHJfbmFtZSkgIT0g MDsKCX0KCQoJaW50IGxlbigpIGNvbnN0Cgl7CgkJcmV0dXJuIFB5T2JqZWN0X0xlbmd0aChnZXQo KSk7Cgl9CgkKCXN0ZDo6c3RyaW5nIHN0cigpIGNvbnN0Cgl7CgkJcmVmIHN0cihQeU9iamVjdF9T dHIoZ2V0KCkpKTsKCQlyZXR1cm4gZnJvbV9weXRob24oc3RyLmdldCgpLHB5dGhvbjo6dHlwZTxz dGQ6OnN0cmluZz4oKSk7Cgl9CgoJb2JqZWN0IG9wZXJhdG9yKCkoKQoJewoJCXJldHVybiBvYmpl Y3QocmVmKFB5T2JqZWN0X0NhbGxGdW5jdGlvbihnZXQoKSwiKCkiKSkpOwoJfQoKCW9iamVjdCBj YWxsX21ldGhvZChjaGFyKiBtZXRob2RfbmFtZSkKCXsKCQlyZXR1cm4gb2JqZWN0KHJlZihQeU9i amVjdF9DYWxsTWV0aG9kKGdldCgpLG1ldGhvZF9uYW1lLCIoKSIpKSk7Cgl9CgoJdGVtcGxhdGUg PGNsYXNzIEExPgoJb2JqZWN0IG9wZXJhdG9yKCkoY29uc3QgQTEmIGExKQoJewoJCXJldHVybiBv YmplY3QocmVmKFB5T2JqZWN0X0NhbGxGdW5jdGlvbihnZXQoKSwiKE8pIixtYWtlX3JlZihhMSku Z2V0KCkpKSk7Cgl9CgoJdGVtcGxhdGUgPGNsYXNzIEExPgoJb2JqZWN0IGNhbGxfbWV0aG9kKGNo YXIqIG1ldGhvZF9uYW1lLGNvbnN0IEExJiBhMSkKCXsKCQlyZXR1cm4gb2JqZWN0KHJlZihQeU9i amVjdF9DYWxsTWV0aG9kKGdldCgpLG1ldGhvZF9uYW1lLCIoTykiLG1ha2VfcmVmKGExKS5nZXQo KSkpKTsKCX0KCgl0ZW1wbGF0ZSA8Y2xhc3MgQTEsIGNsYXNzIEEyPgoJb2JqZWN0IG9wZXJhdG9y KCkoY29uc3QgQTEmIGExLCBjb25zdCBBMiYgYTIpCgl7CgkJcmV0dXJuIG9iamVjdChyZWYoUHlP YmplY3RfQ2FsbEZ1bmN0aW9uKGdldCgpLCIoT08pIixtYWtlX3JlZihhMSkuZ2V0KCksbWFrZV9y ZWYoYTIpLmdldCgpKSkpOwoJfQoKCXRlbXBsYXRlIDxjbGFzcyBBMSwgY2xhc3MgQTI+CglvYmpl Y3QgY2FsbF9tZXRob2QoY2hhciogbWV0aG9kX25hbWUsY29uc3QgQTEmIGExLCBjb25zdCBBMiYg YTIpCgl7CgkJcmV0dXJuIG9iamVjdChyZWYoUHlPYmplY3RfQ2FsbE1ldGhvZChnZXQoKSxtZXRo b2RfbmFtZSwiKE9PKSIsbWFrZV9yZWYoYTEpLmdldCgpLG1ha2VfcmVmKGEyKS5nZXQoKSkpKTsK CX0KCQoJdGVtcGxhdGU8Y2xhc3MgVD4KCW9wZXJhdG9yIFQoKSBjb25zdAoJewoJCXJldHVybiBm cm9tX3B5dGhvbihnZXQoKSx0eXBlPFQ+KCkpOwoJfQoJCn07CgoKY2xhc3Mgc2VxdWVuY2UgOiBw dWJsaWMgdmlydHVhbCBvYmplY3QKewpwdWJsaWM6CgljbGFzcyBwcm94eTsKCQpwdWJsaWM6Cglz dGF0aWMgYm9vbCBhY2NlcHRzKHJlZiBwKQoJewoJCXJldHVybiBQeVNlcXVlbmNlX0NoZWNrKHAu Z2V0KCkpOwoJfQoKCWV4cGxpY2l0IHNlcXVlbmNlKGNvbnN0IG9iamVjdCAmIG9iaik6IG9iamVj dChvYmopIHt9CgkKCWV4cGxpY2l0IHNlcXVlbmNlKGNvbnN0IHJlZiYgcmhzKTogb2JqZWN0KHJo cykge30KCQoJY29uc3QgcHJveHkgb3BlcmF0b3JbXShpbnQgaSkgY29uc3Q7CgoJcHJveHkgb3Bl cmF0b3JbXShpbnQgaSk7CgkKCXRlbXBsYXRlPGNsYXNzIFQ+Cgl2b2lkIGFwcGVuZChjb25zdCBU JiB2YWwpCgl7CgkJUHlMaXN0X0FwcGVuZChnZXQoKSxtYWtlX3JlZih2YWwpLmdldCgpKTsKCX0K CQoJaW50IHNpemUoKSBjb25zdAoJewoJCXJldHVybiBQeVNlcXVlbmNlX1NpemUoZ2V0KCkpOwoJ fQoJCglyZWYgZ2V0X2l0ZW0oaW50IGkpIGNvbnN0Cgl7CgkJcmV0dXJuIHJlZihQeVNlcXVlbmNl X0dldEl0ZW0oZ2V0KCksaSkpOwoJfQoKCXRlbXBsYXRlPGNsYXNzIFQ+Cgl2b2lkIHNldF9pdGVt KGludCBpLGNvbnN0IFQmIHZhbCkKCXsKCQlzZXRfaXRlbShpLG1ha2VfcmVmKHZhbCkpOwoJfQoK CXZvaWQgc2V0X2l0ZW0oaW50IGkscmVmIHJ2YWwpCgl7CgkJUHlTZXF1ZW5jZV9TZXRJdGVtKGdl dCgpLGkscnZhbC5nZXQoKSk7Cgl9CQoKCXZvaWQgcnNldF9pdGVtKGludCBpLHJlZiBydmFsKQoJ ewoJCVB5U2VxdWVuY2VfU2V0SXRlbShnZXQoKSxpLHJ2YWwuZ2V0KCkpOwoJfQkKCn07CgoKY2xh c3MgbWFwcGluZyA6IHB1YmxpYyB2aXJ0dWFsIG9iamVjdAp7CnB1YmxpYzoKCWNsYXNzIHByb3h5 OwoJCQpwdWJsaWM6CgoJc3RhdGljIGJvb2wgYWNjZXB0cyhyZWYgcCkKCXsKCQlyZXR1cm4gUHlN YXBwaW5nX0NoZWNrKHAuZ2V0KCkpOwoJfQoJCglleHBsaWNpdCBtYXBwaW5nKGNvbnN0IG9iamVj dCAmIG9iaik6IG9iamVjdChvYmopIHt9CgkKCWV4cGxpY2l0IG1hcHBpbmcoY29uc3QgcmVmJiBy aHMpOiBvYmplY3QocmhzKSB7fQoKCXRlbXBsYXRlPGNsYXNzIFQ+Cglwcm94eSBvcGVyYXRvcltd KGNvbnN0IFQgJiBrZXkpOwoKCXRlbXBsYXRlPGNsYXNzIFQ+Cgljb25zdCBwcm94eSBvcGVyYXRv cltdKGNvbnN0IFQgJiBrZXkpIGNvbnN0OwoKCXRlbXBsYXRlPGNsYXNzIFQ+Cglib29sIGhhc19r ZXkoY29uc3QgVCAmIGtleSkgY29uc3QKCXsKCQlyZXR1cm4gaGFzX2tleShtYWtlX3JlZihrZXkp KTsKCX0KCglib29sIGhhc19rZXkoY29uc3QgcmVmICYga2V5KSBjb25zdAoJewoJCXJldHVybiBQ eU1hcHBpbmdfSGFzS2V5KGdldCgpLGtleS5nZXQoKSk7Cgl9CgkKCXNlcXVlbmNlIGtleXMoKSBj b25zdAoJewoJCXJldHVybiBzZXF1ZW5jZShyZWYoUHlNYXBwaW5nX0tleXMoZ2V0KCkpKSk7Cgl9 CgoJc2VxdWVuY2UgdmFsdWVzKCkgY29uc3QKCXsKCQlyZXR1cm4gc2VxdWVuY2UocmVmKFB5TWFw cGluZ19WYWx1ZXMoZ2V0KCkpKSk7Cgl9CgoJc2VxdWVuY2UgaXRlbXMoKSBjb25zdAoJewoJCXJl dHVybiBzZXF1ZW5jZShyZWYoUHlNYXBwaW5nX0l0ZW1zKGdldCgpKSkpOwoJfQoKCXRlbXBsYXRl IDxjbGFzcyBLZXk+CglyZWYgZ2V0X2l0ZW0oY29uc3QgS2V5JiBrZXkpIGNvbnN0Cgl7IAoJCXJl dHVybiB0aGlzLT5nZXRfaXRlbShtYWtlX3JlZihrZXkpKTsgCgl9CgoJcmVmIGdldF9pdGVtKHJl ZiBrZXkpIGNvbnN0Cgl7CgkJcmV0dXJuIHJlZihQeU9iamVjdF9HZXRJdGVtKGdldCgpLGtleS5n ZXQoKSkpOwoJfQoKCXJlZiByZ2V0X2l0ZW0ocmVmIGtleSkgY29uc3QKCXsKCQlyZXR1cm4gcmVm KFB5T2JqZWN0X0dldEl0ZW0oZ2V0KCksa2V5LmdldCgpKSk7Cgl9CgoKCXRlbXBsYXRlIDxjbGFz cyBLZXksIGNsYXNzIFZhbHVlPgoJdm9pZCBzZXRfaXRlbShjb25zdCBLZXkmIGtleSwgY29uc3Qg VmFsdWUmIHZhbHVlKQoJewoJCXRoaXMtPnNldF9pdGVtKG1ha2VfcmVmKGtleSksIG1ha2VfcmVm KHZhbHVlKSk7IAoJfQoKCXZvaWQgc2V0X2l0ZW0ocmVmIGtleSwgcmVmIHZhbHVlKQoJewoJCVB5 T2JqZWN0X1NldEl0ZW0oZ2V0KCksa2V5LmdldCgpLHZhbHVlLmdldCgpKTsKCX0KCgl2b2lkIHJz ZXRfaXRlbShyZWYga2V5LCByZWYgdmFsdWUpCgl7CgkJUHlPYmplY3RfU2V0SXRlbShnZXQoKSxr ZXkuZ2V0KCksdmFsdWUuZ2V0KCkpOwoJfQoKfTsKCgoKY2xhc3Mgc2VxbWFwIDogcHVibGljIHNl cXVlbmNlICwgcHVibGljIG1hcHBpbmcKewpwdWJsaWM6CgoJc3RhdGljIGJvb2wgYWNjZXB0cyhy ZWYgcCkKCXsKCQlyZXR1cm4gc2VxdWVuY2U6OmFjY2VwdHMocCkgJiYgbWFwcGluZzo6YWNjZXB0 cyhwKTsKCX0KCglleHBsaWNpdCBzZXFtYXAoY29uc3Qgb2JqZWN0ICYgb2JqKTogb2JqZWN0KG9i aikgLCBzZXF1ZW5jZShvYmplY3Q6OnJlZmVyZW5jZSgpKSAsIG1hcHBpbmcob2JqZWN0OjpyZWZl cmVuY2UoKSkge30KCQoJZXhwbGljaXQgc2VxbWFwKGNvbnN0IHJlZiYgcmhzKTogb2JqZWN0KHJo cykgLCBzZXF1ZW5jZShvYmplY3Q6OnJlZmVyZW5jZSgpKSAsIG1hcHBpbmcob2JqZWN0OjpyZWZl cmVuY2UoKSkge30KCgljb25zdCBzZXF1ZW5jZTo6cHJveHkgb3BlcmF0b3JbXShpbnQgaSkgY29u c3Q7CglzZXF1ZW5jZTo6cHJveHkgb3BlcmF0b3JbXShpbnQgaSk7CgoJdGVtcGxhdGU8Y2xhc3Mg VD4KCW1hcHBpbmc6OnByb3h5IG9wZXJhdG9yW10oY29uc3QgVCAmIGtleSk7CgoJdGVtcGxhdGU8 Y2xhc3MgVD4KCWNvbnN0IG1hcHBpbmc6OnByb3h5IG9wZXJhdG9yW10oY29uc3QgVCAmIGtleSkg Y29uc3Q7CgkKCQoJLy8gRGVmaW5lZCBiZWNhdXNlIHRoZSBkZWZhdWx0IGltcGxlbWVudGF0aW9u IGlzIHVuc3BlY2lmaWVkIHJlZ2FyZGluZyBob3cgb2Z0ZW4gYSB2aXJ0dWFsIGJhc2UgY2xhc3Mg aXMgYXNzaWduZWQKCXNlcW1hcCYgb3BlcmF0b3I9KGNvbnN0IHNlcW1hcCYgcmhzKQoJewoJCXRo aXMtPm9iamVjdF9iYXNlOjpvcGVyYXRvcj0ocmhzKTsKCQlyZXR1cm4gKnRoaXM7Cgl9CgkKfTsK CmNsYXNzIHNlcXVlbmNlOjpwcm94eSA6IHB1YmxpYyBzZXFtYXAKewpwdWJsaWM6Cglwcm94eShj b25zdCBzZXF1ZW5jZSAmIHNlcSxpbnQgaSkgOiBvYmplY3QocmVmKFB5U2VxdWVuY2VfR2V0SXRl bShzZXEuZ2V0KCksaSkpKSAsIHNlcW1hcChvYmplY3Q6OnJlZmVyZW5jZSgpKSAsIF9zZXEoc2Vx KSAsIF9pKGkpIHt9CgoJdGVtcGxhdGU8Y2xhc3MgVD4KCXByb3h5JiBvcGVyYXRvcj0oY29uc3Qg VCYgcmhzKQoJewoJCXJlZiB2YWwobWFrZV9yZWYocmhzKSk7CgkJX3NlcS5zZXRfaXRlbShfaSx2 YWwpOyAgCgkJcmVzZXQodmFsKTsKCQlyZXR1cm4gKnRoaXM7Cgl9CgoJcHJveHkmIG9wZXJhdG9y PShjb25zdCBwcm94eSYgcmhzKQoJewoJCWlmICh0aGlzID09ICZyaHMpIHJldHVybiAqdGhpczsK CQlfc2VxLnNldF9pdGVtKF9pLHJocy5yZWZlcmVuY2UoKSk7CgkJcmVzZXQocmhzLnJlZmVyZW5j ZSgpKTsKCQlyZXR1cm4gKnRoaXM7Cgl9CgoKCnByaXZhdGU6CglzZXF1ZW5jZSBfc2VxOwoJaW50 IF9pOwp9OwoKCgoKaW5saW5lIHNlcXVlbmNlOjpwcm94eSBzZXF1ZW5jZTo6b3BlcmF0b3JbXShp bnQgaSkKewoJcmV0dXJuIHByb3h5KCp0aGlzLGkpOwp9CgppbmxpbmUgY29uc3Qgc2VxdWVuY2U6 OnByb3h5IHNlcXVlbmNlOjpvcGVyYXRvcltdKGludCBpKSBjb25zdAp7CglyZXR1cm4gcHJveHko KnRoaXMsaSk7IAp9CgoKY2xhc3MgbWFwcGluZzo6cHJveHkgOiBwdWJsaWMgc2VxbWFwCnsKcHVi bGljOgoJcHJveHkoY29uc3QgbWFwcGluZyAmIG9iaixyZWYga2V5LHJlZiBpdGVtKTogIG9iamVj dChpdGVtKSAsIHNlcW1hcChvYmplY3Q6OnJlZmVyZW5jZSgpKSAsIF9tYXAob2JqKSwgX2tleShr ZXkpIAoJeyAKCQlpZiAoIWl0ZW0uZ2V0KCkpCgkJCXNldF9jYWxsYmFjayggYm9vc3Q6OmJpbmQo Jm1hcHBpbmc6OnJnZXRfaXRlbSxfbWFwLF9rZXkpICk7Cgl9CgoJdGVtcGxhdGU8Y2xhc3MgVD4K CXByb3h5JiBvcGVyYXRvcj0oY29uc3QgVCYgcmhzKQoJewoJCXJlZiB2YWwobWFrZV9yZWYocmhz KSk7CgkJX21hcC5zZXRfaXRlbShfa2V5LHZhbCk7CgkJcmVzZXQodmFsKTsKCQlyZXR1cm4gKnRo aXM7Cgl9CgoJcHJveHkmIG9wZXJhdG9yPShjb25zdCBwcm94eSYgcmhzKQoJewoJCWlmICh0aGlz ID09ICZyaHMpIHJldHVybiAqdGhpczsKCQkKCQlfbWFwLnNldF9pdGVtKF9rZXkscmhzLnJlZmVy ZW5jZSgpKTsKCQlyZXNldChyaHMucmVmZXJlbmNlKCkpOwoJCXJldHVybiAqdGhpczsKCX0KCQpw cml2YXRlOgoJbWFwcGluZyBfbWFwOwoJcmVmIF9rZXk7Cn07CgoKCgp0ZW1wbGF0ZTxjbGFzcyBU PgppbmxpbmUgbWFwcGluZzo6cHJveHkgbWFwcGluZzo6b3BlcmF0b3JbXShjb25zdCBUICYga2V5 KQp7CglyZWYga2V5cmVmKHRvX3B5dGhvbihrZXkpKTsKCXJlZiByaXRlbTsKCWlmIChoYXNfa2V5 KGtleXJlZikpCgkJcml0ZW0gPSByZWYoUHlPYmplY3RfR2V0SXRlbShnZXQoKSxrZXlyZWYuZ2V0 KCkpKTsKCS8vcmV0dXJuIHByb3h5KHJpdGVtLCBib29zdDo6YmluZCgmbWFwcGluZzo6cnNldF9p dGVtLHRoaXMsa2V5cmVmLF8xKSAsIGJvb3N0OjpiaW5kKCZtYXBwaW5nOjpyZ2V0X2l0ZW0sdGhp cyxrZXlyZWYpKTsKCXJldHVybiBwcm94eSgqdGhpcyxrZXlyZWYscml0ZW0pOyAKfQoKCnRlbXBs YXRlPGNsYXNzIFQ+CmlubGluZSBjb25zdCBtYXBwaW5nOjpwcm94eSBtYXBwaW5nOjpvcGVyYXRv cltdKGNvbnN0IFQgJiBrZXkpIGNvbnN0CnsKCXJlZiBrZXlyZWYodG9fcHl0aG9uKGtleSkpOwoJ cmVmIHJpdGVtKFB5T2JqZWN0X0dldEl0ZW0oZ2V0KCksa2V5cmVmLmdldCgpKSk7CglyZXR1cm4g cHJveHkoKnRoaXMsa2V5cmVmLHJpdGVtKTsgCn0KCgppbmxpbmUgc2VxdWVuY2U6OnByb3h5IHNl cW1hcDo6b3BlcmF0b3JbXShpbnQgaSkKewoJcmV0dXJuIHNlcXVlbmNlOjpvcGVyYXRvcltdKGkp Owp9CgppbmxpbmUgY29uc3Qgc2VxdWVuY2U6OnByb3h5IHNlcW1hcDo6b3BlcmF0b3JbXShpbnQg aSkgY29uc3QKewoJcmV0dXJuIHNlcXVlbmNlOjpvcGVyYXRvcltdKGkpOwp9CgoKdGVtcGxhdGU8 Y2xhc3MgVD4KaW5saW5lIG1hcHBpbmc6OnByb3h5IHNlcW1hcDo6b3BlcmF0b3JbXShjb25zdCBU ICYga2V5KQp7CglyZXR1cm4gbWFwcGluZzo6b3BlcmF0b3JbXShrZXkpOwp9Cgp0ZW1wbGF0ZTxj bGFzcyBUPgppbmxpbmUgY29uc3QgbWFwcGluZzo6cHJveHkgc2VxbWFwOjpvcGVyYXRvcltdKGNv bnN0IFQgJiBrZXkpIGNvbnN0CnsKCXJldHVybiBtYXBwaW5nOjpvcGVyYXRvcltdKGtleSk7Cn0J CgkKCmNsYXNzIHR1cGxlIDogcHVibGljIG9iamVjdF9iYXNlCnsKIHB1YmxpYzoKICAgIGV4cGxp Y2l0IHR1cGxlKHN0ZDo6c2l6ZV90IG4gPSAwKTsKICAgIGV4cGxpY2l0IHR1cGxlKHJlZiBwKTsK CiAgICB0ZW1wbGF0ZSA8Y2xhc3MgRmlyc3QsIGNsYXNzIFNlY29uZD4KICAgIHR1cGxlKGNvbnN0 IHN0ZDo6cGFpcjxGaXJzdCxTZWNvbmQ+JiB4KQogICAgICAgIDogb2JqZWN0KHJlZihQeVR1cGxl X05ldygyKSkpCiAgICB7CiAgICAgICAgc2V0X2l0ZW0oMCwgeC5maXJzdCk7CiAgICAgICAgc2V0 X2l0ZW0oMSwgeC5zZWNvbmQpOwogICAgfQogICAgCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgRmlyc3Qs IGNsYXNzIFNlY29uZD4KICAgIHR1cGxlKGNvbnN0IEZpcnN0JiBmaXJzdCwgY29uc3QgU2Vjb25k JiBzZWNvbmQpCiAgICAgICAgOiBvYmplY3QocmVmKFB5VHVwbGVfTmV3KDIpKSkKICAgIHsKICAg ICAgICBzZXRfaXRlbSgwLCBmaXJzdCk7CiAgICAgICAgc2V0X2l0ZW0oMSwgc2Vjb25kKTsKICAg IH0KICAgIAogICAgdGVtcGxhdGUgPGNsYXNzIEZpcnN0LCBjbGFzcyBTZWNvbmQsIGNsYXNzIFRo aXJkPgogICAgdHVwbGUoY29uc3QgRmlyc3QmIGZpcnN0LCBjb25zdCBTZWNvbmQmIHNlY29uZCwg Y29uc3QgVGhpcmQmIHRoaXJkKQogICAgICAgIDogb2JqZWN0KHJlZihQeVR1cGxlX05ldygzKSkp CiAgICB7CiAgICAgICAgc2V0X2l0ZW0oMCwgZmlyc3QpOwogICAgICAgIHNldF9pdGVtKDEsIHNl Y29uZCk7CiAgICAgICAgc2V0X2l0ZW0oMiwgdGhpcmQpOwogICAgfQogICAgCiAgICB0ZW1wbGF0 ZSA8Y2xhc3MgRmlyc3QsIGNsYXNzIFNlY29uZCwgY2xhc3MgVGhpcmQsIGNsYXNzIEZvdXJ0aD4K ICAgIHR1cGxlKGNvbnN0IEZpcnN0JiBmaXJzdCwgY29uc3QgU2Vjb25kJiBzZWNvbmQsIGNvbnN0 IFRoaXJkJiB0aGlyZCwgY29uc3QgRm91cnRoJiBmb3VydGgpCiAgICAgICAgOiBvYmplY3QocmVm KFB5VHVwbGVfTmV3KDQpKSkKICAgIHsKICAgICAgICBzZXRfaXRlbSgwLCBmaXJzdCk7CiAgICAg ICAgc2V0X2l0ZW0oMSwgc2Vjb25kKTsKICAgICAgICBzZXRfaXRlbSgyLCB0aGlyZCk7CiAgICAg ICAgc2V0X2l0ZW0oMywgZm91cnRoKTsKICAgIH0KICAgIAogICAgc3RhdGljIFB5VHlwZU9iamVj dCogdHlwZV9vYmooKTsKICAgIHN0YXRpYyBib29sIGFjY2VwdHMocmVmIHApOwogICAgc3RkOjpz aXplX3Qgc2l6ZSgpIGNvbnN0OwogICAgcmVmIG9wZXJhdG9yW10oc3RkOjpzaXplX3QgcG9zKSBj b25zdDsKCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgVD4KICAgIHZvaWQgc2V0X2l0ZW0oc3RkOjpzaXpl X3QgcG9zLCBjb25zdCBUJiByaHMpCiAgICB7CiAgICAgICAgdGhpcy0+c2V0X2l0ZW0ocG9zLCBt YWtlX3JlZihyaHMpKTsKICAgIH0KICAgIAogICAgdm9pZCBzZXRfaXRlbShzdGQ6OnNpemVfdCBw b3MsIGNvbnN0IHJlZiYgcmhzKTsKICAgIAogICAgdHVwbGUgc2xpY2UoaW50IGxvdywgaW50IGhp Z2gpIGNvbnN0OwoKICAgIGZyaWVuZCB0dXBsZSBvcGVyYXRvcisoY29uc3QgdHVwbGUmLCBjb25z dCB0dXBsZSYpOwogICAgdHVwbGUmIG9wZXJhdG9yKz0oY29uc3QgdHVwbGUmIHJocyk7Cn07Cgpj bGFzcyBsaXN0IDogcHVibGljIG9iamVjdF9iYXNlCnsKICAgIHN0cnVjdCBwcm94eTsKICAgIHN0 cnVjdCBzbGljZV9wcm94eTsKIHB1YmxpYzoKICAgIGV4cGxpY2l0IGxpc3QoY29uc3Qgb2JqZWN0 ICYgbyk6IG9iamVjdF9iYXNlKG8ucmVmZXJlbmNlKCkpIHt9CiAgICBleHBsaWNpdCBsaXN0KHJl ZiBwKTsKICAgIGV4cGxpY2l0IGxpc3Qoc3RkOjpzaXplX3Qgc3ogPSAwKTsKICAgIHN0YXRpYyBQ eVR5cGVPYmplY3QqIHR5cGVfb2JqKCk7CiAgICBzdGF0aWMgYm9vbCBhY2NlcHRzKHJlZiBwKTsK ICAgIHN0ZDo6c2l6ZV90IHNpemUoKSBjb25zdDsKICAgIHNlcXVlbmNlIG9wZXJhdG9yW10oc3Rk OjpzaXplX3QgcG9zKSBjb25zdDsKICAgIHByb3h5IG9wZXJhdG9yW10oc3RkOjpzaXplX3QgcG9z KTsKICAgIHJlZiBnZXRfaXRlbShzdGQ6OnNpemVfdCBwb3MpIGNvbnN0OwoKICAgIHRlbXBsYXRl IDxjbGFzcyBUPgogICAgdm9pZCBzZXRfaXRlbShzdGQ6OnNpemVfdCBwb3MsIGNvbnN0IFQmIHgp CiAgICAgICAgeyB0aGlzLT5zZXRfaXRlbShwb3MsIG1ha2VfcmVmKHgpKTsgfQogICAgdm9pZCBz ZXRfaXRlbShzdGQ6OnNpemVfdCBwb3MsIGNvbnN0IHJlZiYgKTsKICAgIAoKICAgIHRlbXBsYXRl IDxjbGFzcyBUPgogICAgdm9pZCBpbnNlcnQoc3RkOjpzaXplX3QgaW5kZXgsIGNvbnN0IFQmIHgp CiAgICAgICAgeyB0aGlzLT5pbnNlcnQoaW5kZXgsIG1ha2VfcmVmKHgpKTsgfQogICAgdm9pZCBp bnNlcnQoc3RkOjpzaXplX3QgaW5kZXgsIGNvbnN0IHJlZiYgaXRlbSk7CgogICAgdGVtcGxhdGUg PGNsYXNzIFQ+CiAgICB2b2lkIHB1c2hfYmFjayhjb25zdCBUJiBpdGVtKQogICAgICAgIHsgdGhp cy0+cHVzaF9iYWNrKG1ha2VfcmVmKGl0ZW0pKTsgfQogICAgdm9pZCBwdXNoX2JhY2soY29uc3Qg cmVmJiBpdGVtKTsKICAgIAogICAgdGVtcGxhdGUgPGNsYXNzIFQ+CiAgICB2b2lkIGFwcGVuZChj b25zdCBUJiBpdGVtKQogICAgICAgIHsgdGhpcy0+YXBwZW5kKG1ha2VfcmVmKGl0ZW0pKTsgfQog ICAgdm9pZCBhcHBlbmQoY29uc3QgcmVmJiBpdGVtKTsKICAgIAogICAgbGlzdCBzbGljZShpbnQg bG93LCBpbnQgaGlnaCkgY29uc3Q7CiAgICBzbGljZV9wcm94eSBzbGljZShpbnQgbG93LCBpbnQg aGlnaCk7CiAgICB2b2lkIHNvcnQoKTsKICAgIHZvaWQgcmV2ZXJzZSgpOwogICAgdHVwbGUgYXNf dHVwbGUoKSBjb25zdDsKfTsKCmNsYXNzIHN0cmluZwogICAgOiBwdWJsaWMgb2JqZWN0X2Jhc2Us IHB1YmxpYyBib29zdDo6bXVsdGlwbGlhYmxlMjxzdHJpbmcsIHVuc2lnbmVkIGludD4KewogcHVi bGljOgogICAgLy8gQ29uc3RydWN0IGZyb20gYW4gb3duZWQgUHlPYmplY3QqLgogICAgLy8gUHJl Y29uZGl0aW9uOiBwIG11c3QgcG9pbnQgdG8gYSBweXRob24gc3RyaW5nLgogICAgZXhwbGljaXQg c3RyaW5nKHJlZiBwKTsKICAgIGV4cGxpY2l0IHN0cmluZyhjb25zdCBjaGFyKiBzKTsKICAgIHN0 cmluZyhjb25zdCBjaGFyKiBzLCBzdGQ6OnNpemVfdCBsZW5ndGgpOwogICAgc3RyaW5nKGNvbnN0 IHN0cmluZyYgcmhzKTsKCiAgICBlbnVtIGludGVybmVkX3QgeyBpbnRlcm5lZCB9OwogICAgc3Ry aW5nKGNvbnN0IGNoYXIqIHMsIGludGVybmVkX3QpOwogICAgCiAgICAvLyBHZXQgdGhlIHR5cGUg b2JqZWN0IGZvciBTdHJpbmdzCiAgICBzdGF0aWMgUHlUeXBlT2JqZWN0KiB0eXBlX29iaigpOwoK ICAgIC8vIFJldHVybiB0cnVlIGlmIHRoZSBnaXZlbiBvYmplY3QgaXMgYSBweXRob24gc3RyaW5n CiAgICBzdGF0aWMgYm9vbCBhY2NlcHRzKHJlZiBvKTsKCiAgICAvLyBSZXR1cm4gdGhlIGxlbmd0 aCBvZiB0aGUgc3RyaW5nLgogICAgc3RkOjpzaXplX3Qgc2l6ZSgpIGNvbnN0OwoKICAgIC8vIFJl dHVybnMgYSBudWxsLXRlcm1pbmF0ZWQgcmVwcmVzZW50YXRpb24gb2YgdGhlIGNvbnRlbnRzIG9m IHN0cmluZy4KICAgIC8vIFRoZSBwb2ludGVyIHJlZmVycyB0byB0aGUgaW50ZXJuYWwgYnVmZmVy IG9mIHN0cmluZywgbm90IGEgY29weS4KICAgIC8vIFRoZSBkYXRhIG11c3Qgbm90IGJlIG1vZGlm aWVkIGluIGFueSB3YXkuIEl0IG11c3Qgbm90IGJlIGRlLWFsbG9jYXRlZC4gCiAgICBjb25zdCBj aGFyKiBjX3N0cigpIGNvbnN0OwoKICAgIHN0cmluZyYgb3BlcmF0b3IqPSh1bnNpZ25lZCBpbnQg cmVwZWF0X2NvdW50KTsKICAgIHN0cmluZyYgb3BlcmF0b3IrPShjb25zdCBzdHJpbmcmIHJocyk7 CiAgICBmcmllbmQgc3RyaW5nIG9wZXJhdG9yKyhzdHJpbmcgeCwgc3RyaW5nIHkpOwogICAgc3Ry aW5nJiBvcGVyYXRvcis9KGNvbnN0IGNoYXIqIHJocyk7CiAgICBmcmllbmQgc3RyaW5nIG9wZXJh dG9yKyhzdHJpbmcgeCwgY29uc3QgY2hhciogeSk7CiAgICBmcmllbmQgc3RyaW5nIG9wZXJhdG9y Kyhjb25zdCBjaGFyKiB4LCBzdHJpbmcgeSk7CgogICAgdm9pZCBpbnRlcm4oKTsKCiAgICBmcmll bmQgc3RyaW5nIG9wZXJhdG9yJShjb25zdCBzdHJpbmcmIGZvcm1hdCwgY29uc3QgdHVwbGUmIGFy Z3MpOwp9OwoKY2xhc3MgZGljdGlvbmFyeSA6IHB1YmxpYyBvYmplY3RfYmFzZQp7CiBwcml2YXRl OgogICAgc3RydWN0IHByb3h5OwogICAgCiBwdWJsaWM6CiAgICBleHBsaWNpdCBkaWN0aW9uYXJ5 KGNvbnN0IG9iamVjdCAmIG8pOiBvYmplY3RfYmFzZShvLnJlZmVyZW5jZSgpKSB7fQogICAgZXhw bGljaXQgZGljdGlvbmFyeShyZWYgcCk7CiAgICBkaWN0aW9uYXJ5KCk7CiAgICB2b2lkIGNsZWFy KCk7CgogICAgc3RhdGljIFB5VHlwZU9iamVjdCogdHlwZV9vYmooKTsKICAgIHN0YXRpYyBib29s IGFjY2VwdHMocmVmIHApOwogICAgCiBwdWJsaWM6CiAgICB0ZW1wbGF0ZSA8Y2xhc3MgS2V5Pgog ICAgcHJveHkgb3BlcmF0b3JbXShjb25zdCBLZXkmIGtleSkKICAgICAgICB7IHJldHVybiB0aGlz LT5vcGVyYXRvcltdKG1ha2VfcmVmKGtleSkpOyB9CiAgICBwcm94eSBvcGVyYXRvcltdKHJlZiBr ZXkpOwogICAgCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgS2V5PgogICAgcmVmIG9wZXJhdG9yW10oY29u c3QgS2V5JiBrZXkpIGNvbnN0CiAgICAgICAgeyByZXR1cm4gdGhpcy0+b3BlcmF0b3JbXShtYWtl X3JlZihrZXkpKTsgfQogICAgcmVmIG9wZXJhdG9yW10ocmVmIGtleSkgY29uc3Q7CgogICAgdGVt cGxhdGUgPGNsYXNzIEtleT4KICAgIHJlZiBnZXRfaXRlbShjb25zdCBLZXkmIGtleSkgY29uc3QK ICAgICAgICB7IHJldHVybiB0aGlzLT5nZXRfaXRlbShtYWtlX3JlZihrZXkpKTsgfQogICAgcmVm IGdldF9pdGVtKGNvbnN0IHJlZiYga2V5KSBjb25zdDsKICAgIAogICAgdGVtcGxhdGUgPGNsYXNz IEtleSwgY2xhc3MgRGVmYXVsdD4KICAgIHJlZiBnZXRfaXRlbShjb25zdCBLZXkmIGtleSwgY29u c3QgRGVmYXVsdCYgZGVmYXVsdF8pIGNvbnN0CiAgICAgICAgeyByZXR1cm4gdGhpcy0+Z2V0X2l0 ZW0obWFrZV9yZWYoa2V5KSwgbWFrZV9yZWYoZGVmYXVsdF8pKTsgfQogICAgcmVmIGdldF9pdGVt KGNvbnN0IHJlZiYga2V5LCBjb25zdCByZWYmIGRlZmF1bHRfKSBjb25zdDsKICAgIAogICAgdGVt cGxhdGUgPGNsYXNzIEtleSwgY2xhc3MgVmFsdWU+CiAgICB2b2lkIHNldF9pdGVtKGNvbnN0IEtl eSYga2V5LCBjb25zdCBWYWx1ZSYgdmFsdWUpCiAgICAgICAgeyB0aGlzLT5zZXRfaXRlbShtYWtl X3JlZihrZXkpLCBtYWtlX3JlZih2YWx1ZSkpOyB9CiAgICB2b2lkIHNldF9pdGVtKGNvbnN0IHJl ZiYga2V5LCBjb25zdCByZWYmIHZhbHVlKTsKCiAgICB0ZW1wbGF0ZSA8Y2xhc3MgS2V5PgogICAg dm9pZCBlcmFzZShjb25zdCBLZXkmIGtleSkKICAgICAgICB7IHRoaXMtPmVyYXNlKG1ha2VfcmVm KGtleSkpOyB9CiAgICB2b2lkIGVyYXNlKHJlZiBrZXkpOwoKLy8gICAgcHJveHkgb3BlcmF0b3Jb XShjb25zdCBvYmplY3QmIGtleSk7Ci8vICAgIHJlZiBvcGVyYXRvcltdKGNvbnN0IG9iamVjdCYg a2V5KSBjb25zdDsKCi8vICAgIHJlZiBnZXRfaXRlbShjb25zdCBvYmplY3QmIGtleSwgcmVmIGRl ZmF1bHRfID0gcmVmKCkpIGNvbnN0OwovLyAgICB2b2lkIHNldF9pdGVtKGNvbnN0IG9iamVjdCYg a2V5LCBjb25zdCByZWYmIHZhbHVlKTsKICAgICAgICAKLy8gICAgdm9pZCBlcmFzZShjb25zdCBv YmplY3QmIGtleSk7CgogICAgbGlzdCBpdGVtcygpIGNvbnN0OwogICAgbGlzdCBrZXlzKCkgY29u c3Q7CiAgICBsaXN0IHZhbHVlcygpIGNvbnN0OwoKICAgIHN0ZDo6c2l6ZV90IHNpemUoKSBjb25z dDsKICAgIC8vIFRPRE86IGl0ZXJhdG9yIHN1cHBvcnQKfTsKCnN0cnVjdCBkaWN0aW9uYXJ5Ojpw cm94eQp7CiAgICB0ZW1wbGF0ZSA8Y2xhc3MgVD4KICAgIGNvbnN0IHJlZiYgb3BlcmF0b3I9KGNv bnN0IFQmIHJocykKICAgICAgICB7IHJldHVybiAoKnRoaXMpID0gbWFrZV9yZWYocmhzKTsgfQog ICAgY29uc3QgcmVmJiBvcGVyYXRvcj0oY29uc3QgcmVmJiByaHMpOwoKICAgIG9wZXJhdG9yIHJl ZigpIGNvbnN0OwogcHJpdmF0ZToKICAgIGZyaWVuZCBjbGFzcyBkaWN0aW9uYXJ5OwogICAgcHJv eHkoY29uc3QgcmVmJiBkaWN0LCBjb25zdCByZWYmIGtleSk7CgogICAgLy8gVGhpcyBpcyBuZWVk ZWQgdG8gd29yayBhcm91bmQgdGhlIHZlcnkgc3RyYW5nZSBNU1ZDIGVycm9yIHJlcG9ydCB0aGF0 IHRoZQogICAgLy8gcmV0dXJuIHR5cGUgb2YgdGhlIGJ1aWx0LWluIG9wZXJhdG9yPSBkaWZmZXJz IGZyb20gdGhhdCBvZiB0aGUgb25lcwogICAgLy8gZGVmaW5lZCBhYm92ZS4gQ291bGRuJ3QgaHVy dCB0byBtYWtlIHRoZXNlIHVuLWFzc2lnbmFibGUgYW55d2F5LCB0aG91Z2guCiAgICBjb25zdCBy ZWYmIG9wZXJhdG9yPShjb25zdCBwcm94eSYpOyAvLyBOb3QgYWN0dWFsbHkgaW1wbGVtZW50ZWQK IHByaXZhdGU6CiAgICByZWYgbV9kaWN0OwogICAgcmVmIG1fa2V5Owp9OwoKc3RydWN0IGxpc3Q6 OnByb3h5IDogcHVibGljIHNlcW1hcAp7CiAgICB0ZW1wbGF0ZSA8Y2xhc3MgVD4KICAgIGNvbnN0 IHJlZiYgb3BlcmF0b3I9KGNvbnN0IFQmIHJocykKICAgICAgICB7IHJldHVybiAoKnRoaXMpID0g bWFrZV9yZWYocmhzKTsgfQogICAgY29uc3QgcmVmJiBvcGVyYXRvcj0oY29uc3QgcmVmJiByaHMp OwogICAgCiAgICAvL29wZXJhdG9yIHJlZigpIGNvbnN0OwogICAgCiBwcml2YXRlOgoJIHByb3h5 KGNvbnN0IHByb3h5JiByaHMpIDogb2JqZWN0KHJocyksIHNlcW1hcChvYmplY3Q6OnJlZmVyZW5j ZSgpKSAsIG1fbGlzdChyaHMubV9saXN0KSAsIG1faW5kZXgocmhzLm1faW5kZXgpIHt9CiAgICBm cmllbmQgY2xhc3MgbGlzdDsKICAgIHByb3h5KGNvbnN0IHJlZiYgbGlzdCwgc3RkOjpzaXplX3Qg aW5kZXgpOwogICAgCiAgICAvLyBUaGlzIGlzIG5lZWRlZCB0byB3b3JrIGFyb3VuZCB0aGUgdmVy eSBzdHJhbmdlIE1TVkMgZXJyb3IgcmVwb3J0IHRoYXQgdGhlCiAgICAvLyByZXR1cm4gdHlwZSBv ZiB0aGUgYnVpbHQtaW4gb3BlcmF0b3I9IGRpZmZlcnMgZnJvbSB0aGF0IG9mIHRoZSBvbmVzCiAg ICAvLyBkZWZpbmVkIGFib3ZlLiBDb3VsZG4ndCBodXJ0IHRvIG1ha2UgdGhlc2UgdW4tYXNzaWdu YWJsZSBhbnl3YXksIHRob3VnaC4KICAgIGNvbnN0IHJlZiYgb3BlcmF0b3I9KGNvbnN0IHByb3h5 Jik7IC8vIE5vdCBhY3R1YWxseSBpbXBsZW1lbnRlZAogcHJpdmF0ZToKICAgIGxpc3QgbV9saXN0 OwogICAgc3RkOjpzaXplX3QgbV9pbmRleDsKfTsKCnN0cnVjdCBsaXN0OjpzbGljZV9wcm94eQp7 CiAgICBjb25zdCBsaXN0JiBvcGVyYXRvcj0oY29uc3QgbGlzdCYgcmhzKTsKICAgIG9wZXJhdG9y IHJlZigpIGNvbnN0OwogICAgb3BlcmF0b3IgbGlzdCgpIGNvbnN0OwogICAgc3RkOjpzaXplX3Qg c2l6ZSgpIGNvbnN0OwogICAgcmVmIG9wZXJhdG9yW10oc3RkOjpzaXplX3QgcG9zKSBjb25zdDsK IHByaXZhdGU6CiAgICBmcmllbmQgY2xhc3MgbGlzdDsKICAgIHNsaWNlX3Byb3h5KGNvbnN0IHJl ZiYgbGlzdCwgaW50IGxvdywgaW50IGhpZ2gpOwogcHJpdmF0ZToKICAgIHJlZiBtX2xpc3Q7CiAg ICBpbnQgbV9sb3csIG1faGlnaDsKfTsKCn19IC8vIG5hbWVzcGFjZSBib29zdDo6cHl0aG9uCgpC T09TVF9QWVRIT05fQkVHSU5fQ09OVkVSU0lPTl9OQU1FU1BBQ0UKCi8vIEdlbmVyaWMgb2JqZWN0 cwoKUHlPYmplY3QqIHRvX3B5dGhvbihjb25zdCBib29zdDo6cHl0aG9uOjpvYmplY3QmKTsKYm9v c3Q6OnB5dGhvbjo6b2JqZWN0IGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9u Ojp0eXBlPGJvb3N0OjpweXRob246Om9iamVjdD4pOwoKaW5saW5lIGJvb3N0OjpweXRob246Om9i amVjdCBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxjb25zdCBi b29zdDo6cHl0aG9uOjpvYmplY3QmPikKewogICAgcmV0dXJuIGZyb21fcHl0aG9uKHAsIGJvb3N0 OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6b2JqZWN0PigpKTsKfQoKUHlPYmplY3QqIHRv X3B5dGhvbihjb25zdCBib29zdDo6cHl0aG9uOjpzZXF1ZW5jZSYpOwpib29zdDo6cHl0aG9uOjpz ZXF1ZW5jZSBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29z dDo6cHl0aG9uOjpzZXF1ZW5jZT4pOwoKaW5saW5lIGJvb3N0OjpweXRob246OnNlcXVlbmNlIGZy b21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGNvbnN0IGJvb3N0Ojpw eXRob246OnNlcXVlbmNlJj4pCnsKICAgIHJldHVybiBmcm9tX3B5dGhvbihwLCBib29zdDo6cHl0 aG9uOjp0eXBlPGJvb3N0OjpweXRob246OnNlcXVlbmNlPigpKTsKfQoKUHlPYmplY3QqIHRvX3B5 dGhvbihjb25zdCBib29zdDo6cHl0aG9uOjptYXBwaW5nJik7CmJvb3N0OjpweXRob246Om1hcHBp bmcgZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5 dGhvbjo6bWFwcGluZz4pOwoKaW5saW5lIGJvb3N0OjpweXRob246Om1hcHBpbmcgZnJvbV9weXRo b24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Y29uc3QgYm9vc3Q6OnB5dGhvbjo6 bWFwcGluZyY+KQp7CiAgICByZXR1cm4gZnJvbV9weXRob24ocCwgYm9vc3Q6OnB5dGhvbjo6dHlw ZTxib29zdDo6cHl0aG9uOjptYXBwaW5nPigpKTsKfQoKUHlPYmplY3QqIHRvX3B5dGhvbihjb25z dCBib29zdDo6cHl0aG9uOjpzZXFtYXAmKTsKYm9vc3Q6OnB5dGhvbjo6c2VxbWFwIGZyb21fcHl0 aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0OjpweXRob246OnNlcW1h cD4pOwoKaW5saW5lIGJvb3N0OjpweXRob246OnNlcW1hcCBmcm9tX3B5dGhvbihQeU9iamVjdCog cCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxjb25zdCBib29zdDo6cHl0aG9uOjpzZXFtYXAmPikKewog ICAgcmV0dXJuIGZyb21fcHl0aG9uKHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5dGhv bjo6c2VxbWFwPigpKTsKfQoKUHlPYmplY3QqIHRvX3B5dGhvbihjb25zdCBib29zdDo6cHl0aG9u OjpzZXF1ZW5jZTo6cHJveHkmKTsKCgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0Ojpw eXRob246Om1hcHBpbmc6OnByb3h5Jik7CgoKCi8vIENvbmNyZXRlIG9iamVjdHMKCgpQeU9iamVj dCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246OnR1cGxlJik7CmJvb3N0OjpweXRob246 OnR1cGxlIGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0 OjpweXRob246OnR1cGxlPik7CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6dHVwbGUgZnJvbV9weXRo b24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Y29uc3QgYm9vc3Q6OnB5dGhvbjo6 dHVwbGUmPikKewogICAgcmV0dXJuIGZyb21fcHl0aG9uKHAsIGJvb3N0OjpweXRob246OnR5cGU8 Ym9vc3Q6OnB5dGhvbjo6dHVwbGU+KCkpOwp9CgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJv b3N0OjpweXRob246Omxpc3QmKTsKYm9vc3Q6OnB5dGhvbjo6bGlzdCBmcm9tX3B5dGhvbihQeU9i amVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29zdDo6cHl0aG9uOjpsaXN0Pik7Cgppbmxp bmUgYm9vc3Q6OnB5dGhvbjo6bGlzdCBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5 dGhvbjo6dHlwZTxjb25zdCBib29zdDo6cHl0aG9uOjpsaXN0Jj4pCnsKICAgIHJldHVybiBmcm9t X3B5dGhvbihwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0OjpweXRob246Omxpc3Q+KCkpOwp9 CgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246OnN0cmluZyYpOwpib29z dDo6cHl0aG9uOjpzdHJpbmcgZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246 OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6c3RyaW5nPik7CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6c3Ry aW5nIGZyb21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGNvbnN0IGJv b3N0OjpweXRob246OnN0cmluZyY+KQp7CiAgICByZXR1cm4gZnJvbV9weXRob24ocCwgYm9vc3Q6 OnB5dGhvbjo6dHlwZTxib29zdDo6cHl0aG9uOjpzdHJpbmc+KCkpOwp9CgpQeU9iamVjdCogdG9f cHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246OmRpY3Rpb25hcnkmKTsKYm9vc3Q6OnB5dGhvbjo6 ZGljdGlvbmFyeSBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxi b29zdDo6cHl0aG9uOjpkaWN0aW9uYXJ5Pik7CgppbmxpbmUgYm9vc3Q6OnB5dGhvbjo6ZGljdGlv bmFyeSBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxjb25zdCBi b29zdDo6cHl0aG9uOjpkaWN0aW9uYXJ5Jj4pCnsKICAgIHJldHVybiBmcm9tX3B5dGhvbihwLCBi b29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0OjpweXRob246OmRpY3Rpb25hcnk+KCkpOwp9CgpCT09T VF9QWVRIT05fRU5EX0NPTlZFUlNJT05fTkFNRVNQQUNFCgojZW5kaWYgLy8gT0JKRUNUU19EV0Ew NTExMDBfSF8K --0__=00256B270048BEB98f9e8a93df938690918c00256B270048BEB9 Content-type: application/octet-stream; name="objects.cpp" Content-Disposition: attachment; filename="objects.cpp" Content-transfer-encoding: base64 Ly8gIChDKSBDb3B5cmlnaHQgRGF2aWQgQWJyYWhhbXMgMjAwMC4gUGVybWlzc2lvbiB0byBjb3B5 LCB1c2UsIG1vZGlmeSwgc2VsbCBhbmQKLy8gIGRpc3RyaWJ1dGUgdGhpcyBzb2Z0d2FyZSBpcyBn cmFudGVkIHByb3ZpZGVkIHRoaXMgY29weXJpZ2h0IG5vdGljZSBhcHBlYXJzCi8vICBpbiBhbGwg Y29waWVzLiBUaGlzIHNvZnR3YXJlIGlzIHByb3ZpZGVkICJhcyBpcyIgd2l0aG91dCBleHByZXNz IG9yIGltcGxpZWQKLy8gIHdhcnJhbnR5LCBhbmQgd2l0aCBubyBjbGFpbSBhcyB0byBpdHMgc3Vp dGFiaWxpdHkgZm9yIGFueSBwdXJwb3NlLgovLwovLyAgVGhlIGF1dGhvciBncmF0ZWZ1bGx5IGFj a25vd2xlZ2VzIHRoZSBzdXBwb3J0IG9mIERyYWdvbiBTeXN0ZW1zLCBJbmMuLCBpbgovLyAgcHJv ZHVjaW5nIHRoaXMgd29yay4KCi8vIFRPRE86IE1vdmUgaW5saW5lIGltcGxlbWVudGF0aW9ucyBm cm9tIG9iamVjdHMuY3BwIGhlcmUKCiNpbmNsdWRlIDxib29zdC9weXRob24vb2JqZWN0cy5ocHA+ CiNpbmNsdWRlIDxib29zdC9weXRob24vZGV0YWlsL25vbmUuaHBwPgoKI2luY2x1ZGUgPGlvc3Ry ZWFtPgoKbmFtZXNwYWNlIGJvb3N0IHsgbmFtZXNwYWNlIHB5dGhvbiB7Cgp0ZW1wbGF0ZSA8Y2xh c3MgVD4KVCBvYmplY3RfZnJvbV9weXRob24oUHlPYmplY3QqIHAsIHR5cGU8VD4pCnsKICAgIHJl ZiB4KHAsIHJlZjo6aW5jcmVtZW50X2NvdW50KTsKICAgIGlmICghVDo6YWNjZXB0cyh4KSkKICAg IHsKICAgICAgICBQeUVycl9TZXRTdHJpbmcoUHlFeGNfVHlwZUVycm9yLCBwLT5vYl90eXBlLT50 cF9uYW1lKTsKICAgICAgICB0aHJvdyBlcnJvcl9hbHJlYWR5X3NldCgpOwogICAgfQogICAgcmV0 dXJuIFQoeCk7Cn0KCmlubGluZSBQeU9iamVjdCogb2JqZWN0X3RvX3B5dGhvbihjb25zdCBvYmpl Y3RfYmFzZSYgeCkKewogICAgcmV0dXJuIHgucmVmZXJlbmNlKCkucmVsZWFzZSgpOwp9CgpyZWYg dG9fcmVmKFB5T2JqZWN0KiBwKQp7CglyZXR1cm4gcmVmKHApOwp9CgpyZWYgdG9fcmVmKFB5T2Jq ZWN0KiBwLHJlZjo6aW5jcmVtZW50X2NvdW50X3QpCnsKCXJldHVybiByZWYocCxyZWY6OmluY3Jl bWVudF9jb3VudCk7Cn0KCgp9fSAvLyBuYW1lc3BhY2UgYm9vc3Q6OnB5dGhvbgoKQk9PU1RfUFlU SE9OX0JFR0lOX0NPTlZFUlNJT05fTkFNRVNQQUNFCgoKLy8gR2VuZXJpYyBvYmplY3RzCgpQeU9i amVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246Om9iamVjdCYgeCkKewogICAgcmV0 dXJuIG9iamVjdF90b19weXRob24oeCk7Cn0KCmJvb3N0OjpweXRob246Om9iamVjdCBmcm9tX3B5 dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29zdDo6cHl0aG9uOjpvYmpl Y3Q+IHR5cGUpCnsKICAgIHJldHVybiBib29zdDo6cHl0aG9uOjpvYmplY3RfZnJvbV9weXRob24o cCwgdHlwZSk7Cn0KClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhvbjo6c2Vx dWVuY2UmIHgpCnsKICAgIHJldHVybiBvYmplY3RfdG9fcHl0aG9uKHgpOwp9Cgpib29zdDo6cHl0 aG9uOjpzZXF1ZW5jZSBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlw ZTxib29zdDo6cHl0aG9uOjpzZXF1ZW5jZT4gdHlwZSkKewogICAgcmV0dXJuIGJvb3N0OjpweXRo b246Om9iamVjdF9mcm9tX3B5dGhvbihwLCB0eXBlKTsKfQoKClB5T2JqZWN0KiB0b19weXRob24o Y29uc3QgYm9vc3Q6OnB5dGhvbjo6bWFwcGluZyYgeCkKewogICAgcmV0dXJuIG9iamVjdF90b19w eXRob24oeCk7Cn0KCmJvb3N0OjpweXRob246Om1hcHBpbmcgZnJvbV9weXRob24oUHlPYmplY3Qq IHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6bWFwcGluZz4gdHlwZSkKewog ICAgcmV0dXJuIGJvb3N0OjpweXRob246Om9iamVjdF9mcm9tX3B5dGhvbihwLCB0eXBlKTsKfQoK ClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhvbjo6c2VxbWFwJiB4KQp7CiAg ICByZXR1cm4gb2JqZWN0X3RvX3B5dGhvbih4KTsKfQoKYm9vc3Q6OnB5dGhvbjo6c2VxbWFwIGZy b21fcHl0aG9uKFB5T2JqZWN0KiBwLCBib29zdDo6cHl0aG9uOjp0eXBlPGJvb3N0OjpweXRob246 OnNlcW1hcD4gdHlwZSkKewogICAgcmV0dXJuIGJvb3N0OjpweXRob246Om9iamVjdF9mcm9tX3B5 dGhvbihwLCB0eXBlKTsKfQoKClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhv bjo6c2VxdWVuY2U6OnByb3h5JiB4KQp7CiAgICByZXR1cm4gb2JqZWN0X3RvX3B5dGhvbih4KTsK fQoKClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6OnB5dGhvbjo6bWFwcGluZzo6cHJv eHkmIHgpCnsKICAgIHJldHVybiBvYmplY3RfdG9fcHl0aG9uKHgpOwp9CgoKCi8vIENvbmNyZXRl IG9iamVjdHMKCgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246OnR1cGxl JiB4KQp7CiAgICByZXR1cm4gb2JqZWN0X3RvX3B5dGhvbih4KTsKfQoKYm9vc3Q6OnB5dGhvbjo6 dHVwbGUgZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246OnR5cGU8Ym9vc3Q6 OnB5dGhvbjo6dHVwbGU+IHR5cGUpCnsKICAgIHJldHVybiBib29zdDo6cHl0aG9uOjpvYmplY3Rf ZnJvbV9weXRob24ocCwgdHlwZSk7Cn0KClB5T2JqZWN0KiB0b19weXRob24oY29uc3QgYm9vc3Q6 OnB5dGhvbjo6bGlzdCYgeCkKewogICAgcmV0dXJuIG9iamVjdF90b19weXRob24oeCk7Cn0KCmJv b3N0OjpweXRob246Omxpc3QgZnJvbV9weXRob24oUHlPYmplY3QqIHAsIGJvb3N0OjpweXRob246 OnR5cGU8Ym9vc3Q6OnB5dGhvbjo6bGlzdD4gdHlwZSkKewogICAgcmV0dXJuIGJvb3N0OjpweXRo b246Om9iamVjdF9mcm9tX3B5dGhvbihwLCB0eXBlKTsKfQoKUHlPYmplY3QqIHRvX3B5dGhvbihj b25zdCBib29zdDo6cHl0aG9uOjpkaWN0aW9uYXJ5JiB4KQp7CiAgICByZXR1cm4gb2JqZWN0X3Rv X3B5dGhvbih4KTsKfQoKYm9vc3Q6OnB5dGhvbjo6ZGljdGlvbmFyeSBmcm9tX3B5dGhvbihQeU9i amVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29zdDo6cHl0aG9uOjpkaWN0aW9uYXJ5PiB0 eXBlKQp7CiAgICByZXR1cm4gYm9vc3Q6OnB5dGhvbjo6b2JqZWN0X2Zyb21fcHl0aG9uKHAsIHR5 cGUpOwp9CgpQeU9iamVjdCogdG9fcHl0aG9uKGNvbnN0IGJvb3N0OjpweXRob246OnN0cmluZyYg eCkKewogICAgcmV0dXJuIG9iamVjdF90b19weXRob24oeCk7Cn0KCmJvb3N0OjpweXRob246OnN0 cmluZyBmcm9tX3B5dGhvbihQeU9iamVjdCogcCwgYm9vc3Q6OnB5dGhvbjo6dHlwZTxib29zdDo6 cHl0aG9uOjpzdHJpbmc+IHR5cGUpCnsKICAgIHJldHVybiBib29zdDo6cHl0aG9uOjpvYmplY3Rf ZnJvbV9weXRob24ocCwgdHlwZSk7Cn0KCkJPT1NUX1BZVEhPTl9FTkRfQ09OVkVSU0lPTl9OQU1F U1BBQ0UKCm5hbWVzcGFjZSBib29zdCB7IG5hbWVzcGFjZSBweXRob24gewoKCgp0dXBsZTo6dHVw bGUoc3RkOjpzaXplX3QgbikKICAgIDogb2JqZWN0X2Jhc2UocmVmKFB5VHVwbGVfTmV3KG4pKSkK ewogICAgZm9yIChzdGQ6OnNpemVfdCBpID0gMDsgaSA8IG47ICsraSkKICAgICAgICBQeVR1cGxl X1NFVF9JVEVNKGdldCgpLCBpLCBkZXRhaWw6Om5vbmUoKSk7Cn0KICAgIAp0dXBsZTo6dHVwbGUo cmVmIHApCiAgICA6IG9iamVjdF9iYXNlKHApCnsKICAgIGFzc2VydChhY2NlcHRzKHApKTsKICAg IGlmICghYWNjZXB0cyhwKSkKICAgIHsKICAgICAgICBQeUVycl9TZXRTdHJpbmcoUHlFeGNfVHlw ZUVycm9yLCBwLT5vYl90eXBlLT50cF9uYW1lKTsKICAgICAgICB0aHJvdyBlcnJvcl9hbHJlYWR5 X3NldCgpOwogICAgfQp9CgpQeVR5cGVPYmplY3QqIHR1cGxlOjp0eXBlX29iaigpCnsKICAgIHJl dHVybiAmUHlUdXBsZV9UeXBlOwp9Cgpib29sIHR1cGxlOjphY2NlcHRzKHJlZiBwKQp7CiAgICBy ZXR1cm4gUHlUdXBsZV9DaGVjayhwLmdldCgpKTsKfQoKc3RkOjpzaXplX3QgdHVwbGU6OnNpemUo KSBjb25zdAp7CiAgICByZXR1cm4gUHlUdXBsZV9TaXplKGdldCgpKTsKfQoKcmVmIHR1cGxlOjpv cGVyYXRvcltdKHN0ZDo6c2l6ZV90IHBvcykgY29uc3QKewogICAgcmV0dXJuIHJlZihQeVR1cGxl X0dldEl0ZW0oZ2V0KCksIHN0YXRpY19jYXN0PGludD4ocG9zKSksCiAgICAgICAgICAgICAgIHJl Zjo6aW5jcmVtZW50X2NvdW50KTsKfQoKdm9pZCB0dXBsZTo6c2V0X2l0ZW0oc3RkOjpzaXplX3Qg cG9zLCBjb25zdCByZWYmIHJocykKewogICAgaW50IGZhaWxlZCA9IFB5VHVwbGVfU2V0SXRlbSgK ICAgICAgICBnZXQoKSwgc3RhdGljX2Nhc3Q8aW50Pihwb3MpLCByZWYocmhzKS5yZWxlYXNlKCkp OyAvLyBBIHJlZmVyZW5jZSBpcyBzdG9sZW4gaGVyZS4KICAgICh2b2lkKWZhaWxlZDsKICAgIGFz c2VydChmYWlsZWQgPT0gMCk7Cn0KCnR1cGxlIHR1cGxlOjpzbGljZShpbnQgbG93LCBpbnQgaGln aCkgY29uc3QKewogICAgcmV0dXJuIHR1cGxlKHJlZihQeVR1cGxlX0dldFNsaWNlKGdldCgpLCBs b3csIGhpZ2gpKSk7Cn0KCnR1cGxlJiB0dXBsZTo6b3BlcmF0b3IrPShjb25zdCB0dXBsZSYgcmhz KQp7CiAgICByZXR1cm4gKnRoaXMgPSAqdGhpcyArIHJoczsKfQoKCi8vIENvbnN0cnVjdCBmcm9t IGFuIG93bmVkIFB5T2JqZWN0Ki4KLy8gUHJlY29uZGl0aW9uOiBwIG11c3QgcG9pbnQgdG8gYSBw eXRob24gc3RyaW5nLgpzdHJpbmc6OnN0cmluZyhyZWYgcCkKICAgIDogb2JqZWN0X2Jhc2UocCkK ewogICAgYXNzZXJ0KGFjY2VwdHMocCkpOwogICAgaWYgKCFhY2NlcHRzKHApKQogICAgewogICAg ICAgIFB5RXJyX1NldFN0cmluZyhQeUV4Y19UeXBlRXJyb3IsIHAtPm9iX3R5cGUtPnRwX25hbWUp OwogICAgICAgIHRocm93IGVycm9yX2FscmVhZHlfc2V0KCk7CiAgICB9Cn0KICAgIApzdHJpbmc6 OnN0cmluZyhjb25zdCBjaGFyKiBzKQogICAgOiBvYmplY3RfYmFzZShyZWYoUHlTdHJpbmdfRnJv bVN0cmluZyhzKSkpIHt9CgpzdHJpbmc6OnN0cmluZyhjb25zdCBjaGFyKiBzLCBzdGQ6OnNpemVf dCBsZW5ndGgpCiAgICA6IG9iamVjdF9iYXNlKHJlZihQeVN0cmluZ19Gcm9tU3RyaW5nQW5kU2l6 ZShzLCBsZW5ndGgpKSkge30KCnN0cmluZzo6c3RyaW5nKGNvbnN0IGNoYXIqIHMsIGludGVybmVk X3QpCiAgICA6IG9iamVjdF9iYXNlKHJlZihQeVN0cmluZ19JbnRlcm5Gcm9tU3RyaW5nKHMpKSkg e30KCiNpZiAwCnN0cmluZzo6c3RyaW5nKGNvbnN0IGNoYXIqIHMsIHN0ZDo6c2l6ZV90IGxlbmd0 aCwgaW50ZXJuZWRfdCkKICAgIDogb2JqZWN0X2Jhc2UocmVmKFB5U3RyaW5nX0ludGVybkZyb21T dHJpbmdBbmRTaXplKHMsIGxlbmd0aCkpKSB7fQojZW5kaWYKCnN0cmluZzo6c3RyaW5nKGNvbnN0 IHN0cmluZyYgcmhzKQogICAgOiBvYmplY3RfYmFzZShyaHMucmVmZXJlbmNlKCkpIHt9CgovLyBH ZXQgdGhlIHR5cGUgb2JqZWN0IGZvciBTdHJpbmdzClB5VHlwZU9iamVjdCogc3RyaW5nOjp0eXBl X29iaigpCnsgcmV0dXJuICZQeVN0cmluZ19UeXBlOyB9CgovLyBSZXR1cm4gdHJ1ZSBpZiB0aGUg Z2l2ZW4gb2JqZWN0IGlzIGEgcHl0aG9uIHN0cmluZwpib29sIHN0cmluZzo6YWNjZXB0cyhyZWYg bykKeyByZXR1cm4gUHlTdHJpbmdfQ2hlY2soby5nZXQoKSk7IH0KCi8vIFJldHVybiB0aGUgbGVu Z3RoIG9mIHRoZSBzdHJpbmcuCnN0ZDo6c2l6ZV90IHN0cmluZzo6c2l6ZSgpIGNvbnN0CnsKICAg IGludCBzaXplID0gUHlTdHJpbmdfR0VUX1NJWkUoZ2V0KCkpOwogICAgYXNzZXJ0KHNpemUgPj0g MCk7CiAgICByZXR1cm4gc3RhdGljX2Nhc3Q8c3RkOjpzaXplX3Q+KHNpemUpOwp9CgovLyBSZXR1 cm5zIGEgbnVsbC10ZXJtaW5hdGVkIHJlcHJlc2VudGF0aW9uIG9mIHRoZSBjb250ZW50cyBvZiBz dHJpbmcuCi8vIFRoZSBwb2ludGVyIHJlZmVycyB0byB0aGUgaW50ZXJuYWwgYnVmZmVyIG9mIHN0 cmluZywgbm90IGEgY29weS4KLy8gVGhlIGRhdGEgbXVzdCBub3QgYmUgbW9kaWZpZWQgaW4gYW55 IHdheS4gSXQgbXVzdCBub3QgYmUgZGUtYWxsb2NhdGVkLiAKY29uc3QgY2hhciogc3RyaW5nOjpj X3N0cigpIGNvbnN0CnsgcmV0dXJuIFB5U3RyaW5nX0FTX1NUUklORyhnZXQoKSk7IH0KCnZvaWQg c3RyaW5nOjppbnRlcm4oKQp7IC8vIFVOVEVTVEVEISEKICAgICp0aGlzID0gc3RyaW5nKHJlZihQ eVN0cmluZ19JbnRlcm5Gcm9tU3RyaW5nKGNfc3RyKCkpLCByZWY6OmluY3JlbWVudF9jb3VudCkp Owp9CgpzdHJpbmcmIHN0cmluZzo6b3BlcmF0b3IqPSh1bnNpZ25lZCBpbnQgcmVwZWF0X2NvdW50 KQp7CiAgICAqdGhpcyA9IHN0cmluZyhyZWYoUHlTZXF1ZW5jZV9SZXBlYXQoZ2V0KCksIHJlcGVh dF9jb3VudCkpKTsKICAgIHJldHVybiAqdGhpczsKfQoKZGljdGlvbmFyeTo6ZGljdGlvbmFyeShy ZWYgcCkKICAgIDogb2JqZWN0X2Jhc2UocCkKewogICAgYXNzZXJ0KGFjY2VwdHMocCkpOwogICAg aWYgKCFhY2NlcHRzKHApKQogICAgewogICAgICAgIFB5RXJyX1NldFN0cmluZyhQeUV4Y19UeXBl RXJyb3IsIHAtPm9iX3R5cGUtPnRwX25hbWUpOwogICAgICAgIHRocm93IGVycm9yX2FscmVhZHlf c2V0KCk7CiAgICB9Cn0KCmRpY3Rpb25hcnk6OmRpY3Rpb25hcnkoKQogICAgOiBvYmplY3RfYmFz ZShyZWYoUHlEaWN0X05ldygpKSkge30KClB5VHlwZU9iamVjdCogZGljdGlvbmFyeTo6dHlwZV9v YmooKQp7IHJldHVybiAmUHlEaWN0X1R5cGU7IH0KCmJvb2wgZGljdGlvbmFyeTo6YWNjZXB0cyhy ZWYgcCkKeyByZXR1cm4gUHlEaWN0X0NoZWNrKHAuZ2V0KCkpOyB9Cgp2b2lkIGRpY3Rpb25hcnk6 OmNsZWFyKCkKeyBQeURpY3RfQ2xlYXIoZ2V0KCkpOyB9Cgpjb25zdCByZWYmIGRpY3Rpb25hcnk6 OnByb3h5OjpvcGVyYXRvcj0oY29uc3QgcmVmJiByaHMpCnsKICAgIGlmIChQeURpY3RfU2V0SXRl bShtX2RpY3QuZ2V0KCksIG1fa2V5LmdldCgpLCByaHMuZ2V0KCkpID09IC0xKQogICAgICAgIHRo cm93IGVycm9yX2FscmVhZHlfc2V0KCk7CiAgICByZXR1cm4gcmhzOwp9CgpkaWN0aW9uYXJ5Ojpw cm94eTo6b3BlcmF0b3IgcmVmKCkgY29uc3QKewogICAgcmV0dXJuIHJlZihtX2RpY3QtPm9iX3R5 cGUtPnRwX2FzX21hcHBpbmctPm1wX3N1YnNjcmlwdChtX2RpY3QuZ2V0KCksIG1fa2V5LmdldCgp KSwKICAgICAgICAgICAgICAgcmVmOjppbmNyZW1lbnRfY291bnQpOwp9CgpkaWN0aW9uYXJ5Ojpw cm94eTo6cHJveHkoY29uc3QgcmVmJiBkaWN0LCBjb25zdCByZWYmIGtleSkKICAgIDogbV9kaWN0 KGRpY3QpLCBtX2tleShrZXkpIHt9CgpkaWN0aW9uYXJ5Ojpwcm94eSBkaWN0aW9uYXJ5OjpvcGVy YXRvcltdKHJlZiBrZXkpCnsgcmV0dXJuIHByb3h5KHJlZmVyZW5jZSgpLCBrZXkpOyB9CiAgICAK cmVmIGRpY3Rpb25hcnk6Om9wZXJhdG9yW10ocmVmIGtleSkgY29uc3QgewogICAgLy8gQW4gb2Rk IE1TVkMgYnVnIGNhdXNlcyB0aGUgIi5vcGVyYXRvciBQdHIoKSIgdG8gYmUgbmVlZGVkCiAgICBy ZXR1cm4gcHJveHkocmVmZXJlbmNlKCksIGtleSkub3BlcmF0b3IgcmVmKCk7Cn0KCiAgICAKcmVm IGRpY3Rpb25hcnk6OmdldF9pdGVtKGNvbnN0IHJlZiYga2V5KSBjb25zdAp7CiAgICByZXR1cm4g Z2V0X2l0ZW0oa2V5LCByZWYoKSk7Cn0KCnJlZiBkaWN0aW9uYXJ5OjpnZXRfaXRlbShjb25zdCBy ZWYmIGtleSwgY29uc3QgcmVmJiBkZWZhdWx0XykgY29uc3QKewogICAgUHlPYmplY3QqIHZhbHVl X29yX251bGwgPSBQeURpY3RfR2V0SXRlbShnZXQoKSwga2V5LmdldCgpKTsKICAgIGlmICh2YWx1 ZV9vcl9udWxsID09IDAgJiYgIVB5RXJyX09jY3VycmVkKCkpCiAgICAgICAgcmV0dXJuIGRlZmF1 bHRfOwogICAgZWxzZQogICAgICAgIHJldHVybiByZWYodmFsdWVfb3JfbnVsbCwgcmVmOjppbmNy ZW1lbnRfY291bnQpOyAvLyBXaWxsIHRocm93IGlmIHRoZXJlIHdhcyBhbm90aGVyIGVycm9yCn0K ICAgICAgICAKdm9pZCBkaWN0aW9uYXJ5OjpzZXRfaXRlbShjb25zdCByZWYmIGtleSwgY29uc3Qg cmVmJiB2YWx1ZSkKewogICAgaWYgKFB5RGljdF9TZXRJdGVtKGdldCgpLCBrZXkuZ2V0KCksIHZh bHVlLmdldCgpKSA9PSAtMSkKICAgICAgICB0aHJvdyBlcnJvcl9hbHJlYWR5X3NldCgpOwp9Cgp2 b2lkIGRpY3Rpb25hcnk6OmVyYXNlKHJlZiBrZXkpIHsKICAgIGlmIChQeURpY3RfRGVsSXRlbShn ZXQoKSwga2V5LmdldCgpKSA9PSAtMSkKICAgICAgICB0aHJvdyBlcnJvcl9hbHJlYWR5X3NldCgp Owp9CgpsaXN0IGRpY3Rpb25hcnk6Oml0ZW1zKCkgY29uc3QgeyByZXR1cm4gbGlzdChyZWYoUHlE aWN0X0l0ZW1zKGdldCgpKSkpOyB9Cmxpc3QgZGljdGlvbmFyeTo6a2V5cygpIGNvbnN0IHsgcmV0 dXJuIGxpc3QocmVmKFB5RGljdF9LZXlzKGdldCgpKSkpOyB9Cmxpc3QgZGljdGlvbmFyeTo6dmFs dWVzKCkgY29uc3QgeyByZXR1cm4gbGlzdChyZWYoUHlEaWN0X1ZhbHVlcyhnZXQoKSkpKTsgfQoK c3RkOjpzaXplX3QgZGljdGlvbmFyeTo6c2l6ZSgpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0 PHN0ZDo6c2l6ZV90PihQeURpY3RfU2l6ZShnZXQoKSkpOyB9CgpzdHJpbmcgb3BlcmF0b3IrKHN0 cmluZyB4LCBzdHJpbmcgeSkKewogICAgUHlPYmplY3QqIGlvX3N0cmluZyA9IHgucmVmZXJlbmNl KCkucmVsZWFzZSgpOwogICAgUHlTdHJpbmdfQ29uY2F0KCZpb19zdHJpbmcsIHkuZ2V0KCkpOwog ICAgcmV0dXJuIHN0cmluZyhyZWYoaW9fc3RyaW5nKSk7ICAgIAp9CgpzdHJpbmcmIHN0cmluZzo6 b3BlcmF0b3IrPShjb25zdCBzdHJpbmcmIHJocykKewogICAgcmV0dXJuICp0aGlzID0gKnRoaXMg KyByaHM7Cn0KCnN0cmluZyYgc3RyaW5nOjpvcGVyYXRvcis9KGNvbnN0IGNoYXIqIHkpCnsKICAg IHJldHVybiAqdGhpcyArPSBzdHJpbmcoeSk7Cn0KCnN0cmluZyBvcGVyYXRvciUoY29uc3Qgc3Ry aW5nJiBmb3JtYXQsIGNvbnN0IHR1cGxlJiBhcmdzKQp7CiAgICByZXR1cm4gc3RyaW5nKHJlZihQ eVN0cmluZ19Gb3JtYXQoZm9ybWF0LmdldCgpLCBhcmdzLnJlZmVyZW5jZSgpLmdldCgpKSkpOwp9 CgpzdHJpbmcgb3BlcmF0b3IrKHN0cmluZyB4LCBjb25zdCBjaGFyKiB5KQp7CiAgICByZXR1cm4g eCArIHN0cmluZyh5KTsKfQoKc3RyaW5nIG9wZXJhdG9yKyhjb25zdCBjaGFyKiB4LCBzdHJpbmcg eSkKewogICAgcmV0dXJuIHN0cmluZyh4KSArIHk7Cn0KCnR1cGxlIG9wZXJhdG9yKyhjb25zdCB0 dXBsZSYgeCwgY29uc3QgdHVwbGUmIHkpCnsKICAgIHR1cGxlIHJlc3VsdCh4LnNpemUoKSArIHku c2l6ZSgpKTsKICAgIGZvciAoc3RkOjpzaXplX3QgeGkgPSAwOyB4aSA8IHguc2l6ZSgpOyArK3hp KQogICAgICAgIHJlc3VsdC5zZXRfaXRlbSh4aSwgeFt4aV0pOwogICAgZm9yIChzdGQ6OnNpemVf dCB5aSA9IDA7IHlpIDwgeS5zaXplKCk7ICsreWkpCiAgICAgICAgcmVzdWx0LnNldF9pdGVtKHlp ICsgeC5zaXplKCksIHlbeWldKTsKICAgIHJldHVybiByZXN1bHQ7Cn0KCgpsaXN0OjpsaXN0KHJl ZiBwKQogICAgOiBvYmplY3RfYmFzZShwKQp7CiAgICBhc3NlcnQoYWNjZXB0cyhwKSk7CiAgICBp ZiAoIWFjY2VwdHMocCkpCiAgICB7CiAgICAgICAgUHlFcnJfU2V0U3RyaW5nKFB5RXhjX1R5cGVF cnJvciwgcC0+b2JfdHlwZS0+dHBfbmFtZSk7CiAgICAgICAgdGhyb3cgZXJyb3JfYWxyZWFkeV9z ZXQoKTsKICAgIH0KfQoKbGlzdDo6bGlzdChzdGQ6OnNpemVfdCBzeikKICAgIDogb2JqZWN0X2Jh c2UocmVmKFB5TGlzdF9OZXcoc3opKSkKewp9CgpQeVR5cGVPYmplY3QqIGxpc3Q6OnR5cGVfb2Jq KCkKewogICAgcmV0dXJuICZQeUxpc3RfVHlwZTsKfQoKYm9vbCBsaXN0OjphY2NlcHRzKHJlZiBw KQp7CiAgICByZXR1cm4gUHlMaXN0X0NoZWNrKHAuZ2V0KCkpOwp9CgpzdGQ6OnNpemVfdCBsaXN0 OjpzaXplKCkgY29uc3QKewogICAgcmV0dXJuIFB5TGlzdF9TaXplKGdldCgpKTsKfQoKc2VxdWVu Y2UgbGlzdDo6b3BlcmF0b3JbXShzdGQ6OnNpemVfdCBwb3MpIGNvbnN0CnsKICAgIHJldHVybiBz ZXF1ZW5jZShyZWYoUHlMaXN0X0dldEl0ZW0oZ2V0KCksIHBvcyksIHJlZjo6aW5jcmVtZW50X2Nv dW50KSk7Cn0KCmxpc3Q6OnByb3h5IGxpc3Q6Om9wZXJhdG9yW10oc3RkOjpzaXplX3QgcG9zKQp7 CiAgICByZXR1cm4gcHJveHkocmVmZXJlbmNlKCksIHBvcyk7Cn0KCnZvaWQgbGlzdDo6aW5zZXJ0 KHN0ZDo6c2l6ZV90IGluZGV4LCBjb25zdCByZWYmIGl0ZW0pCnsKICAgIGlmIChQeUxpc3RfSW5z ZXJ0KGdldCgpLCBpbmRleCwgaXRlbS5nZXQoKSkgPT0gLTEpCiAgICAgICAgdGhyb3cgZXJyb3Jf YWxyZWFkeV9zZXQoKTsKfQoKdm9pZCBsaXN0OjpwdXNoX2JhY2soY29uc3QgcmVmJiBpdGVtKQp7 CiAgICBpZiAoUHlMaXN0X0FwcGVuZChnZXQoKSwgaXRlbS5nZXQoKSkgPT0gLTEpCiAgICAgICAg dGhyb3cgZXJyb3JfYWxyZWFkeV9zZXQoKTsKfQoKdm9pZCBsaXN0OjphcHBlbmQoY29uc3QgcmVm JiBpdGVtKQp7CiAgICB0aGlzLT5wdXNoX2JhY2soaXRlbSk7Cn0KCmxpc3QgbGlzdDo6c2xpY2Uo aW50IGxvdywgaW50IGhpZ2gpIGNvbnN0CnsKICAgIHJldHVybiBsaXN0KHJlZihQeUxpc3RfR2V0 U2xpY2UoZ2V0KCksIGxvdywgaGlnaCkpKTsKfQoKbGlzdDo6c2xpY2VfcHJveHkgbGlzdDo6c2xp Y2UoaW50IGxvdywgaW50IGhpZ2gpCnsKICAgIHJldHVybiBzbGljZV9wcm94eShyZWZlcmVuY2Uo KSwgbG93LCBoaWdoKTsKfQoKdm9pZCBsaXN0Ojpzb3J0KCkKewogICAgaWYgKFB5TGlzdF9Tb3J0 KGdldCgpKSA9PSAtMSkKICAgICAgICB0aHJvdyBlcnJvcl9hbHJlYWR5X3NldCgpOwp9Cgp2b2lk IGxpc3Q6OnJldmVyc2UoKQp7CiAgICBpZiAoUHlMaXN0X1JldmVyc2UoZ2V0KCkpID09IC0xKQog ICAgICAgIHRocm93IGVycm9yX2FscmVhZHlfc2V0KCk7Cn0KCnR1cGxlIGxpc3Q6OmFzX3R1cGxl KCkgY29uc3QKewogICAgcmV0dXJuIHR1cGxlKHJlZihQeUxpc3RfQXNUdXBsZShnZXQoKSkpKTsK fQoKY29uc3QgcmVmJiBsaXN0Ojpwcm94eTo6b3BlcmF0b3I9KGNvbnN0IHJlZiYgcmhzKQp7CiAg ICBtX2xpc3Quc2V0X2l0ZW0obV9pbmRleCwgcmhzKTsKICAgIHJldHVybiByaHM7Cn0KCi8qbGlz dDo6cHJveHk6Om9wZXJhdG9yIHJlZigpIGNvbnN0CnsKICAgIHJldHVybiByZWYoUHlMaXN0X0dl dEl0ZW0obV9saXN0LmdldCgpLCBtX2luZGV4KSwgcmVmOjppbmNyZW1lbnRfY291bnQpOwp9Ki8K CgpyZWYgbGlzdDo6Z2V0X2l0ZW0oc3RkOjpzaXplX3QgcG9zKSBjb25zdAp7CiAgICByZXR1cm4g cmVmKFB5TGlzdF9HZXRJdGVtKHRoaXMtPmdldCgpLCBwb3MpLCByZWY6OmluY3JlbWVudF9jb3Vu dCk7Cn0KCnZvaWQgbGlzdDo6c2V0X2l0ZW0oc3RkOjpzaXplX3QgcG9zLCBjb25zdCByZWYmIHJo cykKewogICAgaW50IHJlc3VsdCA9IFB5TGlzdF9TZXRJdGVtKHRoaXMtPmdldCgpLCBwb3MsIHJo cy5nZXQoKSk7CiAgICBpZiAocmVzdWx0ID09IC0xKQogICAgICAgIHRocm93IGVycm9yX2FscmVh ZHlfc2V0KCk7CiAgICBQeV9JTkNSRUYocmhzLmdldCgpKTsKfQoKbGlzdDo6cHJveHk6OnByb3h5 KGNvbnN0IHJlZiYgbGlzdCwgc3RkOjpzaXplX3QgaW5kZXgpCiAgICA6IG9iamVjdChyZWYoUHlM aXN0X0dldEl0ZW0obGlzdC5nZXQoKSwgaW5kZXgpLCByZWY6OmluY3JlbWVudF9jb3VudCkpICwg c2VxbWFwKG9iamVjdDo6cmVmZXJlbmNlKCkpICwgbV9saXN0KGxpc3QpLCBtX2luZGV4KGluZGV4 KQp7Cn0KCmNvbnN0IGxpc3QmIGxpc3Q6OnNsaWNlX3Byb3h5OjpvcGVyYXRvcj0oY29uc3QgbGlz dCYgcmhzKQp7CiAgICBpZiAoUHlMaXN0X1NldFNsaWNlKG1fbGlzdC5nZXQoKSwgbV9sb3csIG1f aGlnaCwgcmhzLmdldCgpKSA9PSAtMSkKICAgICAgICB0aHJvdyBlcnJvcl9hbHJlYWR5X3NldCgp OwogICAgcmV0dXJuIHJoczsKfQoKbGlzdDo6c2xpY2VfcHJveHk6Om9wZXJhdG9yIHJlZigpIGNv bnN0CnsKICAgIHJldHVybiByZWYoUHlMaXN0X0dldFNsaWNlKG1fbGlzdC5nZXQoKSwgbV9sb3cs IG1faGlnaCkpOwp9CgpsaXN0OjpzbGljZV9wcm94eTo6b3BlcmF0b3IgbGlzdCgpIGNvbnN0CnsK ICAgIHJldHVybiBsaXN0KHRoaXMtPm9wZXJhdG9yIHJlZigpKTsKfQoKc3RkOjpzaXplX3QgbGlz dDo6c2xpY2VfcHJveHk6OnNpemUoKSBjb25zdAp7CiAgICByZXR1cm4gdGhpcy0+b3BlcmF0b3Ig bGlzdCgpLnNpemUoKTsKfQoKcmVmIGxpc3Q6OnNsaWNlX3Byb3h5OjpvcGVyYXRvcltdKHN0ZDo6 c2l6ZV90IHBvcykgY29uc3QKewogICAgcmV0dXJuIHRoaXMtPm9wZXJhdG9yIGxpc3QoKVtwb3Nd Lm9wZXJhdG9yIHJlZigpOwp9CgpsaXN0OjpzbGljZV9wcm94eTo6c2xpY2VfcHJveHkoY29uc3Qg cmVmJiBsaXN0LCBpbnQgbG93LCBpbnQgaGlnaCkKICAgIDogbV9saXN0KGxpc3QpLCBtX2xvdyhs b3cpLCBtX2hpZ2goaGlnaCkKewp9Cgp9fSAvLyBuYW1lc3BhY2UgYm9vc3Q6OnB5dGhvbgo= --0__=00256B270048BEB98f9e8a93df938690918c00256B270048BEB9 Content-type: application/octet-stream; name="tmodule.cpp" Content-Disposition: attachment; filename="tmodule.cpp" Content-transfer-encoding: base64 CiNpbmNsdWRlIDxQeXRob24uaD4KI2luY2x1ZGUgPGJvb3N0L3B5dGhvbi9jbGFzc19idWlsZGVy LmhwcD4KI2luY2x1ZGUgPGJvb3N0L3B5dGhvbi9yZWZlcmVuY2UuaHBwPgojaW5jbHVkZSA8Ym9v c3QvcHl0aG9uL29iamVjdHMuaHBwPgovLyNpbmNsdWRlIDxib29zdC9weXRob24vY2FsbGJhY2su aHBwPgojaW5jbHVkZSA8Ym9vc3QvdHlwZV90cmFpdHMuaHBwPgoKI2luY2x1ZGUgPGlvc3RyZWFt PgoKbmFtZXNwYWNlIHB5dGhvbiA9IGJvb3N0OjpweXRob247CgpuYW1lc3BhY2UKewoJCgkvKgoJ cHl0aG9uOjpyZWYgY3JlYXRlVE1QKCkKCXsKCQlweXRob246OnB5cmVmIHRtcF9kYXRhX21vZChQ eUltcG9ydF9JbXBvcnRNb2R1bGUoInRtcF9kYXRhIikpOwoKCQlweXRob246OnB5cmVmIFRNUF90 ID0gdG1wX2RhdGFfbW9kLmdldGF0dHIoIlRNUCIpOyAvLyBweXRob246OnB5cmVmIFRNUF90ID0g Z2V0YXR0cih0bXBfZGF0YV9tb2QsIlRNUCIpCgoJCXB5dGhvbjo6cHlyZWYgbmV3X3RtcCA9IFRN UF90KCk7CgoJCW5ld190bXAuc2V0YXR0cigicCIsMSk7CgkJbmV3X3RtcC5zZXRhdHRyKCJpZCIs IkExIik7CgkJbmV3X3RtcC5zZXRhdHRyKCJzY29yZSIsMS4xKTsKCQkKCQlyZXR1cm4gbmV3X3Rt cDsKCX0KCQoJCglweXRob246OnJlZiBjcmVhdGVMaXN0KCkKCXsKCQlweXRob246OnB5c2VxcmVm IG15bGlzdChQeUxpc3RfTmV3KDApKTsKCQlmb3IoaW50IGkgPSAwO2kgPCAxMDsrK2kpCgkJCW15 bGlzdC5hcHBlbmQoaSk7CgkJcHl0aG9uOjpweXNlcXJlZiBteWl0ZW0obXlsaXN0WzJdKTsKCQlj b3V0IDw8IGludChteWl0ZW0pIDw8IGVuZGw7CgkJbXlpdGVtID0gMTU7CgkJY291dCA8PCBpbnQo bXlpdGVtKSA8PCBlbmRsOwoJCWNvbnN0IHB5dGhvbjo6cHlzZXFyZWYgbXlsaXN0MihteWxpc3Qp OwoJCXB5dGhvbjo6cHlzZXFyZWYgbXlpdGVtMihteWxpc3QyWzJdKTsKCQkKCQlteWxpc3Quc2V0 X2l0ZW0oNSwibXkiKTsKCQlteWxpc3Quc2V0X2l0ZW0oNiwxLjEyKTsKCQlteWxpc3RbN10gPSAx MDA7CgkJbXlsaXN0LmNhbGxfbWV0aG9kKCJwb3AiLDQpOwoJCQoJCWludCB2YWwgPSBteWxpc3Rb Nl07CgkJCgkJLy9mb3IoaW50IGkgPSAwO2kgPCBteWxpc3Quc2l6ZSgpOysraSkKCQkJLy9jb3V0 IDw8IGludChteWxpc3RbaV0pOwoJCQoJCXJldHVybiBteWxpc3Q7Cgl9CgkKCXB5dGhvbjo6cmVm IGNyZWF0ZU1hcCgpCgl7CgkJcHl0aG9uOjpweW1hcHJlZiBteW1hcChQeURpY3RfTmV3KCkpOwoJ CW15bWFwWyJrZXkxIl0gPSAyOwoJCW15bWFwWyJrZXkyIl0gPSAzOwoJCQoJCXB5dGhvbjo6cHlz ZXFyZWYgbXlrZXlzID0gbXltYXAua2V5cygpOwoJCWZvcihpbnQgaT0wO2k8bXlrZXlzLnNpemUo KTsrK2kpCgkJewoJCQljb3V0IDw8IChjb25zdCBjaGFyKikgbXlrZXlzW2ldIDw8IGVuZGw7CgkJ fQoJCQoJCWludCB2YWwgPSBteW1hcFsia2V5MiJdOwoJCQoJCWNvdXQgPDwgdmFsOwoJCQoJCXJl dHVybiBteW1hcDsKCX0KCSovCgkKCXB5dGhvbjo6cmVmIHRlc3RfbGlzdCgpCgl7CgkJcHl0aG9u OjpsaXN0IG15bGlzdDsKCQlmb3IoaW50IGkgPSAwO2kgPCAxMDsrK2kpCgkJCW15bGlzdC5hcHBl bmQocHl0aG9uOjpsaXN0KCkpOwoJCQoJCW15bGlzdFszXSA9ICIxMjMiOwoJCXB5dGhvbjo6bGlz dCBsKG15bGlzdFs1XSk7CgkJbC5hcHBlbmQoMyk7CgkJcHl0aG9uOjpvYmplY3Qgb2IobXlsaXN0 WzFdKTsKCQlvYi5jYWxsX21ldGhvZCgiYXBwZW5kIiwyKTsKCgkJLy9weXRob246OnJlZiBwID0g bXlsaXN0WzhdOwoJCQoJCW15bGlzdFsxXS5jYWxsX21ldGhvZCgiYXBwZW5kIiw0KTsKCQlteWxp c3RbMV1bMV0gPSBweXRob246Omxpc3QoKTsKCQlteWxpc3RbMV1bMV0uYXBwZW5kKDIpOwoJCW15 bGlzdFsxXVsxXVswXSA9IDk5OwoJCWNvbnN0IHB5dGhvbjo6bGlzdCBsMihteWxpc3QpOwoJCXB5 dGhvbjo6b2JqZWN0IHIgPSBsMls5XTsKCgkJcmV0dXJuIG15bGlzdDsKCX0KCQkKCXB5dGhvbjo6 cmVmIHRlc3RfbWFwKCkKCXsKCQlweXRob246OmRpY3Rpb25hcnkgZDsKCQlweXRob246Om1hcHBp bmcgbShkKTsKCQkKCQltWyJrayJdID0gMTsKCQltWyJqaiJdID0gcHl0aG9uOjpkaWN0aW9uYXJ5 KCk7CgkJbVsiamoiXVsiaGgiXSA9IDI7CgkJCgkJcmV0dXJuIG07Cgl9CgoJcHl0aG9uOjpyZWYg dGVzdF9saXN0bWFwKCkKCXsKCQlweXRob246OmRpY3Rpb25hcnkgZDsKCQlweXRob246Om1hcHBp bmcgbShkKTsKCQkKCQltWyJrayJdID0gMTsKCQltWyJqaiJdID0gcHl0aG9uOjpsaXN0KCk7CgkJ bVsiamoiXS5hcHBlbmQoMik7IC8vIC5leHRlbmQocHl0aG9uOjpsaXN0KCJbMSwyLCdmZyddIikp OwoJCW1bImpqIl1bMF0gPSBweXRob246OmRpY3Rpb25hcnkoKTsKCQltWyJqaiJdWzBdWyJpaSJd ID0gcHl0aG9uOjpsaXN0KCk7CgkJbVsiamoiXVswXVsiaWkiXS5hcHBlbmQoMyk7CgkJbVsiamoi XVswXVsiaWkiXVswXSA9IHB5dGhvbjo6bGlzdCgpOwoJCWZvcihpbnQgaSA9IDA7aTwxMDsrK2kp CgkJCW1bImpqIl1bMF1bImlpIl1bMF0uYXBwZW5kKGkpOwoJCQkKCQltWyJqaiJdWzBdWyJpaSJd WzBdWzVdID0gOTk5OwoJCQoJCQoJCWNvdXQgPDwgImEwIjsKCQlweXRob246Om9iamVjdCBvKG1b ImR1bW15Il0pOwoJCS8vY291dCA8PCBtWyJkdW1teSJdLnN0cigpOwoJCWNvdXQgPDwgImExIjsK CQljb3V0IDw8IG8uc3RyKCk7IC8vU2VnbWVudGF0aW9uIEZhdWx0CgkJLy9vLmNhbGxfbWV0aG9k KCJsZW4iKTsgLy9TZWdtZW50YXRpb24gRmF1bHQKCQljb3V0IDw8ICJhMiI7CgkJLy9weXRob246 OnJlZiByKG1bImR1bW15Il0pOwoJCQoJCXJldHVybiBtOwoJfQoJCglweXRob246OnJlZiB0ZXN0 X2NvbnN0KCkKCXsKCQlweXRob246Omxpc3QgbXlsaXN0OwoJCWZvcihpbnQgaSA9IDA7aSA8IDEw OysraSkKCQkJbXlsaXN0LmFwcGVuZChweXRob246Omxpc3QoKSk7CgkJCgkJY29uc3QgcHl0aG9u OjpzZXF1ZW5jZSBjc2VxKG15bGlzdCk7CgkJCgkJLy9jc2VxWzFdLmFwcGVuZCgyKTsgLy8gVGhp cyBzaG91bGQgbm90IGNvbXBpbGUhIChhbmQgZG9lc24ndCkKCQkKCQljb3V0IDw8IGNzZXFbMV0u c3RyKCk7CgkJCgkJcHl0aG9uOjpzZXF1ZW5jZTo6cHJveHkgc3AoY3NlcVszXSk7CgkJc3AgPSA5 OTsKCQkKCQlyZXR1cm4gY3NlcTsKCX0KCQoJcHl0aG9uOjpyZWYgdGVzdF9zZXFhc3NpZ24oKQoJ ewoJCXB5dGhvbjo6bGlzdCBteWxpc3Q7CgkJZm9yKGludCBpID0gMDtpIDwgMTA7KytpKQoJCQlt eWxpc3QuYXBwZW5kKHB5dGhvbjo6bGlzdCgpKTsKCQkKCQlweXRob246OnNlcXVlbmNlIHNlcSht eWxpc3QpOwoJCQoJCXNlcVsxXS5hcHBlbmQoMik7CgkJY291dCA8PCAibDEiOwoJCXNlcVsyXSA9 IDM7Ly9zZXFbMV07CgkJY291dCA8PCAibDIiOwoJCXNlcVszXSA9IHNlcVsxXTsKCQljb3V0IDw8 ICJsMyI7CgkJcHl0aG9uOjpzZXF1ZW5jZSBzZXEyID0gc2VxWzJdID0gNTsKCQljb3V0IDw8IHNl cTIuc3RyKCk7CgoJCXB5dGhvbjo6bGlzdCBteWxpc3QyOwoJCWZvcihpbnQgaSA9IDA7aSA8IDEw OysraSkKCQkJbXlsaXN0Mi5hcHBlbmQoaSk7CgkJCQoJCXB5dGhvbjo6b2JqZWN0IG9iaihteWxp c3QyKTsKCQlzZXFbN10gPSBvYmo7CgkJCgkJcmV0dXJuIHNlcTsKCX0KCQoJLypweXRob246OnJl ZiB0ZXN0X2NvcHkoKQoJewoJCQoJfSovCgkJCn0KCgoKQk9PU1RfUFlUSE9OX01PRFVMRV9JTklU KHQpCnsKCXRyeQoJewoJCXB5dGhvbjo6bW9kdWxlX2J1aWxkZXIgdGhpc19tb2R1bGUoInQiKTsK CQkvL3RoaXNfbW9kdWxlLmRlZihjcmVhdGVUTVAsImNyZWF0ZVRNUCIpOwoJCS8vdGhpc19tb2R1 bGUuZGVmKGNyZWF0ZUxpc3QsImNyZWF0ZUxpc3QiKTsKCQkvL3RoaXNfbW9kdWxlLmRlZihjcmVh dGVNYXAsImNyZWF0ZU1hcCIpOwoJCXRoaXNfbW9kdWxlLmRlZih0ZXN0X2xpc3QsInRlc3RfbGlz dCIpOwoJCXRoaXNfbW9kdWxlLmRlZih0ZXN0X21hcCwidGVzdF9tYXAiKTsKCQl0aGlzX21vZHVs ZS5kZWYodGVzdF9saXN0bWFwLCJ0ZXN0X2xpc3RtYXAiKTsKCQl0aGlzX21vZHVsZS5kZWYodGVz dF9jb25zdCwidGVzdF9jb25zdCIpOwoJCXRoaXNfbW9kdWxlLmRlZih0ZXN0X3NlcWFzc2lnbiwi dGVzdF9zZXFhc3NpZ24iKTsKCgl9CgljYXRjaCguLi4pCgl7CgkJLy9weXRob246OmhhbmRsZV9l eGNlcHRpb24oKTsgLy8gR2l2ZXMgY29tcGlsZSBlcnJvciAoPz8pCgl9Cn0K --0__=00256B270048BEB98f9e8a93df938690918c00256B270048BEB9--

1 0

Re: boost::python, returning new PyObject references
by David Abrahams Dec. 18, 2001

Dec. 18, 2001

----- Original Message ----- From: "Arnaldur Gylfason" <arnaldur(a)decode.is> > David > > Thanks. > I would very much like to discuss the design with you and contribute. I > took a look at objects.hpp and it was a good thing > you pointed it out to me. I had already started last night designing a few > things that are already there. > I am going to take a better look at it tonight and think about what I would > consider the best design for this hierarchy. > It is maybe a better idea to have object hold a ref instead of inheriting > from it. I suppose at least that it will be simpler. I think it would be a misuse of inheritance to do otherwise. > I'm going to think about it tonight though. > I'm also going to delve into the boost::python source to understand it all. Have fun! > Any hint about contents of each file would be greatly appreciated. > I have mainly looked at reference.hpp, conversion.hpp, callback.hpp (+ > objects.hpp now). > I have glimpsed through some of the other files but not really read them > and understood. There's a lot there and much of it is messy. I hope that we'll be cleaning all of this up and dividing it into smaller, more understandable/maintainable parcels over the next few months. > The hierarchy I had in mind is something like this: > > > -- object (PyObject_*) > | This inheritance must be private, or object must provide a restricted interface. > |-- mapping (PyMapping_*) > | | > | -- dictionary (PyDict_*) > | > |-- sequence (PySequence_*) > | | > | |-- list (PyList_*) > | | > | |-- string (PyString_*) > | | > | |-- tuple (PyTuple_*) > | | > | |-- unicode (PyUnicode_*) > | | > | -- array I think that under Python2.2, Dict is both a sequence and a mapping! The upshot is that either everything inherits virtually from object, or we remove object as a base class altogether. I'm inclined toward the former, but could go either way. > | > |-- number (PyNumber_*) > | | > | |-- int (PyInt_*) > | | > | |-- long (PyLong_*) > | | > | |-- float (PyFloat_*) > | | > | -- complex (PyComplex_*) > | > |-- buffer<T> (PyBuffer_*) > | > |-- file (PyFile_*) > | > -- module (PyModule_*) This looks really nice. > After taking a look at objects.hpp I'll sketch some of those > interfaces/classes (that are not already in objects.hpp) and send you. > The idea behind buffer<T> is to interprete the memory buffer as an array of > T. It would also compute it's begin and end in the constructor and > provide a begin() and end(). This would be helpful while working with > array. We could easily go back and forth between Python and C++ without > copying memory and > could use the STL algorithms and more. That's terriffic. The "iterators" used in some of the objects which return proxies should probably be rewritten in terms of iterator_adaptor. They could be conforming input iterators, at least (possibly also output iterators; I'm not sure yet -- for that we'd need a new iterator tag). > Another thing, I was thinking about providing an interface to some of these > Python classes that model some of the concepts in STL and thus provide > access to it. What do you have in mind? Could you be more specific? > Later, by inspecting the memory layout of some of the classes (or adding > new ones) we could have sequence and mapping objects in Python that have > efficient iterators in > C++ that work on the same memory layout. I don't get it yet; I'd love it if you'd say more. > In the end the idea is to be able to use python as the development > environment but get an efficient implementation almost for free using > boost::python and later additions. > (WeŽre talking about the future here of course). Sounds fascinating, but I need to get a clearer picture of your intention. Regards, Dave

1 0

[Boost.Python] News and Recent changes
by David Abrahams Dec. 14, 2001

Dec. 14, 2001

Firstly, I want to thank the three (yes, three!) developers who have appeared in the last week with important and well-written changes to contribute. I will mention them individually and describe their contributions below. Second, I am pleased to announce that a large chunk of work on Boost.Python is now being funded by the Lawrence Berkeley and Lawrence Livermore National Laboratories. The features they've requested will make a big difference for many other users of the library; I'll try to make a list available in the next few days. A big thank-you goes out to the national labs for making this possible! I have just integrated Scott Snyder's first round of patches which provide support for inplace operators on Boost.Python extension classes (thanks, Scott!). Scott also has patches which implement wrapping of static data members (http://groups.yahoo.com/group/boost/message/21033), and nested classes (http://groups.yahoo.com/group/boost/message/21035). I expect these additional features will be ready to be checked in soon. I have added some changes to support building under Python 2.2 with CodeWarrior Pro7 and Borland (though Borland's template implementation is pretty broken and doesn't actually work yet). The generalized Jam code for building and testing Python modules has been moved out of the Boost.Python Jamfile and into python.jam in <boost-root>/tools/build/test. I updated the comprehensive test for compatibility with Python 2.2 - it was reporting some errors because Python 2.2 gives much richer results from the built-in dir() function. Arnaldur Gylfason is working on some wrappers that will improve manipulation of Python objects from C++. He is planning support for generalized objects, which have all of the potentially-available Python operations defined, as well as some more restricted interfaces corresponding to Python "Concepts" such as Sequence. Having these will be a big improvement. Andreas Zieringer has moved nearly all of the Boost.Python static library into a shared library, an important contribution which should have been made long ago. This will help enormously in reducing the size of extension modules. It is also a critical element in enabling cross-module inheritance support. Some fairly radical changes were made to gen_function.py in order to help me generate the family of template functions for caller<> and callback<> with the upcoming type conversion system. ----- New Codebase Development ----- Speaking of which, I am ready to show the infrastructure of the new type conversion system. There are several reasons for this transition: 1. It's needed to support better cross-module interaction, including inheritance. 2. The current system (embarrassingly) relies on a common bug in C++ compilers, and more conformant compilers are now coming out which reject the code 3. It will be easier to use. I'm going to check something in to CVS tomorrow (Friday) on a branch. I could use some help with the names, so if you have a moment please take a look and see if you have any suggestions. I'll let you know when, and how. I have looked for a way to quickly shoehorn this new system into the existing codebase without success. The conversion of types between C++ and Python is fundamental to Boost.Python and is woven into many aspects of the library. Before you panic, I am NOT planning on throwing out the existing codebase or most of your recent contributions; on the contrary, most of it will remain. However, it makes more sense to me that we move pieces over to sit on the new substrate, so we don't have to break the existing system and then fix it. One element that I'm not sure we'll want to keep is (believe it or not) the existing class/metaclass system. Python 2.2, to be released soon, provides the code neccessary to replace most of that implementation with code that's already in Python. I'm fairly sure that most, if not all, of the programmer interface to exposing classes can remain as is. I'm going to try to build a simple class wrapping system on top of the Python 2.2 facilities starting tomorrow. Of course, removing the existing class/metaclass system will break compatibility with earlier versions of Python. So far, I'm not too worried about that. Python upgrades are easy to install, and the Python folks have been pretty good about ensuring that forward transitions aren't too rough. Also, the existing Boost.Python codebase will still be available to those who insist on living in the past ;-). Whether or not we keep another mechanism available in order to preserve 1.5.2->2.1 compatibility is really up to you, however. If there is sufficient demand, we'll keep it for a while... probably because one of you will keep it alive ;-). Remember, though, that the extension class mechanism contributes a /significant/ amount of code to the library, and I'm not sure it makes sense to maintain it. Also, keeping the behavior identical to what we get with the Python 2.2 system may be challenging. Your feedback on this decision, as well as any others, is most welcome. =================================================== David Abrahams, C++ library designer for hire resume: http://users.rcn.com/abrahams/resume.html C++ Booster (http://www.boost.org) email: david.abrahams(a)rcn.com ===================================================

1 0