25534 2009-05-03 20:28:10 -0700 [GTK] Objects of ROLE_TABLE should implement the accessible table interface 2009-10-30 10:35:52 -0700 1 1 1 Unclassified WebKit Accessibility 528+ (Nightly build) PC Linux RESOLVED FIXED Gtk P2 Normal --- 25531 0 jdiggs webkit-unassigned apinheiro commit-queue eric walker.willie xan.lopez oldest_to_newest 119753 0 jdiggs 2009-05-03 20:28:10 -0700 Steps to reproduce: 1. Open the (to be) attached test case. 2. In Accerciser, select the table in the list of objects in the left-hand pane. Then use Accerciser's Interface Viewer to view the information exposed via the accessible table interface. Expected results: The accessible table interface would be implemented, exposing all of the information detailed here: http://library.gnome.org/devel/atk/unstable/AtkTable.html Actual results: The accessible table interface does not appear to be implemented for accessibles of ROLE_TABLE. Note: I believe I have all of the needed patches associated with bug 21546. Also, please note that the accessible hierarchy of the table seems unusual. The table cells appear to each be represented by two children within the table rather than one. First they appear in row order as children of objects of ROLE_LIST_ITEM. Then they appear again in column order as children of objects of ROLE_UNKNOWN. Please let me know if you'd like me to open a separate bug for this latter issue. 119754 1 29971 jdiggs 2009-05-03 20:30:02 -0700 Created attachment 29971 aforementioned test case 156016 2 jdiggs 2009-10-19 18:32:55 -0700 Calling dibs on this one as I've already done quite a bit of the implementation (and don't seem to have the necessary privs to assign this to myself). 156073 3 41481 jdiggs 2009-10-19 23:08:06 -0700 Created attachment 41481 Part 1 Part 1: * accessibility/gtk/AccessibilityObjectWrapperAtk.cpp: (getCell): (getCellIndex): (webkit_accessible_table_ref_at): (webkit_accessible_table_get_index_at): (webkit_accessible_table_get_n_columns): (webkit_accessible_table_get_n_rows): (webkit_accessible_table_get_column_extent_at): (webkit_accessible_table_get_row_extent_at): (webkit_accessible_table_get_column_header): (webkit_accessible_table_get_row_header): (atk_table_interface_init): (AtkInterfacesInitFunctions): (GetAtkInterfaceTypeFromWAIType): 156110 4 41481 xan.lopez 2009-10-20 02:47:15 -0700 Comment on attachment 41481 Part 1 >+ >+static guint getCellIndex(AccessibilityTableCell* AXCell, AccessibilityTable* AXTable) >+{ >+ // Calculate the cell's index as if we had traditional Gtk+ tables. So how does that work exactly? Does it simply put row after row, the index being n_columns*row + column or something like that? The way you are doing it in the patch you are simply relying on cells to be ordered the way you want, so I guess it wouldn't hurt to be a bit more explicit. >+ AccessibilityObject::AccessibilityChildrenVector allCells; >+ AXTable->cells(allCells); >+ unsigned cellCount = allCells.size(); >+ for (unsigned k = 0; k < cellCount; ++k) >+ if (allCells[k] == AXCell) >+ return k; if allCells is a normal C++ vector I think you can use std::find to get the index of the element intsead of looking for it manually. It will return an iterator, so to get the index value you just have to substract from it the first iterator in the vector (so... something like pos = find(allCells.begin(), allCells.end(), AXCell) - allCells.begin();) Now that I just wrote this I wonder if it actually matters or if the code is more readable that way... feel free to ignore it :) >+ return -1; Don't think returning '-1' for error will work having a 'guint' return value :) >+} >+ >+static AtkObject* webkit_accessible_table_ref_at(AtkTable* table, gint row, gint column) >+{ >+ AccessibilityTableCell* AXCell = getCell(table, row, column); >+ if (!AXCell) >+ return NULL; >+ return AXCell->wrapper(); >+} >+ >+static gint webkit_accessible_table_get_index_at(AtkTable* table, gint row, gint column) >+{ >+ AccessibilityTableCell* AXCell = getCell(table, row, column); >+ AccessibilityTable* AXTable = static_cast<AccessibilityTable*>(core(table)); >+ return getCellIndex(AXCell, AXTable); >+} >+ >+static gint webkit_accessible_table_get_n_columns(AtkTable* table) >+{ >+ AccessibilityObject* accTable = core(table); >+ if (accTable->isAccessibilityRenderObject()) >+ return static_cast<AccessibilityTable*>(accTable)->columnCount(); >+ return 0; >+} >+ >+static gint webkit_accessible_table_get_n_rows(AtkTable* table) >+{ >+ AccessibilityObject* accTable = core(table); >+ if (accTable->isAccessibilityRenderObject()) >+ return static_cast<AccessibilityTable*>(accTable)->rowCount(); >+ return 0; >+} >+ >+static gint webkit_accessible_table_get_column_extent_at(AtkTable* table, gint row, gint column) >+{ >+ AccessibilityTableCell* AXCell = getCell(table, row, column); >+ if (AXCell) { >+ pair<int, int> columnRange; >+ AXCell->columnIndexRange(columnRange); >+ return columnRange.second; Just a sanity check: what comes in that pair, the indexes of the columns the cell occupies? If the function returns the extent shouldn't you return second - first? >+ } >+ return 0; >+} >+ >+static gint webkit_accessible_table_get_row_extent_at(AtkTable* table, gint row, gint column) >+{ >+ AccessibilityTableCell* AXCell = getCell(table, row, column); >+ if (AXCell) { >+ pair<int, int> rowRange; >+ AXCell->rowIndexRange(rowRange); >+ return rowRange.second; >+ } >+ return 0; >+} >+ >+static AtkObject* webkit_accessible_table_get_column_header(AtkTable* table, gint column) >+{ >+ // Something is not quite right here. :-( We get headers but not the child >+ // text which holds the header content. Also note that the nearly identical >+ // get_row_header works as expected. Might be related to the funky hierarchy. >+ AccessibilityObject* accTable = core(table); >+ if (accTable->isAccessibilityRenderObject()) { >+ AccessibilityObject::AccessibilityChildrenVector allColumnHeaders; >+ static_cast<AccessibilityTable*>(accTable)->columnHeaders(allColumnHeaders); >+ >+ unsigned colCount = allColumnHeaders.size(); >+ for (unsigned k = 0; k < colCount; ++k) { >+ AccessibilityObject* columnObject = allColumnHeaders[k]->parentObject(); >+ if (static_cast<AccessibilityTableColumn*>(columnObject)->columnIndex() == column) >+ return allColumnHeaders[k]->wrapper(); >+ } >+ } >+ return NULL; >+} I'm sure you'll figure it out in a follow-up patch ;) >+ >+static AtkObject* webkit_accessible_table_get_row_header(AtkTable* table, gint row) >+{ >+ AccessibilityObject* accTable = core(table); >+ if (accTable->isAccessibilityRenderObject()) { >+ AccessibilityObject::AccessibilityChildrenVector allRowHeaders; >+ static_cast<AccessibilityTable*>(accTable)->rowHeaders(allRowHeaders); >+ >+ unsigned rowCount = allRowHeaders.size(); >+ for (unsigned k = 0; k < rowCount; ++k) { >+ AccessibilityObject* rowObject = allRowHeaders[k]->parentObject(); >+ if (static_cast<AccessibilityTableRow*>(rowObject)->rowIndex() == row) >+ return allRowHeaders[k]->wrapper(); >+ } >+ } >+ return NULL; >+} >+ >+static void atk_table_interface_init(AtkTableIface* iface) >+{ >+ iface->ref_at = webkit_accessible_table_ref_at; >+ iface->get_index_at = webkit_accessible_table_get_index_at; >+ iface->get_n_columns = webkit_accessible_table_get_n_columns; >+ iface->get_n_rows = webkit_accessible_table_get_n_rows; >+ iface->get_column_extent_at = webkit_accessible_table_get_column_extent_at; >+ iface->get_row_extent_at = webkit_accessible_table_get_row_extent_at; >+ iface->get_column_header = webkit_accessible_table_get_column_header; >+ iface->get_row_header = webkit_accessible_table_get_row_header; >+} >+ > static const GInterfaceInfo AtkInterfacesInitFunctions[] = { > {(GInterfaceInitFunc)atk_action_interface_init, > (GInterfaceFinalizeFunc) NULL, NULL}, >@@ -991,6 +1124,8 @@ static const GInterfaceInfo AtkInterfacesInitFunctions[] = { > {(GInterfaceInitFunc)atk_component_interface_init, > (GInterfaceFinalizeFunc) NULL, NULL}, > {(GInterfaceInitFunc)atk_image_interface_init, >+ (GInterfaceFinalizeFunc) NULL, NULL}, >+ {(GInterfaceInitFunc)atk_table_interface_init, > (GInterfaceFinalizeFunc) NULL, NULL} > }; > >@@ -999,7 +1134,8 @@ enum WAIType { > WAI_EDITABLE_TEXT, > WAI_TEXT, > WAI_COMPONENT, >- WAI_IMAGE >+ WAI_IMAGE, >+ WAI_TABLE > }; > > static GType GetAtkInterfaceTypeFromWAIType(WAIType type) >@@ -1015,6 +1151,8 @@ static GType GetAtkInterfaceTypeFromWAIType(WAIType type) > return ATK_TYPE_COMPONENT; > case WAI_IMAGE: > return ATK_TYPE_IMAGE; >+ case WAI_TABLE: >+ return ATK_TYPE_TABLE; > } > > return G_TYPE_INVALID; >@@ -1048,6 +1186,10 @@ static guint16 getInterfaceMaskFromObject(AccessibilityObject* coreObject) > if (coreObject->isImage()) > interfaceMask |= 1 << WAI_IMAGE; > >+ // Table >+ if (role == TableRole) >+ interfaceMask |= 1 << WAI_TABLE; >+ > return interfaceMask; > } > >-- >1.6.3.3 > Looks great to me but for those small comments, let's fix them and commit it. 156824 5 41642 jdiggs 2009-10-22 00:21:56 -0700 Created attachment 41642 Part 1 - Take 2 (In reply to comment #4) > So how does that work exactly? Does it simply put row after row, the index > being n_columns*row + column or something like that? Something very much like that. But we also have to keep cell spans in mind. What we get from a traditional Gtk+ table which does not manage its descendants is a table whose children are table cells, no intervening row or column accessibles, indexed from 0 to childCount - 1. > The way you are doing it > in the patch you are simply relying on cells to be ordered the way you want, so > I guess it wouldn't hurt to be a bit more explicit. I added a bit more detail to the original comment. Please let me know if further detail would be beneficial. Any concerns over the underlying order changing in the vector down the road? > if allCells is a normal C++ vector I think you can use std::find to get the > index of the element intsead of looking for it manually. It will return an > iterator, so to get the index value you just have to substract from it the > first iterator in the vector (so... something like pos = find(allCells.begin(), > allCells.end(), AXCell) - allCells.begin();) Cool. Being new to C++, I love these sorts of tips. Thanks!! > Now that I just wrote this I wonder if it actually matters or if the code is > more readable that way... feel free to ignore it :) Too late. I went with the change. :-) > >+ return -1; > > Don't think returning '-1' for error will work having a 'guint' return value :) Merely a test to see if you were paying attention. Yeah... A test... Because... I obviously was not. Thanks for catching this. Sorry it needed catching. Fixed. > >+ > >+static gint webkit_accessible_table_get_column_extent_at(AtkTable* table, gint row, gint column) > >+{ > >+ AccessibilityTableCell* AXCell = getCell(table, row, column); > >+ if (AXCell) { > >+ pair<int, int> columnRange; > >+ AXCell->columnIndexRange(columnRange); > >+ return columnRange.second; > > Just a sanity check: what comes in that pair, the indexes of the columns the > cell occupies? Nope. It's the index of the column and then the column span: void AccessibilityTableCell::columnIndexRange(pair<int, int>& columnRange) { if (!m_renderer || !m_renderer->isTableCell()) return; RenderTableCell* renderCell = toRenderTableCell(m_renderer); columnRange.first = renderCell->col(); columnRange.second = renderCell->colSpan(); } > If the function returns the extent shouldn't you return second - > first? The extent is indeed the span. Verified with testing with a variety of tables. > I'm sure you'll figure it out in a follow-up patch ;) Me too, as there really isn't a choice. :-) I've not quite figured it out yet, however. If you'd like, I can just rip that function out until I get to the bottom of it. In addition to the above, this patch: 1. Renames a couple of private methods (fooBar instead of getFooBar) to be in keeping with the style guide. 2. Implements: webkit_accessible_table_get_caption webkit_accessible_table_get_column_at_index webkit_accessible_table_get_row_at_index along with a new helper method, cellAtIndex. 3. Includes a "stub" for webkit_accessible_table_get_summary. (I thought it was going to be pretty much like caption; I was wrong. If I shouldn't include such stubs, let me know.) 157411 6 jdiggs 2009-10-23 19:58:08 -0700 I'm working on the totally-bogus-table-hierarchy issue now. The winner -- at least in part -- seems to be the presence of a table border. I kid thee not. :-) === Debugging/Test Conditions === Locate every last instance where accessibilityIsIgnored() could possibly return false and ensure that it returns true. === Expected Results Under These Conditions === Because accessibility is being ignored for ALL things, I would expect to find an accessible of ROLE_DOCUMENT_FRAME with no text and no children. === Table Which Works As Expected === <html> <head> <title>Tables Test</title> </head> <body> <table> <tr><td>One</td></tr> <tr><td>Two</td></tr> </table> </body> </html> ~~~~~ layer at (0,0) size 800x600 RenderView at (0,0) size 800x600 layer at (0,0) size 800x600 RenderBlock {HTML} at (0,0) size 800x600 RenderBody {BODY} at (8,8) size 784x584 RenderTable {TABLE} at (0,0) size 36x50 RenderTableSection {TBODY} at (0,0) size 36x50 RenderTableRow {TR} at (0,2) size 36x22 RenderTableCell {TD} at (2,2) size 32x22 [r=0 c=0 rs=1 cs=1] RenderText {#text} at (1,1) size 27x20 text run at (1,1) width 27: "One" RenderTableRow {TR} at (0,26) size 36x22 RenderTableCell {TD} at (2,26) size 32x22 [r=1 c=0 rs=1 cs=1] RenderText {#text} at (1,1) size 30x20 text run at (1,1) width 30: "Two" #EOF === Table Which Does NOT Work As Expected === <html> <head> <title>Tables Test</title> </head> <body> <table border="1"> <tr><td>One</td></tr> <tr><td>Two</td></tr> </table> </body> </html> ~~~~~ layer at (0,0) size 800x600 RenderView at (0,0) size 800x600 layer at (0,0) size 800x600 RenderBlock {HTML} at (0,0) size 800x600 RenderBody {BODY} at (8,8) size 784x584 RenderTable {TABLE} at (0,0) size 40x56 [border: (1px outset #808080)] RenderTableSection {TBODY} at (1,1) size 38x54 RenderTableRow {TR} at (0,2) size 38x24 RenderTableCell {TD} at (2,2) size 34x24 [border: (1px inset #808080)] [r=0 c=0 rs=1 cs=1] RenderText {#text} at (2,2) size 27x20 text run at (2,2) width 27: "One" RenderTableRow {TR} at (0,28) size 38x24 RenderTableCell {TD} at (2,28) size 34x24 [border: (1px inset #808080)] [r=1 c=0 rs=1 cs=1] RenderText {#text} at (2,2) size 30x20 text run at (2,2) width 30: "Two" #EOF === Hierarchy In Accerciser === --> document frame --> list item - seems to be cell with "one" --> list item - seems to be cell with "two" --> unknown -> table cell - "one" -> table cell - "two" --> unknown - (no clue what this corresponds to....) Now to figure out what is doing the bogus rendering.... 157925 7 41898 jdiggs 2009-10-26 14:27:21 -0700 Created attachment 41898 table 1 (breaking these apart for easier review) It's rough being the new kid. ;-) Okay. This is based on the original patch reviewed by Xan. Changes: 1. Makes the suggested (and then withdrawn) change to use std:find. 2. Correct the guint/gint error 3. Acknowledges, but makes no changes in response to, this comment: > Just a sanity check: what comes in that pair, the indexes of the columns the > cell occupies? Nope. It's the index of the column and then the column span: void AccessibilityTableCell::columnIndexRange(pair<int, int>& columnRange) { if (!m_renderer || !m_renderer->isTableCell()) return; RenderTableCell* renderCell = toRenderTableCell(m_renderer); columnRange.first = renderCell->col(); columnRange.second = renderCell->colSpan(); } > If the function returns the extent shouldn't you return second - > first? I need the colSpan, columnRange.second contains the colSpan. Testing with tables with multiple spans would also seem to indicate that what I have done is sound. 4. Removes webkit_accessible_table_get_column_header. Xan suggests I'll figure it out in a follow-up patch. Agreed. Might as well just introduce it into the code then. Please review. Thanks! 158002 8 41913 jdiggs 2009-10-26 16:14:23 -0700 Created attachment 41913 table 2 Second part of the implementation of AtkTable. * accessibility/gtk/AccessibilityObjectWrapperAtk.cpp: (cellAtIndex): (webkit_accessible_table_get_column_at_index): (webkit_accessible_table_get_row_at_index): (webkit_accessible_table_get_caption): (atk_table_interface_init): 158024 9 jdiggs 2009-10-26 17:10:55 -0700 I took a look at what remains to be done in terms of implementing AtkTable. And there's a bunch left. :-( However, in terms of the immediate need to make basic content accessible to users of the GNOME desktop, there's only four left. :-) * atk_table_get_column_description * atk_table_get_row_description * atk_table_get_column_header * atk_table_get_summary Well, that, plus a completely bizarre and possibly broken table hierarchy. For the rest of the AtkTable items, I have opened bug 30799. I've also created a new metabug (bug 30796) so that we can track such things without them distracting us from the must-do-now items from bug 25531. 158055 10 41924 jdiggs 2009-10-26 18:51:24 -0700 Created attachment 41924 table 3 * accessibility/gtk/AccessibilityObjectWrapperAtk.cpp: (nameFromChildren): (webkit_accessible_get_name): New convenience function to construct an object's name using the name(s) of any children it has. (atk_table_interface_init): (webkit_accessible_table_get_column_description): (webkit_accessible_table_get_row_description): Implemented. (webkit_accessible_table_get_column_header): Stub function added so that webkit_accessible_table_get_column_description could be implemented in the meantime. 158152 11 41898 xan.lopez 2009-10-27 05:12:45 -0700 Comment on attachment 41898 table 1 (breaking these apart for easier review) >+static gint cellIndex(AccessibilityTableCell* AXCell, AccessibilityTable* AXTable) >+{ >+ // Calculate the cell's index as if we had a traditional Gtk+ table in >+ // which cells are all direct children of the table, arranged row-first. >+ // No need for that empty comment line. >+ AccessibilityObject::AccessibilityChildrenVector allCells; >+ AXTable->cells(allCells); >+ AccessibilityObject::AccessibilityChildrenVector::iterator position; >+ position = std::find(allCells.begin(), allCells.end(), AXCell); >+ if (position == allCells.end()) >+ return -1; >+ return position - allCells.begin(); >+} >+ >+static AtkObject* webkit_accessible_table_ref_at(AtkTable* table, gint row, gint column) >+{ >+ AccessibilityTableCell* AXCell = cell(table, row, column); >+ if (!AXCell) >+ return NULL; In theory we try to use '0' instead of 'NULL' (per WebKit style guide), but I realize this file is a mess wrt that. >+ return AXCell->wrapper(); >+} >+ I'll land this fixing those small details, thanks! 158154 12 41898 xan.lopez 2009-10-27 05:22:14 -0700 Comment on attachment 41898 table 1 (breaking these apart for easier review) Landed in r50140, clearing flags. Also, there were a few "Trailing whitespace" warnings. Try to be careful with that. You can make git lart at you for that if you do chmod +x .git/hooks/pre-commit in your local repo. 158158 13 41913 xan.lopez 2009-10-27 05:47:49 -0700 Comment on attachment 41913 table 2 >+static AccessibilityTableCell* cellAtIndex(AtkTable* table, gint index) >+{ >+ AccessibilityObject* accTable = core(table); >+ if (accTable->isAccessibilityRenderObject()) { >+ AccessibilityObject::AccessibilityChildrenVector allCells; >+ static_cast<AccessibilityTable*>(accTable)->cells(allCells); >+ if (0 <= index < allCells.size()) { Mmm, I don't think this does what you think. '0 <= index' becomes a boolean (0/1), which is then compared against allCells.size(). So you'd get TRUE in cases like 0 <= 1000 < 10, because 0 <= 1000 -> 1, 1 < 10 -> 1. What you need is simply if (0 <= index && index < allCells.size()). >+ AccessibilityObject* accCell = allCells.at(index).get(); >+ return static_cast<AccessibilityTableCell*>(accCell); >+ } >+ } >+ return NULL; While you are it, s/NULL/0/ Marking r- for now, but looks good to me otherwise. 158159 14 41924 xan.lopez 2009-10-27 05:53:30 -0700 Comment on attachment 41924 table 3 >+static const gchar* nameFromChildren(AccessibilityObject* object) >+{ >+ if (object) { >+ AccessibilityRenderObject::AccessibilityChildrenVector children = object->children(); >+ // Currently, object->stringValue() should be an empty String. This >+ // might not be the case down the road. >+ String name = object->stringValue(); >+ for (unsigned i = 0; i < children.size(); ++i) >+ name += children.at(i).get()->stringValue(); >+ return returnString(name); >+ } >+ >+ return NULL; I think it's better to do a if (!object)\nreturn 0; at the beginning here. >+static AtkObject* webkit_accessible_table_get_column_header(AtkTable* table, gint column) >+{ >+ // FIXME: This needs to be implemented. >+ notImplemented(); >+ return NULL; >+} Same comment about NULL than in the other patches (sorry about that!). r- for now, let's fix those two things. 158230 15 41959 jdiggs 2009-10-27 10:08:37 -0700 Created attachment 41959 table 2 - corrected as per review >+static AccessibilityTableCell* cellAtIndex(AtkTable* table, gint index) > >+{ > >+ AccessibilityObject* accTable = core(table); > >+ if (accTable->isAccessibilityRenderObject()) { > >+ AccessibilityObject::AccessibilityChildrenVector allCells; > >+ static_cast<AccessibilityTable*>(accTable)->cells(allCells); > >+ if (0 <= index < allCells.size()) { > > Mmm, I don't think this does what you think. '0 <= index' becomes a boolean > (0/1), which is then compared against allCells.size(). So you'd get TRUE in > cases like 0 <= 1000 < 10, because 0 <= 1000 -> 1, 1 < 10 -> 1. > > What you need is simply if (0 <= index && index < allCells.size()). D'oh! Pythonism. Fixed. > >+ AccessibilityObject* accCell = allCells.at(index).get(); > >+ return static_cast<AccessibilityTableCell*>(accCell); > >+ } > >+ } > >+ return NULL; > > While you are it, s/NULL/0/ Done. Thanks for the review! 158254 16 41963 jdiggs 2009-10-27 10:36:59 -0700 Created attachment 41963 Table 2 - Adjusted to address compiler warning about comparing signed and unsigned 158263 17 41965 jdiggs 2009-10-27 10:40:50 -0700 Created attachment 41965 table 3 - corrected as per review > I think it's better to do a if (!object)\nreturn 0; at the beginning here. Done. > Same comment about NULL than in the other patches (sorry about that!). Done. No need to apologize. I need to re-read the style guide until it becomes second nature. Thanks for the review! 158452 18 41999 jdiggs 2009-10-27 19:40:30 -0700 Created attachment 41999 Table Summary atk_table_get_summary returns an AtkObject. Summary is an attribute; not an object. Therefore we need some other way to expose this information. Because a table summary describes the table, this patch exposes the summary attribute as the table's accessible description. Please review. Thanks! (Note that this patch does *not* depend on Table 2 or Table 3). 158455 19 41999 jmalonzo 2009-10-27 20:01:01 -0700 Comment on attachment 41999 Table Summary Looks fine. r=me. 158456 20 41999 commit-queue 2009-10-27 20:05:24 -0700 Comment on attachment 41999 Table Summary Rejecting patch 41999 from commit-queue. Failed to run "['WebKitTools/Scripts/run-webkit-tests', '--no-launch-safari', '--quiet', '--exit-after-n-failures=1']" exit_code: 1 Running build-dumprendertree Running tests from /Users/eseidel/Projects/CommitQueue/LayoutTests Testing 11534 test cases. accessibility/table-with-aria-role.html -> failed Exiting early after 1 failures. 49 tests run. 3.15s total testing time 48 test cases (97%) succeeded 1 test case (2%) had incorrect layout 1 test case (2%) had stderr output 158460 21 41963 jmalonzo 2009-10-27 20:12:35 -0700 Comment on attachment 41963 Table 2 - Adjusted to address compiler warning about comparing signed and unsigned > AccessibilityTableCell* AXCell = cell(table, row, column); One minor nit: this should be axCell. > +static gint webkit_accessible_table_get_column_at_index(AtkTable* table, gint index) > +{ > + AccessibilityTableCell* AXCell = cellAtIndex(table, index); Ditto. 158465 22 42001 jdiggs 2009-10-27 21:40:12 -0700 Created attachment 42001 Table Summary - with ARIA check I tried to run the tests (Jan, thanks for your help/pointers!). But they all claim to crash, e.g.: dom/html/level1/core/hc_attrremovechild1.html -> crashed So.... I will add learning about the tests to my list of things to do. In the meantime, given the late hour.... The failed test is an ARIA one. I would think we could do a check for ARIA and not do the new functionality if it is ARIA. That's what this patch does. To "test" I compared what Accerciser reported as the accessible description without my patch with what it reports with it. According to Accerciser, the values are the same. <fingers crossed> If someone wouldn't mind tossing the regression tests at this patch, I would really, really appreciate it. Thanks! 158466 23 41999 jmalonzo 2009-10-27 21:52:28 -0700 Comment on attachment 41999 Table Summary One more time. 158496 24 jdiggs 2009-10-28 02:44:57 -0700 (In reply to comment #23) > (From update of attachment 41999 [details]) > One more time. Just double-checking.... If you literally mean that attachment (41999), the one with the ARIA check (which should stop the tests from failing I hope) is attachment 42001. I obsoleted 41999. 158499 25 42001 jmalonzo 2009-10-28 02:57:12 -0700 Comment on attachment 42001 Table Summary - with ARIA check Still ok. 158606 26 42001 commit-queue 2009-10-28 09:53:49 -0700 Comment on attachment 42001 Table Summary - with ARIA check Clearing flags on attachment: 42001 Committed r50219: <http://trac.webkit.org/changeset/50219> 158607 27 commit-queue 2009-10-28 09:53:54 -0700 All reviewed patches have been landed. Closing bug. 158612 28 jdiggs 2009-10-28 09:56:54 -0700 (In reply to comment #27) > All reviewed patches have been landed. Closing bug. Reopening. :-) 158614 29 jdiggs 2009-10-28 09:57:25 -0700 . 158616 30 eric 2009-10-28 09:58:46 -0700 This is caused directly by bug 28230. However our tools just aren't really designed to work with more than one change per bug. If you'd like to post a patch to fix bug 28230 you'd certainly be welcome to. :) Eventually I'll get around to it. 158833 31 jdiggs 2009-10-28 22:45:55 -0700 (In reply to comment #28) > (In reply to comment #27) > > All reviewed patches have been landed. Closing bug. > > Reopening. :-) (In reply to comment #30) > This is caused directly by bug 28230. However our tools just aren't really > designed to work with more than one change per bug. If you'd like to post a > patch to fix bug 28230 you'd certainly be welcome to. :) Eventually I'll get > around to it. Eric, for the record, I was joking. (And if you thought otherwise, I'm truly sorry.) Because of several bugs which spiraled into uber bugs with a life all their own, we'd gotten into a silly pattern: review, commit queue, bug gets closed, bug gets reopened, rinse and repeat. Your tools are awesome, and I wish we had stuff like that in GNOME. The problem is contributors like me. ;-) But to prove I am redeemable, I have just spun off two bugs from this one: * Bug 30895 to deal with the bogus table hierarchy * Bug 30896 to deal with atk_table_get_column_header So, once the two remaining patches in need of final review and commit have both landed, we will never, ever re-open this bug again. :-) And as for bug 28230, absolutely! Just as soon as all of the Atk a11y problems are resolved. ;-) 158837 32 eric 2009-10-28 22:58:05 -0700 Oh, I certainly too no offense whatsoever! :) I hope my terse response did not lead you to believe such. Just wanted you to be informed as to why the bug got closed, that's all. :) Thanks. 158842 33 42083 jdiggs 2009-10-28 23:09:41 -0700 Created attachment 42083 Table 2 - Address Jan's comments (In reply to comment #21) > (From update of attachment 41963 [details]) > > AccessibilityTableCell* AXCell = cell(table, row, column); > > One minor nit: this should be axCell. Ok. Given that it's in existing code and not added by this patch, I left that particular one alone. Hope that's ok!(?) But I've already promised Xan I'd go through the Atk a11y stuff with a lint brush. My current list is: * Trailing whitespace * NULL * AXFoo should be axFoo Bug 30901 has just been created so y'all can add to the list. :-) > > +static gint webkit_accessible_table_get_column_at_index(AtkTable* table, gint index) > > +{ > > + AccessibilityTableCell* AXCell = cellAtIndex(table, index); > > Ditto. Changed. Thanks! 159313 34 41965 xan.lopez 2009-10-30 08:08:45 -0700 Comment on attachment 41965 table 3 - corrected as per review Looks good to me. 159314 35 42083 xan.lopez 2009-10-30 08:10:11 -0700 Comment on attachment 42083 Table 2 - Address Jan's comments Looks good to me too. 159332 36 41965 commit-queue 2009-10-30 10:07:46 -0700 Comment on attachment 41965 table 3 - corrected as per review Rejecting patch 41965 from commit-queue. Failed to run "['/Users/eseidel/Projects/CommitQueue/WebKitTools/Scripts/svn-apply', '--reviewer', 'Xan Lopez', '--force']" exit_code: 1 Last 500 characters of output: , 9 deletions(-) ------------------------------------------------------------------- patching file WebCore/ChangeLog Hunk #1 succeeded at 5 with fuzz 3. patching file WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp Hunk #1 succeeded at 137 (offset 6 lines). Hunk #2 succeeded at 1297 (offset 113 lines). Hunk #3 succeeded at 1321 (offset 99 lines). Hunk #4 FAILED at 1349. 1 out of 4 hunks FAILED -- saving rejects to file WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp.rej 159333 37 jdiggs 2009-10-30 10:12:24 -0700 (In reply to comment #36) > (From update of attachment 41965 [details]) > Rejecting patch 41965 from commit-queue. > > Failed to run > "['/Users/eseidel/Projects/CommitQueue/WebKitTools/Scripts/svn-apply', > '--reviewer', 'Xan Lopez', '--force']" exit_code: 1 > Last 500 characters of output: > , 9 deletions(-) > > > ------------------------------------------------------------------- > patching file WebCore/ChangeLog > Hunk #1 succeeded at 5 with fuzz 3. > patching file WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp > Hunk #1 succeeded at 137 (offset 6 lines). > Hunk #2 succeeded at 1297 (offset 113 lines). > Hunk #3 succeeded at 1321 (offset 99 lines). > Hunk #4 FAILED at 1349. > 1 out of 4 hunks FAILED -- saving rejects to file > WebCore/accessibility/gtk/AccessibilityObjectWrapperAtk.cpp.rej Table 3 assumed Table 2 (i.e. had these been submitted in the reverse order, I believe the patch would've cleanly applied) 159337 38 eric 2009-10-30 10:18:17 -0700 Ah yes. The commit-queue is not smart enough to know what the implicit order of patches on a bug is. :) It assumes first to last in attachment order... 159339 39 42083 commit-queue 2009-10-30 10:19:48 -0700 Comment on attachment 42083 Table 2 - Address Jan's comments Clearing flags on attachment: 42083 Committed r50339: <http://trac.webkit.org/changeset/50339> 159340 40 commit-queue 2009-10-30 10:19:54 -0700 All reviewed patches have been landed. Closing bug. 159341 41 eric 2009-10-30 10:24:30 -0700 OK. I'll fix bug 28230 today. It's kinda silly to close bugs with r+'d patches on them. We'll start having the opposite problem of people forgetting to close their bugs. But then again, we already have that problem. :) 159343 42 41965 eric 2009-10-30 10:24:58 -0700 Comment on attachment 41965 table 3 - corrected as per review Since this supposedly will apply cleanly now, i'll cq+ it. 159348 43 jdiggs 2009-10-30 10:30:51 -0700 (In reply to comment #42) > (From update of attachment 41965 [details]) > Since this supposedly will apply cleanly now, i'll cq+ it. Thanks Eric! I just pulled the latest from git master and it does indeed apply cleanly. Hopefully it will pass all tests too. :-) 159350 44 41965 commit-queue 2009-10-30 10:35:24 -0700 Comment on attachment 41965 table 3 - corrected as per review Clearing flags on attachment: 41965 Committed r50342: <http://trac.webkit.org/changeset/50342> 159351 45 commit-queue 2009-10-30 10:35:52 -0700 All reviewed patches have been landed. Closing bug. 29971 2009-05-03 20:30:02 -0700 2009-05-03 20:30:02 -0700 aforementioned test case tables.html text/html 379 jdiggs PGh0bWw+CjxoZWFkPgo8dGl0bGU+VGFibGVzIFRlc3Q8L3RpdGxlPgo8L2hlYWQ+Cjxib2R5Pgo8 cD5IZXJlIGlzIGEgc2ltcGxlIHRhYmxlOjwvcD4KPHRhYmxlIHdpZHRoPSIxMDAlIiBib3JkZXI9 IjEiPgo8Y2FwdGlvbj5UYWJsZSBDYXB0aW9uPC9jYXB0aW9uPgo8dHI+PHRoPjwvdGg+PHRoPkNv bC4gSGVhZGVyIDE8L3RoPjx0aD5Db2wuIEhlYWRlciAyPC90aD48L3RyPgo8dHI+PHRoPlJvdyBI ZWFkZXIgMTwvdGg+PHRkPk9uZTwvdGQ+PHRkPlR3bzwvdGQ+PC90cj4KPHRyPjx0aD5Sb3cgSGVh ZGVyIDI8L3RoPjx0ZD5UaHJlZTwvdGQ+PHRkPkZvdXI8L3RkPjwvdHI+CjwvdGFibGU+CjxwPkhl cmUgaXMgbW9yZSB0ZXh0LjwvcD4KPC9ib2R5Pgo8L2h0bWw+Cg== 41481 2009-10-19 23:08:06 -0700 2009-10-22 00:21:56 -0700 Part 1 25534-part1.patch text/plain 9426 jdiggs RnJvbSBmODAzNDM2ZjVhODIwMzFkN2NkYTAzZWQ5MTFmYjNlNzZhYTk0NzZkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IE1vbiwgMTkgT2N0IDIwMDkgMTg6Mzg6NTcgLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNAoKW0dUS10gT2JqZWN0cyBvZiBST0xFX1RBQkxFIHNob3Vs ZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlCgpGaXJzdCBwYXJ0IG9m IHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4KCiogYWNjZXNzaWJpbGl0eS9ndGsvQWNj ZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwOgooZ2V0Q2VsbCk6CihnZXRDZWxsSW5kZXgp Ogood2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9pbmRleF9hdCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9jb2x1bW5z KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX3Jvd3MpOgood2Via2l0X2FjY2Vzc2li bGVfdGFibGVfZ2V0X2NvbHVtbl9leHRlbnRfYXQpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X3Jvd19leHRlbnRfYXQpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9o ZWFkZXIpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19oZWFkZXIpOgooYXRrX3Rh YmxlX2ludGVyZmFjZV9pbml0KToKKEF0a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zKToKKEdldEF0 a0ludGVyZmFjZVR5cGVGcm9tV0FJVHlwZSk6Ci0tLQogV2ViQ29yZS9DaGFuZ2VMb2cgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDI0ICsrKysKIC4uLi9ndGsvQWNjZXNzaWJp bGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwICAgICAgICAgIHwgIDE0NCArKysrKysrKysrKysrKysr KysrLQogMiBmaWxlcyBjaGFuZ2VkLCAxNjcgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9XZWJDb3JlL0NoYW5nZUxvZyBiL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4 IDdlNjJjNjkuLmY5YjkxMDkgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1dl YkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjcgQEAKKzIwMDktMTAtMTkgIEpvYW5tYXJpZSBE aWdncyAgPGpvYW5tYXJpZS5kaWdnc0BnbWFpbC5jb20+CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTI1NTM0CisgICAgICAgIFtHVEtdIE9iamVjdHMgb2YgUk9MRV9UQUJMRSBzaG91 bGQgaW1wbGVtZW50IHRoZSBhY2Nlc3NpYmxlIHRhYmxlIGludGVyZmFjZSAKKworICAgICAgICBG aXJzdCBwYXJ0IG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4gICAKKworICAgICAg ICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcDoK KyAgICAgICAgKGdldENlbGwpOgorICAgICAgICAoZ2V0Q2VsbEluZGV4KToKKyAgICAgICAgKHdl YmtpdF9hY2Nlc3NpYmxlX3RhYmxlX3JlZl9hdCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfaW5kZXhfYXQpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X25fY29sdW1ucyk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9y b3dzKToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5fZXh0ZW50 X2F0KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0 KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5faGVhZGVyKToK KyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyKToKKyAgICAg ICAgKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6CisgICAgICAgIChBdGtJbnRlcmZhY2VzSW5p dEZ1bmN0aW9ucyk6CisgICAgICAgIChHZXRBdGtJbnRlcmZhY2VUeXBlRnJvbVdBSVR5cGUpOgor CiAyMDA5LTEwLTE5ICBOYXRlIENoYXBpbiAgPGphcGhldEBjaHJvbWl1bS5vcmc+CiAKICAgICAg ICAgUmV2aWV3ZWQgYnkgQWRhbSBCYXJ0aC4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwIGIvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKaW5kZXggYzMz ZTM3NS4uNTkyZTgwOCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nl c3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKQEAgLTM2LDYgKzM2LDEwIEBA CiAjaW5jbHVkZSAiQVhPYmplY3RDYWNoZS5oIgogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlMaXN0 Qm94LmgiCiAjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdC5oIgorI2luY2x1ZGUg IkFjY2Vzc2liaWxpdHlUYWJsZS5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlUYWJsZUNlbGwu aCIKKyNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5VGFibGVDb2x1bW4uaCIKKyNpbmNsdWRlICJBY2Nl c3NpYmlsaXR5VGFibGVSb3cuaCIKICNpbmNsdWRlICJBdG9taWNTdHJpbmcuaCIKICNpbmNsdWRl ICJDU3RyaW5nLmgiCiAjaW5jbHVkZSAiRG9jdW1lbnQuaCIKQEAgLTEyMCw2ICsxMjQsMTEgQEAg c3RhdGljIEFjY2Vzc2liaWxpdHlPYmplY3QqIGNvcmUoQXRrSW1hZ2UqIGltYWdlKQogICAgIHJl dHVybiBjb3JlKEFUS19PQkpFQ1QoaW1hZ2UpKTsKIH0KIAorc3RhdGljIEFjY2Vzc2liaWxpdHlP YmplY3QqIGNvcmUoQXRrVGFibGUqIHRhYmxlKQoreworICAgIHJldHVybiBjb3JlKEFUS19PQkpF Q1QodGFibGUpKTsKK30KKwogc3RhdGljIGNvbnN0IGdjaGFyKiB3ZWJraXRfYWNjZXNzaWJsZV9n ZXRfbmFtZShBdGtPYmplY3QqIG9iamVjdCkKIHsKICAgICByZXR1cm4gcmV0dXJuU3RyaW5nKGNv cmUob2JqZWN0KS0+c3RyaW5nVmFsdWUoKSk7CkBAIC05ODEsNiArOTkwLDEzMCBAQCBzdGF0aWMg dm9pZCBhdGtfaW1hZ2VfaW50ZXJmYWNlX2luaXQoQXRrSW1hZ2VJZmFjZSogaWZhY2UpCiAgICAg aWZhY2UtPmdldF9pbWFnZV9zaXplID0gd2Via2l0X2FjY2Vzc2libGVfaW1hZ2VfZ2V0X2ltYWdl X3NpemU7CiB9CiAKKy8vIFRhYmxlCisKK3N0YXRpYyBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBn ZXRDZWxsKEF0a1RhYmxlKiB0YWJsZSwgZ3VpbnQgcm93LCBndWludCBjb2x1bW4pCit7CisgICAg QWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKKyAgICBpZiAoYWNj VGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSAKKyAgICAgICAgcmV0dXJuIHN0 YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+Y2VsbEZvckNvbHVtbkFu ZFJvdyhjb2x1bW4sIHJvdyk7CisgICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBndWludCBn ZXRDZWxsSW5kZXgoQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsLCBBY2Nlc3NpYmlsaXR5 VGFibGUqIEFYVGFibGUpCit7CisgICAgLy8gQ2FsY3VsYXRlIHRoZSBjZWxsJ3MgaW5kZXggYXMg aWYgd2UgaGFkIHRyYWRpdGlvbmFsIEd0aysgdGFibGVzLgorICAgIEFjY2Vzc2liaWxpdHlPYmpl Y3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxDZWxsczsKKyAgICBBWFRhYmxlLT5j ZWxscyhhbGxDZWxscyk7CisgICAgdW5zaWduZWQgY2VsbENvdW50ID0gYWxsQ2VsbHMuc2l6ZSgp OworICAgIGZvciAodW5zaWduZWQgayA9IDA7IGsgPCBjZWxsQ291bnQ7ICsraykKKyAgICAgICAg aWYgKGFsbENlbGxzW2tdID09IEFYQ2VsbCkKKyAgICAgICAgICAgIHJldHVybiBrOworICAgIHJl dHVybiAtMTsKK30KKworc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVf cmVmX2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3csIGdpbnQgY29sdW1uKQoreworICAgIEFj Y2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9IGdldENlbGwodGFibGUsIHJvdywgY29sdW1u KTsKKyAgICBpZiAoIUFYQ2VsbCkKKyAgICAgICAgcmV0dXJuIE5VTEw7CisgICAgcmV0dXJuIEFY Q2VsbC0+d3JhcHBlcigpOworfQorCitzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9nZXRfaW5kZXhfYXQoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdywgZ2ludCBjb2x1bW4pCit7 CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsID0gZ2V0Q2VsbCh0YWJsZSwgcm93 LCBjb2x1bW4pOworICAgIEFjY2Vzc2liaWxpdHlUYWJsZSogQVhUYWJsZSA9IHN0YXRpY19jYXN0 PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGNvcmUodGFibGUpKTsKKyAgICByZXR1cm4gZ2V0Q2VsbElu ZGV4KEFYQ2VsbCwgQVhUYWJsZSk7Cit9CisKK3N0YXRpYyBnaW50IHdlYmtpdF9hY2Nlc3NpYmxl X3RhYmxlX2dldF9uX2NvbHVtbnMoQXRrVGFibGUqIHRhYmxlKQoreworICAgIEFjY2Vzc2liaWxp dHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CisgICAgaWYgKGFjY1RhYmxlLT5pc0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFj Y2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+Y29sdW1uQ291bnQoKTsKKyAgICByZXR1cm4g MDsKK30KKworc3RhdGljIGdpbnQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X25fcm93cyhB dGtUYWJsZSogdGFibGUpCit7CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBj b3JlKHRhYmxlKTsKKyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dCgpKQorICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0eVRhYmxlKj4oYWNj VGFibGUpLT5yb3dDb3VudCgpOworICAgIHJldHVybiAwOworfQorCitzdGF0aWMgZ2ludCB3ZWJr aXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2V4dGVudF9hdChBdGtUYWJsZSogdGFibGUs IGdpbnQgcm93LCBnaW50IGNvbHVtbikKK3sKKyAgICBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBB WENlbGwgPSBnZXRDZWxsKHRhYmxlLCByb3csIGNvbHVtbik7CisgICAgaWYgKEFYQ2VsbCkgewor ICAgICAgICBwYWlyPGludCwgaW50PiBjb2x1bW5SYW5nZTsKKyAgICAgICAgQVhDZWxsLT5jb2x1 bW5JbmRleFJhbmdlKGNvbHVtblJhbmdlKTsKKyAgICAgICAgcmV0dXJuIGNvbHVtblJhbmdlLnNl Y29uZDsKKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBnaW50IHdlYmtpdF9hY2Nl c3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3cs IGdpbnQgY29sdW1uKQoreworICAgIEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9IGdl dENlbGwodGFibGUsIHJvdywgY29sdW1uKTsKKyAgICBpZiAoQVhDZWxsKSB7CisgICAgICAgIHBh aXI8aW50LCBpbnQ+IHJvd1JhbmdlOworICAgICAgICBBWENlbGwtPnJvd0luZGV4UmFuZ2Uocm93 UmFuZ2UpOworICAgICAgICByZXR1cm4gcm93UmFuZ2Uuc2Vjb25kOworICAgIH0KKyAgICByZXR1 cm4gMDsKK30KKworc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0 X2NvbHVtbl9oZWFkZXIoQXRrVGFibGUqIHRhYmxlLCBnaW50IGNvbHVtbikKK3sKKyAgICAvLyBT b21ldGhpbmcgaXMgbm90IHF1aXRlIHJpZ2h0IGhlcmUuIDotKCBXZSBnZXQgaGVhZGVycyBidXQg bm90IHRoZSBjaGlsZAorICAgIC8vIHRleHQgd2hpY2ggaG9sZHMgdGhlIGhlYWRlciBjb250ZW50 LiBBbHNvIG5vdGUgdGhhdCB0aGUgbmVhcmx5IGlkZW50aWNhbAorICAgIC8vIGdldF9yb3dfaGVh ZGVyIHdvcmtzIGFzIGV4cGVjdGVkLiBNaWdodCBiZSByZWxhdGVkIHRvIHRoZSBmdW5reSBoaWVy YXJjaHkuCisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsK KyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAg ICAgIEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxD b2x1bW5IZWFkZXJzOworICAgICAgICBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGUqPihh Y2NUYWJsZSktPmNvbHVtbkhlYWRlcnMoYWxsQ29sdW1uSGVhZGVycyk7CisKKyAgICAgICAgdW5z aWduZWQgY29sQ291bnQgPSBhbGxDb2x1bW5IZWFkZXJzLnNpemUoKTsKKyAgICAgICAgZm9yICh1 bnNpZ25lZCBrID0gMDsgayA8IGNvbENvdW50OyArK2spIHsKKyAgICAgICAgICAgIEFjY2Vzc2li aWxpdHlPYmplY3QqIGNvbHVtbk9iamVjdCA9IGFsbENvbHVtbkhlYWRlcnNba10tPnBhcmVudE9i amVjdCgpOworICAgICAgICAgICAgaWYgKHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZUNv bHVtbio+KGNvbHVtbk9iamVjdCktPmNvbHVtbkluZGV4KCkgPT0gY29sdW1uKQorICAgICAgICAg ICAgICAgIHJldHVybiBhbGxDb2x1bW5IZWFkZXJzW2tdLT53cmFwcGVyKCk7CisgICAgICAgIH0K KyAgICB9CisgICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9h Y2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3cp Cit7CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKKyAg ICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAgICAg IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxSb3dI ZWFkZXJzOworICAgICAgICBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGUqPihhY2NUYWJs ZSktPnJvd0hlYWRlcnMoYWxsUm93SGVhZGVycyk7CisKKyAgICAgICAgdW5zaWduZWQgcm93Q291 bnQgPSBhbGxSb3dIZWFkZXJzLnNpemUoKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBrID0gMDsg ayA8IHJvd0NvdW50OyArK2spIHsKKyAgICAgICAgICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIHJv d09iamVjdCA9IGFsbFJvd0hlYWRlcnNba10tPnBhcmVudE9iamVjdCgpOworICAgICAgICAgICAg aWYgKHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZVJvdyo+KHJvd09iamVjdCktPnJvd0lu ZGV4KCkgPT0gcm93KQorICAgICAgICAgICAgICAgIHJldHVybiBhbGxSb3dIZWFkZXJzW2tdLT53 cmFwcGVyKCk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRp YyB2b2lkIGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdChBdGtUYWJsZUlmYWNlKiBpZmFjZSkKK3sK KyAgICBpZmFjZS0+cmVmX2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0OworICAg IGlmYWNlLT5nZXRfaW5kZXhfYXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfaW5kZXhf YXQ7CisgICAgaWZhY2UtPmdldF9uX2NvbHVtbnMgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9n ZXRfbl9jb2x1bW5zOworICAgIGlmYWNlLT5nZXRfbl9yb3dzID0gd2Via2l0X2FjY2Vzc2libGVf dGFibGVfZ2V0X25fcm93czsKKyAgICBpZmFjZS0+Z2V0X2NvbHVtbl9leHRlbnRfYXQgPSB3ZWJr aXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2V4dGVudF9hdDsKKyAgICBpZmFjZS0+Z2V0 X3Jvd19leHRlbnRfYXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfcm93X2V4dGVudF9h dDsKKyAgICBpZmFjZS0+Z2V0X2NvbHVtbl9oZWFkZXIgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9nZXRfY29sdW1uX2hlYWRlcjsKKyAgICBpZmFjZS0+Z2V0X3Jvd19oZWFkZXIgPSB3ZWJraXRf YWNjZXNzaWJsZV90YWJsZV9nZXRfcm93X2hlYWRlcjsKK30KKwogc3RhdGljIGNvbnN0IEdJbnRl cmZhY2VJbmZvIEF0a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zW10gPSB7CiAgICAgeyhHSW50ZXJm YWNlSW5pdEZ1bmMpYXRrX2FjdGlvbl9pbnRlcmZhY2VfaW5pdCwKICAgICAgKEdJbnRlcmZhY2VG aW5hbGl6ZUZ1bmMpIE5VTEwsIE5VTEx9LApAQCAtOTkxLDYgKzExMjQsOCBAQCBzdGF0aWMgY29u c3QgR0ludGVyZmFjZUluZm8gQXRrSW50ZXJmYWNlc0luaXRGdW5jdGlvbnNbXSA9IHsKICAgICB7 KEdJbnRlcmZhY2VJbml0RnVuYylhdGtfY29tcG9uZW50X2ludGVyZmFjZV9pbml0LAogICAgICAo R0ludGVyZmFjZUZpbmFsaXplRnVuYykgTlVMTCwgTlVMTH0sCiAgICAgeyhHSW50ZXJmYWNlSW5p dEZ1bmMpYXRrX2ltYWdlX2ludGVyZmFjZV9pbml0LAorICAgICAoR0ludGVyZmFjZUZpbmFsaXpl RnVuYykgTlVMTCwgTlVMTH0sCisgICAgeyhHSW50ZXJmYWNlSW5pdEZ1bmMpYXRrX3RhYmxlX2lu dGVyZmFjZV9pbml0LAogICAgICAoR0ludGVyZmFjZUZpbmFsaXplRnVuYykgTlVMTCwgTlVMTH0K IH07CiAKQEAgLTk5OSw3ICsxMTM0LDggQEAgZW51bSBXQUlUeXBlIHsKICAgICBXQUlfRURJVEFC TEVfVEVYVCwKICAgICBXQUlfVEVYVCwKICAgICBXQUlfQ09NUE9ORU5ULAotICAgIFdBSV9JTUFH RQorICAgIFdBSV9JTUFHRSwKKyAgICBXQUlfVEFCTEUKIH07CiAKIHN0YXRpYyBHVHlwZSBHZXRB dGtJbnRlcmZhY2VUeXBlRnJvbVdBSVR5cGUoV0FJVHlwZSB0eXBlKQpAQCAtMTAxNSw2ICsxMTUx LDggQEAgc3RhdGljIEdUeXBlIEdldEF0a0ludGVyZmFjZVR5cGVGcm9tV0FJVHlwZShXQUlUeXBl IHR5cGUpCiAgICAgICByZXR1cm4gQVRLX1RZUEVfQ09NUE9ORU5UOwogICBjYXNlIFdBSV9JTUFH RToKICAgICAgIHJldHVybiBBVEtfVFlQRV9JTUFHRTsKKyAgY2FzZSBXQUlfVEFCTEU6CisgICAg ICByZXR1cm4gQVRLX1RZUEVfVEFCTEU7CiAgIH0KIAogICByZXR1cm4gR19UWVBFX0lOVkFMSUQ7 CkBAIC0xMDQ4LDYgKzExODYsMTAgQEAgc3RhdGljIGd1aW50MTYgZ2V0SW50ZXJmYWNlTWFza0Zy b21PYmplY3QoQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCkKICAgICBpZiAoY29yZU9i amVjdC0+aXNJbWFnZSgpKQogICAgICAgICBpbnRlcmZhY2VNYXNrIHw9IDEgPDwgV0FJX0lNQUdF OwogCisgICAgLy8gVGFibGUKKyAgICBpZiAocm9sZSA9PSBUYWJsZVJvbGUpCisgICAgICAgIGlu dGVyZmFjZU1hc2sgfD0gMSA8PCBXQUlfVEFCTEU7CisKICAgICByZXR1cm4gaW50ZXJmYWNlTWFz azsKIH0KIAotLSAKMS42LjMuMwoK 41642 2009-10-22 00:21:56 -0700 2009-10-26 14:27:21 -0700 Part 1 - Take 2 25534-part1-2.patch text/plain 13067 jdiggs RnJvbSBjMDdkMjViYjA5M2QzMzg2OGYyMzYzOTcwOGI4ZThhZDg2ZTFhNDNlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFdlZCwgMjEgT2N0IDIwMDkgMjM6MTY6NTIgLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKCkZpcnN0IHBhcnQgb2Yg dGhlIGltcGxlbWVudGF0aW9uIG9mIEF0a1RhYmxlLgoKKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nl c3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHA6CihjZWxsKToKKGNlbGxJbmRleCk6CihjZWxs QXRJbmRleCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9yZWZfYXQpOgood2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X2luZGV4X2F0KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9j b2x1bW5fYXRfaW5kZXgpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRl eCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9jb2x1bW5zKToKKHdlYmtpdF9hY2Nl c3NpYmxlX3RhYmxlX2dldF9uX3Jvd3MpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2Nv bHVtbl9leHRlbnRfYXQpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19leHRlbnRf YXQpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NhcHRpb24pOgood2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X2NvbHVtbl9oZWFkZXIpOgood2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X3Jvd19oZWFkZXIpOgooYXRrX3RhYmxlX2ludGVyZmFjZV9pbml0KToKKEF0a0ludGVyZmFj ZXNJbml0RnVuY3Rpb25zKToKKEdldEF0a0ludGVyZmFjZVR5cGVGcm9tV0FJVHlwZSk6CihBdGtP YmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9zdW1tYXJ5KTogKHN0dWIpCi0tLQog V2ViQ29yZS9DaGFuZ2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDI5 ICsrKwogLi4uL2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAgICAgICAgICAg fCAgMjIzICsrKysrKysrKysrKysrKysrKystCiAyIGZpbGVzIGNoYW5nZWQsIDI1MSBpbnNlcnRp b25zKCspLCAxIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIv V2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZDhiYjUzNC4uZDljOGYyMiAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAor MjAwOS0xMC0yMSAgSm9hbm1hcmllIERpZ2dzICA8am9hbm1hcmllLmRpZ2dzQGdtYWlsLmNvbT4K KworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKKyAgICAgICAgW0dUS10gT2Jq ZWN0cyBvZiBST0xFX1RBQkxFIHNob3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUg aW50ZXJmYWNlCisKKyAgICAgICAgRmlyc3QgcGFydCBvZiB0aGUgaW1wbGVtZW50YXRpb24gb2Yg QXRrVGFibGUuCisKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2Jq ZWN0V3JhcHBlckF0ay5jcHA6CisgICAgICAgIChjZWxsKToKKyAgICAgICAgKGNlbGxJbmRleCk6 CisgICAgICAgIChjZWxsQXRJbmRleCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9yZWZfYXQpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2luZGV4X2F0 KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5fYXRfaW5kZXgp OgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleCk6Cisg ICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9jb2x1bW5zKToKKyAgICAgICAg KHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX3Jvd3MpOgorICAgICAgICAod2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9leHRlbnRfYXQpOgorICAgICAgICAod2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfZ2V0X3Jvd19leHRlbnRfYXQpOgorICAgICAgICAod2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X2NhcHRpb24pOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFi bGVfZ2V0X2NvbHVtbl9oZWFkZXIpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X3Jvd19oZWFkZXIpOgorICAgICAgICAoYXRrX3RhYmxlX2ludGVyZmFjZV9pbml0KToKKyAg ICAgICAgKEF0a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zKToKKyAgICAgICAgKEdldEF0a0ludGVy ZmFjZVR5cGVGcm9tV0FJVHlwZSk6CisgICAgICAgIChBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3Np YmxlX3RhYmxlX2dldF9zdW1tYXJ5KTogKHN0dWIpCisKIDIwMDktMTAtMjEgIFBhdmVsIEZlbGRt YW4gIDxwZmVsZG1hbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgTm90IHJldmlld2VkOiBjaHJv bWl1bSBidWlsZCBmaXggLSBhZGQgbWlzc2luZyBpbWFnZSB0byBneXBpLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5j cHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVy QXRrLmNwcAppbmRleCA0ZGZiMWM1Li43ZGE4NGM0IDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcAorKysgYi9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcApA QCAtMzYsNiArMzYsMTAgQEAKICNpbmNsdWRlICJBWE9iamVjdENhY2hlLmgiCiAjaW5jbHVkZSAi QWNjZXNzaWJpbGl0eUxpc3RCb3guaCIKICNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5UmVuZGVyT2Jq ZWN0LmgiCisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVRhYmxlLmgiCisjaW5jbHVkZSAiQWNjZXNz aWJpbGl0eVRhYmxlQ2VsbC5oIgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlUYWJsZUNvbHVtbi5o IgorI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlUYWJsZVJvdy5oIgogI2luY2x1ZGUgIkF0b21pY1N0 cmluZy5oIgogI2luY2x1ZGUgIkNTdHJpbmcuaCIKICNpbmNsdWRlICJEb2N1bWVudC5oIgpAQCAt NDQsNiArNDgsOCBAQAogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgogI2luY2x1ZGUgIkhvc3RXaW5k b3cuaCIKICNpbmNsdWRlICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJIVE1MVGFibGVDYXB0aW9u RWxlbWVudC5oIgorI2luY2x1ZGUgIkhUTUxUYWJsZUVsZW1lbnQuaCIKICNpbmNsdWRlICJJbmxp bmVUZXh0Qm94LmgiCiAjaW5jbHVkZSAiSW50UmVjdC5oIgogI2luY2x1ZGUgIk5vdEltcGxlbWVu dGVkLmgiCkBAIC0xMjAsNiArMTI2LDExIEBAIHN0YXRpYyBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBj b3JlKEF0a0ltYWdlKiBpbWFnZSkKICAgICByZXR1cm4gY29yZShBVEtfT0JKRUNUKGltYWdlKSk7 CiB9CiAKK3N0YXRpYyBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBjb3JlKEF0a1RhYmxlKiB0YWJsZSkK K3sKKyAgICByZXR1cm4gY29yZShBVEtfT0JKRUNUKHRhYmxlKSk7Cit9CisKIHN0YXRpYyBjb25z dCBnY2hhciogd2Via2l0X2FjY2Vzc2libGVfZ2V0X25hbWUoQXRrT2JqZWN0KiBvYmplY3QpCiB7 CiAgICAgcmV0dXJuIHJldHVyblN0cmluZyhjb3JlKG9iamVjdCktPnN0cmluZ1ZhbHVlKCkpOwpA QCAtOTg2LDYgKzk5NywyMDcgQEAgc3RhdGljIHZvaWQgYXRrX2ltYWdlX2ludGVyZmFjZV9pbml0 KEF0a0ltYWdlSWZhY2UqIGlmYWNlKQogICAgIGlmYWNlLT5nZXRfaW1hZ2Vfc2l6ZSA9IHdlYmtp dF9hY2Nlc3NpYmxlX2ltYWdlX2dldF9pbWFnZV9zaXplOwogfQogCisvLyBUYWJsZQorCitzdGF0 aWMgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogY2VsbChBdGtUYWJsZSogdGFibGUsIGd1aW50IHJv dywgZ3VpbnQgY29sdW1uKQoreworICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGFjY1RhYmxlID0g Y29yZSh0YWJsZSk7CisgICAgaWYgKGFjY1RhYmxlLT5pc0FjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QoKSkgCisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGUqPihh Y2NUYWJsZSktPmNlbGxGb3JDb2x1bW5BbmRSb3coY29sdW1uLCByb3cpOworICAgIHJldHVybiBO VUxMOworfQorCitzdGF0aWMgZ2ludCBjZWxsSW5kZXgoQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCog QVhDZWxsLCBBY2Nlc3NpYmlsaXR5VGFibGUqIEFYVGFibGUpCit7CisgICAgLy8gQ2FsY3VsYXRl IHRoZSBjZWxsJ3MgaW5kZXggYXMgaWYgd2UgaGFkIGEgdHJhZGl0aW9uYWwgR3RrKyB0YWJsZSBp bgorICAgIC8vIHdoaWNoIGNlbGxzIGFyZSBhbGwgZGlyZWN0IGNoaWxkcmVuIG9mIHRoZSB0YWJs ZSwgYXJyYW5nZWQgcm93LWZpcnN0LgorICAgIC8vCisgICAgQWNjZXNzaWJpbGl0eU9iamVjdDo6 QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIGFsbENlbGxzOworICAgIEFYVGFibGUtPmNlbGxz KGFsbENlbGxzKTsKKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRy ZW5WZWN0b3I6Oml0ZXJhdG9yIHBvc2l0aW9uOworICAgIHBvc2l0aW9uID0gc3RkOjpmaW5kKGFs bENlbGxzLmJlZ2luKCksIGFsbENlbGxzLmVuZCgpLCBBWENlbGwpOworICAgIGlmIChwb3NpdGlv biA9PSBhbGxDZWxscy5lbmQoKSkKKyAgICAgICAgcmV0dXJuIC0xOworICAgIHJldHVybiBwb3Np dGlvbiAtIGFsbENlbGxzLmJlZ2luKCk7Cit9CisKK3N0YXRpYyBBY2Nlc3NpYmlsaXR5VGFibGVD ZWxsKiBjZWxsQXRJbmRleChBdGtUYWJsZSogdGFibGUsIGdpbnQgaW5kZXgpCit7CisgICAgQWNj ZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKKyAgICBpZiAoYWNjVGFi bGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAgICAgIEFjY2Vzc2liaWxp dHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxDZWxsczsKKyAgICAgICAg c3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0eVRhYmxlKj4oYWNjVGFibGUpLT5jZWxscyhhbGxDZWxs cyk7CisgICAgICAgIGlmICgwIDw9IGluZGV4IDwgYWxsQ2VsbHMuc2l6ZSgpKSB7CisgICAgICAg ICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NDZWxsID0gYWxsQ2VsbHMuYXQoaW5kZXgpLmdl dCgpOworICAgICAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZUNl bGwqPihhY2NDZWxsKTsKKyAgICAgICAgfQorICAgIH0KKyAgICByZXR1cm4gTlVMTDsKK30KKwor c3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0KEF0a1RhYmxl KiB0YWJsZSwgZ2ludCByb3csIGdpbnQgY29sdW1uKQoreworICAgIEFjY2Vzc2liaWxpdHlUYWJs ZUNlbGwqIEFYQ2VsbCA9IGNlbGwodGFibGUsIHJvdywgY29sdW1uKTsKKyAgICBpZiAoIUFYQ2Vs bCkKKyAgICAgICAgcmV0dXJuIE5VTEw7CisgICAgcmV0dXJuIEFYQ2VsbC0+d3JhcHBlcigpOwor fQorCitzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfaW5kZXhfYXQoQXRr VGFibGUqIHRhYmxlLCBnaW50IHJvdywgZ2ludCBjb2x1bW4pCit7CisgICAgQWNjZXNzaWJpbGl0 eVRhYmxlQ2VsbCogQVhDZWxsID0gY2VsbCh0YWJsZSwgcm93LCBjb2x1bW4pOworICAgIEFjY2Vz c2liaWxpdHlUYWJsZSogQVhUYWJsZSA9IHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+ KGNvcmUodGFibGUpKTsKKyAgICByZXR1cm4gY2VsbEluZGV4KEFYQ2VsbCwgQVhUYWJsZSk7Cit9 CisKK3N0YXRpYyBnaW50IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5fYXRfaW5k ZXgoQXRrVGFibGUqIHRhYmxlLCBnaW50IGluZGV4KQoreworICAgIEFjY2Vzc2liaWxpdHlUYWJs ZUNlbGwqIEFYQ2VsbCA9IGNlbGxBdEluZGV4KHRhYmxlLCBpbmRleCk7CisgICAgaWYgKEFYQ2Vs bCl7CisgICAgICAgIHBhaXI8aW50LCBpbnQ+IGNvbHVtblJhbmdlOworICAgICAgICBBWENlbGwt PmNvbHVtbkluZGV4UmFuZ2UoY29sdW1uUmFuZ2UpOworICAgICAgICByZXR1cm4gY29sdW1uUmFu Z2UuZmlyc3Q7CisgICAgfQorICAgIHJldHVybiAtMTsKK30KKworc3RhdGljIGdpbnQgd2Via2l0 X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleChBdGtUYWJsZSogdGFibGUsIGdpbnQg aW5kZXgpCit7CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsID0gY2VsbEF0SW5k ZXgodGFibGUsIGluZGV4KTsKKyAgICBpZiAoQVhDZWxsKXsKKyAgICAgICAgcGFpcjxpbnQsIGlu dD4gcm93UmFuZ2U7CisgICAgICAgIEFYQ2VsbC0+cm93SW5kZXhSYW5nZShyb3dSYW5nZSk7Cisg ICAgICAgIHJldHVybiByb3dSYW5nZS5maXJzdDsKKyAgICB9CisgICAgcmV0dXJuIC0xOworfQor CitzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9jb2x1bW5zKEF0a1Rh YmxlKiB0YWJsZSkKK3sKKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NUYWJsZSA9IGNvcmUo dGFibGUpOworICAgIGlmIChhY2NUYWJsZS0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkp CisgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGUqPihhY2NUYWJs ZSktPmNvbHVtbkNvdW50KCk7CisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBnaW50IHdlYmtp dF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX3Jvd3MoQXRrVGFibGUqIHRhYmxlKQoreworICAgIEFj Y2Vzc2liaWxpdHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CisgICAgaWYgKGFjY1Rh YmxlLT5pc0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHN0YXRp Y19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+cm93Q291bnQoKTsKKyAgICBy ZXR1cm4gMDsKK30KKworc3RhdGljIGdpbnQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2Nv bHVtbl9leHRlbnRfYXQoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdywgZ2ludCBjb2x1bW4pCit7 CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsID0gY2VsbCh0YWJsZSwgcm93LCBj b2x1bW4pOworICAgIGlmIChBWENlbGwpIHsKKyAgICAgICAgcGFpcjxpbnQsIGludD4gY29sdW1u UmFuZ2U7CisgICAgICAgIEFYQ2VsbC0+Y29sdW1uSW5kZXhSYW5nZShjb2x1bW5SYW5nZSk7Cisg ICAgICAgIHJldHVybiBjb2x1bW5SYW5nZS5zZWNvbmQ7CisgICAgfQorICAgIHJldHVybiAwOwor fQorCitzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfcm93X2V4dGVudF9h dChBdGtUYWJsZSogdGFibGUsIGdpbnQgcm93LCBnaW50IGNvbHVtbikKK3sKKyAgICBBY2Nlc3Np YmlsaXR5VGFibGVDZWxsKiBBWENlbGwgPSBjZWxsKHRhYmxlLCByb3csIGNvbHVtbik7CisgICAg aWYgKEFYQ2VsbCkgeworICAgICAgICBwYWlyPGludCwgaW50PiByb3dSYW5nZTsKKyAgICAgICAg QVhDZWxsLT5yb3dJbmRleFJhbmdlKHJvd1JhbmdlKTsKKyAgICAgICAgcmV0dXJuIHJvd1Jhbmdl LnNlY29uZDsKKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBBdGtPYmplY3QqIHdl YmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0aW9uKEF0a1RhYmxlKiB0YWJsZSkKK3sKKyAg ICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NUYWJsZSA9IGNvcmUodGFibGUpOworICAgIGlmIChh Y2NUYWJsZS0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkpIHsKKyAgICAgICAgTm9kZSog bm9kZSA9IHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqPihhY2NUYWJsZSkt PnJlbmRlcmVyKCktPm5vZGUoKTsKKyAgICAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFt ZShIVE1MTmFtZXM6OnRhYmxlVGFnKSkgeworICAgICAgICAgICAgSFRNTFRhYmxlQ2FwdGlvbkVs ZW1lbnQqIGNhcHRpb24gPSBzdGF0aWNfY2FzdDxIVE1MVGFibGVFbGVtZW50Kj4obm9kZSktPmNh cHRpb24oKTsKKyAgICAgICAgICAgIGlmIChjYXB0aW9uKQorICAgICAgICAgICAgICAgIHJldHVy biBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpmaXJzdEFjY2Vzc2libGVPYmplY3RGcm9tTm9kZShjYXB0 aW9uLT5yZW5kZXJlcigpLT5ub2RlKCkpLT53cmFwcGVyKCk7CisgICAgICAgIH0KKyAgICB9Cisg ICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBjb25zdCBnY2hhciogd2Via2l0X2FjY2Vzc2li bGVfdGFibGVfZ2V0X2NvbHVtbl9kZXNjcmlwdGlvbihBdGtUYWJsZSogdGFibGUsIGdpbnQgY29s dW1uKQoreworICAgIC8vIEZJWE1FOiBUaGlzIG5lZWRzIHRvIGJlIGltcGxlbWVudGVkLgorICAg IHJldHVybiBOVUxMOworfQorCitzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtpdF9hY2Nlc3NpYmxl X3RhYmxlX2dldF9yb3dfZGVzY3JpcHRpb24oQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdykKK3sK KyAgICAvLyBGSVhNRTogVGhpcyBuZWVkcyB0byBiZSBpbXBsZW1lbnRlZC4KKyAgICByZXR1cm4g TlVMTDsKK30KKworc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0 X2NvbHVtbl9oZWFkZXIoQXRrVGFibGUqIHRhYmxlLCBnaW50IGNvbHVtbikKK3sKKyAgICAvLyBT b21ldGhpbmcgaXMgbm90IHF1aXRlIHJpZ2h0IGhlcmUuIDotKCBXZSBnZXQgaGVhZGVycyBidXQg bm90IHRoZSBjaGlsZAorICAgIC8vIHRleHQgd2hpY2ggaG9sZHMgdGhlIGhlYWRlciBjb250ZW50 LiBBbHNvIG5vdGUgdGhhdCB0aGUgbmVhcmx5IGlkZW50aWNhbAorICAgIC8vIGdldF9yb3dfaGVh ZGVyIHdvcmtzIGFzIGV4cGVjdGVkLiBNaWdodCBiZSByZWxhdGVkIHRvIHRoZSBmdW5reSBoaWVy YXJjaHkuCisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsK KyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAg ICAgIEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxD b2x1bW5IZWFkZXJzOworICAgICAgICBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGUqPihh Y2NUYWJsZSktPmNvbHVtbkhlYWRlcnMoYWxsQ29sdW1uSGVhZGVycyk7CisKKyAgICAgICAgdW5z aWduZWQgY29sQ291bnQgPSBhbGxDb2x1bW5IZWFkZXJzLnNpemUoKTsKKyAgICAgICAgZm9yICh1 bnNpZ25lZCBrID0gMDsgayA8IGNvbENvdW50OyArK2spIHsKKyAgICAgICAgICAgIEFjY2Vzc2li aWxpdHlPYmplY3QqIGNvbHVtbk9iamVjdCA9IGFsbENvbHVtbkhlYWRlcnNba10tPnBhcmVudE9i amVjdCgpOworICAgICAgICAgICAgaWYgKHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZUNv bHVtbio+KGNvbHVtbk9iamVjdCktPmNvbHVtbkluZGV4KCkgPT0gY29sdW1uKQorICAgICAgICAg ICAgICAgIHJldHVybiBhbGxDb2x1bW5IZWFkZXJzW2tdLT53cmFwcGVyKCk7CisgICAgICAgIH0K KyAgICB9CisgICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9h Y2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3cp Cit7CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKKyAg ICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAgICAg IEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxSb3dI ZWFkZXJzOworICAgICAgICBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGUqPihhY2NUYWJs ZSktPnJvd0hlYWRlcnMoYWxsUm93SGVhZGVycyk7CisKKyAgICAgICAgdW5zaWduZWQgcm93Q291 bnQgPSBhbGxSb3dIZWFkZXJzLnNpemUoKTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBrID0gMDsg ayA8IHJvd0NvdW50OyArK2spIHsKKyAgICAgICAgICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIHJv d09iamVjdCA9IGFsbFJvd0hlYWRlcnNba10tPnBhcmVudE9iamVjdCgpOworICAgICAgICAgICAg aWYgKHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZVJvdyo+KHJvd09iamVjdCktPnJvd0lu ZGV4KCkgPT0gcm93KQorICAgICAgICAgICAgICAgIHJldHVybiBhbGxSb3dIZWFkZXJzW2tdLT53 cmFwcGVyKCk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIE5VTEw7Cit9CisKK3N0YXRp YyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9zdW1tYXJ5KEF0a1RhYmxl KiB0YWJsZSkKK3sKKyAgICAvLyBGSVhNRTogVGhpcyBuZWVkcyB0byBiZSBpbXBsZW1lbnRlZC4g TWlnaHQgYmUgYSBjaGFsbGVuZ2UgYXMKKyAgICAvLyBBdGsgdHJlYXRzIHRoZSBzdW1tYXJ5IGFz IGFuIGFjY2Vzc2libGUgb2JqZWN0OyBub3QgYSBzdHJpbmcuCisgICAgcmV0dXJuIDA7Cit9CisK K3N0YXRpYyB2b2lkIGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdChBdGtUYWJsZUlmYWNlKiBpZmFj ZSkKK3sKKyAgICBpZmFjZS0+cmVmX2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0 OworICAgIGlmYWNlLT5nZXRfaW5kZXhfYXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRf aW5kZXhfYXQ7CisgICAgaWZhY2UtPmdldF9jb2x1bW5fYXRfaW5kZXggPSB3ZWJraXRfYWNjZXNz aWJsZV90YWJsZV9nZXRfY29sdW1uX2F0X2luZGV4OworICAgIGlmYWNlLT5nZXRfcm93X2F0X2lu ZGV4ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleDsKKyAgICBpZmFj ZS0+Z2V0X25fY29sdW1ucyA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnM7 CisgICAgaWZhY2UtPmdldF9uX3Jvd3MgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9y b3dzOworICAgIGlmYWNlLT5nZXRfY29sdW1uX2V4dGVudF9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxl X3RhYmxlX2dldF9jb2x1bW5fZXh0ZW50X2F0OworICAgIGlmYWNlLT5nZXRfcm93X2V4dGVudF9h dCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0OworICAgIGlmYWNl LT5nZXRfY2FwdGlvbiA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0aW9uOworICAg IGlmYWNlLT5nZXRfY29sdW1uX2Rlc2NyaXB0aW9uID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X2NvbHVtbl9kZXNjcmlwdGlvbjsKKyAgICBpZmFjZS0+Z2V0X3Jvd19kZXNjcmlwdGlvbiA9 IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZGVzY3JpcHRpb247CisgICAgaWZhY2Ut PmdldF9jb2x1bW5faGVhZGVyID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9o ZWFkZXI7CisgICAgaWZhY2UtPmdldF9yb3dfaGVhZGVyID0gd2Via2l0X2FjY2Vzc2libGVfdGFi bGVfZ2V0X3Jvd19oZWFkZXI7CisgICAgaWZhY2UtPmdldF9zdW1tYXJ5ID0gd2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X3N1bW1hcnk7Cit9CisKIHN0YXRpYyBjb25zdCBHSW50ZXJmYWNlSW5m byBBdGtJbnRlcmZhY2VzSW5pdEZ1bmN0aW9uc1tdID0gewogICAgIHsoR0ludGVyZmFjZUluaXRG dW5jKWF0a19hY3Rpb25faW50ZXJmYWNlX2luaXQsCiAgICAgIChHSW50ZXJmYWNlRmluYWxpemVG dW5jKSBOVUxMLCBOVUxMfSwKQEAgLTk5Niw2ICsxMjA4LDggQEAgc3RhdGljIGNvbnN0IEdJbnRl cmZhY2VJbmZvIEF0a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zW10gPSB7CiAgICAgeyhHSW50ZXJm YWNlSW5pdEZ1bmMpYXRrX2NvbXBvbmVudF9pbnRlcmZhY2VfaW5pdCwKICAgICAgKEdJbnRlcmZh Y2VGaW5hbGl6ZUZ1bmMpIE5VTEwsIE5VTEx9LAogICAgIHsoR0ludGVyZmFjZUluaXRGdW5jKWF0 a19pbWFnZV9pbnRlcmZhY2VfaW5pdCwKKyAgICAgKEdJbnRlcmZhY2VGaW5hbGl6ZUZ1bmMpIE5V TEwsIE5VTEx9LAorICAgIHsoR0ludGVyZmFjZUluaXRGdW5jKWF0a190YWJsZV9pbnRlcmZhY2Vf aW5pdCwKICAgICAgKEdJbnRlcmZhY2VGaW5hbGl6ZUZ1bmMpIE5VTEwsIE5VTEx9CiB9OwogCkBA IC0xMDA0LDcgKzEyMTgsOCBAQCBlbnVtIFdBSVR5cGUgewogICAgIFdBSV9FRElUQUJMRV9URVhU LAogICAgIFdBSV9URVhULAogICAgIFdBSV9DT01QT05FTlQsCi0gICAgV0FJX0lNQUdFCisgICAg V0FJX0lNQUdFLAorICAgIFdBSV9UQUJMRQogfTsKIAogc3RhdGljIEdUeXBlIEdldEF0a0ludGVy ZmFjZVR5cGVGcm9tV0FJVHlwZShXQUlUeXBlIHR5cGUpCkBAIC0xMDIwLDYgKzEyMzUsOCBAQCBz dGF0aWMgR1R5cGUgR2V0QXRrSW50ZXJmYWNlVHlwZUZyb21XQUlUeXBlKFdBSVR5cGUgdHlwZSkK ICAgICAgIHJldHVybiBBVEtfVFlQRV9DT01QT05FTlQ7CiAgIGNhc2UgV0FJX0lNQUdFOgogICAg ICAgcmV0dXJuIEFUS19UWVBFX0lNQUdFOworICBjYXNlIFdBSV9UQUJMRToKKyAgICAgIHJldHVy biBBVEtfVFlQRV9UQUJMRTsKICAgfQogCiAgIHJldHVybiBHX1RZUEVfSU5WQUxJRDsKQEAgLTEw NTMsNiArMTI3MCwxMCBAQCBzdGF0aWMgZ3VpbnQxNiBnZXRJbnRlcmZhY2VNYXNrRnJvbU9iamVj dChBY2Nlc3NpYmlsaXR5T2JqZWN0KiBjb3JlT2JqZWN0KQogICAgIGlmIChjb3JlT2JqZWN0LT5p c0ltYWdlKCkpCiAgICAgICAgIGludGVyZmFjZU1hc2sgfD0gMSA8PCBXQUlfSU1BR0U7CiAKKyAg ICAvLyBUYWJsZQorICAgIGlmIChyb2xlID09IFRhYmxlUm9sZSkKKyAgICAgICAgaW50ZXJmYWNl TWFzayB8PSAxIDw8IFdBSV9UQUJMRTsKKwogICAgIHJldHVybiBpbnRlcmZhY2VNYXNrOwogfQog Ci0tIAoxLjYuMy4zCgo= 41898 2009-10-26 14:27:21 -0700 2009-10-27 05:22:14 -0700 table 1 (breaking these apart for easier review) table-1 text/plain 8650 jdiggs RnJvbSA0ODBlOGU5MDE4OTNhOWVkNTI0MmM2YTc4MWM4YjcxOWI1ZDMyY2JmIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IE1vbiwgMjYgT2N0IDIwMDkgMTc6MTU6NTUgLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKCkZpcnN0IHBhcnQgb2Yg dGhlIGltcGxlbWVudGF0aW9uIG9mIEF0a1RhYmxlLgoKKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nl c3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHA6CihnZXRDZWxsKToKKGdldENlbGxJbmRleCk6 Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9yZWZfYXQpOgood2Via2l0X2FjY2Vzc2libGVfdGFi bGVfZ2V0X2luZGV4X2F0KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnMp Ogood2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X25fcm93cyk6Cih3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfY29sdW1uX2V4dGVudF9hdCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9n ZXRfcm93X2V4dGVudF9hdCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfcm93X2hlYWRl cik6CihhdGtfdGFibGVfaW50ZXJmYWNlX2luaXQpOgooQXRrSW50ZXJmYWNlc0luaXRGdW5jdGlv bnMpOgooR2V0QXRrSW50ZXJmYWNlVHlwZUZyb21XQUlUeXBlKToKLS0tCiBXZWJDb3JlL0NoYW5n ZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjMgKysrKwogLi4uL2d0 ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAgICAgICAgICAgfCAgMTI3ICsrKysr KysrKysrKysrKysrKystCiAyIGZpbGVzIGNoYW5nZWQsIDE0OSBpbnNlcnRpb25zKCspLCAxIGRl bGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFu Z2VMb2cKaW5kZXggN2Y5MWVkYy4uODMyMzg1ZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNiBAQAorMjAwOS0xMC0yNiAg Sm9hbm1hcmllIERpZ2dzICA8am9hbm1hcmllLmRpZ2dzQGdtYWlsLmNvbT4KKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKKyAgICAgICAgW0dUS10gT2JqZWN0cyBvZiBST0xF X1RBQkxFIHNob3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlIAor CisgICAgICAgIEZpcnN0IHBhcnQgb2YgdGhlIGltcGxlbWVudGF0aW9uIG9mIEF0a1RhYmxlLiAg IAorCisgICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBw ZXJBdGsuY3BwOgorICAgICAgICAoZ2V0Q2VsbCk6CisgICAgICAgIChnZXRDZWxsSW5kZXgpOgor ICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0KToKKyAgICAgICAgKHdlYmtp dF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9pbmRleF9hdCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNz aWJsZV90YWJsZV9nZXRfbl9jb2x1bW5zKToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9uX3Jvd3MpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2Nv bHVtbl9leHRlbnRfYXQpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jv d19leHRlbnRfYXQpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19o ZWFkZXIpOgorICAgICAgICAoYXRrX3RhYmxlX2ludGVyZmFjZV9pbml0KToKKyAgICAgICAgKEF0 a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zKToKKyAgICAgICAgKEdldEF0a0ludGVyZmFjZVR5cGVG cm9tV0FJVHlwZSk6CisKIDIwMDktMTAtMjYgIEJyZW50IEZ1bGdoYW0gIDxiZnVsZ2hhbUB3ZWJr aXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IEFkYW0gUm9iZW4uCmRpZmYgLS1naXQgYS9X ZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNw cCBiL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJB dGsuY3BwCmluZGV4IGUyODI0ZGQuLjY2NGYzZWMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNz aWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCisrKyBiL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCkBA IC0zNiw2ICszNiwxMCBAQAogI2luY2x1ZGUgIkFYT2JqZWN0Q2FjaGUuaCIKICNpbmNsdWRlICJB Y2Nlc3NpYmlsaXR5TGlzdEJveC5oIgogI2luY2x1ZGUgIkFjY2Vzc2liaWxpdHlSZW5kZXJPYmpl Y3QuaCIKKyNpbmNsdWRlICJBY2Nlc3NpYmlsaXR5VGFibGUuaCIKKyNpbmNsdWRlICJBY2Nlc3Np YmlsaXR5VGFibGVDZWxsLmgiCisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVRhYmxlQ29sdW1uLmgi CisjaW5jbHVkZSAiQWNjZXNzaWJpbGl0eVRhYmxlUm93LmgiCiAjaW5jbHVkZSAiQXRvbWljU3Ry aW5nLmgiCiAjaW5jbHVkZSAiQ1N0cmluZy5oIgogI2luY2x1ZGUgIkRvY3VtZW50LmgiCkBAIC00 NCw2ICs0OCw4IEBACiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCiAjaW5jbHVkZSAiSG9zdFdpbmRv dy5oIgogI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIkhUTUxUYWJsZUNhcHRpb25F bGVtZW50LmgiCisjaW5jbHVkZSAiSFRNTFRhYmxlRWxlbWVudC5oIgogI2luY2x1ZGUgIklubGlu ZVRleHRCb3guaCIKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiTm90SW1wbGVtZW50 ZWQuaCIKQEAgLTEyMCw2ICsxMjYsMTEgQEAgc3RhdGljIEFjY2Vzc2liaWxpdHlPYmplY3QqIGNv cmUoQXRrSW1hZ2UqIGltYWdlKQogICAgIHJldHVybiBjb3JlKEFUS19PQkpFQ1QoaW1hZ2UpKTsK IH0KIAorc3RhdGljIEFjY2Vzc2liaWxpdHlPYmplY3QqIGNvcmUoQXRrVGFibGUqIHRhYmxlKQor eworICAgIHJldHVybiBjb3JlKEFUS19PQkpFQ1QodGFibGUpKTsKK30KKwogc3RhdGljIGNvbnN0 IGdjaGFyKiB3ZWJraXRfYWNjZXNzaWJsZV9nZXRfbmFtZShBdGtPYmplY3QqIG9iamVjdCkKIHsK ICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBjb3JlT2JqZWN0ID0gY29yZShvYmplY3QpOwpAQCAt MTA0NSw2ICsxMDU2LDExMSBAQCBzdGF0aWMgdm9pZCBhdGtfaW1hZ2VfaW50ZXJmYWNlX2luaXQo QXRrSW1hZ2VJZmFjZSogaWZhY2UpCiAgICAgaWZhY2UtPmdldF9pbWFnZV9zaXplID0gd2Via2l0 X2FjY2Vzc2libGVfaW1hZ2VfZ2V0X2ltYWdlX3NpemU7CiB9CiAKKy8vIFRhYmxlCisKK3N0YXRp YyBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBjZWxsKEF0a1RhYmxlKiB0YWJsZSwgZ3VpbnQgcm93 LCBndWludCBjb2x1bW4pCit7CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBj b3JlKHRhYmxlKTsKKyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVj dCgpKSAKKyAgICAgICAgcmV0dXJuIHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFj Y1RhYmxlKS0+Y2VsbEZvckNvbHVtbkFuZFJvdyhjb2x1bW4sIHJvdyk7CisgICAgcmV0dXJuIE5V TEw7Cit9CisKK3N0YXRpYyBnaW50IGNlbGxJbmRleChBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBB WENlbGwsIEFjY2Vzc2liaWxpdHlUYWJsZSogQVhUYWJsZSkKK3sKKyAgICAvLyBDYWxjdWxhdGUg dGhlIGNlbGwncyBpbmRleCBhcyBpZiB3ZSBoYWQgYSB0cmFkaXRpb25hbCBHdGsrIHRhYmxlIGlu CisgICAgLy8gd2hpY2ggY2VsbHMgYXJlIGFsbCBkaXJlY3QgY2hpbGRyZW4gb2YgdGhlIHRhYmxl LCBhcnJhbmdlZCByb3ctZmlyc3QuCisgICAgLy8KKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpB Y2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgYWxsQ2VsbHM7CisgICAgQVhUYWJsZS0+Y2VsbHMo YWxsQ2VsbHMpOworICAgIEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGlsZHJl blZlY3Rvcjo6aXRlcmF0b3IgcG9zaXRpb247CisgICAgcG9zaXRpb24gPSBzdGQ6OmZpbmQoYWxs Q2VsbHMuYmVnaW4oKSwgYWxsQ2VsbHMuZW5kKCksIEFYQ2VsbCk7CisgICAgaWYgKHBvc2l0aW9u ID09IGFsbENlbGxzLmVuZCgpKQorICAgICAgICByZXR1cm4gLTE7CisgICAgcmV0dXJuIHBvc2l0 aW9uIC0gYWxsQ2VsbHMuYmVnaW4oKTsKK30KKworc3RhdGljIEF0a09iamVjdCogd2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfcmVmX2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3csIGdpbnQgY29s dW1uKQoreworICAgIEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9IGNlbGwodGFibGUs IHJvdywgY29sdW1uKTsKKyAgICBpZiAoIUFYQ2VsbCkKKyAgICAgICAgcmV0dXJuIE5VTEw7Cisg ICAgcmV0dXJuIEFYQ2VsbC0+d3JhcHBlcigpOworfQorCitzdGF0aWMgZ2ludCB3ZWJraXRfYWNj ZXNzaWJsZV90YWJsZV9nZXRfaW5kZXhfYXQoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdywgZ2lu dCBjb2x1bW4pCit7CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsID0gY2VsbCh0 YWJsZSwgcm93LCBjb2x1bW4pOworICAgIEFjY2Vzc2liaWxpdHlUYWJsZSogQVhUYWJsZSA9IHN0 YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGNvcmUodGFibGUpKTsKKyAgICByZXR1cm4g Y2VsbEluZGV4KEFYQ2VsbCwgQVhUYWJsZSk7Cit9CisKK3N0YXRpYyBnaW50IHdlYmtpdF9hY2Nl c3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnMoQXRrVGFibGUqIHRhYmxlKQoreworICAgIEFjY2Vz c2liaWxpdHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CisgICAgaWYgKGFjY1RhYmxl LT5pc0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkKKyAgICAgICAgcmV0dXJuIHN0YXRpY19j YXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+Y29sdW1uQ291bnQoKTsKKyAgICBy ZXR1cm4gMDsKK30KKworc3RhdGljIGdpbnQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X25f cm93cyhBdGtUYWJsZSogdGFibGUpCit7CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFi bGUgPSBjb3JlKHRhYmxlKTsKKyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRl ck9iamVjdCgpKQorICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0eVRhYmxl Kj4oYWNjVGFibGUpLT5yb3dDb3VudCgpOworICAgIHJldHVybiAwOworfQorCitzdGF0aWMgZ2lu dCB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2V4dGVudF9hdChBdGtUYWJsZSog dGFibGUsIGdpbnQgcm93LCBnaW50IGNvbHVtbikKK3sKKyAgICBBY2Nlc3NpYmlsaXR5VGFibGVD ZWxsKiBBWENlbGwgPSBjZWxsKHRhYmxlLCByb3csIGNvbHVtbik7CisgICAgaWYgKEFYQ2VsbCkg eworICAgICAgICBwYWlyPGludCwgaW50PiBjb2x1bW5SYW5nZTsKKyAgICAgICAgQVhDZWxsLT5j b2x1bW5JbmRleFJhbmdlKGNvbHVtblJhbmdlKTsKKyAgICAgICAgcmV0dXJuIGNvbHVtblJhbmdl LnNlY29uZDsKKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBnaW50IHdlYmtpdF9h Y2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCBy b3csIGdpbnQgY29sdW1uKQoreworICAgIEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9 IGNlbGwodGFibGUsIHJvdywgY29sdW1uKTsKKyAgICBpZiAoQVhDZWxsKSB7CisgICAgICAgIHBh aXI8aW50LCBpbnQ+IHJvd1JhbmdlOworICAgICAgICBBWENlbGwtPnJvd0luZGV4UmFuZ2Uocm93 UmFuZ2UpOworICAgICAgICByZXR1cm4gcm93UmFuZ2Uuc2Vjb25kOworICAgIH0KKyAgICByZXR1 cm4gMDsKK30KKworc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0 X3Jvd19oZWFkZXIoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdykKK3sKKyAgICBBY2Nlc3NpYmls aXR5T2JqZWN0KiBhY2NUYWJsZSA9IGNvcmUodGFibGUpOworICAgIGlmIChhY2NUYWJsZS0+aXNB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0KCkpIHsKKyAgICAgICAgQWNjZXNzaWJpbGl0eU9iamVj dDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIGFsbFJvd0hlYWRlcnM7CisgICAgICAgIHN0 YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+cm93SGVhZGVycyhhbGxS b3dIZWFkZXJzKTsKKworICAgICAgICB1bnNpZ25lZCByb3dDb3VudCA9IGFsbFJvd0hlYWRlcnMu c2l6ZSgpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGsgPSAwOyBrIDwgcm93Q291bnQ7ICsraykg eworICAgICAgICAgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogcm93T2JqZWN0ID0gYWxsUm93SGVh ZGVyc1trXS0+cGFyZW50T2JqZWN0KCk7CisgICAgICAgICAgICBpZiAoc3RhdGljX2Nhc3Q8QWNj ZXNzaWJpbGl0eVRhYmxlUm93Kj4ocm93T2JqZWN0KS0+cm93SW5kZXgoKSA9PSByb3cpCisgICAg ICAgICAgICAgICAgcmV0dXJuIGFsbFJvd0hlYWRlcnNba10tPndyYXBwZXIoKTsKKyAgICAgICAg fQorICAgIH0KKyAgICByZXR1cm4gTlVMTDsKK30KKworc3RhdGljIHZvaWQgYXRrX3RhYmxlX2lu dGVyZmFjZV9pbml0KEF0a1RhYmxlSWZhY2UqIGlmYWNlKQoreworICAgIGlmYWNlLT5yZWZfYXQg PSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9yZWZfYXQ7CisgICAgaWZhY2UtPmdldF9pbmRleF9h dCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9pbmRleF9hdDsKKyAgICBpZmFjZS0+Z2V0 X25fY29sdW1ucyA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnM7CisgICAg aWZhY2UtPmdldF9uX3Jvd3MgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9yb3dzOwor ICAgIGlmYWNlLT5nZXRfY29sdW1uX2V4dGVudF9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9jb2x1bW5fZXh0ZW50X2F0OworICAgIGlmYWNlLT5nZXRfcm93X2V4dGVudF9hdCA9IHdl YmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0OworICAgIGlmYWNlLT5nZXRf cm93X2hlYWRlciA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyOworfQor CiBzdGF0aWMgY29uc3QgR0ludGVyZmFjZUluZm8gQXRrSW50ZXJmYWNlc0luaXRGdW5jdGlvbnNb XSA9IHsKICAgICB7KEdJbnRlcmZhY2VJbml0RnVuYylhdGtfYWN0aW9uX2ludGVyZmFjZV9pbml0 LAogICAgICAoR0ludGVyZmFjZUZpbmFsaXplRnVuYykgTlVMTCwgTlVMTH0sCkBAIC0xMDU1LDYg KzExNzEsOCBAQCBzdGF0aWMgY29uc3QgR0ludGVyZmFjZUluZm8gQXRrSW50ZXJmYWNlc0luaXRG dW5jdGlvbnNbXSA9IHsKICAgICB7KEdJbnRlcmZhY2VJbml0RnVuYylhdGtfY29tcG9uZW50X2lu dGVyZmFjZV9pbml0LAogICAgICAoR0ludGVyZmFjZUZpbmFsaXplRnVuYykgTlVMTCwgTlVMTH0s CiAgICAgeyhHSW50ZXJmYWNlSW5pdEZ1bmMpYXRrX2ltYWdlX2ludGVyZmFjZV9pbml0LAorICAg ICAoR0ludGVyZmFjZUZpbmFsaXplRnVuYykgTlVMTCwgTlVMTH0sCisgICAgeyhHSW50ZXJmYWNl SW5pdEZ1bmMpYXRrX3RhYmxlX2ludGVyZmFjZV9pbml0LAogICAgICAoR0ludGVyZmFjZUZpbmFs aXplRnVuYykgTlVMTCwgTlVMTH0KIH07CiAKQEAgLTEwNjMsNyArMTE4MSw4IEBAIGVudW0gV0FJ VHlwZSB7CiAgICAgV0FJX0VESVRBQkxFX1RFWFQsCiAgICAgV0FJX1RFWFQsCiAgICAgV0FJX0NP TVBPTkVOVCwKLSAgICBXQUlfSU1BR0UKKyAgICBXQUlfSU1BR0UsCisgICAgV0FJX1RBQkxFCiB9 OwogCiBzdGF0aWMgR1R5cGUgR2V0QXRrSW50ZXJmYWNlVHlwZUZyb21XQUlUeXBlKFdBSVR5cGUg dHlwZSkKQEAgLTEwNzksNiArMTE5OCw4IEBAIHN0YXRpYyBHVHlwZSBHZXRBdGtJbnRlcmZhY2VU eXBlRnJvbVdBSVR5cGUoV0FJVHlwZSB0eXBlKQogICAgICAgcmV0dXJuIEFUS19UWVBFX0NPTVBP TkVOVDsKICAgY2FzZSBXQUlfSU1BR0U6CiAgICAgICByZXR1cm4gQVRLX1RZUEVfSU1BR0U7Cisg IGNhc2UgV0FJX1RBQkxFOgorICAgICAgcmV0dXJuIEFUS19UWVBFX1RBQkxFOwogICB9CiAKICAg cmV0dXJuIEdfVFlQRV9JTlZBTElEOwpAQCAtMTExMiw2ICsxMjMzLDEwIEBAIHN0YXRpYyBndWlu dDE2IGdldEludGVyZmFjZU1hc2tGcm9tT2JqZWN0KEFjY2Vzc2liaWxpdHlPYmplY3QqIGNvcmVP YmplY3QpCiAgICAgaWYgKGNvcmVPYmplY3QtPmlzSW1hZ2UoKSkKICAgICAgICAgaW50ZXJmYWNl TWFzayB8PSAxIDw8IFdBSV9JTUFHRTsKIAorICAgIC8vIFRhYmxlCisgICAgaWYgKHJvbGUgPT0g VGFibGVSb2xlKQorICAgICAgICBpbnRlcmZhY2VNYXNrIHw9IDEgPDwgV0FJX1RBQkxFOworCiAg ICAgcmV0dXJuIGludGVyZmFjZU1hc2s7CiB9CiAKLS0gCjEuNi4zLjMKCg== 41913 2009-10-26 16:14:23 -0700 2009-10-27 10:08:37 -0700 table 2 table-2 text/plain 5386 jdiggs RnJvbSA1MTJlZjI4NzA3ZjRlNTBmOTU2YjlmZjA3YjRhYjY2MWJkOGEwMjQwIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IE1vbiwgMjYgT2N0IDIwMDkgMTk6MDI6NTMgLTA0MDAKU3ViamVjdDogW1BB VENIIDIvMl0gUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKW0dUS10gT2JqZWN0cyBvZiBST0xFX1RBQkxFIHNo b3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlCgpTZWNvbmQgcGFy dCBvZiB0aGUgaW1wbGVtZW50YXRpb24gb2YgQXRrVGFibGUuCgoqIGFjY2Vzc2liaWxpdHkvZ3Rr L0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcDoKKGNlbGxBdEluZGV4KToKKHdlYmtp dF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5fYXRfaW5kZXgpOgood2Via2l0X2FjY2Vzc2li bGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRf Y2FwdGlvbik6CihhdGtfdGFibGVfaW50ZXJmYWNlX2luaXQpOgotLS0KIFdlYkNvcmUvQ2hhbmdl TG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxNiArKysrKysKIC4uLi9n dGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwICAgICAgICAgIHwgICA1MyArKysr KysrKysrKysrKysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCA2OSBpbnNlcnRpb25zKCspLCAwIGRl bGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFu Z2VMb2cKaW5kZXggODMyMzg1ZS4uZjk4ODRiOSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VM b2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTMsNiArMywyMiBAQAogICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KIAogICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKKyAgICAgICAgW0dUS10gT2JqZWN0cyBvZiBST0xFX1RB QkxFIHNob3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlCisKKyAg ICAgICAgU2Vjb25kIHBhcnQgb2YgdGhlIGltcGxlbWVudGF0aW9uIG9mIEF0a1RhYmxlLgorCisg ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsu Y3BwOgorICAgICAgICAoY2VsbEF0SW5kZXgpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVf dGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfcm93X2F0X2luZGV4KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9jYXB0aW9uKToKKyAgICAgICAgKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6CisKKzIw MDktMTAtMjYgIEpvYW5tYXJpZSBEaWdncyAgPGpvYW5tYXJpZS5kaWdnc0BnbWFpbC5jb20+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1NTM0CiAgICAgICAgIFtHVEtdIE9iamVj dHMgb2YgUk9MRV9UQUJMRSBzaG91bGQgaW1wbGVtZW50IHRoZSBhY2Nlc3NpYmxlIHRhYmxlIGlu dGVyZmFjZSAKIAogICAgICAgICBGaXJzdCBwYXJ0IG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBB dGtUYWJsZS4gICAKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNz aWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9B Y2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKaW5kZXggNjY0ZjNlYy4uODk2OTBiMCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0 V3JhcHBlckF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmls aXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKQEAgLTEwODAsNiArMTA4MCwyMCBAQCBzdGF0aWMgZ2lu dCBjZWxsSW5kZXgoQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsLCBBY2Nlc3NpYmlsaXR5 VGFibGUqIEFYVGFibAogICAgIHJldHVybiBwb3NpdGlvbiAtIGFsbENlbGxzLmJlZ2luKCk7CiB9 CiAKK3N0YXRpYyBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBjZWxsQXRJbmRleChBdGtUYWJsZSog dGFibGUsIGdpbnQgaW5kZXgpCit7CisgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUg PSBjb3JlKHRhYmxlKTsKKyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdCgpKSB7CisgICAgICAgIEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFjY2Vzc2liaWxpdHlDaGls ZHJlblZlY3RvciBhbGxDZWxsczsKKyAgICAgICAgc3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0eVRh YmxlKj4oYWNjVGFibGUpLT5jZWxscyhhbGxDZWxscyk7CisgICAgICAgIGlmICgwIDw9IGluZGV4 IDwgYWxsQ2VsbHMuc2l6ZSgpKSB7CisgICAgICAgICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBh Y2NDZWxsID0gYWxsQ2VsbHMuYXQoaW5kZXgpLmdldCgpOworICAgICAgICAgICAgcmV0dXJuIHN0 YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqPihhY2NDZWxsKTsKKyAgICAgICAgfQor ICAgIH0KKyAgICByZXR1cm4gTlVMTDsKK30KKwogc3RhdGljIEF0a09iamVjdCogd2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfcmVmX2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3csIGdpbnQgY29s dW1uKQogewogICAgIEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9IGNlbGwodGFibGUs IHJvdywgY29sdW1uKTsKQEAgLTEwOTUsNiArMTEwOSwyOCBAQCBzdGF0aWMgZ2ludCB3ZWJraXRf YWNjZXNzaWJsZV90YWJsZV9nZXRfaW5kZXhfYXQoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdywg Z2ludAogICAgIHJldHVybiBjZWxsSW5kZXgoQVhDZWxsLCBBWFRhYmxlKTsKIH0KIAorc3RhdGlj IGdpbnQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleChBdGtUYWJs ZSogdGFibGUsIGdpbnQgaW5kZXgpCit7CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhD ZWxsID0gY2VsbEF0SW5kZXgodGFibGUsIGluZGV4KTsKKyAgICBpZiAoQVhDZWxsKXsKKyAgICAg ICAgcGFpcjxpbnQsIGludD4gY29sdW1uUmFuZ2U7CisgICAgICAgIEFYQ2VsbC0+Y29sdW1uSW5k ZXhSYW5nZShjb2x1bW5SYW5nZSk7CisgICAgICAgIHJldHVybiBjb2x1bW5SYW5nZS5maXJzdDsK KyAgICB9CisgICAgcmV0dXJuIC0xOworfQorCitzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfcm93X2F0X2luZGV4KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCBpbmRleCkKK3sK KyAgICBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBBWENlbGwgPSBjZWxsQXRJbmRleCh0YWJsZSwg aW5kZXgpOworICAgIGlmIChBWENlbGwpeworICAgICAgICBwYWlyPGludCwgaW50PiByb3dSYW5n ZTsKKyAgICAgICAgQVhDZWxsLT5yb3dJbmRleFJhbmdlKHJvd1JhbmdlKTsKKyAgICAgICAgcmV0 dXJuIHJvd1JhbmdlLmZpcnN0OworICAgIH0KKyAgICByZXR1cm4gLTE7Cit9CisKIHN0YXRpYyBn aW50IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnMoQXRrVGFibGUqIHRhYmxl KQogewogICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CkBA IC0xMTUwLDE1ICsxMTg2LDMyIEBAIHN0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxl X3RhYmxlX2dldF9yb3dfaGVhZGVyKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByCiAgICAgcmV0dXJu IE5VTEw7CiB9CiAKK3N0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dl dF9jYXB0aW9uKEF0a1RhYmxlKiB0YWJsZSkKK3sKKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBh Y2NUYWJsZSA9IGNvcmUodGFibGUpOworICAgIGlmIChhY2NUYWJsZS0+aXNBY2Nlc3NpYmlsaXR5 UmVuZGVyT2JqZWN0KCkpIHsKKyAgICAgICAgTm9kZSogbm9kZSA9IHN0YXRpY19jYXN0PEFjY2Vz c2liaWxpdHlSZW5kZXJPYmplY3QqPihhY2NUYWJsZSktPnJlbmRlcmVyKCktPm5vZGUoKTsKKyAg ICAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OnRhYmxlVGFnKSkg eworICAgICAgICAgICAgSFRNTFRhYmxlQ2FwdGlvbkVsZW1lbnQqIGNhcHRpb24gPSBzdGF0aWNf Y2FzdDxIVE1MVGFibGVFbGVtZW50Kj4obm9kZSktPmNhcHRpb24oKTsKKyAgICAgICAgICAgIGlm IChjYXB0aW9uKQorICAgICAgICAgICAgICAgIHJldHVybiBBY2Nlc3NpYmlsaXR5T2JqZWN0Ojpm aXJzdEFjY2Vzc2libGVPYmplY3RGcm9tTm9kZShjYXB0aW9uLT5yZW5kZXJlcigpLT5ub2RlKCkp LT53cmFwcGVyKCk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIE5VTEw7Cit9CisKIHN0 YXRpYyB2b2lkIGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdChBdGtUYWJsZUlmYWNlKiBpZmFjZSkK IHsKICAgICBpZmFjZS0+cmVmX2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0Owog ICAgIGlmYWNlLT5nZXRfaW5kZXhfYXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfaW5k ZXhfYXQ7CisgICAgaWZhY2UtPmdldF9jb2x1bW5fYXRfaW5kZXggPSB3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfY29sdW1uX2F0X2luZGV4OworICAgIGlmYWNlLT5nZXRfcm93X2F0X2luZGV4 ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleDsKICAgICBpZmFjZS0+ Z2V0X25fY29sdW1ucyA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnM7CiAg ICAgaWZhY2UtPmdldF9uX3Jvd3MgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9yb3dz OwogICAgIGlmYWNlLT5nZXRfY29sdW1uX2V4dGVudF9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9jb2x1bW5fZXh0ZW50X2F0OwogICAgIGlmYWNlLT5nZXRfcm93X2V4dGVudF9hdCA9 IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0OwogICAgIGlmYWNlLT5n ZXRfcm93X2hlYWRlciA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyOwor ICAgIGlmYWNlLT5nZXRfY2FwdGlvbiA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0 aW9uOwogfQogCiBzdGF0aWMgY29uc3QgR0ludGVyZmFjZUluZm8gQXRrSW50ZXJmYWNlc0luaXRG dW5jdGlvbnNbXSA9IHsKLS0gCjEuNi4zLjMKCg== 41924 2009-10-26 18:51:24 -0700 2009-10-27 10:40:50 -0700 table 3 table-3 text/plain 6332 jdiggs RnJvbSBkZjRkYWI3YzRjOGYxYmI2YTY1NTdjNGM5YjRlMmVmZTEzMDAzMTU4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IE1vbiwgMjYgT2N0IDIwMDkgMjE6NDE6NTMgLTA0MDAKU3ViamVjdDogW1BB VENIIDMvM10gUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKW0dUS10gT2JqZWN0cyBvZiBST0xFX1RBQkxFIHNo b3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlCgpUaGlyZCBwYXJ0 IG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4KCiogYWNjZXNzaWJpbGl0eS9ndGsv QWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwOgoobmFtZUZyb21DaGlsZHJlbik6Cih3 ZWJraXRfYWNjZXNzaWJsZV9nZXRfbmFtZSk6Ck5ldyBjb252ZW5pZW5jZSBmdW5jdGlvbiB0byBj b25zdHJ1Y3QgYW4gb2JqZWN0J3MgbmFtZSB1c2luZyB0aGUgbmFtZShzKSBvZgphbnkgY2hpbGRy ZW4gaXQgaGFzLgoKKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6Cih3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfY29sdW1uX2Rlc2NyaXB0aW9uKToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9yb3dfZGVzY3JpcHRpb24pOgpJbXBsZW1lbnRlZC4KCih3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfY29sdW1uX2hlYWRlcik6ClN0dWIgZnVuY3Rpb24gYWRkZWQgc28gdGhhdCB3ZWJr aXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2Rlc2NyaXB0aW9uCmNvdWxkIGJlIGltcGxl bWVudGVkIGluIHRoZSBtZWFudGltZS4KLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjQgKysrKysrKysrCiAuLi4vZ3RrL0FjY2Vzc2li aWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcCAgICAgICAgICB8ICAgNTQgKysrKysrKysrKysrKysr Ky0tLQogMiBmaWxlcyBjaGFuZ2VkLCA2OSBpbnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg Zjk4ODRiOS4uMzFlMDRlNSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTEsNiArMSwzMCBAQAogMjAwOS0xMC0yNiAgSm9hbm1hcmllIERp Z2dzICA8am9hbm1hcmllLmRpZ2dzQGdtYWlsLmNvbT4KIAogICAgICAgICBSZXZpZXdlZCBieSBO T0JPRFkgKE9PUFMhKS4KKyAgICAgICAgCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNAorICAgICAgICBbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFC TEUgc2hvdWxkIGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKKyAgICAg ICAgCisgICAgICAgIFRoaXJkIHBhcnQgb2YgdGhlIGltcGxlbWVudGF0aW9uIG9mIEF0a1RhYmxl LgorICAgICAgICAKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2Jq ZWN0V3JhcHBlckF0ay5jcHA6CisgICAgICAgIChuYW1lRnJvbUNoaWxkcmVuKToKKyAgICAgICAg KHdlYmtpdF9hY2Nlc3NpYmxlX2dldF9uYW1lKToKKyAgICAgICAgTmV3IGNvbnZlbmllbmNlIGZ1 bmN0aW9uIHRvIGNvbnN0cnVjdCBhbiBvYmplY3QncyBuYW1lIHVzaW5nIHRoZSBuYW1lKHMpIG9m CisgICAgICAgIGFueSBjaGlsZHJlbiBpdCBoYXMuCisKKyAgICAgICAgKGF0a190YWJsZV9pbnRl cmZhY2VfaW5pdCk6ICAgICAgICAKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dl dF9jb2x1bW5fZGVzY3JpcHRpb24pOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X3Jvd19kZXNjcmlwdGlvbik6CisgICAgICAgIEltcGxlbWVudGVkLgorICAgICAgICAKKyAg ICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5faGVhZGVyKToKKyAgICAg ICAgU3R1YiBmdW5jdGlvbiBhZGRlZCBzbyB0aGF0IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dl dF9jb2x1bW5fZGVzY3JpcHRpb24KKyAgICAgICAgY291bGQgYmUgaW1wbGVtZW50ZWQgaW4gdGhl IG1lYW50aW1lLgorCisyMDA5LTEwLTI2ICBKb2FubWFyaWUgRGlnZ3MgIDxqb2FubWFyaWUuZGln Z3NAZ21haWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgogCiAg ICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTUzNAogICAg ICAgICBbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxkIGltcGxlbWVudCB0aGUgYWNj ZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKaW5kZXggODk2OTBi MC4uNjRmYmY3ZCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3Np YmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0 ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKQEAgLTEzMSwyMSArMTMxLDI5IEBA IHN0YXRpYyBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBjb3JlKEF0a1RhYmxlKiB0YWJsZSkKICAgICBy ZXR1cm4gY29yZShBVEtfT0JKRUNUKHRhYmxlKSk7CiB9CiAKK3N0YXRpYyBjb25zdCBnY2hhciog bmFtZUZyb21DaGlsZHJlbihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QpCit7CisgICAgaWYg KG9iamVjdCkgeworICAgICAgICBBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0OjpBY2Nlc3NpYmls aXR5Q2hpbGRyZW5WZWN0b3IgY2hpbGRyZW4gPSBvYmplY3QtPmNoaWxkcmVuKCk7CisgICAgICAg IC8vIEN1cnJlbnRseSwgb2JqZWN0LT5zdHJpbmdWYWx1ZSgpIHNob3VsZCBiZSBhbiBlbXB0eSBT dHJpbmcuIFRoaXMKKyAgICAgICAgLy8gbWlnaHQgbm90IGJlIHRoZSBjYXNlIGRvd24gdGhlIHJv YWQuCisgICAgICAgIFN0cmluZyBuYW1lID0gb2JqZWN0LT5zdHJpbmdWYWx1ZSgpOworICAgICAg ICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgY2hpbGRyZW4uc2l6ZSgpOyArK2kpCisgICAgICAg ICAgICBuYW1lICs9IGNoaWxkcmVuLmF0KGkpLmdldCgpLT5zdHJpbmdWYWx1ZSgpOworICAgICAg ICByZXR1cm4gcmV0dXJuU3RyaW5nKG5hbWUpOworICAgIH0KKworICAgIHJldHVybiBOVUxMOwor fQorCiBzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtpdF9hY2Nlc3NpYmxlX2dldF9uYW1lKEF0a09i amVjdCogb2JqZWN0KQogewogICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGNvcmVPYmplY3QgPSBj b3JlKG9iamVjdCk7CiAgICAgaWYgKGNvcmVPYmplY3QtPmlzQ29udHJvbCgpKSB7CiAgICAgICAg IEFjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqIHJlbmRlck9iamVjdCA9IHN0YXRpY19jYXN0PEFj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QqPihjb3JlT2JqZWN0KTsKICAgICAgICAgQWNjZXNzaWJp bGl0eU9iamVjdCogbGFiZWwgPSByZW5kZXJPYmplY3QtPmNvcnJlc3BvbmRpbmdMYWJlbEZvckNv bnRyb2xFbGVtZW50KCk7Ci0gICAgICAgIGlmIChsYWJlbCkgewotICAgICAgICAgICAgQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdDo6QWNjZXNzaWJpbGl0eUNoaWxkcmVuVmVjdG9yIGNoaWxkcmVu ID0gbGFiZWwtPmNoaWxkcmVuKCk7Ci0gICAgICAgICAgICAvLyBDdXJyZW50bHksIGxhYmVsLT5z dHJpbmdWYWx1ZSgpIHNob3VsZCBiZSBhbiBlbXB0eSBTdHJpbmcuIFRoaXMKLSAgICAgICAgICAg IC8vIG1pZ2h0IG5vdCBiZSB0aGUgY2FzZSBkb3duIHRoZSByb2FkLgotICAgICAgICAgICAgU3Ry aW5nIG5hbWUgPSBsYWJlbC0+c3RyaW5nVmFsdWUoKTsKLSAgICAgICAgICAgIGZvciAodW5zaWdu ZWQgaSA9IDA7IGkgPCBjaGlsZHJlbi5zaXplKCk7ICsraSkKLSAgICAgICAgICAgICAgICBuYW1l ICs9IGNoaWxkcmVuLmF0KGkpLmdldCgpLT5zdHJpbmdWYWx1ZSgpOwotICAgICAgICAgICAgcmV0 dXJuIHJldHVyblN0cmluZyhuYW1lKTsKLSAgICAgICAgfQorICAgICAgICBpZiAobGFiZWwpCisg ICAgICAgICAgICByZXR1cm4gcmV0dXJuU3RyaW5nKG5hbWVGcm9tQ2hpbGRyZW4obGFiZWwpKTsK ICAgICB9CiAgICAgcmV0dXJuIHJldHVyblN0cmluZyhjb3JlT2JqZWN0LT5zdHJpbmdWYWx1ZSgp KTsKIH0KQEAgLTExNjksNiArMTE3NywxMyBAQCBzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfcm93X2V4dGVudF9hdChBdGtUYWJsZSogdGFibGUsIGdpbnQgcm93LAogICAg IHJldHVybiAwOwogfQogCitzdGF0aWMgQXRrT2JqZWN0KiB3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9nZXRfY29sdW1uX2hlYWRlcihBdGtUYWJsZSogdGFibGUsIGdpbnQgY29sdW1uKQoreworICAg IC8vIEZJWE1FOiBUaGlzIG5lZWRzIHRvIGJlIGltcGxlbWVudGVkLgorICAgIG5vdEltcGxlbWVu dGVkKCk7CisgICAgcmV0dXJuIE5VTEw7Cit9CisKIHN0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9h Y2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3cp CiB7CiAgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKQEAg LTEyMDAsNiArMTIxNSwyNCBAQCBzdGF0aWMgQXRrT2JqZWN0KiB3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfY2FwdGlvbihBdGtUYWJsZSogdGFibGUpCiAgICAgcmV0dXJuIE5VTEw7CiB9CiAK K3N0YXRpYyBjb25zdCBnY2hhciogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9k ZXNjcmlwdGlvbihBdGtUYWJsZSogdGFibGUsIGdpbnQgY29sdW1uKQoreworICAgIEF0a09iamVj dCogY29sdW1uSGVhZGVyID0gYXRrX3RhYmxlX2dldF9jb2x1bW5faGVhZGVyKHRhYmxlLCBjb2x1 bW4pOworICAgIGlmIChjb2x1bW5IZWFkZXIpCisgICAgICAgIHJldHVybiByZXR1cm5TdHJpbmco bmFtZUZyb21DaGlsZHJlbihjb3JlKGNvbHVtbkhlYWRlcikpKTsKKworICAgIHJldHVybiBOVUxM OworfQorCitzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9y b3dfZGVzY3JpcHRpb24oQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdykKK3sKKyAgICBBdGtPYmpl Y3QqIHJvd0hlYWRlciA9IGF0a190YWJsZV9nZXRfcm93X2hlYWRlcih0YWJsZSwgcm93KTsKKyAg ICBpZiAocm93SGVhZGVyKSAKKyAgICAgICAgcmV0dXJuIHJldHVyblN0cmluZyhuYW1lRnJvbUNo aWxkcmVuKGNvcmUocm93SGVhZGVyKSkpOworCisgICAgcmV0dXJuIE5VTEw7Cit9CisKIHN0YXRp YyB2b2lkIGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdChBdGtUYWJsZUlmYWNlKiBpZmFjZSkKIHsK ICAgICBpZmFjZS0+cmVmX2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0OwpAQCAt MTIxMCw4ICsxMjQzLDExIEBAIHN0YXRpYyB2b2lkIGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdChB dGtUYWJsZUlmYWNlKiBpZmFjZSkKICAgICBpZmFjZS0+Z2V0X25fcm93cyA9IHdlYmtpdF9hY2Nl c3NpYmxlX3RhYmxlX2dldF9uX3Jvd3M7CiAgICAgaWZhY2UtPmdldF9jb2x1bW5fZXh0ZW50X2F0 ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9leHRlbnRfYXQ7CiAgICAgaWZh Y2UtPmdldF9yb3dfZXh0ZW50X2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19l eHRlbnRfYXQ7CisgICAgaWZhY2UtPmdldF9jb2x1bW5faGVhZGVyID0gd2Via2l0X2FjY2Vzc2li bGVfdGFibGVfZ2V0X2NvbHVtbl9oZWFkZXI7CiAgICAgaWZhY2UtPmdldF9yb3dfaGVhZGVyID0g d2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19oZWFkZXI7CiAgICAgaWZhY2UtPmdldF9j YXB0aW9uID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NhcHRpb247CisgICAgaWZhY2Ut PmdldF9jb2x1bW5fZGVzY3JpcHRpb24gPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29s dW1uX2Rlc2NyaXB0aW9uOworICAgIGlmYWNlLT5nZXRfcm93X2Rlc2NyaXB0aW9uID0gd2Via2l0 X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19kZXNjcmlwdGlvbjsKIH0KIAogc3RhdGljIGNvbnN0 IEdJbnRlcmZhY2VJbmZvIEF0a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zW10gPSB7Ci0tIAoxLjYu My4zCgo= 41959 2009-10-27 10:08:37 -0700 2009-10-27 10:36:59 -0700 table 2 - corrected as per review table-2.1-patch text/plain 5291 jdiggs RnJvbSAwMmY4ODQzMjU0ODQ2NWIzYzA5ZjllYTJiZTZkMDA0Y2I4YTFiYTQ5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMTI6MTY6MTggLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKClNlY29uZCBwYXJ0IG9m IHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4KCiogYWNjZXNzaWJpbGl0eS9ndGsvQWNj ZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwOgooY2VsbEF0SW5kZXgpOgood2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfcm93X2F0X2luZGV4KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0 aW9uKToKKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6Ci0tLQogV2ViQ29yZS9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKwogLi4uL2d0ay9B Y2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAgICAgICAgICAgfCAgIDUzICsrKysrKysr KysrKysrKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDY5IGluc2VydGlvbnMoKyksIDAgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCA4M2U5YTM3Li5iMmZlZGM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDIxIEBACiAyMDA5LTEwLTI3ICBKb2Fu bWFyaWUgRGlnZ3MgIDxqb2FubWFyaWUuZGlnZ3NAZ21haWwuY29tPgogCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNAorICAgICAgICBbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFC TEUgc2hvdWxkIGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKKworICAg ICAgICBTZWNvbmQgcGFydCBvZiB0aGUgaW1wbGVtZW50YXRpb24gb2YgQXRrVGFibGUuCisKKyAg ICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5j cHA6CisgICAgICAgIChjZWxsQXRJbmRleCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfY29sdW1uX2F0X2luZGV4KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9yb3dfYXRfaW5kZXgpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X2NhcHRpb24pOgorICAgICAgICAoYXRrX3RhYmxlX2ludGVyZmFjZV9pbml0KToKKworMjAw OS0xMC0yNyAgSm9hbm1hcmllIERpZ2dzICA8am9hbm1hcmllLmRpZ2dzQGdtYWlsLmNvbT4KKwog ICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXouCiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1NTM0CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcCBiL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCmluZGV4 IDhmZDViNDAuLjFjZGYyYjggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsv QWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCkBAIC0xMDg5LDYgKzEw ODksMjAgQEAgc3RhdGljIGdpbnQgY2VsbEluZGV4KEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFY Q2VsbCwgQWNjZXNzaWJpbGl0eVRhYmxlKiBBWFRhYmwKICAgICByZXR1cm4gcG9zaXRpb24gLSBh bGxDZWxscy5iZWdpbigpOwogfQogCitzdGF0aWMgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogY2Vs bEF0SW5kZXgoQXRrVGFibGUqIHRhYmxlLCBnaW50IGluZGV4KQoreworICAgIEFjY2Vzc2liaWxp dHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CisgICAgaWYgKGFjY1RhYmxlLT5pc0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkgeworICAgICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0 OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgYWxsQ2VsbHM7CisgICAgICAgIHN0YXRpY19j YXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+Y2VsbHMoYWxsQ2VsbHMpOworICAg ICAgICBpZiAoMCA8PSBpbmRleCAmJiBpbmRleCA8IGFsbENlbGxzLnNpemUoKSkgeworICAgICAg ICAgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogYWNjQ2VsbCA9IGFsbENlbGxzLmF0KGluZGV4KS5n ZXQoKTsKKyAgICAgICAgICAgIHJldHVybiBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5VGFibGVD ZWxsKj4oYWNjQ2VsbCk7CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKIHN0 YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX3JlZl9hdChBdGtUYWJsZSog dGFibGUsIGdpbnQgcm93LCBnaW50IGNvbHVtbikKIHsKICAgICBBY2Nlc3NpYmlsaXR5VGFibGVD ZWxsKiBBWENlbGwgPSBjZWxsKHRhYmxlLCByb3csIGNvbHVtbik7CkBAIC0xMTA0LDYgKzExMTgs MjggQEAgc3RhdGljIGdpbnQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2luZGV4X2F0KEF0 a1RhYmxlKiB0YWJsZSwgZ2ludCByb3csIGdpbnQKICAgICByZXR1cm4gY2VsbEluZGV4KEFYQ2Vs bCwgQVhUYWJsZSk7CiB9CiAKK3N0YXRpYyBnaW50IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dl dF9jb2x1bW5fYXRfaW5kZXgoQXRrVGFibGUqIHRhYmxlLCBnaW50IGluZGV4KQoreworICAgIEFj Y2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9IGNlbGxBdEluZGV4KHRhYmxlLCBpbmRleCk7 CisgICAgaWYgKEFYQ2VsbCl7CisgICAgICAgIHBhaXI8aW50LCBpbnQ+IGNvbHVtblJhbmdlOwor ICAgICAgICBBWENlbGwtPmNvbHVtbkluZGV4UmFuZ2UoY29sdW1uUmFuZ2UpOworICAgICAgICBy ZXR1cm4gY29sdW1uUmFuZ2UuZmlyc3Q7CisgICAgfQorICAgIHJldHVybiAtMTsKK30KKworc3Rh dGljIGdpbnQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleChBdGtUYWJs ZSogdGFibGUsIGdpbnQgaW5kZXgpCit7CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhD ZWxsID0gY2VsbEF0SW5kZXgodGFibGUsIGluZGV4KTsKKyAgICBpZiAoQVhDZWxsKXsKKyAgICAg ICAgcGFpcjxpbnQsIGludD4gcm93UmFuZ2U7CisgICAgICAgIEFYQ2VsbC0+cm93SW5kZXhSYW5n ZShyb3dSYW5nZSk7CisgICAgICAgIHJldHVybiByb3dSYW5nZS5maXJzdDsKKyAgICB9CisgICAg cmV0dXJuIC0xOworfQorCiBzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRf bl9jb2x1bW5zKEF0a1RhYmxlKiB0YWJsZSkKIHsKICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBh Y2NUYWJsZSA9IGNvcmUodGFibGUpOwpAQCAtMTE1OSwxNSArMTE5NSwzMiBAQCBzdGF0aWMgQXRr T2JqZWN0KiB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfcm93X2hlYWRlcihBdGtUYWJsZSog dGFibGUsIGdpbnQgcgogICAgIHJldHVybiAwOwogfQogCitzdGF0aWMgQXRrT2JqZWN0KiB3ZWJr aXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY2FwdGlvbihBdGtUYWJsZSogdGFibGUpCit7CisgICAg QWNjZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKKyAgICBpZiAoYWNj VGFibGUtPmlzQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAgICAgIE5vZGUqIG5v ZGUgPSBzdGF0aWNfY2FzdDxBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4oYWNjVGFibGUpLT5y ZW5kZXJlcigpLT5ub2RlKCk7CisgICAgICAgIGlmIChub2RlICYmIG5vZGUtPmhhc1RhZ05hbWUo SFRNTE5hbWVzOjp0YWJsZVRhZykpIHsKKyAgICAgICAgICAgIEhUTUxUYWJsZUNhcHRpb25FbGVt ZW50KiBjYXB0aW9uID0gc3RhdGljX2Nhc3Q8SFRNTFRhYmxlRWxlbWVudCo+KG5vZGUpLT5jYXB0 aW9uKCk7CisgICAgICAgICAgICBpZiAoY2FwdGlvbikKKyAgICAgICAgICAgICAgICByZXR1cm4g QWNjZXNzaWJpbGl0eU9iamVjdDo6Zmlyc3RBY2Nlc3NpYmxlT2JqZWN0RnJvbU5vZGUoY2FwdGlv bi0+cmVuZGVyZXIoKS0+bm9kZSgpKS0+d3JhcHBlcigpOworICAgICAgICB9CisgICAgfQorICAg IHJldHVybiAwOworfQorCiBzdGF0aWMgdm9pZCBhdGtfdGFibGVfaW50ZXJmYWNlX2luaXQoQXRr VGFibGVJZmFjZSogaWZhY2UpCiB7CiAgICAgaWZhY2UtPnJlZl9hdCA9IHdlYmtpdF9hY2Nlc3Np YmxlX3RhYmxlX3JlZl9hdDsKICAgICBpZmFjZS0+Z2V0X2luZGV4X2F0ID0gd2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X2luZGV4X2F0OworICAgIGlmYWNlLT5nZXRfY29sdW1uX2F0X2luZGV4 ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleDsKKyAgICBpZmFj ZS0+Z2V0X3Jvd19hdF9pbmRleCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfYXRf aW5kZXg7CiAgICAgaWZhY2UtPmdldF9uX2NvbHVtbnMgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9nZXRfbl9jb2x1bW5zOwogICAgIGlmYWNlLT5nZXRfbl9yb3dzID0gd2Via2l0X2FjY2Vzc2li bGVfdGFibGVfZ2V0X25fcm93czsKICAgICBpZmFjZS0+Z2V0X2NvbHVtbl9leHRlbnRfYXQgPSB3 ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2V4dGVudF9hdDsKICAgICBpZmFjZS0+ Z2V0X3Jvd19leHRlbnRfYXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfcm93X2V4dGVu dF9hdDsKICAgICBpZmFjZS0+Z2V0X3Jvd19oZWFkZXIgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9nZXRfcm93X2hlYWRlcjsKKyAgICBpZmFjZS0+Z2V0X2NhcHRpb24gPSB3ZWJraXRfYWNjZXNz aWJsZV90YWJsZV9nZXRfY2FwdGlvbjsKIH0KIAogc3RhdGljIGNvbnN0IEdJbnRlcmZhY2VJbmZv IEF0a0ludGVyZmFjZXNJbml0RnVuY3Rpb25zW10gPSB7Ci0tIAoxLjYuMy4zCgo= 41963 2009-10-27 10:36:59 -0700 2009-10-28 23:09:41 -0700 Table 2 - Adjusted to address compiler warning about comparing signed and unsigned table-2.1-patch text/plain 5314 jdiggs RnJvbSAwMmY4ODQzMjU0ODQ2NWIzYzA5ZjllYTJiZTZkMDA0Y2I4YTFiYTQ5IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMTI6MTY6MTggLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKClNlY29uZCBwYXJ0IG9m IHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4KCiogYWNjZXNzaWJpbGl0eS9ndGsvQWNj ZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwOgooY2VsbEF0SW5kZXgpOgood2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfcm93X2F0X2luZGV4KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0 aW9uKToKKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6Ci0tLQogV2ViQ29yZS9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE2ICsrKysrKwogLi4uL2d0ay9B Y2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAgICAgICAgICAgfCAgIDUzICsrKysrKysr KysrKysrKysrKysrCiAyIGZpbGVzIGNoYW5nZWQsIDY5IGluc2VydGlvbnMoKyksIDAgZGVsZXRp b25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFuZ2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxv ZwppbmRleCA4M2U5YTM3Li5iMmZlZGM5IDEwMDY0NAotLS0gYS9XZWJDb3JlL0NoYW5nZUxvZwor KysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSw1ICsxLDIxIEBACiAyMDA5LTEwLTI3ICBKb2Fu bWFyaWUgRGlnZ3MgIDxqb2FubWFyaWUuZGlnZ3NAZ21haWwuY29tPgogCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNAorICAgICAgICBbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFC TEUgc2hvdWxkIGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKKworICAg ICAgICBTZWNvbmQgcGFydCBvZiB0aGUgaW1wbGVtZW50YXRpb24gb2YgQXRrVGFibGUuCisKKyAg ICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5j cHA6CisgICAgICAgIChjZWxsQXRJbmRleCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfY29sdW1uX2F0X2luZGV4KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9yb3dfYXRfaW5kZXgpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVfdGFibGVf Z2V0X2NhcHRpb24pOgorICAgICAgICAoYXRrX3RhYmxlX2ludGVyZmFjZV9pbml0KToKKworMjAw OS0xMC0yNyAgSm9hbm1hcmllIERpZ2dzICA8am9hbm1hcmllLmRpZ2dzQGdtYWlsLmNvbT4KKwog ICAgICAgICBSZXZpZXdlZCBieSBYYW4gTG9wZXouCiAKICAgICAgICAgaHR0cHM6Ly9idWdzLndl YmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTI1NTM0CmRpZmYgLS1naXQgYS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcCBiL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCmluZGV4 IDhmZDViNDAuLjFjZGYyYjggMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsv QWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCisrKyBiL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwCkBAIC0xMDg5LDYgKzEw ODksMjAgQEAgc3RhdGljIGdpbnQgY2VsbEluZGV4KEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFY Q2VsbCwgQWNjZXNzaWJpbGl0eVRhYmxlKiBBWFRhYmwKICAgICByZXR1cm4gcG9zaXRpb24gLSBh bGxDZWxscy5iZWdpbigpOwogfQogCitzdGF0aWMgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogY2Vs bEF0SW5kZXgoQXRrVGFibGUqIHRhYmxlLCBnaW50IGluZGV4KQoreworICAgIEFjY2Vzc2liaWxp dHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CisgICAgaWYgKGFjY1RhYmxlLT5pc0Fj Y2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkgeworICAgICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0 OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgYWxsQ2VsbHM7CisgICAgICAgIHN0YXRpY19j YXN0PEFjY2Vzc2liaWxpdHlUYWJsZSo+KGFjY1RhYmxlKS0+Y2VsbHMoYWxsQ2VsbHMpOworICAg ICAgICBpZiAoMCA8PSBpbmRleCAmJiBzdGF0aWNfY2FzdDx1bnNpZ25lZD4oaW5kZXgpIDwgYWxs Q2VsbHMuc2l6ZSgpKSB7CisgICAgICAgICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NDZWxs ID0gYWxsQ2VsbHMuYXQoaW5kZXgpLmdldCgpOworICAgICAgICAgICAgcmV0dXJuIHN0YXRpY19j YXN0PEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqPihhY2NDZWxsKTsKKyAgICAgICAgfQorICAgIH0K KyAgICByZXR1cm4gMDsKK30KKwogc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVf dGFibGVfcmVmX2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3csIGdpbnQgY29sdW1uKQogewog ICAgIEFjY2Vzc2liaWxpdHlUYWJsZUNlbGwqIEFYQ2VsbCA9IGNlbGwodGFibGUsIHJvdywgY29s dW1uKTsKQEAgLTExMDQsNiArMTExOCwyOCBAQCBzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfaW5kZXhfYXQoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdywgZ2ludAogICAg IHJldHVybiBjZWxsSW5kZXgoQVhDZWxsLCBBWFRhYmxlKTsKIH0KIAorc3RhdGljIGdpbnQgd2Vi a2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleChBdGtUYWJsZSogdGFibGUs IGdpbnQgaW5kZXgpCit7CisgICAgQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsID0gY2Vs bEF0SW5kZXgodGFibGUsIGluZGV4KTsKKyAgICBpZiAoQVhDZWxsKXsKKyAgICAgICAgcGFpcjxp bnQsIGludD4gY29sdW1uUmFuZ2U7CisgICAgICAgIEFYQ2VsbC0+Y29sdW1uSW5kZXhSYW5nZShj b2x1bW5SYW5nZSk7CisgICAgICAgIHJldHVybiBjb2x1bW5SYW5nZS5maXJzdDsKKyAgICB9Cisg ICAgcmV0dXJuIC0xOworfQorCitzdGF0aWMgZ2ludCB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9n ZXRfcm93X2F0X2luZGV4KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCBpbmRleCkKK3sKKyAgICBBY2Nl c3NpYmlsaXR5VGFibGVDZWxsKiBBWENlbGwgPSBjZWxsQXRJbmRleCh0YWJsZSwgaW5kZXgpOwor ICAgIGlmIChBWENlbGwpeworICAgICAgICBwYWlyPGludCwgaW50PiByb3dSYW5nZTsKKyAgICAg ICAgQVhDZWxsLT5yb3dJbmRleFJhbmdlKHJvd1JhbmdlKTsKKyAgICAgICAgcmV0dXJuIHJvd1Jh bmdlLmZpcnN0OworICAgIH0KKyAgICByZXR1cm4gLTE7Cit9CisKIHN0YXRpYyBnaW50IHdlYmtp dF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnMoQXRrVGFibGUqIHRhYmxlKQogewogICAg IEFjY2Vzc2liaWxpdHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0YWJsZSk7CkBAIC0xMTU5LDE1 ICsxMTk1LDMyIEBAIHN0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dl dF9yb3dfaGVhZGVyKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByCiAgICAgcmV0dXJuIDA7CiB9CiAK K3N0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0aW9uKEF0 a1RhYmxlKiB0YWJsZSkKK3sKKyAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NUYWJsZSA9IGNv cmUodGFibGUpOworICAgIGlmIChhY2NUYWJsZS0+aXNBY2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0 KCkpIHsKKyAgICAgICAgTm9kZSogbm9kZSA9IHN0YXRpY19jYXN0PEFjY2Vzc2liaWxpdHlSZW5k ZXJPYmplY3QqPihhY2NUYWJsZSktPnJlbmRlcmVyKCktPm5vZGUoKTsKKyAgICAgICAgaWYgKG5v ZGUgJiYgbm9kZS0+aGFzVGFnTmFtZShIVE1MTmFtZXM6OnRhYmxlVGFnKSkgeworICAgICAgICAg ICAgSFRNTFRhYmxlQ2FwdGlvbkVsZW1lbnQqIGNhcHRpb24gPSBzdGF0aWNfY2FzdDxIVE1MVGFi bGVFbGVtZW50Kj4obm9kZSktPmNhcHRpb24oKTsKKyAgICAgICAgICAgIGlmIChjYXB0aW9uKQor ICAgICAgICAgICAgICAgIHJldHVybiBBY2Nlc3NpYmlsaXR5T2JqZWN0OjpmaXJzdEFjY2Vzc2li bGVPYmplY3RGcm9tTm9kZShjYXB0aW9uLT5yZW5kZXJlcigpLT5ub2RlKCkpLT53cmFwcGVyKCk7 CisgICAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIDA7Cit9CisKIHN0YXRpYyB2b2lkIGF0a190 YWJsZV9pbnRlcmZhY2VfaW5pdChBdGtUYWJsZUlmYWNlKiBpZmFjZSkKIHsKICAgICBpZmFjZS0+ cmVmX2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfcmVmX2F0OwogICAgIGlmYWNlLT5nZXRf aW5kZXhfYXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfaW5kZXhfYXQ7CisgICAgaWZh Y2UtPmdldF9jb2x1bW5fYXRfaW5kZXggPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29s dW1uX2F0X2luZGV4OworICAgIGlmYWNlLT5nZXRfcm93X2F0X2luZGV4ID0gd2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X3Jvd19hdF9pbmRleDsKICAgICBpZmFjZS0+Z2V0X25fY29sdW1ucyA9 IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX2NvbHVtbnM7CiAgICAgaWZhY2UtPmdldF9u X3Jvd3MgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfbl9yb3dzOwogICAgIGlmYWNlLT5n ZXRfY29sdW1uX2V4dGVudF9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5f ZXh0ZW50X2F0OwogICAgIGlmYWNlLT5nZXRfcm93X2V4dGVudF9hdCA9IHdlYmtpdF9hY2Nlc3Np YmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0OwogICAgIGlmYWNlLT5nZXRfcm93X2hlYWRlciA9 IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyOworICAgIGlmYWNlLT5nZXRf Y2FwdGlvbiA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0aW9uOwogfQogCiBzdGF0 aWMgY29uc3QgR0ludGVyZmFjZUluZm8gQXRrSW50ZXJmYWNlc0luaXRGdW5jdGlvbnNbXSA9IHsK LS0gCjEuNi4zLjMKCg== 41965 2009-10-27 10:40:50 -0700 2009-10-30 10:35:23 -0700 table 3 - corrected as per review table-3.1.patch text/plain 6261 jdiggs RnJvbSA0ODI2YjdiOTJkNWJhNDY1NGRiOTI4ODFlZmZiODk3MTVhNDZhN2I2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMTM6MjY6NTYgLTA0MDAKU3ViamVjdDogW1BB VENIIDIvMl0gUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKW0dUS10gT2JqZWN0cyBvZiBST0xFX1RBQkxFIHNo b3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlCgpUaGlyZCBwYXJ0 IG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4KCiogYWNjZXNzaWJpbGl0eS9ndGsv QWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwOgoobmFtZUZyb21DaGlsZHJlbik6Cih3 ZWJraXRfYWNjZXNzaWJsZV9nZXRfbmFtZSk6Ck5ldyBjb252ZW5pZW5jZSBmdW5jdGlvbiB0byBj b25zdHJ1Y3QgYW4gb2JqZWN0J3MgbmFtZSB1c2luZyB0aGUgbmFtZShzKSBvZgphbnkgY2hpbGRy ZW4gaXQgaGFzLgoKKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6Cih3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfY29sdW1uX2Rlc2NyaXB0aW9uKToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9yb3dfZGVzY3JpcHRpb24pOgpJbXBsZW1lbnRlZC4KCih3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfY29sdW1uX2hlYWRlcik6ClN0dWIgZnVuY3Rpb24gYWRkZWQgc28gdGhhdCB3ZWJr aXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2Rlc2NyaXB0aW9uCmNvdWxkIGJlIGltcGxl bWVudGVkIGluIHRoZSBtZWFudGltZS4KLS0tCiBXZWJDb3JlL0NoYW5nZUxvZyAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICB8ICAgMjQgKysrKysrKysrCiAuLi4vZ3RrL0FjY2Vzc2li aWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcCAgICAgICAgICB8ICAgNTIgKysrKysrKysrKysrKysr Ky0tLQogMiBmaWxlcyBjaGFuZ2VkLCA2NyBpbnNlcnRpb25zKCspLCA5IGRlbGV0aW9ucygtKQoK ZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXgg YjJmZWRjOS4uZWM2YTcyNCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2Vi Q29yZS9DaGFuZ2VMb2cKQEAgLTUsNiArNSwzMCBAQAogICAgICAgICBodHRwczovL2J1Z3Mud2Vi a2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKICAgICAgICAgW0dUS10gT2JqZWN0cyBvZiBS T0xFX1RBQkxFIHNob3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNl CiAKKyAgICAgICAgVGhpcmQgcGFydCBvZiB0aGUgaW1wbGVtZW50YXRpb24gb2YgQXRrVGFibGUu CisKKyAgICAgICAgKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBl ckF0ay5jcHA6CisgICAgICAgIChuYW1lRnJvbUNoaWxkcmVuKToKKyAgICAgICAgKHdlYmtpdF9h Y2Nlc3NpYmxlX2dldF9uYW1lKToKKyAgICAgICAgTmV3IGNvbnZlbmllbmNlIGZ1bmN0aW9uIHRv IGNvbnN0cnVjdCBhbiBvYmplY3QncyBuYW1lIHVzaW5nIHRoZSBuYW1lKHMpIG9mCisgICAgICAg IGFueSBjaGlsZHJlbiBpdCBoYXMuCisKKyAgICAgICAgKGF0a190YWJsZV9pbnRlcmZhY2VfaW5p dCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2Rlc2NyaXB0 aW9uKToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZGVzY3JpcHRp b24pOgorICAgICAgICBJbXBsZW1lbnRlZC4KKworICAgICAgICAod2Via2l0X2FjY2Vzc2libGVf dGFibGVfZ2V0X2NvbHVtbl9oZWFkZXIpOgorICAgICAgICBTdHViIGZ1bmN0aW9uIGFkZGVkIHNv IHRoYXQgd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9kZXNjcmlwdGlvbgorICAg ICAgICBjb3VsZCBiZSBpbXBsZW1lbnRlZCBpbiB0aGUgbWVhbnRpbWUuCisKKzIwMDktMTAtMjcg IEpvYW5tYXJpZSBEaWdncyAgPGpvYW5tYXJpZS5kaWdnc0BnbWFpbC5jb20+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTI1NTM0CisgICAgICAgIFtHVEtdIE9iamVjdHMgb2YgUk9M RV9UQUJMRSBzaG91bGQgaW1wbGVtZW50IHRoZSBhY2Nlc3NpYmxlIHRhYmxlIGludGVyZmFjZQor CiAgICAgICAgIFNlY29uZCBwYXJ0IG9mIHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4K IAogICAgICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVy QXRrLmNwcDoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJp bGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nl c3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKaW5kZXggMWNkZjJiOC4uNDRlMjE4OSAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3Jh cHBlckF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5 T2JqZWN0V3JhcHBlckF0ay5jcHAKQEAgLTEzMSwyMSArMTMxLDI3IEBAIHN0YXRpYyBBY2Nlc3Np YmlsaXR5T2JqZWN0KiBjb3JlKEF0a1RhYmxlKiB0YWJsZSkKICAgICByZXR1cm4gY29yZShBVEtf T0JKRUNUKHRhYmxlKSk7CiB9CiAKK3N0YXRpYyBjb25zdCBnY2hhciogbmFtZUZyb21DaGlsZHJl bihBY2Nlc3NpYmlsaXR5T2JqZWN0KiBvYmplY3QpCit7CisgICAgaWYgKCFvYmplY3QpCisgICAg ICAgIHJldHVybiAwOworCisgICAgQWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdDo6QWNjZXNzaWJp bGl0eUNoaWxkcmVuVmVjdG9yIGNoaWxkcmVuID0gb2JqZWN0LT5jaGlsZHJlbigpOworICAgIC8v IEN1cnJlbnRseSwgb2JqZWN0LT5zdHJpbmdWYWx1ZSgpIHNob3VsZCBiZSBhbiBlbXB0eSBTdHJp bmcuIFRoaXMgbWlnaHQgbm90IGJlIHRoZSBjYXNlIGRvd24gdGhlIHJvYWQuCisgICAgU3RyaW5n IG5hbWUgPSBvYmplY3QtPnN0cmluZ1ZhbHVlKCk7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsg aSA8IGNoaWxkcmVuLnNpemUoKTsgKytpKQorICAgICAgICBuYW1lICs9IGNoaWxkcmVuLmF0KGkp LmdldCgpLT5zdHJpbmdWYWx1ZSgpOworICAgIHJldHVybiByZXR1cm5TdHJpbmcobmFtZSk7Cit9 CisKIHN0YXRpYyBjb25zdCBnY2hhciogd2Via2l0X2FjY2Vzc2libGVfZ2V0X25hbWUoQXRrT2Jq ZWN0KiBvYmplY3QpCiB7CiAgICAgQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCA9IGNv cmUob2JqZWN0KTsKICAgICBpZiAoY29yZU9iamVjdC0+aXNDb250cm9sKCkpIHsKICAgICAgICAg QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCogcmVuZGVyT2JqZWN0ID0gc3RhdGljX2Nhc3Q8QWNj ZXNzaWJpbGl0eVJlbmRlck9iamVjdCo+KGNvcmVPYmplY3QpOwogICAgICAgICBBY2Nlc3NpYmls aXR5T2JqZWN0KiBsYWJlbCA9IHJlbmRlck9iamVjdC0+Y29ycmVzcG9uZGluZ0xhYmVsRm9yQ29u dHJvbEVsZW1lbnQoKTsKLSAgICAgICAgaWYgKGxhYmVsKSB7Ci0gICAgICAgICAgICBBY2Nlc3Np YmlsaXR5UmVuZGVyT2JqZWN0OjpBY2Nlc3NpYmlsaXR5Q2hpbGRyZW5WZWN0b3IgY2hpbGRyZW4g PSBsYWJlbC0+Y2hpbGRyZW4oKTsKLSAgICAgICAgICAgIC8vIEN1cnJlbnRseSwgbGFiZWwtPnN0 cmluZ1ZhbHVlKCkgc2hvdWxkIGJlIGFuIGVtcHR5IFN0cmluZy4gVGhpcwotICAgICAgICAgICAg Ly8gbWlnaHQgbm90IGJlIHRoZSBjYXNlIGRvd24gdGhlIHJvYWQuCi0gICAgICAgICAgICBTdHJp bmcgbmFtZSA9IGxhYmVsLT5zdHJpbmdWYWx1ZSgpOwotICAgICAgICAgICAgZm9yICh1bnNpZ25l ZCBpID0gMDsgaSA8IGNoaWxkcmVuLnNpemUoKTsgKytpKQotICAgICAgICAgICAgICAgIG5hbWUg Kz0gY2hpbGRyZW4uYXQoaSkuZ2V0KCktPnN0cmluZ1ZhbHVlKCk7Ci0gICAgICAgICAgICByZXR1 cm4gcmV0dXJuU3RyaW5nKG5hbWUpOwotICAgICAgICB9CisgICAgICAgIGlmIChsYWJlbCkKKyAg ICAgICAgICAgIHJldHVybiByZXR1cm5TdHJpbmcobmFtZUZyb21DaGlsZHJlbihsYWJlbCkpOwog ICAgIH0KICAgICByZXR1cm4gcmV0dXJuU3RyaW5nKGNvcmVPYmplY3QtPnN0cmluZ1ZhbHVlKCkp OwogfQpAQCAtMTE3OCw2ICsxMTg0LDEzIEBAIHN0YXRpYyBnaW50IHdlYmtpdF9hY2Nlc3NpYmxl X3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0KEF0a1RhYmxlKiB0YWJsZSwgZ2ludCByb3csCiAgICAg cmV0dXJuIDA7CiB9CiAKK3N0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9jb2x1bW5faGVhZGVyKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCBjb2x1bW4pCit7CisgICAg Ly8gRklYTUU6IFRoaXMgbmVlZHMgdG8gYmUgaW1wbGVtZW50ZWQuCisgICAgbm90SW1wbGVtZW50 ZWQoKTsKKyAgICByZXR1cm4gMDsKK30KKwogc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vz c2libGVfdGFibGVfZ2V0X3Jvd19oZWFkZXIoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdykKIHsK ICAgICBBY2Nlc3NpYmlsaXR5T2JqZWN0KiBhY2NUYWJsZSA9IGNvcmUodGFibGUpOwpAQCAtMTIw OSw2ICsxMjIyLDI0IEBAIHN0YXRpYyBBdGtPYmplY3QqIHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9jYXB0aW9uKEF0a1RhYmxlKiB0YWJsZSkKICAgICByZXR1cm4gMDsKIH0KIAorc3RhdGlj IGNvbnN0IGdjaGFyKiB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2Rlc2NyaXB0 aW9uKEF0a1RhYmxlKiB0YWJsZSwgZ2ludCBjb2x1bW4pCit7CisgICAgQXRrT2JqZWN0KiBjb2x1 bW5IZWFkZXIgPSBhdGtfdGFibGVfZ2V0X2NvbHVtbl9oZWFkZXIodGFibGUsIGNvbHVtbik7Cisg ICAgaWYgKGNvbHVtbkhlYWRlcikKKyAgICAgICAgcmV0dXJuIHJldHVyblN0cmluZyhuYW1lRnJv bUNoaWxkcmVuKGNvcmUoY29sdW1uSGVhZGVyKSkpOworCisgICAgcmV0dXJuIDA7Cit9CisKK3N0 YXRpYyBjb25zdCBnY2hhciogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19kZXNjcmlw dGlvbihBdGtUYWJsZSogdGFibGUsIGdpbnQgcm93KQoreworICAgIEF0a09iamVjdCogcm93SGVh ZGVyID0gYXRrX3RhYmxlX2dldF9yb3dfaGVhZGVyKHRhYmxlLCByb3cpOworICAgIGlmIChyb3dI ZWFkZXIpCisgICAgICAgIHJldHVybiByZXR1cm5TdHJpbmcobmFtZUZyb21DaGlsZHJlbihjb3Jl KHJvd0hlYWRlcikpKTsKKworICAgIHJldHVybiAwOworfQorCiBzdGF0aWMgdm9pZCBhdGtfdGFi bGVfaW50ZXJmYWNlX2luaXQoQXRrVGFibGVJZmFjZSogaWZhY2UpCiB7CiAgICAgaWZhY2UtPnJl Zl9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX3JlZl9hdDsKQEAgLTEyMTksOCArMTI1MCwx MSBAQCBzdGF0aWMgdm9pZCBhdGtfdGFibGVfaW50ZXJmYWNlX2luaXQoQXRrVGFibGVJZmFjZSog aWZhY2UpCiAgICAgaWZhY2UtPmdldF9uX3Jvd3MgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9n ZXRfbl9yb3dzOwogICAgIGlmYWNlLT5nZXRfY29sdW1uX2V4dGVudF9hdCA9IHdlYmtpdF9hY2Nl c3NpYmxlX3RhYmxlX2dldF9jb2x1bW5fZXh0ZW50X2F0OwogICAgIGlmYWNlLT5nZXRfcm93X2V4 dGVudF9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9yb3dfZXh0ZW50X2F0OworICAg IGlmYWNlLT5nZXRfY29sdW1uX2hlYWRlciA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9j b2x1bW5faGVhZGVyOwogICAgIGlmYWNlLT5nZXRfcm93X2hlYWRlciA9IHdlYmtpdF9hY2Nlc3Np YmxlX3RhYmxlX2dldF9yb3dfaGVhZGVyOwogICAgIGlmYWNlLT5nZXRfY2FwdGlvbiA9IHdlYmtp dF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0aW9uOworICAgIGlmYWNlLT5nZXRfY29sdW1uX2Rl c2NyaXB0aW9uID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9kZXNjcmlwdGlv bjsKKyAgICBpZmFjZS0+Z2V0X3Jvd19kZXNjcmlwdGlvbiA9IHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9yb3dfZGVzY3JpcHRpb247CiB9CiAKIHN0YXRpYyBjb25zdCBHSW50ZXJmYWNlSW5m byBBdGtJbnRlcmZhY2VzSW5pdEZ1bmN0aW9uc1tdID0gewotLSAKMS42LjMuMwoK 41999 2009-10-27 19:40:30 -0700 2009-10-28 02:56:09 -0700 Table Summary table-summary-1.patch text/plain 2767 jdiggs RnJvbSBkZDY1ZDAzNzQ2NjhmNzQyZjFiYTkyODgzMTk1YTliZjAyOTVlNzg1IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMjI6Mjc6NDUgLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKCkV4cG9zZSB0aGUgdGFi bGUgc3VtbWFyeSBhcyB0aGUgYWNjZXNzaWJsZSBkZXNjcmlwdGlvbiBiZWNhdXNlIHRoZXJlIGlz IG5vIHN1bW1hcnkgb2JqZWN0LgoKKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2Jq ZWN0V3JhcHBlckF0ay5jcHA6Cih3ZWJraXRfYWNjZXNzaWJsZV9nZXRfZGVzY3JpcHRpb24pOgot LS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg ICAxMiArKysrKysrKysrKysKIC4uLi9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsu Y3BwICAgICAgICAgIHwgICAxNiArKysrKysrKysrKysrLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDI1 IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFu Z2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1NGYwMmQ4Li4yNTY5OGVkIDEwMDY0NAot LS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsx LDE1IEBACisyMDA5LTEwLTI3ICBKb2FubWFyaWUgRGlnZ3MgIDxqb2FubWFyaWUuZGlnZ3NAZ21h aWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTUzNAorICAgICAgICBb R1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxkIGltcGxlbWVudCB0aGUgYWNjZXNzaWJs ZSB0YWJsZSBpbnRlcmZhY2UKKworICAgICAgICBFeHBvc2UgdGhlIHRhYmxlIHN1bW1hcnkgYXMg dGhlIGFjY2Vzc2libGUgZGVzY3JpcHRpb24gYmVjYXVzZSB0aGVyZSBpcyBubyBzdW1tYXJ5IG9i amVjdC4KKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RX cmFwcGVyQXRrLmNwcDoKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX2dldF9kZXNjcmlwdGlv bik6CisKIDIwMDktMTAtMjcgIEdlb2ZmcmV5IEdhcmVuICA8Z2dhcmVuQGFwcGxlLmNvbT4KIAog ICAgICAgICBNYWMgYnVpbGQgZml4OiBhIGZvcndhcmRpbmcgaGVhZGVyLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5j cHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVy QXRrLmNwcAppbmRleCAzM2Y5MWE3Li4wMDkzMzRkIDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcAorKysgYi9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcApA QCAtMTUyLDkgKzE1MiwxOSBAQCBzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtpdF9hY2Nlc3NpYmxl X2dldF9uYW1lKEF0a09iamVjdCogb2JqZWN0KQogCiBzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtp dF9hY2Nlc3NpYmxlX2dldF9kZXNjcmlwdGlvbihBdGtPYmplY3QqIG9iamVjdCkKIHsKLSAgICAv LyBUT0RPOiB0aGUgTW96aWxsYSBNU0FBIGltcGxlbWVudGF0aW9uIHByZXBlbmRzICJEZXNjcmlw dGlvbjogIgotICAgIC8vIFNob3VsZCB3ZSBkbyB0aGlzIHRvbz8KLSAgICByZXR1cm4gcmV0dXJu U3RyaW5nKGNvcmUob2JqZWN0KS0+YWNjZXNzaWJpbGl0eURlc2NyaXB0aW9uKCkpOworICAgIEFj Y2Vzc2liaWxpdHlPYmplY3QqIGNvcmVPYmplY3QgPSBjb3JlKG9iamVjdCk7CisKKyAgICAvLyBh dGtfdGFibGVfZ2V0X3N1bW1hcnkgcmV0dXJucyBhbiBBdGtPYmplY3QuIFdlIGhhdmUgbm8gc3Vt bWFyeSBvYmplY3QsIHNvIGV4cG9zZSBzdW1tYXJ5IGhlcmUuCisgICAgaWYgKGNvcmVPYmplY3Qt PnJvbGVWYWx1ZSgpID09IFRhYmxlUm9sZSkgeworICAgICAgICBOb2RlKiBub2RlID0gc3RhdGlj X2Nhc3Q8QWNjZXNzaWJpbGl0eVJlbmRlck9iamVjdCo+KGNvcmVPYmplY3QpLT5yZW5kZXJlcigp LT5ub2RlKCk7CisgICAgICAgIGlmIChub2RlICYmIG5vZGUtPmlzSFRNTEVsZW1lbnQoKSkgewor ICAgICAgICAgICAgU3RyaW5nIHN1bW1hcnkgPSBzdGF0aWNfY2FzdDxIVE1MVGFibGVFbGVtZW50 Kj4obm9kZSktPnN1bW1hcnkoKTsKKyAgICAgICAgICAgIGlmICghc3VtbWFyeS5pc0VtcHR5KCkp CisgICAgICAgICAgICAgICAgcmV0dXJuIHJldHVyblN0cmluZyhzdW1tYXJ5KTsKKyAgICAgICAg fQorICAgIH0KKworICAgIHJldHVybiByZXR1cm5TdHJpbmcoY29yZU9iamVjdC0+YWNjZXNzaWJp bGl0eURlc2NyaXB0aW9uKCkpOwogfQogCiBzdGF0aWMgdm9pZCBzZXRBdGtSZWxhdGlvblNldEZy b21Db3JlT2JqZWN0KEFjY2Vzc2liaWxpdHlPYmplY3QqIGNvcmVPYmplY3QsIEF0a1JlbGF0aW9u U2V0KiByZWxhdGlvblNldCkKLS0gCjEuNi4zLjMKCg== 42001 2009-10-27 21:40:12 -0700 2009-10-28 09:53:49 -0700 Table Summary - with ARIA check table-summary-2.patch text/plain 2817 jdiggs RnJvbSBiODlkMjA3NzQ4NGU2N2RhMGNlNDdkNTYxMmNhNWE1NGFhZTI2MzAxIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFR1ZSwgMjcgT2N0IDIwMDkgMjI6Mjc6NDUgLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKCkV4cG9zZSB0aGUgdGFi bGUgc3VtbWFyeSBhcyB0aGUgYWNjZXNzaWJsZSBkZXNjcmlwdGlvbiBiZWNhdXNlIHRoZXJlIGlz IG5vIHN1bW1hcnkgb2JqZWN0LgoKKiBhY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2Jq ZWN0V3JhcHBlckF0ay5jcHA6Cih3ZWJraXRfYWNjZXNzaWJsZV9nZXRfZGVzY3JpcHRpb24pOgot LS0KIFdlYkNvcmUvQ2hhbmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwg ICAxMiArKysrKysrKysrKysKIC4uLi9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsu Y3BwICAgICAgICAgIHwgICAxNiArKysrKysrKysrKysrLS0tCiAyIGZpbGVzIGNoYW5nZWQsIDI1 IGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9DaGFu Z2VMb2cgYi9XZWJDb3JlL0NoYW5nZUxvZwppbmRleCA1NGYwMmQ4Li4yNTY5OGVkIDEwMDY0NAot LS0gYS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsx LDE1IEBACisyMDA5LTEwLTI3ICBKb2FubWFyaWUgRGlnZ3MgIDxqb2FubWFyaWUuZGlnZ3NAZ21h aWwuY29tPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNTUzNAorICAgICAgICBb R1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxkIGltcGxlbWVudCB0aGUgYWNjZXNzaWJs ZSB0YWJsZSBpbnRlcmZhY2UKKworICAgICAgICBFeHBvc2UgdGhlIHRhYmxlIHN1bW1hcnkgYXMg dGhlIGFjY2Vzc2libGUgZGVzY3JpcHRpb24gYmVjYXVzZSB0aGVyZSBpcyBubyBzdW1tYXJ5IG9i amVjdC4KKworICAgICAgICAqIGFjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RX cmFwcGVyQXRrLmNwcDoKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX2dldF9kZXNjcmlwdGlv bik6CisKIDIwMDktMTAtMjcgIEdlb2ZmcmV5IEdhcmVuICA8Z2dhcmVuQGFwcGxlLmNvbT4KIAog ICAgICAgICBNYWMgYnVpbGQgZml4OiBhIGZvcndhcmRpbmcgaGVhZGVyLgpkaWZmIC0tZ2l0IGEv V2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5j cHAgYi9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVy QXRrLmNwcAppbmRleCAzM2Y5MWE3Li4yNWQ0YzAyIDEwMDY0NAotLS0gYS9XZWJDb3JlL2FjY2Vz c2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcAorKysgYi9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvZ3RrL0FjY2Vzc2liaWxpdHlPYmplY3RXcmFwcGVyQXRrLmNwcApA QCAtMTUyLDkgKzE1MiwxOSBAQCBzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtpdF9hY2Nlc3NpYmxl X2dldF9uYW1lKEF0a09iamVjdCogb2JqZWN0KQogCiBzdGF0aWMgY29uc3QgZ2NoYXIqIHdlYmtp dF9hY2Nlc3NpYmxlX2dldF9kZXNjcmlwdGlvbihBdGtPYmplY3QqIG9iamVjdCkKIHsKLSAgICAv LyBUT0RPOiB0aGUgTW96aWxsYSBNU0FBIGltcGxlbWVudGF0aW9uIHByZXBlbmRzICJEZXNjcmlw dGlvbjogIgotICAgIC8vIFNob3VsZCB3ZSBkbyB0aGlzIHRvbz8KLSAgICByZXR1cm4gcmV0dXJu U3RyaW5nKGNvcmUob2JqZWN0KS0+YWNjZXNzaWJpbGl0eURlc2NyaXB0aW9uKCkpOworICAgIEFj Y2Vzc2liaWxpdHlPYmplY3QqIGNvcmVPYmplY3QgPSBjb3JlKG9iamVjdCk7CisKKyAgICAvLyBh dGtfdGFibGVfZ2V0X3N1bW1hcnkgcmV0dXJucyBhbiBBdGtPYmplY3QuIFdlIGhhdmUgbm8gc3Vt bWFyeSBvYmplY3QsIHNvIGV4cG9zZSBzdW1tYXJ5IGhlcmUuCisgICAgaWYgKGNvcmVPYmplY3Qt PnJvbGVWYWx1ZSgpID09IFRhYmxlUm9sZSAmJiBjb3JlT2JqZWN0LT5hcmlhUm9sZUF0dHJpYnV0 ZSgpID09IFVua25vd25Sb2xlKSB7CisgICAgICAgIE5vZGUqIG5vZGUgPSBzdGF0aWNfY2FzdDxB Y2Nlc3NpYmlsaXR5UmVuZGVyT2JqZWN0Kj4oY29yZU9iamVjdCktPnJlbmRlcmVyKCktPm5vZGUo KTsKKyAgICAgICAgaWYgKG5vZGUgJiYgbm9kZS0+aXNIVE1MRWxlbWVudCgpKSB7CisgICAgICAg ICAgICBTdHJpbmcgc3VtbWFyeSA9IHN0YXRpY19jYXN0PEhUTUxUYWJsZUVsZW1lbnQqPihub2Rl KS0+c3VtbWFyeSgpOworICAgICAgICAgICAgaWYgKCFzdW1tYXJ5LmlzRW1wdHkoKSkKKyAgICAg ICAgICAgICAgICByZXR1cm4gcmV0dXJuU3RyaW5nKHN1bW1hcnkpOworICAgICAgICB9CisgICAg fQorCisgICAgcmV0dXJuIHJldHVyblN0cmluZyhjb3JlT2JqZWN0LT5hY2Nlc3NpYmlsaXR5RGVz Y3JpcHRpb24oKSk7CiB9CiAKIHN0YXRpYyB2b2lkIHNldEF0a1JlbGF0aW9uU2V0RnJvbUNvcmVP YmplY3QoQWNjZXNzaWJpbGl0eU9iamVjdCogY29yZU9iamVjdCwgQXRrUmVsYXRpb25TZXQqIHJl bGF0aW9uU2V0KQotLSAKMS42LjMuMwoK 42083 2009-10-28 23:09:41 -0700 2009-10-30 10:19:48 -0700 Table 2 - Address Jan's comments tables-2-2.patch text/plain 5253 jdiggs RnJvbSA4OWFlZTcwODdlMmRiYTJlZDFjMzM3Yzc3OTM0OTM5MGYyYzkwZTA3IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb2FubWFyaWUgRGlnZ3MgPGpvYW5tYXJpZS5kaWdnc0BnbWFp bC5jb20+CkRhdGU6IFRodSwgMjkgT2N0IDIwMDkgMDA6MzM6MjIgLTA0MDAKU3ViamVjdDogW1BB VENIXSBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KCmh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yNTUzNApbR1RLXSBPYmplY3RzIG9mIFJPTEVfVEFCTEUgc2hvdWxk IGltcGxlbWVudCB0aGUgYWNjZXNzaWJsZSB0YWJsZSBpbnRlcmZhY2UKClNlY29uZCBwYXJ0IG9m IHRoZSBpbXBsZW1lbnRhdGlvbiBvZiBBdGtUYWJsZS4KCiogYWNjZXNzaWJpbGl0eS9ndGsvQWNj ZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwOgooY2VsbEF0SW5kZXgpOgood2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleCk6Cih3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfcm93X2F0X2luZGV4KToKKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jYXB0 aW9uKToKKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6Ci0tLQogV2ViQ29yZS9DaGFuZ2VMb2cg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDE4ICsrKysrKy0KIC4uLi9ndGsv QWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwICAgICAgICAgIHwgICA1MyArKysrKysr KysrKysrKysrKysrKwogMiBmaWxlcyBjaGFuZ2VkLCA3MCBpbnNlcnRpb25zKCspLCAxIGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VM b2cKaW5kZXggMTcyNzA4OS4uOWU2ZmUyZSAxMDA2NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cK KysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxOSBAQAorMjAwOS0xMC0yOSAgSm9h bm1hcmllIERpZ2dzICA8am9hbm1hcmllLmRpZ2dzQGdtYWlsLmNvbT4KKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjU1MzQKKyAgICAgICAgW0dUS10gT2JqZWN0cyBvZiBST0xFX1RB QkxFIHNob3VsZCBpbXBsZW1lbnQgdGhlIGFjY2Vzc2libGUgdGFibGUgaW50ZXJmYWNlCisKKyAg ICAgICAgU2Vjb25kIHBhcnQgb2YgdGhlIGltcGxlbWVudGF0aW9uIG9mIEF0a1RhYmxlLgorCisg ICAgICAgICogYWNjZXNzaWJpbGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsu Y3BwOgorICAgICAgICAoY2VsbEF0SW5kZXgpOgorICAgICAgICAod2Via2l0X2FjY2Vzc2libGVf dGFibGVfZ2V0X2NvbHVtbl9hdF9pbmRleCk6CisgICAgICAgICh3ZWJraXRfYWNjZXNzaWJsZV90 YWJsZV9nZXRfcm93X2F0X2luZGV4KToKKyAgICAgICAgKHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxl X2dldF9jYXB0aW9uKToKKyAgICAgICAgKGF0a190YWJsZV9pbnRlcmZhY2VfaW5pdCk6CisKIDIw MDktMTAtMjcgIENocmlzIEZsZWl6YWNoICA8Y2ZsZWl6YWNoQGFwcGxlLmNvbT4KIAogICAgICAg ICBSZXZpZXdlZCBieSBEYXJpbiBBZGxlci4KZGlmZiAtLWdpdCBhL1dlYkNvcmUvYWNjZXNzaWJp bGl0eS9ndGsvQWNjZXNzaWJpbGl0eU9iamVjdFdyYXBwZXJBdGsuY3BwIGIvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKaW5kZXggYzVm MDlhZS4uNmI1N2Q4NyAxMDA2NDQKLS0tIGEvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2d0ay9BY2Nl c3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKKysrIGIvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L2d0ay9BY2Nlc3NpYmlsaXR5T2JqZWN0V3JhcHBlckF0ay5jcHAKQEAgLTEwOTMsNiArMTA5Mywy MCBAQCBzdGF0aWMgZ2ludCBjZWxsSW5kZXgoQWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxs LCBBY2Nlc3NpYmlsaXR5VGFibGUqIEFYVGFibAogICAgIHJldHVybiBwb3NpdGlvbiAtIGFsbENl bGxzLmJlZ2luKCk7CiB9CiAKK3N0YXRpYyBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBjZWxsQXRJ bmRleChBdGtUYWJsZSogdGFibGUsIGdpbnQgaW5kZXgpCit7CisgICAgQWNjZXNzaWJpbGl0eU9i amVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKKyAgICBpZiAoYWNjVGFibGUtPmlzQWNjZXNz aWJpbGl0eVJlbmRlck9iamVjdCgpKSB7CisgICAgICAgIEFjY2Vzc2liaWxpdHlPYmplY3Q6OkFj Y2Vzc2liaWxpdHlDaGlsZHJlblZlY3RvciBhbGxDZWxsczsKKyAgICAgICAgc3RhdGljX2Nhc3Q8 QWNjZXNzaWJpbGl0eVRhYmxlKj4oYWNjVGFibGUpLT5jZWxscyhhbGxDZWxscyk7CisgICAgICAg IGlmICgwIDw9IGluZGV4ICYmIHN0YXRpY19jYXN0PHVuc2lnbmVkPihpbmRleCkgPCBhbGxDZWxs cy5zaXplKCkpIHsKKyAgICAgICAgICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGFjY0NlbGwgPSBh bGxDZWxscy5hdChpbmRleCkuZ2V0KCk7CisgICAgICAgICAgICByZXR1cm4gc3RhdGljX2Nhc3Q8 QWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCo+KGFjY0NlbGwpOworICAgICAgICB9CisgICAgfQorICAg IHJldHVybiAwOworfQorCiBzdGF0aWMgQXRrT2JqZWN0KiB3ZWJraXRfYWNjZXNzaWJsZV90YWJs ZV9yZWZfYXQoQXRrVGFibGUqIHRhYmxlLCBnaW50IHJvdywgZ2ludCBjb2x1bW4pCiB7CiAgICAg QWNjZXNzaWJpbGl0eVRhYmxlQ2VsbCogQVhDZWxsID0gY2VsbCh0YWJsZSwgcm93LCBjb2x1bW4p OwpAQCAtMTEwOCw2ICsxMTIyLDI4IEBAIHN0YXRpYyBnaW50IHdlYmtpdF9hY2Nlc3NpYmxlX3Rh YmxlX2dldF9pbmRleF9hdChBdGtUYWJsZSogdGFibGUsIGdpbnQgcm93LCBnaW50CiAgICAgcmV0 dXJuIGNlbGxJbmRleChBWENlbGwsIEFYVGFibGUpOwogfQogCitzdGF0aWMgZ2ludCB3ZWJraXRf YWNjZXNzaWJsZV90YWJsZV9nZXRfY29sdW1uX2F0X2luZGV4KEF0a1RhYmxlKiB0YWJsZSwgZ2lu dCBpbmRleCkKK3sKKyAgICBBY2Nlc3NpYmlsaXR5VGFibGVDZWxsKiBheENlbGwgPSBjZWxsQXRJ bmRleCh0YWJsZSwgaW5kZXgpOworICAgIGlmIChheENlbGwpeworICAgICAgICBwYWlyPGludCwg aW50PiBjb2x1bW5SYW5nZTsKKyAgICAgICAgYXhDZWxsLT5jb2x1bW5JbmRleFJhbmdlKGNvbHVt blJhbmdlKTsKKyAgICAgICAgcmV0dXJuIGNvbHVtblJhbmdlLmZpcnN0OworICAgIH0KKyAgICBy ZXR1cm4gLTE7Cit9CisKK3N0YXRpYyBnaW50IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9y b3dfYXRfaW5kZXgoQXRrVGFibGUqIHRhYmxlLCBnaW50IGluZGV4KQoreworICAgIEFjY2Vzc2li aWxpdHlUYWJsZUNlbGwqIGF4Q2VsbCA9IGNlbGxBdEluZGV4KHRhYmxlLCBpbmRleCk7CisgICAg aWYgKGF4Q2VsbCl7CisgICAgICAgIHBhaXI8aW50LCBpbnQ+IHJvd1JhbmdlOworICAgICAgICBh eENlbGwtPnJvd0luZGV4UmFuZ2Uocm93UmFuZ2UpOworICAgICAgICByZXR1cm4gcm93UmFuZ2Uu Zmlyc3Q7CisgICAgfQorICAgIHJldHVybiAtMTsKK30KKwogc3RhdGljIGdpbnQgd2Via2l0X2Fj Y2Vzc2libGVfdGFibGVfZ2V0X25fY29sdW1ucyhBdGtUYWJsZSogdGFibGUpCiB7CiAgICAgQWNj ZXNzaWJpbGl0eU9iamVjdCogYWNjVGFibGUgPSBjb3JlKHRhYmxlKTsKQEAgLTExNjMsMTUgKzEx OTksMzIgQEAgc3RhdGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jv d19oZWFkZXIoQXRrVGFibGUqIHRhYmxlLCBnaW50IHIKICAgICByZXR1cm4gMDsKIH0KIAorc3Rh dGljIEF0a09iamVjdCogd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NhcHRpb24oQXRrVGFi bGUqIHRhYmxlKQoreworICAgIEFjY2Vzc2liaWxpdHlPYmplY3QqIGFjY1RhYmxlID0gY29yZSh0 YWJsZSk7CisgICAgaWYgKGFjY1RhYmxlLT5pc0FjY2Vzc2liaWxpdHlSZW5kZXJPYmplY3QoKSkg eworICAgICAgICBOb2RlKiBub2RlID0gc3RhdGljX2Nhc3Q8QWNjZXNzaWJpbGl0eVJlbmRlck9i amVjdCo+KGFjY1RhYmxlKS0+cmVuZGVyZXIoKS0+bm9kZSgpOworICAgICAgICBpZiAobm9kZSAm JiBub2RlLT5oYXNUYWdOYW1lKEhUTUxOYW1lczo6dGFibGVUYWcpKSB7CisgICAgICAgICAgICBI VE1MVGFibGVDYXB0aW9uRWxlbWVudCogY2FwdGlvbiA9IHN0YXRpY19jYXN0PEhUTUxUYWJsZUVs ZW1lbnQqPihub2RlKS0+Y2FwdGlvbigpOworICAgICAgICAgICAgaWYgKGNhcHRpb24pCisgICAg ICAgICAgICAgICAgcmV0dXJuIEFjY2Vzc2liaWxpdHlPYmplY3Q6OmZpcnN0QWNjZXNzaWJsZU9i amVjdEZyb21Ob2RlKGNhcHRpb24tPnJlbmRlcmVyKCktPm5vZGUoKSktPndyYXBwZXIoKTsKKyAg ICAgICAgfQorICAgIH0KKyAgICByZXR1cm4gMDsKK30KKwogc3RhdGljIHZvaWQgYXRrX3RhYmxl X2ludGVyZmFjZV9pbml0KEF0a1RhYmxlSWZhY2UqIGlmYWNlKQogewogICAgIGlmYWNlLT5yZWZf YXQgPSB3ZWJraXRfYWNjZXNzaWJsZV90YWJsZV9yZWZfYXQ7CiAgICAgaWZhY2UtPmdldF9pbmRl eF9hdCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9pbmRleF9hdDsKKyAgICBpZmFjZS0+ Z2V0X2NvbHVtbl9hdF9pbmRleCA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9jb2x1bW5f YXRfaW5kZXg7CisgICAgaWZhY2UtPmdldF9yb3dfYXRfaW5kZXggPSB3ZWJraXRfYWNjZXNzaWJs ZV90YWJsZV9nZXRfcm93X2F0X2luZGV4OwogICAgIGlmYWNlLT5nZXRfbl9jb2x1bW5zID0gd2Vi a2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X25fY29sdW1uczsKICAgICBpZmFjZS0+Z2V0X25fcm93 cyA9IHdlYmtpdF9hY2Nlc3NpYmxlX3RhYmxlX2dldF9uX3Jvd3M7CiAgICAgaWZhY2UtPmdldF9j b2x1bW5fZXh0ZW50X2F0ID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NvbHVtbl9leHRl bnRfYXQ7CiAgICAgaWZhY2UtPmdldF9yb3dfZXh0ZW50X2F0ID0gd2Via2l0X2FjY2Vzc2libGVf dGFibGVfZ2V0X3Jvd19leHRlbnRfYXQ7CiAgICAgaWZhY2UtPmdldF9yb3dfaGVhZGVyID0gd2Vi a2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X3Jvd19oZWFkZXI7CisgICAgaWZhY2UtPmdldF9jYXB0 aW9uID0gd2Via2l0X2FjY2Vzc2libGVfdGFibGVfZ2V0X2NhcHRpb247CiB9CiAKIHN0YXRpYyBj b25zdCBHSW50ZXJmYWNlSW5mbyBBdGtJbnRlcmZhY2VzSW5pdEZ1bmN0aW9uc1tdID0gewotLSAK MS42LjMuMwoK