239015 2022-04-08 13:53:04 -0700 REGRESSION (Safari 15.4) Performance regression after uploading WebGL buffers 2022-04-26 07:21:36 -0700 1 1 1 Unclassified WebKit WebGL Safari Technology Preview All All RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=239518 InRadar P2 Blocker --- 1 philip.taylor kkinnunen dino ews-watchlist geofflang gman jonahr kbr kkinnunen kondapallykalyan kpiddington webkit-bug-importer oldest_to_newest 1859878 0 philip.taylor 2022-04-08 13:53:04 -0700 Hello, I am responsible for a WebGL rendering engine for displaying large CAD models on the web. The recent 15.4 update of Safari broke our engine, and I have been unable to reliably track down and implement workaround to the issue. This url should crash any iOS device, but load correctly on desktop browsers. https://docs.zea.live/Safari-Crash-Test/ A few comments. 1. We already disabled out 'multi-draw' code paths. 2. We already disabled antialiasing for iOS devices. 3. We already tried pre-allocating large GPU buffers to avoid re-allocations. It seemed at first that it was caused by us allocating and freeing buffers, so we have tried to eliminate as many buffer free/allocations sequences as possible, but still cannot make the provided page load. Note: Prior to 15.4 our engine would handle these large data sets very well on iOS Safari. 1859891 1 webkit-bug-importer 2022-04-08 14:37:04 -0700 <rdar://problem/91503287> 1860763 2 kbr 2022-04-12 12:19:08 -0700 Hopefully these problems have already been resolved in top-of-tree WebKit and given sufficient testing on the EWS won't happen again. 1860765 3 kbr 2022-04-12 12:22:25 -0700 Actually I'm not sure they have been - https://docs.zea.live/Safari-Crash-Test/ seems to hang while loading in Safari Technology Preview on an M1 MacBook Pro. The same model loads successfully, albeit very slowly, in Chrome Canary with ANGLE's Metal backend enabled. 1860985 4 philip.taylor 2022-04-12 17:54:22 -0700 I have been experiencing a mix of extremely 1. poor performance (2fps), 2. crashes, or 3. excellent performance (60fps) on quite similar datasets. The pre-allocating large GPU buffers was a solution that caused some datasets to jump from 2fps up to 60 fps on the same machine. (normally I incrementally grow GPU buffers by powers of 2). I can provide other datasets that provide various behaviors if needed. I am making stabs in the dark, but it felt like my buffer allocations were corrupting something in the back end. 1862378 5 kbr 2022-04-18 16:59:16 -0700 If you have an M1 MacBook Pro and can produce a test case which demonstrates more of these problems on Safari Technology Preview, more of us can help investigate. Only Apple engineers can build and test WebKit on iOS. 1862985 6 philip.taylor 2022-04-20 10:56:43 -0700 Thanks Ken. I'd like to update this issue. The issues is not specific to iOS. What seems to be happening is a severe performance regression, that looks like a crash in Safari as our renderer gets stuck iterating through a lot of draw calls. We store Geometries in one large buffer, and we update this buffer as we stream in geometries. Depending on the order that our workers finish parsing geoms, the _number_ of buffer updates may change. It seems like if we touch the same geom buffer twice, subsequent calls to drawElements are incredibly slow. First we allocate our large buffers. (Resizing each time by powers of 2) Then upload our geometries into these buffers using.. ``` gl.bufferSubData(gl.ARRAY_BUFFER, dstByteOffsetInBytes, attrData.values) ``` ``` gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, dstByteOffsetInBytes, offsettedIndices) ``` Then we draw in large batches. ``` if (gl.multiDrawElements) { gl.multiDrawElements(gl.TRIANGLES, counts, 0, gl.UNSIGNED_INT, offsets, 0, drawCount) } else { const { geomItemId } = renderstate.unifs for (let i = 0; i < drawCount; i++) { gl.uniform1i(geomItemId.location, drawIds[i]) gl.drawElements(gl.TRIANGLES, counts[i], gl.UNSIGNED_INT, offsets[i]) } } ``` Something must change after our calls to bufferSubData that then makes drawElements unusably slow. Note: We do have a code path for multi-draw, which is currently disabled on Safari due to another regression. This performance issue may have existed before, but we didn't notice it, because we didn't use this code path, as it was a fallback. We spent today debugging this issue in Safari on an M1 macbook pro. The issue is not only on iOS. 1863168 7 philip.taylor 2022-04-20 18:41:33 -0700 1. We generate some buffers (larger than we need) using the following code. const attrBuffer = gl.createBuffer() gl.bindBuffer(gl.ARRAY_BUFFER, attrBuffer) const sizeInBytes = numValues * attrSpec.elementSize gl.bufferData(gl.ARRAY_BUFFER, sizeInBytes, gl.STATIC_DRAW) 2. We start loading our geometries, and populating the buffers using the following gl.bindBuffer(gl.ARRAY_BUFFER, glattrbuffer.buffer) gl.bufferSubData(gl.ARRAY_BUFFER, offsetInBytes, attrData.values) 3. We generate Vertex Array Objects to bind our buffers to the GPU. this.vao = gl.createVertexArray() gl.bindVertexArray(this.vao) ... 4. During rendering we bind these buffers and dra. gl.bindVertexArray(this.vao) ... gl.drawElements(gl.TRIANGLES, counts[i], gl.UNSIGNED_INT, offsets[i]) 5. Subsequently more data might be uploaded, which means we might got back to step 2 if the buffers were already big enough, else 1 if we need to allocate more space. - if we need to re-allocate, we copy the data from the previous buffers into the new ones, but I have ensured this does not happen. I used to think this bug was caused by us repeatedly increasing the size of the buffers, but that does not seem to be the case. I now pre-allocate rather big buffers so we don't need to resize them, and can still repro the problem on even small assets. Now... it seems that if we simply generate the buffers, populate them, generate the bindings, and then draw, the performance is abysmal. However, if we upload more data into the buffers, then performance is perfect again.... We don't regenerate our VAOs, as they should be valid until we need to resize. I now have simpler repros than the heavy scene I setup last week. 1863267 8 philip.taylor 2022-04-21 05:39:48 -0700 Hi, just updating my test scene with a simple repro.(my last scene loaded a rather large asset). This page loads and renders incredibly slowly (~1fps) in Safari. https://docs.zea.live/Safari-Crash-Test/ This page loads and renders incredibly quickly (60fps) in Safari. https://docs.zea.live/Safari-Crash-Test/?grid The difference? I have 2 sets of geometries. The grid and the brake system. Both are used to populate the buffers in 2 different steps. 1863366 9 philip.taylor 2022-04-21 12:20:48 -0700 I have tried re-enabling the multi-draw code path and allocating extra indices above what is used, and we no longer see the exception that was thrown previously. However, the current performance regression is still there. 1863375 10 kkinnunen 2022-04-21 13:11:15 -0700 The slowdown seems to come from the primitive restart index cache update. WebKit's restart cache refactor was copied to ANGLE but not verbatim. The is cache truthiness flag meaning got inverted and the memory usage optimisation in clearConversionBuffers was lost. https://bugs.webkit.org/show_bug.cgi?id=227451 https://chromium-review.googlesource.com/c/angle/angle/+/3331675 It appears that the dummy workaround would be to make a dummy sub buffer update to the element buffer after the first draw. - First draw updates the indexType to be correct (invalid enum -> draw buffer element type) - dummy subbuffer update marks the cache dirty since the "cache is dirty" state currently means "don't update the cache", it will skip the cache update. 1863388 11 kbr 2022-04-21 13:37:11 -0700 Kimmo, thank you for tracking that down. Can you file a bug against ANGLE pointing to this one and describing in detail what the bug is and what we need to do to fix it? I'd suggest we fix it upstream in ANGLE and then roll the fix into WebKit. How does that sound? 1863571 12 458119 kkinnunen 2022-04-22 01:24:34 -0700 Created attachment 458119 Patch 1863572 13 ews-watchlist 2022-04-22 01:26:14 -0700 Note that there are important steps to take when updating ANGLE. See https://trac.webkit.org/wiki/UpdatingANGLE 1863574 14 458121 kkinnunen 2022-04-22 01:34:49 -0700 Created attachment 458121 Patch 1863633 15 philip.taylor 2022-04-22 05:46:39 -0700 Hi Kimmo, I tried applying your suggested workaround, and its not having any effect. I believe it must be close, your workaround aligns with my observations that multiple buffer uploads avoided the regression. Can you take a quick look at this code to see what could be missing? ``` { // Hack to force the primitive restart index cache to be dirty... // https://bugs.webkit.org/show_bug.cgi?id=239015 // - First draw updates the indexType to be correct (invalid enum -> draw buffer element type) const gl = this.__gl gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer) gl.drawElements(gl.POINTS, 1, gl.UNSIGNED_INT, 0) // - dummy subbuffer update marks the cache dirty // bufferSubData an array of size 1 at the end of the current allocation. const dummyIndices = new Uint32Array(1) const elementSize = 4 // Uint32Array const offsetInBytes = this.indicesAllocator.allocatedSpace * elementSize gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, dummyIndices) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null) } ``` 1863634 16 philip.taylor 2022-04-22 05:52:30 -0700 For good measure, I tried drawing each of the element types. { // Hack to force the primitive restart index cache to be dirty... // https://bugs.webkit.org/show_bug.cgi?id=239015 // - First draw updates the indexType to be correct (invalid enum -> draw buffer element type) const gl = this.__gl gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexBuffer) gl.drawElements(gl.POINTS, 1, gl.UNSIGNED_INT, 0) gl.drawElements(gl.LINES, 2, gl.UNSIGNED_INT, 0) gl.drawElements(gl.TRIANGLES, 3, gl.UNSIGNED_INT, 0) // - dummy subbuffer update marks the cache dirty // bufferSubData an array of size 1 at the end of the current allocation. const dummyIndices = new Uint32Array(1) const elementSize = 4 // Uint32Array const offsetInBytes = this.indicesAllocator.allocatedSpace * elementSize gl.bufferSubData(gl.ELEMENT_ARRAY_BUFFER, offsetInBytes, dummyIndices) gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null) } 1863667 17 kkinnunen 2022-04-22 08:29:56 -0700 I think you need to draw with TRIANGLE_STRIP or TRIANGLE_FAN Btw, another option for a workaround may be that if you can select your mesh format, draw just with TRIANGLES. This does not need to compute the primitive restart. 1863668 18 kkinnunen 2022-04-22 08:33:07 -0700 (In reply to Kimmo Kinnunen from comment #17) > I think you need to draw with TRIANGLE_STRIP or TRIANGLE_FAN > > Btw, another option for a workaround may be that if you can select your mesh > format, draw just with TRIANGLES. This does not need to compute the > primitive restart. Ooops, disregard this. It's just the inverse: For first workaround, drawing with points, lines, triangles should be the workaround. For the second workaround to try, you can try to use trinagle_strip, triangle_fan if possible. 1863669 19 kkinnunen 2022-04-22 08:49:17 -0700 (In reply to Kenneth Russell from comment #11) > Kimmo, thank you for tracking that down. Can you file a bug against ANGLE > pointing to this one and describing in detail what the bug is and what we > need to do to fix it? > > I'd suggest we fix it upstream in ANGLE and then roll the fix into WebKit. > How does that sound? I think for our release cherrypick purposes we need to merge it the other way. 1863681 20 philip.taylor 2022-04-22 09:16:13 -0700 (In reply to Kimmo Kinnunen from comment #18) > (In reply to Kimmo Kinnunen from comment #17) > > I think you need to draw with TRIANGLE_STRIP or TRIANGLE_FAN > > > > Btw, another option for a workaround may be that if you can select your mesh > > format, draw just with TRIANGLES. This does not need to compute the > > primitive restart. > > > Ooops, disregard this. > > > It's just the inverse: > > For first workaround, drawing with points, lines, triangles should be the > workaround. > > For the second workaround to try, you can try to use trinagle_strip, > triangle_fan if possible. Thanks. but If I understand you correctly, we have applied your workaround.. From one set of GPU buffers we draw TRIANGLES, LINES, and POINTS. (not fans and strips). So I am not sure what next steps need to be taken to improve my workaround. I may just not understand what you are saying. 1863761 21 kkinnunen 2022-04-22 13:13:54 -0700 (In reply to Philip Taylor from comment #20) > So I am not sure what next steps need to be taken to improve my workaround. > I may just not understand what you are saying. As far as I see, it would appear that your test case matches my mental model. I think next step I need to build a simple test case for the workaround that exercises the codepath and try to see why it doesn't repro. I get to that only on Monday.. 1863763 22 458121 kbr 2022-04-22 13:20:34 -0700 Comment on attachment 458121 Patch Thank you so much Kimmo for tracking this down. This was a major performance pitfall for some customers. Sounds good to apply this in WebKit and then upstream it to ANGLE. 1864035 23 ews-feeder 2022-04-25 00:05:45 -0700 Committed r293317 (249940@main): <https://commits.webkit.org/249940@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 458121. 1864053 24 458254 kkinnunen 2022-04-25 02:26:21 -0700 Created attachment 458254 Example workaround 1864435 25 philip.taylor 2022-04-26 07:21:36 -0700 I can confirm that the workaround does address the performance issue on our side. thanks Kimmo 458119 2022-04-22 01:24:34 -0700 2022-04-22 01:34:44 -0700 Patch bug-239015-20220422112432.patch text/plain 5049 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjkzMTYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggNTgyYTc2MGZkNjNkNzM2Y2FlZDhlNGU2N2JmMGQ1MzVmNWRhMTVlMS4uMWEzN2E0MTFlZjM4 ZDYxMjc0NWRjNGQyNDdiMmRjZjg5MDRmNDdiMSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDMwIEBACisyMDIyLTA0LTIyICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAoU2FmYXJpIDE1LjQpIFBlcmZvcm1h bmNlIHJlZ3Jlc3Npb24gYWZ0ZXIgdXBsb2FkaW5nIFdlYkdMIGJ1ZmZlcnMKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzOTAxNQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEJ1ZmZlck10bDo6Z2V0UmVzdGFy dEluZGljZXMoKSB3b3VsZCByZWNhbGN1bGF0ZSByZXN0YXJ0IGluZGljZXMgb24gZWFjaAorICAg ICAgICBkcmF3IGJlY2F1c2UgUmVzdGFydFJhbmdlQ2FjaGU6Om9wZXJhdG9yIGJvb2woKSB3b3Vs ZCByZXR1cm4gbV9pc0RpcnR5CisgICAgICAgIGluc3RlYWQgb2YgIW1faXNEaXJ0eS4KKworICAg ICAgICBVc2Ugb3B0aW9uYWwgdG8gaG9sZCB0aGUgUmVzdGFydFJhbmdlQ2FjaGUgaW4gb3B0aW9u YWwgaW5zdGVhZCBvZgorICAgICAgICBtYWludGFpbmluZyBtX2lzRGlydHkuIFRoaXMgYWxsb3dz IHRoZSB0eXBlIHN5c3RlbSB0byBjb250cmlidXRlIHRvIHRoZQorICAgICAgICBjb3JyZWN0bmVz cyBvZiB0aGUgY29kZS4gRGlydHkgcmVzdGFydCByYW5nZSBjYWNoZSBpcyBub3QgdXNlZnVsIGFu ZCB0YWtlcworICAgICAgICB1cCBtZW1vcnkuCisKKyAgICAgICAgUmUtYXBwbHkgaHVua3MgZnJv bSByMjgxNTUwICJBTkdMRSBNZXRhbCBpbmRleCBidWZmZXIgbGVmdCBtYXBwZWQgd2hlbiBidWls ZGluZyBwcmltaXRpdmUgcmVzdGFydCByYW5nZXMiLgorCisgICAgICAgIFRoZXNlIHdlcmUgb3Zl cndyaXR0ZW4gaW4gcjI4NjYzOCAiUm9sbCBBTkdMRSB0byBpbmNsdWRlIHVwc3RyZWFtZWQgTWV0 YWwgYmFja2VuZCIuCisKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvbWV0YWwvQnVm ZmVyTXRsLmg6CisgICAgICAgIChyeDo6QnVmZmVyTXRsOjpSZXN0YXJ0UmFuZ2VDYWNoZTo6UmVz dGFydFJhbmdlQ2FjaGUpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9C dWZmZXJNdGwubW06CisgICAgICAgIChyeDo6QnVmZmVyTXRsOjptYXJrQ29udmVyc2lvbkJ1ZmZl cnNEaXJ0eSk6CisgICAgICAgIChyeDo6QnVmZmVyTXRsOjpjbGVhckNvbnZlcnNpb25CdWZmZXJz KToKKyAgICAgICAgKHJ4OjpCdWZmZXJNdGw6OmdldFJlc3RhcnRJbmRpY2VzKToKKwogMjAyMi0w NC0xOCAgRWxsaW90dCBXaWxsaWFtcyAgPGVtd0BhcHBsZS5jb20+CiAKICAgICAgICAgW1hDQnVp bGRdIFVzZSBYQ0J1aWxkIGZvciBhbGwgY29tbWFuZC1saW5lIGFuZCBwcm9qZWN0IGJ1aWxkcwpk aWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVy L21ldGFsL0J1ZmZlck10bC5oIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xF L3JlbmRlcmVyL21ldGFsL0J1ZmZlck10bC5oCmluZGV4IDQzOGU4ZGFmZWI5YzRkMTg1OTVhYjQ4 NmY0ZTNlZWU3YTE1NmYyODUuLmMyMDY5MGM2MmVkMmUzYjY0YTUyZTUwYTlmMjhjN2Q5OGJiZDUw NTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5k ZXJlci9tZXRhbC9CdWZmZXJNdGwuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMv bGliQU5HTEUvcmVuZGVyZXIvbWV0YWwvQnVmZmVyTXRsLmgKQEAgLTEyLDYgKzEyLDcgQEAKIAog I2ltcG9ydCA8TWV0YWwvTWV0YWwuaD4KIAorI2luY2x1ZGUgPG9wdGlvbmFsPgogI2luY2x1ZGUg PHV0aWxpdHk+CiAKICNpbmNsdWRlICJsaWJBTkdMRS9CdWZmZXIuaCIKQEAgLTIxNSwxNyArMjE2 LDEzIEBAIGNsYXNzIEJ1ZmZlck10bCA6IHB1YmxpYyBCdWZmZXJJbXBsLCBwdWJsaWMgQnVmZmVy SG9sZGVyTXRsCiAKICAgICBzdHJ1Y3QgUmVzdGFydFJhbmdlQ2FjaGUKICAgICB7Ci0gICAgICAg IFJlc3RhcnRSYW5nZUNhY2hlKCkgOiBpbmRleFR5cGUoZ2w6OkRyYXdFbGVtZW50c1R5cGU6Oklu dmFsaWRFbnVtKSB7IGlzRGlydHkgPSB0cnVlOyB9CiAgICAgICAgIFJlc3RhcnRSYW5nZUNhY2hl KHN0ZDo6dmVjdG9yPEluZGV4UmFuZ2U+ICYmcmFuZ2VzXywgZ2w6OkRyYXdFbGVtZW50c1R5cGUg aW5kZXhUeXBlXykKLSAgICAgICAgICAgIDogcmFuZ2VzKHJhbmdlc18pLCBpbmRleFR5cGUoaW5k ZXhUeXBlXyksIGlzRGlydHkoZmFsc2UpCisgICAgICAgICAgICA6IHJhbmdlcyhyYW5nZXNfKSwg aW5kZXhUeXBlKGluZGV4VHlwZV8pCiAgICAgICAgIHt9Ci0gICAgICAgIHZvaWQgbWFya0RpcnR5 KCkgeyBpc0RpcnR5ID0gdHJ1ZTsgfQotICAgICAgICBvcGVyYXRvciBib29sKCkgY29uc3QgeyBy ZXR1cm4gaXNEaXJ0eTsgfQotICAgICAgICBzdGQ6OnZlY3RvcjxJbmRleFJhbmdlPiByYW5nZXM7 Ci0gICAgICAgIGdsOjpEcmF3RWxlbWVudHNUeXBlIGluZGV4VHlwZTsKLSAgICAgICAgYm9vbCBp c0RpcnR5OworICAgICAgICBjb25zdCBzdGQ6OnZlY3RvcjxJbmRleFJhbmdlPiByYW5nZXM7Cisg ICAgICAgIGNvbnN0IGdsOjpEcmF3RWxlbWVudHNUeXBlIGluZGV4VHlwZTsKICAgICB9OwotICAg IFJlc3RhcnRSYW5nZUNhY2hlIG1SZXN0YXJ0UmFuZ2VDYWNoZTsKKyAgICBzdGQ6Om9wdGlvbmFs PFJlc3RhcnRSYW5nZUNhY2hlPiBtUmVzdGFydFJhbmdlQ2FjaGU7CiAgICAgc3RkOjp2ZWN0b3I8 SW5kZXhSYW5nZT4gbVJlc3RhcnRJbmRpY2VzOwogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL0J1ZmZlck10bC5tbSBi L1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9tZXRhbC9CdWZm ZXJNdGwubW0KaW5kZXggOTAwYWVhOGFmYjk0YWUzMmIzNzcxMWRkYjgxMzZjNDNiMDMwOGI0OS4u MTc2NjI1NjkzMDkxNGIwMzAxMTk3MjRmMDFkMmFkYjJmNTQyNjlhMiAxMDA2NDQKLS0tIGEvU291 cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL0J1ZmZlck10 bC5tbQorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVuZGVyZXIv bWV0YWwvQnVmZmVyTXRsLm1tCkBAIC0zOTUsNyArMzk1LDcgQEAgdm9pZCBCdWZmZXJNdGw6Om1h cmtDb252ZXJzaW9uQnVmZmVyc0RpcnR5KCkKICAgICAgICAgYnVmZmVyLmNvbnZlcnRlZEJ1ZmZl ciA9IG51bGxwdHI7CiAgICAgICAgIGJ1ZmZlci5jb252ZXJ0ZWRPZmZzZXQgPSAwOwogICAgIH0K LSAgICBtUmVzdGFydFJhbmdlQ2FjaGUubWFya0RpcnR5KCk7CisgICAgbVJlc3RhcnRSYW5nZUNh Y2hlLnJlc2V0KCk7CiB9CiAKIHZvaWQgQnVmZmVyTXRsOjpjbGVhckNvbnZlcnNpb25CdWZmZXJz KCkKQEAgLTQwMyw3ICs0MDMsNyBAQCB2b2lkIEJ1ZmZlck10bDo6Y2xlYXJDb252ZXJzaW9uQnVm ZmVycygpCiAgICAgbVZlcnRleENvbnZlcnNpb25CdWZmZXJzLmNsZWFyKCk7CiAgICAgbUluZGV4 Q29udmVyc2lvbkJ1ZmZlcnMuY2xlYXIoKTsKICAgICBtVW5pZm9ybUNvbnZlcnNpb25CdWZmZXJz LmNsZWFyKCk7Ci0gICAgbVJlc3RhcnRSYW5nZUNhY2hlLm1hcmtEaXJ0eSgpOworICAgIG1SZXN0 YXJ0UmFuZ2VDYWNoZS5yZXNldCgpOwogfQogCiB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4KQEAgLTQz Myw5ICs0MzMsOSBAQCBzdGF0aWMgc3RkOjp2ZWN0b3I8SW5kZXhSYW5nZT4gY2FsY3VsYXRlUmVz dGFydFJhbmdlcyhDb250ZXh0TXRsICpjdHgsIG10bDo6QnVmZgogY29uc3Qgc3RkOjp2ZWN0b3I8 SW5kZXhSYW5nZT4gJkJ1ZmZlck10bDo6Z2V0UmVzdGFydEluZGljZXMoQ29udGV4dE10bCAqY3R4 LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgZ2w6OkRyYXdFbGVtZW50c1R5cGUgaW5kZXhUeXBlKQogewotICAgIGlmICghbVJlc3Rh cnRSYW5nZUNhY2hlIHx8IG1SZXN0YXJ0UmFuZ2VDYWNoZS5pbmRleFR5cGUgIT0gaW5kZXhUeXBl KQorICAgIGlmICghbVJlc3RhcnRSYW5nZUNhY2hlIHx8IG1SZXN0YXJ0UmFuZ2VDYWNoZS0+aW5k ZXhUeXBlICE9IGluZGV4VHlwZSkKICAgICB7Ci0gICAgICAgIG1SZXN0YXJ0UmFuZ2VDYWNoZS5t YXJrRGlydHkoKTsKKyAgICAgICAgbVJlc3RhcnRSYW5nZUNhY2hlLnJlc2V0KCk7CiAgICAgICAg IHN0ZDo6dmVjdG9yPEluZGV4UmFuZ2U+IHJhbmdlczsKICAgICAgICAgc3dpdGNoIChpbmRleFR5 cGUpCiAgICAgICAgIHsKQEAgLTQ1MSw5ICs0NTEsOSBAQCBjb25zdCBzdGQ6OnZlY3RvcjxJbmRl eFJhbmdlPiAmQnVmZmVyTXRsOjpnZXRSZXN0YXJ0SW5kaWNlcyhDb250ZXh0TXRsICpjdHgsCiAg ICAgICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgICAgIEFTU0VSVChmYWxzZSk7CiAgICAg ICAgIH0KLSAgICAgICAgbVJlc3RhcnRSYW5nZUNhY2hlID0gUmVzdGFydFJhbmdlQ2FjaGUoc3Rk Ojptb3ZlKHJhbmdlcyksIGluZGV4VHlwZSk7CisgICAgICAgIG1SZXN0YXJ0UmFuZ2VDYWNoZS5l bXBsYWNlKHN0ZDo6bW92ZShyYW5nZXMpLCBpbmRleFR5cGUpOwogICAgIH0KLSAgICByZXR1cm4g bVJlc3RhcnRSYW5nZUNhY2hlLnJhbmdlczsKKyAgICByZXR1cm4gbVJlc3RhcnRSYW5nZUNhY2hl LT5yYW5nZXM7CiB9CiAKIGNvbnN0IHN0ZDo6dmVjdG9yPEluZGV4UmFuZ2U+IEJ1ZmZlck10bDo6 Z2V0UmVzdGFydEluZGljZXNGcm9tQ2xpZW50RGF0YSgK 458121 2022-04-22 01:34:49 -0700 2022-04-25 00:05:46 -0700 Patch bug-239015-20220422113448.patch text/plain 5055 kkinnunen U3VidmVyc2lvbiBSZXZpc2lvbjogMjkzMTYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggNTgyYTc2MGZkNjNkNzM2Y2FlZDhlNGU2N2JmMGQ1MzVmNWRhMTVlMS4uMjJmM2U4MGViMjMz YmUyZjBmMTZmMjA5YzI3MzVhZTI0ZmE3MWM1MiAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDMwIEBACisyMDIyLTA0LTIyICBLaW1tbyBLaW5udW5lbiAgPGtraW5udW5l bkBhcHBsZS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lPTiAoU2FmYXJpIDE1LjQpIFBlcmZvcm1h bmNlIHJlZ3Jlc3Npb24gYWZ0ZXIgdXBsb2FkaW5nIFdlYkdMIGJ1ZmZlcnMKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIzOTAxNQorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEJ1ZmZlck10bDo6Z2V0UmVzdGFy dEluZGljZXMoKSB3b3VsZCByZWNhbGN1bGF0ZSByZXN0YXJ0IGluZGljZXMgb24gZWFjaAorICAg ICAgICBkcmF3IGJlY2F1c2UgUmVzdGFydFJhbmdlQ2FjaGU6Om9wZXJhdG9yIGJvb2woKSB3b3Vs ZCByZXR1cm4gbV9pc0RpcnR5CisgICAgICAgIGluc3RlYWQgb2YgdGhlIGludGVuZGVkICFtX2lz RGlydHkuCisKKyAgICAgICAgVXNlIHN0ZDo6b3B0aW9uYWwgdG8gaG9sZCB0aGUgUmVzdGFydFJh bmdlQ2FjaGUgaW5zdGVhZCBvZgorICAgICAgICBtYWludGFpbmluZyBtX2lzRGlydHkuIFRoaXMg YWxsb3dzIHRoZSB0eXBlIHN5c3RlbSB0byBjb250cmlidXRlIHRvIHRoZQorICAgICAgICBjb3Jy ZWN0bmVzcyBvZiB0aGUgY29kZS4gRGlydHkgcmVzdGFydCByYW5nZSBjYWNoZSBpcyBub3QgdXNl ZnVsIGFuZCB0YWtlcworICAgICAgICB1cCBtZW1vcnkuCisKKyAgICAgICAgUmUtYXBwbHkgaHVu a3MgZnJvbSByMjgxNTUwICJBTkdMRSBNZXRhbCBpbmRleCBidWZmZXIgbGVmdCBtYXBwZWQgd2hl biBidWlsZGluZyBwcmltaXRpdmUgcmVzdGFydCByYW5nZXMiLgorCisgICAgICAgIFRoZXNlIHdl cmUgb3ZlcndyaXR0ZW4gaW4gcjI4NjYzOCAiUm9sbCBBTkdMRSB0byBpbmNsdWRlIHVwc3RyZWFt ZWQgTWV0YWwgYmFja2VuZCIuCisKKyAgICAgICAgKiBzcmMvbGliQU5HTEUvcmVuZGVyZXIvbWV0 YWwvQnVmZmVyTXRsLmg6CisgICAgICAgIChyeDo6QnVmZmVyTXRsOjpSZXN0YXJ0UmFuZ2VDYWNo ZTo6UmVzdGFydFJhbmdlQ2FjaGUpOgorICAgICAgICAqIHNyYy9saWJBTkdMRS9yZW5kZXJlci9t ZXRhbC9CdWZmZXJNdGwubW06CisgICAgICAgIChyeDo6QnVmZmVyTXRsOjptYXJrQ29udmVyc2lv bkJ1ZmZlcnNEaXJ0eSk6CisgICAgICAgIChyeDo6QnVmZmVyTXRsOjpjbGVhckNvbnZlcnNpb25C dWZmZXJzKToKKyAgICAgICAgKHJ4OjpCdWZmZXJNdGw6OmdldFJlc3RhcnRJbmRpY2VzKToKKwog MjAyMi0wNC0xOCAgRWxsaW90dCBXaWxsaWFtcyAgPGVtd0BhcHBsZS5jb20+CiAKICAgICAgICAg W1hDQnVpbGRdIFVzZSBYQ0J1aWxkIGZvciBhbGwgY29tbWFuZC1saW5lIGFuZCBwcm9qZWN0IGJ1 aWxkcwpkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3Jl bmRlcmVyL21ldGFsL0J1ZmZlck10bC5oIGIvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xp YkFOR0xFL3JlbmRlcmVyL21ldGFsL0J1ZmZlck10bC5oCmluZGV4IDQzOGU4ZGFmZWI5YzRkMTg1 OTVhYjQ4NmY0ZTNlZWU3YTE1NmYyODUuLmMyMDY5MGM2MmVkMmUzYjY0YTUyZTUwYTlmMjhjN2Q5 OGJiZDUwNTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdM RS9yZW5kZXJlci9tZXRhbC9CdWZmZXJNdGwuaAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdM RS9zcmMvbGliQU5HTEUvcmVuZGVyZXIvbWV0YWwvQnVmZmVyTXRsLmgKQEAgLTEyLDYgKzEyLDcg QEAKIAogI2ltcG9ydCA8TWV0YWwvTWV0YWwuaD4KIAorI2luY2x1ZGUgPG9wdGlvbmFsPgogI2lu Y2x1ZGUgPHV0aWxpdHk+CiAKICNpbmNsdWRlICJsaWJBTkdMRS9CdWZmZXIuaCIKQEAgLTIxNSwx NyArMjE2LDEzIEBAIGNsYXNzIEJ1ZmZlck10bCA6IHB1YmxpYyBCdWZmZXJJbXBsLCBwdWJsaWMg QnVmZmVySG9sZGVyTXRsCiAKICAgICBzdHJ1Y3QgUmVzdGFydFJhbmdlQ2FjaGUKICAgICB7Ci0g ICAgICAgIFJlc3RhcnRSYW5nZUNhY2hlKCkgOiBpbmRleFR5cGUoZ2w6OkRyYXdFbGVtZW50c1R5 cGU6OkludmFsaWRFbnVtKSB7IGlzRGlydHkgPSB0cnVlOyB9CiAgICAgICAgIFJlc3RhcnRSYW5n ZUNhY2hlKHN0ZDo6dmVjdG9yPEluZGV4UmFuZ2U+ICYmcmFuZ2VzXywgZ2w6OkRyYXdFbGVtZW50 c1R5cGUgaW5kZXhUeXBlXykKLSAgICAgICAgICAgIDogcmFuZ2VzKHJhbmdlc18pLCBpbmRleFR5 cGUoaW5kZXhUeXBlXyksIGlzRGlydHkoZmFsc2UpCisgICAgICAgICAgICA6IHJhbmdlcyhyYW5n ZXNfKSwgaW5kZXhUeXBlKGluZGV4VHlwZV8pCiAgICAgICAgIHt9Ci0gICAgICAgIHZvaWQgbWFy a0RpcnR5KCkgeyBpc0RpcnR5ID0gdHJ1ZTsgfQotICAgICAgICBvcGVyYXRvciBib29sKCkgY29u c3QgeyByZXR1cm4gaXNEaXJ0eTsgfQotICAgICAgICBzdGQ6OnZlY3RvcjxJbmRleFJhbmdlPiBy YW5nZXM7Ci0gICAgICAgIGdsOjpEcmF3RWxlbWVudHNUeXBlIGluZGV4VHlwZTsKLSAgICAgICAg Ym9vbCBpc0RpcnR5OworICAgICAgICBjb25zdCBzdGQ6OnZlY3RvcjxJbmRleFJhbmdlPiByYW5n ZXM7CisgICAgICAgIGNvbnN0IGdsOjpEcmF3RWxlbWVudHNUeXBlIGluZGV4VHlwZTsKICAgICB9 OwotICAgIFJlc3RhcnRSYW5nZUNhY2hlIG1SZXN0YXJ0UmFuZ2VDYWNoZTsKKyAgICBzdGQ6Om9w dGlvbmFsPFJlc3RhcnRSYW5nZUNhY2hlPiBtUmVzdGFydFJhbmdlQ2FjaGU7CiAgICAgc3RkOjp2 ZWN0b3I8SW5kZXhSYW5nZT4gbVJlc3RhcnRJbmRpY2VzOwogfTsKIApkaWZmIC0tZ2l0IGEvU291 cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL0J1ZmZlck10 bC5tbSBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL3NyYy9saWJBTkdMRS9yZW5kZXJlci9tZXRh bC9CdWZmZXJNdGwubW0KaW5kZXggOTAwYWVhOGFmYjk0YWUzMmIzNzcxMWRkYjgxMzZjNDNiMDMw OGI0OS4uMTc2NjI1NjkzMDkxNGIwMzAxMTk3MjRmMDFkMmFkYjJmNTQyNjlhMiAxMDA2NDQKLS0t IGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvc3JjL2xpYkFOR0xFL3JlbmRlcmVyL21ldGFsL0J1 ZmZlck10bC5tbQorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9zcmMvbGliQU5HTEUvcmVu ZGVyZXIvbWV0YWwvQnVmZmVyTXRsLm1tCkBAIC0zOTUsNyArMzk1LDcgQEAgdm9pZCBCdWZmZXJN dGw6Om1hcmtDb252ZXJzaW9uQnVmZmVyc0RpcnR5KCkKICAgICAgICAgYnVmZmVyLmNvbnZlcnRl ZEJ1ZmZlciA9IG51bGxwdHI7CiAgICAgICAgIGJ1ZmZlci5jb252ZXJ0ZWRPZmZzZXQgPSAwOwog ICAgIH0KLSAgICBtUmVzdGFydFJhbmdlQ2FjaGUubWFya0RpcnR5KCk7CisgICAgbVJlc3RhcnRS YW5nZUNhY2hlLnJlc2V0KCk7CiB9CiAKIHZvaWQgQnVmZmVyTXRsOjpjbGVhckNvbnZlcnNpb25C dWZmZXJzKCkKQEAgLTQwMyw3ICs0MDMsNyBAQCB2b2lkIEJ1ZmZlck10bDo6Y2xlYXJDb252ZXJz aW9uQnVmZmVycygpCiAgICAgbVZlcnRleENvbnZlcnNpb25CdWZmZXJzLmNsZWFyKCk7CiAgICAg bUluZGV4Q29udmVyc2lvbkJ1ZmZlcnMuY2xlYXIoKTsKICAgICBtVW5pZm9ybUNvbnZlcnNpb25C dWZmZXJzLmNsZWFyKCk7Ci0gICAgbVJlc3RhcnRSYW5nZUNhY2hlLm1hcmtEaXJ0eSgpOworICAg IG1SZXN0YXJ0UmFuZ2VDYWNoZS5yZXNldCgpOwogfQogCiB0ZW1wbGF0ZSA8dHlwZW5hbWUgVD4K QEAgLTQzMyw5ICs0MzMsOSBAQCBzdGF0aWMgc3RkOjp2ZWN0b3I8SW5kZXhSYW5nZT4gY2FsY3Vs YXRlUmVzdGFydFJhbmdlcyhDb250ZXh0TXRsICpjdHgsIG10bDo6QnVmZgogY29uc3Qgc3RkOjp2 ZWN0b3I8SW5kZXhSYW5nZT4gJkJ1ZmZlck10bDo6Z2V0UmVzdGFydEluZGljZXMoQ29udGV4dE10 bCAqY3R4LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgZ2w6OkRyYXdFbGVtZW50c1R5cGUgaW5kZXhUeXBlKQogewotICAgIGlmICgh bVJlc3RhcnRSYW5nZUNhY2hlIHx8IG1SZXN0YXJ0UmFuZ2VDYWNoZS5pbmRleFR5cGUgIT0gaW5k ZXhUeXBlKQorICAgIGlmICghbVJlc3RhcnRSYW5nZUNhY2hlIHx8IG1SZXN0YXJ0UmFuZ2VDYWNo ZS0+aW5kZXhUeXBlICE9IGluZGV4VHlwZSkKICAgICB7Ci0gICAgICAgIG1SZXN0YXJ0UmFuZ2VD YWNoZS5tYXJrRGlydHkoKTsKKyAgICAgICAgbVJlc3RhcnRSYW5nZUNhY2hlLnJlc2V0KCk7CiAg ICAgICAgIHN0ZDo6dmVjdG9yPEluZGV4UmFuZ2U+IHJhbmdlczsKICAgICAgICAgc3dpdGNoIChp bmRleFR5cGUpCiAgICAgICAgIHsKQEAgLTQ1MSw5ICs0NTEsOSBAQCBjb25zdCBzdGQ6OnZlY3Rv cjxJbmRleFJhbmdlPiAmQnVmZmVyTXRsOjpnZXRSZXN0YXJ0SW5kaWNlcyhDb250ZXh0TXRsICpj dHgsCiAgICAgICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICAgICAgIEFTU0VSVChmYWxzZSk7 CiAgICAgICAgIH0KLSAgICAgICAgbVJlc3RhcnRSYW5nZUNhY2hlID0gUmVzdGFydFJhbmdlQ2Fj aGUoc3RkOjptb3ZlKHJhbmdlcyksIGluZGV4VHlwZSk7CisgICAgICAgIG1SZXN0YXJ0UmFuZ2VD YWNoZS5lbXBsYWNlKHN0ZDo6bW92ZShyYW5nZXMpLCBpbmRleFR5cGUpOwogICAgIH0KLSAgICBy ZXR1cm4gbVJlc3RhcnRSYW5nZUNhY2hlLnJhbmdlczsKKyAgICByZXR1cm4gbVJlc3RhcnRSYW5n ZUNhY2hlLT5yYW5nZXM7CiB9CiAKIGNvbnN0IHN0ZDo6dmVjdG9yPEluZGV4UmFuZ2U+IEJ1ZmZl ck10bDo6Z2V0UmVzdGFydEluZGljZXNGcm9tQ2xpZW50RGF0YSgK 458254 2022-04-25 02:26:21 -0700 2022-04-25 02:26:21 -0700 Example workaround element-buffer.html text/html 3736 kkinnunen PCFET0NUWVBFIGh0bWw+CjxodG1sPgo8aGVhZD4KPG1ldGEgY2hhcnNldD0idXRmLTgiPgo8bWV0 YSBuYW1lPSJ2aWV3cG9ydCIgY29udGVudD0id2lkdGg9ZGV2aWNlLXdpZHRoLCBpbml0aWFsLXNj YWxlPTEuMCwgdXNlci1zY2FsYWJsZT15ZXMiPgo8L2hlYWQ+Cjxib2R5Pgo8Y2FudmFzIGlkPSJj YW52YXMiPjwvY2FudmFzPgo8L2JvZHk+CjxzY3JpcHQ+CiJ1c2Ugc3RyaWN0IjsKCmZ1bmN0aW9u IG1haW4od29ya2Fyb3VuZCkgewogICAgdmFyIGNhbnZhcyA9IGRvY3VtZW50LnF1ZXJ5U2VsZWN0 b3IoIiNjYW52YXMiKTsKICAgIGNhbnZhcy53aWR0aCA9IDEwMDA7CiAgICBjYW52YXMuaGVpZ2h0 ID0gMTAwMDsKICAgIHZhciBnbCA9IGNhbnZhcy5nZXRDb250ZXh0KCJ3ZWJnbDIiKTsKICAgIGlm ICghZ2wpCiAgICAgICAgcmV0dXJuOwogICAgY29uc3QgZnN0ZXh0ID0gYHByZWNpc2lvbiBtZWRp dW1wIGZsb2F0Owp1bmlmb3JtIHZlYzQgdV9jb2xvcjsKdm9pZCBtYWluKCkgewogICBnbF9GcmFn Q29sb3IgPSB1X2NvbG9yOwp9YDsKICAgIGNvbnN0IHZzdGV4dCA9IGBhdHRyaWJ1dGUgdmVjMiBh X3Bvc2l0aW9uOwp1bmlmb3JtIHZlYzIgdV9yZXNvbHV0aW9uOwp2b2lkIG1haW4oKSB7CiAgIHZl YzIgY2xpcFNwYWNlID0gYV9wb3NpdGlvbiAvIHVfcmVzb2x1dGlvbiAqIDIuIC0gMS47CiAgIGds X1Bvc2l0aW9uID0gdmVjNChjbGlwU3BhY2UgKiB2ZWMyKDEsIC0xKSwgMCwgMSk7Cn1gOwoKICAg IGNvbnN0IHZzID0gZ2wuY3JlYXRlU2hhZGVyKGdsLlZFUlRFWF9TSEFERVIpOwogICAgZ2wuc2hh ZGVyU291cmNlKHZzLCB2c3RleHQpOwogICAgZ2wuY29tcGlsZVNoYWRlcih2cyk7CiAgICBjb25z dCBmcyA9IGdsLmNyZWF0ZVNoYWRlcihnbC5GUkFHTUVOVF9TSEFERVIpOwogICAgZ2wuc2hhZGVy U291cmNlKGZzLCBmc3RleHQpOwogICAgZ2wuY29tcGlsZVNoYWRlcihmcyk7CiAgICBjb25zdCBw cm9ncmFtID0gZ2wuY3JlYXRlUHJvZ3JhbSgpOwogICAgZ2wuYXR0YWNoU2hhZGVyKHByb2dyYW0s IHZzKTsKICAgIGdsLmF0dGFjaFNoYWRlcihwcm9ncmFtLCBmcyk7CiAgICBnbC5saW5rUHJvZ3Jh bShwcm9ncmFtKQogICAgdmFyIHBvc2l0aW9uQXR0cmlidXRlTG9jYXRpb24gPSBnbC5nZXRBdHRy aWJMb2NhdGlvbihwcm9ncmFtLCAiYV9wb3NpdGlvbiIpOwogICAgdmFyIHJlc29sdXRpb25Vbmlm b3JtTG9jYXRpb24gPSBnbC5nZXRVbmlmb3JtTG9jYXRpb24ocHJvZ3JhbSwgInVfcmVzb2x1dGlv biIpOwogICAgdmFyIGNvbG9yVW5pZm9ybUxvY2F0aW9uID0gZ2wuZ2V0VW5pZm9ybUxvY2F0aW9u KHByb2dyYW0sICJ1X2NvbG9yIik7CgogICAgZ2wudmlld3BvcnQoMCwgMCwgZ2wuY2FudmFzLndp ZHRoLCBnbC5jYW52YXMuaGVpZ2h0KTsKICAgIGdsLmNsZWFyQ29sb3IoMCwgMCwgMCwgMCk7CiAg ICBnbC5jbGVhcihnbC5DT0xPUl9CVUZGRVJfQklUKTsKICAgIGdsLnVzZVByb2dyYW0ocHJvZ3Jh bSk7CgoKICAgIGNvbnN0IGluZGV4QnVmZmVyID0gZ2wuY3JlYXRlQnVmZmVyKCk7CiAgICBnbC5i aW5kQnVmZmVyKGdsLkVMRU1FTlRfQVJSQVlfQlVGRkVSLCBpbmRleEJ1ZmZlcik7CgogICAgY29u c3QgY291bnQgPSAyMDAwMDA7CiAgICB2YXIgaWR4cyA9IG5ldyBVaW50MTZBcnJheShjb3VudCAq IDYpOwogICAgZm9yIChsZXQgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CiAgICAgICAgaWR4c1tp KjZdID0gMCArIGkqNDsKICAgICAgICBpZHhzW2kqNisxXSA9IDEgKyBpKjQ7CiAgICAgICAgaWR4 c1tpKjYrMl0gPSAyICsgaSo0OwogICAgICAgIGlkeHNbaSo2KzNdID0gMiArIGkqNDsKICAgICAg ICBpZHhzW2kqNis0XSA9IDEgKyBpKjQ7CiAgICAgICAgaWR4c1tpKjYrNV0gPSAzICsgaSo0Owog ICAgfQogICAgZ2wuYnVmZmVyRGF0YShnbC5FTEVNRU5UX0FSUkFZX0JVRkZFUiwgaWR4cywgZ2wu U1RBVElDX0RSQVcpOwoKICAgIHZhciBwb3NpdGlvbkJ1ZmZlciA9IGdsLmNyZWF0ZUJ1ZmZlcigp OwogICAgZ2wuYmluZEJ1ZmZlcihnbC5BUlJBWV9CVUZGRVIsIHBvc2l0aW9uQnVmZmVyKTsKICAg IGNvbnN0IGEgPSBuZXcgRmxvYXQzMkFycmF5KGNvdW50ICogOCk7CiAgICBmb3IgKHZhciBpaSA9 IDA7IGlpIDwgY291bnQ7ICsraWkpIHsKICAgICAgICBjb25zdCB3aWR0aCA9IDMwOwogICAgICAg IGNvbnN0IGhlaWdodCA9IDMwOwogICAgICAgIHZhciB4MSA9IChpaSAlIDMwMCkgKiB3aWR0aDsK ICAgICAgICB2YXIgeDIgPSB4MSArIHdpZHRoOwogICAgICAgIHZhciB5MSA9IChpaSAvIDMwMCkg KiBoZWlnaHQ7CiAgICAgICAgdmFyIHkyID0geTEgKyBoZWlnaHQ7CiAgICAgICAgYVtpaSo4XSA9 IHgxOwogICAgICAgIGFbaWkqOCsxXSA9IHkxOwogICAgICAgIGFbaWkqOCsyXSA9IHgyOwogICAg ICAgIGFbaWkqOCszXSA9IHkxOwogICAgICAgIGFbaWkqOCs0XSA9IHgxOwogICAgICAgIGFbaWkq OCs1XSA9IHkyOwogICAgICAgIGFbaWkqOCs2XSA9IHgyOwogICAgICAgIGFbaWkqOCs3XSA9IHky OwogICAgfQogICAgZ2wuYnVmZmVyRGF0YShnbC5BUlJBWV9CVUZGRVIsIGEsIGdsLlNUQVRJQ19E UkFXKTsKCiAgICBnbC5lbmFibGVWZXJ0ZXhBdHRyaWJBcnJheShwb3NpdGlvbkF0dHJpYnV0ZUxv Y2F0aW9uKTsKCiAgICB2YXIgc2l6ZSA9IDI7CiAgICB2YXIgdHlwZSA9IGdsLkZMT0FUOwogICAg dmFyIG5vcm1hbGl6ZSA9IGZhbHNlOwogICAgdmFyIHN0cmlkZSA9IDA7CiAgICB2YXIgb2Zmc2V0 ID0gMDsKICAgIGdsLnZlcnRleEF0dHJpYlBvaW50ZXIocG9zaXRpb25BdHRyaWJ1dGVMb2NhdGlv biwgc2l6ZSwgdHlwZSwgbm9ybWFsaXplLCBzdHJpZGUsIG9mZnNldCk7CiAgICBnbC51bmlmb3Jt MmYocmVzb2x1dGlvblVuaWZvcm1Mb2NhdGlvbiwgZ2wuY2FudmFzLndpZHRoLCBnbC5jYW52YXMu aGVpZ2h0KTsKICAgIGdsLnVuaWZvcm00Zihjb2xvclVuaWZvcm1Mb2NhdGlvbiwgTWF0aC5yYW5k b20oKSwgTWF0aC5yYW5kb20oKSwgTWF0aC5yYW5kb20oKSwgMSk7CgogICAgdmFyIHByaW1pdGl2 ZVR5cGUgPSBnbC5UUklBTkdMRVM7CiAgICB2YXIgb2Zmc2V0ID0gMDsKICAgIHZhciBpbmRleFR5 cGUgPSBnbC5VTlNJR05FRF9TSE9SVDsKICAgIGZ1bmN0aW9uIGQoKSB7CiAgICAgICAgZ2wudW5p Zm9ybTRmKGNvbG9yVW5pZm9ybUxvY2F0aW9uLCBNYXRoLnJhbmRvbSgpLCBNYXRoLnJhbmRvbSgp LCBNYXRoLnJhbmRvbSgpLCAxKTsKICAgICAgICBjb25zdCBiZWZvcmUgPSBwZXJmb3JtYW5jZS5u b3coKTsKICAgICAgICBnbC5kcmF3RWxlbWVudHMocHJpbWl0aXZlVHlwZSwgY291bnQgKiA2LCBp bmRleFR5cGUsIG9mZnNldCk7CiAgICAgICAgY29uc29sZS5sb2coYGRyYXcgdG9vazogJHtwZXJm b3JtYW5jZS5ub3coKSAtIGJlZm9yZX0gbXMgJHt3b3JrYXJvdW5kID8gIndpdGgiIDogIndpdGhv dXQifSB3b3JrYXJvdW5kYCkKICAgICAgICB3aW5kb3cucmVxdWVzdEFuaW1hdGlvbkZyYW1lKGQp OwogICAgfTsKICAgIGQoKTsKICAgIGlmICh3b3JrYXJvdW5kKQogICAgICAgIGdsLmJ1ZmZlclN1 YkRhdGEoZ2wuRUxFTUVOVF9BUlJBWV9CVUZGRVIsIDAsIG5ldyBVaW50MTZBcnJheShbMF0pKTsK fQoKPC9zY3JpcHQ+CjxidXR0b24gb25jbGljaz0iamF2YXNjcmlwdDptYWluKHRydWUpIj5Xb3Jr YXJvdW5kPC9idXR0b24+CjxidXR0b24gb25jbGljaz0iamF2YXNjcmlwdDptYWluKGZhbHNlKSI+ Tm8gd29ya2Fyb3VuZDwvYnV0dG9uPgo8L2h0bWw+Cg==