3756 2006-09-20 22:50:31 +0000 Pre-canonicalize the testsuite 2006-09-25 22:48:15 +0000 1 1 1 Unclassified XML Query Test Suite XML Query Test Suite unspecified PC Linux RESOLVED WONTFIX P2 enhancement --- 1 per andrew.eisenberg public-qt-comments oldest_to_newest 11896 0 per 2006-09-20 22:50:31 +0000 The following files contains XML or Fragment expected output with xmlns declarations that are *not* in canonical order: (See http://www.w3.org/TR/xml-c14n#DocumentOrder.) fn-union-node-args-015.txt fn-union-node-args-016.txt fn-union-node-args-017.txt fn-intersect-node-args-015.txt fn-intersect-node-args-016.txt fn-except-node-args-017.txt Constr-cont-nsmode-1.xml Constr-inscope-1.xml ('XXX' is lexicographically before 'foo') Constr-inscope-2.xml Constr-inscope-3.xml Constr-inscope-4.xml ns-queries-results-q2.txt ns-queries-results-q3.txt ns-queries-results-q5.txt ns-queries-results-q6.txt ns-queries-results-q7.txt ns-queries-results-q8.txt There may be similar issues with order of attribute nodes; I haven't inspect that yet. 11934 1 mike 2006-09-21 07:46:14 +0000 The spec say that "The test harness must canonicalize both the actual result and the expected result according to the “Canonical XML” recommendation" There's no statement anywhere, AFAIK, that the published results are already canonicalized. 11936 2 frans.englich 2006-09-21 09:13:36 +0000 I believe Michael's comment is right here. None of the XML results are purposefully canonical(although that can be the case for some tests), but require that the implementor do the canonicalization, or use a semantically equivalent method. For example, I load the XML into DOM trees and compare them. Slow, but it works. Therefore, I'm closing this report as invalid. Per, if this resolution is ok, feel free to change status to CLOSED, otherwise re-open the bug. 11943 3 per 2006-09-21 15:49:45 +0000 Ok, I changed the severity to "enhancement". The reason is I sometimes run the testsuite many times an hour. Having to canonicalize the expected output adds an extra processing step which slows down running the testsuite. (Since I haven't yet implemented this extra step I don't know how much.) It would be much more efficient to pre-canonicalize the testsuite. As there doesn't seemt o be that many testsuites that aren't already canonicalized it should be fairly easy to do. (I volunteer to send patches if you'll accept this change in principle.) It makes more sense to change a few test cases rather than run an extra canonicalization step on *each* non-error testcase. 11944 4 frans.englich 2006-09-21 16:11:13 +0000 I think it is a reasonable suggestion, and I wouldn't mind to see it done either, I think. The question is whether it's feasible: How would fragments be handled? Those are messy since c14n tools will choke on non-XML input(I guess). One could wrap them with an element and leave it there but that would require existing drivers to be changed, and also require them to wrap their output in a particular way. Another approach is to try to remove the document element afterwards, but this is all getting messy. As I currently see it, XML fragments are a show stopper for this enhancement. It should probably be implemented as a tool that the task force run on the suite(just like all our other scripts), to ensure maintainability. The smartest thing would probably be to extract the K-* tests into the CVS rep., as suggested by several(including me), otherwise they would pose a problem. But again, in principle the idea is good. Especially since it feels like this test infrastructure will be used for future XQuery extensions. However, there's a general conservatism towards changes in the XQTS(understandably), so I wouldn't expect anything to change any time soon. 11945 5 per 2006-09-21 16:56:06 +0000 (In reply to comment #4) > How would fragments be handled? Those are messy since c14n tools will choke on > non-XML input(I guess). One could wrap them with an element and leave it there > but that would require existing drivers to be changed, and also require them to > wrap their output in a particular way. Another approach is to try to remove the > document element afterwards, but this is all getting messy. As I currently see > it, XML fragments are a show stopper for this enhancement. First, we may not need a tool, if most of the tests are already canonicalized, which they seem to be. The number of mis-ordered namespace declarations that I found is quite modest. Attribute order may be another (unknown) problem. And there may be soem whitespace issues. If the discrepancies are modest, we could just fix them manually. I can certainly submit patches for the namespace-declaration "errors". Secondly, I don't see that handling Fragments shoudl be difficult. Surround the Fragment by some magical header like <xqts-magic-frag-wrapper> ... </xqts-magic-frag-wrapper> before running the canonicalizer. Removing the header afterwards should just be a trivial sed/perl script. Am I missing something? 11946 6 439 per 2006-09-21 19:04:20 +0000 Created attachment 439 sort order of namespace declarations in some test output This "fixes" 6 of the test cases on my list so the namespaces declarations are "canonically" sorted. This improves the number of passing tests for Qexo. 11947 7 per 2006-09-21 19:13:47 +0000 If the previous patch is accepted (which I woukd much appreciate) I'll submit a similar patch for the remaining namespace-declaration-order cases. I did find one rather larger discrepency from canonical output: Most of the results "short-cut" end-tags, which is not allowed by canonical XML. I.e. <foo attributes.../> rather than <foo attributes...></foo>. When I changed my output routine to emit the latter rather than the former, then the number of passes dropped by 174 in my testing. "Fixing" these manually will be somewhat more tedious. Of course the goal isn't necessarily "canonical XML" as it is a well-specified and predictable output format. So "canonical XML but with end-tag abbreviation" is a reasonable option for expected output files, at least as an interim step for XQTS 1.0.x. 11948 8 mike 2006-09-21 22:05:47 +0000 What I do is to first compare my test results with the published results as a simple string compare. Only if that fails do I try to canonicalize. If, as you suggest, most of the results are in canonical form already, this procedure efectively eliminates any performance impact of canonicalization. 11949 9 per 2006-09-22 05:54:47 +0000 (In reply to comment #8) > What I do is to first compare my test results with the published results as a > simple string compare. Only if that fails do I try to canonicalize. If, as you > suggest, most of the results are in canonical form already, this procedure > efectively eliminates any performance impact of canonicalization. That is certainly a practical work-around. But we're talking about a testsuite, and running the testsuite should be as simple and regular as possible, to avoid artifacts and errors in the testsuite and testing framework. The more complicated the comparison is, and the more different ways we try finding a match between expected and actual output, then the greater the risk of errors in the testing framework or otherwise missing actual bugs in the implementation. 11950 10 mike 2006-09-22 08:37:40 +0000 >running the testsuite should be as simple and regular as possible That suggests that it's better for the test suite to use the output format that most processors are likely to generate from their everyday serializers, for example <a/>, rather than the canonicalized form which is <a></a>. But I'm probably influenced by the fact that I chose not to use canonicalization as my comparison method: instead (assuming string comparison fails) I use a customized variant of the deep-equal() function applied to the two node trees. 11961 11 frans.englich 2006-09-22 14:36:33 +0000 If any kind of output normalization is deployed it needs to be done in a verifiable and maintainable way. A patch or two can fix some issues that are found by a particular harness driver at this point, but it doesn't help when bugs are fixed and the test suite is potentially further developed in the future. That's why I mention a tool here, such that the task force can guarantee any promises it gives. So, I doubt patches would be accepted. However, I do think the more general ideas behind this surely has it merits and that it should be considered for further development. My best advice is what Michael said; to do string comparisons and in the cases they fail, fallback to c14n comparison(or functional equivalent). This is only my personal response. The task force will discuss and take action on this report. 12013 12 andrew.eisenberg 2006-09-25 20:12:12 +0000 The Testing TF discussed this at our meeting on Sept. 21 and decline to make this change. In part this is because our decision to have implementors canonicalize the expected result is one that was made a very long time ago and has been found acceptable by many implementors. In part this is also because we are about to "declare victory" when we publish XQTS 1.0.1 (containing bug fixes for reports that we've received over the last several weeks). I suggest that if you want to reduce the cost running the test suite repeatedly, that you first replace our expected results with their canonic representations on your local copy. We may produce some versions of XQTS beyond 1.0.1, but these will likely be few and far between. By the way, we do acknowledge and appreciate the offer of your labor for the change that you suggest. Please close this bug report if you agree with this resolution. 12016 13 per 2006-09-25 21:47:57 +0000 (In reply to comment #12) > In part this is because our decision to have implementors > canonicalize the expected result is one that was made a very long time ago and > has been found acceptable by many implementors. The problem is that this can mroe easily hide errors, thus making the testsuite stricly less powerful. To verify that matches(ACTUAL,EXPECTED) by doing match(canonicalize(ACTAL),canonicalize(EXPECTED)) is doing a stricly less powerful test. A bug in canonicalize can lead to a false positive. Alternatively, if canonicalize "throws away too much information" you can also get false positives. E.g. if someone implements canonicalize by taking the string value of the argument then a test case is more likely to pass even in an implementation fails to emit correct namespace declarations. > In part this is also because we > are about to "declare victory" when we publish XQTS 1.0.1 (containing bug fixes > for reports that we've received over the last several weeks). Yes, I understand the timing issue, and I apologize for not brining this issue up earlier. > > I suggest that if you want to reduce the cost running the test suite > repeatedly, that you first replace our expected results with their canonic > representations on your local copy. I not so concerned about the cost (as Mike Kay said one only needs to do canonicalization for the relatively few tests that aren't canonicalized), but it does reduce the "power" of the testsuite, and its usefulness in avoiding regressions. 12017 14 mike 2006-09-25 22:28:51 +0000 >if someone implements canonicalize by taking the string value of the argument but that wouldn't implement canonicalize. 12018 15 per 2006-09-25 22:48:15 +0000 (In reply to comment #14) > but that wouldn't implement canonicalize. My point is: how could you tell? Unless you had a separate test-suite for canonicalization. Using the string value is an extreme and unlikely case, but some more subtle bug in the canonicalization mechanism could easily mask a real error. You mentioned you use a "customized variant" of deep-equal. A lazy implementor might use deep-equal, without remembering that it doesn't check namespace declarations or element/attribute prefixes or nested comments or nested processing instructions. Plus of course one might want to check that serialization works as expected. using a variant of deep-equal doesn't do that. 439 2006-09-21 19:04:20 +0000 2006-09-21 19:04:20 +0000 sort order of namespace declarations in some test output ns-queries-results.patch text/plain 9616 per SW5kZXg6IC4vRXhwZWN0ZWRUZXN0UmVzdWx0cy9Vc2VDYXNlL1VzZUNhc2VOUy9ucy1xdWVyaWVz LXJlc3VsdHMtcTIudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6IC9zb3VyY2VzL3B1YmxpYy8yMDA2 L3hxdWVyeS10ZXN0LXN1aXRlL1Rlc3RTdWl0ZVN0YWdpbmdBcmVhL0V4cGVjdGVkVGVzdFJlc3Vs dHMvVXNlQ2FzZS9Vc2VDYXNlTlMvbnMtcXVlcmllcy1yZXN1bHRzLXEyLnR4dCx2CnJldHJpZXZp bmcgcmV2aXNpb24gMS4zCmRpZmYgLXIxLjMgbnMtcXVlcmllcy1yZXN1bHRzLXEyLnR4dAoxYzEK PCA8UTI+PHRpdGxlIHhtbG5zPSJodHRwOi8vd3d3LmV4YW1wbGUub3JnL211c2ljL3JlY29yZHMi IHhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxp bms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93 d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDov L3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczp5YWJhZG9vPSJodHRw Oi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iPkluIGEgU2lsZW50IFdheTwv dGl0bGU+PHRpdGxlIHhtbG5zPSJodHRwOi8vd3d3LmV4YW1wbGUub3JnL211c2ljL3JlY29yZHMi IHhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxp bms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93 d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDov L3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczp5YWJhZG9vPSJodHRw Oi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iPlRoaW5rIG9mIE9uZSAuLi48 L3RpdGxlPjwvUTI+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQotLS0KPiA8UTI+PHRpdGxl IHhtbG5zPSJodHRwOi8vd3d3LmV4YW1wbGUub3JnL211c2ljL3JlY29yZHMiIHhtbG5zOmFueXpv bmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFj aGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczpt YT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9BdWN0aW9uV2F0Y2giIHhtbG5zOnhsaW5rPSJodHRw Oi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4bWxuczp5YWJhZG9vPSJodHRwOi8vd3d3LmV4YW1w bGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iPkluIGEgU2lsZW50IFdheTwvdGl0bGU+PHRpdGxl IHhtbG5zPSJodHRwOi8vd3d3LmV4YW1wbGUub3JnL211c2ljL3JlY29yZHMiIHhtbG5zOmFueXpv bmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFj aGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczpt YT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9BdWN0aW9uV2F0Y2giIHhtbG5zOnhsaW5rPSJodHRw Oi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4bWxuczp5YWJhZG9vPSJodHRwOi8vd3d3LmV4YW1w bGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iPlRoaW5rIG9mIE9uZSAuLi48L3RpdGxlPjwvUTI+ ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpJbmRleDogLi9FeHBlY3RlZFRlc3RSZXN1bHRz L1VzZUNhc2UvVXNlQ2FzZU5TL25zLXF1ZXJpZXMtcmVzdWx0cy1xMy50eHQKPT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpS Q1MgZmlsZTogL3NvdXJjZXMvcHVibGljLzIwMDYveHF1ZXJ5LXRlc3Qtc3VpdGUvVGVzdFN1aXRl U3RhZ2luZ0FyZWEvRXhwZWN0ZWRUZXN0UmVzdWx0cy9Vc2VDYXNlL1VzZUNhc2VOUy9ucy1xdWVy aWVzLXJlc3VsdHMtcTMudHh0LHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjMKZGlmZiAtcjEuMyBu cy1xdWVyaWVzLXJlc3VsdHMtcTMudHh0CjFjMQo8IDxRMz48bWE6T3BlbiB4bWxuczpkdD0iaHR0 cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIHhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1w bGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkv eGxpbmsiIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMj YW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVy cyNlYWNoYmF5IiB4bWxuczp5YWJhZG9vPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25l ZXJzI3lhYmFkb28iIGR0OnR5cGU9InRpbWVJbnN0YW50Ij4yMDAwLTAzLTIxOjA3OjQxOjM0LTA1 OjAwPC9tYTpPcGVuPjxtYTpDbG9zZSB4bWxuczpkdD0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9Y TUxTY2hlbWEiIHhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIg eG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOmFueXpvbmU9 Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFjaGJh eT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczp5YWJh ZG9vPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iIGR0OnR5cGU9 InRpbWVJbnN0YW50Ij4yMDAwLTAzLTIzOjA3OjQxOjM0LTA1OjAwPC9tYTpDbG9zZT48bWE6T3Bl biB4bWxuczpkdD0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIHhtbG5zOm1hPSJo dHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0dHA6Ly93 d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5j b20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3dy5leGFtcGxl LmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczp5YWJhZG9vPSJodHRwOi8vd3d3LmV4YW1w bGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iIGR0OnR5cGU9InRpbWVJbnN0YW50Ij4yMDAwLTAz LTE5OjE3OjAzOjAwLTA0OjAwPC9tYTpPcGVuPjxtYTpDbG9zZSB4bWxuczpkdD0iaHR0cDovL3d3 dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIHhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29t L0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsi IHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9u ZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNo YmF5IiB4bWxuczp5YWJhZG9vPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI3lh YmFkb28iIGR0OnR5cGU9InRpbWVJbnN0YW50Ij4yMDAwLTAzLTI5OjE3OjAzOjAwLTA0OjAwPC9t YTpDbG9zZT48L1EzPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKLS0tCj4gPFEzPjxtYTpP cGVuIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55 em9uZSIgeG1sbnM6ZHQ9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hIiB4bWxuczpl YWNoYmF5PSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2VhY2hiYXkiIHhtbG5z Om1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0 dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhh bXBsZS5jb20vYXVjdGlvbmVlcnMjeWFiYWRvbyIgZHQ6dHlwZT0idGltZUluc3RhbnQiPjIwMDAt MDMtMjE6MDc6NDE6MzQtMDU6MDA8L21hOk9wZW4+PG1hOkNsb3NlIHhtbG5zOmFueXpvbmU9Imh0 dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZHQ9Imh0dHA6 Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hIiB4bWxuczplYWNoYmF5PSJodHRwOi8vd3d3LmV4 YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2VhY2hiYXkiIHhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1w bGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkv eGxpbmsiIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMj eWFiYWRvbyIgZHQ6dHlwZT0idGltZUluc3RhbnQiPjIwMDAtMDMtMjM6MDc6NDE6MzQtMDU6MDA8 L21hOkNsb3NlPjxtYTpPcGVuIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20v YXVjdGlvbmVlcnMjYW55em9uZSIgIHhtbG5zOmR0PSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hN TFNjaGVtYSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVy cyNlYWNoYmF5InhtbG5zOm1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIg eG1sbnM6eGxpbms9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOnlhYmFkb289 Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjeWFiYWRvbyIgZHQ6dHlwZT0idGlt ZUluc3RhbnQiPjIwMDAtMDMtMTk6MTc6MDM6MDAtMDQ6MDA8L21hOk9wZW4+PG1hOkNsb3NlIHht bG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIg eG1sbnM6ZHQ9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hIiB4bWxuczplYWNoYmF5 PSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2VhY2hiYXkiIHhtbG5zOm1hPSJo dHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0dHA6Ly93 d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhhbXBsZS5j b20vYXVjdGlvbmVlcnMjeWFiYWRvbyIgZHQ6dHlwZT0idGltZUluc3RhbnQiPjIwMDAtMDMtMjk6 MTc6MDM6MDAtMDQ6MDA8L21hOkNsb3NlPjwvUTM+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmls ZQpJbmRleDogLi9FeHBlY3RlZFRlc3RSZXN1bHRzL1VzZUNhc2UvVXNlQ2FzZU5TL25zLXF1ZXJp ZXMtcmVzdWx0cy1xNS50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogL3NvdXJjZXMvcHVibGljLzIw MDYveHF1ZXJ5LXRlc3Qtc3VpdGUvVGVzdFN1aXRlU3RhZ2luZ0FyZWEvRXhwZWN0ZWRUZXN0UmVz dWx0cy9Vc2VDYXNlL1VzZUNhc2VOUy9ucy1xdWVyaWVzLXJlc3VsdHMtcTUudHh0LHYKcmV0cmll dmluZyByZXZpc2lvbiAxLjUKZGlmZiAtcjEuNSBucy1xdWVyaWVzLXJlc3VsdHMtcTUudHh0CjFj MQo8IDxRNSB4bWxuczptdXNpYz0iaHR0cDovL3d3dy5leGFtcGxlLm9yZy9tdXNpYy9yZWNvcmRz Ij48cmVjb3JkIHhtbG5zPSJodHRwOi8vd3d3LmV4YW1wbGUub3JnL211c2ljL3JlY29yZHMiIHht bG5zOm1hPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9 Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cu ZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3 dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczp5YWJhZG9vPSJodHRwOi8v d3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI3lhYmFkb28iPgotLS0KPiA8UTUgeG1sbnM6bXVz aWM9Imh0dHA6Ly93d3cuZXhhbXBsZS5vcmcvbXVzaWMvcmVjb3JkcyI+PHJlY29yZCB4bWxucz0i aHR0cDovL3d3dy5leGFtcGxlLm9yZy9tdXNpYy9yZWNvcmRzIiB4bWxuczphbnl6b25lPSJodHRw Oi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2FueXpvbmUiIHhtbG5zOmVhY2hiYXk9Imh0 dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjZWFjaGJheSIgeG1sbnM6bWE9Imh0dHA6 Ly93d3cuZXhhbXBsZS5jb20vQXVjdGlvbldhdGNoIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53 My5vcmcvMTk5OS94bGluayIgeG1sbnM6eWFiYWRvbz0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9h dWN0aW9uZWVycyN5YWJhZG9vIj4KSW5kZXg6IC4vRXhwZWN0ZWRUZXN0UmVzdWx0cy9Vc2VDYXNl L1VzZUNhc2VOUy9ucy1xdWVyaWVzLXJlc3VsdHMtcTYudHh0Cj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KUkNTIGZpbGU6 IC9zb3VyY2VzL3B1YmxpYy8yMDA2L3hxdWVyeS10ZXN0LXN1aXRlL1Rlc3RTdWl0ZVN0YWdpbmdB cmVhL0V4cGVjdGVkVGVzdFJlc3VsdHMvVXNlQ2FzZS9Vc2VDYXNlTlMvbnMtcXVlcmllcy1yZXN1 bHRzLXE2LnR4dCx2CnJldHJpZXZpbmcgcmV2aXNpb24gMS4zCmRpZmYgLXIxLjMgbnMtcXVlcmll cy1yZXN1bHRzLXE2LnR4dAoxYzEKPCA8UTYgeG1sbnM6bWE9Imh0dHA6Ly93d3cuZXhhbXBsZS5j b20vQXVjdGlvbldhdGNoIj48bWE6Q2xvc2UgeG1sbnM6ZHQ9Imh0dHA6Ly93d3cudzMub3JnLzIw MDEvWE1MU2NoZW1hIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayIg eG1sbnM6YW55em9uZT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNhbnl6b25l IiB4bWxuczplYWNoYmF5PSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2VhY2hi YXkiIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjeWFi YWRvbyIgZHQ6dHlwZT0idGltZUluc3RhbnQiPjIwMDAtMDMtMjM6MDc6NDE6MzQtMDU6MDA8L21h OkNsb3NlPjwvUTY+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQotLS0KPiA8UTYgeG1sbnM6 bWE9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vQXVjdGlvbldhdGNoIj48bWE6Q2xvc2UgeG1sbnM6 YW55em9uZT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNhbnl6b25lIiB4bWxu czpkdD0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEiIHhtbG5zOmVhY2hiYXk9Imh0 dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjZWFjaGJheSIgeG1sbnM6eGxpbms9Imh0 dHA6Ly93d3cudzMub3JnLzE5OTkveGxpbmsiIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhh bXBsZS5jb20vYXVjdGlvbmVlcnMjeWFiYWRvbyIgZHQ6dHlwZT0idGltZUluc3RhbnQiPjIwMDAt MDMtMjM6MDc6NDE6MzQtMDU6MDA8L21hOkNsb3NlPjwvUTY+ClwgTm8gbmV3bGluZSBhdCBlbmQg b2YgZmlsZQpJbmRleDogLi9FeHBlY3RlZFRlc3RSZXN1bHRzL1VzZUNhc2UvVXNlQ2FzZU5TL25z LXF1ZXJpZXMtcmVzdWx0cy1xNy50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1MgZmlsZTogL3NvdXJjZXMvcHVi bGljLzIwMDYveHF1ZXJ5LXRlc3Qtc3VpdGUvVGVzdFN1aXRlU3RhZ2luZ0FyZWEvRXhwZWN0ZWRU ZXN0UmVzdWx0cy9Vc2VDYXNlL1VzZUNhc2VOUy9ucy1xdWVyaWVzLXJlc3VsdHMtcTcudHh0LHYK cmV0cmlldmluZyByZXZpc2lvbiAxLjQKZGlmZiAtcjEuNCBucy1xdWVyaWVzLXJlc3VsdHMtcTcu dHh0CjFjMQo8IDxRNyB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+ PG1hOkF1Y3Rpb25Ib21lcGFnZSB4bWxuczptYT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9BdWN0 aW9uV2F0Y2giIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVl cnMjYW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9hdWN0aW9u ZWVycyNlYWNoYmF5IiB4bWxuczp5YWJhZG9vPSJodHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rp b25lZXJzI3lhYmFkb28iIHhsaW5rOnR5cGU9InNpbXBsZSIgeGxpbms6aHJlZj0iaHR0cDovL2F1 Y3Rpb25zLnlhYmFkb28uY29tL2F1Y3Rpb24vMTMxNDM4MTYiLz48L1E3PgpcIE5vIG5ld2xpbmUg YXQgZW5kIG9mIGZpbGUKLS0tCj4gPFE3IHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8x OTk5L3hsaW5rIj48bWE6QXVjdGlvbkhvbWVwYWdlIHhtbG5zOmFueXpvbmU9Imh0dHA6Ly93d3cu ZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjYW55em9uZSIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3 dy5leGFtcGxlLmNvbS9hdWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczptYT0iaHR0cDovL3d3dy5l eGFtcGxlLmNvbS9BdWN0aW9uV2F0Y2giIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhhbXBs ZS5jb20vYXVjdGlvbmVlcnMjeWFiYWRvbyIgeGxpbms6dHlwZT0ic2ltcGxlIiB4bGluazpocmVm PSJodHRwOi8vYXVjdGlvbnMueWFiYWRvby5jb20vYXVjdGlvbi8xMzE0MzgxNiIvPjwvUTc+Clwg Tm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpJbmRleDogLi9FeHBlY3RlZFRlc3RSZXN1bHRzL1Vz ZUNhc2UvVXNlQ2FzZU5TL25zLXF1ZXJpZXMtcmVzdWx0cy1xOC50eHQKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQpSQ1Mg ZmlsZTogL3NvdXJjZXMvcHVibGljLzIwMDYveHF1ZXJ5LXRlc3Qtc3VpdGUvVGVzdFN1aXRlU3Rh Z2luZ0FyZWEvRXhwZWN0ZWRUZXN0UmVzdWx0cy9Vc2VDYXNlL1VzZUNhc2VOUy9ucy1xdWVyaWVz LXJlc3VsdHMtcTgudHh0LHYKcmV0cmlldmluZyByZXZpc2lvbiAxLjMKZGlmZiAtcjEuMyBucy1x dWVyaWVzLXJlc3VsdHMtcTgudHh0CjFjMQo8IDxROCB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53 My5vcmcvMTk5OS94bGluayIgeG1sbnM6ZWFjaGJheT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9h dWN0aW9uZWVycyNlYWNoYmF5IiB4bWxuczptYT0iaHR0cDovL3d3dy5leGFtcGxlLmNvbS9BdWN0 aW9uV2F0Y2giPjxtYTpIaWdoX0JpZGRlciB4bWxuczphbnl6b25lPSJodHRwOi8vd3d3LmV4YW1w bGUuY29tL2F1Y3Rpb25lZXJzI2FueXpvbmUiIHhtbG5zOnlhYmFkb289Imh0dHA6Ly93d3cuZXhh bXBsZS5jb20vYXVjdGlvbmVlcnMjeWFiYWRvbyI+Ci0tLQo+IDxROCB4bWxuczplYWNoYmF5PSJo dHRwOi8vd3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2VhY2hiYXkiIHhtbG5zOm1hPSJodHRw Oi8vd3d3LmV4YW1wbGUuY29tL0F1Y3Rpb25XYXRjaCIgeG1sbnM6eGxpbms9Imh0dHA6Ly93d3cu dzMub3JnLzE5OTkveGxpbmsiPjxtYTpIaWdoX0JpZGRlciB4bWxuczphbnl6b25lPSJodHRwOi8v d3d3LmV4YW1wbGUuY29tL2F1Y3Rpb25lZXJzI2FueXpvbmUiIHhtbG5zOnlhYmFkb289Imh0dHA6 Ly93d3cuZXhhbXBsZS5jb20vYXVjdGlvbmVlcnMjeWFiYWRvbyI+Cg==