Received: from malur.postgresql.org ([217.196.149.56]) by arkaria.postgresql.org with esmtp (Exim 4.84_2) (envelope-from ) id 1e9gCc-0007kt-Ai for pgsql-hackers@arkaria.postgresql.org; Tue, 31 Oct 2017 23:44:15 +0000 Received: from localhost ([127.0.0.1] helo=postgresql.org) by malur.postgresql.org with smtp (Exim 4.84_2) (envelope-from ) id 1e9gCb-0008Ob-TH for pgsql-hackers@arkaria.postgresql.org; Tue, 31 Oct 2017 23:44:13 +0000 Received: from makus.postgresql.org ([2001:4800:1501:1::229]) by malur.postgresql.org with esmtps (TLS1.2:ECDHE_RSA_AES_256_CBC_SHA384:256) (Exim 4.84_2) (envelope-from ) id 1e9gCX-0008DV-BX for pgsql-hackers@postgresql.org; Tue, 31 Oct 2017 23:44:09 +0000 Received: from mail.postgrespro.ru ([93.174.131.138]) by makus.postgresql.org with esmtp (Exim 4.84_2) (envelope-from ) id 1e9gCS-0000If-5b for pgsql-hackers@postgresql.org; Tue, 31 Oct 2017 23:44:08 +0000 Received: from localhost (localhost [127.0.0.1]) by mail.postgrespro.ru (Postfix) with ESMTP id 78D87236A002 for ; Wed, 1 Nov 2017 02:44:01 +0300 (MSK) X-Virus-Scanned: Debian amavisd-new at postgrespro.ru Received: from [192.168.1.6] (nat-1-31.msu.umos.ru [85.89.127.31]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (Client did not present a certificate) by mail.postgrespro.ru (Postfix) with ESMTPSA id 3276F21C1E5F for ; Wed, 1 Nov 2017 02:44:01 +0300 (MSK) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=postgrespro.ru; s=mail; t=1509493441; bh=ET7Ez8B7782diYbI0JKtnJ9KKePJ4v6SKpDdlHqsb9I=; h=From:Subject:To:Date; b=Q3ElHD/ftfyYZvB4wz2/sPO6BtCROrOQmlAcdaTfhj7y9197gQ8IVgBDJx0HUwQIW ZNyJ9ITfoYX9eUXRu7CH4X+DK20+2P+I6/Xyw1Id2fSDHtcnWyh4jS1Ybub77davZM eoi90QqMQPQvqH2BgB3YrwJvEfZw+cr1VOtvhbBE= From: Oleg Ivanov Subject: Proposal: generic WAL compression To: pgsql-hackers@postgresql.org Message-ID: <59F90ABF.2060407@postgrespro.ru> Date: Wed, 1 Nov 2017 02:43:59 +0300 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:38.0) Gecko/20100101 Thunderbird/38.5.1 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------000300020108020004010200" List-Archive: List-Help: List-ID: List-Owner: List-Post: List-Subscribe: List-Unsubscribe: X-Mailing-List: pgsql-hackers Precedence: bulk Sender: pgsql-hackers-owner@postgresql.org This is a multi-part message in MIME format. --------------000300020108020004010200 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Hackers, a few years ago generic WAL was proposed by Alexander Korotkov (https://www.postgresql.org/message-id/flat/CAPpHfdsXwZmojm6Dx%2BTJnpYk27kT4o7Ri6X_4OSWcByu1Rm%2BVA%40mail.gmail.com#CAPpHfdsXwZmojm6Dx+TJnpYk27kT4o7Ri6X_4OSWcByu1Rm+VA@mail.gmail.com). and was committed into PostgreSQL 9.6. One of the generic WAL advantages is the common interface for safe interaction with WAL for modules and extensions. The interface allows module to register the page, then change it, and then generic WAL generates and writes into xlog the algorithm of changing the old version of page into the new one. In the case of crash and recovery this algorithm may be applied. Bloom and RUM indexes use generic WAL. The issue is that the generic algorithm of turning the old page into the new one is not optimal in the sense of record size in xlog. Now the main idea of the approach is to find all positions in the page where new version is different from the original one and write these changes into xlog. It works well if the page was rewritten completely or if only a few bytes have been changed. Nevertheless, this approach produces too large WAL record in the case of inserting or deleting a few bytes into the page. In this case there are almost no position where the old version and the new one are equal, so the record size is near the page size, but actual amount of changes in the page is small. This is exactly what happens often in RUM indexes. In order to overcome that issue, I would like to propose the patch, which provides possibility to use another approach of the WAL record construction. If another approach fails to make a short enough record, it rolls back to the original approach. The main idea of another approach is not to perform bytewise comparison of pages, but finding the minimal editing distance between two pages and the corresponding editing algorithm. In the general case, finding editing distance takes O(N^2) time and memory. But there is also an algorithm which requires only O(ND) time and O(D^2) memory, where D is the editing distance between two sequences. Also for given D algorithm may show that the minimal editing distance between two sequences is more than D in the same amount of time and memory. The special case of this algorithm which does not consider replace operations is described in the paper (http://www.xmailserver.org/diff2.pdf). The version of this algorithm which consumes O(ND) time and O(N) memory is used in diff console command, but for our purposes we don't need to increase the constant for the time in order to decrease memory complexity. For RUM indexes we usually have small enough editing distance (less than 64), so D^2 is not too much to store. The results of experiments: +------------------------------+----------------+----------------+----------------+----------------+ | Name | WAL_diff(MB) | WAL_orig(MB) | Time_diff(s) | Time_orig(s) | +------------------------------+----------------+----------------+----------------+----------------+ | rum: make installcheck | 38.9 | 82.5 | 4.37 | 4.16 | +------------------------------+----------------+----------------+----------------+----------------+ | bloom: make installcheck | 1.0 | 1.0 | 0.66 | 0.53 | +------------------------------+----------------+----------------+----------------+----------------+ | test00.sql | 20.5 | 51.0 | 1.86 | 1.41 | +------------------------------+----------------+----------------+----------------+----------------+ | test01.sql | 207.1 | 219.7 | 8.06 | 6.89 | +------------------------------+----------------+----------------+----------------+----------------+ We can see that the patch provides a little slowdown, but compresses generic WAL efficiently for RUM index. Also I'm going to do a few more experiments on this patch with another data. The patch was tested on Lubuntu 14.04, but should not contain any platform-specific items. The patch, the files and scripts for doing the experiments and performance tests are attached. Oleg Ivanov Postgres Professional The Russian PostgreSQL Company --------------000300020108020004010200 Content-Type: text/x-patch; name="generic_xlog_diffdelta_v1.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="generic_xlog_diffdelta_v1.patch" diff --git a/src/backend/access/transam/generic_xlog.c b/src/backend/access/transam/generic_xlog.c index 3adbf7b..cd0ed2a 100644 --- a/src/backend/access/transam/generic_xlog.c +++ b/src/backend/access/transam/generic_xlog.c @@ -43,9 +43,18 @@ * a full page's worth of data. *------------------------------------------------------------------------- */ -#define FRAGMENT_HEADER_SIZE (2 * sizeof(OffsetNumber)) +#define FRAGMENT_HEADER_SIZE (2 * (sizeof(OffsetNumber) + \ + sizeof(char) + sizeof(int))) #define MATCH_THRESHOLD FRAGMENT_HEADER_SIZE -#define MAX_DELTA_SIZE (BLCKSZ + 2 * FRAGMENT_HEADER_SIZE) +#define MAX_DELTA_SIZE (BLCKSZ + 2 * FRAGMENT_HEADER_SIZE) + sizeof(bool) + +#define MAX_ALIGN_MISMATCHES 64 +/* MAX_ALIGN_MISMATCHES is supposed to be not greater than PG_UINT8_MAX */ +#define MIN_DELTA_DIFFERECE 12 +#define ALIGN_GAP 256 + +#define writeToPtr(ptr, x) memcpy(ptr, &(x), sizeof(x)), ptr += sizeof(x) +#define readFromPtr(ptr, x) memcpy(&(x), ptr, sizeof(x)), ptr += sizeof(x) /* Struct of generic xlog data for single page */ typedef struct @@ -71,6 +80,22 @@ struct GenericXLogState bool isLogged; }; +/* Describes for the region which type of delta is used in it */ +typedef enum +{ + DIFF_DELTA, /* diff delta with insert, remove and replace + * operations */ + BASE_DELTA, /* base delta with update operations only */ +} DeltaType; + +/* Diff delta operations for transforming current page to target page */ +typedef enum +{ + DIFF_INSERT, + DIFF_REMOVE, + DIFF_REPLACE, +} DiffDeltaOperations; + static void writeFragment(PageData *pageData, OffsetNumber offset, OffsetNumber len, const char *data); static void computeRegionDelta(PageData *pageData, @@ -80,6 +105,32 @@ static void computeRegionDelta(PageData *pageData, static void computeDelta(PageData *pageData, Page curpage, Page targetpage); static void applyPageRedo(Page page, const char *delta, Size deltaSize); +static int alignRegions(const char *curRegion, const char *targetRegion, + int curRegionLen, int targetRegionLen); + +static bool computeRegionDiffDelta(PageData *pageData, + const char *curpage, const char *targetpage, + int targetStart, int targetEnd, + int validStart, int validEnd); +static const char *applyPageDiffRedo(Page page, const char *delta, Size deltaSize); + +static void computeRegionBaseDelta(PageData *pageData, + const char *curpage, const char *targetpage, + int targetStart, int targetEnd, + int validStart, int validEnd); +static const char *applyPageBaseRedo(Page page, const char *delta, Size deltaSize); + +static bool containsDiffDelta(PageData *pageData); +static void downgradeDeltaToBaseFormat(PageData *pageData); + +/* Arrays for the alignment building and for the resulting alignments */ +static int V[MAX_ALIGN_MISMATCHES + 1][2 * MAX_ALIGN_MISMATCHES + 1]; +static int16 curRegionAligned[BLCKSZ + MAX_ALIGN_MISMATCHES]; +static int16 targetRegionAligned[BLCKSZ + MAX_ALIGN_MISMATCHES]; + +/* Array for diff delta application */ +static char localPage[BLCKSZ]; + /* * Write next fragment into pageData's delta. @@ -95,13 +146,12 @@ writeFragment(PageData *pageData, OffsetNumber offset, OffsetNumber length, /* Verify we have enough space */ Assert(pageData->deltaLen + sizeof(offset) + - sizeof(length) + length <= sizeof(pageData->delta)); + sizeof(length) + length <= MAX_DELTA_SIZE); /* Write fragment data */ - memcpy(ptr, &offset, sizeof(offset)); - ptr += sizeof(offset); - memcpy(ptr, &length, sizeof(length)); - ptr += sizeof(length); + writeToPtr(ptr, offset); + writeToPtr(ptr, length); + memcpy(ptr, data, length); ptr += length; @@ -111,12 +161,13 @@ writeFragment(PageData *pageData, OffsetNumber offset, OffsetNumber length, /* * Compute the XLOG fragments needed to transform a region of curpage into the * corresponding region of targetpage, and append them to pageData's delta - * field. The region to transform runs from targetStart to targetEnd-1. + * field. The region to transform runs from targetStart to targetEnd-1. * Bytes in curpage outside the range validStart to validEnd-1 should be * considered invalid, and always overwritten with target data. * - * This function is a hot spot, so it's worth being as tense as possible - * about the data-matching loops. + * This function tries to build diff delta first and, if it fails, uses + * the base delta. It also provides the header before the delta in which + * the type and the length of the delta are contained. */ static void computeRegionDelta(PageData *pageData, @@ -124,6 +175,60 @@ computeRegionDelta(PageData *pageData, int targetStart, int targetEnd, int validStart, int validEnd) { + int length; + char header; + bool diff; + int prevDeltaLen; + char *ptr = pageData->delta + pageData->deltaLen; + + /* Verify we have enough space */ + Assert(pageData->deltaLen + sizeof(header) + + sizeof(length) <= MAX_DELTA_SIZE); + + pageData->deltaLen += sizeof(header) + sizeof(length); + prevDeltaLen = pageData->deltaLen; + diff = computeRegionDiffDelta(pageData, + curpage, targetpage, + targetStart, targetEnd, + validStart, validEnd); + /* + * If we succeeded to make diff delta, just set the header. + * Otherwise, make base delta. + */ + if (diff) + { + header = DIFF_DELTA; + } + else + { + header = BASE_DELTA; + computeRegionBaseDelta(pageData, + curpage, targetpage, + targetStart, targetEnd, + validStart, validEnd); + } + length = pageData->deltaLen - prevDeltaLen; + + writeToPtr(ptr, header); + writeToPtr(ptr, length); +} + +/* + * Compute the XLOG fragments needed to transform a region of curpage into the + * corresponding region of targetpage, and append them to pageData's delta + * field. The region to transform runs from targetStart to targetEnd-1. + * Bytes in curpage outside the range validStart to validEnd-1 should be + * considered invalid, and always overwritten with target data. + * + * This function is a hot spot, so it's worth being as tense as possible + * about the data-matching loops. + */ +static void +computeRegionBaseDelta(PageData *pageData, + const char *curpage, const char *targetpage, + int targetStart, int targetEnd, + int validStart, int validEnd) +{ int i, loopEnd, fragmentBegin = -1, @@ -222,6 +327,389 @@ computeRegionDelta(PageData *pageData, } /* + * Align curRegion and targetRegion and return the length of the alignment + * or -1 if the alignment with number of mismathing positions less than + * or equal to MAX_ALIGN_MISMATCHES does not exist. + * The alignment is stored in curRegionAligned and targetRegionAligned. + * The algorithm guarantees to find the alignment with the least possible + * number of mismathing positions or return that such least number is greater + * than MAX_ALIGN_MISMATCHES. + * + * The implemented algorithm is a modification of that was described in + * the paper "An O(ND) Difference Algorithm and Its Variations". We chose + * the algorithm which requires O(N + D^2) memory with time complexity O(ND), + * because it is faster than another one which requires O(N + D) memory and + * O(ND) time. The only modification we made is the introduction of REPLACE + * operations, while in the original algorithm only INSERT and REMOVE + * are considered. + */ +static int +alignRegions(const char *curRegion, const char *targetRegion, + int curRegionLen, int targetRegionLen) +{ + /* Number of mismatches */ + int m; + + /* Difference between curRegion and targetRegion prefix lengths */ + int k; + + /* Curbuf and targetRegion prefix lengths */ + int i, + j; + int resLen; + int numMismatches = -1; + + /* + * V is an array to store the values of dynamic programming. The first + * dimension corresponds to m, and the second one is for k + m. + */ + V[0][0] = 0; + + /* Find the longest path with the given number of mismatches */ + for (m = 0; m <= MAX_ALIGN_MISMATCHES; ++m) + { + /* + * Find the largest prefix alignment with the given number of + * mismatches and the given difference between curRegion and + * targetRegion prefix lengths. + */ + for (k = -m; k <= m; ++k) + { + /* Dynamic programming recurrent step */ + if (m > 0) + { + if (k == 0 && m == 1) + i = 1; + else if (k == -m || (k != m && + V[m - 1][m - 1 + k - 1] < V[m - 1][m - 1 + k + 1])) + i = V[m - 1][m - 1 + k + 1]; + else + i = V[m - 1][m - 1 + k - 1] + 1; + if (k != -m && k != m && V[m - 1][m - 1 + k] + 1 > i) + i = V[m - 1][m - 1 + k] + 1; + } + else + i = 0; + j = i - k; + + /* Boundary checks */ + Assert(i >= 0); + Assert(j >= 0); + + /* Increase the prefixes while the bytes are equal */ + while (i < curRegionLen && j < targetRegionLen && + curRegion[i] == targetRegion[j]) + i++, j++; + + /* + * Save the largest curRegion prefix that was aligned with given + * number of mismatches and difference between curRegion and + * targetRegion prefix lengths. + */ + V[m][m + k] = i; + + /* If we find the alignment, save its length and break */ + if (i == curRegionLen && j == targetRegionLen) + { + numMismatches = m; + break; + } + } + /* Break if we find an alignment */ + if (numMismatches != -1) + break; + } + /* No alignment was found */ + if (numMismatches == -1) + return -1; + + /* Restore the reversed alignment */ + resLen = 0; + while (i != 0 || j != 0) + { + /* Check cycle invariants */ + Assert(i >= 0 && j >= 0); + Assert(m >= 0); + Assert(-m <= k && k <= m); + + /* Rollback the equal bytes */ + while (i != 0 && j != 0 && curRegion[i - 1] == targetRegion[j - 1]) + { + curRegionAligned[resLen] = curRegion[--i]; + targetRegionAligned[resLen] = targetRegion[--j]; + resLen++; + } + Assert(i >= 0 && j >= 0); + + /* Break if we reach the start point */ + if (i == 0 && j == 0) + break; + + /* Do the backward dynamic programming step */ + if ((k == 0 && m == 1) || + (k != -m && k != m && V[m - 1][m - 1 + k] + 1 == i)) + { + curRegionAligned[resLen] = curRegion[--i]; + targetRegionAligned[resLen] = targetRegion[--j]; + resLen++; + m -= 1; + } + else if (k == -m || (k != m && + V[m - 1][m - 1 + k - 1] < V[m - 1][m - 1 + k + 1])) + { + curRegionAligned[resLen] = ALIGN_GAP; + targetRegionAligned[resLen] = targetRegion[--j]; + resLen++; + m -= 1, k += 1; + } + else + { + curRegionAligned[resLen] = curRegion[--i]; + targetRegionAligned[resLen] = ALIGN_GAP; + resLen++; + m -= 1, k -= 1; + } + } + Assert(m == 0 && k == 0); + + /* Reverse alignment */ + for (i = 0, j = resLen - 1; i < j; ++i, --j) + { + int16 t; + + t = curRegionAligned[i]; + curRegionAligned[i] = curRegionAligned[j]; + curRegionAligned[j] = t; + t = targetRegionAligned[i]; + targetRegionAligned[i] = targetRegionAligned[j]; + targetRegionAligned[j] = t; + } + + return resLen; +} + +/* + * Try to build a short alignment in order to produce a short diff delta. + * If fails, return false, otherwise return true and write the delta to + * pageData->delta. + * Also return false if the produced alignment is not much better than + * the alignment with DIFF_REPLACE operations only (the minimal difference + * is set in MIN_DELTA_DIFFERECE in order to avoid cases when diff delta + * is larger than base delta because of the greater header size). + */ +static bool +computeRegionDiffDelta(PageData *pageData, + const char *curpage, const char *targetpage, + int targetStart, int targetEnd, + int validStart, int validEnd) +{ + char *ptr = pageData->delta + pageData->deltaLen; + int i, + j; + char type; + char len; + OffsetNumber start; + OffsetNumber tmp; + + int baseAlignmentCost = 0; + int diffAlignmentCost = 0; + int alignmentLength; + + alignmentLength = alignRegions(&curpage[validStart], + &targetpage[targetStart], + validEnd - validStart, + targetEnd - targetStart); + + /* If no proper alignment was found return false */ + if (alignmentLength < 0) + return false; + + /* Compute the cost of found alignment */ + for (i = 0; i < alignmentLength; ++i) + diffAlignmentCost += (curRegionAligned[i] != targetRegionAligned[i]); + + /* + * The following cycle computes the cost of alignment with DIFF_REPLACE + * operations only (similar to as if the previous delta was used). The + * position is match if both regions don't contain it, or if both regions + * contain that position and the bytes on it are equal. Otherwise the + * position is mismatch with cost 1. + */ + for (i = Min(validStart, targetStart); i < validEnd || i < targetEnd; ++i) + baseAlignmentCost += (i < validStart || i < targetStart || + i >= validEnd || i >= targetEnd || + curpage[i] != targetpage[i]); + + /* + * Check whether the found alignment is much better than the one with + * DIFF_PERLACE operations only. + */ + if (baseAlignmentCost - MIN_DELTA_DIFFERECE < diffAlignmentCost) + return false; + + /* + * Translate the alignment into the set of instructions for transformation + * from curRegion into targetRegion, and write these instructions into + * pageData->delta. + */ + + /* Verify we have enough space */ + Assert(pageData->deltaLen + 4 * sizeof(tmp) <= MAX_DELTA_SIZE); + + /* Write start and end indexes of the buffers */ + tmp = validStart; + writeToPtr(ptr, tmp); + tmp = validEnd; + writeToPtr(ptr, tmp); + tmp = targetStart; + writeToPtr(ptr, tmp); + tmp = targetEnd; + writeToPtr(ptr, tmp); + + /* Transform the alignment into the set of instructions */ + start = 0; + for (i = 0; i < alignmentLength; ++i) + { + /* Verify the alignment */ + Assert(curRegionAligned[i] != ALIGN_GAP || + targetRegionAligned[i] != ALIGN_GAP); + + /* If the values are equal, write no instructions */ + if (curRegionAligned[i] == targetRegionAligned[i]) + { + start++; + continue; + } + + if (curRegionAligned[i] == ALIGN_GAP) + type = DIFF_INSERT; + else if (targetRegionAligned[i] == ALIGN_GAP) + type = DIFF_REMOVE; + else + type = DIFF_REPLACE; + + /* Find the end of the block of the same instructions */ + j = i + 1; + while (j < alignmentLength) + { + bool sameType = false; + + switch (type) + { + case DIFF_INSERT: + sameType = (curRegionAligned[j] == ALIGN_GAP); + break; + case DIFF_REMOVE: + sameType = (targetRegionAligned[j] == ALIGN_GAP); + break; + case DIFF_REPLACE: + sameType = (curRegionAligned[j] != ALIGN_GAP && + targetRegionAligned[j] != ALIGN_GAP && + curRegionAligned[j] != targetRegionAligned[j]); + break; + default: + elog(ERROR, "unrecognized delta operation type: %d", type); + break; + } + if (sameType) + j++; + else + break; + } + len = j - i; + + /* Verify we have enough space */ + Assert(pageData->deltaLen + sizeof(type) + + sizeof(len) + sizeof(start) <= MAX_DELTA_SIZE); + /* Write the header for instruction */ + writeToPtr(ptr, type); + writeToPtr(ptr, len); + writeToPtr(ptr, start); + + /* Write instruction data and go to the end of the block */ + if (type != DIFF_REMOVE) + { + /* Verify we have enough space */ + Assert(pageData->deltaLen + len <= MAX_DELTA_SIZE); + while (i < j) + { + char c = targetRegionAligned[i++]; + + writeToPtr(ptr, c); + } + } + else + i = j; + i--; + + /* Shift start position which shows where to apply instruction */ + if (type != DIFF_INSERT) + start += len; + } + + pageData->deltaLen = ptr - pageData->delta; + + return true; +} + +/* + * Return whether pageData->delta contains diff deltas or not. + */ +static bool +containsDiffDelta(PageData *pageData) +{ + char *ptr = pageData->delta + sizeof(bool); + char *end = pageData->delta + pageData->deltaLen; + char header; + int length; + + while (ptr < end) + { + readFromPtr(ptr, header); + readFromPtr(ptr, length); + + if (header == DIFF_DELTA) + return true; + ptr += length; + } + return false; +} + +/* + * Downgrade pageData->delta to base delta format. + * + * Only base diffs are allowed to perform the transformation. + */ +static void +downgradeDeltaToBaseFormat(PageData *pageData) +{ + char *ptr = pageData->delta + sizeof(bool); + char *cur = pageData->delta + sizeof(bool); + char *end = pageData->delta + pageData->deltaLen; + char header; + int length; + int newDeltaLength = 0; + + /* Check whether the first byte is false */ + Assert(!*((bool *) pageData->delta)); + + while (ptr < end) + { + readFromPtr(ptr, header); + readFromPtr(ptr, length); + + /* Check whether the region delta is base delta */ + Assert(header == BASE_DELTA); + newDeltaLength += length; + + memmove(cur, ptr, length); + cur += length; + ptr += length; + } + pageData->deltaLen = newDeltaLength; +} + +/* * Compute the XLOG delta record needed to transform curpage into targetpage, * and store it in pageData's delta field. */ @@ -233,7 +721,7 @@ computeDelta(PageData *pageData, Page curpage, Page targetpage) curLower = ((PageHeader) curpage)->pd_lower, curUpper = ((PageHeader) curpage)->pd_upper; - pageData->deltaLen = 0; + pageData->deltaLen = sizeof(bool); /* Compute delta records for lower part of page ... */ computeRegionDelta(pageData, curpage, targetpage, @@ -245,6 +733,15 @@ computeDelta(PageData *pageData, Page curpage, Page targetpage) curUpper, BLCKSZ); /* + * Set first byte to true if at least one of the region deltas + * is diff delta. Otherwise set first byte to false and downgrade all + * regions to base format without extra headers. + */ + *((bool *) pageData->delta) = containsDiffDelta(pageData); + if (!*((bool *) pageData->delta)) + downgradeDeltaToBaseFormat(pageData); + + /* * If xlog debug is enabled, then check produced delta. Result of delta * application to curpage should be equivalent to targetpage. */ @@ -451,27 +948,145 @@ GenericXLogAbort(GenericXLogState *state) /* * Apply delta to given page image. + * + * Read blocks of instructions and apply them based on their type: + * BASE_DELTA or DIFF_DELTA. */ static void applyPageRedo(Page page, const char *delta, Size deltaSize) { const char *ptr = delta; const char *end = delta + deltaSize; + char header; + int length; + bool diff_delta; + + /* If page delta is base delta, apply it. */ + readFromPtr(ptr, diff_delta); + if (!diff_delta) + { + applyPageBaseRedo(page, ptr, end - ptr); + return; + } + + /* Otherwise apply each region delta. */ + while (ptr < end) + { + readFromPtr(ptr, header); + readFromPtr(ptr, length); + + switch (header) + { + case DIFF_DELTA: + ptr = applyPageDiffRedo(page, ptr, length); + break; + case BASE_DELTA: + ptr = applyPageBaseRedo(page, ptr, length); + break; + default: + elog(ERROR, + "unrecognized delta type: %d", + header); + break; + } + } +} + +/* + * Apply base delta to given page image. + */ +static const char * +applyPageBaseRedo(Page page, const char *delta, Size deltaSize) +{ + const char *ptr = delta; + const char *end = delta + deltaSize; while (ptr < end) { OffsetNumber offset, length; - memcpy(&offset, ptr, sizeof(offset)); - ptr += sizeof(offset); - memcpy(&length, ptr, sizeof(length)); - ptr += sizeof(length); + readFromPtr(ptr, offset); + readFromPtr(ptr, length); memcpy(page + offset, ptr, length); ptr += length; } + return ptr; +} + +/* + * Apply diff delta to given page image. + */ +static const char * +applyPageDiffRedo(Page page, const char *delta, Size deltaSize) +{ + const char *ptr = delta; + const char *end = delta + deltaSize; + OffsetNumber targetStart, + targetEnd; + OffsetNumber validStart, + validEnd; + int i, + j; + OffsetNumber start; + + /* Read start and end indexes of the buffers */ + readFromPtr(ptr, validStart); + readFromPtr(ptr, validEnd); + readFromPtr(ptr, targetStart); + readFromPtr(ptr, targetEnd); + + /* Read and apply the instructions */ + i = 0, j = 0; + while (ptr < end) + { + char type; + char len; + + /* Read the header of the current instruction */ + readFromPtr(ptr, type); + readFromPtr(ptr, len); + readFromPtr(ptr, start); + + /* Copy the data before current instruction to buffer */ + memcpy(&localPage[j], page + validStart + i, start - i); + j += start - i; + i = start; + + /* Apply the instruction */ + switch (type) + { + case DIFF_INSERT: + memcpy(&localPage[j], ptr, len); + ptr += len; + j += len; + break; + case DIFF_REMOVE: + i += len; + break; + case DIFF_REPLACE: + memcpy(&localPage[j], ptr, len); + i += len; + j += len; + ptr += len; + break; + default: + elog(ERROR, + "unrecognized delta instruction type: %d", + type); + break; + } + } + + /* Copy the data after the last instruction */ + memcpy(&localPage[j], page + validStart + i, validEnd - validStart - i); + j += validEnd - validStart - i; + i = validEnd - validStart; + + memcpy(page + targetStart, localPage, j); + return ptr; } /* --------------000300020108020004010200 Content-Type: text/plain; charset=UTF-8; name="postgresql.conf" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="postgresql.conf" IyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojIFBvc3RncmVTUUwg Y29uZmlndXJhdGlvbiBmaWxlCiMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0KIwojIFRoaXMgZmlsZSBjb25zaXN0cyBvZiBsaW5lcyBvZiB0aGUg Zm9ybToKIwojICAgbmFtZSA9IHZhbHVlCiMKIyAoVGhlICI9IiBpcyBvcHRp b25hbC4pICBXaGl0ZXNwYWNlIG1heSBiZSB1c2VkLiAgQ29tbWVudHMgYXJl IGludHJvZHVjZWQgd2l0aAojICIjIiBhbnl3aGVyZSBvbiBhIGxpbmUuICBU aGUgY29tcGxldGUgbGlzdCBvZiBwYXJhbWV0ZXIgbmFtZXMgYW5kIGFsbG93 ZWQKIyB2YWx1ZXMgY2FuIGJlIGZvdW5kIGluIHRoZSBQb3N0Z3JlU1FMIGRv Y3VtZW50YXRpb24uCiMKIyBUaGUgY29tbWVudGVkLW91dCBzZXR0aW5ncyBz aG93biBpbiB0aGlzIGZpbGUgcmVwcmVzZW50IHRoZSBkZWZhdWx0IHZhbHVl cy4KIyBSZS1jb21tZW50aW5nIGEgc2V0dGluZyBpcyBOT1Qgc3VmZmljaWVu dCB0byByZXZlcnQgaXQgdG8gdGhlIGRlZmF1bHQgdmFsdWU7CiMgeW91IG5l ZWQgdG8gcmVsb2FkIHRoZSBzZXJ2ZXIuCiMKIyBUaGlzIGZpbGUgaXMgcmVh ZCBvbiBzZXJ2ZXIgc3RhcnR1cCBhbmQgd2hlbiB0aGUgc2VydmVyIHJlY2Vp dmVzIGEgU0lHSFVQCiMgc2lnbmFsLiAgSWYgeW91IGVkaXQgdGhlIGZpbGUg b24gYSBydW5uaW5nIHN5c3RlbSwgeW91IGhhdmUgdG8gU0lHSFVQIHRoZQoj IHNlcnZlciBmb3IgdGhlIGNoYW5nZXMgdG8gdGFrZSBlZmZlY3QsIHJ1biAi cGdfY3RsIHJlbG9hZCIsIG9yIGV4ZWN1dGUKIyAiU0VMRUNUIHBnX3JlbG9h ZF9jb25mKCkiLiAgU29tZSBwYXJhbWV0ZXJzLCB3aGljaCBhcmUgbWFya2Vk IGJlbG93LAojIHJlcXVpcmUgYSBzZXJ2ZXIgc2h1dGRvd24gYW5kIHJlc3Rh cnQgdG8gdGFrZSBlZmZlY3QuCiMKIyBBbnkgcGFyYW1ldGVyIGNhbiBhbHNv IGJlIGdpdmVuIGFzIGEgY29tbWFuZC1saW5lIG9wdGlvbiB0byB0aGUgc2Vy dmVyLCBlLmcuLAojICJwb3N0Z3JlcyAtYyBsb2dfY29ubmVjdGlvbnM9b24i LiAgU29tZSBwYXJhbWV0ZXJzIGNhbiBiZSBjaGFuZ2VkIGF0IHJ1biB0aW1l CiMgd2l0aCB0aGUgIlNFVCIgU1FMIGNvbW1hbmQuCiMKIyBNZW1vcnkgdW5p dHM6ICBrQiA9IGtpbG9ieXRlcyAgICAgICAgVGltZSB1bml0czogIG1zICA9 IG1pbGxpc2Vjb25kcwojICAgICAgICAgICAgICAgIE1CID0gbWVnYWJ5dGVz ICAgICAgICAgICAgICAgICAgICAgcyAgID0gc2Vjb25kcwojICAgICAgICAg ICAgICAgIEdCID0gZ2lnYWJ5dGVzICAgICAgICAgICAgICAgICAgICAgbWlu ID0gbWludXRlcwojICAgICAgICAgICAgICAgIFRCID0gdGVyYWJ5dGVzICAg ICAgICAgICAgICAgICAgICAgaCAgID0gaG91cnMKIyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGQgICA9IGRh eXMKCgojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiMgRklM RSBMT0NBVElPTlMKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQoKIyBUaGUgZGVmYXVsdCB2YWx1ZXMgb2YgdGhlc2UgdmFyaWFibGVzIGFy ZSBkcml2ZW4gZnJvbSB0aGUgLUQgY29tbWFuZC1saW5lCiMgb3B0aW9uIG9y IFBHREFUQSBlbnZpcm9ubWVudCB2YXJpYWJsZSwgcmVwcmVzZW50ZWQgaGVy ZSBhcyBDb25maWdEaXIuCgojZGF0YV9kaXJlY3RvcnkgPSAnQ29uZmlnRGly JwkJIyB1c2UgZGF0YSBpbiBhbm90aGVyIGRpcmVjdG9yeQoJCQkJCSMgKGNo YW5nZSByZXF1aXJlcyByZXN0YXJ0KQojaGJhX2ZpbGUgPSAnQ29uZmlnRGly L3BnX2hiYS5jb25mJwkjIGhvc3QtYmFzZWQgYXV0aGVudGljYXRpb24gZmls ZQoJCQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQojaWRlbnRfZmls ZSA9ICdDb25maWdEaXIvcGdfaWRlbnQuY29uZicJIyBpZGVudCBjb25maWd1 cmF0aW9uIGZpbGUKCQkJCQkjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkK CiMgSWYgZXh0ZXJuYWxfcGlkX2ZpbGUgaXMgbm90IGV4cGxpY2l0bHkgc2V0 LCBubyBleHRyYSBQSUQgZmlsZSBpcyB3cml0dGVuLgojZXh0ZXJuYWxfcGlk X2ZpbGUgPSAnJwkJCSMgd3JpdGUgYW4gZXh0cmEgUElEIGZpbGUKCQkJCQkj IChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKCgojLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tCiMgQ09OTkVDVElPTlMgQU5EIEFVVEhFTlRJ Q0FUSU9OCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCiMg LSBDb25uZWN0aW9uIFNldHRpbmdzIC0KCiNsaXN0ZW5fYWRkcmVzc2VzID0g J2xvY2FsaG9zdCcJCSMgd2hhdCBJUCBhZGRyZXNzKGVzKSB0byBsaXN0ZW4g b247CgkJCQkJIyBjb21tYS1zZXBhcmF0ZWQgbGlzdCBvZiBhZGRyZXNzZXM7 CgkJCQkJIyBkZWZhdWx0cyB0byAnbG9jYWxob3N0JzsgdXNlICcqJyBmb3Ig YWxsCgkJCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpCiNwb3J0ID0g NTg0NQkJCQkjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKbWF4X2Nvbm5l Y3Rpb25zID0gMTAwCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpCiNz dXBlcnVzZXJfcmVzZXJ2ZWRfY29ubmVjdGlvbnMgPSAzCSMgKGNoYW5nZSBy ZXF1aXJlcyByZXN0YXJ0KQojdW5peF9zb2NrZXRfZGlyZWN0b3JpZXMgPSAn L3RtcCcJIyBjb21tYS1zZXBhcmF0ZWQgbGlzdCBvZiBkaXJlY3RvcmllcwoJ CQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQojdW5peF9zb2NrZXRf Z3JvdXAgPSAnJwkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQojdW5p eF9zb2NrZXRfcGVybWlzc2lvbnMgPSAwNzc3CQkjIGJlZ2luIHdpdGggMCB0 byB1c2Ugb2N0YWwgbm90YXRpb24KCQkJCQkjIChjaGFuZ2UgcmVxdWlyZXMg cmVzdGFydCkKI2JvbmpvdXIgPSBvZmYJCQkJIyBhZHZlcnRpc2Ugc2VydmVy IHZpYSBCb25qb3VyCgkJCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQp CiNib25qb3VyX25hbWUgPSAnJwkJCSMgZGVmYXVsdHMgdG8gdGhlIGNvbXB1 dGVyIG5hbWUKCQkJCQkjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKCiMg LSBTZWN1cml0eSBhbmQgQXV0aGVudGljYXRpb24gLQoKI2F1dGhlbnRpY2F0 aW9uX3RpbWVvdXQgPSAxbWluCQkjIDFzLTYwMHMKI3NzbCA9IG9mZgojc3Ns X2NpcGhlcnMgPSAnSElHSDpNRURJVU06KzNERVM6IWFOVUxMJyAjIGFsbG93 ZWQgU1NMIGNpcGhlcnMKI3NzbF9wcmVmZXJfc2VydmVyX2NpcGhlcnMgPSBv bgojc3NsX2VjZGhfY3VydmUgPSAncHJpbWUyNTZ2MScKI3NzbF9kaF9wYXJh bXNfZmlsZSA9ICcnCiNzc2xfY2VydF9maWxlID0gJ3NlcnZlci5jcnQnCiNz c2xfa2V5X2ZpbGUgPSAnc2VydmVyLmtleScKI3NzbF9jYV9maWxlID0gJycK I3NzbF9jcmxfZmlsZSA9ICcnCiNwYXNzd29yZF9lbmNyeXB0aW9uID0gbWQ1 CQkjIG1kNSBvciBzY3JhbS1zaGEtMjU2CiNkYl91c2VyX25hbWVzcGFjZSA9 IG9mZgojcm93X3NlY3VyaXR5ID0gb24KCiMgR1NTQVBJIHVzaW5nIEtlcmJl cm9zCiNrcmJfc2VydmVyX2tleWZpbGUgPSAnJwoja3JiX2Nhc2VpbnNfdXNl cnMgPSBvZmYKCiMgLSBUQ1AgS2VlcGFsaXZlcyAtCiMgc2VlICJtYW4gNyB0 Y3AiIGZvciBkZXRhaWxzCgojdGNwX2tlZXBhbGl2ZXNfaWRsZSA9IDAJCSMg VENQX0tFRVBJRExFLCBpbiBzZWNvbmRzOwoJCQkJCSMgMCBzZWxlY3RzIHRo ZSBzeXN0ZW0gZGVmYXVsdAojdGNwX2tlZXBhbGl2ZXNfaW50ZXJ2YWwgPSAw CQkjIFRDUF9LRUVQSU5UVkwsIGluIHNlY29uZHM7CgkJCQkJIyAwIHNlbGVj dHMgdGhlIHN5c3RlbSBkZWZhdWx0CiN0Y3Bfa2VlcGFsaXZlc19jb3VudCA9 IDAJCSMgVENQX0tFRVBDTlQ7CgkJCQkJIyAwIHNlbGVjdHMgdGhlIHN5c3Rl bSBkZWZhdWx0CgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQojIFJFU09VUkNFIFVTQUdFIChleGNlcHQgV0FMKQojLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCgojIC0gTWVtb3J5IC0KCnNoYXJlZF9i dWZmZXJzID0gMTAyNE1CCQkJIyBtaW4gMTI4a0IKCQkJCQkjIChjaGFuZ2Ug cmVxdWlyZXMgcmVzdGFydCkKI2h1Z2VfcGFnZXMgPSB0cnkJCQkjIG9uLCBv ZmYsIG9yIHRyeQoJCQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQoj dGVtcF9idWZmZXJzID0gOE1CCQkJIyBtaW4gODAwa0IKI21heF9wcmVwYXJl ZF90cmFuc2FjdGlvbnMgPSAwCQkjIHplcm8gZGlzYWJsZXMgdGhlIGZlYXR1 cmUKCQkJCQkjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKIyBDYXV0aW9u OiBpdCBpcyBub3QgYWR2aXNhYmxlIHRvIHNldCBtYXhfcHJlcGFyZWRfdHJh bnNhY3Rpb25zIG5vbnplcm8gdW5sZXNzCiMgeW91IGFjdGl2ZWx5IGludGVu ZCB0byB1c2UgcHJlcGFyZWQgdHJhbnNhY3Rpb25zLgojd29ya19tZW0gPSA0 TUIJCQkJIyBtaW4gNjRrQgojbWFpbnRlbmFuY2Vfd29ya19tZW0gPSA2NE1C CQkjIG1pbiAxTUIKI3JlcGxhY2VtZW50X3NvcnRfdHVwbGVzID0gMTUwMDAw CSMgbGltaXRzIHVzZSBvZiByZXBsYWNlbWVudCBzZWxlY3Rpb24gc29ydAoj YXV0b3ZhY3V1bV93b3JrX21lbSA9IC0xCQkjIG1pbiAxTUIsIG9yIC0xIHRv IHVzZSBtYWludGVuYW5jZV93b3JrX21lbQojbWF4X3N0YWNrX2RlcHRoID0g Mk1CCQkJIyBtaW4gMTAwa0IKZHluYW1pY19zaGFyZWRfbWVtb3J5X3R5cGUg PSBwb3NpeAkjIHRoZSBkZWZhdWx0IGlzIHRoZSBmaXJzdCBvcHRpb24KCQkJ CQkjIHN1cHBvcnRlZCBieSB0aGUgb3BlcmF0aW5nIHN5c3RlbToKCQkJCQkj ICAgcG9zaXgKCQkJCQkjICAgc3lzdgoJCQkJCSMgICB3aW5kb3dzCgkJCQkJ IyAgIG1tYXAKCQkJCQkjIHVzZSBub25lIHRvIGRpc2FibGUgZHluYW1pYyBz aGFyZWQgbWVtb3J5CgkJCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQp CgojIC0gRGlzayAtCgojdGVtcF9maWxlX2xpbWl0ID0gLTEJCQkjIGxpbWl0 cyBwZXItcHJvY2VzcyB0ZW1wIGZpbGUgc3BhY2UKCQkJCQkjIGluIGtCLCBv ciAtMSBmb3Igbm8gbGltaXQKCiMgLSBLZXJuZWwgUmVzb3VyY2UgVXNhZ2Ug LQoKI21heF9maWxlc19wZXJfcHJvY2VzcyA9IDEwMDAJCSMgbWluIDI1CgkJ CQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpCiNzaGFyZWRfcHJlbG9h ZF9saWJyYXJpZXMgPSAnJwkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQp CgojIC0gQ29zdC1CYXNlZCBWYWN1dW0gRGVsYXkgLQoKI3ZhY3V1bV9jb3N0 X2RlbGF5ID0gMAkJCSMgMC0xMDAgbWlsbGlzZWNvbmRzCiN2YWN1dW1fY29z dF9wYWdlX2hpdCA9IDEJCSMgMC0xMDAwMCBjcmVkaXRzCiN2YWN1dW1fY29z dF9wYWdlX21pc3MgPSAxMAkJIyAwLTEwMDAwIGNyZWRpdHMKI3ZhY3V1bV9j b3N0X3BhZ2VfZGlydHkgPSAyMAkJIyAwLTEwMDAwIGNyZWRpdHMKI3ZhY3V1 bV9jb3N0X2xpbWl0ID0gMjAwCQkjIDEtMTAwMDAgY3JlZGl0cwoKIyAtIEJh Y2tncm91bmQgV3JpdGVyIC0KCmJnd3JpdGVyX2RlbGF5ID0gMjBtcwkJCSMg MTAtMTAwMDBtcyBiZXR3ZWVuIHJvdW5kcwpiZ3dyaXRlcl9scnVfbWF4cGFn ZXMgPSA4MDAJCSMgMC0xMDAwIG1heCBidWZmZXJzIHdyaXR0ZW4vcm91bmQK Ymd3cml0ZXJfbHJ1X211bHRpcGxpZXIgPSA4LjAJCSMgMC0xMC4wIG11bHRp cGxpZXIgb24gYnVmZmVycyBzY2FubmVkL3JvdW5kCiNiZ3dyaXRlcl9mbHVz aF9hZnRlciA9IDUxMmtCCQkjIG1lYXN1cmVkIGluIHBhZ2VzLCAwIGRpc2Fi bGVzCgojIC0gQXN5bmNocm9ub3VzIEJlaGF2aW9yIC0KCiNlZmZlY3RpdmVf aW9fY29uY3VycmVuY3kgPSAxCQkjIDEtMTAwMDsgMCBkaXNhYmxlcyBwcmVm ZXRjaGluZwojbWF4X3dvcmtlcl9wcm9jZXNzZXMgPSA4CQkjIChjaGFuZ2Ug cmVxdWlyZXMgcmVzdGFydCkKI21heF9wYXJhbGxlbF93b3JrZXJzX3Blcl9n YXRoZXIgPSAyCSMgdGFrZW4gZnJvbSBtYXhfcGFyYWxsZWxfd29ya2Vycwoj bWF4X3BhcmFsbGVsX3dvcmtlcnMgPSA4CQkjIG1heGltdW0gbnVtYmVyIG9m IG1heF93b3JrZXJfcHJvY2Vzc2VzIHRoYXQKCQkJCQkjIGNhbiBiZSB1c2Vk IGluIHBhcmFsbGVsIHF1ZXJpZXMKI29sZF9zbmFwc2hvdF90aHJlc2hvbGQg PSAtMQkJIyAxbWluLTYwZDsgLTEgZGlzYWJsZXM7IDAgaXMgaW1tZWRpYXRl CgkJCQkJIyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpCiNiYWNrZW5kX2Zs dXNoX2FmdGVyID0gMAkJIyBtZWFzdXJlZCBpbiBwYWdlcywgMCBkaXNhYmxl cwoKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBXUklU RSBBSEVBRCBMT0cKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LQoKIyAtIFNldHRpbmdzIC0KCndhbF9sZXZlbCA9IG1pbmltYWwJCQkjIG1p bmltYWwsIHJlcGxpY2EsIG9yIGxvZ2ljYWwKCQkJCQkjIChjaGFuZ2UgcmVx dWlyZXMgcmVzdGFydCkKZnN5bmMgPSBvZmYJCQkJIyBmbHVzaCBkYXRhIHRv IGRpc2sgZm9yIGNyYXNoIHNhZmV0eQoJCQkJCSMgKHR1cm5pbmcgdGhpcyBv ZmYgY2FuIGNhdXNlCgkJCQkJIyB1bnJlY292ZXJhYmxlIGRhdGEgY29ycnVw dGlvbikKc3luY2hyb25vdXNfY29tbWl0ID0gb2ZmCQkjIHN5bmNocm9uaXph dGlvbiBsZXZlbDsKCQkJCQkjIG9mZiwgbG9jYWwsIHJlbW90ZV93cml0ZSwg cmVtb3RlX2FwcGx5LCBvciBvbgojd2FsX3N5bmNfbWV0aG9kID0gZnN5bmMJ CSMgdGhlIGRlZmF1bHQgaXMgdGhlIGZpcnN0IG9wdGlvbgoJCQkJCSMgc3Vw cG9ydGVkIGJ5IHRoZSBvcGVyYXRpbmcgc3lzdGVtOgoJCQkJCSMgICBvcGVu X2RhdGFzeW5jCgkJCQkJIyAgIGZkYXRhc3luYyAoZGVmYXVsdCBvbiBMaW51 eCkKCQkJCQkjICAgZnN5bmMKCQkJCQkjICAgZnN5bmNfd3JpdGV0aHJvdWdo CgkJCQkJIyAgIG9wZW5fc3luYwpmdWxsX3BhZ2Vfd3JpdGVzID0gb2ZmCQkJ IyByZWNvdmVyIGZyb20gcGFydGlhbCBwYWdlIHdyaXRlcwojd2FsX2NvbXBy ZXNzaW9uID0gb2ZmCQkJIyBlbmFibGUgY29tcHJlc3Npb24gb2YgZnVsbC1w YWdlIHdyaXRlcwojd2FsX2xvZ19oaW50cyA9IG9mZgkJCSMgYWxzbyBkbyBm dWxsIHBhZ2Ugd3JpdGVzIG9mIG5vbi1jcml0aWNhbCB1cGRhdGVzCgkJCQkJ IyAoY2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpCiN3YWxfYnVmZmVycyA9IC0x CQkJIyBtaW4gMzJrQiwgLTEgc2V0cyBiYXNlZCBvbiBzaGFyZWRfYnVmZmVy cwoJCQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQojd2FsX3dyaXRl cl9kZWxheSA9IDIwMG1zCQkjIDEtMTAwMDAgbWlsbGlzZWNvbmRzCiN3YWxf d3JpdGVyX2ZsdXNoX2FmdGVyID0gMU1CCQkjIG1lYXN1cmVkIGluIHBhZ2Vz LCAwIGRpc2FibGVzCgojY29tbWl0X2RlbGF5ID0gMAkJCSMgcmFuZ2UgMC0x MDAwMDAsIGluIG1pY3Jvc2Vjb25kcwojY29tbWl0X3NpYmxpbmdzID0gNQkJ CSMgcmFuZ2UgMS0xMDAwCgojIC0gQ2hlY2twb2ludHMgLQoKY2hlY2twb2lu dF90aW1lb3V0ID0gMTIwbWluCQkjIHJhbmdlIDMwcy0xZAptYXhfd2FsX3Np emUgPSA4R0IKbWluX3dhbF9zaXplID0gMUdCCiNjaGVja3BvaW50X2NvbXBs ZXRpb25fdGFyZ2V0ID0gMC41CSMgY2hlY2twb2ludCB0YXJnZXQgZHVyYXRp b24sIDAuMCAtIDEuMAojY2hlY2twb2ludF9mbHVzaF9hZnRlciA9IDI1NmtC CQkjIG1lYXN1cmVkIGluIHBhZ2VzLCAwIGRpc2FibGVzCiNjaGVja3BvaW50 X3dhcm5pbmcgPSAzMHMJCSMgMCBkaXNhYmxlcwoKIyAtIEFyY2hpdmluZyAt CgojYXJjaGl2ZV9tb2RlID0gb2ZmCQkjIGVuYWJsZXMgYXJjaGl2aW5nOyBv ZmYsIG9uLCBvciBhbHdheXMKCQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0 YXJ0KQojYXJjaGl2ZV9jb21tYW5kID0gJycJCSMgY29tbWFuZCB0byB1c2Ug dG8gYXJjaGl2ZSBhIGxvZ2ZpbGUgc2VnbWVudAoJCQkJIyBwbGFjZWhvbGRl cnM6ICVwID0gcGF0aCBvZiBmaWxlIHRvIGFyY2hpdmUKCQkJCSMgICAgICAg ICAgICAgICAlZiA9IGZpbGUgbmFtZSBvbmx5CgkJCQkjIGUuZy4gJ3Rlc3Qg ISAtZiAvbW50L3NlcnZlci9hcmNoaXZlZGlyLyVmICYmIGNwICVwIC9tbnQv c2VydmVyL2FyY2hpdmVkaXIvJWYnCiNhcmNoaXZlX3RpbWVvdXQgPSAwCQkj IGZvcmNlIGEgbG9nZmlsZSBzZWdtZW50IHN3aXRjaCBhZnRlciB0aGlzCgkJ CQkjIG51bWJlciBvZiBzZWNvbmRzOyAwIGRpc2FibGVzCgoKIy0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojIFJFUExJQ0FUSU9OCiMtLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCiMgLSBTZW5kaW5nIFNl cnZlcihzKSAtCgojIFNldCB0aGVzZSBvbiB0aGUgbWFzdGVyIGFuZCBvbiBh bnkgc3RhbmRieSB0aGF0IHdpbGwgc2VuZCByZXBsaWNhdGlvbiBkYXRhLgoK bWF4X3dhbF9zZW5kZXJzID0gMAkJIyBtYXggbnVtYmVyIG9mIHdhbHNlbmRl ciBwcm9jZXNzZXMKCQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQoj d2FsX2tlZXBfc2VnbWVudHMgPSAwCQkjIGluIGxvZ2ZpbGUgc2VnbWVudHMs IDE2TUIgZWFjaDsgMCBkaXNhYmxlcwojd2FsX3NlbmRlcl90aW1lb3V0ID0g NjBzCSMgaW4gbWlsbGlzZWNvbmRzOyAwIGRpc2FibGVzCgojbWF4X3JlcGxp Y2F0aW9uX3Nsb3RzID0gMTAJIyBtYXggbnVtYmVyIG9mIHJlcGxpY2F0aW9u IHNsb3RzCgkJCQkjIChjaGFuZ2UgcmVxdWlyZXMgcmVzdGFydCkKI3RyYWNr X2NvbW1pdF90aW1lc3RhbXAgPSBvZmYJIyBjb2xsZWN0IHRpbWVzdGFtcCBv ZiB0cmFuc2FjdGlvbiBjb21taXQKCQkJCSMgKGNoYW5nZSByZXF1aXJlcyBy ZXN0YXJ0KQoKIyAtIE1hc3RlciBTZXJ2ZXIgLQoKIyBUaGVzZSBzZXR0aW5n cyBhcmUgaWdub3JlZCBvbiBhIHN0YW5kYnkgc2VydmVyLgoKI3N5bmNocm9u b3VzX3N0YW5kYnlfbmFtZXMgPSAnJwkjIHN0YW5kYnkgc2VydmVycyB0aGF0 IHByb3ZpZGUgc3luYyByZXAKCQkJCSMgbWV0aG9kIHRvIGNob29zZSBzeW5j IHN0YW5kYnlzLCBudW1iZXIgb2Ygc3luYyBzdGFuZGJ5cywKCQkJCSMgYW5k IGNvbW1hLXNlcGFyYXRlZCBsaXN0IG9mIGFwcGxpY2F0aW9uX25hbWUKCQkJ CSMgZnJvbSBzdGFuZGJ5KHMpOyAnKicgPSBhbGwKI3ZhY3V1bV9kZWZlcl9j bGVhbnVwX2FnZSA9IDAJIyBudW1iZXIgb2YgeGFjdHMgYnkgd2hpY2ggY2xl YW51cCBpcyBkZWxheWVkCgojIC0gU3RhbmRieSBTZXJ2ZXJzIC0KCiMgVGhl c2Ugc2V0dGluZ3MgYXJlIGlnbm9yZWQgb24gYSBtYXN0ZXIgc2VydmVyLgoK I2hvdF9zdGFuZGJ5ID0gb24JCQkjICJvZmYiIGRpc2FsbG93cyBxdWVyaWVz IGR1cmluZyByZWNvdmVyeQoJCQkJCSMgKGNoYW5nZSByZXF1aXJlcyByZXN0 YXJ0KQojbWF4X3N0YW5kYnlfYXJjaGl2ZV9kZWxheSA9IDMwcwkjIG1heCBk ZWxheSBiZWZvcmUgY2FuY2VsaW5nIHF1ZXJpZXMKCQkJCQkjIHdoZW4gcmVh ZGluZyBXQUwgZnJvbSBhcmNoaXZlOwoJCQkJCSMgLTEgYWxsb3dzIGluZGVm aW5pdGUgZGVsYXkKI21heF9zdGFuZGJ5X3N0cmVhbWluZ19kZWxheSA9IDMw cwkjIG1heCBkZWxheSBiZWZvcmUgY2FuY2VsaW5nIHF1ZXJpZXMKCQkJCQkj IHdoZW4gcmVhZGluZyBzdHJlYW1pbmcgV0FMOwoJCQkJCSMgLTEgYWxsb3dz IGluZGVmaW5pdGUgZGVsYXkKI3dhbF9yZWNlaXZlcl9zdGF0dXNfaW50ZXJ2 YWwgPSAxMHMJIyBzZW5kIHJlcGxpZXMgYXQgbGVhc3QgdGhpcyBvZnRlbgoJ CQkJCSMgMCBkaXNhYmxlcwojaG90X3N0YW5kYnlfZmVlZGJhY2sgPSBvZmYJ CSMgc2VuZCBpbmZvIGZyb20gc3RhbmRieSB0byBwcmV2ZW50CgkJCQkJIyBx dWVyeSBjb25mbGljdHMKI3dhbF9yZWNlaXZlcl90aW1lb3V0ID0gNjBzCQkj IHRpbWUgdGhhdCByZWNlaXZlciB3YWl0cyBmb3IKCQkJCQkjIGNvbW11bmlj YXRpb24gZnJvbSBtYXN0ZXIKCQkJCQkjIGluIG1pbGxpc2Vjb25kczsgMCBk aXNhYmxlcwojd2FsX3JldHJpZXZlX3JldHJ5X2ludGVydmFsID0gNXMJIyB0 aW1lIHRvIHdhaXQgYmVmb3JlIHJldHJ5aW5nIHRvCgkJCQkJIyByZXRyaWV2 ZSBXQUwgYWZ0ZXIgYSBmYWlsZWQgYXR0ZW1wdAoKIyAtIFN1YnNjcmliZXJz IC0KCiMgVGhlc2Ugc2V0dGluZ3MgYXJlIGlnbm9yZWQgb24gYSBwdWJsaXNo ZXIuCgojbWF4X2xvZ2ljYWxfcmVwbGljYXRpb25fd29ya2VycyA9IDQJIyB0 YWtlbiBmcm9tIG1heF93b3JrZXJfcHJvY2Vzc2VzCgkJCQkJIyAoY2hhbmdl IHJlcXVpcmVzIHJlc3RhcnQpCiNtYXhfc3luY193b3JrZXJzX3Blcl9zdWJz Y3JpcHRpb24gPSAyCSMgdGFrZW4gZnJvbSBtYXhfbG9naWNhbF9yZXBsaWNh dGlvbl93b3JrZXJzCgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLQojIFFVRVJZIFRVTklORwojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tCgojIC0gUGxhbm5lciBNZXRob2QgQ29uZmlndXJhdGlvbiAt CgojZW5hYmxlX2JpdG1hcHNjYW4gPSBvbgojZW5hYmxlX2hhc2hhZ2cgPSBv bgojZW5hYmxlX2hhc2hqb2luID0gb24KI2VuYWJsZV9pbmRleHNjYW4gPSBv bgojZW5hYmxlX2luZGV4b25seXNjYW4gPSBvbgojZW5hYmxlX21hdGVyaWFs ID0gb24KI2VuYWJsZV9tZXJnZWpvaW4gPSBvbgojZW5hYmxlX25lc3Rsb29w ID0gb24KI2VuYWJsZV9zZXFzY2FuID0gb24KI2VuYWJsZV9zb3J0ID0gb24K I2VuYWJsZV90aWRzY2FuID0gb24KCiMgLSBQbGFubmVyIENvc3QgQ29uc3Rh bnRzIC0KCiNzZXFfcGFnZV9jb3N0ID0gMS4wCQkJIyBtZWFzdXJlZCBvbiBh biBhcmJpdHJhcnkgc2NhbGUKI3JhbmRvbV9wYWdlX2Nvc3QgPSA0LjAJCQkj IHNhbWUgc2NhbGUgYXMgYWJvdmUKI2NwdV90dXBsZV9jb3N0ID0gMC4wMQkJ CSMgc2FtZSBzY2FsZSBhcyBhYm92ZQojY3B1X2luZGV4X3R1cGxlX2Nvc3Qg PSAwLjAwNQkJIyBzYW1lIHNjYWxlIGFzIGFib3ZlCiNjcHVfb3BlcmF0b3Jf Y29zdCA9IDAuMDAyNQkJIyBzYW1lIHNjYWxlIGFzIGFib3ZlCiNwYXJhbGxl bF90dXBsZV9jb3N0ID0gMC4xCQkjIHNhbWUgc2NhbGUgYXMgYWJvdmUKI3Bh cmFsbGVsX3NldHVwX2Nvc3QgPSAxMDAwLjAJIyBzYW1lIHNjYWxlIGFzIGFi b3ZlCiNtaW5fcGFyYWxsZWxfdGFibGVfc2Nhbl9zaXplID0gOE1CCiNtaW5f cGFyYWxsZWxfaW5kZXhfc2Nhbl9zaXplID0gNTEya0IKI2VmZmVjdGl2ZV9j YWNoZV9zaXplID0gNEdCCgojIC0gR2VuZXRpYyBRdWVyeSBPcHRpbWl6ZXIg LQoKI2dlcW8gPSBvbgojZ2Vxb190aHJlc2hvbGQgPSAxMgojZ2Vxb19lZmZv cnQgPSA1CQkJIyByYW5nZSAxLTEwCiNnZXFvX3Bvb2xfc2l6ZSA9IDAJCQkj IHNlbGVjdHMgZGVmYXVsdCBiYXNlZCBvbiBlZmZvcnQKI2dlcW9fZ2VuZXJh dGlvbnMgPSAwCQkJIyBzZWxlY3RzIGRlZmF1bHQgYmFzZWQgb24gZWZmb3J0 CiNnZXFvX3NlbGVjdGlvbl9iaWFzID0gMi4wCQkjIHJhbmdlIDEuNS0yLjAK I2dlcW9fc2VlZCA9IDAuMAkJCSMgcmFuZ2UgMC4wLTEuMAoKIyAtIE90aGVy IFBsYW5uZXIgT3B0aW9ucyAtCgojZGVmYXVsdF9zdGF0aXN0aWNzX3Rhcmdl dCA9IDEwMAkjIHJhbmdlIDEtMTAwMDAKI2NvbnN0cmFpbnRfZXhjbHVzaW9u ID0gcGFydGl0aW9uCSMgb24sIG9mZiwgb3IgcGFydGl0aW9uCiNjdXJzb3Jf dHVwbGVfZnJhY3Rpb24gPSAwLjEJCSMgcmFuZ2UgMC4wLTEuMAojZnJvbV9j b2xsYXBzZV9saW1pdCA9IDgKI2pvaW5fY29sbGFwc2VfbGltaXQgPSA4CQkj IDEgZGlzYWJsZXMgY29sbGFwc2luZyBvZiBleHBsaWNpdAoJCQkJCSMgSk9J TiBjbGF1c2VzCiNmb3JjZV9wYXJhbGxlbF9tb2RlID0gb2ZmCgoKIy0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojIEVSUk9SIFJFUE9SVElO RyBBTkQgTE9HR0lORwojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tCgojIC0gV2hlcmUgdG8gTG9nIC0KCiNsb2dfZGVzdGluYXRpb24gPSAn c3RkZXJyJwkJIyBWYWxpZCB2YWx1ZXMgYXJlIGNvbWJpbmF0aW9ucyBvZgoJ CQkJCSMgc3RkZXJyLCBjc3Zsb2csIHN5c2xvZywgYW5kIGV2ZW50bG9nLAoJ CQkJCSMgZGVwZW5kaW5nIG9uIHBsYXRmb3JtLiAgY3N2bG9nCgkJCQkJIyBy ZXF1aXJlcyBsb2dnaW5nX2NvbGxlY3RvciB0byBiZSBvbi4KCiMgVGhpcyBp cyB1c2VkIHdoZW4gbG9nZ2luZyB0byBzdGRlcnI6CiNsb2dnaW5nX2NvbGxl Y3RvciA9IG9mZgkJIyBFbmFibGUgY2FwdHVyaW5nIG9mIHN0ZGVyciBhbmQg Y3N2bG9nCgkJCQkJIyBpbnRvIGxvZyBmaWxlcy4gUmVxdWlyZWQgdG8gYmUg b24gZm9yCgkJCQkJIyBjc3Zsb2dzLgoJCQkJCSMgKGNoYW5nZSByZXF1aXJl cyByZXN0YXJ0KQoKIyBUaGVzZSBhcmUgb25seSB1c2VkIGlmIGxvZ2dpbmdf Y29sbGVjdG9yIGlzIG9uOgojbG9nX2RpcmVjdG9yeSA9ICdsb2cnCQkJIyBk aXJlY3Rvcnkgd2hlcmUgbG9nIGZpbGVzIGFyZSB3cml0dGVuLAoJCQkJCSMg Y2FuIGJlIGFic29sdXRlIG9yIHJlbGF0aXZlIHRvIFBHREFUQQojbG9nX2Zp bGVuYW1lID0gJ3Bvc3RncmVzcWwtJVktJW0tJWRfJUglTSVTLmxvZycJIyBs b2cgZmlsZSBuYW1lIHBhdHRlcm4sCgkJCQkJIyBjYW4gaW5jbHVkZSBzdHJm dGltZSgpIGVzY2FwZXMKI2xvZ19maWxlX21vZGUgPSAwNjAwCQkJIyBjcmVh dGlvbiBtb2RlIGZvciBsb2cgZmlsZXMsCgkJCQkJIyBiZWdpbiB3aXRoIDAg dG8gdXNlIG9jdGFsIG5vdGF0aW9uCiNsb2dfdHJ1bmNhdGVfb25fcm90YXRp b24gPSBvZmYJCSMgSWYgb24sIGFuIGV4aXN0aW5nIGxvZyBmaWxlIHdpdGgg dGhlCgkJCQkJIyBzYW1lIG5hbWUgYXMgdGhlIG5ldyBsb2cgZmlsZSB3aWxs IGJlCgkJCQkJIyB0cnVuY2F0ZWQgcmF0aGVyIHRoYW4gYXBwZW5kZWQgdG8u CgkJCQkJIyBCdXQgc3VjaCB0cnVuY2F0aW9uIG9ubHkgb2NjdXJzIG9uCgkJ CQkJIyB0aW1lLWRyaXZlbiByb3RhdGlvbiwgbm90IG9uIHJlc3RhcnRzCgkJ CQkJIyBvciBzaXplLWRyaXZlbiByb3RhdGlvbi4gIERlZmF1bHQgaXMKCQkJ CQkjIG9mZiwgbWVhbmluZyBhcHBlbmQgdG8gZXhpc3RpbmcgZmlsZXMKCQkJ CQkjIGluIGFsbCBjYXNlcy4KI2xvZ19yb3RhdGlvbl9hZ2UgPSAxZAkJCSMg QXV0b21hdGljIHJvdGF0aW9uIG9mIGxvZ2ZpbGVzIHdpbGwKCQkJCQkjIGhh cHBlbiBhZnRlciB0aGF0IHRpbWUuICAwIGRpc2FibGVzLgojbG9nX3JvdGF0 aW9uX3NpemUgPSAxME1CCQkjIEF1dG9tYXRpYyByb3RhdGlvbiBvZiBsb2dm aWxlcyB3aWxsCgkJCQkJIyBoYXBwZW4gYWZ0ZXIgdGhhdCBtdWNoIGxvZyBv dXRwdXQuCgkJCQkJIyAwIGRpc2FibGVzLgoKIyBUaGVzZSBhcmUgcmVsZXZh bnQgd2hlbiBsb2dnaW5nIHRvIHN5c2xvZzoKI3N5c2xvZ19mYWNpbGl0eSA9 ICdMT0NBTDAnCiNzeXNsb2dfaWRlbnQgPSAncG9zdGdyZXMnCiNzeXNsb2df c2VxdWVuY2VfbnVtYmVycyA9IG9uCiNzeXNsb2dfc3BsaXRfbWVzc2FnZXMg PSBvbgoKIyBUaGlzIGlzIG9ubHkgcmVsZXZhbnQgd2hlbiBsb2dnaW5nIHRv IGV2ZW50bG9nICh3aW4zMik6CiMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0 KQojZXZlbnRfc291cmNlID0gJ1Bvc3RncmVTUUwnCgojIC0gV2hlbiB0byBM b2cgLQoKI2NsaWVudF9taW5fbWVzc2FnZXMgPSBub3RpY2UJCSMgdmFsdWVz IGluIG9yZGVyIG9mIGRlY3JlYXNpbmcgZGV0YWlsOgoJCQkJCSMgICBkZWJ1 ZzUKCQkJCQkjICAgZGVidWc0CgkJCQkJIyAgIGRlYnVnMwoJCQkJCSMgICBk ZWJ1ZzIKCQkJCQkjICAgZGVidWcxCgkJCQkJIyAgIGxvZwoJCQkJCSMgICBu b3RpY2UKCQkJCQkjICAgd2FybmluZwoJCQkJCSMgICBlcnJvcgoKI2xvZ19t aW5fbWVzc2FnZXMgPSB3YXJuaW5nCQkjIHZhbHVlcyBpbiBvcmRlciBvZiBk ZWNyZWFzaW5nIGRldGFpbDoKCQkJCQkjICAgZGVidWc1CgkJCQkJIyAgIGRl YnVnNAoJCQkJCSMgICBkZWJ1ZzMKCQkJCQkjICAgZGVidWcyCgkJCQkJIyAg IGRlYnVnMQoJCQkJCSMgICBpbmZvCgkJCQkJIyAgIG5vdGljZQoJCQkJCSMg ICB3YXJuaW5nCgkJCQkJIyAgIGVycm9yCgkJCQkJIyAgIGxvZwoJCQkJCSMg ICBmYXRhbAoJCQkJCSMgICBwYW5pYwoKI2xvZ19taW5fZXJyb3Jfc3RhdGVt ZW50ID0gZXJyb3IJIyB2YWx1ZXMgaW4gb3JkZXIgb2YgZGVjcmVhc2luZyBk ZXRhaWw6CgkJCQkJIyAgIGRlYnVnNQoJCQkJCSMgICBkZWJ1ZzQKCQkJCQkj ICAgZGVidWczCgkJCQkJIyAgIGRlYnVnMgoJCQkJCSMgICBkZWJ1ZzEKCQkJ CQkjICAgaW5mbwoJCQkJCSMgICBub3RpY2UKCQkJCQkjICAgd2FybmluZwoJ CQkJCSMgICBlcnJvcgoJCQkJCSMgICBsb2cKCQkJCQkjICAgZmF0YWwKCQkJ CQkjICAgcGFuaWMgKGVmZmVjdGl2ZWx5IG9mZikKCiNsb2dfbWluX2R1cmF0 aW9uX3N0YXRlbWVudCA9IC0xCSMgLTEgaXMgZGlzYWJsZWQsIDAgbG9ncyBh bGwgc3RhdGVtZW50cwoJCQkJCSMgYW5kIHRoZWlyIGR1cmF0aW9ucywgPiAw IGxvZ3Mgb25seQoJCQkJCSMgc3RhdGVtZW50cyBydW5uaW5nIGF0IGxlYXN0 IHRoaXMgbnVtYmVyCgkJCQkJIyBvZiBtaWxsaXNlY29uZHMKCgojIC0gV2hh dCB0byBMb2cgLQoKI2RlYnVnX3ByaW50X3BhcnNlID0gb2ZmCiNkZWJ1Z19w cmludF9yZXdyaXR0ZW4gPSBvZmYKI2RlYnVnX3ByaW50X3BsYW4gPSBvZmYK I2RlYnVnX3ByZXR0eV9wcmludCA9IG9uCiNsb2dfY2hlY2twb2ludHMgPSBv ZmYKI2xvZ19jb25uZWN0aW9ucyA9IG9mZgojbG9nX2Rpc2Nvbm5lY3Rpb25z ID0gb2ZmCiNsb2dfZHVyYXRpb24gPSBvZmYKI2xvZ19lcnJvcl92ZXJib3Np dHkgPSBkZWZhdWx0CQkjIHRlcnNlLCBkZWZhdWx0LCBvciB2ZXJib3NlIG1l c3NhZ2VzCiNsb2dfaG9zdG5hbWUgPSBvZmYKI2xvZ19saW5lX3ByZWZpeCA9 ICclbSBbJXBdICcJCSMgc3BlY2lhbCB2YWx1ZXM6CgkJCQkJIyAgICVhID0g YXBwbGljYXRpb24gbmFtZQoJCQkJCSMgICAldSA9IHVzZXIgbmFtZQoJCQkJ CSMgICAlZCA9IGRhdGFiYXNlIG5hbWUKCQkJCQkjICAgJXIgPSByZW1vdGUg aG9zdCBhbmQgcG9ydAoJCQkJCSMgICAlaCA9IHJlbW90ZSBob3N0CgkJCQkJ IyAgICVwID0gcHJvY2VzcyBJRAoJCQkJCSMgICAldCA9IHRpbWVzdGFtcCB3 aXRob3V0IG1pbGxpc2Vjb25kcwoJCQkJCSMgICAlbSA9IHRpbWVzdGFtcCB3 aXRoIG1pbGxpc2Vjb25kcwoJCQkJCSMgICAlbiA9IHRpbWVzdGFtcCB3aXRo IG1pbGxpc2Vjb25kcyAoYXMgYSBVbml4IGVwb2NoKQoJCQkJCSMgICAlaSA9 IGNvbW1hbmQgdGFnCgkJCQkJIyAgICVlID0gU1FMIHN0YXRlCgkJCQkJIyAg ICVjID0gc2Vzc2lvbiBJRAoJCQkJCSMgICAlbCA9IHNlc3Npb24gbGluZSBu dW1iZXIKCQkJCQkjICAgJXMgPSBzZXNzaW9uIHN0YXJ0IHRpbWVzdGFtcAoJ CQkJCSMgICAldiA9IHZpcnR1YWwgdHJhbnNhY3Rpb24gSUQKCQkJCQkjICAg JXggPSB0cmFuc2FjdGlvbiBJRCAoMCBpZiBub25lKQoJCQkJCSMgICAlcSA9 IHN0b3AgaGVyZSBpbiBub24tc2Vzc2lvbgoJCQkJCSMgICAgICAgIHByb2Nl c3NlcwoJCQkJCSMgICAlJSA9ICclJwoJCQkJCSMgZS5nLiAnPCV1JSUlZD4g JwojbG9nX2xvY2tfd2FpdHMgPSBvZmYJCQkjIGxvZyBsb2NrIHdhaXRzID49 IGRlYWRsb2NrX3RpbWVvdXQKI2xvZ19zdGF0ZW1lbnQgPSAnbm9uZScJCQkj IG5vbmUsIGRkbCwgbW9kLCBhbGwKI2xvZ19yZXBsaWNhdGlvbl9jb21tYW5k cyA9IG9mZgojbG9nX3RlbXBfZmlsZXMgPSAtMQkJCSMgbG9nIHRlbXBvcmFy eSBmaWxlcyBlcXVhbCBvciBsYXJnZXIKCQkJCQkjIHRoYW4gdGhlIHNwZWNp ZmllZCBzaXplIGluIGtpbG9ieXRlczsKCQkJCQkjIC0xIGRpc2FibGVzLCAw IGxvZ3MgYWxsIHRlbXAgZmlsZXMKbG9nX3RpbWV6b25lID0gJ1ctU1UnCgoK IyAtIFByb2Nlc3MgVGl0bGUgLQoKI2NsdXN0ZXJfbmFtZSA9ICcnCQkJIyBh ZGRlZCB0byBwcm9jZXNzIHRpdGxlcyBpZiBub25lbXB0eQoJCQkJCSMgKGNo YW5nZSByZXF1aXJlcyByZXN0YXJ0KQojdXBkYXRlX3Byb2Nlc3NfdGl0bGUg PSBvbgoKCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBS VU5USU1FIFNUQVRJU1RJQ1MKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQoKIyAtIFF1ZXJ5L0luZGV4IFN0YXRpc3RpY3MgQ29sbGVjdG9y IC0KCiN0cmFja19hY3Rpdml0aWVzID0gb24KI3RyYWNrX2NvdW50cyA9IG9u CiN0cmFja19pb190aW1pbmcgPSBvZmYKI3RyYWNrX2Z1bmN0aW9ucyA9IG5v bmUJCQkjIG5vbmUsIHBsLCBhbGwKI3RyYWNrX2FjdGl2aXR5X3F1ZXJ5X3Np emUgPSAxMDI0CSMgKGNoYW5nZSByZXF1aXJlcyByZXN0YXJ0KQojc3RhdHNf dGVtcF9kaXJlY3RvcnkgPSAncGdfc3RhdF90bXAnCgoKIyAtIFN0YXRpc3Rp Y3MgTW9uaXRvcmluZyAtCgojbG9nX3BhcnNlcl9zdGF0cyA9IG9mZgojbG9n X3BsYW5uZXJfc3RhdHMgPSBvZmYKI2xvZ19leGVjdXRvcl9zdGF0cyA9IG9m ZgojbG9nX3N0YXRlbWVudF9zdGF0cyA9IG9mZgoKCiMtLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KIyBBVVRPVkFDVVVNIFBBUkFNRVRFUlMK Iy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoKI2F1dG92YWN1 dW0gPSBvbgkJCSMgRW5hYmxlIGF1dG92YWN1dW0gc3VicHJvY2Vzcz8gICdv bicKCQkJCQkjIHJlcXVpcmVzIHRyYWNrX2NvdW50cyB0byBhbHNvIGJlIG9u LgojbG9nX2F1dG92YWN1dW1fbWluX2R1cmF0aW9uID0gLTEJIyAtMSBkaXNh YmxlcywgMCBsb2dzIGFsbCBhY3Rpb25zIGFuZAoJCQkJCSMgdGhlaXIgZHVy YXRpb25zLCA+IDAgbG9ncyBvbmx5CgkJCQkJIyBhY3Rpb25zIHJ1bm5pbmcg YXQgbGVhc3QgdGhpcyBudW1iZXIKCQkJCQkjIG9mIG1pbGxpc2Vjb25kcy4K I2F1dG92YWN1dW1fbWF4X3dvcmtlcnMgPSAzCQkjIG1heCBudW1iZXIgb2Yg YXV0b3ZhY3V1bSBzdWJwcm9jZXNzZXMKCQkJCQkjIChjaGFuZ2UgcmVxdWly ZXMgcmVzdGFydCkKI2F1dG92YWN1dW1fbmFwdGltZSA9IDFtaW4JCSMgdGlt ZSBiZXR3ZWVuIGF1dG92YWN1dW0gcnVucwojYXV0b3ZhY3V1bV92YWN1dW1f dGhyZXNob2xkID0gNTAJIyBtaW4gbnVtYmVyIG9mIHJvdyB1cGRhdGVzIGJl Zm9yZQoJCQkJCSMgdmFjdXVtCiNhdXRvdmFjdXVtX2FuYWx5emVfdGhyZXNo b2xkID0gNTAJIyBtaW4gbnVtYmVyIG9mIHJvdyB1cGRhdGVzIGJlZm9yZQoJ CQkJCSMgYW5hbHl6ZQojYXV0b3ZhY3V1bV92YWN1dW1fc2NhbGVfZmFjdG9y ID0gMC4yCSMgZnJhY3Rpb24gb2YgdGFibGUgc2l6ZSBiZWZvcmUgdmFjdXVt CiNhdXRvdmFjdXVtX2FuYWx5emVfc2NhbGVfZmFjdG9yID0gMC4xCSMgZnJh Y3Rpb24gb2YgdGFibGUgc2l6ZSBiZWZvcmUgYW5hbHl6ZQojYXV0b3ZhY3V1 bV9mcmVlemVfbWF4X2FnZSA9IDIwMDAwMDAwMAkjIG1heGltdW0gWElEIGFn ZSBiZWZvcmUgZm9yY2VkIHZhY3V1bQoJCQkJCSMgKGNoYW5nZSByZXF1aXJl cyByZXN0YXJ0KQojYXV0b3ZhY3V1bV9tdWx0aXhhY3RfZnJlZXplX21heF9h Z2UgPSA0MDAwMDAwMDAJIyBtYXhpbXVtIG11bHRpeGFjdCBhZ2UKCQkJCQkj IGJlZm9yZSBmb3JjZWQgdmFjdXVtCgkJCQkJIyAoY2hhbmdlIHJlcXVpcmVz IHJlc3RhcnQpCiNhdXRvdmFjdXVtX3ZhY3V1bV9jb3N0X2RlbGF5ID0gMjBt cwkjIGRlZmF1bHQgdmFjdXVtIGNvc3QgZGVsYXkgZm9yCgkJCQkJIyBhdXRv dmFjdXVtLCBpbiBtaWxsaXNlY29uZHM7CgkJCQkJIyAtMSBtZWFucyB1c2Ug dmFjdXVtX2Nvc3RfZGVsYXkKI2F1dG92YWN1dW1fdmFjdXVtX2Nvc3RfbGlt aXQgPSAtMQkjIGRlZmF1bHQgdmFjdXVtIGNvc3QgbGltaXQgZm9yCgkJCQkJ IyBhdXRvdmFjdXVtLCAtMSBtZWFucyB1c2UKCQkJCQkjIHZhY3V1bV9jb3N0 X2xpbWl0CgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoj IENMSUVOVCBDT05ORUNUSU9OIERFRkFVTFRTCiMtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KCiMgLSBTdGF0ZW1lbnQgQmVoYXZpb3IgLQoK I3NlYXJjaF9wYXRoID0gJyIkdXNlciIsIHB1YmxpYycJIyBzY2hlbWEgbmFt ZXMKI2RlZmF1bHRfdGFibGVzcGFjZSA9ICcnCQkjIGEgdGFibGVzcGFjZSBu YW1lLCAnJyB1c2VzIHRoZSBkZWZhdWx0CiN0ZW1wX3RhYmxlc3BhY2VzID0g JycJCQkjIGEgbGlzdCBvZiB0YWJsZXNwYWNlIG5hbWVzLCAnJyB1c2VzCgkJ CQkJIyBvbmx5IGRlZmF1bHQgdGFibGVzcGFjZQojY2hlY2tfZnVuY3Rpb25f Ym9kaWVzID0gb24KI2RlZmF1bHRfdHJhbnNhY3Rpb25faXNvbGF0aW9uID0g J3JlYWQgY29tbWl0dGVkJwojZGVmYXVsdF90cmFuc2FjdGlvbl9yZWFkX29u bHkgPSBvZmYKI2RlZmF1bHRfdHJhbnNhY3Rpb25fZGVmZXJyYWJsZSA9IG9m Zgojc2Vzc2lvbl9yZXBsaWNhdGlvbl9yb2xlID0gJ29yaWdpbicKI3N0YXRl bWVudF90aW1lb3V0ID0gMAkJCSMgaW4gbWlsbGlzZWNvbmRzLCAwIGlzIGRp c2FibGVkCiNsb2NrX3RpbWVvdXQgPSAwCQkJIyBpbiBtaWxsaXNlY29uZHMs IDAgaXMgZGlzYWJsZWQKI2lkbGVfaW5fdHJhbnNhY3Rpb25fc2Vzc2lvbl90 aW1lb3V0ID0gMAkjIGluIG1pbGxpc2Vjb25kcywgMCBpcyBkaXNhYmxlZAoj dmFjdXVtX2ZyZWV6ZV9taW5fYWdlID0gNTAwMDAwMDAKI3ZhY3V1bV9mcmVl emVfdGFibGVfYWdlID0gMTUwMDAwMDAwCiN2YWN1dW1fbXVsdGl4YWN0X2Zy ZWV6ZV9taW5fYWdlID0gNTAwMDAwMAojdmFjdXVtX211bHRpeGFjdF9mcmVl emVfdGFibGVfYWdlID0gMTUwMDAwMDAwCiNieXRlYV9vdXRwdXQgPSAnaGV4 JwkJCSMgaGV4LCBlc2NhcGUKI3htbGJpbmFyeSA9ICdiYXNlNjQnCiN4bWxv cHRpb24gPSAnY29udGVudCcKI2dpbl9mdXp6eV9zZWFyY2hfbGltaXQgPSAw CiNnaW5fcGVuZGluZ19saXN0X2xpbWl0ID0gNE1CCgojIC0gTG9jYWxlIGFu ZCBGb3JtYXR0aW5nIC0KCmRhdGVzdHlsZSA9ICdpc28sIGRteScKI2ludGVy dmFsc3R5bGUgPSAncG9zdGdyZXMnCnRpbWV6b25lID0gJ1ctU1UnCiN0aW1l em9uZV9hYmJyZXZpYXRpb25zID0gJ0RlZmF1bHQnICAgICAjIFNlbGVjdCB0 aGUgc2V0IG9mIGF2YWlsYWJsZSB0aW1lIHpvbmUKCQkJCQkjIGFiYnJldmlh dGlvbnMuICBDdXJyZW50bHksIHRoZXJlIGFyZQoJCQkJCSMgICBEZWZhdWx0 CgkJCQkJIyAgIEF1c3RyYWxpYSAoaGlzdG9yaWNhbCB1c2FnZSkKCQkJCQkj ICAgSW5kaWEKCQkJCQkjIFlvdSBjYW4gY3JlYXRlIHlvdXIgb3duIGZpbGUg aW4KCQkJCQkjIHNoYXJlL3RpbWV6b25lc2V0cy8uCiNleHRyYV9mbG9hdF9k aWdpdHMgPSAwCQkJIyBtaW4gLTE1LCBtYXggMwojY2xpZW50X2VuY29kaW5n ID0gc3FsX2FzY2lpCQkjIGFjdHVhbGx5LCBkZWZhdWx0cyB0byBkYXRhYmFz ZQoJCQkJCSMgZW5jb2RpbmcKCiMgVGhlc2Ugc2V0dGluZ3MgYXJlIGluaXRp YWxpemVkIGJ5IGluaXRkYiwgYnV0IHRoZXkgY2FuIGJlIGNoYW5nZWQuCmxj X21lc3NhZ2VzID0gJ2VuX1VTLlVURi04JwkJCSMgbG9jYWxlIGZvciBzeXN0 ZW0gZXJyb3IgbWVzc2FnZQoJCQkJCSMgc3RyaW5ncwpsY19tb25ldGFyeSA9 ICdydV9SVS5VVEYtOCcJCQkjIGxvY2FsZSBmb3IgbW9uZXRhcnkgZm9ybWF0 dGluZwpsY19udW1lcmljID0gJ3J1X1JVLlVURi04JwkJCSMgbG9jYWxlIGZv ciBudW1iZXIgZm9ybWF0dGluZwpsY190aW1lID0gJ3J1X1JVLlVURi04JwkJ CQkjIGxvY2FsZSBmb3IgdGltZSBmb3JtYXR0aW5nCgojIGRlZmF1bHQgY29u ZmlndXJhdGlvbiBmb3IgdGV4dCBzZWFyY2gKZGVmYXVsdF90ZXh0X3NlYXJj aF9jb25maWcgPSAncGdfY2F0YWxvZy5lbmdsaXNoJwoKIyAtIE90aGVyIERl ZmF1bHRzIC0KCiNkeW5hbWljX2xpYnJhcnlfcGF0aCA9ICckbGliZGlyJwoj bG9jYWxfcHJlbG9hZF9saWJyYXJpZXMgPSAnJwojc2Vzc2lvbl9wcmVsb2Fk X2xpYnJhcmllcyA9ICcnCgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLQojIExPQ0sgTUFOQUdFTUVOVAojLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tCgojZGVhZGxvY2tfdGltZW91dCA9IDFzCiNtYXhf bG9ja3NfcGVyX3RyYW5zYWN0aW9uID0gNjQJCSMgbWluIDEwCgkJCQkJIyAo Y2hhbmdlIHJlcXVpcmVzIHJlc3RhcnQpCiNtYXhfcHJlZF9sb2Nrc19wZXJf dHJhbnNhY3Rpb24gPSA2NAkjIG1pbiAxMAoJCQkJCSMgKGNoYW5nZSByZXF1 aXJlcyByZXN0YXJ0KQojbWF4X3ByZWRfbG9ja3NfcGVyX3JlbGF0aW9uID0g LTIJIyBuZWdhdGl2ZSB2YWx1ZXMgbWVhbgoJCQkJCSMgKG1heF9wcmVkX2xv Y2tzX3Blcl90cmFuc2FjdGlvbgoJCQkJCSMgIC8gLW1heF9wcmVkX2xvY2tz X3Blcl9yZWxhdGlvbikgLSAxCiNtYXhfcHJlZF9sb2Nrc19wZXJfcGFnZSA9 IDIgICAgICAgICAgICAjIG1pbiAwCgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQojIFZFUlNJT04vUExBVEZPUk0gQ09NUEFUSUJJTElU WQojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgojIC0gUHJl dmlvdXMgUG9zdGdyZVNRTCBWZXJzaW9ucyAtCgojYXJyYXlfbnVsbHMgPSBv bgojYmFja3NsYXNoX3F1b3RlID0gc2FmZV9lbmNvZGluZwkjIG9uLCBvZmYs IG9yIHNhZmVfZW5jb2RpbmcKI2RlZmF1bHRfd2l0aF9vaWRzID0gb2ZmCiNl c2NhcGVfc3RyaW5nX3dhcm5pbmcgPSBvbgojbG9fY29tcGF0X3ByaXZpbGVn ZXMgPSBvZmYKI29wZXJhdG9yX3ByZWNlZGVuY2Vfd2FybmluZyA9IG9mZgoj cXVvdGVfYWxsX2lkZW50aWZpZXJzID0gb2ZmCiNzdGFuZGFyZF9jb25mb3Jt aW5nX3N0cmluZ3MgPSBvbgojc3luY2hyb25pemVfc2Vxc2NhbnMgPSBvbgoK IyAtIE90aGVyIFBsYXRmb3JtcyBhbmQgQ2xpZW50cyAtCgojdHJhbnNmb3Jt X251bGxfZXF1YWxzID0gb2ZmCgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQojIEVSUk9SIEhBTkRMSU5HCiMtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0KCiNleGl0X29uX2Vycm9yID0gb2ZmCQkJIyB0 ZXJtaW5hdGUgc2Vzc2lvbiBvbiBhbnkgZXJyb3I/CiNyZXN0YXJ0X2FmdGVy X2NyYXNoID0gb24JCSMgcmVpbml0aWFsaXplIGFmdGVyIGJhY2tlbmQgY3Jh c2g/CgoKIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQojIENP TkZJRyBGSUxFIElOQ0xVREVTCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KCiMgVGhlc2Ugb3B0aW9ucyBhbGxvdyBzZXR0aW5ncyB0byBi ZSBsb2FkZWQgZnJvbSBmaWxlcyBvdGhlciB0aGFuIHRoZQojIGRlZmF1bHQg cG9zdGdyZXNxbC5jb25mLgoKI2luY2x1ZGVfZGlyID0gJ2NvbmYuZCcJCQkj IGluY2x1ZGUgZmlsZXMgZW5kaW5nIGluICcuY29uZicgZnJvbQoJCQkJCSMg ZGlyZWN0b3J5ICdjb25mLmQnCiNpbmNsdWRlX2lmX2V4aXN0cyA9ICdleGlz dHMuY29uZicJIyBpbmNsdWRlIGZpbGUgb25seSBpZiBpdCBleGlzdHMKI2lu Y2x1ZGUgPSAnc3BlY2lhbC5jb25mJwkJIyBpbmNsdWRlIGZpbGUKCgojLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiMgQ1VTVE9NSVpFRCBP UFRJT05TCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KCiMg QWRkIHNldHRpbmdzIGZvciBleHRlbnNpb25zIGhlcmUK --------------000300020108020004010200 Content-Type: application/sql; name="test00.sql" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="test00.sql" Q1JFQVRFIEVYVEVOU0lPTiBydW07CgpDUkVBVEUgVEFCTEUgdHN0IChpIGlu dDQsIHQgdHN2ZWN0b3IpOwpJTlNFUlQgSU5UTyB0c3QgU0VMRUNUIGklMTAs IHRvX3RzdmVjdG9yKCdzaW1wbGUnLCBzdWJzdHIobWQ1KGk6OnRleHQpLCAx LCAxKSkgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMSwxMDAwMDApIGk7CkNSRUFU RSBJTkRFWCB0c3RpZHggT04gdHN0IFVTSU5HIHJ1bSAodCBydW1fdHN2ZWN0 b3Jfb3BzKTsKCkRFTEVURSBGUk9NIHRzdCBXSEVSRSBpID0gMTsKVkFDVVVN IHRzdDsKSU5TRVJUIElOVE8gdHN0IFNFTEVDVCBpJTEwLCB0b190c3ZlY3Rv cignc2ltcGxlJywgc3Vic3RyKG1kNShpOjp0ZXh0KSwgMSwgMSkpIEZST00g Z2VuZXJhdGVfc2VyaWVzKDEwMDAxLDExMDAwKSBpOwoKREVMRVRFIEZST00g dHN0IFdIRVJFIGkgPSAyOwpWQUNVVU0gdHN0OwpJTlNFUlQgSU5UTyB0c3Qg U0VMRUNUIGklMTAsIHRvX3RzdmVjdG9yKCdzaW1wbGUnLCBzdWJzdHIobWQ1 KGk6OnRleHQpLCAxLCAxKSkgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMTEwMDEs MTIwMDApIGk7CgpERUxFVEUgRlJPTSB0c3QgV0hFUkUgaSA9IDM7ClZBQ1VV TSB0c3Q7CklOU0VSVCBJTlRPIHRzdCBTRUxFQ1QgaSUxMCwgdG9fdHN2ZWN0 b3IoJ3NpbXBsZScsIHN1YnN0cihtZDUoaTo6dGV4dCksIDEsIDEpKSBGUk9N IGdlbmVyYXRlX3NlcmllcygxMjAwMSwxMzAwMCkgaTsKCkRFTEVURSBGUk9N IHRzdCBXSEVSRSBpID0gNDsKVkFDVVVNIHRzdDsKSU5TRVJUIElOVE8gdHN0 IFNFTEVDVCBpJTEwLCB0b190c3ZlY3Rvcignc2ltcGxlJywgc3Vic3RyKG1k NShpOjp0ZXh0KSwgMSwgMSkpIEZST00gZ2VuZXJhdGVfc2VyaWVzKDEzMDAx LDE0MDAwKSBpOwoKREVMRVRFIEZST00gdHN0IFdIRVJFIGkgPSA1OwpWQUNV VU0gdHN0OwpJTlNFUlQgSU5UTyB0c3QgU0VMRUNUIGklMTAsIHRvX3RzdmVj dG9yKCdzaW1wbGUnLCBzdWJzdHIobWQ1KGk6OnRleHQpLCAxLCAxKSkgRlJP TSBnZW5lcmF0ZV9zZXJpZXMoMTQwMDEsMTUwMDApIGk7CgpERUxFVEUgRlJP TSB0c3QgV0hFUkUgaSA9IDY7ClZBQ1VVTSB0c3Q7CklOU0VSVCBJTlRPIHRz dCBTRUxFQ1QgaSUxMCwgdG9fdHN2ZWN0b3IoJ3NpbXBsZScsIHN1YnN0ciht ZDUoaTo6dGV4dCksIDEsIDEpKSBGUk9NIGdlbmVyYXRlX3NlcmllcygxNTAw MSwxNjAwMCkgaTsKCkRFTEVURSBGUk9NIHRzdCBXSEVSRSBpID0gNzsKVkFD VVVNIHRzdDsKSU5TRVJUIElOVE8gdHN0IFNFTEVDVCBpJTEwLCB0b190c3Zl Y3Rvcignc2ltcGxlJywgc3Vic3RyKG1kNShpOjp0ZXh0KSwgMSwgMSkpIEZS T00gZ2VuZXJhdGVfc2VyaWVzKDE2MDAxLDE3MDAwKSBpOwoKREVMRVRFIEZS T00gdHN0IFdIRVJFIGkgPSA4OwpWQUNVVU0gdHN0OwpJTlNFUlQgSU5UTyB0 c3QgU0VMRUNUIGklMTAsIHRvX3RzdmVjdG9yKCdzaW1wbGUnLCBzdWJzdHIo bWQ1KGk6OnRleHQpLCAxLCAxKSkgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMTcw MDEsMTgwMDApIGk7CgpERUxFVEUgRlJPTSB0c3QgV0hFUkUgaSA9IDk7ClZB Q1VVTSB0c3Q7CklOU0VSVCBJTlRPIHRzdCBTRUxFQ1QgaSUxMCwgdG9fdHN2 ZWN0b3IoJ3NpbXBsZScsIHN1YnN0cihtZDUoaTo6dGV4dCksIDEsIDEpKSBG Uk9NIGdlbmVyYXRlX3NlcmllcygxODAwMSwxOTAwMCkgaTsKCkRST1AgVEFC TEUgdHN0OwpEUk9QIEVYVEVOU0lPTiBydW07Cg== --------------000300020108020004010200 Content-Type: application/sql; name="test01.sql" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="test01.sql" Q1JFQVRFIEVYVEVOU0lPTiBibG9vbTsKCkNSRUFURSBUQUJMRSB0c3QgKGkg aW50NCwgdCB0ZXh0KTsKCklOU0VSVCBJTlRPIHRzdCBTRUxFQ1QgaSUxMDAw MCwgc3Vic3RyKG1kNShpOjp0ZXh0KSwgMSwgMSkgRlJPTSBnZW5lcmF0ZV9z ZXJpZXMoMSwxMDAwMDAwKSBpOwpDUkVBVEUgSU5ERVggYmxvb21pZHggT04g dHN0IFVTSU5HIGJsb29tIChpLCB0KSBXSVRIIChjb2wxID0gMTMpOwoKREVM RVRFIEZST00gdHN0IFdIRVJFIGkgPSA1OwpWQUNVVU0gdHN0OwoKREVMRVRF IEZST00gdHN0IFdIRVJFIGkgPSAyOwpWQUNVVU0gdHN0OwoKREVMRVRFIEZS T00gdHN0IFdIRVJFIGkgPSA4OwpWQUNVVU0gdHN0OwoKREVMRVRFIEZST00g dHN0IFdIRVJFIHQgPSAnNSc7ClZBQ1VVTSB0c3Q7CgpERUxFVEUgRlJPTSB0 c3QgV0hFUkUgdCA9ICcyJzsKVkFDVVVNIHRzdDsKCkRFTEVURSBGUk9NIHRz dCBXSEVSRSB0ID0gJzgnOwpWQUNVVU0gdHN0OwoKRFJPUCBUQUJMRSB0c3Q7 CgpDUkVBVEUgVEFCTEUgdHN0IChpIGludDQsIHQgdGV4dCk7CgpJTlNFUlQg SU5UTyB0c3QgU0VMRUNUIGklMTAwMCwgc3Vic3RyKG1kNShpOjp0ZXh0KSwg MSwgMSkgRlJPTSBnZW5lcmF0ZV9zZXJpZXMoMSwxMDAwMDAwKSBpOwpDUkVB VEUgSU5ERVggYmxvb21pZHggT04gdHN0IFVTSU5HIGJsb29tIChpLCB0KSBX SVRIIChjb2wxID0gMTMpOwoKREVMRVRFIEZST00gdHN0IFdIRVJFIGkgPSA1 OwpWQUNVVU0gdHN0OwoKREVMRVRFIEZST00gdHN0IFdIRVJFIGkgPSAyOwpW QUNVVU0gdHN0OwoKREVMRVRFIEZST00gdHN0IFdIRVJFIGkgPSA4OwpWQUNV VU0gdHN0OwoKRFJPUCBUQUJMRSB0c3Q7CgpEUk9QIEVYVEVOU0lPTiBibG9v bTsK --------------000300020108020004010200 Content-Type: application/x-shellscript; name="test_correctness.sh" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="test_correctness.sh" IyEvYmluL2Jhc2gKCmVjaG8gUHJlcGFyaW5nLi4uCgppZiAhIFsgLWEgcG9z dGdyZXNxbCBdOyB0aGVuCiAgZ2l0IGNsb25lIGdpdDovL2dpdC5wb3N0Z3Jl c3FsLm9yZy9naXQvcG9zdGdyZXNxbC5naXQ7CmZpCmNkIHBvc3RncmVzcWwK Z2l0IGNoZWNrb3V0IFJFTF8xMF8wCmNkIC4uCgppZiAhIFsgLWEgcnVtIF07 IHRoZW4KICBnaXQgY2xvbmUgaHR0cHM6Ly9naXRodWIuY29tL3Bvc3RncmVz cHJvL3J1bQpmaQoKcm0gLXJmIHBvc3RncmVzcWxfY29ycmVjdG5lc3MKY3Ag LXIgcG9zdGdyZXNxbCBwb3N0Z3Jlc3FsX2NvcnJlY3RuZXNzCmNwIC1yIHJ1 bSBwb3N0Z3Jlc3FsX2NvcnJlY3RuZXNzL2NvbnRyaWIKCmNkIHBvc3RncmVz cWxfY29ycmVjdG5lc3MKcGF0Y2ggLXAxIDwgLi4vZ2VuZXJpY194bG9nX2Rp ZmZkZWx0YV92MS5wYXRjaApjZCAuLgoKdGVzdF9wb3N0Z3Jlc3FsX3ZlcnNp b25zPSJwb3N0Z3Jlc3FsX2NvcnJlY3RuZXNzIgp0ZXN0X2NvbnRyaWJzPSJy dW0gYmxvb20iCgpwcmVmaXg9YHB3ZGAKCnBvcnQ9NTg0NQoKZm9yIHBvc3Rn cmVzcWwgaW4gJHRlc3RfcG9zdGdyZXNxbF92ZXJzaW9uczsgZG8KICBlY2hv IFRlc3RpbmcgJHBvc3RncmVzcWwuLi4KICBybSAtcmYgZGJfJHBvc3RncmVz cWwKICBybSAtcmYgYmluXyRwb3N0Z3Jlc3FsCiAgcm0gLWYgbG9nXyR7cG9z dGdyZXNxbH0ubG9nCgogIGNkICRwb3N0Z3Jlc3FsCiAgLi9jb25maWd1cmUg LS1wcmVmaXg9JHByZWZpeC9iaW5fJHBvc3RncmVzcWwgLS1lbmFibGUtY2Fz c2VydCAtLWVuYWJsZS1kZWJ1ZyAtLWVuYWJsZS1ubHMgLS13aXRoLXBncG9y dD0kcG9ydCBDRkxBR1M9Ii1EV0FMX0RFQlVHIiA+IC9kZXYvbnVsbAogIG1h a2UgLWo0ID4gL2Rldi9udWxsCiAgbWFrZSBpbnN0YWxsID4gL2Rldi9udWxs CiAgZm9yIGNvbnRyaWIgaW4gJHRlc3RfY29udHJpYnM7IGRvCiAgICBjZCBj b250cmliLyRjb250cmliCiAgICBtYWtlIC1qNCA+IC9kZXYvbnVsbAogICAg bWFrZSBpbnN0YWxsID4gL2Rldi9udWxsCiAgICBjZCAuLi8uLjsKICBkb25l CiAgY2QgLi4KCiAgYmluXyRwb3N0Z3Jlc3FsL2Jpbi9pbml0ZGIgLUQgZGJf JHBvc3RncmVzcWwgPiAvZGV2L251bGwgMj4gL2Rldi9udWxsCiAgZWNobyAi d2FsX2RlYnVnID0gb24iID4+IGRiXyRwb3N0Z3Jlc3FsL3Bvc3RncmVzcWwu Y29uZgoKICBiaW5fJHBvc3RncmVzcWwvYmluL3BnX2N0bCAtRCBkYl8kcG9z dGdyZXNxbCAtbCBsb2dfJHtwb3N0Z3Jlc3FsfS5sb2cgc3RhcnQKICB3aGls ZSAhKGJpbl8kcG9zdGdyZXNxbC9iaW4vcHNxbCAtLXBvcnQgJHBvcnQgLWQg cG9zdGdyZXMgLWMgIlNFTEVDVCAxOyIgPiAvZGV2L251bGwgMj4gL2Rldi9u dWxsKTsgZG8KICAgIHNsZWVwIDE7CiAgZG9uZQoKICAjY2QgJHBvc3RncmVz cWwKICAjUEdQT1JUPSRwb3J0IHRpbWUgbWFrZSBpbnN0YWxsY2hlY2sKICAj Y2QgLi4KCiAgZm9yIGNvbnRyaWIgaW4gJHRlc3RfY29udHJpYnM7IGRvCiAg ICBjZCAkcG9zdGdyZXNxbC9jb250cmliLyRjb250cmliCiAgICBQR1BPUlQ9 JHBvcnQgdGltZSBtYWtlIGluc3RhbGxjaGVjawogICAgY2QgLi4vLi4vLi47 CiAgZG9uZQoKICBiaW5fJHBvc3RncmVzcWwvYmluL3BnX2N0bCAtRCBkYl8k cG9zdGdyZXNxbCAtbCBsb2dfJHtwb3N0Z3Jlc3FsfS5sb2cgc3RvcApkb25l Cg== --------------000300020108020004010200 Content-Type: application/x-shellscript; name="total_test.sh" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="total_test.sh" IyEvYmluL2Jhc2gKCmVjaG8gUHJlcGFyaW5nLi4uCgppZiAhIFsgLWEgcG9z dGdyZXNxbCBdOyB0aGVuCiAgZ2l0IGNsb25lIGdpdDovL2dpdC5wb3N0Z3Jl c3FsLm9yZy9naXQvcG9zdGdyZXNxbC5naXQ7CmZpCmNkIHBvc3RncmVzcWwK Z2l0IGNoZWNrb3V0IFJFTF8xMF8wCmNkIC4uCgppZiAhIFsgLWEgcnVtIF07 IHRoZW4KICBnaXQgY2xvbmUgaHR0cHM6Ly9naXRodWIuY29tL3Bvc3RncmVz cHJvL3J1bQpmaQoKcm0gLXJmIHBvc3RncmVzcWxfb3JpZ2luYWwKcm0gLXJm IHBvc3RncmVzcWxfb3B0aW1pemVkCmNwIC1yIHBvc3RncmVzcWwgcG9zdGdy ZXNxbF9vcmlnaW5hbApjcCAtciBydW0gcG9zdGdyZXNxbF9vcmlnaW5hbC9j b250cmliCgpjcCAtciBwb3N0Z3Jlc3FsX29yaWdpbmFsIHBvc3RncmVzcWxf b3B0aW1pemVkCmNkIHBvc3RncmVzcWxfb3B0aW1pemVkCnBhdGNoIC1wMSA8 IC4uL2dlbmVyaWNfeGxvZ19kaWZmZGVsdGFfdjEucGF0Y2gKY2QgLi4KCnRl c3RfcG9zdGdyZXNxbF92ZXJzaW9ucz0icG9zdGdyZXNxbF9vcHRpbWl6ZWQi CnRlc3RfY29udHJpYnM9InJ1bSBibG9vbSIKCnByZWZpeD1gcHdkYAoKcG9y dD01ODQ1Cgpmb3IgcG9zdGdyZXNxbCBpbiAkdGVzdF9wb3N0Z3Jlc3FsX3Zl cnNpb25zOyBkbwogIGVjaG8gVGVzdGluZyAkcG9zdGdyZXNxbC4uLgogIHJt IC1yZiBkYl8kcG9zdGdyZXNxbAogIHJtIC1yZiBiaW5fJHBvc3RncmVzcWwK ICBybSAtZiBsb2dfJHtwb3N0Z3Jlc3FsfS5sb2cKCiAgY2QgJHBvc3RncmVz cWwKICAuL2NvbmZpZ3VyZSAtLXByZWZpeD0kcHJlZml4L2Jpbl8kcG9zdGdy ZXNxbCAtLWVuYWJsZS1jYXNzZXJ0IC0tZW5hYmxlLW5scyAtLXdpdGgtcGdw b3J0PSRwb3J0ID4gL2Rldi9udWxsCiAgbWFrZSAtajQgPiAvZGV2L251bGwK ICBtYWtlIGluc3RhbGwgPiAvZGV2L251bGwKICBmb3IgY29udHJpYiBpbiAk dGVzdF9jb250cmliczsgZG8KICAgIGNkIGNvbnRyaWIvJGNvbnRyaWIKICAg IG1ha2UgLWo0ID4gL2Rldi9udWxsCiAgICBtYWtlIGluc3RhbGwgPiAvZGV2 L251bGwKICAgIGNkIC4uLy4uOwogIGRvbmUKICBjZCAuLgoKICBiaW5fJHBv c3RncmVzcWwvYmluL2luaXRkYiAtRCBkYl8kcG9zdGdyZXNxbCA+IC9kZXYv bnVsbCAyPiAvZGV2L251bGwKICBjcCBwb3N0Z3Jlc3FsLmNvbmYgZGJfJHBv c3RncmVzcWwvCiAgYmluXyRwb3N0Z3Jlc3FsL2Jpbi9wZ19jdGwgLUQgZGJf JHBvc3RncmVzcWwgLWwgbG9nXyR7cG9zdGdyZXNxbH0ubG9nIHN0YXJ0CiAg d2hpbGUgIShiaW5fJHBvc3RncmVzcWwvYmluL3BzcWwgLS1wb3J0ICRwb3J0 IC1kIHBvc3RncmVzIC1jICJTRUxFQ1QgMTsiID4gL2Rldi9udWxsIDI+IC9k ZXYvbnVsbCk7IGRvCiAgICBzbGVlcCAxOwogIGRvbmUKCiAgZWNobyAiIiJD UkVBVEUgRlVOQ1RJT04gcGdfY2F0YWxvZy5wZ19jdXJyZW50X3hsb2dfbG9j YXRpb24oKSBSRVRVUk5TIHBnX2xzbiBBUyBcJFwkCkJFR0lOCiAgICBSRVRV Uk4gcGdfY3VycmVudF93YWxfbHNuKCk7CkVORDsKXCRcJCBMQU5HVUFHRSBw bHBnc3FsOyIiIiB8IGJpbl8kcG9zdGdyZXNxbC9iaW4vcHNxbCAtLXBvcnQg JHBvcnQgLWQgcG9zdGdyZXMKCiAgZm9yIGNvbnRyaWIgaW4gJHRlc3RfY29u dHJpYnM7IGRvCiAgICBzdGFydD1gYmluXyRwb3N0Z3Jlc3FsL2Jpbi9wc3Fs IC0tcG9ydCAkcG9ydCAtZCBwb3N0Z3JlcyAtYyAiQ09QWSAoU0VMRUNUIHBn X2N1cnJlbnRfeGxvZ19sb2NhdGlvbigpKSBUTyBzdGRvdXQ7IiB8IHRyIC8g eGAKICAgIGNkICRwb3N0Z3Jlc3FsL2NvbnRyaWIvJGNvbnRyaWIKICAgIFBH UE9SVD0kcG9ydCB0aW1lIG1ha2UgaW5zdGFsbGNoZWNrID4gL2Rldi9udWxs CiAgICBjZCAuLi8uLi8uLgogICAgZmluaXNoPWBiaW5fJHBvc3RncmVzcWwv YmluL3BzcWwgLS1wb3J0ICRwb3J0IC1kIHBvc3RncmVzIC1jICJDT1BZIChT RUxFQ1QgcGdfY3VycmVudF94bG9nX2xvY2F0aW9uKCkpIFRPIHN0ZG91dDsi IHwgdHIgLyB4YAogICAgZWNobyBJbnN0YWxsQ2hlY2sgb2YgJGNvbnRyaWIg V0FMIHNpemUgaXMgJCgoJGZpbmlzaCAtICRzdGFydCkpIGJ5dGVzOwogIGRv bmUKCiAgYmluXyRwb3N0Z3Jlc3FsL2Jpbi9jcmVhdGVkYiAtLXBvcnQgJHBv cnQgdGVzdDAwCiAgc3RhcnQ9YGJpbl8kcG9zdGdyZXNxbC9iaW4vcHNxbCAt LXBvcnQgJHBvcnQgLWQgcG9zdGdyZXMgLWMgIkNPUFkgKFNFTEVDVCBwZ19j dXJyZW50X3hsb2dfbG9jYXRpb24oKSkgVE8gc3Rkb3V0OyIgfCB0ciAvIHhg CiAgc3RhcnRfZ2xvYmFsPSRzdGFydAogIGNhdCB0ZXN0MDAuc3FsIHwgd2hp bGUgcmVhZCBsaW5lOyBkbwogICAgaWYgdGVzdCAteiAiJGxpbmUiOyB0aGVu CiAgICAgIGNvbnRpbnVlOwogICAgZmkKICAgIGJpbl8kcG9zdGdyZXNxbC9i aW4vcHNxbCAtLXBvcnQgJHBvcnQgLWQgdGVzdDAwIC1jICIkbGluZSIgPiAv ZGV2L251bGwKICAgIGZpbmlzaD1gYmluXyRwb3N0Z3Jlc3FsL2Jpbi9wc3Fs IC0tcG9ydCAkcG9ydCAtZCBwb3N0Z3JlcyAtYyAiQ09QWSAoU0VMRUNUIHBn X2N1cnJlbnRfeGxvZ19sb2NhdGlvbigpKSBUTyBzdGRvdXQ7IiB8IHRyIC8g eGAKICAgIGVjaG8gUnVtIFwiJGxpbmVcIiBXQUwgc2l6ZSBpcyAkKCgkZmlu aXNoIC0gJHN0YXJ0KSkgYnl0ZXMKICAgIHN0YXJ0PSRmaW5pc2gKICBkb25l IAogIGZpbmlzaF9nbG9iYWw9YGJpbl8kcG9zdGdyZXNxbC9iaW4vcHNxbCAt LXBvcnQgJHBvcnQgLWQgcG9zdGdyZXMgLWMgIkNPUFkgKFNFTEVDVCBwZ19j dXJyZW50X3hsb2dfbG9jYXRpb24oKSkgVE8gc3Rkb3V0OyIgfCB0ciAvIHhg CiAgdGltZSBiaW5fJHBvc3RncmVzcWwvYmluL3BzcWwgLS1wb3J0ICRwb3J0 IC1kIHRlc3QwMCA8IHRlc3QwMC5zcWwgPiAvZGV2L251bGwKICBlY2hvIFJ1 bSB0ZXN0MDAuc3FsIFdBTCBzaXplIGlzICQoKCRmaW5pc2hfZ2xvYmFsIC0g JHN0YXJ0X2dsb2JhbCkpIGJ5dGVzCgogIGJpbl8kcG9zdGdyZXNxbC9iaW4v Y3JlYXRlZGIgLS1wb3J0ICRwb3J0IHRlc3QwMQogIHN0YXJ0PWBiaW5fJHBv c3RncmVzcWwvYmluL3BzcWwgLS1wb3J0ICRwb3J0IC1kIHBvc3RncmVzIC1j ICJDT1BZIChTRUxFQ1QgcGdfY3VycmVudF94bG9nX2xvY2F0aW9uKCkpIFRP IHN0ZG91dDsiIHwgdHIgLyB4YAogIHN0YXJ0X2dsb2JhbD0kc3RhcnQKICBj YXQgdGVzdDAxLnNxbCB8IHdoaWxlIHJlYWQgbGluZTsgZG8KICAgIGlmIHRl c3QgLXogIiRsaW5lIjsgdGhlbgogICAgICBjb250aW51ZTsKICAgIGZpCiAg ICBiaW5fJHBvc3RncmVzcWwvYmluL3BzcWwgLS1wb3J0ICRwb3J0IC1kIHRl c3QwMSAtYyAiJGxpbmUiID4gL2Rldi9udWxsCiAgICBmaW5pc2g9YGJpbl8k cG9zdGdyZXNxbC9iaW4vcHNxbCAtLXBvcnQgJHBvcnQgLWQgcG9zdGdyZXMg LWMgIkNPUFkgKFNFTEVDVCBwZ19jdXJyZW50X3hsb2dfbG9jYXRpb24oKSkg VE8gc3Rkb3V0OyIgfCB0ciAvIHhgCiAgICBlY2hvIEJsb29tIFwiJGxpbmVc IiBXQUwgc2l6ZSBpcyAkKCgkZmluaXNoIC0gJHN0YXJ0KSkgYnl0ZXMKICAg IHN0YXJ0PSRmaW5pc2gKICBkb25lIAogIGZpbmlzaF9nbG9iYWw9YGJpbl8k cG9zdGdyZXNxbC9iaW4vcHNxbCAtLXBvcnQgJHBvcnQgLWQgcG9zdGdyZXMg LWMgIkNPUFkgKFNFTEVDVCBwZ19jdXJyZW50X3hsb2dfbG9jYXRpb24oKSkg VE8gc3Rkb3V0OyIgfCB0ciAvIHhgCiAgdGltZSBiaW5fJHBvc3RncmVzcWwv YmluL3BzcWwgLS1wb3J0ICRwb3J0IC1kIHRlc3QwMSA8IHRlc3QwMS5zcWwg PiAvZGV2L251bGwKICBlY2hvIEJsb29tIHRlc3QwMS5zcWwgV0FMIHNpemUg aXMgJCgoJGZpbmlzaF9nbG9iYWwgLSAkc3RhcnRfZ2xvYmFsKSkgYnl0ZXMK CiAgYmluXyRwb3N0Z3Jlc3FsL2Jpbi9wZ19jdGwgLUQgZGJfJHBvc3RncmVz cWwgLWwgbG9nXyR7cG9zdGdyZXNxbH0ubG9nIHN0b3AKZG9uZQo= --------------000300020108020004010200 Content-Type: text/plain Content-Disposition: inline Content-Transfer-Encoding: 8bit MIME-Version: 1.0 -- Sent via pgsql-hackers mailing list (pgsql-hackers@postgresql.org) To make changes to your subscription: http://www.postgresql.org/mailpref/pgsql-hackers --------------000300020108020004010200--