From 7ba1aa4bda8dce396b435e6055d0a195ddf17aec Mon Sep 17 00:00:00 2001 From: Vadim Gusev Date: Tue, 16 Jul 2024 18:08:31 +0300 Subject: [PATCH 01/30] Add Grafana dashboard (#319) --- event_reporter/grafana-dashboard.json | 1364 +++++++++++++++++++++++++ 1 file changed, 1364 insertions(+) create mode 100644 event_reporter/grafana-dashboard.json diff --git a/event_reporter/grafana-dashboard.json b/event_reporter/grafana-dashboard.json new file mode 100644 index 0000000000000..1c43c1049b7da --- /dev/null +++ b/event_reporter/grafana-dashboard.json @@ -0,0 +1,1364 @@ +{ + "__inputs": [ + { + "name": "DS_MIMIR_(PRODUCTION PERMANENT RETENTION)", + "label": "Mimir (Production permanent retention)", + "description": "", + "type": "datasource", + "pluginId": "prometheus", + "pluginName": "Prometheus" + } + ], + "__elements": {}, + "__requires": [ + { + "type": "grafana", + "id": "grafana", + "name": "Grafana", + "version": "11.0.0" + }, + { + "type": "panel", + "id": "heatmap", + "name": "Heatmap", + "version": "" + }, + { + "type": "datasource", + "id": "prometheus", + "name": "Prometheus", + "version": "1.0.0" + }, + { + "type": "panel", + "id": "timeseries", + "name": "Time series", + "version": "" + } + ], + "annotations": { + "list": [ + { + "builtIn": 1, + "datasource": { + "type": "datasource", + "uid": "grafana" + }, + "enable": true, + "hide": true, + "iconColor": "rgba(0, 211, 255, 1)", + "name": "Annotations & Alerts", + "type": "dashboard" + } + ] + }, + "editable": true, + "fiscalYearStartMonth": 0, + "graphTooltip": 1, + "id": null, + "links": [], + "liveNow": false, + "panels": [ + { + "collapsed": false, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 0 + }, + "id": 49, + "panels": [], + "title": "General stats", + "type": "row" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "line" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "transparent", + "value": null + }, + { + "color": "orange", + "value": 400 + }, + { + "color": "red", + "value": 800 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 9, + "w": 24, + "x": 0, + "y": 1 + }, + "id": 54, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "maxHeight": 600, + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n codefresh_event_reporter_queue_size\n {reporter_shard=~\"$reporter_shard\", namespace=~\"$runtime\"}\n) by(reporter_shard)", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Queue size", + "transformations": [ + { + "id": "renameByRegex", + "options": { + "regex": "(\\d+)", + "renamePattern": "shard $1" + } + } + ], + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "eps" + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 24, + "x": 0, + "y": 10 + }, + "id": 58, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "maxHeight": 600, + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n rate(\n codefresh_event_reporter_enqueued_events_total\n {reporter_shard=~\"$reporter_shard\", namespace=\"$runtime\"}\n [$__rate_interval])\n) by(${group_by:csv})", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Events enqueued", + "transformations": [ + { + "id": "renameByRegex", + "options": { + "regex": "(\\d+)", + "renamePattern": "shard $1" + } + } + ], + "type": "timeseries" + }, + { + "collapsed": false, + "datasource": { + "uid": "$datasource" + }, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 18 + }, + "id": 4, + "panels": [], + "targets": [ + { + "datasource": { + "uid": "$datasource" + }, + "refId": "A" + } + ], + "title": "Events stats", + "type": "row" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "s" + }, + "overrides": [] + }, + "gridPos": { + "h": 9, + "w": 24, + "x": 0, + "y": 19 + }, + "id": 52, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "maxHeight": 600, + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.4.0", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n rate(\n codefresh_event_reporter_event_processing_duration_sum\n {reporter_shard=~\"$reporter_shard\", namespace=~\"$runtime\"}\n [$__rate_interval])\n) by(${group_by:csv})\n/\nsum(\n rate(\n codefresh_event_reporter_event_processing_duration_count\n {reporter_shard=~\"$reporter_shard\", namespace=~\"$runtime\"}\n [$__rate_interval])\n) by(${group_by:csv})", + "format": "time_series", + "fullMetaSearch": false, + "hide": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Average processing time", + "transformations": [ + { + "id": "renameByRegex", + "options": { + "regex": "(\\d+)", + "renamePattern": "shard $1" + } + } + ], + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "description": "Dropped due to one of:\n- rate limited\n- queue overflow", + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "eps" + }, + "overrides": [] + }, + "gridPos": { + "h": 9, + "w": 24, + "x": 0, + "y": 28 + }, + "id": 47, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "maxHeight": 600, + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum (\n rate(\n codefresh_event_reporter_dropped_events_total\n {reporter_shard=~\"$reporter_shard\", namespace=~\"$runtime\"}\n [$__rate_interval])\n) by(${group_by:csv})\n> 0", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Dropped events", + "transformations": [ + { + "id": "renameByRegex", + "options": { + "regex": "(\\d+)", + "renamePattern": "shard $1" + } + } + ], + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green", + "value": null + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "eps" + }, + "overrides": [] + }, + "gridPos": { + "h": 9, + "w": 24, + "x": 0, + "y": 37 + }, + "id": 59, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "maxHeight": 600, + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum (\n rate(\n codefresh_event_reporter_errored_events_total\n {reporter_shard=~\"$reporter_shard\", namespace=~\"$runtime\"}\n [$__rate_interval])\n) by(${group_by:csv})\n> 0", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Errored events", + "transformations": [ + { + "id": "renameByRegex", + "options": { + "regex": "(\\d+)", + "renamePattern": "shard $1" + } + } + ], + "type": "timeseries" + }, + { + "collapsed": true, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 46 + }, + "id": 51, + "panels": [ + { + "cards": {}, + "color": { + "cardColor": "#b4ff00", + "colorScale": "sqrt", + "colorScheme": "interpolateSpectral", + "exponent": 0.5, + "mode": "spectrum" + }, + "dataFormat": "tsbuckets", + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "custom": { + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "scaleDistribution": { + "type": "linear" + } + } + }, + "overrides": [] + }, + "gridPos": { + "h": 8, + "w": 24, + "x": 0, + "y": 47 + }, + "heatmap": {}, + "hideZeroBuckets": false, + "highlightCards": true, + "id": 44, + "interval": "$resolution", + "legend": { + "show": false + }, + "options": { + "calculate": false, + "calculation": {}, + "cellGap": 2, + "cellValues": {}, + "color": { + "exponent": 0.5, + "fill": "#b4ff00", + "mode": "scheme", + "reverse": false, + "scale": "exponential", + "scheme": "Spectral", + "steps": 128 + }, + "exemplars": { + "color": "rgba(255,0,255,0.7)" + }, + "filterValues": { + "le": 1e-9 + }, + "legend": { + "show": true + }, + "rowsFrame": { + "layout": "auto" + }, + "showValue": "never", + "tooltip": { + "mode": "single", + "showColorScale": false, + "yHistogram": false + }, + "yAxis": { + "axisPlacement": "left", + "reverse": false, + "unit": "s" + } + }, + "pluginVersion": "10.4.0", + "reverseYBuckets": false, + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n rate(\n codefresh_event_reporter_event_processing_duration_bucket\n {reporter_shard=~\"$reporter_shard\", namespace=~\"$runtime\"}\n [$__rate_interval])\n) by(le) ", + "format": "heatmap", + "fullMetaSearch": false, + "hide": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "App event performance", + "tooltip": { + "show": true, + "showHistogram": false + }, + "type": "heatmap", + "xAxis": { + "show": true + }, + "yAxis": { + "format": "short", + "logBase": 1, + "show": true + }, + "yBucketBound": "auto" + } + ], + "title": "Processing performance", + "type": "row" + }, + { + "collapsed": true, + "gridPos": { + "h": 1, + "w": 24, + "x": 0, + "y": 47 + }, + "id": 50, + "panels": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green" + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "bytes" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 55 + }, + "id": 12, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n go_memstats_heap_alloc_bytes\n {namespace=~\"$runtime\", pod=~\"argo-cd-event-reporter-$reporter_shard.+\"}\n) by(pod)", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Memory Used", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green" + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 62 + }, + "id": 45, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n go_goroutines\n {namespace=~\"$runtime\", pod=~\"argo-cd-event-reporter-$reporter_shard.+\"}\n) by(pod)", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Number of go routines", + "type": "timeseries" + }, + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "fieldConfig": { + "defaults": { + "color": { + "mode": "palette-classic" + }, + "custom": { + "axisBorderShow": false, + "axisCenteredZero": false, + "axisColorMode": "text", + "axisLabel": "", + "axisPlacement": "auto", + "barAlignment": 0, + "drawStyle": "line", + "fillOpacity": 10, + "gradientMode": "opacity", + "hideFrom": { + "legend": false, + "tooltip": false, + "viz": false + }, + "insertNulls": false, + "lineInterpolation": "linear", + "lineWidth": 1, + "pointSize": 5, + "scaleDistribution": { + "type": "linear" + }, + "showPoints": "never", + "spanNulls": false, + "stacking": { + "group": "A", + "mode": "none" + }, + "thresholdsStyle": { + "mode": "off" + } + }, + "mappings": [], + "min": 0, + "thresholds": { + "mode": "absolute", + "steps": [ + { + "color": "green" + }, + { + "color": "red", + "value": 80 + } + ] + }, + "unit": "short" + }, + "overrides": [] + }, + "gridPos": { + "h": 7, + "w": 24, + "x": 0, + "y": 69 + }, + "id": 46, + "options": { + "legend": { + "calcs": [ + "mean", + "max" + ], + "displayMode": "table", + "placement": "right", + "showLegend": true, + "sortBy": "Mean", + "sortDesc": true + }, + "tooltip": { + "mode": "multi", + "sort": "desc" + } + }, + "pluginVersion": "10.1.5", + "targets": [ + { + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "disableTextWrap": false, + "editorMode": "code", + "expr": "sum(\n go_threads\n {namespace=~\"$runtime\", pod=~\"argo-cd-event-reporter-$reporter_shard.+\"}\n) by(pod)", + "format": "time_series", + "fullMetaSearch": false, + "includeNullMetadata": true, + "interval": "$resolution", + "intervalFactor": 1, + "legendFormat": "__auto", + "range": true, + "refId": "A", + "useBackend": false + } + ], + "title": "Number of OS threads created", + "type": "timeseries" + } + ], + "title": "Go stats", + "type": "row" + } + ], + "refresh": "5m", + "schemaVersion": 39, + "tags": [], + "templating": { + "list": [ + { + "current": { + "selected": false, + "text": "Mimir (Production permanent retention)", + "value": "Mimir" + }, + "definition": "datasource(prometheus)", + "description": "rollout datasource", + "hide": 0, + "includeAll": false, + "label": "Datasource", + "multi": false, + "name": "datasource", + "options": [], + "query": "prometheus", + "queryValue": "", + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "type": "datasource" + }, + { + "current": {}, + "datasource": { + "type": "prometheus", + "uid": "${DS_MIMIR_(PRODUCTION PERMANENT RETENTION)}" + }, + "definition": "label_values(codefresh_event_reporter_queue_size,namespace)", + "hide": 0, + "includeAll": false, + "label": "Runtime", + "multi": false, + "name": "runtime", + "options": [], + "query": { + "qryType": 1, + "query": "label_values(codefresh_event_reporter_queue_size,namespace)", + "refId": "PrometheusVariableQueryEditor-VariableQuery" + }, + "refresh": 1, + "regex": "", + "skipUrlSync": false, + "sort": 0, + "type": "query" + }, + { + "allValue": "", + "current": {}, + "datasource": { + "type": "prometheus", + "uid": "$datasource" + }, + "definition": "label_values(codefresh_event_reporter_queue_size,reporter_shard)", + "description": "Reporter shard number", + "hide": 0, + "includeAll": true, + "label": "Shard Number", + "multi": true, + "name": "reporter_shard", + "options": [], + "query": { + "qryType": 1, + "query": "label_values(codefresh_event_reporter_queue_size,reporter_shard)", + "refId": "PrometheusVariableQueryEditor-VariableQuery" + }, + "refresh": 2, + "regex": "", + "skipUrlSync": false, + "sort": 3, + "tagValuesQuery": "", + "tagsQuery": "", + "type": "query", + "useTags": false + }, + { + "current": { + "selected": false, + "text": "reporter_shard", + "value": "reporter_shard" + }, + "hide": 0, + "includeAll": false, + "label": "Group By", + "multi": false, + "name": "group_by", + "options": [ + { + "selected": true, + "text": "reporter_shard", + "value": "reporter_shard" + }, + { + "selected": false, + "text": "application", + "value": "application" + } + ], + "query": "reporter_shard, application", + "queryValue": "", + "skipUrlSync": false, + "type": "custom" + }, + { + "current": { + "selected": false, + "text": "1m", + "value": "1m" + }, + "hide": 0, + "includeAll": false, + "multi": false, + "name": "resolution", + "options": [ + { + "selected": false, + "text": "30s", + "value": "30s" + }, + { + "selected": true, + "text": "1m", + "value": "1m" + }, + { + "selected": false, + "text": "5m", + "value": "5m" + }, + { + "selected": false, + "text": "10m", + "value": "10m" + }, + { + "selected": false, + "text": "30m", + "value": "30m" + }, + { + "selected": false, + "text": "1h", + "value": "1h" + } + ], + "query": "30s, 1m, 5m, 10m, 30m, 1h", + "queryValue": "", + "skipUrlSync": false, + "type": "custom" + } + ] + }, + "time": { + "from": "now-3h", + "to": "now" + }, + "timeRangeUpdatedDuringEditOrView": false, + "timepicker": { + "refresh_intervals": [ + "5s", + "10s", + "30s", + "1m", + "5m", + "15m", + "30m", + "1h", + "2h", + "1d" + ], + "time_options": [ + "5m", + "15m", + "1h", + "6h", + "12h", + "24h", + "2d", + "7d", + "30d" + ] + }, + "timezone": "", + "title": "Codefresh argo-cd events reporter (v2)", + "uid": "c80f9007-2398-4f05-9a87-2b06586dddef", + "version": 73, + "weekStart": "" +} \ No newline at end of file From bcbe05e187b71b590eff7cde7b856a8a8987d683 Mon Sep 17 00:00:00 2001 From: Noam Gal Date: Thu, 18 Jul 2024 17:27:42 +0300 Subject: [PATCH 02/30] fix: use JoinPath instead of string concat (#320) * use JoinPath instead of string concat --- pkg/codefresh/client.go | 7 ++- pkg/codefresh/client_test.go | 97 ++++++++++++++++++++++++++++++++++++ 2 files changed, 103 insertions(+), 1 deletion(-) create mode 100644 pkg/codefresh/client_test.go diff --git a/pkg/codefresh/client.go b/pkg/codefresh/client.go index 1dc87732a4f99..73ac1be3b9015 100644 --- a/pkg/codefresh/client.go +++ b/pkg/codefresh/client.go @@ -10,6 +10,7 @@ import ( "fmt" "io" "net/http" + "net/url" "os" "time" @@ -43,7 +44,11 @@ type GraphQLQuery struct { func (c *CodefreshClient) SendEvent(ctx context.Context, appName string, event *events.Event) error { return WithRetry(&DefaultBackoff, func() error { - url := c.cfConfig.BaseURL + "/2.0/api/events" + url, err := url.JoinPath(c.cfConfig.BaseURL, "/2.0/api/events") + if err != nil { + return fmt.Errorf("failed to join URL: %w", err) + } + log.Infof("Sending application event for %s", appName) wrappedPayload := map[string]json.RawMessage{ diff --git a/pkg/codefresh/client_test.go b/pkg/codefresh/client_test.go new file mode 100644 index 0000000000000..b8aa97aff4991 --- /dev/null +++ b/pkg/codefresh/client_test.go @@ -0,0 +1,97 @@ +package codefresh + +import ( + "compress/gzip" + "context" + "io" + "net/http" + "testing" + + "github.com/argoproj/argo-cd/v2/pkg/apiclient/events" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +type MockRoundTripper struct { + mock.Mock +} + +func (r *MockRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) { + args := r.Called(req) + + if args.Error(1) != nil { + return nil, args.Error(1) + } + + return args.Get(0).(*http.Response), args.Error(1) +} + +func TestCodefreshClient_SendEvent(t *testing.T) { + tests := []struct { + name string + baseURL string + authToken string + payload []byte + wantErr string + beforeFn func(t *testing.T, rt *MockRoundTripper) + }{ + { + name: "should return nil when all is good", + baseURL: "http://some.host", + authToken: "some-token", + payload: []byte(`{"key": "value"}`), + beforeFn: func(t *testing.T, rt *MockRoundTripper) { + rt.On("RoundTrip", mock.Anything).Run(func(args mock.Arguments) { + req := args.Get(0).(*http.Request) + assert.Equal(t, "POST", req.Method, "invalid request method") + assert.Equal(t, "http://some.host/2.0/api/events", req.URL.String(), "invalid request URL") + assert.Equal(t, "some-token", req.Header.Get("Authorization"), "missing or invalid Authorization header") + assert.Equal(t, "application/json", req.Header.Get("Content-Type"), "missing or invalid Content-Type header") + reader, err := gzip.NewReader(req.Body) + assert.NoError(t, err, "failed to create gzip reader") + defer reader.Close() + body, err := io.ReadAll(reader) + assert.NoError(t, err, "failed to read request body") + assert.JSONEq(t, `{"data":{"key":"value"}}`, string(body), "invalid request body") + }).Return(&http.Response{ + StatusCode: 200, + }, nil) + }, + }, + { + name: "should create correct url when baseUrl ends with '/'", + baseURL: "http://some.host/", + authToken: "some-token", + payload: []byte(`{"key": "value"}`), + beforeFn: func(t *testing.T, rt *MockRoundTripper) { + rt.On("RoundTrip", mock.Anything).Run(func(args mock.Arguments) { + req := args.Get(0).(*http.Request) + assert.Equal(t, "http://some.host/2.0/api/events", req.URL.String(), "invalid request URL") + }).Return(&http.Response{ + StatusCode: 200, + }, nil) + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + mockRT := &MockRoundTripper{} + c := &CodefreshClient{ + cfConfig: &CodefreshConfig{ + BaseURL: tt.baseURL, + AuthToken: tt.authToken, + }, + httpClient: &http.Client{ + Transport: mockRT, + }, + } + event := &events.Event{ + Payload: tt.payload, + } + tt.beforeFn(t, mockRT) + if err := c.SendEvent(context.Background(), "appName", event); err != nil || tt.wantErr != "" { + assert.EqualError(t, err, tt.wantErr) + } + }) + } +} From 8eb51f7a6328665b840f46c30c247e9f7318cd91 Mon Sep 17 00:00:00 2001 From: pasha-codefresh Date: Sat, 20 Jul 2024 19:41:53 +0300 Subject: [PATCH 03/30] fix: wh improvement (#321) * wh improvement * fix build err --- server/server.go | 2 +- util/settings/settings.go | 26 ++++++++++++++++++++++++++ util/webhook/webhook.go | 15 +++++++++++++-- util/webhook/webhook_test.go | 27 +++++++++++++++++++++++++-- 4 files changed, 65 insertions(+), 5 deletions(-) diff --git a/server/server.go b/server/server.go index 2ce70a933742b..b8f0fc1a76dee 100644 --- a/server/server.go +++ b/server/server.go @@ -1048,7 +1048,7 @@ func (a *ArgoCDServer) newHTTPServer(ctx context.Context, port int, grpcWebHandl // Webhook handler for git events (Note: cache timeouts are hardcoded because API server does not write to cache and not really using them) argoDB := db.NewDB(a.Namespace, a.settingsMgr, a.KubeClientset) - acdWebhookHandler := webhook.NewHandler(a.Namespace, a.ArgoCDServerOpts.ApplicationNamespaces, a.AppClientset, a.settings, a.settingsMgr, a.RepoServerCache, a.Cache, argoDB) + acdWebhookHandler := webhook.NewHandler(a.Namespace, a.ArgoCDServerOpts.ApplicationNamespaces, a.AppClientset, a.settings, a.settingsMgr, a.RepoServerCache, a.Cache, argoDB, a.settingsMgr.GetMaxWebhookPayloadSize()) mux.HandleFunc("/api/webhook", acdWebhookHandler.Handler) diff --git a/util/settings/settings.go b/util/settings/settings.go index 8cf7f8bec1dcc..316f78fc4af2c 100644 --- a/util/settings/settings.go +++ b/util/settings/settings.go @@ -442,6 +442,8 @@ const ( settingsWebhookAzureDevOpsUsernameKey = "webhook.azuredevops.username" // settingsWebhookAzureDevOpsPasswordKey is the key for Azure DevOps webhook password settingsWebhookAzureDevOpsPasswordKey = "webhook.azuredevops.password" + // settingsWebhookMaxPayloadSize is the key for the maximum payload size for webhooks in MB + settingsWebhookMaxPayloadSizeMB = "webhook.maxPayloadSizeMB" // settingsApplicationInstanceLabelKey is the key to configure injected app instance label key settingsApplicationInstanceLabelKey = "application.instanceLabelKey" // settingsCodefreshReporterVersion is the key to configure injected app instance label key @@ -525,6 +527,11 @@ const ( kustomizeSetNamespaceEnabledKey = "kustomize.setNamespace.enabled" ) +const ( + // default max webhook payload size is 1GB + defaultMaxWebhookPayloadSize = int64(1) * 1024 * 1024 * 1024 +) + var ( sourceTypeToEnableGenerationKey = map[v1alpha1.ApplicationSourceType]string{ v1alpha1.ApplicationSourceTypeKustomize: "kustomize.enable", @@ -2262,3 +2269,22 @@ func (mgr *SettingsManager) GetResourceCustomLabels() ([]string, error) { } return []string{}, nil } + +func (mgr *SettingsManager) GetMaxWebhookPayloadSize() int64 { + argoCDCM, err := mgr.getConfigMap() + if err != nil { + return defaultMaxWebhookPayloadSize + } + + if argoCDCM.Data[settingsWebhookMaxPayloadSizeMB] == "" { + return defaultMaxWebhookPayloadSize + } + + maxPayloadSizeMB, err := strconv.ParseInt(argoCDCM.Data[settingsWebhookMaxPayloadSizeMB], 10, 64) + if err != nil { + log.Warnf("Failed to parse '%s' key: %v", settingsWebhookMaxPayloadSizeMB, err) + return defaultMaxWebhookPayloadSize + } + + return maxPayloadSizeMB * 1024 * 1024 +} diff --git a/util/webhook/webhook.go b/util/webhook/webhook.go index dab69d7b131b7..1da0a0efa2d9c 100644 --- a/util/webhook/webhook.go +++ b/util/webhook/webhook.go @@ -61,9 +61,10 @@ type ArgoCDWebhookHandler struct { azuredevopsAuthHandler func(r *http.Request) error gogs *gogs.Webhook settingsSrc settingsSource + maxWebhookPayloadSizeB int64 } -func NewHandler(namespace string, applicationNamespaces []string, appClientset appclientset.Interface, set *settings.ArgoCDSettings, settingsSrc settingsSource, repoCache *cache.Cache, serverCache *servercache.Cache, argoDB db.ArgoDB) *ArgoCDWebhookHandler { +func NewHandler(namespace string, applicationNamespaces []string, appClientset appclientset.Interface, set *settings.ArgoCDSettings, settingsSrc settingsSource, repoCache *cache.Cache, serverCache *servercache.Cache, argoDB db.ArgoDB, maxWebhookPayloadSizeB int64) *ArgoCDWebhookHandler { githubWebhook, err := github.New(github.Options.Secret(set.WebhookGitHubSecret)) if err != nil { log.Warnf("Unable to init the GitHub webhook") @@ -113,6 +114,7 @@ func NewHandler(namespace string, applicationNamespaces []string, appClientset a repoCache: repoCache, serverCache: serverCache, db: argoDB, + maxWebhookPayloadSizeB: maxWebhookPayloadSizeB, } return &acdWebhook @@ -384,10 +386,11 @@ func sourceUsesURL(source v1alpha1.ApplicationSource, webURL string, repoRegexp } func (a *ArgoCDWebhookHandler) Handler(w http.ResponseWriter, r *http.Request) { - var payload interface{} var err error + r.Body = http.MaxBytesReader(w, r.Body, a.maxWebhookPayloadSizeB) + switch { case r.Header.Get("X-Vss-Activityid") != "": if err = a.azuredevopsAuthHandler(r); err != nil { @@ -430,6 +433,14 @@ func (a *ArgoCDWebhookHandler) Handler(w http.ResponseWriter, r *http.Request) { } if err != nil { + // If the error is due to a large payload, return a more user-friendly error message + if err.Error() == "error parsing payload" { + msg := fmt.Sprintf("Webhook processing failed: The payload is either too large or corrupted. Please check the payload size (must be under %v MB) and ensure it is valid JSON", a.maxWebhookPayloadSizeB/1024/1024) + log.WithField(common.SecurityField, common.SecurityHigh).Warn(msg) + http.Error(w, msg, http.StatusBadRequest) + return + } + log.Infof("Webhook processing failed: %s", err) status := http.StatusBadRequest if r.Method != http.MethodPost { diff --git a/util/webhook/webhook_test.go b/util/webhook/webhook_test.go index a32d7205bcd07..a96a59831b4ac 100644 --- a/util/webhook/webhook_test.go +++ b/util/webhook/webhook_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "github.com/stretchr/testify/require" "io" "net/http" "net/http/httptest" @@ -56,6 +57,11 @@ type reactorDef struct { } func NewMockHandler(reactor *reactorDef, applicationNamespaces []string, objects ...runtime.Object) *ArgoCDWebhookHandler { + defaultMaxPayloadSize := int64(1) * 1024 * 1024 * 1024 + return NewMockHandlerWithPayloadLimit(reactor, applicationNamespaces, defaultMaxPayloadSize, objects...) +} + +func NewMockHandlerWithPayloadLimit(reactor *reactorDef, applicationNamespaces []string, maxPayloadSize int64, objects ...runtime.Object) *ArgoCDWebhookHandler { appClientset := appclientset.NewSimpleClientset(objects...) if reactor != nil { defaultReactor := appClientset.ReactionChain[0] @@ -73,7 +79,7 @@ func NewMockHandler(reactor *reactorDef, applicationNamespaces []string, objects 1*time.Minute, 10*time.Second, 1*time.Minute, - ), servercache.NewCache(appstate.NewCache(cacheClient, time.Minute), time.Minute, time.Minute, time.Minute), &mocks.ArgoDB{}) + ), servercache.NewCache(appstate.NewCache(cacheClient, time.Minute), time.Minute, time.Minute, time.Minute), &mocks.ArgoDB{}, maxPayloadSize) } func TestGitHubCommitEvent(t *testing.T) { @@ -394,7 +400,7 @@ func TestInvalidEvent(t *testing.T) { w := httptest.NewRecorder() h.Handler(w, req) assert.Equal(t, w.Code, http.StatusBadRequest) - expectedLogResult := "Webhook processing failed: error parsing payload" + expectedLogResult := "Webhook processing failed: The payload is either too large or corrupted. Please check the payload size (must be under 1024 MB) and ensure it is valid JSON" assert.Equal(t, expectedLogResult, hook.LastEntry().Message) assert.Equal(t, expectedLogResult+"\n", w.Body.String()) hook.Reset() @@ -605,3 +611,20 @@ func Test_getWebUrlRegex(t *testing.T) { }) } } + +func TestGitHubCommitEventMaxPayloadSize(t *testing.T) { + hook := test.NewGlobal() + maxPayloadSize := int64(100) + h := NewMockHandlerWithPayloadLimit(nil, []string{}, maxPayloadSize) + req := httptest.NewRequest(http.MethodPost, "/api/webhook", nil) + req.Header.Set("X-GitHub-Event", "push") + eventJSON, err := os.ReadFile("testdata/github-commit-event.json") + require.NoError(t, err) + req.Body = io.NopCloser(bytes.NewReader(eventJSON)) + w := httptest.NewRecorder() + h.Handler(w, req) + assert.Equal(t, http.StatusBadRequest, w.Code) + expectedLogResult := "Webhook processing failed: The payload is either too large or corrupted. Please check the payload size (must be under 0 MB) and ensure it is valid JSON" + assert.Equal(t, expectedLogResult, hook.LastEntry().Message) + hook.Reset() +} From fcda44e7b7dea8f1f3e27edb3b908242de59439e Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Sat, 20 Jul 2024 19:43:43 +0300 Subject: [PATCH 04/30] chore: update version to 2.11-2024.7.20-8eb51f7a6 --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.7.20-8eb51f7a6.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.7.20-8eb51f7a6.md diff --git a/VERSION b/VERSION index f1a89ce325dfd..d60b96e4f837b 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.7.3-c0941bcb4 \ No newline at end of file +2.11-2024.7.20-8eb51f7a6 \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.7.20-8eb51f7a6.md b/changelog/CHANGELOG-2.11-2024.7.20-8eb51f7a6.md new file mode 100644 index 0000000000000..623b92cc75ad0 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.7.20-8eb51f7a6.md @@ -0,0 +1,2 @@ +### Fix +- fix event reporter base path for codefresh client \ No newline at end of file From c787eab886dbb2dcf590f940c6437f9fcece30ab Mon Sep 17 00:00:00 2001 From: pasha-codefresh Date: Tue, 30 Jul 2024 11:14:13 +0300 Subject: [PATCH 05/30] fix: monorepo selfheal should not happens if manifest is the same (#322) * fix: monorepo selfheal should not happens if manifest is the same * fix: monorepo selfheal should not happens if manifest is the same * generate manifests --- assets/swagger.json | 7 + controller/appcontroller.go | 8 +- controller/appcontroller_test.go | 52 + controller/hook.go | 2 +- controller/state.go | 60 +- manifests/core-install.yaml | 7 + manifests/crds/application-crd.yaml | 7 + manifests/ha/install.yaml | 7 + manifests/install.yaml | 7 + pkg/apis/application/v1alpha1/generated.pb.go | 1557 +++++++++-------- pkg/apis/application/v1alpha1/generated.proto | 3 + .../application/v1alpha1/openapi_generated.go | 16 + pkg/apis/application/v1alpha1/types.go | 2 + .../v1alpha1/zz_generated.deepcopy.go | 7 + 14 files changed, 1019 insertions(+), 723 deletions(-) diff --git a/assets/swagger.json b/assets/swagger.json index c3f8125d0336f..1e467c4aa18bc 100644 --- a/assets/swagger.json +++ b/assets/swagger.json @@ -9302,6 +9302,13 @@ "comparedTo": { "$ref": "#/definitions/v1alpha1ComparedTo" }, + "manifestsChanged": { + "type": "object", + "title": "ManifestsChanged indicates whether the manifests have changed base on argocd.argoproj.io/manifest-generate-paths annotation", + "additionalProperties": { + "type": "boolean" + } + }, "revision": { "type": "string", "title": "Revision contains information about the revision the comparison has been performed to" diff --git a/controller/appcontroller.go b/controller/appcontroller.go index 067be4408d90e..63d273925fec6 100644 --- a/controller/appcontroller.go +++ b/controller/appcontroller.go @@ -8,6 +8,7 @@ import ( "math" "math/rand" "net/http" + "os" "reflect" "runtime/debug" "sort" @@ -1959,8 +1960,11 @@ func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS return false, "" } } else { - if app.Status.OperationState.SyncResult.Revision != commitSHA { - return false, "" + manifestsChangedMap := app.Status.Sync.ManifestsChanged + if os.Getenv("PERSIST_CHANGE_REVISIONS") != "1" || manifestsChangedMap[commitSHA] { + if app.Status.OperationState.SyncResult.Revision != commitSHA { + return false, "" + } } } diff --git a/controller/appcontroller_test.go b/controller/appcontroller_test.go index 1e331e8bc4a47..4de765a389481 100644 --- a/controller/appcontroller_test.go +++ b/controller/appcontroller_test.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "errors" + "os" "testing" "time" @@ -1929,3 +1930,54 @@ func TestAddControllerNamespace(t *testing.T) { assert.Equal(t, test.FakeArgoCDNamespace, updatedApp.Status.ControllerNamespace) }) } + +func TestAlreadyAttemptSync(t *testing.T) { + app := newFakeApp() + t.Run("same manifest with sync result, with disabled flag", func(t *testing.T) { + + manifestChangedMap := make(map[string]bool) + manifestChangedMap["sha"] = false + + app.Status.Sync.ManifestsChanged = manifestChangedMap + + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + assert.False(t, attempted) + }) + + t.Run("same manifest with sync result, with enabled flag", func(t *testing.T) { + + _ = os.Setenv("PERSIST_CHANGE_REVISIONS", "1") + + manifestChangedMap := make(map[string]bool) + manifestChangedMap["sha"] = false + + app.Status.Sync.ManifestsChanged = manifestChangedMap + + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + assert.True(t, attempted) + }) + + t.Run("different manifest with sync result, with disabled flag", func(t *testing.T) { + + manifestChangedMap := make(map[string]bool) + manifestChangedMap["sha"] = true + + app.Status.Sync.ManifestsChanged = manifestChangedMap + + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + assert.False(t, attempted) + }) + + t.Run("different manifest with sync result, with enabled flag", func(t *testing.T) { + + _ = os.Setenv("PERSIST_CHANGE_REVISIONS", "1") + + manifestChangedMap := make(map[string]bool) + manifestChangedMap["sha"] = true + + app.Status.Sync.ManifestsChanged = manifestChangedMap + + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + assert.False(t, attempted) + }) +} diff --git a/controller/hook.go b/controller/hook.go index 0c019ac6a1e08..25fe4e9f32d64 100644 --- a/controller/hook.go +++ b/controller/hook.go @@ -51,7 +51,7 @@ func (ctrl *ApplicationController) executePostDeleteHooks(app *v1alpha1.Applicat revisions = append(revisions, src.TargetRevision) } - targets, _, err := ctrl.appStateManager.GetRepoObjs(app, app.Spec.GetSources(), appLabelKey, revisions, false, false, false, proj) + targets, _, _, err := ctrl.appStateManager.GetRepoObjs(app, app.Spec.GetSources(), appLabelKey, revisions, false, false, false, proj) if err != nil { return false, err } diff --git a/controller/state.go b/controller/state.go index 6b990958afe4f..e85c227fe8ad4 100644 --- a/controller/state.go +++ b/controller/state.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "os" "reflect" "strings" goSync "sync" @@ -73,7 +74,7 @@ type managedResource struct { type AppStateManager interface { CompareAppState(app *v1alpha1.Application, project *v1alpha1.AppProject, revisions []string, sources []v1alpha1.ApplicationSource, noCache bool, noRevisionCache bool, localObjects []string, hasMultipleSources bool) (*comparisonResult, error) SyncAppState(app *v1alpha1.Application, state *v1alpha1.OperationState) - GetRepoObjs(app *v1alpha1.Application, sources []v1alpha1.ApplicationSource, appLabelKey string, revisions []string, noCache, noRevisionCache, verifySignature bool, proj *v1alpha1.AppProject) ([]*unstructured.Unstructured, []*apiclient.ManifestResponse, error) + GetRepoObjs(app *v1alpha1.Application, sources []v1alpha1.ApplicationSource, appLabelKey string, revisions []string, noCache, noRevisionCache, verifySignature bool, proj *v1alpha1.AppProject) ([]*unstructured.Unstructured, []*apiclient.ManifestResponse, map[string]bool, error) } // comparisonResult holds the state of an application after the reconciliation @@ -126,51 +127,51 @@ type appStateManager struct { // task to the repo-server. It returns the list of generated manifests as unstructured // objects. It also returns the full response from all calls to the repo server as the // second argument. -func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alpha1.ApplicationSource, appLabelKey string, revisions []string, noCache, noRevisionCache, verifySignature bool, proj *v1alpha1.AppProject) ([]*unstructured.Unstructured, []*apiclient.ManifestResponse, error) { +func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alpha1.ApplicationSource, appLabelKey string, revisions []string, noCache, noRevisionCache, verifySignature bool, proj *v1alpha1.AppProject) ([]*unstructured.Unstructured, []*apiclient.ManifestResponse, map[string]bool, error) { ts := stats.NewTimingStats() helmRepos, err := m.db.ListHelmRepositories(context.Background()) if err != nil { - return nil, nil, fmt.Errorf("failed to list Helm repositories: %w", err) + return nil, nil, nil, fmt.Errorf("failed to list Helm repositories: %w", err) } permittedHelmRepos, err := argo.GetPermittedRepos(proj, helmRepos) if err != nil { - return nil, nil, fmt.Errorf("failed to get permitted Helm repositories for project %q: %w", proj.Name, err) + return nil, nil, nil, fmt.Errorf("failed to get permitted Helm repositories for project %q: %w", proj.Name, err) } ts.AddCheckpoint("repo_ms") helmRepositoryCredentials, err := m.db.GetAllHelmRepositoryCredentials(context.Background()) if err != nil { - return nil, nil, fmt.Errorf("failed to get Helm credentials: %w", err) + return nil, nil, nil, fmt.Errorf("failed to get Helm credentials: %w", err) } permittedHelmCredentials, err := argo.GetPermittedReposCredentials(proj, helmRepositoryCredentials) if err != nil { - return nil, nil, fmt.Errorf("failed to get permitted Helm credentials for project %q: %w", proj.Name, err) + return nil, nil, nil, fmt.Errorf("failed to get permitted Helm credentials for project %q: %w", proj.Name, err) } enabledSourceTypes, err := m.settingsMgr.GetEnabledSourceTypes() if err != nil { - return nil, nil, fmt.Errorf("failed to get enabled source types: %w", err) + return nil, nil, nil, fmt.Errorf("failed to get enabled source types: %w", err) } ts.AddCheckpoint("plugins_ms") kustomizeSettings, err := m.settingsMgr.GetKustomizeSettings() if err != nil { - return nil, nil, fmt.Errorf("failed to get Kustomize settings: %w", err) + return nil, nil, nil, fmt.Errorf("failed to get Kustomize settings: %w", err) } helmOptions, err := m.settingsMgr.GetHelmSettings() if err != nil { - return nil, nil, fmt.Errorf("failed to get Helm settings: %w", err) + return nil, nil, nil, fmt.Errorf("failed to get Helm settings: %w", err) } ts.AddCheckpoint("build_options_ms") serverVersion, apiResources, err := m.liveStateCache.GetVersionsInfo(app.Spec.Destination.Server) if err != nil { - return nil, nil, fmt.Errorf("failed to get cluster version for cluster %q: %w", app.Spec.Destination.Server, err) + return nil, nil, nil, fmt.Errorf("failed to get cluster version for cluster %q: %w", app.Spec.Destination.Server, err) } conn, repoClient, err := m.repoClientset.NewRepoServerClient() if err != nil { - return nil, nil, fmt.Errorf("failed to connect to repo server: %w", err) + return nil, nil, nil, fmt.Errorf("failed to connect to repo server: %w", err) } defer io.Close(conn) @@ -180,9 +181,11 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp // Store the map of all sources having ref field into a map for applications with sources field refSources, err := argo.GetRefSources(context.Background(), app.Spec, m.db) if err != nil { - return nil, nil, fmt.Errorf("failed to get ref sources: %v", err) + return nil, nil, nil, fmt.Errorf("failed to get ref sources: %v", err) } + manifestsChanges := make(map[string]bool) + for i, source := range sources { if len(revisions) < len(sources) || revisions[i] == "" { revisions[i] = source.TargetRevision @@ -190,11 +193,11 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp ts.AddCheckpoint("helm_ms") repo, err := m.db.GetRepository(context.Background(), source.RepoURL) if err != nil { - return nil, nil, fmt.Errorf("failed to get repo %q: %w", source.RepoURL, err) + return nil, nil, nil, fmt.Errorf("failed to get repo %q: %w", source.RepoURL, err) } kustomizeOptions, err := kustomizeSettings.GetOptions(source, m.settingsMgr.GetKustomizeSetNamespaceEnabled()) if err != nil { - return nil, nil, fmt.Errorf("failed to get Kustomize options for source %d of %d: %w", i+1, len(sources), err) + return nil, nil, nil, fmt.Errorf("failed to get Kustomize options for source %d of %d: %w", i+1, len(sources), err) } syncedRevision := app.Status.Sync.Revision @@ -209,7 +212,7 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp val, ok := app.Annotations[v1alpha1.AnnotationKeyManifestGeneratePaths] if !source.IsHelm() && syncedRevision != "" && ok && val != "" { // Validate the manifest-generate-path annotation to avoid generating manifests if it has not changed. - _, err = repoClient.UpdateRevisionForPaths(context.Background(), &apiclient.UpdateRevisionForPathsRequest{ + updateRevisionResponse, err := repoClient.UpdateRevisionForPaths(context.Background(), &apiclient.UpdateRevisionForPathsRequest{ Repo: repo, Revision: revisions[i], SyncedRevision: syncedRevision, @@ -224,8 +227,13 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp RefSources: refSources, HasMultipleSources: app.Spec.HasMultipleSources(), }) + + // not need to change, if we already found at least one cached revision that has no changes + if updateRevisionResponse != nil && os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { + manifestsChanges[syncedRevision] = updateRevisionResponse.Changes + } if err != nil { - return nil, nil, fmt.Errorf("failed to compare revisions for source %d of %d: %w", i+1, len(sources), err) + return nil, nil, nil, fmt.Errorf("failed to compare revisions for source %d of %d: %w", i+1, len(sources), err) } } @@ -256,13 +264,13 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp ApplicationMetadata: &app.ObjectMeta, }) if err != nil { - return nil, nil, fmt.Errorf("failed to generate manifest for source %d of %d: %w", i+1, len(sources), err) + return nil, nil, nil, fmt.Errorf("failed to generate manifest for source %d of %d: %w", i+1, len(sources), err) } targetObj, err := unmarshalManifests(manifestInfo.GetCompiledManifests()) if err != nil { - return nil, nil, fmt.Errorf("failed to unmarshal manifests for source %d of %d: %w", i+1, len(sources), err) + return nil, nil, nil, fmt.Errorf("failed to unmarshal manifests for source %d of %d: %w", i+1, len(sources), err) } targetObjs = append(targetObjs, targetObj...) @@ -276,7 +284,7 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp } logCtx = logCtx.WithField("time_ms", time.Since(ts.StartTime).Milliseconds()) logCtx.Info("GetRepoObjs stats") - return targetObjs, manifestInfos, nil + return targetObjs, manifestInfos, manifestsChanges, nil } func unmarshalManifests(manifests []string) ([]*unstructured.Unstructured, error) { @@ -444,6 +452,8 @@ func (m *appStateManager) CompareAppState(app *v1alpha1.Application, project *v1 var manifestInfos []*apiclient.ManifestResponse targetNsExists := false + var manifestChanged map[string]bool + if len(localManifests) == 0 { // If the length of revisions is not same as the length of sources, // we take the revisions from the sources directly for all the sources. @@ -454,7 +464,7 @@ func (m *appStateManager) CompareAppState(app *v1alpha1.Application, project *v1 } } - targetObjs, manifestInfos, err = m.GetRepoObjs(app, sources, appLabelKey, revisions, noCache, noRevisionCache, verifySignature, project) + targetObjs, manifestInfos, manifestChanged, err = m.GetRepoObjs(app, sources, appLabelKey, revisions, noCache, noRevisionCache, verifySignature, project) if err != nil { targetObjs = make([]*unstructured.Unstructured, 0) msg := fmt.Sprintf("Failed to load target state: %s", err.Error()) @@ -828,8 +838,9 @@ func (m *appStateManager) CompareAppState(app *v1alpha1.Application, project *v1 Sources: sources, IgnoreDifferences: app.Spec.IgnoreDifferences, }, - Status: syncCode, - Revisions: manifestRevisions, + Status: syncCode, + Revisions: manifestRevisions, + ManifestsChanged: manifestChanged, } } else { syncStatus = v1alpha1.SyncStatus{ @@ -838,8 +849,9 @@ func (m *appStateManager) CompareAppState(app *v1alpha1.Application, project *v1 Source: app.Spec.GetSource(), IgnoreDifferences: app.Spec.IgnoreDifferences, }, - Status: syncCode, - Revision: revision, + Status: syncCode, + Revision: revision, + ManifestsChanged: manifestChanged, } } diff --git a/manifests/core-install.yaml b/manifests/core-install.yaml index 7f9ea4bd4b665..9a6eb8fa99c4c 100644 --- a/manifests/core-install.yaml +++ b/manifests/core-install.yaml @@ -5036,6 +5036,13 @@ spec: required: - destination type: object + manifestsChanged: + additionalProperties: + type: boolean + description: ManifestsChanged indicates whether the manifests + have changed base on argocd.argoproj.io/manifest-generate-paths + annotation + type: object revision: description: Revision contains information about the revision the comparison has been performed to diff --git a/manifests/crds/application-crd.yaml b/manifests/crds/application-crd.yaml index 77924b96eb068..b1d85acde1e5d 100644 --- a/manifests/crds/application-crd.yaml +++ b/manifests/crds/application-crd.yaml @@ -5035,6 +5035,13 @@ spec: required: - destination type: object + manifestsChanged: + additionalProperties: + type: boolean + description: ManifestsChanged indicates whether the manifests + have changed base on argocd.argoproj.io/manifest-generate-paths + annotation + type: object revision: description: Revision contains information about the revision the comparison has been performed to diff --git a/manifests/ha/install.yaml b/manifests/ha/install.yaml index 6f23be6ed6338..ffa5b1a87cfa3 100644 --- a/manifests/ha/install.yaml +++ b/manifests/ha/install.yaml @@ -5036,6 +5036,13 @@ spec: required: - destination type: object + manifestsChanged: + additionalProperties: + type: boolean + description: ManifestsChanged indicates whether the manifests + have changed base on argocd.argoproj.io/manifest-generate-paths + annotation + type: object revision: description: Revision contains information about the revision the comparison has been performed to diff --git a/manifests/install.yaml b/manifests/install.yaml index 980040e36f59b..2370941eb9fc1 100644 --- a/manifests/install.yaml +++ b/manifests/install.yaml @@ -5036,6 +5036,13 @@ spec: required: - destination type: object + manifestsChanged: + additionalProperties: + type: boolean + description: ManifestsChanged indicates whether the manifests + have changed base on argocd.argoproj.io/manifest-generate-paths + annotation + type: object revision: description: Revision contains information about the revision the comparison has been performed to diff --git a/pkg/apis/application/v1alpha1/generated.pb.go b/pkg/apis/application/v1alpha1/generated.pb.go index bdf0790efa0ad..360825e584d64 100644 --- a/pkg/apis/application/v1alpha1/generated.pb.go +++ b/pkg/apis/application/v1alpha1/generated.pb.go @@ -4466,6 +4466,7 @@ func init() { proto.RegisterType((*SyncPolicy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncPolicy") proto.RegisterType((*SyncPolicyAutomated)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncPolicyAutomated") proto.RegisterType((*SyncStatus)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncStatus") + proto.RegisterMapType((map[string]bool)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncStatus.ManifestsChangedEntry") proto.RegisterType((*SyncStrategy)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncStrategy") proto.RegisterType((*SyncStrategyApply)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncStrategyApply") proto.RegisterType((*SyncStrategyHook)(nil), "github.com.argoproj.argo_cd.v2.pkg.apis.application.v1alpha1.SyncStrategyHook") @@ -4479,702 +4480,705 @@ func init() { } var fileDescriptor_030104ce3b95bcac = []byte{ - // 11119 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0x7d, 0x6d, 0x70, 0x24, 0xc7, - 0x75, 0x98, 0x66, 0x17, 0x0b, 0xec, 0x3e, 0x7c, 0xdd, 0xf5, 0xdd, 0x91, 0xb8, 0x13, 0x49, 0x9c, - 0x87, 0x36, 0x45, 0x47, 0x24, 0x60, 0x9e, 0x48, 0x99, 0x11, 0x6d, 0xc9, 0xf8, 0xb8, 0xc3, 0xe1, - 0x0e, 0x38, 0x80, 0x0d, 0xdc, 0x9d, 0x44, 0x99, 0xa2, 0x06, 0xbb, 0x8d, 0xc5, 0x1c, 0x66, 0x67, - 0x86, 0x33, 0xb3, 0x38, 0x80, 0x96, 0x64, 0xc9, 0x92, 0x6d, 0x25, 0xfa, 0xa0, 0x42, 0x25, 0x65, - 0x3a, 0xb1, 0x14, 0xd9, 0x72, 0x52, 0x71, 0x25, 0xaa, 0x38, 0xc9, 0x8f, 0x38, 0x72, 0xaa, 0x5c, - 0xb6, 0x53, 0x29, 0xa5, 0x14, 0x97, 0x5d, 0x2e, 0x97, 0xe5, 0x24, 0x36, 0x22, 0x5d, 0x2a, 0x95, - 0x54, 0xaa, 0xe2, 0x2a, 0x27, 0xfe, 0x91, 0x5c, 0xf2, 0x23, 0xd5, 0xdf, 0x3d, 0xb3, 0xb3, 0xc0, - 0x02, 0x18, 0xdc, 0x1d, 0x15, 0xfe, 0xdb, 0xed, 0xf7, 0xe6, 0xbd, 0x9e, 0x9e, 0xee, 0xf7, 0x5e, - 0xbf, 0x7e, 0xef, 0x35, 0x2c, 0x34, 0xdd, 0x64, 0xa3, 0xbd, 0x36, 0x51, 0x0f, 0x5a, 0x93, 0x4e, - 0xd4, 0x0c, 0xc2, 0x28, 0xb8, 0xc5, 0x7e, 0x3c, 0x5d, 0x6f, 0x4c, 0x6e, 0x5d, 0x98, 0x0c, 0x37, - 0x9b, 0x93, 0x4e, 0xe8, 0xc6, 0x93, 0x4e, 0x18, 0x7a, 0x6e, 0xdd, 0x49, 0xdc, 0xc0, 0x9f, 0xdc, - 0x7a, 0xc6, 0xf1, 0xc2, 0x0d, 0xe7, 0x99, 0xc9, 0x26, 0xf1, 0x49, 0xe4, 0x24, 0xa4, 0x31, 0x11, - 0x46, 0x41, 0x12, 0xa0, 0x1f, 0xd3, 0xd4, 0x26, 0x24, 0x35, 0xf6, 0xe3, 0x95, 0x7a, 0x63, 0x62, - 0xeb, 0xc2, 0x44, 0xb8, 0xd9, 0x9c, 0xa0, 0xd4, 0x26, 0x0c, 0x6a, 0x13, 0x92, 0xda, 0xb9, 0xa7, - 0x8d, 0xbe, 0x34, 0x83, 0x66, 0x30, 0xc9, 0x88, 0xae, 0xb5, 0xd7, 0xd9, 0x3f, 0xf6, 0x87, 0xfd, - 0xe2, 0xcc, 0xce, 0xd9, 0x9b, 0xcf, 0xc7, 0x13, 0x6e, 0x40, 0xbb, 0x37, 0x59, 0x0f, 0x22, 0x32, - 0xb9, 0xd5, 0xd1, 0xa1, 0x73, 0x97, 0x35, 0x0e, 0xd9, 0x4e, 0x88, 0x1f, 0xbb, 0x81, 0x1f, 0x3f, - 0x4d, 0xbb, 0x40, 0xa2, 0x2d, 0x12, 0x99, 0xaf, 0x67, 0x20, 0xe4, 0x51, 0x7a, 0x56, 0x53, 0x6a, - 0x39, 0xf5, 0x0d, 0xd7, 0x27, 0xd1, 0x8e, 0x7e, 0xbc, 0x45, 0x12, 0x27, 0xef, 0xa9, 0xc9, 0x6e, - 0x4f, 0x45, 0x6d, 0x3f, 0x71, 0x5b, 0xa4, 0xe3, 0x81, 0xf7, 0xee, 0xf7, 0x40, 0x5c, 0xdf, 0x20, - 0x2d, 0xa7, 0xe3, 0xb9, 0xf7, 0x74, 0x7b, 0xae, 0x9d, 0xb8, 0xde, 0xa4, 0xeb, 0x27, 0x71, 0x12, - 0x65, 0x1f, 0xb2, 0x7f, 0xc9, 0x82, 0xe1, 0xa9, 0x9b, 0x2b, 0x53, 0xed, 0x64, 0x63, 0x26, 0xf0, - 0xd7, 0xdd, 0x26, 0x7a, 0x0e, 0x06, 0xeb, 0x5e, 0x3b, 0x4e, 0x48, 0x74, 0xcd, 0x69, 0x91, 0x31, - 0xeb, 0xbc, 0xf5, 0x64, 0x6d, 0xfa, 0xd4, 0xb7, 0x76, 0xc7, 0xdf, 0x71, 0x67, 0x77, 0x7c, 0x70, - 0x46, 0x83, 0xb0, 0x89, 0x87, 0x7e, 0x18, 0x06, 0xa2, 0xc0, 0x23, 0x53, 0xf8, 0xda, 0x58, 0x89, - 0x3d, 0x32, 0x2a, 0x1e, 0x19, 0xc0, 0xbc, 0x19, 0x4b, 0x38, 0x45, 0x0d, 0xa3, 0x60, 0xdd, 0xf5, - 0xc8, 0x58, 0x39, 0x8d, 0xba, 0xcc, 0x9b, 0xb1, 0x84, 0xdb, 0x7f, 0x5c, 0x02, 0x98, 0x0a, 0xc3, - 0xe5, 0x28, 0xb8, 0x45, 0xea, 0x09, 0xfa, 0x28, 0x54, 0xe9, 0x30, 0x37, 0x9c, 0xc4, 0x61, 0x1d, - 0x1b, 0xbc, 0xf0, 0x23, 0x13, 0xfc, 0xad, 0x27, 0xcc, 0xb7, 0xd6, 0x93, 0x8c, 0x62, 0x4f, 0x6c, - 0x3d, 0x33, 0xb1, 0xb4, 0x46, 0x9f, 0x5f, 0x24, 0x89, 0x33, 0x8d, 0x04, 0x33, 0xd0, 0x6d, 0x58, - 0x51, 0x45, 0x3e, 0xf4, 0xc5, 0x21, 0xa9, 0xb3, 0x77, 0x18, 0xbc, 0xb0, 0x30, 0x71, 0x94, 0xd9, - 0x3c, 0xa1, 0x7b, 0xbe, 0x12, 0x92, 0xfa, 0xf4, 0x90, 0xe0, 0xdc, 0x47, 0xff, 0x61, 0xc6, 0x07, - 0x6d, 0x41, 0x7f, 0x9c, 0x38, 0x49, 0x3b, 0x66, 0x43, 0x31, 0x78, 0xe1, 0x5a, 0x61, 0x1c, 0x19, - 0xd5, 0xe9, 0x11, 0xc1, 0xb3, 0x9f, 0xff, 0xc7, 0x82, 0x9b, 0xfd, 0x67, 0x16, 0x8c, 0x68, 0xe4, - 0x05, 0x37, 0x4e, 0xd0, 0x4f, 0x76, 0x0c, 0xee, 0x44, 0x6f, 0x83, 0x4b, 0x9f, 0x66, 0x43, 0x7b, - 0x42, 0x30, 0xab, 0xca, 0x16, 0x63, 0x60, 0x5b, 0x50, 0x71, 0x13, 0xd2, 0x8a, 0xc7, 0x4a, 0xe7, - 0xcb, 0x4f, 0x0e, 0x5e, 0xb8, 0x5c, 0xd4, 0x7b, 0x4e, 0x0f, 0x0b, 0xa6, 0x95, 0x79, 0x4a, 0x1e, - 0x73, 0x2e, 0xf6, 0xaf, 0x0d, 0x99, 0xef, 0x47, 0x07, 0x1c, 0x3d, 0x03, 0x83, 0x71, 0xd0, 0x8e, - 0xea, 0x04, 0x93, 0x30, 0x88, 0xc7, 0xac, 0xf3, 0x65, 0x3a, 0xf5, 0xe8, 0xa4, 0x5e, 0xd1, 0xcd, - 0xd8, 0xc4, 0x41, 0x5f, 0xb4, 0x60, 0xa8, 0x41, 0xe2, 0xc4, 0xf5, 0x19, 0x7f, 0xd9, 0xf9, 0xd5, - 0x23, 0x77, 0x5e, 0x36, 0xce, 0x6a, 0xe2, 0xd3, 0xa7, 0xc5, 0x8b, 0x0c, 0x19, 0x8d, 0x31, 0x4e, - 0xf1, 0xa7, 0x8b, 0xb3, 0x41, 0xe2, 0x7a, 0xe4, 0x86, 0xf4, 0xbf, 0x58, 0x3e, 0x6a, 0x71, 0xce, - 0x6a, 0x10, 0x36, 0xf1, 0x90, 0x0f, 0x15, 0xba, 0xf8, 0xe2, 0xb1, 0x3e, 0xd6, 0xff, 0xf9, 0xa3, - 0xf5, 0x5f, 0x0c, 0x2a, 0x5d, 0xd7, 0x7a, 0xf4, 0xe9, 0xbf, 0x18, 0x73, 0x36, 0xe8, 0x0b, 0x16, - 0x8c, 0x09, 0xe1, 0x80, 0x09, 0x1f, 0xd0, 0x9b, 0x1b, 0x6e, 0x42, 0x3c, 0x37, 0x4e, 0xc6, 0x2a, - 0xac, 0x0f, 0x93, 0xbd, 0xcd, 0xad, 0xb9, 0x28, 0x68, 0x87, 0x57, 0x5d, 0xbf, 0x31, 0x7d, 0x5e, - 0x70, 0x1a, 0x9b, 0xe9, 0x42, 0x18, 0x77, 0x65, 0x89, 0xbe, 0x6c, 0xc1, 0x39, 0xdf, 0x69, 0x91, - 0x38, 0x74, 0xe8, 0xa7, 0xe5, 0xe0, 0x69, 0xcf, 0xa9, 0x6f, 0xb2, 0x1e, 0xf5, 0x1f, 0xae, 0x47, - 0xb6, 0xe8, 0xd1, 0xb9, 0x6b, 0x5d, 0x49, 0xe3, 0x3d, 0xd8, 0xa2, 0xaf, 0x5b, 0x70, 0x32, 0x88, - 0xc2, 0x0d, 0xc7, 0x27, 0x0d, 0x09, 0x8d, 0xc7, 0x06, 0xd8, 0xd2, 0xfb, 0xc8, 0xd1, 0x3e, 0xd1, - 0x52, 0x96, 0xec, 0x62, 0xe0, 0xbb, 0x49, 0x10, 0xad, 0x90, 0x24, 0x71, 0xfd, 0x66, 0x3c, 0x7d, - 0xe6, 0xce, 0xee, 0xf8, 0xc9, 0x0e, 0x2c, 0xdc, 0xd9, 0x1f, 0xf4, 0x53, 0x30, 0x18, 0xef, 0xf8, - 0xf5, 0x9b, 0xae, 0xdf, 0x08, 0x6e, 0xc7, 0x63, 0xd5, 0x22, 0x96, 0xef, 0x8a, 0x22, 0x28, 0x16, - 0xa0, 0x66, 0x80, 0x4d, 0x6e, 0xf9, 0x1f, 0x4e, 0x4f, 0xa5, 0x5a, 0xd1, 0x1f, 0x4e, 0x4f, 0xa6, - 0x3d, 0xd8, 0xa2, 0x9f, 0xb7, 0x60, 0x38, 0x76, 0x9b, 0xbe, 0x93, 0xb4, 0x23, 0x72, 0x95, 0xec, - 0xc4, 0x63, 0xc0, 0x3a, 0x72, 0xe5, 0x88, 0xa3, 0x62, 0x90, 0x9c, 0x3e, 0x23, 0xfa, 0x38, 0x6c, - 0xb6, 0xc6, 0x38, 0xcd, 0x37, 0x6f, 0xa1, 0xe9, 0x69, 0x3d, 0x58, 0xec, 0x42, 0xd3, 0x93, 0xba, - 0x2b, 0x4b, 0xf4, 0x13, 0x70, 0x82, 0x37, 0xa9, 0x91, 0x8d, 0xc7, 0x86, 0x98, 0xa0, 0x3d, 0x7d, - 0x67, 0x77, 0xfc, 0xc4, 0x4a, 0x06, 0x86, 0x3b, 0xb0, 0xd1, 0xab, 0x30, 0x1e, 0x92, 0xa8, 0xe5, - 0x26, 0x4b, 0xbe, 0xb7, 0x23, 0xc5, 0x77, 0x3d, 0x08, 0x49, 0x43, 0x74, 0x27, 0x1e, 0x1b, 0x3e, - 0x6f, 0x3d, 0x59, 0x9d, 0x7e, 0x97, 0xe8, 0xe6, 0xf8, 0xf2, 0xde, 0xe8, 0x78, 0x3f, 0x7a, 0xf6, - 0xbf, 0x29, 0xc1, 0x89, 0xac, 0xe2, 0x44, 0x7f, 0xdf, 0x82, 0xd1, 0x5b, 0xb7, 0x93, 0xd5, 0x60, - 0x93, 0xf8, 0xf1, 0xf4, 0x0e, 0x15, 0x6f, 0x4c, 0x65, 0x0c, 0x5e, 0xa8, 0x17, 0xab, 0xa2, 0x27, - 0xae, 0xa4, 0xb9, 0x5c, 0xf4, 0x93, 0x68, 0x67, 0xfa, 0x61, 0xf1, 0x76, 0xa3, 0x57, 0x6e, 0xae, - 0x9a, 0x50, 0x9c, 0xed, 0xd4, 0xb9, 0xcf, 0x59, 0x70, 0x3a, 0x8f, 0x04, 0x3a, 0x01, 0xe5, 0x4d, - 0xb2, 0xc3, 0x0d, 0x38, 0x4c, 0x7f, 0xa2, 0x97, 0xa1, 0xb2, 0xe5, 0x78, 0x6d, 0x22, 0xac, 0x9b, - 0xb9, 0xa3, 0xbd, 0x88, 0xea, 0x19, 0xe6, 0x54, 0xdf, 0x57, 0x7a, 0xde, 0xb2, 0x7f, 0xbf, 0x0c, - 0x83, 0x86, 0x7e, 0xbb, 0x07, 0x16, 0x5b, 0x90, 0xb2, 0xd8, 0x16, 0x0b, 0x53, 0xcd, 0x5d, 0x4d, - 0xb6, 0xdb, 0x19, 0x93, 0x6d, 0xa9, 0x38, 0x96, 0x7b, 0xda, 0x6c, 0x28, 0x81, 0x5a, 0x10, 0x52, - 0xeb, 0x9d, 0xaa, 0xfe, 0xbe, 0x22, 0x3e, 0xe1, 0x92, 0x24, 0x37, 0x3d, 0x7c, 0x67, 0x77, 0xbc, - 0xa6, 0xfe, 0x62, 0xcd, 0xc8, 0xfe, 0x8e, 0x05, 0xa7, 0x8d, 0x3e, 0xce, 0x04, 0x7e, 0xc3, 0x65, - 0x9f, 0xf6, 0x3c, 0xf4, 0x25, 0x3b, 0xa1, 0xdc, 0x21, 0xa8, 0x91, 0x5a, 0xdd, 0x09, 0x09, 0x66, - 0x10, 0x6a, 0xe8, 0xb7, 0x48, 0x1c, 0x3b, 0x4d, 0x92, 0xdd, 0x13, 0x2c, 0xf2, 0x66, 0x2c, 0xe1, - 0x28, 0x02, 0xe4, 0x39, 0x71, 0xb2, 0x1a, 0x39, 0x7e, 0xcc, 0xc8, 0xaf, 0xba, 0x2d, 0x22, 0x06, - 0xf8, 0xaf, 0xf4, 0x36, 0x63, 0xe8, 0x13, 0xd3, 0x0f, 0xdd, 0xd9, 0x1d, 0x47, 0x0b, 0x1d, 0x94, - 0x70, 0x0e, 0x75, 0xfb, 0xcb, 0x16, 0x3c, 0x94, 0x6f, 0x8b, 0xa1, 0x27, 0xa0, 0x9f, 0x6f, 0x0f, - 0xc5, 0xdb, 0xe9, 0x4f, 0xc2, 0x5a, 0xb1, 0x80, 0xa2, 0x49, 0xa8, 0x29, 0x3d, 0x21, 0xde, 0xf1, - 0xa4, 0x40, 0xad, 0x69, 0xe5, 0xa2, 0x71, 0xe8, 0xa0, 0xd1, 0x3f, 0xc2, 0x72, 0x53, 0x83, 0xc6, - 0xf6, 0x53, 0x0c, 0x62, 0xff, 0x47, 0x0b, 0x46, 0x8d, 0x5e, 0xdd, 0x03, 0xd3, 0xdc, 0x4f, 0x9b, - 0xe6, 0xf3, 0x85, 0xcd, 0xe7, 0x2e, 0xb6, 0xf9, 0x17, 0x2c, 0x38, 0x67, 0x60, 0x2d, 0x3a, 0x49, - 0x7d, 0xe3, 0xe2, 0x76, 0x18, 0x91, 0x98, 0x6e, 0xbd, 0xd1, 0xa3, 0x86, 0xdc, 0x9a, 0x1e, 0x14, - 0x14, 0xca, 0x57, 0xc9, 0x0e, 0x17, 0x62, 0x4f, 0x41, 0x95, 0x4f, 0xce, 0x20, 0x12, 0x23, 0xae, - 0xde, 0x6d, 0x49, 0xb4, 0x63, 0x85, 0x81, 0x6c, 0xe8, 0x67, 0xc2, 0x89, 0x2e, 0x56, 0xaa, 0x86, - 0x80, 0x7e, 0xc4, 0x1b, 0xac, 0x05, 0x0b, 0x88, 0x1d, 0xa7, 0xba, 0xb3, 0x1c, 0x11, 0xf6, 0x71, - 0x1b, 0x97, 0x5c, 0xe2, 0x35, 0x62, 0xba, 0x6d, 0x70, 0x7c, 0x3f, 0x48, 0xc4, 0x0e, 0xc0, 0xd8, - 0x36, 0x4c, 0xe9, 0x66, 0x6c, 0xe2, 0x50, 0xa6, 0x9e, 0xb3, 0x46, 0x3c, 0x3e, 0xa2, 0x82, 0xe9, - 0x02, 0x6b, 0xc1, 0x02, 0x62, 0xdf, 0x29, 0xb1, 0x0d, 0x8a, 0x5a, 0xfa, 0xe4, 0x5e, 0xec, 0x6e, - 0xa3, 0x94, 0xac, 0x5c, 0x2e, 0x4e, 0x70, 0x91, 0xee, 0x3b, 0xdc, 0xd7, 0x32, 0xe2, 0x12, 0x17, - 0xca, 0x75, 0xef, 0x5d, 0xee, 0x6f, 0x97, 0x60, 0x3c, 0xfd, 0x40, 0x87, 0xb4, 0xa5, 0x5b, 0x2a, - 0x83, 0x51, 0xd6, 0xdf, 0x61, 0xe0, 0x63, 0x13, 0xaf, 0x8b, 0xc0, 0x2a, 0x1d, 0xa7, 0xc0, 0x32, - 0xe5, 0x69, 0x79, 0x1f, 0x79, 0xfa, 0x84, 0x1a, 0xf5, 0xbe, 0x8c, 0x00, 0x4b, 0xeb, 0x94, 0xf3, - 0xd0, 0x17, 0x27, 0x24, 0x1c, 0xab, 0xa4, 0xe5, 0xd1, 0x4a, 0x42, 0x42, 0xcc, 0x20, 0xf6, 0x7f, - 0x2b, 0xc1, 0xc3, 0xe9, 0x31, 0xd4, 0x2a, 0xe0, 0x03, 0x29, 0x15, 0xf0, 0x6e, 0x53, 0x05, 0xdc, - 0xdd, 0x1d, 0x7f, 0x67, 0x97, 0xc7, 0xde, 0x32, 0x1a, 0x02, 0xcd, 0x65, 0x46, 0x71, 0x32, 0x3d, - 0x8a, 0x77, 0x77, 0xc7, 0x1f, 0xed, 0xf2, 0x8e, 0x99, 0x61, 0x7e, 0x02, 0xfa, 0x23, 0xe2, 0xc4, - 0x81, 0x2f, 0x06, 0x5a, 0x7d, 0x0e, 0xcc, 0x5a, 0xb1, 0x80, 0xda, 0x7f, 0x58, 0xcb, 0x0e, 0xf6, - 0x1c, 0x77, 0xd8, 0x05, 0x11, 0x72, 0xa1, 0x8f, 0x99, 0xf5, 0x5c, 0x34, 0x5c, 0x3d, 0xda, 0x32, - 0xa2, 0x6a, 0x40, 0x91, 0x9e, 0xae, 0xd2, 0xaf, 0x46, 0x9b, 0x30, 0x63, 0x81, 0xb6, 0xa1, 0x5a, - 0x97, 0xd6, 0x76, 0xa9, 0x08, 0xbf, 0x94, 0xb0, 0xb5, 0x35, 0xc7, 0x21, 0x2a, 0xaf, 0x95, 0x89, - 0xae, 0xb8, 0x21, 0x02, 0xe5, 0xa6, 0x9b, 0x88, 0xcf, 0x7a, 0xc4, 0xfd, 0xd4, 0x9c, 0x6b, 0xbc, - 0xe2, 0x00, 0x55, 0x22, 0x73, 0x6e, 0x82, 0x29, 0x7d, 0xf4, 0xb3, 0x16, 0x0c, 0xc6, 0xf5, 0xd6, - 0x72, 0x14, 0x6c, 0xb9, 0x0d, 0x12, 0x09, 0x6b, 0xea, 0x88, 0xa2, 0x69, 0x65, 0x66, 0x51, 0x12, - 0xd4, 0x7c, 0xf9, 0xfe, 0x56, 0x43, 0xb0, 0xc9, 0x97, 0xee, 0x32, 0x1e, 0x16, 0xef, 0x3e, 0x4b, - 0xea, 0x2e, 0xd5, 0x7f, 0x72, 0x53, 0xc5, 0x66, 0xca, 0x91, 0xad, 0xcb, 0xd9, 0x76, 0x7d, 0x93, - 0xae, 0x37, 0xdd, 0xa1, 0x77, 0xde, 0xd9, 0x1d, 0x7f, 0x78, 0x26, 0x9f, 0x27, 0xee, 0xd6, 0x19, - 0x36, 0x60, 0x61, 0xdb, 0xf3, 0x30, 0x79, 0xb5, 0x4d, 0x98, 0xcb, 0xa4, 0x80, 0x01, 0x5b, 0xd6, - 0x04, 0x33, 0x03, 0x66, 0x40, 0xb0, 0xc9, 0x17, 0xbd, 0x0a, 0xfd, 0x2d, 0x27, 0x89, 0xdc, 0x6d, - 0xe1, 0x27, 0x39, 0xa2, 0xbd, 0xbf, 0xc8, 0x68, 0x69, 0xe6, 0x4c, 0x53, 0xf3, 0x46, 0x2c, 0x18, - 0xa1, 0x16, 0x54, 0x5a, 0x24, 0x6a, 0x92, 0xb1, 0x6a, 0x11, 0x3e, 0xe1, 0x45, 0x4a, 0x4a, 0x33, - 0xac, 0x51, 0xeb, 0x88, 0xb5, 0x61, 0xce, 0x05, 0xbd, 0x0c, 0xd5, 0x98, 0x78, 0xa4, 0x4e, 0xed, - 0x9b, 0x1a, 0xe3, 0xf8, 0x9e, 0x1e, 0x6d, 0x3d, 0x6a, 0x58, 0xac, 0x88, 0x47, 0xf9, 0x02, 0x93, - 0xff, 0xb0, 0x22, 0x49, 0x07, 0x30, 0xf4, 0xda, 0x4d, 0xd7, 0x1f, 0x83, 0x22, 0x06, 0x70, 0x99, - 0xd1, 0xca, 0x0c, 0x20, 0x6f, 0xc4, 0x82, 0x91, 0xfd, 0x9f, 0x2d, 0x40, 0x69, 0xa1, 0x76, 0x0f, - 0x8c, 0xda, 0x57, 0xd3, 0x46, 0xed, 0x42, 0x91, 0x56, 0x47, 0x17, 0xbb, 0xf6, 0x37, 0x6b, 0x90, - 0x51, 0x07, 0xd7, 0x48, 0x9c, 0x90, 0xc6, 0xdb, 0x22, 0xfc, 0x6d, 0x11, 0xfe, 0xb6, 0x08, 0x57, - 0x22, 0x7c, 0x2d, 0x23, 0xc2, 0xdf, 0x6f, 0xac, 0x7a, 0x7d, 0x00, 0xfb, 0x8a, 0x3a, 0xa1, 0x35, - 0x7b, 0x60, 0x20, 0x50, 0x49, 0x70, 0x65, 0x65, 0xe9, 0x5a, 0xae, 0xcc, 0x7e, 0x25, 0x2d, 0xb3, - 0x8f, 0xca, 0xe2, 0xff, 0x07, 0x29, 0xfd, 0xaf, 0x2d, 0x78, 0x57, 0x5a, 0x7a, 0xc9, 0x99, 0x33, - 0xdf, 0xf4, 0x83, 0x88, 0xcc, 0xba, 0xeb, 0xeb, 0x24, 0x22, 0x7e, 0x9d, 0xc4, 0xca, 0x8b, 0x61, - 0x75, 0xf3, 0x62, 0xa0, 0x67, 0x61, 0xe8, 0x56, 0x1c, 0xf8, 0xcb, 0x81, 0xeb, 0x0b, 0x11, 0x44, - 0x37, 0xc2, 0x27, 0xee, 0xec, 0x8e, 0x0f, 0xd1, 0x11, 0x95, 0xed, 0x38, 0x85, 0x85, 0x66, 0xe0, - 0xe4, 0xad, 0x57, 0x97, 0x9d, 0xc4, 0x70, 0x07, 0xc8, 0x8d, 0x3b, 0x3b, 0xb0, 0xb8, 0xf2, 0x62, - 0x06, 0x88, 0x3b, 0xf1, 0xed, 0xbf, 0x53, 0x82, 0xb3, 0x99, 0x17, 0x09, 0x3c, 0x2f, 0x68, 0x27, - 0x74, 0x53, 0x83, 0xbe, 0x6a, 0xc1, 0x89, 0x56, 0xda, 0xe3, 0x10, 0x0b, 0xc7, 0xee, 0x07, 0x0b, - 0xd3, 0x11, 0x19, 0x97, 0xc6, 0xf4, 0x98, 0x18, 0xa1, 0x13, 0x19, 0x40, 0x8c, 0x3b, 0xfa, 0x82, - 0x5e, 0x86, 0x5a, 0xcb, 0xd9, 0xbe, 0x1e, 0x36, 0x9c, 0x44, 0xee, 0x27, 0xbb, 0xbb, 0x01, 0xda, - 0x89, 0xeb, 0x4d, 0xf0, 0xa3, 0xfd, 0x89, 0x79, 0x3f, 0x59, 0x8a, 0x56, 0x92, 0xc8, 0xf5, 0x9b, - 0xdc, 0x9d, 0xb7, 0x28, 0xc9, 0x60, 0x4d, 0xd1, 0xfe, 0x8a, 0x95, 0x55, 0x52, 0x6a, 0x74, 0x22, - 0x27, 0x21, 0xcd, 0x1d, 0xf4, 0x31, 0xa8, 0xd0, 0x8d, 0x9f, 0x1c, 0x95, 0x9b, 0x45, 0x6a, 0x4e, - 0xe3, 0x4b, 0x68, 0x25, 0x4a, 0xff, 0xc5, 0x98, 0x33, 0xb5, 0xbf, 0x5a, 0xcb, 0x1a, 0x0b, 0xec, - 0xf0, 0xf6, 0x02, 0x40, 0x33, 0x58, 0x25, 0xad, 0xd0, 0xa3, 0xc3, 0x62, 0xb1, 0x13, 0x00, 0xe5, - 0xeb, 0x98, 0x53, 0x10, 0x6c, 0x60, 0xa1, 0xbf, 0x66, 0x01, 0x34, 0xe5, 0x9c, 0x97, 0x86, 0xc0, - 0xf5, 0x22, 0x5f, 0x47, 0xaf, 0x28, 0xdd, 0x17, 0xc5, 0x10, 0x1b, 0xcc, 0xd1, 0xcf, 0x58, 0x50, - 0x4d, 0x64, 0xf7, 0xb9, 0x6a, 0x5c, 0x2d, 0xb2, 0x27, 0xf2, 0xa5, 0xb5, 0x4d, 0xa4, 0x86, 0x44, - 0xf1, 0x45, 0x3f, 0x67, 0x01, 0xc4, 0x3b, 0x7e, 0x7d, 0x39, 0xf0, 0xdc, 0xfa, 0x8e, 0xd0, 0x98, - 0x37, 0x0a, 0xf5, 0xc7, 0x28, 0xea, 0xd3, 0x23, 0x74, 0x34, 0xf4, 0x7f, 0x6c, 0x70, 0x46, 0x9f, - 0x80, 0x6a, 0x2c, 0xa6, 0x9b, 0xd0, 0x91, 0xab, 0xc5, 0x7a, 0x85, 0x38, 0x6d, 0x21, 0x5e, 0xc5, - 0x3f, 0xac, 0x78, 0xa2, 0x5f, 0xb0, 0x60, 0x34, 0x4c, 0xfb, 0xf9, 0x84, 0x3a, 0x2c, 0x4e, 0x06, - 0x64, 0xfc, 0x88, 0xd3, 0xa7, 0xee, 0xec, 0x8e, 0x8f, 0x66, 0x1a, 0x71, 0xb6, 0x17, 0x54, 0x02, - 0xea, 0x19, 0xbc, 0x14, 0x72, 0x9f, 0xe3, 0x80, 0x96, 0x80, 0x73, 0x59, 0x20, 0xee, 0xc4, 0x47, - 0xcb, 0x70, 0x9a, 0xf6, 0x6e, 0x87, 0x9b, 0x9f, 0x52, 0xbd, 0xc4, 0x4c, 0x19, 0x56, 0xa7, 0x1f, - 0x11, 0x33, 0x84, 0x79, 0xf5, 0xb3, 0x38, 0x38, 0xf7, 0x49, 0xf4, 0xfb, 0x16, 0x3c, 0xe2, 0x32, - 0x35, 0x60, 0x3a, 0xcc, 0xb5, 0x46, 0x10, 0x27, 0xb1, 0xa4, 0x50, 0x59, 0xd1, 0x4d, 0xfd, 0x4c, - 0xff, 0xa0, 0x78, 0x83, 0x47, 0xe6, 0xf7, 0xe8, 0x12, 0xde, 0xb3, 0xc3, 0xe8, 0x47, 0x61, 0x58, - 0xae, 0x8b, 0x65, 0x2a, 0x82, 0x99, 0xa2, 0xad, 0x4d, 0x9f, 0xbc, 0xb3, 0x3b, 0x3e, 0xbc, 0x6a, - 0x02, 0x70, 0x1a, 0xcf, 0xfe, 0x76, 0x29, 0x75, 0x1e, 0xa2, 0x9c, 0x90, 0x4c, 0xdc, 0xd4, 0xa5, - 0xff, 0x47, 0x4a, 0xcf, 0x42, 0xc5, 0x8d, 0xf2, 0x2e, 0x69, 0x71, 0xa3, 0x9a, 0x62, 0x6c, 0x30, - 0xa7, 0x46, 0xe9, 0x49, 0x27, 0xeb, 0xea, 0x14, 0x12, 0xf0, 0xe5, 0x22, 0xbb, 0xd4, 0x79, 0x7a, - 0x75, 0x56, 0x74, 0xed, 0x64, 0x07, 0x08, 0x77, 0x76, 0xc9, 0xfe, 0x76, 0xfa, 0x0c, 0xc6, 0x58, - 0xbc, 0x3d, 0x9c, 0x2f, 0x7d, 0xd1, 0x82, 0xc1, 0x28, 0xf0, 0x3c, 0xd7, 0x6f, 0x52, 0x41, 0x23, - 0xb4, 0xe5, 0x87, 0x8f, 0x45, 0x61, 0x09, 0x89, 0xc2, 0x4c, 0x5b, 0xac, 0x79, 0x62, 0xb3, 0x03, - 0xf6, 0x9f, 0x59, 0x30, 0xd6, 0x4d, 0x20, 0x22, 0x02, 0xef, 0x94, 0xab, 0x5d, 0x45, 0x57, 0x2c, - 0xf9, 0xb3, 0xc4, 0x23, 0xca, 0xf1, 0x5c, 0x9d, 0x7e, 0x5c, 0xbc, 0xe6, 0x3b, 0x97, 0xbb, 0xa3, - 0xe2, 0xbd, 0xe8, 0xa0, 0x97, 0xe0, 0x84, 0xf1, 0x5e, 0xb1, 0x1a, 0x98, 0xda, 0xf4, 0x04, 0xb5, - 0x40, 0xa6, 0x32, 0xb0, 0xbb, 0xbb, 0xe3, 0x0f, 0x65, 0xdb, 0x84, 0xc4, 0xee, 0xa0, 0x63, 0xff, - 0x6a, 0x29, 0xfb, 0xb5, 0x94, 0xb2, 0x7d, 0xd3, 0xea, 0xd8, 0xce, 0x7f, 0xf0, 0x38, 0x14, 0x1c, - 0xdb, 0xf8, 0xab, 0x00, 0x8e, 0xee, 0x38, 0xf7, 0xf1, 0x84, 0xd8, 0xfe, 0xb7, 0x7d, 0xb0, 0x47, - 0xcf, 0x7a, 0xb0, 0x9e, 0x0f, 0x7c, 0xac, 0xf8, 0x79, 0x4b, 0x1d, 0x39, 0x95, 0xd9, 0x22, 0x6f, - 0x1c, 0xd7, 0xd8, 0xf3, 0x0d, 0x4c, 0xcc, 0xa3, 0x14, 0x94, 0x1b, 0x3b, 0x7d, 0xb8, 0x85, 0xbe, - 0x66, 0xa5, 0x0f, 0xcd, 0x78, 0xd8, 0x99, 0x7b, 0x6c, 0x7d, 0x32, 0x4e, 0xe2, 0x78, 0xc7, 0xf4, - 0xf9, 0x4d, 0xb7, 0x33, 0xba, 0x09, 0x80, 0x75, 0xd7, 0x77, 0x3c, 0xf7, 0x35, 0xba, 0x3d, 0xa9, - 0x30, 0x0d, 0xcb, 0x4c, 0x96, 0x4b, 0xaa, 0x15, 0x1b, 0x18, 0xe7, 0xfe, 0x2a, 0x0c, 0x1a, 0x6f, - 0x9e, 0x13, 0x5c, 0x71, 0xda, 0x0c, 0xae, 0xa8, 0x19, 0x31, 0x11, 0xe7, 0xde, 0x0f, 0x27, 0xb2, - 0x1d, 0x3c, 0xc8, 0xf3, 0xf6, 0xff, 0x1a, 0xc8, 0x9e, 0x62, 0xad, 0x92, 0xa8, 0x45, 0xbb, 0xf6, - 0xb6, 0x67, 0xe9, 0x6d, 0xcf, 0xd2, 0xdb, 0x9e, 0x25, 0xf3, 0x70, 0x40, 0x78, 0x4d, 0x06, 0xee, - 0x91, 0xd7, 0x24, 0xe5, 0x07, 0xaa, 0x16, 0xee, 0x07, 0xb2, 0xef, 0x54, 0x20, 0x65, 0x47, 0xf1, - 0xf1, 0xfe, 0x61, 0x18, 0x88, 0x48, 0x18, 0x5c, 0xc7, 0x0b, 0x42, 0x87, 0xe8, 0x58, 0x7b, 0xde, - 0x8c, 0x25, 0x9c, 0xea, 0x9a, 0xd0, 0x49, 0x36, 0x84, 0x12, 0x51, 0xba, 0x66, 0xd9, 0x49, 0x36, - 0x30, 0x83, 0xa0, 0xf7, 0xc3, 0x48, 0xe2, 0x44, 0x4d, 0x6a, 0x6f, 0x6f, 0xb1, 0xcf, 0x2a, 0xce, - 0x3a, 0x1f, 0x12, 0xb8, 0x23, 0xab, 0x29, 0x28, 0xce, 0x60, 0xa3, 0x57, 0xa1, 0x6f, 0x83, 0x78, - 0x2d, 0x31, 0xe4, 0x2b, 0xc5, 0xc9, 0x78, 0xf6, 0xae, 0x97, 0x89, 0xd7, 0xe2, 0x12, 0x88, 0xfe, - 0xc2, 0x8c, 0x15, 0x9d, 0x6f, 0xb5, 0xcd, 0x76, 0x9c, 0x04, 0x2d, 0xf7, 0x35, 0xe9, 0xe2, 0xfb, - 0x60, 0xc1, 0x8c, 0xaf, 0x4a, 0xfa, 0xdc, 0x97, 0xa2, 0xfe, 0x62, 0xcd, 0x99, 0xf5, 0xa3, 0xe1, - 0x46, 0xec, 0x53, 0xed, 0x08, 0x4f, 0x5d, 0xd1, 0xfd, 0x98, 0x95, 0xf4, 0x79, 0x3f, 0xd4, 0x5f, - 0xac, 0x39, 0xa3, 0x1d, 0x35, 0xef, 0x07, 0x59, 0x1f, 0xae, 0x17, 0xdc, 0x07, 0x3e, 0xe7, 0x73, - 0xe7, 0xff, 0xe3, 0x50, 0xa9, 0x6f, 0x38, 0x51, 0x32, 0x36, 0xc4, 0x26, 0x8d, 0xf2, 0xe9, 0xcc, - 0xd0, 0x46, 0xcc, 0x61, 0xe8, 0x51, 0x28, 0x47, 0x64, 0x9d, 0xc5, 0x6d, 0x1a, 0x11, 0x3d, 0x98, - 0xac, 0x63, 0xda, 0x6e, 0xff, 0x72, 0x29, 0x6d, 0x2e, 0xa5, 0xdf, 0x9b, 0xcf, 0xf6, 0x7a, 0x3b, - 0x8a, 0xa5, 0xdf, 0xc7, 0x98, 0xed, 0xac, 0x19, 0x4b, 0x38, 0xfa, 0x94, 0x05, 0x03, 0xb7, 0xe2, - 0xc0, 0xf7, 0x49, 0x22, 0x54, 0xd3, 0x8d, 0x82, 0x87, 0xe2, 0x0a, 0xa7, 0xae, 0xfb, 0x20, 0x1a, - 0xb0, 0xe4, 0x4b, 0xbb, 0x4b, 0xb6, 0xeb, 0x5e, 0xbb, 0xd1, 0x11, 0xa4, 0x71, 0x91, 0x37, 0x63, - 0x09, 0xa7, 0xa8, 0xae, 0xcf, 0x51, 0xfb, 0xd2, 0xa8, 0xf3, 0xbe, 0x40, 0x15, 0x70, 0xfb, 0x6f, - 0xf5, 0xc3, 0x99, 0xdc, 0xc5, 0x41, 0x0d, 0x19, 0x66, 0x2a, 0x5c, 0x72, 0x3d, 0x22, 0xc3, 0x93, - 0x98, 0x21, 0x73, 0x43, 0xb5, 0x62, 0x03, 0x03, 0xfd, 0x34, 0x40, 0xe8, 0x44, 0x4e, 0x8b, 0x28, - 0xbf, 0xec, 0x91, 0xed, 0x05, 0xda, 0x8f, 0x65, 0x49, 0x53, 0xef, 0x4d, 0x55, 0x53, 0x8c, 0x0d, - 0x96, 0xe8, 0x39, 0x18, 0x8c, 0x88, 0x47, 0x9c, 0x98, 0x85, 0xfd, 0x66, 0x73, 0x18, 0xb0, 0x06, - 0x61, 0x13, 0x0f, 0x3d, 0xa1, 0x22, 0xb9, 0x32, 0x11, 0x2d, 0xe9, 0x68, 0x2e, 0xf4, 0xba, 0x05, - 0x23, 0xeb, 0xae, 0x47, 0x34, 0x77, 0x91, 0x71, 0xb0, 0x74, 0xf4, 0x97, 0xbc, 0x64, 0xd2, 0xd5, - 0x12, 0x32, 0xd5, 0x1c, 0xe3, 0x0c, 0x7b, 0xfa, 0x99, 0xb7, 0x48, 0xc4, 0x44, 0x6b, 0x7f, 0xfa, - 0x33, 0xdf, 0xe0, 0xcd, 0x58, 0xc2, 0xd1, 0x14, 0x8c, 0x86, 0x4e, 0x1c, 0xcf, 0x44, 0xa4, 0x41, - 0xfc, 0xc4, 0x75, 0x3c, 0x9e, 0x0f, 0x50, 0xd5, 0xf1, 0xc0, 0xcb, 0x69, 0x30, 0xce, 0xe2, 0xa3, - 0x0f, 0xc1, 0xc3, 0xdc, 0xf1, 0xb1, 0xe8, 0xc6, 0xb1, 0xeb, 0x37, 0xf5, 0x34, 0x10, 0xfe, 0x9f, - 0x71, 0x41, 0xea, 0xe1, 0xf9, 0x7c, 0x34, 0xdc, 0xed, 0x79, 0xf4, 0x14, 0x54, 0xe3, 0x4d, 0x37, - 0x9c, 0x89, 0x1a, 0x31, 0x3b, 0xf4, 0xa8, 0x6a, 0x6f, 0xe3, 0x8a, 0x68, 0xc7, 0x0a, 0x03, 0xd5, - 0x61, 0x88, 0x7f, 0x12, 0x1e, 0x8a, 0x26, 0xe4, 0xe3, 0xd3, 0x5d, 0xd5, 0xa3, 0x48, 0x6f, 0x9b, - 0xc0, 0xce, 0xed, 0x8b, 0xf2, 0x08, 0x86, 0x9f, 0x18, 0xdc, 0x30, 0xc8, 0xe0, 0x14, 0x51, 0xfb, - 0x17, 0x4b, 0xe9, 0x1d, 0xb7, 0xb9, 0x48, 0x51, 0x4c, 0x97, 0x62, 0x72, 0xc3, 0x89, 0xa4, 0x37, - 0xe6, 0x88, 0x69, 0x0b, 0x82, 0xee, 0x0d, 0x27, 0x32, 0x17, 0x35, 0x63, 0x80, 0x25, 0x27, 0x74, - 0x0b, 0xfa, 0x12, 0xcf, 0x29, 0x28, 0xcf, 0xc9, 0xe0, 0xa8, 0x1d, 0x20, 0x0b, 0x53, 0x31, 0x66, - 0x3c, 0xd0, 0x23, 0xd4, 0xea, 0x5f, 0x93, 0x47, 0x24, 0xc2, 0x50, 0x5f, 0x8b, 0x31, 0x6b, 0xb5, - 0xbf, 0x39, 0x98, 0x23, 0x57, 0x95, 0x22, 0x43, 0x17, 0x00, 0xe8, 0x06, 0x72, 0x39, 0x22, 0xeb, - 0xee, 0xb6, 0x30, 0x24, 0xd4, 0xda, 0xbd, 0xa6, 0x20, 0xd8, 0xc0, 0x92, 0xcf, 0xac, 0xb4, 0xd7, - 0xe9, 0x33, 0xa5, 0xce, 0x67, 0x38, 0x04, 0x1b, 0x58, 0xe8, 0x59, 0xe8, 0x77, 0x5b, 0x4e, 0x53, - 0x85, 0x60, 0x3e, 0x42, 0x17, 0xed, 0x3c, 0x6b, 0xb9, 0xbb, 0x3b, 0x3e, 0xa2, 0x3a, 0xc4, 0x9a, - 0xb0, 0xc0, 0x45, 0xbf, 0x6a, 0xc1, 0x50, 0x3d, 0x68, 0xb5, 0x02, 0x9f, 0x6f, 0xbb, 0xc4, 0x1e, - 0xf2, 0xd6, 0x71, 0xa9, 0xf9, 0x89, 0x19, 0x83, 0x19, 0xdf, 0x44, 0xaa, 0x84, 0x2c, 0x13, 0x84, - 0x53, 0xbd, 0x32, 0xd7, 0x76, 0x65, 0x9f, 0xb5, 0xfd, 0x1b, 0x16, 0x9c, 0xe4, 0xcf, 0x1a, 0xbb, - 0x41, 0x91, 0x7b, 0x14, 0x1c, 0xf3, 0x6b, 0x75, 0x6c, 0x90, 0x95, 0x97, 0xae, 0x03, 0x8e, 0x3b, - 0x3b, 0x89, 0xe6, 0xe0, 0xe4, 0x7a, 0x10, 0xd5, 0x89, 0x39, 0x10, 0x42, 0x30, 0x29, 0x42, 0x97, - 0xb2, 0x08, 0xb8, 0xf3, 0x19, 0x74, 0x03, 0x1e, 0x32, 0x1a, 0xcd, 0x71, 0xe0, 0xb2, 0xe9, 0x31, - 0x41, 0xed, 0xa1, 0x4b, 0xb9, 0x58, 0xb8, 0xcb, 0xd3, 0xd4, 0x88, 0x65, 0x10, 0xe5, 0x1c, 0x11, - 0xf2, 0x49, 0x8b, 0xe8, 0x14, 0x14, 0x67, 0xb0, 0xd3, 0x0e, 0x17, 0xe8, 0xc1, 0xe1, 0xf2, 0x0a, - 0x9c, 0xad, 0x77, 0x8e, 0xec, 0x56, 0xdc, 0x5e, 0x63, 0x89, 0x37, 0x94, 0xf7, 0x0f, 0x08, 0x02, - 0x67, 0x67, 0xba, 0x21, 0xe2, 0xee, 0x34, 0xd0, 0xc7, 0xa0, 0x1a, 0x11, 0xf6, 0x55, 0x79, 0x06, - 0xcd, 0x91, 0x77, 0xd9, 0xda, 0x82, 0xe5, 0x64, 0xb5, 0xec, 0x16, 0x0d, 0x31, 0x56, 0x1c, 0xd1, - 0x6d, 0x18, 0x08, 0x9d, 0xa4, 0xbe, 0x41, 0xe2, 0xb1, 0xe1, 0x22, 0xe2, 0x67, 0x14, 0x73, 0xe6, - 0x43, 0x37, 0x12, 0x7e, 0x39, 0x13, 0x2c, 0xb9, 0x51, 0x6b, 0xa6, 0x1e, 0xb4, 0xc2, 0xc0, 0x27, - 0x7e, 0x12, 0x8f, 0x8d, 0x68, 0x6b, 0x66, 0x46, 0xb5, 0x62, 0x03, 0x03, 0x2d, 0xc3, 0x69, 0xe6, - 0x73, 0xba, 0xe9, 0x26, 0x1b, 0x41, 0x3b, 0x91, 0x5b, 0xa8, 0xb1, 0xd1, 0xf4, 0x51, 0xc7, 0x42, - 0x0e, 0x0e, 0xce, 0x7d, 0xf2, 0xdc, 0x07, 0xe0, 0x64, 0x87, 0x28, 0x38, 0x90, 0xbb, 0x67, 0x16, - 0x1e, 0xca, 0x5f, 0x74, 0x07, 0x72, 0xfa, 0xfc, 0xb3, 0x4c, 0xd8, 0xad, 0x61, 0x88, 0xf7, 0xe0, - 0x40, 0x74, 0xa0, 0x4c, 0xfc, 0x2d, 0xa1, 0x83, 0x2e, 0x1d, 0xed, 0xdb, 0x5d, 0xf4, 0xb7, 0xb8, - 0xcc, 0x60, 0x5e, 0x92, 0x8b, 0xfe, 0x16, 0xa6, 0xb4, 0xd1, 0x1b, 0x56, 0xca, 0x90, 0xe4, 0x6e, - 0xc7, 0x8f, 0x1c, 0xcb, 0xce, 0xa3, 0x67, 0xdb, 0xd2, 0xfe, 0xbd, 0x12, 0x9c, 0xdf, 0x8f, 0x48, - 0x0f, 0xc3, 0xf7, 0x38, 0xf4, 0xc7, 0xec, 0x20, 0x5d, 0x08, 0xf5, 0x41, 0x3a, 0x57, 0xf9, 0xd1, - 0xfa, 0x2b, 0x58, 0x80, 0x90, 0x07, 0xe5, 0x96, 0x13, 0x0a, 0x6f, 0xd4, 0xfc, 0x51, 0x13, 0x71, - 0xe8, 0x7f, 0xc7, 0x5b, 0x74, 0x42, 0xee, 0xe3, 0x30, 0x1a, 0x30, 0x65, 0x83, 0x12, 0xa8, 0x38, - 0x51, 0xe4, 0xc8, 0x53, 0xdb, 0xab, 0xc5, 0xf0, 0x9b, 0xa2, 0x24, 0xf9, 0xa1, 0x57, 0xaa, 0x09, - 0x73, 0x66, 0xf6, 0xe7, 0x07, 0x52, 0xc9, 0x28, 0xec, 0x28, 0x3e, 0x86, 0x7e, 0xe1, 0x84, 0xb2, - 0x8a, 0xce, 0x7f, 0xe2, 0xd9, 0x84, 0x6c, 0x9f, 0x29, 0x72, 0xb2, 0x05, 0x2b, 0xf4, 0x39, 0x8b, - 0x65, 0x3e, 0xcb, 0x04, 0x1d, 0xb1, 0xbb, 0x3b, 0x9e, 0x44, 0x6c, 0x33, 0x9f, 0x5a, 0x36, 0x62, - 0x93, 0xbb, 0xa8, 0x60, 0xc0, 0xac, 0xda, 0xce, 0x0a, 0x06, 0xcc, 0x4a, 0x95, 0x70, 0xb4, 0x9d, - 0x73, 0xe4, 0x5e, 0x40, 0xf6, 0x6c, 0x0f, 0x87, 0xec, 0x5f, 0xb3, 0xe0, 0xa4, 0x9b, 0x3d, 0x3b, - 0x15, 0x7b, 0xa1, 0x23, 0x06, 0x75, 0x74, 0x3f, 0x9a, 0x55, 0xe6, 0x40, 0x07, 0x08, 0x77, 0x76, - 0x06, 0x35, 0xa0, 0xcf, 0xf5, 0xd7, 0x03, 0x61, 0x04, 0x4d, 0x1f, 0xad, 0x53, 0xf3, 0xfe, 0x7a, - 0xa0, 0x57, 0x33, 0xfd, 0x87, 0x19, 0x75, 0xb4, 0x00, 0xa7, 0x23, 0xe1, 0xad, 0xba, 0xec, 0xc6, - 0x49, 0x10, 0xed, 0x2c, 0xb8, 0x2d, 0x37, 0x61, 0x06, 0x4c, 0x79, 0x7a, 0x8c, 0xea, 0x07, 0x9c, - 0x03, 0xc7, 0xb9, 0x4f, 0xa1, 0xd7, 0x60, 0x40, 0xa6, 0x6a, 0x57, 0x8b, 0xd8, 0x57, 0x76, 0xce, - 0x7f, 0x35, 0x99, 0x56, 0x44, 0x56, 0xb6, 0x64, 0x68, 0xbf, 0x3e, 0x08, 0x9d, 0xc7, 0xaa, 0xe8, - 0xe3, 0x50, 0x8b, 0x54, 0xfa, 0xb8, 0x55, 0x84, 0xba, 0x96, 0xdf, 0x57, 0x1c, 0xe9, 0x2a, 0x53, - 0x48, 0x27, 0x8a, 0x6b, 0x8e, 0x74, 0xc3, 0x13, 0xeb, 0xd3, 0xd7, 0x02, 0xe6, 0xb6, 0xe0, 0xaa, - 0x4f, 0xd6, 0x76, 0xfc, 0x3a, 0x66, 0x3c, 0x50, 0x04, 0xfd, 0x1b, 0xc4, 0xf1, 0x92, 0x8d, 0x62, - 0x0e, 0x01, 0x2e, 0x33, 0x5a, 0xd9, 0x24, 0x22, 0xde, 0x8a, 0x05, 0x27, 0xb4, 0x0d, 0x03, 0x1b, - 0x7c, 0x02, 0x88, 0x3d, 0xc8, 0xe2, 0x51, 0x07, 0x37, 0x35, 0xab, 0xf4, 0xe7, 0x16, 0x0d, 0x58, - 0xb2, 0x63, 0xf1, 0x3a, 0x46, 0x44, 0x01, 0x5f, 0xba, 0xc5, 0xe5, 0x4f, 0xf5, 0x1e, 0x4e, 0xf0, - 0x51, 0x18, 0x8a, 0x48, 0x3d, 0xf0, 0xeb, 0xae, 0x47, 0x1a, 0x53, 0xd2, 0xc1, 0x7f, 0x90, 0xac, - 0x1b, 0xb6, 0x8f, 0xc7, 0x06, 0x0d, 0x9c, 0xa2, 0x88, 0x3e, 0x6b, 0xc1, 0x88, 0xca, 0x39, 0xa5, - 0x1f, 0x84, 0x08, 0x87, 0xf2, 0x42, 0x41, 0x19, 0xae, 0x8c, 0xe6, 0x34, 0xa2, 0x7b, 0x81, 0x74, - 0x1b, 0xce, 0xf0, 0x45, 0x2f, 0x01, 0x04, 0x6b, 0x3c, 0x28, 0x67, 0x2a, 0x11, 0xde, 0xe5, 0x83, - 0xbc, 0xea, 0x08, 0x4f, 0xbf, 0x93, 0x14, 0xb0, 0x41, 0x0d, 0x5d, 0x05, 0xe0, 0xcb, 0x66, 0x75, - 0x27, 0xe4, 0x7b, 0x14, 0x9d, 0x36, 0x05, 0x2b, 0x0a, 0x72, 0x77, 0x77, 0xbc, 0xd3, 0xdb, 0xc7, - 0x02, 0x1f, 0x8c, 0xc7, 0xd1, 0x4f, 0xc1, 0x40, 0xdc, 0x6e, 0xb5, 0x1c, 0xe5, 0x7b, 0x2e, 0x30, - 0xa1, 0x8f, 0xd3, 0x35, 0x44, 0x11, 0x6f, 0xc0, 0x92, 0x23, 0xba, 0x45, 0x85, 0x6a, 0x2c, 0xdc, - 0x90, 0x6c, 0x15, 0x71, 0x9b, 0x60, 0x90, 0xbd, 0xd3, 0x7b, 0xa5, 0xe1, 0x8d, 0x73, 0x70, 0xee, - 0xee, 0x8e, 0x3f, 0x94, 0x6e, 0x5f, 0x08, 0x44, 0x8a, 0x5d, 0x2e, 0x4d, 0x74, 0x45, 0x56, 0x6e, - 0xa1, 0xaf, 0x2d, 0x0b, 0x0a, 0x3c, 0xa9, 0x2b, 0xb7, 0xb0, 0xe6, 0xee, 0x63, 0x66, 0x3e, 0x8c, - 0x16, 0xe1, 0x54, 0x3d, 0xf0, 0x93, 0x28, 0xf0, 0x3c, 0x5e, 0xb9, 0x88, 0xef, 0xf9, 0xb8, 0x6f, - 0xfa, 0x9d, 0xa2, 0xdb, 0xa7, 0x66, 0x3a, 0x51, 0x70, 0xde, 0x73, 0xb6, 0x9f, 0x8e, 0x56, 0x14, - 0x83, 0xf3, 0x2c, 0x0c, 0x91, 0xed, 0x84, 0x44, 0xbe, 0xe3, 0x5d, 0xc7, 0x0b, 0xd2, 0x2b, 0xcb, - 0xd6, 0xc0, 0x45, 0xa3, 0x1d, 0xa7, 0xb0, 0x90, 0xad, 0x1c, 0x25, 0x46, 0xda, 0x28, 0x77, 0x94, - 0x48, 0xb7, 0x88, 0xfd, 0xbf, 0x4b, 0x29, 0x83, 0x6c, 0x35, 0x22, 0x04, 0x05, 0x50, 0xf1, 0x83, - 0x86, 0x92, 0xfd, 0x57, 0x8a, 0x91, 0xfd, 0xd7, 0x82, 0x86, 0x51, 0xde, 0x85, 0xfe, 0x8b, 0x31, - 0xe7, 0xc3, 0xea, 0x5f, 0xc8, 0x42, 0x21, 0x0c, 0x20, 0x36, 0x1a, 0x45, 0x72, 0x56, 0xf5, 0x2f, - 0x96, 0x4c, 0x46, 0x38, 0xcd, 0x17, 0x6d, 0x42, 0x65, 0x23, 0x88, 0x13, 0xb9, 0xfd, 0x38, 0xe2, - 0x4e, 0xe7, 0x72, 0x10, 0x27, 0xcc, 0x8a, 0x50, 0xaf, 0x4d, 0x5b, 0x62, 0xcc, 0x79, 0xd8, 0xff, - 0xc5, 0x4a, 0xf9, 0xe0, 0x6f, 0xb2, 0xc8, 0xdd, 0x2d, 0xe2, 0xd3, 0x65, 0x6d, 0x86, 0x2a, 0xfd, - 0x68, 0x26, 0x0f, 0xf2, 0x5d, 0xdd, 0x0a, 0x73, 0xdd, 0xa6, 0x14, 0x26, 0x18, 0x09, 0x23, 0xaa, - 0xe9, 0x93, 0x56, 0x3a, 0x23, 0xb5, 0x54, 0xc4, 0x06, 0xc3, 0xcc, 0xca, 0xde, 0x37, 0xb9, 0xd5, - 0x7e, 0xc3, 0x82, 0x81, 0x69, 0xa7, 0xbe, 0x19, 0xac, 0xaf, 0xa3, 0xa7, 0xa0, 0xda, 0x68, 0x47, - 0x66, 0x72, 0xac, 0x72, 0x1c, 0xcc, 0x8a, 0x76, 0xac, 0x30, 0xe8, 0x1c, 0x5e, 0x77, 0xea, 0x32, - 0x37, 0xbb, 0xcc, 0xe7, 0xf0, 0x25, 0xd6, 0x82, 0x05, 0x04, 0x3d, 0x07, 0x83, 0x2d, 0x67, 0x5b, - 0x3e, 0x9c, 0x3d, 0x00, 0x58, 0xd4, 0x20, 0x6c, 0xe2, 0xd9, 0xff, 0xca, 0x82, 0xb1, 0x69, 0x27, - 0x76, 0xeb, 0x53, 0xed, 0x64, 0x63, 0xda, 0x4d, 0xd6, 0xda, 0xf5, 0x4d, 0x92, 0xf0, 0x84, 0x7c, - 0xda, 0xcb, 0x76, 0x4c, 0x97, 0x92, 0xda, 0xd7, 0xa9, 0x5e, 0x5e, 0x17, 0xed, 0x58, 0x61, 0xa0, - 0xd7, 0x60, 0x30, 0x74, 0xe2, 0xf8, 0x76, 0x10, 0x35, 0x30, 0x59, 0x2f, 0xa6, 0x1c, 0xc6, 0x0a, - 0xa9, 0x47, 0x24, 0xc1, 0x64, 0x5d, 0x1c, 0x52, 0x6b, 0xfa, 0xd8, 0x64, 0x66, 0x7f, 0xd1, 0x82, - 0xb3, 0xd3, 0xc4, 0x89, 0x48, 0xc4, 0xaa, 0x67, 0xa8, 0x17, 0x99, 0xf1, 0x82, 0x76, 0x03, 0xbd, - 0x0a, 0xd5, 0x84, 0x36, 0xd3, 0x6e, 0x59, 0xc5, 0x76, 0x8b, 0x9d, 0x31, 0xaf, 0x0a, 0xe2, 0x58, - 0xb1, 0xb1, 0xff, 0xb6, 0x05, 0x43, 0xec, 0xb8, 0x6e, 0x96, 0x24, 0x8e, 0xeb, 0x75, 0x14, 0x99, - 0xb2, 0x7a, 0x2c, 0x32, 0x75, 0x1e, 0xfa, 0x36, 0x82, 0x16, 0xc9, 0x1e, 0x35, 0x5f, 0x0e, 0xe8, - 0xb6, 0x9a, 0x42, 0xd0, 0x33, 0xf4, 0xc3, 0xbb, 0x7e, 0xe2, 0xd0, 0x25, 0x20, 0xdd, 0xc1, 0xa3, - 0xfc, 0xa3, 0xab, 0x66, 0x6c, 0xe2, 0xd8, 0xbf, 0x5d, 0x83, 0x01, 0x11, 0x8f, 0xd0, 0x73, 0x51, - 0x06, 0xb9, 0xbf, 0x2f, 0x75, 0xdd, 0xdf, 0xc7, 0xd0, 0x5f, 0x67, 0xd5, 0xee, 0x84, 0x19, 0x79, - 0xb5, 0x90, 0x00, 0x16, 0x5e, 0x40, 0x4f, 0x77, 0x8b, 0xff, 0xc7, 0x82, 0x15, 0xfa, 0x92, 0x05, - 0xa3, 0xf5, 0xc0, 0xf7, 0x49, 0x5d, 0xdb, 0x38, 0x7d, 0x45, 0xc4, 0x29, 0xcc, 0xa4, 0x89, 0xea, - 0xb3, 0xa2, 0x0c, 0x00, 0x67, 0xd9, 0xa3, 0x17, 0x60, 0x98, 0x8f, 0xd9, 0x8d, 0x94, 0x0f, 0x5b, - 0xd7, 0x1e, 0x32, 0x81, 0x38, 0x8d, 0x8b, 0x26, 0xf8, 0x59, 0x80, 0xa8, 0xf2, 0xd3, 0xaf, 0x5d, - 0x75, 0x46, 0x7d, 0x1f, 0x03, 0x03, 0x45, 0x80, 0x22, 0xb2, 0x1e, 0x91, 0x78, 0x43, 0xc4, 0x6b, - 0x30, 0xfb, 0x6a, 0xe0, 0x70, 0x09, 0xdc, 0xb8, 0x83, 0x12, 0xce, 0xa1, 0x8e, 0x36, 0xc5, 0x06, - 0xb3, 0x5a, 0x84, 0x0c, 0x15, 0x9f, 0xb9, 0xeb, 0x3e, 0x73, 0x1c, 0x2a, 0xf1, 0x86, 0x13, 0x35, - 0x98, 0x5d, 0x57, 0xe6, 0x49, 0x43, 0x2b, 0xb4, 0x01, 0xf3, 0x76, 0x34, 0x0b, 0x27, 0x32, 0x95, - 0x93, 0x62, 0x66, 0xb9, 0x55, 0x75, 0x82, 0x48, 0xa6, 0xe6, 0x52, 0x8c, 0x3b, 0x9e, 0x30, 0x9d, - 0x0f, 0x83, 0xfb, 0x38, 0x1f, 0x76, 0x54, 0x54, 0x20, 0x77, 0x21, 0xbf, 0x58, 0xc8, 0x00, 0xf4, - 0x14, 0x02, 0xf8, 0x85, 0x4c, 0x08, 0x20, 0x77, 0x23, 0xdf, 0x28, 0xa6, 0x03, 0x07, 0x8f, 0xf7, - 0xbb, 0x9f, 0xf1, 0x7b, 0x7f, 0x69, 0x81, 0xfc, 0xae, 0x33, 0x4e, 0x7d, 0x83, 0xd0, 0x29, 0x83, - 0xde, 0x0f, 0x23, 0x6a, 0x0b, 0x3d, 0x13, 0xb4, 0x7d, 0x1e, 0xba, 0x57, 0xd6, 0x27, 0x16, 0x38, - 0x05, 0xc5, 0x19, 0x6c, 0x34, 0x09, 0x35, 0x3a, 0x4e, 0xfc, 0x51, 0xae, 0x6b, 0xd5, 0x36, 0x7d, - 0x6a, 0x79, 0x5e, 0x3c, 0xa5, 0x71, 0x50, 0x00, 0x27, 0x3d, 0x27, 0x4e, 0x58, 0x0f, 0xe8, 0x8e, - 0xfa, 0x90, 0xe5, 0x13, 0x58, 0x16, 0xc2, 0x42, 0x96, 0x10, 0xee, 0xa4, 0x6d, 0x7f, 0xa7, 0x0f, - 0x86, 0x53, 0x92, 0xf1, 0x80, 0x4a, 0xfa, 0x29, 0xa8, 0x4a, 0xbd, 0x99, 0x2d, 0xf4, 0xa2, 0x94, - 0xab, 0xc2, 0xa0, 0x4a, 0x6b, 0x4d, 0x6b, 0xd5, 0xac, 0x51, 0x61, 0x28, 0x5c, 0x6c, 0xe2, 0x31, - 0xa1, 0x9c, 0x78, 0xf1, 0x8c, 0xe7, 0x12, 0x3f, 0xe1, 0xdd, 0x2c, 0x46, 0x28, 0xaf, 0x2e, 0xac, - 0x98, 0x44, 0xb5, 0x50, 0xce, 0x00, 0x70, 0x96, 0x3d, 0xfa, 0x8c, 0x05, 0xc3, 0xce, 0xed, 0x58, - 0x97, 0x64, 0x15, 0xc1, 0x7e, 0x47, 0x54, 0x52, 0xa9, 0x2a, 0xaf, 0xdc, 0xe5, 0x9b, 0x6a, 0xc2, - 0x69, 0xa6, 0xe8, 0x4d, 0x0b, 0x10, 0xd9, 0x26, 0x75, 0x19, 0x8e, 0x28, 0xfa, 0xd2, 0x5f, 0xc4, - 0x4e, 0xf3, 0x62, 0x07, 0x5d, 0x2e, 0xd5, 0x3b, 0xdb, 0x71, 0x4e, 0x1f, 0xec, 0x6f, 0x96, 0xd5, - 0x82, 0xd2, 0x11, 0xb0, 0x8e, 0x11, 0x89, 0x67, 0x1d, 0x3e, 0x12, 0x4f, 0x47, 0x34, 0x74, 0x66, - 0x65, 0xa6, 0x92, 0xb8, 0x4a, 0xf7, 0x29, 0x89, 0xeb, 0x67, 0xac, 0x54, 0x49, 0xa3, 0xc1, 0x0b, - 0x2f, 0x15, 0x1b, 0x7d, 0x3b, 0xc1, 0xa3, 0x2d, 0x32, 0xd2, 0x3d, 0x1d, 0x64, 0x43, 0xa5, 0xa9, - 0x81, 0x76, 0x20, 0x69, 0xf8, 0xef, 0xcb, 0x30, 0x68, 0x68, 0xd2, 0x5c, 0xb3, 0xc8, 0x7a, 0xc0, - 0xcc, 0xa2, 0xd2, 0x01, 0xcc, 0xa2, 0x9f, 0x86, 0x5a, 0x5d, 0x4a, 0xf9, 0x62, 0x8a, 0xfa, 0x66, - 0x75, 0x87, 0x16, 0xf4, 0xaa, 0x09, 0x6b, 0x9e, 0x68, 0x2e, 0x95, 0xfa, 0x23, 0x34, 0x44, 0x1f, - 0xd3, 0x10, 0x79, 0xb9, 0x39, 0x42, 0x53, 0x74, 0x3e, 0xc3, 0x2a, 0x5f, 0x85, 0xae, 0x78, 0x2f, - 0x19, 0x23, 0xcf, 0x2b, 0x5f, 0x2d, 0xcf, 0xcb, 0x66, 0x6c, 0xe2, 0xd8, 0xdf, 0xb1, 0xd4, 0xc7, - 0xbd, 0x07, 0x35, 0x1e, 0x6e, 0xa5, 0x6b, 0x3c, 0x5c, 0x2c, 0x64, 0x98, 0xbb, 0x14, 0x77, 0xb8, - 0x06, 0x03, 0x33, 0x41, 0xab, 0xe5, 0xf8, 0x0d, 0xf4, 0x43, 0x30, 0x50, 0xe7, 0x3f, 0x85, 0x63, - 0x87, 0x1d, 0x0f, 0x0a, 0x28, 0x96, 0x30, 0xf4, 0x08, 0xf4, 0x39, 0x51, 0x53, 0x3a, 0x73, 0x58, - 0x70, 0xce, 0x54, 0xd4, 0x8c, 0x31, 0x6b, 0xb5, 0xff, 0x69, 0x1f, 0xb0, 0x33, 0x6d, 0x27, 0x22, - 0x8d, 0xd5, 0x80, 0x15, 0x15, 0x3c, 0xd6, 0x43, 0x35, 0xbd, 0x59, 0x7a, 0x90, 0x0f, 0xd6, 0x8c, - 0xc3, 0x95, 0xf2, 0x3d, 0x3e, 0x5c, 0xe9, 0x72, 0x5e, 0xd6, 0xf7, 0x00, 0x9d, 0x97, 0xd9, 0x9f, - 0xb7, 0x00, 0xa9, 0x40, 0x08, 0x7d, 0xa0, 0x3d, 0x09, 0x35, 0x15, 0x12, 0x21, 0x0c, 0x2b, 0x2d, - 0x22, 0x24, 0x00, 0x6b, 0x9c, 0x1e, 0x76, 0xc8, 0x8f, 0x4b, 0xf9, 0x5d, 0x4e, 0xc7, 0xf5, 0x32, - 0xa9, 0x2f, 0xc4, 0xb9, 0xfd, 0x3b, 0x25, 0x78, 0x88, 0xab, 0xe4, 0x45, 0xc7, 0x77, 0x9a, 0xa4, - 0x45, 0x7b, 0xd5, 0x6b, 0x88, 0x42, 0x9d, 0x6e, 0xcd, 0x5c, 0x19, 0xa7, 0x7b, 0xd4, 0xb5, 0xcb, - 0xd7, 0x1c, 0x5f, 0x65, 0xf3, 0xbe, 0x9b, 0x60, 0x46, 0x1c, 0xc5, 0x50, 0x95, 0x15, 0xef, 0x85, - 0x2c, 0x2e, 0x88, 0x91, 0x12, 0x4b, 0x42, 0x6f, 0x12, 0xac, 0x18, 0x51, 0xc3, 0xd5, 0x0b, 0xea, - 0x9b, 0x98, 0x84, 0x01, 0x93, 0xbb, 0x46, 0x98, 0xe4, 0x82, 0x68, 0xc7, 0x0a, 0xc3, 0xfe, 0x1d, - 0x0b, 0xb2, 0x1a, 0xc9, 0xa8, 0xde, 0x66, 0xed, 0x59, 0xbd, 0xed, 0x00, 0xe5, 0xd3, 0x7e, 0x12, - 0x06, 0x9d, 0x84, 0x1a, 0x11, 0x7c, 0xdb, 0x5d, 0x3e, 0xdc, 0xb1, 0xc6, 0x62, 0xd0, 0x70, 0xd7, - 0x5d, 0xb6, 0xdd, 0x36, 0xc9, 0xd9, 0xff, 0xa3, 0x0f, 0x4e, 0x76, 0x64, 0x93, 0xa0, 0xe7, 0x61, - 0xa8, 0x2e, 0xa6, 0x47, 0x28, 0x1d, 0x5a, 0x35, 0x33, 0xac, 0x4e, 0xc3, 0x70, 0x0a, 0xb3, 0x87, - 0x09, 0x3a, 0x0f, 0xa7, 0x22, 0xba, 0xd1, 0x6f, 0x93, 0xa9, 0xf5, 0x84, 0x44, 0x2b, 0xa4, 0x1e, - 0xf8, 0x0d, 0x5e, 0x63, 0xb0, 0x3c, 0xfd, 0xf0, 0x9d, 0xdd, 0xf1, 0x53, 0xb8, 0x13, 0x8c, 0xf3, - 0x9e, 0x41, 0x21, 0x0c, 0x7b, 0xa6, 0x0d, 0x28, 0x36, 0x00, 0x87, 0x32, 0x1f, 0x95, 0x8d, 0x90, - 0x6a, 0xc6, 0x69, 0x06, 0x69, 0x43, 0xb2, 0x72, 0x9f, 0x0c, 0xc9, 0x4f, 0x6b, 0x43, 0x92, 0x9f, - 0xbf, 0x7f, 0xb8, 0xe0, 0x6c, 0xa2, 0xe3, 0xb6, 0x24, 0x5f, 0x84, 0xaa, 0x8c, 0x4d, 0xea, 0x29, - 0xa6, 0xc7, 0xa4, 0xd3, 0x45, 0xa2, 0x3d, 0x01, 0x3f, 0x78, 0x31, 0x8a, 0x8c, 0xc1, 0xbc, 0x16, - 0x24, 0x53, 0x9e, 0x17, 0xdc, 0xa6, 0x4a, 0xfa, 0x7a, 0x4c, 0x84, 0x87, 0xc5, 0xbe, 0x5b, 0x82, - 0x9c, 0xcd, 0x0a, 0x5d, 0x8f, 0xda, 0x32, 0x48, 0xad, 0xc7, 0x83, 0x59, 0x07, 0x68, 0x9b, 0xc7, - 0x6f, 0x71, 0x1d, 0xf8, 0xa1, 0xa2, 0x37, 0x5b, 0x3a, 0xa4, 0x4b, 0x25, 0x63, 0xa8, 0xb0, 0xae, - 0x0b, 0x00, 0xda, 0xa0, 0x13, 0xa1, 0xf6, 0xea, 0x78, 0x58, 0xdb, 0x7d, 0xd8, 0xc0, 0xa2, 0x7b, - 0x6f, 0xd7, 0x8f, 0x13, 0xc7, 0xf3, 0x2e, 0xbb, 0x7e, 0x22, 0x9c, 0x88, 0x4a, 0xd9, 0xcf, 0x6b, - 0x10, 0x36, 0xf1, 0xce, 0xbd, 0xd7, 0xf8, 0x7e, 0x07, 0xf9, 0xee, 0x1b, 0x70, 0x76, 0xce, 0x4d, - 0x54, 0x82, 0x88, 0x9a, 0x6f, 0xd4, 0x5e, 0x53, 0x09, 0x4f, 0x56, 0xd7, 0x84, 0x27, 0x23, 0x41, - 0xa3, 0x94, 0xce, 0x27, 0xc9, 0x26, 0x68, 0xd8, 0xcf, 0xc3, 0xe9, 0x39, 0x37, 0xb9, 0xe4, 0x7a, - 0xe4, 0x80, 0x4c, 0xec, 0xdf, 0xea, 0x87, 0x21, 0x33, 0xc5, 0xf0, 0x20, 0x39, 0x5b, 0x5f, 0xa4, - 0x26, 0x99, 0x78, 0x3b, 0x57, 0x1d, 0xae, 0xdd, 0x3c, 0x72, 0xbe, 0x63, 0xfe, 0x88, 0x19, 0x56, - 0x99, 0xe6, 0x89, 0xcd, 0x0e, 0xa0, 0xdb, 0x50, 0x59, 0x67, 0x09, 0x04, 0xe5, 0x22, 0x22, 0x10, - 0xf2, 0x46, 0x54, 0x2f, 0x47, 0x9e, 0x82, 0xc0, 0xf9, 0x51, 0x4d, 0x1a, 0xa5, 0xb3, 0xd2, 0x8c, - 0xa0, 0x55, 0x91, 0x8f, 0xa6, 0x30, 0xba, 0xa9, 0x84, 0xca, 0x21, 0x54, 0x42, 0x4a, 0x40, 0xf7, - 0xdf, 0x27, 0x01, 0xcd, 0x92, 0x41, 0x92, 0x0d, 0x66, 0xe7, 0x89, 0x28, 0xfd, 0x01, 0x36, 0x08, - 0x46, 0x32, 0x48, 0x0a, 0x8c, 0xb3, 0xf8, 0xe8, 0x13, 0x4a, 0xc4, 0x57, 0x8b, 0xf0, 0xbf, 0x9a, - 0x33, 0xfa, 0xb8, 0xa5, 0xfb, 0xe7, 0x4b, 0x30, 0x32, 0xe7, 0xb7, 0x97, 0xe7, 0x96, 0xdb, 0x6b, - 0x9e, 0x5b, 0xbf, 0x4a, 0x76, 0xa8, 0x08, 0xdf, 0x24, 0x3b, 0xf3, 0xb3, 0x62, 0x05, 0xa9, 0x39, - 0x73, 0x95, 0x36, 0x62, 0x0e, 0xa3, 0xc2, 0x68, 0xdd, 0xf5, 0x9b, 0x24, 0x0a, 0x23, 0x57, 0xb8, - 0x46, 0x0d, 0x61, 0x74, 0x49, 0x83, 0xb0, 0x89, 0x47, 0x69, 0x07, 0xb7, 0x7d, 0x12, 0x65, 0x0d, - 0xde, 0x25, 0xda, 0x88, 0x39, 0x8c, 0x22, 0x25, 0x51, 0x3b, 0x4e, 0xc4, 0x64, 0x54, 0x48, 0xab, - 0xb4, 0x11, 0x73, 0x18, 0x5d, 0xe9, 0x71, 0x7b, 0x8d, 0x05, 0x78, 0x64, 0x52, 0x02, 0x56, 0x78, - 0x33, 0x96, 0x70, 0x8a, 0xba, 0x49, 0x76, 0x66, 0xe9, 0xee, 0x38, 0x93, 0x19, 0x74, 0x95, 0x37, - 0x63, 0x09, 0x67, 0x45, 0x14, 0xd3, 0xc3, 0xf1, 0x96, 0x2b, 0xa2, 0x98, 0xee, 0x7e, 0x97, 0x7d, - 0xf6, 0xaf, 0x58, 0x30, 0x64, 0x86, 0x65, 0xa1, 0x66, 0xc6, 0x16, 0x5e, 0xea, 0xa8, 0xc1, 0xfb, - 0xe3, 0x79, 0x17, 0x98, 0x35, 0xdd, 0x24, 0x08, 0xe3, 0xa7, 0x89, 0xdf, 0x74, 0x7d, 0xc2, 0x4e, - 0xdb, 0x79, 0x38, 0x57, 0x2a, 0xe6, 0x6b, 0x26, 0x68, 0x90, 0x43, 0x18, 0xd3, 0xf6, 0x4d, 0x38, - 0xd9, 0x91, 0x0e, 0xd6, 0x83, 0x09, 0xb2, 0x6f, 0x32, 0xae, 0x8d, 0x61, 0x90, 0x12, 0x96, 0x85, - 0x7c, 0x66, 0xe0, 0x24, 0x5f, 0x48, 0x94, 0xd3, 0x4a, 0x7d, 0x83, 0xb4, 0x54, 0x8a, 0x1f, 0xf3, - 0xc3, 0xdf, 0xc8, 0x02, 0x71, 0x27, 0xbe, 0xfd, 0x05, 0x0b, 0x86, 0x53, 0x19, 0x7a, 0x05, 0x19, - 0x4b, 0x6c, 0xa5, 0x05, 0x2c, 0x4a, 0x90, 0x85, 0x4a, 0x97, 0x99, 0x32, 0xd5, 0x2b, 0x4d, 0x83, - 0xb0, 0x89, 0x67, 0xbf, 0x51, 0x82, 0xaa, 0x8c, 0xb4, 0xe8, 0xa1, 0x2b, 0x9f, 0xb3, 0x60, 0x58, - 0x9d, 0x7d, 0x30, 0xa7, 0x5a, 0xa9, 0x88, 0x74, 0x08, 0xda, 0x03, 0xb5, 0x2d, 0xf7, 0xd7, 0x03, - 0x6d, 0xb9, 0x63, 0x93, 0x19, 0x4e, 0xf3, 0x46, 0x37, 0x00, 0xe2, 0x9d, 0x38, 0x21, 0x2d, 0xc3, - 0xbd, 0x67, 0x1b, 0x2b, 0x6e, 0xa2, 0x1e, 0x44, 0x84, 0xae, 0xaf, 0x6b, 0x41, 0x83, 0xac, 0x28, - 0x4c, 0x6d, 0x42, 0xe9, 0x36, 0x6c, 0x50, 0xb2, 0xff, 0x71, 0x09, 0x4e, 0x64, 0xbb, 0x84, 0x3e, - 0x0c, 0x43, 0x92, 0xbb, 0x71, 0x17, 0x9b, 0x0c, 0x2f, 0x19, 0xc2, 0x06, 0xec, 0xee, 0xee, 0xf8, - 0x78, 0xe7, 0x65, 0x78, 0x13, 0x26, 0x0a, 0x4e, 0x11, 0xe3, 0x07, 0x50, 0xe2, 0xa4, 0x74, 0x7a, - 0x67, 0x2a, 0x0c, 0xc5, 0x29, 0x92, 0x71, 0x00, 0x65, 0x42, 0x71, 0x06, 0x1b, 0x2d, 0xc3, 0x69, - 0xa3, 0xe5, 0x1a, 0x71, 0x9b, 0x1b, 0x6b, 0x41, 0x24, 0x77, 0x60, 0x8f, 0xe8, 0x00, 0xb0, 0x4e, - 0x1c, 0x9c, 0xfb, 0x24, 0xd5, 0xf6, 0x75, 0x27, 0x74, 0xea, 0x6e, 0xb2, 0x23, 0xfc, 0x95, 0x4a, - 0x36, 0xcd, 0x88, 0x76, 0xac, 0x30, 0xec, 0x45, 0xe8, 0xeb, 0x71, 0x06, 0xf5, 0x64, 0xf9, 0xbf, - 0x08, 0x55, 0x4a, 0x4e, 0x9a, 0x77, 0x45, 0x90, 0x0c, 0xa0, 0x2a, 0xef, 0x48, 0x41, 0x36, 0x94, - 0x5d, 0x47, 0x9e, 0xf1, 0xa9, 0xd7, 0x9a, 0x8f, 0xe3, 0x36, 0xdb, 0x4c, 0x53, 0x20, 0x7a, 0x1c, - 0xca, 0x64, 0x3b, 0xcc, 0x1e, 0xe6, 0x5d, 0xdc, 0x0e, 0xdd, 0x88, 0xc4, 0x14, 0x89, 0x6c, 0x87, - 0xe8, 0x1c, 0x94, 0xdc, 0x86, 0x50, 0x52, 0x20, 0x70, 0x4a, 0xf3, 0xb3, 0xb8, 0xe4, 0x36, 0xec, - 0x6d, 0xa8, 0xa9, 0x4b, 0x59, 0xd0, 0xa6, 0x94, 0xdd, 0x56, 0x11, 0xa1, 0x51, 0x92, 0x6e, 0x17, - 0xa9, 0xdd, 0x06, 0xd0, 0xa9, 0x8a, 0x45, 0xc9, 0x97, 0xf3, 0xd0, 0x57, 0x0f, 0x44, 0x1a, 0x75, - 0x55, 0x93, 0x61, 0x42, 0x9b, 0x41, 0xec, 0x9b, 0x30, 0x72, 0xd5, 0x0f, 0x6e, 0xb3, 0x8a, 0xf2, - 0xac, 0x80, 0x1a, 0x25, 0xbc, 0x4e, 0x7f, 0x64, 0x4d, 0x04, 0x06, 0xc5, 0x1c, 0xa6, 0x2a, 0x4b, - 0x95, 0xba, 0x55, 0x96, 0xb2, 0x3f, 0x69, 0xc1, 0x90, 0xca, 0x59, 0x9a, 0xdb, 0xda, 0xa4, 0x74, - 0x9b, 0x51, 0xd0, 0x0e, 0xb3, 0x74, 0xd9, 0xb5, 0x49, 0x98, 0xc3, 0xcc, 0x64, 0xc0, 0xd2, 0x3e, - 0xc9, 0x80, 0xe7, 0xa1, 0x6f, 0xd3, 0xf5, 0x1b, 0xd9, 0x7b, 0x40, 0xae, 0xba, 0x7e, 0x03, 0x33, - 0x88, 0xfd, 0x4d, 0x0b, 0x4e, 0xa8, 0x2e, 0x48, 0x85, 0xf0, 0x3c, 0x0c, 0xad, 0xb5, 0x5d, 0xaf, - 0x21, 0x2b, 0xc3, 0x65, 0x3c, 0x2a, 0xd3, 0x06, 0x0c, 0xa7, 0x30, 0xe9, 0xbe, 0x6e, 0xcd, 0xf5, - 0x9d, 0x68, 0x67, 0x59, 0x6b, 0x20, 0x25, 0x94, 0xa6, 0x15, 0x04, 0x1b, 0x58, 0x94, 0x5b, 0x4c, - 0x12, 0x1d, 0x24, 0xc9, 0x3f, 0x84, 0xe2, 0xb6, 0x62, 0xc0, 0x70, 0x0a, 0xd3, 0x7e, 0xbd, 0x0c, - 0x23, 0xe9, 0x9c, 0xaf, 0x1e, 0x36, 0x66, 0x8f, 0x43, 0x85, 0xa5, 0x81, 0x65, 0x27, 0x05, 0x2f, - 0xc3, 0xc6, 0x61, 0x28, 0x86, 0x7e, 0x5e, 0x80, 0xa2, 0x98, 0xdb, 0x77, 0x54, 0x27, 0x95, 0x07, - 0x87, 0x45, 0xac, 0x89, 0x9a, 0x17, 0x82, 0x15, 0xfa, 0x8c, 0x05, 0x03, 0x41, 0x68, 0xd6, 0x32, - 0xfa, 0x50, 0x91, 0xf9, 0x70, 0x22, 0x1d, 0x47, 0xd8, 0xd2, 0x6a, 0xd2, 0xc8, 0x0f, 0x29, 0x59, - 0x9f, 0x7b, 0x1f, 0x0c, 0x99, 0x98, 0xfb, 0x99, 0xd3, 0x55, 0xd3, 0x9c, 0xfe, 0x9c, 0x39, 0x9d, - 0x44, 0xc6, 0x5f, 0x0f, 0x0b, 0xf5, 0x3a, 0x54, 0xea, 0x2a, 0xc4, 0xe0, 0x50, 0x95, 0x48, 0x55, - 0x45, 0x08, 0x76, 0xcc, 0xc4, 0xa9, 0xd9, 0xdf, 0xb1, 0x8c, 0xf9, 0x81, 0x49, 0x3c, 0xdf, 0x40, - 0x11, 0x94, 0x9b, 0x5b, 0x9b, 0xc2, 0x88, 0xbd, 0x52, 0xd0, 0xf0, 0xce, 0x6d, 0x6d, 0xea, 0xf9, - 0x6a, 0xb6, 0x62, 0xca, 0xac, 0x07, 0x37, 0x63, 0x2a, 0x31, 0xb4, 0xbc, 0x7f, 0x62, 0xa8, 0xfd, - 0x66, 0x09, 0x4e, 0x76, 0x4c, 0x2a, 0xf4, 0x1a, 0x54, 0x22, 0xfa, 0x96, 0xe2, 0xf5, 0x16, 0x0a, - 0x4b, 0xe5, 0x8c, 0xe7, 0x1b, 0x5a, 0x63, 0xa7, 0xdb, 0x31, 0x67, 0x89, 0xae, 0x00, 0xd2, 0x81, - 0x30, 0xca, 0xc7, 0xc9, 0x5f, 0xf9, 0x9c, 0x78, 0x14, 0x4d, 0x75, 0x60, 0xe0, 0x9c, 0xa7, 0xd0, - 0x0b, 0x59, 0x57, 0x69, 0x39, 0x7d, 0x32, 0xba, 0x97, 0xd7, 0xd3, 0xfe, 0x97, 0x25, 0x18, 0x4e, - 0x95, 0x96, 0x42, 0x1e, 0x54, 0x89, 0xc7, 0x8e, 0x0d, 0xa4, 0x9a, 0x3a, 0x6a, 0xa5, 0x66, 0xa5, - 0x5a, 0x2f, 0x0a, 0xba, 0x58, 0x71, 0x78, 0x30, 0x8e, 0xef, 0x9f, 0x87, 0x21, 0xd9, 0xa1, 0x0f, - 0x39, 0x2d, 0x4f, 0x0c, 0xa0, 0x9a, 0xa3, 0x17, 0x0d, 0x18, 0x4e, 0x61, 0xda, 0xbf, 0x5b, 0x86, - 0x31, 0x7e, 0xce, 0xd2, 0x50, 0x33, 0x6f, 0x51, 0xee, 0xd4, 0xfe, 0xba, 0x2e, 0x00, 0xc7, 0x07, - 0x72, 0xed, 0xa8, 0x17, 0x23, 0xe4, 0x33, 0xea, 0x29, 0xf6, 0xeb, 0xab, 0x99, 0xd8, 0x2f, 0x6e, - 0xb0, 0x37, 0x8f, 0xa9, 0x47, 0x6f, 0xad, 0x60, 0xb0, 0x7f, 0x50, 0x82, 0xd1, 0xcc, 0xad, 0x13, - 0xe8, 0xf5, 0x74, 0xa1, 0x62, 0xab, 0x08, 0x6f, 0xfc, 0x9e, 0x17, 0x11, 0x1c, 0xac, 0x5c, 0xf1, - 0x7d, 0x5a, 0x2a, 0xf6, 0x1f, 0x95, 0x60, 0x24, 0x7d, 0x5d, 0xc6, 0x03, 0x38, 0x52, 0xef, 0x86, - 0x1a, 0xab, 0x08, 0xcf, 0xae, 0x01, 0xe5, 0xce, 0x7c, 0x5e, 0x7c, 0x5b, 0x36, 0x62, 0x0d, 0x7f, - 0x20, 0xaa, 0x40, 0xdb, 0xff, 0xd0, 0x82, 0x33, 0xfc, 0x2d, 0xb3, 0xf3, 0xf0, 0x6f, 0xe4, 0x8d, - 0xee, 0xcb, 0xc5, 0x76, 0x30, 0x53, 0xb8, 0x70, 0xbf, 0xf1, 0x65, 0xd7, 0x0f, 0x8a, 0xde, 0xa6, - 0xa7, 0xc2, 0x03, 0xd8, 0xd9, 0x03, 0x4d, 0x06, 0xfb, 0x8f, 0xca, 0xa0, 0x6f, 0x5c, 0x44, 0xae, - 0xc8, 0xa2, 0x2c, 0xa4, 0x80, 0xe3, 0xca, 0x8e, 0x5f, 0xd7, 0x77, 0x3b, 0x56, 0x33, 0x49, 0x94, - 0x3f, 0x6f, 0xc1, 0xa0, 0xeb, 0xbb, 0x89, 0xeb, 0xb0, 0x0d, 0x78, 0x31, 0xb7, 0xc1, 0x29, 0x76, - 0xf3, 0x9c, 0x72, 0x10, 0x99, 0x27, 0x40, 0x8a, 0x19, 0x36, 0x39, 0xa3, 0x8f, 0x8a, 0xf0, 0xec, - 0x72, 0x61, 0xf9, 0xbf, 0xd5, 0x4c, 0x4c, 0x76, 0x48, 0x0d, 0xaf, 0x24, 0x2a, 0x28, 0x6d, 0x1e, - 0x53, 0x52, 0xaa, 0x16, 0xb0, 0xbe, 0xfb, 0x9a, 0x36, 0x63, 0xce, 0xc8, 0x8e, 0x01, 0x75, 0x8e, - 0xc5, 0x01, 0x43, 0x5f, 0x27, 0xa1, 0xe6, 0xb4, 0x93, 0xa0, 0x45, 0x87, 0x49, 0x1c, 0x52, 0xe9, - 0xe0, 0x5e, 0x09, 0xc0, 0x1a, 0xc7, 0x7e, 0xbd, 0x02, 0x99, 0xb4, 0x46, 0xb4, 0x6d, 0xde, 0x16, - 0x6a, 0x15, 0x7b, 0x5b, 0xa8, 0xea, 0x4c, 0xde, 0x8d, 0xa1, 0xa8, 0x09, 0x95, 0x70, 0xc3, 0x89, - 0xa5, 0x59, 0xfd, 0xa2, 0xda, 0xc7, 0xd1, 0xc6, 0xbb, 0xbb, 0xe3, 0x3f, 0xd1, 0x9b, 0xbf, 0x96, - 0xce, 0xd5, 0x49, 0x5e, 0x20, 0x45, 0xb3, 0x66, 0x34, 0x30, 0xa7, 0x7f, 0x90, 0xfb, 0xf0, 0x3e, - 0x25, 0x4a, 0xdf, 0x63, 0x12, 0xb7, 0xbd, 0x44, 0xcc, 0x86, 0x17, 0x0b, 0x5c, 0x65, 0x9c, 0xb0, - 0x4e, 0xc8, 0xe7, 0xff, 0xb1, 0xc1, 0x14, 0x7d, 0x18, 0x6a, 0x71, 0xe2, 0x44, 0xc9, 0x21, 0x53, - 0x68, 0xd5, 0xa0, 0xaf, 0x48, 0x22, 0x58, 0xd3, 0x43, 0x2f, 0xb1, 0x7a, 0xb6, 0x6e, 0xbc, 0x71, - 0xc8, 0xac, 0x0a, 0x59, 0xfb, 0x56, 0x50, 0xc0, 0x06, 0x35, 0x74, 0x01, 0x80, 0xcd, 0x6d, 0x1e, - 0x4a, 0x58, 0x65, 0xfe, 0x29, 0x25, 0x0a, 0xb1, 0x82, 0x60, 0x03, 0xcb, 0xfe, 0x11, 0x48, 0x57, - 0x94, 0x40, 0xe3, 0xb2, 0x80, 0x05, 0xf7, 0x5f, 0xb3, 0xec, 0x88, 0x54, 0xad, 0x89, 0xdf, 0xb0, - 0xc0, 0x2c, 0x7b, 0x81, 0x5e, 0xe5, 0xf5, 0x35, 0xac, 0x22, 0xce, 0x1c, 0x0d, 0xba, 0x13, 0x8b, - 0x4e, 0x98, 0x39, 0xfc, 0x96, 0x45, 0x36, 0xce, 0xbd, 0x17, 0xaa, 0x12, 0x7a, 0x20, 0xa3, 0xee, - 0x13, 0x70, 0x2a, 0x7b, 0x97, 0xba, 0x38, 0xaf, 0xda, 0xdf, 0x69, 0x24, 0x3d, 0x41, 0xa5, 0x6e, - 0x9e, 0xa0, 0x1e, 0xee, 0x8c, 0xfd, 0x4d, 0x0b, 0xce, 0xef, 0x77, 0xe5, 0x3b, 0x7a, 0x04, 0xfa, - 0x6e, 0x3b, 0x91, 0x2c, 0x34, 0xce, 0x04, 0xe5, 0x4d, 0x27, 0xf2, 0x31, 0x6b, 0x45, 0x3b, 0xd0, - 0xcf, 0xe3, 0xcd, 0x84, 0xb5, 0xfe, 0x62, 0xb1, 0x17, 0xd0, 0x5f, 0x25, 0xc6, 0x76, 0x81, 0xc7, - 0xba, 0x61, 0xc1, 0xd0, 0xfe, 0xae, 0x05, 0x68, 0x69, 0x8b, 0x44, 0x91, 0xdb, 0x30, 0x22, 0xe4, - 0xd8, 0x15, 0x32, 0xc6, 0x55, 0x31, 0x66, 0x12, 0x6d, 0xe6, 0x0a, 0x19, 0xe3, 0x5f, 0xfe, 0x15, - 0x32, 0xa5, 0x83, 0x5d, 0x21, 0x83, 0x96, 0xe0, 0x4c, 0x8b, 0x6f, 0x37, 0xf8, 0xb5, 0x0c, 0x7c, - 0xef, 0xa1, 0x52, 0xd6, 0xce, 0xde, 0xd9, 0x1d, 0x3f, 0xb3, 0x98, 0x87, 0x80, 0xf3, 0x9f, 0xb3, - 0xdf, 0x0b, 0x88, 0x07, 0xc6, 0xcd, 0xe4, 0x45, 0x39, 0x75, 0x75, 0xbf, 0xd8, 0x5f, 0xa9, 0xc0, - 0x68, 0xa6, 0x0c, 0x2d, 0xdd, 0xea, 0x75, 0x86, 0x55, 0x1d, 0x59, 0x7f, 0x77, 0x76, 0xaf, 0xa7, - 0x40, 0x2d, 0x1f, 0x2a, 0xae, 0x1f, 0xb6, 0x93, 0x62, 0xb2, 0x54, 0x79, 0x27, 0xe6, 0x29, 0x41, - 0xc3, 0xd1, 0x4c, 0xff, 0x62, 0xce, 0xa6, 0xc8, 0xb0, 0xaf, 0x94, 0x31, 0xde, 0x77, 0x9f, 0xdc, - 0x01, 0x9f, 0xd2, 0x41, 0x58, 0x95, 0x22, 0x1c, 0x8b, 0x99, 0xc9, 0x72, 0xdc, 0x87, 0xf4, 0xbf, - 0x5e, 0x82, 0x41, 0xe3, 0xa3, 0xa1, 0x5f, 0x4e, 0x17, 0x85, 0xb2, 0x8a, 0x7b, 0x25, 0x46, 0x7f, - 0x42, 0x97, 0x7d, 0xe2, 0xaf, 0xf4, 0x44, 0x67, 0x3d, 0xa8, 0xbb, 0xbb, 0xe3, 0x27, 0x32, 0x15, - 0x9f, 0x52, 0x35, 0xa2, 0xce, 0x7d, 0x1c, 0x46, 0x33, 0x64, 0x72, 0x5e, 0x79, 0x35, 0x7d, 0x55, - 0xfe, 0x11, 0xdd, 0x52, 0xe6, 0x90, 0x7d, 0x83, 0x0e, 0x99, 0x48, 0xd4, 0x0b, 0x3c, 0xd2, 0x83, - 0x0f, 0x36, 0x93, 0x8f, 0x5b, 0xea, 0x31, 0x1f, 0xf7, 0x49, 0xa8, 0x86, 0x81, 0xe7, 0xd6, 0x5d, - 0x55, 0x79, 0x91, 0x65, 0x00, 0x2f, 0x8b, 0x36, 0xac, 0xa0, 0xe8, 0x36, 0xd4, 0x6e, 0xdd, 0x4e, - 0xf8, 0xb9, 0x91, 0xf0, 0x6f, 0x17, 0x75, 0x5c, 0xa4, 0x8c, 0x16, 0x75, 0x30, 0x85, 0x35, 0x2f, - 0x64, 0x43, 0x3f, 0x53, 0x82, 0x32, 0xb9, 0x80, 0xf9, 0xde, 0x99, 0x76, 0x8c, 0xb1, 0x80, 0xd8, - 0x5f, 0xaf, 0xc1, 0xe9, 0xbc, 0x5a, 0xe0, 0xe8, 0x63, 0xd0, 0xcf, 0xfb, 0x58, 0xcc, 0x75, 0x13, - 0x79, 0x3c, 0xe6, 0x18, 0x41, 0xd1, 0x2d, 0xf6, 0x1b, 0x0b, 0x9e, 0x82, 0xbb, 0xe7, 0xac, 0x89, - 0x19, 0x72, 0x3c, 0xdc, 0x17, 0x1c, 0xcd, 0x7d, 0xc1, 0xe1, 0xdc, 0x3d, 0x67, 0x0d, 0x6d, 0x43, - 0xa5, 0xe9, 0x26, 0xc4, 0x11, 0x4e, 0x84, 0x9b, 0xc7, 0xc2, 0x9c, 0x38, 0xdc, 0x4a, 0x63, 0x3f, - 0x31, 0x67, 0x88, 0xbe, 0x66, 0xc1, 0xe8, 0x5a, 0x3a, 0xf9, 0x5e, 0x08, 0x4f, 0xe7, 0x18, 0xea, - 0xbd, 0xa7, 0x19, 0xf1, 0x3b, 0x94, 0x32, 0x8d, 0x38, 0xdb, 0x1d, 0xf4, 0x69, 0x0b, 0x06, 0xd6, - 0x5d, 0xcf, 0x28, 0xfd, 0x7b, 0x0c, 0x1f, 0xe7, 0x12, 0x63, 0xa0, 0x77, 0x1c, 0xfc, 0x7f, 0x8c, - 0x25, 0xe7, 0x6e, 0x9a, 0xaa, 0xff, 0xa8, 0x9a, 0x6a, 0xe0, 0x3e, 0x69, 0xaa, 0xcf, 0x5a, 0x50, - 0x53, 0x23, 0x2d, 0x12, 0xaa, 0x3f, 0x7c, 0x8c, 0x9f, 0x9c, 0x7b, 0x4e, 0xd4, 0x5f, 0xac, 0x99, - 0xa3, 0x2f, 0x59, 0x30, 0xe8, 0xbc, 0xd6, 0x8e, 0x48, 0x83, 0x6c, 0x05, 0x61, 0x2c, 0x2e, 0x60, - 0x7c, 0xb9, 0xf8, 0xce, 0x4c, 0x51, 0x26, 0xb3, 0x64, 0x6b, 0x29, 0x8c, 0x45, 0xe2, 0x93, 0x6e, - 0xc0, 0x66, 0x17, 0xec, 0xdd, 0x12, 0x8c, 0xef, 0x43, 0x01, 0x3d, 0x0f, 0x43, 0x41, 0xd4, 0x74, - 0x7c, 0xf7, 0x35, 0xb3, 0x9a, 0x86, 0xb2, 0xb2, 0x96, 0x0c, 0x18, 0x4e, 0x61, 0x9a, 0x29, 0xdf, - 0xa5, 0x7d, 0x52, 0xbe, 0xcf, 0x43, 0x5f, 0x44, 0xc2, 0x20, 0xbb, 0x59, 0x60, 0x49, 0x07, 0x0c, - 0x82, 0x1e, 0x85, 0xb2, 0x13, 0xba, 0x22, 0x84, 0x4d, 0xed, 0x81, 0xa6, 0x96, 0xe7, 0x31, 0x6d, - 0x4f, 0x55, 0xa0, 0xa8, 0xdc, 0x93, 0x0a, 0x14, 0x54, 0x0d, 0x88, 0xb3, 0x8b, 0x7e, 0xad, 0x06, - 0xd2, 0x67, 0x0a, 0xf6, 0x9b, 0x65, 0x78, 0x74, 0xcf, 0xf9, 0xa2, 0x23, 0xf8, 0xac, 0x3d, 0x22, - 0xf8, 0xe4, 0xf0, 0x94, 0xf6, 0x1b, 0x9e, 0x72, 0x97, 0xe1, 0xf9, 0x34, 0x5d, 0x06, 0xb2, 0x0a, - 0x49, 0x31, 0x57, 0xe8, 0x75, 0x2b, 0x6a, 0x22, 0x56, 0x80, 0x84, 0x62, 0xcd, 0x97, 0xee, 0x01, - 0x52, 0xe9, 0xce, 0x95, 0x22, 0xd4, 0x40, 0xd7, 0xaa, 0x24, 0x7c, 0xee, 0x77, 0xcb, 0xa1, 0xb6, - 0x7f, 0xa1, 0x04, 0x8f, 0xf7, 0x20, 0xbd, 0xcd, 0x59, 0x6c, 0xf5, 0x38, 0x8b, 0xdf, 0xda, 0x9f, - 0xc9, 0xfe, 0x9b, 0x16, 0x9c, 0xeb, 0xae, 0x3c, 0xd0, 0x33, 0x30, 0xb8, 0x16, 0x39, 0x7e, 0x7d, - 0x83, 0x5d, 0x0b, 0x2a, 0x07, 0x85, 0x8d, 0xb5, 0x6e, 0xc6, 0x26, 0x0e, 0xdd, 0xde, 0xf2, 0x98, - 0x04, 0x03, 0x43, 0xa6, 0xa7, 0xd2, 0xed, 0xed, 0x6a, 0x16, 0x88, 0x3b, 0xf1, 0xed, 0xbf, 0x28, - 0xe5, 0x77, 0x8b, 0x1b, 0x19, 0x07, 0xf9, 0x4e, 0xe2, 0x2b, 0x94, 0x7a, 0x90, 0x25, 0xe5, 0x7b, - 0x2d, 0x4b, 0xfa, 0xba, 0xc9, 0x12, 0x34, 0x0b, 0x27, 0x8c, 0x6b, 0x63, 0x78, 0xca, 0x31, 0x0f, - 0xd5, 0x55, 0x75, 0x38, 0x96, 0x33, 0x70, 0xdc, 0xf1, 0x04, 0x7a, 0x0a, 0xaa, 0xae, 0x1f, 0x93, - 0x7a, 0x3b, 0xe2, 0x21, 0xe2, 0x46, 0x9a, 0xd7, 0xbc, 0x68, 0xc7, 0x0a, 0xc3, 0xfe, 0x95, 0x12, - 0x9c, 0xed, 0x6a, 0x67, 0xdd, 0x23, 0xd9, 0x65, 0x7e, 0x8e, 0xbe, 0x7b, 0xf3, 0x39, 0xcc, 0x41, - 0xaa, 0xec, 0x3b, 0x48, 0x7f, 0xdc, 0x7d, 0x62, 0x52, 0x9b, 0xfb, 0xfb, 0x76, 0x94, 0x5e, 0x80, - 0x61, 0x27, 0x0c, 0x39, 0x1e, 0x8b, 0xf4, 0xcc, 0xd4, 0xe1, 0x99, 0x32, 0x81, 0x38, 0x8d, 0xdb, - 0x93, 0xf6, 0xfc, 0x53, 0x0b, 0x6a, 0x98, 0xac, 0x73, 0xe9, 0x80, 0x6e, 0x89, 0x21, 0xb2, 0x8a, - 0xa8, 0xd8, 0x49, 0x07, 0x36, 0x76, 0x59, 0x25, 0xcb, 0xbc, 0xc1, 0xee, 0xbc, 0x5e, 0xa8, 0x74, - 0xa0, 0xeb, 0x85, 0xd4, 0x05, 0x33, 0xe5, 0xee, 0x17, 0xcc, 0xd8, 0xdf, 0x18, 0xa0, 0xaf, 0x17, - 0x06, 0x33, 0x11, 0x69, 0xc4, 0xf4, 0xfb, 0xb6, 0x23, 0x4f, 0x4c, 0x12, 0xf5, 0x7d, 0xaf, 0xe3, - 0x05, 0x4c, 0xdb, 0x53, 0x47, 0x31, 0xa5, 0x03, 0x55, 0x21, 0x29, 0xef, 0x5b, 0x85, 0xe4, 0x05, - 0x18, 0x8e, 0xe3, 0x8d, 0xe5, 0xc8, 0xdd, 0x72, 0x12, 0x72, 0x95, 0xec, 0x08, 0x2b, 0x4b, 0x57, - 0x0e, 0x58, 0xb9, 0xac, 0x81, 0x38, 0x8d, 0x8b, 0xe6, 0xe0, 0xa4, 0xae, 0x05, 0x42, 0xa2, 0x84, - 0xe5, 0x05, 0xf0, 0x99, 0xa0, 0xd2, 0x84, 0x75, 0xf5, 0x10, 0x81, 0x80, 0x3b, 0x9f, 0xa1, 0xf2, - 0x2d, 0xd5, 0x48, 0x3b, 0xd2, 0x9f, 0x96, 0x6f, 0x29, 0x3a, 0xb4, 0x2f, 0x1d, 0x4f, 0xa0, 0x45, - 0x38, 0xc5, 0x27, 0xc6, 0x54, 0x18, 0x1a, 0x6f, 0x34, 0x90, 0xae, 0x94, 0x38, 0xd7, 0x89, 0x82, - 0xf3, 0x9e, 0x43, 0xcf, 0xc1, 0xa0, 0x6a, 0x9e, 0x9f, 0x15, 0xa7, 0x08, 0xca, 0x8b, 0xa1, 0xc8, - 0xcc, 0x37, 0xb0, 0x89, 0x87, 0x3e, 0x04, 0x0f, 0xeb, 0xbf, 0x3c, 0x79, 0x8c, 0x1f, 0xad, 0xcd, - 0x8a, 0x32, 0x4b, 0xea, 0x3a, 0x93, 0xb9, 0x5c, 0xb4, 0x06, 0xee, 0xf6, 0x3c, 0x5a, 0x83, 0x73, - 0x0a, 0x74, 0xd1, 0x4f, 0x58, 0x26, 0x48, 0x4c, 0xa6, 0x9d, 0x98, 0x5c, 0x8f, 0x3c, 0x71, 0x0b, - 0x80, 0xba, 0x69, 0x72, 0xce, 0x4d, 0x2e, 0xe7, 0x61, 0xe2, 0x05, 0xbc, 0x07, 0x15, 0x34, 0x09, - 0x35, 0xe2, 0x3b, 0x6b, 0x1e, 0x59, 0x9a, 0x99, 0x17, 0xf7, 0x02, 0xe8, 0xc8, 0x5e, 0x09, 0xc0, - 0x1a, 0x47, 0xc5, 0xa6, 0x0e, 0x75, 0xbd, 0xf5, 0x74, 0x19, 0x4e, 0x37, 0xeb, 0x21, 0xb5, 0x3d, - 0xdc, 0x3a, 0x99, 0xaa, 0xb3, 0x80, 0x3a, 0xfa, 0x61, 0x78, 0x09, 0x4b, 0x15, 0x78, 0x3d, 0x37, - 0xb3, 0xdc, 0x81, 0x83, 0x73, 0x9f, 0x64, 0x81, 0x97, 0x51, 0xb0, 0xbd, 0x33, 0x76, 0x2a, 0x13, - 0x78, 0x49, 0x1b, 0x31, 0x87, 0xa1, 0x2b, 0x80, 0x58, 0x14, 0xff, 0xe5, 0x24, 0x09, 0x95, 0xb1, - 0x33, 0x76, 0x9a, 0xbd, 0x92, 0x0a, 0x23, 0xbb, 0xd4, 0x81, 0x81, 0x73, 0x9e, 0xb2, 0xff, 0x83, - 0x05, 0xc3, 0x6a, 0xbd, 0xde, 0x83, 0x3c, 0x16, 0x2f, 0x9d, 0xc7, 0x32, 0x77, 0x74, 0x89, 0xc7, - 0x7a, 0xde, 0x25, 0x18, 0xfa, 0x67, 0x07, 0x01, 0xb4, 0x54, 0x54, 0x0a, 0xc9, 0xea, 0xaa, 0x90, - 0x1e, 0x58, 0x89, 0x94, 0x57, 0x9b, 0xa5, 0x72, 0x7f, 0x6b, 0xb3, 0xac, 0xc0, 0x19, 0x69, 0x2e, - 0xf0, 0xb3, 0xa2, 0xcb, 0x41, 0xac, 0x04, 0x5c, 0x75, 0xfa, 0x51, 0x41, 0xe8, 0xcc, 0x7c, 0x1e, - 0x12, 0xce, 0x7f, 0x36, 0x65, 0xa5, 0x0c, 0xec, 0x67, 0xa5, 0xe8, 0x35, 0xbd, 0xb0, 0x2e, 0xef, - 0x2d, 0xc9, 0xac, 0xe9, 0x85, 0x4b, 0x2b, 0x58, 0xe3, 0xe4, 0x0b, 0xf6, 0x5a, 0x41, 0x82, 0x1d, - 0x0e, 0x2c, 0xd8, 0xa5, 0x88, 0x19, 0xec, 0x2a, 0x62, 0xa4, 0x4f, 0x7a, 0xa8, 0xab, 0x4f, 0xfa, - 0xfd, 0x30, 0xe2, 0xfa, 0x1b, 0x24, 0x72, 0x13, 0xd2, 0x60, 0x6b, 0x81, 0x89, 0x1f, 0xe3, 0xc2, - 0x95, 0xf9, 0x14, 0x14, 0x67, 0xb0, 0xd3, 0x72, 0x71, 0xa4, 0x07, 0xb9, 0xd8, 0x45, 0x1b, 0x8d, - 0x16, 0xa3, 0x8d, 0x4e, 0x1c, 0x5d, 0x1b, 0x9d, 0x3c, 0x56, 0x6d, 0x84, 0x0a, 0xd1, 0x46, 0x3d, - 0x09, 0x7a, 0x63, 0xfb, 0x77, 0x7a, 0x9f, 0xed, 0x5f, 0x37, 0x55, 0x74, 0xe6, 0xd0, 0xaa, 0x28, - 0x5f, 0xcb, 0x3c, 0x74, 0x28, 0x2d, 0xf3, 0xd9, 0x12, 0x9c, 0xd1, 0x72, 0x98, 0xce, 0x7e, 0x77, - 0x9d, 0x4a, 0x22, 0x76, 0xf5, 0x15, 0x3f, 0xb7, 0x31, 0xd2, 0xaa, 0x74, 0x86, 0x96, 0x82, 0x60, - 0x03, 0x8b, 0x65, 0x27, 0x91, 0x88, 0x15, 0xea, 0xcd, 0x0a, 0xe9, 0x19, 0xd1, 0x8e, 0x15, 0x06, - 0x9d, 0x5f, 0xf4, 0xb7, 0xc8, 0xf8, 0xcc, 0x96, 0xa3, 0x9b, 0xd1, 0x20, 0x6c, 0xe2, 0xa1, 0x27, - 0x39, 0x13, 0x26, 0x20, 0xa8, 0xa0, 0x1e, 0x12, 0x77, 0xe1, 0x4a, 0x99, 0xa0, 0xa0, 0xb2, 0x3b, - 0x2c, 0x0d, 0xad, 0xd2, 0xd9, 0x1d, 0x16, 0x02, 0xa5, 0x30, 0xec, 0xff, 0x69, 0xc1, 0xd9, 0xdc, - 0xa1, 0xb8, 0x07, 0xca, 0x77, 0x3b, 0xad, 0x7c, 0x57, 0x8a, 0xda, 0x6e, 0x18, 0x6f, 0xd1, 0x45, - 0x11, 0xff, 0x3b, 0x0b, 0x46, 0x34, 0xfe, 0x3d, 0x78, 0x55, 0x37, 0xfd, 0xaa, 0xc5, 0xed, 0xac, - 0x6a, 0x1d, 0xef, 0xf6, 0xbb, 0x25, 0x50, 0x25, 0x22, 0xa7, 0xea, 0xb2, 0x00, 0xef, 0x3e, 0x27, - 0x89, 0x3b, 0xd0, 0xcf, 0x0e, 0x42, 0xe3, 0x62, 0x82, 0x3c, 0xd2, 0xfc, 0xd9, 0xa1, 0xaa, 0x3e, - 0x64, 0x66, 0x7f, 0x63, 0x2c, 0x18, 0xb2, 0x32, 0xd2, 0x6e, 0x4c, 0xa5, 0x79, 0x43, 0xe4, 0x11, - 0xe9, 0x32, 0xd2, 0xa2, 0x1d, 0x2b, 0x0c, 0xaa, 0x1e, 0xdc, 0x7a, 0xe0, 0xcf, 0x78, 0x4e, 0x2c, - 0xef, 0x7b, 0x54, 0xea, 0x61, 0x5e, 0x02, 0xb0, 0xc6, 0x61, 0x67, 0xa4, 0x6e, 0x1c, 0x7a, 0xce, - 0x8e, 0xb1, 0x7f, 0x36, 0x2a, 0x1b, 0x28, 0x10, 0x36, 0xf1, 0xec, 0x16, 0x8c, 0xa5, 0x5f, 0x62, - 0x96, 0xac, 0xb3, 0x00, 0xc5, 0x9e, 0x86, 0x73, 0x12, 0x6a, 0x0e, 0x7b, 0x6a, 0xa1, 0xed, 0x64, - 0xaf, 0x69, 0x9f, 0x92, 0x00, 0xac, 0x71, 0xec, 0x5f, 0xb3, 0xe0, 0x54, 0xce, 0xa0, 0x15, 0x98, - 0x30, 0x97, 0x68, 0x69, 0x93, 0xa7, 0xd8, 0x7f, 0x18, 0x06, 0x1a, 0x64, 0xdd, 0x91, 0x21, 0x70, - 0x86, 0x6c, 0x9f, 0xe5, 0xcd, 0x58, 0xc2, 0xed, 0xff, 0x6e, 0xc1, 0x68, 0xba, 0xaf, 0x31, 0x4b, - 0x25, 0xe1, 0xc3, 0xe4, 0xc6, 0xf5, 0x60, 0x8b, 0x44, 0x3b, 0xf4, 0xcd, 0xad, 0x4c, 0x2a, 0x49, - 0x07, 0x06, 0xce, 0x79, 0x8a, 0x15, 0x88, 0x6d, 0xa8, 0xd1, 0x96, 0x33, 0xf2, 0x46, 0x91, 0x33, - 0x52, 0x7f, 0x4c, 0xf3, 0xb8, 0x5c, 0xb1, 0xc4, 0x26, 0x7f, 0xfb, 0xbb, 0x7d, 0xa0, 0x32, 0x6a, - 0x59, 0xfc, 0x51, 0x41, 0xd1, 0x5b, 0x07, 0xcd, 0x20, 0x52, 0x93, 0xa1, 0x6f, 0xaf, 0x80, 0x00, - 0xee, 0x25, 0x31, 0x5d, 0x97, 0xea, 0x0d, 0x57, 0x35, 0x08, 0x9b, 0x78, 0xb4, 0x27, 0x9e, 0xbb, - 0x45, 0xf8, 0x43, 0xfd, 0xe9, 0x9e, 0x2c, 0x48, 0x00, 0xd6, 0x38, 0xb4, 0x27, 0x0d, 0x77, 0x7d, - 0x5d, 0x6c, 0xf9, 0x55, 0x4f, 0xe8, 0xe8, 0x60, 0x06, 0xe1, 0x35, 0xbf, 0x83, 0x4d, 0x61, 0x05, - 0x1b, 0x35, 0xbf, 0x83, 0x4d, 0xcc, 0x20, 0xd4, 0x6e, 0xf3, 0x83, 0xa8, 0xc5, 0xae, 0xd1, 0x6f, - 0x28, 0x2e, 0xc2, 0xfa, 0x55, 0x76, 0xdb, 0xb5, 0x4e, 0x14, 0x9c, 0xf7, 0x1c, 0x9d, 0x81, 0x61, - 0x44, 0x1a, 0x6e, 0x3d, 0x31, 0xa9, 0x41, 0x7a, 0x06, 0x2e, 0x77, 0x60, 0xe0, 0x9c, 0xa7, 0xd0, - 0x14, 0x8c, 0xca, 0x8c, 0x68, 0x59, 0xef, 0x66, 0x30, 0x5d, 0x5f, 0x03, 0xa7, 0xc1, 0x38, 0x8b, - 0x4f, 0xa5, 0x5a, 0x4b, 0x94, 0xc4, 0x62, 0xc6, 0xb2, 0x21, 0xd5, 0x64, 0xa9, 0x2c, 0xac, 0x30, - 0xec, 0x4f, 0x95, 0xa9, 0x16, 0xee, 0x52, 0x0a, 0xee, 0x9e, 0x45, 0x0b, 0xa6, 0x67, 0x64, 0x5f, - 0x0f, 0x33, 0xf2, 0x59, 0x18, 0xba, 0x15, 0x07, 0xbe, 0x8a, 0xc4, 0xab, 0x74, 0x8d, 0xc4, 0x33, - 0xb0, 0xf2, 0x23, 0xf1, 0xfa, 0x8b, 0x8a, 0xc4, 0x1b, 0x38, 0x64, 0x24, 0xde, 0xb7, 0x2b, 0xa0, - 0x2e, 0x1f, 0xb9, 0x46, 0x92, 0xdb, 0x41, 0xb4, 0xe9, 0xfa, 0x4d, 0x96, 0x49, 0xfe, 0x35, 0x0b, - 0x86, 0xf8, 0x7a, 0x59, 0x30, 0x33, 0xa9, 0xd6, 0x0b, 0xba, 0xd5, 0x22, 0xc5, 0x6c, 0x62, 0xd5, - 0x60, 0x94, 0xb9, 0x6e, 0xd4, 0x04, 0xe1, 0x54, 0x8f, 0xd0, 0xc7, 0x01, 0xa4, 0x7f, 0x74, 0x5d, - 0x8a, 0xcc, 0xf9, 0x62, 0xfa, 0x87, 0xc9, 0xba, 0xb6, 0x81, 0x57, 0x15, 0x13, 0x6c, 0x30, 0x44, - 0x9f, 0xd5, 0x59, 0x66, 0x3c, 0x64, 0xff, 0xa3, 0xc7, 0x32, 0x36, 0xbd, 0xe4, 0x98, 0x61, 0x18, - 0x70, 0xfd, 0x26, 0x9d, 0x27, 0x22, 0x62, 0xe9, 0x5d, 0x79, 0x55, 0x18, 0x16, 0x02, 0xa7, 0x31, - 0xed, 0x78, 0x8e, 0x5f, 0x27, 0xd1, 0x3c, 0x47, 0x37, 0x2f, 0xd9, 0x66, 0x0d, 0x58, 0x12, 0xea, - 0xb8, 0xb6, 0xa5, 0xd2, 0xcb, 0xb5, 0x2d, 0xe7, 0x3e, 0x00, 0x27, 0x3b, 0x3e, 0xe6, 0x81, 0x52, - 0xca, 0x0e, 0x9f, 0x8d, 0x66, 0xff, 0x5e, 0x4d, 0x2b, 0xad, 0x6b, 0x41, 0x83, 0x5f, 0x1e, 0x12, - 0xe9, 0x2f, 0x2a, 0x6c, 0xdc, 0x02, 0xa7, 0x88, 0x71, 0x51, 0xb7, 0x6a, 0xc4, 0x26, 0x4b, 0x3a, - 0x47, 0x43, 0x27, 0x22, 0xfe, 0x71, 0xcf, 0xd1, 0x65, 0xc5, 0x04, 0x1b, 0x0c, 0xd1, 0x46, 0x2a, - 0xa7, 0xe4, 0xd2, 0xd1, 0x73, 0x4a, 0x58, 0x7d, 0xaa, 0xbc, 0x7a, 0xff, 0x5f, 0xb2, 0x60, 0xc4, - 0x4f, 0xcd, 0xdc, 0x62, 0xc2, 0x48, 0xf3, 0x57, 0x05, 0xbf, 0xbb, 0x2a, 0xdd, 0x86, 0x33, 0xfc, - 0xf3, 0x54, 0x5a, 0xe5, 0x80, 0x2a, 0x4d, 0xdf, 0x42, 0xd4, 0xdf, 0xed, 0x16, 0x22, 0xe4, 0xab, - 0x6b, 0xd8, 0x06, 0x0a, 0xbf, 0x86, 0x0d, 0x72, 0xae, 0x60, 0xbb, 0x09, 0xb5, 0x7a, 0x44, 0x9c, - 0xe4, 0x90, 0x37, 0x72, 0xb1, 0x03, 0xfa, 0x19, 0x49, 0x00, 0x6b, 0x5a, 0xe8, 0x13, 0x4a, 0x9e, - 0xd5, 0x8a, 0x34, 0x3f, 0xe9, 0x52, 0xec, 0x49, 0x8a, 0xbd, 0x91, 0xc9, 0x94, 0x85, 0x22, 0x12, - 0x1a, 0x53, 0xbd, 0x78, 0x6b, 0x65, 0xc7, 0xfe, 0x9f, 0x3e, 0x38, 0x21, 0xbb, 0x2f, 0x53, 0x02, - 0xa8, 0xbd, 0xc2, 0xe7, 0x81, 0xde, 0x6c, 0x28, 0x7b, 0xe5, 0xb2, 0x04, 0x60, 0x8d, 0x43, 0xed, - 0xe3, 0x76, 0x4c, 0x96, 0x42, 0xe2, 0x2f, 0xb8, 0x6b, 0xb1, 0x38, 0x77, 0x56, 0xef, 0x7d, 0x5d, - 0x83, 0xb0, 0x89, 0x47, 0x37, 0x47, 0x7c, 0x9f, 0x12, 0x67, 0xd3, 0x89, 0xc4, 0xfe, 0x07, 0x4b, - 0x38, 0xfa, 0xc5, 0xdc, 0x5a, 0xc1, 0xc5, 0x24, 0xd2, 0x75, 0x64, 0x42, 0x1c, 0xf0, 0x52, 0xcd, - 0xbf, 0x67, 0xc1, 0x19, 0xde, 0x2a, 0x47, 0xf2, 0x7a, 0xd8, 0x70, 0x12, 0x12, 0x17, 0x53, 0xbb, - 0x3f, 0xa7, 0x7f, 0xda, 0xe9, 0x9e, 0xc7, 0x16, 0xe7, 0xf7, 0x06, 0xbd, 0x6e, 0xc1, 0xe8, 0x66, - 0xaa, 0x7a, 0x8b, 0x54, 0xe5, 0x47, 0x2d, 0x8f, 0x90, 0x22, 0xaa, 0x45, 0x5f, 0xba, 0x3d, 0xc6, - 0x59, 0xee, 0xf6, 0x5f, 0x58, 0x60, 0xaa, 0xb5, 0x7b, 0x5f, 0xf4, 0xe5, 0xe0, 0xa6, 0xb9, 0xb4, - 0xf6, 0x2b, 0x5d, 0xad, 0xfd, 0x47, 0xa1, 0xdc, 0x76, 0x1b, 0x62, 0xbf, 0xa7, 0x4f, 0xc3, 0xe7, - 0x67, 0x31, 0x6d, 0xb7, 0xff, 0x45, 0x45, 0xfb, 0x91, 0x44, 0x9e, 0xda, 0xf7, 0xc5, 0x6b, 0xaf, - 0xab, 0xb2, 0x71, 0xfc, 0xcd, 0xaf, 0x75, 0x94, 0x8d, 0xfb, 0xb1, 0x83, 0xa7, 0x21, 0xf2, 0x01, - 0xea, 0x56, 0x35, 0x6e, 0x60, 0x9f, 0x1c, 0xc4, 0x5b, 0x50, 0xa5, 0x5b, 0x62, 0xe6, 0x10, 0xae, - 0xa6, 0x3a, 0x55, 0xbd, 0x2c, 0xda, 0xef, 0xee, 0x8e, 0xbf, 0xef, 0xe0, 0xdd, 0x92, 0x4f, 0x63, - 0x45, 0x1f, 0xc5, 0x50, 0xa3, 0xbf, 0x59, 0xba, 0xa4, 0xd8, 0x6c, 0x5f, 0x57, 0x32, 0x53, 0x02, - 0x0a, 0xc9, 0xc5, 0xd4, 0x7c, 0x90, 0x0f, 0x35, 0x76, 0xff, 0x30, 0x63, 0xca, 0xf7, 0xe4, 0xcb, - 0x2a, 0x69, 0x51, 0x02, 0xee, 0xee, 0x8e, 0xbf, 0x70, 0x70, 0xa6, 0xea, 0x71, 0xac, 0x59, 0xd8, - 0x6f, 0xf4, 0xe9, 0xb9, 0x2b, 0xaa, 0x05, 0x7e, 0x5f, 0xcc, 0xdd, 0xe7, 0x33, 0x73, 0xf7, 0x7c, - 0xc7, 0xdc, 0x1d, 0xd1, 0xf7, 0xe4, 0xa6, 0x66, 0xe3, 0xbd, 0x36, 0xcc, 0xf6, 0xf7, 0xff, 0x30, - 0x8b, 0xf4, 0xd5, 0xb6, 0x1b, 0x91, 0x78, 0x39, 0x6a, 0xfb, 0xae, 0xdf, 0x64, 0xd3, 0xb1, 0x6a, - 0x5a, 0xa4, 0x29, 0x30, 0xce, 0xe2, 0xa3, 0xa7, 0xa0, 0x4a, 0xbf, 0xf9, 0x4d, 0x67, 0x8b, 0xcf, - 0x2a, 0xa3, 0x80, 0xda, 0x8a, 0x68, 0xc7, 0x0a, 0xc3, 0xfe, 0x06, 0x8b, 0x2d, 0x30, 0xf2, 0xb4, - 0xe9, 0x9c, 0xf0, 0xd8, 0x85, 0xcf, 0xbc, 0xfa, 0x9a, 0x9a, 0x13, 0xfc, 0x96, 0x67, 0x0e, 0x43, - 0xb7, 0x61, 0x60, 0x8d, 0xdf, 0x78, 0x58, 0x4c, 0x45, 0x7a, 0x71, 0x7d, 0x22, 0xbb, 0xd7, 0x46, - 0xde, 0xa5, 0x78, 0x57, 0xff, 0xc4, 0x92, 0x9b, 0xfd, 0x87, 0x15, 0x18, 0xcd, 0x5c, 0x09, 0x9c, - 0xaa, 0x7b, 0x5b, 0xda, 0xb7, 0xee, 0xed, 0x47, 0x00, 0x1a, 0x24, 0xf4, 0x82, 0x1d, 0x66, 0x1e, - 0xf7, 0x1d, 0xd8, 0x3c, 0x56, 0x3b, 0xaa, 0x59, 0x45, 0x05, 0x1b, 0x14, 0x45, 0xc9, 0x39, 0x5e, - 0x46, 0x37, 0x53, 0x72, 0xce, 0xb8, 0xb7, 0xa2, 0xff, 0xde, 0xde, 0x5b, 0xe1, 0xc2, 0x28, 0xef, - 0xa2, 0xca, 0x86, 0x3e, 0x44, 0xd2, 0x33, 0xcb, 0x27, 0x99, 0x4d, 0x93, 0xc1, 0x59, 0xba, 0xf7, - 0xf3, 0xc6, 0x6f, 0xf4, 0x6e, 0xa8, 0xc9, 0xef, 0xcc, 0xf7, 0x28, 0xa2, 0xa2, 0x84, 0x9c, 0x06, - 0xec, 0x26, 0x6e, 0xf1, 0xb3, 0xa3, 0xb0, 0x03, 0xdc, 0xaf, 0xc2, 0x0e, 0xf6, 0x17, 0x4b, 0xd4, - 0x8e, 0xe7, 0xfd, 0x52, 0x35, 0x8a, 0x9e, 0x80, 0x7e, 0xa7, 0x9d, 0x6c, 0x04, 0x1d, 0xf7, 0x37, - 0x4e, 0xb1, 0x56, 0x2c, 0xa0, 0x68, 0x01, 0xfa, 0x1a, 0xba, 0xee, 0xcc, 0x41, 0xbe, 0xa7, 0x76, - 0x51, 0x3b, 0x09, 0xc1, 0x8c, 0x0a, 0x7a, 0x04, 0xfa, 0x12, 0xa7, 0x29, 0x53, 0xe0, 0x58, 0xda, - 0xf3, 0xaa, 0xd3, 0x8c, 0x31, 0x6b, 0x35, 0xd5, 0x77, 0xdf, 0x3e, 0xea, 0xfb, 0x05, 0x18, 0x8e, - 0xdd, 0xa6, 0xef, 0x24, 0xed, 0x88, 0x18, 0xc7, 0xae, 0x3a, 0x92, 0xc6, 0x04, 0xe2, 0x34, 0xae, - 0xfd, 0x5b, 0x43, 0x70, 0x7a, 0x65, 0x66, 0x51, 0xd6, 0x61, 0x3f, 0xb6, 0x2c, 0xb6, 0x3c, 0x1e, - 0xf7, 0x2e, 0x8b, 0xad, 0x0b, 0x77, 0xcf, 0xc8, 0x62, 0xf3, 0x8c, 0x2c, 0xb6, 0x74, 0x4a, 0x51, - 0xb9, 0x88, 0x94, 0xa2, 0xbc, 0x1e, 0xf4, 0x92, 0x52, 0x74, 0x6c, 0x69, 0x6d, 0x7b, 0x76, 0xe8, - 0x40, 0x69, 0x6d, 0x2a, 0xe7, 0xaf, 0x90, 0x64, 0x8f, 0x2e, 0x9f, 0x2a, 0x37, 0xe7, 0x4f, 0xe5, - 0x5b, 0xf1, 0x44, 0x26, 0x21, 0xea, 0x5f, 0x2e, 0xbe, 0x03, 0x3d, 0xe4, 0x5b, 0x89, 0x5c, 0x2a, - 0x33, 0xc7, 0x6f, 0xa0, 0x88, 0x1c, 0xbf, 0xbc, 0xee, 0xec, 0x9b, 0xe3, 0xf7, 0x02, 0x0c, 0xd7, - 0xbd, 0xc0, 0x27, 0xcb, 0x51, 0x90, 0x04, 0xf5, 0xc0, 0x13, 0x66, 0xbd, 0x12, 0x09, 0x33, 0x26, - 0x10, 0xa7, 0x71, 0xbb, 0x25, 0x08, 0xd6, 0x8e, 0x9a, 0x20, 0x08, 0xf7, 0x29, 0x41, 0xf0, 0xe7, - 0x74, 0x2a, 0xfb, 0x20, 0xfb, 0x22, 0x1f, 0x29, 0xfe, 0x8b, 0xf4, 0x92, 0xcf, 0x8e, 0xde, 0xe4, - 0x17, 0x28, 0x52, 0xc3, 0x78, 0x26, 0x68, 0x51, 0xc3, 0x6f, 0x88, 0x0d, 0xc9, 0x2b, 0xc7, 0x30, - 0x61, 0x6f, 0xae, 0x68, 0x36, 0xea, 0x52, 0x45, 0xdd, 0x84, 0xd3, 0x1d, 0x39, 0x4a, 0xaa, 0xfd, - 0x57, 0x4a, 0xf0, 0x03, 0xfb, 0x76, 0x01, 0xdd, 0x06, 0x48, 0x9c, 0xa6, 0x98, 0xa8, 0xe2, 0x00, - 0xeb, 0x88, 0xe1, 0xae, 0xab, 0x92, 0x1e, 0xaf, 0x11, 0xa3, 0xfe, 0xb2, 0xa3, 0x21, 0xf9, 0x9b, - 0x45, 0xb9, 0x06, 0x5e, 0x47, 0x29, 0x4d, 0x1c, 0x78, 0x04, 0x33, 0x08, 0x55, 0xff, 0x11, 0x69, - 0xea, 0x1b, 0xbf, 0xd5, 0xe7, 0xc3, 0xac, 0x15, 0x0b, 0x28, 0x7a, 0x0e, 0x06, 0x1d, 0xcf, 0xe3, - 0xf9, 0x4a, 0x24, 0x16, 0x37, 0x28, 0x69, 0xaf, 0xa5, 0x06, 0x61, 0x13, 0xcf, 0xfe, 0xf3, 0x12, - 0x8c, 0xef, 0x23, 0x53, 0x3a, 0x32, 0x30, 0x2b, 0x3d, 0x67, 0x60, 0x8a, 0x9c, 0x91, 0xfe, 0x2e, - 0x39, 0x23, 0xcf, 0xc1, 0x60, 0x42, 0x9c, 0x96, 0x08, 0x90, 0x13, 0x9e, 0x00, 0x7d, 0x22, 0xaf, - 0x41, 0xd8, 0xc4, 0xa3, 0x52, 0x6c, 0xc4, 0xa9, 0xd7, 0x49, 0x1c, 0xcb, 0xa4, 0x10, 0xe1, 0xdd, - 0x2e, 0x2c, 0xe3, 0x84, 0x1d, 0x1a, 0x4c, 0xa5, 0x58, 0xe0, 0x0c, 0xcb, 0xec, 0x80, 0xd7, 0x7a, - 0x1c, 0xf0, 0xaf, 0x97, 0xe0, 0xd1, 0x3d, 0xb5, 0x5b, 0xcf, 0xf9, 0x3a, 0xed, 0x98, 0x44, 0xd9, - 0x89, 0x73, 0x3d, 0x26, 0x11, 0x66, 0x10, 0x3e, 0x4a, 0x61, 0x68, 0xdc, 0xa8, 0x5e, 0x74, 0x32, - 0x19, 0x1f, 0xa5, 0x14, 0x0b, 0x9c, 0x61, 0x79, 0xd8, 0x69, 0xf9, 0x8f, 0x4a, 0xf0, 0x78, 0x0f, - 0x36, 0x40, 0x81, 0x49, 0x77, 0xe9, 0xd4, 0xc7, 0xf2, 0x7d, 0xca, 0x50, 0x3d, 0xe4, 0x70, 0x7d, - 0xa3, 0x04, 0xe7, 0xba, 0xab, 0x62, 0xf4, 0xe3, 0x30, 0x1a, 0xa9, 0xa8, 0x38, 0x33, 0x6b, 0xf2, - 0x14, 0xf7, 0x24, 0xa4, 0x40, 0x38, 0x8b, 0x8b, 0x26, 0x00, 0x42, 0x27, 0xd9, 0x88, 0x2f, 0x6e, - 0xbb, 0x71, 0x22, 0xaa, 0x02, 0x8d, 0xf0, 0xb3, 0x44, 0xd9, 0x8a, 0x0d, 0x0c, 0xca, 0x8e, 0xfd, - 0x9b, 0x0d, 0xae, 0x05, 0x09, 0x7f, 0x88, 0x6f, 0x23, 0x4e, 0xc9, 0xdb, 0x57, 0x0c, 0x10, 0xce, - 0xe2, 0x52, 0x76, 0xec, 0x9c, 0x87, 0x77, 0x94, 0xef, 0x2f, 0x18, 0xbb, 0x05, 0xd5, 0x8a, 0x0d, - 0x8c, 0x6c, 0x3e, 0x68, 0x65, 0xff, 0x7c, 0x50, 0xfb, 0x9f, 0x97, 0xe0, 0x6c, 0x57, 0x53, 0xae, - 0xb7, 0x05, 0xf8, 0xe0, 0xe5, 0x70, 0x1e, 0x6e, 0xee, 0x1c, 0x30, 0xd7, 0xf0, 0x4f, 0xbb, 0xcc, - 0x34, 0x91, 0x6b, 0x78, 0xf8, 0x64, 0xfd, 0x07, 0x6f, 0x3c, 0x3b, 0xd2, 0x0b, 0xfb, 0x0e, 0x90, - 0x5e, 0x98, 0xf9, 0x18, 0x95, 0x1e, 0x17, 0xf2, 0x5f, 0x96, 0xbb, 0x0e, 0x2f, 0xdd, 0xfa, 0xf5, - 0xe4, 0xa7, 0x9d, 0x85, 0x13, 0xae, 0xcf, 0x6e, 0xe2, 0x5a, 0x69, 0xaf, 0x89, 0x42, 0x31, 0xa5, - 0xf4, 0x7d, 0xf9, 0xf3, 0x19, 0x38, 0xee, 0x78, 0xe2, 0x01, 0x4c, 0xf7, 0x3c, 0xdc, 0x90, 0x1e, - 0x2c, 0xe1, 0x18, 0x2d, 0xc1, 0x19, 0x39, 0x14, 0x1b, 0x4e, 0x44, 0x1a, 0x42, 0x8d, 0xc4, 0x22, - 0xc1, 0xe5, 0x2c, 0x4f, 0x92, 0xc9, 0x41, 0xc0, 0xf9, 0xcf, 0xb1, 0xcb, 0x8f, 0x82, 0xd0, 0xad, - 0x8b, 0x4d, 0x8e, 0xbe, 0xfc, 0x88, 0x36, 0x62, 0x0e, 0xb3, 0x3f, 0x02, 0x35, 0xf5, 0xfe, 0x3c, - 0xcc, 0x5e, 0x4d, 0xba, 0x8e, 0x30, 0x7b, 0x35, 0xe3, 0x0c, 0x2c, 0xfa, 0xb5, 0xa8, 0x49, 0x9c, - 0x59, 0x3d, 0x57, 0xc9, 0x0e, 0xb3, 0x8f, 0xed, 0xf7, 0xc0, 0x90, 0xf2, 0xb3, 0xf4, 0x7a, 0x25, - 0x94, 0xfd, 0x46, 0x3f, 0x0c, 0xa7, 0x8a, 0x35, 0xa6, 0x1c, 0xac, 0xd6, 0xbe, 0x0e, 0x56, 0x96, - 0x36, 0xd1, 0xf6, 0xe5, 0x7d, 0x71, 0x46, 0xda, 0x44, 0xdb, 0x27, 0x98, 0xc3, 0xa8, 0x79, 0xdb, - 0x88, 0x76, 0x70, 0xdb, 0x17, 0xe1, 0xcd, 0xca, 0xbc, 0x9d, 0x65, 0xad, 0x58, 0x40, 0xd1, 0x27, - 0x2d, 0x18, 0x8a, 0x99, 0xf7, 0x9e, 0xbb, 0xa7, 0xc5, 0xa4, 0xbb, 0x72, 0xf4, 0x5a, 0x94, 0xaa, - 0x30, 0x29, 0x8b, 0x58, 0x32, 0x5b, 0x70, 0x8a, 0x23, 0xfa, 0x8c, 0x05, 0x35, 0x75, 0xad, 0x8d, - 0xb8, 0xfc, 0x71, 0xa5, 0xd8, 0x5a, 0x98, 0xdc, 0xaf, 0xa9, 0x0e, 0x42, 0x54, 0x51, 0x42, 0xac, - 0x19, 0xa3, 0x58, 0xf9, 0x8e, 0x07, 0x8e, 0xc7, 0x77, 0x0c, 0x39, 0x7e, 0xe3, 0x77, 0x43, 0xad, - 0xe5, 0xf8, 0xee, 0x3a, 0x89, 0x13, 0xee, 0xce, 0x95, 0x25, 0x7a, 0x65, 0x23, 0xd6, 0x70, 0xaa, - 0x90, 0x63, 0xf6, 0x62, 0x89, 0xe1, 0x7f, 0x65, 0x0a, 0x79, 0x45, 0x37, 0x63, 0x13, 0xc7, 0x74, - 0x16, 0xc3, 0x7d, 0x75, 0x16, 0x0f, 0xee, 0xed, 0x2c, 0xb6, 0xff, 0x89, 0x05, 0x67, 0x72, 0xbf, - 0xda, 0x83, 0x1b, 0x88, 0x6a, 0x7f, 0xb9, 0x02, 0xa7, 0x72, 0xaa, 0xae, 0xa2, 0x1d, 0x73, 0x3e, - 0x5b, 0x45, 0xc4, 0x10, 0xa4, 0x8f, 0xc4, 0xe5, 0x30, 0xe6, 0x4c, 0xe2, 0x83, 0x1d, 0xd5, 0xe8, - 0xe3, 0x92, 0xf2, 0xbd, 0x3d, 0x2e, 0x31, 0xa6, 0x65, 0xdf, 0x7d, 0x9d, 0x96, 0x95, 0x7d, 0xce, - 0x30, 0x7e, 0xdd, 0x82, 0xb1, 0x56, 0x97, 0x52, 0xff, 0xc2, 0xf1, 0x78, 0xe3, 0x78, 0x2e, 0x12, - 0x98, 0x7e, 0xe4, 0xce, 0xee, 0x78, 0xd7, 0x1b, 0x16, 0x70, 0xd7, 0x5e, 0xd9, 0xdf, 0x2d, 0x03, - 0x2b, 0xf9, 0xcb, 0x2a, 0xeb, 0xed, 0xa0, 0x4f, 0x98, 0xc5, 0x9b, 0xad, 0xa2, 0x0a, 0x0d, 0x73, - 0xe2, 0xaa, 0xf8, 0x33, 0x1f, 0xc1, 0xbc, 0x5a, 0xd0, 0x59, 0xa1, 0x55, 0xea, 0x41, 0x68, 0x79, - 0xb2, 0x4a, 0x76, 0xb9, 0xf8, 0x2a, 0xd9, 0xb5, 0x6c, 0x85, 0xec, 0xbd, 0x3f, 0x71, 0xdf, 0x03, - 0xf9, 0x89, 0x7f, 0xc9, 0xe2, 0x82, 0x27, 0xf3, 0x15, 0xb4, 0x65, 0x60, 0xed, 0x61, 0x19, 0x3c, - 0x05, 0xd5, 0x98, 0x78, 0xeb, 0x97, 0x89, 0xe3, 0x09, 0x0b, 0x42, 0x9f, 0x5f, 0x8b, 0x76, 0xac, - 0x30, 0xd8, 0x05, 0xbc, 0x9e, 0x17, 0xdc, 0xbe, 0xd8, 0x0a, 0x93, 0x1d, 0x61, 0x4b, 0xe8, 0x0b, - 0x78, 0x15, 0x04, 0x1b, 0x58, 0xf6, 0xdf, 0x2d, 0xf1, 0x19, 0x28, 0x82, 0x20, 0x9e, 0xcf, 0x5c, - 0x99, 0xd8, 0x7b, 0xfc, 0xc0, 0xc7, 0x00, 0xea, 0x41, 0x2b, 0xa4, 0x76, 0xdf, 0x6a, 0x20, 0xce, - 0x84, 0x2e, 0x1f, 0xf9, 0xc6, 0x74, 0x41, 0x4f, 0xbf, 0x86, 0x6e, 0xc3, 0x06, 0xbf, 0x94, 0x2c, - 0x2d, 0xef, 0x2b, 0x4b, 0x53, 0x62, 0xa5, 0x6f, 0x1f, 0x6d, 0xf7, 0xe7, 0x16, 0xa4, 0x2c, 0x22, - 0x14, 0x42, 0x85, 0x76, 0x77, 0x47, 0xac, 0xd0, 0xa5, 0xe2, 0xcc, 0x2f, 0x2a, 0x1a, 0xc5, 0xb4, - 0x67, 0x3f, 0x31, 0x67, 0x84, 0x3c, 0x11, 0x2b, 0xc1, 0x47, 0xf5, 0x5a, 0x71, 0x0c, 0x2f, 0x07, - 0xc1, 0x26, 0x3f, 0xd8, 0xd4, 0x71, 0x17, 0xf6, 0xf3, 0x70, 0xb2, 0xa3, 0x53, 0xec, 0x76, 0xb4, - 0x80, 0x6a, 0x9f, 0xcc, 0x74, 0x65, 0x09, 0xb5, 0x98, 0xc3, 0xec, 0x6f, 0x58, 0x70, 0x22, 0x4b, - 0x1e, 0xbd, 0x69, 0xc1, 0xc9, 0x38, 0x4b, 0xef, 0xb8, 0xc6, 0x4e, 0xc5, 0x3b, 0x76, 0x80, 0x70, - 0x67, 0x27, 0xec, 0xff, 0x2b, 0x26, 0xff, 0x4d, 0xd7, 0x6f, 0x04, 0xb7, 0x95, 0x61, 0x62, 0x75, - 0x35, 0x4c, 0xe8, 0x7a, 0xac, 0x6f, 0x90, 0x46, 0xdb, 0xeb, 0xc8, 0xe4, 0x5d, 0x11, 0xed, 0x58, - 0x61, 0xb0, 0xc4, 0xc5, 0xb6, 0x28, 0xa3, 0x9f, 0x99, 0x94, 0xb3, 0xa2, 0x1d, 0x2b, 0x0c, 0xf4, - 0x2c, 0x0c, 0x19, 0x2f, 0x29, 0xe7, 0x25, 0x33, 0xc8, 0x0d, 0x95, 0x19, 0xe3, 0x14, 0x16, 0x9a, - 0x00, 0x50, 0x46, 0x8e, 0x54, 0x91, 0xcc, 0x51, 0xa4, 0x24, 0x51, 0x8c, 0x0d, 0x0c, 0x96, 0x26, - 0xec, 0xb5, 0x63, 0xe6, 0xe3, 0xef, 0xd7, 0xa5, 0x5d, 0x67, 0x44, 0x1b, 0x56, 0x50, 0x2a, 0x4d, - 0x5a, 0x8e, 0xdf, 0x76, 0x3c, 0x3a, 0x42, 0x62, 0xeb, 0xa7, 0x96, 0xe1, 0xa2, 0x82, 0x60, 0x03, - 0x8b, 0xbe, 0x71, 0xe2, 0xb6, 0xc8, 0x4b, 0x81, 0x2f, 0xe3, 0xd4, 0xf4, 0xb1, 0x8f, 0x68, 0xc7, - 0x0a, 0xc3, 0xfe, 0xaf, 0x16, 0x8c, 0xea, 0xa2, 0x03, 0xfc, 0x1e, 0x74, 0x73, 0xa7, 0x6a, 0xed, - 0xbb, 0x53, 0x4d, 0x67, 0x63, 0x97, 0x7a, 0xca, 0xc6, 0x36, 0x13, 0xa5, 0xcb, 0x7b, 0x26, 0x4a, - 0xff, 0x90, 0xbe, 0x63, 0x97, 0x67, 0x54, 0x0f, 0xe6, 0xdd, 0xaf, 0x8b, 0x6c, 0xe8, 0xaf, 0x3b, - 0xaa, 0xe2, 0xce, 0x10, 0xdf, 0x3b, 0xcc, 0x4c, 0x31, 0x24, 0x01, 0xb1, 0x97, 0xa0, 0xa6, 0x4e, - 0x3f, 0xe4, 0x46, 0xd5, 0xca, 0xdf, 0xa8, 0xf6, 0x94, 0xb0, 0x39, 0xbd, 0xf6, 0xad, 0xef, 0x3d, - 0xf6, 0x8e, 0x3f, 0xf8, 0xde, 0x63, 0xef, 0xf8, 0x93, 0xef, 0x3d, 0xf6, 0x8e, 0x4f, 0xde, 0x79, - 0xcc, 0xfa, 0xd6, 0x9d, 0xc7, 0xac, 0x3f, 0xb8, 0xf3, 0x98, 0xf5, 0x27, 0x77, 0x1e, 0xb3, 0xbe, - 0x7b, 0xe7, 0x31, 0xeb, 0x4b, 0xff, 0xe9, 0xb1, 0x77, 0xbc, 0x94, 0x1b, 0xa8, 0x48, 0x7f, 0x3c, - 0x5d, 0x6f, 0x4c, 0x6e, 0x5d, 0x60, 0xb1, 0x72, 0x74, 0x79, 0x4d, 0x1a, 0x73, 0x6a, 0x52, 0x2e, - 0xaf, 0xff, 0x17, 0x00, 0x00, 0xff, 0xff, 0x25, 0x92, 0xf4, 0x27, 0xdf, 0xe3, 0x00, 0x00, + // 11167 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xec, 0xbd, 0x6f, 0x70, 0x24, 0xc7, + 0x75, 0x18, 0xae, 0xd9, 0xc5, 0x02, 0xbb, 0x0f, 0xff, 0xee, 0xfa, 0xee, 0x48, 0xdc, 0x89, 0x24, + 0xce, 0x43, 0x9b, 0xa2, 0x7f, 0x22, 0x01, 0xf3, 0x44, 0xca, 0xfc, 0x89, 0xb6, 0x64, 0xfc, 0xb9, + 0xc3, 0xe1, 0x0e, 0x38, 0x80, 0x0d, 0xdc, 0x9d, 0x44, 0x99, 0xa4, 0x06, 0xbb, 0x8d, 0xc5, 0x1c, + 0x66, 0x67, 0x86, 0x33, 0xb3, 0x38, 0x80, 0x96, 0x64, 0xc9, 0x92, 0x6d, 0x25, 0xfa, 0x43, 0x85, + 0x4a, 0xca, 0x74, 0x62, 0xa9, 0x64, 0x4b, 0x49, 0xc5, 0x95, 0xa8, 0xe2, 0x24, 0x1f, 0xe2, 0xc8, + 0xa9, 0x72, 0xd9, 0x4e, 0xa5, 0x94, 0x52, 0x5c, 0x76, 0xb9, 0x5c, 0x96, 0x93, 0xd8, 0x88, 0x74, + 0xa9, 0x54, 0x52, 0xa9, 0x8a, 0xab, 0x9c, 0xf8, 0x43, 0x72, 0xc9, 0x87, 0x54, 0xff, 0xef, 0x99, + 0x9d, 0x05, 0x16, 0xc0, 0xe0, 0xee, 0xa4, 0xf0, 0xdb, 0x6e, 0xbf, 0x37, 0xef, 0xf5, 0xf4, 0x74, + 0xbf, 0xf7, 0xfa, 0xf5, 0x7b, 0xaf, 0x61, 0xa1, 0xe9, 0x26, 0x1b, 0xed, 0xb5, 0x89, 0x7a, 0xd0, + 0x9a, 0x74, 0xa2, 0x66, 0x10, 0x46, 0xc1, 0x2d, 0xf6, 0xe3, 0xe9, 0x7a, 0x63, 0x72, 0xeb, 0xc2, + 0x64, 0xb8, 0xd9, 0x9c, 0x74, 0x42, 0x37, 0x9e, 0x74, 0xc2, 0xd0, 0x73, 0xeb, 0x4e, 0xe2, 0x06, + 0xfe, 0xe4, 0xd6, 0x33, 0x8e, 0x17, 0x6e, 0x38, 0xcf, 0x4c, 0x36, 0x89, 0x4f, 0x22, 0x27, 0x21, + 0x8d, 0x89, 0x30, 0x0a, 0x92, 0x00, 0xfd, 0x84, 0xa6, 0x36, 0x21, 0xa9, 0xb1, 0x1f, 0xaf, 0xd6, + 0x1b, 0x13, 0x5b, 0x17, 0x26, 0xc2, 0xcd, 0xe6, 0x04, 0xa5, 0x36, 0x61, 0x50, 0x9b, 0x90, 0xd4, + 0xce, 0x3d, 0x6d, 0xf4, 0xa5, 0x19, 0x34, 0x83, 0x49, 0x46, 0x74, 0xad, 0xbd, 0xce, 0xfe, 0xb1, + 0x3f, 0xec, 0x17, 0x67, 0x76, 0xce, 0xde, 0x7c, 0x3e, 0x9e, 0x70, 0x03, 0xda, 0xbd, 0xc9, 0x7a, + 0x10, 0x91, 0xc9, 0xad, 0x8e, 0x0e, 0x9d, 0xbb, 0xac, 0x71, 0xc8, 0x76, 0x42, 0xfc, 0xd8, 0x0d, + 0xfc, 0xf8, 0x69, 0xda, 0x05, 0x12, 0x6d, 0x91, 0xc8, 0x7c, 0x3d, 0x03, 0x21, 0x8f, 0xd2, 0xb3, + 0x9a, 0x52, 0xcb, 0xa9, 0x6f, 0xb8, 0x3e, 0x89, 0x76, 0xf4, 0xe3, 0x2d, 0x92, 0x38, 0x79, 0x4f, + 0x4d, 0x76, 0x7b, 0x2a, 0x6a, 0xfb, 0x89, 0xdb, 0x22, 0x1d, 0x0f, 0xbc, 0x77, 0xbf, 0x07, 0xe2, + 0xfa, 0x06, 0x69, 0x39, 0x1d, 0xcf, 0xbd, 0xa7, 0xdb, 0x73, 0xed, 0xc4, 0xf5, 0x26, 0x5d, 0x3f, + 0x89, 0x93, 0x28, 0xfb, 0x90, 0xfd, 0x2b, 0x16, 0x0c, 0x4f, 0xdd, 0x5c, 0x99, 0x6a, 0x27, 0x1b, + 0x33, 0x81, 0xbf, 0xee, 0x36, 0xd1, 0x73, 0x30, 0x58, 0xf7, 0xda, 0x71, 0x42, 0xa2, 0x6b, 0x4e, + 0x8b, 0x8c, 0x59, 0xe7, 0xad, 0x27, 0x6b, 0xd3, 0xa7, 0xbe, 0xb5, 0x3b, 0xfe, 0x8e, 0x3b, 0xbb, + 0xe3, 0x83, 0x33, 0x1a, 0x84, 0x4d, 0x3c, 0xf4, 0xa3, 0x30, 0x10, 0x05, 0x1e, 0x99, 0xc2, 0xd7, + 0xc6, 0x4a, 0xec, 0x91, 0x51, 0xf1, 0xc8, 0x00, 0xe6, 0xcd, 0x58, 0xc2, 0x29, 0x6a, 0x18, 0x05, + 0xeb, 0xae, 0x47, 0xc6, 0xca, 0x69, 0xd4, 0x65, 0xde, 0x8c, 0x25, 0xdc, 0xfe, 0x93, 0x12, 0xc0, + 0x54, 0x18, 0x2e, 0x47, 0xc1, 0x2d, 0x52, 0x4f, 0xd0, 0x47, 0xa0, 0x4a, 0x87, 0xb9, 0xe1, 0x24, + 0x0e, 0xeb, 0xd8, 0xe0, 0x85, 0x1f, 0x9b, 0xe0, 0x6f, 0x3d, 0x61, 0xbe, 0xb5, 0x9e, 0x64, 0x14, + 0x7b, 0x62, 0xeb, 0x99, 0x89, 0xa5, 0x35, 0xfa, 0xfc, 0x22, 0x49, 0x9c, 0x69, 0x24, 0x98, 0x81, + 0x6e, 0xc3, 0x8a, 0x2a, 0xf2, 0xa1, 0x2f, 0x0e, 0x49, 0x9d, 0xbd, 0xc3, 0xe0, 0x85, 0x85, 0x89, + 0xa3, 0xcc, 0xe6, 0x09, 0xdd, 0xf3, 0x95, 0x90, 0xd4, 0xa7, 0x87, 0x04, 0xe7, 0x3e, 0xfa, 0x0f, + 0x33, 0x3e, 0x68, 0x0b, 0xfa, 0xe3, 0xc4, 0x49, 0xda, 0x31, 0x1b, 0x8a, 0xc1, 0x0b, 0xd7, 0x0a, + 0xe3, 0xc8, 0xa8, 0x4e, 0x8f, 0x08, 0x9e, 0xfd, 0xfc, 0x3f, 0x16, 0xdc, 0xec, 0x3f, 0xb7, 0x60, + 0x44, 0x23, 0x2f, 0xb8, 0x71, 0x82, 0x7e, 0xba, 0x63, 0x70, 0x27, 0x7a, 0x1b, 0x5c, 0xfa, 0x34, + 0x1b, 0xda, 0x13, 0x82, 0x59, 0x55, 0xb6, 0x18, 0x03, 0xdb, 0x82, 0x8a, 0x9b, 0x90, 0x56, 0x3c, + 0x56, 0x3a, 0x5f, 0x7e, 0x72, 0xf0, 0xc2, 0xe5, 0xa2, 0xde, 0x73, 0x7a, 0x58, 0x30, 0xad, 0xcc, + 0x53, 0xf2, 0x98, 0x73, 0xb1, 0x7f, 0x7d, 0xc8, 0x7c, 0x3f, 0x3a, 0xe0, 0xe8, 0x19, 0x18, 0x8c, + 0x83, 0x76, 0x54, 0x27, 0x98, 0x84, 0x41, 0x3c, 0x66, 0x9d, 0x2f, 0xd3, 0xa9, 0x47, 0x27, 0xf5, + 0x8a, 0x6e, 0xc6, 0x26, 0x0e, 0xfa, 0x82, 0x05, 0x43, 0x0d, 0x12, 0x27, 0xae, 0xcf, 0xf8, 0xcb, + 0xce, 0xaf, 0x1e, 0xb9, 0xf3, 0xb2, 0x71, 0x56, 0x13, 0x9f, 0x3e, 0x2d, 0x5e, 0x64, 0xc8, 0x68, + 0x8c, 0x71, 0x8a, 0x3f, 0x5d, 0x9c, 0x0d, 0x12, 0xd7, 0x23, 0x37, 0xa4, 0xff, 0xc5, 0xf2, 0x51, + 0x8b, 0x73, 0x56, 0x83, 0xb0, 0x89, 0x87, 0x7c, 0xa8, 0xd0, 0xc5, 0x17, 0x8f, 0xf5, 0xb1, 0xfe, + 0xcf, 0x1f, 0xad, 0xff, 0x62, 0x50, 0xe9, 0xba, 0xd6, 0xa3, 0x4f, 0xff, 0xc5, 0x98, 0xb3, 0x41, + 0x9f, 0xb7, 0x60, 0x4c, 0x08, 0x07, 0x4c, 0xf8, 0x80, 0xde, 0xdc, 0x70, 0x13, 0xe2, 0xb9, 0x71, + 0x32, 0x56, 0x61, 0x7d, 0x98, 0xec, 0x6d, 0x6e, 0xcd, 0x45, 0x41, 0x3b, 0xbc, 0xea, 0xfa, 0x8d, + 0xe9, 0xf3, 0x82, 0xd3, 0xd8, 0x4c, 0x17, 0xc2, 0xb8, 0x2b, 0x4b, 0xf4, 0x25, 0x0b, 0xce, 0xf9, + 0x4e, 0x8b, 0xc4, 0xa1, 0x43, 0x3f, 0x2d, 0x07, 0x4f, 0x7b, 0x4e, 0x7d, 0x93, 0xf5, 0xa8, 0xff, + 0x70, 0x3d, 0xb2, 0x45, 0x8f, 0xce, 0x5d, 0xeb, 0x4a, 0x1a, 0xef, 0xc1, 0x16, 0x7d, 0xcd, 0x82, + 0x93, 0x41, 0x14, 0x6e, 0x38, 0x3e, 0x69, 0x48, 0x68, 0x3c, 0x36, 0xc0, 0x96, 0xde, 0x2b, 0x47, + 0xfb, 0x44, 0x4b, 0x59, 0xb2, 0x8b, 0x81, 0xef, 0x26, 0x41, 0xb4, 0x42, 0x92, 0xc4, 0xf5, 0x9b, + 0xf1, 0xf4, 0x99, 0x3b, 0xbb, 0xe3, 0x27, 0x3b, 0xb0, 0x70, 0x67, 0x7f, 0xd0, 0xcf, 0xc0, 0x60, + 0xbc, 0xe3, 0xd7, 0x6f, 0xba, 0x7e, 0x23, 0xb8, 0x1d, 0x8f, 0x55, 0x8b, 0x58, 0xbe, 0x2b, 0x8a, + 0xa0, 0x58, 0x80, 0x9a, 0x01, 0x36, 0xb9, 0xe5, 0x7f, 0x38, 0x3d, 0x95, 0x6a, 0x45, 0x7f, 0x38, + 0x3d, 0x99, 0xf6, 0x60, 0x8b, 0x7e, 0xd1, 0x82, 0xe1, 0xd8, 0x6d, 0xfa, 0x4e, 0xd2, 0x8e, 0xc8, + 0x55, 0xb2, 0x13, 0x8f, 0x01, 0xeb, 0xc8, 0x95, 0x23, 0x8e, 0x8a, 0x41, 0x72, 0xfa, 0x8c, 0xe8, + 0xe3, 0xb0, 0xd9, 0x1a, 0xe3, 0x34, 0xdf, 0xbc, 0x85, 0xa6, 0xa7, 0xf5, 0x60, 0xb1, 0x0b, 0x4d, + 0x4f, 0xea, 0xae, 0x2c, 0xd1, 0x4f, 0xc1, 0x09, 0xde, 0xa4, 0x46, 0x36, 0x1e, 0x1b, 0x62, 0x82, + 0xf6, 0xf4, 0x9d, 0xdd, 0xf1, 0x13, 0x2b, 0x19, 0x18, 0xee, 0xc0, 0x46, 0xaf, 0xc1, 0x78, 0x48, + 0xa2, 0x96, 0x9b, 0x2c, 0xf9, 0xde, 0x8e, 0x14, 0xdf, 0xf5, 0x20, 0x24, 0x0d, 0xd1, 0x9d, 0x78, + 0x6c, 0xf8, 0xbc, 0xf5, 0x64, 0x75, 0xfa, 0x5d, 0xa2, 0x9b, 0xe3, 0xcb, 0x7b, 0xa3, 0xe3, 0xfd, + 0xe8, 0xd9, 0xff, 0xba, 0x04, 0x27, 0xb2, 0x8a, 0x13, 0xfd, 0x3d, 0x0b, 0x46, 0x6f, 0xdd, 0x4e, + 0x56, 0x83, 0x4d, 0xe2, 0xc7, 0xd3, 0x3b, 0x54, 0xbc, 0x31, 0x95, 0x31, 0x78, 0xa1, 0x5e, 0xac, + 0x8a, 0x9e, 0xb8, 0x92, 0xe6, 0x72, 0xd1, 0x4f, 0xa2, 0x9d, 0xe9, 0x87, 0xc5, 0xdb, 0x8d, 0x5e, + 0xb9, 0xb9, 0x6a, 0x42, 0x71, 0xb6, 0x53, 0xe7, 0x3e, 0x6b, 0xc1, 0xe9, 0x3c, 0x12, 0xe8, 0x04, + 0x94, 0x37, 0xc9, 0x0e, 0x37, 0xe0, 0x30, 0xfd, 0x89, 0x5e, 0x86, 0xca, 0x96, 0xe3, 0xb5, 0x89, + 0xb0, 0x6e, 0xe6, 0x8e, 0xf6, 0x22, 0xaa, 0x67, 0x98, 0x53, 0x7d, 0x5f, 0xe9, 0x79, 0xcb, 0xfe, + 0x83, 0x32, 0x0c, 0x1a, 0xfa, 0xed, 0x1e, 0x58, 0x6c, 0x41, 0xca, 0x62, 0x5b, 0x2c, 0x4c, 0x35, + 0x77, 0x35, 0xd9, 0x6e, 0x67, 0x4c, 0xb6, 0xa5, 0xe2, 0x58, 0xee, 0x69, 0xb3, 0xa1, 0x04, 0x6a, + 0x41, 0x48, 0xad, 0x77, 0xaa, 0xfa, 0xfb, 0x8a, 0xf8, 0x84, 0x4b, 0x92, 0xdc, 0xf4, 0xf0, 0x9d, + 0xdd, 0xf1, 0x9a, 0xfa, 0x8b, 0x35, 0x23, 0xfb, 0x3b, 0x16, 0x9c, 0x36, 0xfa, 0x38, 0x13, 0xf8, + 0x0d, 0x97, 0x7d, 0xda, 0xf3, 0xd0, 0x97, 0xec, 0x84, 0x72, 0x87, 0xa0, 0x46, 0x6a, 0x75, 0x27, + 0x24, 0x98, 0x41, 0xa8, 0xa1, 0xdf, 0x22, 0x71, 0xec, 0x34, 0x49, 0x76, 0x4f, 0xb0, 0xc8, 0x9b, + 0xb1, 0x84, 0xa3, 0x08, 0x90, 0xe7, 0xc4, 0xc9, 0x6a, 0xe4, 0xf8, 0x31, 0x23, 0xbf, 0xea, 0xb6, + 0x88, 0x18, 0xe0, 0xff, 0xaf, 0xb7, 0x19, 0x43, 0x9f, 0x98, 0x7e, 0xe8, 0xce, 0xee, 0x38, 0x5a, + 0xe8, 0xa0, 0x84, 0x73, 0xa8, 0xdb, 0x5f, 0xb2, 0xe0, 0xa1, 0x7c, 0x5b, 0x0c, 0x3d, 0x01, 0xfd, + 0x7c, 0x7b, 0x28, 0xde, 0x4e, 0x7f, 0x12, 0xd6, 0x8a, 0x05, 0x14, 0x4d, 0x42, 0x4d, 0xe9, 0x09, + 0xf1, 0x8e, 0x27, 0x05, 0x6a, 0x4d, 0x2b, 0x17, 0x8d, 0x43, 0x07, 0x8d, 0xfe, 0x11, 0x96, 0x9b, + 0x1a, 0x34, 0xb6, 0x9f, 0x62, 0x10, 0xfb, 0x3f, 0x58, 0x30, 0x6a, 0xf4, 0xea, 0x1e, 0x98, 0xe6, + 0x7e, 0xda, 0x34, 0x9f, 0x2f, 0x6c, 0x3e, 0x77, 0xb1, 0xcd, 0x3f, 0x6f, 0xc1, 0x39, 0x03, 0x6b, + 0xd1, 0x49, 0xea, 0x1b, 0x17, 0xb7, 0xc3, 0x88, 0xc4, 0x74, 0xeb, 0x8d, 0x1e, 0x35, 0xe4, 0xd6, + 0xf4, 0xa0, 0xa0, 0x50, 0xbe, 0x4a, 0x76, 0xb8, 0x10, 0x7b, 0x0a, 0xaa, 0x7c, 0x72, 0x06, 0x91, + 0x18, 0x71, 0xf5, 0x6e, 0x4b, 0xa2, 0x1d, 0x2b, 0x0c, 0x64, 0x43, 0x3f, 0x13, 0x4e, 0x74, 0xb1, + 0x52, 0x35, 0x04, 0xf4, 0x23, 0xde, 0x60, 0x2d, 0x58, 0x40, 0xec, 0x38, 0xd5, 0x9d, 0xe5, 0x88, + 0xb0, 0x8f, 0xdb, 0xb8, 0xe4, 0x12, 0xaf, 0x11, 0xd3, 0x6d, 0x83, 0xe3, 0xfb, 0x41, 0x22, 0x76, + 0x00, 0xc6, 0xb6, 0x61, 0x4a, 0x37, 0x63, 0x13, 0x87, 0x32, 0xf5, 0x9c, 0x35, 0xe2, 0xf1, 0x11, + 0x15, 0x4c, 0x17, 0x58, 0x0b, 0x16, 0x10, 0xfb, 0x4e, 0x89, 0x6d, 0x50, 0xd4, 0xd2, 0x27, 0xf7, + 0x62, 0x77, 0x1b, 0xa5, 0x64, 0xe5, 0x72, 0x71, 0x82, 0x8b, 0x74, 0xdf, 0xe1, 0xbe, 0x9e, 0x11, + 0x97, 0xb8, 0x50, 0xae, 0x7b, 0xef, 0x72, 0x7f, 0xa7, 0x04, 0xe3, 0xe9, 0x07, 0x3a, 0xa4, 0x2d, + 0xdd, 0x52, 0x19, 0x8c, 0xb2, 0xfe, 0x0e, 0x03, 0x1f, 0x9b, 0x78, 0x5d, 0x04, 0x56, 0xe9, 0x38, + 0x05, 0x96, 0x29, 0x4f, 0xcb, 0xfb, 0xc8, 0xd3, 0x27, 0xd4, 0xa8, 0xf7, 0x65, 0x04, 0x58, 0x5a, + 0xa7, 0x9c, 0x87, 0xbe, 0x38, 0x21, 0xe1, 0x58, 0x25, 0x2d, 0x8f, 0x56, 0x12, 0x12, 0x62, 0x06, + 0xb1, 0xff, 0x6b, 0x09, 0x1e, 0x4e, 0x8f, 0xa1, 0x56, 0x01, 0x1f, 0x48, 0xa9, 0x80, 0x77, 0x9b, + 0x2a, 0xe0, 0xee, 0xee, 0xf8, 0x3b, 0xbb, 0x3c, 0xf6, 0x7d, 0xa3, 0x21, 0xd0, 0x5c, 0x66, 0x14, + 0x27, 0xd3, 0xa3, 0x78, 0x77, 0x77, 0xfc, 0xd1, 0x2e, 0xef, 0x98, 0x19, 0xe6, 0x27, 0xa0, 0x3f, + 0x22, 0x4e, 0x1c, 0xf8, 0x62, 0xa0, 0xd5, 0xe7, 0xc0, 0xac, 0x15, 0x0b, 0xa8, 0xfd, 0x47, 0xb5, + 0xec, 0x60, 0xcf, 0x71, 0x87, 0x5d, 0x10, 0x21, 0x17, 0xfa, 0x98, 0x59, 0xcf, 0x45, 0xc3, 0xd5, + 0xa3, 0x2d, 0x23, 0xaa, 0x06, 0x14, 0xe9, 0xe9, 0x2a, 0xfd, 0x6a, 0xb4, 0x09, 0x33, 0x16, 0x68, + 0x1b, 0xaa, 0x75, 0x69, 0x6d, 0x97, 0x8a, 0xf0, 0x4b, 0x09, 0x5b, 0x5b, 0x73, 0x1c, 0xa2, 0xf2, + 0x5a, 0x99, 0xe8, 0x8a, 0x1b, 0x22, 0x50, 0x6e, 0xba, 0x89, 0xf8, 0xac, 0x47, 0xdc, 0x4f, 0xcd, + 0xb9, 0xc6, 0x2b, 0x0e, 0x50, 0x25, 0x32, 0xe7, 0x26, 0x98, 0xd2, 0x47, 0x3f, 0x6f, 0xc1, 0x60, + 0x5c, 0x6f, 0x2d, 0x47, 0xc1, 0x96, 0xdb, 0x20, 0x91, 0xb0, 0xa6, 0x8e, 0x28, 0x9a, 0x56, 0x66, + 0x16, 0x25, 0x41, 0xcd, 0x97, 0xef, 0x6f, 0x35, 0x04, 0x9b, 0x7c, 0xe9, 0x2e, 0xe3, 0x61, 0xf1, + 0xee, 0xb3, 0xa4, 0xee, 0x52, 0xfd, 0x27, 0x37, 0x55, 0x6c, 0xa6, 0x1c, 0xd9, 0xba, 0x9c, 0x6d, + 0xd7, 0x37, 0xe9, 0x7a, 0xd3, 0x1d, 0x7a, 0xe7, 0x9d, 0xdd, 0xf1, 0x87, 0x67, 0xf2, 0x79, 0xe2, + 0x6e, 0x9d, 0x61, 0x03, 0x16, 0xb6, 0x3d, 0x0f, 0x93, 0xd7, 0xda, 0x84, 0xb9, 0x4c, 0x0a, 0x18, + 0xb0, 0x65, 0x4d, 0x30, 0x33, 0x60, 0x06, 0x04, 0x9b, 0x7c, 0xd1, 0x6b, 0xd0, 0xdf, 0x72, 0x92, + 0xc8, 0xdd, 0x16, 0x7e, 0x92, 0x23, 0xda, 0xfb, 0x8b, 0x8c, 0x96, 0x66, 0xce, 0x34, 0x35, 0x6f, + 0xc4, 0x82, 0x11, 0x6a, 0x41, 0xa5, 0x45, 0xa2, 0x26, 0x19, 0xab, 0x16, 0xe1, 0x13, 0x5e, 0xa4, + 0xa4, 0x34, 0xc3, 0x1a, 0xb5, 0x8e, 0x58, 0x1b, 0xe6, 0x5c, 0xd0, 0xcb, 0x50, 0x8d, 0x89, 0x47, + 0xea, 0xd4, 0xbe, 0xa9, 0x31, 0x8e, 0xef, 0xe9, 0xd1, 0xd6, 0xa3, 0x86, 0xc5, 0x8a, 0x78, 0x94, + 0x2f, 0x30, 0xf9, 0x0f, 0x2b, 0x92, 0x74, 0x00, 0x43, 0xaf, 0xdd, 0x74, 0xfd, 0x31, 0x28, 0x62, + 0x00, 0x97, 0x19, 0xad, 0xcc, 0x00, 0xf2, 0x46, 0x2c, 0x18, 0xd9, 0xff, 0xc9, 0x02, 0x94, 0x16, + 0x6a, 0xf7, 0xc0, 0xa8, 0x7d, 0x2d, 0x6d, 0xd4, 0x2e, 0x14, 0x69, 0x75, 0x74, 0xb1, 0x6b, 0x7f, + 0xab, 0x06, 0x19, 0x75, 0x70, 0x8d, 0xc4, 0x09, 0x69, 0xbc, 0x2d, 0xc2, 0xdf, 0x16, 0xe1, 0x6f, + 0x8b, 0x70, 0x25, 0xc2, 0xd7, 0x32, 0x22, 0xfc, 0xfd, 0xc6, 0xaa, 0xd7, 0x07, 0xb0, 0xaf, 0xaa, + 0x13, 0x5a, 0xb3, 0x07, 0x06, 0x02, 0x95, 0x04, 0x57, 0x56, 0x96, 0xae, 0xe5, 0xca, 0xec, 0x57, + 0xd3, 0x32, 0xfb, 0xa8, 0x2c, 0xfe, 0x5f, 0x90, 0xd2, 0xff, 0xca, 0x82, 0x77, 0xa5, 0xa5, 0x97, + 0x9c, 0x39, 0xf3, 0x4d, 0x3f, 0x88, 0xc8, 0xac, 0xbb, 0xbe, 0x4e, 0x22, 0xe2, 0xd7, 0x49, 0xac, + 0xbc, 0x18, 0x56, 0x37, 0x2f, 0x06, 0x7a, 0x16, 0x86, 0x6e, 0xc5, 0x81, 0xbf, 0x1c, 0xb8, 0xbe, + 0x10, 0x41, 0x74, 0x23, 0x7c, 0xe2, 0xce, 0xee, 0xf8, 0x10, 0x1d, 0x51, 0xd9, 0x8e, 0x53, 0x58, + 0x68, 0x06, 0x4e, 0xde, 0x7a, 0x6d, 0xd9, 0x49, 0x0c, 0x77, 0x80, 0xdc, 0xb8, 0xb3, 0x03, 0x8b, + 0x2b, 0x2f, 0x66, 0x80, 0xb8, 0x13, 0xdf, 0xfe, 0x3b, 0x25, 0x38, 0x9b, 0x79, 0x91, 0xc0, 0xf3, + 0x82, 0x76, 0x42, 0x37, 0x35, 0xe8, 0x2b, 0x16, 0x9c, 0x68, 0xa5, 0x3d, 0x0e, 0xb1, 0x70, 0xec, + 0x7e, 0xb0, 0x30, 0x1d, 0x91, 0x71, 0x69, 0x4c, 0x8f, 0x89, 0x11, 0x3a, 0x91, 0x01, 0xc4, 0xb8, + 0xa3, 0x2f, 0xe8, 0x65, 0xa8, 0xb5, 0x9c, 0xed, 0xeb, 0x61, 0xc3, 0x49, 0xe4, 0x7e, 0xb2, 0xbb, + 0x1b, 0xa0, 0x9d, 0xb8, 0xde, 0x04, 0x3f, 0xda, 0x9f, 0x98, 0xf7, 0x93, 0xa5, 0x68, 0x25, 0x89, + 0x5c, 0xbf, 0xc9, 0xdd, 0x79, 0x8b, 0x92, 0x0c, 0xd6, 0x14, 0xed, 0x2f, 0x5b, 0x59, 0x25, 0xa5, + 0x46, 0x27, 0x72, 0x12, 0xd2, 0xdc, 0x41, 0x1f, 0x85, 0x0a, 0xdd, 0xf8, 0xc9, 0x51, 0xb9, 0x59, + 0xa4, 0xe6, 0x34, 0xbe, 0x84, 0x56, 0xa2, 0xf4, 0x5f, 0x8c, 0x39, 0x53, 0xfb, 0x2b, 0xb5, 0xac, + 0xb1, 0xc0, 0x0e, 0x6f, 0x2f, 0x00, 0x34, 0x83, 0x55, 0xd2, 0x0a, 0x3d, 0x3a, 0x2c, 0x16, 0x3b, + 0x01, 0x50, 0xbe, 0x8e, 0x39, 0x05, 0xc1, 0x06, 0x16, 0xfa, 0x6b, 0x16, 0x40, 0x53, 0xce, 0x79, + 0x69, 0x08, 0x5c, 0x2f, 0xf2, 0x75, 0xf4, 0x8a, 0xd2, 0x7d, 0x51, 0x0c, 0xb1, 0xc1, 0x1c, 0xfd, + 0x9c, 0x05, 0xd5, 0x44, 0x76, 0x9f, 0xab, 0xc6, 0xd5, 0x22, 0x7b, 0x22, 0x5f, 0x5a, 0xdb, 0x44, + 0x6a, 0x48, 0x14, 0x5f, 0xf4, 0x0b, 0x16, 0x40, 0xbc, 0xe3, 0xd7, 0x97, 0x03, 0xcf, 0xad, 0xef, + 0x08, 0x8d, 0x79, 0xa3, 0x50, 0x7f, 0x8c, 0xa2, 0x3e, 0x3d, 0x42, 0x47, 0x43, 0xff, 0xc7, 0x06, + 0x67, 0xf4, 0x71, 0xa8, 0xc6, 0x62, 0xba, 0x09, 0x1d, 0xb9, 0x5a, 0xac, 0x57, 0x88, 0xd3, 0x16, + 0xe2, 0x55, 0xfc, 0xc3, 0x8a, 0x27, 0xfa, 0x25, 0x0b, 0x46, 0xc3, 0xb4, 0x9f, 0x4f, 0xa8, 0xc3, + 0xe2, 0x64, 0x40, 0xc6, 0x8f, 0x38, 0x7d, 0xea, 0xce, 0xee, 0xf8, 0x68, 0xa6, 0x11, 0x67, 0x7b, + 0x41, 0x25, 0xa0, 0x9e, 0xc1, 0x4b, 0x21, 0xf7, 0x39, 0x0e, 0x68, 0x09, 0x38, 0x97, 0x05, 0xe2, + 0x4e, 0x7c, 0xb4, 0x0c, 0xa7, 0x69, 0xef, 0x76, 0xb8, 0xf9, 0x29, 0xd5, 0x4b, 0xcc, 0x94, 0x61, + 0x75, 0xfa, 0x11, 0x31, 0x43, 0x98, 0x57, 0x3f, 0x8b, 0x83, 0x73, 0x9f, 0x44, 0x7f, 0x60, 0xc1, + 0x23, 0x2e, 0x53, 0x03, 0xa6, 0xc3, 0x5c, 0x6b, 0x04, 0x71, 0x12, 0x4b, 0x0a, 0x95, 0x15, 0xdd, + 0xd4, 0xcf, 0xf4, 0x0f, 0x8b, 0x37, 0x78, 0x64, 0x7e, 0x8f, 0x2e, 0xe1, 0x3d, 0x3b, 0x8c, 0x7e, + 0x1c, 0x86, 0xe5, 0xba, 0x58, 0xa6, 0x22, 0x98, 0x29, 0xda, 0xda, 0xf4, 0xc9, 0x3b, 0xbb, 0xe3, + 0xc3, 0xab, 0x26, 0x00, 0xa7, 0xf1, 0xec, 0x6f, 0x97, 0x52, 0xe7, 0x21, 0xca, 0x09, 0xc9, 0xc4, + 0x4d, 0x5d, 0xfa, 0x7f, 0xa4, 0xf4, 0x2c, 0x54, 0xdc, 0x28, 0xef, 0x92, 0x16, 0x37, 0xaa, 0x29, + 0xc6, 0x06, 0x73, 0x6a, 0x94, 0x9e, 0x74, 0xb2, 0xae, 0x4e, 0x21, 0x01, 0x5f, 0x2e, 0xb2, 0x4b, + 0x9d, 0xa7, 0x57, 0x67, 0x45, 0xd7, 0x4e, 0x76, 0x80, 0x70, 0x67, 0x97, 0xec, 0x6f, 0xa7, 0xcf, + 0x60, 0x8c, 0xc5, 0xdb, 0xc3, 0xf9, 0xd2, 0x17, 0x2c, 0x18, 0x8c, 0x02, 0xcf, 0x73, 0xfd, 0x26, + 0x15, 0x34, 0x42, 0x5b, 0x7e, 0xf8, 0x58, 0x14, 0x96, 0x90, 0x28, 0xcc, 0xb4, 0xc5, 0x9a, 0x27, + 0x36, 0x3b, 0x60, 0xff, 0xb9, 0x05, 0x63, 0xdd, 0x04, 0x22, 0x22, 0xf0, 0x4e, 0xb9, 0xda, 0x55, + 0x74, 0xc5, 0x92, 0x3f, 0x4b, 0x3c, 0xa2, 0x1c, 0xcf, 0xd5, 0xe9, 0xc7, 0xc5, 0x6b, 0xbe, 0x73, + 0xb9, 0x3b, 0x2a, 0xde, 0x8b, 0x0e, 0x7a, 0x09, 0x4e, 0x18, 0xef, 0x15, 0xab, 0x81, 0xa9, 0x4d, + 0x4f, 0x50, 0x0b, 0x64, 0x2a, 0x03, 0xbb, 0xbb, 0x3b, 0xfe, 0x50, 0xb6, 0x4d, 0x48, 0xec, 0x0e, + 0x3a, 0xf6, 0xd7, 0x4b, 0xd9, 0xaf, 0xa5, 0x94, 0xed, 0x5b, 0x56, 0xc7, 0x76, 0xfe, 0x83, 0xc7, + 0xa1, 0xe0, 0xd8, 0xc6, 0x5f, 0x05, 0x70, 0x74, 0xc7, 0xb9, 0x8f, 0x27, 0xc4, 0xf6, 0xbf, 0xe9, + 0x83, 0x3d, 0x7a, 0xd6, 0x83, 0xf5, 0x7c, 0xe0, 0x63, 0xc5, 0xcf, 0x59, 0xea, 0xc8, 0xa9, 0xcc, + 0x16, 0x79, 0xe3, 0xb8, 0xc6, 0x9e, 0x6f, 0x60, 0x62, 0x1e, 0xa5, 0xa0, 0xdc, 0xd8, 0xe9, 0xc3, + 0x2d, 0xf4, 0x55, 0x2b, 0x7d, 0x68, 0xc6, 0xc3, 0xce, 0xdc, 0x63, 0xeb, 0x93, 0x71, 0x12, 0xc7, + 0x3b, 0xa6, 0xcf, 0x6f, 0xba, 0x9d, 0xd1, 0x4d, 0x00, 0xac, 0xbb, 0xbe, 0xe3, 0xb9, 0xaf, 0xd3, + 0xed, 0x49, 0x85, 0x69, 0x58, 0x66, 0xb2, 0x5c, 0x52, 0xad, 0xd8, 0xc0, 0x38, 0xf7, 0xff, 0xc3, + 0xa0, 0xf1, 0xe6, 0x39, 0xc1, 0x15, 0xa7, 0xcd, 0xe0, 0x8a, 0x9a, 0x11, 0x13, 0x71, 0xee, 0xfd, + 0x70, 0x22, 0xdb, 0xc1, 0x83, 0x3c, 0x6f, 0xff, 0xcf, 0x81, 0xec, 0x29, 0xd6, 0x2a, 0x89, 0x5a, + 0xb4, 0x6b, 0x6f, 0x7b, 0x96, 0xde, 0xf6, 0x2c, 0xbd, 0xed, 0x59, 0x32, 0x0f, 0x07, 0x84, 0xd7, + 0x64, 0xe0, 0x1e, 0x79, 0x4d, 0x52, 0x7e, 0xa0, 0x6a, 0xe1, 0x7e, 0x20, 0xfb, 0x4e, 0x05, 0x52, + 0x76, 0x14, 0x1f, 0xef, 0x1f, 0x85, 0x81, 0x88, 0x84, 0xc1, 0x75, 0xbc, 0x20, 0x74, 0x88, 0x8e, + 0xb5, 0xe7, 0xcd, 0x58, 0xc2, 0xa9, 0xae, 0x09, 0x9d, 0x64, 0x43, 0x28, 0x11, 0xa5, 0x6b, 0x96, + 0x9d, 0x64, 0x03, 0x33, 0x08, 0x7a, 0x3f, 0x8c, 0x24, 0x4e, 0xd4, 0xa4, 0xf6, 0xf6, 0x16, 0xfb, + 0xac, 0xe2, 0xac, 0xf3, 0x21, 0x81, 0x3b, 0xb2, 0x9a, 0x82, 0xe2, 0x0c, 0x36, 0x7a, 0x0d, 0xfa, + 0x36, 0x88, 0xd7, 0x12, 0x43, 0xbe, 0x52, 0x9c, 0x8c, 0x67, 0xef, 0x7a, 0x99, 0x78, 0x2d, 0x2e, + 0x81, 0xe8, 0x2f, 0xcc, 0x58, 0xd1, 0xf9, 0x56, 0xdb, 0x6c, 0xc7, 0x49, 0xd0, 0x72, 0x5f, 0x97, + 0x2e, 0xbe, 0x0f, 0x16, 0xcc, 0xf8, 0xaa, 0xa4, 0xcf, 0x7d, 0x29, 0xea, 0x2f, 0xd6, 0x9c, 0x59, + 0x3f, 0x1a, 0x6e, 0xc4, 0x3e, 0xd5, 0x8e, 0xf0, 0xd4, 0x15, 0xdd, 0x8f, 0x59, 0x49, 0x9f, 0xf7, + 0x43, 0xfd, 0xc5, 0x9a, 0x33, 0xda, 0x51, 0xf3, 0x7e, 0x90, 0xf5, 0xe1, 0x7a, 0xc1, 0x7d, 0xe0, + 0x73, 0x3e, 0x77, 0xfe, 0x3f, 0x0e, 0x95, 0xfa, 0x86, 0x13, 0x25, 0x63, 0x43, 0x6c, 0xd2, 0x28, + 0x9f, 0xce, 0x0c, 0x6d, 0xc4, 0x1c, 0x86, 0x1e, 0x85, 0x72, 0x44, 0xd6, 0x59, 0xdc, 0xa6, 0x11, + 0xd1, 0x83, 0xc9, 0x3a, 0xa6, 0xed, 0xf6, 0xaf, 0x96, 0xd2, 0xe6, 0x52, 0xfa, 0xbd, 0xf9, 0x6c, + 0xaf, 0xb7, 0xa3, 0x58, 0xfa, 0x7d, 0x8c, 0xd9, 0xce, 0x9a, 0xb1, 0x84, 0xa3, 0x4f, 0x5a, 0x30, + 0x70, 0x2b, 0x0e, 0x7c, 0x9f, 0x24, 0x42, 0x35, 0xdd, 0x28, 0x78, 0x28, 0xae, 0x70, 0xea, 0xba, + 0x0f, 0xa2, 0x01, 0x4b, 0xbe, 0xb4, 0xbb, 0x64, 0xbb, 0xee, 0xb5, 0x1b, 0x1d, 0x41, 0x1a, 0x17, + 0x79, 0x33, 0x96, 0x70, 0x8a, 0xea, 0xfa, 0x1c, 0xb5, 0x2f, 0x8d, 0x3a, 0xef, 0x0b, 0x54, 0x01, + 0xb7, 0xff, 0x56, 0x3f, 0x9c, 0xc9, 0x5d, 0x1c, 0xd4, 0x90, 0x61, 0xa6, 0xc2, 0x25, 0xd7, 0x23, + 0x32, 0x3c, 0x89, 0x19, 0x32, 0x37, 0x54, 0x2b, 0x36, 0x30, 0xd0, 0xcf, 0x02, 0x84, 0x4e, 0xe4, + 0xb4, 0x88, 0xf2, 0xcb, 0x1e, 0xd9, 0x5e, 0xa0, 0xfd, 0x58, 0x96, 0x34, 0xf5, 0xde, 0x54, 0x35, + 0xc5, 0xd8, 0x60, 0x89, 0x9e, 0x83, 0xc1, 0x88, 0x78, 0xc4, 0x89, 0x59, 0xd8, 0x6f, 0x36, 0x87, + 0x01, 0x6b, 0x10, 0x36, 0xf1, 0xd0, 0x13, 0x2a, 0x92, 0x2b, 0x13, 0xd1, 0x92, 0x8e, 0xe6, 0x42, + 0x6f, 0x58, 0x30, 0xb2, 0xee, 0x7a, 0x44, 0x73, 0x17, 0x19, 0x07, 0x4b, 0x47, 0x7f, 0xc9, 0x4b, + 0x26, 0x5d, 0x2d, 0x21, 0x53, 0xcd, 0x31, 0xce, 0xb0, 0xa7, 0x9f, 0x79, 0x8b, 0x44, 0x4c, 0xb4, + 0xf6, 0xa7, 0x3f, 0xf3, 0x0d, 0xde, 0x8c, 0x25, 0x1c, 0x4d, 0xc1, 0x68, 0xe8, 0xc4, 0xf1, 0x4c, + 0x44, 0x1a, 0xc4, 0x4f, 0x5c, 0xc7, 0xe3, 0xf9, 0x00, 0x55, 0x1d, 0x0f, 0xbc, 0x9c, 0x06, 0xe3, + 0x2c, 0x3e, 0xfa, 0x10, 0x3c, 0xcc, 0x1d, 0x1f, 0x8b, 0x6e, 0x1c, 0xbb, 0x7e, 0x53, 0x4f, 0x03, + 0xe1, 0xff, 0x19, 0x17, 0xa4, 0x1e, 0x9e, 0xcf, 0x47, 0xc3, 0xdd, 0x9e, 0x47, 0x4f, 0x41, 0x35, + 0xde, 0x74, 0xc3, 0x99, 0xa8, 0x11, 0xb3, 0x43, 0x8f, 0xaa, 0xf6, 0x36, 0xae, 0x88, 0x76, 0xac, + 0x30, 0x50, 0x1d, 0x86, 0xf8, 0x27, 0xe1, 0xa1, 0x68, 0x42, 0x3e, 0x3e, 0xdd, 0x55, 0x3d, 0x8a, + 0xf4, 0xb6, 0x09, 0xec, 0xdc, 0xbe, 0x28, 0x8f, 0x60, 0xf8, 0x89, 0xc1, 0x0d, 0x83, 0x0c, 0x4e, + 0x11, 0xb5, 0x7f, 0xb9, 0x94, 0xde, 0x71, 0x9b, 0x8b, 0x14, 0xc5, 0x74, 0x29, 0x26, 0x37, 0x9c, + 0x48, 0x7a, 0x63, 0x8e, 0x98, 0xb6, 0x20, 0xe8, 0xde, 0x70, 0x22, 0x73, 0x51, 0x33, 0x06, 0x58, + 0x72, 0x42, 0xb7, 0xa0, 0x2f, 0xf1, 0x9c, 0x82, 0xf2, 0x9c, 0x0c, 0x8e, 0xda, 0x01, 0xb2, 0x30, + 0x15, 0x63, 0xc6, 0x03, 0x3d, 0x42, 0xad, 0xfe, 0x35, 0x79, 0x44, 0x22, 0x0c, 0xf5, 0xb5, 0x18, + 0xb3, 0x56, 0xfb, 0x9b, 0x83, 0x39, 0x72, 0x55, 0x29, 0x32, 0x74, 0x01, 0x80, 0x6e, 0x20, 0x97, + 0x23, 0xb2, 0xee, 0x6e, 0x0b, 0x43, 0x42, 0xad, 0xdd, 0x6b, 0x0a, 0x82, 0x0d, 0x2c, 0xf9, 0xcc, + 0x4a, 0x7b, 0x9d, 0x3e, 0x53, 0xea, 0x7c, 0x86, 0x43, 0xb0, 0x81, 0x85, 0x9e, 0x85, 0x7e, 0xb7, + 0xe5, 0x34, 0x55, 0x08, 0xe6, 0x23, 0x74, 0xd1, 0xce, 0xb3, 0x96, 0xbb, 0xbb, 0xe3, 0x23, 0xaa, + 0x43, 0xac, 0x09, 0x0b, 0x5c, 0xf4, 0x75, 0x0b, 0x86, 0xea, 0x41, 0xab, 0x15, 0xf8, 0x7c, 0xdb, + 0x25, 0xf6, 0x90, 0xb7, 0x8e, 0x4b, 0xcd, 0x4f, 0xcc, 0x18, 0xcc, 0xf8, 0x26, 0x52, 0x25, 0x64, + 0x99, 0x20, 0x9c, 0xea, 0x95, 0xb9, 0xb6, 0x2b, 0xfb, 0xac, 0xed, 0xdf, 0xb4, 0xe0, 0x24, 0x7f, + 0xd6, 0xd8, 0x0d, 0x8a, 0xdc, 0xa3, 0xe0, 0x98, 0x5f, 0xab, 0x63, 0x83, 0xac, 0xbc, 0x74, 0x1d, + 0x70, 0xdc, 0xd9, 0x49, 0x34, 0x07, 0x27, 0xd7, 0x83, 0xa8, 0x4e, 0xcc, 0x81, 0x10, 0x82, 0x49, + 0x11, 0xba, 0x94, 0x45, 0xc0, 0x9d, 0xcf, 0xa0, 0x1b, 0xf0, 0x90, 0xd1, 0x68, 0x8e, 0x03, 0x97, + 0x4d, 0x8f, 0x09, 0x6a, 0x0f, 0x5d, 0xca, 0xc5, 0xc2, 0x5d, 0x9e, 0xa6, 0x46, 0x2c, 0x83, 0x28, + 0xe7, 0x88, 0x90, 0x4f, 0x5a, 0x44, 0xa7, 0xa0, 0x38, 0x83, 0x9d, 0x76, 0xb8, 0x40, 0x0f, 0x0e, + 0x97, 0x57, 0xe1, 0x6c, 0xbd, 0x73, 0x64, 0xb7, 0xe2, 0xf6, 0x1a, 0x4b, 0xbc, 0xa1, 0xbc, 0x7f, + 0x48, 0x10, 0x38, 0x3b, 0xd3, 0x0d, 0x11, 0x77, 0xa7, 0x81, 0x3e, 0x0a, 0xd5, 0x88, 0xb0, 0xaf, + 0xca, 0x33, 0x68, 0x8e, 0xbc, 0xcb, 0xd6, 0x16, 0x2c, 0x27, 0xab, 0x65, 0xb7, 0x68, 0x88, 0xb1, + 0xe2, 0x88, 0x6e, 0xc3, 0x40, 0xe8, 0x24, 0xf5, 0x0d, 0x12, 0x8f, 0x0d, 0x17, 0x11, 0x3f, 0xa3, + 0x98, 0x33, 0x1f, 0xba, 0x91, 0xf0, 0xcb, 0x99, 0x60, 0xc9, 0x8d, 0x5a, 0x33, 0xf5, 0xa0, 0x15, + 0x06, 0x3e, 0xf1, 0x93, 0x78, 0x6c, 0x44, 0x5b, 0x33, 0x33, 0xaa, 0x15, 0x1b, 0x18, 0x68, 0x19, + 0x4e, 0x33, 0x9f, 0xd3, 0x4d, 0x37, 0xd9, 0x08, 0xda, 0x89, 0xdc, 0x42, 0x8d, 0x8d, 0xa6, 0x8f, + 0x3a, 0x16, 0x72, 0x70, 0x70, 0xee, 0x93, 0xe7, 0x3e, 0x00, 0x27, 0x3b, 0x44, 0xc1, 0x81, 0xdc, + 0x3d, 0xb3, 0xf0, 0x50, 0xfe, 0xa2, 0x3b, 0x90, 0xd3, 0xe7, 0x9f, 0x66, 0xc2, 0x6e, 0x0d, 0x43, + 0xbc, 0x07, 0x07, 0xa2, 0x03, 0x65, 0xe2, 0x6f, 0x09, 0x1d, 0x74, 0xe9, 0x68, 0xdf, 0xee, 0xa2, + 0xbf, 0xc5, 0x65, 0x06, 0xf3, 0x92, 0x5c, 0xf4, 0xb7, 0x30, 0xa5, 0x8d, 0xde, 0xb4, 0x52, 0x86, + 0x24, 0x77, 0x3b, 0xbe, 0x72, 0x2c, 0x3b, 0x8f, 0x9e, 0x6d, 0x4b, 0xfb, 0xf7, 0x4b, 0x70, 0x7e, + 0x3f, 0x22, 0x3d, 0x0c, 0xdf, 0xe3, 0xd0, 0x1f, 0xb3, 0x83, 0x74, 0x21, 0xd4, 0x07, 0xe9, 0x5c, + 0xe5, 0x47, 0xeb, 0xaf, 0x62, 0x01, 0x42, 0x1e, 0x94, 0x5b, 0x4e, 0x28, 0xbc, 0x51, 0xf3, 0x47, + 0x4d, 0xc4, 0xa1, 0xff, 0x1d, 0x6f, 0xd1, 0x09, 0xb9, 0x8f, 0xc3, 0x68, 0xc0, 0x94, 0x0d, 0x4a, + 0xa0, 0xe2, 0x44, 0x91, 0x23, 0x4f, 0x6d, 0xaf, 0x16, 0xc3, 0x6f, 0x8a, 0x92, 0xe4, 0x87, 0x5e, + 0xa9, 0x26, 0xcc, 0x99, 0xd9, 0x9f, 0x1b, 0x48, 0x25, 0xa3, 0xb0, 0xa3, 0xf8, 0x18, 0xfa, 0x85, + 0x13, 0xca, 0x2a, 0x3a, 0xff, 0x89, 0x67, 0x13, 0xb2, 0x7d, 0xa6, 0xc8, 0xc9, 0x16, 0xac, 0xd0, + 0x67, 0x2d, 0x96, 0xf9, 0x2c, 0x13, 0x74, 0xc4, 0xee, 0xee, 0x78, 0x12, 0xb1, 0xcd, 0x7c, 0x6a, + 0xd9, 0x88, 0x4d, 0xee, 0xa2, 0x82, 0x01, 0xb3, 0x6a, 0x3b, 0x2b, 0x18, 0x30, 0x2b, 0x55, 0xc2, + 0xd1, 0x76, 0xce, 0x91, 0x7b, 0x01, 0xd9, 0xb3, 0x3d, 0x1c, 0xb2, 0x7f, 0xd5, 0x82, 0x93, 0x6e, + 0xf6, 0xec, 0x54, 0xec, 0x85, 0x8e, 0x18, 0xd4, 0xd1, 0xfd, 0x68, 0x56, 0x99, 0x03, 0x1d, 0x20, + 0xdc, 0xd9, 0x19, 0xd4, 0x80, 0x3e, 0xd7, 0x5f, 0x0f, 0x84, 0x11, 0x34, 0x7d, 0xb4, 0x4e, 0xcd, + 0xfb, 0xeb, 0x81, 0x5e, 0xcd, 0xf4, 0x1f, 0x66, 0xd4, 0xd1, 0x02, 0x9c, 0x8e, 0x84, 0xb7, 0xea, + 0xb2, 0x1b, 0x27, 0x41, 0xb4, 0xb3, 0xe0, 0xb6, 0xdc, 0x84, 0x19, 0x30, 0xe5, 0xe9, 0x31, 0xaa, + 0x1f, 0x70, 0x0e, 0x1c, 0xe7, 0x3e, 0x85, 0x5e, 0x87, 0x01, 0x99, 0xaa, 0x5d, 0x2d, 0x62, 0x5f, + 0xd9, 0x39, 0xff, 0xd5, 0x64, 0x5a, 0x11, 0x59, 0xd9, 0x92, 0xa1, 0xfd, 0xc6, 0x20, 0x74, 0x1e, + 0xab, 0xa2, 0x8f, 0x41, 0x2d, 0x52, 0xe9, 0xe3, 0x56, 0x11, 0xea, 0x5a, 0x7e, 0x5f, 0x71, 0xa4, + 0xab, 0x4c, 0x21, 0x9d, 0x28, 0xae, 0x39, 0xd2, 0x0d, 0x4f, 0xac, 0x4f, 0x5f, 0x0b, 0x98, 0xdb, + 0x82, 0xab, 0x3e, 0x59, 0xdb, 0xf1, 0xeb, 0x98, 0xf1, 0x40, 0x11, 0xf4, 0x6f, 0x10, 0xc7, 0x4b, + 0x36, 0x8a, 0x39, 0x04, 0xb8, 0xcc, 0x68, 0x65, 0x93, 0x88, 0x78, 0x2b, 0x16, 0x9c, 0xd0, 0x36, + 0x0c, 0x6c, 0xf0, 0x09, 0x20, 0xf6, 0x20, 0x8b, 0x47, 0x1d, 0xdc, 0xd4, 0xac, 0xd2, 0x9f, 0x5b, + 0x34, 0x60, 0xc9, 0x8e, 0xc5, 0xeb, 0x18, 0x11, 0x05, 0x7c, 0xe9, 0x16, 0x97, 0x3f, 0xd5, 0x7b, + 0x38, 0xc1, 0x47, 0x60, 0x28, 0x22, 0xf5, 0xc0, 0xaf, 0xbb, 0x1e, 0x69, 0x4c, 0x49, 0x07, 0xff, + 0x41, 0xb2, 0x6e, 0xd8, 0x3e, 0x1e, 0x1b, 0x34, 0x70, 0x8a, 0x22, 0xfa, 0x8c, 0x05, 0x23, 0x2a, + 0xe7, 0x94, 0x7e, 0x10, 0x22, 0x1c, 0xca, 0x0b, 0x05, 0x65, 0xb8, 0x32, 0x9a, 0xd3, 0x88, 0xee, + 0x05, 0xd2, 0x6d, 0x38, 0xc3, 0x17, 0xbd, 0x04, 0x10, 0xac, 0xf1, 0xa0, 0x9c, 0xa9, 0x44, 0x78, + 0x97, 0x0f, 0xf2, 0xaa, 0x23, 0x3c, 0xfd, 0x4e, 0x52, 0xc0, 0x06, 0x35, 0x74, 0x15, 0x80, 0x2f, + 0x9b, 0xd5, 0x9d, 0x90, 0xef, 0x51, 0x74, 0xda, 0x14, 0xac, 0x28, 0xc8, 0xdd, 0xdd, 0xf1, 0x4e, + 0x6f, 0x1f, 0x0b, 0x7c, 0x30, 0x1e, 0x47, 0x3f, 0x03, 0x03, 0x71, 0xbb, 0xd5, 0x72, 0x94, 0xef, + 0xb9, 0xc0, 0x84, 0x3e, 0x4e, 0xd7, 0x10, 0x45, 0xbc, 0x01, 0x4b, 0x8e, 0xe8, 0x16, 0x15, 0xaa, + 0xb1, 0x70, 0x43, 0xb2, 0x55, 0xc4, 0x6d, 0x82, 0x41, 0xf6, 0x4e, 0xef, 0x95, 0x86, 0x37, 0xce, + 0xc1, 0xb9, 0xbb, 0x3b, 0xfe, 0x50, 0xba, 0x7d, 0x21, 0x10, 0x29, 0x76, 0xb9, 0x34, 0xd1, 0x15, + 0x59, 0xb9, 0x85, 0xbe, 0xb6, 0x2c, 0x28, 0xf0, 0xa4, 0xae, 0xdc, 0xc2, 0x9a, 0xbb, 0x8f, 0x99, + 0xf9, 0x30, 0x5a, 0x84, 0x53, 0xf5, 0xc0, 0x4f, 0xa2, 0xc0, 0xf3, 0x78, 0xe5, 0x22, 0xbe, 0xe7, + 0xe3, 0xbe, 0xe9, 0x77, 0x8a, 0x6e, 0x9f, 0x9a, 0xe9, 0x44, 0xc1, 0x79, 0xcf, 0xd9, 0x7e, 0x3a, + 0x5a, 0x51, 0x0c, 0xce, 0xb3, 0x30, 0x44, 0xb6, 0x13, 0x12, 0xf9, 0x8e, 0x77, 0x1d, 0x2f, 0x48, + 0xaf, 0x2c, 0x5b, 0x03, 0x17, 0x8d, 0x76, 0x9c, 0xc2, 0x42, 0xb6, 0x72, 0x94, 0x18, 0x69, 0xa3, + 0xdc, 0x51, 0x22, 0xdd, 0x22, 0xf6, 0xff, 0x2a, 0xa5, 0x0c, 0xb2, 0xd5, 0x88, 0x10, 0x14, 0x40, + 0xc5, 0x0f, 0x1a, 0x4a, 0xf6, 0x5f, 0x29, 0x46, 0xf6, 0x5f, 0x0b, 0x1a, 0x46, 0x79, 0x17, 0xfa, + 0x2f, 0xc6, 0x9c, 0x0f, 0xab, 0x7f, 0x21, 0x0b, 0x85, 0x30, 0x80, 0xd8, 0x68, 0x14, 0xc9, 0x59, + 0xd5, 0xbf, 0x58, 0x32, 0x19, 0xe1, 0x34, 0x5f, 0xb4, 0x09, 0x95, 0x8d, 0x20, 0x4e, 0xe4, 0xf6, + 0xe3, 0x88, 0x3b, 0x9d, 0xcb, 0x41, 0x9c, 0x30, 0x2b, 0x42, 0xbd, 0x36, 0x6d, 0x89, 0x31, 0xe7, + 0x61, 0xff, 0x67, 0x2b, 0xe5, 0x83, 0xbf, 0xc9, 0x22, 0x77, 0xb7, 0x88, 0x4f, 0x97, 0xb5, 0x19, + 0xaa, 0xf4, 0xe3, 0x99, 0x3c, 0xc8, 0x77, 0x75, 0x2b, 0xcc, 0x75, 0x9b, 0x52, 0x98, 0x60, 0x24, + 0x8c, 0xa8, 0xa6, 0x4f, 0x58, 0xe9, 0x8c, 0xd4, 0x52, 0x11, 0x1b, 0x0c, 0x33, 0x2b, 0x7b, 0xdf, + 0xe4, 0x56, 0xfb, 0x4d, 0x0b, 0x06, 0xa6, 0x9d, 0xfa, 0x66, 0xb0, 0xbe, 0x8e, 0x9e, 0x82, 0x6a, + 0xa3, 0x1d, 0x99, 0xc9, 0xb1, 0xca, 0x71, 0x30, 0x2b, 0xda, 0xb1, 0xc2, 0xa0, 0x73, 0x78, 0xdd, + 0xa9, 0xcb, 0xdc, 0xec, 0x32, 0x9f, 0xc3, 0x97, 0x58, 0x0b, 0x16, 0x10, 0xf4, 0x1c, 0x0c, 0xb6, + 0x9c, 0x6d, 0xf9, 0x70, 0xf6, 0x00, 0x60, 0x51, 0x83, 0xb0, 0x89, 0x67, 0xff, 0x4b, 0x0b, 0xc6, + 0xa6, 0x9d, 0xd8, 0xad, 0x4f, 0xb5, 0x93, 0x8d, 0x69, 0x37, 0x59, 0x6b, 0xd7, 0x37, 0x49, 0xc2, + 0x13, 0xf2, 0x69, 0x2f, 0xdb, 0x31, 0x5d, 0x4a, 0x6a, 0x5f, 0xa7, 0x7a, 0x79, 0x5d, 0xb4, 0x63, + 0x85, 0x81, 0x5e, 0x87, 0xc1, 0xd0, 0x89, 0xe3, 0xdb, 0x41, 0xd4, 0xc0, 0x64, 0xbd, 0x98, 0x72, + 0x18, 0x2b, 0xa4, 0x1e, 0x91, 0x04, 0x93, 0x75, 0x71, 0x48, 0xad, 0xe9, 0x63, 0x93, 0x99, 0xfd, + 0x05, 0x0b, 0xce, 0x4e, 0x13, 0x27, 0x22, 0x11, 0xab, 0x9e, 0xa1, 0x5e, 0x64, 0xc6, 0x0b, 0xda, + 0x0d, 0xf4, 0x1a, 0x54, 0x13, 0xda, 0x4c, 0xbb, 0x65, 0x15, 0xdb, 0x2d, 0x76, 0xc6, 0xbc, 0x2a, + 0x88, 0x63, 0xc5, 0xc6, 0xfe, 0xdb, 0x16, 0x0c, 0xb1, 0xe3, 0xba, 0x59, 0x92, 0x38, 0xae, 0xd7, + 0x51, 0x64, 0xca, 0xea, 0xb1, 0xc8, 0xd4, 0x79, 0xe8, 0xdb, 0x08, 0x5a, 0x24, 0x7b, 0xd4, 0x7c, + 0x39, 0xa0, 0xdb, 0x6a, 0x0a, 0x41, 0xcf, 0xd0, 0x0f, 0xef, 0xfa, 0x89, 0x43, 0x97, 0x80, 0x74, + 0x07, 0x8f, 0xf2, 0x8f, 0xae, 0x9a, 0xb1, 0x89, 0x63, 0xff, 0x4e, 0x0d, 0x06, 0x44, 0x3c, 0x42, + 0xcf, 0x45, 0x19, 0xe4, 0xfe, 0xbe, 0xd4, 0x75, 0x7f, 0x1f, 0x43, 0x7f, 0x9d, 0x55, 0xbb, 0x13, + 0x66, 0xe4, 0xd5, 0x42, 0x02, 0x58, 0x78, 0x01, 0x3d, 0xdd, 0x2d, 0xfe, 0x1f, 0x0b, 0x56, 0xe8, + 0x8b, 0x16, 0x8c, 0xd6, 0x03, 0xdf, 0x27, 0x75, 0x6d, 0xe3, 0xf4, 0x15, 0x11, 0xa7, 0x30, 0x93, + 0x26, 0xaa, 0xcf, 0x8a, 0x32, 0x00, 0x9c, 0x65, 0x8f, 0x5e, 0x80, 0x61, 0x3e, 0x66, 0x37, 0x52, + 0x3e, 0x6c, 0x5d, 0x7b, 0xc8, 0x04, 0xe2, 0x34, 0x2e, 0x9a, 0xe0, 0x67, 0x01, 0xa2, 0xca, 0x4f, + 0xbf, 0x76, 0xd5, 0x19, 0xf5, 0x7d, 0x0c, 0x0c, 0x14, 0x01, 0x8a, 0xc8, 0x7a, 0x44, 0xe2, 0x0d, + 0x11, 0xaf, 0xc1, 0xec, 0xab, 0x81, 0xc3, 0x25, 0x70, 0xe3, 0x0e, 0x4a, 0x38, 0x87, 0x3a, 0xda, + 0x14, 0x1b, 0xcc, 0x6a, 0x11, 0x32, 0x54, 0x7c, 0xe6, 0xae, 0xfb, 0xcc, 0x71, 0xa8, 0xc4, 0x1b, + 0x4e, 0xd4, 0x60, 0x76, 0x5d, 0x99, 0x27, 0x0d, 0xad, 0xd0, 0x06, 0xcc, 0xdb, 0xd1, 0x2c, 0x9c, + 0xc8, 0x54, 0x4e, 0x8a, 0x99, 0xe5, 0x56, 0xd5, 0x09, 0x22, 0x99, 0x9a, 0x4b, 0x31, 0xee, 0x78, + 0xc2, 0x74, 0x3e, 0x0c, 0xee, 0xe3, 0x7c, 0xd8, 0x51, 0x51, 0x81, 0xdc, 0x85, 0xfc, 0x62, 0x21, + 0x03, 0xd0, 0x53, 0x08, 0xe0, 0xe7, 0x33, 0x21, 0x80, 0xdc, 0x8d, 0x7c, 0xa3, 0x98, 0x0e, 0x1c, + 0x3c, 0xde, 0xef, 0x7e, 0xc6, 0xef, 0xfd, 0x95, 0x05, 0xf2, 0xbb, 0xce, 0x38, 0xf5, 0x0d, 0x42, + 0xa7, 0x0c, 0x7a, 0x3f, 0x8c, 0xa8, 0x2d, 0xf4, 0x4c, 0xd0, 0xf6, 0x79, 0xe8, 0x5e, 0x59, 0x9f, + 0x58, 0xe0, 0x14, 0x14, 0x67, 0xb0, 0xd1, 0x24, 0xd4, 0xe8, 0x38, 0xf1, 0x47, 0xb9, 0xae, 0x55, + 0xdb, 0xf4, 0xa9, 0xe5, 0x79, 0xf1, 0x94, 0xc6, 0x41, 0x01, 0x9c, 0xf4, 0x9c, 0x38, 0x61, 0x3d, + 0xa0, 0x3b, 0xea, 0x43, 0x96, 0x4f, 0x60, 0x59, 0x08, 0x0b, 0x59, 0x42, 0xb8, 0x93, 0xb6, 0xfd, + 0x9d, 0x3e, 0x18, 0x4e, 0x49, 0xc6, 0x03, 0x2a, 0xe9, 0xa7, 0xa0, 0x2a, 0xf5, 0x66, 0xb6, 0xd0, + 0x8b, 0x52, 0xae, 0x0a, 0x83, 0x2a, 0xad, 0x35, 0xad, 0x55, 0xb3, 0x46, 0x85, 0xa1, 0x70, 0xb1, + 0x89, 0xc7, 0x84, 0x72, 0xe2, 0xc5, 0x33, 0x9e, 0x4b, 0xfc, 0x84, 0x77, 0xb3, 0x18, 0xa1, 0xbc, + 0xba, 0xb0, 0x62, 0x12, 0xd5, 0x42, 0x39, 0x03, 0xc0, 0x59, 0xf6, 0xe8, 0xd3, 0x16, 0x0c, 0x3b, + 0xb7, 0x63, 0x5d, 0x92, 0x55, 0x04, 0xfb, 0x1d, 0x51, 0x49, 0xa5, 0xaa, 0xbc, 0x72, 0x97, 0x6f, + 0xaa, 0x09, 0xa7, 0x99, 0xa2, 0xb7, 0x2c, 0x40, 0x64, 0x9b, 0xd4, 0x65, 0x38, 0xa2, 0xe8, 0x4b, + 0x7f, 0x11, 0x3b, 0xcd, 0x8b, 0x1d, 0x74, 0xb9, 0x54, 0xef, 0x6c, 0xc7, 0x39, 0x7d, 0xb0, 0xbf, + 0x59, 0x56, 0x0b, 0x4a, 0x47, 0xc0, 0x3a, 0x46, 0x24, 0x9e, 0x75, 0xf8, 0x48, 0x3c, 0x1d, 0xd1, + 0xd0, 0x99, 0x95, 0x99, 0x4a, 0xe2, 0x2a, 0xdd, 0xa7, 0x24, 0xae, 0x9f, 0xb3, 0x52, 0x25, 0x8d, + 0x06, 0x2f, 0xbc, 0x54, 0x6c, 0xf4, 0xed, 0x04, 0x8f, 0xb6, 0xc8, 0x48, 0xf7, 0x74, 0x90, 0x0d, + 0x95, 0xa6, 0x06, 0xda, 0x81, 0xa4, 0xe1, 0xbf, 0x2b, 0xc3, 0xa0, 0xa1, 0x49, 0x73, 0xcd, 0x22, + 0xeb, 0x01, 0x33, 0x8b, 0x4a, 0x07, 0x30, 0x8b, 0x7e, 0x16, 0x6a, 0x75, 0x29, 0xe5, 0x8b, 0x29, + 0xea, 0x9b, 0xd5, 0x1d, 0x5a, 0xd0, 0xab, 0x26, 0xac, 0x79, 0xa2, 0xb9, 0x54, 0xea, 0x8f, 0xd0, + 0x10, 0x7d, 0x4c, 0x43, 0xe4, 0xe5, 0xe6, 0x08, 0x4d, 0xd1, 0xf9, 0x0c, 0xab, 0x7c, 0x15, 0xba, + 0xe2, 0xbd, 0x64, 0x8c, 0x3c, 0xaf, 0x7c, 0xb5, 0x3c, 0x2f, 0x9b, 0xb1, 0x89, 0x63, 0x7f, 0xc7, + 0x52, 0x1f, 0xf7, 0x1e, 0xd4, 0x78, 0xb8, 0x95, 0xae, 0xf1, 0x70, 0xb1, 0x90, 0x61, 0xee, 0x52, + 0xdc, 0xe1, 0x1a, 0x0c, 0xcc, 0x04, 0xad, 0x96, 0xe3, 0x37, 0xd0, 0x8f, 0xc0, 0x40, 0x9d, 0xff, + 0x14, 0x8e, 0x1d, 0x76, 0x3c, 0x28, 0xa0, 0x58, 0xc2, 0xd0, 0x23, 0xd0, 0xe7, 0x44, 0x4d, 0xe9, + 0xcc, 0x61, 0xc1, 0x39, 0x53, 0x51, 0x33, 0xc6, 0xac, 0xd5, 0xfe, 0x27, 0x7d, 0xc0, 0xce, 0xb4, + 0x9d, 0x88, 0x34, 0x56, 0x03, 0x56, 0x54, 0xf0, 0x58, 0x0f, 0xd5, 0xf4, 0x66, 0xe9, 0x41, 0x3e, + 0x58, 0x33, 0x0e, 0x57, 0xca, 0xf7, 0xf8, 0x70, 0xa5, 0xcb, 0x79, 0x59, 0xdf, 0x03, 0x74, 0x5e, + 0x66, 0x7f, 0xce, 0x02, 0xa4, 0x02, 0x21, 0xf4, 0x81, 0xf6, 0x24, 0xd4, 0x54, 0x48, 0x84, 0x30, + 0xac, 0xb4, 0x88, 0x90, 0x00, 0xac, 0x71, 0x7a, 0xd8, 0x21, 0x3f, 0x2e, 0xe5, 0x77, 0x39, 0x1d, + 0xd7, 0xcb, 0xa4, 0xbe, 0x10, 0xe7, 0xf6, 0xef, 0x96, 0xe0, 0x21, 0xae, 0x92, 0x17, 0x1d, 0xdf, + 0x69, 0x92, 0x16, 0xed, 0x55, 0xaf, 0x21, 0x0a, 0x75, 0xba, 0x35, 0x73, 0x65, 0x9c, 0xee, 0x51, + 0xd7, 0x2e, 0x5f, 0x73, 0x7c, 0x95, 0xcd, 0xfb, 0x6e, 0x82, 0x19, 0x71, 0x14, 0x43, 0x55, 0x56, + 0xbc, 0x17, 0xb2, 0xb8, 0x20, 0x46, 0x4a, 0x2c, 0x09, 0xbd, 0x49, 0xb0, 0x62, 0x44, 0x0d, 0x57, + 0x2f, 0xa8, 0x6f, 0x62, 0x12, 0x06, 0x4c, 0xee, 0x1a, 0x61, 0x92, 0x0b, 0xa2, 0x1d, 0x2b, 0x0c, + 0xfb, 0x77, 0x2d, 0xc8, 0x6a, 0x24, 0xa3, 0x7a, 0x9b, 0xb5, 0x67, 0xf5, 0xb6, 0x03, 0x94, 0x4f, + 0xfb, 0x69, 0x18, 0x74, 0x12, 0x6a, 0x44, 0xf0, 0x6d, 0x77, 0xf9, 0x70, 0xc7, 0x1a, 0x8b, 0x41, + 0xc3, 0x5d, 0x77, 0xd9, 0x76, 0xdb, 0x24, 0x67, 0xff, 0xf7, 0x3e, 0x38, 0xd9, 0x91, 0x4d, 0x82, + 0x9e, 0x87, 0xa1, 0xba, 0x98, 0x1e, 0xa1, 0x74, 0x68, 0xd5, 0xcc, 0xb0, 0x3a, 0x0d, 0xc3, 0x29, + 0xcc, 0x1e, 0x26, 0xe8, 0x3c, 0x9c, 0x8a, 0xe8, 0x46, 0xbf, 0x4d, 0xa6, 0xd6, 0x13, 0x12, 0xad, + 0x90, 0x7a, 0xe0, 0x37, 0x78, 0x8d, 0xc1, 0xf2, 0xf4, 0xc3, 0x77, 0x76, 0xc7, 0x4f, 0xe1, 0x4e, + 0x30, 0xce, 0x7b, 0x06, 0x85, 0x30, 0xec, 0x99, 0x36, 0xa0, 0xd8, 0x00, 0x1c, 0xca, 0x7c, 0x54, + 0x36, 0x42, 0xaa, 0x19, 0xa7, 0x19, 0xa4, 0x0d, 0xc9, 0xca, 0x7d, 0x32, 0x24, 0x3f, 0xa5, 0x0d, + 0x49, 0x7e, 0xfe, 0xfe, 0xe1, 0x82, 0xb3, 0x89, 0x8e, 0xdb, 0x92, 0x7c, 0x11, 0xaa, 0x32, 0x36, + 0xa9, 0xa7, 0x98, 0x1e, 0x93, 0x4e, 0x17, 0x89, 0xf6, 0x04, 0xfc, 0xf0, 0xc5, 0x28, 0x32, 0x06, + 0xf3, 0x5a, 0x90, 0x4c, 0x79, 0x5e, 0x70, 0x9b, 0x2a, 0xe9, 0xeb, 0x31, 0x11, 0x1e, 0x16, 0xfb, + 0x6e, 0x09, 0x72, 0x36, 0x2b, 0x74, 0x3d, 0x6a, 0xcb, 0x20, 0xb5, 0x1e, 0x0f, 0x66, 0x1d, 0xa0, + 0x6d, 0x1e, 0xbf, 0xc5, 0x75, 0xe0, 0x87, 0x8a, 0xde, 0x6c, 0xe9, 0x90, 0x2e, 0x95, 0x8c, 0xa1, + 0xc2, 0xba, 0x2e, 0x00, 0x68, 0x83, 0x4e, 0x84, 0xda, 0xab, 0xe3, 0x61, 0x6d, 0xf7, 0x61, 0x03, + 0x8b, 0xee, 0xbd, 0x5d, 0x3f, 0x4e, 0x1c, 0xcf, 0xbb, 0xec, 0xfa, 0x89, 0x70, 0x22, 0x2a, 0x65, + 0x3f, 0xaf, 0x41, 0xd8, 0xc4, 0x3b, 0xf7, 0x5e, 0xe3, 0xfb, 0x1d, 0xe4, 0xbb, 0x6f, 0xc0, 0xd9, + 0x39, 0x37, 0x51, 0x09, 0x22, 0x6a, 0xbe, 0x51, 0x7b, 0x4d, 0x25, 0x3c, 0x59, 0x5d, 0x13, 0x9e, + 0x8c, 0x04, 0x8d, 0x52, 0x3a, 0x9f, 0x24, 0x9b, 0xa0, 0x61, 0x3f, 0x0f, 0xa7, 0xe7, 0xdc, 0xe4, + 0x92, 0xeb, 0x91, 0x03, 0x32, 0xb1, 0x7f, 0xbb, 0x1f, 0x86, 0xcc, 0x14, 0xc3, 0x83, 0xe4, 0x6c, + 0x7d, 0x81, 0x9a, 0x64, 0xe2, 0xed, 0x5c, 0x75, 0xb8, 0x76, 0xf3, 0xc8, 0xf9, 0x8e, 0xf9, 0x23, + 0x66, 0x58, 0x65, 0x9a, 0x27, 0x36, 0x3b, 0x80, 0x6e, 0x43, 0x65, 0x9d, 0x25, 0x10, 0x94, 0x8b, + 0x88, 0x40, 0xc8, 0x1b, 0x51, 0xbd, 0x1c, 0x79, 0x0a, 0x02, 0xe7, 0x47, 0x35, 0x69, 0x94, 0xce, + 0x4a, 0x33, 0x82, 0x56, 0x45, 0x3e, 0x9a, 0xc2, 0xe8, 0xa6, 0x12, 0x2a, 0x87, 0x50, 0x09, 0x29, + 0x01, 0xdd, 0x7f, 0x9f, 0x04, 0x34, 0x4b, 0x06, 0x49, 0x36, 0x98, 0x9d, 0x27, 0xa2, 0xf4, 0x07, + 0xd8, 0x20, 0x18, 0xc9, 0x20, 0x29, 0x30, 0xce, 0xe2, 0xa3, 0x8f, 0x2b, 0x11, 0x5f, 0x2d, 0xc2, + 0xff, 0x6a, 0xce, 0xe8, 0xe3, 0x96, 0xee, 0x9f, 0x2b, 0xc1, 0xc8, 0x9c, 0xdf, 0x5e, 0x9e, 0x5b, + 0x6e, 0xaf, 0x79, 0x6e, 0xfd, 0x2a, 0xd9, 0xa1, 0x22, 0x7c, 0x93, 0xec, 0xcc, 0xcf, 0x8a, 0x15, + 0xa4, 0xe6, 0xcc, 0x55, 0xda, 0x88, 0x39, 0x8c, 0x0a, 0xa3, 0x75, 0xd7, 0x6f, 0x92, 0x28, 0x8c, + 0x5c, 0xe1, 0x1a, 0x35, 0x84, 0xd1, 0x25, 0x0d, 0xc2, 0x26, 0x1e, 0xa5, 0x1d, 0xdc, 0xf6, 0x49, + 0x94, 0x35, 0x78, 0x97, 0x68, 0x23, 0xe6, 0x30, 0x8a, 0x94, 0x44, 0xed, 0x38, 0x11, 0x93, 0x51, + 0x21, 0xad, 0xd2, 0x46, 0xcc, 0x61, 0x74, 0xa5, 0xc7, 0xed, 0x35, 0x16, 0xe0, 0x91, 0x49, 0x09, + 0x58, 0xe1, 0xcd, 0x58, 0xc2, 0x29, 0xea, 0x26, 0xd9, 0x99, 0xa5, 0xbb, 0xe3, 0x4c, 0x66, 0xd0, + 0x55, 0xde, 0x8c, 0x25, 0x9c, 0x15, 0x51, 0x4c, 0x0f, 0xc7, 0xf7, 0x5d, 0x11, 0xc5, 0x74, 0xf7, + 0xbb, 0xec, 0xb3, 0x7f, 0xcd, 0x82, 0x21, 0x33, 0x2c, 0x0b, 0x35, 0x33, 0xb6, 0xf0, 0x52, 0x47, + 0x0d, 0xde, 0x9f, 0xcc, 0xbb, 0xc0, 0xac, 0xe9, 0x26, 0x41, 0x18, 0x3f, 0x4d, 0xfc, 0xa6, 0xeb, + 0x13, 0x76, 0xda, 0xce, 0xc3, 0xb9, 0x52, 0x31, 0x5f, 0x33, 0x41, 0x83, 0x1c, 0xc2, 0x98, 0xb6, + 0x6f, 0xc2, 0xc9, 0x8e, 0x74, 0xb0, 0x1e, 0x4c, 0x90, 0x7d, 0x93, 0x71, 0x6d, 0x0c, 0x83, 0x94, + 0xb0, 0x2c, 0xe4, 0x33, 0x03, 0x27, 0xf9, 0x42, 0xa2, 0x9c, 0x56, 0xea, 0x1b, 0xa4, 0xa5, 0x52, + 0xfc, 0x98, 0x1f, 0xfe, 0x46, 0x16, 0x88, 0x3b, 0xf1, 0xed, 0xcf, 0x5b, 0x30, 0x9c, 0xca, 0xd0, + 0x2b, 0xc8, 0x58, 0x62, 0x2b, 0x2d, 0x60, 0x51, 0x82, 0x2c, 0x54, 0xba, 0xcc, 0x94, 0xa9, 0x5e, + 0x69, 0x1a, 0x84, 0x4d, 0x3c, 0xfb, 0xcd, 0x12, 0x54, 0x65, 0xa4, 0x45, 0x0f, 0x5d, 0xf9, 0xac, + 0x05, 0xc3, 0xea, 0xec, 0x83, 0x39, 0xd5, 0x4a, 0x45, 0xa4, 0x43, 0xd0, 0x1e, 0xa8, 0x6d, 0xb9, + 0xbf, 0x1e, 0x68, 0xcb, 0x1d, 0x9b, 0xcc, 0x70, 0x9a, 0x37, 0xba, 0x01, 0x10, 0xef, 0xc4, 0x09, + 0x69, 0x19, 0xee, 0x3d, 0xdb, 0x58, 0x71, 0x13, 0xf5, 0x20, 0x22, 0x74, 0x7d, 0x5d, 0x0b, 0x1a, + 0x64, 0x45, 0x61, 0x6a, 0x13, 0x4a, 0xb7, 0x61, 0x83, 0x92, 0xfd, 0x8f, 0x4a, 0x70, 0x22, 0xdb, + 0x25, 0xf4, 0x61, 0x18, 0x92, 0xdc, 0x8d, 0xbb, 0xd8, 0x64, 0x78, 0xc9, 0x10, 0x36, 0x60, 0x77, + 0x77, 0xc7, 0xc7, 0x3b, 0x2f, 0xc3, 0x9b, 0x30, 0x51, 0x70, 0x8a, 0x18, 0x3f, 0x80, 0x12, 0x27, + 0xa5, 0xd3, 0x3b, 0x53, 0x61, 0x28, 0x4e, 0x91, 0x8c, 0x03, 0x28, 0x13, 0x8a, 0x33, 0xd8, 0x68, + 0x19, 0x4e, 0x1b, 0x2d, 0xd7, 0x88, 0xdb, 0xdc, 0x58, 0x0b, 0x22, 0xb9, 0x03, 0x7b, 0x44, 0x07, + 0x80, 0x75, 0xe2, 0xe0, 0xdc, 0x27, 0xa9, 0xb6, 0xaf, 0x3b, 0xa1, 0x53, 0x77, 0x93, 0x1d, 0xe1, + 0xaf, 0x54, 0xb2, 0x69, 0x46, 0xb4, 0x63, 0x85, 0x61, 0x2f, 0x42, 0x5f, 0x8f, 0x33, 0xa8, 0x27, + 0xcb, 0xff, 0x45, 0xa8, 0x52, 0x72, 0xd2, 0xbc, 0x2b, 0x82, 0x64, 0x00, 0x55, 0x79, 0x47, 0x0a, + 0xb2, 0xa1, 0xec, 0x3a, 0xf2, 0x8c, 0x4f, 0xbd, 0xd6, 0x7c, 0x1c, 0xb7, 0xd9, 0x66, 0x9a, 0x02, + 0xd1, 0xe3, 0x50, 0x26, 0xdb, 0x61, 0xf6, 0x30, 0xef, 0xe2, 0x76, 0xe8, 0x46, 0x24, 0xa6, 0x48, + 0x64, 0x3b, 0x44, 0xe7, 0xa0, 0xe4, 0x36, 0x84, 0x92, 0x02, 0x81, 0x53, 0x9a, 0x9f, 0xc5, 0x25, + 0xb7, 0x61, 0x6f, 0x43, 0x4d, 0x5d, 0xca, 0x82, 0x36, 0xa5, 0xec, 0xb6, 0x8a, 0x08, 0x8d, 0x92, + 0x74, 0xbb, 0x48, 0xed, 0x36, 0x80, 0x4e, 0x55, 0x2c, 0x4a, 0xbe, 0x9c, 0x87, 0xbe, 0x7a, 0x20, + 0xd2, 0xa8, 0xab, 0x9a, 0x0c, 0x13, 0xda, 0x0c, 0x62, 0xdf, 0x84, 0x91, 0xab, 0x7e, 0x70, 0x9b, + 0x55, 0x94, 0x67, 0x05, 0xd4, 0x28, 0xe1, 0x75, 0xfa, 0x23, 0x6b, 0x22, 0x30, 0x28, 0xe6, 0x30, + 0x55, 0x59, 0xaa, 0xd4, 0xad, 0xb2, 0x94, 0xfd, 0x09, 0x0b, 0x86, 0x54, 0xce, 0xd2, 0xdc, 0xd6, + 0x26, 0xa5, 0xdb, 0x8c, 0x82, 0x76, 0x98, 0xa5, 0xcb, 0xae, 0x4d, 0xc2, 0x1c, 0x66, 0x26, 0x03, + 0x96, 0xf6, 0x49, 0x06, 0x3c, 0x0f, 0x7d, 0x9b, 0xae, 0xdf, 0xc8, 0xde, 0x03, 0x72, 0xd5, 0xf5, + 0x1b, 0x98, 0x41, 0xec, 0x6f, 0x5a, 0x70, 0x42, 0x75, 0x41, 0x2a, 0x84, 0xe7, 0x61, 0x68, 0xad, + 0xed, 0x7a, 0x0d, 0x59, 0x19, 0x2e, 0xe3, 0x51, 0x99, 0x36, 0x60, 0x38, 0x85, 0x49, 0xf7, 0x75, + 0x6b, 0xae, 0xef, 0x44, 0x3b, 0xcb, 0x5a, 0x03, 0x29, 0xa1, 0x34, 0xad, 0x20, 0xd8, 0xc0, 0xa2, + 0xdc, 0x62, 0x92, 0xe8, 0x20, 0x49, 0xfe, 0x21, 0x14, 0xb7, 0x15, 0x03, 0x86, 0x53, 0x98, 0xf6, + 0x1b, 0x65, 0x18, 0x49, 0xe7, 0x7c, 0xf5, 0xb0, 0x31, 0x7b, 0x1c, 0x2a, 0x2c, 0x0d, 0x2c, 0x3b, + 0x29, 0x78, 0x19, 0x36, 0x0e, 0x43, 0x31, 0xf4, 0xf3, 0x02, 0x14, 0xc5, 0xdc, 0xbe, 0xa3, 0x3a, + 0xa9, 0x3c, 0x38, 0x2c, 0x62, 0x4d, 0xd4, 0xbc, 0x10, 0xac, 0xd0, 0xa7, 0x2d, 0x18, 0x08, 0x42, + 0xb3, 0x96, 0xd1, 0x87, 0x8a, 0xcc, 0x87, 0x13, 0xe9, 0x38, 0xc2, 0x96, 0x56, 0x93, 0x46, 0x7e, + 0x48, 0xc9, 0xfa, 0xdc, 0xfb, 0x60, 0xc8, 0xc4, 0xdc, 0xcf, 0x9c, 0xae, 0x9a, 0xe6, 0xf4, 0x67, + 0xcd, 0xe9, 0x24, 0x32, 0xfe, 0x7a, 0x58, 0xa8, 0xd7, 0xa1, 0x52, 0x57, 0x21, 0x06, 0x87, 0xaa, + 0x44, 0xaa, 0x2a, 0x42, 0xb0, 0x63, 0x26, 0x4e, 0xcd, 0xfe, 0x8e, 0x65, 0xcc, 0x0f, 0x4c, 0xe2, + 0xf9, 0x06, 0x8a, 0xa0, 0xdc, 0xdc, 0xda, 0x14, 0x46, 0xec, 0x95, 0x82, 0x86, 0x77, 0x6e, 0x6b, + 0x53, 0xcf, 0x57, 0xb3, 0x15, 0x53, 0x66, 0x3d, 0xb8, 0x19, 0x53, 0x89, 0xa1, 0xe5, 0xfd, 0x13, + 0x43, 0xed, 0xb7, 0x4a, 0x70, 0xb2, 0x63, 0x52, 0xa1, 0xd7, 0xa1, 0x12, 0xd1, 0xb7, 0x14, 0xaf, + 0xb7, 0x50, 0x58, 0x2a, 0x67, 0x3c, 0xdf, 0xd0, 0x1a, 0x3b, 0xdd, 0x8e, 0x39, 0x4b, 0x74, 0x05, + 0x90, 0x0e, 0x84, 0x51, 0x3e, 0x4e, 0xfe, 0xca, 0xe7, 0xc4, 0xa3, 0x68, 0xaa, 0x03, 0x03, 0xe7, + 0x3c, 0x85, 0x5e, 0xc8, 0xba, 0x4a, 0xcb, 0xe9, 0x93, 0xd1, 0xbd, 0xbc, 0x9e, 0xf6, 0xbf, 0x28, + 0xc1, 0x70, 0xaa, 0xb4, 0x14, 0xf2, 0xa0, 0x4a, 0x3c, 0x76, 0x6c, 0x20, 0xd5, 0xd4, 0x51, 0x2b, + 0x35, 0x2b, 0xd5, 0x7a, 0x51, 0xd0, 0xc5, 0x8a, 0xc3, 0x83, 0x71, 0x7c, 0xff, 0x3c, 0x0c, 0xc9, + 0x0e, 0x7d, 0xc8, 0x69, 0x79, 0x62, 0x00, 0xd5, 0x1c, 0xbd, 0x68, 0xc0, 0x70, 0x0a, 0xd3, 0xfe, + 0xbd, 0x32, 0x8c, 0xf1, 0x73, 0x96, 0x86, 0x9a, 0x79, 0x8b, 0x72, 0xa7, 0xf6, 0xd7, 0x75, 0x01, + 0x38, 0x3e, 0x90, 0x6b, 0x47, 0xbd, 0x18, 0x21, 0x9f, 0x51, 0x4f, 0xb1, 0x5f, 0x5f, 0xc9, 0xc4, + 0x7e, 0x71, 0x83, 0xbd, 0x79, 0x4c, 0x3d, 0xfa, 0xfe, 0x0a, 0x06, 0xfb, 0xfb, 0x25, 0x18, 0xcd, + 0xdc, 0x3a, 0x81, 0xde, 0x48, 0x17, 0x2a, 0xb6, 0x8a, 0xf0, 0xc6, 0xef, 0x79, 0x11, 0xc1, 0xc1, + 0xca, 0x15, 0xdf, 0xa7, 0xa5, 0x62, 0xff, 0x71, 0x09, 0x46, 0xd2, 0xd7, 0x65, 0x3c, 0x80, 0x23, + 0xf5, 0x6e, 0xa8, 0xb1, 0x8a, 0xf0, 0xec, 0x1a, 0x50, 0xee, 0xcc, 0xe7, 0xc5, 0xb7, 0x65, 0x23, + 0xd6, 0xf0, 0x07, 0xa2, 0x0a, 0xb4, 0xfd, 0x0f, 0x2c, 0x38, 0xc3, 0xdf, 0x32, 0x3b, 0x0f, 0xff, + 0x46, 0xde, 0xe8, 0xbe, 0x5c, 0x6c, 0x07, 0x33, 0x85, 0x0b, 0xf7, 0x1b, 0x5f, 0x76, 0xfd, 0xa0, + 0xe8, 0x6d, 0x7a, 0x2a, 0x3c, 0x80, 0x9d, 0x3d, 0xd0, 0x64, 0xb0, 0xff, 0xb8, 0x0c, 0xfa, 0xc6, + 0x45, 0xe4, 0x8a, 0x2c, 0xca, 0x42, 0x0a, 0x38, 0xae, 0xec, 0xf8, 0x75, 0x7d, 0xb7, 0x63, 0x35, + 0x93, 0x44, 0xf9, 0x8b, 0x16, 0x0c, 0xba, 0xbe, 0x9b, 0xb8, 0x0e, 0xdb, 0x80, 0x17, 0x73, 0x1b, + 0x9c, 0x62, 0x37, 0xcf, 0x29, 0x07, 0x91, 0x79, 0x02, 0xa4, 0x98, 0x61, 0x93, 0x33, 0xfa, 0x88, + 0x08, 0xcf, 0x2e, 0x17, 0x96, 0xff, 0x5b, 0xcd, 0xc4, 0x64, 0x87, 0xd4, 0xf0, 0x4a, 0xa2, 0x82, + 0xd2, 0xe6, 0x31, 0x25, 0xa5, 0x6a, 0x01, 0xeb, 0xbb, 0xaf, 0x69, 0x33, 0xe6, 0x8c, 0xec, 0x18, + 0x50, 0xe7, 0x58, 0x1c, 0x30, 0xf4, 0x75, 0x12, 0x6a, 0x4e, 0x3b, 0x09, 0x5a, 0x74, 0x98, 0xc4, + 0x21, 0x95, 0x0e, 0xee, 0x95, 0x00, 0xac, 0x71, 0xec, 0x37, 0x2a, 0x90, 0x49, 0x6b, 0x44, 0xdb, + 0xe6, 0x6d, 0xa1, 0x56, 0xb1, 0xb7, 0x85, 0xaa, 0xce, 0xe4, 0xdd, 0x18, 0x8a, 0x9a, 0x50, 0x09, + 0x37, 0x9c, 0x58, 0x9a, 0xd5, 0x2f, 0xaa, 0x7d, 0x1c, 0x6d, 0xbc, 0xbb, 0x3b, 0xfe, 0x53, 0xbd, + 0xf9, 0x6b, 0xe9, 0x5c, 0x9d, 0xe4, 0x05, 0x52, 0x34, 0x6b, 0x46, 0x03, 0x73, 0xfa, 0x07, 0xb9, + 0x0f, 0xef, 0x93, 0xa2, 0xf4, 0x3d, 0x26, 0x71, 0xdb, 0x4b, 0xc4, 0x6c, 0x78, 0xb1, 0xc0, 0x55, + 0xc6, 0x09, 0xeb, 0x84, 0x7c, 0xfe, 0x1f, 0x1b, 0x4c, 0xd1, 0x87, 0xa1, 0x16, 0x27, 0x4e, 0x94, + 0x1c, 0x32, 0x85, 0x56, 0x0d, 0xfa, 0x8a, 0x24, 0x82, 0x35, 0x3d, 0xf4, 0x12, 0xab, 0x67, 0xeb, + 0xc6, 0x1b, 0x87, 0xcc, 0xaa, 0x90, 0xb5, 0x6f, 0x05, 0x05, 0x6c, 0x50, 0x43, 0x17, 0x00, 0xd8, + 0xdc, 0xe6, 0xa1, 0x84, 0x55, 0xe6, 0x9f, 0x52, 0xa2, 0x10, 0x2b, 0x08, 0x36, 0xb0, 0xec, 0x1f, + 0x83, 0x74, 0x45, 0x09, 0x34, 0x2e, 0x0b, 0x58, 0x70, 0xff, 0x35, 0xcb, 0x8e, 0x48, 0xd5, 0x9a, + 0xf8, 0x4d, 0x0b, 0xcc, 0xb2, 0x17, 0xe8, 0x35, 0x5e, 0x5f, 0xc3, 0x2a, 0xe2, 0xcc, 0xd1, 0xa0, + 0x3b, 0xb1, 0xe8, 0x84, 0x99, 0xc3, 0x6f, 0x59, 0x64, 0xe3, 0xdc, 0x7b, 0xa1, 0x2a, 0xa1, 0x07, + 0x32, 0xea, 0x3e, 0x0e, 0xa7, 0xb2, 0x77, 0xa9, 0x8b, 0xf3, 0xaa, 0xfd, 0x9d, 0x46, 0xd2, 0x13, + 0x54, 0xea, 0xe6, 0x09, 0xea, 0xe1, 0xce, 0xd8, 0xdf, 0xb2, 0xe0, 0xfc, 0x7e, 0x57, 0xbe, 0xa3, + 0x47, 0xa0, 0xef, 0xb6, 0x13, 0xc9, 0x42, 0xe3, 0x4c, 0x50, 0xde, 0x74, 0x22, 0x1f, 0xb3, 0x56, + 0xb4, 0x03, 0xfd, 0x3c, 0xde, 0x4c, 0x58, 0xeb, 0x2f, 0x16, 0x7b, 0x01, 0xfd, 0x55, 0x62, 0x6c, + 0x17, 0x78, 0xac, 0x1b, 0x16, 0x0c, 0xed, 0xef, 0x5a, 0x80, 0x96, 0xb6, 0x48, 0x14, 0xb9, 0x0d, + 0x23, 0x42, 0x8e, 0x5d, 0x21, 0x63, 0x5c, 0x15, 0x63, 0x26, 0xd1, 0x66, 0xae, 0x90, 0x31, 0xfe, + 0xe5, 0x5f, 0x21, 0x53, 0x3a, 0xd8, 0x15, 0x32, 0x68, 0x09, 0xce, 0xb4, 0xf8, 0x76, 0x83, 0x5f, + 0xcb, 0xc0, 0xf7, 0x1e, 0x2a, 0x65, 0xed, 0xec, 0x9d, 0xdd, 0xf1, 0x33, 0x8b, 0x79, 0x08, 0x38, + 0xff, 0x39, 0xfb, 0xbd, 0x80, 0x78, 0x60, 0xdc, 0x4c, 0x5e, 0x94, 0x53, 0x57, 0xf7, 0x8b, 0xfd, + 0xe5, 0x0a, 0x8c, 0x66, 0xca, 0xd0, 0xd2, 0xad, 0x5e, 0x67, 0x58, 0xd5, 0x91, 0xf5, 0x77, 0x67, + 0xf7, 0x7a, 0x0a, 0xd4, 0xf2, 0xa1, 0xe2, 0xfa, 0x61, 0x3b, 0x29, 0x26, 0x4b, 0x95, 0x77, 0x62, + 0x9e, 0x12, 0x34, 0x1c, 0xcd, 0xf4, 0x2f, 0xe6, 0x6c, 0x8a, 0x0c, 0xfb, 0x4a, 0x19, 0xe3, 0x7d, + 0xf7, 0xc9, 0x1d, 0xf0, 0x49, 0x1d, 0x84, 0x55, 0x29, 0xc2, 0xb1, 0x98, 0x99, 0x2c, 0xc7, 0x7d, + 0x48, 0xff, 0x1b, 0x25, 0x18, 0x34, 0x3e, 0x1a, 0xfa, 0xd5, 0x74, 0x51, 0x28, 0xab, 0xb8, 0x57, + 0x62, 0xf4, 0x27, 0x74, 0xd9, 0x27, 0xfe, 0x4a, 0x4f, 0x74, 0xd6, 0x83, 0xba, 0xbb, 0x3b, 0x7e, + 0x22, 0x53, 0xf1, 0x29, 0x55, 0x23, 0xea, 0xdc, 0xc7, 0x60, 0x34, 0x43, 0x26, 0xe7, 0x95, 0x57, + 0xd3, 0x57, 0xe5, 0x1f, 0xd1, 0x2d, 0x65, 0x0e, 0xd9, 0x37, 0xe8, 0x90, 0x89, 0x44, 0xbd, 0xc0, + 0x23, 0x3d, 0xf8, 0x60, 0x33, 0xf9, 0xb8, 0xa5, 0x1e, 0xf3, 0x71, 0x9f, 0x84, 0x6a, 0x18, 0x78, + 0x6e, 0xdd, 0x55, 0x95, 0x17, 0x59, 0x06, 0xf0, 0xb2, 0x68, 0xc3, 0x0a, 0x8a, 0x6e, 0x43, 0xed, + 0xd6, 0xed, 0x84, 0x9f, 0x1b, 0x09, 0xff, 0x76, 0x51, 0xc7, 0x45, 0xca, 0x68, 0x51, 0x07, 0x53, + 0x58, 0xf3, 0x42, 0x36, 0xf4, 0x33, 0x25, 0x28, 0x93, 0x0b, 0x98, 0xef, 0x9d, 0x69, 0xc7, 0x18, + 0x0b, 0x88, 0xfd, 0xb5, 0x1a, 0x9c, 0xce, 0xab, 0x05, 0x8e, 0x3e, 0x0a, 0xfd, 0xbc, 0x8f, 0xc5, + 0x5c, 0x37, 0x91, 0xc7, 0x63, 0x8e, 0x11, 0x14, 0xdd, 0x62, 0xbf, 0xb1, 0xe0, 0x29, 0xb8, 0x7b, + 0xce, 0x9a, 0x98, 0x21, 0xc7, 0xc3, 0x7d, 0xc1, 0xd1, 0xdc, 0x17, 0x1c, 0xce, 0xdd, 0x73, 0xd6, + 0xd0, 0x36, 0x54, 0x9a, 0x6e, 0x42, 0x1c, 0xe1, 0x44, 0xb8, 0x79, 0x2c, 0xcc, 0x89, 0xc3, 0xad, + 0x34, 0xf6, 0x13, 0x73, 0x86, 0xe8, 0xab, 0x16, 0x8c, 0xae, 0xa5, 0x93, 0xef, 0x85, 0xf0, 0x74, + 0x8e, 0xa1, 0xde, 0x7b, 0x9a, 0x11, 0xbf, 0x43, 0x29, 0xd3, 0x88, 0xb3, 0xdd, 0x41, 0x9f, 0xb2, + 0x60, 0x60, 0xdd, 0xf5, 0x8c, 0xd2, 0xbf, 0xc7, 0xf0, 0x71, 0x2e, 0x31, 0x06, 0x7a, 0xc7, 0xc1, + 0xff, 0xc7, 0x58, 0x72, 0xee, 0xa6, 0xa9, 0xfa, 0x8f, 0xaa, 0xa9, 0x06, 0xee, 0x93, 0xa6, 0xfa, + 0x8c, 0x05, 0x35, 0x35, 0xd2, 0x22, 0xa1, 0xfa, 0xc3, 0xc7, 0xf8, 0xc9, 0xb9, 0xe7, 0x44, 0xfd, + 0xc5, 0x9a, 0x39, 0xfa, 0xa2, 0x05, 0x83, 0xce, 0xeb, 0xed, 0x88, 0x34, 0xc8, 0x56, 0x10, 0xc6, + 0xe2, 0x02, 0xc6, 0x97, 0x8b, 0xef, 0xcc, 0x14, 0x65, 0x32, 0x4b, 0xb6, 0x96, 0xc2, 0x58, 0x24, + 0x3e, 0xe9, 0x06, 0x6c, 0x76, 0xc1, 0xde, 0x2d, 0xc1, 0xf8, 0x3e, 0x14, 0xd0, 0xf3, 0x30, 0x14, + 0x44, 0x4d, 0xc7, 0x77, 0x5f, 0x37, 0xab, 0x69, 0x28, 0x2b, 0x6b, 0xc9, 0x80, 0xe1, 0x14, 0xa6, + 0x99, 0xf2, 0x5d, 0xda, 0x27, 0xe5, 0xfb, 0x3c, 0xf4, 0x45, 0x24, 0x0c, 0xb2, 0x9b, 0x05, 0x96, + 0x74, 0xc0, 0x20, 0xe8, 0x51, 0x28, 0x3b, 0xa1, 0x2b, 0x42, 0xd8, 0xd4, 0x1e, 0x68, 0x6a, 0x79, + 0x1e, 0xd3, 0xf6, 0x54, 0x05, 0x8a, 0xca, 0x3d, 0xa9, 0x40, 0x41, 0xd5, 0x80, 0x38, 0xbb, 0xe8, + 0xd7, 0x6a, 0x20, 0x7d, 0xa6, 0x60, 0xbf, 0x55, 0x86, 0x47, 0xf7, 0x9c, 0x2f, 0x3a, 0x82, 0xcf, + 0xda, 0x23, 0x82, 0x4f, 0x0e, 0x4f, 0x69, 0xbf, 0xe1, 0x29, 0x77, 0x19, 0x9e, 0x4f, 0xd1, 0x65, + 0x20, 0xab, 0x90, 0x14, 0x73, 0x85, 0x5e, 0xb7, 0xa2, 0x26, 0x62, 0x05, 0x48, 0x28, 0xd6, 0x7c, + 0xe9, 0x1e, 0x20, 0x95, 0xee, 0x5c, 0x29, 0x42, 0x0d, 0x74, 0xad, 0x4a, 0xc2, 0xe7, 0x7e, 0xb7, + 0x1c, 0x6a, 0xfb, 0x97, 0x4a, 0xf0, 0x78, 0x0f, 0xd2, 0xdb, 0x9c, 0xc5, 0x56, 0x8f, 0xb3, 0xf8, + 0xfb, 0xfb, 0x33, 0xd9, 0x7f, 0xd3, 0x82, 0x73, 0xdd, 0x95, 0x07, 0x7a, 0x06, 0x06, 0xd7, 0x22, + 0xc7, 0xaf, 0x6f, 0xb0, 0x6b, 0x41, 0xe5, 0xa0, 0xb0, 0xb1, 0xd6, 0xcd, 0xd8, 0xc4, 0xa1, 0xdb, + 0x5b, 0x1e, 0x93, 0x60, 0x60, 0xc8, 0xf4, 0x54, 0xba, 0xbd, 0x5d, 0xcd, 0x02, 0x71, 0x27, 0xbe, + 0xfd, 0x97, 0xa5, 0xfc, 0x6e, 0x71, 0x23, 0xe3, 0x20, 0xdf, 0x49, 0x7c, 0x85, 0x52, 0x0f, 0xb2, + 0xa4, 0x7c, 0xaf, 0x65, 0x49, 0x5f, 0x37, 0x59, 0x82, 0x66, 0xe1, 0x84, 0x71, 0x6d, 0x0c, 0x4f, + 0x39, 0xe6, 0xa1, 0xba, 0xaa, 0x0e, 0xc7, 0x72, 0x06, 0x8e, 0x3b, 0x9e, 0x40, 0x4f, 0x41, 0xd5, + 0xf5, 0x63, 0x52, 0x6f, 0x47, 0x3c, 0x44, 0xdc, 0x48, 0xf3, 0x9a, 0x17, 0xed, 0x58, 0x61, 0xd8, + 0xbf, 0x56, 0x82, 0xb3, 0x5d, 0xed, 0xac, 0x7b, 0x24, 0xbb, 0xcc, 0xcf, 0xd1, 0x77, 0x6f, 0x3e, + 0x87, 0x39, 0x48, 0x95, 0x7d, 0x07, 0xe9, 0x4f, 0xba, 0x4f, 0x4c, 0x6a, 0x73, 0xff, 0xc0, 0x8e, + 0xd2, 0x0b, 0x30, 0xec, 0x84, 0x21, 0xc7, 0x63, 0x91, 0x9e, 0x99, 0x3a, 0x3c, 0x53, 0x26, 0x10, + 0xa7, 0x71, 0x7b, 0xd2, 0x9e, 0x7f, 0x66, 0x41, 0x0d, 0x93, 0x75, 0x2e, 0x1d, 0xd0, 0x2d, 0x31, + 0x44, 0x56, 0x11, 0x15, 0x3b, 0xe9, 0xc0, 0xc6, 0x2e, 0xab, 0x64, 0x99, 0x37, 0xd8, 0x9d, 0xd7, + 0x0b, 0x95, 0x0e, 0x74, 0xbd, 0x90, 0xba, 0x60, 0xa6, 0xdc, 0xfd, 0x82, 0x19, 0xfb, 0x1b, 0x03, + 0xf4, 0xf5, 0xc2, 0x60, 0x26, 0x22, 0x8d, 0x98, 0x7e, 0xdf, 0x76, 0xe4, 0x89, 0x49, 0xa2, 0xbe, + 0xef, 0x75, 0xbc, 0x80, 0x69, 0x7b, 0xea, 0x28, 0xa6, 0x74, 0xa0, 0x2a, 0x24, 0xe5, 0x7d, 0xab, + 0x90, 0xbc, 0x00, 0xc3, 0x71, 0xbc, 0xb1, 0x1c, 0xb9, 0x5b, 0x4e, 0x42, 0xae, 0x92, 0x1d, 0x61, + 0x65, 0xe9, 0xca, 0x01, 0x2b, 0x97, 0x35, 0x10, 0xa7, 0x71, 0xd1, 0x1c, 0x9c, 0xd4, 0xb5, 0x40, + 0x48, 0x94, 0xb0, 0xbc, 0x00, 0x3e, 0x13, 0x54, 0x9a, 0xb0, 0xae, 0x1e, 0x22, 0x10, 0x70, 0xe7, + 0x33, 0x54, 0xbe, 0xa5, 0x1a, 0x69, 0x47, 0xfa, 0xd3, 0xf2, 0x2d, 0x45, 0x87, 0xf6, 0xa5, 0xe3, + 0x09, 0xb4, 0x08, 0xa7, 0xf8, 0xc4, 0x98, 0x0a, 0x43, 0xe3, 0x8d, 0x06, 0xd2, 0x95, 0x12, 0xe7, + 0x3a, 0x51, 0x70, 0xde, 0x73, 0xe8, 0x39, 0x18, 0x54, 0xcd, 0xf3, 0xb3, 0xe2, 0x14, 0x41, 0x79, + 0x31, 0x14, 0x99, 0xf9, 0x06, 0x36, 0xf1, 0xd0, 0x87, 0xe0, 0x61, 0xfd, 0x97, 0x27, 0x8f, 0xf1, + 0xa3, 0xb5, 0x59, 0x51, 0x66, 0x49, 0x5d, 0x67, 0x32, 0x97, 0x8b, 0xd6, 0xc0, 0xdd, 0x9e, 0x47, + 0x6b, 0x70, 0x4e, 0x81, 0x2e, 0xfa, 0x09, 0xcb, 0x04, 0x89, 0xc9, 0xb4, 0x13, 0x93, 0xeb, 0x91, + 0x27, 0x6e, 0x01, 0x50, 0x37, 0x4d, 0xce, 0xb9, 0xc9, 0xe5, 0x3c, 0x4c, 0xbc, 0x80, 0xf7, 0xa0, + 0x82, 0x26, 0xa1, 0x46, 0x7c, 0x67, 0xcd, 0x23, 0x4b, 0x33, 0xf3, 0xe2, 0x5e, 0x00, 0x1d, 0xd9, + 0x2b, 0x01, 0x58, 0xe3, 0xa8, 0xd8, 0xd4, 0xa1, 0xae, 0xb7, 0x9e, 0x2e, 0xc3, 0xe9, 0x66, 0x3d, + 0xa4, 0xb6, 0x87, 0x5b, 0x27, 0x53, 0x75, 0x16, 0x50, 0x47, 0x3f, 0x0c, 0x2f, 0x61, 0xa9, 0x02, + 0xaf, 0xe7, 0x66, 0x96, 0x3b, 0x70, 0x70, 0xee, 0x93, 0x2c, 0xf0, 0x32, 0x0a, 0xb6, 0x77, 0xc6, + 0x4e, 0x65, 0x02, 0x2f, 0x69, 0x23, 0xe6, 0x30, 0x74, 0x05, 0x10, 0x8b, 0xe2, 0xbf, 0x9c, 0x24, + 0xa1, 0x32, 0x76, 0xc6, 0x4e, 0xb3, 0x57, 0x52, 0x61, 0x64, 0x97, 0x3a, 0x30, 0x70, 0xce, 0x53, + 0xf6, 0xbf, 0xb7, 0x60, 0x58, 0xad, 0xd7, 0x7b, 0x90, 0xc7, 0xe2, 0xa5, 0xf3, 0x58, 0xe6, 0x8e, + 0x2e, 0xf1, 0x58, 0xcf, 0xbb, 0x04, 0x43, 0xff, 0xfc, 0x20, 0x80, 0x96, 0x8a, 0x4a, 0x21, 0x59, + 0x5d, 0x15, 0xd2, 0x03, 0x2b, 0x91, 0xf2, 0x6a, 0xb3, 0x54, 0xee, 0x6f, 0x6d, 0x96, 0x15, 0x38, + 0x23, 0xcd, 0x05, 0x7e, 0x56, 0x74, 0x39, 0x88, 0x95, 0x80, 0xab, 0x4e, 0x3f, 0x2a, 0x08, 0x9d, + 0x99, 0xcf, 0x43, 0xc2, 0xf9, 0xcf, 0xa6, 0xac, 0x94, 0x81, 0xfd, 0xac, 0x14, 0xbd, 0xa6, 0x17, + 0xd6, 0xe5, 0xbd, 0x25, 0x99, 0x35, 0xbd, 0x70, 0x69, 0x05, 0x6b, 0x9c, 0x7c, 0xc1, 0x5e, 0x2b, + 0x48, 0xb0, 0xc3, 0x81, 0x05, 0xbb, 0x14, 0x31, 0x83, 0x5d, 0x45, 0x8c, 0xf4, 0x49, 0x0f, 0x75, + 0xf5, 0x49, 0xbf, 0x1f, 0x46, 0x5c, 0x7f, 0x83, 0x44, 0x6e, 0x42, 0x1a, 0x6c, 0x2d, 0x30, 0xf1, + 0x63, 0x5c, 0xb8, 0x32, 0x9f, 0x82, 0xe2, 0x0c, 0x76, 0x5a, 0x2e, 0x8e, 0xf4, 0x20, 0x17, 0xbb, + 0x68, 0xa3, 0xd1, 0x62, 0xb4, 0xd1, 0x89, 0xa3, 0x6b, 0xa3, 0x93, 0xc7, 0xaa, 0x8d, 0x50, 0x21, + 0xda, 0xa8, 0x27, 0x41, 0x6f, 0x6c, 0xff, 0x4e, 0xef, 0xb3, 0xfd, 0xeb, 0xa6, 0x8a, 0xce, 0x1c, + 0x5a, 0x15, 0xe5, 0x6b, 0x99, 0x87, 0x0e, 0xa5, 0x65, 0x3e, 0x53, 0x82, 0x33, 0x5a, 0x0e, 0xd3, + 0xd9, 0xef, 0xae, 0x53, 0x49, 0xc4, 0xae, 0xbe, 0xe2, 0xe7, 0x36, 0x46, 0x5a, 0x95, 0xce, 0xd0, + 0x52, 0x10, 0x6c, 0x60, 0xb1, 0xec, 0x24, 0x12, 0xb1, 0x42, 0xbd, 0x59, 0x21, 0x3d, 0x23, 0xda, + 0xb1, 0xc2, 0xa0, 0xf3, 0x8b, 0xfe, 0x16, 0x19, 0x9f, 0xd9, 0x72, 0x74, 0x33, 0x1a, 0x84, 0x4d, + 0x3c, 0xf4, 0x24, 0x67, 0xc2, 0x04, 0x04, 0x15, 0xd4, 0x43, 0xe2, 0x2e, 0x5c, 0x29, 0x13, 0x14, + 0x54, 0x76, 0x87, 0xa5, 0xa1, 0x55, 0x3a, 0xbb, 0xc3, 0x42, 0xa0, 0x14, 0x86, 0xfd, 0x3f, 0x2c, + 0x38, 0x9b, 0x3b, 0x14, 0xf7, 0x40, 0xf9, 0x6e, 0xa7, 0x95, 0xef, 0x4a, 0x51, 0xdb, 0x0d, 0xe3, + 0x2d, 0xba, 0x28, 0xe2, 0x7f, 0x6b, 0xc1, 0x88, 0xc6, 0xbf, 0x07, 0xaf, 0xea, 0xa6, 0x5f, 0xb5, + 0xb8, 0x9d, 0x55, 0xad, 0xe3, 0xdd, 0x7e, 0xaf, 0x04, 0xaa, 0x44, 0xe4, 0x54, 0x5d, 0x16, 0xe0, + 0xdd, 0xe7, 0x24, 0x71, 0x07, 0xfa, 0xd9, 0x41, 0x68, 0x5c, 0x4c, 0x90, 0x47, 0x9a, 0x3f, 0x3b, + 0x54, 0xd5, 0x87, 0xcc, 0xec, 0x6f, 0x8c, 0x05, 0x43, 0x56, 0x46, 0xda, 0x8d, 0xa9, 0x34, 0x6f, + 0x88, 0x3c, 0x22, 0x5d, 0x46, 0x5a, 0xb4, 0x63, 0x85, 0x41, 0xd5, 0x83, 0x5b, 0x0f, 0xfc, 0x19, + 0xcf, 0x89, 0xe5, 0x7d, 0x8f, 0x4a, 0x3d, 0xcc, 0x4b, 0x00, 0xd6, 0x38, 0xec, 0x8c, 0xd4, 0x8d, + 0x43, 0xcf, 0xd9, 0x31, 0xf6, 0xcf, 0x46, 0x65, 0x03, 0x05, 0xc2, 0x26, 0x9e, 0xdd, 0x82, 0xb1, + 0xf4, 0x4b, 0xcc, 0x92, 0x75, 0x16, 0xa0, 0xd8, 0xd3, 0x70, 0x4e, 0x42, 0xcd, 0x61, 0x4f, 0x2d, + 0xb4, 0x9d, 0xec, 0x35, 0xed, 0x53, 0x12, 0x80, 0x35, 0x8e, 0xfd, 0xeb, 0x16, 0x9c, 0xca, 0x19, + 0xb4, 0x02, 0x13, 0xe6, 0x12, 0x2d, 0x6d, 0xf2, 0x14, 0xfb, 0x8f, 0xc2, 0x40, 0x83, 0xac, 0x3b, + 0x32, 0x04, 0xce, 0x90, 0xed, 0xb3, 0xbc, 0x19, 0x4b, 0xb8, 0xfd, 0xdf, 0x2c, 0x18, 0x4d, 0xf7, + 0x35, 0x66, 0xa9, 0x24, 0x7c, 0x98, 0xdc, 0xb8, 0x1e, 0x6c, 0x91, 0x68, 0x87, 0xbe, 0xb9, 0x95, + 0x49, 0x25, 0xe9, 0xc0, 0xc0, 0x39, 0x4f, 0xb1, 0x02, 0xb1, 0x0d, 0x35, 0xda, 0x72, 0x46, 0xde, + 0x28, 0x72, 0x46, 0xea, 0x8f, 0x69, 0x1e, 0x97, 0x2b, 0x96, 0xd8, 0xe4, 0x6f, 0x7f, 0xb7, 0x0f, + 0x54, 0x46, 0x2d, 0x8b, 0x3f, 0x2a, 0x28, 0x7a, 0xeb, 0xa0, 0x19, 0x44, 0x6a, 0x32, 0xf4, 0xed, + 0x15, 0x10, 0xc0, 0xbd, 0x24, 0xa6, 0xeb, 0x52, 0xbd, 0xe1, 0xaa, 0x06, 0x61, 0x13, 0x8f, 0xf6, + 0xc4, 0x73, 0xb7, 0x08, 0x7f, 0xa8, 0x3f, 0xdd, 0x93, 0x05, 0x09, 0xc0, 0x1a, 0x87, 0xf6, 0xa4, + 0xe1, 0xae, 0xaf, 0x8b, 0x2d, 0xbf, 0xea, 0x09, 0x1d, 0x1d, 0xcc, 0x20, 0xbc, 0xe6, 0x77, 0xb0, + 0x29, 0xac, 0x60, 0xa3, 0xe6, 0x77, 0xb0, 0x89, 0x19, 0x84, 0xda, 0x6d, 0x7e, 0x10, 0xb5, 0xd8, + 0x35, 0xfa, 0x0d, 0xc5, 0x45, 0x58, 0xbf, 0xca, 0x6e, 0xbb, 0xd6, 0x89, 0x82, 0xf3, 0x9e, 0xa3, + 0x33, 0x30, 0x8c, 0x48, 0xc3, 0xad, 0x27, 0x26, 0x35, 0x48, 0xcf, 0xc0, 0xe5, 0x0e, 0x0c, 0x9c, + 0xf3, 0x14, 0x9a, 0x82, 0x51, 0x99, 0x11, 0x2d, 0xeb, 0xdd, 0x0c, 0xa6, 0xeb, 0x6b, 0xe0, 0x34, + 0x18, 0x67, 0xf1, 0xa9, 0x54, 0x6b, 0x89, 0x92, 0x58, 0xcc, 0x58, 0x36, 0xa4, 0x9a, 0x2c, 0x95, + 0x85, 0x15, 0x86, 0xfd, 0xc9, 0x32, 0xd5, 0xc2, 0x5d, 0x4a, 0xc1, 0xdd, 0xb3, 0x68, 0xc1, 0xf4, + 0x8c, 0xec, 0xeb, 0x61, 0x46, 0x3e, 0x0b, 0x43, 0xb7, 0xe2, 0xc0, 0x57, 0x91, 0x78, 0x95, 0xae, + 0x91, 0x78, 0x06, 0x56, 0x7e, 0x24, 0x5e, 0x7f, 0x51, 0x91, 0x78, 0x03, 0x87, 0x8c, 0xc4, 0xfb, + 0x76, 0x05, 0xd4, 0xe5, 0x23, 0xd7, 0x48, 0x72, 0x3b, 0x88, 0x36, 0x5d, 0xbf, 0xc9, 0x32, 0xc9, + 0xbf, 0x6a, 0xc1, 0x10, 0x5f, 0x2f, 0x0b, 0x66, 0x26, 0xd5, 0x7a, 0x41, 0xb7, 0x5a, 0xa4, 0x98, + 0x4d, 0xac, 0x1a, 0x8c, 0x32, 0xd7, 0x8d, 0x9a, 0x20, 0x9c, 0xea, 0x11, 0xfa, 0x18, 0x80, 0xf4, + 0x8f, 0xae, 0x4b, 0x91, 0x39, 0x5f, 0x4c, 0xff, 0x30, 0x59, 0xd7, 0x36, 0xf0, 0xaa, 0x62, 0x82, + 0x0d, 0x86, 0xe8, 0x33, 0x3a, 0xcb, 0x8c, 0x87, 0xec, 0x7f, 0xe4, 0x58, 0xc6, 0xa6, 0x97, 0x1c, + 0x33, 0x0c, 0x03, 0xae, 0xdf, 0xa4, 0xf3, 0x44, 0x44, 0x2c, 0xbd, 0x2b, 0xaf, 0x0a, 0xc3, 0x42, + 0xe0, 0x34, 0xa6, 0x1d, 0xcf, 0xf1, 0xeb, 0x24, 0x9a, 0xe7, 0xe8, 0xe6, 0x25, 0xdb, 0xac, 0x01, + 0x4b, 0x42, 0x1d, 0xd7, 0xb6, 0x54, 0x7a, 0xb9, 0xb6, 0xe5, 0xdc, 0x07, 0xe0, 0x64, 0xc7, 0xc7, + 0x3c, 0x50, 0x4a, 0xd9, 0xe1, 0xb3, 0xd1, 0xec, 0xdf, 0xaf, 0x69, 0xa5, 0x75, 0x2d, 0x68, 0xf0, + 0xcb, 0x43, 0x22, 0xfd, 0x45, 0x85, 0x8d, 0x5b, 0xe0, 0x14, 0x31, 0x2e, 0xea, 0x56, 0x8d, 0xd8, + 0x64, 0x49, 0xe7, 0x68, 0xe8, 0x44, 0xc4, 0x3f, 0xee, 0x39, 0xba, 0xac, 0x98, 0x60, 0x83, 0x21, + 0xda, 0x48, 0xe5, 0x94, 0x5c, 0x3a, 0x7a, 0x4e, 0x09, 0xab, 0x4f, 0x95, 0x57, 0xef, 0xff, 0x8b, + 0x16, 0x8c, 0xf8, 0xa9, 0x99, 0x5b, 0x4c, 0x18, 0x69, 0xfe, 0xaa, 0xe0, 0x77, 0x57, 0xa5, 0xdb, + 0x70, 0x86, 0x7f, 0x9e, 0x4a, 0xab, 0x1c, 0x50, 0xa5, 0xe9, 0x5b, 0x88, 0xfa, 0xbb, 0xdd, 0x42, + 0x84, 0x7c, 0x75, 0x0d, 0xdb, 0x40, 0xe1, 0xd7, 0xb0, 0x41, 0xce, 0x15, 0x6c, 0x37, 0xa1, 0x56, + 0x8f, 0x88, 0x93, 0x1c, 0xf2, 0x46, 0x2e, 0x76, 0x40, 0x3f, 0x23, 0x09, 0x60, 0x4d, 0x0b, 0x7d, + 0x5c, 0xc9, 0xb3, 0x5a, 0x91, 0xe6, 0x27, 0x5d, 0x8a, 0x3d, 0x49, 0xb1, 0x37, 0x33, 0x99, 0xb2, + 0x50, 0x44, 0x42, 0x63, 0xaa, 0x17, 0xdf, 0x5f, 0xd9, 0xb1, 0xff, 0xbb, 0x0f, 0x4e, 0xc8, 0xee, + 0xcb, 0x94, 0x00, 0x6a, 0xaf, 0xf0, 0x79, 0xa0, 0x37, 0x1b, 0xca, 0x5e, 0xb9, 0x2c, 0x01, 0x58, + 0xe3, 0x50, 0xfb, 0xb8, 0x1d, 0x93, 0xa5, 0x90, 0xf8, 0x0b, 0xee, 0x5a, 0x2c, 0xce, 0x9d, 0xd5, + 0x7b, 0x5f, 0xd7, 0x20, 0x6c, 0xe2, 0xd1, 0xcd, 0x11, 0xdf, 0xa7, 0xc4, 0xd9, 0x74, 0x22, 0xb1, + 0xff, 0xc1, 0x12, 0x8e, 0x7e, 0x39, 0xb7, 0x56, 0x70, 0x31, 0x89, 0x74, 0x1d, 0x99, 0x10, 0x07, + 0xbc, 0x54, 0xf3, 0xef, 0x5a, 0x70, 0x86, 0xb7, 0xca, 0x91, 0xbc, 0x1e, 0x36, 0x9c, 0x84, 0xc4, + 0xc5, 0xd4, 0xee, 0xcf, 0xe9, 0x9f, 0x76, 0xba, 0xe7, 0xb1, 0xc5, 0xf9, 0xbd, 0x41, 0x6f, 0x58, + 0x30, 0xba, 0x99, 0xaa, 0xde, 0x22, 0x55, 0xf9, 0x51, 0xcb, 0x23, 0xa4, 0x88, 0x6a, 0xd1, 0x97, + 0x6e, 0x8f, 0x71, 0x96, 0xbb, 0xfd, 0x97, 0x16, 0x98, 0x6a, 0xed, 0xde, 0x17, 0x7d, 0x39, 0xb8, + 0x69, 0x2e, 0xad, 0xfd, 0x4a, 0x57, 0x6b, 0xff, 0x51, 0x28, 0xb7, 0xdd, 0x86, 0xd8, 0xef, 0xe9, + 0xd3, 0xf0, 0xf9, 0x59, 0x4c, 0xdb, 0xed, 0x7f, 0x5e, 0xd1, 0x7e, 0x24, 0x91, 0xa7, 0xf6, 0x03, + 0xf1, 0xda, 0xeb, 0xaa, 0x6c, 0x1c, 0x7f, 0xf3, 0x6b, 0x1d, 0x65, 0xe3, 0x7e, 0xe2, 0xe0, 0x69, + 0x88, 0x7c, 0x80, 0xba, 0x55, 0x8d, 0x1b, 0xd8, 0x27, 0x07, 0xf1, 0x16, 0x54, 0xe9, 0x96, 0x98, + 0x39, 0x84, 0xab, 0xa9, 0x4e, 0x55, 0x2f, 0x8b, 0xf6, 0xbb, 0xbb, 0xe3, 0xef, 0x3b, 0x78, 0xb7, + 0xe4, 0xd3, 0x58, 0xd1, 0x47, 0x31, 0xd4, 0xe8, 0x6f, 0x96, 0x2e, 0x29, 0x36, 0xdb, 0xd7, 0x95, + 0xcc, 0x94, 0x80, 0x42, 0x72, 0x31, 0x35, 0x1f, 0xe4, 0x43, 0x8d, 0xdd, 0x3f, 0xcc, 0x98, 0xf2, + 0x3d, 0xf9, 0xb2, 0x4a, 0x5a, 0x94, 0x80, 0xbb, 0xbb, 0xe3, 0x2f, 0x1c, 0x9c, 0xa9, 0x7a, 0x1c, + 0x6b, 0x16, 0xf6, 0x9b, 0x7d, 0x7a, 0xee, 0x8a, 0x6a, 0x81, 0x3f, 0x10, 0x73, 0xf7, 0xf9, 0xcc, + 0xdc, 0x3d, 0xdf, 0x31, 0x77, 0x47, 0xf4, 0x3d, 0xb9, 0xa9, 0xd9, 0x78, 0xaf, 0x0d, 0xb3, 0xfd, + 0xfd, 0x3f, 0xcc, 0x22, 0x7d, 0xad, 0xed, 0x46, 0x24, 0x5e, 0x8e, 0xda, 0xbe, 0xeb, 0x37, 0xd9, + 0x74, 0xac, 0x9a, 0x16, 0x69, 0x0a, 0x8c, 0xb3, 0xf8, 0xe8, 0x29, 0xa8, 0xd2, 0x6f, 0x7e, 0xd3, + 0xd9, 0xe2, 0xb3, 0xca, 0x28, 0xa0, 0xb6, 0x22, 0xda, 0xb1, 0xc2, 0xb0, 0xbf, 0xc1, 0x62, 0x0b, + 0x8c, 0x3c, 0x6d, 0x3a, 0x27, 0x3c, 0x76, 0xe1, 0x33, 0xaf, 0xbe, 0xa6, 0xe6, 0x04, 0xbf, 0xe5, + 0x99, 0xc3, 0xd0, 0x6d, 0x18, 0x58, 0xe3, 0x37, 0x1e, 0x16, 0x53, 0x91, 0x5e, 0x5c, 0x9f, 0xc8, + 0xee, 0xb5, 0x91, 0x77, 0x29, 0xde, 0xd5, 0x3f, 0xb1, 0xe4, 0x66, 0xff, 0x51, 0x05, 0x46, 0x33, + 0x57, 0x02, 0xa7, 0xea, 0xde, 0x96, 0xf6, 0xad, 0x7b, 0xfb, 0x0a, 0x40, 0x83, 0x84, 0x5e, 0xb0, + 0xc3, 0xcc, 0xe3, 0xbe, 0x03, 0x9b, 0xc7, 0x6a, 0x47, 0x35, 0xab, 0xa8, 0x60, 0x83, 0xa2, 0x28, + 0x39, 0xc7, 0xcb, 0xe8, 0x66, 0x4a, 0xce, 0x19, 0xf7, 0x56, 0xf4, 0xdf, 0xdb, 0x7b, 0x2b, 0x5c, + 0x18, 0xe5, 0x5d, 0x54, 0xd9, 0xd0, 0x87, 0x48, 0x7a, 0x66, 0xf9, 0x24, 0xb3, 0x69, 0x32, 0x38, + 0x4b, 0xf7, 0x7e, 0xde, 0xf8, 0x8d, 0xde, 0x0d, 0x35, 0xf9, 0x9d, 0xf9, 0x1e, 0x45, 0x54, 0x94, + 0x90, 0xd3, 0x80, 0xdd, 0xc4, 0x2d, 0x7e, 0x76, 0x14, 0x76, 0x80, 0xfb, 0x55, 0xd8, 0xc1, 0xfe, + 0x42, 0x89, 0xda, 0xf1, 0xbc, 0x5f, 0xaa, 0x46, 0xd1, 0x13, 0xd0, 0xef, 0xb4, 0x93, 0x8d, 0xa0, + 0xe3, 0xfe, 0xc6, 0x29, 0xd6, 0x8a, 0x05, 0x14, 0x2d, 0x40, 0x5f, 0x43, 0xd7, 0x9d, 0x39, 0xc8, + 0xf7, 0xd4, 0x2e, 0x6a, 0x27, 0x21, 0x98, 0x51, 0x41, 0x8f, 0x40, 0x5f, 0xe2, 0x34, 0x65, 0x0a, + 0x1c, 0x4b, 0x7b, 0x5e, 0x75, 0x9a, 0x31, 0x66, 0xad, 0xa6, 0xfa, 0xee, 0xdb, 0x47, 0x7d, 0xbf, + 0x00, 0xc3, 0xb1, 0xdb, 0xf4, 0x9d, 0xa4, 0x1d, 0x11, 0xe3, 0xd8, 0x55, 0x47, 0xd2, 0x98, 0x40, + 0x9c, 0xc6, 0xb5, 0x7f, 0x7b, 0x08, 0x4e, 0xaf, 0xcc, 0x2c, 0xca, 0x3a, 0xec, 0xc7, 0x96, 0xc5, + 0x96, 0xc7, 0xe3, 0xde, 0x65, 0xb1, 0x75, 0xe1, 0xee, 0x19, 0x59, 0x6c, 0x9e, 0x91, 0xc5, 0x96, + 0x4e, 0x29, 0x2a, 0x17, 0x91, 0x52, 0x94, 0xd7, 0x83, 0x5e, 0x52, 0x8a, 0x8e, 0x2d, 0xad, 0x6d, + 0xcf, 0x0e, 0x1d, 0x28, 0xad, 0x4d, 0xe5, 0xfc, 0x15, 0x92, 0xec, 0xd1, 0xe5, 0x53, 0xe5, 0xe6, + 0xfc, 0xa9, 0x7c, 0x2b, 0x9e, 0xc8, 0x24, 0x44, 0xfd, 0xcb, 0xc5, 0x77, 0xa0, 0x87, 0x7c, 0x2b, + 0x91, 0x4b, 0x65, 0xe6, 0xf8, 0x0d, 0x14, 0x91, 0xe3, 0x97, 0xd7, 0x9d, 0x7d, 0x73, 0xfc, 0x5e, + 0x80, 0xe1, 0xba, 0x17, 0xf8, 0x64, 0x39, 0x0a, 0x92, 0xa0, 0x1e, 0x78, 0xc2, 0xac, 0x57, 0x22, + 0x61, 0xc6, 0x04, 0xe2, 0x34, 0x6e, 0xb7, 0x04, 0xc1, 0xda, 0x51, 0x13, 0x04, 0xe1, 0x3e, 0x25, + 0x08, 0xfe, 0x82, 0x4e, 0x65, 0x1f, 0x64, 0x5f, 0xe4, 0x95, 0xe2, 0xbf, 0x48, 0x2f, 0xf9, 0xec, + 0xe8, 0x2d, 0x7e, 0x81, 0x22, 0x35, 0x8c, 0x67, 0x82, 0x16, 0x35, 0xfc, 0x86, 0xd8, 0x90, 0xbc, + 0x7a, 0x0c, 0x13, 0xf6, 0xe6, 0x8a, 0x66, 0xa3, 0x2e, 0x55, 0xd4, 0x4d, 0x38, 0xdd, 0x91, 0xa3, + 0xa4, 0xda, 0x7f, 0xb9, 0x04, 0x3f, 0xb4, 0x6f, 0x17, 0xd0, 0x6d, 0x80, 0xc4, 0x69, 0x8a, 0x89, + 0x2a, 0x0e, 0xb0, 0x8e, 0x18, 0xee, 0xba, 0x2a, 0xe9, 0xf1, 0x1a, 0x31, 0xea, 0x2f, 0x3b, 0x1a, + 0x92, 0xbf, 0x59, 0x94, 0x6b, 0xe0, 0x75, 0x94, 0xd2, 0xc4, 0x81, 0x47, 0x30, 0x83, 0x50, 0xf5, + 0x1f, 0x91, 0xa6, 0xbe, 0xf1, 0x5b, 0x7d, 0x3e, 0xcc, 0x5a, 0xb1, 0x80, 0xa2, 0xe7, 0x60, 0xd0, + 0xf1, 0x3c, 0x9e, 0xaf, 0x44, 0x62, 0x71, 0x83, 0x92, 0xf6, 0x5a, 0x6a, 0x10, 0x36, 0xf1, 0xec, + 0xbf, 0x28, 0xc1, 0xf8, 0x3e, 0x32, 0xa5, 0x23, 0x03, 0xb3, 0xd2, 0x73, 0x06, 0xa6, 0xc8, 0x19, + 0xe9, 0xef, 0x92, 0x33, 0xf2, 0x1c, 0x0c, 0x26, 0xc4, 0x69, 0x89, 0x00, 0x39, 0xe1, 0x09, 0xd0, + 0x27, 0xf2, 0x1a, 0x84, 0x4d, 0x3c, 0x2a, 0xc5, 0x46, 0x9c, 0x7a, 0x9d, 0xc4, 0xb1, 0x4c, 0x0a, + 0x11, 0xde, 0xed, 0xc2, 0x32, 0x4e, 0xd8, 0xa1, 0xc1, 0x54, 0x8a, 0x05, 0xce, 0xb0, 0xcc, 0x0e, + 0x78, 0xad, 0xc7, 0x01, 0xff, 0x5a, 0x09, 0x1e, 0xdd, 0x53, 0xbb, 0xf5, 0x9c, 0xaf, 0xd3, 0x8e, + 0x49, 0x94, 0x9d, 0x38, 0xd7, 0x63, 0x12, 0x61, 0x06, 0xe1, 0xa3, 0x14, 0x86, 0xc6, 0x8d, 0xea, + 0x45, 0x27, 0x93, 0xf1, 0x51, 0x4a, 0xb1, 0xc0, 0x19, 0x96, 0x87, 0x9d, 0x96, 0xff, 0xb0, 0x04, + 0x8f, 0xf7, 0x60, 0x03, 0x14, 0x98, 0x74, 0x97, 0x4e, 0x7d, 0x2c, 0xdf, 0xa7, 0x0c, 0xd5, 0x43, + 0x0e, 0xd7, 0x37, 0x4a, 0x70, 0xae, 0xbb, 0x2a, 0x46, 0x3f, 0x09, 0xa3, 0x91, 0x8a, 0x8a, 0x33, + 0xb3, 0x26, 0x4f, 0x71, 0x4f, 0x42, 0x0a, 0x84, 0xb3, 0xb8, 0x68, 0x02, 0x20, 0x74, 0x92, 0x8d, + 0xf8, 0xe2, 0xb6, 0x1b, 0x27, 0xa2, 0x2a, 0xd0, 0x08, 0x3f, 0x4b, 0x94, 0xad, 0xd8, 0xc0, 0xa0, + 0xec, 0xd8, 0xbf, 0xd9, 0xe0, 0x5a, 0x90, 0xf0, 0x87, 0xf8, 0x36, 0xe2, 0x94, 0xbc, 0x7d, 0xc5, + 0x00, 0xe1, 0x2c, 0x2e, 0x65, 0xc7, 0xce, 0x79, 0x78, 0x47, 0xf9, 0xfe, 0x82, 0xb1, 0x5b, 0x50, + 0xad, 0xd8, 0xc0, 0xc8, 0xe6, 0x83, 0x56, 0xf6, 0xcf, 0x07, 0xb5, 0xff, 0x59, 0x09, 0xce, 0x76, + 0x35, 0xe5, 0x7a, 0x5b, 0x80, 0x0f, 0x5e, 0x0e, 0xe7, 0xe1, 0xe6, 0xce, 0x01, 0x73, 0x0d, 0xff, + 0xac, 0xcb, 0x4c, 0x13, 0xb9, 0x86, 0x87, 0x4f, 0xd6, 0x7f, 0xf0, 0xc6, 0xb3, 0x23, 0xbd, 0xb0, + 0xef, 0x00, 0xe9, 0x85, 0x99, 0x8f, 0x51, 0xe9, 0x71, 0x21, 0xff, 0x55, 0xb9, 0xeb, 0xf0, 0xd2, + 0xad, 0x5f, 0x4f, 0x7e, 0xda, 0x59, 0x38, 0xe1, 0xfa, 0xec, 0x26, 0xae, 0x95, 0xf6, 0x9a, 0x28, + 0x14, 0x53, 0x4a, 0xdf, 0x97, 0x3f, 0x9f, 0x81, 0xe3, 0x8e, 0x27, 0x1e, 0xc0, 0x74, 0xcf, 0xc3, + 0x0d, 0xe9, 0xc1, 0x12, 0x8e, 0xd1, 0x12, 0x9c, 0x91, 0x43, 0xb1, 0xe1, 0x44, 0xa4, 0x21, 0xd4, + 0x48, 0x2c, 0x12, 0x5c, 0xce, 0xf2, 0x24, 0x99, 0x1c, 0x04, 0x9c, 0xff, 0x1c, 0xbb, 0xfc, 0x28, + 0x08, 0xdd, 0xba, 0xd8, 0xe4, 0xe8, 0xcb, 0x8f, 0x68, 0x23, 0xe6, 0x30, 0xfb, 0x15, 0xa8, 0xa9, + 0xf7, 0xe7, 0x61, 0xf6, 0x6a, 0xd2, 0x75, 0x84, 0xd9, 0xab, 0x19, 0x67, 0x60, 0xd1, 0xaf, 0x45, + 0x4d, 0xe2, 0xcc, 0xea, 0xb9, 0x4a, 0x76, 0x98, 0x7d, 0x6c, 0xbf, 0x07, 0x86, 0x94, 0x9f, 0xa5, + 0xd7, 0x2b, 0xa1, 0xec, 0x37, 0xfb, 0x61, 0x38, 0x55, 0xac, 0x31, 0xe5, 0x60, 0xb5, 0xf6, 0x75, + 0xb0, 0xb2, 0xb4, 0x89, 0xb6, 0x2f, 0xef, 0x8b, 0x33, 0xd2, 0x26, 0xda, 0x3e, 0xc1, 0x1c, 0x46, + 0xcd, 0xdb, 0x46, 0xb4, 0x83, 0xdb, 0xbe, 0x08, 0x6f, 0x56, 0xe6, 0xed, 0x2c, 0x6b, 0xc5, 0x02, + 0x8a, 0x3e, 0x61, 0xc1, 0x50, 0xcc, 0xbc, 0xf7, 0xdc, 0x3d, 0x2d, 0x26, 0xdd, 0x95, 0xa3, 0xd7, + 0xa2, 0x54, 0x85, 0x49, 0x59, 0xc4, 0x92, 0xd9, 0x82, 0x53, 0x1c, 0xd1, 0xa7, 0x2d, 0xa8, 0xa9, + 0x6b, 0x6d, 0xc4, 0xe5, 0x8f, 0x2b, 0xc5, 0xd6, 0xc2, 0xe4, 0x7e, 0x4d, 0x75, 0x10, 0xa2, 0x8a, + 0x12, 0x62, 0xcd, 0x18, 0xc5, 0xca, 0x77, 0x3c, 0x70, 0x3c, 0xbe, 0x63, 0xc8, 0xf1, 0x1b, 0xbf, + 0x1b, 0x6a, 0x2d, 0xc7, 0x77, 0xd7, 0x49, 0x9c, 0x70, 0x77, 0xae, 0x2c, 0xd1, 0x2b, 0x1b, 0xb1, + 0x86, 0x53, 0x85, 0x1c, 0xb3, 0x17, 0x4b, 0x0c, 0xff, 0x2b, 0x53, 0xc8, 0x2b, 0xba, 0x19, 0x9b, + 0x38, 0xa6, 0xb3, 0x18, 0xee, 0xab, 0xb3, 0x78, 0x70, 0x6f, 0x67, 0xb1, 0xfd, 0x8f, 0x2d, 0x38, + 0x93, 0xfb, 0xd5, 0x1e, 0xdc, 0x40, 0x54, 0xfb, 0x4b, 0x15, 0x38, 0x95, 0x53, 0x75, 0x15, 0xed, + 0x98, 0xf3, 0xd9, 0x2a, 0x22, 0x86, 0x20, 0x7d, 0x24, 0x2e, 0x87, 0x31, 0x67, 0x12, 0x1f, 0xec, + 0xa8, 0x46, 0x1f, 0x97, 0x94, 0xef, 0xed, 0x71, 0x89, 0x31, 0x2d, 0xfb, 0xee, 0xeb, 0xb4, 0xac, + 0xec, 0x73, 0x86, 0xf1, 0x1b, 0x16, 0x8c, 0xb5, 0xba, 0x94, 0xfa, 0x17, 0x8e, 0xc7, 0x1b, 0xc7, + 0x73, 0x91, 0xc0, 0xf4, 0x23, 0x77, 0x76, 0xc7, 0xbb, 0xde, 0xb0, 0x80, 0xbb, 0xf6, 0xca, 0xfe, + 0x6e, 0x19, 0x58, 0xc9, 0x5f, 0x56, 0x59, 0x6f, 0x07, 0x7d, 0xdc, 0x2c, 0xde, 0x6c, 0x15, 0x55, + 0x68, 0x98, 0x13, 0x57, 0xc5, 0x9f, 0xf9, 0x08, 0xe6, 0xd5, 0x82, 0xce, 0x0a, 0xad, 0x52, 0x0f, + 0x42, 0xcb, 0x93, 0x55, 0xb2, 0xcb, 0xc5, 0x57, 0xc9, 0xae, 0x65, 0x2b, 0x64, 0xef, 0xfd, 0x89, + 0xfb, 0x1e, 0xc8, 0x4f, 0xfc, 0x2b, 0x16, 0x17, 0x3c, 0x99, 0xaf, 0xa0, 0x2d, 0x03, 0x6b, 0x0f, + 0xcb, 0xe0, 0x29, 0xa8, 0xc6, 0xc4, 0x5b, 0xbf, 0x4c, 0x1c, 0x4f, 0x58, 0x10, 0xfa, 0xfc, 0x5a, + 0xb4, 0x63, 0x85, 0xc1, 0x2e, 0xe0, 0xf5, 0xbc, 0xe0, 0xf6, 0xc5, 0x56, 0x98, 0xec, 0x08, 0x5b, + 0x42, 0x5f, 0xc0, 0xab, 0x20, 0xd8, 0xc0, 0xb2, 0x3f, 0xdb, 0xc7, 0x67, 0xa0, 0x08, 0x82, 0x78, + 0x3e, 0x73, 0x65, 0x62, 0xef, 0xf1, 0x03, 0x1f, 0x05, 0xa8, 0x07, 0xad, 0x90, 0xda, 0x7d, 0xab, + 0x81, 0x38, 0x13, 0xba, 0x7c, 0xe4, 0x1b, 0xd3, 0x05, 0x3d, 0xfd, 0x1a, 0xba, 0x0d, 0x1b, 0xfc, + 0x52, 0xb2, 0xb4, 0xbc, 0xaf, 0x2c, 0x4d, 0x89, 0x95, 0xbe, 0x7d, 0xc4, 0xca, 0xd7, 0x2d, 0x38, + 0xa1, 0xf4, 0xfa, 0xcc, 0x86, 0xe3, 0x37, 0x49, 0x43, 0x14, 0x07, 0x7c, 0xa5, 0x08, 0xcb, 0x8b, + 0x8e, 0xde, 0xc4, 0x62, 0x86, 0x01, 0x77, 0x53, 0xab, 0xbd, 0x4a, 0x16, 0x8c, 0x3b, 0x7a, 0x74, + 0x6e, 0x06, 0xce, 0xe4, 0x12, 0x39, 0xd0, 0x55, 0x4f, 0x7f, 0x61, 0x41, 0xca, 0xfa, 0x43, 0x21, + 0x54, 0x68, 0xd7, 0x77, 0x84, 0x34, 0x5a, 0x2a, 0xce, 0xd4, 0xa4, 0x6a, 0x40, 0x2c, 0x71, 0xf6, + 0x13, 0x73, 0x46, 0xc8, 0x13, 0x71, 0x21, 0x7c, 0x06, 0x5d, 0x2b, 0x8e, 0xe1, 0xe5, 0x20, 0xd8, + 0xe4, 0x87, 0xb8, 0x3a, 0xc6, 0xc4, 0x7e, 0x1e, 0x4e, 0x76, 0x74, 0x8a, 0xdd, 0x04, 0x17, 0x50, + 0x4d, 0x9b, 0x59, 0x9a, 0x2c, 0x79, 0x18, 0x73, 0x98, 0xfd, 0x0d, 0x0b, 0x4e, 0x64, 0xc9, 0xa3, + 0xb7, 0x2c, 0x38, 0x19, 0x67, 0xe9, 0x1d, 0xd7, 0xd8, 0xa9, 0xd8, 0xce, 0x0e, 0x10, 0xee, 0xec, + 0x84, 0xfd, 0x7f, 0x4a, 0x7c, 0xa1, 0xdf, 0x74, 0xfd, 0x46, 0x70, 0x5b, 0x19, 0x61, 0x56, 0x57, + 0x23, 0x8c, 0xca, 0x9e, 0xfa, 0x06, 0x69, 0xb4, 0xbd, 0x8e, 0xac, 0xe5, 0x15, 0xd1, 0x8e, 0x15, + 0x06, 0x4b, 0xd2, 0x6c, 0x8b, 0x2b, 0x03, 0x32, 0x0b, 0x70, 0x56, 0xb4, 0x63, 0x85, 0x81, 0x9e, + 0x85, 0x21, 0xe3, 0x25, 0xe5, 0x1a, 0x64, 0x9b, 0x0f, 0xc3, 0x3c, 0x88, 0x71, 0x0a, 0x0b, 0x4d, + 0x00, 0x28, 0x83, 0x4e, 0x9a, 0x03, 0xcc, 0x29, 0xa6, 0xa4, 0x6e, 0x8c, 0x0d, 0x0c, 0x96, 0x12, + 0xed, 0xb5, 0x63, 0x76, 0x9e, 0xd1, 0xaf, 0xcb, 0xd8, 0xce, 0x88, 0x36, 0xac, 0xa0, 0x54, 0x72, + 0xb6, 0x1c, 0xbf, 0xed, 0x78, 0x74, 0x84, 0xc4, 0x36, 0x57, 0x89, 0x9c, 0x45, 0x05, 0xc1, 0x06, + 0x16, 0x7d, 0xe3, 0xc4, 0x6d, 0x91, 0x97, 0x02, 0x5f, 0xc6, 0xe4, 0xe9, 0x23, 0x2e, 0xd1, 0x8e, + 0x15, 0x86, 0xfd, 0x5f, 0x2c, 0x18, 0xd5, 0x05, 0x16, 0xf8, 0x9d, 0xef, 0xe6, 0xae, 0xdc, 0xda, + 0x77, 0x57, 0x9e, 0xce, 0x3c, 0x2f, 0xf5, 0x94, 0x79, 0x6e, 0x26, 0x85, 0x97, 0xf7, 0x4c, 0x0a, + 0xff, 0x11, 0x7d, 0x9f, 0x30, 0xcf, 0x1e, 0x1f, 0xcc, 0xbb, 0x4b, 0x18, 0xd9, 0xd0, 0x5f, 0x77, + 0x54, 0x75, 0xa1, 0x21, 0xbe, 0x4f, 0x9a, 0x99, 0x62, 0x48, 0x02, 0x62, 0x2f, 0x41, 0x4d, 0x9d, + 0xf4, 0xc8, 0x4d, 0xb9, 0x95, 0xbf, 0x29, 0xef, 0x29, 0x39, 0x75, 0x7a, 0xed, 0x5b, 0xdf, 0x7b, + 0xec, 0x1d, 0x7f, 0xf8, 0xbd, 0xc7, 0xde, 0xf1, 0xa7, 0xdf, 0x7b, 0xec, 0x1d, 0x9f, 0xb8, 0xf3, + 0x98, 0xf5, 0xad, 0x3b, 0x8f, 0x59, 0x7f, 0x78, 0xe7, 0x31, 0xeb, 0x4f, 0xef, 0x3c, 0x66, 0x7d, + 0xf7, 0xce, 0x63, 0xd6, 0x17, 0xff, 0xe3, 0x63, 0xef, 0x78, 0x29, 0x37, 0x28, 0x93, 0xfe, 0x78, + 0xba, 0xde, 0x98, 0xdc, 0xba, 0xc0, 0xe2, 0x02, 0xe9, 0xf2, 0x9a, 0x34, 0xe6, 0xd4, 0xa4, 0x5c, + 0x5e, 0xff, 0x37, 0x00, 0x00, 0xff, 0xff, 0x6f, 0x44, 0xc5, 0x49, 0xcb, 0xe4, 0x00, 0x00, } func (m *AWSAuthConfig) Marshal() (dAtA []byte, err error) { @@ -14164,6 +14168,33 @@ func (m *SyncStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ManifestsChanged) > 0 { + keysForManifestsChanged := make([]string, 0, len(m.ManifestsChanged)) + for k := range m.ManifestsChanged { + keysForManifestsChanged = append(keysForManifestsChanged, string(k)) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForManifestsChanged) + for iNdEx := len(keysForManifestsChanged) - 1; iNdEx >= 0; iNdEx-- { + v := m.ManifestsChanged[string(keysForManifestsChanged[iNdEx])] + baseI := i + i-- + if v { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + i -= len(keysForManifestsChanged[iNdEx]) + copy(dAtA[i:], keysForManifestsChanged[iNdEx]) + i = encodeVarintGenerated(dAtA, i, uint64(len(keysForManifestsChanged[iNdEx]))) + i-- + dAtA[i] = 0xa + i = encodeVarintGenerated(dAtA, i, uint64(baseI-i)) + i-- + dAtA[i] = 0x2a + } + } if len(m.Revisions) > 0 { for iNdEx := len(m.Revisions) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Revisions[iNdEx]) @@ -17848,6 +17879,14 @@ func (m *SyncStatus) Size() (n int) { n += 1 + l + sovGenerated(uint64(l)) } } + if len(m.ManifestsChanged) > 0 { + for k, v := range m.ManifestsChanged { + _ = k + _ = v + mapEntrySize := 1 + len(k) + sovGenerated(uint64(len(k))) + 1 + 1 + n += mapEntrySize + 1 + sovGenerated(uint64(mapEntrySize)) + } + } return n } @@ -20477,11 +20516,22 @@ func (this *SyncStatus) String() string { if this == nil { return "nil" } + keysForManifestsChanged := make([]string, 0, len(this.ManifestsChanged)) + for k := range this.ManifestsChanged { + keysForManifestsChanged = append(keysForManifestsChanged, k) + } + github_com_gogo_protobuf_sortkeys.Strings(keysForManifestsChanged) + mapStringForManifestsChanged := "map[string]bool{" + for _, k := range keysForManifestsChanged { + mapStringForManifestsChanged += fmt.Sprintf("%v: %v,", k, this.ManifestsChanged[k]) + } + mapStringForManifestsChanged += "}" s := strings.Join([]string{`&SyncStatus{`, `Status:` + fmt.Sprintf("%v", this.Status) + `,`, `ComparedTo:` + strings.Replace(strings.Replace(this.ComparedTo.String(), "ComparedTo", "ComparedTo", 1), `&`, ``, 1) + `,`, `Revision:` + fmt.Sprintf("%v", this.Revision) + `,`, `Revisions:` + fmt.Sprintf("%v", this.Revisions) + `,`, + `ManifestsChanged:` + mapStringForManifestsChanged + `,`, `}`, }, "") return s @@ -50211,6 +50261,121 @@ func (m *SyncStatus) Unmarshal(dAtA []byte) error { } m.Revisions = append(m.Revisions, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 5: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ManifestsChanged", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthGenerated + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthGenerated + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.ManifestsChanged == nil { + m.ManifestsChanged = make(map[string]bool) + } + var mapkey string + var mapvalue bool + for iNdEx < postIndex { + entryPreIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + if fieldNum == 1 { + var stringLenmapkey uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLenmapkey |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLenmapkey := int(stringLenmapkey) + if intStringLenmapkey < 0 { + return ErrInvalidLengthGenerated + } + postStringIndexmapkey := iNdEx + intStringLenmapkey + if postStringIndexmapkey < 0 { + return ErrInvalidLengthGenerated + } + if postStringIndexmapkey > l { + return io.ErrUnexpectedEOF + } + mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) + iNdEx = postStringIndexmapkey + } else if fieldNum == 2 { + var mapvaluetemp int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowGenerated + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + mapvaluetemp |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + mapvalue = bool(mapvaluetemp != 0) + } else { + iNdEx = entryPreIndex + skippy, err := skipGenerated(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthGenerated + } + if (iNdEx + skippy) > postIndex { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + m.ManifestsChanged[mapkey] = mapvalue + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipGenerated(dAtA[iNdEx:]) diff --git a/pkg/apis/application/v1alpha1/generated.proto b/pkg/apis/application/v1alpha1/generated.proto index 7e6c56dee2ad7..c4024a6eef349 100644 --- a/pkg/apis/application/v1alpha1/generated.proto +++ b/pkg/apis/application/v1alpha1/generated.proto @@ -2246,6 +2246,9 @@ message SyncStatus { // Revisions contains information about the revisions of multiple sources the comparison has been performed to repeated string revisions = 4; + + // ManifestsChanged indicates whether the manifests have changed base on argocd.argoproj.io/manifest-generate-paths annotation + map manifestsChanged = 5; } // SyncStrategy controls the manner in which a sync is performed diff --git a/pkg/apis/application/v1alpha1/openapi_generated.go b/pkg/apis/application/v1alpha1/openapi_generated.go index b9acb9820cc60..e2866e43cd1bc 100644 --- a/pkg/apis/application/v1alpha1/openapi_generated.go +++ b/pkg/apis/application/v1alpha1/openapi_generated.go @@ -7784,6 +7784,22 @@ func schema_pkg_apis_application_v1alpha1_SyncStatus(ref common.ReferenceCallbac }, }, }, + "manifestsChanged": { + SchemaProps: spec.SchemaProps{ + Description: "ManifestsChanged indicates whether the manifests have changed base on argocd.argoproj.io/manifest-generate-paths annotation", + Type: []string{"object"}, + AdditionalProperties: &spec.SchemaOrBool{ + Allows: true, + Schema: &spec.Schema{ + SchemaProps: spec.SchemaProps{ + Default: false, + Type: []string{"boolean"}, + Format: "", + }, + }, + }, + }, + }, }, Required: []string{"status"}, }, diff --git a/pkg/apis/application/v1alpha1/types.go b/pkg/apis/application/v1alpha1/types.go index 7e9362f92d234..5ebe56e90bd4a 100644 --- a/pkg/apis/application/v1alpha1/types.go +++ b/pkg/apis/application/v1alpha1/types.go @@ -1518,6 +1518,8 @@ type SyncStatus struct { Revision string `json:"revision,omitempty" protobuf:"bytes,3,opt,name=revision"` // Revisions contains information about the revisions of multiple sources the comparison has been performed to Revisions []string `json:"revisions,omitempty" protobuf:"bytes,4,opt,name=revisions"` + // ManifestsChanged indicates whether the manifests have changed base on argocd.argoproj.io/manifest-generate-paths annotation + ManifestsChanged map[string]bool `json:"manifestsChanged,omitempty" protobuf:"bytes,5,opt,name=manifestsChanged"` } // HealthStatus contains information about the currently observed health state of an application or resource diff --git a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go index a832e30155fbe..ffc7437f06027 100644 --- a/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go +++ b/pkg/apis/application/v1alpha1/zz_generated.deepcopy.go @@ -4252,6 +4252,13 @@ func (in *SyncStatus) DeepCopyInto(out *SyncStatus) { *out = make([]string, len(*in)) copy(*out, *in) } + if in.ManifestsChanged != nil { + in, out := &in.ManifestsChanged, &out.ManifestsChanged + *out = make(map[string]bool, len(*in)) + for key, val := range *in { + (*out)[key] = val + } + } return } From f09e338db191fa93e5a45c11f8d2bda4f76c9ba0 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Tue, 30 Jul 2024 11:15:23 +0300 Subject: [PATCH 06/30] chore: update version to 2.11-2024.7.30-fcda44e7b --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.7.30-fcda44e7b.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.7.30-fcda44e7b.md diff --git a/VERSION b/VERSION index d60b96e4f837b..dcb6c434ab6ae 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.7.20-8eb51f7a6 \ No newline at end of file +2.11-2024.7.30-fcda44e7b \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.7.30-fcda44e7b.md b/changelog/CHANGELOG-2.11-2024.7.30-fcda44e7b.md new file mode 100644 index 0000000000000..3f2ce2a62f647 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.7.30-fcda44e7b.md @@ -0,0 +1,2 @@ +### Chore +- fix: selfheal should work with monorepo \ No newline at end of file From 10260b1bc2bc573b83ad84d3856b637d7010ad50 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Tue, 30 Jul 2024 11:19:10 +0300 Subject: [PATCH 07/30] chore: update version to 2.11-2024.7.30-a31bf96bb --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.7.30-a31bf96bb.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.7.30-a31bf96bb.md diff --git a/VERSION b/VERSION index dcb6c434ab6ae..93973ef5f9532 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.7.30-fcda44e7b \ No newline at end of file +2.11-2024.7.30-a31bf96bb \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.7.30-a31bf96bb.md b/changelog/CHANGELOG-2.11-2024.7.30-a31bf96bb.md new file mode 100644 index 0000000000000..3f2ce2a62f647 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.7.30-a31bf96bb.md @@ -0,0 +1,2 @@ +### Chore +- fix: selfheal should work with monorepo \ No newline at end of file From 686516825cbbe08f3dff13a0b6c5595eb160f1a2 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Wed, 7 Aug 2024 10:55:29 +0300 Subject: [PATCH 08/30] chore: update version to 2.11-2024.8.7-10260b1bc --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.7-10260b1bc.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.7-10260b1bc.md diff --git a/VERSION b/VERSION index 93973ef5f9532..fcb7962f3cbfb 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.7.30-a31bf96bb \ No newline at end of file +2.11-2024.8.7-10260b1bc \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.7-10260b1bc.md b/changelog/CHANGELOG-2.11-2024.8.7-10260b1bc.md new file mode 100644 index 0000000000000..3f2ce2a62f647 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.7-10260b1bc.md @@ -0,0 +1,2 @@ +### Chore +- fix: selfheal should work with monorepo \ No newline at end of file From b088681c7f4b7b9b13dd6bffa56279a31ead86cf Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Wed, 7 Aug 2024 10:59:34 +0300 Subject: [PATCH 09/30] fix monorepo selfheal support and add logs --- controller/appcontroller.go | 6 +++++- controller/appcontroller_test.go | 8 ++++++++ controller/state.go | 1 + 3 files changed, 14 insertions(+), 1 deletion(-) diff --git a/controller/appcontroller.go b/controller/appcontroller.go index 63d273925fec6..527775a1c2812 100644 --- a/controller/appcontroller.go +++ b/controller/appcontroller.go @@ -1961,10 +1961,14 @@ func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS } } else { manifestsChangedMap := app.Status.Sync.ManifestsChanged - if os.Getenv("PERSIST_CHANGE_REVISIONS") != "1" || manifestsChangedMap[commitSHA] { + manifestChanged, ok := manifestsChangedMap[commitSHA] + // If record not exists, we need to do sync + if os.Getenv("PERSIST_CHANGE_REVISIONS") != "1" || !ok || manifestChanged { if app.Status.OperationState.SyncResult.Revision != commitSHA { return false, "" } + } else { + log.Debugf("Skipping auto-sync: commitSHA %s has no changes", commitSHA) } } diff --git a/controller/appcontroller_test.go b/controller/appcontroller_test.go index 4de765a389481..ac354ca4bbf53 100644 --- a/controller/appcontroller_test.go +++ b/controller/appcontroller_test.go @@ -1980,4 +1980,12 @@ func TestAlreadyAttemptSync(t *testing.T) { attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) assert.False(t, attempted) }) + + t.Run("different manifest with sync result, with enabled flag", func(t *testing.T) { + + _ = os.Setenv("PERSIST_CHANGE_REVISIONS", "1") + + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + assert.False(t, attempted) + }) } diff --git a/controller/state.go b/controller/state.go index e85c227fe8ad4..f28c782211b45 100644 --- a/controller/state.go +++ b/controller/state.go @@ -231,6 +231,7 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp // not need to change, if we already found at least one cached revision that has no changes if updateRevisionResponse != nil && os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { manifestsChanges[syncedRevision] = updateRevisionResponse.Changes + log.WithField("application", app.Name).Debugf("Persisting revision %s with changes exists %t", syncedRevision, updateRevisionResponse.Changes) } if err != nil { return nil, nil, nil, fmt.Errorf("failed to compare revisions for source %d of %d: %w", i+1, len(sources), err) From 9f6f9bc03ca5dfb5c45180defefe00205bc9572c Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Wed, 7 Aug 2024 11:00:31 +0300 Subject: [PATCH 10/30] chore: update version to 2.11-2024.8.7-b088681c7 --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.7-b088681c7.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.7-b088681c7.md diff --git a/VERSION b/VERSION index fcb7962f3cbfb..0790ad4dffd5e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.7-10260b1bc \ No newline at end of file +2.11-2024.8.7-b088681c7 \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.7-b088681c7.md b/changelog/CHANGELOG-2.11-2024.8.7-b088681c7.md new file mode 100644 index 0000000000000..3f2ce2a62f647 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.7-b088681c7.md @@ -0,0 +1,2 @@ +### Chore +- fix: selfheal should work with monorepo \ No newline at end of file From 5c2f0993bdac664194ce0c6f1ee1aaedd0a6ea88 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 11:46:36 +0300 Subject: [PATCH 11/30] fix monorepo selfheal support and add logs --- changelog/CHANGELOG.md | 2 -- controller/appcontroller.go | 13 ++++++++++--- controller/appcontroller_test.go | 13 +++++++++++++ 3 files changed, 23 insertions(+), 5 deletions(-) delete mode 100644 changelog/CHANGELOG.md diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md deleted file mode 100644 index a7746265e6e32..0000000000000 --- a/changelog/CHANGELOG.md +++ /dev/null @@ -1,2 +0,0 @@ -### Chore -- chore(event-reporter v2): code splitting, created utils package \ No newline at end of file diff --git a/controller/appcontroller.go b/controller/appcontroller.go index 527775a1c2812..1216b63527571 100644 --- a/controller/appcontroller.go +++ b/controller/appcontroller.go @@ -1962,13 +1962,16 @@ func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS } else { manifestsChangedMap := app.Status.Sync.ManifestsChanged manifestChanged, ok := manifestsChangedMap[commitSHA] + featureFlagDisabled := os.Getenv("PERSIST_CHANGE_REVISIONS") != "1" // If record not exists, we need to do sync - if os.Getenv("PERSIST_CHANGE_REVISIONS") != "1" || !ok || manifestChanged { + if featureFlagDisabled || !ok || manifestChanged { + log.WithField("application", app.Name).Infof("Executing compare of syncResult.Revision and commitSha because of feature flag disabled or manifest changed: %v", commitSHA) + log.WithField("application", app.Name).Infof("Executing compare of syncResult.Revision and commitSha with context, map: %v, flag: %t, record exists: %t", manifestsChangedMap, featureFlagDisabled, ok) if app.Status.OperationState.SyncResult.Revision != commitSHA { return false, "" } } else { - log.Debugf("Skipping auto-sync: commitSHA %s has no changes", commitSHA) + log.WithField("application", app.Name).Debugf("Skipping auto-sync: commitSHA %s has no changes", commitSHA) } } @@ -1991,7 +1994,11 @@ func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS specSource.TargetRevision = "" syncResSource := app.Status.OperationState.SyncResult.Source.DeepCopy() syncResSource.TargetRevision = "" - return reflect.DeepEqual(app.Spec.GetSource(), app.Status.OperationState.SyncResult.Source), app.Status.OperationState.Phase + equalSource, phase := reflect.DeepEqual(app.Spec.GetSource(), app.Status.OperationState.SyncResult.Source), app.Status.OperationState.Phase + if !equalSource { + log.WithField("application", app.Name).Infof("spec.source and syncResult.source are different") + } + return equalSource, phase } } diff --git a/controller/appcontroller_test.go b/controller/appcontroller_test.go index ac354ca4bbf53..94a6c545a71a4 100644 --- a/controller/appcontroller_test.go +++ b/controller/appcontroller_test.go @@ -1988,4 +1988,17 @@ func TestAlreadyAttemptSync(t *testing.T) { attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) assert.False(t, attempted) }) + + t.Run("different manifest with sync result, with enabled flag v2", func(t *testing.T) { + + _ = os.Setenv("PERSIST_CHANGE_REVISIONS", "1") + + manifestChangedMap := make(map[string]bool) + manifestChangedMap["sha"] = false + + app.Status.Sync.ManifestsChanged = manifestChangedMap + + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + assert.True(t, attempted) + }) } From f3821b5f9b5fdc8a0b6d07707b5d4b46e5bfe5b5 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 11:47:07 +0300 Subject: [PATCH 12/30] fix monorepo selfheal support and add logs --- changelog/CHANGELOG.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 changelog/CHANGELOG.md diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md new file mode 100644 index 0000000000000..44f728a89a47b --- /dev/null +++ b/changelog/CHANGELOG.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal should work with monorepo additional logs \ No newline at end of file From 40dad345e36a281819fc22c09819dd4003cebbfb Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 11:47:22 +0300 Subject: [PATCH 13/30] chore: update version to 2.11-2024.8.8-f3821b5f9 --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.8-f3821b5f9.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.8-f3821b5f9.md diff --git a/VERSION b/VERSION index 0790ad4dffd5e..ffcc3c06c24fc 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.7-b088681c7 \ No newline at end of file +2.11-2024.8.8-f3821b5f9 \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.8-f3821b5f9.md b/changelog/CHANGELOG-2.11-2024.8.8-f3821b5f9.md new file mode 100644 index 0000000000000..44f728a89a47b --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.8-f3821b5f9.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal should work with monorepo additional logs \ No newline at end of file From 9011506bfcfbf908b76db9c95bae82646984eb80 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 15:05:14 +0300 Subject: [PATCH 14/30] fix monorepo selfheal support and add logs --- changelog/CHANGELOG.md | 2 - controller/state.go | 4 +- reposerver/apiclient/repository.pb.go | 375 ++++++++++++++----------- reposerver/repository/repository.go | 12 +- reposerver/repository/repository.proto | 1 + 5 files changed, 223 insertions(+), 171 deletions(-) delete mode 100644 changelog/CHANGELOG.md diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md deleted file mode 100644 index 44f728a89a47b..0000000000000 --- a/changelog/CHANGELOG.md +++ /dev/null @@ -1,2 +0,0 @@ -### Chore -- chore: selfheal should work with monorepo additional logs \ No newline at end of file diff --git a/controller/state.go b/controller/state.go index f28c782211b45..caf8825188d7a 100644 --- a/controller/state.go +++ b/controller/state.go @@ -229,8 +229,8 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp }) // not need to change, if we already found at least one cached revision that has no changes - if updateRevisionResponse != nil && os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { - manifestsChanges[syncedRevision] = updateRevisionResponse.Changes + if updateRevisionResponse != nil && updateRevisionResponse.Revision != "" && os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { + manifestsChanges[updateRevisionResponse.Revision] = updateRevisionResponse.Changes log.WithField("application", app.Name).Debugf("Persisting revision %s with changes exists %t", syncedRevision, updateRevisionResponse.Changes) } if err != nil { diff --git a/reposerver/apiclient/repository.pb.go b/reposerver/apiclient/repository.pb.go index 058b2f7f4400e..5e2dce3f6bfe0 100644 --- a/reposerver/apiclient/repository.pb.go +++ b/reposerver/apiclient/repository.pb.go @@ -2553,6 +2553,7 @@ func (m *UpdateRevisionForPathsRequest) GetPaths() []string { type UpdateRevisionForPathsResponse struct { Changes bool `protobuf:"varint,1,opt,name=changes,proto3" json:"changes,omitempty"` + Revision string `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -2598,6 +2599,13 @@ func (m *UpdateRevisionForPathsResponse) GetChanges() bool { return false } +func (m *UpdateRevisionForPathsResponse) GetRevision() string { + if m != nil { + return m.Revision + } + return "" +} + func init() { proto.RegisterType((*ManifestRequest)(nil), "repository.ManifestRequest") proto.RegisterMapType((map[string]bool)(nil), "repository.ManifestRequest.EnabledSourceTypesEntry") @@ -2651,168 +2659,168 @@ func init() { } var fileDescriptor_dd8723cfcc820480 = []byte{ - // 2563 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x3a, 0x5b, 0x6f, 0x1c, 0x49, - 0xd5, 0x1e, 0xcf, 0xd8, 0x9e, 0x39, 0xbe, 0x57, 0x1c, 0xa7, 0x33, 0xbb, 0xf1, 0xe7, 0xed, 0x6f, - 0x37, 0xca, 0x3a, 0xbb, 0x3d, 0xd8, 0x61, 0x37, 0x4b, 0x36, 0x2c, 0xf2, 0xe6, 0x62, 0xe7, 0xe2, - 0xc4, 0xdb, 0xc9, 0x82, 0xb2, 0x04, 0x50, 0x4d, 0x4f, 0x79, 0xa6, 0x33, 0x7d, 0xa9, 0x74, 0xd7, - 0x38, 0x38, 0x12, 0x12, 0x12, 0x88, 0x9f, 0xc0, 0x03, 0xaf, 0xfc, 0x01, 0x24, 0x84, 0x78, 0xe4, - 0x01, 0xad, 0xe0, 0x09, 0x21, 0xfe, 0x00, 0x28, 0x2f, 0xfc, 0x0d, 0x54, 0x97, 0xee, 0xae, 0xee, - 0x69, 0x4f, 0xbc, 0x38, 0xf1, 0x02, 0x2f, 0x76, 0xd5, 0xe9, 0x53, 0xe7, 0x9c, 0x3a, 0x75, 0xae, - 0x55, 0x03, 0xe7, 0x23, 0x42, 0xc3, 0x98, 0x44, 0xfb, 0x24, 0x6a, 0x89, 0xa1, 0xcb, 0xc2, 0xe8, - 0x40, 0x1b, 0x5a, 0x34, 0x0a, 0x59, 0x88, 0x20, 0x83, 0x34, 0xcd, 0xfe, 0x47, 0xb1, 0xe5, 0x86, - 0x2d, 0x4c, 0xdd, 0x96, 0x13, 0x46, 0xa4, 0xb5, 0xbf, 0xde, 0xea, 0x92, 0x80, 0x44, 0x98, 0x91, - 0x8e, 0xc4, 0x6f, 0x7e, 0x33, 0xc3, 0xf1, 0xb1, 0xd3, 0x73, 0x03, 0x12, 0x1d, 0xb4, 0x68, 0xbf, - 0xcb, 0x01, 0x71, 0xcb, 0x27, 0x0c, 0x97, 0xad, 0xba, 0xdb, 0x75, 0x59, 0x6f, 0xd0, 0xb6, 0x9c, - 0xd0, 0x6f, 0xe1, 0xa8, 0x1b, 0xd2, 0x28, 0x7c, 0x22, 0x06, 0xef, 0x3b, 0x9d, 0xd6, 0xfe, 0x46, - 0x46, 0x00, 0x53, 0xea, 0xb9, 0x0e, 0x66, 0x6e, 0x18, 0xb4, 0xf6, 0xd7, 0xb1, 0x47, 0x7b, 0x78, - 0x98, 0xda, 0x1b, 0xdd, 0x30, 0xec, 0x7a, 0xa4, 0x25, 0x66, 0xed, 0xc1, 0x5e, 0x8b, 0xf8, 0x94, - 0xa9, 0x0d, 0x99, 0x7f, 0x99, 0x85, 0xf9, 0x1d, 0x1c, 0xb8, 0x7b, 0x24, 0x66, 0x36, 0x79, 0x3a, - 0x20, 0x31, 0x43, 0x8f, 0xa1, 0xc6, 0xb7, 0x69, 0x54, 0x56, 0x2b, 0x17, 0xa6, 0x37, 0xb6, 0xad, - 0x4c, 0x1a, 0x2b, 0x91, 0x46, 0x0c, 0x7e, 0xe4, 0x74, 0xac, 0xfd, 0x0d, 0x8b, 0xf6, 0xbb, 0x16, - 0x97, 0xc6, 0xd2, 0xa4, 0xb1, 0x12, 0x69, 0x2c, 0x3b, 0x55, 0x98, 0x2d, 0xa8, 0xa2, 0x26, 0xd4, - 0x23, 0xb2, 0xef, 0xc6, 0x6e, 0x18, 0x18, 0xe3, 0xab, 0x95, 0x0b, 0x0d, 0x3b, 0x9d, 0x23, 0x03, - 0xa6, 0x82, 0xf0, 0x1a, 0x76, 0x7a, 0xc4, 0xa8, 0xae, 0x56, 0x2e, 0xd4, 0xed, 0x64, 0x8a, 0x56, - 0x61, 0x1a, 0x53, 0x7a, 0x17, 0xb7, 0x89, 0x77, 0x87, 0x1c, 0x18, 0x35, 0xb1, 0x50, 0x07, 0xf1, - 0xb5, 0x98, 0xd2, 0x7b, 0xd8, 0x27, 0xc6, 0x84, 0xf8, 0x9a, 0x4c, 0xd1, 0x9b, 0xd0, 0x08, 0xb0, - 0x4f, 0x62, 0x8a, 0x1d, 0x62, 0xd4, 0xc5, 0xb7, 0x0c, 0x80, 0x7e, 0x02, 0x8b, 0x9a, 0xe0, 0x0f, - 0xc2, 0x41, 0xe4, 0x10, 0x03, 0xc4, 0xd6, 0xef, 0x1f, 0x6f, 0xeb, 0x9b, 0x45, 0xb2, 0xf6, 0x30, - 0x27, 0xf4, 0x43, 0x98, 0x10, 0x36, 0x65, 0x4c, 0xaf, 0x56, 0x5f, 0xa9, 0xb6, 0x25, 0x59, 0x14, - 0xc0, 0x14, 0xf5, 0x06, 0x5d, 0x37, 0x88, 0x8d, 0x19, 0xc1, 0xe1, 0xe1, 0xf1, 0x38, 0x5c, 0x0b, - 0x83, 0x3d, 0xb7, 0xbb, 0x83, 0x03, 0xdc, 0x25, 0x3e, 0x09, 0xd8, 0xae, 0x20, 0x6e, 0x27, 0x4c, - 0xd0, 0x73, 0x58, 0xe8, 0x0f, 0x62, 0x16, 0xfa, 0xee, 0x73, 0x72, 0x9f, 0xf2, 0xb5, 0xb1, 0x31, - 0x2b, 0xb4, 0x79, 0xef, 0x78, 0x8c, 0xef, 0x14, 0xa8, 0xda, 0x43, 0x7c, 0xb8, 0x91, 0xf4, 0x07, - 0x6d, 0xf2, 0x5d, 0x12, 0x09, 0xeb, 0x9a, 0x93, 0x46, 0xa2, 0x81, 0xa4, 0x19, 0xb9, 0x6a, 0x16, - 0x1b, 0xf3, 0xab, 0x55, 0x69, 0x46, 0x29, 0x08, 0x5d, 0x80, 0xf9, 0x7d, 0x12, 0xb9, 0x7b, 0x07, - 0x0f, 0xdc, 0x6e, 0x80, 0xd9, 0x20, 0x22, 0xc6, 0x82, 0x30, 0xc5, 0x22, 0x18, 0xf9, 0x30, 0xdb, - 0x23, 0x9e, 0xcf, 0x55, 0x7e, 0x2d, 0x22, 0x9d, 0xd8, 0x58, 0x14, 0xfa, 0xdd, 0x3a, 0xfe, 0x09, - 0x0a, 0x72, 0x76, 0x9e, 0x3a, 0x17, 0x2c, 0x08, 0x6d, 0xe5, 0x29, 0xd2, 0x47, 0x90, 0x14, 0xac, - 0x00, 0x46, 0xe7, 0x61, 0x8e, 0x45, 0xd8, 0xe9, 0xbb, 0x41, 0x77, 0x87, 0xb0, 0x5e, 0xd8, 0x31, - 0x4e, 0x09, 0x4d, 0x14, 0xa0, 0xc8, 0x01, 0x44, 0x02, 0xdc, 0xf6, 0x48, 0x47, 0xda, 0xe2, 0xc3, - 0x03, 0x4a, 0x62, 0x63, 0x49, 0xec, 0xe2, 0x92, 0xa5, 0xc5, 0xbe, 0x42, 0x80, 0xb0, 0x6e, 0x0c, - 0xad, 0xba, 0x11, 0xb0, 0xe8, 0xc0, 0x2e, 0x21, 0x87, 0xfa, 0x30, 0xcd, 0xf7, 0x91, 0x98, 0xc2, - 0x69, 0x61, 0x0a, 0xb7, 0x8e, 0xa7, 0xa3, 0xed, 0x8c, 0xa0, 0xad, 0x53, 0x47, 0x16, 0xa0, 0x1e, - 0x8e, 0x77, 0x06, 0x1e, 0x73, 0xa9, 0x47, 0xa4, 0x18, 0xb1, 0xb1, 0x2c, 0xd4, 0x54, 0xf2, 0x05, - 0xdd, 0x01, 0x88, 0xc8, 0x5e, 0x82, 0x77, 0x46, 0xec, 0xfc, 0xe2, 0xa8, 0x9d, 0xdb, 0x29, 0xb6, - 0xdc, 0xb1, 0xb6, 0x1c, 0xb5, 0xe1, 0x94, 0x26, 0xed, 0x0e, 0x61, 0xb8, 0x83, 0x19, 0x36, 0x0c, - 0xb1, 0xe3, 0x6f, 0x58, 0x32, 0x13, 0x58, 0x7a, 0x26, 0xc8, 0xb6, 0xc9, 0x33, 0x81, 0xb5, 0xbf, - 0x6e, 0xdd, 0x6f, 0x3f, 0x21, 0x0e, 0xe3, 0x6b, 0xed, 0x32, 0x62, 0x7c, 0x83, 0x5c, 0x55, 0xc4, - 0x61, 0x2a, 0xa2, 0x88, 0xd0, 0x71, 0x56, 0x98, 0x71, 0xc9, 0x17, 0x6e, 0xef, 0x0a, 0x2a, 0x02, - 0x63, 0x53, 0x7a, 0x84, 0x06, 0x6a, 0xde, 0x80, 0x33, 0x87, 0x1c, 0x27, 0x5a, 0x80, 0x6a, 0x9f, - 0x1c, 0x88, 0x34, 0xd0, 0xb0, 0xf9, 0x10, 0x2d, 0xc1, 0xc4, 0x3e, 0xf6, 0x06, 0x44, 0x04, 0xee, - 0xba, 0x2d, 0x27, 0x57, 0xc6, 0x3f, 0xaa, 0x34, 0x7f, 0x51, 0x81, 0xf9, 0x82, 0x72, 0x4a, 0xd6, - 0xff, 0x40, 0x5f, 0xff, 0x0a, 0x5c, 0x65, 0xef, 0x21, 0x8e, 0xba, 0x84, 0x69, 0x82, 0x98, 0x7f, - 0xab, 0x80, 0x51, 0x38, 0xb5, 0xef, 0xb9, 0xac, 0x77, 0xd3, 0xf5, 0x48, 0x8c, 0x2e, 0xc3, 0x54, - 0x24, 0x61, 0x2a, 0xb9, 0xbd, 0x31, 0xe2, 0xb0, 0xb7, 0xc7, 0xec, 0x04, 0x1b, 0x7d, 0x02, 0x75, - 0x3f, 0x39, 0x50, 0x29, 0xfb, 0x6a, 0xd9, 0x4a, 0xce, 0x25, 0x39, 0xab, 0xed, 0x31, 0x3b, 0x5d, - 0x83, 0x3e, 0x80, 0x09, 0xa7, 0x37, 0x08, 0xfa, 0x22, 0xad, 0x4d, 0x6f, 0x9c, 0x3b, 0x6c, 0xf1, - 0x35, 0x8e, 0xb4, 0x3d, 0x66, 0x4b, 0xec, 0x4f, 0x27, 0xa1, 0x46, 0x71, 0xc4, 0xcc, 0x9b, 0xb0, - 0x54, 0xc6, 0x82, 0xe7, 0x52, 0xa7, 0x47, 0x9c, 0x7e, 0x3c, 0xf0, 0x95, 0x9a, 0xd3, 0x39, 0x42, - 0x50, 0x8b, 0xdd, 0xe7, 0x52, 0xd5, 0x55, 0x5b, 0x8c, 0xcd, 0x77, 0x61, 0x71, 0x88, 0x1b, 0x3f, - 0x54, 0x29, 0x1b, 0xa7, 0x30, 0xa3, 0x58, 0x9b, 0x03, 0x38, 0xfd, 0x50, 0xe8, 0x22, 0x4d, 0x28, - 0x27, 0x51, 0x1d, 0x98, 0xdb, 0xb0, 0x5c, 0x64, 0x1b, 0xd3, 0x30, 0x88, 0x09, 0x37, 0x7d, 0x11, - 0x81, 0x5d, 0xd2, 0xc9, 0xbe, 0x0a, 0x29, 0xea, 0x76, 0xc9, 0x17, 0xf3, 0xd7, 0xe3, 0xb0, 0x6c, - 0x93, 0x38, 0xf4, 0xf6, 0x49, 0x12, 0x1e, 0x4f, 0xa6, 0xc0, 0xf9, 0x3e, 0x54, 0x31, 0xa5, 0xca, - 0x4c, 0x6e, 0xbd, 0xb2, 0x12, 0xc2, 0xe6, 0x54, 0xd1, 0x7b, 0xb0, 0x88, 0xfd, 0xb6, 0xdb, 0x1d, - 0x84, 0x83, 0x38, 0xd9, 0x96, 0x30, 0xaa, 0x86, 0x3d, 0xfc, 0x81, 0xbb, 0x7f, 0x2c, 0x3c, 0xf2, - 0x56, 0xd0, 0x21, 0x3f, 0x16, 0x55, 0x53, 0xd5, 0xd6, 0x41, 0xa6, 0x03, 0x67, 0x86, 0x94, 0xa4, - 0x14, 0xae, 0x17, 0x6a, 0x95, 0x42, 0xa1, 0x56, 0x2a, 0xc6, 0xf8, 0x21, 0x62, 0x98, 0x3f, 0xad, - 0x40, 0x3d, 0xb1, 0x3b, 0xb4, 0x06, 0x0b, 0x4e, 0xe8, 0x53, 0xd7, 0x23, 0x9d, 0x04, 0xa6, 0xc8, - 0x0f, 0xc1, 0xb9, 0xfc, 0x11, 0x7e, 0x96, 0xa2, 0x49, 0x06, 0x3a, 0x88, 0x5b, 0x39, 0xc5, 0xac, - 0xa7, 0x54, 0x20, 0xc6, 0x1c, 0xe6, 0xb9, 0x01, 0x11, 0xdb, 0x9d, 0xb0, 0xc5, 0xd8, 0xfc, 0x02, - 0x66, 0xae, 0x13, 0x4a, 0x82, 0x0e, 0x09, 0x1c, 0x97, 0xc4, 0x02, 0x27, 0x74, 0xfa, 0x8a, 0xb3, - 0x18, 0x73, 0x58, 0x87, 0xd0, 0x58, 0xb1, 0x11, 0x63, 0x64, 0xc2, 0x0c, 0x8f, 0x01, 0x6e, 0x24, - 0x8a, 0x9d, 0x58, 0xf1, 0xc9, 0xc1, 0xcc, 0x18, 0x4e, 0x69, 0xe7, 0x94, 0x56, 0x12, 0x2b, 0x00, - 0x98, 0xd2, 0xa4, 0x18, 0x91, 0x8c, 0x34, 0x08, 0xba, 0x0a, 0x33, 0x1d, 0x4d, 0x24, 0x65, 0x30, - 0x86, 0x1e, 0x1a, 0x74, 0x91, 0xed, 0x1c, 0xb6, 0xf9, 0x65, 0x15, 0x16, 0xb2, 0x80, 0xa5, 0x8e, - 0x6c, 0x03, 0x1a, 0xbe, 0x82, 0xc5, 0x46, 0x45, 0xa4, 0xb3, 0xa5, 0xd2, 0x08, 0x97, 0xa1, 0xe5, - 0xab, 0xe3, 0xf1, 0x62, 0x75, 0xbc, 0x0c, 0x93, 0xb2, 0x2d, 0x52, 0x3b, 0x57, 0xb3, 0x9c, 0x71, - 0xd4, 0x0a, 0xc6, 0xb1, 0x02, 0x10, 0xa7, 0xb9, 0xc4, 0x98, 0x94, 0x1b, 0xcf, 0x20, 0x5c, 0xa7, - 0xb2, 0x96, 0xb2, 0x49, 0x3c, 0xf0, 0x98, 0x31, 0x25, 0x75, 0xaa, 0xc3, 0xd0, 0xdb, 0x30, 0xeb, - 0x84, 0xbe, 0xef, 0xb2, 0x1d, 0x12, 0xc7, 0xb8, 0x9b, 0xd4, 0xed, 0x79, 0x20, 0xa7, 0x24, 0x01, - 0x9b, 0x03, 0xd6, 0x0b, 0x23, 0xa3, 0x21, 0x29, 0xe9, 0x30, 0x74, 0x1b, 0x40, 0xce, 0xaf, 0x63, - 0x96, 0x14, 0xf6, 0x6b, 0x47, 0xcb, 0xc6, 0x0f, 0x5d, 0x9f, 0xd8, 0xda, 0x6a, 0xf4, 0x59, 0x2e, - 0xc5, 0xa7, 0x65, 0xe4, 0xb4, 0x20, 0xfa, 0x7f, 0xba, 0xa6, 0x4b, 0x0c, 0xc2, 0x2e, 0x5b, 0x6b, - 0x86, 0x30, 0x7f, 0xd7, 0xe5, 0x47, 0xb8, 0x17, 0x9f, 0x4c, 0x84, 0xfd, 0x10, 0x6a, 0x9c, 0x19, - 0x3f, 0xc1, 0x76, 0x84, 0x03, 0xa7, 0x47, 0xa4, 0xa9, 0x34, 0xec, 0x74, 0xce, 0x3d, 0x81, 0xe1, - 0x2e, 0x37, 0x49, 0x0e, 0x17, 0x63, 0xf3, 0xf7, 0xe3, 0x52, 0xd2, 0x4d, 0x4a, 0xe3, 0xaf, 0xbf, - 0x53, 0x2c, 0xaf, 0x5d, 0xab, 0xc3, 0xb5, 0x6b, 0x41, 0xe4, 0xaf, 0x52, 0xbb, 0xbe, 0xa2, 0xda, - 0xc8, 0x1c, 0xc0, 0xd4, 0x26, 0xa5, 0x5c, 0x10, 0xb4, 0x0e, 0x35, 0x4c, 0x69, 0xe2, 0x9b, 0xe7, - 0x0a, 0x16, 0xc3, 0x51, 0xf8, 0x7f, 0x25, 0x92, 0x40, 0x6d, 0x5e, 0x86, 0x46, 0x0a, 0x7a, 0x19, - 0xdb, 0x86, 0xce, 0x76, 0x15, 0x40, 0x36, 0x67, 0xb7, 0x82, 0xbd, 0x90, 0x1f, 0x29, 0xf7, 0xea, - 0x24, 0xe0, 0xf1, 0xb1, 0x79, 0x25, 0xc1, 0x10, 0xb2, 0xbd, 0x07, 0x13, 0x2e, 0x23, 0x7e, 0x22, - 0xdc, 0xb2, 0x2e, 0x5c, 0x46, 0xc8, 0x96, 0x48, 0xe6, 0x9f, 0xea, 0x70, 0x96, 0x9f, 0xd8, 0x03, - 0x11, 0x0f, 0x36, 0x29, 0xbd, 0x4e, 0x18, 0x76, 0xbd, 0xf8, 0xb3, 0x01, 0x89, 0x0e, 0x5e, 0xb3, - 0x61, 0x74, 0x61, 0x52, 0x86, 0x13, 0x15, 0x33, 0x5f, 0x79, 0x9f, 0xae, 0xc8, 0x67, 0xcd, 0x79, - 0xf5, 0xf5, 0x34, 0xe7, 0x65, 0xcd, 0x72, 0xed, 0x84, 0x9a, 0xe5, 0xc3, 0xef, 0x4b, 0xb4, 0x5b, - 0x98, 0xc9, 0xfc, 0x2d, 0x4c, 0x49, 0x0f, 0x3a, 0x75, 0xd4, 0x1e, 0xb4, 0x5e, 0xda, 0x83, 0xfa, - 0xa5, 0x7e, 0xdc, 0x10, 0xea, 0xfe, 0xb6, 0x6e, 0x81, 0x87, 0xda, 0xda, 0x71, 0xba, 0x51, 0x78, - 0xad, 0xdd, 0xe8, 0xe7, 0xb9, 0xee, 0x52, 0xde, 0xef, 0x7c, 0x70, 0xb4, 0x3d, 0x8d, 0xe8, 0x33, - 0xff, 0xe7, 0x3a, 0xb6, 0x9f, 0x8b, 0x42, 0x9d, 0x86, 0x99, 0x0e, 0xd2, 0x7a, 0x86, 0xe7, 0x21, - 0x5e, 0x43, 0xa8, 0xa0, 0xc5, 0xc7, 0xe8, 0x22, 0xd4, 0xb8, 0x92, 0x55, 0x27, 0x75, 0x46, 0xd7, - 0x27, 0x3f, 0x89, 0x4d, 0x4a, 0x1f, 0x50, 0xe2, 0xd8, 0x02, 0x09, 0x5d, 0x81, 0x46, 0x6a, 0xf8, - 0xca, 0xb3, 0xde, 0xd4, 0x57, 0xa4, 0x7e, 0x92, 0x2c, 0xcb, 0xd0, 0xf9, 0xda, 0x8e, 0x1b, 0x11, - 0x47, 0xf4, 0x19, 0x13, 0xc3, 0x6b, 0xaf, 0x27, 0x1f, 0xd3, 0xb5, 0x29, 0x3a, 0x5a, 0x87, 0x49, - 0x79, 0x21, 0x26, 0x3c, 0x68, 0x7a, 0xe3, 0xec, 0x70, 0x30, 0x4d, 0x56, 0x29, 0x44, 0xf3, 0xcb, - 0x0a, 0xbc, 0x95, 0x19, 0x44, 0xe2, 0x4d, 0x49, 0xab, 0xf7, 0xf5, 0x67, 0xdc, 0xf3, 0x30, 0x27, - 0x7a, 0xcb, 0xec, 0x5e, 0x4c, 0x5e, 0xd1, 0x16, 0xa0, 0xe6, 0xef, 0x2a, 0xf0, 0xce, 0xf0, 0x3e, - 0xae, 0xf5, 0x70, 0xc4, 0xd2, 0xe3, 0x3d, 0x89, 0xbd, 0x24, 0x09, 0x6f, 0x3c, 0x4b, 0x78, 0xb9, - 0xfd, 0x55, 0xf3, 0xfb, 0x33, 0xff, 0x30, 0x0e, 0xd3, 0x9a, 0x01, 0x95, 0x25, 0x4c, 0x5e, 0xd9, - 0x0a, 0xbb, 0x15, 0xb7, 0x09, 0x22, 0x29, 0x34, 0x6c, 0x0d, 0x82, 0xfa, 0x00, 0x14, 0x47, 0xd8, - 0x27, 0x8c, 0x44, 0x3c, 0x92, 0x73, 0x8f, 0xbf, 0x73, 0xfc, 0xe8, 0xb2, 0x9b, 0xd0, 0xb4, 0x35, - 0xf2, 0xbc, 0x34, 0x17, 0xac, 0x63, 0x15, 0xbf, 0xd5, 0x0c, 0x3d, 0x83, 0xb9, 0x3d, 0xd7, 0x23, - 0xbb, 0x99, 0x20, 0x93, 0x42, 0x90, 0xfb, 0xc7, 0x17, 0xe4, 0xa6, 0x4e, 0xd7, 0x2e, 0xb0, 0x31, - 0xd7, 0x60, 0xa1, 0xe8, 0x4f, 0x5c, 0x48, 0xd7, 0xc7, 0xdd, 0x54, 0x5b, 0x6a, 0x66, 0x22, 0x58, - 0x28, 0xfa, 0x8f, 0xf9, 0xf7, 0x71, 0x38, 0x9d, 0x92, 0xdb, 0x0c, 0x82, 0x70, 0x10, 0x38, 0xa2, - 0xc5, 0x2a, 0x3d, 0x8b, 0x25, 0x98, 0x60, 0x2e, 0xf3, 0xd2, 0xc2, 0x47, 0x4c, 0x78, 0xee, 0x62, - 0x61, 0xe8, 0x31, 0x97, 0xaa, 0x03, 0x4e, 0xa6, 0xf2, 0xec, 0x45, 0xd7, 0xd6, 0x11, 0x91, 0xa0, - 0x6e, 0xa7, 0x73, 0xfe, 0x8d, 0x57, 0x35, 0xa2, 0x5f, 0x91, 0xca, 0x4c, 0xe7, 0xc2, 0xee, 0x43, - 0xcf, 0x23, 0x0e, 0x57, 0x87, 0xd6, 0xd1, 0x14, 0xa0, 0xa2, 0x53, 0x62, 0x91, 0x1b, 0x74, 0x55, - 0x3f, 0xa3, 0x66, 0x5c, 0x4e, 0x1c, 0x45, 0xf8, 0xc0, 0xa8, 0x0b, 0x05, 0xc8, 0x09, 0xba, 0x0a, - 0x55, 0x1f, 0x53, 0x95, 0xe8, 0xd6, 0x72, 0xd1, 0xa1, 0x4c, 0x03, 0xd6, 0x0e, 0xa6, 0x32, 0x13, - 0xf0, 0x65, 0xcd, 0x0f, 0x79, 0x3f, 0x4d, 0xbf, 0x7a, 0x49, 0xf8, 0x04, 0x66, 0x73, 0xc1, 0x07, - 0x3d, 0x82, 0xe5, 0xcc, 0xa2, 0x74, 0x86, 0xaa, 0x08, 0x7c, 0xeb, 0xa5, 0x92, 0xd9, 0x87, 0x10, - 0x30, 0x9f, 0xc2, 0x22, 0x37, 0x19, 0xe1, 0xf8, 0x27, 0xd4, 0xda, 0x7c, 0x0c, 0x8d, 0x94, 0x65, - 0xa9, 0xcd, 0x34, 0xa1, 0xbe, 0x9f, 0x34, 0x6d, 0xb2, 0xb7, 0x49, 0xe7, 0xe6, 0x26, 0x20, 0x5d, - 0x5e, 0x95, 0x81, 0x2e, 0xe6, 0x8b, 0xe2, 0xd3, 0xc5, 0x74, 0x23, 0xd0, 0x93, 0x9a, 0xf8, 0xb7, - 0xe3, 0x30, 0xbf, 0xe5, 0x8a, 0xab, 0xb5, 0x13, 0x0a, 0x72, 0x6b, 0xb0, 0x10, 0x0f, 0xda, 0x7e, - 0xd8, 0x19, 0x78, 0x44, 0x15, 0x05, 0x2a, 0xd3, 0x0f, 0xc1, 0x47, 0x05, 0xbf, 0xf4, 0x1a, 0xa5, - 0xa6, 0x5d, 0xa3, 0x5c, 0x85, 0xb3, 0xf7, 0xc8, 0x33, 0xb5, 0x9f, 0x2d, 0x2f, 0x6c, 0xb7, 0xdd, - 0xa0, 0x9b, 0x30, 0x99, 0x10, 0x4c, 0x0e, 0x47, 0x28, 0x2b, 0x15, 0x27, 0x4b, 0x4b, 0x45, 0xf3, - 0x67, 0x15, 0x58, 0xc8, 0xb4, 0xa6, 0xf4, 0x7e, 0x59, 0xfa, 0x87, 0xd4, 0xfa, 0x3b, 0xba, 0xd6, - 0x8b, 0xa8, 0xff, 0xbe, 0x6b, 0xcc, 0xe8, 0xae, 0xf1, 0xcf, 0x0a, 0x9c, 0xde, 0x72, 0x59, 0x12, - 0x94, 0xdc, 0xff, 0xb6, 0x13, 0x2c, 0xd1, 0x77, 0xad, 0x5c, 0xdf, 0x16, 0x2c, 0x17, 0x37, 0xaa, - 0x94, 0xbe, 0x04, 0x13, 0xfc, 0xe4, 0x93, 0xfb, 0x00, 0x39, 0x31, 0x7f, 0x33, 0x09, 0xe7, 0x3e, - 0xa7, 0x1d, 0xcc, 0xd2, 0x2b, 0xc2, 0x9b, 0x61, 0xb4, 0xcb, 0x3f, 0x9d, 0x8c, 0x86, 0x0a, 0x4f, - 0xbf, 0xe3, 0x23, 0x9f, 0x7e, 0xab, 0x23, 0x9e, 0x7e, 0x6b, 0x47, 0x7a, 0xfa, 0x9d, 0x38, 0xb1, - 0xa7, 0xdf, 0xe1, 0x1e, 0x69, 0xb2, 0xb4, 0x47, 0x7a, 0x94, 0xeb, 0x23, 0xa6, 0x84, 0x4b, 0x7c, - 0x4b, 0x77, 0x89, 0x91, 0xa7, 0x33, 0xf2, 0xcd, 0xaa, 0xf0, 0x62, 0x5a, 0x7f, 0xe9, 0x8b, 0x69, - 0x63, 0xf8, 0xc5, 0xb4, 0xfc, 0xd1, 0x0d, 0x0e, 0x7d, 0x74, 0x3b, 0x0f, 0x73, 0xf1, 0x41, 0xe0, - 0x90, 0x4e, 0x7a, 0x71, 0x3c, 0x2d, 0xb7, 0x9d, 0x87, 0xe6, 0xac, 0x7d, 0xa6, 0x60, 0xed, 0xa9, - 0xa5, 0xce, 0x6a, 0x96, 0xfa, 0x9f, 0xd3, 0xd2, 0x5c, 0x81, 0x95, 0xc3, 0xce, 0x44, 0xb9, 0x9a, - 0x01, 0x53, 0x4e, 0x0f, 0x07, 0x5d, 0x71, 0xf9, 0x26, 0x7a, 0x6c, 0x35, 0xdd, 0xf8, 0x23, 0xc0, - 0x62, 0x56, 0x3f, 0xf3, 0xbf, 0xae, 0x43, 0xd0, 0x7d, 0x58, 0xd8, 0x52, 0xbf, 0xeb, 0x48, 0xef, - 0xbe, 0x47, 0x3d, 0x5e, 0x35, 0xdf, 0x2c, 0xff, 0x28, 0xd9, 0x9b, 0x63, 0xc8, 0x81, 0xb3, 0x45, - 0x82, 0xd9, 0x3b, 0xd9, 0xdb, 0x23, 0x28, 0xa7, 0x58, 0x2f, 0x63, 0x71, 0xa1, 0x82, 0x1e, 0xc1, - 0x5c, 0xfe, 0x35, 0x07, 0xe5, 0x0a, 0x8a, 0xd2, 0x07, 0xa6, 0xa6, 0x39, 0x0a, 0x25, 0x95, 0xff, - 0x31, 0x3f, 0xea, 0xdc, 0xc3, 0x05, 0x32, 0xf3, 0xbd, 0x75, 0xd9, 0xd3, 0x4f, 0xf3, 0xff, 0x47, - 0xe2, 0xa4, 0xd4, 0x3f, 0x86, 0x7a, 0x72, 0x2b, 0x9b, 0x57, 0x73, 0xe1, 0xae, 0xb6, 0xb9, 0x90, - 0xa7, 0xb7, 0x17, 0x9b, 0x63, 0xe8, 0x13, 0xb9, 0x78, 0x93, 0xd2, 0x92, 0xc5, 0xda, 0x5d, 0x64, - 0xf3, 0x54, 0xc9, 0xfd, 0x9f, 0x39, 0x86, 0xbe, 0x03, 0xd3, 0x7c, 0xb4, 0xab, 0x7e, 0x51, 0xb1, - 0x6c, 0xc9, 0x1f, 0xf0, 0x58, 0xc9, 0x0f, 0x78, 0xac, 0x1b, 0x3e, 0x65, 0x07, 0xcd, 0x92, 0x0b, - 0x3a, 0x45, 0xe0, 0x31, 0xcc, 0x6e, 0x11, 0x96, 0xf5, 0xd3, 0xe8, 0x9d, 0x23, 0xdd, 0x3a, 0x34, - 0xcd, 0x22, 0xda, 0x70, 0x4b, 0x6e, 0x8e, 0xa1, 0x5f, 0x56, 0xe0, 0xd4, 0x16, 0x61, 0xc5, 0x0e, - 0x15, 0xbd, 0x5f, 0xce, 0xe4, 0x90, 0x4e, 0xb6, 0x79, 0xef, 0xb8, 0x7e, 0x97, 0x27, 0x6b, 0x8e, - 0xa1, 0x5f, 0x55, 0xe0, 0x8c, 0x26, 0x98, 0xde, 0x72, 0xa2, 0xf5, 0xd1, 0xc2, 0x95, 0xb4, 0xa7, - 0xcd, 0xdb, 0xc7, 0xfc, 0xa1, 0x8c, 0x46, 0xd2, 0x1c, 0x43, 0xbb, 0xe2, 0x4c, 0xb2, 0x0a, 0x13, - 0x9d, 0x2b, 0x2d, 0x25, 0x53, 0xee, 0x2b, 0x87, 0x7d, 0x4e, 0xcf, 0xe1, 0x36, 0x4c, 0x6f, 0x11, - 0x96, 0x94, 0x43, 0x79, 0x4b, 0x2b, 0x54, 0xa1, 0x79, 0x57, 0x2d, 0x56, 0x50, 0xc2, 0x62, 0x16, - 0x25, 0x2d, 0xad, 0x2c, 0xc8, 0xfb, 0x6a, 0x69, 0x6d, 0x94, 0xb7, 0x98, 0xf2, 0xaa, 0xc2, 0x1c, - 0x43, 0x4f, 0x61, 0xb9, 0x3c, 0x1c, 0xa2, 0x77, 0x8f, 0x9c, 0xc6, 0x9a, 0x6b, 0x47, 0x41, 0x4d, - 0x58, 0x7e, 0xba, 0xf9, 0xe7, 0x17, 0x2b, 0x95, 0xbf, 0xbe, 0x58, 0xa9, 0xfc, 0xe3, 0xc5, 0x4a, - 0xe5, 0x8b, 0x4b, 0x2f, 0xf9, 0x41, 0x9d, 0xf6, 0xeb, 0x3f, 0x4c, 0x5d, 0xc7, 0x73, 0x49, 0xc0, - 0xda, 0x93, 0xc2, 0xdf, 0x2e, 0xfd, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x5c, 0x9d, 0xd5, 0x22, 0x1c, - 0x28, 0x00, 0x00, + // 2565 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x1a, 0xdb, 0x72, 0x1c, 0x47, + 0x55, 0xab, 0x5d, 0x49, 0xbb, 0x47, 0xf7, 0xb6, 0x2c, 0x8f, 0x37, 0xb1, 0x50, 0x86, 0xc4, 0xe5, + 0x28, 0xc9, 0x2c, 0x92, 0x49, 0x1c, 0x1c, 0x13, 0x4a, 0xf1, 0x45, 0xf2, 0x45, 0xb6, 0x32, 0x76, + 0x42, 0x39, 0x18, 0xa8, 0xde, 0xd9, 0xd6, 0xee, 0x78, 0xe7, 0xd2, 0x9e, 0xe9, 0x95, 0x91, 0xab, + 0xa8, 0xa2, 0x0a, 0x8a, 0x4f, 0xe0, 0x81, 0x57, 0x7e, 0x80, 0x2a, 0x8a, 0xe2, 0x91, 0x07, 0x2a, + 0x05, 0x4f, 0x14, 0xc5, 0x0f, 0x40, 0xf9, 0x85, 0xdf, 0xa0, 0xfa, 0x32, 0x33, 0x3d, 0xb3, 0xa3, + 0xb5, 0x82, 0x6c, 0x05, 0x78, 0x91, 0xba, 0xcf, 0x9c, 0x3e, 0xe7, 0xf4, 0xe9, 0x73, 0xed, 0x5e, + 0x38, 0x1f, 0x11, 0x1a, 0xc6, 0x24, 0xda, 0x27, 0x51, 0x4b, 0x0c, 0x5d, 0x16, 0x46, 0x07, 0xda, + 0xd0, 0xa2, 0x51, 0xc8, 0x42, 0x04, 0x19, 0xa4, 0x69, 0xf6, 0x3f, 0x8c, 0x2d, 0x37, 0x6c, 0x61, + 0xea, 0xb6, 0x9c, 0x30, 0x22, 0xad, 0xfd, 0xf5, 0x56, 0x97, 0x04, 0x24, 0xc2, 0x8c, 0x74, 0x24, + 0x7e, 0xf3, 0xdb, 0x19, 0x8e, 0x8f, 0x9d, 0x9e, 0x1b, 0x90, 0xe8, 0xa0, 0x45, 0xfb, 0x5d, 0x0e, + 0x88, 0x5b, 0x3e, 0x61, 0xb8, 0x6c, 0xd5, 0x9d, 0xae, 0xcb, 0x7a, 0x83, 0xb6, 0xe5, 0x84, 0x7e, + 0x0b, 0x47, 0xdd, 0x90, 0x46, 0xe1, 0x63, 0x31, 0x78, 0xcf, 0xe9, 0xb4, 0xf6, 0x37, 0x32, 0x02, + 0x98, 0x52, 0xcf, 0x75, 0x30, 0x73, 0xc3, 0xa0, 0xb5, 0xbf, 0x8e, 0x3d, 0xda, 0xc3, 0xc3, 0xd4, + 0x5e, 0xeb, 0x86, 0x61, 0xd7, 0x23, 0x2d, 0x31, 0x6b, 0x0f, 0xf6, 0x5a, 0xc4, 0xa7, 0x4c, 0x6d, + 0xc8, 0xfc, 0xeb, 0x2c, 0xcc, 0xef, 0xe0, 0xc0, 0xdd, 0x23, 0x31, 0xb3, 0xc9, 0x93, 0x01, 0x89, + 0x19, 0x7a, 0x04, 0x35, 0xbe, 0x4d, 0xa3, 0xb2, 0x5a, 0xb9, 0x30, 0xbd, 0xb1, 0x6d, 0x65, 0xd2, + 0x58, 0x89, 0x34, 0x62, 0xf0, 0x63, 0xa7, 0x63, 0xed, 0x6f, 0x58, 0xb4, 0xdf, 0xb5, 0xb8, 0x34, + 0x96, 0x26, 0x8d, 0x95, 0x48, 0x63, 0xd9, 0xa9, 0xc2, 0x6c, 0x41, 0x15, 0x35, 0xa1, 0x1e, 0x91, + 0x7d, 0x37, 0x76, 0xc3, 0xc0, 0x18, 0x5f, 0xad, 0x5c, 0x68, 0xd8, 0xe9, 0x1c, 0x19, 0x30, 0x15, + 0x84, 0x57, 0xb1, 0xd3, 0x23, 0x46, 0x75, 0xb5, 0x72, 0xa1, 0x6e, 0x27, 0x53, 0xb4, 0x0a, 0xd3, + 0x98, 0xd2, 0x3b, 0xb8, 0x4d, 0xbc, 0xdb, 0xe4, 0xc0, 0xa8, 0x89, 0x85, 0x3a, 0x88, 0xaf, 0xc5, + 0x94, 0xde, 0xc5, 0x3e, 0x31, 0x26, 0xc4, 0xd7, 0x64, 0x8a, 0x5e, 0x87, 0x46, 0x80, 0x7d, 0x12, + 0x53, 0xec, 0x10, 0xa3, 0x2e, 0xbe, 0x65, 0x00, 0xf4, 0x53, 0x58, 0xd4, 0x04, 0xbf, 0x1f, 0x0e, + 0x22, 0x87, 0x18, 0x20, 0xb6, 0x7e, 0xef, 0x78, 0x5b, 0xdf, 0x2c, 0x92, 0xb5, 0x87, 0x39, 0xa1, + 0x1f, 0xc1, 0x84, 0xb0, 0x29, 0x63, 0x7a, 0xb5, 0xfa, 0x52, 0xb5, 0x2d, 0xc9, 0xa2, 0x00, 0xa6, + 0xa8, 0x37, 0xe8, 0xba, 0x41, 0x6c, 0xcc, 0x08, 0x0e, 0x0f, 0x8e, 0xc7, 0xe1, 0x6a, 0x18, 0xec, + 0xb9, 0xdd, 0x1d, 0x1c, 0xe0, 0x2e, 0xf1, 0x49, 0xc0, 0x76, 0x05, 0x71, 0x3b, 0x61, 0x82, 0x9e, + 0xc1, 0x42, 0x7f, 0x10, 0xb3, 0xd0, 0x77, 0x9f, 0x91, 0x7b, 0x94, 0xaf, 0x8d, 0x8d, 0x59, 0xa1, + 0xcd, 0xbb, 0xc7, 0x63, 0x7c, 0xbb, 0x40, 0xd5, 0x1e, 0xe2, 0xc3, 0x8d, 0xa4, 0x3f, 0x68, 0x93, + 0xcf, 0x49, 0x24, 0xac, 0x6b, 0x4e, 0x1a, 0x89, 0x06, 0x92, 0x66, 0xe4, 0xaa, 0x59, 0x6c, 0xcc, + 0xaf, 0x56, 0xa5, 0x19, 0xa5, 0x20, 0x74, 0x01, 0xe6, 0xf7, 0x49, 0xe4, 0xee, 0x1d, 0xdc, 0x77, + 0xbb, 0x01, 0x66, 0x83, 0x88, 0x18, 0x0b, 0xc2, 0x14, 0x8b, 0x60, 0xe4, 0xc3, 0x6c, 0x8f, 0x78, + 0x3e, 0x57, 0xf9, 0xd5, 0x88, 0x74, 0x62, 0x63, 0x51, 0xe8, 0x77, 0xeb, 0xf8, 0x27, 0x28, 0xc8, + 0xd9, 0x79, 0xea, 0x5c, 0xb0, 0x20, 0xb4, 0x95, 0xa7, 0x48, 0x1f, 0x41, 0x52, 0xb0, 0x02, 0x18, + 0x9d, 0x87, 0x39, 0x16, 0x61, 0xa7, 0xef, 0x06, 0xdd, 0x1d, 0xc2, 0x7a, 0x61, 0xc7, 0x38, 0x25, + 0x34, 0x51, 0x80, 0x22, 0x07, 0x10, 0x09, 0x70, 0xdb, 0x23, 0x1d, 0x69, 0x8b, 0x0f, 0x0e, 0x28, + 0x89, 0x8d, 0x25, 0xb1, 0x8b, 0x8b, 0x96, 0x16, 0xfb, 0x0a, 0x01, 0xc2, 0xba, 0x3e, 0xb4, 0xea, + 0x7a, 0xc0, 0xa2, 0x03, 0xbb, 0x84, 0x1c, 0xea, 0xc3, 0x34, 0xdf, 0x47, 0x62, 0x0a, 0xa7, 0x85, + 0x29, 0xdc, 0x3c, 0x9e, 0x8e, 0xb6, 0x33, 0x82, 0xb6, 0x4e, 0x1d, 0x59, 0x80, 0x7a, 0x38, 0xde, + 0x19, 0x78, 0xcc, 0xa5, 0x1e, 0x91, 0x62, 0xc4, 0xc6, 0xb2, 0x50, 0x53, 0xc9, 0x17, 0x74, 0x1b, + 0x20, 0x22, 0x7b, 0x09, 0xde, 0x19, 0xb1, 0xf3, 0x77, 0x46, 0xed, 0xdc, 0x4e, 0xb1, 0xe5, 0x8e, + 0xb5, 0xe5, 0xa8, 0x0d, 0xa7, 0x34, 0x69, 0x77, 0x08, 0xc3, 0x1d, 0xcc, 0xb0, 0x61, 0x88, 0x1d, + 0x7f, 0xcb, 0x92, 0x99, 0xc0, 0xd2, 0x33, 0x41, 0xb6, 0x4d, 0x9e, 0x09, 0xac, 0xfd, 0x75, 0xeb, + 0x5e, 0xfb, 0x31, 0x71, 0x18, 0x5f, 0x6b, 0x97, 0x11, 0xe3, 0x1b, 0xe4, 0xaa, 0x22, 0x0e, 0x53, + 0x11, 0x45, 0x84, 0x8e, 0xb3, 0xc2, 0x8c, 0x4b, 0xbe, 0x70, 0x7b, 0x57, 0x50, 0x11, 0x18, 0x9b, + 0xd2, 0x23, 0x34, 0x50, 0xf3, 0x3a, 0x9c, 0x39, 0xe4, 0x38, 0xd1, 0x02, 0x54, 0xfb, 0xe4, 0x40, + 0xa4, 0x81, 0x86, 0xcd, 0x87, 0x68, 0x09, 0x26, 0xf6, 0xb1, 0x37, 0x20, 0x22, 0x70, 0xd7, 0x6d, + 0x39, 0xb9, 0x3c, 0xfe, 0x61, 0xa5, 0xf9, 0xcb, 0x0a, 0xcc, 0x17, 0x94, 0x53, 0xb2, 0xfe, 0x87, + 0xfa, 0xfa, 0x97, 0xe0, 0x2a, 0x7b, 0x0f, 0x70, 0xd4, 0x25, 0x4c, 0x13, 0xc4, 0xfc, 0x7b, 0x05, + 0x8c, 0xc2, 0xa9, 0x7d, 0xdf, 0x65, 0xbd, 0x1b, 0xae, 0x47, 0x62, 0x74, 0x09, 0xa6, 0x22, 0x09, + 0x53, 0xc9, 0xed, 0xb5, 0x11, 0x87, 0xbd, 0x3d, 0x66, 0x27, 0xd8, 0xe8, 0x63, 0xa8, 0xfb, 0xc9, + 0x81, 0x4a, 0xd9, 0x57, 0xcb, 0x56, 0x72, 0x2e, 0xc9, 0x59, 0x6d, 0x8f, 0xd9, 0xe9, 0x1a, 0xf4, + 0x3e, 0x4c, 0x38, 0xbd, 0x41, 0xd0, 0x17, 0x69, 0x6d, 0x7a, 0xe3, 0xdc, 0x61, 0x8b, 0xaf, 0x72, + 0xa4, 0xed, 0x31, 0x5b, 0x62, 0x7f, 0x32, 0x09, 0x35, 0x8a, 0x23, 0x66, 0xde, 0x80, 0xa5, 0x32, + 0x16, 0x3c, 0x97, 0x3a, 0x3d, 0xe2, 0xf4, 0xe3, 0x81, 0xaf, 0xd4, 0x9c, 0xce, 0x11, 0x82, 0x5a, + 0xec, 0x3e, 0x93, 0xaa, 0xae, 0xda, 0x62, 0x6c, 0xbe, 0x0d, 0x8b, 0x43, 0xdc, 0xf8, 0xa1, 0x4a, + 0xd9, 0x38, 0x85, 0x19, 0xc5, 0xda, 0x1c, 0xc0, 0xe9, 0x07, 0x42, 0x17, 0x69, 0x42, 0x39, 0x89, + 0xea, 0xc0, 0xdc, 0x86, 0xe5, 0x22, 0xdb, 0x98, 0x86, 0x41, 0x4c, 0xb8, 0xe9, 0x8b, 0x08, 0xec, + 0x92, 0x4e, 0xf6, 0x55, 0x48, 0x51, 0xb7, 0x4b, 0xbe, 0x98, 0xbf, 0x19, 0x87, 0x65, 0x9b, 0xc4, + 0xa1, 0xb7, 0x4f, 0x92, 0xf0, 0x78, 0x32, 0x05, 0xce, 0x0f, 0xa0, 0x8a, 0x29, 0x55, 0x66, 0x72, + 0xf3, 0xa5, 0x95, 0x10, 0x36, 0xa7, 0x8a, 0xde, 0x85, 0x45, 0xec, 0xb7, 0xdd, 0xee, 0x20, 0x1c, + 0xc4, 0xc9, 0xb6, 0x84, 0x51, 0x35, 0xec, 0xe1, 0x0f, 0xdc, 0xfd, 0x63, 0xe1, 0x91, 0x37, 0x83, + 0x0e, 0xf9, 0x89, 0xa8, 0x9a, 0xaa, 0xb6, 0x0e, 0x32, 0x1d, 0x38, 0x33, 0xa4, 0x24, 0xa5, 0x70, + 0xbd, 0x50, 0xab, 0x14, 0x0a, 0xb5, 0x52, 0x31, 0xc6, 0x0f, 0x11, 0xc3, 0xfc, 0x59, 0x05, 0xea, + 0x89, 0xdd, 0xa1, 0x35, 0x58, 0x70, 0x42, 0x9f, 0xba, 0x1e, 0xe9, 0x24, 0x30, 0x45, 0x7e, 0x08, + 0xce, 0xe5, 0x8f, 0xf0, 0xd3, 0x14, 0x4d, 0x32, 0xd0, 0x41, 0xdc, 0xca, 0x29, 0x66, 0x3d, 0xa5, + 0x02, 0x31, 0xe6, 0x30, 0xcf, 0x0d, 0x88, 0xd8, 0xee, 0x84, 0x2d, 0xc6, 0xe6, 0x17, 0x30, 0x73, + 0x8d, 0x50, 0x12, 0x74, 0x48, 0xe0, 0xb8, 0x24, 0x16, 0x38, 0xa1, 0xd3, 0x57, 0x9c, 0xc5, 0x98, + 0xc3, 0x3a, 0x84, 0xc6, 0x8a, 0x8d, 0x18, 0x23, 0x13, 0x66, 0x78, 0x0c, 0x70, 0x23, 0x51, 0xec, + 0xc4, 0x8a, 0x4f, 0x0e, 0x66, 0xc6, 0x70, 0x4a, 0x3b, 0xa7, 0xb4, 0x92, 0x58, 0x01, 0xc0, 0x94, + 0x26, 0xc5, 0x88, 0x64, 0xa4, 0x41, 0xd0, 0x15, 0x98, 0xe9, 0x68, 0x22, 0x29, 0x83, 0x31, 0xf4, + 0xd0, 0xa0, 0x8b, 0x6c, 0xe7, 0xb0, 0xcd, 0x2f, 0xab, 0xb0, 0x90, 0x05, 0x2c, 0x75, 0x64, 0x1b, + 0xd0, 0xf0, 0x15, 0x2c, 0x36, 0x2a, 0x22, 0x9d, 0x2d, 0x95, 0x46, 0xb8, 0x0c, 0x2d, 0x5f, 0x1d, + 0x8f, 0x17, 0xab, 0xe3, 0x65, 0x98, 0x94, 0x6d, 0x91, 0xda, 0xb9, 0x9a, 0xe5, 0x8c, 0xa3, 0x56, + 0x30, 0x8e, 0x15, 0x80, 0x38, 0xcd, 0x25, 0xc6, 0xa4, 0xdc, 0x78, 0x06, 0xe1, 0x3a, 0x95, 0xb5, + 0x94, 0x4d, 0xe2, 0x81, 0xc7, 0x8c, 0x29, 0xa9, 0x53, 0x1d, 0x86, 0xde, 0x84, 0x59, 0x27, 0xf4, + 0x7d, 0x97, 0xed, 0x90, 0x38, 0xc6, 0xdd, 0xa4, 0x6e, 0xcf, 0x03, 0x39, 0x25, 0x09, 0xd8, 0x1c, + 0xb0, 0x5e, 0x18, 0x19, 0x0d, 0x49, 0x49, 0x87, 0xa1, 0x5b, 0x00, 0x72, 0x7e, 0x0d, 0xb3, 0xa4, + 0xb0, 0x5f, 0x3b, 0x5a, 0x36, 0x7e, 0xe0, 0xfa, 0xc4, 0xd6, 0x56, 0xa3, 0x4f, 0x73, 0x29, 0x3e, + 0x2d, 0x23, 0xa7, 0x05, 0xd1, 0x6f, 0xe8, 0x9a, 0x2e, 0x31, 0x08, 0xbb, 0x6c, 0xad, 0x19, 0xc2, + 0xfc, 0x1d, 0x97, 0x1f, 0xe1, 0x5e, 0x7c, 0x32, 0x11, 0xf6, 0x03, 0xa8, 0x71, 0x66, 0xfc, 0x04, + 0xdb, 0x11, 0x0e, 0x9c, 0x1e, 0x91, 0xa6, 0xd2, 0xb0, 0xd3, 0x39, 0xf7, 0x04, 0x86, 0xbb, 0xdc, + 0x24, 0x39, 0x5c, 0x8c, 0xcd, 0x3f, 0x8c, 0x4b, 0x49, 0x37, 0x29, 0x8d, 0xbf, 0xfe, 0x4e, 0xb1, + 0xbc, 0x76, 0xad, 0x0e, 0xd7, 0xae, 0x05, 0x91, 0xbf, 0x4a, 0xed, 0xfa, 0x92, 0x6a, 0x23, 0x73, + 0x00, 0x53, 0x9b, 0x94, 0x72, 0x41, 0xd0, 0x3a, 0xd4, 0x30, 0xa5, 0x89, 0x6f, 0x9e, 0x2b, 0x58, + 0x0c, 0x47, 0xe1, 0xff, 0x95, 0x48, 0x02, 0xb5, 0x79, 0x09, 0x1a, 0x29, 0xe8, 0x45, 0x6c, 0x1b, + 0x3a, 0xdb, 0x55, 0x00, 0xd9, 0x9c, 0xdd, 0x0c, 0xf6, 0x42, 0x7e, 0xa4, 0xdc, 0xab, 0x93, 0x80, + 0xc7, 0xc7, 0xe6, 0xe5, 0x04, 0x43, 0xc8, 0xf6, 0x2e, 0x4c, 0xb8, 0x8c, 0xf8, 0x89, 0x70, 0xcb, + 0xba, 0x70, 0x19, 0x21, 0x5b, 0x22, 0x99, 0x7f, 0xae, 0xc3, 0x59, 0x7e, 0x62, 0xf7, 0x45, 0x3c, + 0xd8, 0xa4, 0xf4, 0x1a, 0x61, 0xd8, 0xf5, 0xe2, 0x4f, 0x07, 0x24, 0x3a, 0x78, 0xc5, 0x86, 0xd1, + 0x85, 0x49, 0x19, 0x4e, 0x54, 0xcc, 0x7c, 0xe9, 0x7d, 0xba, 0x22, 0x9f, 0x35, 0xe7, 0xd5, 0x57, + 0xd3, 0x9c, 0x97, 0x35, 0xcb, 0xb5, 0x13, 0x6a, 0x96, 0x0f, 0xbf, 0x2f, 0xd1, 0x6e, 0x61, 0x26, + 0xf3, 0xb7, 0x30, 0x25, 0x3d, 0xe8, 0xd4, 0x51, 0x7b, 0xd0, 0x7a, 0x69, 0x0f, 0xea, 0x97, 0xfa, + 0x71, 0x43, 0xa8, 0xfb, 0xbb, 0xba, 0x05, 0x1e, 0x6a, 0x6b, 0xc7, 0xe9, 0x46, 0xe1, 0x95, 0x76, + 0xa3, 0x9f, 0xe5, 0xba, 0x4b, 0x79, 0xbf, 0xf3, 0xfe, 0xd1, 0xf6, 0x34, 0xa2, 0xcf, 0xfc, 0xbf, + 0xeb, 0xd8, 0x7e, 0x21, 0x0a, 0x75, 0x1a, 0x66, 0x3a, 0x48, 0xeb, 0x19, 0x9e, 0x87, 0x78, 0x0d, + 0xa1, 0x82, 0x16, 0x1f, 0xa3, 0x77, 0xa0, 0xc6, 0x95, 0xac, 0x3a, 0xa9, 0x33, 0xba, 0x3e, 0xf9, + 0x49, 0x6c, 0x52, 0x7a, 0x9f, 0x12, 0xc7, 0x16, 0x48, 0xe8, 0x32, 0x34, 0x52, 0xc3, 0x57, 0x9e, + 0xf5, 0xba, 0xbe, 0x22, 0xf5, 0x93, 0x64, 0x59, 0x86, 0xce, 0xd7, 0x76, 0xdc, 0x88, 0x38, 0xa2, + 0xcf, 0x98, 0x18, 0x5e, 0x7b, 0x2d, 0xf9, 0x98, 0xae, 0x4d, 0xd1, 0xd1, 0x3a, 0x4c, 0xca, 0x0b, + 0x31, 0xe1, 0x41, 0xd3, 0x1b, 0x67, 0x87, 0x83, 0x69, 0xb2, 0x4a, 0x21, 0x9a, 0x5f, 0x56, 0xe0, + 0x8d, 0xcc, 0x20, 0x12, 0x6f, 0x4a, 0x5a, 0xbd, 0xaf, 0x3f, 0xe3, 0x9e, 0x87, 0x39, 0xd1, 0x5b, + 0x66, 0xf7, 0x62, 0xf2, 0x8a, 0xb6, 0x00, 0x35, 0x7f, 0x5f, 0x81, 0xb7, 0x86, 0xf7, 0x71, 0xb5, + 0x87, 0x23, 0x96, 0x1e, 0xef, 0x49, 0xec, 0x25, 0x49, 0x78, 0xe3, 0x59, 0xc2, 0xcb, 0xed, 0xaf, + 0x9a, 0xdf, 0x9f, 0xf9, 0xc7, 0x71, 0x98, 0xd6, 0x0c, 0xa8, 0x2c, 0x61, 0xf2, 0xca, 0x56, 0xd8, + 0xad, 0xb8, 0x4d, 0x10, 0x49, 0xa1, 0x61, 0x6b, 0x10, 0xd4, 0x07, 0xa0, 0x38, 0xc2, 0x3e, 0x61, + 0x24, 0xe2, 0x91, 0x9c, 0x7b, 0xfc, 0xed, 0xe3, 0x47, 0x97, 0xdd, 0x84, 0xa6, 0xad, 0x91, 0xe7, + 0xa5, 0xb9, 0x60, 0x1d, 0xab, 0xf8, 0xad, 0x66, 0xe8, 0x29, 0xcc, 0xed, 0xb9, 0x1e, 0xd9, 0xcd, + 0x04, 0x99, 0x14, 0x82, 0xdc, 0x3b, 0xbe, 0x20, 0x37, 0x74, 0xba, 0x76, 0x81, 0x8d, 0xb9, 0x06, + 0x0b, 0x45, 0x7f, 0xe2, 0x42, 0xba, 0x3e, 0xee, 0xa6, 0xda, 0x52, 0x33, 0x13, 0xc1, 0x42, 0xd1, + 0x7f, 0xcc, 0x7f, 0x8c, 0xc3, 0xe9, 0x94, 0xdc, 0x66, 0x10, 0x84, 0x83, 0xc0, 0x11, 0x2d, 0x56, + 0xe9, 0x59, 0x2c, 0xc1, 0x04, 0x73, 0x99, 0x97, 0x16, 0x3e, 0x62, 0xc2, 0x73, 0x17, 0x0b, 0x43, + 0x8f, 0xb9, 0x54, 0x1d, 0x70, 0x32, 0x95, 0x67, 0x2f, 0xba, 0xb6, 0x8e, 0x88, 0x04, 0x75, 0x3b, + 0x9d, 0xf3, 0x6f, 0xbc, 0xaa, 0x11, 0xfd, 0x8a, 0x54, 0x66, 0x3a, 0x17, 0x76, 0x1f, 0x7a, 0x1e, + 0x71, 0xb8, 0x3a, 0xb4, 0x8e, 0xa6, 0x00, 0x15, 0x9d, 0x12, 0x8b, 0xdc, 0xa0, 0xab, 0xfa, 0x19, + 0x35, 0xe3, 0x72, 0xe2, 0x28, 0xc2, 0x07, 0x46, 0x5d, 0x28, 0x40, 0x4e, 0xd0, 0x15, 0xa8, 0xfa, + 0x98, 0xaa, 0x44, 0xb7, 0x96, 0x8b, 0x0e, 0x65, 0x1a, 0xb0, 0x76, 0x30, 0x95, 0x99, 0x80, 0x2f, + 0x6b, 0x7e, 0xc0, 0xfb, 0x69, 0xfa, 0xd5, 0x4b, 0xc2, 0xc7, 0x30, 0x9b, 0x0b, 0x3e, 0xe8, 0x21, + 0x2c, 0x67, 0x16, 0xa5, 0x33, 0x54, 0x45, 0xe0, 0x1b, 0x2f, 0x94, 0xcc, 0x3e, 0x84, 0x80, 0xf9, + 0x04, 0x16, 0xb9, 0xc9, 0x08, 0xc7, 0x3f, 0xa1, 0xd6, 0xe6, 0x23, 0x68, 0xa4, 0x2c, 0x4b, 0x6d, + 0xa6, 0x09, 0xf5, 0xfd, 0xa4, 0x69, 0x93, 0xbd, 0x4d, 0x3a, 0x37, 0x37, 0x01, 0xe9, 0xf2, 0xaa, + 0x0c, 0xf4, 0x4e, 0xbe, 0x28, 0x3e, 0x5d, 0x4c, 0x37, 0x02, 0x3d, 0xa9, 0x89, 0x7f, 0x37, 0x0e, + 0xf3, 0x5b, 0xae, 0xb8, 0x5a, 0x3b, 0xa1, 0x20, 0xb7, 0x06, 0x0b, 0xf1, 0xa0, 0xed, 0x87, 0x9d, + 0x81, 0x47, 0x54, 0x51, 0xa0, 0x32, 0xfd, 0x10, 0x7c, 0x54, 0xf0, 0x4b, 0xaf, 0x51, 0x6a, 0xda, + 0x35, 0xca, 0x15, 0x38, 0x7b, 0x97, 0x3c, 0x55, 0xfb, 0xd9, 0xf2, 0xc2, 0x76, 0xdb, 0x0d, 0xba, + 0x09, 0x93, 0x09, 0xc1, 0xe4, 0x70, 0x84, 0xb2, 0x52, 0x71, 0xb2, 0xb4, 0x54, 0x34, 0x7f, 0x5e, + 0x81, 0x85, 0x4c, 0x6b, 0x4a, 0xef, 0x97, 0xa4, 0x7f, 0x48, 0xad, 0xbf, 0xa5, 0x6b, 0xbd, 0x88, + 0xfa, 0x9f, 0xbb, 0xc6, 0x8c, 0xee, 0x1a, 0xff, 0xaa, 0xc0, 0xe9, 0x2d, 0x97, 0x25, 0x41, 0xc9, + 0xfd, 0x5f, 0x3b, 0xc1, 0x12, 0x7d, 0xd7, 0xca, 0xf5, 0x6d, 0xc1, 0x72, 0x71, 0xa3, 0x4a, 0xe9, + 0x4b, 0x30, 0xc1, 0x4f, 0x3e, 0xb9, 0x0f, 0x90, 0x13, 0xf3, 0xb7, 0x93, 0x70, 0xee, 0x33, 0xda, + 0xc1, 0x2c, 0xbd, 0x22, 0xbc, 0x11, 0x46, 0xbb, 0xfc, 0xd3, 0xc9, 0x68, 0xa8, 0xf0, 0xf4, 0x3b, + 0x3e, 0xf2, 0xe9, 0xb7, 0x3a, 0xe2, 0xe9, 0xb7, 0x76, 0xa4, 0xa7, 0xdf, 0x89, 0x13, 0x7b, 0xfa, + 0x1d, 0xee, 0x91, 0x26, 0x4b, 0x7b, 0xa4, 0x87, 0xb9, 0x3e, 0x62, 0x4a, 0xb8, 0xc4, 0x77, 0x74, + 0x97, 0x18, 0x79, 0x3a, 0x23, 0xdf, 0xac, 0x0a, 0x2f, 0xa6, 0xf5, 0x17, 0xbe, 0x98, 0x36, 0x86, + 0x5f, 0x4c, 0xcb, 0x1f, 0xdd, 0xe0, 0xd0, 0x47, 0xb7, 0xf3, 0x30, 0x17, 0x1f, 0x04, 0x0e, 0xe9, + 0xa4, 0x17, 0xc7, 0xd3, 0x72, 0xdb, 0x79, 0x68, 0xce, 0xda, 0x67, 0x0a, 0xd6, 0x9e, 0x5a, 0xea, + 0xac, 0x66, 0xa9, 0xff, 0x3d, 0x2d, 0xcd, 0xe7, 0xb0, 0x72, 0xd8, 0x99, 0x28, 0x57, 0x33, 0x60, + 0xca, 0xe9, 0xe1, 0xa0, 0x2b, 0x2e, 0xdf, 0x44, 0x8f, 0xad, 0xa6, 0xa3, 0x6a, 0xf0, 0x8d, 0x3f, + 0x01, 0x2c, 0x66, 0xb5, 0x35, 0xff, 0xeb, 0x3a, 0x04, 0xdd, 0x83, 0x85, 0x2d, 0xf5, 0x9b, 0x8f, + 0xf4, 0x5e, 0x7c, 0xd4, 0xc3, 0x56, 0xf3, 0xf5, 0xf2, 0x8f, 0x52, 0x34, 0x73, 0x0c, 0x39, 0x70, + 0xb6, 0x48, 0x30, 0x7b, 0x43, 0x7b, 0x73, 0x04, 0xe5, 0x14, 0xeb, 0x45, 0x2c, 0x2e, 0x54, 0xd0, + 0x43, 0x98, 0xcb, 0xbf, 0xf4, 0xa0, 0x5c, 0xb1, 0x51, 0xfa, 0xf8, 0xd4, 0x34, 0x47, 0xa1, 0xa4, + 0xf2, 0x3f, 0xe2, 0x66, 0x90, 0x7b, 0xd4, 0x40, 0x66, 0xbe, 0xef, 0x2e, 0x7b, 0x16, 0x6a, 0x7e, + 0x73, 0x24, 0x4e, 0x4a, 0xfd, 0x23, 0xa8, 0x27, 0x37, 0xb6, 0x79, 0x35, 0x17, 0xee, 0x71, 0x9b, + 0x0b, 0x79, 0x7a, 0x7b, 0xb1, 0x39, 0x86, 0x3e, 0x96, 0x8b, 0x37, 0x29, 0x2d, 0x59, 0xac, 0xdd, + 0x53, 0x36, 0x4f, 0x95, 0xdc, 0x0d, 0x9a, 0x63, 0xe8, 0x7b, 0x30, 0xcd, 0x47, 0xbb, 0xea, 0xd7, + 0x16, 0xcb, 0x96, 0xfc, 0x71, 0x8f, 0x95, 0xfc, 0xb8, 0xc7, 0xba, 0xee, 0x53, 0x76, 0xd0, 0x2c, + 0xb9, 0xbc, 0x53, 0x04, 0x1e, 0xc1, 0xec, 0x16, 0x61, 0x59, 0xaf, 0x8d, 0xde, 0x3a, 0xd2, 0x8d, + 0x44, 0xd3, 0x2c, 0xa2, 0x0d, 0xb7, 0xeb, 0xe6, 0x18, 0xfa, 0x55, 0x05, 0x4e, 0x6d, 0x11, 0x56, + 0xec, 0x5e, 0xd1, 0x7b, 0xe5, 0x4c, 0x0e, 0xe9, 0x72, 0x9b, 0x77, 0x8f, 0xeb, 0x93, 0x79, 0xb2, + 0xe6, 0x18, 0xfa, 0x75, 0x05, 0xce, 0x68, 0x82, 0xe9, 0xed, 0x28, 0x5a, 0x1f, 0x2d, 0x5c, 0x49, + 0xeb, 0xda, 0xbc, 0x75, 0xcc, 0x1f, 0xd1, 0x68, 0x24, 0xcd, 0x31, 0xb4, 0x2b, 0xce, 0x24, 0xab, + 0x3e, 0xd1, 0xb9, 0xd2, 0x32, 0x33, 0xe5, 0xbe, 0x72, 0xd8, 0xe7, 0xf4, 0x1c, 0x6e, 0xc1, 0xf4, + 0x16, 0x61, 0x49, 0xa9, 0x94, 0xb7, 0xb4, 0x42, 0x85, 0x9a, 0x77, 0xd5, 0x62, 0x75, 0x25, 0x2c, + 0x66, 0x51, 0xd2, 0xd2, 0x4a, 0x86, 0xbc, 0xaf, 0x96, 0xd6, 0x4d, 0x79, 0x8b, 0x29, 0xaf, 0x38, + 0xcc, 0x31, 0xf4, 0x04, 0x96, 0xcb, 0x43, 0x25, 0x7a, 0xfb, 0xc8, 0x29, 0xae, 0xb9, 0x76, 0x14, + 0xd4, 0x84, 0xe5, 0x27, 0x9b, 0x7f, 0x79, 0xbe, 0x52, 0xf9, 0xdb, 0xf3, 0x95, 0xca, 0x3f, 0x9f, + 0xaf, 0x54, 0xbe, 0xb8, 0xf8, 0x82, 0x1f, 0xdb, 0x69, 0xbf, 0x0c, 0xc4, 0xd4, 0x75, 0x3c, 0x97, + 0x04, 0xac, 0x3d, 0x29, 0xfc, 0xed, 0xe2, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x37, 0xf3, 0xb5, + 0x84, 0x38, 0x28, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5803,6 +5811,13 @@ func (m *UpdateRevisionForPathsResponse) MarshalToSizedBuffer(dAtA []byte) (int, i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if len(m.Revision) > 0 { + i -= len(m.Revision) + copy(dAtA[i:], m.Revision) + i = encodeVarintRepository(dAtA, i, uint64(len(m.Revision))) + i-- + dAtA[i] = 0x12 + } if m.Changes { i-- if m.Changes { @@ -6890,6 +6905,10 @@ func (m *UpdateRevisionForPathsResponse) Size() (n int) { if m.Changes { n += 2 } + l = len(m.Revision) + if l > 0 { + n += 1 + l + sovRepository(uint64(l)) + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -13710,6 +13729,38 @@ func (m *UpdateRevisionForPathsResponse) Unmarshal(dAtA []byte) error { } } m.Changes = bool(v != 0) + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRepository + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthRepository + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthRepository + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Revision = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipRepository(dAtA[iNdEx:]) diff --git a/reposerver/repository/repository.go b/reposerver/repository/repository.go index 4c53f2b08d7ed..a54a09e8c6e23 100644 --- a/reposerver/repository/repository.go +++ b/reposerver/repository/repository.go @@ -2988,7 +2988,7 @@ func (s *Service) UpdateRevisionForPaths(_ context.Context, request *apiclient.U return &apiclient.UpdateRevisionForPathsResponse{}, nil } - gitClientOpts := git.WithCache(s.cache, true) + gitClientOpts := git.WithCache(s.cache, false) gitClient, revision, err := s.newClientResolveRevision(repo, revision, gitClientOpts) if err != nil { return nil, status.Errorf(codes.Internal, "unable to resolve git revision %s: %v", revision, err) @@ -3001,7 +3001,9 @@ func (s *Service) UpdateRevisionForPaths(_ context.Context, request *apiclient.U // No need to compare if it is the same revision if revision == syncedRevision { - return &apiclient.UpdateRevisionForPathsResponse{}, nil + return &apiclient.UpdateRevisionForPathsResponse{ + Revision: revision, + }, nil } s.metricsServer.IncPendingRepoRequest(repo.Repo) @@ -3029,14 +3031,14 @@ func (s *Service) UpdateRevisionForPaths(_ context.Context, request *apiclient.U if err != nil { // Only warn with the error, no need to block anything if there is a caching error. logCtx.Warnf("error updating cached revision for repo %s with revision %s: %v", repo.Repo, revision, err) - return &apiclient.UpdateRevisionForPathsResponse{}, nil + return &apiclient.UpdateRevisionForPathsResponse{Revision: revision,}, nil } - return &apiclient.UpdateRevisionForPathsResponse{}, nil + return &apiclient.UpdateRevisionForPathsResponse{Revision: revision,}, nil } logCtx.Debugf("changes found for application %s in repo %s from revision %s to revision %s", request.AppName, repo.Repo, syncedRevision, revision) - return &apiclient.UpdateRevisionForPathsResponse{Changes: true}, nil + return &apiclient.UpdateRevisionForPathsResponse{Changes: true, Revision: revision,}, nil } func (s *Service) updateCachedRevision(logCtx *log.Entry, oldRev string, newRev string, request *apiclient.UpdateRevisionForPathsRequest, gitClientOpts git.ClientOpts) error { diff --git a/reposerver/repository/repository.proto b/reposerver/repository/repository.proto index 0bdf37b88bfc1..eb8e7077a0f20 100644 --- a/reposerver/repository/repository.proto +++ b/reposerver/repository/repository.proto @@ -313,6 +313,7 @@ message UpdateRevisionForPathsRequest { message UpdateRevisionForPathsResponse { bool changes = 1; + string revision = 2; } // ManifestService From 568b0f7556b92a989f1fead0593b51270db8abf1 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 15:06:33 +0300 Subject: [PATCH 15/30] chore: update version to 2.11-2024.8.8-9011506bf --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.8-9011506bf.md | 2 ++ changelog/CHANGELOG.md | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.8-9011506bf.md create mode 100644 changelog/CHANGELOG.md diff --git a/VERSION b/VERSION index ffcc3c06c24fc..f6dc6914af541 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.8-f3821b5f9 \ No newline at end of file +2.11-2024.8.8-9011506bf \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.8-9011506bf.md b/changelog/CHANGELOG-2.11-2024.8.8-9011506bf.md new file mode 100644 index 0000000000000..69a0c0c996d13 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.8-9011506bf.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal should work with monorepo additional, fix revision persistance \ No newline at end of file diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md new file mode 100644 index 0000000000000..44f728a89a47b --- /dev/null +++ b/changelog/CHANGELOG.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal should work with monorepo additional logs \ No newline at end of file From 0c809966a0e47f115c7002618bc8898fe410f913 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 18:55:20 +0300 Subject: [PATCH 16/30] fix monorepo selfheal support and add logs --- changelog/CHANGELOG.md | 2 -- controller/appcontroller.go | 5 ++--- controller/appcontroller_test.go | 12 ++++++------ 3 files changed, 8 insertions(+), 11 deletions(-) delete mode 100644 changelog/CHANGELOG.md diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md deleted file mode 100644 index 44f728a89a47b..0000000000000 --- a/changelog/CHANGELOG.md +++ /dev/null @@ -1,2 +0,0 @@ -### Chore -- chore: selfheal should work with monorepo additional logs \ No newline at end of file diff --git a/controller/appcontroller.go b/controller/appcontroller.go index 1216b63527571..e2991724b86f8 100644 --- a/controller/appcontroller.go +++ b/controller/appcontroller.go @@ -1858,7 +1858,7 @@ func (ctrl *ApplicationController) autoSync(app *appv1.Application, syncStatus * desiredCommitSHA := syncStatus.Revision desiredCommitSHAsMS := syncStatus.Revisions - alreadyAttempted, attemptPhase := alreadyAttemptedSync(app, desiredCommitSHA, desiredCommitSHAsMS, app.Spec.HasMultipleSources()) + alreadyAttempted, attemptPhase := alreadyAttemptedSync(app, desiredCommitSHA, desiredCommitSHAsMS, app.Spec.HasMultipleSources(), syncStatus.ManifestsChanged) selfHeal := app.Spec.SyncPolicy.Automated.SelfHeal op := appv1.Operation{ Sync: &appv1.SyncOperation{ @@ -1951,7 +1951,7 @@ func (ctrl *ApplicationController) autoSync(app *appv1.Application, syncStatus * // alreadyAttemptedSync returns whether the most recent sync was performed against the // commitSHA and with the same app source config which are currently set in the app -func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS []string, hasMultipleSources bool) (bool, synccommon.OperationPhase) { +func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS []string, hasMultipleSources bool, manifestsChangedMap map[string]bool) (bool, synccommon.OperationPhase) { if app.Status.OperationState == nil || app.Status.OperationState.Operation.Sync == nil || app.Status.OperationState.SyncResult == nil { return false, "" } @@ -1960,7 +1960,6 @@ func alreadyAttemptedSync(app *appv1.Application, commitSHA string, commitSHAsMS return false, "" } } else { - manifestsChangedMap := app.Status.Sync.ManifestsChanged manifestChanged, ok := manifestsChangedMap[commitSHA] featureFlagDisabled := os.Getenv("PERSIST_CHANGE_REVISIONS") != "1" // If record not exists, we need to do sync diff --git a/controller/appcontroller_test.go b/controller/appcontroller_test.go index 94a6c545a71a4..cc40516123e0a 100644 --- a/controller/appcontroller_test.go +++ b/controller/appcontroller_test.go @@ -1940,7 +1940,7 @@ func TestAlreadyAttemptSync(t *testing.T) { app.Status.Sync.ManifestsChanged = manifestChangedMap - attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, nil) assert.False(t, attempted) }) @@ -1953,7 +1953,7 @@ func TestAlreadyAttemptSync(t *testing.T) { app.Status.Sync.ManifestsChanged = manifestChangedMap - attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, manifestChangedMap) assert.True(t, attempted) }) @@ -1964,7 +1964,7 @@ func TestAlreadyAttemptSync(t *testing.T) { app.Status.Sync.ManifestsChanged = manifestChangedMap - attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, nil) assert.False(t, attempted) }) @@ -1977,7 +1977,7 @@ func TestAlreadyAttemptSync(t *testing.T) { app.Status.Sync.ManifestsChanged = manifestChangedMap - attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, manifestChangedMap) assert.False(t, attempted) }) @@ -1985,7 +1985,7 @@ func TestAlreadyAttemptSync(t *testing.T) { _ = os.Setenv("PERSIST_CHANGE_REVISIONS", "1") - attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, nil) assert.False(t, attempted) }) @@ -1998,7 +1998,7 @@ func TestAlreadyAttemptSync(t *testing.T) { app.Status.Sync.ManifestsChanged = manifestChangedMap - attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false) + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, manifestChangedMap) assert.True(t, attempted) }) } From 006029f25f4520fb4424c1b8cd3f7635c1e98686 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 8 Aug 2024 18:56:08 +0300 Subject: [PATCH 17/30] chore: update version to 2.11-2024.8.8-0c809966a --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.8-0c809966a.md | 2 ++ changelog/CHANGELOG.md | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.8-0c809966a.md create mode 100644 changelog/CHANGELOG.md diff --git a/VERSION b/VERSION index f6dc6914af541..921d6f0bf290d 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.8-9011506bf \ No newline at end of file +2.11-2024.8.8-0c809966a \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.8-0c809966a.md b/changelog/CHANGELOG-2.11-2024.8.8-0c809966a.md new file mode 100644 index 0000000000000..ebc2a9bf740e4 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.8-0c809966a.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal should work with monorepo \ No newline at end of file diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md new file mode 100644 index 0000000000000..44f728a89a47b --- /dev/null +++ b/changelog/CHANGELOG.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal should work with monorepo additional logs \ No newline at end of file From 90f077d809c770887f33482016882ad0c59a2a2c Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Fri, 16 Aug 2024 11:18:14 +0300 Subject: [PATCH 18/30] fix repo tests --- reposerver/repository/repository_test.go | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) diff --git a/reposerver/repository/repository_test.go b/reposerver/repository/repository_test.go index a8821e127ee31..14456fae1f34f 100644 --- a/reposerver/repository/repository_test.go +++ b/reposerver/repository/repository_test.go @@ -3504,7 +3504,9 @@ func TestUpdateRevisionForPaths(t *testing.T) { SyncedRevision: "SYNCEDHEAD", Paths: []string{"."}, }, - }, want: &apiclient.UpdateRevisionForPathsResponse{}, wantErr: assert.NoError}, + }, want: &apiclient.UpdateRevisionForPathsResponse{ + Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + }, wantErr: assert.NoError}, {name: "ChangedFilesDoNothing", fields: func() fields { s, _, c := newServiceWithOpt(t, func(gitClient *gitmocks.Client, helmClient *helmmocks.Client, paths *iomocks.TempPaths) { gitClient.On("Init").Return(nil) @@ -3531,6 +3533,7 @@ func TestUpdateRevisionForPaths(t *testing.T) { }, }, want: &apiclient.UpdateRevisionForPathsResponse{ Changes: true, + Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", }, wantErr: assert.NoError}, {name: "NoChangesUpdateCache", fields: func() fields { s, _, c := newServiceWithOpt(t, func(gitClient *gitmocks.Client, helmClient *helmmocks.Client, paths *iomocks.TempPaths) { @@ -3563,7 +3566,9 @@ func TestUpdateRevisionForPaths(t *testing.T) { ApplicationSource: &argoappv1.ApplicationSource{Path: "."}, KubeVersion: "v1.16.0", }, - }, want: &apiclient.UpdateRevisionForPathsResponse{}, wantErr: assert.NoError, cacheHit: &cacheHit{ + }, want: &apiclient.UpdateRevisionForPathsResponse{ + Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + }, wantErr: assert.NoError, cacheHit: &cacheHit{ previousRevision: "1e67a504d03def3a6a1125d934cb511680f72555", revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", }}, @@ -3600,7 +3605,9 @@ func TestUpdateRevisionForPaths(t *testing.T) { HasMultipleSources: true, }, - }, want: &apiclient.UpdateRevisionForPathsResponse{}, wantErr: assert.NoError, cacheHit: &cacheHit{ + }, want: &apiclient.UpdateRevisionForPathsResponse{ + Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + }, wantErr: assert.NoError, cacheHit: &cacheHit{ previousRevision: "1e67a504d03def3a6a1125d934cb511680f72555", revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", }}, From 6be897266aa5a1d1cfe31134d52724acda3a9e2c Mon Sep 17 00:00:00 2001 From: Oleksandr Saulyak Date: Mon, 19 Aug 2024 11:03:07 +0300 Subject: [PATCH 19/30] chore: remove v1 reporter (#327) * event-reporter: added errors parser test from v1 reporter * server: removed v1 reporter code base * event-reporter: removed check of codefresh reporter version * removing v1 reporter leftovers * re-generated files * updated changelog * trigger commit * fix lint issue * mod tidy * lint fix --- assets/swagger.json | 61 -- changelog/CHANGELOG.md | 2 +- controller/appcontroller_test.go | 2 +- .../notifications/services/opsgenie.md | 48 +- .../applications_errors_parser_test.go | 2 +- event_reporter/reporter/broadcaster.go | 5 - event_reporter/reporter/feature_manager.go | 27 - event_reporter/server.go | 1 - go.mod | 2 +- pkg/apiclient/events/events.pb.go | 237 ++--- pkg/apiclient/events/events.pb.gw.go | 147 ---- reposerver/repository/repository.go | 6 +- reposerver/repository/repository_test.go | 10 +- server/application/application.go | 339 +------- .../application/application_errors_parser.go | 147 ---- .../application/application_event_reporter.go | 811 ------------------ .../application_event_reporter_test.go | 452 ---------- .../application_validate_src_and_dest.go | 90 ++ server/application/events.proto | 7 - server/server.go | 3 - util/settings/settings.go | 22 - 21 files changed, 221 insertions(+), 2200 deletions(-) rename {server/application => event_reporter/reporter}/applications_errors_parser_test.go (99%) delete mode 100644 pkg/apiclient/events/events.pb.gw.go delete mode 100644 server/application/application_errors_parser.go delete mode 100644 server/application/application_event_reporter.go delete mode 100644 server/application/application_event_reporter_test.go create mode 100644 server/application/application_validate_src_and_dest.go diff --git a/assets/swagger.json b/assets/swagger.json index 1e467c4aa18bc..3d1d39da23a2c 100644 --- a/assets/swagger.json +++ b/assets/swagger.json @@ -4056,52 +4056,6 @@ } } }, - "/api/v1/stream/events": { - "get": { - "tags": [ - "Eventing" - ], - "operationId": "Eventing_StartEventSource", - "parameters": [ - { - "type": "string", - "description": "The event source name.", - "name": "name", - "in": "query" - }, - { - "type": "string", - "format": "byte", - "description": "The event source configuration value.", - "name": "config", - "in": "query" - } - ], - "responses": { - "200": { - "description": "A successful response.(streaming responses)", - "schema": { - "type": "object", - "title": "Stream result of genericEvent", - "properties": { - "error": { - "$ref": "#/definitions/runtimeStreamError" - }, - "result": { - "$ref": "#/definitions/genericEvent" - } - } - } - }, - "default": { - "description": "An unexpected error response.", - "schema": { - "$ref": "#/definitions/runtimeError" - } - } - } - } - }, "/api/version": { "get": { "tags": [ @@ -4790,21 +4744,6 @@ } } }, - "genericEvent": { - "type": "object", - "title": "*\nRepresents an event", - "properties": { - "name": { - "description": "The event source name.", - "type": "string" - }, - "payload": { - "description": "The event payload.", - "type": "string", - "format": "byte" - } - } - }, "gpgkeyGnuPGPublicKeyCreateResponse": { "type": "object", "title": "Response to a public key creation request", diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md index 44f728a89a47b..ec07d1005bc37 100644 --- a/changelog/CHANGELOG.md +++ b/changelog/CHANGELOG.md @@ -1,2 +1,2 @@ ### Chore -- chore: selfheal should work with monorepo additional logs \ No newline at end of file +- chore: removed v1 reporter \ No newline at end of file diff --git a/controller/appcontroller_test.go b/controller/appcontroller_test.go index cc40516123e0a..eba264d27cf63 100644 --- a/controller/appcontroller_test.go +++ b/controller/appcontroller_test.go @@ -1984,7 +1984,7 @@ func TestAlreadyAttemptSync(t *testing.T) { t.Run("different manifest with sync result, with enabled flag", func(t *testing.T) { _ = os.Setenv("PERSIST_CHANGE_REVISIONS", "1") - + attempted, _ := alreadyAttemptedSync(app, "sha", []string{}, false, nil) assert.False(t, attempted) }) diff --git a/docs/operator-manual/notifications/services/opsgenie.md b/docs/operator-manual/notifications/services/opsgenie.md index c590a4ac979b6..2cc1ebff62abf 100755 --- a/docs/operator-manual/notifications/services/opsgenie.md +++ b/docs/operator-manual/notifications/services/opsgenie.md @@ -7,22 +7,58 @@ To be able to send notifications with argocd-notifications you have to create an 3. Click "Teams" in the Menu on the left 4. Select the team that you want to notify 5. In the teams configuration menu select "Integrations" -6. click "Add Integration" in the top right corner +6. Click "Add Integration" in the top right corner 7. Select "API" integration 8. Give your integration a name, copy the "API key" and safe it somewhere for later -9. Make sure the checkboxes for "Create and Update Access" and "enable" are selected, disable the other checkboxes to remove unnecessary permissions -10. Click "Safe Integration" at the bottom -11. Check your browser for the correct server apiURL. If it is "app.opsgenie.com" then use the US/international api url `api.opsgenie.com` in the next step, otherwise use `api.eu.opsgenie.com` (European API). -12. You are finished with configuring opsgenie. Now you need to configure argocd-notifications. Use the apiUrl, the team name and the apiKey to configure the Opsgenie integration in the `argocd-notifications-secret` secret. +9. Click "Edit" in the integration settings +10. Make sure the checkbox for "Create and Update Access" is selected, disable the other checkboxes to remove unnecessary permissions +11. Click "Save" at the bottom +12. Click "Turn on integration" in the top right corner +13. Check your browser for the correct server apiURL. If it is "app.opsgenie.com" then use the US/international api url `api.opsgenie.com` in the next step, otherwise use `api.eu.opsgenie.com` (European API). +14. You are finished with configuring Opsgenie. Now you need to configure argocd-notifications. Use the apiUrl, the team name and the apiKey to configure the Opsgenie integration in the `argocd-notifications-secret` secret. +15. You can find the example `argocd-notifications-cm` configuration at the below. + +| **Option** | **Required** | **Type** | **Description** | **Example** | +| ------------- | ------------ | -------- | -------------------------------------------------------------------------------------------------------- | -------------------------------- | +| `description` | True | `string` | Description field of the alert that is generally used to provide a detailed information about the alert. | `Hello from Argo CD!` | +| `priority` | False | `string` | Priority level of the alert. Possible values are P1, P2, P3, P4 and P5. Default value is P3. | `P1` | +| `alias` | False | `string` | Client-defined identifier of the alert, that is also the key element of Alert De-Duplication. | `Life is too short for no alias` | +| `note` | False | `string` | Additional note that will be added while creating the alert. | `Error from Argo CD!` | ```yaml apiVersion: v1 kind: ConfigMap metadata: - name: + name: argocd-notifications-cm data: service.opsgenie: | apiUrl: apiKeys: : + template.opsgenie: | + message: | + [Argo CD] Application {{.app.metadata.name}} has a problem. + opsgenie: + description: | + Application: {{.app.metadata.name}} + Health Status: {{.app.status.health.status}} + Operation State Phase: {{.app.status.operationState.phase}} + Sync Status: {{.app.status.sync.status}} + priority: P1 + alias: {{.app.metadata.name}} + note: Error from Argo CD! + trigger.on-a-problem: | + - description: Application has a problem. + send: + - opsgenie + when: app.status.health.status == 'Degraded' or app.status.operationState.phase in ['Error', 'Failed'] or app.status.sync.status == 'Unknown' +``` + +16. Add annotation in application yaml file to enable notifications for specific Argo CD app. +```yaml + apiVersion: argoproj.io/v1alpha1 + kind: Application + metadata: + annotations: + notifications.argoproj.io/subscribe.on-a-problem.opsgenie: ``` \ No newline at end of file diff --git a/server/application/applications_errors_parser_test.go b/event_reporter/reporter/applications_errors_parser_test.go similarity index 99% rename from server/application/applications_errors_parser_test.go rename to event_reporter/reporter/applications_errors_parser_test.go index a028d803f6438..7a4adc7e75a1c 100644 --- a/server/application/applications_errors_parser_test.go +++ b/event_reporter/reporter/applications_errors_parser_test.go @@ -1,4 +1,4 @@ -package application +package reporter import ( "fmt" diff --git a/event_reporter/reporter/broadcaster.go b/event_reporter/reporter/broadcaster.go index 629e3bf9d7279..e4d3b6629e104 100644 --- a/event_reporter/reporter/broadcaster.go +++ b/event_reporter/reporter/broadcaster.go @@ -63,11 +63,6 @@ func (b *broadcasterHandler) notify(event *appv1.ApplicationWatchEvent) { subscribers = append(subscribers, b.subscribers...) b.lock.Unlock() - if !b.featureManager.ShouldReporterRun() { - log.Infof("filtering application '%s', event reporting is turned off and old one is in use", event.Application.Name) - return - } - if b.filter != nil { result, expectedShard := b.filter(&event.Application) if !result { diff --git a/event_reporter/reporter/feature_manager.go b/event_reporter/reporter/feature_manager.go index c483ec9191b8e..bbfd34121736e 100644 --- a/event_reporter/reporter/feature_manager.go +++ b/event_reporter/reporter/feature_manager.go @@ -2,39 +2,12 @@ package reporter import ( settings_util "github.com/argoproj/argo-cd/v2/util/settings" - log "github.com/sirupsen/logrus" - "time" ) type FeatureManager struct { settingsMgr *settings_util.SettingsManager - shouldRun bool } func NewFeatureManager(settingsMgr *settings_util.SettingsManager) *FeatureManager { return &FeatureManager{settingsMgr: settingsMgr} } - -func (f *FeatureManager) setShouldRun() { - reporterVersion, err := f.settingsMgr.GetCodefreshReporterVersion() - if err != nil { - log.Warnf("Failed to get reporter version: %v", err) - f.shouldRun = false - return - } - f.shouldRun = reporterVersion == string(settings_util.CodefreshV2ReporterVersion) -} - -func (f *FeatureManager) Watch() { - f.setShouldRun() - // nolint:staticcheck - tick := time.Tick(5 * time.Second) - for { - <-tick - f.setShouldRun() - } -} - -func (f *FeatureManager) ShouldReporterRun() bool { - return f.shouldRun -} diff --git a/event_reporter/server.go b/event_reporter/server.go index a90eb2d2600bc..4154ac39c1dc2 100644 --- a/event_reporter/server.go +++ b/event_reporter/server.go @@ -146,7 +146,6 @@ func (a *EventReporterServer) healthCheck(r *http.Request) error { // Init starts informers used by the API server func (a *EventReporterServer) Init(ctx context.Context) { go a.appInformer.Run(ctx.Done()) - go a.featureManager.Watch() svcSet := newEventReporterServiceSet(a) a.serviceSet = svcSet } diff --git a/go.mod b/go.mod index 91e9dfece2122..99d8c10f80812 100644 --- a/go.mod +++ b/go.mod @@ -186,7 +186,7 @@ require ( github.com/exponent-io/jsonpath v0.0.0-20151013193312-d6023ce2651d // indirect github.com/fatih/camelcase v1.0.0 // indirect github.com/fvbommel/sortorder v1.0.1 // indirect - github.com/ghodss/yaml v1.0.0 + github.com/ghodss/yaml v1.0.0 // indirect github.com/go-errors/errors v1.4.2 // indirect github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect github.com/go-git/go-billy/v5 v5.5.0 // indirect diff --git a/pkg/apiclient/events/events.pb.go b/pkg/apiclient/events/events.pb.go index 5f19438b95c2f..d00ffe18cc196 100644 --- a/pkg/apiclient/events/events.pb.go +++ b/pkg/apiclient/events/events.pb.go @@ -9,16 +9,12 @@ package events import ( - context "context" fmt "fmt" _ "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" _ "github.com/gogo/protobuf/gogoproto" github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto" _ "google.golang.org/genproto/googleapis/api/annotations" - grpc "google.golang.org/grpc" - codes "google.golang.org/grpc/codes" - status "google.golang.org/grpc/status" io "io" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" math "math" @@ -674,178 +670,67 @@ func init() { func init() { proto.RegisterFile("server/application/events.proto", fileDescriptor_3ad9267ec62b112f) } var fileDescriptor_3ad9267ec62b112f = []byte{ - // 1009 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xdd, 0x6e, 0x1c, 0xb5, - 0x17, 0xff, 0xcf, 0xe6, 0xfb, 0xec, 0x26, 0xed, 0xdf, 0x49, 0x5a, 0x2b, 0x0a, 0xe9, 0x6a, 0x15, - 0xa1, 0x55, 0xd5, 0xce, 0x92, 0xf0, 0xa1, 0xb6, 0x42, 0x48, 0xa9, 0x12, 0x44, 0x20, 0x01, 0x34, - 0xa1, 0x95, 0xe8, 0x9d, 0x33, 0x73, 0x3a, 0xeb, 0xee, 0x8c, 0x6d, 0x6c, 0xef, 0x4a, 0x7b, 0x8b, - 0x78, 0x03, 0x9e, 0x84, 0xb7, 0xe8, 0x25, 0x12, 0xf7, 0x08, 0x45, 0x48, 0xbc, 0x06, 0xb2, 0x67, - 0x76, 0xe3, 0x09, 0xb9, 0xa0, 0xdc, 0xf9, 0xfc, 0xce, 0xef, 0x1c, 0xfb, 0xcc, 0xf9, 0x1a, 0x78, - 0x60, 0x50, 0x4f, 0x50, 0x0f, 0x98, 0x52, 0x05, 0x4f, 0x99, 0xe5, 0x52, 0x0c, 0x70, 0x82, 0xc2, - 0x9a, 0x58, 0x69, 0x69, 0x25, 0x59, 0xc9, 0x51, 0xa0, 0xe6, 0xe9, 0xce, 0x59, 0xce, 0xed, 0x70, - 0x7c, 0x19, 0xa7, 0xb2, 0x1c, 0x30, 0x9d, 0x4b, 0xa5, 0xe5, 0x1b, 0x7f, 0x78, 0x9c, 0x66, 0x83, - 0xc9, 0xe1, 0x40, 0x8d, 0xf2, 0x01, 0x53, 0xdc, 0x34, 0x5c, 0x4d, 0x0e, 0x58, 0xa1, 0x86, 0xec, - 0x60, 0xe0, 0xbd, 0x30, 0x8b, 0x59, 0xe5, 0x76, 0xe7, 0xa3, 0xd1, 0x13, 0x13, 0x73, 0xe9, 0x2c, - 0x4a, 0x96, 0x0e, 0xb9, 0x40, 0x3d, 0xbd, 0x76, 0x51, 0xa2, 0x65, 0x83, 0xc9, 0x3f, 0xad, 0xb6, - 0x72, 0xe9, 0x2f, 0xb6, 0x72, 0xe0, 0x4e, 0x35, 0xba, 0x9b, 0x4b, 0x99, 0x17, 0xe8, 0x4c, 0x07, - 0x4c, 0x08, 0x69, 0xfd, 0xdd, 0x75, 0x00, 0xbd, 0xa7, 0xd0, 0x3e, 0x71, 0x01, 0x5d, 0xc8, 0xb1, - 0x4e, 0x91, 0x10, 0x58, 0x14, 0xac, 0x44, 0x1a, 0x75, 0x5b, 0xfd, 0xb5, 0xc4, 0x9f, 0xc9, 0x3d, - 0x58, 0x4e, 0xa5, 0x78, 0xcd, 0x73, 0xda, 0xea, 0x46, 0xfd, 0x4e, 0x52, 0x4b, 0xbd, 0x8f, 0x61, - 0xc9, 0x9b, 0xde, 0x6a, 0x44, 0x61, 0x45, 0xb1, 0x69, 0x21, 0x59, 0x46, 0x5b, 0xdd, 0x56, 0xbf, - 0x93, 0xcc, 0xc4, 0xde, 0x5f, 0x11, 0x74, 0xbc, 0xdd, 0xb7, 0x15, 0x40, 0x7a, 0xb0, 0x66, 0x79, - 0x89, 0xc6, 0xb2, 0x52, 0x55, 0x3e, 0x9e, 0x2f, 0xbe, 0xfd, 0xfd, 0xc1, 0xff, 0x92, 0x6b, 0xd8, - 0xbd, 0x41, 0x5e, 0xbe, 0xc1, 0xd4, 0xd6, 0xde, 0x6a, 0x89, 0x3c, 0x86, 0x65, 0xe3, 0x5f, 0x4e, - 0x17, 0xba, 0xad, 0x7e, 0xfb, 0x70, 0x3b, 0xae, 0x13, 0x12, 0x7f, 0xe3, 0x09, 0x55, 0x58, 0x49, - 0x4d, 0x22, 0x8f, 0x60, 0x19, 0xb5, 0x96, 0xda, 0xd0, 0xc5, 0xee, 0x42, 0xbf, 0x7d, 0xb8, 0x75, - 0x83, 0x7e, 0xe2, 0x94, 0x49, 0xcd, 0x21, 0x9f, 0x41, 0x9b, 0x29, 0xf5, 0x12, 0xb5, 0x71, 0x1f, - 0x8c, 0x2e, 0x75, 0xa3, 0x7e, 0xfb, 0x70, 0x77, 0x6e, 0x72, 0x74, 0x9d, 0xc9, 0x19, 0x27, 0x09, - 0x0d, 0x7a, 0x3f, 0xad, 0x41, 0x27, 0x7c, 0x06, 0x89, 0xe1, 0x4e, 0x86, 0x86, 0x6b, 0xcc, 0xce, - 0x99, 0xe0, 0xaf, 0xd1, 0x58, 0x1a, 0x75, 0xa3, 0x79, 0xbc, 0x37, 0x95, 0xe4, 0x11, 0x6c, 0xb0, - 0xd4, 0x8e, 0x59, 0x31, 0xa7, 0xb7, 0x02, 0xfa, 0x0d, 0x1d, 0x79, 0x1f, 0xda, 0x39, 0xb7, 0x73, - 0xea, 0x42, 0x40, 0x0d, 0x15, 0x64, 0x0f, 0x56, 0x34, 0x2a, 0xf9, 0x22, 0x39, 0xa3, 0x8b, 0x01, - 0x67, 0x06, 0x12, 0x0a, 0x8b, 0x8a, 0xd9, 0xa1, 0x8f, 0x77, 0xa6, 0xf4, 0x08, 0xe9, 0xc2, 0xaa, - 0xc6, 0x09, 0x77, 0xd1, 0xd1, 0xe5, 0x40, 0x3b, 0x47, 0xc9, 0x43, 0x58, 0x4f, 0x65, 0x59, 0x72, - 0x7b, 0x8e, 0xc6, 0xb0, 0x1c, 0xe9, 0x4a, 0x40, 0x6b, 0xaa, 0x48, 0x1f, 0x3a, 0x15, 0x70, 0x34, - 0xb6, 0x43, 0xa9, 0xe9, 0x6a, 0x40, 0x6d, 0x68, 0xc8, 0x97, 0x00, 0x95, 0x7c, 0xcc, 0x2c, 0xd2, - 0x35, 0x9f, 0x87, 0x87, 0x71, 0xd5, 0x23, 0x71, 0xd8, 0x23, 0xb1, 0x1a, 0xe5, 0x0e, 0x30, 0xb1, - 0xeb, 0x91, 0x78, 0x72, 0x10, 0x7f, 0xc7, 0x4b, 0x4c, 0x02, 0x6b, 0x17, 0x3d, 0x53, 0xea, 0x6b, - 0x57, 0xaf, 0x10, 0x46, 0x5f, 0x83, 0xe4, 0x0b, 0x58, 0x63, 0x4a, 0x9d, 0xb1, 0x4b, 0x2c, 0x0c, - 0x6d, 0xfb, 0x2a, 0xd9, 0xbf, 0xb5, 0xa8, 0x5c, 0xfe, 0x2b, 0xda, 0x89, 0xb0, 0x7a, 0x3a, 0xab, - 0xd9, 0xb9, 0x31, 0xd9, 0x07, 0x30, 0x53, 0x91, 0x5e, 0x58, 0x66, 0xc7, 0x86, 0x76, 0x82, 0xcb, - 0x02, 0x9c, 0xbc, 0x84, 0xf5, 0x5a, 0xd2, 0x16, 0xb3, 0x23, 0x4b, 0xd7, 0xdf, 0x35, 0xbc, 0xd9, - 0xd7, 0x6d, 0xb8, 0x21, 0x09, 0x6c, 0x38, 0xe0, 0x73, 0x2e, 0xb8, 0x19, 0x7a, 0xc7, 0x1b, 0xef, - 0xfc, 0xdd, 0x6e, 0x78, 0x20, 0x3d, 0xe8, 0x0c, 0x91, 0x15, 0x76, 0x58, 0xc7, 0x74, 0xc7, 0xc5, - 0x94, 0x34, 0x30, 0xb2, 0x0f, 0xeb, 0x95, 0x3c, 0xab, 0x80, 0xbb, 0x9e, 0xd4, 0x04, 0x5d, 0x16, - 0xd2, 0x62, 0x6c, 0x2c, 0x6a, 0xfa, 0xff, 0x30, 0x0b, 0x35, 0xe8, 0x66, 0xc2, 0x90, 0x1b, 0x2b, - 0xf5, 0xf4, 0x34, 0xa3, 0xa4, 0x1b, 0xf5, 0x17, 0x66, 0xdf, 0x77, 0x0e, 0x93, 0x67, 0xb0, 0x2d, - 0x95, 0x1b, 0x80, 0x5c, 0x8a, 0x8b, 0xa9, 0x48, 0x93, 0x59, 0x69, 0x6e, 0x06, 0x1e, 0x6f, 0xa7, - 0x90, 0x5d, 0x58, 0x66, 0x4a, 0xbd, 0x38, 0x3d, 0xa6, 0x5b, 0x01, 0xb9, 0xc6, 0x5c, 0x65, 0xd6, - 0xe5, 0x60, 0x14, 0x4b, 0x91, 0x6e, 0x87, 0x95, 0x19, 0x6a, 0xc8, 0x27, 0xb0, 0xc9, 0x94, 0x3a, - 0x15, 0xc6, 0x32, 0x91, 0xa2, 0x4f, 0xfc, 0x57, 0x38, 0xa5, 0xf7, 0x02, 0x83, 0xdb, 0x08, 0xae, - 0xb3, 0xad, 0x66, 0xe9, 0x88, 0x8b, 0xfc, 0x1c, 0xed, 0x50, 0x66, 0xf4, 0x7e, 0xd8, 0xd9, 0x4d, - 0xdd, 0xce, 0xa7, 0xb0, 0xd1, 0x2c, 0x36, 0x72, 0x17, 0x16, 0x46, 0x38, 0xad, 0xa6, 0x47, 0xe2, - 0x8e, 0x64, 0x0b, 0x96, 0x26, 0xac, 0x18, 0x63, 0x35, 0x22, 0x92, 0x4a, 0x78, 0xd6, 0x7a, 0x12, - 0xf5, 0x7e, 0x89, 0xa0, 0x1d, 0x8c, 0x37, 0xd7, 0xdf, 0x76, 0xaa, 0xb0, 0x31, 0x7a, 0x3c, 0x42, - 0x76, 0x60, 0xa9, 0xc0, 0x09, 0x16, 0x8d, 0x31, 0x53, 0x41, 0x2e, 0x63, 0x65, 0x9d, 0xd1, 0x70, - 0xb2, 0xcc, 0x40, 0x72, 0x06, 0xab, 0x05, 0x33, 0xf6, 0x02, 0x51, 0xf8, 0xb1, 0xf2, 0x5f, 0x4a, - 0x78, 0xee, 0xa1, 0xf7, 0x0a, 0x3a, 0xc7, 0xa8, 0x50, 0x64, 0x28, 0x52, 0x8e, 0xc6, 0xad, 0x98, - 0x42, 0xa6, 0xa3, 0x3a, 0x60, 0x7f, 0x76, 0x58, 0x86, 0xca, 0xd4, 0x01, 0xfb, 0xb3, 0xab, 0x50, - 0x8d, 0x3f, 0x8c, 0xb9, 0xc6, 0xd2, 0x6d, 0xe9, 0xea, 0xa9, 0x49, 0x03, 0xeb, 0x29, 0xd8, 0xbc, - 0x65, 0x74, 0x93, 0x3d, 0x80, 0xeb, 0xe1, 0x5d, 0x5f, 0x14, 0x20, 0xe4, 0x29, 0x74, 0xb2, 0xe0, - 0x49, 0xfe, 0xda, 0x70, 0xe1, 0x84, 0xef, 0x4d, 0x1a, 0xd4, 0x43, 0x84, 0x55, 0xbf, 0xf1, 0xb8, - 0xc8, 0xc9, 0xf7, 0x70, 0xd7, 0x37, 0x69, 0xb8, 0x75, 0xaf, 0xd7, 0x50, 0x80, 0xee, 0x6c, 0x34, - 0xd1, 0xde, 0x7b, 0x3f, 0xfe, 0xf6, 0xe7, 0xcf, 0xad, 0xfb, 0x64, 0xdb, 0xaf, 0xf2, 0xc9, 0xc1, - 0xc0, 0x58, 0x8d, 0xac, 0xac, 0x7f, 0x48, 0x3e, 0x88, 0x9e, 0x1f, 0xbd, 0xbd, 0xda, 0x8b, 0x7e, - 0xbd, 0xda, 0x8b, 0xfe, 0xb8, 0xda, 0x8b, 0x5e, 0x7d, 0xf8, 0xef, 0xfe, 0x48, 0xd2, 0x82, 0xa3, - 0xb0, 0xb5, 0x93, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0xc3, 0x5b, 0xa5, 0x9e, 0xf1, 0x08, 0x00, - 0x00, -} - -// Reference imports to suppress errors if they are not otherwise used. -var _ context.Context -var _ grpc.ClientConn - -// This is a compile-time assertion to ensure that this generated file -// is compatible with the grpc package it is being compiled against. -const _ = grpc.SupportPackageIsVersion4 - -// EventingClient is the client API for Eventing service. -// -// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. -type EventingClient interface { - StartEventSource(ctx context.Context, in *EventSource, opts ...grpc.CallOption) (Eventing_StartEventSourceClient, error) -} - -type eventingClient struct { - cc *grpc.ClientConn -} - -func NewEventingClient(cc *grpc.ClientConn) EventingClient { - return &eventingClient{cc} -} - -func (c *eventingClient) StartEventSource(ctx context.Context, in *EventSource, opts ...grpc.CallOption) (Eventing_StartEventSourceClient, error) { - stream, err := c.cc.NewStream(ctx, &_Eventing_serviceDesc.Streams[0], "/generic.Eventing/StartEventSource", opts...) - if err != nil { - return nil, err - } - x := &eventingStartEventSourceClient{stream} - if err := x.ClientStream.SendMsg(in); err != nil { - return nil, err - } - if err := x.ClientStream.CloseSend(); err != nil { - return nil, err - } - return x, nil -} - -type Eventing_StartEventSourceClient interface { - Recv() (*Event, error) - grpc.ClientStream -} - -type eventingStartEventSourceClient struct { - grpc.ClientStream -} - -func (x *eventingStartEventSourceClient) Recv() (*Event, error) { - m := new(Event) - if err := x.ClientStream.RecvMsg(m); err != nil { - return nil, err - } - return m, nil -} - -// EventingServer is the server API for Eventing service. -type EventingServer interface { - StartEventSource(*EventSource, Eventing_StartEventSourceServer) error -} - -// UnimplementedEventingServer can be embedded to have forward compatible implementations. -type UnimplementedEventingServer struct { -} - -func (*UnimplementedEventingServer) StartEventSource(req *EventSource, srv Eventing_StartEventSourceServer) error { - return status.Errorf(codes.Unimplemented, "method StartEventSource not implemented") -} - -func RegisterEventingServer(s *grpc.Server, srv EventingServer) { - s.RegisterService(&_Eventing_serviceDesc, srv) -} - -func _Eventing_StartEventSource_Handler(srv interface{}, stream grpc.ServerStream) error { - m := new(EventSource) - if err := stream.RecvMsg(m); err != nil { - return err - } - return srv.(EventingServer).StartEventSource(m, &eventingStartEventSourceServer{stream}) -} - -type Eventing_StartEventSourceServer interface { - Send(*Event) error - grpc.ServerStream -} - -type eventingStartEventSourceServer struct { - grpc.ServerStream -} - -func (x *eventingStartEventSourceServer) Send(m *Event) error { - return x.ServerStream.SendMsg(m) -} - -var _Eventing_serviceDesc = grpc.ServiceDesc{ - ServiceName: "generic.Eventing", - HandlerType: (*EventingServer)(nil), - Methods: []grpc.MethodDesc{}, - Streams: []grpc.StreamDesc{ - { - StreamName: "StartEventSource", - Handler: _Eventing_StartEventSource_Handler, - ServerStreams: true, - }, - }, - Metadata: "server/application/events.proto", + // 958 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xcf, 0x6e, 0xdc, 0xb6, + 0x13, 0xfe, 0x69, 0xfd, 0x7f, 0x76, 0xed, 0xe4, 0x47, 0xdb, 0x29, 0x61, 0x18, 0xce, 0x62, 0x61, + 0x14, 0x8b, 0x20, 0xd1, 0xc2, 0xee, 0x1f, 0x24, 0x41, 0x51, 0xc0, 0x81, 0x5d, 0xd4, 0xad, 0xdd, + 0x16, 0x72, 0x93, 0x43, 0x6e, 0xb4, 0x34, 0xd1, 0x32, 0x2b, 0x91, 0x2c, 0xc9, 0x5d, 0x60, 0xef, + 0x7d, 0xa1, 0xbe, 0x45, 0x8e, 0x7d, 0x82, 0xa2, 0xf0, 0xa5, 0xaf, 0x51, 0x90, 0x92, 0xd6, 0x94, + 0xeb, 0x43, 0xd3, 0x1b, 0xe7, 0x9b, 0x6f, 0x86, 0xfc, 0x38, 0xc3, 0x91, 0xe0, 0xb1, 0x41, 0x3d, + 0x43, 0x3d, 0x62, 0x4a, 0x15, 0x3c, 0x65, 0x96, 0x4b, 0x31, 0xc2, 0x19, 0x0a, 0x6b, 0x62, 0xa5, + 0xa5, 0x95, 0x64, 0x2d, 0x47, 0x81, 0x9a, 0xa7, 0x7b, 0x17, 0x39, 0xb7, 0xe3, 0xe9, 0x75, 0x9c, + 0xca, 0x72, 0xc4, 0x74, 0x2e, 0x95, 0x96, 0xef, 0xfd, 0xe2, 0x59, 0x9a, 0x8d, 0x66, 0xc7, 0x23, + 0x35, 0xc9, 0x47, 0x4c, 0x71, 0xd3, 0x4a, 0x35, 0x3b, 0x62, 0x85, 0x1a, 0xb3, 0xa3, 0x91, 0xcf, + 0xc2, 0x2c, 0x66, 0x55, 0xda, 0xbd, 0xcf, 0x27, 0xcf, 0x4d, 0xcc, 0xa5, 0x8b, 0x28, 0x59, 0x3a, + 0xe6, 0x02, 0xf5, 0xfc, 0x36, 0x45, 0x89, 0x96, 0x8d, 0x66, 0xff, 0x8c, 0xda, 0xc9, 0xa5, 0xdf, + 0xd8, 0xca, 0x91, 0x5b, 0xd5, 0xe8, 0x7e, 0x2e, 0x65, 0x5e, 0xa0, 0x0b, 0x1d, 0x31, 0x21, 0xa4, + 0xf5, 0x7b, 0xd7, 0x02, 0x06, 0x2f, 0xa0, 0x7b, 0xe6, 0x04, 0x5d, 0xc9, 0xa9, 0x4e, 0x91, 0x10, + 0x58, 0x16, 0xac, 0x44, 0x1a, 0xf5, 0x3b, 0xc3, 0x8d, 0xc4, 0xaf, 0xc9, 0x23, 0x58, 0x4d, 0xa5, + 0x78, 0xc7, 0x73, 0xda, 0xe9, 0x47, 0xc3, 0x5e, 0x52, 0x5b, 0x83, 0x2f, 0x60, 0xc5, 0x87, 0xde, + 0x1b, 0x44, 0x61, 0x4d, 0xb1, 0x79, 0x21, 0x59, 0x46, 0x3b, 0xfd, 0xce, 0xb0, 0x97, 0x34, 0xe6, + 0xe0, 0xaf, 0x08, 0x7a, 0x3e, 0xee, 0xa7, 0x0a, 0x20, 0x03, 0xd8, 0xb0, 0xbc, 0x44, 0x63, 0x59, + 0xa9, 0xaa, 0x1c, 0xaf, 0x96, 0x3f, 0xfc, 0xf1, 0xf8, 0x7f, 0xc9, 0x2d, 0xec, 0xce, 0x20, 0xaf, + 0xdf, 0x63, 0x6a, 0xeb, 0x6c, 0xb5, 0x45, 0x9e, 0xc1, 0xaa, 0xf1, 0x27, 0xa7, 0x4b, 0xfd, 0xce, + 0xb0, 0x7b, 0xbc, 0x1b, 0xd7, 0x05, 0x89, 0x7f, 0xf4, 0x84, 0x4a, 0x56, 0x52, 0x93, 0xc8, 0x53, + 0x58, 0x45, 0xad, 0xa5, 0x36, 0x74, 0xb9, 0xbf, 0x34, 0xec, 0x1e, 0xef, 0xdc, 0xa1, 0x9f, 0x39, + 0x67, 0x52, 0x73, 0xc8, 0xd7, 0xd0, 0x65, 0x4a, 0xbd, 0x41, 0x6d, 0xdc, 0x85, 0xd1, 0x95, 0x7e, + 0x34, 0xec, 0x1e, 0xef, 0x2f, 0x42, 0x4e, 0x6e, 0x2b, 0xd9, 0x70, 0x92, 0x30, 0x60, 0xf0, 0xeb, + 0x06, 0xf4, 0xc2, 0x63, 0x90, 0x18, 0x1e, 0x64, 0x68, 0xb8, 0xc6, 0xec, 0x92, 0x09, 0xfe, 0x0e, + 0x8d, 0xa5, 0x51, 0x3f, 0x5a, 0xe8, 0xbd, 0xeb, 0x24, 0x4f, 0x61, 0x8b, 0xa5, 0x76, 0xca, 0x8a, + 0x05, 0xbd, 0x13, 0xd0, 0xef, 0xf8, 0xc8, 0xa7, 0xd0, 0xcd, 0xb9, 0x5d, 0x50, 0x97, 0x02, 0x6a, + 0xe8, 0x20, 0x07, 0xb0, 0xa6, 0x51, 0xc9, 0xd7, 0xc9, 0x05, 0x5d, 0x0e, 0x38, 0x0d, 0x48, 0x28, + 0x2c, 0x2b, 0x66, 0xc7, 0x5e, 0x6f, 0xe3, 0xf4, 0x08, 0xe9, 0xc3, 0xba, 0xc6, 0x19, 0x77, 0xea, + 0xe8, 0x6a, 0xe0, 0x5d, 0xa0, 0xe4, 0x09, 0x6c, 0xa6, 0xb2, 0x2c, 0xb9, 0xbd, 0x44, 0x63, 0x58, + 0x8e, 0x74, 0x2d, 0xa0, 0xb5, 0x5d, 0x64, 0x08, 0xbd, 0x0a, 0x38, 0x99, 0xda, 0xb1, 0xd4, 0x74, + 0x3d, 0xa0, 0xb6, 0x3c, 0xe4, 0x3b, 0x80, 0xca, 0x3e, 0x65, 0x16, 0xe9, 0x86, 0xaf, 0xc3, 0x93, + 0xb8, 0x7a, 0x23, 0x71, 0xf8, 0x46, 0x62, 0x35, 0xc9, 0x1d, 0x60, 0x62, 0xf7, 0x46, 0xe2, 0xd9, + 0x51, 0xfc, 0x33, 0x2f, 0x31, 0x09, 0xa2, 0x9d, 0x7a, 0xa6, 0xd4, 0x0f, 0xae, 0x5f, 0x21, 0x54, + 0x5f, 0x83, 0xe4, 0x5b, 0xd8, 0x60, 0x4a, 0x5d, 0xb0, 0x6b, 0x2c, 0x0c, 0xed, 0xfa, 0x2e, 0x39, + 0xbc, 0xb7, 0xa9, 0x5c, 0xfd, 0x2b, 0xda, 0x99, 0xb0, 0x7a, 0xde, 0xf4, 0xec, 0x22, 0x98, 0x1c, + 0x02, 0x98, 0xb9, 0x48, 0xaf, 0x2c, 0xb3, 0x53, 0x43, 0x7b, 0xc1, 0x66, 0x01, 0x4e, 0xde, 0xc0, + 0x66, 0x6d, 0x69, 0x8b, 0xd9, 0x89, 0xa5, 0x9b, 0x1f, 0x2b, 0xaf, 0xb9, 0xdd, 0x56, 0x1a, 0x92, + 0xc0, 0x96, 0x03, 0xbe, 0xe1, 0x82, 0x9b, 0xb1, 0x4f, 0xbc, 0xf5, 0xd1, 0xf7, 0x76, 0x27, 0x03, + 0x19, 0x40, 0x6f, 0x8c, 0xac, 0xb0, 0xe3, 0x5a, 0xd3, 0x03, 0xa7, 0x29, 0x69, 0x61, 0xe4, 0x10, + 0x36, 0x2b, 0xbb, 0xe9, 0x80, 0x87, 0x9e, 0xd4, 0x06, 0x5d, 0x15, 0xd2, 0x62, 0x6a, 0x2c, 0x6a, + 0xfa, 0xff, 0xb0, 0x0a, 0x35, 0xe8, 0x66, 0xc2, 0x98, 0x1b, 0x2b, 0xf5, 0xfc, 0x3c, 0xa3, 0xa4, + 0x1f, 0x0d, 0x97, 0x9a, 0xfb, 0x5d, 0xc0, 0xe4, 0x25, 0xec, 0x4a, 0xe5, 0x06, 0x20, 0x97, 0xe2, + 0x6a, 0x2e, 0xd2, 0xa4, 0x69, 0xcd, 0xed, 0x20, 0xe3, 0xfd, 0x14, 0xb2, 0x0f, 0xab, 0x4c, 0xa9, + 0xd7, 0xe7, 0xa7, 0x74, 0x27, 0x20, 0xd7, 0x98, 0xeb, 0xcc, 0xba, 0x1d, 0x8c, 0x62, 0x29, 0xd2, + 0xdd, 0xb0, 0x33, 0x43, 0x0f, 0xf9, 0x12, 0xb6, 0x99, 0x52, 0xe7, 0xc2, 0x58, 0x26, 0x52, 0xf4, + 0x85, 0xff, 0x1e, 0xe7, 0xf4, 0x51, 0x10, 0x70, 0x1f, 0xc1, 0xbd, 0x6c, 0xab, 0x59, 0x3a, 0xe1, + 0x22, 0xbf, 0x44, 0x3b, 0x96, 0x19, 0xfd, 0x24, 0x7c, 0xd9, 0x6d, 0xdf, 0xde, 0x57, 0xb0, 0xd5, + 0x6e, 0x36, 0xf2, 0x10, 0x96, 0x26, 0x38, 0xaf, 0xa6, 0x47, 0xe2, 0x96, 0x64, 0x07, 0x56, 0x66, + 0xac, 0x98, 0x62, 0x35, 0x22, 0x92, 0xca, 0x78, 0xd9, 0x79, 0x1e, 0x0d, 0x7e, 0x8b, 0xa0, 0x1b, + 0x8c, 0x37, 0xf7, 0xbe, 0xed, 0x5c, 0x61, 0x6b, 0xf4, 0x78, 0x84, 0xec, 0xc1, 0x4a, 0x81, 0x33, + 0x2c, 0x5a, 0x63, 0xa6, 0x82, 0x5c, 0xc5, 0xca, 0xba, 0xa2, 0xe1, 0x64, 0x69, 0x40, 0x72, 0x01, + 0xeb, 0x05, 0x33, 0xf6, 0x0a, 0x51, 0xf8, 0xb1, 0xf2, 0x5f, 0x5a, 0x78, 0x91, 0x61, 0xf0, 0x16, + 0x7a, 0xa7, 0xa8, 0x50, 0x64, 0x28, 0x52, 0x8e, 0xc6, 0x7d, 0x62, 0x0a, 0x99, 0x4e, 0x6a, 0xc1, + 0x7e, 0xed, 0xb0, 0x0c, 0x95, 0xa9, 0x05, 0xfb, 0xb5, 0xeb, 0x50, 0x8d, 0xbf, 0x4c, 0xb9, 0xc6, + 0xd2, 0x7d, 0xa5, 0xab, 0xa3, 0x26, 0x2d, 0x6c, 0xa0, 0x60, 0xfb, 0x9e, 0xd1, 0x4d, 0x0e, 0x00, + 0x6e, 0x87, 0x77, 0xbd, 0x51, 0x80, 0x90, 0x17, 0xd0, 0xcb, 0x82, 0x23, 0xf9, 0x6d, 0xc3, 0x0f, + 0x4e, 0x78, 0xde, 0xa4, 0x45, 0x7d, 0x75, 0xf2, 0xe1, 0xe6, 0x20, 0xfa, 0xfd, 0xe6, 0x20, 0xfa, + 0xf3, 0xe6, 0x20, 0x7a, 0xfb, 0xd9, 0xbf, 0xfb, 0x55, 0x48, 0x0b, 0x8e, 0xc2, 0xd6, 0xbf, 0x1b, + 0x7f, 0x07, 0x00, 0x00, 0xff, 0xff, 0x57, 0x77, 0xe0, 0x62, 0x8a, 0x08, 0x00, 0x00, } func (m *EventSource) Marshal() (dAtA []byte, err error) { diff --git a/pkg/apiclient/events/events.pb.gw.go b/pkg/apiclient/events/events.pb.gw.go deleted file mode 100644 index 5f4e02c2ae1f3..0000000000000 --- a/pkg/apiclient/events/events.pb.gw.go +++ /dev/null @@ -1,147 +0,0 @@ -// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT. -// source: server/application/events.proto - -/* -Package events is a reverse proxy. - -It translates gRPC into RESTful JSON APIs. -*/ -package events - -import ( - "context" - "io" - "net/http" - - "github.com/golang/protobuf/descriptor" - "github.com/golang/protobuf/proto" - "github.com/grpc-ecosystem/grpc-gateway/runtime" - "github.com/grpc-ecosystem/grpc-gateway/utilities" - "google.golang.org/grpc" - "google.golang.org/grpc/codes" - "google.golang.org/grpc/grpclog" - "google.golang.org/grpc/metadata" - "google.golang.org/grpc/status" -) - -// Suppress "imported and not used" errors -var _ codes.Code -var _ io.Reader -var _ status.Status -var _ = runtime.String -var _ = utilities.NewDoubleArray -var _ = descriptor.ForMessage -var _ = metadata.Join - -var ( - filter_Eventing_StartEventSource_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)} -) - -func request_Eventing_StartEventSource_0(ctx context.Context, marshaler runtime.Marshaler, client EventingClient, req *http.Request, pathParams map[string]string) (Eventing_StartEventSourceClient, runtime.ServerMetadata, error) { - var protoReq EventSource - var metadata runtime.ServerMetadata - - if err := req.ParseForm(); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Eventing_StartEventSource_0); err != nil { - return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err) - } - - stream, err := client.StartEventSource(ctx, &protoReq) - if err != nil { - return nil, metadata, err - } - header, err := stream.Header() - if err != nil { - return nil, metadata, err - } - metadata.HeaderMD = header - return stream, metadata, nil - -} - -// RegisterEventingHandlerServer registers the http handlers for service Eventing to "mux". -// UnaryRPC :call EventingServer directly. -// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. -// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterEventingHandlerFromEndpoint instead. -func RegisterEventingHandlerServer(ctx context.Context, mux *runtime.ServeMux, server EventingServer) error { - - mux.Handle("GET", pattern_Eventing_StartEventSource_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - err := status.Error(codes.Unimplemented, "streaming calls are not yet supported in the in-process transport") - _, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - }) - - return nil -} - -// RegisterEventingHandlerFromEndpoint is same as RegisterEventingHandler but -// automatically dials to "endpoint" and closes the connection when "ctx" gets done. -func RegisterEventingHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) { - conn, err := grpc.Dial(endpoint, opts...) - if err != nil { - return err - } - defer func() { - if err != nil { - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - return - } - go func() { - <-ctx.Done() - if cerr := conn.Close(); cerr != nil { - grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr) - } - }() - }() - - return RegisterEventingHandler(ctx, mux, conn) -} - -// RegisterEventingHandler registers the http handlers for service Eventing to "mux". -// The handlers forward requests to the grpc endpoint over "conn". -func RegisterEventingHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error { - return RegisterEventingHandlerClient(ctx, mux, NewEventingClient(conn)) -} - -// RegisterEventingHandlerClient registers the http handlers for service Eventing -// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "EventingClient". -// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "EventingClient" -// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in -// "EventingClient" to call the correct interceptors. -func RegisterEventingHandlerClient(ctx context.Context, mux *runtime.ServeMux, client EventingClient) error { - - mux.Handle("GET", pattern_Eventing_StartEventSource_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) { - ctx, cancel := context.WithCancel(req.Context()) - defer cancel() - inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req) - rctx, err := runtime.AnnotateContext(ctx, mux, req) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - resp, md, err := request_Eventing_StartEventSource_0(rctx, inboundMarshaler, client, req, pathParams) - ctx = runtime.NewServerMetadataContext(ctx, md) - if err != nil { - runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err) - return - } - - forward_Eventing_StartEventSource_0(ctx, mux, outboundMarshaler, w, req, func() (proto.Message, error) { return resp.Recv() }, mux.GetForwardResponseOptions()...) - - }) - - return nil -} - -var ( - pattern_Eventing_StartEventSource_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"api", "v1", "stream", "events"}, "", runtime.AssumeColonVerbOpt(true))) -) - -var ( - forward_Eventing_StartEventSource_0 = runtime.ForwardResponseStream -) diff --git a/reposerver/repository/repository.go b/reposerver/repository/repository.go index a54a09e8c6e23..14de84b699138 100644 --- a/reposerver/repository/repository.go +++ b/reposerver/repository/repository.go @@ -3031,14 +3031,14 @@ func (s *Service) UpdateRevisionForPaths(_ context.Context, request *apiclient.U if err != nil { // Only warn with the error, no need to block anything if there is a caching error. logCtx.Warnf("error updating cached revision for repo %s with revision %s: %v", repo.Repo, revision, err) - return &apiclient.UpdateRevisionForPathsResponse{Revision: revision,}, nil + return &apiclient.UpdateRevisionForPathsResponse{Revision: revision}, nil } - return &apiclient.UpdateRevisionForPathsResponse{Revision: revision,}, nil + return &apiclient.UpdateRevisionForPathsResponse{Revision: revision}, nil } logCtx.Debugf("changes found for application %s in repo %s from revision %s to revision %s", request.AppName, repo.Repo, syncedRevision, revision) - return &apiclient.UpdateRevisionForPathsResponse{Changes: true, Revision: revision,}, nil + return &apiclient.UpdateRevisionForPathsResponse{Changes: true, Revision: revision}, nil } func (s *Service) updateCachedRevision(logCtx *log.Entry, oldRev string, newRev string, request *apiclient.UpdateRevisionForPathsRequest, gitClientOpts git.ClientOpts) error { diff --git a/reposerver/repository/repository_test.go b/reposerver/repository/repository_test.go index 14456fae1f34f..4f42df723d09e 100644 --- a/reposerver/repository/repository_test.go +++ b/reposerver/repository/repository_test.go @@ -3505,7 +3505,7 @@ func TestUpdateRevisionForPaths(t *testing.T) { Paths: []string{"."}, }, }, want: &apiclient.UpdateRevisionForPathsResponse{ - Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + Revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", }, wantErr: assert.NoError}, {name: "ChangedFilesDoNothing", fields: func() fields { s, _, c := newServiceWithOpt(t, func(gitClient *gitmocks.Client, helmClient *helmmocks.Client, paths *iomocks.TempPaths) { @@ -3532,8 +3532,8 @@ func TestUpdateRevisionForPaths(t *testing.T) { Paths: []string{"."}, }, }, want: &apiclient.UpdateRevisionForPathsResponse{ - Changes: true, - Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + Changes: true, + Revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", }, wantErr: assert.NoError}, {name: "NoChangesUpdateCache", fields: func() fields { s, _, c := newServiceWithOpt(t, func(gitClient *gitmocks.Client, helmClient *helmmocks.Client, paths *iomocks.TempPaths) { @@ -3567,7 +3567,7 @@ func TestUpdateRevisionForPaths(t *testing.T) { KubeVersion: "v1.16.0", }, }, want: &apiclient.UpdateRevisionForPathsResponse{ - Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + Revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", }, wantErr: assert.NoError, cacheHit: &cacheHit{ previousRevision: "1e67a504d03def3a6a1125d934cb511680f72555", revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", @@ -3606,7 +3606,7 @@ func TestUpdateRevisionForPaths(t *testing.T) { HasMultipleSources: true, }, }, want: &apiclient.UpdateRevisionForPathsResponse{ - Revision:"632039659e542ed7de0c170a4fcc1c571b288fc0", + Revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", }, wantErr: assert.NoError, cacheHit: &cacheHit{ previousRevision: "1e67a504d03def3a6a1125d934cb511680f72555", revision: "632039659e542ed7de0c170a4fcc1c571b288fc0", diff --git a/server/application/application.go b/server/application/application.go index e4ca36f46185e..436bb1e64fc35 100644 --- a/server/application/application.go +++ b/server/application/application.go @@ -12,9 +12,6 @@ import ( "strings" "time" - "github.com/argoproj/argo-cd/v2/pkg/apiclient/events" - "gopkg.in/yaml.v2" - kubecache "github.com/argoproj/gitops-engine/pkg/cache" "github.com/argoproj/gitops-engine/pkg/diff" "github.com/argoproj/gitops-engine/pkg/sync/common" @@ -81,30 +78,26 @@ const ( var ( watchAPIBufferSize = env.ParseNumFromEnv(argocommon.EnvWatchAPIBufferSize, 1000, 0, math.MaxInt32) permissionDeniedErr = status.Error(codes.PermissionDenied, "permission denied") - - applicationEventCacheExpiration = time.Minute * time.Duration(env.ParseNumFromEnv(argocommon.EnvApplicationEventCacheDuration, 20, 0, math.MaxInt32)) - resourceEventCacheExpiration = time.Minute * time.Duration(env.ParseNumFromEnv(argocommon.EnvResourceEventCacheDuration, 20, 0, math.MaxInt32)) ) // Server provides an Application service type Server struct { - ns string - kubeclientset kubernetes.Interface - appclientset appclientset.Interface - appLister applisters.ApplicationLister - appInformer cache.SharedIndexInformer - appBroadcaster Broadcaster - repoClientset apiclient.Clientset - kubectl kube.Kubectl - db db.ArgoDB - enf *rbac.Enforcer - projectLock sync.KeyLock - auditLogger *argo.AuditLogger - settingsMgr *settings.SettingsManager - cache *servercache.Cache - projInformer cache.SharedIndexInformer - enabledNamespaces []string - applicationEventReporter *applicationEventReporter + ns string + kubeclientset kubernetes.Interface + appclientset appclientset.Interface + appLister applisters.ApplicationLister + appInformer cache.SharedIndexInformer + appBroadcaster Broadcaster + repoClientset apiclient.Clientset + kubectl kube.Kubectl + db db.ArgoDB + enf *rbac.Enforcer + projectLock sync.KeyLock + auditLogger *argo.AuditLogger + settingsMgr *settings.SettingsManager + cache *servercache.Cache + projInformer cache.SharedIndexInformer + enabledNamespaces []string } // NewServer returns a new instance of the Application service @@ -150,8 +143,6 @@ func NewServer( projInformer: projInformer, enabledNamespaces: enabledNamespaces, } - s.applicationEventReporter = NewApplicationEventReporter(s) - return s, s.getAppResources } @@ -1243,304 +1234,6 @@ func (s *Server) Watch(q *application.ApplicationQuery, ws application.Applicati } } -func (s *Server) StartEventSource(es *events.EventSource, stream events.Eventing_StartEventSourceServer) error { - var ( - logCtx log.FieldLogger = log.StandardLogger() - selector labels.Selector - err error - ) - q := application.ApplicationQuery{} - if err := yaml.Unmarshal(es.Config, &q); err != nil { - logCtx.WithError(err).Error("failed to unmarshal event-source config") - return fmt.Errorf("failed to unmarshal event-source config: %w", err) - } - - if q.Name != nil { - logCtx = logCtx.WithField("application", *q.Name) - } - - claims := stream.Context().Value("claims") - - if q.Selector != nil { - selector, err = labels.Parse(*q.Selector) - if err != nil { - return err - } - } - - minVersion := 0 - if q.ResourceVersion != nil { - if minVersion, err = strconv.Atoi(*q.ResourceVersion); err != nil { - minVersion = 0 - } - } - - appNs := s.appNamespaceOrDefault(q.GetAppNamespace()) - - // sendIfPermitted is a helper to send the application to the client's streaming channel if the - // caller has RBAC privileges permissions to view it - sendIfPermitted := func(ctx context.Context, logCtx log.FieldLogger, a appv1.Application, ts string, ignoreResourceCache bool) error { - if appVersion, err := strconv.Atoi(a.ResourceVersion); err == nil && appVersion < minVersion { - return nil - } - - if selector != nil { - matchedEvent := (q.GetName() == "" || a.Name == q.GetName()) && selector.Matches(labels.Set(a.Labels)) - if !matchedEvent { - return nil - } - } - - if !s.isNamespaceEnabled(appNs) { - return security.NamespaceNotPermittedError(appNs) - } - - if !s.enf.Enforce(claims, rbacpolicy.ResourceApplications, rbacpolicy.ActionGet, a.RBACName(s.ns)) { - // do not emit apps user does not have accessing - return nil - } - - appInstanceLabelKey, err := s.settingsMgr.GetAppInstanceLabelKey() - if err != nil { - return err - } - trackingMethod := argoutil.GetTrackingMethod(s.settingsMgr) - - err = s.applicationEventReporter.streamApplicationEvents(ctx, logCtx, &a, es, stream, ts, ignoreResourceCache, appInstanceLabelKey, trackingMethod) - if err != nil { - return err - } - - if err := s.cache.SetLastApplicationEvent(&a, applicationEventCacheExpiration); err != nil { - logCtx.WithError(err).Error("failed to cache last sent application event") - return err - } - - return nil - } - - priorityQueueEnabled := env.ParseBoolFromEnv("CODEFRESH_PRIORITY_QUEUE", false) - - allEventsChannel := make(chan *appv1.ApplicationWatchEvent, watchAPIBufferSize) - onUpdateEventsChannel := make(chan *appv1.ApplicationWatchEvent, watchAPIBufferSize) - onDeleteEventsChannel := make(chan *appv1.ApplicationWatchEvent, watchAPIBufferSize) - onAddEventsChannel := make(chan *appv1.ApplicationWatchEvent, watchAPIBufferSize) - - v1ReporterEnabledFilter := func(event *appv1.ApplicationWatchEvent) bool { - if event.Type == watch.Bookmark { - return false // ignore this event - } - - rVersion, _ := s.settingsMgr.GetCodefreshReporterVersion() - if rVersion == string(settings.CodefreshV2ReporterVersion) { - logCtx.Info("v1 reporter disabled skipping event") - return false - } - return true - } - - if priorityQueueEnabled { - unsubscribeOnUpdateChannel := s.appBroadcaster.Subscribe(onUpdateEventsChannel, func(event *appv1.ApplicationWatchEvent) bool { - return event.Type == watch.Modified - }, v1ReporterEnabledFilter) - - unsubscribeOnDeleteChannel := s.appBroadcaster.Subscribe(onDeleteEventsChannel, func(event *appv1.ApplicationWatchEvent) bool { - return event.Type == watch.Deleted - }, v1ReporterEnabledFilter) - - unsubscribeOnAddChannel := s.appBroadcaster.Subscribe(onAddEventsChannel, func(event *appv1.ApplicationWatchEvent) bool { - return event.Type == watch.Added - }, v1ReporterEnabledFilter) - - defer unsubscribeOnUpdateChannel() - defer unsubscribeOnDeleteChannel() - defer unsubscribeOnAddChannel() - } else { - unsubscribeEventsChannel := s.appBroadcaster.Subscribe(allEventsChannel, v1ReporterEnabledFilter) - defer unsubscribeEventsChannel() - } - - ticker := time.NewTicker(5 * time.Second) - defer ticker.Stop() - for { - select { - case event := <-onAddEventsChannel: // active only when CODEFRESH_PRIORITY_QUEUE=true - { - logCtx.Infof("OnAdd channel size is %d", len(onAddEventsChannel)) - logAppEvent := logCtx.WithFields(log.Fields{ - "app": event.Application.Name, - "type": event.Type, - }) - logAppEvent.Infof("Received application added event") - err = s.processEvent(event, logAppEvent, stream, sendIfPermitted) - if err != nil { - return err - } - } - case event := <-onDeleteEventsChannel: // active only when CODEFRESH_PRIORITY_QUEUE=true - { - logCtx.Infof("OnDelete channel size is %d", len(onDeleteEventsChannel)) - logAppEvent := logCtx.WithFields(log.Fields{ - "app": event.Application.Name, - "type": event.Type, - }) - logAppEvent.Infof("Received application deleted event") - err = s.processEvent(event, logAppEvent, stream, sendIfPermitted) - if err != nil { - return err - } - } - case event := <-onUpdateEventsChannel: // active only when CODEFRESH_PRIORITY_QUEUE=true - { - logCtx.Infof("OnUpdate channel size is %d", len(onUpdateEventsChannel)) - logAppEvent := logCtx.WithFields(log.Fields{ - "app": event.Application.Name, - "type": event.Type, - }) - logAppEvent.Infof("Received application update event") - err = s.processEvent(event, logAppEvent, stream, sendIfPermitted) - if err != nil { - return err - } - } - case event := <-allEventsChannel: // active only when CODEFRESH_PRIORITY_QUEUE=false - { - logCtx.Infof("All events channel size is %d", len(allEventsChannel)) - logAppEvent := logCtx.WithFields(log.Fields{ - "app": event.Application.Name, - "type": event.Type, - }) - logAppEvent.Infof("Received application event") - err = s.processEvent(event, logAppEvent, stream, sendIfPermitted) - if err != nil { - return err - } - } - case <-ticker.C: - var err error - ts := time.Now().Format("2006-01-02T15:04:05.000Z") - payload := events.EventPayload{Timestamp: ts} - payloadBytes, err := json.Marshal(&payload) - if err != nil { - log.Errorf("failed to marshal payload for heartbeat: %s", err.Error()) - break - } - - ev := &events.Event{Payload: payloadBytes, Name: es.Name} - if err = stream.Send(ev); err != nil { - log.Errorf("failed to send heartbeat: %s", err.Error()) - break - } - case <-stream.Context().Done(): - return nil - } - } -} - -func (s *Server) processEvent( - event *appv1.ApplicationWatchEvent, - logCtx log.FieldLogger, - stream events.Eventing_StartEventSourceServer, - sendIfPermitted func(ctx context.Context, logCtx log.FieldLogger, a appv1.Application, ts string, ignoreResourceCache bool) error, -) error { - shouldProcess, ignoreResourceCache := s.applicationEventReporter.shouldSendApplicationEvent(event) - if !shouldProcess { - logCtx.Infof("ignore event") - return nil - } - - ts := time.Now().Format("2006-01-02T15:04:05.000Z") - ctx, cancel := context.WithTimeout(stream.Context(), 2*time.Minute) - err := sendIfPermitted(ctx, logCtx, event.Application, ts, ignoreResourceCache) - if err != nil { - logCtx.WithError(err).Error("failed to stream application events") - if strings.Contains(err.Error(), "context deadline exceeded") { - logCtx.Info("Closing event-source connection") - cancel() - return err - } - } - - cancel() - return nil -} - -func (s *Server) ValidateSrcAndDst(ctx context.Context, requset *application.ApplicationValidationRequest) (*application.ApplicationValidateResponse, error) { - app := requset.Application - proj, err := argo.GetAppProject(app, applisters.NewAppProjectLister(s.projInformer.GetIndexer()), s.ns, s.settingsMgr, s.db, ctx) - if err != nil { - entity := projectEntity - if apierr.IsNotFound(err) { - errMsg := fmt.Sprintf("application references project %s which does not exist", app.Spec.Project) - return &application.ApplicationValidateResponse{ - Error: &errMsg, - Entity: &entity, - }, nil - } - errMsg := err.Error() - return &application.ApplicationValidateResponse{ - Error: &errMsg, - Entity: &entity, - }, nil - } - - if err := validateDestination(ctx, &app.Spec.Destination, s.db); err != nil { - entity := destinationEntity - errMsg := fmt.Sprintf("application destination spec for %s is invalid: %s", app.ObjectMeta.Name, err.Error()) - return &application.ApplicationValidateResponse{ - Error: &errMsg, - Entity: &entity, - }, nil - } - var conditions []appv1.ApplicationCondition - conditions, err = argo.ValidateRepo(ctx, app, s.repoClientset, s.db, s.kubectl, proj, s.settingsMgr) - if err != nil { - entity := sourceEntity - errMsg := err.Error() - return &application.ApplicationValidateResponse{ - Error: &errMsg, - Entity: &entity, - }, nil - } - if len(conditions) > 0 { - entity := sourceEntity - errMsg := fmt.Sprintf("application spec for %s is invalid: %s", app.ObjectMeta.Name, argo.FormatAppConditions(conditions)) - return &application.ApplicationValidateResponse{ - Error: &errMsg, - Entity: &entity, - }, nil - } - return &application.ApplicationValidateResponse{ - Error: nil, - Entity: nil, - }, nil -} - -// validates destination name (argo.ValidateDestination) and server with extra logic -func validateDestination(ctx context.Context, dest *appv1.ApplicationDestination, db db.ArgoDB) error { - err := argo.ValidateDestination(ctx, dest, db) - - if err != nil { - return err - } - - if dest.Server != "" { - // Ensure the k8s cluster the app is referencing, is configured in Argo CD - _, err := db.GetCluster(ctx, dest.Server) - if err != nil { - if errStatus, ok := status.FromError(err); ok && errStatus.Code() == codes.NotFound { - return fmt.Errorf("cluster '%s' has not been configured", dest.Server) - } else { - return err - } - } - } else if dest.Server == "" { - return fmt.Errorf("destination server missing from app spec") - } - - return nil -} - func (s *Server) validateAndNormalizeApp(ctx context.Context, app *appv1.Application, proj *appv1.AppProject, validate bool) error { if app.GetName() == "" { return fmt.Errorf("resource name may not be empty") diff --git a/server/application/application_errors_parser.go b/server/application/application_errors_parser.go deleted file mode 100644 index a4da579f57e17..0000000000000 --- a/server/application/application_errors_parser.go +++ /dev/null @@ -1,147 +0,0 @@ -package application - -import ( - "fmt" - "strings" - - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - "github.com/argoproj/gitops-engine/pkg/health" - "github.com/argoproj/gitops-engine/pkg/sync/common" - - "github.com/argoproj/argo-cd/v2/pkg/apiclient/events" - appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" -) - -func parseApplicationSyncResultErrors(os *appv1.OperationState) []*events.ObjectError { - var errors []*events.ObjectError - // mean that resource not found as sync result but application can contain error inside operation state itself, - // for example app created with invalid yaml - if os.Phase == common.OperationError || os.Phase == common.OperationFailed { - errors = append(errors, &events.ObjectError{ - Type: "sync", - Level: "error", - Message: os.Message, - LastSeen: os.StartedAt, - }) - } - return errors -} - -var syncTaskUnsuccessfullErrorMessage = "one or more synchronization tasks completed unsuccessfully" -var syncTaskNotValidErrorMessage = "one or more synchronization tasks are not valid" - -func parseApplicationSyncResultErrorsFromConditions(status appv1.ApplicationStatus) []*events.ObjectError { - var errs []*events.ObjectError - if status.Conditions == nil { - return errs - } - for _, cnd := range status.Conditions { - if !strings.Contains(strings.ToLower(cnd.Type), "error") { - continue - } - - lastSeen := metav1.Now() - if cnd.LastTransitionTime != nil { - lastSeen = *cnd.LastTransitionTime - } - - if (strings.Contains(cnd.Message, syncTaskUnsuccessfullErrorMessage) || strings.Contains(cnd.Message, syncTaskNotValidErrorMessage)) && status.OperationState != nil && status.OperationState.SyncResult != nil && status.OperationState.SyncResult.Resources != nil { - resourcesSyncErrors := parseAggregativeResourcesSyncErrors(status.OperationState.SyncResult.Resources) - - errs = append(errs, resourcesSyncErrors...) - } else { - errs = append(errs, &events.ObjectError{ - Type: "sync", - Level: "error", - Message: cnd.Message, - LastSeen: lastSeen, - }) - } - } - return errs -} - -func parseResourceSyncResultErrors(rs *appv1.ResourceStatus, os *appv1.OperationState) []*events.ObjectError { - errors := []*events.ObjectError{} - if os.SyncResult == nil { - return errors - } - - _, sr := os.SyncResult.Resources.Find( - rs.Group, - rs.Kind, - rs.Namespace, - rs.Name, - common.SyncPhaseSync, - ) - - if sr == nil || !(sr.HookPhase == common.OperationFailed || sr.HookPhase == common.OperationError || sr.Status == common.ResultCodeSyncFailed) { - return errors - } - - errors = append(errors, &events.ObjectError{ - Type: "sync", - Level: "error", - Message: sr.Message, - LastSeen: os.StartedAt, - }) - - return errors -} - -func parseAggregativeHealthErrors(rs *appv1.ResourceStatus, apptree *appv1.ApplicationTree) []*events.ObjectError { - errs := make([]*events.ObjectError, 0) - - if apptree == nil { - return errs - } - - n := apptree.FindNode(rs.Group, rs.Kind, rs.Namespace, rs.Name) - if n == nil { - return errs - } - - childNodes := n.GetAllChildNodes(apptree, "") - - for _, cn := range childNodes { - if cn.Health != nil && cn.Health.Status == health.HealthStatusDegraded { - errs = append(errs, &events.ObjectError{ - Type: "health", - Level: "error", - Message: cn.Health.Message, - LastSeen: *cn.CreatedAt, - }) - } - } - - return errs -} - -func parseAggregativeResourcesSyncErrors(resourceResults appv1.ResourceResults) []*events.ObjectError { - var errs []*events.ObjectError - - if resourceResults == nil { - return errs - } - - for _, rr := range resourceResults { - if rr.Message != "" { - objectError := events.ObjectError{ - Type: "sync", - Level: "error", - LastSeen: metav1.Now(), - Message: fmt.Sprintf("Resource %s(%s): \n %s", rr.Kind, rr.Name, rr.Message), - } - if rr.Status == common.ResultCodeSyncFailed { - errs = append(errs, &objectError) - } - if rr.HookPhase == common.OperationFailed || rr.HookPhase == common.OperationError { - errs = append(errs, &objectError) - } - - } - } - - return errs -} diff --git a/server/application/application_event_reporter.go b/server/application/application_event_reporter.go deleted file mode 100644 index 9371316b45f1d..0000000000000 --- a/server/application/application_event_reporter.go +++ /dev/null @@ -1,811 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "fmt" - "reflect" - "strings" - - "github.com/argoproj/argo-cd/v2/util/argo" - - "github.com/argoproj/gitops-engine/pkg/health" - "github.com/argoproj/gitops-engine/pkg/utils/kube" - "github.com/argoproj/gitops-engine/pkg/utils/text" - log "github.com/sirupsen/logrus" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - "k8s.io/apimachinery/pkg/watch" - "sigs.k8s.io/yaml" - - "github.com/argoproj/argo-cd/v2/pkg/apiclient/application" - "github.com/argoproj/argo-cd/v2/pkg/apiclient/events" - appv1reg "github.com/argoproj/argo-cd/v2/pkg/apis/application" - appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" - "github.com/argoproj/argo-cd/v2/reposerver/apiclient" -) - -type applicationEventReporter struct { - server *Server -} - -func NewApplicationEventReporter(server *Server) *applicationEventReporter { - return &applicationEventReporter{server} -} - -func (s *applicationEventReporter) shouldSendResourceEvent(a *appv1.Application, rs appv1.ResourceStatus) bool { - logCtx := logWithResourceStatus(log.WithFields(log.Fields{ - "app": a.Name, - "gvk": fmt.Sprintf("%s/%s/%s", rs.Group, rs.Version, rs.Kind), - "resource": fmt.Sprintf("%s/%s", rs.Namespace, rs.Name), - }), rs) - - cachedRes, err := s.server.cache.GetLastResourceEvent(a, rs, getApplicationLatestRevision(a)) - if err != nil { - logCtx.Debug("resource not in cache") - return true - } - - if reflect.DeepEqual(&cachedRes, &rs) { - logCtx.Debug("resource status not changed") - - // status not changed - return false - } - - logCtx.Info("resource status changed") - return true -} - -func getParentAppName(a *appv1.Application, appInstanceLabelKey string, trackingMethod appv1.TrackingMethod) string { - resourceTracking := argo.NewResourceTracking() - unApp := kube.MustToUnstructured(&a) - - return resourceTracking.GetAppName(unApp, appInstanceLabelKey, trackingMethod) -} - -func isChildApp(parentAppName string) bool { - return parentAppName != "" -} - -func getAppAsResource(a *appv1.Application) *appv1.ResourceStatus { - return &appv1.ResourceStatus{ - Name: a.Name, - Namespace: a.Namespace, - Version: "v1alpha1", - Kind: "Application", - Group: "argoproj.io", - Status: a.Status.Sync.Status, - Health: &a.Status.Health, - RequiresPruning: a.DeletionTimestamp != nil, - } -} - -func (s *applicationEventReporter) getDesiredManifests(ctx context.Context, a *appv1.Application, logCtx log.FieldLogger) (*apiclient.ManifestResponse, error, bool) { - // get the desired state manifests of the application - desiredManifests, err := s.server.GetManifests(ctx, &application.ApplicationManifestQuery{ - Name: &a.Name, - Revision: &a.Status.Sync.Revision, - }) - if err != nil { - // if it's manifest generation error we need to still report the actual state - // of the resources, but since we can't get the desired state, we will report - // each resource with empty desired state - logCtx.WithError(err).Warn("failed to get application desired state manifests, reporting actual state only") - desiredManifests = &apiclient.ManifestResponse{Manifests: []*apiclient.Manifest{}} - return desiredManifests, nil, true // will ignore requiresPruning=true to not delete resources with actual state - } - return desiredManifests, nil, false -} - -func (s *applicationEventReporter) streamApplicationEvents( - ctx context.Context, - logCtx log.FieldLogger, - a *appv1.Application, - es *events.EventSource, - stream events.Eventing_StartEventSourceServer, - ts string, - ignoreResourceCache bool, - appInstanceLabelKey string, - trackingMethod appv1.TrackingMethod, -) error { - - logCtx.WithField("ignoreResourceCache", ignoreResourceCache).Info("streaming application events") - - appTree, err := s.server.getAppResources(ctx, a) - if err != nil { - if strings.Contains(err.Error(), "context deadline exceeded") { - return fmt.Errorf("failed to get application tree: %w", err) - } - - // we still need process app even without tree, it is in case of app yaml originally contain error, - // we still want to show it the erorrs that related to it on codefresh ui - logCtx.WithError(err).Warn("failed to get application tree, resuming") - } - - desiredManifests, err, manifestGenErr := s.getDesiredManifests(ctx, a, logCtx) - if err != nil { - return err - } - - parentAppName := getParentAppName(a, appInstanceLabelKey, trackingMethod) - - if isChildApp(parentAppName) { - parentApplicationEntity, err := s.server.Get(ctx, &application.ApplicationQuery{ - Name: &parentAppName, - }) - if err != nil { - return fmt.Errorf("failed to get parent application entity: %w", err) - } - - rs := getAppAsResource(a) - - parentDesiredManifests, err, manifestGenErr := s.getDesiredManifests(ctx, parentApplicationEntity, logCtx) - if err != nil { - logCtx.WithError(err).Warn("failed to get parent application's desired manifests, resuming") - } - - // helm app hasnt revision - // TODO: add check if it helm application - parentOperationRevision := getOperationRevision(parentApplicationEntity) - parentRevisionMetadata, err := s.getApplicationRevisionDetails(ctx, parentApplicationEntity, parentOperationRevision) - if err != nil { - logCtx.WithError(err).Warn("failed to get parent application's revision metadata, resuming") - } - - err = s.processResource(ctx, *rs, parentApplicationEntity, logCtx, ts, parentDesiredManifests, stream, appTree, es, manifestGenErr, a, parentRevisionMetadata, true, appInstanceLabelKey, trackingMethod, desiredManifests.ApplicationVersions) - if err != nil { - return err - } - } else { - // will get here only for root applications (not managed as a resource by another application) - appEvent, err := s.getApplicationEventPayload(ctx, a, es, ts, appInstanceLabelKey, trackingMethod, desiredManifests.ApplicationVersions) - if err != nil { - return fmt.Errorf("failed to get application event: %w", err) - } - - if appEvent == nil { - // event did not have an OperationState - skip all events - return nil - } - - logWithAppStatus(a, logCtx, ts).Info("sending root application event") - if err := stream.Send(appEvent); err != nil { - return fmt.Errorf("failed to send event for root application %s/%s: %w", a.Namespace, a.Name, err) - } - } - - revisionMetadata, _ := s.getApplicationRevisionDetails(ctx, a, getOperationRevision(a)) - // for each resource in the application get desired and actual state, - // then stream the event - for _, rs := range a.Status.Resources { - if isApp(rs) { - continue - } - - err := s.processResource(ctx, rs, a, logCtx, ts, desiredManifests, stream, appTree, es, manifestGenErr, nil, revisionMetadata, ignoreResourceCache, appInstanceLabelKey, trackingMethod, nil) - if err != nil { - return err - } - } - return nil -} - -func (s *applicationEventReporter) getAppForResourceReporting( - rs appv1.ResourceStatus, - ctx context.Context, - a *appv1.Application, - revisionMetadata *appv1.RevisionMetadata, -) (*appv1.Application, *appv1.RevisionMetadata) { - if rs.Kind != "Rollout" { // for rollout it's crucial to report always correct operationSyncRevision - return a, revisionMetadata - } - - latestAppStatus, err := s.server.appLister.Applications(a.Namespace).Get(a.Name) - - if err != nil { - return a, revisionMetadata - } - - revisionMetadataToReport, err := s.getApplicationRevisionDetails(ctx, latestAppStatus, getOperationRevision(latestAppStatus)) - - if err != nil { - return a, revisionMetadata - } - - return latestAppStatus, revisionMetadataToReport -} - -func (s *applicationEventReporter) processResource( - ctx context.Context, - rs appv1.ResourceStatus, - parentApplication *appv1.Application, - logCtx log.FieldLogger, - ts string, - desiredManifests *apiclient.ManifestResponse, - stream events.Eventing_StartEventSourceServer, - appTree *appv1.ApplicationTree, - es *events.EventSource, - manifestGenErr bool, - originalApplication *appv1.Application, - revisionMetadata *appv1.RevisionMetadata, - ignoreResourceCache bool, - appInstanceLabelKey string, - trackingMethod appv1.TrackingMethod, - applicationVersions *apiclient.ApplicationVersions, -) error { - logCtx = logCtx.WithFields(log.Fields{ - "gvk": fmt.Sprintf("%s/%s/%s", rs.Group, rs.Version, rs.Kind), - "resource": fmt.Sprintf("%s/%s", rs.Namespace, rs.Name), - }) - - if rs.Health == nil && rs.Status == appv1.SyncStatusCodeSynced { - // for resources without health status we need to add 'Healthy' status - // when they are synced because we might have sent an event with 'Missing' - // status earlier and they would be stuck in it if we don't switch to 'Healthy' - rs.Health = &appv1.HealthStatus{ - Status: health.HealthStatusHealthy, - } - } - - if !ignoreResourceCache && !s.shouldSendResourceEvent(parentApplication, rs) { - return nil - } - - // get resource desired state - desiredState := getResourceDesiredState(&rs, desiredManifests, logCtx) - - // get resource actual state - actualState, err := s.server.GetResource(ctx, &application.ApplicationResourceRequest{ - Name: &parentApplication.Name, - Namespace: &rs.Namespace, - ResourceName: &rs.Name, - Version: &rs.Version, - Group: &rs.Group, - Kind: &rs.Kind, - }) - if err != nil { - if !strings.Contains(err.Error(), "not found") { - // only return error if there is no point in trying to send the - // next resource. For example if the shared context has exceeded - // its deadline - if strings.Contains(err.Error(), "context deadline exceeded") { - return fmt.Errorf("failed to get actual state: %w", err) - } - - logCtx.WithError(err).Warn("failed to get actual state, resuming") - return nil - } - - manifest := "" - // empty actual state - actualState = &application.ApplicationResourceResponse{Manifest: &manifest} - } - - parentApplicationToReport, revisionMetadataToReport := s.getAppForResourceReporting(rs, ctx, parentApplication, revisionMetadata) - - var originalAppRevisionMetadata *appv1.RevisionMetadata = nil - - if originalApplication != nil { - originalAppRevisionMetadata, _ = s.getApplicationRevisionDetails(ctx, originalApplication, getOperationRevision(originalApplication)) - } - - ev, err := getResourceEventPayload(parentApplicationToReport, &rs, es, actualState, desiredState, appTree, manifestGenErr, ts, originalApplication, revisionMetadataToReport, originalAppRevisionMetadata, appInstanceLabelKey, trackingMethod, applicationVersions) - if err != nil { - logCtx.WithError(err).Warn("failed to get event payload, resuming") - return nil - } - - appRes := appv1.Application{} - if isApp(rs) && actualState.Manifest != nil && json.Unmarshal([]byte(*actualState.Manifest), &appRes) == nil { - logWithAppStatus(&appRes, logCtx, ts).Info("streaming resource event") - } else { - logWithResourceStatus(logCtx, rs).Info("streaming resource event") - } - - if err := stream.Send(ev); err != nil { - if strings.Contains(err.Error(), "context deadline exceeded") { - return fmt.Errorf("failed to send resource event: %w", err) - } - - logCtx.WithError(err).Warn("failed to send resource event, resuming") - return nil - } - - if err := s.server.cache.SetLastResourceEvent(parentApplicationToReport, rs, resourceEventCacheExpiration, getApplicationLatestRevision(parentApplicationToReport)); err != nil { - logCtx.WithError(err).Warn("failed to cache resource event") - } - - return nil -} - -func (s *applicationEventReporter) shouldSendApplicationEvent(ae *appv1.ApplicationWatchEvent) (shouldSend bool, syncStatusChanged bool) { - logCtx := log.WithField("app", ae.Application.Name) - - if ae.Type == watch.Deleted { - logCtx.Info("application deleted") - return true, false - } - - cachedApp, err := s.server.cache.GetLastApplicationEvent(&ae.Application) - if err != nil || cachedApp == nil { - return true, false - } - - cachedApp.Status.ReconciledAt = ae.Application.Status.ReconciledAt // ignore those in the diff - cachedApp.Spec.Project = ae.Application.Spec.Project // - for i := range cachedApp.Status.Conditions { - cachedApp.Status.Conditions[i].LastTransitionTime = nil - } - for i := range ae.Application.Status.Conditions { - ae.Application.Status.Conditions[i].LastTransitionTime = nil - } - - // check if application changed to healthy status - if ae.Application.Status.Health.Status == health.HealthStatusHealthy && cachedApp.Status.Health.Status != health.HealthStatusHealthy { - return true, true - } - - if !reflect.DeepEqual(ae.Application.Spec, cachedApp.Spec) { - logCtx.Info("application spec changed") - return true, false - } - - if !reflect.DeepEqual(ae.Application.Status, cachedApp.Status) { - logCtx.Info("application status changed") - return true, false - } - - if !reflect.DeepEqual(ae.Application.Operation, cachedApp.Operation) { - logCtx.Info("application operation changed") - return true, false - } - - return false, false -} - -func isApp(rs appv1.ResourceStatus) bool { - return rs.GroupVersionKind().String() == appv1.ApplicationSchemaGroupVersionKind.String() -} - -func logWithAppStatus(a *appv1.Application, logCtx log.FieldLogger, ts string) *log.Entry { - return logCtx.WithFields(log.Fields{ - "sync": a.Status.Sync.Status, - "health": a.Status.Health.Status, - "resourceVersion": a.ResourceVersion, - "ts": ts, - }) -} - -func logWithResourceStatus(logCtx log.FieldLogger, rs appv1.ResourceStatus) log.FieldLogger { - logCtx = logCtx.WithField("sync", rs.Status) - if rs.Health != nil { - logCtx = logCtx.WithField("health", rs.Health.Status) - } - - return logCtx -} - -func getLatestAppHistoryItem(a *appv1.Application) *appv1.RevisionHistory { - if a.Status.History != nil && len(a.Status.History) > 0 { - return &a.Status.History[len(a.Status.History)-1] - } - - return nil -} - -func getApplicationLatestRevision(a *appv1.Application) string { - revision := a.Status.Sync.Revision - lastHistory := getLatestAppHistoryItem(a) - - if lastHistory != nil { - revision = lastHistory.Revision - } - - return revision -} - -func getOperationRevision(a *appv1.Application) string { - var revision string - if a != nil { - // this value will be used in case if application hasnt resources , like gitsource - revision = a.Status.Sync.Revision - if a.Status.OperationState != nil && a.Status.OperationState.Operation.Sync != nil && a.Status.OperationState.Operation.Sync.Revision != "" { - revision = a.Status.OperationState.Operation.Sync.Revision - } else if a.Operation != nil && a.Operation.Sync != nil && a.Operation.Sync.Revision != "" { - revision = a.Operation.Sync.Revision - } - } - - return revision -} - -func (s *applicationEventReporter) getApplicationRevisionDetails(ctx context.Context, a *appv1.Application, revision string) (*appv1.RevisionMetadata, error) { - name := a.GetName() - namespace := a.GetNamespace() - project := a.Spec.GetProject() - return s.server.RevisionMetadata(ctx, &application.RevisionMetadataQuery{ - Name: &name, - AppNamespace: &namespace, - Project: &project, - Revision: &revision, - }) -} - -func getLatestAppHistoryId(a *appv1.Application) int64 { - var id int64 - lastHistory := getLatestAppHistoryItem(a) - - if lastHistory != nil { - id = lastHistory.ID - } - - return id -} - -func getResourceEventPayload( - parentApplication *appv1.Application, - rs *appv1.ResourceStatus, - es *events.EventSource, - actualState *application.ApplicationResourceResponse, - desiredState *apiclient.Manifest, - apptree *appv1.ApplicationTree, - manifestGenErr bool, - ts string, - originalApplication *appv1.Application, // passed when rs is application - revisionMetadata *appv1.RevisionMetadata, - originalAppRevisionMetadata *appv1.RevisionMetadata, // passed when rs is application - appInstanceLabelKey string, - trackingMethod appv1.TrackingMethod, - applicationVersions *apiclient.ApplicationVersions, -) (*events.Event, error) { - var ( - err error - syncStarted = metav1.Now() - syncFinished *metav1.Time - errors = []*events.ObjectError{} - logCtx *log.Entry - ) - - if originalApplication != nil { - logCtx = log.WithField("application", originalApplication.Name) - } else { - logCtx = log.NewEntry(log.StandardLogger()) - } - - object := []byte(*actualState.Manifest) - - if originalAppRevisionMetadata != nil && len(object) != 0 { - actualObject, err := appv1.UnmarshalToUnstructured(*actualState.Manifest) - - if err == nil { - actualObject = addCommitDetailsToLabels(actualObject, originalAppRevisionMetadata) - object, err = actualObject.MarshalJSON() - if err != nil { - return nil, fmt.Errorf("failed to marshal unstructured object: %w", err) - } - } - } - if len(object) == 0 { - if len(desiredState.CompiledManifest) == 0 { - // no actual or desired state, don't send event - u := &unstructured.Unstructured{} - apiVersion := rs.Version - if rs.Group != "" { - apiVersion = rs.Group + "/" + rs.Version - } - - u.SetAPIVersion(apiVersion) - u.SetKind(rs.Kind) - u.SetName(rs.Name) - u.SetNamespace(rs.Namespace) - if originalAppRevisionMetadata != nil { - u = addCommitDetailsToLabels(u, originalAppRevisionMetadata) - } - - object, err = u.MarshalJSON() - if err != nil { - return nil, fmt.Errorf("failed to marshal unstructured object: %w", err) - } - } else { - // no actual state, use desired state as event object - unstructuredWithNamespace, err := addDestNamespaceToManifest([]byte(desiredState.CompiledManifest), rs) - if err != nil { - return nil, fmt.Errorf("failed to add destination namespace to manifest: %w", err) - } - if originalAppRevisionMetadata != nil { - unstructuredWithNamespace = addCommitDetailsToLabels(unstructuredWithNamespace, originalAppRevisionMetadata) - } - - object, _ = unstructuredWithNamespace.MarshalJSON() - } - } else if rs.RequiresPruning && !manifestGenErr { - // resource should be deleted - desiredState.CompiledManifest = "" - manifest := "" - actualState.Manifest = &manifest - } - - if (originalApplication != nil && originalApplication.DeletionTimestamp != nil) || parentApplication.ObjectMeta.DeletionTimestamp != nil { - // resource should be deleted in case if application in process of deletion - desiredState.CompiledManifest = "" - manifest := "" - actualState.Manifest = &manifest - } - - if parentApplication.Status.OperationState != nil { - syncStarted = parentApplication.Status.OperationState.StartedAt - syncFinished = parentApplication.Status.OperationState.FinishedAt - errors = append(errors, parseResourceSyncResultErrors(rs, parentApplication.Status.OperationState)...) - } - - // for primitive resources that are synced right away and don't require progression time (like configmap) - if rs.Status == appv1.SyncStatusCodeSynced && rs.Health != nil && rs.Health.Status == health.HealthStatusHealthy { - syncFinished = &syncStarted - } - - // parent application not include errors in application originally was created with broken state, for example in destination missed namespace - if originalApplication != nil && originalApplication.Status.OperationState != nil { - errors = append(errors, parseApplicationSyncResultErrors(originalApplication.Status.OperationState)...) - } - - if originalApplication != nil && originalApplication.Status.Conditions != nil { - errors = append(errors, parseApplicationSyncResultErrorsFromConditions(originalApplication.Status)...) - } - - if len(desiredState.RawManifest) == 0 && len(desiredState.CompiledManifest) != 0 { - // for handling helm defined resources, etc... - y, err := yaml.JSONToYAML([]byte(desiredState.CompiledManifest)) - if err == nil { - desiredState.RawManifest = string(y) - } - } - - applicationVersionsEvents, err := repoAppVersionsToEvent(applicationVersions) - if err != nil { - logCtx.Errorf("failed to convert appVersions: %v", err) - } - - source := events.ObjectSource{ - DesiredManifest: desiredState.CompiledManifest, - ActualManifest: *actualState.Manifest, - GitManifest: desiredState.RawManifest, - RepoURL: parentApplication.Status.Sync.ComparedTo.Source.RepoURL, - Path: desiredState.Path, - Revision: getApplicationLatestRevision(parentApplication), - OperationSyncRevision: getOperationRevision(parentApplication), - HistoryId: getLatestAppHistoryId(parentApplication), - AppName: parentApplication.Name, - AppNamespace: parentApplication.Namespace, - AppUID: string(parentApplication.ObjectMeta.UID), - AppLabels: parentApplication.Labels, - SyncStatus: string(rs.Status), - SyncStartedAt: syncStarted, - SyncFinishedAt: syncFinished, - Cluster: parentApplication.Spec.Destination.Server, - AppInstanceLabelKey: appInstanceLabelKey, - TrackingMethod: string(trackingMethod), - } - - if revisionMetadata != nil { - source.CommitMessage = revisionMetadata.Message - source.CommitAuthor = revisionMetadata.Author - source.CommitDate = &revisionMetadata.Date - } - - if rs.Health != nil { - source.HealthStatus = (*string)(&rs.Health.Status) - source.HealthMessage = &rs.Health.Message - if rs.Health.Status != health.HealthStatusHealthy { - errors = append(errors, parseAggregativeHealthErrors(rs, apptree)...) - } - } - - payload := events.EventPayload{ - Timestamp: ts, - Object: object, - Source: &source, - Errors: errors, - AppVersions: applicationVersionsEvents, - } - - logCtx.Infof("AppVersion before encoding: %v", safeString(payload.AppVersions.AppVersion)) - - payloadBytes, err := json.Marshal(&payload) - if err != nil { - return nil, fmt.Errorf("failed to marshal payload for resource %s/%s: %w", rs.Namespace, rs.Name, err) - } - - return &events.Event{Payload: payloadBytes, Name: es.Name}, nil -} - -func (s *applicationEventReporter) getApplicationEventPayload( - ctx context.Context, - a *appv1.Application, - es *events.EventSource, - ts string, - appInstanceLabelKey string, - trackingMethod appv1.TrackingMethod, - applicationVersions *apiclient.ApplicationVersions, -) (*events.Event, error) { - var ( - syncStarted = metav1.Now() - syncFinished *metav1.Time - logCtx = log.WithField("application", a.Name) - ) - - obj := appv1.Application{} - a.DeepCopyInto(&obj) - - // make sure there is type meta on object - obj.TypeMeta = metav1.TypeMeta{ - Kind: appv1reg.ApplicationKind, - APIVersion: appv1.SchemeGroupVersion.String(), - } - - if a.Status.OperationState != nil { - syncStarted = a.Status.OperationState.StartedAt - syncFinished = a.Status.OperationState.FinishedAt - } - - applicationSource := a.Spec.GetSource() - if !applicationSource.IsHelm() && (a.Status.Sync.Revision != "" || (a.Status.History != nil && len(a.Status.History) > 0)) { - revisionMetadata, err := s.getApplicationRevisionDetails(ctx, a, getOperationRevision(a)) - - if err != nil { - if !strings.Contains(err.Error(), "not found") { - return nil, fmt.Errorf("failed to get revision metadata: %w", err) - } - - logCtx.Warnf("failed to get revision metadata: %s, reporting application deletion event", err.Error()) - } else { - if obj.ObjectMeta.Labels == nil { - obj.ObjectMeta.Labels = map[string]string{} - } - - obj.ObjectMeta.Labels["app.meta.commit-date"] = revisionMetadata.Date.Format("2006-01-02T15:04:05.000Z") - obj.ObjectMeta.Labels["app.meta.commit-author"] = revisionMetadata.Author - obj.ObjectMeta.Labels["app.meta.commit-message"] = revisionMetadata.Message - } - } - - object, err := json.Marshal(&obj) - if err != nil { - return nil, fmt.Errorf("failed to marshal application event") - } - - actualManifest := string(object) - if a.DeletionTimestamp != nil { - actualManifest = "" // mark as deleted - logCtx.Info("reporting application deletion event") - } - - applicationVersionsEvents, err := repoAppVersionsToEvent(applicationVersions) - if err != nil { - logCtx.Errorf("failed to convert appVersions: %v", err) - } - - hs := string(a.Status.Health.Status) - source := &events.ObjectSource{ - DesiredManifest: "", - GitManifest: "", - ActualManifest: actualManifest, - RepoURL: a.Spec.GetSource().RepoURL, - CommitMessage: "", - CommitAuthor: "", - Path: "", - Revision: "", - OperationSyncRevision: "", - HistoryId: 0, - AppName: "", - AppUID: "", - AppLabels: map[string]string{}, - SyncStatus: string(a.Status.Sync.Status), - SyncStartedAt: syncStarted, - SyncFinishedAt: syncFinished, - HealthStatus: &hs, - HealthMessage: &a.Status.Health.Message, - Cluster: a.Spec.Destination.Server, - AppInstanceLabelKey: appInstanceLabelKey, - TrackingMethod: string(trackingMethod), - } - - payload := events.EventPayload{ - Timestamp: ts, - Object: object, - Source: source, - Errors: parseApplicationSyncResultErrorsFromConditions(a.Status), - AppVersions: applicationVersionsEvents, - } - - logCtx.Infof("AppVersion before encoding: %v", safeString(payload.AppVersions.AppVersion)) - - payloadBytes, err := json.Marshal(&payload) - if err != nil { - return nil, fmt.Errorf("failed to marshal payload for resource %s/%s: %w", a.Namespace, a.Name, err) - } - - return &events.Event{Payload: payloadBytes, Name: es.Name}, nil -} - -func getResourceDesiredState(rs *appv1.ResourceStatus, ds *apiclient.ManifestResponse, logger log.FieldLogger) *apiclient.Manifest { - if ds == nil { - return &apiclient.Manifest{} - } - for _, m := range ds.Manifests { - u, err := appv1.UnmarshalToUnstructured(m.CompiledManifest) - if err != nil { - logger.WithError(err).Warnf("failed to unmarshal compiled manifest") - continue - } - - if u == nil { - continue - } - - ns := text.FirstNonEmpty(u.GetNamespace(), rs.Namespace) - - if u.GroupVersionKind().String() == rs.GroupVersionKind().String() && - u.GetName() == rs.Name && - ns == rs.Namespace { - if rs.Kind == kube.SecretKind && rs.Version == "v1" { - m.RawManifest = m.CompiledManifest - } - - return m - } - } - - // no desired state for resource - // it's probably deleted from git - return &apiclient.Manifest{} -} - -func addDestNamespaceToManifest(resourceManifest []byte, rs *appv1.ResourceStatus) (*unstructured.Unstructured, error) { - u, err := appv1.UnmarshalToUnstructured(string(resourceManifest)) - if err != nil { - return nil, fmt.Errorf("failed to unmarshal manifest: %w", err) - } - - if u.GetNamespace() == rs.Namespace { - return u, nil - } - - // need to change namespace - u.SetNamespace(rs.Namespace) - - return u, nil -} - -func addCommitDetailsToLabels(u *unstructured.Unstructured, revisionMetadata *appv1.RevisionMetadata) *unstructured.Unstructured { - if revisionMetadata == nil || u == nil { - return u - } - - if field, _, _ := unstructured.NestedFieldCopy(u.Object, "metadata", "labels"); field == nil { - _ = unstructured.SetNestedStringMap(u.Object, map[string]string{}, "metadata", "labels") - } - - _ = unstructured.SetNestedField(u.Object, revisionMetadata.Date.Format("2006-01-02T15:04:05.000Z"), "metadata", "labels", "app.meta.commit-date") - _ = unstructured.SetNestedField(u.Object, revisionMetadata.Author, "metadata", "labels", "app.meta.commit-author") - _ = unstructured.SetNestedField(u.Object, revisionMetadata.Message, "metadata", "labels", "app.meta.commit-message") - - return u -} - -func repoAppVersionsToEvent(applicationVersions *apiclient.ApplicationVersions) (*events.ApplicationVersions, error) { - applicationVersionsEvents := &events.ApplicationVersions{} - applicationVersionsData, _ := json.Marshal(applicationVersions) - err := json.Unmarshal(applicationVersionsData, applicationVersionsEvents) - if err != nil { - return nil, err - } - return applicationVersionsEvents, nil -} - -func safeString(s *string) string { - if s == nil { - return "" - } - return *s -} diff --git a/server/application/application_event_reporter_test.go b/server/application/application_event_reporter_test.go deleted file mode 100644 index 756b1d350f1a9..0000000000000 --- a/server/application/application_event_reporter_test.go +++ /dev/null @@ -1,452 +0,0 @@ -package application - -import ( - "context" - "encoding/json" - "testing" - "time" - - "github.com/ghodss/yaml" - "k8s.io/apimachinery/pkg/apis/meta/v1/unstructured" - - log "github.com/sirupsen/logrus" - "google.golang.org/grpc" - "k8s.io/apimachinery/pkg/runtime" - - appsv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" - fakeapps "github.com/argoproj/argo-cd/v2/pkg/client/clientset/versioned/fake" - appinformer "github.com/argoproj/argo-cd/v2/pkg/client/informers/externalversions" - applisters "github.com/argoproj/argo-cd/v2/pkg/client/listers/application/v1alpha1" - - "k8s.io/client-go/kubernetes/fake" - "k8s.io/client-go/tools/cache" - - apps "github.com/argoproj/argo-cd/v2/pkg/client/clientset/versioned/fake" - appinformers "github.com/argoproj/argo-cd/v2/pkg/client/informers/externalversions/application/v1alpha1" - servercache "github.com/argoproj/argo-cd/v2/server/cache" - "github.com/argoproj/argo-cd/v2/test" - cacheutil "github.com/argoproj/argo-cd/v2/util/cache" - appstatecache "github.com/argoproj/argo-cd/v2/util/cache/appstate" - "github.com/argoproj/argo-cd/v2/util/rbac" - - "github.com/stretchr/testify/assert" - metav1 "k8s.io/apimachinery/pkg/apis/meta/v1" - - "github.com/argoproj/argo-cd/v2/common" - "github.com/argoproj/argo-cd/v2/pkg/apiclient/application" - "github.com/argoproj/argo-cd/v2/pkg/apiclient/events" - "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" - "github.com/argoproj/argo-cd/v2/reposerver/apiclient" - "github.com/argoproj/argo-cd/v2/util/argo" -) - -func TestGetResourceEventPayload(t *testing.T) { - t.Run("Deleting timestamp is empty", func(t *testing.T) { - - app := v1alpha1.Application{} - rs := v1alpha1.ResourceStatus{} - es := events.EventSource{} - - man := "{ \"key\" : \"manifest\" }" - - actualState := application.ApplicationResourceResponse{ - Manifest: &man, - } - desiredState := apiclient.Manifest{ - CompiledManifest: "{ \"key\" : \"manifest\" }", - } - appTree := v1alpha1.ApplicationTree{} - revisionMetadata := v1alpha1.RevisionMetadata{ - Author: "demo usert", - Date: metav1.Time{}, - Message: "some message", - } - - event, err := getResourceEventPayload(&app, &rs, &es, &actualState, &desiredState, &appTree, true, "", nil, &revisionMetadata, nil, common.LabelKeyAppInstance, argo.TrackingMethodLabel, &apiclient.ApplicationVersions{}) - assert.NoError(t, err) - - var eventPayload events.EventPayload - - err = json.Unmarshal(event.Payload, &eventPayload) - assert.NoError(t, err) - - assert.Equal(t, "{ \"key\" : \"manifest\" }", eventPayload.Source.DesiredManifest) - assert.Equal(t, "{ \"key\" : \"manifest\" }", eventPayload.Source.ActualManifest) - }) - - t.Run("Deleting timestamp is empty", func(t *testing.T) { - - app := v1alpha1.Application{ - ObjectMeta: metav1.ObjectMeta{ - DeletionTimestamp: &metav1.Time{}, - }, - Status: v1alpha1.ApplicationStatus{}, - } - rs := v1alpha1.ResourceStatus{} - es := events.EventSource{} - man := "{ \"key\" : \"manifest\" }" - actualState := application.ApplicationResourceResponse{ - Manifest: &man, - } - desiredState := apiclient.Manifest{ - CompiledManifest: "{ \"key\" : \"manifest\" }", - } - appTree := v1alpha1.ApplicationTree{} - revisionMetadata := v1alpha1.RevisionMetadata{ - Author: "demo usert", - Date: metav1.Time{}, - Message: "some message", - } - - event, err := getResourceEventPayload(&app, &rs, &es, &actualState, &desiredState, &appTree, true, "", nil, &revisionMetadata, nil, common.LabelKeyAppInstance, argo.TrackingMethodLabel, &apiclient.ApplicationVersions{}) - assert.NoError(t, err) - - var eventPayload events.EventPayload - - err = json.Unmarshal(event.Payload, &eventPayload) - assert.NoError(t, err) - - assert.Equal(t, "", eventPayload.Source.DesiredManifest) - assert.Equal(t, "", eventPayload.Source.ActualManifest) - }) -} - -func TestGetApplicationLatestRevision(t *testing.T) { - appRevision := "a-revision" - history1Revision := "history-revision-1" - history2Revision := "history-revision-2" - - t.Run("resource revision should be taken from sync.revision", func(t *testing.T) { - noStatusHistoryAppMock := v1alpha1.Application{ - Status: v1alpha1.ApplicationStatus{ - Sync: v1alpha1.SyncStatus{ - Revision: appRevision, - }, - }, - } - - revisionResult := getApplicationLatestRevision(&noStatusHistoryAppMock) - assert.Equal(t, revisionResult, appRevision) - - emptyStatusHistoryAppMock := v1alpha1.Application{ - Status: v1alpha1.ApplicationStatus{ - Sync: v1alpha1.SyncStatus{ - Revision: appRevision, - }, - History: []v1alpha1.RevisionHistory{}, - }, - } - - revision2Result := getApplicationLatestRevision(&emptyStatusHistoryAppMock) - assert.Equal(t, revision2Result, appRevision) - }) - - t.Run("resource revision should be taken from latest history.revision", func(t *testing.T) { - appMock := v1alpha1.Application{ - Status: v1alpha1.ApplicationStatus{ - Sync: v1alpha1.SyncStatus{ - Revision: appRevision, - }, - History: []v1alpha1.RevisionHistory{ - { - Revision: history1Revision, - }, - { - Revision: history2Revision, - }, - }, - }, - } - - revisionResult := getApplicationLatestRevision(&appMock) - assert.Equal(t, revisionResult, history2Revision) - }) -} - -func TestGetLatestAppHistoryId(t *testing.T) { - history1Id := int64(1) - history2Id := int64(2) - - t.Run("resource revision should be 0", func(t *testing.T) { - noStatusHistoryAppMock := v1alpha1.Application{} - - idResult := getLatestAppHistoryId(&noStatusHistoryAppMock) - assert.Equal(t, idResult, int64(0)) - - emptyStatusHistoryAppMock := v1alpha1.Application{ - Status: v1alpha1.ApplicationStatus{ - History: []v1alpha1.RevisionHistory{}, - }, - } - - id2Result := getLatestAppHistoryId(&emptyStatusHistoryAppMock) - assert.Equal(t, id2Result, int64(0)) - }) - - t.Run("resource revision should be taken from latest history.Id", func(t *testing.T) { - appMock := v1alpha1.Application{ - Status: v1alpha1.ApplicationStatus{ - History: []v1alpha1.RevisionHistory{ - { - ID: history1Id, - }, - { - ID: history2Id, - }, - }, - }, - } - - revisionResult := getLatestAppHistoryId(&appMock) - assert.Equal(t, revisionResult, history2Id) - }) -} - -func newAppLister(objects ...runtime.Object) applisters.ApplicationLister { - fakeAppsClientset := fakeapps.NewSimpleClientset(objects...) - factory := appinformer.NewSharedInformerFactoryWithOptions(fakeAppsClientset, 0, appinformer.WithNamespace(""), appinformer.WithTweakListOptions(func(options *metav1.ListOptions) {})) - appsInformer := factory.Argoproj().V1alpha1().Applications() - for _, obj := range objects { - switch obj.(type) { - case *appsv1.Application: - _ = appsInformer.Informer().GetStore().Add(obj) - } - } - appLister := appsInformer.Lister() - return appLister -} - -func fakeServer() *Server { - cm := test.NewFakeConfigMap() - secret := test.NewFakeSecret() - kubeclientset := fake.NewSimpleClientset(cm, secret) - appClientSet := apps.NewSimpleClientset() - - appInformer := appinformers.NewApplicationInformer(appClientSet, "", time.Minute, cache.Indexers{}) - - guestbookApp := &appsv1.Application{ - TypeMeta: metav1.TypeMeta{ - Kind: "Application", - APIVersion: "argoproj.io/v1alpha1", - }, - ObjectMeta: metav1.ObjectMeta{ - Name: "guestbook", - Namespace: testNamespace, - }, - Spec: appsv1.ApplicationSpec{ - Project: "default", - Source: &appsv1.ApplicationSource{ - RepoURL: "https://test", - TargetRevision: "HEAD", - Helm: &appsv1.ApplicationSourceHelm{ - ValueFiles: []string{"values.yaml"}, - }, - }, - }, - Status: appsv1.ApplicationStatus{ - History: appsv1.RevisionHistories{ - { - Revision: "abcdef123567", - Source: appsv1.ApplicationSource{ - RepoURL: "https://test", - TargetRevision: "HEAD", - Helm: &appsv1.ApplicationSourceHelm{ - ValueFiles: []string{"values-old.yaml"}, - }, - }, - }, - }, - }, - } - - appLister := newAppLister(guestbookApp) - // _, _ := test.NewInMemoryRedis() - - cache := servercache.NewCache( - appstatecache.NewCache( - cacheutil.NewCache(cacheutil.NewInMemoryCache(1*time.Hour)), - 1*time.Minute, - ), - 1*time.Minute, - 1*time.Minute, - 1*time.Minute, - ) - - enf := rbac.NewEnforcer(kubeclientset, testNamespace, common.ArgoCDRBACConfigMapName, nil) - server, _ := NewServer(test.FakeArgoCDNamespace, kubeclientset, appClientSet, appLister, appInformer, nil, nil, cache, nil, nil, enf, nil, nil, nil, nil) - return server.(*Server) -} - -func TestShouldSendEvent(t *testing.T) { - serverInstance := fakeServer() - t.Run("should send because cache is missing", func(t *testing.T) { - eventReporter := applicationEventReporter{ - server: serverInstance, - } - - app := &v1alpha1.Application{} - rs := v1alpha1.ResourceStatus{} - - res := eventReporter.shouldSendResourceEvent(app, rs) - assert.True(t, res) - }) - - t.Run("should not send - same entities", func(t *testing.T) { - eventReporter := applicationEventReporter{ - server: serverInstance, - } - - app := &v1alpha1.Application{} - rs := v1alpha1.ResourceStatus{} - - _ = eventReporter.server.cache.SetLastResourceEvent(app, rs, time.Minute, "") - - res := eventReporter.shouldSendResourceEvent(app, rs) - assert.False(t, res) - }) - - t.Run("should send - different entities", func(t *testing.T) { - eventReporter := applicationEventReporter{ - server: serverInstance, - } - - app := &v1alpha1.Application{} - rs := v1alpha1.ResourceStatus{} - - _ = eventReporter.server.cache.SetLastResourceEvent(app, rs, time.Minute, "") - - rs.Status = v1alpha1.SyncStatusCodeOutOfSync - - res := eventReporter.shouldSendResourceEvent(app, rs) - assert.True(t, res) - }) - -} - -type MockEventing_StartEventSourceServer struct { - grpc.ServerStream -} - -var result func(*events.Event) error - -func (m *MockEventing_StartEventSourceServer) Send(event *events.Event) error { - return result(event) -} - -func TestStreamApplicationEvent(t *testing.T) { - serverInstance := fakeServer() - t.Run("root application", func(t *testing.T) { - eventReporter := applicationEventReporter{ - server: serverInstance, - } - - app := &v1alpha1.Application{ - TypeMeta: metav1.TypeMeta{ - APIVersion: "argoproj.io/v1alpha1", - Kind: "Application", - }, - } - name := "name" - - result = func(event *events.Event) error { - var payload events.EventPayload - _ = json.Unmarshal(event.Payload, &payload) - - var actualApp v1alpha1.Application - _ = json.Unmarshal([]byte(payload.Source.ActualManifest), &actualApp) - assert.Equal(t, *app, actualApp) - return nil - } - - _ = eventReporter.streamApplicationEvents(context.Background(), log.New(), app, &events.EventSource{Name: &name}, &MockEventing_StartEventSourceServer{}, "", false, common.LabelKeyAppInstance, argo.TrackingMethodLabel) - }) - -} - -func TestGetResourceEventPayloadWithoutRevision(t *testing.T) { - app := v1alpha1.Application{} - rs := v1alpha1.ResourceStatus{} - es := events.EventSource{} - - mf := "{ \"key\" : \"manifest\" }" - - actualState := application.ApplicationResourceResponse{ - Manifest: &mf, - } - desiredState := apiclient.Manifest{ - CompiledManifest: "{ \"key\" : \"manifest\" }", - } - appTree := v1alpha1.ApplicationTree{} - - _, err := getResourceEventPayload(&app, &rs, &es, &actualState, &desiredState, &appTree, true, "", nil, nil, nil, common.LabelKeyAppInstance, argo.TrackingMethodLabel, &apiclient.ApplicationVersions{}) - assert.NoError(t, err) - -} - -func StrToUnstructured(jsonStr string) *unstructured.Unstructured { - obj := make(map[string]interface{}) - err := yaml.Unmarshal([]byte(jsonStr), &obj) - if err != nil { - panic(err) - } - return &unstructured.Unstructured{Object: obj} -} - -func TestAddCommitDetailsToLabels(t *testing.T) { - revisionMetadata := v1alpha1.RevisionMetadata{ - Author: "demo usert", - Date: metav1.Time{}, - Message: "some message", - } - - t.Run("set labels when lable object missing", func(t *testing.T) { - resource := StrToUnstructured(` - apiVersion: v1 - kind: Service - metadata: - name: helm-guestbook - namespace: default - resourceVersion: "123" - uid: "4" - spec: - selector: - app: guestbook - type: LoadBalancer - status: - loadBalancer: - ingress: - - hostname: localhost`, - ) - - result := addCommitDetailsToLabels(resource, &revisionMetadata) - labels := result.GetLabels() - assert.Equal(t, revisionMetadata.Author, labels["app.meta.commit-author"]) - assert.Equal(t, revisionMetadata.Message, labels["app.meta.commit-message"]) - }) - - t.Run("set labels when labels present", func(t *testing.T) { - resource := StrToUnstructured(` - apiVersion: v1 - kind: Service - metadata: - name: helm-guestbook - namespace: default - labels: - link: http://my-grafana.com/pre-generated-link - spec: - selector: - app: guestbook - type: LoadBalancer - status: - loadBalancer: - ingress: - - hostname: localhost`, - ) - - result := addCommitDetailsToLabels(resource, &revisionMetadata) - labels := result.GetLabels() - assert.Equal(t, revisionMetadata.Author, labels["app.meta.commit-author"]) - assert.Equal(t, revisionMetadata.Message, labels["app.meta.commit-message"]) - assert.Equal(t, "http://my-grafana.com/pre-generated-link", result.GetLabels()["link"]) - }) -} diff --git a/server/application/application_validate_src_and_dest.go b/server/application/application_validate_src_and_dest.go new file mode 100644 index 0000000000000..0aa12a1fe6bdf --- /dev/null +++ b/server/application/application_validate_src_and_dest.go @@ -0,0 +1,90 @@ +package application + +import ( + "context" + "fmt" + "github.com/argoproj/argo-cd/v2/pkg/apiclient/application" + appv1 "github.com/argoproj/argo-cd/v2/pkg/apis/application/v1alpha1" + applisters "github.com/argoproj/argo-cd/v2/pkg/client/listers/application/v1alpha1" + "github.com/argoproj/argo-cd/v2/util/argo" + "github.com/argoproj/argo-cd/v2/util/db" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + apierr "k8s.io/apimachinery/pkg/api/errors" +) + +func (s *Server) ValidateSrcAndDst(ctx context.Context, requset *application.ApplicationValidationRequest) (*application.ApplicationValidateResponse, error) { + app := requset.Application + proj, err := argo.GetAppProject(app, applisters.NewAppProjectLister(s.projInformer.GetIndexer()), s.ns, s.settingsMgr, s.db, ctx) + if err != nil { + entity := projectEntity + if apierr.IsNotFound(err) { + errMsg := fmt.Sprintf("application references project %s which does not exist", app.Spec.Project) + return &application.ApplicationValidateResponse{ + Error: &errMsg, + Entity: &entity, + }, nil + } + errMsg := err.Error() + return &application.ApplicationValidateResponse{ + Error: &errMsg, + Entity: &entity, + }, nil + } + + if err := validateDestination(ctx, &app.Spec.Destination, s.db); err != nil { + entity := destinationEntity + errMsg := fmt.Sprintf("application destination spec for %s is invalid: %s", app.ObjectMeta.Name, err.Error()) + return &application.ApplicationValidateResponse{ + Error: &errMsg, + Entity: &entity, + }, nil + } + var conditions []appv1.ApplicationCondition + conditions, err = argo.ValidateRepo(ctx, app, s.repoClientset, s.db, s.kubectl, proj, s.settingsMgr) + if err != nil { + entity := sourceEntity + errMsg := err.Error() + return &application.ApplicationValidateResponse{ + Error: &errMsg, + Entity: &entity, + }, nil + } + if len(conditions) > 0 { + entity := sourceEntity + errMsg := fmt.Sprintf("application spec for %s is invalid: %s", app.ObjectMeta.Name, argo.FormatAppConditions(conditions)) + return &application.ApplicationValidateResponse{ + Error: &errMsg, + Entity: &entity, + }, nil + } + return &application.ApplicationValidateResponse{ + Error: nil, + Entity: nil, + }, nil +} + +// validates destination name (argo.ValidateDestination) and server with extra logic +func validateDestination(ctx context.Context, dest *appv1.ApplicationDestination, db db.ArgoDB) error { + err := argo.ValidateDestination(ctx, dest, db) + + if err != nil { + return err + } + + if dest.Server != "" { + // Ensure the k8s cluster the app is referencing, is configured in Argo CD + _, err := db.GetCluster(ctx, dest.Server) + if err != nil { + if errStatus, ok := status.FromError(err); ok && errStatus.Code() == codes.NotFound { + return fmt.Errorf("cluster '%s' has not been configured", dest.Server) + } else { + return err + } + } + } else if dest.Server == "" { + return fmt.Errorf("destination server missing from app spec") + } + + return nil +} diff --git a/server/application/events.proto b/server/application/events.proto index bcd8bf16a265d..c946bf6214bc9 100644 --- a/server/application/events.proto +++ b/server/application/events.proto @@ -12,13 +12,6 @@ import "k8s.io/apimachinery/pkg/apis/meta/v1/generated.proto"; import "gogoproto/gogo.proto"; import "google/api/annotations.proto"; -// Eventing service -service Eventing { - rpc StartEventSource(EventSource) returns (stream Event) { - option (google.api.http).get = "/api/v1/stream/events"; - } -} - message EventSource { // The event source name. required string name = 1; diff --git a/server/server.go b/server/server.go index b8f0fc1a76dee..9ca4492493289 100644 --- a/server/server.go +++ b/server/server.go @@ -68,7 +68,6 @@ import ( applicationsetpkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/applicationset" certificatepkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/certificate" clusterpkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/cluster" - eventspkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/events" gpgkeypkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/gpgkey" projectpkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/project" repocredspkg "github.com/argoproj/argo-cd/v2/pkg/apiclient/repocreds" @@ -800,8 +799,6 @@ func (a *ArgoCDServer) newGRPCServer() (*grpc.Server, application.AppResourceTre ))) grpcS := grpc.NewServer(sOpts...) - srv := a.serviceSet.ApplicationService.(*application.Server) - eventspkg.RegisterEventingServer(grpcS, srv) versionpkg.RegisterVersionServiceServer(grpcS, a.serviceSet.VersionService) clusterpkg.RegisterClusterServiceServer(grpcS, a.serviceSet.ClusterService) applicationpkg.RegisterApplicationServiceServer(grpcS, a.serviceSet.ApplicationService) diff --git a/util/settings/settings.go b/util/settings/settings.go index 316f78fc4af2c..7eb16e75f8f10 100644 --- a/util/settings/settings.go +++ b/util/settings/settings.go @@ -218,14 +218,6 @@ type KustomizeSettings struct { Versions []KustomizeVersion } -// CodefreshReporterVersion includes all cf reporter versions -type CodefreshReporterVersion string - -const ( - CodefreshV1ReporterVersion CodefreshReporterVersion = "v1" - CodefreshV2ReporterVersion CodefreshReporterVersion = "v2" -) - var ( ByClusterURLIndexer = "byClusterURL" byClusterURLIndexerFunc = func(obj interface{}) ([]string, error) { @@ -446,8 +438,6 @@ const ( settingsWebhookMaxPayloadSizeMB = "webhook.maxPayloadSizeMB" // settingsApplicationInstanceLabelKey is the key to configure injected app instance label key settingsApplicationInstanceLabelKey = "application.instanceLabelKey" - // settingsCodefreshReporterVersion is the key to configure injected app instance label key - settingsCodefreshReporterVersion = "codefresh.reporterVersion" // settingsResourceTrackingMethodKey is the key to configure tracking method for application resources settingsResourceTrackingMethodKey = "application.resourceTrackingMethod" // resourcesCustomizationsKey is the key to the map of resource overrides @@ -781,18 +771,6 @@ func (mgr *SettingsManager) GetAppInstanceLabelKey() (string, error) { return label, nil } -func (mgr *SettingsManager) GetCodefreshReporterVersion() (string, error) { - argoCDCM, err := mgr.getConfigMap() - if err != nil { - return "", err - } - label := argoCDCM.Data[settingsCodefreshReporterVersion] - if label == "" { - return string(CodefreshV1ReporterVersion), nil - } - return label, nil -} - func (mgr *SettingsManager) GetKustomizeSetNamespaceEnabled() bool { argoCDCM, err := mgr.getConfigMap() if err != nil { From d9db1088e952181de1cbfc030e15a493d079201e Mon Sep 17 00:00:00 2001 From: oleksandr-codefresh Date: Mon, 19 Aug 2024 11:52:16 +0300 Subject: [PATCH 20/30] chore: update version to 2.11-2024.8.19-6be897266 --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.19-6be897266.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.19-6be897266.md diff --git a/VERSION b/VERSION index 921d6f0bf290d..bea915026985d 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.8-0c809966a \ No newline at end of file +2.11-2024.8.19-6be897266 \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.19-6be897266.md b/changelog/CHANGELOG-2.11-2024.8.19-6be897266.md new file mode 100644 index 0000000000000..ec07d1005bc37 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.19-6be897266.md @@ -0,0 +1,2 @@ +### Chore +- chore: removed v1 reporter \ No newline at end of file From 4ca622d7d538e462d69298e5942ed28b6d3179da Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Mon, 19 Aug 2024 15:58:46 +0300 Subject: [PATCH 21/30] improve logs --- controller/state.go | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/controller/state.go b/controller/state.go index caf8825188d7a..5b52daa8def18 100644 --- a/controller/state.go +++ b/controller/state.go @@ -209,6 +209,8 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp } } + var updateRevision string + val, ok := app.Annotations[v1alpha1.AnnotationKeyManifestGeneratePaths] if !source.IsHelm() && syncedRevision != "" && ok && val != "" { // Validate the manifest-generate-path annotation to avoid generating manifests if it has not changed. @@ -227,11 +229,15 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp RefSources: refSources, HasMultipleSources: app.Spec.HasMultipleSources(), }) + + if updateRevisionResponse != nil && updateRevisionResponse.Revision != "" { + updateRevision = updateRevisionResponse.Revision + } // not need to change, if we already found at least one cached revision that has no changes if updateRevisionResponse != nil && updateRevisionResponse.Revision != "" && os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { manifestsChanges[updateRevisionResponse.Revision] = updateRevisionResponse.Changes - log.WithField("application", app.Name).Debugf("Persisting revision %s with changes exists %t", syncedRevision, updateRevisionResponse.Changes) + log.WithField("application", app.Name).Debugf("Persisting revision %s with changes exists %t", updateRevisionResponse.Revision, updateRevisionResponse.Changes) } if err != nil { return nil, nil, nil, fmt.Errorf("failed to compare revisions for source %d of %d: %w", i+1, len(sources), err) @@ -239,7 +245,7 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp } ts.AddCheckpoint("version_ms") - log.Debugf("Generating Manifest for source %s revision %s, cache %t, revisionCache %t", source, revisions[i], !noCache, noRevisionCache) + log.WithField("application", app.Name).Debugf("Generating Manifest for source %s revision %s, cache %t, revisionCache %t", source, revisions[i], !noCache, noRevisionCache) manifestInfo, err := repoClient.GenerateManifest(context.Background(), &apiclient.ManifestRequest{ Repo: repo, Repos: permittedHelmRepos, @@ -267,6 +273,10 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp if err != nil { return nil, nil, nil, fmt.Errorf("failed to generate manifest for source %d of %d: %w", i+1, len(sources), err) } + + if updateRevision != "" && manifestInfo.Revision != updateRevision { + log.WithField("application", app.Name).Warnf("Generated revision %s is different from the updated revision %s", manifestInfo.Revision, updateRevision) + } targetObj, err := unmarshalManifests(manifestInfo.GetCompiledManifests()) From d20b4d9a7ec6cfa93d0db04ee05cfab41c17721f Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Mon, 19 Aug 2024 16:00:04 +0300 Subject: [PATCH 22/30] additional logs in compare app state --- changelog/CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md index ec07d1005bc37..47cb3a8281c7d 100644 --- a/changelog/CHANGELOG.md +++ b/changelog/CHANGELOG.md @@ -1,2 +1,2 @@ ### Chore -- chore: removed v1 reporter \ No newline at end of file +- chore: selfheal additional logs in CompareAppState \ No newline at end of file From 53edaf2ef63934379ed14049ee4eae48606ecfd4 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Mon, 19 Aug 2024 16:00:14 +0300 Subject: [PATCH 23/30] chore: update version to 2.11-2024.8.19-d20b4d9a7 --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.19-d20b4d9a7.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.19-d20b4d9a7.md diff --git a/VERSION b/VERSION index bea915026985d..9eaacc069499e 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.19-6be897266 \ No newline at end of file +2.11-2024.8.19-d20b4d9a7 \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.19-d20b4d9a7.md b/changelog/CHANGELOG-2.11-2024.8.19-d20b4d9a7.md new file mode 100644 index 0000000000000..47cb3a8281c7d --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.19-d20b4d9a7.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal additional logs in CompareAppState \ No newline at end of file From 67c8093a65e0b41b3a3c9b2e50ebbbcd51d15605 Mon Sep 17 00:00:00 2001 From: pasha-codefresh Date: Tue, 27 Aug 2024 18:40:11 +0300 Subject: [PATCH 24/30] ignore rev cache during manifest generation (#329) --- controller/state.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/controller/state.go b/controller/state.go index 5b52daa8def18..07b90080f341d 100644 --- a/controller/state.go +++ b/controller/state.go @@ -244,6 +244,11 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp } } + if os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { + // we need to make sure that revision cache is the same as the updateRevision, we want to skip the cache for this + noRevisionCache = true + } + ts.AddCheckpoint("version_ms") log.WithField("application", app.Name).Debugf("Generating Manifest for source %s revision %s, cache %t, revisionCache %t", source, revisions[i], !noCache, noRevisionCache) manifestInfo, err := repoClient.GenerateManifest(context.Background(), &apiclient.ManifestRequest{ From 8932b8655a522b3530b0daef3ead13e68a788108 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Tue, 27 Aug 2024 18:50:09 +0300 Subject: [PATCH 25/30] chore: update version to 2.11-2024.8.27-53edaf2ef --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.27-53edaf2ef.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.27-53edaf2ef.md diff --git a/VERSION b/VERSION index 9eaacc069499e..f3ab5d3526ccf 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.19-d20b4d9a7 \ No newline at end of file +2.11-2024.8.27-53edaf2ef \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.27-53edaf2ef.md b/changelog/CHANGELOG-2.11-2024.8.27-53edaf2ef.md new file mode 100644 index 0000000000000..47cb3a8281c7d --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.27-53edaf2ef.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal additional logs in CompareAppState \ No newline at end of file From 8f2001a7542fdfb9aa40cd55dc0a27d602f8476a Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Tue, 27 Aug 2024 18:55:34 +0300 Subject: [PATCH 26/30] chore: update version to 2.11-2024.8.27-7144356ed --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.27-7144356ed.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.27-7144356ed.md diff --git a/VERSION b/VERSION index f3ab5d3526ccf..da2bde564b7a8 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.27-53edaf2ef \ No newline at end of file +2.11-2024.8.27-7144356ed \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.27-7144356ed.md b/changelog/CHANGELOG-2.11-2024.8.27-7144356ed.md new file mode 100644 index 0000000000000..47cb3a8281c7d --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.27-7144356ed.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal additional logs in CompareAppState \ No newline at end of file From 62776e60effb10bbfbf106cd9d48e5a224b14dad Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Wed, 28 Aug 2024 16:54:47 +0300 Subject: [PATCH 27/30] ignore rev cache during manifest generation --- changelog/CHANGELOG.md | 2 -- controller/state.go | 4 ++++ 2 files changed, 4 insertions(+), 2 deletions(-) delete mode 100644 changelog/CHANGELOG.md diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md deleted file mode 100644 index 47cb3a8281c7d..0000000000000 --- a/changelog/CHANGELOG.md +++ /dev/null @@ -1,2 +0,0 @@ -### Chore -- chore: selfheal additional logs in CompareAppState \ No newline at end of file diff --git a/controller/state.go b/controller/state.go index 07b90080f341d..87ad89b9bae0f 100644 --- a/controller/state.go +++ b/controller/state.go @@ -247,6 +247,10 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp if os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { // we need to make sure that revision cache is the same as the updateRevision, we want to skip the cache for this noRevisionCache = true + + if updateRevision != "" { + revisions[i] = updateRevision + } } ts.AddCheckpoint("version_ms") From 4121408321662e5c4ed26d54b4be0dc3702ccf14 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Wed, 28 Aug 2024 16:55:14 +0300 Subject: [PATCH 28/30] chore: update version to 2.11-2024.8.28-62776e60e --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.28-62776e60e.md | 2 ++ changelog/CHANGELOG.md | 2 ++ 3 files changed, 5 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.28-62776e60e.md create mode 100644 changelog/CHANGELOG.md diff --git a/VERSION b/VERSION index da2bde564b7a8..e0038178258e9 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.27-7144356ed \ No newline at end of file +2.11-2024.8.28-62776e60e \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.28-62776e60e.md b/changelog/CHANGELOG-2.11-2024.8.28-62776e60e.md new file mode 100644 index 0000000000000..47cb3a8281c7d --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.28-62776e60e.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal additional logs in CompareAppState \ No newline at end of file diff --git a/changelog/CHANGELOG.md b/changelog/CHANGELOG.md new file mode 100644 index 0000000000000..47cb3a8281c7d --- /dev/null +++ b/changelog/CHANGELOG.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal additional logs in CompareAppState \ No newline at end of file From fa0e3225a59e5ca142930b793d01d4216a5e9a36 Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 29 Aug 2024 16:57:56 +0300 Subject: [PATCH 29/30] respect rev cache during manifest generation --- controller/state.go | 4 +- reposerver/apiclient/repository.pb.go | 365 ++++++++++++++----------- reposerver/repository/repository.go | 2 +- reposerver/repository/repository.proto | 2 + 4 files changed, 207 insertions(+), 166 deletions(-) diff --git a/controller/state.go b/controller/state.go index 87ad89b9bae0f..ad94ef58424a0 100644 --- a/controller/state.go +++ b/controller/state.go @@ -228,6 +228,7 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp TrackingMethod: string(argo.GetTrackingMethod(m.settingsMgr)), RefSources: refSources, HasMultipleSources: app.Spec.HasMultipleSources(), + NoRevisionCache: noRevisionCache, }) if updateRevisionResponse != nil && updateRevisionResponse.Revision != "" { @@ -245,9 +246,6 @@ func (m *appStateManager) GetRepoObjs(app *v1alpha1.Application, sources []v1alp } if os.Getenv("PERSIST_CHANGE_REVISIONS") == "1" { - // we need to make sure that revision cache is the same as the updateRevision, we want to skip the cache for this - noRevisionCache = true - if updateRevision != "" { revisions[i] = updateRevision } diff --git a/reposerver/apiclient/repository.pb.go b/reposerver/apiclient/repository.pb.go index 5e2dce3f6bfe0..0742ad4cc4dae 100644 --- a/reposerver/apiclient/repository.pb.go +++ b/reposerver/apiclient/repository.pb.go @@ -2422,6 +2422,7 @@ type UpdateRevisionForPathsRequest struct { SyncedRevision string `protobuf:"bytes,11,opt,name=syncedRevision,proto3" json:"syncedRevision,omitempty"` Revision string `protobuf:"bytes,12,opt,name=revision,proto3" json:"revision,omitempty"` Paths []string `protobuf:"bytes,13,rep,name=paths,proto3" json:"paths,omitempty"` + NoRevisionCache bool `protobuf:"varint,14,opt,name=noRevisionCache,proto3" json:"noRevisionCache,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_unrecognized []byte `json:"-"` XXX_sizecache int32 `json:"-"` @@ -2551,6 +2552,13 @@ func (m *UpdateRevisionForPathsRequest) GetPaths() []string { return nil } +func (m *UpdateRevisionForPathsRequest) GetNoRevisionCache() bool { + if m != nil { + return m.NoRevisionCache + } + return false +} + type UpdateRevisionForPathsResponse struct { Changes bool `protobuf:"varint,1,opt,name=changes,proto3" json:"changes,omitempty"` Revision string `protobuf:"bytes,2,opt,name=revision,proto3" json:"revision,omitempty"` @@ -2659,168 +2667,168 @@ func init() { } var fileDescriptor_dd8723cfcc820480 = []byte{ - // 2565 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x1a, 0xdb, 0x72, 0x1c, 0x47, - 0x55, 0xab, 0x5d, 0x49, 0xbb, 0x47, 0xf7, 0xb6, 0x2c, 0x8f, 0x37, 0xb1, 0x50, 0x86, 0xc4, 0xe5, - 0x28, 0xc9, 0x2c, 0x92, 0x49, 0x1c, 0x1c, 0x13, 0x4a, 0xf1, 0x45, 0xf2, 0x45, 0xb6, 0x32, 0x76, - 0x42, 0x39, 0x18, 0xa8, 0xde, 0xd9, 0xd6, 0xee, 0x78, 0xe7, 0xd2, 0x9e, 0xe9, 0x95, 0x91, 0xab, - 0xa8, 0xa2, 0x0a, 0x8a, 0x4f, 0xe0, 0x81, 0x57, 0x7e, 0x80, 0x2a, 0x8a, 0xe2, 0x91, 0x07, 0x2a, - 0x05, 0x4f, 0x14, 0xc5, 0x0f, 0x40, 0xf9, 0x85, 0xdf, 0xa0, 0xfa, 0x32, 0x33, 0x3d, 0xb3, 0xa3, - 0xb5, 0x82, 0x6c, 0x05, 0x78, 0x91, 0xba, 0xcf, 0x9c, 0x3e, 0xe7, 0xf4, 0xe9, 0x73, 0xed, 0x5e, - 0x38, 0x1f, 0x11, 0x1a, 0xc6, 0x24, 0xda, 0x27, 0x51, 0x4b, 0x0c, 0x5d, 0x16, 0x46, 0x07, 0xda, - 0xd0, 0xa2, 0x51, 0xc8, 0x42, 0x04, 0x19, 0xa4, 0x69, 0xf6, 0x3f, 0x8c, 0x2d, 0x37, 0x6c, 0x61, - 0xea, 0xb6, 0x9c, 0x30, 0x22, 0xad, 0xfd, 0xf5, 0x56, 0x97, 0x04, 0x24, 0xc2, 0x8c, 0x74, 0x24, - 0x7e, 0xf3, 0xdb, 0x19, 0x8e, 0x8f, 0x9d, 0x9e, 0x1b, 0x90, 0xe8, 0xa0, 0x45, 0xfb, 0x5d, 0x0e, - 0x88, 0x5b, 0x3e, 0x61, 0xb8, 0x6c, 0xd5, 0x9d, 0xae, 0xcb, 0x7a, 0x83, 0xb6, 0xe5, 0x84, 0x7e, - 0x0b, 0x47, 0xdd, 0x90, 0x46, 0xe1, 0x63, 0x31, 0x78, 0xcf, 0xe9, 0xb4, 0xf6, 0x37, 0x32, 0x02, - 0x98, 0x52, 0xcf, 0x75, 0x30, 0x73, 0xc3, 0xa0, 0xb5, 0xbf, 0x8e, 0x3d, 0xda, 0xc3, 0xc3, 0xd4, - 0x5e, 0xeb, 0x86, 0x61, 0xd7, 0x23, 0x2d, 0x31, 0x6b, 0x0f, 0xf6, 0x5a, 0xc4, 0xa7, 0x4c, 0x6d, - 0xc8, 0xfc, 0xeb, 0x2c, 0xcc, 0xef, 0xe0, 0xc0, 0xdd, 0x23, 0x31, 0xb3, 0xc9, 0x93, 0x01, 0x89, - 0x19, 0x7a, 0x04, 0x35, 0xbe, 0x4d, 0xa3, 0xb2, 0x5a, 0xb9, 0x30, 0xbd, 0xb1, 0x6d, 0x65, 0xd2, - 0x58, 0x89, 0x34, 0x62, 0xf0, 0x63, 0xa7, 0x63, 0xed, 0x6f, 0x58, 0xb4, 0xdf, 0xb5, 0xb8, 0x34, - 0x96, 0x26, 0x8d, 0x95, 0x48, 0x63, 0xd9, 0xa9, 0xc2, 0x6c, 0x41, 0x15, 0x35, 0xa1, 0x1e, 0x91, - 0x7d, 0x37, 0x76, 0xc3, 0xc0, 0x18, 0x5f, 0xad, 0x5c, 0x68, 0xd8, 0xe9, 0x1c, 0x19, 0x30, 0x15, - 0x84, 0x57, 0xb1, 0xd3, 0x23, 0x46, 0x75, 0xb5, 0x72, 0xa1, 0x6e, 0x27, 0x53, 0xb4, 0x0a, 0xd3, - 0x98, 0xd2, 0x3b, 0xb8, 0x4d, 0xbc, 0xdb, 0xe4, 0xc0, 0xa8, 0x89, 0x85, 0x3a, 0x88, 0xaf, 0xc5, - 0x94, 0xde, 0xc5, 0x3e, 0x31, 0x26, 0xc4, 0xd7, 0x64, 0x8a, 0x5e, 0x87, 0x46, 0x80, 0x7d, 0x12, - 0x53, 0xec, 0x10, 0xa3, 0x2e, 0xbe, 0x65, 0x00, 0xf4, 0x53, 0x58, 0xd4, 0x04, 0xbf, 0x1f, 0x0e, - 0x22, 0x87, 0x18, 0x20, 0xb6, 0x7e, 0xef, 0x78, 0x5b, 0xdf, 0x2c, 0x92, 0xb5, 0x87, 0x39, 0xa1, - 0x1f, 0xc1, 0x84, 0xb0, 0x29, 0x63, 0x7a, 0xb5, 0xfa, 0x52, 0xb5, 0x2d, 0xc9, 0xa2, 0x00, 0xa6, - 0xa8, 0x37, 0xe8, 0xba, 0x41, 0x6c, 0xcc, 0x08, 0x0e, 0x0f, 0x8e, 0xc7, 0xe1, 0x6a, 0x18, 0xec, - 0xb9, 0xdd, 0x1d, 0x1c, 0xe0, 0x2e, 0xf1, 0x49, 0xc0, 0x76, 0x05, 0x71, 0x3b, 0x61, 0x82, 0x9e, - 0xc1, 0x42, 0x7f, 0x10, 0xb3, 0xd0, 0x77, 0x9f, 0x91, 0x7b, 0x94, 0xaf, 0x8d, 0x8d, 0x59, 0xa1, - 0xcd, 0xbb, 0xc7, 0x63, 0x7c, 0xbb, 0x40, 0xd5, 0x1e, 0xe2, 0xc3, 0x8d, 0xa4, 0x3f, 0x68, 0x93, - 0xcf, 0x49, 0x24, 0xac, 0x6b, 0x4e, 0x1a, 0x89, 0x06, 0x92, 0x66, 0xe4, 0xaa, 0x59, 0x6c, 0xcc, - 0xaf, 0x56, 0xa5, 0x19, 0xa5, 0x20, 0x74, 0x01, 0xe6, 0xf7, 0x49, 0xe4, 0xee, 0x1d, 0xdc, 0x77, - 0xbb, 0x01, 0x66, 0x83, 0x88, 0x18, 0x0b, 0xc2, 0x14, 0x8b, 0x60, 0xe4, 0xc3, 0x6c, 0x8f, 0x78, - 0x3e, 0x57, 0xf9, 0xd5, 0x88, 0x74, 0x62, 0x63, 0x51, 0xe8, 0x77, 0xeb, 0xf8, 0x27, 0x28, 0xc8, - 0xd9, 0x79, 0xea, 0x5c, 0xb0, 0x20, 0xb4, 0x95, 0xa7, 0x48, 0x1f, 0x41, 0x52, 0xb0, 0x02, 0x18, - 0x9d, 0x87, 0x39, 0x16, 0x61, 0xa7, 0xef, 0x06, 0xdd, 0x1d, 0xc2, 0x7a, 0x61, 0xc7, 0x38, 0x25, - 0x34, 0x51, 0x80, 0x22, 0x07, 0x10, 0x09, 0x70, 0xdb, 0x23, 0x1d, 0x69, 0x8b, 0x0f, 0x0e, 0x28, - 0x89, 0x8d, 0x25, 0xb1, 0x8b, 0x8b, 0x96, 0x16, 0xfb, 0x0a, 0x01, 0xc2, 0xba, 0x3e, 0xb4, 0xea, - 0x7a, 0xc0, 0xa2, 0x03, 0xbb, 0x84, 0x1c, 0xea, 0xc3, 0x34, 0xdf, 0x47, 0x62, 0x0a, 0xa7, 0x85, - 0x29, 0xdc, 0x3c, 0x9e, 0x8e, 0xb6, 0x33, 0x82, 0xb6, 0x4e, 0x1d, 0x59, 0x80, 0x7a, 0x38, 0xde, - 0x19, 0x78, 0xcc, 0xa5, 0x1e, 0x91, 0x62, 0xc4, 0xc6, 0xb2, 0x50, 0x53, 0xc9, 0x17, 0x74, 0x1b, - 0x20, 0x22, 0x7b, 0x09, 0xde, 0x19, 0xb1, 0xf3, 0x77, 0x46, 0xed, 0xdc, 0x4e, 0xb1, 0xe5, 0x8e, - 0xb5, 0xe5, 0xa8, 0x0d, 0xa7, 0x34, 0x69, 0x77, 0x08, 0xc3, 0x1d, 0xcc, 0xb0, 0x61, 0x88, 0x1d, - 0x7f, 0xcb, 0x92, 0x99, 0xc0, 0xd2, 0x33, 0x41, 0xb6, 0x4d, 0x9e, 0x09, 0xac, 0xfd, 0x75, 0xeb, - 0x5e, 0xfb, 0x31, 0x71, 0x18, 0x5f, 0x6b, 0x97, 0x11, 0xe3, 0x1b, 0xe4, 0xaa, 0x22, 0x0e, 0x53, - 0x11, 0x45, 0x84, 0x8e, 0xb3, 0xc2, 0x8c, 0x4b, 0xbe, 0x70, 0x7b, 0x57, 0x50, 0x11, 0x18, 0x9b, - 0xd2, 0x23, 0x34, 0x50, 0xf3, 0x3a, 0x9c, 0x39, 0xe4, 0x38, 0xd1, 0x02, 0x54, 0xfb, 0xe4, 0x40, - 0xa4, 0x81, 0x86, 0xcd, 0x87, 0x68, 0x09, 0x26, 0xf6, 0xb1, 0x37, 0x20, 0x22, 0x70, 0xd7, 0x6d, - 0x39, 0xb9, 0x3c, 0xfe, 0x61, 0xa5, 0xf9, 0xcb, 0x0a, 0xcc, 0x17, 0x94, 0x53, 0xb2, 0xfe, 0x87, - 0xfa, 0xfa, 0x97, 0xe0, 0x2a, 0x7b, 0x0f, 0x70, 0xd4, 0x25, 0x4c, 0x13, 0xc4, 0xfc, 0x7b, 0x05, - 0x8c, 0xc2, 0xa9, 0x7d, 0xdf, 0x65, 0xbd, 0x1b, 0xae, 0x47, 0x62, 0x74, 0x09, 0xa6, 0x22, 0x09, - 0x53, 0xc9, 0xed, 0xb5, 0x11, 0x87, 0xbd, 0x3d, 0x66, 0x27, 0xd8, 0xe8, 0x63, 0xa8, 0xfb, 0xc9, - 0x81, 0x4a, 0xd9, 0x57, 0xcb, 0x56, 0x72, 0x2e, 0xc9, 0x59, 0x6d, 0x8f, 0xd9, 0xe9, 0x1a, 0xf4, - 0x3e, 0x4c, 0x38, 0xbd, 0x41, 0xd0, 0x17, 0x69, 0x6d, 0x7a, 0xe3, 0xdc, 0x61, 0x8b, 0xaf, 0x72, - 0xa4, 0xed, 0x31, 0x5b, 0x62, 0x7f, 0x32, 0x09, 0x35, 0x8a, 0x23, 0x66, 0xde, 0x80, 0xa5, 0x32, - 0x16, 0x3c, 0x97, 0x3a, 0x3d, 0xe2, 0xf4, 0xe3, 0x81, 0xaf, 0xd4, 0x9c, 0xce, 0x11, 0x82, 0x5a, - 0xec, 0x3e, 0x93, 0xaa, 0xae, 0xda, 0x62, 0x6c, 0xbe, 0x0d, 0x8b, 0x43, 0xdc, 0xf8, 0xa1, 0x4a, - 0xd9, 0x38, 0x85, 0x19, 0xc5, 0xda, 0x1c, 0xc0, 0xe9, 0x07, 0x42, 0x17, 0x69, 0x42, 0x39, 0x89, - 0xea, 0xc0, 0xdc, 0x86, 0xe5, 0x22, 0xdb, 0x98, 0x86, 0x41, 0x4c, 0xb8, 0xe9, 0x8b, 0x08, 0xec, - 0x92, 0x4e, 0xf6, 0x55, 0x48, 0x51, 0xb7, 0x4b, 0xbe, 0x98, 0xbf, 0x19, 0x87, 0x65, 0x9b, 0xc4, - 0xa1, 0xb7, 0x4f, 0x92, 0xf0, 0x78, 0x32, 0x05, 0xce, 0x0f, 0xa0, 0x8a, 0x29, 0x55, 0x66, 0x72, - 0xf3, 0xa5, 0x95, 0x10, 0x36, 0xa7, 0x8a, 0xde, 0x85, 0x45, 0xec, 0xb7, 0xdd, 0xee, 0x20, 0x1c, - 0xc4, 0xc9, 0xb6, 0x84, 0x51, 0x35, 0xec, 0xe1, 0x0f, 0xdc, 0xfd, 0x63, 0xe1, 0x91, 0x37, 0x83, - 0x0e, 0xf9, 0x89, 0xa8, 0x9a, 0xaa, 0xb6, 0x0e, 0x32, 0x1d, 0x38, 0x33, 0xa4, 0x24, 0xa5, 0x70, - 0xbd, 0x50, 0xab, 0x14, 0x0a, 0xb5, 0x52, 0x31, 0xc6, 0x0f, 0x11, 0xc3, 0xfc, 0x59, 0x05, 0xea, - 0x89, 0xdd, 0xa1, 0x35, 0x58, 0x70, 0x42, 0x9f, 0xba, 0x1e, 0xe9, 0x24, 0x30, 0x45, 0x7e, 0x08, - 0xce, 0xe5, 0x8f, 0xf0, 0xd3, 0x14, 0x4d, 0x32, 0xd0, 0x41, 0xdc, 0xca, 0x29, 0x66, 0x3d, 0xa5, - 0x02, 0x31, 0xe6, 0x30, 0xcf, 0x0d, 0x88, 0xd8, 0xee, 0x84, 0x2d, 0xc6, 0xe6, 0x17, 0x30, 0x73, - 0x8d, 0x50, 0x12, 0x74, 0x48, 0xe0, 0xb8, 0x24, 0x16, 0x38, 0xa1, 0xd3, 0x57, 0x9c, 0xc5, 0x98, - 0xc3, 0x3a, 0x84, 0xc6, 0x8a, 0x8d, 0x18, 0x23, 0x13, 0x66, 0x78, 0x0c, 0x70, 0x23, 0x51, 0xec, - 0xc4, 0x8a, 0x4f, 0x0e, 0x66, 0xc6, 0x70, 0x4a, 0x3b, 0xa7, 0xb4, 0x92, 0x58, 0x01, 0xc0, 0x94, - 0x26, 0xc5, 0x88, 0x64, 0xa4, 0x41, 0xd0, 0x15, 0x98, 0xe9, 0x68, 0x22, 0x29, 0x83, 0x31, 0xf4, - 0xd0, 0xa0, 0x8b, 0x6c, 0xe7, 0xb0, 0xcd, 0x2f, 0xab, 0xb0, 0x90, 0x05, 0x2c, 0x75, 0x64, 0x1b, - 0xd0, 0xf0, 0x15, 0x2c, 0x36, 0x2a, 0x22, 0x9d, 0x2d, 0x95, 0x46, 0xb8, 0x0c, 0x2d, 0x5f, 0x1d, - 0x8f, 0x17, 0xab, 0xe3, 0x65, 0x98, 0x94, 0x6d, 0x91, 0xda, 0xb9, 0x9a, 0xe5, 0x8c, 0xa3, 0x56, - 0x30, 0x8e, 0x15, 0x80, 0x38, 0xcd, 0x25, 0xc6, 0xa4, 0xdc, 0x78, 0x06, 0xe1, 0x3a, 0x95, 0xb5, - 0x94, 0x4d, 0xe2, 0x81, 0xc7, 0x8c, 0x29, 0xa9, 0x53, 0x1d, 0x86, 0xde, 0x84, 0x59, 0x27, 0xf4, - 0x7d, 0x97, 0xed, 0x90, 0x38, 0xc6, 0xdd, 0xa4, 0x6e, 0xcf, 0x03, 0x39, 0x25, 0x09, 0xd8, 0x1c, - 0xb0, 0x5e, 0x18, 0x19, 0x0d, 0x49, 0x49, 0x87, 0xa1, 0x5b, 0x00, 0x72, 0x7e, 0x0d, 0xb3, 0xa4, - 0xb0, 0x5f, 0x3b, 0x5a, 0x36, 0x7e, 0xe0, 0xfa, 0xc4, 0xd6, 0x56, 0xa3, 0x4f, 0x73, 0x29, 0x3e, - 0x2d, 0x23, 0xa7, 0x05, 0xd1, 0x6f, 0xe8, 0x9a, 0x2e, 0x31, 0x08, 0xbb, 0x6c, 0xad, 0x19, 0xc2, - 0xfc, 0x1d, 0x97, 0x1f, 0xe1, 0x5e, 0x7c, 0x32, 0x11, 0xf6, 0x03, 0xa8, 0x71, 0x66, 0xfc, 0x04, - 0xdb, 0x11, 0x0e, 0x9c, 0x1e, 0x91, 0xa6, 0xd2, 0xb0, 0xd3, 0x39, 0xf7, 0x04, 0x86, 0xbb, 0xdc, - 0x24, 0x39, 0x5c, 0x8c, 0xcd, 0x3f, 0x8c, 0x4b, 0x49, 0x37, 0x29, 0x8d, 0xbf, 0xfe, 0x4e, 0xb1, - 0xbc, 0x76, 0xad, 0x0e, 0xd7, 0xae, 0x05, 0x91, 0xbf, 0x4a, 0xed, 0xfa, 0x92, 0x6a, 0x23, 0x73, - 0x00, 0x53, 0x9b, 0x94, 0x72, 0x41, 0xd0, 0x3a, 0xd4, 0x30, 0xa5, 0x89, 0x6f, 0x9e, 0x2b, 0x58, - 0x0c, 0x47, 0xe1, 0xff, 0x95, 0x48, 0x02, 0xb5, 0x79, 0x09, 0x1a, 0x29, 0xe8, 0x45, 0x6c, 0x1b, - 0x3a, 0xdb, 0x55, 0x00, 0xd9, 0x9c, 0xdd, 0x0c, 0xf6, 0x42, 0x7e, 0xa4, 0xdc, 0xab, 0x93, 0x80, - 0xc7, 0xc7, 0xe6, 0xe5, 0x04, 0x43, 0xc8, 0xf6, 0x2e, 0x4c, 0xb8, 0x8c, 0xf8, 0x89, 0x70, 0xcb, - 0xba, 0x70, 0x19, 0x21, 0x5b, 0x22, 0x99, 0x7f, 0xae, 0xc3, 0x59, 0x7e, 0x62, 0xf7, 0x45, 0x3c, - 0xd8, 0xa4, 0xf4, 0x1a, 0x61, 0xd8, 0xf5, 0xe2, 0x4f, 0x07, 0x24, 0x3a, 0x78, 0xc5, 0x86, 0xd1, - 0x85, 0x49, 0x19, 0x4e, 0x54, 0xcc, 0x7c, 0xe9, 0x7d, 0xba, 0x22, 0x9f, 0x35, 0xe7, 0xd5, 0x57, - 0xd3, 0x9c, 0x97, 0x35, 0xcb, 0xb5, 0x13, 0x6a, 0x96, 0x0f, 0xbf, 0x2f, 0xd1, 0x6e, 0x61, 0x26, - 0xf3, 0xb7, 0x30, 0x25, 0x3d, 0xe8, 0xd4, 0x51, 0x7b, 0xd0, 0x7a, 0x69, 0x0f, 0xea, 0x97, 0xfa, - 0x71, 0x43, 0xa8, 0xfb, 0xbb, 0xba, 0x05, 0x1e, 0x6a, 0x6b, 0xc7, 0xe9, 0x46, 0xe1, 0x95, 0x76, - 0xa3, 0x9f, 0xe5, 0xba, 0x4b, 0x79, 0xbf, 0xf3, 0xfe, 0xd1, 0xf6, 0x34, 0xa2, 0xcf, 0xfc, 0xbf, - 0xeb, 0xd8, 0x7e, 0x21, 0x0a, 0x75, 0x1a, 0x66, 0x3a, 0x48, 0xeb, 0x19, 0x9e, 0x87, 0x78, 0x0d, - 0xa1, 0x82, 0x16, 0x1f, 0xa3, 0x77, 0xa0, 0xc6, 0x95, 0xac, 0x3a, 0xa9, 0x33, 0xba, 0x3e, 0xf9, - 0x49, 0x6c, 0x52, 0x7a, 0x9f, 0x12, 0xc7, 0x16, 0x48, 0xe8, 0x32, 0x34, 0x52, 0xc3, 0x57, 0x9e, - 0xf5, 0xba, 0xbe, 0x22, 0xf5, 0x93, 0x64, 0x59, 0x86, 0xce, 0xd7, 0x76, 0xdc, 0x88, 0x38, 0xa2, - 0xcf, 0x98, 0x18, 0x5e, 0x7b, 0x2d, 0xf9, 0x98, 0xae, 0x4d, 0xd1, 0xd1, 0x3a, 0x4c, 0xca, 0x0b, - 0x31, 0xe1, 0x41, 0xd3, 0x1b, 0x67, 0x87, 0x83, 0x69, 0xb2, 0x4a, 0x21, 0x9a, 0x5f, 0x56, 0xe0, - 0x8d, 0xcc, 0x20, 0x12, 0x6f, 0x4a, 0x5a, 0xbd, 0xaf, 0x3f, 0xe3, 0x9e, 0x87, 0x39, 0xd1, 0x5b, - 0x66, 0xf7, 0x62, 0xf2, 0x8a, 0xb6, 0x00, 0x35, 0x7f, 0x5f, 0x81, 0xb7, 0x86, 0xf7, 0x71, 0xb5, - 0x87, 0x23, 0x96, 0x1e, 0xef, 0x49, 0xec, 0x25, 0x49, 0x78, 0xe3, 0x59, 0xc2, 0xcb, 0xed, 0xaf, - 0x9a, 0xdf, 0x9f, 0xf9, 0xc7, 0x71, 0x98, 0xd6, 0x0c, 0xa8, 0x2c, 0x61, 0xf2, 0xca, 0x56, 0xd8, - 0xad, 0xb8, 0x4d, 0x10, 0x49, 0xa1, 0x61, 0x6b, 0x10, 0xd4, 0x07, 0xa0, 0x38, 0xc2, 0x3e, 0x61, - 0x24, 0xe2, 0x91, 0x9c, 0x7b, 0xfc, 0xed, 0xe3, 0x47, 0x97, 0xdd, 0x84, 0xa6, 0xad, 0x91, 0xe7, - 0xa5, 0xb9, 0x60, 0x1d, 0xab, 0xf8, 0xad, 0x66, 0xe8, 0x29, 0xcc, 0xed, 0xb9, 0x1e, 0xd9, 0xcd, - 0x04, 0x99, 0x14, 0x82, 0xdc, 0x3b, 0xbe, 0x20, 0x37, 0x74, 0xba, 0x76, 0x81, 0x8d, 0xb9, 0x06, - 0x0b, 0x45, 0x7f, 0xe2, 0x42, 0xba, 0x3e, 0xee, 0xa6, 0xda, 0x52, 0x33, 0x13, 0xc1, 0x42, 0xd1, - 0x7f, 0xcc, 0x7f, 0x8c, 0xc3, 0xe9, 0x94, 0xdc, 0x66, 0x10, 0x84, 0x83, 0xc0, 0x11, 0x2d, 0x56, - 0xe9, 0x59, 0x2c, 0xc1, 0x04, 0x73, 0x99, 0x97, 0x16, 0x3e, 0x62, 0xc2, 0x73, 0x17, 0x0b, 0x43, - 0x8f, 0xb9, 0x54, 0x1d, 0x70, 0x32, 0x95, 0x67, 0x2f, 0xba, 0xb6, 0x8e, 0x88, 0x04, 0x75, 0x3b, - 0x9d, 0xf3, 0x6f, 0xbc, 0xaa, 0x11, 0xfd, 0x8a, 0x54, 0x66, 0x3a, 0x17, 0x76, 0x1f, 0x7a, 0x1e, - 0x71, 0xb8, 0x3a, 0xb4, 0x8e, 0xa6, 0x00, 0x15, 0x9d, 0x12, 0x8b, 0xdc, 0xa0, 0xab, 0xfa, 0x19, - 0x35, 0xe3, 0x72, 0xe2, 0x28, 0xc2, 0x07, 0x46, 0x5d, 0x28, 0x40, 0x4e, 0xd0, 0x15, 0xa8, 0xfa, - 0x98, 0xaa, 0x44, 0xb7, 0x96, 0x8b, 0x0e, 0x65, 0x1a, 0xb0, 0x76, 0x30, 0x95, 0x99, 0x80, 0x2f, - 0x6b, 0x7e, 0xc0, 0xfb, 0x69, 0xfa, 0xd5, 0x4b, 0xc2, 0xc7, 0x30, 0x9b, 0x0b, 0x3e, 0xe8, 0x21, - 0x2c, 0x67, 0x16, 0xa5, 0x33, 0x54, 0x45, 0xe0, 0x1b, 0x2f, 0x94, 0xcc, 0x3e, 0x84, 0x80, 0xf9, - 0x04, 0x16, 0xb9, 0xc9, 0x08, 0xc7, 0x3f, 0xa1, 0xd6, 0xe6, 0x23, 0x68, 0xa4, 0x2c, 0x4b, 0x6d, - 0xa6, 0x09, 0xf5, 0xfd, 0xa4, 0x69, 0x93, 0xbd, 0x4d, 0x3a, 0x37, 0x37, 0x01, 0xe9, 0xf2, 0xaa, - 0x0c, 0xf4, 0x4e, 0xbe, 0x28, 0x3e, 0x5d, 0x4c, 0x37, 0x02, 0x3d, 0xa9, 0x89, 0x7f, 0x37, 0x0e, - 0xf3, 0x5b, 0xae, 0xb8, 0x5a, 0x3b, 0xa1, 0x20, 0xb7, 0x06, 0x0b, 0xf1, 0xa0, 0xed, 0x87, 0x9d, - 0x81, 0x47, 0x54, 0x51, 0xa0, 0x32, 0xfd, 0x10, 0x7c, 0x54, 0xf0, 0x4b, 0xaf, 0x51, 0x6a, 0xda, - 0x35, 0xca, 0x15, 0x38, 0x7b, 0x97, 0x3c, 0x55, 0xfb, 0xd9, 0xf2, 0xc2, 0x76, 0xdb, 0x0d, 0xba, - 0x09, 0x93, 0x09, 0xc1, 0xe4, 0x70, 0x84, 0xb2, 0x52, 0x71, 0xb2, 0xb4, 0x54, 0x34, 0x7f, 0x5e, - 0x81, 0x85, 0x4c, 0x6b, 0x4a, 0xef, 0x97, 0xa4, 0x7f, 0x48, 0xad, 0xbf, 0xa5, 0x6b, 0xbd, 0x88, - 0xfa, 0x9f, 0xbb, 0xc6, 0x8c, 0xee, 0x1a, 0xff, 0xaa, 0xc0, 0xe9, 0x2d, 0x97, 0x25, 0x41, 0xc9, - 0xfd, 0x5f, 0x3b, 0xc1, 0x12, 0x7d, 0xd7, 0xca, 0xf5, 0x6d, 0xc1, 0x72, 0x71, 0xa3, 0x4a, 0xe9, - 0x4b, 0x30, 0xc1, 0x4f, 0x3e, 0xb9, 0x0f, 0x90, 0x13, 0xf3, 0xb7, 0x93, 0x70, 0xee, 0x33, 0xda, - 0xc1, 0x2c, 0xbd, 0x22, 0xbc, 0x11, 0x46, 0xbb, 0xfc, 0xd3, 0xc9, 0x68, 0xa8, 0xf0, 0xf4, 0x3b, - 0x3e, 0xf2, 0xe9, 0xb7, 0x3a, 0xe2, 0xe9, 0xb7, 0x76, 0xa4, 0xa7, 0xdf, 0x89, 0x13, 0x7b, 0xfa, - 0x1d, 0xee, 0x91, 0x26, 0x4b, 0x7b, 0xa4, 0x87, 0xb9, 0x3e, 0x62, 0x4a, 0xb8, 0xc4, 0x77, 0x74, - 0x97, 0x18, 0x79, 0x3a, 0x23, 0xdf, 0xac, 0x0a, 0x2f, 0xa6, 0xf5, 0x17, 0xbe, 0x98, 0x36, 0x86, - 0x5f, 0x4c, 0xcb, 0x1f, 0xdd, 0xe0, 0xd0, 0x47, 0xb7, 0xf3, 0x30, 0x17, 0x1f, 0x04, 0x0e, 0xe9, - 0xa4, 0x17, 0xc7, 0xd3, 0x72, 0xdb, 0x79, 0x68, 0xce, 0xda, 0x67, 0x0a, 0xd6, 0x9e, 0x5a, 0xea, - 0xac, 0x66, 0xa9, 0xff, 0x3d, 0x2d, 0xcd, 0xe7, 0xb0, 0x72, 0xd8, 0x99, 0x28, 0x57, 0x33, 0x60, - 0xca, 0xe9, 0xe1, 0xa0, 0x2b, 0x2e, 0xdf, 0x44, 0x8f, 0xad, 0xa6, 0xa3, 0x6a, 0xf0, 0x8d, 0x3f, - 0x01, 0x2c, 0x66, 0xb5, 0x35, 0xff, 0xeb, 0x3a, 0x04, 0xdd, 0x83, 0x85, 0x2d, 0xf5, 0x9b, 0x8f, - 0xf4, 0x5e, 0x7c, 0xd4, 0xc3, 0x56, 0xf3, 0xf5, 0xf2, 0x8f, 0x52, 0x34, 0x73, 0x0c, 0x39, 0x70, - 0xb6, 0x48, 0x30, 0x7b, 0x43, 0x7b, 0x73, 0x04, 0xe5, 0x14, 0xeb, 0x45, 0x2c, 0x2e, 0x54, 0xd0, - 0x43, 0x98, 0xcb, 0xbf, 0xf4, 0xa0, 0x5c, 0xb1, 0x51, 0xfa, 0xf8, 0xd4, 0x34, 0x47, 0xa1, 0xa4, - 0xf2, 0x3f, 0xe2, 0x66, 0x90, 0x7b, 0xd4, 0x40, 0x66, 0xbe, 0xef, 0x2e, 0x7b, 0x16, 0x6a, 0x7e, - 0x73, 0x24, 0x4e, 0x4a, 0xfd, 0x23, 0xa8, 0x27, 0x37, 0xb6, 0x79, 0x35, 0x17, 0xee, 0x71, 0x9b, - 0x0b, 0x79, 0x7a, 0x7b, 0xb1, 0x39, 0x86, 0x3e, 0x96, 0x8b, 0x37, 0x29, 0x2d, 0x59, 0xac, 0xdd, - 0x53, 0x36, 0x4f, 0x95, 0xdc, 0x0d, 0x9a, 0x63, 0xe8, 0x7b, 0x30, 0xcd, 0x47, 0xbb, 0xea, 0xd7, - 0x16, 0xcb, 0x96, 0xfc, 0x71, 0x8f, 0x95, 0xfc, 0xb8, 0xc7, 0xba, 0xee, 0x53, 0x76, 0xd0, 0x2c, - 0xb9, 0xbc, 0x53, 0x04, 0x1e, 0xc1, 0xec, 0x16, 0x61, 0x59, 0xaf, 0x8d, 0xde, 0x3a, 0xd2, 0x8d, - 0x44, 0xd3, 0x2c, 0xa2, 0x0d, 0xb7, 0xeb, 0xe6, 0x18, 0xfa, 0x55, 0x05, 0x4e, 0x6d, 0x11, 0x56, - 0xec, 0x5e, 0xd1, 0x7b, 0xe5, 0x4c, 0x0e, 0xe9, 0x72, 0x9b, 0x77, 0x8f, 0xeb, 0x93, 0x79, 0xb2, - 0xe6, 0x18, 0xfa, 0x75, 0x05, 0xce, 0x68, 0x82, 0xe9, 0xed, 0x28, 0x5a, 0x1f, 0x2d, 0x5c, 0x49, - 0xeb, 0xda, 0xbc, 0x75, 0xcc, 0x1f, 0xd1, 0x68, 0x24, 0xcd, 0x31, 0xb4, 0x2b, 0xce, 0x24, 0xab, - 0x3e, 0xd1, 0xb9, 0xd2, 0x32, 0x33, 0xe5, 0xbe, 0x72, 0xd8, 0xe7, 0xf4, 0x1c, 0x6e, 0xc1, 0xf4, - 0x16, 0x61, 0x49, 0xa9, 0x94, 0xb7, 0xb4, 0x42, 0x85, 0x9a, 0x77, 0xd5, 0x62, 0x75, 0x25, 0x2c, - 0x66, 0x51, 0xd2, 0xd2, 0x4a, 0x86, 0xbc, 0xaf, 0x96, 0xd6, 0x4d, 0x79, 0x8b, 0x29, 0xaf, 0x38, - 0xcc, 0x31, 0xf4, 0x04, 0x96, 0xcb, 0x43, 0x25, 0x7a, 0xfb, 0xc8, 0x29, 0xae, 0xb9, 0x76, 0x14, - 0xd4, 0x84, 0xe5, 0x27, 0x9b, 0x7f, 0x79, 0xbe, 0x52, 0xf9, 0xdb, 0xf3, 0x95, 0xca, 0x3f, 0x9f, - 0xaf, 0x54, 0xbe, 0xb8, 0xf8, 0x82, 0x1f, 0xdb, 0x69, 0xbf, 0x0c, 0xc4, 0xd4, 0x75, 0x3c, 0x97, - 0x04, 0xac, 0x3d, 0x29, 0xfc, 0xed, 0xe2, 0xbf, 0x03, 0x00, 0x00, 0xff, 0xff, 0x37, 0xf3, 0xb5, - 0x84, 0x38, 0x28, 0x00, 0x00, + // 2570 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xdc, 0x1a, 0x4d, 0x73, 0x1c, 0x47, + 0x55, 0xab, 0x5d, 0x49, 0xbb, 0x4f, 0xdf, 0x6d, 0x59, 0x1e, 0x6f, 0x62, 0xa1, 0x0c, 0x89, 0xcb, + 0x51, 0x92, 0x59, 0x24, 0x93, 0x38, 0x38, 0x26, 0x94, 0xe2, 0x0f, 0xc9, 0x1f, 0xb2, 0x95, 0xb1, + 0x13, 0xca, 0xc1, 0x40, 0xf5, 0xce, 0xb6, 0x76, 0xc7, 0x3b, 0x1f, 0xed, 0x99, 0x5e, 0x19, 0xb9, + 0x8a, 0x2a, 0xaa, 0xa0, 0xf8, 0x09, 0x1c, 0xb8, 0xf2, 0x13, 0x28, 0x8a, 0x23, 0x07, 0x2a, 0x05, + 0x27, 0x8a, 0xe2, 0xc8, 0x05, 0xca, 0x17, 0xfe, 0x06, 0xd5, 0x1f, 0x33, 0xd3, 0x33, 0x3b, 0x5a, + 0x2b, 0xc8, 0x56, 0x80, 0x8b, 0xd4, 0xfd, 0xe6, 0xf5, 0x7b, 0xaf, 0x5f, 0xbf, 0xcf, 0xee, 0x85, + 0xf3, 0x11, 0xa1, 0x61, 0x4c, 0xa2, 0x7d, 0x12, 0xb5, 0xc4, 0xd0, 0x65, 0x61, 0x74, 0xa0, 0x0d, + 0x2d, 0x1a, 0x85, 0x2c, 0x44, 0x90, 0x41, 0x9a, 0x66, 0xff, 0xc3, 0xd8, 0x72, 0xc3, 0x16, 0xa6, + 0x6e, 0xcb, 0x09, 0x23, 0xd2, 0xda, 0x5f, 0x6f, 0x75, 0x49, 0x40, 0x22, 0xcc, 0x48, 0x47, 0xe2, + 0x37, 0xbf, 0x9d, 0xe1, 0xf8, 0xd8, 0xe9, 0xb9, 0x01, 0x89, 0x0e, 0x5a, 0xb4, 0xdf, 0xe5, 0x80, + 0xb8, 0xe5, 0x13, 0x86, 0xcb, 0x56, 0xdd, 0xe9, 0xba, 0xac, 0x37, 0x68, 0x5b, 0x4e, 0xe8, 0xb7, + 0x70, 0xd4, 0x0d, 0x69, 0x14, 0x3e, 0x16, 0x83, 0xf7, 0x9c, 0x4e, 0x6b, 0x7f, 0x23, 0x23, 0x80, + 0x29, 0xf5, 0x5c, 0x07, 0x33, 0x37, 0x0c, 0x5a, 0xfb, 0xeb, 0xd8, 0xa3, 0x3d, 0x3c, 0x4c, 0xed, + 0xb5, 0x6e, 0x18, 0x76, 0x3d, 0xd2, 0x12, 0xb3, 0xf6, 0x60, 0xaf, 0x45, 0x7c, 0xca, 0xd4, 0x86, + 0xcc, 0xbf, 0xcc, 0xc2, 0xfc, 0x0e, 0x0e, 0xdc, 0x3d, 0x12, 0x33, 0x9b, 0x3c, 0x19, 0x90, 0x98, + 0xa1, 0x47, 0x50, 0xe3, 0xdb, 0x34, 0x2a, 0xab, 0x95, 0x0b, 0xd3, 0x1b, 0xdb, 0x56, 0x26, 0x8d, + 0x95, 0x48, 0x23, 0x06, 0x3f, 0x76, 0x3a, 0xd6, 0xfe, 0x86, 0x45, 0xfb, 0x5d, 0x8b, 0x4b, 0x63, + 0x69, 0xd2, 0x58, 0x89, 0x34, 0x96, 0x9d, 0x2a, 0xcc, 0x16, 0x54, 0x51, 0x13, 0xea, 0x11, 0xd9, + 0x77, 0x63, 0x37, 0x0c, 0x8c, 0xf1, 0xd5, 0xca, 0x85, 0x86, 0x9d, 0xce, 0x91, 0x01, 0x53, 0x41, + 0x78, 0x15, 0x3b, 0x3d, 0x62, 0x54, 0x57, 0x2b, 0x17, 0xea, 0x76, 0x32, 0x45, 0xab, 0x30, 0x8d, + 0x29, 0xbd, 0x83, 0xdb, 0xc4, 0xbb, 0x4d, 0x0e, 0x8c, 0x9a, 0x58, 0xa8, 0x83, 0xf8, 0x5a, 0x4c, + 0xe9, 0x5d, 0xec, 0x13, 0x63, 0x42, 0x7c, 0x4d, 0xa6, 0xe8, 0x75, 0x68, 0x04, 0xd8, 0x27, 0x31, + 0xc5, 0x0e, 0x31, 0xea, 0xe2, 0x5b, 0x06, 0x40, 0x3f, 0x85, 0x45, 0x4d, 0xf0, 0xfb, 0xe1, 0x20, + 0x72, 0x88, 0x01, 0x62, 0xeb, 0xf7, 0x8e, 0xb7, 0xf5, 0xcd, 0x22, 0x59, 0x7b, 0x98, 0x13, 0xfa, + 0x11, 0x4c, 0x08, 0x9b, 0x32, 0xa6, 0x57, 0xab, 0x2f, 0x55, 0xdb, 0x92, 0x2c, 0x0a, 0x60, 0x8a, + 0x7a, 0x83, 0xae, 0x1b, 0xc4, 0xc6, 0x8c, 0xe0, 0xf0, 0xe0, 0x78, 0x1c, 0xae, 0x86, 0xc1, 0x9e, + 0xdb, 0xdd, 0xc1, 0x01, 0xee, 0x12, 0x9f, 0x04, 0x6c, 0x57, 0x10, 0xb7, 0x13, 0x26, 0xe8, 0x19, + 0x2c, 0xf4, 0x07, 0x31, 0x0b, 0x7d, 0xf7, 0x19, 0xb9, 0x47, 0xf9, 0xda, 0xd8, 0x98, 0x15, 0xda, + 0xbc, 0x7b, 0x3c, 0xc6, 0xb7, 0x0b, 0x54, 0xed, 0x21, 0x3e, 0xdc, 0x48, 0xfa, 0x83, 0x36, 0xf9, + 0x9c, 0x44, 0xc2, 0xba, 0xe6, 0xa4, 0x91, 0x68, 0x20, 0x69, 0x46, 0xae, 0x9a, 0xc5, 0xc6, 0xfc, + 0x6a, 0x55, 0x9a, 0x51, 0x0a, 0x42, 0x17, 0x60, 0x7e, 0x9f, 0x44, 0xee, 0xde, 0xc1, 0x7d, 0xb7, + 0x1b, 0x60, 0x36, 0x88, 0x88, 0xb1, 0x20, 0x4c, 0xb1, 0x08, 0x46, 0x3e, 0xcc, 0xf6, 0x88, 0xe7, + 0x73, 0x95, 0x5f, 0x8d, 0x48, 0x27, 0x36, 0x16, 0x85, 0x7e, 0xb7, 0x8e, 0x7f, 0x82, 0x82, 0x9c, + 0x9d, 0xa7, 0xce, 0x05, 0x0b, 0x42, 0x5b, 0x79, 0x8a, 0xf4, 0x11, 0x24, 0x05, 0x2b, 0x80, 0xd1, + 0x79, 0x98, 0x63, 0x11, 0x76, 0xfa, 0x6e, 0xd0, 0xdd, 0x21, 0xac, 0x17, 0x76, 0x8c, 0x53, 0x42, + 0x13, 0x05, 0x28, 0x72, 0x00, 0x91, 0x00, 0xb7, 0x3d, 0xd2, 0x91, 0xb6, 0xf8, 0xe0, 0x80, 0x92, + 0xd8, 0x58, 0x12, 0xbb, 0xb8, 0x68, 0x69, 0xb1, 0xaf, 0x10, 0x20, 0xac, 0xeb, 0x43, 0xab, 0xae, + 0x07, 0x2c, 0x3a, 0xb0, 0x4b, 0xc8, 0xa1, 0x3e, 0x4c, 0xf3, 0x7d, 0x24, 0xa6, 0x70, 0x5a, 0x98, + 0xc2, 0xcd, 0xe3, 0xe9, 0x68, 0x3b, 0x23, 0x68, 0xeb, 0xd4, 0x91, 0x05, 0xa8, 0x87, 0xe3, 0x9d, + 0x81, 0xc7, 0x5c, 0xea, 0x11, 0x29, 0x46, 0x6c, 0x2c, 0x0b, 0x35, 0x95, 0x7c, 0x41, 0xb7, 0x01, + 0x22, 0xb2, 0x97, 0xe0, 0x9d, 0x11, 0x3b, 0x7f, 0x67, 0xd4, 0xce, 0xed, 0x14, 0x5b, 0xee, 0x58, + 0x5b, 0x8e, 0xda, 0x70, 0x4a, 0x93, 0x76, 0x87, 0x30, 0xdc, 0xc1, 0x0c, 0x1b, 0x86, 0xd8, 0xf1, + 0xb7, 0x2c, 0x99, 0x09, 0x2c, 0x3d, 0x13, 0x64, 0xdb, 0xe4, 0x99, 0xc0, 0xda, 0x5f, 0xb7, 0xee, + 0xb5, 0x1f, 0x13, 0x87, 0xf1, 0xb5, 0x76, 0x19, 0x31, 0xbe, 0x41, 0xae, 0x2a, 0xe2, 0x30, 0x15, + 0x51, 0x44, 0xe8, 0x38, 0x2b, 0xcc, 0xb8, 0xe4, 0x0b, 0xb7, 0x77, 0x05, 0x15, 0x81, 0xb1, 0x29, + 0x3d, 0x42, 0x03, 0x35, 0xaf, 0xc3, 0x99, 0x43, 0x8e, 0x13, 0x2d, 0x40, 0xb5, 0x4f, 0x0e, 0x44, + 0x1a, 0x68, 0xd8, 0x7c, 0x88, 0x96, 0x60, 0x62, 0x1f, 0x7b, 0x03, 0x22, 0x02, 0x77, 0xdd, 0x96, + 0x93, 0xcb, 0xe3, 0x1f, 0x56, 0x9a, 0xbf, 0xac, 0xc0, 0x7c, 0x41, 0x39, 0x25, 0xeb, 0x7f, 0xa8, + 0xaf, 0x7f, 0x09, 0xae, 0xb2, 0xf7, 0x00, 0x47, 0x5d, 0xc2, 0x34, 0x41, 0xcc, 0xbf, 0x55, 0xc0, + 0x28, 0x9c, 0xda, 0xf7, 0x5d, 0xd6, 0xbb, 0xe1, 0x7a, 0x24, 0x46, 0x97, 0x60, 0x2a, 0x92, 0x30, + 0x95, 0xdc, 0x5e, 0x1b, 0x71, 0xd8, 0xdb, 0x63, 0x76, 0x82, 0x8d, 0x3e, 0x86, 0xba, 0x9f, 0x1c, + 0xa8, 0x94, 0x7d, 0xb5, 0x6c, 0x25, 0xe7, 0x92, 0x9c, 0xd5, 0xf6, 0x98, 0x9d, 0xae, 0x41, 0xef, + 0xc3, 0x84, 0xd3, 0x1b, 0x04, 0x7d, 0x91, 0xd6, 0xa6, 0x37, 0xce, 0x1d, 0xb6, 0xf8, 0x2a, 0x47, + 0xda, 0x1e, 0xb3, 0x25, 0xf6, 0x27, 0x93, 0x50, 0xa3, 0x38, 0x62, 0xe6, 0x0d, 0x58, 0x2a, 0x63, + 0xc1, 0x73, 0xa9, 0xd3, 0x23, 0x4e, 0x3f, 0x1e, 0xf8, 0x4a, 0xcd, 0xe9, 0x1c, 0x21, 0xa8, 0xc5, + 0xee, 0x33, 0xa9, 0xea, 0xaa, 0x2d, 0xc6, 0xe6, 0xdb, 0xb0, 0x38, 0xc4, 0x8d, 0x1f, 0xaa, 0x94, + 0x8d, 0x53, 0x98, 0x51, 0xac, 0xcd, 0x01, 0x9c, 0x7e, 0x20, 0x74, 0x91, 0x26, 0x94, 0x93, 0xa8, + 0x0e, 0xcc, 0x6d, 0x58, 0x2e, 0xb2, 0x8d, 0x69, 0x18, 0xc4, 0x84, 0x9b, 0xbe, 0x88, 0xc0, 0x2e, + 0xe9, 0x64, 0x5f, 0x85, 0x14, 0x75, 0xbb, 0xe4, 0x8b, 0xf9, 0x9b, 0x71, 0x58, 0xb6, 0x49, 0x1c, + 0x7a, 0xfb, 0x24, 0x09, 0x8f, 0x27, 0x53, 0xe0, 0xfc, 0x00, 0xaa, 0x98, 0x52, 0x65, 0x26, 0x37, + 0x5f, 0x5a, 0x09, 0x61, 0x73, 0xaa, 0xe8, 0x5d, 0x58, 0xc4, 0x7e, 0xdb, 0xed, 0x0e, 0xc2, 0x41, + 0x9c, 0x6c, 0x4b, 0x18, 0x55, 0xc3, 0x1e, 0xfe, 0xc0, 0xdd, 0x3f, 0x16, 0x1e, 0x79, 0x33, 0xe8, + 0x90, 0x9f, 0x88, 0xaa, 0xa9, 0x6a, 0xeb, 0x20, 0xd3, 0x81, 0x33, 0x43, 0x4a, 0x52, 0x0a, 0xd7, + 0x0b, 0xb5, 0x4a, 0xa1, 0x50, 0x2b, 0x15, 0x63, 0xfc, 0x10, 0x31, 0xcc, 0x9f, 0x55, 0xa0, 0x9e, + 0xd8, 0x1d, 0x5a, 0x83, 0x05, 0x27, 0xf4, 0xa9, 0xeb, 0x91, 0x4e, 0x02, 0x53, 0xe4, 0x87, 0xe0, + 0x5c, 0xfe, 0x08, 0x3f, 0x4d, 0xd1, 0x24, 0x03, 0x1d, 0xc4, 0xad, 0x9c, 0x62, 0xd6, 0x53, 0x2a, + 0x10, 0x63, 0x0e, 0xf3, 0xdc, 0x80, 0x88, 0xed, 0x4e, 0xd8, 0x62, 0x6c, 0x7e, 0x01, 0x33, 0xd7, + 0x08, 0x25, 0x41, 0x87, 0x04, 0x8e, 0x4b, 0x62, 0x81, 0x13, 0x3a, 0x7d, 0xc5, 0x59, 0x8c, 0x39, + 0xac, 0x43, 0x68, 0xac, 0xd8, 0x88, 0x31, 0x32, 0x61, 0x86, 0xc7, 0x00, 0x37, 0x12, 0xc5, 0x4e, + 0xac, 0xf8, 0xe4, 0x60, 0x66, 0x0c, 0xa7, 0xb4, 0x73, 0x4a, 0x2b, 0x89, 0x15, 0x00, 0x4c, 0x69, + 0x52, 0x8c, 0x48, 0x46, 0x1a, 0x04, 0x5d, 0x81, 0x99, 0x8e, 0x26, 0x92, 0x32, 0x18, 0x43, 0x0f, + 0x0d, 0xba, 0xc8, 0x76, 0x0e, 0xdb, 0xfc, 0xb2, 0x0a, 0x0b, 0x59, 0xc0, 0x52, 0x47, 0xb6, 0x01, + 0x0d, 0x5f, 0xc1, 0x62, 0xa3, 0x22, 0xd2, 0xd9, 0x52, 0x69, 0x84, 0xcb, 0xd0, 0xf2, 0xd5, 0xf1, + 0x78, 0xb1, 0x3a, 0x5e, 0x86, 0x49, 0xd9, 0x16, 0xa9, 0x9d, 0xab, 0x59, 0xce, 0x38, 0x6a, 0x05, + 0xe3, 0x58, 0x01, 0x88, 0xd3, 0x5c, 0x62, 0x4c, 0xca, 0x8d, 0x67, 0x10, 0xae, 0x53, 0x59, 0x4b, + 0xd9, 0x24, 0x1e, 0x78, 0xcc, 0x98, 0x92, 0x3a, 0xd5, 0x61, 0xe8, 0x4d, 0x98, 0x75, 0x42, 0xdf, + 0x77, 0xd9, 0x0e, 0x89, 0x63, 0xdc, 0x4d, 0xea, 0xf6, 0x3c, 0x90, 0x53, 0x92, 0x80, 0xcd, 0x01, + 0xeb, 0x85, 0x91, 0xd1, 0x90, 0x94, 0x74, 0x18, 0xba, 0x05, 0x20, 0xe7, 0xd7, 0x30, 0x4b, 0x0a, + 0xfb, 0xb5, 0xa3, 0x65, 0xe3, 0x07, 0xae, 0x4f, 0x6c, 0x6d, 0x35, 0xfa, 0x34, 0x97, 0xe2, 0xd3, + 0x32, 0x72, 0x5a, 0x10, 0xfd, 0x86, 0xae, 0xe9, 0x12, 0x83, 0xb0, 0xcb, 0xd6, 0x9a, 0x21, 0xcc, + 0xdf, 0x71, 0xf9, 0x11, 0xee, 0xc5, 0x27, 0x13, 0x61, 0x3f, 0x80, 0x1a, 0x67, 0xc6, 0x4f, 0xb0, + 0x1d, 0xe1, 0xc0, 0xe9, 0x11, 0x69, 0x2a, 0x0d, 0x3b, 0x9d, 0x73, 0x4f, 0x60, 0xb8, 0xcb, 0x4d, + 0x92, 0xc3, 0xc5, 0xd8, 0xfc, 0xfd, 0xb8, 0x94, 0x74, 0x93, 0xd2, 0xf8, 0xeb, 0xef, 0x14, 0xcb, + 0x6b, 0xd7, 0xea, 0x70, 0xed, 0x5a, 0x10, 0xf9, 0xab, 0xd4, 0xae, 0x2f, 0xa9, 0x36, 0x32, 0x07, + 0x30, 0xb5, 0x49, 0x29, 0x17, 0x04, 0xad, 0x43, 0x0d, 0x53, 0x9a, 0xf8, 0xe6, 0xb9, 0x82, 0xc5, + 0x70, 0x14, 0xfe, 0x5f, 0x89, 0x24, 0x50, 0x9b, 0x97, 0xa0, 0x91, 0x82, 0x5e, 0xc4, 0xb6, 0xa1, + 0xb3, 0x5d, 0x05, 0x90, 0xcd, 0xd9, 0xcd, 0x60, 0x2f, 0xe4, 0x47, 0xca, 0xbd, 0x3a, 0x09, 0x78, + 0x7c, 0x6c, 0x5e, 0x4e, 0x30, 0x84, 0x6c, 0xef, 0xc2, 0x84, 0xcb, 0x88, 0x9f, 0x08, 0xb7, 0xac, + 0x0b, 0x97, 0x11, 0xb2, 0x25, 0x92, 0xf9, 0xa7, 0x3a, 0x9c, 0xe5, 0x27, 0x76, 0x5f, 0xc4, 0x83, + 0x4d, 0x4a, 0xaf, 0x11, 0x86, 0x5d, 0x2f, 0xfe, 0x74, 0x40, 0xa2, 0x83, 0x57, 0x6c, 0x18, 0x5d, + 0x98, 0x94, 0xe1, 0x44, 0xc5, 0xcc, 0x97, 0xde, 0xa7, 0x2b, 0xf2, 0x59, 0x73, 0x5e, 0x7d, 0x35, + 0xcd, 0x79, 0x59, 0xb3, 0x5c, 0x3b, 0xa1, 0x66, 0xf9, 0xf0, 0xfb, 0x12, 0xed, 0x16, 0x66, 0x32, + 0x7f, 0x0b, 0x53, 0xd2, 0x83, 0x4e, 0x1d, 0xb5, 0x07, 0xad, 0x97, 0xf6, 0xa0, 0x7e, 0xa9, 0x1f, + 0x37, 0x84, 0xba, 0xbf, 0xab, 0x5b, 0xe0, 0xa1, 0xb6, 0x76, 0x9c, 0x6e, 0x14, 0x5e, 0x69, 0x37, + 0xfa, 0x59, 0xae, 0xbb, 0x94, 0xf7, 0x3b, 0xef, 0x1f, 0x6d, 0x4f, 0x23, 0xfa, 0xcc, 0xff, 0xbb, + 0x8e, 0xed, 0x17, 0xa2, 0x50, 0xa7, 0x61, 0xa6, 0x83, 0xb4, 0x9e, 0xe1, 0x79, 0x88, 0xd7, 0x10, + 0x2a, 0x68, 0xf1, 0x31, 0x7a, 0x07, 0x6a, 0x5c, 0xc9, 0xaa, 0x93, 0x3a, 0xa3, 0xeb, 0x93, 0x9f, + 0xc4, 0x26, 0xa5, 0xf7, 0x29, 0x71, 0x6c, 0x81, 0x84, 0x2e, 0x43, 0x23, 0x35, 0x7c, 0xe5, 0x59, + 0xaf, 0xeb, 0x2b, 0x52, 0x3f, 0x49, 0x96, 0x65, 0xe8, 0x7c, 0x6d, 0xc7, 0x8d, 0x88, 0x23, 0xfa, + 0x8c, 0x89, 0xe1, 0xb5, 0xd7, 0x92, 0x8f, 0xe9, 0xda, 0x14, 0x1d, 0xad, 0xc3, 0xa4, 0xbc, 0x10, + 0x13, 0x1e, 0x34, 0xbd, 0x71, 0x76, 0x38, 0x98, 0x26, 0xab, 0x14, 0xa2, 0xf9, 0x65, 0x05, 0xde, + 0xc8, 0x0c, 0x22, 0xf1, 0xa6, 0xa4, 0xd5, 0xfb, 0xfa, 0x33, 0xee, 0x79, 0x98, 0x13, 0xbd, 0x65, + 0x76, 0x2f, 0x26, 0xaf, 0x68, 0x0b, 0x50, 0xf3, 0x77, 0x15, 0x78, 0x6b, 0x78, 0x1f, 0x57, 0x7b, + 0x38, 0x62, 0xe9, 0xf1, 0x9e, 0xc4, 0x5e, 0x92, 0x84, 0x37, 0x9e, 0x25, 0xbc, 0xdc, 0xfe, 0xaa, + 0xf9, 0xfd, 0x99, 0x7f, 0x18, 0x87, 0x69, 0xcd, 0x80, 0xca, 0x12, 0x26, 0xaf, 0x6c, 0x85, 0xdd, + 0x8a, 0xdb, 0x04, 0x91, 0x14, 0x1a, 0xb6, 0x06, 0x41, 0x7d, 0x00, 0x8a, 0x23, 0xec, 0x13, 0x46, + 0x22, 0x1e, 0xc9, 0xb9, 0xc7, 0xdf, 0x3e, 0x7e, 0x74, 0xd9, 0x4d, 0x68, 0xda, 0x1a, 0x79, 0x5e, + 0x9a, 0x0b, 0xd6, 0xb1, 0x8a, 0xdf, 0x6a, 0x86, 0x9e, 0xc2, 0xdc, 0x9e, 0xeb, 0x91, 0xdd, 0x4c, + 0x90, 0x49, 0x21, 0xc8, 0xbd, 0xe3, 0x0b, 0x72, 0x43, 0xa7, 0x6b, 0x17, 0xd8, 0x98, 0x6b, 0xb0, + 0x50, 0xf4, 0x27, 0x2e, 0xa4, 0xeb, 0xe3, 0x6e, 0xaa, 0x2d, 0x35, 0x33, 0x11, 0x2c, 0x14, 0xfd, + 0xc7, 0xfc, 0xc7, 0x38, 0x9c, 0x4e, 0xc9, 0x6d, 0x06, 0x41, 0x38, 0x08, 0x1c, 0xd1, 0x62, 0x95, + 0x9e, 0xc5, 0x12, 0x4c, 0x30, 0x97, 0x79, 0x69, 0xe1, 0x23, 0x26, 0x3c, 0x77, 0xb1, 0x30, 0xf4, + 0x98, 0x4b, 0xd5, 0x01, 0x27, 0x53, 0x79, 0xf6, 0xa2, 0x6b, 0xeb, 0x88, 0x48, 0x50, 0xb7, 0xd3, + 0x39, 0xff, 0xc6, 0xab, 0x1a, 0xd1, 0xaf, 0x48, 0x65, 0xa6, 0x73, 0x61, 0xf7, 0xa1, 0xe7, 0x11, + 0x87, 0xab, 0x43, 0xeb, 0x68, 0x0a, 0x50, 0xd1, 0x29, 0xb1, 0xc8, 0x0d, 0xba, 0xaa, 0x9f, 0x51, + 0x33, 0x2e, 0x27, 0x8e, 0x22, 0x7c, 0x60, 0xd4, 0x85, 0x02, 0xe4, 0x04, 0x5d, 0x81, 0xaa, 0x8f, + 0xa9, 0x4a, 0x74, 0x6b, 0xb9, 0xe8, 0x50, 0xa6, 0x01, 0x6b, 0x07, 0x53, 0x99, 0x09, 0xf8, 0xb2, + 0xe6, 0x07, 0xbc, 0x9f, 0xa6, 0x5f, 0xbd, 0x24, 0x7c, 0x0c, 0xb3, 0xb9, 0xe0, 0x83, 0x1e, 0xc2, + 0x72, 0x66, 0x51, 0x3a, 0x43, 0x55, 0x04, 0xbe, 0xf1, 0x42, 0xc9, 0xec, 0x43, 0x08, 0x98, 0x4f, + 0x60, 0x91, 0x9b, 0x8c, 0x70, 0xfc, 0x13, 0x6a, 0x6d, 0x3e, 0x82, 0x46, 0xca, 0xb2, 0xd4, 0x66, + 0x9a, 0x50, 0xdf, 0x4f, 0x9a, 0x36, 0xd9, 0xdb, 0xa4, 0x73, 0x73, 0x13, 0x90, 0x2e, 0xaf, 0xca, + 0x40, 0xef, 0xe4, 0x8b, 0xe2, 0xd3, 0xc5, 0x74, 0x23, 0xd0, 0x93, 0x9a, 0xf8, 0xb7, 0xe3, 0x30, + 0xbf, 0xe5, 0x8a, 0xab, 0xb5, 0x13, 0x0a, 0x72, 0x6b, 0xb0, 0x10, 0x0f, 0xda, 0x7e, 0xd8, 0x19, + 0x78, 0x44, 0x15, 0x05, 0x2a, 0xd3, 0x0f, 0xc1, 0x47, 0x05, 0xbf, 0xf4, 0x1a, 0xa5, 0xa6, 0x5d, + 0xa3, 0x5c, 0x81, 0xb3, 0x77, 0xc9, 0x53, 0xb5, 0x9f, 0x2d, 0x2f, 0x6c, 0xb7, 0xdd, 0xa0, 0x9b, + 0x30, 0x99, 0x10, 0x4c, 0x0e, 0x47, 0x28, 0x2b, 0x15, 0x27, 0x4b, 0x4b, 0x45, 0xf3, 0xe7, 0x15, + 0x58, 0xc8, 0xb4, 0xa6, 0xf4, 0x7e, 0x49, 0xfa, 0x87, 0xd4, 0xfa, 0x5b, 0xba, 0xd6, 0x8b, 0xa8, + 0xff, 0xb9, 0x6b, 0xcc, 0xe8, 0xae, 0xf1, 0xaf, 0x0a, 0x9c, 0xde, 0x72, 0x59, 0x12, 0x94, 0xdc, + 0xff, 0xb5, 0x13, 0x2c, 0xd1, 0x77, 0xad, 0x5c, 0xdf, 0x16, 0x2c, 0x17, 0x37, 0xaa, 0x94, 0xbe, + 0x04, 0x13, 0xfc, 0xe4, 0x93, 0xfb, 0x00, 0x39, 0x31, 0xff, 0x3e, 0x09, 0xe7, 0x3e, 0xa3, 0x1d, + 0xcc, 0xd2, 0x2b, 0xc2, 0x1b, 0x61, 0xb4, 0xcb, 0x3f, 0x9d, 0x8c, 0x86, 0x0a, 0x4f, 0xbf, 0xe3, + 0x23, 0x9f, 0x7e, 0xab, 0x23, 0x9e, 0x7e, 0x6b, 0x47, 0x7a, 0xfa, 0x9d, 0x38, 0xb1, 0xa7, 0xdf, + 0xe1, 0x1e, 0x69, 0xb2, 0xb4, 0x47, 0x7a, 0x98, 0xeb, 0x23, 0xa6, 0x84, 0x4b, 0x7c, 0x47, 0x77, + 0x89, 0x91, 0xa7, 0x33, 0xf2, 0xcd, 0xaa, 0xf0, 0x62, 0x5a, 0x7f, 0xe1, 0x8b, 0x69, 0x63, 0xf8, + 0xc5, 0xb4, 0xfc, 0xd1, 0x0d, 0x0e, 0x7d, 0x74, 0x3b, 0x0f, 0x73, 0xf1, 0x41, 0xe0, 0x90, 0x4e, + 0x7a, 0x71, 0x3c, 0x2d, 0xb7, 0x9d, 0x87, 0xe6, 0xac, 0x7d, 0xa6, 0x60, 0xed, 0xa9, 0xa5, 0xce, + 0x6a, 0x96, 0x5a, 0xe6, 0x03, 0x73, 0xa5, 0x3e, 0xf0, 0xdf, 0xd3, 0xfc, 0x7c, 0x0e, 0x2b, 0x87, + 0x9d, 0x9e, 0x72, 0x4a, 0x03, 0xa6, 0x9c, 0x1e, 0x0e, 0xba, 0xe2, 0x9a, 0x4e, 0x74, 0xe3, 0x6a, + 0x3a, 0xaa, 0x5a, 0xdf, 0xf8, 0x23, 0xc0, 0x62, 0x56, 0x85, 0xf3, 0xbf, 0xae, 0x43, 0xd0, 0x3d, + 0x58, 0xd8, 0x52, 0xbf, 0x0e, 0x49, 0x6f, 0xd0, 0x47, 0x3d, 0x81, 0x35, 0x5f, 0x2f, 0xff, 0x28, + 0x45, 0x33, 0xc7, 0x90, 0x03, 0x67, 0x8b, 0x04, 0xb3, 0xd7, 0xb6, 0x37, 0x47, 0x50, 0x4e, 0xb1, + 0x5e, 0xc4, 0xe2, 0x42, 0x05, 0x3d, 0x84, 0xb9, 0xfc, 0x9b, 0x10, 0xca, 0x95, 0x25, 0xa5, 0xcf, + 0x54, 0x4d, 0x73, 0x14, 0x4a, 0x2a, 0xff, 0x23, 0x6e, 0x06, 0xb9, 0xe7, 0x0f, 0x64, 0xe6, 0x3b, + 0xf4, 0xb2, 0x07, 0xa4, 0xe6, 0x37, 0x47, 0xe2, 0xa4, 0xd4, 0x3f, 0x82, 0x7a, 0x72, 0xb7, 0x9b, + 0x57, 0x73, 0xe1, 0xc6, 0xb7, 0xb9, 0x90, 0xa7, 0xb7, 0x17, 0x9b, 0x63, 0xe8, 0x63, 0xb9, 0x78, + 0x93, 0xd2, 0x92, 0xc5, 0xda, 0x8d, 0x66, 0xf3, 0x54, 0xc9, 0x2d, 0xa2, 0x39, 0x86, 0xbe, 0x07, + 0xd3, 0x7c, 0xb4, 0xab, 0x7e, 0x97, 0xb1, 0x6c, 0xc9, 0x9f, 0x01, 0x59, 0xc9, 0xcf, 0x80, 0xac, + 0xeb, 0x3e, 0x65, 0x07, 0xcd, 0x92, 0x6b, 0x3e, 0x45, 0xe0, 0x11, 0xcc, 0x6e, 0x11, 0x96, 0x75, + 0xe5, 0xe8, 0xad, 0x23, 0xdd, 0x5d, 0x34, 0xcd, 0x22, 0xda, 0x70, 0x63, 0x6f, 0x8e, 0xa1, 0x5f, + 0x55, 0xe0, 0xd4, 0x16, 0x61, 0xc5, 0x3e, 0x17, 0xbd, 0x57, 0xce, 0xe4, 0x90, 0x7e, 0xb8, 0x79, + 0xf7, 0xb8, 0x3e, 0x99, 0x27, 0x6b, 0x8e, 0xa1, 0x5f, 0x57, 0xe0, 0x8c, 0x26, 0x98, 0xde, 0xb8, + 0xa2, 0xf5, 0xd1, 0xc2, 0x95, 0x34, 0xb9, 0xcd, 0x5b, 0xc7, 0xfc, 0xb9, 0x8d, 0x46, 0xd2, 0x1c, + 0x43, 0xbb, 0xe2, 0x4c, 0xb2, 0x3a, 0x15, 0x9d, 0x2b, 0x2d, 0x48, 0x53, 0xee, 0x2b, 0x87, 0x7d, + 0x4e, 0xcf, 0xe1, 0x16, 0x4c, 0x6f, 0x11, 0x96, 0x14, 0x55, 0x79, 0x4b, 0x2b, 0xd4, 0xb2, 0x79, + 0x57, 0x2d, 0xd6, 0x61, 0xc2, 0x62, 0x16, 0x25, 0x2d, 0xad, 0xb8, 0xc8, 0xfb, 0x6a, 0x69, 0x85, + 0x95, 0xb7, 0x98, 0xf2, 0xda, 0xc4, 0x1c, 0x43, 0x4f, 0x60, 0xb9, 0x3c, 0x54, 0xa2, 0xb7, 0x8f, + 0x9c, 0x0c, 0x9b, 0x6b, 0x47, 0x41, 0x4d, 0x58, 0x7e, 0xb2, 0xf9, 0xe7, 0xe7, 0x2b, 0x95, 0xbf, + 0x3e, 0x5f, 0xa9, 0xfc, 0xf3, 0xf9, 0x4a, 0xe5, 0x8b, 0x8b, 0x2f, 0xf8, 0x59, 0x9e, 0xf6, 0x1b, + 0x42, 0x4c, 0x5d, 0xc7, 0x73, 0x49, 0xc0, 0xda, 0x93, 0xc2, 0xdf, 0x2e, 0xfe, 0x3b, 0x00, 0x00, + 0xff, 0xff, 0xbb, 0x92, 0xae, 0xd6, 0x62, 0x28, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -5657,6 +5665,16 @@ func (m *UpdateRevisionForPathsRequest) MarshalToSizedBuffer(dAtA []byte) (int, i -= len(m.XXX_unrecognized) copy(dAtA[i:], m.XXX_unrecognized) } + if m.NoRevisionCache { + i-- + if m.NoRevisionCache { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x70 + } if len(m.Paths) > 0 { for iNdEx := len(m.Paths) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Paths[iNdEx]) @@ -6890,6 +6908,9 @@ func (m *UpdateRevisionForPathsRequest) Size() (n int) { n += 1 + l + sovRepository(uint64(l)) } } + if m.NoRevisionCache { + n += 2 + } if m.XXX_unrecognized != nil { n += len(m.XXX_unrecognized) } @@ -13658,6 +13679,26 @@ func (m *UpdateRevisionForPathsRequest) Unmarshal(dAtA []byte) error { } m.Paths = append(m.Paths, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex + case 14: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field NoRevisionCache", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowRepository + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.NoRevisionCache = bool(v != 0) default: iNdEx = preIndex skippy, err := skipRepository(dAtA[iNdEx:]) diff --git a/reposerver/repository/repository.go b/reposerver/repository/repository.go index 14de84b699138..26e9c6b4947c8 100644 --- a/reposerver/repository/repository.go +++ b/reposerver/repository/repository.go @@ -2988,7 +2988,7 @@ func (s *Service) UpdateRevisionForPaths(_ context.Context, request *apiclient.U return &apiclient.UpdateRevisionForPathsResponse{}, nil } - gitClientOpts := git.WithCache(s.cache, false) + gitClientOpts := git.WithCache(s.cache, !request.GetNoRevisionCache()) gitClient, revision, err := s.newClientResolveRevision(repo, revision, gitClientOpts) if err != nil { return nil, status.Errorf(codes.Internal, "unable to resolve git revision %s: %v", revision, err) diff --git a/reposerver/repository/repository.proto b/reposerver/repository/repository.proto index eb8e7077a0f20..a38e24fce1fdf 100644 --- a/reposerver/repository/repository.proto +++ b/reposerver/repository/repository.proto @@ -309,6 +309,8 @@ message UpdateRevisionForPathsRequest { string syncedRevision = 11; string revision = 12; repeated string paths = 13; + + bool noRevisionCache = 14; } message UpdateRevisionForPathsResponse { From 2b2230a1e45de94c0f71637c594ec5d87d59729d Mon Sep 17 00:00:00 2001 From: pashakostohrys Date: Thu, 29 Aug 2024 16:58:14 +0300 Subject: [PATCH 30/30] chore: update version to 2.11-2024.8.29-fa0e3225a --- VERSION | 2 +- changelog/CHANGELOG-2.11-2024.8.29-fa0e3225a.md | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 changelog/CHANGELOG-2.11-2024.8.29-fa0e3225a.md diff --git a/VERSION b/VERSION index e0038178258e9..153da099b0bca 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -2.11-2024.8.28-62776e60e \ No newline at end of file +2.11-2024.8.29-fa0e3225a \ No newline at end of file diff --git a/changelog/CHANGELOG-2.11-2024.8.29-fa0e3225a.md b/changelog/CHANGELOG-2.11-2024.8.29-fa0e3225a.md new file mode 100644 index 0000000000000..74d4934457254 --- /dev/null +++ b/changelog/CHANGELOG-2.11-2024.8.29-fa0e3225a.md @@ -0,0 +1,2 @@ +### Chore +- chore: selfheal bring back revision cache \ No newline at end of file