431951 2021-01-22 18:51:46 +0000 UI lockup for upwards of 15 seconds while just scrolling album views and selecting images 2021-02-19 19:06:07 +0000 1 1 2 Applications digikam Database-Sqlite 7.2.0 Arch Linux Linux RESOLVED FIXED NOR normal --- 0 griffiths_andy digikam-bugs-null caulier.gilles metzpinguin 7.2.0 0 oldest_to_newest 1996890 0 griffiths_andy 2021-01-22 18:51:46 +0000 SUMMARY Whenever I am doing any work on my database, occasionally the UI locks up for upwards of 15 seconds for no apparent reason. During the lockup I can't scroll anything in the album view (also applies in other views eg tags). I have run digikam with the message debugging on, and the only thing I can correlate this with messages from digikam.general digikam.general: Action Thread run 1 new jobs # UI locks up now digikam.general: One job is done digikam.general: Cancel Main Thread # UI recovers There's no indication of what that job is doing, but for it's duration I am locked out. I'm not doing anything special or out of the ordinary when this happens. I could be scrolling up and down in the album, or selecting images. Is there any extra debug output I can enable? All other logging eg. thumbnails, detection, or SQL statments appear as normal. I'm running a self compiled digikam build 7.2 from Arch AUR. The revision is https://invent.kde.org/graphics/digikam/commit/fd85e5002c0a0dc24a4583c67c3f157b55d35d29 I'm using the beta because I was keen to see if this issue had been resolved with newer revisions, but I find it's the same issue as I've had since 7.0. This issue seems to have plagued me for quite some time in 7.0 onwards. I have a large database of images (300,000+) on MySQL backend, db is on SSD. Most of the images live on USB3 attached disk, but this problem affects images also in the internal SSD. STEPS TO REPRODUCE 1. QT_LOGGING_RULES="digikam.*=true" digikam 2. Use digikam while observing the console 3. Note that lockup occurs on 'digikam.general: Action Thread run 1 new jobs' 4. Note that lockup frees on 'digikam.general: Cancel Main Thread' OBSERVED RESULT UI locks up occasionally for a long time EXPECTED RESULT UI should not lockup SOFTWARE/OS VERSIONS Windows: macOS: Linux/KDE Plasma: ArchLinux (available in About System) KDE Plasma Version: 5.20.5 KDE Frameworks Version: 5.78.0 Qt Version: 5.15.2 ADDITIONAL INFORMATION 1996891 1 griffiths_andy 2021-01-22 18:58:37 +0000 Forgot to mention. The digikam process hits 100% CPU while this is happening. The sub threads (QT processes, mysqld) appear to be unaffected. 1996893 2 caulier.gilles 2021-01-22 19:08:04 +0000 Can you reproduce this problem with 7.2.0 RC AppImage bundle for linux ? https://files.kde.org/digikam/ Gilles Caulier 1996896 3 griffiths_andy 2021-01-22 19:13:45 +0000 I'll try, but I always have issues running the appimage, and have to mess around with eg. QT_XCB_GL_INTEGRATION=none Downloads/digikam-7.2.0-beta1-x86-64.appimage I only found that workaround after a long investigation. I'll try again with the 7.2.0 RC 1996900 4 griffiths_andy 2021-01-22 19:27:28 +0000 QT_LOGGING_RULES="digikam.*=true" QT_XCB_GL_INTEGRATION=none Downloads/digiKam-7.2.0-rc-20210122T180600-x86-64.appimage Still happens occasionally but the delay is much shorter, maybe only 2 or 3 seconds. It's a lot less frequent. All the versions I have had a problem with in the past have either been Arch official package releases, or AUR compiles. So whatever is different is in the Arch libs I suppose. 1996904 5 metzpinguin 2021-01-22 19:59:18 +0000 The problem should only occur if the tags view in the right sidebar is open and many images are selected. In order to get the tag status (selected, partially selected, etc.) the tags and metadata of all images must be read. This is a sequential process for MySQL that is quite slow. I don't see any way to improve it at the moment. In frequent queries, MySQL is significantly slower as than SQLite on an SSD. Maik 1996907 6 metzpinguin 2021-01-22 20:07:47 +0000 By the way, the text fields for title and description are the main problems. To get the status whether all have the same or different content, all must be read. If you have empty content here, it will take a particularly long time. Maik 1996911 7 griffiths_andy 2021-01-22 20:27:29 +0000 (In reply to Maik Qualmann from comment #5) > The problem should only occur if the tags view in the right sidebar is open > and many images are selected. In order to get the tag status (selected, > partially selected, etc.) the tags and metadata of all images must be read. > This is a sequential process for MySQL that is quite slow. I don't see any > way to improve it at the moment. In frequent queries, MySQL is significantly > slower as than SQLite on an SSD. > > Maik That's not what I experience. It happens also when file properties is open, and when just scrolling through images, not necessarily selecting them, so there is no change in file properties (or tags if that view is open). I could understand that the query process for retrieving tags is time consuming, but that is not the only trigger. Would you suggest I do a comparison with an SQLite database (if so I can do a conversion using the migration tool)? I'm on MySQL due to the recommendations re number of images. 1996913 8 griffiths_andy 2021-01-22 20:29:11 +0000 (In reply to Maik Qualmann from comment #6) > By the way, the text fields for title and description are the main problems. > To get the status whether all have the same or different content, all must > be read. If you have empty content here, it will take a particularly long > time. > > Maik Maik, Are you commenting on the correct bug? Your reply seems to be unrelated to what I'm talking about. 1996929 9 metzpinguin 2021-01-22 21:37:49 +0000 Yes, I'm in the right thread ((:-)) Problems with scrolling are not known and I cannot reproduce them here with MySQL. Run digiKam in the GDB, stop it if the problem occurs, copy the backtrace and continue digiKam. Do this a few times. Then maybe we can assess what digiKam is doing. Maik 1996934 10 griffiths_andy 2021-01-22 21:50:43 +0000 (In reply to Maik Qualmann from comment #9) > Yes, I'm in the right thread ((:-)) > Problems with scrolling are not known and I cannot reproduce them here with > MySQL. Run digiKam in the GDB, stop it if the problem occurs, copy the > backtrace and continue digiKam. Do this a few times. Then maybe we can > assess what digiKam is doing. > > Maik Ah Ok, just thought I'd check! Ok, I'll look at producing the backtraces. I'll probably end up doing it a few times with different setups, all properly documented of course. eg. my build using MySQL my build using SQLite appimage using MySQL appimage using SQLite I'll probably update my build to the same rev as the 7.2 RC for consistency. I'm currently converting a copy of my MySQL db to SQLite, as it's been a very long time since I've used digikam with SQLite and I'd like to compare performance anyway. I'll report back... 1996935 11 griffiths_andy 2021-01-22 21:54:23 +0000 (In reply to griffiths_andy from comment #10) > (In reply to Maik Qualmann from comment #9) > > Yes, I'm in the right thread ((:-)) > > Problems with scrolling are not known and I cannot reproduce them here with > > MySQL. Run digiKam in the GDB, stop it if the problem occurs, copy the > > backtrace and continue digiKam. Do this a few times. Then maybe we can > > assess what digiKam is doing. > > > > Maik > > Ah Ok, just thought I'd check! > > Ok, I'll look at producing the backtraces. I'll probably end up doing it a > few times with different setups, all properly documented of course. > > eg. > my build using MySQL > my build using SQLite > appimage using MySQL > appimage using SQLite > > I'll probably update my build to the same rev as the 7.2 RC for consistency. > > I'm currently converting a copy of my MySQL db to SQLite, as it's been a > very long time since I've used digikam with SQLite and I'd like to compare > performance anyway. > > I'll report back... Hmm maybe not do the backtraces for the appimage.. 1996937 12 metzpinguin 2021-01-22 22:02:15 +0000 The AppImage isn't that well suited for this. You cannot run it in an external GDB. You have to download the debug version of the AppImage and start it with the debug option because it has an internal GDB. Maik 1996939 13 metzpinguin 2021-01-22 22:04:33 +0000 Another question, does the number of images in the icon view make any difference? How many images are we assuming in the view? Maik 1996944 14 griffiths_andy 2021-01-22 22:10:41 +0000 The number of images varies with album. It could be 10 to 1000. I haven't noticed any correlation between the number vs. the likelihood or duration of the hang, but I'll look out for it. Noted re. debug appimage. If I need to I'll try that one also. 1996976 15 caulier.gilles 2021-01-23 02:37:14 +0000 To Maik, comment #12: debug appimage version do not have an internal GDB inside. the "debug" argument run the internal main executable with the GDB from the host system. See the main internal bash script used internally to run AppImage binary: https://invent.kde.org/graphics/digikam/-/blob/master/project/bundles/appimage/data/AppRun#L127 The difference between the standard appimage bundle and the debug version is the debug symbols dropped or not from all binaries (.so, .a, executable files, etc.). This id done at last stage of bundle compilation where the bash script parse all binaries one by one to strip debug symbols. https://invent.kde.org/graphics/digikam/-/blob/master/project/bundles/appimage/04-build-appimage.sh#L402 Typically both version of appimage bundles are the same excepted the strip debug stage, which reduce by 2 the file size... Gilles 1997071 16 griffiths_andy 2021-01-23 12:27:27 +0000 Well, I can say with a small amount of confidence that I think my issue is related to my MySQL db. I have completed the MySQL to SQLite conversion overnight, and I'm now trying it out in both my own compiled binary and in the appimage. Performance is now very good in both. There are no hangups while scrolling or selecting. I have a total of 402,000 files in the db which gave a 10GB thumbnail table and 620MB ImageHaarMatrix table in the old MySQL db. Total image size is probably 4TB+. Obviously I haven't got a comparison yet in the SQLite db until the thumbnail db is populated, and I've yet to try face recognition again. Would it be safe to say that my old db was severely underperforming and full of redundant data (despite regular db maintenance)? I've been using it since 6.4 IIRC. If I get the time I'm going to try a MySQL to MySQL conversion and see whether there is any comparison in table sizes over time. For the moment though, I'll continue with the new db and see whether running face recognition (and retagging ofc unfortunately as that was lost) has any detrimental effect. I don't think I need to do any tests for GDB backtraces. Gilles & Maik, Thanks for your help and guidance so far! 1997100 17 griffiths_andy 2021-01-23 16:12:29 +0000 I'm getting lockups again, so I'll start doing the backtraces. So far it looks like Mutex locking in Digikam::CoreDbAccess::CoreDbAccess(), but I'll post proper logs later. 1997107 18 135103 griffiths_andy 2021-01-23 16:36:05 +0000 Created attachment 135103 Backtraces from digikam lockups Backtraces as requested. A range of actions were the cause: scrolling, selecting, renaming, deleting. 1997112 19 griffiths_andy 2021-01-23 17:20:43 +0000 I noticed that my binary was built without symbols, so I'm going to recompile and retest. 1997113 20 metzpinguin 2021-01-23 17:41:08 +0000 Debug symbols are not necessary. I also know ao where the breakpoints are in the code. I have no idea why you are having the problem with MySQL. The CoreDbAccess() lock is wanted. The database is being accessed in another thread. So certain database accesses must take a long time before a response is received. Maik 1997118 21 griffiths_andy 2021-01-23 17:52:34 +0000 I'm on SQLite now, as I mentioned above. Still experiencing the same issue occasionally. 1997163 22 metzpinguin 2021-01-23 21:52:57 +0000 Git commit e9b438fdac100a7f0ea85f8078aec4080b47468a by Maik Qualmann. Committed on 23/01/2021 at 21:51. Pushed by mqualmann into branch 'master'. use item count from the item model SELECT COUNT() can be very slow for many items in the table. And we call it up very often when selecting items. M +1 -4 core/app/main/digikamapp.cpp M +1 -0 core/app/views/stack/itemiconview.h M +5 -0 core/app/views/stack/itemiconview_items.cpp M +0 -15 core/libs/database/coredb/coredb.cpp M +0 -6 core/libs/database/coredb/coredb.h M +5 -0 core/libs/database/models/itemmodel.cpp M +1 -0 core/libs/database/models/itemmodel.h https://invent.kde.org/graphics/digikam/commit/e9b438fdac100a7f0ea85f8078aec4080b47468a 1997177 23 griffiths_andy 2021-01-23 23:12:18 +0000 Thanks. Compiling now, I'll report back... 1997179 24 135120 griffiths_andy 2021-01-23 23:44:25 +0000 Created attachment 135120 Backtrace 1997181 25 griffiths_andy 2021-01-23 23:47:19 +0000 Maik, It still does it. In the latest backtrace, I Ctrl-C as soon as I feel its locked up, and then 'bt' and leisurely read the output. Once I continue execution it still hangs for a number of seconds before the 'digikam.general: One job is done' message. 2000904 26 griffiths_andy 2021-02-07 23:26:00 +0000 I'm trying to accumulate a bit more information on this issue for you. Currently I'm running https://invent.kde.org/graphics/digikam/commit/4c6b84b15cd6111aa9d3dfb430635a754f40ccba directly compiled as per your standard instructions (not via Arch AUR). I'm using SQLite. Given that the potential issue (still occurring) is happening around database access I wanted to pin down which SQL statements are active at the time I experience the hangs. I expected to see the SQL statements appearing in logs when QT_LOGGING_RULES="digikam.*=true", but they do not. Everything else is logged but not SQL. eg. in core/libs/database/coredb/coredb.cpp QMap<QString, int> map; QString queryString = QString::fromUtf8("SELECT COUNT(*), II.format " "FROM ImageInformation AS II " "INNER JOIN Images ON II.imageid=Images.id " " WHERE Images.status=1 "); if (category != DatabaseItem::UndefinedCategory) { queryString.append(QString::fromUtf8("AND Images.category=%1 ").arg(category)); } queryString.append(QString::fromUtf8("GROUP BY II.format;")); qCDebug(DIGIKAM_DATABASE_LOG) << queryString; etc..... I expected with the logging level set as so, that all would be logged. 2000905 27 griffiths_andy 2021-02-07 23:35:29 +0000 To clarify.. I do see some digikam.database output when logging, just not the SQL. 2000912 28 griffiths_andy 2021-02-07 23:57:54 +0000 Hmm.. Have I just picked one of the very few places SQL is logged in that file? Is it not performed generally? I picked QMap<QString, int> CoreDB::getFormatStatistics(DatabaseItem::Category category) const but I see that lots of other methods don't log. Sorry for the misdirection if that's the case, but I think it would be a great help if SQL could be logged at the point the database call is actually performed. 2000931 29 metzpinguin 2021-02-08 08:54:55 +0000 If you can scroll the view, i.e. the items became visible. A large part of the database is already in the ItemInfo cache. So things like date, file size and much more and are not reloaded from the database again. There are very few things that are still loaded when scrolling when they are needed, e.g. the tags, but are then also in the cache. The thumbnails are also reloaded when they are needed, but you don't seem to have a thumbnail lock. But there are no database queries in digiKam that would take 15 seconds, even the complex SQL queries of an advanced search do not take a second. I suspect some other or external problem here. Maik 2000980 30 griffiths_andy 2021-02-08 14:11:13 +0000 Agreed, the fundamental problem remains that it's having trouble for whatever reason waiting to lock a mutex before doing some operation and this locks up the whole UI. Logging the SQL was a roundabout way of trying to establish what its doing at that point. I don't have issues with any other application at the same time, there's plenty of memory, so no swap issues, no IO waits. I did a test with QT_LOGGING_RULES="qt.*=true", and there were still plenty of Qt messages when it locked up while still moving the mouse around, *BUT* they appeared to be: qt.qpa.events.reader: [heap] 202 qt.qpa.events.reader: [heap] 203 qt.qpa.events.reader: [heap] 204 qt.qpa.events.reader: [heap] 205 qt.qpa.events.reader: [heap] 206 qt.qpa.events.reader: [heap] 207 qt.qpa.events.reader: [heap] 208 qt.qpa.events.reader: [heap] 209 qt.qpa.events.reader: [heap] 210 etc.. which feels like the events were getting queued up. Could my issue be more Qt related? I appreciate that you can't replicate this issue so I just need a bit of guidance so I can provide you with enough info to sort this out. I don't have any other hardware / OS combination on which to test so I have to work with what I've got. 2003587 31 135802 griffiths_andy 2021-02-17 23:09:11 +0000 Created attachment 135802 Timestamped log showing UI lockup delay during possible mutex contention More debugging info. Build http://commits.kde.org/digikam/46fd680f2328c7ff3c55a0b538271c326c781063 Invoke digikam thru ts (timestamp input) $ gdb digikam | ts | tee digikam_timestamped_log.txt With this run I have attempted to timestamp the gdb output in order to accurately work out the delay during which the UI is unresponsive (accounting for the time in GDB examining the backtraces and threads. In every case where I have performed this I have found that the UI is locked while the main thread and the "DBJobsThread" are contending for a mutex (to my eye...) Overall there is a delay of 14 seconds, which occurs randomly, and usually at the most inconvenient point. My comments in the attached file are prefixed ** 2003651 32 metzpinguin 2021-02-18 06:50:10 +0000 We are at the mutex where the item view wants to read the information for the geo-icon in the thumbnail. The mutex on which the thread is waiting has nothing to do with the CoreDbAccess mutex. I'll add a debug timer for how long each CoreDbAccess mutex is taking. Maik 2003655 33 metzpinguin 2021-02-18 07:06:15 +0000 Git commit 9bed4e982ab4b2f294e5e5f9e106d55baa08a6f6 by Maik Qualmann. Committed on 18/02/2021 at 07:05. Pushed by mqualmann into branch 'master'. add test debug for CoreDbAccess lock time M +10 -0 core/libs/database/coredb/coredbaccess.cpp https://invent.kde.org/graphics/digikam/commit/9bed4e982ab4b2f294e5e5f9e106d55baa08a6f6 2003656 34 metzpinguin 2021-02-18 07:09:11 +0000 A message is output if the lock time is longer than 10 ms. First of all, we check whether a CoreDbAccess lock takes a long time. Maik 2003657 35 metzpinguin 2021-02-18 07:13:41 +0000 Git commit c958341c0f442cf7bdc2e8adb35cc2f329bcd030 by Maik Qualmann. Committed on 18/02/2021 at 07:13. Pushed by mqualmann into branch 'master'. restart timer after lock M +2 -2 core/libs/database/coredb/coredbaccess.cpp https://invent.kde.org/graphics/digikam/commit/c958341c0f442cf7bdc2e8adb35cc2f329bcd030 2003666 36 caulier.gilles 2021-02-18 07:28:20 +0000 Andy, The new AppImage Linux bundle including last changes from Maik will be available today late this evening at usual place: https://files.kde.org/digikam/ Gilles Caulier 2003735 37 griffiths_andy 2021-02-18 10:41:47 +0000 Thanks... I've compiled from source as usual, http://commits.kde.org/digikam/54974097ef336dc9ba1edaa90bbade42529ab084 Although I've run in GDB again I have not paused at the delay, as that affects the timer you've just coded in. Instead I paused after the UI became responsive again: digikam.general: Using 4 CPU core to run threads [New Thread 0x7fff377fe640 (LWP 1026906)] digikam.general: Action Thread run 1 new jobs [New Thread 0x7fff37fff640 (LWP 1026907)] digikam.coredb: CoreDbAccess lock time: 12870 ms digikam.general: One job is done [Thread 0x7fff377fe640 (LWP 1026906) exited] digikam.general: Cancel Main Thread [Thread 0x7fff37fff640 (LWP 1026907) exited] ^C Thread 1 "digikam" received signal SIGINT, Interrupt. 0x00007ffff3ce946f in poll () from /usr/lib/libc.so.6 (gdb) Quit (gdb) c Continuing. 2003762 38 metzpinguin 2021-02-18 11:40:32 +0000 Ok, almost 13 seconds for a database query is a problem. However, I suspect the problem outside of digiKam. Let's see which query it concerns, we crash digikam at 10 seconds. Maik 2003763 39 metzpinguin 2021-02-18 11:42:41 +0000 Git commit f9a9d695c5a499291581a59dc1163b7c752a0ea1 by Maik Qualmann. Committed on 18/02/2021 at 11:41. Pushed by mqualmann into branch 'master'. crash at 10 seconds lock time M +2 -0 core/libs/database/coredb/coredbaccess.cpp https://invent.kde.org/graphics/digikam/commit/f9a9d695c5a499291581a59dc1163b7c752a0ea1 2003773 40 griffiths_andy 2021-02-18 12:02:41 +0000 Heh.. this was straight away during program startup. Not even displaying main UI yet, just the splash. digikam.general: Action Thread run 1 new jobs [New Thread 0x7fff31ffb640 (LWP 1043703)] digikam.coredb: CoreDbAccess lock time: 12022 ms ASSERT: "d->timer.elapsed() < 10000" in file /home/andyg/projects/digikam/core/libs/database/coredb/coredbaccess.cpp, line 143 --Type <RET> for more, q to quit, c to continue without paging-- Thread 45 "Thread (pooled)" received signal SIGABRT, Aborted. [Switching to Thread 0x7fff31ffb640 (LWP 1043703)] 0x00007ffff3c31615 in raise () from /usr/lib/libc.so.6 (gdb) bt #0 0x00007ffff3c31615 in raise () at /usr/lib/libc.so.6 #1 0x00007ffff3c1a862 in abort () at /usr/lib/libc.so.6 #2 0x00007ffff41ef9ac in () at /usr/lib/libQt5Core.so.5 #3 0x00007ffff41eed59 in qt_assert_x(char const*, char const*, char const*, int) () at /usr/lib/libQt5Core.so.5 #4 0x00007ffff70931a1 in Digikam::CoreDbAccess::~CoreDbAccess() (this=0x7fff31ffa748, __in_chrg=<optimized out>) at /home/andyg/projects/digikam/core/libs/database/coredb/coredbaccess.cpp:143 #5 0x00007ffff70adfbe in Digikam::DatesJob::run() (this=0x555556b2c610) at /home/andyg/projects/digikam/core/libs/database/dbjobs/dbjob.cpp:102 #6 0x00007ffff4230302 in () at /usr/lib/libQt5Core.so.5 #7 0x00007ffff422cf0f in () at /usr/lib/libQt5Core.so.5 #8 0x00007ffff3dc83e9 in start_thread () at /usr/lib/libpthread.so.0 #9 0x00007ffff3cf4293 in clone () at /usr/lib/libc.so.6 2003775 41 griffiths_andy 2021-02-18 12:12:17 +0000 A second try. Crashes at the same place. Digikam::DatesJob::run() [New Thread 0x7fff31ffb640 (LWP 1045062)] digikam.coredb: CoreDbAccess lock time: 11949 ms ASSERT: "d->timer.elapsed() < 10000" in file /home/andyg/projects/digikam/core/libs/database/coredb/coredbaccess.cpp, line 143 --Type <RET> for more, q to quit, c to continue without paging-- Thread 45 "Thread (pooled)" received signal SIGABRT, Aborted. [Switching to Thread 0x7fff31ffb640 (LWP 1045062)] 0x00007ffff3c31615 in raise () from /usr/lib/libc.so.6 (gdb) bt #0 0x00007ffff3c31615 in raise () at /usr/lib/libc.so.6 #1 0x00007ffff3c1a862 in abort () at /usr/lib/libc.so.6 #2 0x00007ffff41ef9ac in () at /usr/lib/libQt5Core.so.5 #3 0x00007ffff41eed59 in qt_assert_x(char const*, char const*, char const*, int) () at /usr/lib/libQt5Core.so.5 #4 0x00007ffff70931a1 in Digikam::CoreDbAccess::~CoreDbAccess() (this=0x7fff31ffa748, __in_chrg=<optimized out>) at /home/andyg/projects/digikam/core/libs/database/coredb/coredbaccess.cpp:143 #5 0x00007ffff70adfbe in Digikam::DatesJob::run() (this=0x555556c9b6f0) at /home/andyg/projects/digikam/core/libs/database/dbjobs/dbjob.cpp:102 #6 0x00007ffff4230302 in () at /usr/lib/libQt5Core.so.5 #7 0x00007ffff422cf0f in () at /usr/lib/libQt5Core.so.5 #8 0x00007ffff3dc83e9 in start_thread () at /usr/lib/libpthread.so.0 #9 0x00007ffff3cf4293 in clone () at /usr/lib/libc.so.6 2003801 42 metzpinguin 2021-02-18 13:20:49 +0000 We Are Here: https://invent.kde.org/graphics/digikam/-/blob/master/core/libs/database/dbjobs/dbjob.cpp#L102 It is not normal for this query to take 10 seconds. maybe you could increase the 10000 times in the Q_Assert to 20000. /home/andyg/projects/digikam/core/libs/database/coredb/coredbaccess.cpp, line 143 Maik 2003808 43 metzpinguin 2021-02-18 13:31:00 +0000 On the other hand, you could install a DB Browser for SQLite, open the digikam4.db file in the DB Browser and execute the following query: SELECT creationDate FROM ImageInformation INNER JOIN Images ON Images.id=ImageInformation.imageid WHERE Images.status=1; Maik 2003820 44 griffiths_andy 2021-02-18 14:04:05 +0000 Done, and it gets over that initial ASSERT crash. But now it doesn't ASSERT crash where we want it to, as the timer is still < 20000ms. So we need a way of not crashing where we expect the query to take a long time. I reduced it to 14000, to maybe find a point at which the initial query succeeds, but subsequent ones fail if >= 14000. However, even the UI hang timers are still < 14000, at roughly 12000ms. As the times look fairly consistent, maybe it's the same query? So I went back to looking at the backtraces again by interrupting while there is the delay. 204 Thread 0x7fff307f8640 (LWP 1073656) "Thread (pooled)" 0x00007ffff3ce425a in __xstat64 () from /usr/lib/libc.so.6 (gdb) thread 204 [Switching to thread 204 (Thread 0x7fff307f8640 (LWP 1073656))] #0 0x00007ffff3ce425a in __xstat64 () from /usr/lib/libc.so.6 (gdb) bt #0 0x00007ffff3ce425a in __xstat64 () at /usr/lib/libc.so.6 #1 0x00007ffff3cb1e91 in __tzfile_read () at /usr/lib/libc.so.6 #2 0x00007ffff3cb1a3d in tzset_internal () at /usr/lib/libc.so.6 #3 0x00007ffff3cb1b4a in tzset () at /usr/lib/libc.so.6 #4 0x00007ffff3cb085d in timelocal () at /usr/lib/libc.so.6 #5 0x00007ffff4220ed0 in qMkTime(tm*) () at /usr/lib/libQt5Core.so.5 #6 0x00007ffff42f696e in () at /usr/lib/libQt5Core.so.5 #7 0x00007ffff42f7008 in () at /usr/lib/libQt5Core.so.5 #8 0x00007ffff42f8706 in QDateTime::toMSecsSinceEpoch() const () at /usr/lib/libQt5Core.so.5 #9 0x00007ffff42fbb11 in QDateTime::operator<(QDateTime const&) const () at /usr/lib/libQt5Core.so.5 #10 0x00007ffff706897d in qMapLessThanKey<QDateTime>(QDateTime const&, QDateTime const&) (key1=..., key2=...) at /usr/include/qt/QtCore/qmap.h:68 #11 0x00007ffff706d020 in QMapNode<QDateTime, int>::lowerBound(QDateTime const&) (this=0x7fff82fa70e0, akey=...) at /usr/include/qt/QtCore/qmap.h:152 #12 0x00007ffff70688d6 in QMapData<QDateTime, int>::findNode(QDateTime const&) const (this=0x7fff8000cb10, akey=...) at /usr/include/qt/QtCore/qmap.h:284 #13 0x00007ffff706472b in QMap<QDateTime, int>::find(QDateTime const&) (this=0x7fff307f7750, akey=...) at /usr/include/qt/QtCore/qmap.h:862 #14 0x00007ffff7056866 in Digikam::CoreDB::getAllCreationDatesAndNumberOfImages() const (this=0x555555ad7540) at /home/andyg/projects/digikam/core/libs/database/coredb/coredb.cpp:3268 #15 0x00007ffff70adfb2 in Digikam::DatesJob::run() (this=0x7fff80066fa0) at /home/andyg/projects/digikam/core/libs/database/dbjobs/dbjob.cpp:102 #16 0x00007ffff4230302 in () at /usr/lib/libQt5Core.so.5 #17 0x00007ffff422cf0f in () at /usr/lib/libQt5Core.so.5 #18 0x00007ffff3dc83e9 in start_thread () at /usr/lib/libpthread.so.0 #19 0x00007ffff3cf4293 in clone () at /usr/lib/libc.so.6 (gdb) Again we see Digikam::CoreDB::getAllCreationDatesAndNumberOfImages(), called from Digikam::DatesJob::run() Maybe this query is taking too long whenever it is run, regardless of where it's called in the code. 2003822 45 griffiths_andy 2021-02-18 14:04:39 +0000 (In reply to Maik Qualmann from comment #43) > On the other hand, you could install a DB Browser for SQLite, open the > digikam4.db file in the DB Browser and execute the following query: > > SELECT creationDate FROM ImageInformation INNER JOIN Images ON > Images.id=ImageInformation.imageid WHERE Images.status=1; > > Maik Yes, that's my next move.. 2003824 46 griffiths_andy 2021-02-18 14:15:03 +0000 andyg@arch ~/Pictures/digikam % sqlite3 digikam4.db SQLite version 3.34.1 2021-01-20 14:10:07 Enter ".help" for usage hints. sqlite> .timer on sqlite> .mode csv sqlite> .output datequery.csv sqlite> SELECT creationDate FROM ImageInformation INNER JOIN Images ON Images.id=ImageInformation.imageid WHERE Images.status=1; Run Time: real 0.174 user 0.136208 sys 0.037326 sqlite> .output stdout sqlite> .q andyg@arch ~/Pictures/digikam % wc -l datequery.csv 405890 datequery.csv Query took hardly any time at all for 405890 results. Agreed, it shouldn't take 12 seconds in digikam. 2003828 47 griffiths_andy 2021-02-18 14:18:46 +0000 Maybe it's the post-processing in getAllCreationDatesAndNumberOfImages() to return datesStatMap that is taking the time? 2003852 48 metzpinguin 2021-02-18 15:08:52 +0000 The fact is, if you had such times for queries everywhere in digiKam, digiKam would be inoperable. So there must be something special about this query. There is an indication in the web of a QDateTime problem in current Qt versions that QDateTime is extremely slow. A large number of QDateTime objects are created in this function. I'm going to apply a new timer patch tonight. Maik 2003877 49 griffiths_andy 2021-02-18 15:41:31 +0000 Thanks. I'll look forward to trying it. 2003911 50 griffiths_andy 2021-02-18 17:06:17 +0000 Just did my own rough & ready mod to log query and post-processing in core/libs/database/coredb/coredb.cpp: QMap<QDateTime, int> CoreDB::getAllCreationDatesAndNumberOfImages() const { qCDebug(DIGIKAM_COREDB_LOG) << "getAllCreationDatesAndNumberOfImages() query starts"; QList<QVariant> values; d->db->execSql(QString::fromUtf8("SELECT creationDate FROM ImageInformation " "INNER JOIN Images ON Images.id=ImageInformation.imageid " " WHERE Images.status=1;"), &values); qCDebug(DIGIKAM_COREDB_LOG) << "getAllCreationDatesAndNumberOfImages() query ends"; QMap<QDateTime, int> datesStatMap; qCDebug(DIGIKAM_COREDB_LOG) << "getAllCreationDatesAndNumberOfImages() post-processing starts"; foreach (const QVariant& value, values) { if (!value.isNull()) { QDateTime dateTime = value.toDateTime(); if (!dateTime.isValid()) { continue; } QMap<QDateTime, int>::iterator it2 = datesStatMap.find(dateTime); if (it2 == datesStatMap.end()) { datesStatMap.insert(dateTime, 1); } else { it2.value()++; } } } qCDebug(DIGIKAM_COREDB_LOG) << "getAllCreationDatesAndNumberOfImages() post-processing ends"; return datesStatMap; } Then run thru ts to timestamp it: andyg@arch ~/projects/digikam/build (git)-[master] % QT_LOGGING_RULES="digikam.core*=true" digikam 2>&1 | ts Feb 18 17:03:46 QCommandLineParser: already having an option named "h" Feb 18 17:03:46 QCommandLineParser: already having an option named "help-all" Feb 18 17:03:46 QCommandLineParser: already having an option named "v" Feb 18 17:03:46 digikam.coredb: Core database: running schema update Feb 18 17:03:46 digikam.coredb: Core database: have a structure version 11 Feb 18 17:03:46 digikam.coredb: Core database: makeUpdates 11 to 11 Feb 18 17:03:50 [ALSOFT] (EE) Failed to set real-time priority for thread: Operation not permitted (1) Feb 18 17:03:50 [ALSOFT] (EE) Failed to set real-time priority for thread: Operation not permitted (1) Feb 18 17:03:50 kf.xmlgui: Unhandled container to remove : Digikam::DigikamApp Feb 18 17:03:50 digikam.coredb: CoreDbAccess lock time: 41 ms Feb 18 17:03:53 digikam.coredb: CoreDbAccess lock time: 2119 ms Feb 18 17:03:55 digikam.coredb: CoreDbAccess lock time: 676 ms Feb 18 17:03:55 digikam.coredb: CoreDbAccess lock time: 66 ms Feb 18 17:03:55 digikam.coredb: getAllCreationDatesAndNumberOfImages() query starts Feb 18 17:03:55 digikam.coredb: getAllCreationDatesAndNumberOfImages() query ends Feb 18 17:03:55 digikam.coredb: getAllCreationDatesAndNumberOfImages() post-processing starts Feb 18 17:04:07 digikam.coredb: getAllCreationDatesAndNumberOfImages() post-processing ends Feb 18 17:04:07 digikam.coredb: CoreDbAccess lock time: 12682 ms Sub-second in the query, ~ 12 seconds in the QDateTime manipulation. 2003984 51 metzpinguin 2021-02-18 20:04:10 +0000 Ok, the problem was reported by KPhotoAlbum among others. Qt says it doesn't go faster, many things have to be calculated when comparing dates, daylight saving time, etc. Our problem is that we are using a QMap, so the QDateTime keys are compared again and again when inserted. A QHash is 10 times faster. Maik 2003995 52 metzpinguin 2021-02-18 21:05:21 +0000 Git commit bec249c5dc8350b293c258fc767440139da3fcf0 by Maik Qualmann. Committed on 18/02/2021 at 21:03. Pushed by mqualmann into branch 'master'. port QMap<QDateTime, int> to a QHash M +7 -7 core/app/date/timelinewidget.cpp M +1 -1 core/app/date/timelinewidget.h M +2 -2 core/app/views/sidebar/timelinesidebarwidget.cpp M +1 -1 core/libs/album/manager/albummanager.cpp M +2 -2 core/libs/album/manager/albummanager.h M +7 -7 core/libs/album/manager/albummanager_dalbum.cpp M +7 -6 core/libs/database/coredb/coredb.cpp M +2 -2 core/libs/database/coredb/coredb.h M +1 -1 core/libs/database/dbjobs/dbjob.cpp M +1 -1 core/libs/database/dbjobs/dbjob.h M +2 -2 core/libs/database/dbjobs/dbjobsthread.cpp M +1 -1 core/libs/database/dbjobs/dbjobsthread.h M +1 -1 core/libs/database/models/itemfiltersettings.h https://invent.kde.org/graphics/digikam/commit/bec249c5dc8350b293c258fc767440139da3fcf0 2003997 53 metzpinguin 2021-02-18 21:11:39 +0000 Update to current git/master and please try to find out where it takes a long time in the item view when scrolling, or where it crashes after 10 seconds. Maik 2004003 54 griffiths_andy 2021-02-18 21:40:40 +0000 Checking now.. BTW, I had to apply this change a while ago to get a working compile. Seems like a missing include. diff --git a/core/tests/video/qtavcodecs.cpp b/core/tests/video/qtavcodecs.cpp index 19b028de99..51d7ddcea0 100644 --- a/core/tests/video/qtavcodecs.cpp +++ b/core/tests/video/qtavcodecs.cpp @@ -22,6 +22,7 @@ * ============================================================ */ #include <QDebug> +#include <QPainterPath> // QtAv includes 2004009 55 griffiths_andy 2021-02-18 21:50:35 +0000 Distinct improvement. I stashed and reapplied my local changes prior to compile. (Inc the patch in prev comment). Feb 18 21:41:34 digikam.coredb: getAllCreationDatesAndNumberOfImages() query starts Feb 18 21:41:34 digikam.coredb: getAllCreationDatesAndNumberOfImages() query ends Feb 18 21:41:34 digikam.coredb: getAllCreationDatesAndNumberOfImages() post-processing starts Feb 18 21:41:37 digikam.coredb: getAllCreationDatesAndNumberOfImages() post-processing ends Feb 18 21:41:37 digikam.coredb: CoreDbAccess lock time: 3665 ms I'll carry on testing and try to make it crash (response > 10000ms). Report back tomorrow. Thanks very much. It seems like it might be a solution, although it still throws a 3sec delay occasionally. 2004319 56 metzpinguin 2021-02-19 17:59:24 +0000 Git commit c7bda4772d7731404ff0337000dabcbff253102b by Maik Qualmann. Committed on 19/02/2021 at 17:58. Pushed by mqualmann into branch 'master'. calculate QDateTime outside of the DB lock Related: bug 432257 M +4 -36 core/libs/database/coredb/coredb.cpp M +2 -3 core/libs/database/coredb/coredb.h M +0 -12 core/libs/database/coredb/coredbaccess.cpp M +28 -2 core/libs/database/dbjobs/dbjob.cpp https://invent.kde.org/graphics/digikam/commit/c7bda4772d7731404ff0337000dabcbff253102b 2004323 57 metzpinguin 2021-02-19 18:01:37 +0000 Please test if the problem with the git/master version is fixed. Maik 2004338 58 griffiths_andy 2021-02-19 18:28:14 +0000 Compiled, and checking now. I had to apply the patch I mentioned in comment 54. I also see I should have raised that as a separate report so I'll do so. I'll report back later this evening with results, but tests of the QHash changes were going very well, even with the still present but much reduced delay. If the delay is gone by moving the loop outside the DB lock, then that will be very welcome. 2004360 59 griffiths_andy 2021-02-19 19:03:08 +0000 Hi Maik, I'm happy. I have experienced no lockup delays while giving it a thorough going over... Seems that last change has really improved the performance due to moving the long running op outside the DB lock (I noticed you had removed the timer & assert). Thank you for your efforts (and applying that other patch)! I think this can be closed at last. Andy 2004364 60 metzpinguin 2021-02-19 19:06:07 +0000 Thank you for the feedback and for testing the changes. Maik 135103 2021-01-23 16:36:05 +0000 2021-02-17 23:09:11 +0000 Backtraces from digikam lockups digikam_bt.txt text/plain 20457 griffiths_andy ZGlnaWthbS5nZW5lcmFsOiBBY3Rpb24gVGhyZWFkIHJ1biAgMSAgbmV3IGpvYnMKW05ldyBUaHJl YWQgMHg3ZmZmODVmZmI2NDAgKExXUCAxNjQyNjQyKV0KXkMtLVR5cGUgPFJFVD4gZm9yIG1vcmUs IHEgdG8gcXVpdCwgYyB0byBjb250aW51ZSB3aXRob3V0IHBhZ2luZy0tcQpRdWl0CihnZGIpIGJ0 CiMwICAweDAwMDA3ZmZmZjUyMjBkNWQgaW4gc3lzY2FsbCAoKSBhdCAvdXNyL2xpYi9saWJjLnNv LjYKIzEgIDB4MDAwMDdmZmZmNTViNjI2NiBpbiBRQmFzaWNNdXRleDo6bG9ja0ludGVybmFsKCkg KCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMyICAweDAwMDA3ZmZmZjU1YjY1NzQgaW4g ICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMyAgMHgwMDAwN2ZmZmY3NjU0M2E1IGlu IERpZ2lrYW06OkNvcmVEYkFjY2Vzczo6Q29yZURiQWNjZXNzKCkgKCkgYXQgL3Vzci9saWIvbGli ZGlnaWthbWRhdGFiYXNlLnNvLjcuMi4wCiM0ICAweDAwMDA3ZmZmZjc2YTFjMzIgaW4gRGlnaWth bTo6SXRlbVNjYW5uZXI6OmZpbGxDb21tb25Db250YWluZXIobG9uZyBsb25nLCBEaWdpa2FtOjpJ bWFnZUNvbW1vbkNvbnRhaW5lciopICgpCiAgICBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZGF0YWJh c2Uuc28uNy4yLjAKIzUgIDB4MDAwMDdmZmZmNzY2ZGQ5MSBpbiBEaWdpa2FtOjpJdGVtSW5mbzo6 aW1hZ2VDb21tb25Db250YWluZXIoKSBjb25zdCAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZGF0 YWJhc2Uuc28uNy4yLjAKIzYgIDB4MDAwMDdmZmZmN2FkMDk3MCBpbiAgKCkgYXQgL3Vzci9saWIv bGliZGlnaWthbWd1aS5zby43LjIuMAojNyAgMHgwMDAwN2ZmZmY3YWQyNjlhIGluICAoKSBhdCAv dXNyL2xpYi9saWJkaWdpa2FtZ3VpLnNvLjcuMi4wCiM4ICAweDAwMDA3ZmZmZjdhZDA3ODMgaW4g ICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWkuc28uNy4yLjAKIzkgIDB4MDAwMDdmZmZmN2E2 ZWEzZSBpbiAgKCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWd1aS5zby43LjIuMAojMTAgMHgwMDAw N2ZmZmY1N2Q0ZTEwIGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzExIDB4MDAw MDdmZmZmNTdkOGU0YiBpbiBRVGltZXI6OnRpbWVvdXQoUVRpbWVyOjpRUHJpdmF0ZVNpZ25hbCkg KCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMxMiAweDAwMDA3ZmZmZjU3Y2E0YmYgaW4g UU9iamVjdDo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMx MyAweDAwMDA3ZmZmZjYyNjU3NTIgaW4gUUFwcGxpY2F0aW9uUHJpdmF0ZTo6bm90aWZ5X2hlbHBl cihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMx NCAweDAwMDA3ZmZmZjU3OWRhN2EgaW4gUUNvcmVBcHBsaWNhdGlvbjo6bm90aWZ5SW50ZXJuYWwy KFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzE1IDB4 MDAwMDdmZmZmNTdmNWE2NSBpbiBRVGltZXJJbmZvTGlzdDo6YWN0aXZhdGVUaW1lcnMoKSAoKSBh dCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzE2IDB4MDAwMDdmZmZmNTdmNjMxMiBpbiAgKCkg YXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMxNyAweDAwMDA3ZmZmZTRjYThhODQgaW4gZ19t YWluX2NvbnRleHRfZGlzcGF0Y2ggKCkgYXQgL3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMAojMTgg MHgwMDAwN2ZmZmU0Y2ZjOWIxIGluICAoKSBhdCAvdXNyL2xpYi9saWJnbGliLTIuMC5zby4wCiMx OSAweDAwMDA3ZmZmZTRjYTcyYjEgaW4gZ19tYWluX2NvbnRleHRfaXRlcmF0aW9uICgpIGF0IC91 c3IvbGliL2xpYmdsaWItMi4wLnNvLjAKIzIwIDB4MDAwMDdmZmZmNTdmNjZlMSBpbiBRRXZlbnRE aXNwYXRjaGVyR2xpYjo6cHJvY2Vzc0V2ZW50cyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2 ZW50c0ZsYWc+KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzIxIDB4MDAwMDdmZmZm NTc5YzNmYyBpbiBRRXZlbnRMb29wOjpleGVjKFFGbGFnczxRRXZlbnRMb29wOjpQcm9jZXNzRXZl bnRzRmxhZz4pICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMjIgMHgwMDAwN2ZmZmY1 N2E0ODk0IGluIFFDb3JlQXBwbGljYXRpb246OmV4ZWMoKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVD b3JlLnNvLjUKIzIzIDB4MDAwMDU1NTU1NTU1OTg4OCBpbiAgKCkKIzI0IDB4MDAwMDdmZmZmNTE0 ZTE1MiBpbiBfX2xpYmNfc3RhcnRfbWFpbiAoKSBhdCAvdXNyL2xpYi9saWJjLnNvLjYKIzI1IDB4 MDAwMDU1NTU1NTU1YTUwZSBpbiBfc3RhcnQgKCkKCgoKCgoKZGlnaWthbS5nZW5lcmFsOiBBY3Rp b24gVGhyZWFkIHJ1biAgMSAgbmV3IGpvYnMKW05ldyBUaHJlYWQgMHg3ZmZmMzE3ZjI2NDAgKExX UCAxNjQ1NDkxKV0KXkMtLVR5cGUgPFJFVD4gZm9yIG1vcmUsIHEgdG8gcXVpdCwgYyB0byBjb250 aW51ZSB3aXRob3V0IHBhZ2luZy0tcQpRdWl0CihnZGIpIGJ0CiMwICAweDAwMDA3ZmZmZjUyMjBk NWQgaW4gc3lzY2FsbCAoKSBhdCAvdXNyL2xpYi9saWJjLnNvLjYKIzEgIDB4MDAwMDdmZmZmNTVi NjI2NiBpbiBRQmFzaWNNdXRleDo6bG9ja0ludGVybmFsKCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1 Q29yZS5zby41CiMyICAweDAwMDA3ZmZmZjU1YjY1NzQgaW4gICgpIGF0IC91c3IvbGliL2xpYlF0 NUNvcmUuc28uNQojMyAgMHgwMDAwN2ZmZmY3NjU0M2E1IGluIERpZ2lrYW06OkNvcmVEYkFjY2Vz czo6Q29yZURiQWNjZXNzKCkgKCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWRhdGFiYXNlLnNvLjcu Mi4wCiM0ICAweDAwMDA3ZmZmZjc2NzVlNzcgaW4gRGlnaWthbTo6SXRlbUluZm86OnRhZ0lkcygp IGNvbnN0ICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1kYXRhYmFzZS5zby43LjIuMAojNSAgMHgw MDAwN2ZmZmY3NjcxODgzIGluIERpZ2lrYW06Okl0ZW1JbmZvOjpjb2xvckxhYmVsKCkgY29uc3Qg KCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWRhdGFiYXNlLnNvLjcuMi4wCiM2ICAweDAwMDA3ZmZm ZjdhMjU3NmIgaW4gICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWkuc28uNy4yLjAKIzcgIDB4 MDAwMDdmZmZmNzA5NGFlYyBpbiBEaWdpa2FtOjpEQ2F0ZWdvcml6ZWRWaWV3OjpwYWludEV2ZW50 KFFQYWludEV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWNvcmUuc28uNy4yLjAKIzgg IDB4MDAwMDdmZmZmNjJhNmIwZSBpbiBRV2lkZ2V0OjpldmVudChRRXZlbnQqKSAoKSBhdCAvdXNy L2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzkgIDB4MDAwMDdmZmZmNjM1MjE2ZiBpbiBRRnJhbWU6 OmV2ZW50KFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTAgMHgw MDAwN2ZmZmY1NzlkN2UzIGluIFFDb3JlQXBwbGljYXRpb25Qcml2YXRlOjpzZW5kVGhyb3VnaE9i amVjdEV2ZW50RmlsdGVycyhRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1 Q29yZS5zby41CiMxMSAweDAwMDA3ZmZmZjYyNjU3NDEgaW4gUUFwcGxpY2F0aW9uUHJpdmF0ZTo6 bm90aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CiMxMiAweDAwMDA3ZmZmZjU3OWRhN2EgaW4gUUNvcmVBcHBsaWNhdGlvbjo6bm90 aWZ5SW50ZXJuYWwyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3Jl LnNvLjUKIzEzIDB4MDAwMDdmZmZmNjI5ZThlOCBpbiBRV2lkZ2V0UHJpdmF0ZTo6c2VuZFBhaW50 RXZlbnQoUVJlZ2lvbiBjb25zdCYpICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQoj MTQgMHgwMDAwN2ZmZmY2MjlmMTVjIGluIFFXaWRnZXRQcml2YXRlOjpkcmF3V2lkZ2V0KFFQYWlu dERldmljZSosIFFSZWdpb24gY29uc3QmLCBRUG9pbnQgY29uc3QmLCBRRmxhZ3M8UVdpZGdldFBy aXZhdGU6OkRyYXdXaWRnZXRGbGFnPiwgUVBhaW50ZXIqLCBRV2lkZ2V0UmVwYWludE1hbmFnZXIq KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzE1IDB4MDAwMDdmZmZmNjI3NjI5 ZSBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxNiAweDAwMDA3ZmZmZjYy YTcyNWIgaW4gUVdpZGdldDo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CiMxNyAweDAwMDA3ZmZmZjRkNzZhOGEgaW4gS1htbEd1aVdpbmRvdzo6ZXZlbnQo UUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliS0Y1WG1sR3VpLnNvLjUKIzE4IDB4MDAwMDdmZmZm NjI2NTc1MiBpbiBRQXBwbGljYXRpb25Qcml2YXRlOjpub3RpZnlfaGVscGVyKFFPYmplY3QqLCBR RXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzE5IDB4MDAwMDdmZmZm NTc5ZGE3YSBpbiBRQ29yZUFwcGxpY2F0aW9uOjpub3RpZnlJbnRlcm5hbDIoUU9iamVjdCosIFFF dmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMjAgMHgwMDAwN2ZmZmY1N2Ew NTczIGluIFFDb3JlQXBwbGljYXRpb25Qcml2YXRlOjpzZW5kUG9zdGVkRXZlbnRzKFFPYmplY3Qq LCBpbnQsIFFUaHJlYWREYXRhKikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMyMSAw eDAwMDA3ZmZmZjU3ZjcwYTQgaW4gICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMjIg MHgwMDAwN2ZmZmU0Y2E4YTg0IGluIGdfbWFpbl9jb250ZXh0X2Rpc3BhdGNoICgpIGF0IC91c3Iv bGliL2xpYmdsaWItMi4wLnNvLjAKIzIzIDB4MDAwMDdmZmZlNGNmYzliMSBpbiAgKCkgYXQgL3Vz ci9saWIvbGliZ2xpYi0yLjAuc28uMAojMjQgMHgwMDAwN2ZmZmU0Y2E3MmIxIGluIGdfbWFpbl9j b250ZXh0X2l0ZXJhdGlvbiAoKSBhdCAvdXNyL2xpYi9saWJnbGliLTIuMC5zby4wCiMyNSAweDAw MDA3ZmZmZjU3ZjY2ZTEgaW4gUUV2ZW50RGlzcGF0Y2hlckdsaWI6OnByb2Nlc3NFdmVudHMoUUZs YWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVudHNGbGFnPikgKCkgYXQgL3Vzci9saWIvbGliUXQ1 Q29yZS5zby41CiMyNiAweDAwMDA3ZmZmZjU3OWMzZmMgaW4gUUV2ZW50TG9vcDo6ZXhlYyhRRmxh Z3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVD b3JlLnNvLjUKIzI3IDB4MDAwMDdmZmZmNTdhNDg5NCBpbiBRQ29yZUFwcGxpY2F0aW9uOjpleGVj KCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMyOCAweDAwMDA1NTU1NTU1NTk4ODgg aW4gICgpCiMyOSAweDAwMDA3ZmZmZjUxNGUxNTIgaW4gX19saWJjX3N0YXJ0X21haW4gKCkgYXQg L3Vzci9saWIvbGliYy5zby42CiMzMCAweDAwMDA1NTU1NTU1NWE1MGUgaW4gX3N0YXJ0ICgpCihn ZGIpIAoKCmRpZ2lrYW0uZ2VuZXJhbDogQWN0aW9uIFRocmVhZCBydW4gIDEgIG5ldyBqb2JzCltO ZXcgVGhyZWFkIDB4N2ZmZjM0N2Y4NjQwIChMV1AgMTY0NzA5NCldCl5DLS1UeXBlIDxSRVQ+IGZv ciBtb3JlLCBxIHRvIHF1aXQsIGMgdG8gY29udGludWUgd2l0aG91dCBwYWdpbmctLXEKUXVpdAoo Z2RiKSBidAojMCAgMHgwMDAwN2ZmZmY1MjIwZDVkIGluIHN5c2NhbGwgKCkgYXQgL3Vzci9saWIv bGliYy5zby42CiMxICAweDAwMDA3ZmZmZjU1YjYyNjYgaW4gUUJhc2ljTXV0ZXg6OmxvY2tJbnRl cm5hbCgpICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMiAgMHgwMDAwN2ZmZmY1NWI2 NTc0IGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzMgIDB4MDAwMDdmZmZmNzY1 NDNhNSBpbiBEaWdpa2FtOjpDb3JlRGJBY2Nlc3M6OkNvcmVEYkFjY2VzcygpICgpIGF0IC91c3Iv bGliL2xpYmRpZ2lrYW1kYXRhYmFzZS5zby43LjIuMAojNCAgMHgwMDAwN2ZmZmY3OWU4MTljIGlu IERpZ2lrYW06OkRpZ2lrYW1BcHA6OnNsb3RJbWFnZVNlbGVjdGVkKERpZ2lrYW06Okl0ZW1JbmZv TGlzdCBjb25zdCYsIERpZ2lrYW06Okl0ZW1JbmZvTGlzdCBjb25zdCYpICgpCiAgICBhdCAvdXNy L2xpYi9saWJkaWdpa2FtZ3VpLnNvLjcuMi4wCiM1ICAweDAwMDA3ZmZmZjU3ZDRlMTAgaW4gICgp IGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojNiAgMHgwMDAwN2ZmZmY3OWQzMWViIGluICAo KSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZ3VpLnNvLjcuMi4wCiM3ICAweDAwMDA3ZmZmZjdhNmVi NTcgaW4gICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWkuc28uNy4yLjAKIzggIDB4MDAwMDdm ZmZmNTdkNGUxMCBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiM5ICAweDAwMDA3 ZmZmZjU3ZDhlNGIgaW4gUVRpbWVyOjp0aW1lb3V0KFFUaW1lcjo6UVByaXZhdGVTaWduYWwpICgp IGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMTAgMHgwMDAwN2ZmZmY1N2NhNGJmIGluIFFP YmplY3Q6OmV2ZW50KFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMTEg MHgwMDAwN2ZmZmY2MjY1NzUyIGluIFFBcHBsaWNhdGlvblByaXZhdGU6Om5vdGlmeV9oZWxwZXIo UU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTIg MHgwMDAwN2ZmZmY1NzlkYTdhIGluIFFDb3JlQXBwbGljYXRpb246Om5vdGlmeUludGVybmFsMihR T2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMxMyAweDAw MDA3ZmZmZjU3ZjVhNjUgaW4gUVRpbWVySW5mb0xpc3Q6OmFjdGl2YXRlVGltZXJzKCkgKCkgYXQg L3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMxNCAweDAwMDA3ZmZmZjU3ZjYzMTIgaW4gICgpIGF0 IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMTUgMHgwMDAwN2ZmZmU0Y2E4YTg0IGluIGdfbWFp bl9jb250ZXh0X2Rpc3BhdGNoICgpIGF0IC91c3IvbGliL2xpYmdsaWItMi4wLnNvLjAKIzE2IDB4 MDAwMDdmZmZlNGNmYzliMSBpbiAgKCkgYXQgL3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMAojMTcg MHgwMDAwN2ZmZmU0Y2E3MmIxIGluIGdfbWFpbl9jb250ZXh0X2l0ZXJhdGlvbiAoKSBhdCAvdXNy L2xpYi9saWJnbGliLTIuMC5zby4wCiMxOCAweDAwMDA3ZmZmZjU3ZjY2ZTEgaW4gUUV2ZW50RGlz cGF0Y2hlckdsaWI6OnByb2Nlc3NFdmVudHMoUUZsYWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVu dHNGbGFnPikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMxOSAweDAwMDA3ZmZmZjU3 OWMzZmMgaW4gUUV2ZW50TG9vcDo6ZXhlYyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50 c0ZsYWc+KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzIwIDB4MDAwMDdmZmZmNTdh NDg5NCBpbiBRQ29yZUFwcGxpY2F0aW9uOjpleGVjKCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29y ZS5zby41CiMyMSAweDAwMDA1NTU1NTU1NTk4ODggaW4gICgpCiMyMiAweDAwMDA3ZmZmZjUxNGUx NTIgaW4gX19saWJjX3N0YXJ0X21haW4gKCkgYXQgL3Vzci9saWIvbGliYy5zby42CiMyMyAweDAw MDA1NTU1NTU1NWE1MGUgaW4gX3N0YXJ0ICgpCihnZGIpCgoKZGlnaWthbS5nZW5lcmFsOiBBY3Rp b24gVGhyZWFkIHJ1biAgMSAgbmV3IGpvYnMKW05ldyBUaHJlYWQgMHg3ZmZmODVmZmI2NDAgKExX UCAxNjQ3NzQ1KV0KW1RocmVhZCAweDdmZmY4NzdmZTY0MCAoTFdQIDE2NDc2MzUpIGV4aXRlZF0K W1RocmVhZCAweDdmZmZiMzMyNzY0MCAoTFdQIDE2NDc2MzQpIGV4aXRlZF0KW1RocmVhZCAweDdm ZmZiM2IyODY0MCAoTFdQIDE2NDc2MzMpIGV4aXRlZF0KW1RocmVhZCAweDdmZmZjMGNlNzY0MCAo TFdQIDE2NDc2MzIpIGV4aXRlZF0KW1RocmVhZCAweDdmZmYzNGZmOTY0MCAoTFdQIDE2NDc2MzEp IGV4aXRlZF0KW1RocmVhZCAweDdmZmY5ZDQ4OTY0MCAoTFdQIDE2NDc2MzApIGV4aXRlZF0KW1Ro cmVhZCAweDdmZmYzNDdmODY0MCAoTFdQIDE2NDc2MjgpIGV4aXRlZF0KW1RocmVhZCAweDdmZmYz NmZmZDY0MCAoTFdQIDE2NDc2MjkpIGV4aXRlZF0KXkMKVGhyZWFkIDEgImRpZ2lrYW0iIHJlY2Vp dmVkIHNpZ25hbCBTSUdJTlQsIEludGVycnVwdC4KMHgwMDAwN2ZmZmY1MjIwZDVkIGluIHN5c2Nh bGwgKCkgZnJvbSAvdXNyL2xpYi9saWJjLnNvLjYKKGdkYikgYnQKIzAgIDB4MDAwMDdmZmZmNTIy MGQ1ZCBpbiBzeXNjYWxsICgpIGF0IC91c3IvbGliL2xpYmMuc28uNgojMSAgMHgwMDAwN2ZmZmY1 NWI2MjY2IGluIFFCYXNpY011dGV4Ojpsb2NrSW50ZXJuYWwoKSAoKSBhdCAvdXNyL2xpYi9saWJR dDVDb3JlLnNvLjUKIzIgIDB4MDAwMDdmZmZmNTViNjU3NCBpbiAgKCkgYXQgL3Vzci9saWIvbGli UXQ1Q29yZS5zby41CiMzICAweDAwMDA3ZmZmZjc2NTQzYTUgaW4gRGlnaWthbTo6Q29yZURiQWNj ZXNzOjpDb3JlRGJBY2Nlc3MoKSAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZGF0YWJhc2Uuc28u Ny4yLjAKIzQgIDB4MDAwMDdmZmZmNzY4Mjg4MSBpbiBEaWdpa2FtOjpJdGVtUG9zaXRpb246Okl0 ZW1Qb3NpdGlvbihsb25nIGxvbmcpICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1kYXRhYmFzZS5z by43LjIuMAojNSAgMHgwMDAwN2ZmZmY3NjZmN2JjIGluIERpZ2lrYW06Okl0ZW1JbmZvOjppbWFn ZVBvc2l0aW9uKCkgY29uc3QgKCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWRhdGFiYXNlLnNvLjcu Mi4wCiM2ICAweDAwMDA3ZmZmZjc2NmZhZDIgaW4gRGlnaWthbTo6SXRlbUluZm86Omhhc0Nvb3Jk aW5hdGVzKCkgY29uc3QgKCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWRhdGFiYXNlLnNvLjcuMi4w CiM3ICAweDAwMDA3ZmZmZjdhMzI3Y2YgaW4gICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWku c28uNy4yLjAKIzggIDB4MDAwMDdmZmZmNzA5ZjkwMSBpbiBEaWdpa2FtOjpBYnN0cmFjdFdpZGdl dERlbGVnYXRlT3ZlcmxheTo6c2xvdEVudGVyZWQoUU1vZGVsSW5kZXggY29uc3QmKSAoKSBhdCAv dXNyL2xpYi9saWJkaWdpa2FtY29yZS5zby43LjIuMAojOSAgMHgwMDAwN2ZmZmY3YTMyOGIzIGlu ICAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZ3VpLnNvLjcuMi4wCiMxMCAweDAwMDA3ZmZmZjU3 ZDRlMTAgaW4gICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMTEgMHgwMDAwN2ZmZmY2 NGM2NWE2IGluIFFBYnN0cmFjdEl0ZW1WaWV3OjplbnRlcmVkKFFNb2RlbEluZGV4IGNvbnN0Jikg KCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxMiAweDAwMDA3ZmZmZjY0ZDQ2NDIg aW4gICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTMgMHgwMDAwN2ZmZmY2NGQ1 MDNlIGluIFFBYnN0cmFjdEl0ZW1WaWV3Ojp2ZXJ0aWNhbFNjcm9sbGJhclZhbHVlQ2hhbmdlZChp bnQpICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTQgMHgwMDAwN2ZmZmY1N2Q0 ZTEwIGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzE1IDB4MDAwMDdmZmZmNjM1 YTgxZiBpbiBRQWJzdHJhY3RTbGlkZXI6OnZhbHVlQ2hhbmdlZChpbnQpICgpIGF0IC91c3IvbGli L2xpYlF0NVdpZGdldHMuc28uNQojMTYgMHgwMDAwN2ZmZmY2MzVhZjhjIGluIFFBYnN0cmFjdFNs aWRlcjo6c2V0VmFsdWUoaW50KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzE3 IDB4MDAwMDdmZmZmNjM1YmE5NyBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41 CiMxOCAweDAwMDA3ZmZmZjY0MDE1NjkgaW4gUVNjcm9sbEJhcjo6d2hlZWxFdmVudChRV2hlZWxF dmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTkgMHgwMDAwN2ZmZmY2 MmE2YjBlIGluIFFXaWRnZXQ6OmV2ZW50KFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdp ZGdldHMuc28uNQojMjAgMHgwMDAwN2ZmZmY2MjY1NzUyIGluIFFBcHBsaWNhdGlvblByaXZhdGU6 Om5vdGlmeV9oZWxwZXIoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdp ZGdldHMuc28uNQojMjEgMHgwMDAwN2ZmZmY1NzlkYTdhIGluIFFDb3JlQXBwbGljYXRpb246Om5v dGlmeUludGVybmFsMihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29y ZS5zby41CiMyMiAweDAwMDA3ZmZmZjYyYTZiMGUgaW4gUVdpZGdldDo6ZXZlbnQoUUV2ZW50Kikg KCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMyMyAweDAwMDA3ZmZmZjYzNTIxNmYg aW4gUUZyYW1lOjpldmVudChRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNv LjUKIzI0IDB4MDAwMDdmZmZmNTc5ZDdlMyBpbiBRQ29yZUFwcGxpY2F0aW9uUHJpdmF0ZTo6c2Vu ZFRocm91Z2hPYmplY3RFdmVudEZpbHRlcnMoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3Iv bGliL2xpYlF0NUNvcmUuc28uNQojMjUgMHgwMDAwN2ZmZmY2MjY1NzQxIGluIFFBcHBsaWNhdGlv blByaXZhdGU6Om5vdGlmeV9oZWxwZXIoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGli L2xpYlF0NVdpZGdldHMuc28uNQojMjYgMHgwMDAwN2ZmZmY2MjZkMmRjIGluIFFBcHBsaWNhdGlv bjo6bm90aWZ5KFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRz LnNvLjUKIzI3IDB4MDAwMDdmZmZmNTc5ZGE3YSBpbiBRQ29yZUFwcGxpY2F0aW9uOjpub3RpZnlJ bnRlcm5hbDIoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28u NQojMjggMHgwMDAwN2ZmZmY2MmMwZGY1IGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRz LnNvLjUKIzI5IDB4MDAwMDdmZmZmNjJjMjgzNiBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CiMzMCAweDAwMDA3ZmZmZjYyNjU3NTIgaW4gUUFwcGxpY2F0aW9uUHJpdmF0ZTo6 bm90aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CiMzMSAweDAwMDA3ZmZmZjU3OWRhN2EgaW4gUUNvcmVBcHBsaWNhdGlvbjo6bm90 aWZ5SW50ZXJuYWwyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3Jl LnNvLjUKLS1UeXBlIDxSRVQ+IGZvciBtb3JlLCBxIHRvIHF1aXQsIGMgdG8gY29udGludWUgd2l0 aG91dCBwYWdpbmctLWMKIzMyIDB4MDAwMDdmZmZmNWI3MzBiOSBpbiBRR3VpQXBwbGljYXRpb25Q cml2YXRlOjpwcm9jZXNzV2hlZWxFdmVudChRV2luZG93U3lzdGVtSW50ZXJmYWNlUHJpdmF0ZTo6 V2hlZWxFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUd1aS5zby41CiMzMyAweDAwMDA3ZmZm ZjViNGNiYjUgaW4gUVdpbmRvd1N5c3RlbUludGVyZmFjZTo6c2VuZFdpbmRvd1N5c3RlbUV2ZW50 cyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAoKSBhdCAvdXNyL2xpYi9s aWJRdDVHdWkuc28uNQojMzQgMHgwMDAwN2ZmZmRjMzQ4MTZjIGluICAoKSBhdCAvdXNyL2xpYi9s aWJRdDVYY2JRcGEuc28uNQojMzUgMHgwMDAwN2ZmZmU0Y2E4YTg0IGluIGdfbWFpbl9jb250ZXh0 X2Rpc3BhdGNoICgpIGF0IC91c3IvbGliL2xpYmdsaWItMi4wLnNvLjAKIzM2IDB4MDAwMDdmZmZl NGNmYzliMSBpbiAgKCkgYXQgL3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMAojMzcgMHgwMDAwN2Zm ZmU0Y2E3MmIxIGluIGdfbWFpbl9jb250ZXh0X2l0ZXJhdGlvbiAoKSBhdCAvdXNyL2xpYi9saWJn bGliLTIuMC5zby4wCiMzOCAweDAwMDA3ZmZmZjU3ZjY2ZTEgaW4gUUV2ZW50RGlzcGF0Y2hlckds aWI6OnByb2Nlc3NFdmVudHMoUUZsYWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVudHNGbGFnPikg KCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMzOSAweDAwMDA3ZmZmZjU3OWMzZmMgaW4g UUV2ZW50TG9vcDo6ZXhlYyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAo KSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzQwIDB4MDAwMDdmZmZmNTdhNDg5NCBpbiBR Q29yZUFwcGxpY2F0aW9uOjpleGVjKCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiM0 MSAweDAwMDA1NTU1NTU1NTk4ODggaW4gICgpCiM0MiAweDAwMDA3ZmZmZjUxNGUxNTIgaW4gX19s aWJjX3N0YXJ0X21haW4gKCkgYXQgL3Vzci9saWIvbGliYy5zby42CiM0MyAweDAwMDA1NTU1NTU1 NWE1MGUgaW4gX3N0YXJ0ICgpCihnZGIpIAoKCgpkaWdpa2FtLmdlbmVyYWw6IEFjdGlvbiBUaHJl YWQgcnVuICAxICBuZXcgam9icwpbTmV3IFRocmVhZCAweDdmZmYzNmZmZDY0MCAoTFdQIDE2NDg2 MTEpXQpbVGhyZWFkIDB4N2ZmZjM2N2ZjNjQwIChMV1AgMTY0ODQ5MikgZXhpdGVkXQpbVGhyZWFk IDB4N2ZmZmIzYjI4NjQwIChMV1AgMTY0ODQ1NSkgZXhpdGVkXQpeQy0tVHlwZSA8UkVUPiBmb3Ig bW9yZSwgcSB0byBxdWl0LCBjIHRvIGNvbnRpbnVlIHdpdGhvdXQgcGFnaW5nLS1jCgpUaHJlYWQg MSAiZGlnaWthbSIgcmVjZWl2ZWQgc2lnbmFsIFNJR0lOVCwgSW50ZXJydXB0LgoweDAwMDA3ZmZm ZjUyMjBkNWQgaW4gc3lzY2FsbCAoKSBmcm9tIC91c3IvbGliL2xpYmMuc28uNgooZ2RiKSBidAoj MCAgMHgwMDAwN2ZmZmY1MjIwZDVkIGluIHN5c2NhbGwgKCkgYXQgL3Vzci9saWIvbGliYy5zby42 CiMxICAweDAwMDA3ZmZmZjU1YjYyNjYgaW4gUUJhc2ljTXV0ZXg6OmxvY2tJbnRlcm5hbCgpICgp IGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMiAgMHgwMDAwN2ZmZmY1NWI2NTc0IGluICAo KSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzMgIDB4MDAwMDdmZmZmNzY1NDNhNSBpbiBE aWdpa2FtOjpDb3JlRGJBY2Nlc3M6OkNvcmVEYkFjY2VzcygpICgpIGF0IC91c3IvbGliL2xpYmRp Z2lrYW1kYXRhYmFzZS5zby43LjIuMAojNCAgMHgwMDAwN2ZmZmY3NjgyODgxIGluIERpZ2lrYW06 Okl0ZW1Qb3NpdGlvbjo6SXRlbVBvc2l0aW9uKGxvbmcgbG9uZykgKCkgYXQgL3Vzci9saWIvbGli ZGlnaWthbWRhdGFiYXNlLnNvLjcuMi4wCiM1ICAweDAwMDA3ZmZmZjc2NmY3YmMgaW4gRGlnaWth bTo6SXRlbUluZm86OmltYWdlUG9zaXRpb24oKSBjb25zdCAoKSBhdCAvdXNyL2xpYi9saWJkaWdp a2FtZGF0YWJhc2Uuc28uNy4yLjAKIzYgIDB4MDAwMDdmZmZmNzY2ZmFkMiBpbiBEaWdpa2FtOjpJ dGVtSW5mbzo6aGFzQ29vcmRpbmF0ZXMoKSBjb25zdCAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2Ft ZGF0YWJhc2Uuc28uNy4yLjAKIzcgIDB4MDAwMDdmZmZmN2EzMjdjZiBpbiAgKCkgYXQgL3Vzci9s aWIvbGliZGlnaWthbWd1aS5zby43LjIuMAojOCAgMHgwMDAwN2ZmZmY3MDlmOTAxIGluIERpZ2lr YW06OkFic3RyYWN0V2lkZ2V0RGVsZWdhdGVPdmVybGF5OjpzbG90RW50ZXJlZChRTW9kZWxJbmRl eCBjb25zdCYpICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1jb3JlLnNvLjcuMi4wCiM5ICAweDAw MDA3ZmZmZjdhMzI4YjMgaW4gICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWkuc28uNy4yLjAK IzEwIDB4MDAwMDdmZmZmNTdkNGUxMCBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41 CiMxMSAweDAwMDA3ZmZmZjY0YzY1YTYgaW4gUUFic3RyYWN0SXRlbVZpZXc6OmVudGVyZWQoUU1v ZGVsSW5kZXggY29uc3QmKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzEyIDB4 MDAwMDdmZmZmNjRkNDY0MiBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMx MyAweDAwMDA3ZmZmZjY0ZDQ4YzAgaW4gUUFic3RyYWN0SXRlbVZpZXc6Om1vdXNlTW92ZUV2ZW50 KFFNb3VzZUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxNCAweDAw MDA3ZmZmZjY1MGZlMzggaW4gUUxpc3RWaWV3Ojptb3VzZU1vdmVFdmVudChRTW91c2VFdmVudCop ICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTUgMHgwMDAwN2ZmZmY3MDk2MDAw IGluIERpZ2lrYW06OkRDYXRlZ29yaXplZFZpZXc6Om1vdXNlTW92ZUV2ZW50KFFNb3VzZUV2ZW50 KikgKCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWNvcmUuc28uNy4yLjAKIzE2IDB4MDAwMDdmZmZm NzBhODM1YyBpbiBEaWdpa2FtOjpJdGVtVmlld0NhdGVnb3JpemVkOjptb3VzZU1vdmVFdmVudChR TW91c2VFdmVudCopICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1jb3JlLnNvLjcuMi4wCiMxNyAw eDAwMDA3ZmZmZjYyYTZiMGUgaW4gUVdpZGdldDo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vzci9s aWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxOCAweDAwMDA3ZmZmZjYzNTIxNmYgaW4gUUZyYW1lOjpl dmVudChRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzE5IDB4MDAw MDdmZmZmNTc5ZDdlMyBpbiBRQ29yZUFwcGxpY2F0aW9uUHJpdmF0ZTo6c2VuZFRocm91Z2hPYmpl Y3RFdmVudEZpbHRlcnMoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNv cmUuc28uNQojMjAgMHgwMDAwN2ZmZmY2MjY1NzQxIGluIFFBcHBsaWNhdGlvblByaXZhdGU6Om5v dGlmeV9oZWxwZXIoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdl dHMuc28uNQojMjEgMHgwMDAwN2ZmZmY2MjZjODdiIGluIFFBcHBsaWNhdGlvbjo6bm90aWZ5KFFP YmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzIyIDB4 MDAwMDdmZmZmNTc5ZGE3YSBpbiBRQ29yZUFwcGxpY2F0aW9uOjpub3RpZnlJbnRlcm5hbDIoUU9i amVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMjMgMHgwMDAw N2ZmZmY2MjZiODdlIGluIFFBcHBsaWNhdGlvblByaXZhdGU6OnNlbmRNb3VzZUV2ZW50KFFXaWRn ZXQqLCBRTW91c2VFdmVudCosIFFXaWRnZXQqLCBRV2lkZ2V0KiwgUVdpZGdldCoqLCBRUG9pbnRl cjxRV2lkZ2V0PiYsIGJvb2wsIGJvb2wpICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28u NQojMjQgMHgwMDAwN2ZmZmY2MmJmMjQ5IGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRz LnNvLjUKIzI1IDB4MDAwMDdmZmZmNjJjMjYzZiBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CiMyNiAweDAwMDA3ZmZmZjYyNjU3NTIgaW4gUUFwcGxpY2F0aW9uUHJpdmF0ZTo6 bm90aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CiMyNyAweDAwMDA3ZmZmZjU3OWRhN2EgaW4gUUNvcmVBcHBsaWNhdGlvbjo6bm90 aWZ5SW50ZXJuYWwyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3Jl LnNvLjUKIzI4IDB4MDAwMDdmZmZmNWI3NzU5NCBpbiBRR3VpQXBwbGljYXRpb25Qcml2YXRlOjpw cm9jZXNzTW91c2VFdmVudChRV2luZG93U3lzdGVtSW50ZXJmYWNlUHJpdmF0ZTo6TW91c2VFdmVu dCopICgpIGF0IC91c3IvbGliL2xpYlF0NUd1aS5zby41CiMyOSAweDAwMDA3ZmZmZjViNGNiYjUg aW4gUVdpbmRvd1N5c3RlbUludGVyZmFjZTo6c2VuZFdpbmRvd1N5c3RlbUV2ZW50cyhRRmxhZ3M8 UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVHdWku c28uNQojMzAgMHgwMDAwN2ZmZmRjMzQ4MTZjIGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVYY2JR cGEuc28uNQotLVR5cGUgPFJFVD4gZm9yIG1vcmUsIHEgdG8gcXVpdCwgYyB0byBjb250aW51ZSB3 aXRob3V0IHBhZ2luZy0tYwojMzEgMHgwMDAwN2ZmZmU0Y2E4YTg0IGluIGdfbWFpbl9jb250ZXh0 X2Rpc3BhdGNoICgpIGF0IC91c3IvbGliL2xpYmdsaWItMi4wLnNvLjAKIzMyIDB4MDAwMDdmZmZl NGNmYzliMSBpbiAgKCkgYXQgL3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMAojMzMgMHgwMDAwN2Zm ZmU0Y2E3MmIxIGluIGdfbWFpbl9jb250ZXh0X2l0ZXJhdGlvbiAoKSBhdCAvdXNyL2xpYi9saWJn bGliLTIuMC5zby4wCiMzNCAweDAwMDA3ZmZmZjU3ZjY2ZTEgaW4gUUV2ZW50RGlzcGF0Y2hlckds aWI6OnByb2Nlc3NFdmVudHMoUUZsYWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVudHNGbGFnPikg KCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMzNSAweDAwMDA3ZmZmZjU3OWMzZmMgaW4g UUV2ZW50TG9vcDo6ZXhlYyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAo KSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzM2IDB4MDAwMDdmZmZmNTdhNDg5NCBpbiBR Q29yZUFwcGxpY2F0aW9uOjpleGVjKCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMz NyAweDAwMDA1NTU1NTU1NTk4ODggaW4gICgpCiMzOCAweDAwMDA3ZmZmZjUxNGUxNTIgaW4gX19s aWJjX3N0YXJ0X21haW4gKCkgYXQgL3Vzci9saWIvbGliYy5zby42CiMzOSAweDAwMDA1NTU1NTU1 NWE1MGUgaW4gX3N0YXJ0ICgpCihnZGIpIAoKZGlnaWthbS5nZW5lcmFsOiBBY3Rpb24gVGhyZWFk IHJ1biAgMSAgbmV3IGpvYnMKW05ldyBUaHJlYWQgMHg3ZmZmMzRmZjk2NDAgKExXUCAxNjQ5Nzg4 KV0KXkMtLVR5cGUgPFJFVD4gZm9yIG1vcmUsIHEgdG8gcXVpdCwgYyB0byBjb250aW51ZSB3aXRo b3V0IHBhZ2luZy0tYwoKVGhyZWFkIDEgImRpZ2lrYW0iIHJlY2VpdmVkIHNpZ25hbCBTSUdJTlQs IEludGVycnVwdC4KMHgwMDAwN2ZmZmY1MjIwZDVkIGluIHN5c2NhbGwgKCkgZnJvbSAvdXNyL2xp Yi9saWJjLnNvLjYKKGdkYikgYnQKIzAgIDB4MDAwMDdmZmZmNTIyMGQ1ZCBpbiBzeXNjYWxsICgp IGF0IC91c3IvbGliL2xpYmMuc28uNgojMSAgMHgwMDAwN2ZmZmY1NWI2MjY2IGluIFFCYXNpY011 dGV4Ojpsb2NrSW50ZXJuYWwoKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzIgIDB4 MDAwMDdmZmZmNTViNjU3NCBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMzICAw eDAwMDA3ZmZmZjc2NTQzYTUgaW4gRGlnaWthbTo6Q29yZURiQWNjZXNzOjpDb3JlRGJBY2Nlc3Mo KSAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZGF0YWJhc2Uuc28uNy4yLjAKIzQgIDB4MDAwMDdm ZmZmNzY4Mjg4MSBpbiBEaWdpa2FtOjpJdGVtUG9zaXRpb246Okl0ZW1Qb3NpdGlvbihsb25nIGxv bmcpICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1kYXRhYmFzZS5zby43LjIuMAojNSAgMHgwMDAw N2ZmZmY3NjZmN2JjIGluIERpZ2lrYW06Okl0ZW1JbmZvOjppbWFnZVBvc2l0aW9uKCkgY29uc3Qg KCkgYXQgL3Vzci9saWIvbGliZGlnaWthbWRhdGFiYXNlLnNvLjcuMi4wCiM2ICAweDAwMDA3ZmZm Zjc2NmZhZDIgaW4gRGlnaWthbTo6SXRlbUluZm86Omhhc0Nvb3JkaW5hdGVzKCkgY29uc3QgKCkg YXQgL3Vzci9saWIvbGliZGlnaWthbWRhdGFiYXNlLnNvLjcuMi4wCiM3ICAweDAwMDA3ZmZmZjdh MzI3Y2YgaW4gICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWkuc28uNy4yLjAKIzggIDB4MDAw MDdmZmZmNzA5ZjkwMSBpbiBEaWdpa2FtOjpBYnN0cmFjdFdpZGdldERlbGVnYXRlT3ZlcmxheTo6 c2xvdEVudGVyZWQoUU1vZGVsSW5kZXggY29uc3QmKSAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2Ft Y29yZS5zby43LjIuMAojOSAgMHgwMDAwN2ZmZmY3YTMyOGIzIGluICAoKSBhdCAvdXNyL2xpYi9s aWJkaWdpa2FtZ3VpLnNvLjcuMi4wCiMxMCAweDAwMDA3ZmZmZjU3ZDRlMTAgaW4gICgpIGF0IC91 c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMTEgMHgwMDAwN2ZmZmY2NGM2NWE2IGluIFFBYnN0cmFj dEl0ZW1WaWV3OjplbnRlcmVkKFFNb2RlbEluZGV4IGNvbnN0JikgKCkgYXQgL3Vzci9saWIvbGli UXQ1V2lkZ2V0cy5zby41CiMxMiAweDAwMDA3ZmZmZjY0ZDQ2NDIgaW4gICgpIGF0IC91c3IvbGli L2xpYlF0NVdpZGdldHMuc28uNQojMTMgMHgwMDAwN2ZmZmY2NGQ0OGMwIGluIFFBYnN0cmFjdEl0 ZW1WaWV3Ojptb3VzZU1vdmVFdmVudChRTW91c2VFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0 NVdpZGdldHMuc28uNQojMTQgMHgwMDAwN2ZmZmY2NTBmZTM4IGluIFFMaXN0Vmlldzo6bW91c2VN b3ZlRXZlbnQoUU1vdXNlRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUK IzE1IDB4MDAwMDdmZmZmNzA5NjAwMCBpbiBEaWdpa2FtOjpEQ2F0ZWdvcml6ZWRWaWV3Ojptb3Vz ZU1vdmVFdmVudChRTW91c2VFdmVudCopICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1jb3JlLnNv LjcuMi4wCiMxNiAweDAwMDA3ZmZmZjcwYTgzNWMgaW4gRGlnaWthbTo6SXRlbVZpZXdDYXRlZ29y aXplZDo6bW91c2VNb3ZlRXZlbnQoUU1vdXNlRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJkaWdp a2FtY29yZS5zby43LjIuMAojMTcgMHgwMDAwN2ZmZmY2MmE2YjBlIGluIFFXaWRnZXQ6OmV2ZW50 KFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMTggMHgwMDAwN2Zm ZmY2MzUyMTZmIGluIFFGcmFtZTo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1 V2lkZ2V0cy5zby41CiMxOSAweDAwMDA3ZmZmZjU3OWQ3ZTMgaW4gUUNvcmVBcHBsaWNhdGlvblBy aXZhdGU6OnNlbmRUaHJvdWdoT2JqZWN0RXZlbnRGaWx0ZXJzKFFPYmplY3QqLCBRRXZlbnQqKSAo KSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzIwIDB4MDAwMDdmZmZmNjI2NTc0MSBpbiBR QXBwbGljYXRpb25Qcml2YXRlOjpub3RpZnlfaGVscGVyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBh dCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzIxIDB4MDAwMDdmZmZmNjI2Yzg3YiBpbiBR QXBwbGljYXRpb246Om5vdGlmeShRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGli UXQ1V2lkZ2V0cy5zby41CiMyMiAweDAwMDA3ZmZmZjU3OWRhN2EgaW4gUUNvcmVBcHBsaWNhdGlv bjo6bm90aWZ5SW50ZXJuYWwyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJR dDVDb3JlLnNvLjUKIzIzIDB4MDAwMDdmZmZmNjI2Yjg3ZSBpbiBRQXBwbGljYXRpb25Qcml2YXRl OjpzZW5kTW91c2VFdmVudChRV2lkZ2V0KiwgUU1vdXNlRXZlbnQqLCBRV2lkZ2V0KiwgUVdpZGdl dCosIFFXaWRnZXQqKiwgUVBvaW50ZXI8UVdpZGdldD4mLCBib29sLCBib29sKSAoKSBhdCAvdXNy L2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzI0IDB4MDAwMDdmZmZmNjJiZjI0OSBpbiAgKCkgYXQg L3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMyNSAweDAwMDA3ZmZmZjYyYzI2M2YgaW4gICgp IGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMjYgMHgwMDAwN2ZmZmY2MjY1NzUyIGlu IFFBcHBsaWNhdGlvblByaXZhdGU6Om5vdGlmeV9oZWxwZXIoUU9iamVjdCosIFFFdmVudCopICgp IGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQojMjcgMHgwMDAwN2ZmZmY1NzlkYTdhIGlu IFFDb3JlQXBwbGljYXRpb246Om5vdGlmeUludGVybmFsMihRT2JqZWN0KiwgUUV2ZW50KikgKCkg YXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMyOCAweDAwMDA3ZmZmZjViNzc1OTQgaW4gUUd1 aUFwcGxpY2F0aW9uUHJpdmF0ZTo6cHJvY2Vzc01vdXNlRXZlbnQoUVdpbmRvd1N5c3RlbUludGVy ZmFjZVByaXZhdGU6Ok1vdXNlRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVHdWkuc28uNQoj MjkgMHgwMDAwN2ZmZmY1YjRjYmI1IGluIFFXaW5kb3dTeXN0ZW1JbnRlcmZhY2U6OnNlbmRXaW5k b3dTeXN0ZW1FdmVudHMoUUZsYWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVudHNGbGFnPikgKCkg YXQgL3Vzci9saWIvbGliUXQ1R3VpLnNvLjUKIzMwIDB4MDAwMDdmZmZkYzM0ODE2YyBpbiAgKCkg YXQgL3Vzci9saWIvbGliUXQ1WGNiUXBhLnNvLjUKLS1UeXBlIDxSRVQ+IGZvciBtb3JlLCBxIHRv IHF1aXQsIGMgdG8gY29udGludWUgd2l0aG91dCBwYWdpbmctLWMKIzMxIDB4MDAwMDdmZmZlNGNh OGE4NCBpbiBnX21haW5fY29udGV4dF9kaXNwYXRjaCAoKSBhdCAvdXNyL2xpYi9saWJnbGliLTIu MC5zby4wCiMzMiAweDAwMDA3ZmZmZTRjZmM5YjEgaW4gICgpIGF0IC91c3IvbGliL2xpYmdsaWIt Mi4wLnNvLjAKIzMzIDB4MDAwMDdmZmZlNGNhNzJiMSBpbiBnX21haW5fY29udGV4dF9pdGVyYXRp b24gKCkgYXQgL3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMAojMzQgMHgwMDAwN2ZmZmY1N2Y2NmUx IGluIFFFdmVudERpc3BhdGNoZXJHbGliOjpwcm9jZXNzRXZlbnRzKFFGbGFnczxRRXZlbnRMb29w OjpQcm9jZXNzRXZlbnRzRmxhZz4pICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMzUg MHgwMDAwN2ZmZmY1NzljM2ZjIGluIFFFdmVudExvb3A6OmV4ZWMoUUZsYWdzPFFFdmVudExvb3A6 OlByb2Nlc3NFdmVudHNGbGFnPikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMzNiAw eDAwMDA3ZmZmZjU3YTQ4OTQgaW4gUUNvcmVBcHBsaWNhdGlvbjo6ZXhlYygpICgpIGF0IC91c3Iv bGliL2xpYlF0NUNvcmUuc28uNQojMzcgMHgwMDAwNTU1NTU1NTU5ODg4IGluICAoKQojMzggMHgw MDAwN2ZmZmY1MTRlMTUyIGluIF9fbGliY19zdGFydF9tYWluICgpIGF0IC91c3IvbGliL2xpYmMu c28uNgojMzkgMHgwMDAwNTU1NTU1NTVhNTBlIGluIF9zdGFydCAoKQooZ2RiKSAKCgoK 135120 2021-01-23 23:44:25 +0000 2021-02-17 23:09:11 +0000 Backtrace digikam-bt.txt text/plain 4769 griffiths_andy ZGlnaWthbS5nZW5lcmFsOiBBY3Rpb24gVGhyZWFkIHJ1biAgMSAgbmV3IGpvYnMKW05ldyBUaHJl YWQgMHg3ZmZmODc3ZmU2NDAgKExXUCAxNzU5OTc0KV0KXkMtLVR5cGUgPFJFVD4gZm9yIG1vcmUs IHEgdG8gcXVpdCwgYyB0byBjb250aW51ZSB3aXRob3V0IHBhZ2luZy0tCgpUaHJlYWQgMSAiZGln aWthbSIgcmVjZWl2ZWQgc2lnbmFsIFNJR0lOVCwgSW50ZXJydXB0LgoweDAwMDA3ZmZmZjUyMGRk NWQgaW4gc3lzY2FsbCAoKSBmcm9tIC91c3IvbGliL2xpYmMuc28uNgooZ2RiKSBidAojMCAgMHgw MDAwN2ZmZmY1MjBkZDVkIGluIHN5c2NhbGwgKCkgYXQgL3Vzci9saWIvbGliYy5zby42CiMxICAw eDAwMDA3ZmZmZjU1YTMyNjYgaW4gUUJhc2ljTXV0ZXg6OmxvY2tJbnRlcm5hbCgpICgpIGF0IC91 c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMiAgMHgwMDAwN2ZmZmY1NWEzNTc0IGluICAoKSBhdCAv dXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKIzMgIDB4MDAwMDdmZmZmNzY1MjI2NSBpbiBEaWdpa2Ft OjpDb3JlRGJBY2Nlc3M6OkNvcmVEYkFjY2VzcygpICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1k YXRhYmFzZS5zby43LjIuMAojNCAgMHgwMDAwN2ZmZmY3NjgwNzQxIGluIERpZ2lrYW06Okl0ZW1Q b3NpdGlvbjo6SXRlbVBvc2l0aW9uKGxvbmcgbG9uZykgKCkgYXQgL3Vzci9saWIvbGliZGlnaWth bWRhdGFiYXNlLnNvLjcuMi4wCiM1ICAweDAwMDA3ZmZmZjc2NmQ2N2MgaW4gRGlnaWthbTo6SXRl bUluZm86OmltYWdlUG9zaXRpb24oKSBjb25zdCAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZGF0 YWJhc2Uuc28uNy4yLjAKIzYgIDB4MDAwMDdmZmZmNzY2ZDk5MiBpbiBEaWdpa2FtOjpJdGVtSW5m bzo6aGFzQ29vcmRpbmF0ZXMoKSBjb25zdCAoKSBhdCAvdXNyL2xpYi9saWJkaWdpa2FtZGF0YWJh c2Uuc28uNy4yLjAKIzcgIDB4MDAwMDdmZmZmN2EzMGE3ZiBpbiAgKCkgYXQgL3Vzci9saWIvbGli ZGlnaWthbWd1aS5zby43LjIuMAojOCAgMHgwMDAwN2ZmZmY3MDk1NmUxIGluIERpZ2lrYW06OkFi c3RyYWN0V2lkZ2V0RGVsZWdhdGVPdmVybGF5OjpzbG90RW50ZXJlZChRTW9kZWxJbmRleCBjb25z dCYpICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1jb3JlLnNvLjcuMi4wCiM5ICAweDAwMDA3ZmZm ZjdhMzBiNjMgaW4gICgpIGF0IC91c3IvbGliL2xpYmRpZ2lrYW1ndWkuc28uNy4yLjAKIzEwIDB4 MDAwMDdmZmZmNTdjMWUxMCBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMxMSAw eDAwMDA3ZmZmZjY0YjM1YTYgaW4gUUFic3RyYWN0SXRlbVZpZXc6OmVudGVyZWQoUU1vZGVsSW5k ZXggY29uc3QmKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzEyIDB4MDAwMDdm ZmZmNjRjMTY0MiBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxMyAweDAw MDA3ZmZmZjY0YzIwM2UgaW4gUUFic3RyYWN0SXRlbVZpZXc6OnZlcnRpY2FsU2Nyb2xsYmFyVmFs dWVDaGFuZ2VkKGludCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxNCAweDAw MDA3ZmZmZjU3YzFlMTAgaW4gICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMTUgMHgw MDAwN2ZmZmY2MzQ3ODFmIGluIFFBYnN0cmFjdFNsaWRlcjo6dmFsdWVDaGFuZ2VkKGludCkgKCkg YXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxNiAweDAwMDA3ZmZmZjYzNDdmOGMgaW4g UUFic3RyYWN0U2xpZGVyOjpzZXRWYWx1ZShpbnQpICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdl dHMuc28uNQojMTcgMHgwMDAwN2ZmZmY2MzQ4YTk3IGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVX aWRnZXRzLnNvLjUKIzE4IDB4MDAwMDdmZmZmNjNlZTU2OSBpbiBRU2Nyb2xsQmFyOjp3aGVlbEV2 ZW50KFFXaGVlbEV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMxOSAw eDAwMDA3ZmZmZjYyOTNiMGUgaW4gUVdpZGdldDo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vzci9s aWIvbGliUXQ1V2lkZ2V0cy5zby41CiMyMCAweDAwMDA3ZmZmZjYyNTI3NTIgaW4gUUFwcGxpY2F0 aW9uUHJpdmF0ZTo6bm90aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9s aWIvbGliUXQ1V2lkZ2V0cy5zby41CiMyMSAweDAwMDA3ZmZmZjU3OGFhN2EgaW4gUUNvcmVBcHBs aWNhdGlvbjo6bm90aWZ5SW50ZXJuYWwyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xp Yi9saWJRdDVDb3JlLnNvLjUKIzIyIDB4MDAwMDdmZmZmNjI5M2IwZSBpbiBRV2lkZ2V0OjpldmVu dChRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKIzIzIDB4MDAwMDdm ZmZmNjMzZjE2ZiBpbiBRRnJhbWU6OmV2ZW50KFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0 NVdpZGdldHMuc28uNQojMjQgMHgwMDAwN2ZmZmY1NzhhN2UzIGluIFFDb3JlQXBwbGljYXRpb25Q cml2YXRlOjpzZW5kVGhyb3VnaE9iamVjdEV2ZW50RmlsdGVycyhRT2JqZWN0KiwgUUV2ZW50Kikg KCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiMyNSAweDAwMDA3ZmZmZjYyNTI3NDEgaW4g UUFwcGxpY2F0aW9uUHJpdmF0ZTo6bm90aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50KikgKCkg YXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CiMyNiAweDAwMDA3ZmZmZjYyNWEyZGMgaW4g UUFwcGxpY2F0aW9uOjpub3RpZnkoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xp YlF0NVdpZGdldHMuc28uNQojMjcgMHgwMDAwN2ZmZmY1NzhhYTdhIGluIFFDb3JlQXBwbGljYXRp b246Om5vdGlmeUludGVybmFsMihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGli UXQ1Q29yZS5zby41CiMyOCAweDAwMDA3ZmZmZjYyYWRkZjUgaW4gICgpIGF0IC91c3IvbGliL2xp YlF0NVdpZGdldHMuc28uNQojMjkgMHgwMDAwN2ZmZmY2MmFmODM2IGluICAoKSBhdCAvdXNyL2xp Yi9saWJRdDVXaWRnZXRzLnNvLjUKIzMwIDB4MDAwMDdmZmZmNjI1Mjc1MiBpbiBRQXBwbGljYXRp b25Qcml2YXRlOjpub3RpZnlfaGVscGVyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xp Yi9saWJRdDVXaWRnZXRzLnNvLjUKIzMxIDB4MDAwMDdmZmZmNTc4YWE3YSBpbiBRQ29yZUFwcGxp Y2F0aW9uOjpub3RpZnlJbnRlcm5hbDIoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGli L2xpYlF0NUNvcmUuc28uNQotLVR5cGUgPFJFVD4gZm9yIG1vcmUsIHEgdG8gcXVpdCwgYyB0byBj b250aW51ZSB3aXRob3V0IHBhZ2luZy0tCiMzMiAweDAwMDA3ZmZmZjViNjAwYjkgaW4gUUd1aUFw cGxpY2F0aW9uUHJpdmF0ZTo6cHJvY2Vzc1doZWVsRXZlbnQoUVdpbmRvd1N5c3RlbUludGVyZmFj ZVByaXZhdGU6OldoZWVsRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVHdWkuc28uNQojMzMg MHgwMDAwN2ZmZmY1YjM5YmI1IGluIFFXaW5kb3dTeXN0ZW1JbnRlcmZhY2U6OnNlbmRXaW5kb3dT eXN0ZW1FdmVudHMoUUZsYWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVudHNGbGFnPikgKCkgYXQg L3Vzci9saWIvbGliUXQ1R3VpLnNvLjUKIzM0IDB4MDAwMDdmZmZkYzMzNTE2YyBpbiAgKCkgYXQg L3Vzci9saWIvbGliUXQ1WGNiUXBhLnNvLjUKIzM1IDB4MDAwMDdmZmZlNGM5NWE4NCBpbiBnX21h aW5fY29udGV4dF9kaXNwYXRjaCAoKSBhdCAvdXNyL2xpYi9saWJnbGliLTIuMC5zby4wCiMzNiAw eDAwMDA3ZmZmZTRjZTk5YjEgaW4gICgpIGF0IC91c3IvbGliL2xpYmdsaWItMi4wLnNvLjAKIzM3 IDB4MDAwMDdmZmZlNGM5NDJiMSBpbiBnX21haW5fY29udGV4dF9pdGVyYXRpb24gKCkgYXQgL3Vz ci9saWIvbGliZ2xpYi0yLjAuc28uMAojMzggMHgwMDAwN2ZmZmY1N2UzNmUxIGluIFFFdmVudERp c3BhdGNoZXJHbGliOjpwcm9jZXNzRXZlbnRzKFFGbGFnczxRRXZlbnRMb29wOjpQcm9jZXNzRXZl bnRzRmxhZz4pICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQojMzkgMHgwMDAwN2ZmZmY1 Nzg5M2ZjIGluIFFFdmVudExvb3A6OmV4ZWMoUUZsYWdzPFFFdmVudExvb3A6OlByb2Nlc3NFdmVu dHNGbGFnPikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CiM0MCAweDAwMDA3ZmZmZjU3 OTE4OTQgaW4gUUNvcmVBcHBsaWNhdGlvbjo6ZXhlYygpICgpIGF0IC91c3IvbGliL2xpYlF0NUNv cmUuc28uNQojNDEgMHgwMDAwNTU1NTU1NTU5ODg4IGluICAoKQojNDIgMHgwMDAwN2ZmZmY1MTNi MTUyIGluIF9fbGliY19zdGFydF9tYWluICgpIGF0IC91c3IvbGliL2xpYmMuc28uNgojNDMgMHgw MDAwNTU1NTU1NTVhNTBlIGluIF9zdGFydCAoKQooZ2RiKSAKKGdkYikgCihnZGIpIGMKQ29udGlu dWluZy4KW1RocmVhZCAweDdmZmZiMmIwZDY0MCAoTFdQIDE3NTk2NjEpIGV4aXRlZF0KW1RocmVh ZCAweDdmZmZiMzMwZTY0MCAoTFdQIDE3NTk2NjApIGV4aXRlZF0KW1RocmVhZCAweDdmZmZiM2Iw ZjY0MCAoTFdQIDE3NTk2NTkpIGV4aXRlZF0KW1RocmVhZCAweDdmZmZjMGNlNzY0MCAoTFdQIDE3 NTk2NTgpIGV4aXRlZF0KW1RocmVhZCAweDdmZmYzNTdmYTY0MCAoTFdQIDE3NTk3NjgpIGV4aXRl ZF0KW1RocmVhZCAweDdmZmYzM2ZmNzY0MCAoTFdQIDE3NTk3NjcpIGV4aXRlZF0KW1RocmVhZCAw eDdmZmYzMmZmNTY0MCAoTFdQIDE3NTk3NjkpIGV4aXRlZF0KZGlnaWthbS5nZW5lcmFsOiBPbmUg am9iIGlzIGRvbmUKW1RocmVhZCAweDdmZmYzNGZmOTY0MCAoTFdQIDE3NTk5NzMpIGV4aXRlZF0K ZGlnaWthbS5nZW5lcmFsOiBDYW5jZWwgTWFpbiBUaHJlYWQKCgo= 135802 2021-02-17 23:09:11 +0000 2021-02-17 23:09:11 +0000 Timestamped log showing UI lockup delay during possible mutex contention digikam_timestamped_log.txt text/plain 16815 griffiths_andy RmViIDE3IDIyOjMyOjUyIFtUaHJlYWQgMHg3ZmZmMzk3ZmE2NDAgKExXUCA5ODUxNzkpIGV4aXRl ZF0KRmViIDE3IDIyOjMzOjAyIFtOZXcgVGhyZWFkIDB4N2ZmZjM5N2ZhNjQwIChMV1AgOTg1Mjkz KV0KRmViIDE3IDIyOjMzOjAyIFtOZXcgVGhyZWFkIDB4N2ZmZjhmZmZmNjQwIChMV1AgOTg1Mjk0 KV0KXkNGZWIgMTcgMjI6MzM6MDcgCgoqKiBVSSBsb2NrZWQgdXAgd2hpbGUgc2Nyb2xsaW5nIHRo cm91Z2ggYSBkaXNwbGF5IG9mIDI5NTkgaXRlbXMuIFRoaXMgc2V0IGhhcyBiZWVuIG9uc2NyZWVu IGZvciBzb21lIG1pbnV0ZXMgYW5kIHdvcmtlZAoqKiBPaywgYWxsb3dpbmcgc2VsZWN0aW9uLCB0 YWdnaW5nLCBwcmV2aWV3aW5nLiBUaGVuIHRoZSBuZXh0IHJhbmRvbSBzY3JvbGwgbG9ja2VkIHVw LgoqKiBDdHJsLUMgKioKCkZlYiAxNyAyMjozMzowNyBUaHJlYWQgMSAiZGlnaWthbSIgcmVjZWl2 ZWQgc2lnbmFsIFNJR0lOVCwgSW50ZXJydXB0LgpGZWIgMTcgMjI6MzM6MDcgMHgwMDAwN2ZmZmYz Y2VlZDVkIGluIHN5c2NhbGwgKCkgZnJvbSAvdXNyL2xpYi9saWJjLnNvLjYKRmViIDE3IDIyOjMz OjE0IChnZGIpIGJ0IAojMCAgMHgwMDAwN2ZmZmYzY2VlZDVkIGluIHN5c2NhbGwgKCkgYXQgL3Vz ci9saWIvbGliYy5zby42CkZlYiAxNyAyMjozMzoxNCAjMSAgMHgwMDAwN2ZmZmY0MjJkMjY2IGlu IFFCYXNpY011dGV4Ojpsb2NrSW50ZXJuYWwoKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNv LjUKRmViIDE3IDIyOjMzOjE0ICMyICAweDAwMDA3ZmZmZjQyMmQ1NzQgaW4gICgpIGF0IC91c3Iv bGliL2xpYlF0NUNvcmUuc28uNQpGZWIgMTcgMjI6MzM6MTQgIzMgIDB4MDAwMDdmZmZmNzA5MmYw NyBpbiBEaWdpa2FtOjpDb3JlRGJBY2Nlc3M6OkNvcmVEYkFjY2VzcygpICh0aGlzPTB4N2ZmZmZm ZmZjOGY3KQpGZWIgMTcgMjI6MzM6MTQgICAgIGF0IC9ob21lL2FuZHlnL3Byb2plY3RzL2RpZ2lr YW0vY29yZS9saWJzL2RhdGFiYXNlL2NvcmVkYi9jb3JlZGJhY2Nlc3MuY3BwOjExNgpGZWIgMTcg MjI6MzM6MTQgIzQgIDB4MDAwMDdmZmZmNzBjZGY4YSBpbiBEaWdpa2FtOjpJdGVtUG9zaXRpb246 Okl0ZW1Qb3NpdGlvbihsb25nIGxvbmcpICh0aGlzPTB4N2ZmZmZmZmZjOTM4LCBpbWFnZUlkPTEw OTAwMSkKRmViIDE3IDIyOjMzOjE0ICAgICBhdCAvaG9tZS9hbmR5Zy9wcm9qZWN0cy9kaWdpa2Ft L2NvcmUvbGlicy9kYXRhYmFzZS9pdGVtL2NvbnRhaW5lcnMvaXRlbXBvc2l0aW9uLmNwcDoxMTkK RmViIDE3IDIyOjMzOjE0ICM1ICAweDAwMDA3ZmZmZjcwYjViNmMgaW4gRGlnaWthbTo6SXRlbUlu Zm86OmltYWdlUG9zaXRpb24oKSBjb25zdCAodGhpcz0weDdmZmZmZmZmYzliMCkKRmViIDE3IDIy OjMzOjE0ICAgICBhdCAvaG9tZS9hbmR5Zy9wcm9qZWN0cy9kaWdpa2FtL2NvcmUvbGlicy9kYXRh YmFzZS9pdGVtL2NvbnRhaW5lcnMvaXRlbWluZm9fZ2VvbG9jYXRpb24uY3BwOjM5CkZlYiAxNyAy MjozMzoxNCAjNiAgMHgwMDAwN2ZmZmY3MGI1ZjU4IGluIERpZ2lrYW06Okl0ZW1JbmZvOjpoYXND b29yZGluYXRlcygpIGNvbnN0ICh0aGlzPTB4N2ZmZmZmZmZjOWIwKQpGZWIgMTcgMjI6MzM6MTQg ICAgIGF0IC9ob21lL2FuZHlnL3Byb2plY3RzL2RpZ2lrYW0vY29yZS9saWJzL2RhdGFiYXNlL2l0 ZW0vY29udGFpbmVycy9pdGVtaW5mb19nZW9sb2NhdGlvbi5jcHA6MTA5CkZlYiAxNyAyMjozMzox NCAjNyAgMHgwMDAwN2ZmZmY3N2ZiN2I4IGluIERpZ2lrYW06Okl0ZW1Db29yZGluYXRlc092ZXJs YXk6OmNoZWNrSW5kZXgoUU1vZGVsSW5kZXggY29uc3QmKSBjb25zdCAodGhpcz0weDU1NTU1NWVi MmFlMCwgaW5kZXg9Li4uKQpGZWIgMTcgMjI6MzM6MTQgICAgIGF0IC9ob21lL2FuZHlnL3Byb2pl Y3RzL2RpZ2lrYW0vY29yZS9hcHAvaXRlbXMvb3ZlcmxheXMvaXRlbWNvb3JkaW5hdGVzb3Zlcmxh eS5jcHA6MTAwCkZlYiAxNyAyMjozMzoxNCAjOCAgMHgwMDAwN2ZmZmY2ODFiYWJhIGluIERpZ2lr YW06OkFic3RyYWN0V2lkZ2V0RGVsZWdhdGVPdmVybGF5OjpjaGVja0luZGV4T25FbnRlcihRTW9k ZWxJbmRleCBjb25zdCYpIGNvbnN0ICh0aGlzPTB4NTU1NTU1ZWIyYWUwLCBpbmRleD0uLi4pCkZl YiAxNyAyMjozMzoxNCAgICAgYXQgL2hvbWUvYW5keWcvcHJvamVjdHMvZGlnaWthbS9jb3JlL2xp YnMvd2lkZ2V0cy9pdGVtdmlldy9pdGVtZGVsZWdhdGVvdmVybGF5LmNwcDoyODgKRmViIDE3IDIy OjMzOjE0ICM5ICAweDAwMDA3ZmZmZjY4MWI5ZWMgaW4gRGlnaWthbTo6QWJzdHJhY3RXaWRnZXRE ZWxlZ2F0ZU92ZXJsYXk6OnNsb3RFbnRlcmVkKFFNb2RlbEluZGV4IGNvbnN0JikgKHRoaXM9MHg1 NTU1NTVlYjJhZTAsIGluZGV4PS4uLikKRmViIDE3IDIyOjMzOjE0ICAgICBhdCAvaG9tZS9hbmR5 Zy9wcm9qZWN0cy9kaWdpa2FtL2NvcmUvbGlicy93aWRnZXRzL2l0ZW12aWV3L2l0ZW1kZWxlZ2F0 ZW92ZXJsYXkuY3BwOjI2OApGZWIgMTcgMjI6MzM6MTQgIzEwIDB4MDAwMDdmZmZmNzdmYjg5NSBp biBEaWdpa2FtOjpJdGVtQ29vcmRpbmF0ZXNPdmVybGF5OjpzbG90RW50ZXJlZChRTW9kZWxJbmRl eCBjb25zdCYpICh0aGlzPTB4NTU1NTU1ZWIyYWUwLCBpbmRleD0uLi4pCkZlYiAxNyAyMjozMzox NCAgICAgYXQgL2hvbWUvYW5keWcvcHJvamVjdHMvZGlnaWthbS9jb3JlL2FwcC9pdGVtcy9vdmVy bGF5cy9pdGVtY29vcmRpbmF0ZXNvdmVybGF5LmNwcDoxMTMKRmViIDE3IDIyOjMzOjE0ICMxMSAw eDAwMDA3ZmZmZjY3YmJlN2EgaW4gRGlnaWthbTo6QWJzdHJhY3RXaWRnZXREZWxlZ2F0ZU92ZXJs YXk6OnF0X3N0YXRpY19tZXRhY2FsbChRT2JqZWN0KiwgUU1ldGFPYmplY3Q6OkNhbGwsIGludCwg dm9pZCoqKQpGZWIgMTcgMjI6MzM6MTQgICAgIChfbz0weDU1NTU1NWViMmFlMCwgX2M9UU1ldGFP YmplY3Q6Okludm9rZU1ldGFNZXRob2QsIF9pZD0wLCBfYT0weDdmZmZmZmZmY2JiMCkKRmViIDE3 IDIyOjMzOjE0ICAgICBhdCAvaG9tZS9hbmR5Zy9wcm9qZWN0cy9kaWdpa2FtL2J1aWxkL2NvcmUv bGlicy93aWRnZXRzL2NvcmVfZGlnaWthbXdpZGdldHNfb2JqX2F1dG9nZW4vWEJOTUNHRDI0UC9t b2NfaXRlbWRlbGVnYXRlb3ZlcmxheS5jcHA6MjQ5CkZlYiAxNyAyMjozMzoxNCAjMTIgMHgwMDAw N2ZmZmY0NDRiZTEwIGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKRmViIDE3IDIy OjMzOjE0ICMxMyAweDAwMDA3ZmZmZjUyYzE1YTYgaW4gUUFic3RyYWN0SXRlbVZpZXc6OmVudGVy ZWQoUU1vZGVsSW5kZXggY29uc3QmKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUK RmViIDE3IDIyOjMzOjE0ICMxNCAweDAwMDA3ZmZmZjUyY2Y2NDIgaW4gICgpIGF0IC91c3IvbGli L2xpYlF0NVdpZGdldHMuc28uNQpGZWIgMTcgMjI6MzM6MTQgIzE1IDB4MDAwMDdmZmZmNTJkMDAz ZSBpbiBRQWJzdHJhY3RJdGVtVmlldzo6dmVydGljYWxTY3JvbGxiYXJWYWx1ZUNoYW5nZWQoaW50 KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKRmViIDE3IDIyOjMzOjE0ICMxNiAw eDAwMDA3ZmZmZjQ0NGJlMTAgaW4gICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQpGZWIg MTcgMjI6MzM6MTQgIzE3IDB4MDAwMDdmZmZmNTE1NTgxZiBpbiBRQWJzdHJhY3RTbGlkZXI6OnZh bHVlQ2hhbmdlZChpbnQpICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMuc28uNQpGZWIgMTcg MjI6MzM6MTQgIzE4IDB4MDAwMDdmZmZmNTE1NWY4YyBpbiBRQWJzdHJhY3RTbGlkZXI6OnNldFZh bHVlKGludCkgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CkZlYiAxNyAyMjozMzox NCAjMTkgMHgwMDAwN2ZmZmY1MTU2YTk3IGluICAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRz LnNvLjUKRmViIDE3IDIyOjMzOjE0ICMyMCAweDAwMDA3ZmZmZjUxZmM1NjkgaW4gUVNjcm9sbEJh cjo6d2hlZWxFdmVudChRV2hlZWxFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NVdpZGdldHMu c28uNQpGZWIgMTcgMjI6MzM6MTQgIzIxIDB4MDAwMDdmZmZmNTBhMWIwZSBpbiBRV2lkZ2V0Ojpl dmVudChRRXZlbnQqKSAoKSBhdCAvdXNyL2xpYi9saWJRdDVXaWRnZXRzLnNvLjUKRmViIDE3IDIy OjMzOjE0ICMyMiAweDAwMDA3ZmZmZjUwNjA3NTIgaW4gUUFwcGxpY2F0aW9uUHJpdmF0ZTo6bm90 aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0 cy5zby41CkZlYiAxNyAyMjozMzoxNCAjMjMgMHgwMDAwN2ZmZmY0NDE0YTdhIGluIFFDb3JlQXBw bGljYXRpb246Om5vdGlmeUludGVybmFsMihRT2JqZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9s aWIvbGliUXQ1Q29yZS5zby41CkZlYiAxNyAyMjozMzoxNCAjMjQgMHgwMDAwN2ZmZmY2ODI3NmNh IGluIERpZ2lrYW06Okl0ZW1WaWV3Q2F0ZWdvcml6ZWQ6OndoZWVsRXZlbnQoUVdoZWVsRXZlbnQq KSAodGhpcz0weDU1NTU1NWNmZDZiMCwgZXZlbnQ9MHg3ZmZmZmZmZmQ0MTApCkZlYiAxNyAyMjoz MzoxNCAgICAgYXQgL2hvbWUvYW5keWcvcHJvamVjdHMvZGlnaWthbS9jb3JlL2xpYnMvd2lkZ2V0 cy9pdGVtdmlldy9pdGVtdmlld2NhdGVnb3JpemVkLmNwcDo5NDkKRmViIDE3IDIyOjMzOjE0ICMy NSAweDAwMDA3ZmZmZjUwYTFiMGUgaW4gUVdpZGdldDo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vz ci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CkZlYiAxNyAyMjozMzoxNCAjMjYgMHgwMDAwN2ZmZmY1 MTRkMTZmIGluIFFGcmFtZTo6ZXZlbnQoUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lk Z2V0cy5zby41CkZlYiAxNyAyMjozMzoxNCAjMjcgMHgwMDAwN2ZmZmY2ODI3YTQ2IGluIERpZ2lr YW06Okl0ZW1WaWV3Q2F0ZWdvcml6ZWQ6OnZpZXdwb3J0RXZlbnQoUUV2ZW50KikgKHRoaXM9MHg1 NTU1NTVjZmQ2YjAsIGV2ZW50PTB4N2ZmZmZmZmZkNDEwKQpGZWIgMTcgMjI6MzM6MTQgICAgIGF0 IC9ob21lL2FuZHlnL3Byb2plY3RzL2RpZ2lrYW0vY29yZS9saWJzL3dpZGdldHMvaXRlbXZpZXcv aXRlbXZpZXdjYXRlZ29yaXplZC5jcHA6MTAzNwpGZWIgMTcgMjI6MzM6MTQgIzI4IDB4MDAwMDdm ZmZmNDQxNDdlMyBpbiBRQ29yZUFwcGxpY2F0aW9uUHJpdmF0ZTo6c2VuZFRocm91Z2hPYmplY3RF dmVudEZpbHRlcnMoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUu c28uNQpGZWIgMTcgMjI6MzM6MTQgIzI5IDB4MDAwMDdmZmZmNTA2MDc0MSBpbiBRQXBwbGljYXRp b25Qcml2YXRlOjpub3RpZnlfaGVscGVyKFFPYmplY3QqLCBRRXZlbnQqKSAoKSBhdCAvdXNyL2xp Yi9saWJRdDVXaWRnZXRzLnNvLjUKRmViIDE3IDIyOjMzOjE0ICMzMCAweDAwMDA3ZmZmZjUwNjgy ZGMgaW4gUUFwcGxpY2F0aW9uOjpub3RpZnkoUU9iamVjdCosIFFFdmVudCopICgpIGF0IC91c3Iv bGliL2xpYlF0NVdpZGdldHMuc28uNQpGZWIgMTcgMjI6MzM6MTQgIzMxIDB4MDAwMDdmZmZmNDQx NGE3YSBpbiBRQ29yZUFwcGxpY2F0aW9uOjpub3RpZnlJbnRlcm5hbDIoUU9iamVjdCosIFFFdmVu dCopICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28uNQpGZWIgMTcgMjI6MzM6MTQgIzMyIDB4 MDAwMDdmZmZmNTBiYmRmNSBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CkZl YiAxNyAyMjozMzoxNCAjMzMgMHgwMDAwN2ZmZmY1MGJkODM2IGluICAoKSBhdCAvdXNyL2xpYi9s aWJRdDVXaWRnZXRzLnNvLjUKRmViIDE3IDIyOjMzOjE0ICMzNCAweDAwMDA3ZmZmZjUwNjA3NTIg aW4gUUFwcGxpY2F0aW9uUHJpdmF0ZTo6bm90aWZ5X2hlbHBlcihRT2JqZWN0KiwgUUV2ZW50Kikg KCkgYXQgL3Vzci9saWIvbGliUXQ1V2lkZ2V0cy5zby41CkZlYiAxNyAyMjozMzoxNCAjMzUgMHgw MDAwN2ZmZmY0NDE0YTdhIGluIFFDb3JlQXBwbGljYXRpb246Om5vdGlmeUludGVybmFsMihRT2Jq ZWN0KiwgUUV2ZW50KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CkZlYiAxNyAyMjoz MzoxNCAjMzYgMHgwMDAwN2ZmZmY0OTZlMGI5IGluIFFHdWlBcHBsaWNhdGlvblByaXZhdGU6OnBy b2Nlc3NXaGVlbEV2ZW50KFFXaW5kb3dTeXN0ZW1JbnRlcmZhY2VQcml2YXRlOjpXaGVlbEV2ZW50 KikgKCkgYXQgL3Vzci9saWIvbGliUXQ1R3VpLnNvLjUKRmViIDE3IDIyOjMzOjE0ICMzNyAweDAw MDA3ZmZmZjQ5NDdiYjUgaW4gUVdpbmRvd1N5c3RlbUludGVyZmFjZTo6c2VuZFdpbmRvd1N5c3Rl bUV2ZW50cyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAoKSBhdCAvdXNy L2xpYi9saWJRdDVHdWkuc28uNQpGZWIgMTcgMjI6MzM6MTQgIzM4IDB4MDAwMDdmZmZkYjc5ZjE2 YyBpbiAgKCkgYXQgL3Vzci9saWIvbGliUXQ1WGNiUXBhLnNvLjUKRmViIDE3IDIyOjMzOjE0ICMz OSAweDAwMDA3ZmZmZTUwNDRhODQgaW4gZ19tYWluX2NvbnRleHRfZGlzcGF0Y2ggKCkgYXQgL3Vz ci9saWIvbGliZ2xpYi0yLjAuc28uMApGZWIgMTcgMjI6MzM6MTQgIzQwIDB4MDAwMDdmZmZlNTA5 ODliMSBpbiAgKCkgYXQgL3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMApGZWIgMTcgMjI6MzM6MTQg IzQxIDB4MDAwMDdmZmZlNTA0MzJiMSBpbiBnX21haW5fY29udGV4dF9pdGVyYXRpb24gKCkgYXQg L3Vzci9saWIvbGliZ2xpYi0yLjAuc28uMApGZWIgMTcgMjI6MzM6MTQgIzQyIDB4MDAwMDdmZmZm NDQ2ZDZlMSBpbiBRRXZlbnREaXNwYXRjaGVyR2xpYjo6cHJvY2Vzc0V2ZW50cyhRRmxhZ3M8UUV2 ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNv LjUKRmViIDE3IDIyOjMzOjE0ICM0MyAweDAwMDA3ZmZmZjQ0MTMzZmMgaW4gUUV2ZW50TG9vcDo6 ZXhlYyhRRmxhZ3M8UUV2ZW50TG9vcDo6UHJvY2Vzc0V2ZW50c0ZsYWc+KSAoKSBhdCAvdXNyL2xp Yi9saWJRdDVDb3JlLnNvLjUKRmViIDE3IDIyOjMzOjE0ICM0NCAweDAwMDA3ZmZmZjQ0MWI4OTQg aW4gUUNvcmVBcHBsaWNhdGlvbjo6ZXhlYygpICgpIGF0IC91c3IvbGliL2xpYlF0NUNvcmUuc28u NQpGZWIgMTcgMjI6MzM6MTQgIzQ1IDB4MDAwMDU1NTU1NTU1YWI0ZSBpbiBtYWluKGludCwgY2hh cioqKSAoYXJnYz0xLCBhcmd2PTB4N2ZmZmZmZmZkZTc4KSBhdCAvaG9tZS9hbmR5Zy9wcm9qZWN0 cy9kaWdpa2FtL2NvcmUvYXBwL21haW4vbWFpbi5jcHA6NDA2CkZlYiAxNyAyMjozMzo0NyAoZ2Ri KSBpbmZvIHRocmVhZHMKICBJZCAgIFRhcmdldCBJZCAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgRnJhbWUgCkZlYiAxNyAyMjozMzo0NyAqIDEgICAgVGhyZWFkIDB4 N2ZmZmRiYmZjMmMwIChMV1AgOTg0NTEyKSAiZGlnaWthbSIgICAgICAgICAweDAwMDA3ZmZmZjNj ZWVkNWQgaW4gc3lzY2FsbCAoKSBmcm9tIC91c3IvbGliL2xpYmMuc28uNgpGZWIgMTcgMjI6MzM6 NDcgICAyICAgIFRocmVhZCAweDdmZmZkYjZhMjY0MCAoTFdQIDk4NDUzOSkgIlFYY2JFdmVudFF1 ZXVlIiAgMHgwMDAwN2ZmZmYzY2U5NDZmIGluIHBvbGwgKCkgZnJvbSAvdXNyL2xpYi9saWJjLnNv LjYKRmViIDE3IDIyOjMzOjQ3ICAgMyAgICBUaHJlYWQgMHg3ZmZmZDk5ZDE2NDAgKExXUCA5ODQ1 NDgpICJkaWdpa2FtOmRpc2skMCIgIDB4MDAwMDdmZmZmM2RjZTZhMiBpbiBwdGhyZWFkX2NvbmRf d2FpdEBAR0xJQkNfMi4zLjIgKCkgZnJvbSAvdXNyL2xpYi9saWJwdGhyZWFkLnNvLjAKRmViIDE3 IDIyOjMzOjQ3ICAgNCAgICBUaHJlYWQgMHg3ZmZmZDkxZDA2NDAgKExXUCA5ODQ1NDkpICJkaWdp a2FtOmRpc2skMSIgIDB4MDAwMDdmZmZmM2RjZTZhMiBpbiBwdGhyZWFkX2NvbmRfd2FpdEBAR0xJ QkNfMi4zLjIgKCkgZnJvbSAvdXNyL2xpYi9saWJwdGhyZWFkLnNvLjAKRmViIDE3IDIyOjMzOjQ3 ICAgNSAgICBUaHJlYWQgMHg3ZmZmZDg5Y2Y2NDAgKExXUCA5ODQ1NTApICJkaWdpa2FtOmRpc2sk MiIgIDB4MDAwMDdmZmZmM2RjZTZhMiBpbiBwdGhyZWFkX2NvbmRfd2FpdEBAR0xJQkNfMi4zLjIg KCkgZnJvbSAvdXNyL2xpYi9saWJwdGhyZWFkLnNvLjAKRmViIDE3IDIyOjMzOjQ3ICAgNiAgICBU aHJlYWQgMHg3ZmZmY2JmZmY2NDAgKExXUCA5ODQ1NTEpICJkaWdpa2FtOmRpc2skMyIgIDB4MDAw MDdmZmZmM2RjZTZhMiBpbiBwdGhyZWFkX2NvbmRfd2FpdEBAR0xJQkNfMi4zLjIgKCkgZnJvbSAv dXNyL2xpYi9saWJwdGhyZWFkLnNvLjAKRmViIDE3IDIyOjMzOjQ3ICAgNyAgICBUaHJlYWQgMHg3 ZmZmY2E0MDI2NDAgKExXUCA5ODQ1NTIpICJRREJ1c0Nvbm5lY3Rpb24iIDB4MDAwMDdmZmZmM2Nl OTQ2ZiBpbiBwb2xsICgpIGZyb20gL3Vzci9saWIvbGliYy5zby42CkZlYiAxNyAyMjozMzo0NyAg IDggICAgVGhyZWFkIDB4N2ZmZmM5MWYxNjQwIChMV1AgOTg0NTUzKSAiRGlnaWthbTo6U2NhbkNv IiAweDAwMDA3ZmZmZjNkY2U2YTIgaW4gcHRocmVhZF9jb25kX3dhaXRAQEdMSUJDXzIuMy4yICgp IGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDkgICAgVGhy ZWFkIDB4N2ZmZmM4OWYwNjQwIChMV1AgOTg0NTU0KSAiZGlnaWthbSIgICAgICAgICAweDAwMDA3 ZmZmZjNjZWJjOTYgaW4gcHNlbGVjdCAoKSBmcm9tIC91c3IvbGliL2xpYmMuc28uNgpGZWIgMTcg MjI6MzM6NDcgICAxMSAgIFRocmVhZCAweDdmZmZiN2ZmZjY0MCAoTFdQIDk4NDU1NikgIlRocmVh ZCAocG9vbGVkKSIgMHgwMDAwN2ZmZmYzZGNlOWM4IGluIHB0aHJlYWRfY29uZF90aW1lZHdhaXRA QEdMSUJDXzIuMy4yICgpCkZlYiAxNyAyMjozMzo0NyAgICBmcm9tIC91c3IvbGliL2xpYnB0aHJl YWQuc28uMApGZWIgMTcgMjI6MzM6NDcgICAxMiAgIFRocmVhZCAweDdmZmZiNmM4MzY0MCAoTFdQ IDk4NDU1NykgIlRocmVhZCAocG9vbGVkKSIgMHgwMDAwN2ZmZmYzZGNlOWM4IGluIHB0aHJlYWRf Y29uZF90aW1lZHdhaXRAQEdMSUJDXzIuMy4yICgpCkZlYiAxNyAyMjozMzo0NyAgICBmcm9tIC91 c3IvbGliL2xpYnB0aHJlYWQuc28uMApGZWIgMTcgMjI6MzM6NDcgICAxMyAgIFRocmVhZCAweDdm ZmZiNjQ4MjY0MCAoTFdQIDk4NDU1OCkgIlRocmVhZCAocG9vbGVkKSIgMHgwMDAwN2ZmZmYzZGNl OWM4IGluIHB0aHJlYWRfY29uZF90aW1lZHdhaXRAQEdMSUJDXzIuMy4yICgpCkZlYiAxNyAyMjoz Mzo0NyAgICBmcm9tIC91c3IvbGliL2xpYnB0aHJlYWQuc28uMApGZWIgMTcgMjI6MzM6NDcgICAx NCAgIFRocmVhZCAweDdmZmZiNWM4MTY0MCAoTFdQIDk4NDU1OSkgIlRocmVhZCAocG9vbGVkKSIg MHgwMDAwN2ZmZmYzZGNlOWM4IGluIHB0aHJlYWRfY29uZF90aW1lZHdhaXRAQEdMSUJDXzIuMy4y ICgpCkZlYiAxNyAyMjozMzo0NyAgICBmcm9tIC91c3IvbGliL2xpYnB0aHJlYWQuc28uMApGZWIg MTcgMjI6MzM6NDcgICAxNSAgIFRocmVhZCAweDdmZmZhMmMxNjY0MCAoTFdQIDk4NDU3MykgIkRp Z2lrYW06OlBhcmtpbiIgMHgwMDAwN2ZmZmYzZGNlNmEyIGluIHB0aHJlYWRfY29uZF93YWl0QEBH TElCQ18yLjMuMiAoKSBmcm9tIC91c3IvbGliL2xpYnB0aHJlYWQuc28uMApGZWIgMTcgMjI6MzM6 NDcgICAxNiAgIFRocmVhZCAweDdmZmZhMWQzZDY0MCAoTFdQIDk4NDU4MikgInNhbmRib3hfaXBj X3RociIgMHgwMDAwN2ZmZmYzY2U5NDZmIGluIHBvbGwgKCkgZnJvbSAvdXNyL2xpYi9saWJjLnNv LjYKRmViIDE3IDIyOjMzOjQ3ICAgMTcgICBUaHJlYWQgMHg3ZmZmYTE1M2M2NDAgKExXUCA5ODQ1 ODgpICJkaWdpa2FtIiAgICAgICAgIDB4MDAwMDdmZmZmM2NjMGVlZiBpbiB3YWl0NCAoKSBmcm9t IC91c3IvbGliL2xpYmMuc28uNgpGZWIgMTcgMjI6MzM6NDcgICAxOCAgIFRocmVhZCAweDdmZmZh MGQzYjY0MCAoTFdQIDk4NDU4OSkgIlRocmVhZFBvb2xTZXJ2aSIgMHgwMDAwN2ZmZmYzY2Y0NWRl IGluIGVwb2xsX3dhaXQgKCkgZnJvbSAvdXNyL2xpYi9saWJjLnNvLjYKRmViIDE3IDIyOjMzOjQ3 ICAgMjAgICBUaHJlYWQgMHg3ZmZmOGY3ZmU2NDAgKExXUCA5ODQ1OTEpICJDaHJvbWVfSU9UaHJl YWQiIDB4MDAwMDdmZmZmM2NmNDVkZSBpbiBlcG9sbF93YWl0ICgpIGZyb20gL3Vzci9saWIvbGli Yy5zby42CkZlYiAxNyAyMjozMzo0NyAgIDIyICAgVGhyZWFkIDB4N2ZmZjhlN2ZjNjQwIChMV1Ag OTg0NTkzKSAiVGhyZWFkUG9vbEZvcmVnIiAweDAwMDA3ZmZmZjNkY2U5YzggaW4gcHRocmVhZF9j b25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIgKCkKRmViIDE3IDIyOjMzOjQ3ICAgIGZyb20gL3Vz ci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDIzICAgVGhyZWFkIDB4N2Zm ZjhkZmZiNjQwIChMV1AgOTg0NTk0KSAiaW5vdGlmeV9yZWFkZXIiICAweDAwMDA3ZmZmZjNjZWJi N2IgaW4gc2VsZWN0ICgpIGZyb20gL3Vzci9saWIvbGliYy5zby42CkZlYiAxNyAyMjozMzo0NyAg IDI0ICAgVGhyZWFkIDB4N2ZmZjhjZmY5NjQwIChMV1AgOTg0NTk2KSAiQ29tcG9zaXRvclRpbGVX IiAweDAwMDA3ZmZmZjNkY2U2YTIgaW4gcHRocmVhZF9jb25kX3dhaXRAQEdMSUJDXzIuMy4yICgp IGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDI2ICAgVGhy ZWFkIDB4N2ZmZjdmZmZmNjQwIChMV1AgOTg0NTk3KSAiQ2hyb21lX0luUHJvY0dwIiAweDAwMDA3 ZmZmZjNkY2U5YzggaW4gcHRocmVhZF9jb25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIgKCkKRmVi IDE3IDIyOjMzOjQ3ICAgIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjoz Mzo0NyAgIDI3ICAgVGhyZWFkIDB4N2ZmZjdlN2ZjNjQwIChMV1AgOTg0NjAwKSAiVmlkZW9DYXB0 dXJlVGhyIiAweDAwMDA3ZmZmZjNkY2U2YTIgaW4gcHRocmVhZF9jb25kX3dhaXRAQEdMSUJDXzIu My4yICgpIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDI4 ICAgVGhyZWFkIDB4N2ZmZjdmN2ZlNjQwIChMV1AgOTg0NTk4KSAiQ2hyb21lX0NoaWxkSU9UIiAw eDAwMDA3ZmZmZjNjZjQ1ZGUgaW4gZXBvbGxfd2FpdCAoKSBmcm9tIC91c3IvbGliL2xpYmMuc28u NgpGZWIgMTcgMjI6MzM6NDcgICAzMCAgIFRocmVhZCAweDdmZmY3ZGZmYjY0MCAoTFdQIDk4NDYw MSkgIlZpekNvbXBvc2l0b3JUaCIgMHgwMDAwN2ZmZmYzZGNlNmEyIGluIHB0aHJlYWRfY29uZF93 YWl0QEBHTElCQ18yLjMuMiAoKSBmcm9tIC91c3IvbGliL2xpYnB0aHJlYWQuc28uMApGZWIgMTcg MjI6MzM6NDcgICAzMiAgIFRocmVhZCAweDdmZmY3ZDdmYTY0MCAoTFdQIDk4NDYwNCkgImRpZ2lr YW0iICAgICAgICAgMHgwMDAwN2ZmZmYzY2U5NDZmIGluIHBvbGwgKCkgZnJvbSAvdXNyL2xpYi9s aWJjLnNvLjYKRmViIDE3IDIyOjMzOjQ3ICAgMzMgICBUaHJlYWQgMHg3ZmZmN2NmZjk2NDAgKExX UCA5ODQ2MDUpICJkaWdpa2FtIiAgICAgICAgIDB4MDAwMDdmZmZmM2NlOTQ2ZiBpbiBwb2xsICgp IGZyb20gL3Vzci9saWIvbGliYy5zby42CkZlYiAxNyAyMjozMzo0NyAgIDM0ICAgVGhyZWFkIDB4 N2ZmZjNiZmZmNjQwIChMV1AgOTg0NjA4KSAiZGlnaWthbSIgICAgICAgICAweDAwMDA3ZmZmZjNk ZDEwMTQgaW4gZG9fZnV0ZXhfd2FpdC5jb25zdHByb3AgKCkgZnJvbSAvdXNyL2xpYi9saWJwdGhy ZWFkLnNvLjAKRmViIDE3IDIyOjMzOjQ3ICAgMzUgICBUaHJlYWQgMHg3ZmZmM2I3ZmU2NDAgKExX UCA5ODQ2MDkpICJUaHJlYWRQb29sU2luZ2wiIDB4MDAwMDdmZmZmM2RjZTZhMiBpbiBwdGhyZWFk X2NvbmRfd2FpdEBAR0xJQkNfMi4zLjIgKCkgZnJvbSAvdXNyL2xpYi9saWJwdGhyZWFkLnNvLjAK RmViIDE3IDIyOjMzOjQ3ICAgMzYgICBUaHJlYWQgMHg3ZmZmM2FmZmQ2NDAgKExXUCA5ODQ2MTEp ICJDYWNoZVRocmVhZF9CbG8iIDB4MDAwMDdmZmZmM2NmNDVkZSBpbiBlcG9sbF93YWl0ICgpIGZy b20gL3Vzci9saWIvbGliYy5zby42CkZlYiAxNyAyMjozMzo0NyAgIDM3ICAgVGhyZWFkIDB4N2Zm ZjNhN2ZjNjQwIChMV1AgOTg0NjI5KSAiTWVtb3J5SW5mcmEiICAgICAweDAwMDA3ZmZmZjNkY2U2 YTIgaW4gcHRocmVhZF9jb25kX3dhaXRAQEdMSUJDXzIuMy4yICgpIGZyb20gL3Vzci9saWIvbGli cHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDQ4ICAgVGhyZWFkIDB4N2ZmZjMyN2ZjNjQw IChMV1AgOTg0Njc2KSAiVGhyZWFkIChwb29sZWQpIiAweDAwMDA3ZmZmZjNkY2U5YzggaW4gcHRo cmVhZF9jb25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIgKCkKRmViIDE3IDIyOjMzOjQ3ICAgIGZy b20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDQ5ICAgVGhyZWFk IDB4N2ZmZjMzZmZmNjQwIChMV1AgOTg0Njc3KSAiVGhyZWFkIChwb29sZWQpIiAweDAwMDA3ZmZm ZjNkY2U5YzggaW4gcHRocmVhZF9jb25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIgKCkKRmViIDE3 IDIyOjMzOjQ3ICAgIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0 NyAgIDUwICAgVGhyZWFkIDB4N2ZmZjMxN2ZhNjQwIChMV1AgOTg0Njc4KSAiVGhyZWFkIChwb29s ZWQpIiAweDAwMDA3ZmZmZjNkY2U5YzggaW4gcHRocmVhZF9jb25kX3RpbWVkd2FpdEBAR0xJQkNf Mi4zLjIgKCkKRmViIDE3IDIyOjMzOjQ3ICAgIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4w CkZlYiAxNyAyMjozMzo0NyAgIDUxICAgVGhyZWFkIDB4N2ZmZjMxZmZiNjQwIChMV1AgOTg0Njgw KSAiVGhyZWFkUG9vbFNpbmdsIiAweDAwMDA3ZmZmZjNkY2U2YTIgaW4gcHRocmVhZF9jb25kX3dh aXRAQEdMSUJDXzIuMy4yICgpIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAy MjozMzo0NyAgIDYzICAgVGhyZWFkIDB4N2ZmZjhkN2ZhNjQwIChMV1AgOTg0OTM1KSAiVGhyZWFk IChwb29sZWQpIiAweDAwMDA3ZmZmZjNkY2U5YzggaW4gcHRocmVhZF9jb25kX3RpbWVkd2FpdEBA R0xJQkNfMi4zLjIgKCkKRmViIDE3IDIyOjMzOjQ3ICAgIGZyb20gL3Vzci9saWIvbGlicHRocmVh ZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDY0ICAgVGhyZWFkIDB4N2ZmZjhlZmZkNjQwIChMV1Ag OTg0OTM2KSAiVGhyZWFkIChwb29sZWQpIiAweDAwMDA3ZmZmZjNkY2U5YzggaW4gcHRocmVhZF9j b25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIgKCkKRmViIDE3IDIyOjMzOjQ3ICAgIGZyb20gL3Vz ci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDY1ICAgVGhyZWFkIDB4N2Zm ZjdlZmZkNjQwIChMV1AgOTg0OTM4KSAiVGhyZWFkIChwb29sZWQpIiAweDAwMDA3ZmZmZjNkY2U5 YzggaW4gcHRocmVhZF9jb25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIgKCkKRmViIDE3IDIyOjMz OjQ3ICAgIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAxNyAyMjozMzo0NyAgIDcx ICAgVGhyZWFkIDB4N2ZmZjM5ZmZiNjQwIChMV1AgOTg0OTg4KSAiVGhyZWFkIChwb29sZWQpIiAw eDAwMDA3ZmZmZjNkY2U5YzggaW4gcHRocmVhZF9jb25kX3RpbWVkd2FpdEBAR0xJQkNfMi4zLjIg KCkKRmViIDE3IDIyOjMzOjQ3ICAgIGZyb20gL3Vzci9saWIvbGlicHRocmVhZC5zby4wCkZlYiAx NyAyMjozMzo0OCAgIDkyICAgVGhyZWFkIDB4N2ZmZjMyZmZkNjQwIChMV1AgOTg1MTc0KSAidGhy ZWFkZWQtbWwiICAgICAweDAwMDA3ZmZmZjNjZTk0NmYgaW4gcG9sbCAoKSBmcm9tIC91c3IvbGli L2xpYmMuc28uNgpGZWIgMTcgMjI6MzM6NDggICAxMDIgIFRocmVhZCAweDdmZmYzOTdmYTY0MCAo TFdQIDk4NTI5MykgIkRCSm9ic1RocmVhZCIgICAgMHgwMDAwN2ZmZmYzZGNlNmEyIGluIHB0aHJl YWRfY29uZF93YWl0QEBHTElCQ18yLjMuMiAoKSBmcm9tIC91c3IvbGliL2xpYnB0aHJlYWQuc28u MApGZWIgMTcgMjI6MzM6NDggICAxMDMgIFRocmVhZCAweDdmZmY4ZmZmZjY0MCAoTFdQIDk4NTI5 NCkgIlRocmVhZCAocG9vbGVkKSIgMHgwMDAwN2ZmZmYzY2U0MjVhIGluIF9feHN0YXQ2NCAoKSBm cm9tIC91c3IvbGliL2xpYmMuc28uNgoKKiogSW4gcGFzdCBvY2N1cnJlbmNlcyBpdCB3YXMgbm90 aWNlZCB0aGF0IHRoZSBVSSBsb2NrdXAgb2NjdXJyZWQgZHVyaW5nIHRoZSBsaWZldGltZSBvZiBh IHBhcnRpY3VsYXIgdGhyZWFkLCB0aGUKKiogIkRCSm9ic1RocmVhZCIuIEluIHRoaXMgaW5zdGFu Y2UsIExXUCA5ODUyOTMuCgpGZWIgMTcgMjI6MzQ6MDEgKGdkYikgdGhyZWFkIDEwMgpbU3dpdGNo aW5nIHRvIHRocmVhZCAxMDIgKFRocmVhZCAweDdmZmYzOTdmYTY0MCAoTFdQIDk4NTI5MykpXQpG ZWIgMTcgMjI6MzQ6MDkgIzAgIDB4MDAwMDdmZmZmM2RjZTZhMiBpbiBwdGhyZWFkX2NvbmRfd2Fp dEBAR0xJQkNfMi4zLjIgKCkgZnJvbSAvdXNyL2xpYi9saWJwdGhyZWFkLnNvLjAKRmViIDE3IDIy OjM0OjExIChnZGIpIGJ0CiMwICAweDAwMDA3ZmZmZjNkY2U2YTIgaW4gcHRocmVhZF9jb25kX3dh aXRAQEdMSUJDXzIuMy4yICgpIGF0IC91c3IvbGliL2xpYnB0aHJlYWQuc28uMApGZWIgMTcgMjI6 MzQ6MTEgIzEgIDB4MDAwMDdmZmZmNDIzMzBkNCBpbiBRV2FpdENvbmRpdGlvbjo6d2FpdChRTXV0 ZXgqLCBRRGVhZGxpbmVUaW1lcikgKCkgYXQgL3Vzci9saWIvbGliUXQ1Q29yZS5zby41CkZlYiAx NyAyMjozNDoxMSAjMiAgMHgwMDAwN2ZmZmY2NDVlNTFjIGluIERpZ2lrYW06OkFjdGlvblRocmVh ZEJhc2U6OnJ1bigpICh0aGlzPTB4NTU1NTYxMTY0MTYwKQpGZWIgMTcgMjI6MzQ6MTEgICAgIGF0 IC9ob21lL2FuZHlnL3Byb2plY3RzL2RpZ2lrYW0vY29yZS9saWJzL3RocmVhZHMvYWN0aW9udGhy ZWFkYmFzZS5jcHA6MjM3CkZlYiAxNyAyMjozNDoxMSAjMyAgMHgwMDAwN2ZmZmY0MjJjZjBmIGlu ICAoKSBhdCAvdXNyL2xpYi9saWJRdDVDb3JlLnNvLjUKRmViIDE3IDIyOjM0OjExICM0ICAweDAw MDA3ZmZmZjNkYzgzZTkgaW4gc3RhcnRfdGhyZWFkICgpIGF0IC91c3IvbGliL2xpYnB0aHJlYWQu c28uMApGZWIgMTcgMjI6MzQ6MTEgIzUgIDB4MDAwMDdmZmZmM2NmNDI5MyBpbiBjbG9uZSAoKSBh dCAvdXNyL2xpYi9saWJjLnNvLjYKCioqIFRocmVhZCBMV1AgOTg1MjkzIHdhaXRpbmcgZm9yIGEg TXV0ZXg/IEluIGNvcmUvbGlicy90aHJlYWRzL2FjdGlvbnRocmVhZGJhc2UuY3BwOjIzNwoKRmVi IDE3IDIyOjM0OjQ2IChnZGIpIGMKQ29udGludWluZy40OjQ2IApGZWIgMTcgMjI6MzQ6NDYgW1Ro cmVhZCAweDdmZmY3ZWZmZDY0MCAoTFdQIDk4NDkzOCkgZXhpdGVkXQpGZWIgMTcgMjI6MzQ6NDYg W1RocmVhZCAweDdmZmY4ZWZmZDY0MCAoTFdQIDk4NDkzNikgZXhpdGVkXQpGZWIgMTcgMjI6MzQ6 NDYgW1RocmVhZCAweDdmZmY4ZDdmYTY0MCAoTFdQIDk4NDkzNSkgZXhpdGVkXQpGZWIgMTcgMjI6 MzQ6NDYgW1RocmVhZCAweDdmZmYzOWZmYjY0MCAoTFdQIDk4NDk4OCkgZXhpdGVkXQpGZWIgMTcg MjI6MzQ6NDYgW1RocmVhZCAweDdmZmYzMTdmYTY0MCAoTFdQIDk4NDY3OCkgZXhpdGVkXQpGZWIg MTcgMjI6MzQ6NDYgW1RocmVhZCAweDdmZmYzM2ZmZjY0MCAoTFdQIDk4NDY3NykgZXhpdGVkXQpG ZWIgMTcgMjI6MzQ6NDYgW1RocmVhZCAweDdmZmYzMjdmYzY0MCAoTFdQIDk4NDY3NikgZXhpdGVk XQpGZWIgMTcgMjI6MzQ6NDYgW05ldyBUaHJlYWQgMHg3ZmZmYjVjODE2NDAgKExXUCA5ODU1Mzcp XQpGZWIgMTcgMjI6MzQ6NDYgW1RocmVhZCAweDdmZmZiNWM4MTY0MCAoTFdQIDk4NDU1OSkgZXhp dGVkXQpGZWIgMTcgMjI6MzQ6NDYgW1RocmVhZCAweDdmZmZiNjQ4MjY0MCAoTFdQIDk4NDU1OCkg ZXhpdGVkXQpGZWIgMTcgMjI6MzQ6NDYgW1RocmVhZCAweDdmZmZiNmM4MzY0MCAoTFdQIDk4NDU1 NykgZXhpdGVkXQpGZWIgMTcgMjI6MzQ6NDYgW1RocmVhZCAweDdmZmZiN2ZmZjY0MCAoTFdQIDk4 NDU1NikgZXhpdGVkXQpGZWIgMTcgMjI6MzQ6NTUgW1RocmVhZCAweDdmZmYzOTdmYTY0MCAoTFdQ IDk4NTI5MykgZXhpdGVkXQoKKiogVUkgbm93IHJlc3BvbnNpdmUgYWdhaW4KKiogUGF1c2VkIGlu IEdEQiAgICAgZm9yIDIyOjM0OjQ2CioqICAgICAgICAgICAgICAgICAgICAgLSAyMjozMzowNwoq KiAgICAgICAgICAgICAgICAgICAgICAgLS0tLS0tLS0KKiogICAgICAgICAgICAgICAgICAgICAg ICAgIDAxOjM5CioqCioqIExXUCA5ODUyOTMgYWN0aXZlIGZvciAyMjozNDo1NQoqKiAgICAgICAg ICAgICAgICAgICAgIC0gMjI6MzM6MDIKKiogICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0t CioqICAgICAgICAgICAgICAgICAgICAgICAgICAwMTo1MwoqKiAgICAgICAgICAgICAgICAgICAg IC0gICAgMDE6MzkKKiogICAgICAgICAgICAgICAgICAgICAgIC0tLS0tLS0tCioqICAgICAgICAg ICAgICAgICAgICAgICAgICAwMDoxNAoqKgoqKiBXaGljaCBjb3JyZXNwb25kcyB0byBteSAncGVy Y2lldmVkJyBkZWxheSBvZiAxNCBzZWNvbmRzIGR1cmluZyB3aGljaCB0aGUgVUkgaXMgdW5yZXNw b25zaXZlLiAgIAoKRmViIDE3IDIyOjM0OjU1IFtOZXcgVGhyZWFkIDB4N2ZmZjM5N2ZhNjQwIChM V1AgOTg1NTY2KV0KRmViIDE3IDIyOjM0OjU1IFtOZXcgVGhyZWFkIDB4N2ZmZjM5ZmZiNjQwIChM V1AgOTg1NTY3KV0KRmViIDE3IDIyOjM0OjU1IFtOZXcgVGhyZWFkIDB4N2ZmZjhlZmZkNjQwIChM V1AgOTg1NTY4KV0KRmViIDE3IDIyOjM0OjU1IFtUaHJlYWQgMHg3ZmZmOGZmZmY2NDAgKExXUCA5 ODUyOTQpIGV4aXRlZF0KRmViIDE3IDIyOjM0OjU1IFtOZXcgVGhyZWFkIDB4N2ZmZjhmZmZmNjQw IChMV1AgOTg1NTY5KV0KXkNGZWIgMTcgMjI6MzQ6NTkgCkZlYiAxNyAyMjozNDo1OSBUaHJlYWQg MSAiZGlnaWthbSIgcmVjZWl2ZWQgc2lnbmFsIFNJR0lOVCwgSW50ZXJydXB0LgpGZWIgMTcgMjI6 MzQ6NTkgW1N3aXRjaGluZyB0byBUaHJlYWQgMHg3ZmZmZGJiZmMyYzAgKExXUCA5ODQ1MTIpXQoK