From b3b14039e0767704451f744a17c9008bd0a635f8 Mon Sep 17 00:00:00 2001 From: laurentbarontini Date: Tue, 7 Jul 2026 15:05:04 +0200 Subject: [PATCH] Linkage --- modules/purchase_trade/stock.py | 553 +++++++ modules/purchase_trade/tests/test_module.py | 86 + modules/stock/linkage.fodt | 1553 +++++++++++++++++++ 3 files changed, 2192 insertions(+) create mode 100644 modules/stock/linkage.fodt diff --git a/modules/purchase_trade/stock.py b/modules/purchase_trade/stock.py index 0a3f3e8..5a30df9 100755 --- a/modules/purchase_trade/stock.py +++ b/modules/purchase_trade/stock.py @@ -1489,6 +1489,559 @@ class ShipmentIn(metaclass=PoolMeta): if not today: return '' return today.strftime('%d-%m-%Y') + + @staticmethod + def _report_record_key(record): + record_id = getattr(record, 'id', None) + return record_id if record_id is not None else id(record) + + @classmethod + def _report_unique_records(cls, records): + unique = [] + seen = set() + for record in records: + if not record: + continue + key = cls._report_record_key(record) + if key in seen: + continue + seen.add(key) + unique.append(record) + return unique + + def _get_report_linkage_lots(self): + lots = self._get_report_physical_lots() + if lots: + return lots + return self._report_unique_records( + getattr(move, 'lot', None) + for move in (self.incoming_moves or self.moves or [])) + + def _get_report_linkage_purchase_lines(self): + return self._report_unique_records( + getattr(lot, 'line', None) + for lot in self._get_report_linkage_lots()) + + def _get_report_linkage_sale_lines(self): + return self._report_unique_records( + getattr(lot, 'sale_line', None) + for lot in self._get_report_linkage_lots()) + + def _get_report_linkage_purchase(self): + purchases = self._report_unique_records( + getattr(line, 'purchase', None) + for line in self._get_report_linkage_purchase_lines()) + return purchases[0] if purchases else None + + def _get_report_linkage_sale(self): + sales = self._report_unique_records( + getattr(line, 'sale', None) + for line in self._get_report_linkage_sale_lines()) + return sales[0] if sales else None + + @staticmethod + def _report_rec_name(record): + return ( + getattr(record, 'rec_name', None) + or getattr(record, 'name', None) + or getattr(record, 'number', None) + or '') + + @classmethod + def _report_number(cls, record): + return ( + getattr(record, 'number', None) + or getattr(record, 'full_number', None) + or cls._report_rec_name(record) + or '') + + @staticmethod + def _report_date(value): + if not value: + return '' + if hasattr(value, 'strftime'): + return value.strftime('%d %b %y') + return str(value) + + @staticmethod + def _report_amount(value): + if value in (None, ''): + return '' + return format(Decimal(str(value or 0)).quantize(Decimal('0.001')), ',f') + + @staticmethod + def _report_price(value): + if value in (None, ''): + return '' + return format(Decimal(str(value or 0)).quantize(Decimal('0.001')), 'f') + + @classmethod + def _report_currency_code(cls, record): + currency = getattr(record, 'currency', None) + return ( + getattr(currency, 'code', None) + or getattr(currency, 'name', None) + or getattr(currency, 'symbol', None) + or '') + + @classmethod + def _report_unit_symbol(cls, line): + unit = getattr(line, 'unit', None) + return ( + getattr(unit, 'symbol', None) + or getattr(unit, 'rec_name', None) + or getattr(unit, 'name', None) + or '') + + @classmethod + def _report_line_quantity(cls, line): + return Decimal(str( + getattr(line, 'quantity_theorical', None) + or getattr(line, 'quantity', 0) + or 0)) + + @classmethod + def _report_line_amount(cls, line): + quantity = cls._report_line_quantity(line) + price = Decimal(str(getattr(line, 'unit_price', 0) or 0)) + return quantity * price + + def _get_report_linkage_product(self): + lines = ( + self._get_report_linkage_purchase_lines() + or self._get_report_linkage_sale_lines()) + product = getattr(lines[0], 'product', None) if lines else None + if product: + return product + move = self._get_report_primary_move() + return getattr(move, 'product', None) if move else None + + def _get_report_linkage_fees(self): + fees = [] + seen = set() + + def add_fee(fee): + if not fee: + return + key = self._report_record_key(fee) + if key in seen: + return + seen.add(key) + fees.append(fee) + + for fee in getattr(self, 'fees', []) or []: + add_fee(fee) + for line in ( + self._get_report_linkage_purchase_lines() + + self._get_report_linkage_sale_lines()): + for fee in getattr(line, 'fees', []) or []: + add_fee(fee) + return fees + + @classmethod + def _report_fee_amount(cls, fee): + get_amount = getattr(fee, 'get_amount', None) + if callable(get_amount): + amount = get_amount() + else: + amount = None + if amount in (None, ''): + price = Decimal(str(getattr(fee, 'price', 0) or 0)) + quantity = Decimal(str(getattr(fee, 'quantity', 0) or 0)) + mode = getattr(fee, 'mode', None) + amount = price if mode == 'lumpsum' else price * quantity + amount = Decimal(str(amount or 0)) + return -amount if getattr(fee, 'p_r', None) == 'pay' else amount + + def _get_report_linkage_summary_rows(self): + purchase_lines = self._get_report_linkage_purchase_lines() + sale_lines = self._get_report_linkage_sale_lines() + purchase_total = -sum( + self._report_line_amount(line) for line in purchase_lines) + sale_total = sum(self._report_line_amount(line) for line in sale_lines) + + rows = [] + if purchase_lines: + rows.append(('Purchases', '', purchase_total, purchase_total)) + if sale_lines: + rows.append(('Sales', '', sale_total, sale_total)) + + fee_total = Decimal('0') + for fee in self._get_report_linkage_fees(): + product = getattr(fee, 'product', None) + label = self._report_rec_name(product) or 'Fee' + amount = self._report_fee_amount(fee) + fee_total += amount + rows.append(('Costs', label, amount, amount)) + + if rows: + rows.append(('Costs', 'Total', fee_total, fee_total)) + pnl = purchase_total + sale_total + fee_total + rows.append(('P&L', '', pnl, pnl)) + return rows + + def _get_report_linkage_movement_rows(self): + rows = [] + purchase_lines = self._get_report_linkage_purchase_lines() + sale_lines = self._get_report_linkage_sale_lines() + if purchase_lines: + rows.append(('Purchase', '', '', '', '', '', '', '', '', '')) + for line in purchase_lines: + purchase = getattr(line, 'purchase', None) + rows.append(self._get_report_linkage_movement_row( + 'Deal', purchase, line)) + if sale_lines: + rows.append(('Sale', '', '', '', '', '', '', '', '', '')) + for line in sale_lines: + sale = getattr(line, 'sale', None) + rows.append(self._get_report_linkage_movement_row( + 'Deal', sale, line)) + if purchase_lines or sale_lines: + balance = ( + sum(self._report_line_quantity(line) for line in purchase_lines) + - sum(self._report_line_quantity(line) for line in sale_lines)) + unit = self._report_unit_symbol( + purchase_lines[0] if purchase_lines else sale_lines[0]) + rows.append(( + 'Balance (Gain/Loss)', '', '', '', + ' '.join(part for part in [ + self._format_report_quantity(balance), + unit.upper() if unit else ''] if part), + '', '', '', '', '')) + return rows + + def _get_report_linkage_movement_row(self, kind, trade, line): + product = getattr(line, 'product', None) + quantity = ' '.join(part for part in [ + self._format_report_quantity(self._report_line_quantity(line)), + (self._report_unit_symbol(line) or '').upper()] if part) + incoterm = getattr(trade, 'incoterm', None) + period = getattr(line, 'period_at', None) or '' + if period == 'laycan': + period = 'Laycan' + return ( + kind, + self._report_number(trade), + self._report_rec_name(getattr(trade, 'party', None)), + self._report_rec_name(product), + quantity, + getattr(incoterm, 'code', None) or '', + self._report_rec_name(getattr(trade, 'to_location', None)), + period, + self._report_date(getattr(line, 'from_del', None)), + self._report_date(getattr(line, 'to_del', None)), + ) + + def _get_report_linkage_pricing_rows(self): + rows = [] + for label, lines in ( + ('Buy', self._get_report_linkage_purchase_lines()), + ('Sell', self._get_report_linkage_sale_lines())): + for line in lines: + trade = ( + getattr(line, 'purchase', None) + or getattr(line, 'sale', None)) + currency = self._report_currency_code(trade) + unit = self._report_unit_symbol(line).upper() + price = self._report_price(getattr(line, 'unit_price', 0)) + rows.append(( + self._report_number(trade), + label, + (getattr(line, 'price_type', None) or 'Fixed').title(), + '', + self._report_rec_name(getattr(line, 'del_period', None)), + ' '.join(part for part in [ + price, + '/'.join(part for part in [currency, unit] if part)] + if part), + )) + return rows + + def _get_report_linkage_detail_rows(self): + rows = [] + for line in self._get_report_linkage_sale_lines(): + sale = getattr(line, 'sale', None) + rows.append(self._get_report_linkage_detail_row( + 'A', 'Deal revenue', sale, line, self._report_line_amount(line))) + for line in self._get_report_linkage_purchase_lines(): + purchase = getattr(line, 'purchase', None) + rows.append(self._get_report_linkage_detail_row( + 'A', 'Deal expense', purchase, line, + -self._report_line_amount(line))) + for fee in self._get_report_linkage_fees(): + rows.append(self._get_report_linkage_fee_detail_row(fee)) + total = sum((row[-1] for row in rows), Decimal('0')) + if rows: + rows.append(('A', 'Total', '', '', '', '', total, total)) + rows.append(('P&L', '', '', '', '', '', total, total)) + return rows + + def _get_report_linkage_detail_row(self, group, label, trade, line, amount): + currency = self._report_currency_code(trade) + unit = self._report_unit_symbol(line).upper() + unit_price = self._report_price(getattr(line, 'unit_price', 0)) + quantity = self._format_report_quantity(self._report_line_quantity(line)) + return ( + group, + label, + self._report_rec_name(getattr(trade, 'party', None)), + self._report_number(trade), + ' '.join(part for part in [ + unit_price, + '/'.join(part for part in [currency, unit] if part)] + if part), + quantity, + amount, + amount, + ) + + def _get_report_linkage_fee_detail_row(self, fee): + product = getattr(fee, 'product', None) + trade_line = ( + getattr(fee, 'line', None) + or getattr(fee, 'sale_line', None) + or (self._get_report_linkage_purchase_lines() + or self._get_report_linkage_sale_lines() + or [None])[0]) + trade = ( + getattr(trade_line, 'purchase', None) + or getattr(trade_line, 'sale', None)) + currency = self._report_currency_code(fee) or self._report_currency_code(trade) + unit = self._get_report_unit_text(getattr(fee, 'unit', None)) + amount = self._report_fee_amount(fee) + quantity = getattr(fee, 'quantity', None) + if quantity in (None, '') and trade_line: + quantity = self._report_line_quantity(trade_line) + return ( + 'A', + self._report_rec_name(product) or 'Fee', + self._report_rec_name(getattr(fee, 'supplier', None)), + self._report_number(trade), + ' '.join(part for part in [ + self._report_price(getattr(fee, 'price', 0)), + '/'.join(part for part in [currency, unit.upper() if unit else ''] if part)] + if part), + self._format_report_quantity(quantity or 0), + amount, + amount, + ) + + @classmethod + def _report_column(cls, rows, index, amount=False): + values = [] + for row in rows: + value = row[index] + if amount: + value = cls._report_amount(value) + values.append(str(value or '')) + return '\n'.join(values) + + @property + def report_linkage_title(self): + purchase = self._get_report_linkage_purchase() + sale = self._get_report_linkage_sale() + reference = ( + getattr(purchase, 'reference', None) + or getattr(sale, 'reference', None) + or getattr(self, 'reference', None) + or '') + numbers = '/'.join(filter(None, [ + self._report_number(purchase), + self._report_number(sale), + ])) + return ' '.join(part for part in ['Linkage', numbers, reference] if part) + + @property + def report_linkage_desk(self): + product = self._get_report_linkage_product() + return self._report_rec_name(product) + + @property + def report_linkage_book(self): + product = self._get_report_linkage_product() + code = getattr(product, 'code', None) if product else '' + period = self.report_linkage_strategy + return ' '.join(part for part in [code, period] if part) + + @property + def report_linkage_strategy(self): + for line in ( + self._get_report_linkage_purchase_lines() + + self._get_report_linkage_sale_lines()): + strategies = list(getattr(line, 'mtm', []) or []) + if strategies: + strategy = getattr(strategies[0], 'strategy', None) or strategies[0] + return self._report_rec_name(strategy) + period = getattr(line, 'del_period', None) + if period: + return self._report_rec_name(period) + return '' + + @property + def report_linkage_bl_date(self): + return self.bl_date and self.bl_date.strftime('%A, %B %d, %Y') or '' + + @property + def report_linkage_trading_unit(self): + sale = self._get_report_linkage_sale() + party = getattr(sale, 'party', None) if sale else None + return self._report_rec_name(party) + + @property + def report_linkage_finance_user(self): + trade = self._get_report_linkage_purchase() or self._get_report_linkage_sale() + operator = getattr(trade, 'operator', None) if trade else None + return self._report_rec_name(operator) + + @property + def report_linkage_summary_groups(self): + return self._report_column(self._get_report_linkage_summary_rows(), 0) + + @property + def report_linkage_summary_cost_types(self): + return self._report_column(self._get_report_linkage_summary_rows(), 1) + + @property + def report_linkage_summary_estimated(self): + return self._report_column( + self._get_report_linkage_summary_rows(), 2, amount=True) + + @property + def report_linkage_summary_validated(self): + return self._report_column( + self._get_report_linkage_summary_rows(), 3, amount=True) + + @property + def report_linkage_movement_types(self): + return self._report_column(self._get_report_linkage_movement_rows(), 0) + + @property + def report_linkage_movement_references(self): + return self._report_column(self._get_report_linkage_movement_rows(), 1) + + @property + def report_linkage_movement_counterparts(self): + return self._report_column(self._get_report_linkage_movement_rows(), 2) + + @property + def report_linkage_movement_commodities(self): + return self._report_column(self._get_report_linkage_movement_rows(), 3) + + @property + def report_linkage_movement_quantities(self): + return self._report_column(self._get_report_linkage_movement_rows(), 4) + + @property + def report_linkage_movement_deliveries(self): + return self._report_column(self._get_report_linkage_movement_rows(), 5) + + @property + def report_linkage_movement_basis(self): + return self._report_column(self._get_report_linkage_movement_rows(), 6) + + @property + def report_linkage_movement_periods(self): + return self._report_column(self._get_report_linkage_movement_rows(), 7) + + @property + def report_linkage_movement_from_dates(self): + return self._report_column(self._get_report_linkage_movement_rows(), 8) + + @property + def report_linkage_movement_to_dates(self): + return self._report_column(self._get_report_linkage_movement_rows(), 9) + + @property + def report_linkage_bank_deal(self): + purchase = self._get_report_linkage_purchase() + return self._report_number(purchase) + + @property + def report_linkage_bank_type(self): + return 'Buy' if self._get_report_linkage_purchase() else '' + + @property + def report_linkage_bank_name(self): + sale = self._get_report_linkage_sale() + bank = getattr(sale, 'our_bank_account', None) if sale else None + bank_party = getattr(bank, 'bank', None) if bank else None + return self._report_rec_name(bank_party) + + @property + def report_linkage_lc_type(self): + return 'N/A' + + @property + def report_linkage_lc_number(self): + sale = self._get_report_linkage_sale() + return getattr(sale, 'lc_number', '') or '' + + @property + def report_linkage_lc_amount(self): + return '' + + @property + def report_linkage_lc_expiry_date(self): + sale = self._get_report_linkage_sale() + return self._report_date(getattr(sale, 'lc_date', None)) + + @property + def report_linkage_pricing_deals(self): + return self._report_column(self._get_report_linkage_pricing_rows(), 0) + + @property + def report_linkage_pricing_sides(self): + return self._report_column(self._get_report_linkage_pricing_rows(), 1) + + @property + def report_linkage_pricing_types(self): + return self._report_column(self._get_report_linkage_pricing_rows(), 2) + + @property + def report_linkage_pricing_symbols(self): + return self._report_column(self._get_report_linkage_pricing_rows(), 3) + + @property + def report_linkage_pricing_periods(self): + return self._report_column(self._get_report_linkage_pricing_rows(), 4) + + @property + def report_linkage_pricing_input_prices(self): + return self._report_column(self._get_report_linkage_pricing_rows(), 5) + + @property + def report_linkage_detail_groups(self): + return self._report_column(self._get_report_linkage_detail_rows(), 0) + + @property + def report_linkage_detail_cost_types(self): + return self._report_column(self._get_report_linkage_detail_rows(), 1) + + @property + def report_linkage_detail_counterparts(self): + return self._report_column(self._get_report_linkage_detail_rows(), 2) + + @property + def report_linkage_detail_sources(self): + return self._report_column(self._get_report_linkage_detail_rows(), 3) + + @property + def report_linkage_detail_unit_prices(self): + return self._report_column(self._get_report_linkage_detail_rows(), 4) + + @property + def report_linkage_detail_quantities(self): + return self._report_column(self._get_report_linkage_detail_rows(), 5) + + @property + def report_linkage_detail_estimated(self): + return self._report_column( + self._get_report_linkage_detail_rows(), 6, amount=True) + + @property + def report_linkage_detail_validated(self): + return self._report_column( + self._get_report_linkage_detail_rows(), 7, amount=True) def get_rec_name(self, name=None): if self.number: diff --git a/modules/purchase_trade/tests/test_module.py b/modules/purchase_trade/tests/test_module.py index b2fa99c..b43281d 100644 --- a/modules/purchase_trade/tests/test_module.py +++ b/modules/purchase_trade/tests/test_module.py @@ -6407,6 +6407,92 @@ class PurchaseTradeTestCase(ModuleTestCase): self.assertEqual( shipment.report_insurance_amount, 'USD 550.00') + def test_shipment_linkage_helpers_use_matched_purchase_sale_lot(self): + 'linkage helpers expose matched purchase and sale values' + ShipmentIn = Pool().get('stock.shipment.in') + shipment = ShipmentIn() + shipment.bl_date = datetime.date(2026, 4, 30) + shipment.fees = [] + shipment.moves = [] + shipment.lotqt = [] + + currency = SimpleNamespace(code='USD') + unit = SimpleNamespace(symbol='MT') + product = SimpleNamespace( + rec_name='Sulphuric Acid', + name='Sulphuric Acid', + code='H2SO4') + purchase = SimpleNamespace( + id=1, + number='P-10', + reference='26.0001', + currency=currency, + party=SimpleNamespace(rec_name='SUPPLIER SA'), + to_location=SimpleNamespace(rec_name='Odda'), + incoterm=SimpleNamespace(code='FOB'), + operator=SimpleNamespace(rec_name='Operator A')) + sale = SimpleNamespace( + id=2, + number='S-20', + reference='26.0001', + currency=currency, + party=SimpleNamespace(rec_name='CLIENT SA'), + to_location=SimpleNamespace(rec_name='Mejillones'), + incoterm=SimpleNamespace(code='CFR')) + period = SimpleNamespace(rec_name='Chile FY26') + purchase_line = SimpleNamespace( + id=11, + product=product, + purchase=purchase, + quantity_theorical=Decimal('100'), + quantity=Decimal('100'), + unit_price=Decimal('80'), + unit=unit, + price_type='fixed', + del_period=period, + period_at='laycan', + from_del=datetime.date(2026, 4, 30), + to_del=datetime.date(2026, 5, 8), + fees=[], + mtm=[]) + sale_line = SimpleNamespace( + id=12, + product=product, + sale=sale, + quantity_theorical=Decimal('100'), + quantity=Decimal('100'), + unit_price=Decimal('100'), + unit=unit, + price_type='fixed', + del_period=period, + period_at='laycan', + from_del=datetime.date(2026, 4, 30), + to_del=datetime.date(2026, 4, 30), + fees=[], + mtm=[]) + lot = SimpleNamespace( + id=101, + lot_type='physic', + line=purchase_line, + sale_line=sale_line) + shipment.incoming_moves = [SimpleNamespace(lot=lot)] + + self.assertEqual( + shipment.report_linkage_title, 'Linkage P-10/S-20 26.0001') + self.assertEqual(shipment.report_linkage_desk, 'Sulphuric Acid') + self.assertEqual(shipment.report_linkage_book, 'H2SO4 Chile FY26') + self.assertEqual( + shipment.report_linkage_bl_date, 'Thursday, April 30, 2026') + self.assertIn('Purchases', shipment.report_linkage_summary_groups) + self.assertIn('Sales', shipment.report_linkage_summary_groups) + self.assertIn('-8,000.000', shipment.report_linkage_summary_estimated) + self.assertIn('10,000.000', shipment.report_linkage_summary_estimated) + self.assertIn('P-10', shipment.report_linkage_movement_references) + self.assertIn('S-20', shipment.report_linkage_movement_references) + self.assertIn('100 MT', shipment.report_linkage_movement_quantities) + self.assertIn('80.000 USD/MT', shipment.report_linkage_pricing_input_prices) + self.assertIn('100.000 USD/MT', shipment.report_linkage_pricing_input_prices) + def test_shipment_insurance_contact_surveyor_prefers_shipment_surveyor(self): 'insurance contact surveyor property uses shipment surveyor first' ShipmentIn = Pool().get('stock.shipment.in') diff --git a/modules/stock/linkage.fodt b/modules/stock/linkage.fodt new file mode 100644 index 0000000..72da5ea --- /dev/null +++ b/modules/stock/linkage.fodt @@ -0,0 +1,1553 @@ + + + + LibreOffice/7.6.0.3$Windows_X86_64 LibreOffice_project/69edd8b8ebc41d00b4de3915dc82f8f0fc3b6265Laurent BARONTINI2026-07-07T11:58:00Z2026-07-07T14:41:47.9550000003PT2M53S + + + 11 + 0 + 48470 + 23442 + true + false + + + view2 + 11404 + 2521 + 0 + 11 + 48468 + 23451 + 0 + 0 + false + 90 + false + false + true + true + false + false + + + + + true + + true + false + false + false + true + 1 + true + false + false + true + + false + + false + false + false + + 0 + false + true + true + false + false + false + + 0 + + true + high-resolution + false + false + false + false + true + false + false + true + false + false + true + true + false + true + false + false + true + true + false + false + false + false + false + false + false + false + false + 2124067 + 2065993 + false + false + false + false + false + false + true + true + false + true + true + false + false + false + false + false + true + false + true + false + false + false + false + false + false + 0 + true + false + false + true + 0 + true + false + true + true + true + true + false + false + false + false + false + true + + false + true + false + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +<records[0].report_linkage_title or ''> + /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoM + DAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsN + FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAAR + CAAyAqADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAA + AgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkK + FhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWG + h4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl + 5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREA + AgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYk + NOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE + hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk + 5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9Txwp4Ga87+OPxdtPgf8AD/UPFd7p82pw + WmN1tbuEZs+54FeiMgHfFeV/tHQ+A7j4WarH8SJ5oPChwbmWAS7hzx/qwW6+1Z1LqDcXZnTh + IwlXgqkXKPVLc+X0/wCCs3hPAz4F1n8LqKpB/wAFZfCOD/xQ+tf+BER/rXnC6N+wsSG/tnVm + JGM/8TI/+06uW/hT9iGexnuIL3Wpba3x5syJqZVM9Mny68F1sRHepFH6osuyVrTA1vul/md0 + f+CsfhJ8D/hBtZI7/wCkRcfrXsH7NX7aOjftJeI9R0jTfDt/pD2cAnMt1KjBhu24G3vXy6dL + /YVQg/2lqj49TqY/9kr3r9kO1/Z0g8a6q3wdubybVzaD7Utwbvb5W4dPPAGc+nNdNCdeU1zT + TR5eZ4HK6eFnOhhKsJLrJO35n1xEMH39alrxn4j/ALW3wu+EXieTw/4r8S/2ZqqIsjQfY55c + KwBU5RCOQa5Y/wDBQr4ED/mdj+GmXf8A8ar05VqcXZyR8TTyzHVoqpCjJp9UmfR9FfN5/wCC + hnwHH/M6sf8AuF3f/wAapn/Dw74Fdf8AhM2x6f2Zd/8Axqp+sUf5kaf2RmH/AD4l/wCAs+k6 + K+a/+HiHwK/6HF//AAV3f/xqnD/gof8AAjH/ACOb/wDgru//AI1S+s0f5kP+x8x/6B5f+As+ + kqjbGfevnL/h4Z8CcA/8Jm3P/UMu/wD41Ucv/BQ74Fg/L4xZu3Om3Y/9pU/rFH+ZA8mzHrh5 + f+As+jXUuFGcDPrXyN+0f+3vD+zt8SW8Ky+C5dcxapci5TUhCCGLDG0xN/d9a9p+Fv7Svw4+ + NN3Na+EfE9vqd7Em97UxyQyhc9dsiqSPoK/Nv/gpfj/hozOCG/suDP03Pj+tcmMxDp0eekz3 + eG8op4zMFhcdB2ts9D2o/wDBXG2zx8MJj/3Gx/8AGKP+HuNs3H/Cr5efXWx/8Yr846K8H+0c + R/N+B+v/AOpeS/8APp/+BP8AzP0aP/BW22HH/Cspf/B2CP8A0nr7f+FHjcfEr4faD4nWz+wD + VLSO5Ft5vmeXuGcbsDP5V+BHXjANfqb+z9+3J8H/AAD8HPCmga34lmtdTsNPigmhTTrmTY6q + ARlYyD+Fejg8dOcrVpHw3E/C+HwlCEstottvW15H28BgAUteY6J+0T4E134ct48ttfiTwou4 + G/uYpIcFTgja6hs/hXmUv/BRb4GxSFR4smfB5I0u6wfp+7r25Vqcd5I/NaeW42q5KFGTto9G + fTdFfMy/8FF/gUeviucf9wu6/wDjdH/Dxf4Ff9DZP/4K7r/43Wf1mj/Mjo/sXMv+gef/AICz + 6Zor5lP/AAUY+BQ/5muf/wAFd1/8bob/AIKM/Aof8zXcf+Cq6/8AjdH1mj/Oh/2LmW/1ef8A + 4Cz6aor5j/4eNfArBx4quj9NKuv/AI3TR/wUc+BZOP8AhKLsf9wm6/8AjdP6xR/mQf2LmX/Q + PP8A8BZ9PUV8yWv/AAUW+Bl1cRxDxXcRF22h5dLuVQe5Pl8CvUfHvx+8HfDXwLB4x1vVdnh6 + fZ5V1bwvLv342kBQTg5q41acldSRzVctxtGUYVKMk5aLR6npVFfMK/8ABR34GEc+J7pT76Xc + /wDxunD/AIKNfAsjJ8U3Q9hpV1/8bqPrFH+ZHT/YuZf9A8//AAFn05RXzA3/AAUd+Ban/kZ7 + w/TSbr/43TW/4KP/AAMwdvie84/6hF1/8RR9Yo/zIP7EzP8A6B5/+As+oaK8q+Hn7Snw++KX + h/UtZ8OeJra8stNiM16JEeKS2QAks6uAQAAT0rzi8/4KM/A6yuZIj4nuZtjbd0OmXDKfodlU + 61OKu5L7znp5bjK05Qp0pNx30eh9OUV8t/8ADyb4Hcf8T+/z6f2Xcf8AxNL/AMPJvgb/ANB+ + /wD/AAVz/wDxNZ/WqP8AMvvOn+xMz/6B5/8AgLPqOivlv/h5L8Dh/wAx+/8A/BVP/wDE00/8 + FJvgfnH9v3//AIK5/wD4mj61R/nQf2Jmf/QPP7mfU1FfLX/Dyb4HBQf7f1D/AMFU/wD8TR/w + 8m+B3/Qev/8AwVz/APxNH1qh/Oh/2Hmn/QNP7mfUtFfL9v8A8FIPgdcToh8RXkQJwXk0u4wP + rhDXu/gz4jaB8Q/D0GueHdVt9U0qYZS5gbj8QeR+NaQrU6jtB3OLEYDF4RXr0pR9UzqaK8J8 + Tfts/BrwdrNzpWq+NrVL62cxzRwQTT7GHVSUQjI+tZf/AA8B+BOM/wDCcoP+4fdf/GqTr0k7 + OSNI5XjppSjQlZ/3WfRVFfOv/DwL4Ef9Dyn/AIL7r/41TW/4KC/Alf8Amd1P0066/wDjVH1i + l/Miv7JzD/nxL/wFn0ZRXzg3/BQf4Fqf+R1H4addH/2lSH/goZ8CB18anP8A2DLv/wCNUe3p + fzIf9kZg/wDlxL/wFn0hUb9eelfOQ/4KG/Ag/wDM6N/4LLv/AONUh/4KEfAp3GPGhweMnTLv + j6/uqX1il/Mh/wBkZh/z4l/4C/8AI7T9pf44f8M+fDS78W/2P/bwglii+x/avs+d7hc7tjdM + 56V8gR/8FcCoDf8ACrQWPp4g/wDuavqn4wfEH4Q+J/g0fEPjKe21vwHdNEVlWOWVXJYBPlj+ + bOSK+ZB43/YbdQG0m25GRiw1DgflXFiJ1U1yVEkfSZNhcE6EljMFUqST3V9PxX5FT/h7o5/5 + paP/AAf/AP3NQf8AgrlIwwPhZyf+o/8A/c1W28Z/sMEDOk2+B/1D7/8AwpreOP2Gen9kQD/u + Hah/hXJ7Sv8A8/kfQfVMo/6FlX8f8z6E/ZO/avb9py01u4PhY+G/7Nkjj2/b/tPm7hnP+rTG + MfjX0OzH04r57/ZU1v4Iataa6fg7ZxWkCSRm+KW88IdsHbxMMnj0re8a/tefCL4f63No+u+N + LK11SEkS20UMszIcZw3lqwBx6mvXpz5aadSVz87xmEdXFzhg6Mkv5bO6/M9rXpS188r+318C + uMePLf8A8Abn/wCN0q/t9fAps48eW4xxzY3X/wAbp/WKX8yI/srH/wDPif8A4C/8j38jLccf + 1rxf9p39o61/Zq8K2eu3Whza6lzOLfyYrgQlT65KnNZB/bz+Bmf+R8tv/AK5/wDjdfLf/BQD + 9pD4cfGX4ZaZpfhDxNFrN9FfLK8MdvLGQuOuXQCsa+KhGm5Rkj08qyWvWxlKliqEuRvXRo6I + f8FatITP/Fur0nPbU0/+N0v/AA9u0fPPw5vsf9hNP/jdfm3Iuw43AnuB2pma+c/tLELqftf+ + pWTdaT/8Cf8AmfpUf+CtWhnH/FvdRH/cQjP/ALJXtv7L/wC2RY/tN6zqtha+GrnQX0+FZmee + 5WUPkgYGFGOtfjQDz1r72/4JRAN438Yk4ybFMjv99a7MJja1aqozeh81xDwvlmX5fUxFCDUl + tqz73+M/jzxB8N/Ak+teGPBt1481WOaONNGspzDI6s2GYMEf7o5+7+VfHHib/gqX4i8F+J5P + DuufA250vXY2jV9PuvEBSZS6hkBU2ncMpH1FfoEIxgA5IFfnr+05+wz8Sviz+07qPjzQv7H/ + ALCnnsZU+1XhjlxFFEj/AC7D3Rsc+lexifbKzpM/N8leX1HKnj4KyTabclrpZaNL8D0DxR+3 + h458BfDvVfFfi74E6j4ZS1vbWztrfUNYKC7MwlLFXNsMbPKXjBzvHIxzz3wk/wCCqOg+OvF3 + 9leJPBb+E7E2k86agmrC7BkjQv5ZUwxAblV8Hd97aMfNkezftvfAzxN8fvgtbeF/Cv2MapHq + kF2ftsxij2Ikgb5gDzlh2r4en/4JWfFD/hE7O4hvtF/4SH7VIlzZSXh8nyNqGN0fy/vZ8wMD + /s471z1XioTShqvke1l9LIsThpSxVqc22lZy0XR6t/iel3f/AAWASK6mWD4VmeBZCI5G8Q7C + 6Z4JX7KcEjBxk/Wv0S0W/wD7U0q0vPL8r7REkuzOdu4A4z361+UXij/glX8ULSexTQ73Rb+M + 2kbXUtxeGILcHO9UHl8oPlwTz1r9WfDtnJp2h2FpNjzYII4n2nIyFAOPyrbCuvK/tjzM8p5V + CNJ5a073vq399zSooorvPkwooooAKKKKACiiigAooooAKKKKAIi3QGvnD9v9c/szeJiGwdqD + /wAer6PfqK+df29oTdfs2+JI1zy0eSvPG7Ga5cQ7UZN9tT1so/5GFH/Ej8k/h58O77x7qQji + DRWUTDz7g4+QHoBnqTivqPw/4X0/w7o6aZa2yC2CbHDDJk9d3rXJfDyS30XVn8N2wEUNnZxT + gAY853zvc98/cFeiAHqe/tX855/mFarW9l8MFqvPzP7BoU422Pnv4s/Bk6R52taLHvs1y89s + OsYz1HtXu3/BKwn/AIW74n24BGljg9f9YKvMFcFGAKsMHNdV+wj4fsvD/wC0x4thsQIom0hJ + TEucIWcZFfXcJ5tUxVaOHq6yXXyPj+LqfLlNdrax4p/wUoOf2k74j/nyt/8A0WtfKdfV3/BS + qPZ+0hdH+9YwH/xwCvlGvsMY715NE8NpPKqHoFSLhtoY81HUifO6AcnOOK5Y6tLzPoaukJW7 + H6E/HL9kz4YeCf2VJvG2kaBNb6+LG3lS4a+ncK7sgJ2lyO57V+ejEEmv1s/ae+T9hOVSVH/E + vsxk8/8ALSOvyRr08fGMZR5VbQ+F4RxNbE0azrzcrSdru4uaXdgdKbRXlLc/QLW2PpD/AIJ+ + OF/ae8N4Xlo5gTn/AGa6H/gpdJv/AGj5F5wumwAZ/wB565r9gB9n7TvhjjgrKM/8Bro/+Clp + z+0jMMYxpsHP/Anr1b/7F8z8/enFEf8Ar2fKFKOtJRXkn6CO6cjiv1V/Zl/Y7+EXj74JeEtf + 1zwbBfare2YknuHu7hS7ZOThZAB+VflUfuiv26/YvZm/Zq8CblKH7DjBPP3mAP417eWQhUk+ + dXPy7jnE1sNhaboTcW30bXQ8Z/bn+G3h/wCFf7I76B4X01NK0qLU4njgWR3Clt5PLEnr71+V + m7cOTnFfr3/wUpG79mu5x0XUIc/k9fkGv3TUZmkqtka8DydXL5SqO7cnfz0F3kjk5pAflb6U + 2nAgKSRmvIP0l6qx9gfsB/ADwN8cbvxYnjLSv7USwVPs/wDpUsO0k4ydjLmvnv46eG9O8HfF + 3xbomjw/ZdLsdQlggh3F9iqcYySSenevSv2S/h/8XPHV/rsfwt8SLoE8CILwtcmHzB2/hOea + 9D1v/gm58b/Emq3Wq6pfaJeajdymWeeW/JaRj1JOyvUVN1KKUKd33Pz/AOu0sBmtWpisUlFp + Wi3tp2PjYAgE0ma+u1/4JgfGEkjzNAA9ftx5/wDHKcP+CXvxgzkzeH8f9f7f/EVz/U8R/Iz3 + HxJlH/QTH7z5Br9IP2kxu/4J7eEeSyxwWGMjBHzLXkOn/wDBLz4s3V1Glze6BawFsPMLtnKD + 1A2DP519DftueCz8O/2K9O8OvdG8OmyWVq1wwxu2yKM4r0KFCpSpTc1Y+RzfNMFjsdg1hqik + 1LoflypAHTP40Hr0o2nHIwfSk6GvD7n6jG9kmOVh07194/8ABNj4O+CPiloXjOXxZ4asdent + J7cQyXabzHkSZx6ZwPyr4MGSOPrX6Q/8Emp86F4+TAyJ7U8D2lr0MAlKvFNHxnF1WpRyuc6U + mnpqnZ7o+vdD+Anw28CWOqDSfCemaVbX1u0F95UWFlhI+ZXyfu4FeEahdfsdabdzWl5D4Jjm + ifZIvl7trDtkA19B/HskfBXxwyOUf+xbzBBwQfJavwamOHkBQA7jk/jXt47EKhZKKfyPzLhj + KaudKrUqYicWmtm9T9W/7Y/YvLBv+KJz/wBcW/wpyax+xg6nb/whWPeEj+lfk7x/dFKMemBX + lfX3/wA+19x97/qh/wBRlX/wI/WVNT/Y0PCjwRn3hP8AhXxr+2/L8Kp/E3hs/Co6O2nCCb7a + NHi2rvJUJv6dt+Pxryn4B/CyL4x/FTRfCE1/JpkWoMym5ijEhTCk9CRXcftb/s22n7NPirSN + JtNauNdS/tmnLzwrEUKkDAAJz9406lWpVpcygku5jg8twmW5lGhLFVJVGr8stV+R4HIAHIxj + 603PsKG4J4xSV45+lcqeo5ScHsO9fp3/AME1JC/7PHjCPBOL2cgn/ritfmID29a/Tb/gmW5b + 4CeMVO7i+m6/9clr1MvbVWyPg+M0v7NX+JH5w+McDxVrQBJxfTg59d5rGzW344/5HTxB/wBh + G4/9GNWHXBV/iSPs8Ir4eD8kLXo37P8A4d03xh8avB2jaxbreaZe6lDDPbOSFkVnAKkgg/rX + nFesfsu8/tDeAOduNXt+/wD00FVQ/iI5c1bjgqsouzSZ+rCfsN/BCSJd3gDT8kZJEkw/9nqR + P2F/gcv/ADT+wJ9TNMf/AGevc4/9Uv0FT19sqFL+VH8tf2njrv8Afy/8Cf8AmeD/APDDXwOz + n/hX2n5/66zf/F0N+w78ECMf8K907HX/AFkv/wAXXvFFP2FL+RfcH9p47/n/AC/8Cf8AmfGP + 7dXgTQPhn+yNqmh+HNKh0nSY7q2MdtASVUmdM9TmvyiLZHPWv2A/4KSjP7Mes+11a/8Ao9K/ + H3O4Zr5jMtKtl0P3DgWUp4CUpO7cmBNAznIpKcteSfpVj9Fv+CUhxpXj4vtcCS36dfutXxH8 + cphP8YfGLqeupTjH/A//AK1fa3/BKNy2m/EFNoALW5yDznDj+lfE3xsjEXxc8YDBx/ac3/oZ + r2q7bwcH5n5llST4hxbfkcOetJSnrSV4h+m2O1+DVjbar8UvCdldwR3NtPqUKSwyqGR1LDKk + GvuD/go78KPB/gL4YeHrvw54Z03RLqS8MbzWUCxsw2jgkDpXxD8E9y/Fzwgy5yNTgP8A4+K/ + Qz/gqWP+LSeG/a/b/wBBFe1hYxlh5Nq5+Z55VqQz3CQjJpPzZ+XzkHBAxTad/CPrTa8U/TUK + Bk4r7x/4JQtn4g+MVHT+z1P/AJEWvg2vu7/glLx8RPFwAPOnL/6MWvQwLarI+N4tV8oreVvz + P07z70vJrl/H3xD0P4ZaA+t+Ib37Fp0bKjSiGSTBJwOEVj+leaJ+218G3umth4xH2lRuaH+z + bsuo9x5WR+VfZSnGL1Z/NdPDV6sXOnBteSue6ZpNwHXivH9f/av+GXhlNIfUvE6266tD9oso + zZXBknjyRuCCPcOh6jtS+Hf2sfhb4o1u10iy8VQpqF22y2hvLaa381vRTIign2qfaQ2ujR4P + Fcrn7N29GevKSBxyPWnB65Px38TPDnwz8N3Ov+J9Vi0nSbcAyXEgYgZOAAFBJJJHAFM+HfxT + 8MfFjw6uu+FdUj1bSmYr58aMvI6gqwDD8qvnje1zBUqrh7Tldu9jsA2e1G8Z714nqn7Yfwo0 + TxFqWh3PiSU6pp0rQXdvBpl3KYnBwQSkRHWup8DfHjwN8SoL2fw34jttUWyUtcxIrpLDgZO6 + NlDD8qlVIN2ubTwmIhFSlTaXoz0PcKNwryWP9qL4bzeBr7xgniSM+HbK6NlPefZ5sJMMZQrs + 3dxzjHNdPZfFnwtqHgRvGlvq0Vx4bS3a4N/ErOoRepwBnj0xmmpxbtcl4etFXlBrpt1Oz3+1 + G+vPIvjx4GfwFF41bxJZw+GJE8xdRnJjQjOBgMAST0xjNcXaftqfCi5eJ5NfurK0mIEd9e6T + dw2r56ETNEEx75pe0h3KjhMRO/LTenke77hQWAqlp2pWusafBe2dxHdWs6CSKeFgyOpGQQR1 + Brzbx9+0t4C+HGvNoeratLLrKoJGsNOsZ7ydFIyCyQoxUEc84qnJR1bMqdGrVnyQi2z1YMDQ + WArzr4Z/HrwV8W5LqHw1rK3V9a4+0WFxDJb3MGem+KRVYZ+lVfif+0X4A+Dup6bp/i/xFFo1 + 5qGfs0TQySlwCMk7FO0cjlsUueO9y1hq/P7PkfN26nqAOTS1R0zUYdUtYLq2kEtvNGJI3Xoy + nkH8jV6rOezTsyPFfPn7cmmX2s/s5+J7WwtZ7y5aNdkNtG0jv8w6KoJNfQ20UxoVbqM1lUh7 + WDhLZnTha7wteFeKu4u9j8QdI03xJfRWqa34U8SadqtmoS31my02YyKo6CRNvzD3616BY3/j + i0iGYv7ShxxLc6PeQSfiFj/lX6/CBB/CKPJT+6K+SxHDVDEP3pfek/zP1WHiJiIr/d197/yP + x31bxj4vsYt1v4d1jUrrBCpBo08dup9SXUs2Pwr17/gm1o3iOP4y+K9Q8QaVqdm1xpwPnX1r + JEHPmDgFgATX6UNaxsclQT7ihLaOM5A59a68vyDD5dPnpb+h5uacb1s0ws8LOikpdbs/Kf8A + 4KNeB/EOv/tAvc6ZoOpahbmxhUS2tnJImQoBGVBFfKx+F/jBTg+Fdbz6f2dN/wDE1/QF9nTd + u2jNO8pc5wPyrtq5bGrNy5hZdxtVy/Cww0aCairXuz+fv/hWHjH/AKFTW/8AwXTf/E07/hWX + jEx/8inrQHqNOm/+Jr+gIxKRjA/Km/Z0/ujHpioWVRT+I75eINaUXH6utfP/AIB8l/tEaDf3 + 37DM1ha2F3PqA0+zBtI4mMmRJGSNnXgZr8sz8LfGWN3/AAiet4P/AFDpv/ia/oAFugGMcUvk + rjAAA+ldOIwEcQ03LY8HJ+K6mUQqQjSUuZ31f/AP5/X+F/jGPG7wpra59dOm/wDiaevwr8aY + BXwlrjZ9NOm/+Jr+gDyl9B+VMa2jYg7Rkd8Vyf2TFP4j334hV+mHX3v/ACPx+/YY8AeKNF/a + R8N3l94d1WxtoxJvmubKWNFyp6sVwPzr1b/go7+z7428RfEu08Y6Fo11rmkzWaW0osUMrwSI + WPKDnBDdcdq/SsWyKcgYPTOKd5S4wckV1rAx9i6Lelz52fFmIlmMcxjTSaVmu6PwCb4SeN1B + J8Ia6B6nTpv/AImoz8LfGUZ+bwlrY+unTf8AxNf0A+SmQcdKXyUP8IP4Vyf2TD+Y+ij4hYhb + 4dfe/wDI/ABfhZ40cfL4P1w/TTpv/ia9q8CfGb9pTwPomn+HfDa+IbLTrZfKtrZdARtoyTjL + QknknrX7KeQn90flSC3jH8IrWGWum7wqNHHieNnjFavhYyXn/wAMfF/jD4cfFv41fsYNpfil + Wu/Hs8wvPImEUMjoCdqbVCqDtPSvzf1H4LeP9KvJbe58F69FcRsVZP7Plbke4BBr97zbKTkE + g+1OEKjtWtfL4V9XI8vK+La+VqcadGLjJ3S1VvQ/AP8A4VL43YFh4P13A6n+zpv/AImmj4Te + Njux4R1wgdcadN/8TX7/AAgRQcDrS+WvpXN/ZMVtM9//AIiDX/6B197PxS+Bnj34z/s+XWpz + eEPC2opJqCqs4vNGmlHHPHyjFevD9tv9qDdj/hF2Pt/wjstfqf5a+go8pfSt4YGcFyxqNI8b + EcUYbFVHVrYGEpPq27/kfliP22v2n36eFj+Hh2Wnj9tX9qHO3/hFXJP/AFLstfqX5S+go8lM + /dH5Vf1Sr/z9Zzf6w4H/AKF9P8T8utM/bC/ar1e9js7Twq0txM2yNW8Pugz7lsAfjXv/AO2x + 4f8AFvin9keG3vrF9T8TbrWW7h062LFn3rv2ouSAOa+xTbo2cqMGm/ZUx6nGM+1arCvlcZzb + uefWzmlKvSrUMNGHI76X1PwIb4Q+OVy3/CH69gDOf7Ol/wDiajHwl8bnn/hENd/8Fs3/AMTX + 7+C3QDG3j0pwiRRgKAPpXB/ZMf5j7FeIWI/6B197PwCT4R+OG4Hg/XSTx/yDZv8A4mv0I/4J + c+D9d8L6X46XWtHvdJ86W18r7bbtEXwJc43AZ7V96+WvpSiNR0GK6MPl8aE1NM8fNuMK2a4W + WGlSUb21u+hynxM8NzeLfAHiLRLdgk2oadPaxuegZ42UE/nX4m+MP2cfiX4R12602/8ABmrv + NExAktbR5YnGeqsoINfu2YVbPJ596RbZFOQBn1xXRicJHE25meRkfENfIuaNKCkpdz8Cf+FM + ePv+hL1//wAFs3/xNA+C/j7/AKEvX/8AwWzf/E1+/Hlj0oEYHYflXn/2TD+Y+u/4iDif+fEf + vZ+Gfw00L4qfCfxlYeJ9C8Ga0NSsmLRfaNKlZMkEcjHPWuh+NviD4y/H/WbHU/FXg7UnuLKJ + oYvsejTRLhiCc8HPQV+1RgX0H5UCFMYIB/CtP7N05ed27HG+NZOusS8LHnSte7vbsfgQfgz4 + 9JyPBWv4P/UNm/8AiaP+FMePv+hK1/8A8Fs3/wATX78eWP8AIo8sf5FZ/wBkw/mOxeIOJX/L + iP3s/AyD4KfECdhHH4J8QNITwP7Nm/8Aia/TL9gP4P8Ain4afBLXLbxPpM2kX+rXUk8FtcMN + +wxhQWUfd5B4NfYHkqWBI5pPIXI6nHFdOHy+FCV73PCzfi7E5tQ+rumoq6el+h+G/wAVf2eP + iPoPxA163uPBusTFryaWOS2tHmjeNnZlZXQFSCCO+fauQHwZ8fE8eC9f/wDBbN/8TX78eSoP + el8seg/KsJZXCUm+Y9ijx9iqUFB0Iu3mz8B/+FMePh/zJev/APgtm/8Aia6DwR4E+JvgbxXp + PiHTfBOuPfabcpdQrPpczIXU5GRtGa/djyl9B+VHlL6CksqjF3U3cdTj6vVi4Tw8Wn0uz8w0 + /bS/agRAq+BCAowD/wAI/PSf8NqftRucL4HYY/6l6ev088lR2p3lr6Cur6pVtb2rPn/7ewX/ + AEAU/wAT8wv+Gzv2pi20eCHB/wCxemP9akj/AGwf2qbhwg8DuzHgY8PTD+tfpz5a5+6KYbdC + +7GD7Gj6pVX/AC9Ynn2DtpgKf4nw18bT8U/il+xNfnxh4alj8Xz3cDDT7G2JkMQmjIPlqWIO + Mk/Svz1/4UX8Ren/AAg/iD6f2bN/8TX73/Z1J55oW3Vfc+tTWwEa1nKR05ZxZVyqEqdGjG0n + frp5H4IL8C/iM4JHgbxAQP8AqHS//E0o+BPxGBGfA3iEe/8AZsv/AMTX74eUBQ0SsCCMg1z/ + ANkw/mPb/wCIg4v/AJ8R+9nwD/wTF8A+IvCNv43OvaFqOk+fJB5Rv7d4d+A+cBgM18w/tIfs + zfEzSfi34mu18IalqGn3149xbXWnwmeN1Y8fcyQfqBX7OCJQMDOKb9nXPf8AOuupgoTpqnfb + qfO4binEYbH1MdGCvPRrWx+CY+AnxIYkDwJ4gz/2Dpf/AImlb4B/ElcZ8B+IP/BdL/8AE1+9 + vlijyx/kVyf2TD+Y+h/4iDi1tQj97Pwh0j4NfFXw/qdpqNh4K8Q299ayCWGUaXIxRgcg4KkH + 8RXefEq//aO+L2lQ6Z4w0rxPrNlE/mJDJogjCt6/u4l/Wv2i8oUCMdyT9atZaoq0Zs5J8bVK + tRVqmFg5LZu7PwVPwB+JbdPAniEj/sHS/wCFA/Z9+Jhz/wAUH4g4/wCodL/hX71+WvpSGNT2 + qP7Kh/Mdf/EQcX/z5j97PwVX9n74l43f8IH4gx/2Dpf8K+z/APgmX8NfFfgn4ieJrjxB4c1L + RYJdOCRyX1q8QZvMU4BI5OK/RowqR0potkHOOfWt6OXQoz50zysz4yxOZ4aWFnSSUuqEKbyS + RyBivj3wVoGoW/8AwUD8a376ZdDTZtMhEd2YGWFiIkGAxGCcg9K+xwgFR/ZUznHNejUp89vI + +Lw2KeGjONr8ysfF37T/AIO8Sa9+1v8ADG48PG501xYvH/a8VgLmO2O9z8wb5e/c96w/2ivh + r420/wCIXwwm8W65dfErw+dWAaxt9HWyFm424lZ4c5AJ6NgcV93fZoyQSORxSC2UEn1rKVBS + bd9z06WcVKPs7RXuRa21d/PofDnx/j8cfHX43aF4Y8K+FpdU8K+D5I9Su01GY2NreXCkBVEj + IwYDPRQcgn0qP4PL4+/Z+/aEu7PX/CDaV4S8ayl44dJuGvrazuScKS4jXYCTjkADOe1fc/2V + BnAxn0o+zLzgkH1FR9WSfMnqV/bL9j9WVJclrdb+vbfyPg74MeN7f4MfH/4wah4o0bX47XU9 + Vla0mtNGurlJP3h5BjjYY961NB8Pa98Wv2l9b+JmkeHdS8N+FbbRZbJrrULdraTUpCnB8psN + gdMkdq+3lt1UY68Y5pGtlZs81fsNEnLREyzZXc407Sas3dvRdkfmR4c8A+Ih+xb4rsJdC1E3 + 0nioyi0azkEkkfy5cIVyV9wD0r0z4kfCLxP8HfhZe6j4A0241Xw14j0dYNY8KxA77a4eIAXU + AIJHJw6ADsfp91/Zk96DaofWpWGS69LGrz2rKam4K3NzNdHtofm/qPwX8Xav+zx8F9Vh8OXu + sWvhi8W71Tw48ZjnkjDElhGxG4gZGMZ+avWPiv8AHU/Ebwx9g+HjayusravFJ4YuvBklws7B + eEkknVI0UdM7jX2QLWP0yfX1oNpEQRtHNCw/KrJkzzj2s1OpTu4tta6au9mranjf7K2pa3q3 + wP8AD0+v2Eek6p5RWW0hshaLHg8KIgAFwPQV4R8XdE0nwj8ctc194fHHw0vr2GMHxPoNr/ad + nqAVQAGhWOQoR05A5zX255Cgg5NH2cZOST9TWs6fNBRucNHHujiJ1lG3N0T/AOHX4HxN8FPG + /jf/AIWtqd9JHceOfCUGmtJN4sv/AAsNJvhIOVgXChpuOfu964TSfhh8UPjf4q8ceO9U8BWe + oWviK3fSNOt9c1FrOaztlbIZYzC3JYBucEEe9fom1qjNnGD6igWyjuc+vrWTw97JvY74506U + 3Uo0kpaL7vS2/wAj5o/Yl8Q+MdM8O6l8PfHOlX1pq3hqTyre8mjZobi3z8oWXADlfXqc+1fT + tRpCqNuGc4xUldFOPJFRueLiq6xNaVZRUb9FsFFFFaHKFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB//9k= + + + Desk<records[0].report_linkage_desk or ''>B/L Date<records[0].report_linkage_bl_date or ''>Book<records[0].report_linkage_book or ''>Trading Unit<records[0].report_linkage_trading_unit or ''>Strategy<records[0].report_linkage_strategy or ''>Finance user<records[0].report_linkage_finance_user or ''>1- Financial summary ( USD )2- InformationGroupCost TypeEstimatedValidated<records[0].report_linkage_summary_groups or ''><records[0].report_linkage_summary_cost_types or ''><records[0].report_linkage_summary_estimated or ''><records[0].report_linkage_summary_validated or ''>3- Loading and Discharge movementsTypeReferenceCounterpartCommodityQuantityDeliveryBasisPeriod atFromTo<records[0].report_linkage_movement_types or ''><records[0].report_linkage_movement_references or ''><records[0].report_linkage_movement_counterparts or ''><records[0].report_linkage_movement_commodities or ''><records[0].report_linkage_movement_quantities or ''><records[0].report_linkage_movement_deliveries or ''><records[0].report_linkage_movement_basis or ''><records[0].report_linkage_movement_periods or ''><records[0].report_linkage_movement_from_dates or ''><records[0].report_linkage_movement_to_dates or ''>4- Bank InformationDeal<records[0].report_linkage_bank_deal or ''>Type<records[0].report_linkage_bank_type or ''>Financing Bank<records[0].report_linkage_bank_name or ''>LC Type<records[0].report_linkage_lc_type or ''>LC Number<records[0].report_linkage_lc_number or ''>LC Amount<records[0].report_linkage_lc_amount or ''>LC Expiry Date<records[0].report_linkage_lc_expiry_date or ''>5- PricingDealTypeTypeSymbolPeriodInput Price<records[0].report_linkage_pricing_deals or ''><records[0].report_linkage_pricing_sides or ''><records[0].report_linkage_pricing_types or ''><records[0].report_linkage_pricing_symbols or ''><records[0].report_linkage_pricing_periods or ''><records[0].report_linkage_pricing_input_prices or ''><records[0].report_linkage_title or ''> + /9j/4AAQSkZJRgABAQEAYABgAAD/2wBDAAMCAgMCAgMDAwMEAwMEBQgFBQQEBQoHBwYIDAoM + DAsKCwsNDhIQDQ4RDgsLEBYQERMUFRUVDA8XGBYUGBIUFRT/2wBDAQMEBAUEBQkFBQkUDQsN + FBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBQUFBT/wAAR + CAAyAqADASIAAhEBAxEB/8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/8QAtRAA + AgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2JyggkK + FhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDhIWG + h4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+Tl + 5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/8QAtREA + AgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnLRChYk + NOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6goOE + hYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uPk + 5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD9Txwp4Ga87+OPxdtPgf8AD/UPFd7p82pw + WmN1tbuEZs+54FeiMgHfFeV/tHQ+A7j4WarH8SJ5oPChwbmWAS7hzx/qwW6+1Z1LqDcXZnTh + IwlXgqkXKPVLc+X0/wCCs3hPAz4F1n8LqKpB/wAFZfCOD/xQ+tf+BER/rXnC6N+wsSG/tnVm + JGM/8TI/+06uW/hT9iGexnuIL3Wpba3x5syJqZVM9Mny68F1sRHepFH6osuyVrTA1vul/md0 + f+CsfhJ8D/hBtZI7/wCkRcfrXsH7NX7aOjftJeI9R0jTfDt/pD2cAnMt1KjBhu24G3vXy6dL + /YVQg/2lqj49TqY/9kr3r9kO1/Z0g8a6q3wdubybVzaD7Utwbvb5W4dPPAGc+nNdNCdeU1zT + TR5eZ4HK6eFnOhhKsJLrJO35n1xEMH39alrxn4j/ALW3wu+EXieTw/4r8S/2ZqqIsjQfY55c + KwBU5RCOQa5Y/wDBQr4ED/mdj+GmXf8A8ar05VqcXZyR8TTyzHVoqpCjJp9UmfR9FfN5/wCC + hnwHH/M6sf8AuF3f/wAapn/Dw74Fdf8AhM2x6f2Zd/8Axqp+sUf5kaf2RmH/AD4l/wCAs+k6 + K+a/+HiHwK/6HF//AAV3f/xqnD/gof8AAjH/ACOb/wDgru//AI1S+s0f5kP+x8x/6B5f+As+ + kqjbGfevnL/h4Z8CcA/8Jm3P/UMu/wD41Ucv/BQ74Fg/L4xZu3Om3Y/9pU/rFH+ZA8mzHrh5 + f+As+jXUuFGcDPrXyN+0f+3vD+zt8SW8Ky+C5dcxapci5TUhCCGLDG0xN/d9a9p+Fv7Svw4+ + NN3Na+EfE9vqd7Em97UxyQyhc9dsiqSPoK/Nv/gpfj/hozOCG/suDP03Pj+tcmMxDp0eekz3 + eG8op4zMFhcdB2ts9D2o/wDBXG2zx8MJj/3Gx/8AGKP+HuNs3H/Cr5efXWx/8Yr846K8H+0c + R/N+B+v/AOpeS/8APp/+BP8AzP0aP/BW22HH/Cspf/B2CP8A0nr7f+FHjcfEr4faD4nWz+wD + VLSO5Ft5vmeXuGcbsDP5V+BHXjANfqb+z9+3J8H/AAD8HPCmga34lmtdTsNPigmhTTrmTY6q + ARlYyD+Fejg8dOcrVpHw3E/C+HwlCEstottvW15H28BgAUteY6J+0T4E134ct48ttfiTwou4 + G/uYpIcFTgja6hs/hXmUv/BRb4GxSFR4smfB5I0u6wfp+7r25Vqcd5I/NaeW42q5KFGTto9G + fTdFfMy/8FF/gUeviucf9wu6/wDjdH/Dxf4Ff9DZP/4K7r/43Wf1mj/Mjo/sXMv+gef/AICz + 6Zor5lP/AAUY+BQ/5muf/wAFd1/8bob/AIKM/Aof8zXcf+Cq6/8AjdH1mj/Oh/2LmW/1ef8A + 4Cz6aor5j/4eNfArBx4quj9NKuv/AI3TR/wUc+BZOP8AhKLsf9wm6/8AjdP6xR/mQf2LmX/Q + PP8A8BZ9PUV8yWv/AAUW+Bl1cRxDxXcRF22h5dLuVQe5Pl8CvUfHvx+8HfDXwLB4x1vVdnh6 + fZ5V1bwvLv342kBQTg5q41acldSRzVctxtGUYVKMk5aLR6npVFfMK/8ABR34GEc+J7pT76Xc + /wDxunD/AIKNfAsjJ8U3Q9hpV1/8bqPrFH+ZHT/YuZf9A8//AAFn05RXzA3/AAUd+Ban/kZ7 + w/TSbr/43TW/4KP/AAMwdvie84/6hF1/8RR9Yo/zIP7EzP8A6B5/+As+oaK8q+Hn7Snw++KX + h/UtZ8OeJra8stNiM16JEeKS2QAks6uAQAAT0rzi8/4KM/A6yuZIj4nuZtjbd0OmXDKfodlU + 61OKu5L7znp5bjK05Qp0pNx30eh9OUV8t/8ADyb4Hcf8T+/z6f2Xcf8AxNL/AMPJvgb/ANB+ + /wD/AAVz/wDxNZ/WqP8AMvvOn+xMz/6B5/8AgLPqOivlv/h5L8Dh/wAx+/8A/BVP/wDE00/8 + FJvgfnH9v3//AIK5/wD4mj61R/nQf2Jmf/QPP7mfU1FfLX/Dyb4HBQf7f1D/AMFU/wD8TR/w + 8m+B3/Qev/8AwVz/APxNH1qh/Oh/2Hmn/QNP7mfUtFfL9v8A8FIPgdcToh8RXkQJwXk0u4wP + rhDXu/gz4jaB8Q/D0GueHdVt9U0qYZS5gbj8QeR+NaQrU6jtB3OLEYDF4RXr0pR9UzqaK8J8 + Tfts/BrwdrNzpWq+NrVL62cxzRwQTT7GHVSUQjI+tZf/AA8B+BOM/wDCcoP+4fdf/GqTr0k7 + OSNI5XjppSjQlZ/3WfRVFfOv/DwL4Ef9Dyn/AIL7r/41TW/4KC/Alf8Amd1P0066/wDjVH1i + l/Miv7JzD/nxL/wFn0ZRXzg3/BQf4Fqf+R1H4addH/2lSH/goZ8CB18anP8A2DLv/wCNUe3p + fzIf9kZg/wDlxL/wFn0hUb9eelfOQ/4KG/Ag/wDM6N/4LLv/AONUh/4KEfAp3GPGhweMnTLv + j6/uqX1il/Mh/wBkZh/z4l/4C/8AI7T9pf44f8M+fDS78W/2P/bwglii+x/avs+d7hc7tjdM + 56V8gR/8FcCoDf8ACrQWPp4g/wDuavqn4wfEH4Q+J/g0fEPjKe21vwHdNEVlWOWVXJYBPlj+ + bOSK+ZB43/YbdQG0m25GRiw1DgflXFiJ1U1yVEkfSZNhcE6EljMFUqST3V9PxX5FT/h7o5/5 + paP/AAf/AP3NQf8AgrlIwwPhZyf+o/8A/c1W28Z/sMEDOk2+B/1D7/8AwpreOP2Gen9kQD/u + Hah/hXJ7Sv8A8/kfQfVMo/6FlX8f8z6E/ZO/avb9py01u4PhY+G/7Nkjj2/b/tPm7hnP+rTG + MfjX0OzH04r57/ZU1v4Iataa6fg7ZxWkCSRm+KW88IdsHbxMMnj0re8a/tefCL4f63No+u+N + LK11SEkS20UMszIcZw3lqwBx6mvXpz5aadSVz87xmEdXFzhg6Mkv5bO6/M9rXpS188r+318C + uMePLf8A8Abn/wCN0q/t9fAps48eW4xxzY3X/wAbp/WKX8yI/srH/wDPif8A4C/8j38jLccf + 1rxf9p39o61/Zq8K2eu3Whza6lzOLfyYrgQlT65KnNZB/bz+Bmf+R8tv/AK5/wDjdfLf/BQD + 9pD4cfGX4ZaZpfhDxNFrN9FfLK8MdvLGQuOuXQCsa+KhGm5Rkj08qyWvWxlKliqEuRvXRo6I + f8FatITP/Fur0nPbU0/+N0v/AA9u0fPPw5vsf9hNP/jdfm3Iuw43AnuB2pma+c/tLELqftf+ + pWTdaT/8Cf8AmfpUf+CtWhnH/FvdRH/cQjP/ALJXtv7L/wC2RY/tN6zqtha+GrnQX0+FZmee + 5WUPkgYGFGOtfjQDz1r72/4JRAN438Yk4ybFMjv99a7MJja1aqozeh81xDwvlmX5fUxFCDUl + tqz73+M/jzxB8N/Ak+teGPBt1481WOaONNGspzDI6s2GYMEf7o5+7+VfHHib/gqX4i8F+J5P + DuufA250vXY2jV9PuvEBSZS6hkBU2ncMpH1FfoEIxgA5IFfnr+05+wz8Sviz+07qPjzQv7H/ + ALCnnsZU+1XhjlxFFEj/AC7D3Rsc+lexifbKzpM/N8leX1HKnj4KyTabclrpZaNL8D0DxR+3 + h458BfDvVfFfi74E6j4ZS1vbWztrfUNYKC7MwlLFXNsMbPKXjBzvHIxzz3wk/wCCqOg+OvF3 + 9leJPBb+E7E2k86agmrC7BkjQv5ZUwxAblV8Hd97aMfNkezftvfAzxN8fvgtbeF/Cv2MapHq + kF2ftsxij2Ikgb5gDzlh2r4en/4JWfFD/hE7O4hvtF/4SH7VIlzZSXh8nyNqGN0fy/vZ8wMD + /s471z1XioTShqvke1l9LIsThpSxVqc22lZy0XR6t/iel3f/AAWASK6mWD4VmeBZCI5G8Q7C + 6Z4JX7KcEjBxk/Wv0S0W/wD7U0q0vPL8r7REkuzOdu4A4z361+UXij/glX8ULSexTQ73Rb+M + 2kbXUtxeGILcHO9UHl8oPlwTz1r9WfDtnJp2h2FpNjzYII4n2nIyFAOPyrbCuvK/tjzM8p5V + CNJ5a073vq399zSooorvPkwooooAKKKKACiiigAooooAKKKKAIi3QGvnD9v9c/szeJiGwdqD + /wAer6PfqK+df29oTdfs2+JI1zy0eSvPG7Ga5cQ7UZN9tT1so/5GFH/Ej8k/h58O77x7qQji + DRWUTDz7g4+QHoBnqTivqPw/4X0/w7o6aZa2yC2CbHDDJk9d3rXJfDyS30XVn8N2wEUNnZxT + gAY853zvc98/cFeiAHqe/tX855/mFarW9l8MFqvPzP7BoU422Pnv4s/Bk6R52taLHvs1y89s + OsYz1HtXu3/BKwn/AIW74n24BGljg9f9YKvMFcFGAKsMHNdV+wj4fsvD/wC0x4thsQIom0hJ + TEucIWcZFfXcJ5tUxVaOHq6yXXyPj+LqfLlNdrax4p/wUoOf2k74j/nyt/8A0WtfKdfV3/BS + qPZ+0hdH+9YwH/xwCvlGvsMY715NE8NpPKqHoFSLhtoY81HUifO6AcnOOK5Y6tLzPoaukJW7 + H6E/HL9kz4YeCf2VJvG2kaBNb6+LG3lS4a+ncK7sgJ2lyO57V+ejEEmv1s/ae+T9hOVSVH/E + vsxk8/8ALSOvyRr08fGMZR5VbQ+F4RxNbE0azrzcrSdru4uaXdgdKbRXlLc/QLW2PpD/AIJ+ + OF/ae8N4Xlo5gTn/AGa6H/gpdJv/AGj5F5wumwAZ/wB565r9gB9n7TvhjjgrKM/8Bro/+Clp + z+0jMMYxpsHP/Anr1b/7F8z8/enFEf8Ar2fKFKOtJRXkn6CO6cjiv1V/Zl/Y7+EXj74JeEtf + 1zwbBfare2YknuHu7hS7ZOThZAB+VflUfuiv26/YvZm/Zq8CblKH7DjBPP3mAP417eWQhUk+ + dXPy7jnE1sNhaboTcW30bXQ8Z/bn+G3h/wCFf7I76B4X01NK0qLU4njgWR3Clt5PLEnr71+V + m7cOTnFfr3/wUpG79mu5x0XUIc/k9fkGv3TUZmkqtka8DydXL5SqO7cnfz0F3kjk5pAflb6U + 2nAgKSRmvIP0l6qx9gfsB/ADwN8cbvxYnjLSv7USwVPs/wDpUsO0k4ydjLmvnv46eG9O8HfF + 3xbomjw/ZdLsdQlggh3F9iqcYySSenevSv2S/h/8XPHV/rsfwt8SLoE8CILwtcmHzB2/hOea + 9D1v/gm58b/Emq3Wq6pfaJeajdymWeeW/JaRj1JOyvUVN1KKUKd33Pz/AOu0sBmtWpisUlFp + Wi3tp2PjYAgE0ma+u1/4JgfGEkjzNAA9ftx5/wDHKcP+CXvxgzkzeH8f9f7f/EVz/U8R/Iz3 + HxJlH/QTH7z5Br9IP2kxu/4J7eEeSyxwWGMjBHzLXkOn/wDBLz4s3V1Glze6BawFsPMLtnKD + 1A2DP519DftueCz8O/2K9O8OvdG8OmyWVq1wwxu2yKM4r0KFCpSpTc1Y+RzfNMFjsdg1hqik + 1LoflypAHTP40Hr0o2nHIwfSk6GvD7n6jG9kmOVh07194/8ABNj4O+CPiloXjOXxZ4asdent + J7cQyXabzHkSZx6ZwPyr4MGSOPrX6Q/8Emp86F4+TAyJ7U8D2lr0MAlKvFNHxnF1WpRyuc6U + mnpqnZ7o+vdD+Anw28CWOqDSfCemaVbX1u0F95UWFlhI+ZXyfu4FeEahdfsdabdzWl5D4Jjm + ifZIvl7trDtkA19B/HskfBXxwyOUf+xbzBBwQfJavwamOHkBQA7jk/jXt47EKhZKKfyPzLhj + KaudKrUqYicWmtm9T9W/7Y/YvLBv+KJz/wBcW/wpyax+xg6nb/whWPeEj+lfk7x/dFKMemBX + lfX3/wA+19x97/qh/wBRlX/wI/WVNT/Y0PCjwRn3hP8AhXxr+2/L8Kp/E3hs/Co6O2nCCb7a + NHi2rvJUJv6dt+Pxryn4B/CyL4x/FTRfCE1/JpkWoMym5ijEhTCk9CRXcftb/s22n7NPirSN + JtNauNdS/tmnLzwrEUKkDAAJz9406lWpVpcygku5jg8twmW5lGhLFVJVGr8stV+R4HIAHIxj + 603PsKG4J4xSV45+lcqeo5ScHsO9fp3/AME1JC/7PHjCPBOL2cgn/ritfmID29a/Tb/gmW5b + 4CeMVO7i+m6/9clr1MvbVWyPg+M0v7NX+JH5w+McDxVrQBJxfTg59d5rGzW344/5HTxB/wBh + G4/9GNWHXBV/iSPs8Ir4eD8kLXo37P8A4d03xh8avB2jaxbreaZe6lDDPbOSFkVnAKkgg/rX + nFesfsu8/tDeAOduNXt+/wD00FVQ/iI5c1bjgqsouzSZ+rCfsN/BCSJd3gDT8kZJEkw/9nqR + P2F/gcv/ADT+wJ9TNMf/AGevc4/9Uv0FT19sqFL+VH8tf2njrv8Afy/8Cf8AmeD/APDDXwOz + n/hX2n5/66zf/F0N+w78ECMf8K907HX/AFkv/wAXXvFFP2FL+RfcH9p47/n/AC/8Cf8AmfGP + 7dXgTQPhn+yNqmh+HNKh0nSY7q2MdtASVUmdM9TmvyiLZHPWv2A/4KSjP7Mes+11a/8Ao9K/ + H3O4Zr5jMtKtl0P3DgWUp4CUpO7cmBNAznIpKcteSfpVj9Fv+CUhxpXj4vtcCS36dfutXxH8 + cphP8YfGLqeupTjH/A//AK1fa3/BKNy2m/EFNoALW5yDznDj+lfE3xsjEXxc8YDBx/ac3/oZ + r2q7bwcH5n5llST4hxbfkcOetJSnrSV4h+m2O1+DVjbar8UvCdldwR3NtPqUKSwyqGR1LDKk + GvuD/go78KPB/gL4YeHrvw54Z03RLqS8MbzWUCxsw2jgkDpXxD8E9y/Fzwgy5yNTgP8A4+K/ + Qz/gqWP+LSeG/a/b/wBBFe1hYxlh5Nq5+Z55VqQz3CQjJpPzZ+XzkHBAxTad/CPrTa8U/TUK + Bk4r7x/4JQtn4g+MVHT+z1P/AJEWvg2vu7/glLx8RPFwAPOnL/6MWvQwLarI+N4tV8oreVvz + P07z70vJrl/H3xD0P4ZaA+t+Ib37Fp0bKjSiGSTBJwOEVj+leaJ+218G3umth4xH2lRuaH+z + bsuo9x5WR+VfZSnGL1Z/NdPDV6sXOnBteSue6ZpNwHXivH9f/av+GXhlNIfUvE6266tD9oso + zZXBknjyRuCCPcOh6jtS+Hf2sfhb4o1u10iy8VQpqF22y2hvLaa381vRTIign2qfaQ2ujR4P + Fcrn7N29GevKSBxyPWnB65Px38TPDnwz8N3Ov+J9Vi0nSbcAyXEgYgZOAAFBJJJHAFM+HfxT + 8MfFjw6uu+FdUj1bSmYr58aMvI6gqwDD8qvnje1zBUqrh7Tldu9jsA2e1G8Z714nqn7Yfwo0 + TxFqWh3PiSU6pp0rQXdvBpl3KYnBwQSkRHWup8DfHjwN8SoL2fw34jttUWyUtcxIrpLDgZO6 + NlDD8qlVIN2ubTwmIhFSlTaXoz0PcKNwryWP9qL4bzeBr7xgniSM+HbK6NlPefZ5sJMMZQrs + 3dxzjHNdPZfFnwtqHgRvGlvq0Vx4bS3a4N/ErOoRepwBnj0xmmpxbtcl4etFXlBrpt1Oz3+1 + G+vPIvjx4GfwFF41bxJZw+GJE8xdRnJjQjOBgMAST0xjNcXaftqfCi5eJ5NfurK0mIEd9e6T + dw2r56ETNEEx75pe0h3KjhMRO/LTenke77hQWAqlp2pWusafBe2dxHdWs6CSKeFgyOpGQQR1 + Brzbx9+0t4C+HGvNoeratLLrKoJGsNOsZ7ydFIyCyQoxUEc84qnJR1bMqdGrVnyQi2z1YMDQ + WArzr4Z/HrwV8W5LqHw1rK3V9a4+0WFxDJb3MGem+KRVYZ+lVfif+0X4A+Dup6bp/i/xFFo1 + 5qGfs0TQySlwCMk7FO0cjlsUueO9y1hq/P7PkfN26nqAOTS1R0zUYdUtYLq2kEtvNGJI3Xoy + nkH8jV6rOezTsyPFfPn7cmmX2s/s5+J7WwtZ7y5aNdkNtG0jv8w6KoJNfQ20UxoVbqM1lUh7 + WDhLZnTha7wteFeKu4u9j8QdI03xJfRWqa34U8SadqtmoS31my02YyKo6CRNvzD3616BY3/j + i0iGYv7ShxxLc6PeQSfiFj/lX6/CBB/CKPJT+6K+SxHDVDEP3pfek/zP1WHiJiIr/d197/yP + x31bxj4vsYt1v4d1jUrrBCpBo08dup9SXUs2Pwr17/gm1o3iOP4y+K9Q8QaVqdm1xpwPnX1r + JEHPmDgFgATX6UNaxsclQT7ihLaOM5A59a68vyDD5dPnpb+h5uacb1s0ws8LOikpdbs/Kf8A + 4KNeB/EOv/tAvc6ZoOpahbmxhUS2tnJImQoBGVBFfKx+F/jBTg+Fdbz6f2dN/wDE1/QF9nTd + u2jNO8pc5wPyrtq5bGrNy5hZdxtVy/Cww0aCairXuz+fv/hWHjH/AKFTW/8AwXTf/E07/hWX + jEx/8inrQHqNOm/+Jr+gIxKRjA/Km/Z0/ujHpioWVRT+I75eINaUXH6utfP/AIB8l/tEaDf3 + 37DM1ha2F3PqA0+zBtI4mMmRJGSNnXgZr8sz8LfGWN3/AAiet4P/AFDpv/ia/oAFugGMcUvk + rjAAA+ldOIwEcQ03LY8HJ+K6mUQqQjSUuZ31f/AP5/X+F/jGPG7wpra59dOm/wDiaevwr8aY + BXwlrjZ9NOm/+Jr+gDyl9B+VMa2jYg7Rkd8Vyf2TFP4j334hV+mHX3v/ACPx+/YY8AeKNF/a + R8N3l94d1WxtoxJvmubKWNFyp6sVwPzr1b/go7+z7428RfEu08Y6Fo11rmkzWaW0osUMrwSI + WPKDnBDdcdq/SsWyKcgYPTOKd5S4wckV1rAx9i6Lelz52fFmIlmMcxjTSaVmu6PwCb4SeN1B + J8Ia6B6nTpv/AImoz8LfGUZ+bwlrY+unTf8AxNf0A+SmQcdKXyUP8IP4Vyf2TD+Y+ij4hYhb + 4dfe/wDI/ABfhZ40cfL4P1w/TTpv/ia9q8CfGb9pTwPomn+HfDa+IbLTrZfKtrZdARtoyTjL + QknknrX7KeQn90flSC3jH8IrWGWum7wqNHHieNnjFavhYyXn/wAMfF/jD4cfFv41fsYNpfil + Wu/Hs8wvPImEUMjoCdqbVCqDtPSvzf1H4LeP9KvJbe58F69FcRsVZP7Plbke4BBr97zbKTkE + g+1OEKjtWtfL4V9XI8vK+La+VqcadGLjJ3S1VvQ/AP8A4VL43YFh4P13A6n+zpv/AImmj4Te + Njux4R1wgdcadN/8TX7/AAgRQcDrS+WvpXN/ZMVtM9//AIiDX/6B197PxS+Bnj34z/s+XWpz + eEPC2opJqCqs4vNGmlHHPHyjFevD9tv9qDdj/hF2Pt/wjstfqf5a+go8pfSt4YGcFyxqNI8b + EcUYbFVHVrYGEpPq27/kfliP22v2n36eFj+Hh2Wnj9tX9qHO3/hFXJP/AFLstfqX5S+go8lM + /dH5Vf1Sr/z9Zzf6w4H/AKF9P8T8utM/bC/ar1e9js7Twq0txM2yNW8Pugz7lsAfjXv/AO2x + 4f8AFvin9keG3vrF9T8TbrWW7h062LFn3rv2ouSAOa+xTbo2cqMGm/ZUx6nGM+1arCvlcZzb + uefWzmlKvSrUMNGHI76X1PwIb4Q+OVy3/CH69gDOf7Ol/wDiajHwl8bnn/hENd/8Fs3/AMTX + 7+C3QDG3j0pwiRRgKAPpXB/ZMf5j7FeIWI/6B197PwCT4R+OG4Hg/XSTx/yDZv8A4mv0I/4J + c+D9d8L6X46XWtHvdJ86W18r7bbtEXwJc43AZ7V96+WvpSiNR0GK6MPl8aE1NM8fNuMK2a4W + WGlSUb21u+hynxM8NzeLfAHiLRLdgk2oadPaxuegZ42UE/nX4m+MP2cfiX4R12602/8ABmrv + NExAktbR5YnGeqsoINfu2YVbPJ596RbZFOQBn1xXRicJHE25meRkfENfIuaNKCkpdz8Cf+FM + ePv+hL1//wAFs3/xNA+C/j7/AKEvX/8AwWzf/E1+/Hlj0oEYHYflXn/2TD+Y+u/4iDif+fEf + vZ+Gfw00L4qfCfxlYeJ9C8Ga0NSsmLRfaNKlZMkEcjHPWuh+NviD4y/H/WbHU/FXg7UnuLKJ + oYvsejTRLhiCc8HPQV+1RgX0H5UCFMYIB/CtP7N05ed27HG+NZOusS8LHnSte7vbsfgQfgz4 + 9JyPBWv4P/UNm/8AiaP+FMePv+hK1/8A8Fs3/wATX78eWP8AIo8sf5FZ/wBkw/mOxeIOJX/L + iP3s/AyD4KfECdhHH4J8QNITwP7Nm/8Aia/TL9gP4P8Ain4afBLXLbxPpM2kX+rXUk8FtcMN + +wxhQWUfd5B4NfYHkqWBI5pPIXI6nHFdOHy+FCV73PCzfi7E5tQ+rumoq6el+h+G/wAVf2eP + iPoPxA163uPBusTFryaWOS2tHmjeNnZlZXQFSCCO+fauQHwZ8fE8eC9f/wDBbN/8TX78eSoP + el8seg/KsJZXCUm+Y9ijx9iqUFB0Iu3mz8B/+FMePh/zJev/APgtm/8Aia6DwR4E+JvgbxXp + PiHTfBOuPfabcpdQrPpczIXU5GRtGa/djyl9B+VHlL6CksqjF3U3cdTj6vVi4Tw8Wn0uz8w0 + /bS/agRAq+BCAowD/wAI/PSf8NqftRucL4HYY/6l6ev088lR2p3lr6Cur6pVtb2rPn/7ewX/ + AEAU/wAT8wv+Gzv2pi20eCHB/wCxemP9akj/AGwf2qbhwg8DuzHgY8PTD+tfpz5a5+6KYbdC + +7GD7Gj6pVX/AC9Ynn2DtpgKf4nw18bT8U/il+xNfnxh4alj8Xz3cDDT7G2JkMQmjIPlqWIO + Mk/Svz1/4UX8Ren/AAg/iD6f2bN/8TX73/Z1J55oW3Vfc+tTWwEa1nKR05ZxZVyqEqdGjG0n + frp5H4IL8C/iM4JHgbxAQP8AqHS//E0o+BPxGBGfA3iEe/8AZsv/AMTX74eUBQ0SsCCMg1z/ + ANkw/mPb/wCIg4v/AJ8R+9nwD/wTF8A+IvCNv43OvaFqOk+fJB5Rv7d4d+A+cBgM18w/tIfs + zfEzSfi34mu18IalqGn3149xbXWnwmeN1Y8fcyQfqBX7OCJQMDOKb9nXPf8AOuupgoTpqnfb + qfO4binEYbH1MdGCvPRrWx+CY+AnxIYkDwJ4gz/2Dpf/AImlb4B/ElcZ8B+IP/BdL/8AE1+9 + vlijyx/kVyf2TD+Y+h/4iDi1tQj97Pwh0j4NfFXw/qdpqNh4K8Q299ayCWGUaXIxRgcg4KkH + 8RXefEq//aO+L2lQ6Z4w0rxPrNlE/mJDJogjCt6/u4l/Wv2i8oUCMdyT9atZaoq0Zs5J8bVK + tRVqmFg5LZu7PwVPwB+JbdPAniEj/sHS/wCFA/Z9+Jhz/wAUH4g4/wCodL/hX71+WvpSGNT2 + qP7Kh/Mdf/EQcX/z5j97PwVX9n74l43f8IH4gx/2Dpf8K+z/APgmX8NfFfgn4ieJrjxB4c1L + RYJdOCRyX1q8QZvMU4BI5OK/RowqR0potkHOOfWt6OXQoz50zysz4yxOZ4aWFnSSUuqEKbyS + RyBivj3wVoGoW/8AwUD8a376ZdDTZtMhEd2YGWFiIkGAxGCcg9K+xwgFR/ZUznHNejUp89vI + +Lw2KeGjONr8ysfF37T/AIO8Sa9+1v8ADG48PG501xYvH/a8VgLmO2O9z8wb5e/c96w/2ivh + r420/wCIXwwm8W65dfErw+dWAaxt9HWyFm424lZ4c5AJ6NgcV93fZoyQSORxSC2UEn1rKVBS + bd9z06WcVKPs7RXuRa21d/PofDnx/j8cfHX43aF4Y8K+FpdU8K+D5I9Su01GY2NreXCkBVEj + IwYDPRQcgn0qP4PL4+/Z+/aEu7PX/CDaV4S8ayl44dJuGvrazuScKS4jXYCTjkADOe1fc/2V + BnAxn0o+zLzgkH1FR9WSfMnqV/bL9j9WVJclrdb+vbfyPg74MeN7f4MfH/4wah4o0bX47XU9 + Vla0mtNGurlJP3h5BjjYY961NB8Pa98Wv2l9b+JmkeHdS8N+FbbRZbJrrULdraTUpCnB8psN + gdMkdq+3lt1UY68Y5pGtlZs81fsNEnLREyzZXc407Sas3dvRdkfmR4c8A+Ih+xb4rsJdC1E3 + 0nioyi0azkEkkfy5cIVyV9wD0r0z4kfCLxP8HfhZe6j4A0241Xw14j0dYNY8KxA77a4eIAXU + AIJHJw6ADsfp91/Zk96DaofWpWGS69LGrz2rKam4K3NzNdHtofm/qPwX8Xav+zx8F9Vh8OXu + sWvhi8W71Tw48ZjnkjDElhGxG4gZGMZ+avWPiv8AHU/Ebwx9g+HjayusravFJ4YuvBklws7B + eEkknVI0UdM7jX2QLWP0yfX1oNpEQRtHNCw/KrJkzzj2s1OpTu4tta6au9mranjf7K2pa3q3 + wP8AD0+v2Eek6p5RWW0hshaLHg8KIgAFwPQV4R8XdE0nwj8ctc194fHHw0vr2GMHxPoNr/ad + nqAVQAGhWOQoR05A5zX255Cgg5NH2cZOST9TWs6fNBRucNHHujiJ1lG3N0T/AOHX4HxN8FPG + /jf/AIWtqd9JHceOfCUGmtJN4sv/AAsNJvhIOVgXChpuOfu964TSfhh8UPjf4q8ceO9U8BWe + oWviK3fSNOt9c1FrOaztlbIZYzC3JYBucEEe9fom1qjNnGD6igWyjuc+vrWTw97JvY74506U + 3Uo0kpaL7vS2/wAj5o/Yl8Q+MdM8O6l8PfHOlX1pq3hqTyre8mjZobi3z8oWXADlfXqc+1fT + tRpCqNuGc4xUldFOPJFRueLiq6xNaVZRUb9FsFFFFaHKFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFF + ABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQAU + UUUAFFFFABRRRQAUUUUAFFFFABRRRQAUUUUAFFFFABRRRQB//9k= + + + Desk<records[0].report_linkage_desk or ''>B/L Date<records[0].report_linkage_bl_date or ''>Book<records[0].report_linkage_book or ''>Trading Unit<records[0].report_linkage_trading_unit or ''>Strategy<records[0].report_linkage_strategy or ''>Finance user<records[0].report_linkage_finance_user or ''>6- Financial details ( USD )GroupCost TypeCounterpartSourceUnit PriceQuantityEstimatedValidated<records[0].report_linkage_detail_groups or ''><records[0].report_linkage_detail_cost_types or ''><records[0].report_linkage_detail_counterparts or ''><records[0].report_linkage_detail_sources or ''><records[0].report_linkage_detail_unit_prices or ''><records[0].report_linkage_detail_quantities or ''><records[0].report_linkage_detail_estimated or ''><records[0].report_linkage_detail_validated or ''>OliverGyslerDigitally signed by Oliver GyslerDate: 2026.03.27 10:02:25 +01'00'J?r?mieCOLLOTDigitally signed by J?r?mie COLLOTDate: 2026.03.27 10:05:10 +01'00'Stephane MonnardDigitally signed by Stephane MonnardDate: 2026.03.27 10:54:44 +01'00'SteveZaccariniDigitally signed by Steve ZaccariniDate: 2026.03.30 15:49:42 +02'00' + + + \ No newline at end of file