37440 2010-04-12 00:29:12 -0700 [WINCE] Port tiled backing store 2023-01-22 14:45:19 -0800 1 1 1 Unclassified WebKit Platform 528+ (Nightly build) Other Other RESOLVED INVALID P2 Normal --- 28272 0 skyul webkit-unassigned ahmad.saleem792 ap bunhere eric hausmann joybro201 kenneth koivisto zherczeg oldest_to_newest 211563 0 skyul 2010-04-12 00:29:12 -0700 Port tiled backing store to WinCE with SharedBitmap. 211564 1 53156 skyul 2010-04-12 00:32:41 -0700 Created attachment 53156 Patch This patch depends on SharedBitmap which is not yet upstreamed. I will submit a patch for SharedBitmap soon. 211872 2 zherczeg 2010-04-12 23:34:08 -0700 (In reply to comment #1) > Created an attachment (id=53156) [details] > Patch > > This patch depends on SharedBitmap which is not yet upstreamed. I will submit a > patch for SharedBitmap soon. Hm, looking at the Qt implementation, the target of paintCheckerPattern is not necessary checkerSize aligned, and might be scaled as well. Otherwise this patch seems ok. 212210 3 skyul 2010-04-13 21:34:29 -0700 I updated the SharedBitmap patch in bug 28272 as this patch depends on SharedBitmap. 212730 4 skyul 2010-04-14 21:01:34 -0700 (In reply to comment #2) > Hm, looking at the Qt implementation, the target of paintCheckerPattern is not > necessary checkerSize aligned, and might be scaled as well. Otherwise this > patch seems ok. You are right. I will fix it. 223081 5 eric 2010-05-09 14:23:35 -0700 What does Tile do? What ports use it? I'm still not sure why recent ports have had to add so many image-related classes. 223104 6 kenneth 2010-05-09 16:29:23 -0700 (In reply to comment #5) > What does Tile do? What ports use it? I'm still not sure why recent ports have had to add so many image-related classes. Qt uses it, it is a tiled backing store that we are painting to, similar to what coregraphics does for the iphone port. So in that way it is not really related to images, but to painting. 225375 7 53156 aroben 2010-05-13 10:46:18 -0700 Comment on attachment 53156 Patch > + * platform/graphics/wince/TileWince.cpp: Added. This file should be named TileWinCE.cpp (see bug 37287). > + (WebCore::checkeredBitmap): > + (WebCore::Tile::Tile): > + (WebCore::Tile::~Tile): > + (WebCore::Tile::isDirty): > + (WebCore::Tile::isReadyToPaint): > + (WebCore::Tile::invalidate): > + (WebCore::enclosingRect): > + (WebCore::getUpdateRects): > + (WebCore::Tile::updateBackBuffer): > + (WebCore::Tile::swapBackBufferToFront): > + (WebCore::Tile::paint): > + (WebCore::Tile::paintCheckerPattern): Function-level comments are helpful to anyone trying to understand the patch. That includes reviewers and people in the future who are trying to figure out what the point of this patch was (if, e.g., it caused a regression or contained a bug). It's especially good if the comments explain the "why" of the patch, not just the "how". > +static PassRefPtr<SharedBitmap> checkeredBitmap() > +{ > + static RefPtr<SharedBitmap> bitmap; > + if (!bitmap) { > + bitmap = SharedBitmap::createInstance(true, checkerSize, checkerSize, false); > + unsigned key1, key2; > + HDC dc = bitmap->getDC(&key1, &key2); > + GraphicsContext context(dc); > + > + Color color1(checkerColor1); > + Color color2(checkerColor2); > + for (unsigned y = 0; y < checkerSize; y += checkerSize / 2) { > + bool alternate = y % checkerSize; > + for (unsigned x = 0; x < checkerSize; x += checkerSize / 2) { > + context.fillRect(FloatRect(x, y, checkerSize / 2, checkerSize / 2), > + alternate ? color1 : color2, DeviceColorSpace); > + alternate = !alternate; > + } > + } > + > + bitmap->releaseDC(dc, key1, key2); > + } > + return bitmap.release(); > +} It looks like this function is trying to create the bitmap just once and then return that single cached instance. But that's not the behavior it will have. RefPtr::release nulls out the RefPtr, so if (!bitmap) will always be true. I think instead you should change this function to return a bare pointer. It's a also slightly nicer style to have two separate functions: a "create" function that always allocates a new bitmap, and a getter that returns a single cached instance. Like this: static PassRefPtr<SharedBitmap> createCheckeredBitmap() { RefPtr<SharedBitmap> bitmap = SharedBitmap::createInstance(...); // Draw the checker pattern return bitmap.release(); } static SharedBitmap* checkeredBitmap() { static SharedBitmap* bitmap = createCheckeredBitmap().releaseRef(); return bitmap; } > +Tile::Tile(TiledBackingStore* backingStore, const Coordinate& tileCoordinate) > + : m_backingStore(backingStore) > + , m_coordinate(tileCoordinate) > + , m_rect(m_backingStore->tileRectForCoordinate(tileCoordinate)) > + , m_buffer(0) > + , m_backBuffer(0) No need to initialize m_buffer or m_backBuffer here. RefPtr does this for you automatically. > +static IntRect enclosingRect(HRGN hrgn) > +{ > + RECT r; > + GetRgnBox(hrgn, &r); > + return r; > +} > + This function is only called once. I'm not sure it's worth having a separate function for this. > +static void getUpdateRects(HRGN region, Vector<IntRect>& rects) > +{ > + const int rectThreshold = 10; > + const float wastedSpaceThreshold = 0.75f; > + > + IntRect dirtyRect(enclosingRect(region)); > + > + DWORD regionDataSize = GetRegionData(region, sizeof(RGNDATA), 0); > + if (!regionDataSize) { > + rects.append(dirtyRect); > + return; > + } > + > + Vector<unsigned char> buffer(regionDataSize); > + RGNDATA* regionData = reinterpret_cast<RGNDATA*>(buffer.data()); > + GetRegionData(region, regionDataSize, regionData); > + if (regionData->rdh.nCount > rectThreshold) { > + rects.append(dirtyRect); > + return; > + } > + > + double singlePixels = 0.0; > + unsigned i; > + RECT* rect; > + for (i = 0, rect = reinterpret_cast<RECT*>(regionData->Buffer); i < regionData->rdh.nCount; i++, rect++) > + singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top); > + > + double unionPixels = dirtyRect.width() * dirtyRect.height(); > + double wastedSpace = 1.0 - (singlePixels / unionPixels); > + if (wastedSpace <= wastedSpaceThreshold) { > + rects.append(dirtyRect); > + return; > + } > + > + for (i = 0, rect = reinterpret_cast<RECT*>(regionData->Buffer); i < regionData->rdh.nCount; i++, rect++) > + rects.append(*rect); > +} This looks to be a copy of the function of the same name in WebKit/win/WebView.cpp. Can we share the code instead of duplicating it? > +void Tile::updateBackBuffer() > +{ > + if (m_buffer && !isDirty()) > + return; > + > + if (!m_backBuffer) { > + if (!m_buffer) > + m_backBuffer = SharedBitmap::createInstance( > + true, m_backingStore->m_tileSize.width(), m_backingStore->m_tileSize.height(), false); We normally would just put this all on one line. I think you should do that here. It would be nice if there were an overload of SharedBitmap::createInstance that took a const IntSize&. It would also be nice if it used enums instead of booleans, as I have no idea what "true" and "false" mean here. > + else { > + // Currently all buffers are updated synchronously at the same time so there is no real need > + // to have separate back and front buffers. Just use the existing buffer. If there's no need for two buffers, why do we have them? > + m_backBuffer = m_buffer; > + m_buffer = 0; You can do this more efficiently like this: m_backBuffer = m_buffer.release(); > + HRGN nullRegion = CreateRectRgn(0, 0, 0, 0); > + m_dirtyRegion.set(nullRegion); No need for the local nullRegion variable. > + int size = dirtyRects.size(); > + for (int n = 0; n < size; ++n) { It's a little better to use size_t instead of int when iterating over a Vector. > +void Tile::swapBackBufferToFront() > +{ > + if (!m_backBuffer) > + return; > + m_buffer = m_backBuffer; > + m_backBuffer = 0; > +} You can do this more efficiently like this: m_buffer = m_backBuffer.release(); > +void Tile::paint(GraphicsContext* context, const IntRect& rect) > +{ > + if (!m_buffer) > + return; > + > + IntRect target = intersection(rect, m_rect); > + IntRect source((target.x() - m_rect.x()), > + (target.y() - m_rect.y()), No need for the parentheses around these expressions. I'm also not sure all the newlines are making this more readable. > +void Tile::paintCheckerPattern(GraphicsContext* context, const FloatRect& target) > +{ > + FloatRect tileRectIn(0, 0, checkerSize, checkerSize); > + context->drawBitmapPattern(checkeredBitmap().get(), > + tileRectIn, > + AffineTransform(), > + FloatPoint(0, 0), You can just say FloatPoint() > + CompositeCopy, > + target, > + IntSize(checkerSize, checkerSize)); Is there no way to get the size from checkeredBitmap? It seems unfortunate to have to use the constants again here. Again, I don't think all the newlines are helping here. 228261 8 joybro201 2010-05-20 01:21:07 -0700 (In reply to comment #2) > (In reply to comment #1) > > Created an attachment (id=53156) [details] [details] > > Patch > > > > This patch depends on SharedBitmap which is not yet upstreamed. I will submit a > > patch for SharedBitmap soon. > > Hm, looking at the Qt implementation, the target of paintCheckerPattern is not necessary checkerSize aligned, and might be scaled as well. Otherwise this patch seems ok. The target doesn't be scaled and the checker is always displayed in same size. 228270 9 joybro201 2010-05-20 01:27:12 -0700 (In reply to comment #7) > (From update of attachment 53156 [details]) > > + * platform/graphics/wince/TileWince.cpp: Added. > > This file should be named TileWinCE.cpp (see bug 37287). > > > + (WebCore::checkeredBitmap): > > + (WebCore::Tile::Tile): > > + (WebCore::Tile::~Tile): > > + (WebCore::Tile::isDirty): > > + (WebCore::Tile::isReadyToPaint): > > + (WebCore::Tile::invalidate): > > + (WebCore::enclosingRect): > > + (WebCore::getUpdateRects): > > + (WebCore::Tile::updateBackBuffer): > > + (WebCore::Tile::swapBackBufferToFront): > > + (WebCore::Tile::paint): > > + (WebCore::Tile::paintCheckerPattern): > > Function-level comments are helpful to anyone trying to understand the patch. That includes reviewers and people in the future who are trying to figure out what the point of this patch was (if, e.g., it caused a regression or contained a bug). It's especially good if the comments explain the "why" of the patch, not just the "how". > > > +static PassRefPtr<SharedBitmap> checkeredBitmap() > > +{ > > + static RefPtr<SharedBitmap> bitmap; > > + if (!bitmap) { > > + bitmap = SharedBitmap::createInstance(true, checkerSize, checkerSize, false); > > + unsigned key1, key2; > > + HDC dc = bitmap->getDC(&key1, &key2); > > + GraphicsContext context(dc); > > + > > + Color color1(checkerColor1); > > + Color color2(checkerColor2); > > + for (unsigned y = 0; y < checkerSize; y += checkerSize / 2) { > > + bool alternate = y % checkerSize; > > + for (unsigned x = 0; x < checkerSize; x += checkerSize / 2) { > > + context.fillRect(FloatRect(x, y, checkerSize / 2, checkerSize / 2), > > + alternate ? color1 : color2, DeviceColorSpace); > > + alternate = !alternate; > > + } > > + } > > + > > + bitmap->releaseDC(dc, key1, key2); > > + } > > + return bitmap.release(); > > +} > > It looks like this function is trying to create the bitmap just once and then return that single cached instance. But that's not the behavior it will have. RefPtr::release nulls out the RefPtr, so if (!bitmap) will always be true. > > I think instead you should change this function to return a bare pointer. It's a also slightly nicer style to have two separate functions: a "create" function that always allocates a new bitmap, and a getter that returns a single cached instance. Like this: > > static PassRefPtr<SharedBitmap> createCheckeredBitmap() > { > RefPtr<SharedBitmap> bitmap = SharedBitmap::createInstance(...); > // Draw the checker pattern > return bitmap.release(); > } > > static SharedBitmap* checkeredBitmap() > { > static SharedBitmap* bitmap = createCheckeredBitmap().releaseRef(); > return bitmap; > } > > > +Tile::Tile(TiledBackingStore* backingStore, const Coordinate& tileCoordinate) > > + : m_backingStore(backingStore) > > + , m_coordinate(tileCoordinate) > > + , m_rect(m_backingStore->tileRectForCoordinate(tileCoordinate)) > > + , m_buffer(0) > > + , m_backBuffer(0) > > No need to initialize m_buffer or m_backBuffer here. RefPtr does this for you automatically. > > > +static IntRect enclosingRect(HRGN hrgn) > > +{ > > + RECT r; > > + GetRgnBox(hrgn, &r); > > + return r; > > +} > > + > > This function is only called once. I'm not sure it's worth having a separate function for this. > > > +static void getUpdateRects(HRGN region, Vector<IntRect>& rects) > > +{ > > + const int rectThreshold = 10; > > + const float wastedSpaceThreshold = 0.75f; > > + > > + IntRect dirtyRect(enclosingRect(region)); > > + > > + DWORD regionDataSize = GetRegionData(region, sizeof(RGNDATA), 0); > > + if (!regionDataSize) { > > + rects.append(dirtyRect); > > + return; > > + } > > + > > + Vector<unsigned char> buffer(regionDataSize); > > + RGNDATA* regionData = reinterpret_cast<RGNDATA*>(buffer.data()); > > + GetRegionData(region, regionDataSize, regionData); > > + if (regionData->rdh.nCount > rectThreshold) { > > + rects.append(dirtyRect); > > + return; > > + } > > + > > + double singlePixels = 0.0; > > + unsigned i; > > + RECT* rect; > > + for (i = 0, rect = reinterpret_cast<RECT*>(regionData->Buffer); i < regionData->rdh.nCount; i++, rect++) > > + singlePixels += (rect->right - rect->left) * (rect->bottom - rect->top); > > + > > + double unionPixels = dirtyRect.width() * dirtyRect.height(); > > + double wastedSpace = 1.0 - (singlePixels / unionPixels); > > + if (wastedSpace <= wastedSpaceThreshold) { > > + rects.append(dirtyRect); > > + return; > > + } > > + > > + for (i = 0, rect = reinterpret_cast<RECT*>(regionData->Buffer); i < regionData->rdh.nCount; i++, rect++) > > + rects.append(*rect); > > +} > > This looks to be a copy of the function of the same name in WebKit/win/WebView.cpp. Can we share the code instead of duplicating it? > > > +void Tile::updateBackBuffer() > > +{ > > + if (m_buffer && !isDirty()) > > + return; > > + > > + if (!m_backBuffer) { > > + if (!m_buffer) > > + m_backBuffer = SharedBitmap::createInstance( > > + true, m_backingStore->m_tileSize.width(), m_backingStore->m_tileSize.height(), false); > > We normally would just put this all on one line. I think you should do that here. > > It would be nice if there were an overload of SharedBitmap::createInstance that took a const IntSize&. It would also be nice if it used enums instead of booleans, as I have no idea what "true" and "false" mean here. > > > + else { > > + // Currently all buffers are updated synchronously at the same time so there is no real need > > + // to have separate back and front buffers. Just use the existing buffer. > > If there's no need for two buffers, why do we have them? > > > + m_backBuffer = m_buffer; > > + m_buffer = 0; > > You can do this more efficiently like this: > > m_backBuffer = m_buffer.release(); > > > + HRGN nullRegion = CreateRectRgn(0, 0, 0, 0); > > + m_dirtyRegion.set(nullRegion); > > No need for the local nullRegion variable. > > > + int size = dirtyRects.size(); > > + for (int n = 0; n < size; ++n) { > > It's a little better to use size_t instead of int when iterating over a Vector. > > > +void Tile::swapBackBufferToFront() > > +{ > > + if (!m_backBuffer) > > + return; > > + m_buffer = m_backBuffer; > > + m_backBuffer = 0; > > +} > > You can do this more efficiently like this: > > m_buffer = m_backBuffer.release(); > > > +void Tile::paint(GraphicsContext* context, const IntRect& rect) > > +{ > > + if (!m_buffer) > > + return; > > + > > + IntRect target = intersection(rect, m_rect); > > + IntRect source((target.x() - m_rect.x()), > > + (target.y() - m_rect.y()), > > No need for the parentheses around these expressions. I'm also not sure all the newlines are making this more readable. > > > +void Tile::paintCheckerPattern(GraphicsContext* context, const FloatRect& target) > > +{ > > + FloatRect tileRectIn(0, 0, checkerSize, checkerSize); > > + context->drawBitmapPattern(checkeredBitmap().get(), > > + tileRectIn, > > + AffineTransform(), > > + FloatPoint(0, 0), > > You can just say FloatPoint() > > > + CompositeCopy, > > + target, > > + IntSize(checkerSize, checkerSize)); > > Is there no way to get the size from checkeredBitmap? It seems unfortunate to have to use the constants again here. > > Again, I don't think all the newlines are helping here. I accepted all your points except a few works seems like overwork. We could consider it later. 228271 10 56574 joybro201 2010-05-20 01:28:38 -0700 Created attachment 56574 patch 228274 11 56574 joybro201 2010-05-20 01:48:12 -0700 Comment on attachment 56574 patch There were some mistakes. sorry. 228809 12 56686 joybro201 2010-05-21 02:20:28 -0700 Created attachment 56686 new patch Here is the patch I intended to attach, sorry for the confusion. 260176 13 56686 hausmann 2010-08-04 13:10:52 -0700 Comment on attachment 56686 new patch WebCore/platform/graphics/wince/TileWinCE.cpp:117 + static void getUpdateRects(HRGN region, Vector<IntRect>& rects) Before this function you define the convenient enclosingRect() helper function, and a few lines into this function you call GetRgnBox instead of the newly defined helper functions. I suggest to make use of it :) The rest of the patch looks okay to me, although I pity you guys for having to use HRGN :) 264689 14 56686 kenneth 2010-08-14 08:19:43 -0700 Comment on attachment 56686 new patch r- due to Simon Hausmann's comment. 1927329 15 ahmad.saleem792 2023-01-22 14:16:56 -0800 @ap - WINCE port exist? I don't think so.. Can we close this? 53156 2010-04-12 00:32:41 -0700 2010-08-12 07:13:55 -0700 Patch tile.patch text/plain 9694 skyul SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1NzQ2OSkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDQtMTIgIEt3YW5nIFl1bCBTZW8gIDxza3l1bEBjb21wYW55 MTAwLm5ldD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBbV0lOQ0VdIFBvcnQgdGlsZWQgYmFja2luZyBzdG9yZQorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Mzc0NDAKKworICAgICAgICBQb3J0IHRpbGVkIGJh Y2tpbmcgc3RvcmUgdG8gV2luQ0Ugd2l0aCBTaGFyZWRCaXRtYXAuCisKKyAgICAgICAgKiBwbGF0 Zm9ybS9ncmFwaGljcy9UaWxlLmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2Uv VGlsZVdpbmNlLmNwcDogQWRkZWQuCisgICAgICAgIChXZWJDb3JlOjpjaGVja2VyZWRCaXRtYXAp OgorICAgICAgICAoV2ViQ29yZTo6VGlsZTo6VGlsZSk6CisgICAgICAgIChXZWJDb3JlOjpUaWxl Ojp+VGlsZSk6CisgICAgICAgIChXZWJDb3JlOjpUaWxlOjppc0RpcnR5KToKKyAgICAgICAgKFdl YkNvcmU6OlRpbGU6OmlzUmVhZHlUb1BhaW50KToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGU6Omlu dmFsaWRhdGUpOgorICAgICAgICAoV2ViQ29yZTo6ZW5jbG9zaW5nUmVjdCk6CisgICAgICAgIChX ZWJDb3JlOjpnZXRVcGRhdGVSZWN0cyk6CisgICAgICAgIChXZWJDb3JlOjpUaWxlOjp1cGRhdGVC YWNrQnVmZmVyKToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGU6OnN3YXBCYWNrQnVmZmVyVG9Gcm9u dCk6CisgICAgICAgIChXZWJDb3JlOjpUaWxlOjpwYWludCk6CisgICAgICAgIChXZWJDb3JlOjpU aWxlOjpwYWludENoZWNrZXJQYXR0ZXJuKToKKwogMjAxMC0wNC0xMSAgU2hlcmlmZiBCb3QgIDx3 ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGlu ZyBvdXQgcjU3NDY4LgpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgKPT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgJKHJldmlzaW9uIDU3 NDY5KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9UaWxlLmgJKHdvcmtpbmcgY29weSkK QEAgLTEsNSArMSw2IEBACiAvKgogIENvcHlyaWdodCAoQykgMjAxMCBOb2tpYSBDb3Jwb3JhdGlv biBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyBDb3B5cmlnaHQgKEMpIDIwMTAgQ29tcGFu eSAxMDAsIEluYy4KICAKICBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiBy ZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgbW9kaWZ5IGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUg R05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTMzLDYgKzM0LDEwIEBAIGNsYXNzIFFQaXht YXA7CiBjbGFzcyBRUmVnaW9uOwogI2VuZGlmCiAKKyNpZiBQTEFURk9STShXSU5DRSkKKyNpbmNs dWRlICJTaGFyZWRCaXRtYXAuaCIKKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAgICAg CiBjbGFzcyBHcmFwaGljc0NvbnRleHQ7CkBAIC02OSw2ICs3NCwxMiBAQCBwcml2YXRlOgogICAg IFFQaXhtYXAqIG1fYmFja0J1ZmZlcjsKICAgICBRUmVnaW9uKiBtX2RpcnR5UmVnaW9uOwogI2Vu ZGlmCisKKyNpZiBQTEFURk9STShXSU5DRSkKKyAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBtX2J1 ZmZlcjsKKyAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBtX2JhY2tCdWZmZXI7CisgICAgT3duUHRy PEhSR04+IG1fZGlydHlSZWdpb247CisjZW5kaWYKIH07CiAKIH0KSW5kZXg6IFdlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3Mvd2luY2UvVGlsZVdpbmNlLmNwcAo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL1RpbGVXaW5jZS5jcHAJKHJldmlzaW9uIDApCisrKyBX ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL1RpbGVXaW5jZS5jcHAJKHJldmlzaW9uIDAp CkBAIC0wLDAgKzEsMjI5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEwIENvbXBhbnkgMTAw LCBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBDT01QVVRFUiwgSU5DLiBgYEFTIElTJycgQU5EIEFOWQor ICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1J VEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5E IEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElO IE5PIEVWRU5UIFNIQUxMIEFQUExFIENPTVBVVEVSLCBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK KyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgor I2luY2x1ZGUgIlRpbGUuaCIKKworI2lmIEVOQUJMRShUSUxFRF9CQUNLSU5HX1NUT1JFKQorCisj aW5jbHVkZSAiQWZmaW5lVHJhbnNmb3JtLmgiCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0Lmgi CisjaW5jbHVkZSAiVGlsZWRCYWNraW5nU3RvcmUuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdT dG9yZUNsaWVudC5oIgorCisjaW5jbHVkZSA8d2luZG93cy5oPgorI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KKworbmFtZXNwYWNlIFdlYkNvcmUgeworCitzdGF0aWMgY29uc3QgdW5zaWduZWQgY2hl Y2tlclNpemUgPSAzMjsKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBjaGVja2VyQ29sb3IxID0gMHhm ZmZmZmZmZjsKK3N0YXRpYyBjb25zdCB1bnNpZ25lZCBjaGVja2VyQ29sb3IyID0gMHhmZmNjY2Nj YzsKKworc3RhdGljIFBhc3NSZWZQdHI8U2hhcmVkQml0bWFwPiBjaGVja2VyZWRCaXRtYXAoKQor eworICAgIHN0YXRpYyBSZWZQdHI8U2hhcmVkQml0bWFwPiBiaXRtYXA7CisgICAgaWYgKCFiaXRt YXApIHsKKyAgICAgICAgYml0bWFwID0gU2hhcmVkQml0bWFwOjpjcmVhdGVJbnN0YW5jZSh0cnVl LCBjaGVja2VyU2l6ZSwgY2hlY2tlclNpemUsIGZhbHNlKTsKKyAgICAgICAgdW5zaWduZWQga2V5 MSwga2V5MjsKKyAgICAgICAgSERDIGRjID0gYml0bWFwLT5nZXREQygma2V5MSwgJmtleTIpOwor ICAgICAgICBHcmFwaGljc0NvbnRleHQgY29udGV4dChkYyk7CisKKyAgICAgICAgQ29sb3IgY29s b3IxKGNoZWNrZXJDb2xvcjEpOworICAgICAgICBDb2xvciBjb2xvcjIoY2hlY2tlckNvbG9yMik7 CisgICAgICAgIGZvciAodW5zaWduZWQgeSA9IDA7IHkgPCBjaGVja2VyU2l6ZTsgeSArPSBjaGVj a2VyU2l6ZSAvIDIpIHsKKyAgICAgICAgICAgIGJvb2wgYWx0ZXJuYXRlID0geSAlIGNoZWNrZXJT aXplOworICAgICAgICAgICAgZm9yICh1bnNpZ25lZCB4ID0gMDsgeCA8IGNoZWNrZXJTaXplOyB4 ICs9IGNoZWNrZXJTaXplIC8gMikgeworICAgICAgICAgICAgICAgIGNvbnRleHQuZmlsbFJlY3Qo RmxvYXRSZWN0KHgsIHksIGNoZWNrZXJTaXplIC8gMiwgY2hlY2tlclNpemUgLyAyKSwKKyAgICAg ICAgICAgICAgICAgICAgYWx0ZXJuYXRlID8gY29sb3IxIDogY29sb3IyLCBEZXZpY2VDb2xvclNw YWNlKTsKKyAgICAgICAgICAgICAgICBhbHRlcm5hdGUgPSAhYWx0ZXJuYXRlOworICAgICAgICAg ICAgfQorICAgICAgICB9CisKKyAgICAgICAgYml0bWFwLT5yZWxlYXNlREMoZGMsIGtleTEsIGtl eTIpOworICAgIH0KKyAgICByZXR1cm4gYml0bWFwLnJlbGVhc2UoKTsKK30KKworVGlsZTo6VGls ZShUaWxlZEJhY2tpbmdTdG9yZSogYmFja2luZ1N0b3JlLCBjb25zdCBDb29yZGluYXRlJiB0aWxl Q29vcmRpbmF0ZSkKKyAgICA6IG1fYmFja2luZ1N0b3JlKGJhY2tpbmdTdG9yZSkKKyAgICAsIG1f Y29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkKKyAgICAsIG1fcmVjdChtX2JhY2tpbmdTdG9yZS0+ dGlsZVJlY3RGb3JDb29yZGluYXRlKHRpbGVDb29yZGluYXRlKSkKKyAgICAsIG1fYnVmZmVyKDAp CisgICAgLCBtX2JhY2tCdWZmZXIoMCkKK3sKKyAgICBSRUNUIHIgPSBtX3JlY3Q7CisgICAgbV9k aXJ0eVJlZ2lvbi5zZXQoQ3JlYXRlUmVjdFJnbkluZGlyZWN0KCZyKSk7Cit9CisKK1RpbGU6On5U aWxlKCkKK3sKK30KKworYm9vbCBUaWxlOjppc0RpcnR5KCkgY29uc3QKK3sKKyAgICBSRUNUIHI7 CisgICAgcmV0dXJuIEdldFJnbkJveChtX2RpcnR5UmVnaW9uLmdldCgpLCAmcikgIT0gTlVMTFJF R0lPTjsKK30KKworYm9vbCBUaWxlOjppc1JlYWR5VG9QYWludCgpIGNvbnN0Cit7CisgICAgcmV0 dXJuIG1fYnVmZmVyOworfQorCit2b2lkIFRpbGU6OmludmFsaWRhdGUoY29uc3QgSW50UmVjdCYg ZGlydHlSZWN0KQoreworICAgIEludFJlY3QgdGlsZURpcnR5UmVjdCA9IGludGVyc2VjdGlvbihk aXJ0eVJlY3QsIG1fcmVjdCk7CisgICAgaWYgKHRpbGVEaXJ0eVJlY3QuaXNFbXB0eSgpKQorICAg ICAgICByZXR1cm47CisKKyAgICBSRUNUIHIgPSB0aWxlRGlydHlSZWN0OworICAgIE93blB0cjxI UkdOPiB0aWxlRGlydHlSZWdpb24oQ3JlYXRlUmVjdFJnbkluZGlyZWN0KCZyKSk7CisgICAgQ29t YmluZVJnbihtX2RpcnR5UmVnaW9uLmdldCgpLCBtX2RpcnR5UmVnaW9uLmdldCgpLCB0aWxlRGly dHlSZWdpb24uZ2V0KCksIFJHTl9PUik7Cit9CisKK3N0YXRpYyBJbnRSZWN0IGVuY2xvc2luZ1Jl Y3QoSFJHTiBocmduKQoreworICAgIFJFQ1QgcjsKKyAgICBHZXRSZ25Cb3goaHJnbiwgJnIpOwor ICAgIHJldHVybiByOworfQorCitzdGF0aWMgdm9pZCBnZXRVcGRhdGVSZWN0cyhIUkdOIHJlZ2lv biwgVmVjdG9yPEludFJlY3Q+JiByZWN0cykKK3sKKyAgICBjb25zdCBpbnQgcmVjdFRocmVzaG9s ZCA9IDEwOworICAgIGNvbnN0IGZsb2F0IHdhc3RlZFNwYWNlVGhyZXNob2xkID0gMC43NWY7CisK KyAgICBJbnRSZWN0IGRpcnR5UmVjdChlbmNsb3NpbmdSZWN0KHJlZ2lvbikpOworCisgICAgRFdP UkQgcmVnaW9uRGF0YVNpemUgPSBHZXRSZWdpb25EYXRhKHJlZ2lvbiwgc2l6ZW9mKFJHTkRBVEEp LCAwKTsKKyAgICBpZiAoIXJlZ2lvbkRhdGFTaXplKSB7CisgICAgICAgIHJlY3RzLmFwcGVuZChk aXJ0eVJlY3QpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgVmVjdG9yPHVuc2lnbmVk IGNoYXI+IGJ1ZmZlcihyZWdpb25EYXRhU2l6ZSk7CisgICAgUkdOREFUQSogcmVnaW9uRGF0YSA9 IHJlaW50ZXJwcmV0X2Nhc3Q8UkdOREFUQSo+KGJ1ZmZlci5kYXRhKCkpOworICAgIEdldFJlZ2lv bkRhdGEocmVnaW9uLCByZWdpb25EYXRhU2l6ZSwgcmVnaW9uRGF0YSk7CisgICAgaWYgKHJlZ2lv bkRhdGEtPnJkaC5uQ291bnQgPiByZWN0VGhyZXNob2xkKSB7CisgICAgICAgIHJlY3RzLmFwcGVu ZChkaXJ0eVJlY3QpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgZG91YmxlIHNpbmds ZVBpeGVscyA9IDAuMDsKKyAgICB1bnNpZ25lZCBpOworICAgIFJFQ1QqIHJlY3Q7CisgICAgZm9y IChpID0gMCwgcmVjdCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UkVDVCo+KHJlZ2lvbkRhdGEtPkJ1ZmZl cik7IGkgPCByZWdpb25EYXRhLT5yZGgubkNvdW50OyBpKyssIHJlY3QrKykKKyAgICAgICAgc2lu Z2xlUGl4ZWxzICs9IChyZWN0LT5yaWdodCAtIHJlY3QtPmxlZnQpICogKHJlY3QtPmJvdHRvbSAt IHJlY3QtPnRvcCk7CisKKyAgICBkb3VibGUgdW5pb25QaXhlbHMgPSBkaXJ0eVJlY3Qud2lkdGgo KSAqIGRpcnR5UmVjdC5oZWlnaHQoKTsKKyAgICBkb3VibGUgd2FzdGVkU3BhY2UgPSAxLjAgLSAo c2luZ2xlUGl4ZWxzIC8gdW5pb25QaXhlbHMpOworICAgIGlmICh3YXN0ZWRTcGFjZSA8PSB3YXN0 ZWRTcGFjZVRocmVzaG9sZCkgeworICAgICAgICByZWN0cy5hcHBlbmQoZGlydHlSZWN0KTsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGZvciAoaSA9IDAsIHJlY3QgPSByZWludGVycHJl dF9jYXN0PFJFQ1QqPihyZWdpb25EYXRhLT5CdWZmZXIpOyBpIDwgcmVnaW9uRGF0YS0+cmRoLm5D b3VudDsgaSsrLCByZWN0KyspCisgICAgICAgIHJlY3RzLmFwcGVuZCgqcmVjdCk7Cit9CisKK3Zv aWQgVGlsZTo6dXBkYXRlQmFja0J1ZmZlcigpCit7CisgICAgaWYgKG1fYnVmZmVyICYmICFpc0Rp cnR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9iYWNrQnVmZmVyKSB7CisgICAg ICAgIGlmICghbV9idWZmZXIpCisgICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBTaGFyZWRCaXRt YXA6OmNyZWF0ZUluc3RhbmNlKAorICAgICAgICAgICAgICAgICAgICB0cnVlLCBtX2JhY2tpbmdT dG9yZS0+bV90aWxlU2l6ZS53aWR0aCgpLCBtX2JhY2tpbmdTdG9yZS0+bV90aWxlU2l6ZS5oZWln aHQoKSwgZmFsc2UpOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIC8vIEN1cnJlbnRseSBh bGwgYnVmZmVycyBhcmUgdXBkYXRlZCBzeW5jaHJvbm91c2x5IGF0IHRoZSBzYW1lIHRpbWUgc28g dGhlcmUgaXMgbm8gcmVhbCBuZWVkCisgICAgICAgICAgICAvLyB0byBoYXZlIHNlcGFyYXRlIGJh Y2sgYW5kIGZyb250IGJ1ZmZlcnMuIEp1c3QgdXNlIHRoZSBleGlzdGluZyBidWZmZXIuCisgICAg ICAgICAgICBtX2JhY2tCdWZmZXIgPSBtX2J1ZmZlcjsKKyAgICAgICAgICAgIG1fYnVmZmVyID0g MDsKKyAgICAgICAgfQorICAgIH0KKworICAgIFZlY3RvcjxJbnRSZWN0PiBkaXJ0eVJlY3RzOwor ICAgIGdldFVwZGF0ZVJlY3RzKG1fZGlydHlSZWdpb24uZ2V0KCksIGRpcnR5UmVjdHMpOworCisg ICAgSFJHTiBudWxsUmVnaW9uID0gQ3JlYXRlUmVjdFJnbigwLCAwLCAwLCAwKTsKKyAgICBtX2Rp cnR5UmVnaW9uLnNldChudWxsUmVnaW9uKTsKKworICAgIHVuc2lnbmVkIGtleTEsIGtleTI7Cisg ICAgSERDIGRjID0gbV9iYWNrQnVmZmVyLT5nZXREQygma2V5MSwgJmtleTIpOworICAgIEdyYXBo aWNzQ29udGV4dCBjb250ZXh0KGRjKTsKKyAgICBjb250ZXh0LnRyYW5zbGF0ZSgtbV9yZWN0Lngo KSwgLW1fcmVjdC55KCkpOworCisgICAgaW50IHNpemUgPSBkaXJ0eVJlY3RzLnNpemUoKTsKKyAg ICBmb3IgKGludCBuID0gMDsgbiA8IHNpemU7ICsrbikgIHsKKyAgICAgICAgY29udGV4dC5zYXZl KCk7CisgICAgICAgIEludFJlY3QgcmVjdCA9IGRpcnR5UmVjdHNbbl07CisgICAgICAgIGNvbnRl eHQuY2xpcChGbG9hdFJlY3QocmVjdCkpOworICAgICAgICBjb250ZXh0LnNjYWxlKEZsb2F0U2l6 ZShtX2JhY2tpbmdTdG9yZS0+bV9jb250ZW50c1NjYWxlLCBtX2JhY2tpbmdTdG9yZS0+bV9jb250 ZW50c1NjYWxlKSk7CisgICAgICAgIG1fYmFja2luZ1N0b3JlLT5tX2NsaWVudC0+dGlsZWRCYWNr aW5nU3RvcmVQYWludCgmY29udGV4dCwgbV9iYWNraW5nU3RvcmUtPm1hcFRvQ29udGVudHMocmVj dCkpOworICAgICAgICBjb250ZXh0LnJlc3RvcmUoKTsKKyAgICB9CisKKyAgICBtX2JhY2tCdWZm ZXItPnJlbGVhc2VEQyhkYywga2V5MSwga2V5Mik7Cit9CisKK3ZvaWQgVGlsZTo6c3dhcEJhY2tC dWZmZXJUb0Zyb250KCkKK3sKKyAgICBpZiAoIW1fYmFja0J1ZmZlcikKKyAgICAgICAgcmV0dXJu OworICAgIG1fYnVmZmVyID0gbV9iYWNrQnVmZmVyOworICAgIG1fYmFja0J1ZmZlciA9IDA7Cit9 CisKK3ZvaWQgVGlsZTo6cGFpbnQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRS ZWN0JiByZWN0KQoreworICAgIGlmICghbV9idWZmZXIpCisgICAgICAgIHJldHVybjsKKworICAg IEludFJlY3QgdGFyZ2V0ID0gaW50ZXJzZWN0aW9uKHJlY3QsIG1fcmVjdCk7CisgICAgSW50UmVj dCBzb3VyY2UoKHRhcmdldC54KCkgLSBtX3JlY3QueCgpKSwKKyAgICAgICAgICAgICAgICAgICAo dGFyZ2V0LnkoKSAtIG1fcmVjdC55KCkpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC53aWR0 aCgpLAorICAgICAgICAgICAgICAgICAgIHRhcmdldC5oZWlnaHQoKSk7CisKKyAgICBtX2J1ZmZl ci0+ZHJhdyhjb250ZXh0LCB0YXJnZXQsIHNvdXJjZSwgQ29tcG9zaXRlQ29weSk7Cit9CisKK3Zv aWQgVGlsZTo6cGFpbnRDaGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNv bnN0IEZsb2F0UmVjdCYgdGFyZ2V0KQoreworICAgIEZsb2F0UmVjdCB0aWxlUmVjdEluKDAsIDAs IGNoZWNrZXJTaXplLCBjaGVja2VyU2l6ZSk7CisgICAgY29udGV4dC0+ZHJhd0JpdG1hcFBhdHRl cm4oY2hlY2tlcmVkQml0bWFwKCkuZ2V0KCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgdGlsZVJlY3RJbiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBBZmZpbmVUcmFu c2Zvcm0oKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGbG9hdFBvaW50KDAsIDAp LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENvbXBvc2l0ZUNvcHksCisgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0LAorICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIEludFNpemUoY2hlY2tlclNpemUsIGNoZWNrZXJTaXplKSk7Cit9CisKK30KKworI2Vu ZGlmCg== 56574 2010-05-20 01:28:38 -0700 2010-05-21 02:20:28 -0700 patch patchFor37440 text/plain 9658 joybro201 SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1OTc1OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDUtMTkgIEt3YW5nIFl1bCBTZW8gIDxza3l1bEBjb21wYW55 MTAwLm5ldD4sIFlvdW5nIEhhbiBMZWUgIDxqb3licm9AY29tcGFueTEwMC5uZXQ+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW1dJTkNFXSBQb3J0IHRp bGVkIGJhY2tpbmcgc3RvcmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM3NDQwCisKKyAgICAgICAgUG9ydCB0aWxlZCBiYWNraW5nIHN0b3JlIHRvIFdp bkNFIHdpdGggU2hhcmVkQml0bWFwLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvVGls ZS5oOiB1c2UgU2hhcmVkQml0bWFwIGFzIGEgYnVmZmVyIGluIFdpbkNFIHBvcnQuCisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvVGlsZVdpbkNFLmNwcDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpjaGVja2VyZWRCaXRtYXApOgorICAgICAgICAoV2ViQ29yZTo6VGlsZTo6VGls ZSk6CisgICAgICAgIChXZWJDb3JlOjpUaWxlOjp+VGlsZSk6CisgICAgICAgIChXZWJDb3JlOjpU aWxlOjppc0RpcnR5KToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGU6OmlzUmVhZHlUb1BhaW50KToK KyAgICAgICAgKFdlYkNvcmU6OlRpbGU6OmludmFsaWRhdGUpOgorICAgICAgICAoV2ViQ29yZTo6 ZW5jbG9zaW5nUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpnZXRVcGRhdGVSZWN0cyk6CisgICAg ICAgIChXZWJDb3JlOjpUaWxlOjp1cGRhdGVCYWNrQnVmZmVyKTogVGhpcyBmdW5jdGlvbiBhY3R1 YWxseSB1cGRhdGUgdGhlIGZyb250IGJ1ZmZlciBiZWNhdXNlIHRoaXMgcG9ydCBkb2Vzbid0IHVz ZSBkb3VibGUgYnVmZmVyaW5nLgorICAgICAgICAoV2ViQ29yZTo6VGlsZTo6c3dhcEJhY2tCdWZm ZXJUb0Zyb250KTogRGl0dG8uCisgICAgICAgIChXZWJDb3JlOjpUaWxlOjpwYWludCk6CisgICAg ICAgIChXZWJDb3JlOjpUaWxlOjpwYWludENoZWNrZXJQYXR0ZXJuKToKKwogMjAxMC0wNS0xOSAg U3RldmUgQmxvY2sgIDxzdGV2ZWJsb2NrQGdvb2dsZS5jb20+CiAKICAgICAgICAgUmV2aWV3ZWQg YnkgTmF0ZSBDaGFwaW4uCkluZGV4OiBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGUuaAo9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Ci0tLSBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGUuaAkocmV2aXNpb24g NTk3NTgpCisrKyBXZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1RpbGUuaAkod29ya2luZyBjb3B5 KQpAQCAtMSw1ICsxLDYgQEAKIC8qCiAgQ29weXJpZ2h0IChDKSAyMDEwIE5va2lhIENvcnBvcmF0 aW9uIGFuZC9vciBpdHMgc3Vic2lkaWFyeSgtaWVzKQorIENvcHlyaWdodCAoQykgMjAxMCBDb21w YW55IDEwMCwgSW5jLgogIAogIFRoaXMgbGlicmFyeSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2Fu IHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IKICBtb2RpZnkgaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgTGlicmFyeSBHZW5lcmFsIFB1YmxpYwpAQCAtMzUsNiArMzYsMTAgQEAgY2xhc3MgUVJl Z2lvbjsKIFFUX0VORF9OQU1FU1BBQ0UKICNlbmRpZgogCisjaWYgUExBVEZPUk0oV0lOQ0UpCisj aW5jbHVkZSAiU2hhcmVkQml0bWFwLmgiCisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYkNvcmUgewog ICAgIAogY2xhc3MgR3JhcGhpY3NDb250ZXh0OwpAQCAtNzEsNiArNzYsMTIgQEAgcHJpdmF0ZToK ICAgICBRUGl4bWFwKiBtX2JhY2tCdWZmZXI7CiAgICAgUVJlZ2lvbiogbV9kaXJ0eVJlZ2lvbjsK ICNlbmRpZgorCisjaWYgUExBVEZPUk0oV0lOQ0UpCisgICAgUmVmUHRyPFNoYXJlZEJpdG1hcD4g bV9idWZmZXI7CisgICAgUmVmUHRyPFNoYXJlZEJpdG1hcD4gbV9iYWNrQnVmZmVyOworICAgIE93 blB0cjxIUkdOPiBtX2RpcnR5UmVnaW9uOworI2VuZGlmCiB9OwogCiB9CkluZGV4OiBXZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3dpbmNlL1RpbGVXaW5DRS5jcHAKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9UaWxlV2luQ0UuY3BwCShyZXZpc2lvbiAwKQor KysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9UaWxlV2luQ0UuY3BwCShyZXZpc2lv biAwKQpAQCAtMCwwICsxLDIyMiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMCBDb21wYW55 IDEwMCwgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFu ZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9k aWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25k aXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2Rl IG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlz dHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBt YXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09G VFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgQ09NUFVURVIsIElOQy4gYGBBUyBJUycnIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu ICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBDT01QVVRFUiwgSU5DLiBPUgorICogQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJ QUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJUaWxlLmgiCisKKyNpZiBFTkFCTEUoVElMRURfQkFDS0lOR19TVE9SRSkK KworI2luY2x1ZGUgIkFmZmluZVRyYW5zZm9ybS5oIgorI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4 dC5oIgorI2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlLmgiCisjaW5jbHVkZSAiVGlsZWRCYWNr aW5nU3RvcmVDbGllbnQuaCIKKworI2luY2x1ZGUgPHdpbmRvd3MuaD4KKyNpbmNsdWRlIDx3dGYv VmVjdG9yLmg+CisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKworc3RhdGljIGNvbnN0IHVuc2lnbmVk IGNoZWNrZXJTaXplID0gMzI7CitzdGF0aWMgY29uc3QgdW5zaWduZWQgY2hlY2tlckNvbG9yMSA9 IDB4ZmZmZmZmZmY7CitzdGF0aWMgY29uc3QgdW5zaWduZWQgY2hlY2tlckNvbG9yMiA9IDB4ZmZj Y2NjY2M7CisKK3N0YXRpYyBQYXNzUmVmUHRyPFNoYXJlZEJpdG1hcD4gY3JlYXRlQ2hlY2tlcmVk Qml0bWFwKCkKK3sKKyAgICBSZWZQdHI8U2hhcmVkQml0bWFwPiBiaXRtYXAgPSBTaGFyZWRCaXRt YXA6OmNyZWF0ZUluc3RhbmNlKHRydWUsIGNoZWNrZXJTaXplLCBjaGVja2VyU2l6ZSwgZmFsc2Up OworCisgICAgdW5zaWduZWQga2V5MSwga2V5MjsKKyAgICBIREMgZGMgPSBiaXRtYXAtPmdldERD KCZrZXkxLCAma2V5Mik7CisgICAgR3JhcGhpY3NDb250ZXh0IGNvbnRleHQoZGMpOworCisgICAg Q29sb3IgY29sb3IxKGNoZWNrZXJDb2xvcjEpOworICAgIENvbG9yIGNvbG9yMihjaGVja2VyQ29s b3IyKTsKKyAgICBmb3IgKHVuc2lnbmVkIHkgPSAwOyB5IDwgY2hlY2tlclNpemU7IHkgKz0gY2hl Y2tlclNpemUgLyAyKSB7CisgICAgICAgIGJvb2wgYWx0ZXJuYXRlID0geSAlIGNoZWNrZXJTaXpl OworICAgICAgICBmb3IgKHVuc2lnbmVkIHggPSAwOyB4IDwgY2hlY2tlclNpemU7IHggKz0gY2hl Y2tlclNpemUgLyAyKSB7CisgICAgICAgICAgICBjb250ZXh0LmZpbGxSZWN0KEZsb2F0UmVjdCh4 LCB5LCBjaGVja2VyU2l6ZSAvIDIsIGNoZWNrZXJTaXplIC8gMiksCisgICAgICAgICAgICAgICAg YWx0ZXJuYXRlID8gY29sb3IxIDogY29sb3IyLCBEZXZpY2VDb2xvclNwYWNlKTsKKyAgICAgICAg ICAgIGFsdGVybmF0ZSA9ICFhbHRlcm5hdGU7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBiaXRt YXAtPnJlbGVhc2VEQyhkYywga2V5MSwga2V5Mik7CisKKyAgICByZXR1cm4gYml0bWFwLnJlbGVh c2UoKTsKK30KKworc3RhdGljIFNoYXJlZEJpdG1hcCogY2hlY2tlcmVkQml0bWFwKCkKK3sKKyAg ICBzdGF0aWMgU2hhcmVkQml0bWFwKiBiaXRtYXAgPSBjcmVhdGVDaGVja2VyZWRCaXRtYXAoKS5y ZWxlYXNlUmVmKCk7CisgICAgcmV0dXJuIGJpdG1hcDsKK30KKworVGlsZTo6VGlsZShUaWxlZEJh Y2tpbmdTdG9yZSogYmFja2luZ1N0b3JlLCBjb25zdCBDb29yZGluYXRlJiB0aWxlQ29vcmRpbmF0 ZSkKKyAgICA6IG1fYmFja2luZ1N0b3JlKGJhY2tpbmdTdG9yZSkKKyAgICAsIG1fY29vcmRpbmF0 ZSh0aWxlQ29vcmRpbmF0ZSkKKyAgICAsIG1fcmVjdChtX2JhY2tpbmdTdG9yZS0+dGlsZVJlY3RG b3JDb29yZGluYXRlKHRpbGVDb29yZGluYXRlKSkKK3sKKyAgICBSRUNUIHIgPSBtX3JlY3Q7Cisg ICAgbV9kaXJ0eVJlZ2lvbi5zZXQoQ3JlYXRlUmVjdFJnbkluZGlyZWN0KCZyKSk7Cit9CisKK1Rp bGU6On5UaWxlKCkKK3sKK30KKworYm9vbCBUaWxlOjppc0RpcnR5KCkgY29uc3QKK3sKKyAgICBS RUNUIHI7CisgICAgcmV0dXJuIEdldFJnbkJveChtX2RpcnR5UmVnaW9uLmdldCgpLCAmcikgIT0g TlVMTFJFR0lPTjsKK30KKworYm9vbCBUaWxlOjppc1JlYWR5VG9QYWludCgpIGNvbnN0Cit7Cisg ICAgcmV0dXJuIG1fYnVmZmVyOworfQorCit2b2lkIFRpbGU6OmludmFsaWRhdGUoY29uc3QgSW50 UmVjdCYgZGlydHlSZWN0KQoreworICAgIEludFJlY3QgdGlsZURpcnR5UmVjdCA9IGludGVyc2Vj dGlvbihkaXJ0eVJlY3QsIG1fcmVjdCk7CisgICAgaWYgKHRpbGVEaXJ0eVJlY3QuaXNFbXB0eSgp KQorICAgICAgICByZXR1cm47CisKKyAgICBSRUNUIHIgPSB0aWxlRGlydHlSZWN0OworICAgIE93 blB0cjxIUkdOPiB0aWxlRGlydHlSZWdpb24oQ3JlYXRlUmVjdFJnbkluZGlyZWN0KCZyKSk7Cisg ICAgQ29tYmluZVJnbihtX2RpcnR5UmVnaW9uLmdldCgpLCBtX2RpcnR5UmVnaW9uLmdldCgpLCB0 aWxlRGlydHlSZWdpb24uZ2V0KCksIFJHTl9PUik7Cit9CisKK3N0YXRpYyBJbnRSZWN0IGVuY2xv c2luZ1JlY3QoSFJHTiBocmduKQoreworICAgIFJFQ1QgcjsKKyAgICBHZXRSZ25Cb3goaHJnbiwg JnIpOworICAgIHJldHVybiByOworfQorCitzdGF0aWMgdm9pZCBnZXRVcGRhdGVSZWN0cyhIUkdO IHJlZ2lvbiwgVmVjdG9yPEludFJlY3Q+JiByZWN0cykKK3sKKyAgICBjb25zdCBpbnQgcmVjdFRo cmVzaG9sZCA9IDEwOworICAgIGNvbnN0IGZsb2F0IHdhc3RlZFNwYWNlVGhyZXNob2xkID0gMC43 NWY7CisKKyAgICBSRUNUIGVuY2xvc2luZ1JlY3Q7CisgICAgR2V0UmduQm94KHJlZ2lvbiwgJmVu Y2xvc2luZ1JlY3QpOworICAgIEludFJlY3QgZGlydHlSZWN0KGVuY2xvc2luZ1JlY3QpOworCisg ICAgRFdPUkQgcmVnaW9uRGF0YVNpemUgPSBHZXRSZWdpb25EYXRhKHJlZ2lvbiwgc2l6ZW9mKFJH TkRBVEEpLCAwKTsKKyAgICBpZiAoIXJlZ2lvbkRhdGFTaXplKSB7CisgICAgICAgIHJlY3RzLmFw cGVuZChkaXJ0eVJlY3QpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgVmVjdG9yPHVu c2lnbmVkIGNoYXI+IGJ1ZmZlcihyZWdpb25EYXRhU2l6ZSk7CisgICAgUkdOREFUQSogcmVnaW9u RGF0YSA9IHJlaW50ZXJwcmV0X2Nhc3Q8UkdOREFUQSo+KGJ1ZmZlci5kYXRhKCkpOworICAgIEdl dFJlZ2lvbkRhdGEocmVnaW9uLCByZWdpb25EYXRhU2l6ZSwgcmVnaW9uRGF0YSk7CisgICAgaWYg KHJlZ2lvbkRhdGEtPnJkaC5uQ291bnQgPiByZWN0VGhyZXNob2xkKSB7CisgICAgICAgIHJlY3Rz LmFwcGVuZChkaXJ0eVJlY3QpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgZG91Ymxl IHNpbmdsZVBpeGVscyA9IDAuMDsKKyAgICB1bnNpZ25lZCBpOworICAgIFJFQ1QqIHJlY3Q7Cisg ICAgZm9yIChpID0gMCwgcmVjdCA9IHJlaW50ZXJwcmV0X2Nhc3Q8UkVDVCo+KHJlZ2lvbkRhdGEt PkJ1ZmZlcik7IGkgPCByZWdpb25EYXRhLT5yZGgubkNvdW50OyBpKyssIHJlY3QrKykKKyAgICAg ICAgc2luZ2xlUGl4ZWxzICs9IChyZWN0LT5yaWdodCAtIHJlY3QtPmxlZnQpICogKHJlY3QtPmJv dHRvbSAtIHJlY3QtPnRvcCk7CisKKyAgICBkb3VibGUgdW5pb25QaXhlbHMgPSBkaXJ0eVJlY3Qu d2lkdGgoKSAqIGRpcnR5UmVjdC5oZWlnaHQoKTsKKyAgICBkb3VibGUgd2FzdGVkU3BhY2UgPSAx LjAgLSAoc2luZ2xlUGl4ZWxzIC8gdW5pb25QaXhlbHMpOworICAgIGlmICh3YXN0ZWRTcGFjZSA8 PSB3YXN0ZWRTcGFjZVRocmVzaG9sZCkgeworICAgICAgICByZWN0cy5hcHBlbmQoZGlydHlSZWN0 KTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGZvciAoaSA9IDAsIHJlY3QgPSByZWlu dGVycHJldF9jYXN0PFJFQ1QqPihyZWdpb25EYXRhLT5CdWZmZXIpOyBpIDwgcmVnaW9uRGF0YS0+ cmRoLm5Db3VudDsgaSsrLCByZWN0KyspCisgICAgICAgIHJlY3RzLmFwcGVuZCgqcmVjdCk7Cit9 CisKK3ZvaWQgVGlsZTo6dXBkYXRlQmFja0J1ZmZlcigpCit7CisgICAgaWYgKG1fYnVmZmVyICYm ICFpc0RpcnR5KCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghbV9iYWNrQnVmZmVyKSB7 CisgICAgICAgIGlmICghbV9idWZmZXIpCisgICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBTaGFy ZWRCaXRtYXA6OmNyZWF0ZUluc3RhbmNlKHRydWUsIG1fYmFja2luZ1N0b3JlLT5tX3RpbGVTaXpl LndpZHRoKCksIG1fYmFja2luZ1N0b3JlLT5tX3RpbGVTaXplLmhlaWdodCgpLCBmYWxzZSk7Cisg ICAgICAgIGVsc2UgeworICAgICAgICAgICAgLy8gQ3VycmVudGx5IGFsbCBidWZmZXJzIGFyZSB1 cGRhdGVkIHN5bmNocm9ub3VzbHkgYXQgdGhlIHNhbWUgdGltZSBzbyB0aGVyZSBpcyBubyByZWFs IG5lZWQKKyAgICAgICAgICAgIC8vIHRvIGhhdmUgc2VwYXJhdGUgYmFjayBhbmQgZnJvbnQgYnVm ZmVycy4gSnVzdCB1c2UgdGhlIGV4aXN0aW5nIGJ1ZmZlci4KKyAgICAgICAgICAgIG1fYmFja0J1 ZmZlciA9IG1fYnVmZmVyLnJlbGVhc2UoKTsKKyAgICAgICAgfQorICAgIH0KKworICAgIFZlY3Rv cjxJbnRSZWN0PiBkaXJ0eVJlY3RzOworICAgIGdldFVwZGF0ZVJlY3RzKG1fZGlydHlSZWdpb24u Z2V0KCksIGRpcnR5UmVjdHMpOworCisgICAgbV9kaXJ0eVJlZ2lvbi5zZXQoQ3JlYXRlUmVjdFJn bigwLCAwLCAwLCAwKSk7CisKKyAgICB1bnNpZ25lZCBrZXkxLCBrZXkyOworICAgIEhEQyBkYyA9 IG1fYmFja0J1ZmZlci0+Z2V0REMoJmtleTEsICZrZXkyKTsKKyAgICBHcmFwaGljc0NvbnRleHQg Y29udGV4dChkYyk7CisgICAgY29udGV4dC50cmFuc2xhdGUoLW1fcmVjdC54KCksIC1tX3JlY3Qu eSgpKTsKKworICAgIHNpemVfdCBzaXplID0gZGlydHlSZWN0cy5zaXplKCk7CisgICAgZm9yIChz aXplX3QgbiA9IDA7IG4gPCBzaXplOyArK24pICB7CisgICAgICAgIGNvbnRleHQuc2F2ZSgpOwor ICAgICAgICBJbnRSZWN0IHJlY3QgPSBkaXJ0eVJlY3RzW25dOworICAgICAgICBjb250ZXh0LmNs aXAoRmxvYXRSZWN0KHJlY3QpKTsKKyAgICAgICAgY29udGV4dC5zY2FsZShGbG9hdFNpemUobV9i YWNraW5nU3RvcmUtPm1fY29udGVudHNTY2FsZSwgbV9iYWNraW5nU3RvcmUtPm1fY29udGVudHNT Y2FsZSkpOworICAgICAgICBtX2JhY2tpbmdTdG9yZS0+bV9jbGllbnQtPnRpbGVkQmFja2luZ1N0 b3JlUGFpbnQoJmNvbnRleHQsIG1fYmFja2luZ1N0b3JlLT5tYXBUb0NvbnRlbnRzKHJlY3QpKTsK KyAgICAgICAgY29udGV4dC5yZXN0b3JlKCk7CisgICAgfQorCisgICAgbV9iYWNrQnVmZmVyLT5y ZWxlYXNlREMoZGMsIGtleTEsIGtleTIpOworfQorCit2b2lkIFRpbGU6OnN3YXBCYWNrQnVmZmVy VG9Gcm9udCgpCit7CisgICAgaWYgKCFtX2JhY2tCdWZmZXIpCisgICAgICAgIHJldHVybjsKKyAg ICBtX2J1ZmZlciA9IG1fYmFja0J1ZmZlci5yZWxlYXNlKCk7Cit9CisKK3ZvaWQgVGlsZTo6cGFp bnQoR3JhcGhpY3NDb250ZXh0KiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAg IGlmICghbV9idWZmZXIpCisgICAgICAgIHJldHVybjsKKworICAgIEludFJlY3QgdGFyZ2V0ID0g aW50ZXJzZWN0aW9uKHJlY3QsIG1fcmVjdCk7CisgICAgSW50UmVjdCBzb3VyY2UodGFyZ2V0Lngo KSAtIG1fcmVjdC54KCksIHRhcmdldC55KCkgLSBtX3JlY3QueSgpLCB0YXJnZXQud2lkdGgoKSwg dGFyZ2V0LmhlaWdodCgpKTsKKworICAgIG1fYnVmZmVyLT5kcmF3KGNvbnRleHQsIHRhcmdldCwg c291cmNlLCBDb21wb3NpdGVDb3B5KTsKK30KKwordm9pZCBUaWxlOjpwYWludENoZWNrZXJQYXR0 ZXJuKEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgRmxvYXRSZWN0JiB0YXJnZXQpCit7 CisgICAgRmxvYXRSZWN0IHRpbGVSZWN0SW4oMCwgMCwgY2hlY2tlcmVkQml0bWFwKCkud2lkdGgo KSwgY2hlY2tlcmVkQml0bWFwKCkuaGVpZ2h0KCkpOworICAgIGNvbnRleHQtPmRyYXdCaXRtYXBQ YXR0ZXJuKGNoZWNrZXJlZEJpdG1hcCgpLmdldCgpLCB0aWxlUmVjdEluLCBBZmZpbmVUcmFuc2Zv cm0oKSwgRmxvYXRQb2ludCgpLCBDb21wb3NpdGVDb3B5LAorICAgICAgICAgICAgdGFyZ2V0LCBJ bnRTaXplKGNoZWNrZXJlZEJpdG1hcCgpLndpZHRoKCksIGNoZWNrZXJlZEJpdG1hcCgpLmhlaWdo dCgpKSk7Cit9CisKK30KKworI2VuZGlmCg== 56686 2010-05-21 02:20:28 -0700 2011-01-22 19:51:23 -0800 new patch patchFor37440_0 text/plain 9732 joybro201 SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA1OTc1OCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjcgQEAKKzIwMTAtMDUtMTkgIEt3YW5nIFl1bCBTZW8gIDxza3l1bEBjb21wYW55 MTAwLm5ldD4sIFlvdW5nIEhhbiBMZWUgIDxqb3licm9AY29tcGFueTEwMC5uZXQ+CisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgW1dJTkNFXSBQb3J0IHRp bGVkIGJhY2tpbmcgc3RvcmUKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTM3NDQwCisKKyAgICAgICAgUG9ydCB0aWxlZCBiYWNraW5nIHN0b3JlIHRvIFdp bkNFIHdpdGggU2hhcmVkQml0bWFwLgorCisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvVGls ZS5oOiBVc2UgU2hhcmVkQml0bWFwIGFzIGEgYnVmZmVyIGluIFdpbkNFIHBvcnQuCisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvVGlsZVdpbkNFLmNwcDogQWRkZWQuCisgICAgICAg IChXZWJDb3JlOjpjaGVja2VyZWRCaXRtYXApOgorICAgICAgICAoV2ViQ29yZTo6VGlsZTo6VGls ZSk6CisgICAgICAgIChXZWJDb3JlOjpUaWxlOjp+VGlsZSk6CisgICAgICAgIChXZWJDb3JlOjpU aWxlOjppc0RpcnR5KToKKyAgICAgICAgKFdlYkNvcmU6OlRpbGU6OmlzUmVhZHlUb1BhaW50KToK KyAgICAgICAgKFdlYkNvcmU6OlRpbGU6OmludmFsaWRhdGUpOgorICAgICAgICAoV2ViQ29yZTo6 ZW5jbG9zaW5nUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpnZXRVcGRhdGVSZWN0cyk6CisgICAg ICAgIChXZWJDb3JlOjpUaWxlOjp1cGRhdGVCYWNrQnVmZmVyKTogVGhpcyBmdW5jdGlvbiBhY3R1 YWxseSB1cGRhdGVzIHRoZSBmcm9udCBidWZmZXIgYmVjYXVzZSBXaW5DRSBwb3J0IGRvZXNuJ3Qg dXNlIGRvdWJsZSBidWZmZXJpbmcuCisgICAgICAgIChXZWJDb3JlOjpUaWxlOjpzd2FwQmFja0J1 ZmZlclRvRnJvbnQpOiBJZiB0aGVyZSBpcyBhbiB1cGRhdGVkIGJhY2sgYnVmZmVyLCBqdXN0IGJy aW5nIGl0IHRvIHRoZSBmcm9udCBidWZmZXIsIG5vdCBzd2FwLgorICAgICAgICAoV2ViQ29yZTo6 VGlsZTo6cGFpbnQpOgorICAgICAgICAoV2ViQ29yZTo6VGlsZTo6cGFpbnRDaGVja2VyUGF0dGVy bik6CisKIDIwMTAtMDUtMTkgIFN0ZXZlIEJsb2NrICA8c3RldmVibG9ja0Bnb29nbGUuY29tPgog CiAgICAgICAgIFJldmlld2VkIGJ5IE5hdGUgQ2hhcGluLgpJbmRleDogV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9UaWxlLmgKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9UaWxlLmgJKHJldmlzaW9uIDU5NzU4KQorKysgV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9U aWxlLmgJKHdvcmtpbmcgY29weSkKQEAgLTEsNSArMSw2IEBACiAvKgogIENvcHlyaWdodCAoQykg MjAxMCBOb2tpYSBDb3Jwb3JhdGlvbiBhbmQvb3IgaXRzIHN1YnNpZGlhcnkoLWllcykKKyBDb3B5 cmlnaHQgKEMpIDIwMTAgQ29tcGFueSAxMDAsIEluYy4KICAKICBUaGlzIGxpYnJhcnkgaXMgZnJl ZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAgbW9kaWZ5IGl0IHVu ZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIExpYnJhcnkgR2VuZXJhbCBQdWJsaWMKQEAgLTM1LDYg KzM2LDEwIEBAIGNsYXNzIFFSZWdpb247CiBRVF9FTkRfTkFNRVNQQUNFCiAjZW5kaWYKIAorI2lm IFBMQVRGT1JNKFdJTkNFKQorI2luY2x1ZGUgIlNoYXJlZEJpdG1hcC5oIgorI2VuZGlmCisKIG5h bWVzcGFjZSBXZWJDb3JlIHsKICAgICAKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDsKQEAgLTcxLDYg Kzc2LDEyIEBAIHByaXZhdGU6CiAgICAgUVBpeG1hcCogbV9iYWNrQnVmZmVyOwogICAgIFFSZWdp b24qIG1fZGlydHlSZWdpb247CiAjZW5kaWYKKworI2lmIFBMQVRGT1JNKFdJTkNFKQorICAgIFJl ZlB0cjxTaGFyZWRCaXRtYXA+IG1fYnVmZmVyOworICAgIFJlZlB0cjxTaGFyZWRCaXRtYXA+IG1f YmFja0J1ZmZlcjsKKyAgICBPd25QdHI8SFJHTj4gbV9kaXJ0eVJlZ2lvbjsKKyNlbmRpZgogfTsK IAogfQpJbmRleDogV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW5jZS9UaWxlV2luQ0UuY3Bw Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvVGlsZVdpbkNF LmNwcAkocmV2aXNpb24gMCkKKysrIFdlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvd2luY2UvVGls ZVdpbkNFLmNwcAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSwyMjIgQEAKKy8qCisgKiBDb3B5cmln aHQgKEMpIDIwMTAgQ29tcGFueSAxMDAsIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIENPTVBVVEVSLCBJ TkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgQ09NUFVURVIsIElO Qy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiVGlsZS5oIgorCisjaWYgRU5BQkxFKFRJ TEVEX0JBQ0tJTkdfU1RPUkUpCisKKyNpbmNsdWRlICJBZmZpbmVUcmFuc2Zvcm0uaCIKKyNpbmNs dWRlICJHcmFwaGljc0NvbnRleHQuaCIKKyNpbmNsdWRlICJUaWxlZEJhY2tpbmdTdG9yZS5oIgor I2luY2x1ZGUgIlRpbGVkQmFja2luZ1N0b3JlQ2xpZW50LmgiCisKKyNpbmNsdWRlIDx3aW5kb3dz Lmg+CisjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorCituYW1lc3BhY2UgV2ViQ29yZSB7CisKK3N0 YXRpYyBjb25zdCB1bnNpZ25lZCBjaGVja2VyU2l6ZSA9IDMyOworc3RhdGljIGNvbnN0IHVuc2ln bmVkIGNoZWNrZXJDb2xvcjEgPSAweGZmZmZmZmZmOworc3RhdGljIGNvbnN0IHVuc2lnbmVkIGNo ZWNrZXJDb2xvcjIgPSAweGZmY2NjY2NjOworCitzdGF0aWMgUGFzc1JlZlB0cjxTaGFyZWRCaXRt YXA+IGNyZWF0ZUNoZWNrZXJlZEJpdG1hcCgpCit7CisgICAgUmVmUHRyPFNoYXJlZEJpdG1hcD4g Yml0bWFwID0gU2hhcmVkQml0bWFwOjpjcmVhdGVJbnN0YW5jZSh0cnVlLCBjaGVja2VyU2l6ZSwg Y2hlY2tlclNpemUsIGZhbHNlKTsKKworICAgIHVuc2lnbmVkIGtleTEsIGtleTI7CisgICAgSERD IGRjID0gYml0bWFwLT5nZXREQygma2V5MSwgJmtleTIpOworICAgIEdyYXBoaWNzQ29udGV4dCBj b250ZXh0KGRjKTsKKworICAgIENvbG9yIGNvbG9yMShjaGVja2VyQ29sb3IxKTsKKyAgICBDb2xv ciBjb2xvcjIoY2hlY2tlckNvbG9yMik7CisgICAgZm9yICh1bnNpZ25lZCB5ID0gMDsgeSA8IGNo ZWNrZXJTaXplOyB5ICs9IGNoZWNrZXJTaXplIC8gMikgeworICAgICAgICBib29sIGFsdGVybmF0 ZSA9IHkgJSBjaGVja2VyU2l6ZTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCB4ID0gMDsgeCA8IGNo ZWNrZXJTaXplOyB4ICs9IGNoZWNrZXJTaXplIC8gMikgeworICAgICAgICAgICAgY29udGV4dC5m aWxsUmVjdChGbG9hdFJlY3QoeCwgeSwgY2hlY2tlclNpemUgLyAyLCBjaGVja2VyU2l6ZSAvIDIp LAorICAgICAgICAgICAgICAgIGFsdGVybmF0ZSA/IGNvbG9yMSA6IGNvbG9yMiwgRGV2aWNlQ29s b3JTcGFjZSk7CisgICAgICAgICAgICBhbHRlcm5hdGUgPSAhYWx0ZXJuYXRlOworICAgICAgICB9 CisgICAgfQorCisgICAgYml0bWFwLT5yZWxlYXNlREMoZGMsIGtleTEsIGtleTIpOworCisgICAg cmV0dXJuIGJpdG1hcC5yZWxlYXNlKCk7Cit9CisKK3N0YXRpYyBTaGFyZWRCaXRtYXAqIGNoZWNr ZXJlZEJpdG1hcCgpCit7CisgICAgc3RhdGljIFNoYXJlZEJpdG1hcCogYml0bWFwID0gY3JlYXRl Q2hlY2tlcmVkQml0bWFwKCkucmVsZWFzZVJlZigpOworICAgIHJldHVybiBiaXRtYXA7Cit9CisK K1RpbGU6OlRpbGUoVGlsZWRCYWNraW5nU3RvcmUqIGJhY2tpbmdTdG9yZSwgY29uc3QgQ29vcmRp bmF0ZSYgdGlsZUNvb3JkaW5hdGUpCisgICAgOiBtX2JhY2tpbmdTdG9yZShiYWNraW5nU3RvcmUp CisgICAgLCBtX2Nvb3JkaW5hdGUodGlsZUNvb3JkaW5hdGUpCisgICAgLCBtX3JlY3QobV9iYWNr aW5nU3RvcmUtPnRpbGVSZWN0Rm9yQ29vcmRpbmF0ZSh0aWxlQ29vcmRpbmF0ZSkpCit7CisgICAg UkVDVCByID0gbV9yZWN0OworICAgIG1fZGlydHlSZWdpb24uc2V0KENyZWF0ZVJlY3RSZ25JbmRp cmVjdCgmcikpOworfQorCitUaWxlOjp+VGlsZSgpCit7Cit9CisKK2Jvb2wgVGlsZTo6aXNEaXJ0 eSgpIGNvbnN0Cit7CisgICAgUkVDVCByOworICAgIHJldHVybiBHZXRSZ25Cb3gobV9kaXJ0eVJl Z2lvbi5nZXQoKSwgJnIpICE9IE5VTExSRUdJT047Cit9CisKK2Jvb2wgVGlsZTo6aXNSZWFkeVRv UGFpbnQoKSBjb25zdAoreworICAgIHJldHVybiBtX2J1ZmZlcjsKK30KKwordm9pZCBUaWxlOjpp bnZhbGlkYXRlKGNvbnN0IEludFJlY3QmIGRpcnR5UmVjdCkKK3sKKyAgICBJbnRSZWN0IHRpbGVE aXJ0eVJlY3QgPSBpbnRlcnNlY3Rpb24oZGlydHlSZWN0LCBtX3JlY3QpOworICAgIGlmICh0aWxl RGlydHlSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgUkVDVCByID0gdGls ZURpcnR5UmVjdDsKKyAgICBPd25QdHI8SFJHTj4gdGlsZURpcnR5UmVnaW9uKENyZWF0ZVJlY3RS Z25JbmRpcmVjdCgmcikpOworICAgIENvbWJpbmVSZ24obV9kaXJ0eVJlZ2lvbi5nZXQoKSwgbV9k aXJ0eVJlZ2lvbi5nZXQoKSwgdGlsZURpcnR5UmVnaW9uLmdldCgpLCBSR05fT1IpOworfQorCitz dGF0aWMgSW50UmVjdCBlbmNsb3NpbmdSZWN0KEhSR04gaHJnbikKK3sKKyAgICBSRUNUIHI7Cisg ICAgR2V0UmduQm94KGhyZ24sICZyKTsKKyAgICByZXR1cm4gcjsKK30KKworc3RhdGljIHZvaWQg Z2V0VXBkYXRlUmVjdHMoSFJHTiByZWdpb24sIFZlY3RvcjxJbnRSZWN0PiYgcmVjdHMpCit7Cisg ICAgY29uc3QgaW50IHJlY3RUaHJlc2hvbGQgPSAxMDsKKyAgICBjb25zdCBmbG9hdCB3YXN0ZWRT cGFjZVRocmVzaG9sZCA9IDAuNzVmOworCisgICAgUkVDVCBlbmNsb3NpbmdSZWN0OworICAgIEdl dFJnbkJveChyZWdpb24sICZlbmNsb3NpbmdSZWN0KTsKKyAgICBJbnRSZWN0IGRpcnR5UmVjdChl bmNsb3NpbmdSZWN0KTsKKworICAgIERXT1JEIHJlZ2lvbkRhdGFTaXplID0gR2V0UmVnaW9uRGF0 YShyZWdpb24sIHNpemVvZihSR05EQVRBKSwgMCk7CisgICAgaWYgKCFyZWdpb25EYXRhU2l6ZSkg eworICAgICAgICByZWN0cy5hcHBlbmQoZGlydHlSZWN0KTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKworICAgIFZlY3Rvcjx1bnNpZ25lZCBjaGFyPiBidWZmZXIocmVnaW9uRGF0YVNpemUpOwor ICAgIFJHTkRBVEEqIHJlZ2lvbkRhdGEgPSByZWludGVycHJldF9jYXN0PFJHTkRBVEEqPihidWZm ZXIuZGF0YSgpKTsKKyAgICBHZXRSZWdpb25EYXRhKHJlZ2lvbiwgcmVnaW9uRGF0YVNpemUsIHJl Z2lvbkRhdGEpOworICAgIGlmIChyZWdpb25EYXRhLT5yZGgubkNvdW50ID4gcmVjdFRocmVzaG9s ZCkgeworICAgICAgICByZWN0cy5hcHBlbmQoZGlydHlSZWN0KTsKKyAgICAgICAgcmV0dXJuOwor ICAgIH0KKworICAgIGRvdWJsZSBzaW5nbGVQaXhlbHMgPSAwLjA7CisgICAgdW5zaWduZWQgaTsK KyAgICBSRUNUKiByZWN0OworICAgIGZvciAoaSA9IDAsIHJlY3QgPSByZWludGVycHJldF9jYXN0 PFJFQ1QqPihyZWdpb25EYXRhLT5CdWZmZXIpOyBpIDwgcmVnaW9uRGF0YS0+cmRoLm5Db3VudDsg aSsrLCByZWN0KyspCisgICAgICAgIHNpbmdsZVBpeGVscyArPSAocmVjdC0+cmlnaHQgLSByZWN0 LT5sZWZ0KSAqIChyZWN0LT5ib3R0b20gLSByZWN0LT50b3ApOworCisgICAgZG91YmxlIHVuaW9u UGl4ZWxzID0gZGlydHlSZWN0LndpZHRoKCkgKiBkaXJ0eVJlY3QuaGVpZ2h0KCk7CisgICAgZG91 YmxlIHdhc3RlZFNwYWNlID0gMS4wIC0gKHNpbmdsZVBpeGVscyAvIHVuaW9uUGl4ZWxzKTsKKyAg ICBpZiAod2FzdGVkU3BhY2UgPD0gd2FzdGVkU3BhY2VUaHJlc2hvbGQpIHsKKyAgICAgICAgcmVj dHMuYXBwZW5kKGRpcnR5UmVjdCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBmb3Ig KGkgPSAwLCByZWN0ID0gcmVpbnRlcnByZXRfY2FzdDxSRUNUKj4ocmVnaW9uRGF0YS0+QnVmZmVy KTsgaSA8IHJlZ2lvbkRhdGEtPnJkaC5uQ291bnQ7IGkrKywgcmVjdCsrKQorICAgICAgICByZWN0 cy5hcHBlbmQoKnJlY3QpOworfQorCit2b2lkIFRpbGU6OnVwZGF0ZUJhY2tCdWZmZXIoKQorewor ICAgIGlmIChtX2J1ZmZlciAmJiAhaXNEaXJ0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBp ZiAoIW1fYmFja0J1ZmZlcikgeworICAgICAgICBpZiAoIW1fYnVmZmVyKQorICAgICAgICAgICAg bV9iYWNrQnVmZmVyID0gU2hhcmVkQml0bWFwOjpjcmVhdGVJbnN0YW5jZSh0cnVlLCBtX2JhY2tp bmdTdG9yZS0+bV90aWxlU2l6ZS53aWR0aCgpLCBtX2JhY2tpbmdTdG9yZS0+bV90aWxlU2l6ZS5o ZWlnaHQoKSwgZmFsc2UpOworICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIC8vIEN1cnJlbnRs eSBhbGwgYnVmZmVycyBhcmUgdXBkYXRlZCBzeW5jaHJvbm91c2x5IGF0IHRoZSBzYW1lIHRpbWUg c28gdGhlcmUgaXMgbm8gcmVhbCBuZWVkCisgICAgICAgICAgICAvLyB0byBoYXZlIHNlcGFyYXRl IGJhY2sgYW5kIGZyb250IGJ1ZmZlcnMuIEp1c3QgdXNlIHRoZSBleGlzdGluZyBidWZmZXIuCisg ICAgICAgICAgICBtX2JhY2tCdWZmZXIgPSBtX2J1ZmZlci5yZWxlYXNlKCk7CisgICAgICAgIH0K KyAgICB9CisKKyAgICBWZWN0b3I8SW50UmVjdD4gZGlydHlSZWN0czsKKyAgICBnZXRVcGRhdGVS ZWN0cyhtX2RpcnR5UmVnaW9uLmdldCgpLCBkaXJ0eVJlY3RzKTsKKworICAgIG1fZGlydHlSZWdp b24uc2V0KENyZWF0ZVJlY3RSZ24oMCwgMCwgMCwgMCkpOworCisgICAgdW5zaWduZWQga2V5MSwg a2V5MjsKKyAgICBIREMgZGMgPSBtX2JhY2tCdWZmZXItPmdldERDKCZrZXkxLCAma2V5Mik7Cisg ICAgR3JhcGhpY3NDb250ZXh0IGNvbnRleHQoZGMpOworICAgIGNvbnRleHQudHJhbnNsYXRlKC1t X3JlY3QueCgpLCAtbV9yZWN0LnkoKSk7CisKKyAgICBzaXplX3Qgc2l6ZSA9IGRpcnR5UmVjdHMu c2l6ZSgpOworICAgIGZvciAoc2l6ZV90IG4gPSAwOyBuIDwgc2l6ZTsgKytuKSAgeworICAgICAg ICBjb250ZXh0LnNhdmUoKTsKKyAgICAgICAgSW50UmVjdCByZWN0ID0gZGlydHlSZWN0c1tuXTsK KyAgICAgICAgY29udGV4dC5jbGlwKEZsb2F0UmVjdChyZWN0KSk7CisgICAgICAgIGNvbnRleHQu c2NhbGUoRmxvYXRTaXplKG1fYmFja2luZ1N0b3JlLT5tX2NvbnRlbnRzU2NhbGUsIG1fYmFja2lu Z1N0b3JlLT5tX2NvbnRlbnRzU2NhbGUpKTsKKyAgICAgICAgbV9iYWNraW5nU3RvcmUtPm1fY2xp ZW50LT50aWxlZEJhY2tpbmdTdG9yZVBhaW50KCZjb250ZXh0LCBtX2JhY2tpbmdTdG9yZS0+bWFw VG9Db250ZW50cyhyZWN0KSk7CisgICAgICAgIGNvbnRleHQucmVzdG9yZSgpOworICAgIH0KKwor ICAgIG1fYmFja0J1ZmZlci0+cmVsZWFzZURDKGRjLCBrZXkxLCBrZXkyKTsKK30KKwordm9pZCBU aWxlOjpzd2FwQmFja0J1ZmZlclRvRnJvbnQoKQoreworICAgIGlmICghbV9iYWNrQnVmZmVyKQor ICAgICAgICByZXR1cm47CisgICAgbV9idWZmZXIgPSBtX2JhY2tCdWZmZXIucmVsZWFzZSgpOwor fQorCit2b2lkIFRpbGU6OnBhaW50KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgSW50 UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAoIW1fYnVmZmVyKQorICAgICAgICByZXR1cm47CisKKyAg ICBJbnRSZWN0IHRhcmdldCA9IGludGVyc2VjdGlvbihyZWN0LCBtX3JlY3QpOworICAgIEludFJl Y3Qgc291cmNlKHRhcmdldC54KCkgLSBtX3JlY3QueCgpLCB0YXJnZXQueSgpIC0gbV9yZWN0Lnko KSwgdGFyZ2V0LndpZHRoKCksIHRhcmdldC5oZWlnaHQoKSk7CisKKyAgICBtX2J1ZmZlci0+ZHJh dyhjb250ZXh0LCB0YXJnZXQsIHNvdXJjZSwgQ29tcG9zaXRlQ29weSk7Cit9CisKK3ZvaWQgVGls ZTo6cGFpbnRDaGVja2VyUGF0dGVybihHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IEZs b2F0UmVjdCYgdGFyZ2V0KQoreworICAgIEZsb2F0UmVjdCB0aWxlUmVjdEluKDAsIDAsIGNoZWNr ZXJlZEJpdG1hcCgpLT53aWR0aCgpLCBjaGVja2VyZWRCaXRtYXAoKS0+aGVpZ2h0KCkpOworICAg IGNvbnRleHQtPmRyYXdCaXRtYXBQYXR0ZXJuKGNoZWNrZXJlZEJpdG1hcCgpLCB0aWxlUmVjdElu LCBBZmZpbmVUcmFuc2Zvcm0oKSwgRmxvYXRQb2ludCgpLCBDb21wb3NpdGVDb3B5LAorICAgICAg ICAgICAgdGFyZ2V0LCBJbnRTaXplKGNoZWNrZXJlZEJpdG1hcCgpLT53aWR0aCgpLCBjaGVja2Vy ZWRCaXRtYXAoKS0+aGVpZ2h0KCkpKTsKK30KKworfQorCisjZW5kaWYK