badmark/frankfurter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
frankfurter/spec/vcr_cassettes/bi.yml
BadMark d0a43e357a
Some checks failed
CI/CD Pipeline / test (push) Has been cancelled
Details
CI/CD Pipeline / publish (push) Has been cancelled
Details
CI/CD Pipeline / release (push) Has been cancelled
Details
up
2026-05-21 01:38:14 -06:00

284 lines
1 MiB
Raw Permalink Blame History

---
http_interactions:
- request:
method: get
uri: https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
body:
encoding: US-ASCII
string: ''
headers:
Accept-Encoding:
- gzip;q=1.0,deflate;q=0.6,identity;q=0.3
Accept:
- "*/*"
User-Agent:
- Mozilla/5.0 (compatible; Frankfurter/2.0; +https://frankfurter.dev)
Host:
- www.bi.go.id
response:
status:
code: 200
message: OK
headers:
Cache-Control:
- private, max-age=0
Content-Type:
- text/html; charset=utf-8
Expires:
- Sat, 21 Mar 2026 00:49:24 GMT
Last-Modified:
- Sun, 05 Apr 2026 00:49:24 GMT
Vary:
- Accept-Encoding
X-Sharepointhealthscore:
- ''
Sprequestguid:
- a8d406a2-bc40-c0de-605c-defc706448f3
Request-Id:
- a8d406a2-bc40-c0de-605c-defc706448f3
Strict-Transport-Security:
- max-age=31536000; includeSubDomains; preload
X-Frame-Options:
- SAMEORIGIN
Content-Security-Policy:
- frame-ancestors 'self' teams.microsoft.com *.teams.microsoft.com *.skype.com
*.teams.microsoft.us local.teams.office.com *.powerapps.com *.yammer.com *.officeapps.live.com
*.office.com *.stream.azure-test.net *.microsoftstream.com *.dynamics.com
*.microsoft.com onedrive.live.com *.onedrive.live.com;
Microsoftsharepointteamservices:
- ''
X-Ms-Invokeapp:
- 1; RequireReadOnly
X-Xss-Protection:
- 1; mode=block
Date:
- Sun, 05 Apr 2026 00:49:24 GMT
Connection:
- Keep-Alive
Transfer-Encoding:
- chunked
body:
encoding: ASCII-8BIT
string: !binary |-

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html dir="ltr" lang="en-US">

    <head><meta name="keywords" content="Bank Indonesia, BI, Rupiah, kurs BI, kurs tengah BI, kalkulator kurs, inflasi, kurs transaksi, JISDOR, PINTAR BI, BI Fast, bank sentral, QRIS, uang Rupiah, SIMODIS, Sobat Rupiah, Cadangan Devisa, Gubernur Bank Indonesia, uang, bank, CBP, Cinta Bangga Rupiah, Cinta Rupiah, JIBOR, IndONIA" /><meta name="robots" content="index, follow" /><meta name="Author" content="Bank Indonesia" /><meta name="GENERATOR" content="Microsoft SharePoint" /><meta http-equiv="Content-type" content="text/html; charset=utf-8" /><meta http-equiv="X-UA-Compatible" content="IE=11; IE=10" /><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" /><meta name="viewport" content="width=device-width, initial-scale=1" /><meta http-equiv="X-UA-Compatible" content="IE=10"/><script type='text/javascript'>var _browserisFlight = true;</script><meta http-equiv="Expires" content="0" /><meta name="msapplication-TileImage" content="/_layouts/15/images/SharePointMetroAppTile.png" /><meta name="msapplication-TileColor" content="#0072C6" /><title>
	Foreign Exchange Rates
</title><link rel="shortcut icon" href="/favicon.png" type="image/vnd.microsoft.icon" id="favicon" /><link id="CssLink-63879aaa5d6a4c7cacbaada0f90eb2db" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/Themable/corev15.css?rev=UP2nlZLed9gOy%2BMP38oz0A%3D%3DTAG0"/>
<link id="CssLink-228ac5cb6d574bf799732f0b55deea5a" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/SuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ%3D%3DTAG0"/>
<style id="SPThemeHideForms" type="text/css">body {opacity:0 !important}</style><script type="text/javascript">// <![CDATA[ 

var g_SPOffSwitches={};
// ]]>
</script>
<script type="text/javascript" src="/_layouts/15/1033/initstrings.js?rev=94%2F8Pzbtowd6g2cd%2FsOoIg%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/init.js?rev=eqiUN2EN5Xn%2F2YyfuJQDtA%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/theming.js?rev=SuLUbbwTXcxFWOWLFUsOkw%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=sa1PqOHf5j2-6ssMNtdqimFp8nte-oIkdwJ1eOlUHUtOp0vjD2ImoMOMcCHq1bp0xvsD4Z3e86bZnUB2GeqPAZ5tXV4_nTT2jYY2_isi_31MH0efbPRKDe01qwHMlhjCqLYGR-Z4R_iUcMTmpehd2gzVBx3-AFsGfQMAjUkrTW2nxC2ljpAK-Lzwgqii3l2k0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=KvY94j2NghrBo6dT9b1k169bI6meVaRfhNlBBvNxLwKSSwkjBP3MBZHoPl9f9rloh9rNbh8ojtrmFM5d9fu_pn052DtTQVrukBbiH42jb3KYVgH6ktRQ-N9tLXZaVfnOiMT6hM1r-FY7atAipPNrcmQHuNtbk-ilaUaQ4QiBaTJCYyFOuHhrtEDu9ZQfUWGH0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/suitenav.js?rev=VM%2FdyE40A0OgsmOI%2BIKIqQ%3D%3DTAG0"></script>
<script type="text/javascript">RegisterSod("require.js", "\u002f_layouts\u002f15\u002frequire.js?rev=bv3fWJhk0uFGpVwBxnZKNQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("strings.js", "\u002f_layouts\u002f15\u002f1033\u002fstrings.js?rev=qTd5Iu3wkfWjQOhKADG18A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.res.resx", "\u002f_layouts\u002f15\u002f1033\u002fsp.res.js?rev=FnWveYddVjlqQYS2ZBOOzA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.runtime.js", "\u002f_layouts\u002f15\u002fsp.runtime.js?rev=ieBn\u00252FPr8FuV9095CsVXFdw\u00253D\u00253DTAG0");RegisterSodDep("sp.runtime.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.js", "\u002f_layouts\u002f15\u002fsp.js?rev=Os4G339\u00252BEf5vdNuG9dSWtw\u00253D\u00253DTAG0");RegisterSodDep("sp.js", "sp.runtime.js");RegisterSodDep("sp.js", "sp.ui.dialog.js");RegisterSodDep("sp.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.init.js", "\u002f_layouts\u002f15\u002fsp.init.js?rev=GcX1\u00252BQkwU9iewwepsza2Kw\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.dialog.js", "\u002f_layouts\u002f15\u002fsp.ui.dialog.js?rev=d7y1SiSVwqLJzuIiMAukpg\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.dialog.js", "sp.init.js");RegisterSodDep("sp.ui.dialog.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("core.js", "\u002f_layouts\u002f15\u002fcore.js?rev=OuK8lknoOD37VvjQyOsHrw\u00253D\u00253DTAG0");RegisterSodDep("core.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("menu.js", "\u002f_layouts\u002f15\u002fmenu.js?rev=WMbI5XqdDKTzX20rarEQsQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("mQuery.js", "\u002f_layouts\u002f15\u002fmquery.js?rev=wdHoEUjBno2g0ULGFwFjAg\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("callout.js", "\u002f_layouts\u002f15\u002fcallout.js?rev=yFnKkBSYasfA2rW6krdVFQ\u00253D\u00253DTAG0");RegisterSodDep("callout.js", "strings.js");RegisterSodDep("callout.js", "mQuery.js");RegisterSodDep("callout.js", "core.js");</script>
<script type="text/javascript">RegisterSod("sp.core.js", "\u002f_layouts\u002f15\u002fsp.core.js?rev=LSKJVyPWTBdDAU6EL2A6kw\u00253D\u00253DTAG0");RegisterSodDep("sp.core.js", "strings.js");RegisterSodDep("sp.core.js", "sp.init.js");RegisterSodDep("sp.core.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clienttemplates.js", "\u002f_layouts\u002f15\u002fclienttemplates.js?rev=oZO8iLnMIX278DJXZp9S4A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sharing.js", "\u002f_layouts\u002f15\u002fsharing.js?rev=z7dWWrP\u00252FqzzxvtLQKR08Ww\u00253D\u00253DTAG0");RegisterSodDep("sharing.js", "strings.js");RegisterSodDep("sharing.js", "mQuery.js");RegisterSodDep("sharing.js", "clienttemplates.js");RegisterSodDep("sharing.js", "core.js");</script>
<script type="text/javascript">RegisterSod("suitelinks.js", "\u002f_layouts\u002f15\u002fsuitelinks.js?rev=hNe7S\u00252B4EVV83bzPy9U\u00252BEvQ\u00253D\u00253DTAG0");RegisterSodDep("suitelinks.js", "strings.js");RegisterSodDep("suitelinks.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clientrenderer.js", "\u002f_layouts\u002f15\u002fclientrenderer.js?rev=Evu1eqGPwP\u00252FeN5ZuIpaSTQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("srch.resources.resx", "\u002f_layouts\u002f15\u002f1033\u002fsrch.resources.js?rev=vZPcBJM2l80oZNzRUCRQ4g\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("search.clientcontrols.js", "\u002f_layouts\u002f15\u002fsearch.clientcontrols.js?rev=xgTuNRzK\u00252B28qr6bjGThpIw\u00253D\u00253DTAG0");RegisterSodDep("search.clientcontrols.js", "sp.init.js");RegisterSodDep("search.clientcontrols.js", "clientrenderer.js");RegisterSodDep("search.clientcontrols.js", "srch.resources.resx");</script>
<script type="text/javascript">RegisterSod("sp.search.js", "\u002f_layouts\u002f15\u002fsp.search.js?rev=eMyDf7ZGV6rTjB2sDSdovA\u00253D\u00253DTAG0");RegisterSodDep("sp.search.js", "sp.init.js");RegisterSodDep("sp.search.js", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("ajaxtoolkit.js", "\u002f_layouts\u002f15\u002fajaxtoolkit.js?rev=I3jVxnVkBqeUZ\u00252FWA\u00252BgwTLg\u00253D\u00253DTAG0");RegisterSodDep("ajaxtoolkit.js", "search.clientcontrols.js");</script>
<script type="text/javascript">RegisterSod("userprofile", "\u002f_layouts\u002f15\u002fsp.userprofiles.js?rev=J0M1pzLkfDXcJflabMvTYA\u00253D\u00253DTAG0");RegisterSodDep("userprofile", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("followingcommon.js", "\u002f_layouts\u002f15\u002ffollowingcommon.js?rev=MgAestdI8p64n4UsP1Xeug\u00253D\u00253DTAG0");RegisterSodDep("followingcommon.js", "strings.js");RegisterSodDep("followingcommon.js", "sp.js");RegisterSodDep("followingcommon.js", "userprofile");RegisterSodDep("followingcommon.js", "core.js");RegisterSodDep("followingcommon.js", "mQuery.js");</script>
<script type="text/javascript">RegisterSod("profilebrowserscriptres.resx", "\u002f_layouts\u002f15\u002f1033\u002fprofilebrowserscriptres.js?rev=qwf69WaVc1mYlJLXqmZmVA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.mysitecommon.js", "\u002f_layouts\u002f15\u002fsp.ui.mysitecommon.js?rev=5nRJiZWvHP3AB7VS14cjuw\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.mysitecommon.js", "sp.init.js");RegisterSodDep("sp.ui.mysitecommon.js", "sp.runtime.js");RegisterSodDep("sp.ui.mysitecommon.js", "userprofile");RegisterSodDep("sp.ui.mysitecommon.js", "profilebrowserscriptres.resx");</script>
<script type="text/javascript">RegisterSod("browserScript", "\u002f_layouts\u002f15\u002fnon_ie.js?rev=KT6LY54Wt0vnHyVV6VVzWw\u00253D\u00253DTAG0");RegisterSodDep("browserScript", "strings.js");</script>
<script type="text/javascript">RegisterSod("inplview", "\u002f_layouts\u002f15\u002finplview.js?rev=ecdG8BqIlGbfoftF0\u00252FIAZA\u00253D\u00253DTAG0");RegisterSodDep("inplview", "strings.js");RegisterSodDep("inplview", "core.js");RegisterSodDep("inplview", "clienttemplates.js");RegisterSodDep("inplview", "sp.js");</script>
<script type="text/javascript">RegisterSod("offline.js", "\u002f_layouts\u002f15\u002foffline.js?rev=D5D\u00252FDMDxW0p0dIDUqgv0Zw\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("cui.js", "\u002f_layouts\u002f15\u002fcui.js?rev=ejf8nksDjeL2s1mvUvw77w\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("ribbon", "\u002f_layouts\u002f15\u002fsp.ribbon.js?rev=wPDmc1LZubpR2Fgk01M8qw\u00253D\u00253DTAG0");RegisterSodDep("ribbon", "strings.js");RegisterSodDep("ribbon", "core.js");RegisterSodDep("ribbon", "sp.core.js");RegisterSodDep("ribbon", "sp.js");RegisterSodDep("ribbon", "cui.js");RegisterSodDep("ribbon", "sp.res.resx");RegisterSodDep("ribbon", "sp.runtime.js");RegisterSodDep("ribbon", "inplview");</script>
<script type="text/javascript">RegisterSod("WPAdderClass", "\u002f_layouts\u002f15\u002fwpadder.js?rev=cLi8ZAp2DVY4x\u00252BMDFIRWvQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("dragdrop.js", "\u002f_layouts\u002f15\u002fdragdrop.js?rev=h\u00252F2Jd5ursJLUu88iNs\u00252FM2A\u00253D\u00253DTAG0");RegisterSodDep("dragdrop.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("quicklaunch.js", "\u002f_layouts\u002f15\u002fquicklaunch.js?rev=yuA4NhRQlmo9X6TJsaidUg\u00253D\u00253DTAG0");RegisterSodDep("quicklaunch.js", "strings.js");RegisterSodDep("quicklaunch.js", "dragdrop.js");</script>
<link type="text/xml" rel="alternate" href="/en/statistik/informasi-kurs/transaksi-bi/_vti_bin/spsdisco.aspx" /><link href="/Style Library/biweb/css/bootstrap4.min.css" rel="stylesheet" />
        
        <!-- Update Font Family 1 Februari 2024 -->
        <link rel="preconnect" href="https://fonts.googleapis.com" /><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin="" />
		<!-- Update Font Family 2 Februari 2026 -->
		<link href="https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,400;1,300&amp;display=swap" integrity="sha512-e2mrHtfsfL/rkAg+Q3rQpEIkWMdGU36OfDwUIJz4nyq7/pevf44ZAXwTt1/mr8mLsnPJbslCx85k+qRTTZIDjA==" crossorigin="anonymous" rel="stylesheet" /><link href="https://fonts.googleapis.com/css2?family=PT+Sans&amp;display=swap" integrity="sha512-pZRQvRtRsHut00kYTpiGGYlYLiGNEP+/efrLNNzhAxe/uT3UiRpLYUEqXW1+zwVvWAxWrVyYxrDT6tDShkc2lA==" crossorigin="anonymous" rel="stylesheet" /><link href="/Style Library/biweb/css/maincss.min.css" rel="stylesheet" />
        
        <!--<script src="/Style Library/biweb/js/jquery-3.4.1.min.js" type="text/javascript"></script>-->
        <script src="/Style Library/biweb/js/jquery-3.5.1.min.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/bootstrap4.min.js" type="text/javascript"></script>        
        <script src="/Style Library/biweb/js/jquery.scollingTabs.min.js" type="text/javascript"></script>       
        <script src="/Style Library/biweb/js/mainjs.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/jquery.dataTables.min.js" type="text/javascript"></script>
        <link href="/Style Library/biweb/css/jquery.dataTables.min.css" rel="stylesheet" />
                
		<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
		new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
		j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
		'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
		})(window,document,'script','dataLayer','GTM-TX6N9KL');</script>
		<script>
			  $(document).ready(function() {
			    if (window.location.href.indexOf("/en/") > -1) {
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia has one single objective of achieving and maintaining stability of the Rupiah value." />' );
							    }
			    else{
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia adalah Bank Sentral Republik Indonesia dengan Satu Tujuan Tunggal yaitu Mencapai dan Memelihara Kestabilan Nilai Rupiah." />' );
							    }
			  });
		</script>
		<script  type="text/javascript">
			$(document).ready(function(){
				setTimeout(function () {
					$('#ctl00_onetidProjectPropertyTitleGraphic').attr("title", "Bank Indonesia")
			        if (window.location.href.indexOf("/en/") > -1) {
			           $('#ctl00_onetidProjectPropertyTitleGraphic').attr('href', '/en/');
			        }
			    }, 500); 	
			    
				$('#tablecustom').DataTable();		
			});
		</script>
		
        
            
	<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
    <script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>
    <script type="text/javascript">
        $(window).ready(function () {
            $('#selectPeriod').change(function () {
                $('.datepicker-period').hide();
                $('#' + $(this).val()).show();
            });



            var date_input_harian = $('.input-daterange-harian input');
            var options = {
                format: 'mm/dd/yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto"
            };
            date_input_harian.datepicker(options);
        });
    </script>

            <link rel="canonical" href="https://www.bi.go.id:443/en/statistik/informasi-kurs/transaksi-bi/default.aspx" />
            
        </head>

    <body>
	<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TX6N9KL"
	height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
      <div id="imgPrefetch" style="display:none">
<img src="/favicon.png?rev=43" />
<img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" />
<img src="/_layouts/15/images/spcommon.png?rev=43" />
<img src="/SiteAssets/logo-bi@2x.png?rev=43" />
</div>

        <noscript><div class='noindex'>You may be trying to access this site from a secured browser on the server. Please enable scripts and reload this page.</div></noscript>
        
        <form method="post" action="./default.aspx" onsubmit="javascript:return WebForm_OnSubmit();" id="aspnetForm">
<div class="aspNetHidden">
<input type="hidden" name="_wpcmWpid" id="_wpcmWpid" value="" />
<input type="hidden" name="wpcmVal" id="wpcmVal" value="" />
<input type="hidden" name="MSOWebPartPage_PostbackSource" id="MSOWebPartPage_PostbackSource" value="" />
<input type="hidden" name="MSOTlPn_SelectedWpId" id="MSOTlPn_SelectedWpId" value="" />
<input type="hidden" name="MSOTlPn_View" id="MSOTlPn_View" value="0" />
<input type="hidden" name="MSOTlPn_ShowSettings" id="MSOTlPn_ShowSettings" value="False" />
<input type="hidden" name="MSOGallery_SelectedLibrary" id="MSOGallery_SelectedLibrary" value="" />
<input type="hidden" name="MSOGallery_FilterString" id="MSOGallery_FilterString" value="" />
<input type="hidden" name="MSOTlPn_Button" id="MSOTlPn_Button" value="none" />
<input type="hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
<input type="hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
<input type="hidden" name="__REQUESTDIGEST" id="__REQUESTDIGEST" value="0x41D00311222AA5C7BCCDE7DFEA5D3ED0FA83851A66FFBB06DF250B456DB0D3DEACCB775F47795FC4F63284D1626209AAD854D6F5053BDE3EC332F5FFFCE9D770,05 Apr 2026 00:49:24 -0000" />
<input type="hidden" name="MSOSPWebPartManager_DisplayModeName" id="MSOSPWebPartManager_DisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_ExitingDesignMode" id="MSOSPWebPartManager_ExitingDesignMode" value="false" />
<input type="hidden" name="MSOWebPartPage_Shared" id="MSOWebPartPage_Shared" value="" />
<input type="hidden" name="MSOLayout_LayoutChanges" id="MSOLayout_LayoutChanges" value="" />
<input type="hidden" name="MSOLayout_InDesignMode" id="MSOLayout_InDesignMode" value="" />
<input type="hidden" name="_wpSelected" id="_wpSelected" value="" />
<input type="hidden" name="_wzSelected" id="_wzSelected" value="" />
<input type="hidden" name="MSOSPWebPartManager_OldDisplayModeName" id="MSOSPWebPartManager_OldDisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_StartWebPartEditingName" id="MSOSPWebPartManager_StartWebPartEditingName" value="false" />
<input type="hidden" name="MSOSPWebPartManager_EndWebPartEditing" id="MSOSPWebPartManager_EndWebPartEditing" value="false" />
<input type="hidden" name="_maintainWorkspaceScrollPosition" id="_maintainWorkspaceScrollPosition" value="0" />
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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" />
</div>

<script type="text/javascript">
//<![CDATA[
var theForm = document.forms['aspnetForm'];
if (!theForm) {
    theForm = document.aspnetForm;
}
function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
        theForm.__EVENTTARGET.value = eventTarget;
        theForm.__EVENTARGUMENT.value = eventArgument;
        theForm.submit();
    }
}
//]]>
</script>


<script src="/WebResource.axd?d=HRMEYubZPUzVts77E_7Ik1yT-44y5_IDixxutdmFieYdhwteoLUd0gvCyyYvKy3z7ple1Au9_czBVt-tA8fqYJ7_DchPiphcRPRL6mZmE2M1&amp;t=638259656865233147" type="text/javascript"></script>


<script type="text/javascript">
//<![CDATA[
var MSOWebPartPageFormName = 'aspnetForm';
var g_presenceEnabled = true;
var g_wsaEnabled = false;

var g_correlationId = 'a8d406a2-bc40-c0de-605c-defc706448f3';
var g_wsaQoSEnabled = false;
var g_wsaQoSDataPoints = [];
var g_wsaRUMEnabled = false;
var g_wsaLCID = 1033;
var g_wsaListTemplateId = null;
var g_wsaSiteTemplateId = 'CMSPUBLISHING#0';
var _spPageContextInfo={"webServerRelativeUrl":"/en/statistik/informasi-kurs/transaksi-bi","webAbsoluteUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","viewId":"","listId":"","listPermsMask":null,"listUrl":"","listTitle":null,"listBaseTemplate":-1,"viewOnlyExperienceEnabled":false,"blockDownloadsExperienceEnabled":false,"idleSessionSignOutEnabled":false,"cdnPrefix":"","siteAbsoluteUrl":"https://www.bi.go.id","siteId":"{e671e14c-2777-404f-9b86-2f3b332aa0f1}","showNGSCDialogForSyncOnTS":false,"supportPoundStorePath":true,"supportPercentStorePath":true,"siteSubscriptionId":null,"CustomMarkupInCalculatedFieldDisabled":true,"AllowCustomMarkupInCalculatedField":false,"isSPO":false,"farmLabel":null,"serverRequestPath":"/en/statistik/informasi-kurs/transaksi-bi/default.aspx","layoutsUrl":"_layouts/15","webId":"{18d3b9c9-56e5-44c2-9518-566e5ed25d9a}","webTitle":"Foreign Exchange Rates","webTemplate":"39","webTemplateConfiguration":"CMSPUBLISHING#0","webDescription":"","tenantAppVersion":"0","isAppWeb":false,"webLogoUrl":"/SiteAssets/logo-bi@2x.png","webLanguage":1033,"currentLanguage":1033,"currentUICultureName":"en-US","currentCultureName":"en-US","currentCultureLCID":1033,"env":null,"nid":0,"fid":0,"serverTime":"2026-04-05T00:49:24.5535403Z","siteClientTag":"2144$$16.0.10417.20037","crossDomainPhotosEnabled":false,"openInClient":false,"Has2019Era":true,"webUIVersion":15,"webPermMasks":{"High":16,"Low":196673},"pageListId":null,"pageItemId":-1,"pagePermsMask":null,"pagePersonalizationScope":1,"userEmail":"","userId":0,"userLoginName":null,"userDisplayName":null,"isAnonymousUser":true,"isAnonymousGuestUser":false,"isEmailAuthenticationGuestUser":false,"isExternalGuestUser":false,"systemUserKey":null,"alertsEnabled":true,"siteServerRelativeUrl":"/","allowSilverlightPrompt":"True","themeCacheToken":"/en/statistik/informasi-kurs/transaksi-bi::9:","themedCssFolderUrl":null,"themedImageFileNames":null,"modernThemingEnabled":true,"isSiteAdmin":false,"ExpFeatures":[480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"killSwitches":{},"InternalValidAuthorities":["www.bi.go.id","web.bi.go.id","dc1biwebapp21","dc1biwebapp22"],"CorrelationId":"a8d406a2-bc40-c0de-605c-defc706448f3","hasManageWebPermissions":false,"isNoScriptEnabled":false,"groupId":null,"groupHasHomepage":true,"groupHasQuickLaunchConversationsLink":false,"departmentId":null,"hubSiteId":null,"hasPendingWebTemplateExtension":false,"isHubSite":false,"isWebWelcomePage":true,"siteClassification":"","hideSyncButtonOnODB":false,"showNGSCDialogForSyncOnODB":false,"sitePagesEnabled":false,"sitePagesFeatureVersion":0,"DesignPackageId":"00000000-0000-0000-0000-000000000000","groupType":null,"groupColor":"#757575","siteColor":"#757575","headerEmphasis":0,"navigationInfo":null,"guestsEnabled":false,"MenuData":{"SignInUrl":"/en/statistik/informasi-kurs/transaksi-bi/_layouts/15/Authenticate.aspx?Source=%2Fen%2Fstatistik%2Finformasi%2Dkurs%2Ftransaksi%2Dbi%2Fdefault%2Easpx"},"RecycleBinItemCount":-1,"PublishingFeatureOn":true,"PreviewFeaturesEnabled":false,"disableAppViews":false,"disableFlows":false,"serverRedirectedUrl":null,"formDigestValue":"0x41D00311222AA5C7BCCDE7DFEA5D3ED0FA83851A66FFBB06DF250B456DB0D3DEACCB775F47795FC4F63284D1626209AAD854D6F5053BDE3EC332F5FFFCE9D770,05 Apr 2026 00:49:24 -0000","maximumFileSize":10240,"formDigestTimeoutSeconds":1800,"canUserCreateMicrosoftForm":false,"canUserCreateVisioDrawing":true,"readOnlyState":null,"isTenantDevSite":false,"preferUserTimeZone":false,"userTimeZoneData":null,"userTime24":false,"userFirstDayOfWeek":null,"webTimeZoneData":null,"webTime24":false,"webFirstDayOfWeek":null,"isSelfServiceSiteCreationEnabled":null,"alternateWebAppHost":"","aadTenantId":"","aadUserId":"","aadInstanceUrl":"","msGraphEndpointUrl":"https://","allowInfectedDownload":true};_spPageContextInfo.updateFormDigestPageLoaded=new Date();_spPageContextInfo.clientServerTimeDelta=new Date(_spPageContextInfo.serverTime)-new Date();if(typeof(define)=='function'){define('SPPageContextInfo',[],function(){return _spPageContextInfo;});}
function _spNavigateHierarchy(nodeDiv, dataSourceId, dataPath, url, listInContext, type) {

    CoreInvoke('ProcessDefaultNavigateHierarchy', nodeDiv, dataSourceId, dataPath, url, listInContext, type, document.forms.aspnetForm, "", "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002fdefault.aspx");

}
Flighting.ExpFeatures = [480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; (function()
{
    if(typeof(window.SP) == "undefined") window.SP = {};
    if(typeof(window.SP.YammerSwitch) == "undefined") window.SP.YammerSwitch = {};

    var ysObj = window.SP.YammerSwitch;
    ysObj.IsEnabled = false;
    ysObj.TargetYammerHostName = "www.yammer.com";
} )(); 
                var g_syncButtonUsePopup = true;
                //]]>
</script>

<script src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0" type="text/javascript"></script>
<script type="text/javascript">
//<![CDATA[
window.SPThemeUtils && SPThemeUtils.RegisterCssReferences([{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","Id":"CssLink-63879aaa5d6a4c7cacbaada0f90eb2db","ConditionalExpression":"","After":"","RevealToNonIE":"false"},{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","Id":"CssLink-228ac5cb6d574bf799732f0b55deea5a","ConditionalExpression":"","After":"","RevealToNonIE":"false"}]);
(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingDocument', function() { FollowingDocument(); });
        });
    })();(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingCallout', function() { FollowingCallout(); });
        });
    })();if (typeof(DeferWebFormInitCallback) == 'function') DeferWebFormInitCallback();function WebForm_OnSubmit() {
UpdateFormDigest('\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi', 1440000);
                    var workspaceElem = GetCachedElement("s4-workspace");
                    if (workspaceElem != null)
                    {
                        var scrollElem = GetCachedElement("_maintainWorkspaceScrollPosition");
                        if (scrollElem != null)
                        {
                            scrollElem.value = workspaceElem.scrollTop;
                        }
                    };
                if (typeof(_spFormOnSubmitWrapper) != 'undefined') {return _spFormOnSubmitWrapper();} else {return true;};
return true;
}
//]]>
</script>

<div class="aspNetHidden">

	<input type="hidden" name="__VIEWSTATEGENERATOR" id="__VIEWSTATEGENERATOR" value="FC2F6B36" />
	<input type="hidden" name="__SCROLLPOSITIONX" id="__SCROLLPOSITIONX" value="0" />
	<input type="hidden" name="__SCROLLPOSITIONY" id="__SCROLLPOSITIONY" value="0" />
	<input type="hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" value="/wEdAD5fPwGme843RfwEsPE1wynjMTZk9qLGncDjImqxppn1M6g+uGj1e5yNMxNarkQnNGQD/MwBujI58QztY2J/pZIxTKKThsEAjvBIzZ/azVBGeCseMKUY4FMnWOlaC4KYRMoqTRQkqOJA6zqRb4gMmtkgdx4UmW/7xcCfcKpKuvlz1/n+9iGjf1yV0RPm+5CWNSgnxDJcvG1lEz/rc5StNmfqzcjpUZgS1ZX3d1EsQPAXraQs8icFer7v4LiV0lOOQsYkRT4zcerzyfUynDciQYKEq2lCtoHbb2hEni9ouOVEsm39Q00Fw17NOnm+ozuW3CEwhfeQ2efgxu21Am0Xz33Z7DSMYxpJZKkihQpkRJvnuxXI27Xo9WTRzpFAqk0jLOR7yK6AgeEFi9+u9QgiqdWHV43515M7TTl7yog+eChWakHqaPzhK6mK7oXe3z1Y/mxT7soP/alJ1OhQFU9/cTZdT86o+G0OT8tvJC5ae6RpK5mq6v+czfdP+my7NXpJ10ozzPUicZg0tsnR9pSA4MkFxSitqMXfoolGmE6GUUl2K5sL2zr2gw1Ecm04IkZ0/dPm+6NSzvtshRKHOBYURGG/t4wdwgJiBPDE5CsYa/ofAebObvLUToLFFFUcOA/vYuryS2OE5Hg4CA3d6DOoZaQxpxRBNFeDpaMAVVOs0lpH/+wY0WwoRdjFfqfhAqGeqa3Br28GzRrOR7o1YGWZsPDbuJmlp7jH35v0dcMRth/kxf2ZxlBMrDRMuVgAWL2eRVf7X1zQvWcCOjjl0ejAC+pyie8n0dVD2DOZ/ex1pANqnjtB9wxs4OS9Z2gAVh9/hP7iwQfY7NduX5ufutrTu8GQmOksuxcPOlo8LRC6lfUzWCeiY25rN0dyS2kHWGOLy+Z2zV0tAij06DHnycDDr9GcLbfwn9ozbra6EC0Z1FbCnsHKXYsh7eVy0+7zWcYIt7bbaUpWxXuZ0NecmjLcFda1lIZJdkNplB3BstzJsVdUyQHi3jkf1KoJnHceAFWAIlz2mfjyVIv5Sjt2AxeSkjLTCPBwnjM99olJgNCsJpgKW0UC3to7K60JXTWSBxmhAuYViN93nQ6+48B8esRgMbNKylMv4+xB3WNEOQHn0exjr9ErOzhjTsya3v77e9g1MLjA7/1+el5DNfhcSXlZnxX8OM7SY2OjlPjYIcqlT/1kbIjHo1RoCoBOdKtPJM9iMrI2UtOvCGtbTiPlI23w2O6l4j3FR/n12JgTE84Akvn/29zOw3KyOSJGJryE51hrVCFHIyqh9avaCdFUenvHgQvjtqLtNevYkENLUS02AUyBYW9w+QBP9yykaI8C/hOJh+PSn8FIUpZGYp8gfv9oKqCm" />
</div>
            <script type="text/javascript">
//<![CDATA[
Sys.WebForms.PageRequestManager._initialize('ctl00$ScriptManager', 'aspnetForm', ['fctl00$WebPartAdderUpdatePanel',''], [], ['ctl00$WebPartAdder',''], 90, 'ctl00');
//]]>
</script>

            
            <script
                type="text/javascript"> var submitHook = function () { return false; }; theForm._spOldSubmit = theForm.submit; theForm.submit = function () { if (!submitHook()) { this._spOldSubmit(); } }; </script>
            <span id="DeltaSPWebPartManager">
            </span>
            <span id="DeltaDelegateControls">
                
                
            </span>
            <div id="TurnOnAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOnAcc"
                    title="Turn on more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(true);UpdateAccessibilityUI();document.getElementById('linkTurnOffAcc').focus();return
                false;">
                Turn on more accessible mode</a></div>
            <div id="TurnOffAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOffAcc"
                    title="Turn off more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(false);UpdateAccessibilityUI();document.getElementById('linkTurnOnAcc').focus();return
                false;">
                Turn off more accessible mode</a></div>
            <div class="s4-notdlg s4-skipribbonshortcut noindex">
                <a href="javascript:;"
                    title="Skip Ribbon Commands"
                onclick="document.getElementById('startNavigation').focus();" class="ms-accessible ms-acc-button"
                accesskey="
                Y">
                Skip Ribbon Commands</a></div>
            <div class="s4-notdlg noindex">
                <a href="javascript:;"
                    title="Skip to main content"
                onclick="document.getElementById('mainContent').focus();" class="ms-accessible ms-acc-button">
                Skip to main content</a></div>
            <div id="TurnOffAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOffAnimation"
                    title="Turn off Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn off Animations</a></div>
            <div id="TurnOnAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOnAnimation"
                    title="Turn on Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn on Animations</a></div>
            <a id="HiddenAnchor" href="javascript:;" style="display:none;"></a>

                <div id="suiteBarDelta" class="ms-dialogHidden ms-fullWidth noindex">
	
                    <div id="suiteMenuData" class="ms-hide">
                        


                        <span class="ms-siteactions-root" id="siteactiontd">
                            
                        </span>
                    </div>
                    <script type="text/javascript">// <![CDATA[ 

var g_navBarHelpDefaultKey = "HelpHome";
		
		 // ]]>
</script>
                    <div id="suiteBarTop" class="ms-fullWidth ms-TopBarBackground-bgColor" style="height:50px; position:relative;">

	</div><div class="wf-family-o365 o365wf" style="display:none">

	</div>
                
</div>

                <div id="ms-hcTest"></div>
                                <div id="s4-ribbonrow">
                    <div id="globalNavBox" class="noindex">
                        <div id="ribbonBox">
                            <div id="s4-ribboncont">
                                <div id="DeltaSPRibbon">
	
                                    

                                    <input id="RibbonContainer_activeTabId" name="ctl00$ctl74" type="hidden" value=""/><div id='RibbonContainer'><div class="ms-cui-ribbon ms-cui-needIEFilter" id="Ribbon" unselectable="on" aria-describedby="ribboninstructions" role="toolbar"><span class="ms-cui-hidden" id="ribboninstructions" unselectable="on">To navigate through the Ribbon, use standard browser navigation keys. To skip between groups, use Ctrl+LEFT or Ctrl+RIGHT. To jump to the first Ribbon tab use Ctrl+[. To jump to the last selected command use Ctrl+]. To activate a command, use Enter.</span><div class="ms-cui-ribbonTopBars" unselectable="on"><div class="ms-cui-topBar1" unselectable="on" style="display:none"><div class="ms-cui-qat-container" unselectable="on"></div></div><div class="ms-cui-topBar2" unselectable="on"><div class="ms-cui-jewel-container" id="jewelcontainer" unselectable="on" style="display:none"></div><div class="ms-cui-TabRowLeft ms-core-defaultFont ms-dialogHidden" id="RibbonContainer-TabRowLeft" unselectable="on">
									
								
                                        </div><ul class="ms-cui-tts" unselectable="on" role="tablist"><li class="ms-cui-tt ms-browseTab ms-cui-tt-s" id="Ribbon.Read-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.Read',false, event);" title="Browse" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.Read',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Browse</span><span class="ms-cui-hidden" unselectable="on">Tab 1 of 2.</span></a></li><li class="ms-cui-tt" id="Ribbon.WebPartPage-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.WebPartPage',false, event);" title="Page" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.WebPartPage',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Page</span><span class="ms-cui-hidden" unselectable="on">Tab 2 of 2.</span></a></li></ul><div class="ms-cui-TabRowRight s4-trc-container s4-notdlg ms-core-defaultFont" id="RibbonContainer-TabRowRight" unselectable="on">
									
								
                                            
                                            <a onmouseover="this.firstChild.firstChild.style.left=&#39;-217px&#39;; this.firstChild.firstChild.style.top=&#39;-192px&#39;;" onmouseout="this.firstChild.firstChild.style.left=&#39;-218px&#39;; this.firstChild.firstChild.style.top=&#39;-48px&#39;;" onclick="SP.SOD.executeFunc(&#39;followingcommon.js&#39;, &#39;FollowSite&#39;, function() { FollowSite(); }); return false;" id="site_follow_button" title="Follow this site and get back to it easily from your sites page." class="ms-promotedActionButton" href="javascript:__doPostBack(&#39;ctl00$site_follow_button&#39;,&#39;&#39;)" style="display:inline-block;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust ms-promotedActionButton-icon"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Follow" style="position:absolute;left:-218px;top:-48px;" /></span><span class="ms-promotedActionButton-text">Follow</span></a>
                                            
                                            
                                            <span id="fullscreenmodebox" class="ms-qatbutton">
                                                <span id="fullscreenmode">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-125px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-143px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_fullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(true);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-143px;top:-178px;" /></span></span></a>
                                                </span>
                                                <span id="exitfullscreenmode" style="display: none;">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-179px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-96px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-107px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_exitfullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(false);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-107px;top:-178px;" /></span></span></a>
                                                </span>
                                            </span>
                                            
                                            
                                        </div></div></div></div></div>
                                
</div>
                            </div>
                            <span id="DeltaSPNavigation">
                                
									<span id="ctl00_SPNavigation_ctl00_publishingRibbon"></span>

                                
                            </span>
                        </div>
                        <div id="DeltaWebPartAdderUpdatePanelContainer" class="ms-core-webpartadder">
	
                            <div id="WebPartAdderUpdatePanelContainer">
                                <div id="ctl00_WebPartAdderUpdatePanel">
		
										<span id="ctl00_WebPartAdder"></span>
									
	</div>
                            </div>
                        
</div>
                    </div>
                </div>

         

            <div id="s4-workspace" class="ms-core-overlay">
                <div id="s4-bodyContainer">
                    <div id="s4-titlerow" class="ms-dialogHidden s4-titlerowhidetitle d-none">
                        <div id="titleAreaBox" class="ms-noList ms-table ms-core-tableNoSpace">
                            <div id="titleAreaRow" class="ms-tableRow">
                                <div class="ms-breadcrumb-box ms-tableCell ms-verticalAlignTop">
                                    <div class="ms-breadcrumb-top">
                                        <div class="ms-breadcrumb-dropdownBox" style="display:none;">
                                            <span id="DeltaBreadcrumbDropdown">
                                                
                                            </span>
                                        </div>
                                        <div id="DeltaTopNavigation" class="ms-displayInline ms-core-navigation" role="navigation">
	
                                            
                                            
												<div id="zz1_TopNavigationMenu" class=" noindex ms-core-listMenu-horizontalBox">
		<ul id="zz2_RootAspMenu" class="root ms-core-listMenu-root static">
			<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" title="Home" href="/default.aspx" accesskey="1"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Bank Indonesia</span><span class="ms-hidden">Currently selected</span></span></a></li>
		</ul>
	</div>
                                            
                                        
</div>
                                    </div>
                                    <h1 id="pageTitle" class="ms-core-pageTitle">
                                        <span id="DeltaPlaceHolderPageTitleInTitleArea">
                                            
												Foreign Exchange Rates
                                            
                                        </span>
                                        <div id="DeltaPlaceHolderPageDescription" class="ms-displayInlineBlock ms-normalWrap">
	
                                            <a href="javascript:;" id="ms-pageDescriptionDiv" style="display:none;"
                                                data-accessibility-nocheck="true">
                                                <span id="ms-pageDescriptionImage">&#160;</span>
                                            </a>
                                            <span class="ms-accessible" id="ms-pageDescription">
                                                
                                            </span>
                                            <script type="text/javascript">// <![CDATA[ 

_spBodyOnLoadFunctionNames.push("setupPageDescriptionCallout");
										
										 // ]]>
</script>
                                        
</div>
                                    </h1>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                    <div id="DeltaPlaceHolderGroupActionsArea" class="ms-floatRight ms-noWrap">
	
                                        
                                    
</div>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                </div>
                            </div>
                        </div>
                    </div>

                    <header class="ms-dialogHidden mega-menu-wrapper noindex">
                        <div class="top-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                        
                                
<div id="ctl00_g_9675ef44_8939_42e2_aefd_df1b1e975487" __MarkupType="vsattributemarkup" __WebPartId="{9675ef44-8939-42e2-aefd-df1b1e975487}" WebPart="true">
	
        <ul class="header-menu navbar-nav">
            
        <li class="nav-item"><a href='https://www.bi.go.id/en/karier' >Career</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/edukasi' >Education</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/glosarium.aspx' >Glossary</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/peta-situs.aspx' >Sitemap</a></li>       
    
        </ul>
    

</div>
                                        
                                
                                    <div id="DeltaPlaceHolderSearchArea" class="ms-mpSearchBox clearfix">
	
                                        
											<div id="searchInputBox">
                                                <div class="ms-webpart-chrome ms-webpart-chrome-fullWidth ">
		<div WebPartID="00000000-0000-0000-0000-000000000000" HasPers="true" id="WebPartWPQ1" width="100%" class="ms-WPBody " OnlyForMePart="true" allowDelete="false" style="" ><div componentid="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"><div id="SearchBox" name="Control"><div class="ms-srch-sb ms-srch-sb-border" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv"><input type="search" value="Search this site" maxlength="2048" title="Search this site" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox" autocomplete="off" autocorrect="off" onkeypress="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {if (Srch.U.isEnterKey(String.fromCharCode(event.keyCode))) {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);return Srch.U.cancelEvent(event);}})" onkeydown="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.activateDefaultQuerySuggestionBehavior();})" onfocus="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.hidePrompt();ctl.setBorder(true);})" onblur="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr'); if (ctl){ ctl.showPrompt(); ctl.setBorder(false);}})" class="ms-textSmall ms-srch-sb-prompt ms-helperText" role="combobox" aria-owns="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" aria-haspopup="true" aria-autocomplete="list" aria-expanded="false" /><a title="Search" role="button" class="ms-srch-sb-searchLink" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink" onclick="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);})" href="javascript: {}" aria-label="Search"><img src="/_layouts/15/images/searchresultui.png?rev=43#ThemeKey=searchresultui" class="ms-srch-sb-searchImg" id="searchImg" alt="Search" /></a><div class="ms-qSuggest-container ms-shadow" id="AutoCompContainer"><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" role="listbox" aria-label="Suggestions"></div></div></div></div></div><noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_noscript">It looks like your browser does not have JavaScript enabled. Please turn on JavaScript and try again.</div></noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1">

		</div><div class="ms-clear"></div></div>
	</div>
                                            </div>
                                        
                                    
</div>

                                    <div id="bahasa-indon" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="ENLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>
                                    <div id="bahasa-english" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="IDLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>


                                </nav>
                            </div>
                        </div>
                        <div class="bottom-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                    <div id="siteIcon" class="ms-tableCell ms-verticalAlignTop">
                                        <div id="DeltaSiteLogo">
	
                                            <a id="ctl00_onetidProjectPropertyTitleGraphic" class="ms-siteicon-a" href="/id/"><img id="ctl00_onetidHeadbnnr2" class="ms-siteicon-img" name="onetidHeadbnnr0" src="/SiteAssets/logo-bi@2x.png" alt="Foreign Exchange Rates" /></a>
                                        
</div>
                                    </div>

                                    <button class="navbar-toggler" type="button" data-toggle="collapse"
                                        data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent"
                                        aria-expanded="false" aria-label="Toggle navigation">
                                        <span class="navbar-toggler-icon"></span>
                                    </button>
                                    
                                    <div class="collapse navbar-collapse navbar-responsive" id="navbarSupportedContent">
										<div class="noindex">
	                                        <div id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7" __MarkupType="vsattributemarkup" __WebPartId="{3e01a6ba-0414-4f22-b082-8b109c19b6c7}" WebPart="true">
	

<ul class="top-menu navbar-nav" id="test-menu">           
    <li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/tentang-bi/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>About BI</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/tentang-bi/profil/Default.aspx'>Profile</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/tentang-bi/profil/organisasi/Default.aspx' > Organization</a></li><li class='level3'><a href = '/en/tentang-bi/profil/governance/default.aspx' >Governance</a></li><li class='level3'><a href = '/en/tentang-bi/profil/uu-bi/Default.aspx' >Regulations</a></li></ul><li><a href = '/en/tentang-bi/sejarah-bi/Default.aspx'> History </a ></li><li><a href = '/en/tentang-bi/transformasi/Default.aspx'> Transformation </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/tentang-BI_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>About BI</p>
                        <p class='dropdown-megamenu__about--description'>Information about the organisation, transformation and history of Bank Indonesia as the central bank of the Republic of Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/fungsi-utama/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Main Functions</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/moneter/Default.aspx'>Monetary</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/moneter/inflasi/Default.aspx' >Inflation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indikator-moneter/default.aspx' >Monetary Indicator</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/bi-rate/default.aspx' >BI-Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/operasi-moneter/Default.aspx' >Monetary Operation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indonia-jibor/Default.aspx' >INDONIA, Compounded INDONIA, INDONIA Index and JIBOR</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/informasi-kurs/default.aspx' >JISDOR, Non-USD/IDR Reference Rate, and Transaction Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pengembangan-ekonomi/Default.aspx' >Sharia Economy and Financial</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/'>Financial System Stability</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/' >Overview</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/instrumen-makroprudensial/default.aspx' >Macroprudential Policy Instrument</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/manajemen-krisis/default.aspx' >Crisis Management Protocol</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/koordinasi-bi-lainnya/' >Institutional Coordination</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/pengembangan-umkm/' >MSME Development</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/keuangan-inklusif/' >Financial Inclusion</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/sistem-pembayaran'>Payment System and Rupiah Currency Management</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/nilai-besar/' >High Value Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/ritel/' >Retail Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/pengelolaan-rupiah/default.aspx' >Rupiah Currency Management</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/perizinan/default.aspx' >Licensing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/anti-pencucian-uang-dan-pencegahan-pendanaan-terrorisme/' >Anti-Money Laundering and Counter-Terrorism Financing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/Standardisasi-Kompetensi/Default.aspx' >Standardisation Of HR Competencies</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/blueprint/default.aspx' >Indonesia Payment System Blueprint</a></li></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Style Library/biweb/img/bi-photo.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Main Functions</p>
                        <p class='dropdown-megamenu__about--description'>Information about the main functions and responsibilities of Bank Indonesia to achieve and maintain rupiah stability.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/rupiah/' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Rupiah</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/rupiah/gambar-uang/Default.aspx'> Currency Image </a ></li><li><a href = '/en/rupiah/uang-dicabut/'> Withdrawn Currency </a ></li><li><a href = '/en/rupiah/pencegahan-rupiah-palsu/'> Counterfeit Prevention and Management </a ></li><li><a href = '/en/rupiah/cinta-bangga-paham-rupiah/default.aspx'> Cinta, Bangga, Paham Rupiah </a ></li><li><a href = '/en/rupiah/digital-rupiah/default.aspx#overview'> Project Garuda: Digital Rupiah </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/rupiah_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Rupiah</p>
                        <p class='dropdown-megamenu__about--description'>Information about the rupiah as the currency of the Republic of Indonesia managed by Bank Indonesia pursuant to prevailing laws and regulations.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/publikasi/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Publications</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='#'>Media Room</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/ruang-media/news-release/' >Latest News (Press Release)</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/cerita-bi/' >Story</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/pidato-dewan-gubernur/' >Board of Governor Speeches</a></li></ul><li><a href = '/en/publikasi/Kalender/'> Calendar </a ></li><li><a href = '/en/publikasi/peraturan/'> Regulation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/publikasi/lelang/'>Transaction</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/lelang/operasi-moneter/' >Monetary Operation</a></li></ul><li><a href = '/en/publikasi/laporan/'> Report </a ></li><li><a href = '/en/publikasi/kajian/'> Review </a ></li><li><a href = '/en/publikasi/lain/default.aspx'>  Other Publications </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/publikasi.jpg?csf=1&e=QrfjCa&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Publications</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia’s publications include regulations, reports and papers, as well as the calendar of activities</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/statistik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Statistics</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/id/statistik/sdds'> Special Data Dissemination Standard (SDDS) </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/ekonomi-keuangan/seki/Default.aspx'>Financial Statistics</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/seki/Default.aspx' >Indonesian Economic and Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/items/Default.aspx' >Monetary and Payment System Selected Indicators</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sekda/Default.aspx' >The Regional Economic Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sulni/Default.aspx' >Indonesia External Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sski/default.aspx' >Indonesia Financial System Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/suspi/default.aspx' >Indonesia Public Sector Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/spip/Default.aspx' >Payment System and Financial Market Infrastructure Statistics</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/informasi-kurs/jisdor'>Foreign Exchange Rate</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/informasi-kurs/jisdor' >JISDOR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi' >Bank Indonesia Foreign Exchange Transaction Rates</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/kurs-acuan-non-usd-idr/' >Reference Rate for Non-USD/IDR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx' >Calculator</a></li></ul><li><a href = '/en/statistik/indikator'> Indicators </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/Statistik.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Statistics</p>
                        <p class='dropdown-megamenu__about--description'>Statistics include historical indicators for all sectors under the jurisdiction of Bank Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/layanan/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Services</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/layanan/permintaan-informasi/default.aspx'> Information Request </a ></li><li><a href = '/en/layanan/pengaduan-konsumen'> Consumer Protection and Complaints </a ></li><li><a href = '/en/layanan/elicensing/default.aspx'>  E-Licensing </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/informasi-perizinan/default.aspx'>Licensed Institutions</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/informasi-perizinan/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/layanan/informasi-perizinan/sistem-pembayaran/default.aspx' >Payment System and Rupiah Currency Management</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/perpustakaan/'>Library</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/perpustakaan/koleksi-buku/' >Book Collection</a></li></ul><li><a href = '/en/layanan/kas-bi/'> Bank Indonesia Cash Service </a ></li><li><a href = '/en/layanan/lelang-jasa-barang/'> Goods and Services Auction </a ></li><li><a href = '/en/layanan/kunjungan-bi/default.aspx'> Visitation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/museum-bi/'>Museum</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/museum-bi/koleksi-museum' >Museum Collection</a></li><li class='level3'><a href = '/en/layanan/museum-bi/program-informasi/default.aspx' >Museum Program and Information</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/Standar/SNAP/default.aspx'>Payment System Standard - Open API</a></div><ul class='dropdown-megamenu__submenu-list'></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/layanan.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Services</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia offers various services, including requests for information, complaints, licensing and so on.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/informasi-publik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Public Information</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/informasi-publik/profil-ppid/Default.aspx'> Profile </a ></li><li><a href = '/en/informasi-publik/dasar-hukum'> Regulation </a ></li><li><a href = '/en/informasi-publik/informasi-publik/Default.aspx'> List of Public Information </a ></li><li><a href = '/en/informasi-publik/layanan-informasi/Default.aspx'> Information Service </a ></li><li><a href = '/en/informasi-publik/berita-ppid/Default.aspx'> News </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/informasi-publik.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Public Information</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia maintains public information in accordance with the Public Information Disclosure Act of 2008.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li>
</ul>
<span id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7_ctl00_LabelDebug"></span>    
 

</div>
                                        </div>
                                    </div>
                                </nav>
                            </div>
                        </div>

                    </header>
                    <div class="menu-overlay"></div>

                    <div id="contentRow">
                        <div id="sideNavBox" role="Navigation" class="ms-dialogHidden ms-forceWrap ms-noList">
                            <div id="DeltaPlaceHolderLeftNavBar" class="ms-core-navigation" role="navigation">
	
                                
									
                                    <a id="startNavigation" name="startNavigation" tabIndex="-1"></a>
                                    
                                    
                                    
                                    
                                    
                                    <div class="ms-core-sideNavBox-removeLeftMargin">
                                        <div id="ctl00_PlaceHolderLeftNavBar_QuickLaunchNavigationManager">
		<div id="zz3_V4QuickLaunchMenu" class=" noindex ms-core-listMenu-verticalBox">
			<ul id="zz4_RootAspMenu" class="root ms-core-listMenu-root static">
				<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" href="/"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Recent</span><span class="ms-hidden">Currently selected</span></span></a></li>
			</ul>
		</div>
	</div>
                                        
                                        
											<div class="ms-core-listMenu-verticalBox">
                                                
                                            </div>
                                            
                                        
                                    </div>
                                    
                                
                            
</div>
                        </div>
                        <div id="contentBox" aria-live="polite" aria-relevant="all" role="main">
                            <a id="mainContent" name="mainContent" tabindex="-1"></a>
                            <div id="notificationArea" class="ms-notif-box"></div>
                            <div id="DeltaPageStatusBar">
	
                                <div id="pageStatusBar"></div>
                            
</div>
                            <div id="DeltaPlaceHolderTop">
	
                                <div class="noindex">
                                	
	<div id="ctl00_PlaceHolderTop_g_717976cb_8b48_4283_98d0_c1ff5d699b5d" __MarkupType="vsattributemarkup" __WebPartId="{717976cb-8b48-4283-98d0-c1ff5d699b5d}" WebPart="true">
		

<div class="top-banner">
    <div class="container">
        <nav aria-label="breadcrumb">
            <ol class="breadcrumb color">
                
                        
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en">Home </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik">Statistics </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik/informasi-kurs">Foreign Exchange Rate </a>
                        </li>
                    
                    
                <li class="breadcrumb-item color-white" aria-current="page">
                    Foreign Exchange Rates
                </li>
            </ol>
        </nav>
        <h1 class="top-banner__title"> Foreign Exchange Rates</h1>
    </div>
    <div class="top-banner__overlay"></div>
</div>



<div style="display:none;">
    Start;Home;Statistics;Foreign Exchange Rate;bukan default.aspx
</div>

	</div>

                                </div>
                            
</div>

                            <div class="container">
								 <a id="button-back-to-top"><img src="/Style Library/biweb/img/ico_back-to-top.svg" alt=""/></a>
                                <div id="DeltaPlaceHolderMain">
	
                                    
<div id="content-wrapper" class="content-text">                
		<h2>EXCHANGE RATES ON TRANSACTION</h2>
		<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf" __MarkupType="vsattributemarkup" __WebPartId="{6C89D4AD-107F-437D-BD54-8FDA17B556BF}" WebPart="true" partorder="2">
		


<script type="text/javascript" src="/Style Library/biweb/js/jquery-ui-1.12.1.min.js"></script>


<script type="text/javascript" src="/Style Library/biweb/js/jquery.cookie.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/Chart.min.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/html2canvas.min.js"></script>
<link rel="stylesheet" href="/Style Library/biweb/css/jquery-ui.css" />

<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
<script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>

<script type="text/javascript"> 
    var myApp = new function () {
        this.printTable = function () {
            var tab = document.getElementById('tableData');
            var win = window.print('', '', 'height=700,width=700');
            win.document.write(tab.outerHTML);
            win.document.close();
            win.print();
        }
    }
</script>

<style>

</style>

<script type="text/javascript">
    //////chart

    var getMataUang = "";
    var arrayValueDate = [];
    var arrayValueKurs = [];
    console.log(arrayValueDate);
    console.log(arrayValueKurs);
    window.onload = function () {
        var ctx = document.getElementById("myChart").getContext("2d");
        console.log(ctx);
        var data = {
            labels: arrayValueDate,
            datasets: [{
                label: "Kurs Transaksi",
                data: arrayValueKurs,
                borderColor: "blue",
                lineTension: 0
            }]
        };

        var myLineChart = new Chart(ctx, {
            type: 'line',
            data: data,
            options: {
                legend: {
                    display: false,
                    labels: {
                        display: false
                    }
                },
                title: {
                    display: true,
                    text: 'Kurs Transaksi (Exchange Rates on Transaction) - ' + getMataUang
                },
                responsive: true,
                maintainAspectRatio: false,
                tooltips: {
                    callbacks: {
                        label: function (t, d) {
                            if (url.toLowerCase().indexOf("/id/") !== -1) {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".") : "Rp " + t.yLabel;
                            }
                            else {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") : "Rp " + t.yLabel;
                            }
                            return yLabel;
                        }
                    }
                },
                scales: {
                    xAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Source Bank Indonesia'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10
                        },

                    }],
                    yAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Rupiah'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10,
                            callback: function (value, index, values) {
                                if (parseInt(value) >= 1000) {
                                    if (url.toLowerCase().indexOf("/id/") !== -1) {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
                                    }
                                    else {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
                                    }

                                } else {
                                    return value;
                                }
                            }
                        }
                    }]
                }
            }
        });

        window.addEventListener('resize', function () {
            myLineChart.resize()
        })
    }
    function setFormSubmitToFalse() {
        setTimeout(function () { _spFormOnSubmitCalled = false; }, 1000);
        return true;
    }
</script>

<script type="text/javascript">

    $(document).ready(function () {
        url = window.location.href;

        

        if (url.toLowerCase().indexOf("/id/") !== -1) {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);

        }
        else {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);
        }


        if (url.toLowerCase().indexOf("/id/") !== -1) {
            var dialogSingkatan = "Code of Currency";
            $(".btn[id$='_btnGraphImage']").prop("value", "Lihat");
            $(".btn[id$='_ButtonExport']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Unduh");
        }
        else {
            var dialogSingkatan = "Kode Singkatan";
            $(".btn[id$='_btnGraphImage']").prop("value", "View");
            $(".btn[id$='_ButtonExport']").prop("value", "Download");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Download");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Download");
            $("#linkId").attr("href", "/en/statistik/informasi-kurs/transaksi-bi/Default.aspx");
            $("#exampleModalLabel").text("Currency Code");
        }

        $("#KodeSingkatan").dialog({
            autoOpen: false,
            show: "blind",
            width: "240",
            height: "500",
            hide: "explode",
            title: dialogSingkatan
        });

        $("#linkSingkatan1").click(function () {
            $("#KodeSingkatan").dialog("open");
            return false;
        });



        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Masukkan periode awal dan akhir dengan benar');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Periode tanggal awal tidak valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('Periode tanggal akhir tidak valid');
                        return false;
                    }

                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Input start date and end date correctly');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Start date is not valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('End date is not valid');
                        return false;
                    }

                }
            }
            

        });

        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Masukkan periode dengan benar');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Periode tanggal tidak valid');
                        return false;
                    }
                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Input period correctly');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Period is not valid');
                        return false;
                    }
                }
            }
            
        });

    });

    function SetSource(SourceID) {
        var hideSourceID = $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID");
        hideSourceID.val(SourceID);
    }

    // function validation 
    function isValidDate(val, format) {
        try {
            var newDate = val.split("-")[0];
            var newMonth = val.split("-")[1];
            var newYear = val.split("-")[2];

            if (newYear.length == 2 || newYear.length == 4) {
                if (newYear.length == 4) { newYear = newYear.substring(2, 4); }
            }
            else {
                return false;
            }

            var date = getDateFromFormat(newDate + '-' + newMonth + '-' + newYear, format);
            if (date == 0) { return false; }
            return true;
        }
        catch (ex) {
            return false;
        }
    }

    var MONTH_NAMES = new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember', 'Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Ags', 'Sep', 'Okt', 'Nov', 'Des');
    var DAY_NAMES = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
    function LZ(x) { return (x < 0 || x > 9 ? "" : "0") + x }
    function getDateFromFormat(val, format) {
        val = val + "";
        format = format + "";
        var i_val = 0;
        var i_format = 0;
        var c = "";
        var token = "";
        var token2 = "";
        var x, y;
        var now = new Date();
        var year = now.getYear();
        var month = now.getMonth() + 1;
        var date = 1;
        var hh = now.getHours();
        var mm = now.getMinutes();
        var ss = now.getSeconds();
        var ampm = "";

        while (i_format < format.length) {
            c = format.charAt(i_format);
            token = "";
            while ((format.charAt(i_format) == c) && (i_format < format.length)) {
                token += format.charAt(i_format++);
            }
            if (token == "yyyy" || token == "yy" || token == "y") {
                if (token == "yyyy") { x = 4; y = 4; }
                if (token == "yy") { x = 2; y = 2; }
                if (token == "y") { x = 2; y = 4; }
                year = _getInt(val, i_val, x, y);
                if (year == null) { return 0; }
                i_val += year.length;
                if (year.length == 2) {
                    if (year > 70) { year = 1900 + (year - 0); }
                    else { year = 2000 + (year - 0); }
                }
            }
            else if (token == "MMM" || token == "NNN") {
                month = 0;
                for (var i = 0; i < MONTH_NAMES.length; i++) {
                    var month_name = MONTH_NAMES[i];
                    if (val.substring(i_val, i_val + month_name.length).toLowerCase() == month_name.toLowerCase()) {
                        if (token == "MMM" || (token == "NNN" && i > 11)) {
                            month = i + 1;
                            if (month > 24) { month -= 24; }
                            if (month > 12) { month -= 12; }
                            i_val += month_name.length;
                            break;
                        }
                    }
                }
                if ((month < 1) || (month > 12)) { return 0; }
            }
            else if (token == "EE" || token == "E") {
                for (var i = 0; i < DAY_NAMES.length; i++) {
                    var day_name = DAY_NAMES[i];
                    if (val.substring(i_val, i_val + day_name.length).toLowerCase() == day_name.toLowerCase()) {
                        i_val += day_name.length;
                        break;
                    }
                }
            }
            else if (token == "MM" || token == "M") {
                month = _getInt(val, i_val, token.length, 2);
                if (month == null || (month < 1) || (month > 12)) { return 0; }
                i_val += month.length;
            }
            else if (token == "dd" || token == "d") {
                date = _getInt(val, i_val, token.length, 2);
                if (date == null || (date < 1) || (date > 31)) { return 0; }
                i_val += date.length;
            }
            else if (token == "hh" || token == "h") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 12)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "HH" || token == "H") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 23)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "KK" || token == "K") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 11)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "kk" || token == "k") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 24)) { return 0; }
                i_val += hh.length; hh--;
            }
            else if (token == "mm" || token == "m") {
                mm = _getInt(val, i_val, token.length, 2);
                if (mm == null || (mm < 0) || (mm > 59)) { return 0; }
                i_val += mm.length;
            }
            else if (token == "ss" || token == "s") {
                ss = _getInt(val, i_val, token.length, 2);
                if (ss == null || (ss < 0) || (ss > 59)) { return 0; }
                i_val += ss.length;
            }
            else if (token == "a") {
                if (val.substring(i_val, i_val + 2).toLowerCase() == "am") { ampm = "AM"; }
                else if (val.substring(i_val, i_val + 2).toLowerCase() == "pm") { ampm = "PM"; }
                else { return 0; }
                i_val += 2;
            }
            else {
                if (val.substring(i_val, i_val + token.length) != token) { return 0; }
                else { i_val += token.length; }
            }
        }
        if (i_val != val.length) { return 0; }
        if (month == 2) {
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
                // leap year
                if (date > 29) { return 0; }
            }
            else { if (date > 28) { return 0; } }
        }
        if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
            if (date > 30) { return 0; }
        }
        if (hh < 12 && ampm == "PM") { hh = hh - 0 + 12; }
        else if (hh > 11 && ampm == "AM") { hh -= 12; }
        var newdate = new Date(year, month - 1, date, hh, mm, ss);
        return newdate.getTime();
    }

    function _isInteger(val) {
        var digits = "1234567890";
        for (var i = 0; i < val.length; i++) {
            if (digits.indexOf(val.charAt(i)) == -1) { return false; }
        }
        return true;
    }

    function _getInt(str, i, minlength, maxlength) {
        for (var x = maxlength; x >= minlength; x--) {
            var token = str.substring(i, i + x);
            if (token.length < minlength) { return null; }
            if (_isInteger(token)) { return token; }
        }
        return null;
    }

    function download() {
        //if (!isChartRendered) return; // return if chart not rendered
        html2canvas(document.getElementById('chart-container'), {
            onrendered: function (canvas) {
                if (canvas.msToBlob) { //for IE
                    var blob = canvas.msToBlob();
                    window.navigator.msSaveBlob(blob, 'BIexchangeRates.jpeg');
                }
                else {
                    var link = document.createElement('a');
                    link.href = canvas.toDataURL('image/jpeg');
                    link.download = 'BIexchangeRates.jpeg';
                    link.click();
                }
            }
        })
    }

</script>


<div class="card-block" id="tableData">
    <div class="card-body">

       

        <div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_MataUang" class="row">
            <div class="col-lg-3">
                <label class="label-custom mb-1">
                    Access Data</label>
                <div style="margin-top: 10px">
                    <div class="select-custom-wrapper select-custom-wrapper">
                        <select class="custom-select" id="selectPeriod">
                            <option selected='' value="harian">
                                Daily
                            </option>
                            <option  value="range">
                                Time Series
                            </option>
                        </select>
                        <i class="fas fa-chevron-down primary--color select-custom__icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-3">
                <div class="mb-4">
                    <p>
                        Currencies
                    </p>
                    <div class="select-custom-wrapper select-custom-wrapper">
                        <select name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ddlmatauang1" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ddlmatauang1" class="custom-select">
			<option value="AED  ">AED  </option>
			<option value="AUD  ">AUD  </option>
			<option value="BND  ">BND  </option>
			<option value="CAD  ">CAD  </option>
			<option value="CHF  ">CHF  </option>
			<option value="CNH  ">CNH  </option>
			<option value="CNY  ">CNY  </option>
			<option value="DKK  ">DKK  </option>
			<option value="EUR  ">EUR  </option>
			<option value="GBP  ">GBP  </option>
			<option value="HKD  ">HKD  </option>
			<option value="JPY  ">JPY  </option>
			<option value="KRW  ">KRW  </option>
			<option value="KWD  ">KWD  </option>
			<option value="LAK  ">LAK  </option>
			<option value="MYR  ">MYR  </option>
			<option value="NOK  ">NOK  </option>
			<option value="NZD  ">NZD  </option>
			<option value="PGK  ">PGK  </option>
			<option value="PHP  ">PHP  </option>
			<option value="SAR  ">SAR  </option>
			<option value="SEK  ">SEK  </option>
			<option value="SGD  ">SGD  </option>
			<option value="THB  ">THB  </option>
			<option value="USD  ">USD  </option>
			<option value="VND  ">VND  </option>

		</select>
                        <i class="fas fa-chevron-down primary--color select-custom__icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-3 align-self-center">
                <div class="btn btn-primary modal-trigger" data-toggle="modal" data-target="#exampleModal">
                    Currency Code
                </div>
                <div class="modal fade" id="exampleModal" tabindex="-1" role="dialog"
                    aria-labelledby="exampleModalLabel" aria-hidden="true">
                    <div class="modal-dialog" role="document">
                        <div class="modal-content">
                            <div class="modal-header">
                                <h5 class="modal-title" id="exampleModalLabel">Kode Singkatan
                                </h5>
                                <button type="button" class="close" data-dismiss="modal"
                                    aria-label="Close">
                                    <span aria-hidden="true"
                                        style="font-size: 32px;">×
                                    </span>
                                </button>
                            </div>
                            <div class="modal-body">
                                <div class="page-table table-responsive page-table--bordered mb-3">
                                    <table class="table table-striped table-no-bordered table-md">
                                        <thead>
                                            <tr class="table-header">
                                                <th scope="col">
                                                    Code
                                                </th>
                                                <th scope="col">
                                                    Currencies
                                                </th>
                                            </tr>
                                        </thead>
                                        <tbody>
                                            
                                                    <tr>
                                                        <td>AED</td>
                                                        <td>UNITED ARAB EMIRATES DIRHAM</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>AUD</td>
                                                        <td>AUSTRALIAN DOLLAR</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>BND</td>
                                                        <td>BRUNEI DOLLAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>CAD</td>
                                                        <td>CANADIAN DOLLAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>CHF</td>
                                                        <td>SWISS FRANC
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>CNH</td>
                                                        <td>CHINA YUAN
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>CNY</td>
                                                        <td>CHINA YUAN
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>DKK</td>
                                                        <td>DANISH KRONE
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>EUR</td>
                                                        <td>EURO</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>GBP</td>
                                                        <td>BRITISH POUND
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>HKD</td>
                                                        <td>HONGKONG DOLLAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>JPY</td>
                                                        <td>JAPANESE YEN
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>KRW</td>
                                                        <td>KOREAN WON
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>KWD</td>
                                                        <td>KUWAITI DINAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>LAK</td>
                                                        <td>LAOTIAN KIP</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>MYR</td>
                                                        <td>MALAYSIAN RINGGIT
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>NOK</td>
                                                        <td>NORWEGIAN KRONE
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>NZD</td>
                                                        <td>NEW ZEALAND DOLLAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>PGK</td>
                                                        <td>PAPUA N.G. KINA
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>PHP</td>
                                                        <td>PHILLIPINE PESO</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>SAR</td>
                                                        <td>SAUDI ARABIAN RIYAL
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>SEK</td>
                                                        <td>	SWEDISH KRONA</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>SGD</td>
                                                        <td>SINGAPORE DOLLAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>THB</td>
                                                        <td>THAI BAHT
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>USD</td>
                                                        <td>US DOLLAR
</td>
                                                    </tr>
                                                
                                                    <tr>
                                                        <td>VND</td>
                                                        <td>VIETNAMESE DONG
</td>
                                                    </tr>
                                                
                                        </tbody>
                                    </table>
                                    
                                </div>

                            </div>
                        </div>
                    </div>
                </div>
            </div>
        </div>
        <div class="row datepicker-period" id="harian" >
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        Daily</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTanggal" type="text" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch2" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
            
            
        </div>
        <div class="row datepicker-period" id="range" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        From</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtFrom" type="text" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        To</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTo" type="text" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch1" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
        </div>
        <div>
            
            
            <div class="row">
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        <div class="search-box-wrapper text-left">
                            Last Update&nbsp;<span>2 April 2026</span>
                        </div>
                    </div>
                </div>
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        <div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_printDefault" class="search-box-wrapper text-right">
                            <input type="button" value="Print Table" onclick="myApp.printTable()" class="btn btn-secondary btn-icon btn-icon__print" />
                            <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ButtonExport" value="Unduh" onclick="javascript:setFormSubmitToFalse();" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ButtonExport" class=" btn btn-primary btn-export" />                            
                        </div>
                        
                        
                    </div>
                </div>                
            </div>
            <div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_GridView1" class="page-table table-responsive page-table--bordered mb-3">
                <table class="table table-striped table-no-bordered table-lg">
                    <thead class="thead color-blue">
                        <tr class="table-header">
                            <th class="text-right" scope="col">
                                Currencies</th>
                            <th class="text-right" scope="col">
                                Value</th>
                            <th class="text-right" scope="col">
                                Sell</th>
                            <th class="text-right" scope="col">
                                Buy</th>
                            <th class="text-right" scope="col">
                                Graph</th>
                        </tr>
                    </thead>
                    
                            <tbody>
                                
                            <tr>
                                <td class="text-right">AED  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">4,653.45</td>
                                <td class="text-right">4,605.27</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl0$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl0_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">AUD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">11,839.59</td>
                                <td class="text-right">11,720.09</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl1$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl1_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">BND  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">13,307.64</td>
                                <td class="text-right">13,167.02</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl2$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl2_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">CAD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">12,286.63</td>
                                <td class="text-right">12,160.87</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl3$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl3_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">CHF  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">21,509.33</td>
                                <td class="text-right">21,292.62</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl4$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl4_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">CNH  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">2,484.01</td>
                                <td class="text-right">2,458.51</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl5$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl5_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">CNY  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">2,484.30</td>
                                <td class="text-right">2,459.29</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl6$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl6_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">DKK  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">2,648.62</td>
                                <td class="text-right">2,622.10</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl7$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl7_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">EUR  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">19,791.88</td>
                                <td class="text-right">19,593.26</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl8$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl8_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">GBP  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">22,667.63</td>
                                <td class="text-right">22,440.39</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl9$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl9_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">HKD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">2,180.13</td>
                                <td class="text-right">2,158.16</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl10$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl10_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">JPY  </td>
                                <td class="text-right">100</td>
                                <td class="text-right">10,762.12</td>
                                <td class="text-right">10,653.69</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl11$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl11_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">KRW  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">11.34</td>
                                <td class="text-right">11.22</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl12$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl12_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">KWD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">55,712.46</td>
                                <td class="text-right">55,140.12</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl13$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl13_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">LAK  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">0.78</td>
                                <td class="text-right">0.76</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl14$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl14_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">MYR  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">4,248.39</td>
                                <td class="text-right">4,197.76</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl15$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl15_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">NOK  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">1,763.84</td>
                                <td class="text-right">1,743.35</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl16$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl16_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">NZD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">9,830.16</td>
                                <td class="text-right">9,730.65</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl17$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl17_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">PGK  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">4,100.88</td>
                                <td class="text-right">3,772.49</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl18$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl18_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">PHP  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">283.76</td>
                                <td class="text-right">280.76</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl19$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl19_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">SAR  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">4,552.89</td>
                                <td class="text-right">4,506.39</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl20$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl20_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">SEK  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">1,815.51</td>
                                <td class="text-right">1,796.77</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl21$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl21_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">SGD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">13,303.50</td>
                                <td class="text-right">13,170.10</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl22$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl22_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">THB  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">524.46</td>
                                <td class="text-right">518.77</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl23$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl23_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">USD  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">17,087.01</td>
                                <td class="text-right">16,916.99</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl24$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl24_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            <tr>
                                <td class="text-right">VND  </td>
                                <td class="text-right">1</td>
                                <td class="text-right">0.65</td>
                                <td class="text-right">0.64</td>
                                <td class="text-right">
                                    <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ListViewKurs$ctrl25$btnGraphImage" value="Lihat" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ListViewKurs_ctrl25_btnGraphImage" class="btn" AutoPostBack="True" alternatetext="graph" style="background: #045498; color: white" />
                                    
                                </td>
                            </tr>

                        
                            </tbody>
                        
                </table>

            </div>
        </div>
    </div>

</div>

<input type="hidden" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$hidSourceID" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID" />



<div id="myChartWrapper" style="width: 100%; height: 100%; display: none">
    <div id="chart-container">
        <canvas id="myChart" width="500" height="400"></canvas>
    </div>
    <div class="text-right my-3">
        <button class="btn btn-primary" onclick="download()">Save Chart</button>
    </div>
</div>




	</div>
		<div id="accordion" style="display:none">
		
                    <div class="card">
                        <div class="card-header" id="headingOne">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseOne" href="#headingOne"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Tentang JISDOR</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseOne" class="collapse" aria-labelledby="headingOne" data-parent="#accordion">
                            <div class="card-block">
                                <div class="card-body">
                                    <div class="content-text-subtitle">
                                        <p>Penjelasan JISDOR</p>
                                    </div>
                                    <ol>

                                        <menu class="ms-hide">
		<ie:menuitem id="MSOMenu_Help" iconsrc="/_layouts/15/images/HelpIcon.gif" onmenuclick="MSOWebPartPage_SetNewWindowLocation(MenuWebPart.getAttribute('helpLink'), MenuWebPart.getAttribute('helpMode'))" text="Help" type="option" style="display:none">

		</ie:menuitem>
	</menu>


                                        
                                        


                                    </ol>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header" id="headingTwo">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseTwo" href="#headingTwo"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Penjelasan Kurs Transaksi</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseTwo" class="collapse" aria-labelledby="headingTwo" data-parent="#accordion">
                            
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a href="/id/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx"
                                        class="collapsed">
                                        <div class="color-gray">
                                            <p>Kalkulator Kurs</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        
                    </div>
                </div>
            </div>
        
<div style='display:none' id='hidZone'></div>
                                
</div>
                            </div>
                            <div id="DeltaPlaceHolderBottom">
	
                                <div class="noindex">
                                
	<div id="ctl00_PlaceHolderBottom_g_e3052be3_673c_405e_9cbe_a883a244c053" __MarkupType="vsattributemarkup" __WebPartId="{e3052be3-673c-405e-9cbe-a883a244c053}" WebPart="true">
		

<script type="text/javascript">
    $(document).ready(function() {
        $(".carousel-item-othersites:first").addClass("active");
        console.log($("#HiddenFieldCount").val());
        if ($("#HiddenFieldCount").val()<=3){
            $(".carousel-control-othersites").hide();
        }
    });
</script>
<input type="hidden" name="ctl00$PlaceHolderBottom$g_e3052be3_673c_405e_9cbe_a883a244c053$ctl00$HiddenFieldCount" id="HiddenFieldCount" value="1" />
<div class="bottom-banner">
    <div class="container">
        <p class="bottom-banner__title">Other Articles</p>
        <div id="carouselOtherSites" class="carousel slide carousel-column" data-ride="carousel" data-interval="false">
            
                    <div class="carousel-inner">
                        
                    <div class="carousel-item carousel-item-othersites">
                        <div class="row bottom-banner-slides">
                            
                    <div class="col-sm-4">
                        <div class="box-list">
                            <a href="https://www.bi.go.id/en/fungsi-utama/moneter/informasi-kurs/default.aspx#floating-2" class="box-list__hyperlink"></a>
                            <p class="mb-0">
                                Bank Indonesia Foreign Exchange Transaction Rates​
                            </p>
                        </div>
                    </div>
                
                        </div>
                    </div>
                
                    </div>
                
            <a class="carousel-control-othersites carousel-control-prev" href="#carouselOtherSites" role="button" data-slide="prev">
                <span class="carousel-control-prev-icon" aria-hidden="true"></span>
                <span class="sr-only">Previous</span>
            </a>
            <a class="carousel-control-othersites carousel-control-next" href="#carouselOtherSites" role="button" data-slide="next">
                <span class="carousel-control-next-icon" aria-hidden="true"></span>
                <span class="sr-only">Next</span>
            </a>
        </div>
    </div>
</div>


	</div>

                                </div>
                            
</div>

                        </div>
                        <div id="DeltaFormDigest">
	
                            
								
                            
                        
</div>
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                    </div>

                    <footer class="ms-dialogHidden noindex">
                        <div class="top-footer">
                            <div class="container">
                                                        	    		
<div id="ctl00_UserControl1" __MarkupType="vsattributemarkup" __WebPartId="{72f5f1f8-08c8-489c-ad0f-67bc21b60514}" WebPart="true">
	
        <ul class="list-unstyled link-list">
            
        <li class="ml-4"><a href='https://www.bi.go.id/en/publikasi/Kalender' class="link__item">Calendar</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/archive' class="link__item">Archieve</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/minisite.aspx' class="link__item">Minisite</a></li>       
    
        </ul>
    

</div>
                                                        	    		
                                <div class="row">
<div id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa" __MarkupType="vsattributemarkup" __WebPartId="{ecc2559e-4a60-437f-ba58-80eaeea6b4aa}" WebPart="true">
	

<div class="col-12 col-md-6 sosmed-wrapper">
    
            <div class="sosmed-list"> 
                
            <a class="sosmed__item" href='https://www.facebook.com/BankIndonesiaOfficial/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-fb.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.instagram.com/bank_indonesia/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-ig.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.youtube.com/user/BankIndonesiaChannel'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-youtube.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.tiktok.com/@bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-tiktok.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://twitter.com/bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-twitter-X_.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://open.spotify.com/show/4Q38i2lcJpxvtJvcmJuWWv'>
                <img src='https://www.bi.go.id/Sosial%20Media/SPOTIFY-svg.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://whatsapp.com/channel/0029VahA0uQL2ATyd7fOSE39'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-WA-Channel.svg' width="32" alt="icon-fb"></a>
         
            </div> 
        
    
            <div class="app-list">
                
            <a class="app__item" href='https://apps.apple.com/id/app/bi-mobile/id1198899727'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-app-store.svg' width="98" alt="icon-app-store"></a>
        
            <a class="app__item" href='https://play.google.com/store/apps/details?id=com.bi.mobile'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-play-store.svg' width="98" alt="icon-app-store"></a>
        
            </div>
        
</div>
<span id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa_ctl00_LabelDebug"></span>

</div>

                                    <div class="col-12 col-md-6 address-wrapper">
                                        <div class="address-list">
                                            <p class="mb-0">Bank Indonesia<br/>
Jalan M.H. Thamrin No. 2, Jakarta 10350<br/>
Contact Center Bank Indonesia Bicara<br/>
Telp. : 131 dan 1500131 (dari luar negeri)<br/>
E-mail : <a href="mailto:bicara@bi.go.id">bicara@bi.go.id</a><br/>
Chatbot LISA :<a href="https://wa.me/6281131131131?text=Hi,%20Lisa" target="blank"> 081 131 131 131</a></p>
                                        </div>
                                    </div>
                                    <div class="col-12 col-md-12 mt-3 d-flex justify-content-end">
                                    	<div id="ctl00_g_e8c52fcb_2724_4885_9437_c0f616f27eb4" __MarkupType="vsattributemarkup" __WebPartId="{e8c52fcb-2724-4885-9437-c0f616f27eb4}" WebPart="true" partorder="2">
	


</div>
                                    </div>
                                </div>
                            </div>
                        </div>
                        <div class="copyright-wrapper">
                            <div class="container">
                                <p class="text-right mb-0">© 2020 Bank Indonesia</p>
                            </div>
                        </div>

                    </footer>

                </div>
                <span id="DeltaHelpPanel">
                    <div id="helppanelCntdiv" class="ms-Help-PanelContainer">
                        
                    </div>
                </span>
                <span id="DeltaPageInstrumentation">
                    
                </span>
            </div>
        

<script type="text/javascript">
//<![CDATA[
var _spFormDigestRefreshInterval = 1440000;window.SPThemeUtils && SPThemeUtils.ApplyCurrentTheme(true); IsSPSocialSwitchEnabled = function() { return true; };var _fV4UI = true;
function _RegisterWebPartPageCUI()
{
    var initInfo = {editable: false,isEditMode: false,allowWebPartAdder: false};
    SP.Ribbon.WebPartComponent.registerWithPageManager(initInfo);
    var wpcomp = SP.Ribbon.WebPartComponent.get_instance();
    var hid;
    hid = document.getElementById("_wpSelected");
    if (hid != null)
    {
        var wpid = hid.value;
        if (wpid.length > 0)
        {
            var zc = document.getElementById(wpid);
            if (zc != null)
                wpcomp.selectWebPart(zc, false);
        }
    }
    hid = document.getElementById("_wzSelected");
    if (hid != null)
    {
        var wzid = hid.value;
        if (wzid.length > 0)
        {
            wpcomp.selectWebPartZone(null, wzid);
        }
    }
};
function __RegisterWebPartPageCUI() {
ExecuteOrDelayUntilScriptLoaded(_RegisterWebPartPageCUI, "sp.ribbon.js");}
_spBodyOnLoadFunctionNames.push("__RegisterWebPartPageCUI");var __wpmExportWarning='This Web Part Page has been personalized. As a result, one or more Web Part properties may contain confidential information. Make sure the properties contain information that is safe for others to read. After exporting this Web Part, view properties in the Web Part description file (.WebPart) by using a text editor such as Microsoft Notepad.';var __wpmCloseProviderWarning='You are about to close this Web Part.  It is currently providing data to other Web Parts, and these connections will be deleted if this Web Part is closed.  To close this Web Part, click OK.  To keep this Web Part, click Cancel.';var __wpmDeleteWarning='You are about to permanently delete this Web Part.  Are you sure you want to do this?  To delete this Web Part, click OK.  To keep this Web Part, click Cancel.';SuiteNavRendering.RenderSuiteNav({top:'suiteBarTop', version:2, dataEndpoint:'Microsoft.SharePoint.Portal.SuiteNavData.GetSuiteNavData', culture:'en-US', signInLink:'\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fAuthenticate.aspx?Source=\u00252Fen\u00252Fstatistik\u00252Finformasi\u00252Dkurs\u00252Ftransaksi\u00252Dbi\u00252Fdefault\u00252Easpx', brandingText:'', brandingLogo:'', brandingLogoLink:'', brandingLogoTitle:''});
var _spWebPermMasks = {High:16,Low:196673};g_spPreFetchKeys.push('sp.core.js');function _cUpdonetidHeadbnnr2(){var myd = null; if (typeof(dataonetidHeadbnnr2) != 'undefined') {myd = dataonetidHeadbnnr2;} var myc = document.getElementById('ctl00_onetidHeadbnnr2');_cUpdconetidHeadbnnr2(myd, myc);}function _cUpdconetidHeadbnnr2(data, ctrl){SiteLogoImagePageUpdate(ctrl, data);}$('#myChartWrapper').dialog({ autoOpen:false, show: 'blind', hide: 'explode',draggable: true,modal: false, height: 310, width: 430});
            ExecuteOrDelayUntilScriptLoaded(
                function() 
                {                    
                    Srch.ScriptApplicationManager.get_current().states = {"webUILanguageName":"en-US","webDefaultLanguageName":"en-US","QueryDateTimeCulture":1033,"timeZoneOffsetInHours":7,"contextUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","contextTitle":"Foreign Exchange Rates","supportedLanguages":[{"id":1025,"label":"Arabic"},{"id":1093,"label":"Bangla"},{"id":1026,"label":"Bulgarian"},{"id":1027,"label":"Catalan"},{"id":2052,"label":"Chinese (Simplified)"},{"id":1028,"label":"Chinese (Traditional)"},{"id":1050,"label":"Croatian"},{"id":1029,"label":"Czech"},{"id":1030,"label":"Danish"},{"id":1043,"label":"Dutch"},{"id":1033,"label":"English"},{"id":1035,"label":"Finnish"},{"id":1036,"label":"French"},{"id":1031,"label":"German"},{"id":1032,"label":"Greek"},{"id":1095,"label":"Gujarati"},{"id":1037,"label":"Hebrew"},{"id":1081,"label":"Hindi"},{"id":1038,"label":"Hungarian"},{"id":1039,"label":"Icelandic"},{"id":1057,"label":"Indonesian"},{"id":1040,"label":"Italian"},{"id":1041,"label":"Japanese"},{"id":1099,"label":"Kannada"},{"id":1042,"label":"Korean"},{"id":1062,"label":"Latvian"},{"id":1063,"label":"Lithuanian"},{"id":1086,"label":"Malay"},{"id":1100,"label":"Malayalam"},{"id":1102,"label":"Marathi"},{"id":1044,"label":"Norwegian"},{"id":1045,"label":"Polish"},{"id":1046,"label":"Portuguese (Brazil)"},{"id":2070,"label":"Portuguese (Portugal)"},{"id":1094,"label":"Punjabi"},{"id":1048,"label":"Romanian"},{"id":1049,"label":"Russian"},{"id":3098,"label":"Serbian (Cyrillic)"},{"id":2074,"label":"Serbian (Latin)"},{"id":1051,"label":"Slovak"},{"id":1060,"label":"Slovenian"},{"id":3082,"label":"Spanish (Spain)"},{"id":2058,"label":"Spanish (Mexico)"},{"id":1053,"label":"Swedish"},{"id":1097,"label":"Tamil"},{"id":1098,"label":"Telugu"},{"id":1054,"label":"Thai"},{"id":1055,"label":"Turkish"},{"id":1058,"label":"Ukrainian"},{"id":1056,"label":"Urdu"},{"id":1066,"label":"Vietnamese"}],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"webUILanguageDirectory":"en-US","showAdminDetails":false,"defaultPagesListName":"Pages","isSPFSKU":false,"defaultQueryProperties":{"culture":1033,"uiLanguage":1033,"summaryLength":180,"desiredSnippetLength":90,"enableStemming":true,"enablePhonetic":false,"enableNicknames":false,"trimDuplicates":true,"bypassResultTypes":false,"enableInterleaving":true,"enableQueryRules":true,"processBestBets":true,"enableOrderingHitHighlightedProperty":false,"hitHighlightedMultivaluePropertyLimit":-1,"processPersonalFavorites":true}};
                    Srch.U.trace(null, 'SerializeToClient', 'ScriptApplicationManager state initialized.');
                }, 'Search.ClientControls.js');var g_clientIdDeltaPlaceHolderMain = "DeltaPlaceHolderMain";
var g_clientIdDeltaPlaceHolderPageTitleInTitleArea = "DeltaPlaceHolderPageTitleInTitleArea";
var g_clientIdDeltaPlaceHolderUtilityContent = "DeltaPlaceHolderUtilityContent";

theForm.oldSubmit = theForm.submit;
theForm.submit = WebForm_SaveScrollPositionSubmit;

theForm.oldOnSubmit = theForm.onsubmit;
theForm.onsubmit = WebForm_SaveScrollPositionOnSubmit;

                function _ribbonInitFunc1()

                {
                    EnsureScriptParams('core.js', '_ribbonInitFunc1Wrapped', '', '', '\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx', '-1997219614', '1033', 'RibbonContainer', {'Ribbon.Read':true,'Ribbon.WebPartPage':true}, null, {'Ribbon.WebPartInsert.InsertRelatedDataToListForm':true},
                                            null, false, 0, false, 'SP.Ribbon.PageManager.get_instance()', false, null, null, null, '1522130250', 1, '.');
                }
                function _ribbonStartInit(initialTabId, buildMinimized, e)
                {
                    EnsureScriptParams('core.js', '_ribbonStartInitWrapped', initialTabId, buildMinimized, e, true, 'EnsureScriptParams("core.js", "RibbonControlInitWrapped");EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", function () { _registerCUIEComponentWrapped( "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx", "1033", "-1997219614");});EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", _ribbonInitFunc1);');
                }
                function _ribbonKeyboardTitleShortcut(e)
                {
                    EnsureScriptParams('core.js', '_ribbonKeyboardTitleShortcutWrapped', e, 'tff[', 'Ribbon.Read-title');
                }
                function _ribbonDataInit(p6, p7)
                {
                    _ribbon = new Object();
                    _ribbon.initialTabId = p6;
                    _ribbon.buildMinimized = p7;
                    _ribbon.initStarted = false;
                    _ribbon.initialTabSelectedByUser = false;
                    _ribbon.launchedByKeyboard = false;
                }
                function _ribbonWaitForBodyEvent()
                {
                    if (false)
                        _ribbonStartInit();
                    
                function _ribbonOnWindowResizeForHeaderScaling(evt)
                {
                    _ribbonOnWindowResizeForHeaderScalingWrapped(evt, 'RibbonContainer', false);
                }
                EnsureScriptParams('core.js', '_ribbonInitResizeHandlers', _ribbonOnWindowResizeForHeaderScaling, 'RibbonContainer', true, false);
                
                    EnsureScriptParams('core.js', '_ribbonAddEventListener', _ribbonKeyboardTitleShortcut);
                }
                _ribbonDataInit('Ribbon.Read', true);                
                if (SP.SOD.get_prefetch() == 0 && _ribbon.buildMinimized == true)
                {
                    ExecuteOrDelayUntilScriptLoaded(_ribbonWaitForBodyEvent, 'sp.ribbon.js');
                }
                else
                {
                    EnsureScriptFunc('ribbon', 'SP.Ribbon.PageStateActionButton', _ribbonWaitForBodyEvent);
                }
                
var g_commandUIHandlers = {"name":"CommandHandlers","attrs":{},"children":[]};
g_QuickLaunchControlIds.push("zz1_TopNavigationMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz1_TopNavigationMenu = null; function init_zz1_TopNavigationMenu() { if (g_zz1_TopNavigationMenu == null) g_zz1_TopNavigationMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz1_TopNavigationMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz1_TopNavigationMenu, 'SP.Core.js');

                    ExecuteOrDelayUntilScriptLoaded(
                        function() 
                        {
                            if ($isNull($find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr')))
                            {
                                var sb = $create(Srch.SearchBox, {"delayLoadTemplateScripts":true,"initialPrompt":"Search this site","messages":[],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"queryGroupNames":["MasterPage"],"renderTemplateId":"~sitecollection/_catalogs/masterpage/Display Templates/Search/Control_SearchBox_Compact.js","resultsPageAddress":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","serverInitialRender":true,"showDataErrors":true,"showNavigation":true,"states":{},"tryInplaceQuery":false}, null, null, $get("ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"));
                                sb.activate('Search this site', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavButton', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavDropdownList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink', 'ms-srch-sbprogress', 'ms-srch-sb-prompt ms-helperText');
                            }
                        }, 'Search.ClientControls.js');g_QuickLaunchControlIds.push("zz3_V4QuickLaunchMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz3_V4QuickLaunchMenu = null; function init_zz3_V4QuickLaunchMenu() { if (g_zz3_V4QuickLaunchMenu == null) g_zz3_V4QuickLaunchMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz3_V4QuickLaunchMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz3_V4QuickLaunchMenu, 'SP.Core.js');
//]]>
</script>
</form>
        <span id="DeltaPlaceHolderUtilityContent">
            
        </span>
        <script type="text/javascript">// <![CDATA[ 

var g_Workspace = "s4-workspace";
		
		 // ]]>
</script>
    </body>
</html>
recorded_at: Sun, 05 Apr 2026 00:49:25 GMT
- request:
method: post
uri: https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
body:
encoding: US-ASCII
string: MSOWebPartPage_PostbackSource=&MSOTlPn_View=0&MSOTlPn_ShowSettings=False&MSOTlPn_Button=none&__EVENTTARGET=&__EVENTARGUMENT=&__REQUESTDIGEST=0x41D00311222AA5C7BCCDE7DFEA5D3ED0FA83851A66FFBB06DF250B456DB0D3DEACCB775F47795FC4F63284D1626209AAD854D6F5053BDE3EC332F5FFFCE9D770%2C05+Apr+2026+00%3A49%3A24+-0000&MSOSPWebPartManager_DisplayModeName=Browse&MSOSPWebPartManager_ExitingDesignMode=false&MSOSPWebPartManager_OldDisplayModeName=Browse&MSOSPWebPartManager_StartWebPartEditingName=false&MSOSPWebPartManager_EndWebPartEditing=false&_maintainWorkspaceScrollPosition=0&__VIEWSTATE=%2FwEPDwUBMA9kFgJmD2QWAgIBD2QWBAIBD2QWAgInD2QWAgIDD2QWAmYPZBYCZg88KwAGAGQCCQ9kFhYCIw9kFgICAw8WAh4HVmlzaWJsZWgWAmYPZBYEAgMPZBYOAgEPFgIfAGhkAgMPFgIfAGhkAgUPFgIfAGhkAgcPFgIfAGhkAgkPFgIfAGhkAgsPFgIfAGhkAg0PFgIfAGhkAgQPDxYCHglBY2Nlc3NLZXkFAS9kZAIlD2QWAgIDD2QWAgIBD2QWBAIDD2QWAmYPDxYEHgRfIVNCAgIeCENzc0NsYXNzBRdtcy1wcm9tb3RlZEFjdGlvbkJ1dHRvbmRkAgUPDxYGHwMFF21zLXByb21vdGVkQWN0aW9uQnV0dG9uHwICAh8AaGRkAi8PZBYCAgEPZBYCAgEPPCsABQEADxYCHhVQYXJlbnRMZXZlbHNEaXNwbGF5ZWRmZGQCNQ9kFgJmD2QWAmYPFCsAAg8WBB4LXyFEYXRhQm91bmRnHgtfIUl0ZW1Db3VudAIEZGQWAmYPZBYIAgEPZBYCZg8VAh5odHRwczovL3d3dy5iaS5nby5pZC9lbi9rYXJpZXIGQ2FyZWVyZAICD2QWAmYPFQIfaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vZWR1a2FzaQlFZHVjYXRpb25kAgMPZBYCZg8VAiZodHRwczovL3d3dy5iaS5nby5pZC9lbi9nbG9zYXJpdW0uYXNweAhHbG9zc2FyeWQCBA9kFgJmDxUCJ2h0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL3BldGEtc2l0dXMuYXNweAdTaXRlbWFwZAI7D2QWAmYPZBYCAgEPFgIeBFRleHQFqKMBPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi90ZW50YW5nLWJpL2RlZmF1bHQuYXNweCcgaWQ9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJyByb2xlPSdidXR0b24nIGRhdGEtdG9nZ2xlPSdkcm9wZG93bicgYXJpYS1oYXNwb3B1cD0ndHJ1ZScgYXJpYS1leHBhbmRlZD0nZmFsc2UnPkFib3V0IEJJPC9hPgogICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVudSBkcm9wZG93bi1tZWdhbWVudScgYXJpYS1sYWJlbGxlZGJ5PSduYXZiYXJEcm9wZG93blN0YXRpc3Rpayc%2BCiAgICAgICAgPGRpdiBjbGFzcz0nY29udGFpbmVyJz4KICAgICAgICAgICAgPGRpdiBjbGFzcz0nZC1tZC1mbGV4Jz4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gcHItbWQtNCc%2BIAogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19tZW51Jz48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3RlbnRhbmctYmkvcHJvZmlsL0RlZmF1bHQuYXNweCc%2BUHJvZmlsZTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi90ZW50YW5nLWJpL3Byb2ZpbC9vcmdhbmlzYXNpL0RlZmF1bHQuYXNweCcgPiBPcmdhbml6YXRpb248L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vdGVudGFuZy1iaS9wcm9maWwvZ292ZXJuYW5jZS9kZWZhdWx0LmFzcHgnID5Hb3Zlcm5hbmNlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3RlbnRhbmctYmkvcHJvZmlsL3V1LWJpL0RlZmF1bHQuYXNweCcgPlJlZ3VsYXRpb25zPC9hPjwvbGk%2BPC91bD48bGk%2BPGEgaHJlZiA9ICcvZW4vdGVudGFuZy1iaS9zZWphcmFoLWJpL0RlZmF1bHQuYXNweCc%2BIEhpc3RvcnkgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi90ZW50YW5nLWJpL3RyYW5zZm9ybWFzaS9EZWZhdWx0LmFzcHgnPiBUcmFuc2Zvcm1hdGlvbiA8L2EgPjwvbGk%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L01lbnUlMjBJbWFnZS90ZW50YW5nLUJJX3YyLnBuZyZxdW90OyknPjwvZGl2PgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aXRsZSc%2BQWJvdXQgQkk8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgb3JnYW5pc2F0aW9uLCB0cmFuc2Zvcm1hdGlvbiBhbmQgaGlzdG9yeSBvZiBCYW5rIEluZG9uZXNpYSBhcyB0aGUgY2VudHJhbCBiYW5rIG9mIHRoZSBSZXB1YmxpYyBvZiBJbmRvbmVzaWEuPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9mdW5nc2ktdXRhbWEvZGVmYXVsdC5hc3B4JyBpZD0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnIHJvbGU9J2J1dHRvbicgZGF0YS10b2dnbGU9J2Ryb3Bkb3duJyBhcmlhLWhhc3BvcHVwPSd0cnVlJyBhcmlhLWV4cGFuZGVkPSdmYWxzZSc%2BTWFpbiBGdW5jdGlvbnM8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvRGVmYXVsdC5hc3B4Jz5Nb25ldGFyeTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmZsYXNpL0RlZmF1bHQuYXNweCcgPkluZmxhdGlvbjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmRpa2F0b3ItbW9uZXRlci9kZWZhdWx0LmFzcHgnID5Nb25ldGFyeSBJbmRpY2F0b3I8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvYmktcmF0ZS9kZWZhdWx0LmFzcHgnID5CSS1SYXRlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL29wZXJhc2ktbW9uZXRlci9EZWZhdWx0LmFzcHgnID5Nb25ldGFyeSBPcGVyYXRpb248L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvaW5kb25pYS1qaWJvci9EZWZhdWx0LmFzcHgnID5JTkRPTklBLCBDb21wb3VuZGVkIElORE9OSUEsIElORE9OSUEgSW5kZXggYW5kIEpJQk9SPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL2luZm9ybWFzaS1rdXJzL2RlZmF1bHQuYXNweCcgPkpJU0RPUiwgTm9uLVVTRC9JRFIgUmVmZXJlbmNlIFJhdGUsIGFuZCBUcmFuc2FjdGlvbiBSYXRlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL3Bhc2FyLWtldWFuZ2FuL2RlZmF1bHQuYXNweCcgPk1vbmV5IE1hcmtldDwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9wZW5nZW1iYW5nYW4tZWtvbm9taS9EZWZhdWx0LmFzcHgnID5TaGFyaWEgRWNvbm9teSBhbmQgRmluYW5jaWFsPC9hPjwvbGk%2BPC91bD48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL2Z1bmdzaS11dGFtYS9zdGFiaWxpdGFzLXNpc3RlbS1rZXVhbmdhbi9pa2h0aXNhci8nPkZpbmFuY2lhbCBTeXN0ZW0gU3RhYmlsaXR5PC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zdGFiaWxpdGFzLXNpc3RlbS1rZXVhbmdhbi9pa2h0aXNhci8nID5PdmVydmlldzwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4vaW5zdHJ1bWVuLW1ha3JvcHJ1ZGVuc2lhbC9kZWZhdWx0LmFzcHgnID5NYWNyb3BydWRlbnRpYWwgUG9saWN5IEluc3RydW1lbnQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3N0YWJpbGl0YXMtc2lzdGVtLWtldWFuZ2FuL21hbmFqZW1lbi1rcmlzaXMvZGVmYXVsdC5hc3B4JyA%2BQ3Jpc2lzIE1hbmFnZW1lbnQgUHJvdG9jb2w8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3N0YWJpbGl0YXMtc2lzdGVtLWtldWFuZ2FuL2tvb3JkaW5hc2ktYmktbGFpbm55YS8nID5JbnN0aXR1dGlvbmFsIENvb3JkaW5hdGlvbjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4vcGVuZ2VtYmFuZ2FuLXVta20vJyA%2BTVNNRSBEZXZlbG9wbWVudDwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4va2V1YW5nYW4taW5rbHVzaWYvJyA%2BRmluYW5jaWFsIEluY2x1c2lvbjwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4nPlBheW1lbnQgU3lzdGVtIGFuZCBSdXBpYWggQ3VycmVuY3kgTWFuYWdlbWVudDwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4vbmlsYWktYmVzYXIvJyA%2BSGlnaCBWYWx1ZSBQYXltZW50IFN5c3RlbTwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4vcml0ZWwvJyA%2BUmV0YWlsIFBheW1lbnQgU3lzdGVtPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zaXN0ZW0tcGVtYmF5YXJhbi9wZW5nZWxvbGFhbi1ydXBpYWgvZGVmYXVsdC5hc3B4JyA%2BUnVwaWFoIEN1cnJlbmN5IE1hbmFnZW1lbnQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL3Blcml6aW5hbi9kZWZhdWx0LmFzcHgnID5MaWNlbnNpbmc8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL2FudGktcGVuY3VjaWFuLXVhbmctZGFuLXBlbmNlZ2FoYW4tcGVuZGFuYWFuLXRlcnJvcmlzbWUvJyA%2BQW50aS1Nb25leSBMYXVuZGVyaW5nIGFuZCBDb3VudGVyLVRlcnJvcmlzbSBGaW5hbmNpbmc8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL1N0YW5kYXJkaXNhc2ktS29tcGV0ZW5zaS9EZWZhdWx0LmFzcHgnID5TdGFuZGFyZGlzYXRpb24gT2YgSFIgQ29tcGV0ZW5jaWVzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zaXN0ZW0tcGVtYmF5YXJhbi9ibHVlcHJpbnQvZGVmYXVsdC5hc3B4JyA%2BSW5kb25lc2lhIFBheW1lbnQgU3lzdGVtIEJsdWVwcmludDwvYT48L2xpPjwvdWw%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L1N0eWxlIExpYnJhcnkvYml3ZWIvaW1nL2JpLXBob3RvLmpwZyZxdW90OyknPjwvZGl2PgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aXRsZSc%2BTWFpbiBGdW5jdGlvbnM8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgbWFpbiBmdW5jdGlvbnMgYW5kIHJlc3BvbnNpYmlsaXRpZXMgb2YgQmFuayBJbmRvbmVzaWEgdG8gYWNoaWV2ZSBhbmQgbWFpbnRhaW4gcnVwaWFoIHN0YWJpbGl0eS48L3A%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgPC9kaXY%2BCiAgICA8L2Rpdj4KPC9saT48bGkgY2xhc3M9J25hdi1pdGVtIGRyb3Bkb3duJz4KICAgICAgPGEgY2xhc3M9J25hdi1saW5rIGRyb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3J1cGlhaC8nIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5SdXBpYWg8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaT48YSBocmVmID0gJy9lbi9ydXBpYWgvZ2FtYmFyLXVhbmcvRGVmYXVsdC5hc3B4Jz4gQ3VycmVuY3kgSW1hZ2UgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi9ydXBpYWgvdWFuZy1kaWNhYnV0Lyc%2BIFdpdGhkcmF3biBDdXJyZW5jeSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL3J1cGlhaC9wZW5jZWdhaGFuLXJ1cGlhaC1wYWxzdS8nPiBDb3VudGVyZmVpdCBQcmV2ZW50aW9uIGFuZCBNYW5hZ2VtZW50IDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcnVwaWFoL2NpbnRhLWJhbmdnYS1wYWhhbS1ydXBpYWgvZGVmYXVsdC5hc3B4Jz4gQ2ludGEsIEJhbmdnYSwgUGFoYW0gUnVwaWFoIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcnVwaWFoL2RpZ2l0YWwtcnVwaWFoL2RlZmF1bHQuYXNweCNvdmVydmlldyc%2BIFByb2plY3QgR2FydWRhOiBEaWdpdGFsIFJ1cGlhaCA8L2EgPjwvbGk%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L01lbnUlMjBJbWFnZS9ydXBpYWhfdjIucG5nJnF1b3Q7KSc%2BPC9kaXY%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRpdGxlJz5SdXBpYWg8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgcnVwaWFoIGFzIHRoZSBjdXJyZW5jeSBvZiB0aGUgUmVwdWJsaWMgb2YgSW5kb25lc2lhIG1hbmFnZWQgYnkgQmFuayBJbmRvbmVzaWEgcHVyc3VhbnQgdG8gcHJldmFpbGluZyBsYXdzIGFuZCByZWd1bGF0aW9ucy48L3A%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgPC9kaXY%2BCiAgICA8L2Rpdj4KPC9saT48bGkgY2xhc3M9J25hdi1pdGVtIGRyb3Bkb3duJz4KICAgICAgPGEgY2xhc3M9J25hdi1saW5rIGRyb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3B1Ymxpa2FzaS9EZWZhdWx0LmFzcHgnIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5QdWJsaWNhdGlvbnM8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScjJz5NZWRpYSBSb29tPC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9ydWFuZy1tZWRpYS9uZXdzLXJlbGVhc2UvJyA%2BTGF0ZXN0IE5ld3MgKFByZXNzIFJlbGVhc2UpPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9ydWFuZy1tZWRpYS9jZXJpdGEtYmkvJyA%2BU3Rvcnk8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL3J1YW5nLW1lZGlhL3BpZGF0by1kZXdhbi1ndWJlcm51ci8nID5Cb2FyZCBvZiBHb3Zlcm5vciBTcGVlY2hlczwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9LYWxlbmRlci8nPiBDYWxlbmRhciA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9wZXJhdHVyYW4vJz4gUmVndWxhdGlvbiA8L2EgPjwvbGk%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9wdWJsaWthc2kvbGVsYW5nLyc%2BVHJhbnNhY3Rpb248L2E%2BPHNwYW4gY2xhc3M9J2NhcmV0Jz48L3NwYW4%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2xlbGFuZy9vcGVyYXNpLW1vbmV0ZXIvJyA%2BTW9uZXRhcnkgT3BlcmF0aW9uPC9hPjwvbGk%2BPC91bD48bGk%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2xhcG9yYW4vJz4gUmVwb3J0IDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2thamlhbi8nPiBSZXZpZXcgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi9wdWJsaWthc2kvbGFpbi9kZWZhdWx0LmFzcHgnPiAgT3RoZXIgUHVibGljYXRpb25zIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL3B1Ymxpa2FzaS5qcGc%2FY3NmPTEmZT1RcmZqQ2EmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlB1YmxpY2F0aW9uczwvcD4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tZGVzY3JpcHRpb24nPkJhbmsgSW5kb25lc2lh4oCZcyBwdWJsaWNhdGlvbnMgaW5jbHVkZSByZWd1bGF0aW9ucywgcmVwb3J0cyBhbmQgcGFwZXJzLCBhcyB3ZWxsIGFzIHRoZSBjYWxlbmRhciBvZiBhY3Rpdml0aWVzPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9zdGF0aXN0aWsvRGVmYXVsdC5hc3B4JyBpZD0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnIHJvbGU9J2J1dHRvbicgZGF0YS10b2dnbGU9J2Ryb3Bkb3duJyBhcmlhLWhhc3BvcHVwPSd0cnVlJyBhcmlhLWV4cGFuZGVkPSdmYWxzZSc%2BU3RhdGlzdGljczwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2lkL3N0YXRpc3Rpay9zZGRzJz4gU3BlY2lhbCBEYXRhIERpc3NlbWluYXRpb24gU3RhbmRhcmQgKFNERFMpIDwvYSA%2BPC9saT48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nla2kvRGVmYXVsdC5hc3B4Jz5GaW5hbmNpYWwgU3RhdGlzdGljczwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zZWtpL0RlZmF1bHQuYXNweCcgPkluZG9uZXNpYW4gRWNvbm9taWMgYW5kIEZpbmFuY2lhbCBTdGF0aXN0aWNzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL2l0ZW1zL0RlZmF1bHQuYXNweCcgPk1vbmV0YXJ5IGFuZCBQYXltZW50IFN5c3RlbSBTZWxlY3RlZCBJbmRpY2F0b3JzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nla2RhL0RlZmF1bHQuYXNweCcgPlRoZSBSZWdpb25hbCBFY29ub21pYyBGaW5hbmNpYWwgU3RhdGlzdGljczwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zdWxuaS9EZWZhdWx0LmFzcHgnID5JbmRvbmVzaWEgRXh0ZXJuYWwgRGVidCBTdGF0aXN0aWNzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nza2kvZGVmYXVsdC5hc3B4JyA%2BSW5kb25lc2lhIEZpbmFuY2lhbCBTeXN0ZW0gU3RhdGlzdGljczwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zdXNwaS9kZWZhdWx0LmFzcHgnID5JbmRvbmVzaWEgUHVibGljIFNlY3RvciBEZWJ0IFN0YXRpc3RpY3M8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vc3RhdGlzdGlrL2Vrb25vbWkta2V1YW5nYW4vc3BpcC9EZWZhdWx0LmFzcHgnID5QYXltZW50IFN5c3RlbSBhbmQgRmluYW5jaWFsIE1hcmtldCBJbmZyYXN0cnVjdHVyZSBTdGF0aXN0aWNzPC9hPjwvbGk%2BPC91bD48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy9qaXNkb3InPkZvcmVpZ24gRXhjaGFuZ2UgUmF0ZTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvaW5mb3JtYXNpLWt1cnMvamlzZG9yJyA%2BSklTRE9SPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy90cmFuc2Frc2ktYmknID5CYW5rIEluZG9uZXNpYSBGb3JlaWduIEV4Y2hhbmdlIFRyYW5zYWN0aW9uIFJhdGVzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy9rdXJzLWFjdWFuLW5vbi11c2QtaWRyLycgPlJlZmVyZW5jZSBSYXRlIGZvciBOb24tVVNEL0lEUjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvaW5mb3JtYXNpLWt1cnMvdHJhbnNha3NpLWJpL2thbGt1bGF0b3Ita3Vycy5hc3B4JyA%2BQ2FsY3VsYXRvcjwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmRpa2F0b3InPiBJbmRpY2F0b3JzIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL1N0YXRpc3Rpay5qcGcmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlN0YXRpc3RpY3M8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5TdGF0aXN0aWNzIGluY2x1ZGUgaGlzdG9yaWNhbCBpbmRpY2F0b3JzIGZvciBhbGwgc2VjdG9ycyB1bmRlciB0aGUganVyaXNkaWN0aW9uIG9mIEJhbmsgSW5kb25lc2lhLjwvcD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICA8L2Rpdj4KICAgICAgICA8L2Rpdj4KICAgIDwvZGl2Pgo8L2xpPjxsaSBjbGFzcz0nbmF2LWl0ZW0gZHJvcGRvd24nPgogICAgICA8YSBjbGFzcz0nbmF2LWxpbmsgZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vbGF5YW5hbi9kZWZhdWx0LmFzcHgnIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5TZXJ2aWNlczwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vcGVybWludGFhbi1pbmZvcm1hc2kvZGVmYXVsdC5hc3B4Jz4gSW5mb3JtYXRpb24gUmVxdWVzdCA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vcGVuZ2FkdWFuLWtvbnN1bWVuJz4gQ29uc3VtZXIgUHJvdGVjdGlvbiBhbmQgQ29tcGxhaW50cyA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vZWxpY2Vuc2luZy9kZWZhdWx0LmFzcHgnPiAgRS1MaWNlbnNpbmcgPC9hID48L2xpPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vbGF5YW5hbi9pbmZvcm1hc2ktcGVyaXppbmFuL2RlZmF1bHQuYXNweCc%2BTGljZW5zZWQgSW5zdGl0dXRpb25zPC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vaW5mb3JtYXNpLXBlcml6aW5hbi9wYXNhci1rZXVhbmdhbi9kZWZhdWx0LmFzcHgnID5Nb25leSBNYXJrZXQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9pbmZvcm1hc2ktcGVyaXppbmFuL3Npc3RlbS1wZW1iYXlhcmFuL2RlZmF1bHQuYXNweCcgPlBheW1lbnQgU3lzdGVtIGFuZCBSdXBpYWggQ3VycmVuY3kgTWFuYWdlbWVudDwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL3BlcnB1c3Rha2Fhbi8nPkxpYnJhcnk8L2E%2BPHNwYW4gY2xhc3M9J2NhcmV0Jz48L3NwYW4%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9wZXJwdXN0YWthYW4va29sZWtzaS1idWt1LycgPkJvb2sgQ29sbGVjdGlvbjwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4va2FzLWJpLyc%2BIEJhbmsgSW5kb25lc2lhIENhc2ggU2VydmljZSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vbGVsYW5nLWphc2EtYmFyYW5nLyc%2BIEdvb2RzIGFuZCBTZXJ2aWNlcyBBdWN0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9rdW5qdW5nYW4tYmkvZGVmYXVsdC5hc3B4Jz4gVmlzaXRhdGlvbiA8L2EgPjwvbGk%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL211c2V1bS1iaS8nPk11c2V1bTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9sYXlhbmFuL211c2V1bS1iaS9rb2xla3NpLW11c2V1bScgPk11c2V1bSBDb2xsZWN0aW9uPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vbXVzZXVtLWJpL3Byb2dyYW0taW5mb3JtYXNpL2RlZmF1bHQuYXNweCcgPk11c2V1bSBQcm9ncmFtIGFuZCBJbmZvcm1hdGlvbjwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL1N0YW5kYXIvU05BUC9kZWZhdWx0LmFzcHgnPlBheW1lbnQgU3lzdGVtIFN0YW5kYXJkIC0gT3BlbiBBUEk8L2E%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48L3VsPjwvdWw%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIGRyb3Bkb3duLW1lZ2FtZW51X19hYm91dCBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aHVtYm5haWwgbWItMicgc3R5bGU9J2JhY2tncm91bmQtaW1hZ2U6dXJsKCZxdW90Oy9NZW51JTIwSW1hZ2UvbGF5YW5hbi5qcGcmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlNlcnZpY2VzPC9wPgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS1kZXNjcmlwdGlvbic%2BQmFuayBJbmRvbmVzaWEgb2ZmZXJzIHZhcmlvdXMgc2VydmljZXMsIGluY2x1ZGluZyByZXF1ZXN0cyBmb3IgaW5mb3JtYXRpb24sIGNvbXBsYWludHMsIGxpY2Vuc2luZyBhbmQgc28gb24uPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9pbmZvcm1hc2ktcHVibGlrL0RlZmF1bHQuYXNweCcgaWQ9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJyByb2xlPSdidXR0b24nIGRhdGEtdG9nZ2xlPSdkcm9wZG93bicgYXJpYS1oYXNwb3B1cD0ndHJ1ZScgYXJpYS1leHBhbmRlZD0nZmFsc2UnPlB1YmxpYyBJbmZvcm1hdGlvbjwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2VuL2luZm9ybWFzaS1wdWJsaWsvcHJvZmlsLXBwaWQvRGVmYXVsdC5hc3B4Jz4gUHJvZmlsZSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2luZm9ybWFzaS1wdWJsaWsvZGFzYXItaHVrdW0nPiBSZWd1bGF0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9pbmZvcm1hc2ktcHVibGlrL0RlZmF1bHQuYXNweCc%2BIExpc3Qgb2YgUHVibGljIEluZm9ybWF0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9sYXlhbmFuLWluZm9ybWFzaS9EZWZhdWx0LmFzcHgnPiBJbmZvcm1hdGlvbiBTZXJ2aWNlIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9iZXJpdGEtcHBpZC9EZWZhdWx0LmFzcHgnPiBOZXdzIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL2luZm9ybWFzaS1wdWJsaWsucG5nJnF1b3Q7KSc%2BPC9kaXY%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRpdGxlJz5QdWJsaWMgSW5mb3JtYXRpb248L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5CYW5rIEluZG9uZXNpYSBtYWludGFpbnMgcHVibGljIGluZm9ybWF0aW9uIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgUHVibGljIEluZm9ybWF0aW9uIERpc2Nsb3N1cmUgQWN0IG9mIDIwMDguPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BZAI9D2QWAgIBD2QWBAIPDw8WAh8AaGQWAgIBD2QWAgIDD2QWAgIBDzwrAAkBAA8WAh4NTmV2ZXJFeHBhbmRlZGdkZAITD2QWAmYPFgIfAGhkAkEPZBYCAgEPZBYCAgEPZBYCZg9kFggCAQ8UKwACDxYEHwVnHwYCA2RkFgJmD2QWBgIBD2QWAmYPFQIXaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4ESG9tZWQCAg9kFgJmDxUCIWh0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL3N0YXRpc3RpawpTdGF0aXN0aWNzZAIDD2QWAmYPFQIwaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vc3RhdGlzdGlrL2luZm9ybWFzaS1rdXJzFUZvcmVpZ24gRXhjaGFuZ2UgUmF0ZWQCAw8WAh8HBRZGb3JlaWduIEV4Y2hhbmdlIFJhdGVzZAIFDxYCHwcFFkZvcmVpZ24gRXhjaGFuZ2UgUmF0ZXNkAgkPFgIfBwU%2BU3RhcnQ7SG9tZTtTdGF0aXN0aWNzO0ZvcmVpZ24gRXhjaGFuZ2UgUmF0ZTtidWthbiBkZWZhdWx0LmFzcHhkAkMPZBYCAgIPZBYCAgEPZBYCZg9kFhRmD2QWEmYPFgIfBwULQWNjZXNzIERhdGFkAgEPFgIfBwUFRGFpbHlkAgIPFgIfBwULVGltZSBTZXJpZXNkAgMPFgIfBwUKQ3VycmVuY2llc2QCBA8QZA8WGmYCAQICAgMCBAIFAgYCBwIIAgkCCgILAgwCDQIOAg8CEAIRAhICEwIUAhUCFgIXAhgCGRYaEAUFQUVEICAFBUFFRCAgZxAFBUFVRCAgBQVBVUQgIGcQBQVCTkQgIAUFQk5EICBnEAUFQ0FEICAFBUNBRCAgZxAFBUNIRiAgBQVDSEYgIGcQBQVDTkggIAUFQ05IICBnEAUFQ05ZICAFBUNOWSAgZxAFBURLSyAgBQVES0sgIGcQBQVFVVIgIAUFRVVSICBnEAUFR0JQICAFBUdCUCAgZxAFBUhLRCAgBQVIS0QgIGcQBQVKUFkgIAUFSlBZICBnEAUFS1JXICAFBUtSVyAgZxAFBUtXRCAgBQVLV0QgIGcQBQVMQUsgIAUFTEFLICBnEAUFTVlSICAFBU1ZUiAgZxAFBU5PSyAgBQVOT0sgIGcQBQVOWkQgIAUFTlpEICBnEAUFUEdLICAFBVBHSyAgZxAFBVBIUCAgBQVQSFAgIGcQBQVTQVIgIAUFU0FSICBnEAUFU0VLICAFBVNFSyAgZxAFBVNHRCAgBQVTR0QgIGcQBQVUSEIgIAUFVEhCICBnEAUFVVNEICAFBVVTRCAgZxAFBVZORCAgBQVWTkQgIGdkZAIFDxYCHwcFDUN1cnJlbmN5IENvZGVkAgYPFgIfBwUEQ29kZWQCBw8WAh8HBQpDdXJyZW5jaWVzZAIIDxYCHwYCGhY0Zg9kFgJmDxUCA0FFRBtVTklURUQgQVJBQiBFTUlSQVRFUyBESVJIQU1kAgEPZBYCZg8VAgNBVUQRQVVTVFJBTElBTiBET0xMQVJkAgIPZBYCZg8VAgNCTkQPQlJVTkVJIERPTExBUg0KZAIDD2QWAmYPFQIDQ0FEEUNBTkFESUFOIERPTExBUg0KZAIED2QWAmYPFQIDQ0hGDVNXSVNTIEZSQU5DDQpkAgUPZBYCZg8VAgNDTkgMQ0hJTkEgWVVBTg0KZAIGD2QWAmYPFQIDQ05ZDENISU5BIFlVQU4NCmQCBw9kFgJmDxUCA0RLSw5EQU5JU0ggS1JPTkUNCmQCCA9kFgJmDxUCA0VVUgRFVVJPZAIJD2QWAmYPFQIDR0JQD0JSSVRJU0ggUE9VTkQNCmQCCg9kFgJmDxUCA0hLRBFIT05HS09ORyBET0xMQVINCmQCCw9kFgJmDxUCA0pQWQ5KQVBBTkVTRSBZRU4NCmQCDA9kFgJmDxUCA0tSVwxLT1JFQU4gV09ODQpkAg0PZBYCZg8VAgNLV0QPS1VXQUlUSSBESU5BUg0KZAIOD2QWAmYPFQIDTEFLC0xBT1RJQU4gS0lQZAIPD2QWAmYPFQIDTVlSE01BTEFZU0lBTiBSSU5HR0lUDQpkAhAPZBYCZg8VAgNOT0sRTk9SV0VHSUFOIEtST05FDQpkAhEPZBYCZg8VAgNOWkQUTkVXIFpFQUxBTkQgRE9MTEFSDQpkAhIPZBYCZg8VAgNQR0sRUEFQVUEgTi5HLiBLSU5BDQpkAhMPZBYCZg8VAgNQSFAPUEhJTExJUElORSBQRVNPZAIUD2QWAmYPFQIDU0FSFVNBVURJIEFSQUJJQU4gUklZQUwNCmQCFQ9kFgJmDxUCA1NFSw4JU1dFRElTSCBLUk9OQWQCFg9kFgJmDxUCA1NHRBJTSU5HQVBPUkUgRE9MTEFSDQpkAhcPZBYCZg8VAgNUSEILVEhBSSBCQUhUDQpkAhgPZBYCZg8VAgNVU0QLVVMgRE9MTEFSDQpkAhkPZBYCZg8VAgNWTkQRVklFVE5BTUVTRSBET05HDQpkAgEPFgIfBwUFRGFpbHlkAgMPDxYCHwcFBlNlYXJjaGRkAgQPFgIfBwUERnJvbWQCBg8WAh8HBQJUb2QCCA8PFgIfBwUGU2VhcmNoZGQCCQ8WAh8HBQtMYXN0IFVwZGF0ZWQCCg8WAh8HBQwyIEFwcmlsIDIwMjZkAg4PZBYMAgEPFgIfBwUKQ3VycmVuY2llc2QCAw8WAh8HBQVWYWx1ZWQCBQ8WAh8HBQRTZWxsZAIHDxYCHwcFA0J1eWQCCQ8WAh8HBQVHcmFwaGQCCw8UKwACDxYEHwVnHwYCGmRkFgJmD2QWNAIBD2QWBGYPFQQFQUVEICABMQg0LDY1My40NQg0LDYwNS4yN2QCAQ8PFgIeD0NvbW1hbmRBcmd1bWVudAUFQUVEICBkZAICD2QWBGYPFQQFQVVEICABMQkxMSw4MzkuNTkJMTEsNzIwLjA5ZAIBDw8WAh8JBQVBVUQgIGRkAgMPZBYEZg8VBAVCTkQgIAExCTEzLDMwNy42NAkxMywxNjcuMDJkAgEPDxYCHwkFBUJORCAgZGQCBA9kFgRmDxUEBUNBRCAgATEJMTIsMjg2LjYzCTEyLDE2MC44N2QCAQ8PFgIfCQUFQ0FEICBkZAIFD2QWBGYPFQQFQ0hGICABMQkyMSw1MDkuMzMJMjEsMjkyLjYyZAIBDw8WAh8JBQVDSEYgIGRkAgYPZBYEZg8VBAVDTkggIAExCDIsNDg0LjAxCDIsNDU4LjUxZAIBDw8WAh8JBQVDTkggIGRkAgcPZBYEZg8VBAVDTlkgIAExCDIsNDg0LjMwCDIsNDU5LjI5ZAIBDw8WAh8JBQVDTlkgIGRkAggPZBYEZg8VBAVES0sgIAExCDIsNjQ4LjYyCDIsNjIyLjEwZAIBDw8WAh8JBQVES0sgIGRkAgkPZBYEZg8VBAVFVVIgIAExCTE5LDc5MS44OAkxOSw1OTMuMjZkAgEPDxYCHwkFBUVVUiAgZGQCCg9kFgRmDxUEBUdCUCAgATEJMjIsNjY3LjYzCTIyLDQ0MC4zOWQCAQ8PFgIfCQUFR0JQICBkZAILD2QWBGYPFQQFSEtEICABMQgyLDE4MC4xMwgyLDE1OC4xNmQCAQ8PFgIfCQUFSEtEICBkZAIMD2QWBGYPFQQFSlBZICADMTAwCTEwLDc2Mi4xMgkxMCw2NTMuNjlkAgEPDxYCHwkFBUpQWSAgZGQCDQ9kFgRmDxUEBUtSVyAgATEFMTEuMzQFMTEuMjJkAgEPDxYCHwkFBUtSVyAgZGQCDg9kFgRmDxUEBUtXRCAgATEJNTUsNzEyLjQ2CTU1LDE0MC4xMmQCAQ8PFgIfCQUFS1dEICBkZAIPD2QWBGYPFQQFTEFLICABMQQwLjc4BDAuNzZkAgEPDxYCHwkFBUxBSyAgZGQCEA9kFgRmDxUEBU1ZUiAgATEINCwyNDguMzkINCwxOTcuNzZkAgEPDxYCHwkFBU1ZUiAgZGQCEQ9kFgRmDxUEBU5PSyAgATEIMSw3NjMuODQIMSw3NDMuMzVkAgEPDxYCHwkFBU5PSyAgZGQCEg9kFgRmDxUEBU5aRCAgATEIOSw4MzAuMTYIOSw3MzAuNjVkAgEPDxYCHwkFBU5aRCAgZGQCEw9kFgRmDxUEBVBHSyAgATEINCwxMDAuODgIMyw3NzIuNDlkAgEPDxYCHwkFBVBHSyAgZGQCFA9kFgRmDxUEBVBIUCAgATEGMjgzLjc2BjI4MC43NmQCAQ8PFgIfCQUFUEhQICBkZAIVD2QWBGYPFQQFU0FSICABMQg0LDU1Mi44OQg0LDUwNi4zOWQCAQ8PFgIfCQUFU0FSICBkZAIWD2QWBGYPFQQFU0VLICABMQgxLDgxNS41MQgxLDc5Ni43N2QCAQ8PFgIfCQUFU0VLICBkZAIXD2QWBGYPFQQFU0dEICABMQkxMywzMDMuNTAJMTMsMTcwLjEwZAIBDw8WAh8JBQVTR0QgIGRkAhgPZBYEZg8VBAVUSEIgIAExBjUyNC40NgY1MTguNzdkAgEPDxYCHwkFBVRIQiAgZGQCGQ9kFgRmDxUEBVVTRCAgATEJMTcsMDg3LjAxCTE2LDkxNi45OWQCAQ8PFgIfCQUFVVNEICBkZAIaD2QWBGYPFQQFVk5EICABMQQwLjY1BDAuNjRkAgEPDxYCHwkFBVZORCAgZGQCEA9kFggCAQ8WAh8HBQRCYWNrZAIDDw8WAh8HBR1FWENIQU5HRSBSQVRFUyBPTiBUUkFOU0FDVElPTmRkAgkPPCsAEQIBEBYAFgAWAAwUKwAAZAILDzwrABECARAWABYAFgAMFCsAAGQCRQ9kFgICAQ9kFgICAQ9kFgJmD2QWAgIBDxQrAAIPFgQfBWcfBgIBZGQWAmYPZBYCAgEPZBYCAgEPZBYCZg8VAlNodHRwczovL3d3dy5iaS5nby5pZC9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmZvcm1hc2kta3Vycy9kZWZhdWx0LmFzcHgjZmxvYXRpbmctMjRCYW5rIEluZG9uZXNpYSBGb3JlaWduIEV4Y2hhbmdlIFRyYW5zYWN0aW9uIFJhdGVz4oCLZAJnD2QWAmYPZBYCZg8UKwACDxYEHwVnHwYCA2RkFgJmD2QWBgIBD2QWAmYPFQIqaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vcHVibGlrYXNpL0thbGVuZGVyCENhbGVuZGFyZAICD2QWAmYPFQIfaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vYXJjaGl2ZQhBcmNoaWV2ZWQCAw9kFgJmDxUCJWh0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL21pbmlzaXRlLmFzcHgITWluaXNpdGVkAmkPZBYCZg9kFgQCAQ8UKwACDxYEHwVnHwYCB2RkFgJmD2QWDgIBD2QWAmYPFQIvaHR0cHM6Ly93d3cuZmFjZWJvb2suY29tL0JhbmtJbmRvbmVzaWFPZmZpY2lhbC8vaHR0cHM6Ly93d3cuYmkuZ28uaWQvU29zaWFsJTIwTWVkaWEvaWNvbi1mYi5zdmdkAgIPZBYCZg8VAilodHRwczovL3d3dy5pbnN0YWdyYW0uY29tL2JhbmtfaW5kb25lc2lhLy9odHRwczovL3d3dy5iaS5nby5pZC9Tb3NpYWwlMjBNZWRpYS9pY29uLWlnLnN2Z2QCAw9kFgJmDxUCMWh0dHBzOi8vd3d3LnlvdXR1YmUuY29tL3VzZXIvQmFua0luZG9uZXNpYUNoYW5uZWw0aHR0cHM6Ly93d3cuYmkuZ28uaWQvU29zaWFsJTIwTWVkaWEvaWNvbi15b3V0dWJlLnN2Z2QCBA9kFgJmDxUCJmh0dHBzOi8vd3d3LnRpa3Rvay5jb20vQGJhbmtfaW5kb25lc2lhM2h0dHBzOi8vd3d3LmJpLmdvLmlkL1Nvc2lhbCUyME1lZGlhL2ljb24tdGlrdG9rLnN2Z2QCBQ9kFgJmDxUCImh0dHBzOi8vdHdpdHRlci5jb20vYmFua19pbmRvbmVzaWE3aHR0cHM6Ly93d3cuYmkuZ28uaWQvU29zaWFsJTIwTWVkaWEvaWNvbi10d2l0dGVyLVhfLnN2Z2QCBg9kFgJmDxUCNGh0dHBzOi8vb3Blbi5zcG90aWZ5LmNvbS9zaG93LzRRMzhpMmxjSnB4dnRKdmNtSnVXV3YzaHR0cHM6Ly93d3cuYmkuZ28uaWQvU29zaWFsJTIwTWVkaWEvU1BPVElGWS1zdmcuc3ZnZAIHD2QWAmYPFQI1aHR0cHM6Ly93aGF0c2FwcC5jb20vY2hhbm5lbC8wMDI5VmFoQTB1UUwyQVR5ZDdmT1NFMzk3aHR0cHM6Ly93d3cuYmkuZ28uaWQvU29zaWFsJTIwTWVkaWEvaWNvbi1XQS1DaGFubmVsLnN2Z2QCAw8UKwACDxYEHwVnHwYCAmRkFgJmD2QWBAIBD2QWAmYPFQI0aHR0cHM6Ly9hcHBzLmFwcGxlLmNvbS9pZC9hcHAvYmktbW9iaWxlL2lkMTE5ODg5OTcyNzZodHRwczovL3d3dy5iaS5nby5pZC9Tb3NpYWwlMjBNZWRpYS9pY29uLWFwcC1zdG9yZS5zdmdkAgIPZBYCZg8VAjtodHRwczovL3BsYXkuZ29vZ2xlLmNvbS9zdG9yZS9hcHBzL2RldGFpbHM%2FaWQ9Y29tLmJpLm1vYmlsZTdodHRwczovL3d3dy5iaS5nby5pZC9Tb3NpYWwlMjBNZWRpYS9pY29uLXBsYXktc3RvcmUuc3ZnZBgLBVJjdGwwMCRQbGFjZUhvbGRlck1haW4kZ182Yzg5ZDRhZF8xMDdmXzQzN2RfYmQ1NF84ZmRhMTdiNTU2YmYkY3RsMDAkZ3ZTZWFyY2hSZXN1bHQxD2dkBStjdGwwMCRVc2VyQ29udHJvbDEkY3RsMDAkTGlzdFZpZXdNZW51Rm9vdGVyDxQrAA5kZGRkZGRkFCsAA2RkZAIDZGRkZgL%2F%2F%2F%2F%2FD2QFRWN0bDAwJGdfZWNjMjU1OWVfNGE2MF80MzdmX2JhNThfODBlYWVlYTZiNGFhJGN0bDAwJExpc3RWaWV3QXBwc1Nvc21lZA8UKwAOZGRkZGRkZDwrAAcAAgdkZGRmAv%2F%2F%2F%2F8PZAUtY3RsMDAkUGxhY2VIb2xkZXJMZWZ0TmF2QmFyJFY0UXVpY2tMYXVuY2hNZW51Dw9kBQZSZWNlbnRkBU9jdGwwMCRQbGFjZUhvbGRlck1haW4kZ182Yzg5ZDRhZF8xMDdmXzQzN2RfYmQ1NF84ZmRhMTdiNTU2YmYkY3RsMDAkTGlzdFZpZXdLdXJzDxQrAA5kZGRkZGRkPCsAGgACGmRkZGYC%2F%2F%2F%2F%2Fw9kBSxjdGwwMCRQbGFjZUhvbGRlclRvcE5hdkJhciRUb3BOYXZpZ2F0aW9uTWVudQ8PZAUOQmFuayBJbmRvbmVzaWFkBV1jdGwwMCRQbGFjZUhvbGRlckJvdHRvbSRnX2UzMDUyYmUzXzY3M2NfNDA1ZV85Y2JlX2E4ODNhMjQ0YzA1MyRjdGwwMCRMaXN0Vmlld090aGVyTGlua3NTbGlkZXIPFCsADmRkZAIDZGRkFCsAAWQCAWRkZGYC%2F%2F%2F%2F%2Fw9kBUVjdGwwMCRnXzk2NzVlZjQ0Xzg5MzlfNDJlMl9hZWZkX2RmMWIxZTk3NTQ4NyRjdGwwMCRMaXN0Vmlld01lbnVIZWFkZXIPFCsADmRkZGRkZGQ8KwAEAAIEZGRkZgL%2F%2F%2F%2F%2FD2QFUmN0bDAwJFBsYWNlSG9sZGVyTWFpbiRnXzZjODlkNGFkXzEwN2ZfNDM3ZF9iZDU0XzhmZGExN2I1NTZiZiRjdGwwMCRndlNlYXJjaFJlc3VsdDIPZ2QFVGN0bDAwJFBsYWNlSG9sZGVyVG9wJGdfNzE3OTc2Y2JfOGI0OF80MjgzXzk4ZDBfYzFmZjVkNjk5YjVkJGN0bDAwJExpc3RWaWV3QnJlYWRjcnVtYg8UKwAOZGRkZGRkZBQrAANkZGQCA2RkZGYC%2F%2F%2F%2F%2Fw9kBUVjdGwwMCRnX2VjYzI1NTllXzRhNjBfNDM3Zl9iYTU4XzgwZWFlZWE2YjRhYSRjdGwwMCRMaXN0Vmlld09TUGxhdGZvcm0PFCsADmRkZGRkZGQUKwACZGQCAmRkZGYC%2F%2F%2F%2F%2Fw9k0fdDg5ROJEmaSe8FIAazpit1QNOZN4DOxeEIXZpaLeU%3D&__VIEWSTATEGENERATOR=FC2F6B36&__SCROLLPOSITIONX=0&__SCROLLPOSITIONY=0&__EVENTVALIDATION=%2FwEdAD5fPwGme843RfwEsPE1wynjMTZk9qLGncDjImqxppn1M6g%2BuGj1e5yNMxNarkQnNGQD%2FMwBujI58QztY2J%2FpZIxTKKThsEAjvBIzZ%2FazVBGeCseMKUY4FMnWOlaC4KYRMoqTRQkqOJA6zqRb4gMmtkgdx4UmW%2F7xcCfcKpKuvlz1%2Fn%2B9iGjf1yV0RPm%2B5CWNSgnxDJcvG1lEz%2Frc5StNmfqzcjpUZgS1ZX3d1EsQPAXraQs8icFer7v4LiV0lOOQsYkRT4zcerzyfUynDciQYKEq2lCtoHbb2hEni9ouOVEsm39Q00Fw17NOnm%2BozuW3CEwhfeQ2efgxu21Am0Xz33Z7DSMYxpJZKkihQpkRJvnuxXI27Xo9WTRzpFAqk0jLOR7yK6AgeEFi9%2Bu9QgiqdWHV43515M7TTl7yog%2BeChWakHqaPzhK6mK7oXe3z1Y%2FmxT7soP%2FalJ1OhQFU9%2FcTZdT86o%2BG0OT8tvJC5ae6RpK5mq6v%2BczfdP%2Bmy7NXpJ10ozzPUicZg0tsnR9pSA4MkFxSitqMXfoolGmE6GUUl2K5sL2zr2gw1Ecm04IkZ0%2FdPm%2B6NSzvtshRKHOBYURGG%2Ft4wdwgJiBPDE5CsYa%2FofAebObvLUToLFFFUcOA%2FvYuryS2OE5Hg4CA3d6DOoZaQxpxRBNFeDpaMAVVOs0lpH%2F%2BwY0WwoRdjFfqfhAqGeqa3Br28GzRrOR7o1YGWZsPDbuJmlp7jH35v0dcMRth%2Fkxf2ZxlBMrDRMuVgAWL2eRVf7X1zQvWcCOjjl0ejAC%2Bpyie8n0dVD2DOZ%2Fex1pANqnjtB9wxs4OS9Z2gAVh9%2FhP7iwQfY7NduX5ufutrTu8GQmOksuxcPOlo8LRC6lfUzWCeiY25rN0dyS2kHWGOLy%2BZ2zV0tAij06DHnycDDr9GcLbfwn9ozbra6EC0Z1FbCnsHKXYsh7eVy0%2B7zWcYIt7bbaUpWxXuZ0NecmjLcFda1lIZJdkNplB3BstzJsVdUyQHi3jkf1KoJnHceAFWAIlz2mfjyVIv5Sjt2AxeSkjLTCPBwnjM99olJgNCsJpgKW0UC3to7K60JXTWSBxmhAuYViN93nQ6%2B48B8esRgMbNKylMv4%2BxB3WNEOQHn0exjr9ErOzhjTsya3v77e9g1MLjA7%2F1%2Bel5DNfhcSXlZnxX8OM7SY2OjlPjYIcqlT%2F1kbIjHo1RoCoBOdKtPJM9iMrI2UtOvCGtbTiPlI23w2O6l4j3FR%2Fn12JgTE84Akvn%2F29zOw3KyOSJGJryE51hrVCFHIyqh9avaCdFUenvHgQvjtqLtNevYkENLUS02AUyBYW9w%2BQBP9yykaI8C%2FhOJh%2BPSn8FIUpZGYp8gfv9oKqCm&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24ddlmatauang1=AED++&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtFrom=01-Mar-2026&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtTo=05-Mar-2026&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtTanggal=&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24btnSearch1=Search&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24hidSourceID=ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1
headers:
Accept-Encoding:
- gzip;q=1.0,deflate;q=0.6,identity;q=0.3
Accept:
- "*/*"
User-Agent:
- Mozilla/5.0 (compatible; Frankfurter/2.0; +https://frankfurter.dev)
Host:
- www.bi.go.id
Cookie:
- ''
Referer:
- https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
Content-Type:
- application/x-www-form-urlencoded
response:
status:
code: 200
message: OK
headers:
Cache-Control:
- private
Content-Type:
- text/html; charset=utf-8
Vary:
- Accept-Encoding
X-Sharepointhealthscore:
- ''
Sprequestguid:
- a8d406a2-7cb2-c0de-c56e-9352db4420e1
Request-Id:
- a8d406a2-7cb2-c0de-c56e-9352db4420e1
Strict-Transport-Security:
- max-age=31536000; includeSubDomains; preload
X-Frame-Options:
- SAMEORIGIN
Content-Security-Policy:
- frame-ancestors 'self' teams.microsoft.com *.teams.microsoft.com *.skype.com
*.teams.microsoft.us local.teams.office.com *.powerapps.com *.yammer.com *.officeapps.live.com
*.office.com *.stream.azure-test.net *.microsoftstream.com *.dynamics.com
*.microsoft.com onedrive.live.com *.onedrive.live.com;
Sprequestduration:
- '238'
Spiislatency:
- '0'
Microsoftsharepointteamservices:
- ''
X-Ms-Invokeapp:
- 1; RequireReadOnly
X-Xss-Protection:
- 1; mode=block
Date:
- Sun, 05 Apr 2026 00:49:25 GMT
Set-Cookie:
- TS0163f88e=01374ae98b84276d4dcbc8ec843bd01fd6c38ccf170057c93e86e2f5dfe7b6bdce4c80a6790b965ec8f646581247e79f971536aee6;
Path=/
- cookie_BIWEB=!C41xi7Nh8yr8n+QoDRl+P44g/gfW3mIUhLIWAPGDnTkMhyqv/doq5g0xugs9j7OV9pAYfykkfFcTi/Wku4VlLAS5X24yLbdEmrqa9kQz;
path=/; Httponly; Secure
Connection:
- Keep-Alive
Transfer-Encoding:
- chunked
body:
encoding: ASCII-8BIT
string: !binary |-

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html dir="ltr" lang="en-US">

    <head><meta name="keywords" content="Bank Indonesia, BI, Rupiah, kurs BI, kurs tengah BI, kalkulator kurs, inflasi, kurs transaksi, JISDOR, PINTAR BI, BI Fast, bank sentral, QRIS, uang Rupiah, SIMODIS, Sobat Rupiah, Cadangan Devisa, Gubernur Bank Indonesia, uang, bank, CBP, Cinta Bangga Rupiah, Cinta Rupiah, JIBOR, IndONIA" /><meta name="robots" content="index, follow" /><meta name="Author" content="Bank Indonesia" /><meta name="GENERATOR" content="Microsoft SharePoint" /><meta http-equiv="Content-type" content="text/html; charset=utf-8" /><meta http-equiv="X-UA-Compatible" content="IE=11; IE=10" /><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" /><meta name="viewport" content="width=device-width, initial-scale=1" /><meta http-equiv="X-UA-Compatible" content="IE=10"/><script type='text/javascript'>var _browserisFlight = true;</script><meta http-equiv="Expires" content="0" /><meta name="msapplication-TileImage" content="/_layouts/15/images/SharePointMetroAppTile.png" /><meta name="msapplication-TileColor" content="#0072C6" /><title>
	Foreign Exchange Rates
</title><link rel="shortcut icon" href="/favicon.png" type="image/vnd.microsoft.icon" id="favicon" /><link id="CssLink-48064803c727466a9df3f494e8372a07" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/Themable/corev15.css?rev=UP2nlZLed9gOy%2BMP38oz0A%3D%3DTAG0"/>
<link id="CssLink-eabced0807bd4f67a275521f1f216e28" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/SuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ%3D%3DTAG0"/>
<style id="SPThemeHideForms" type="text/css">body {opacity:0 !important}</style><script type="text/javascript">// <![CDATA[ 

var g_SPOffSwitches={};
// ]]>
</script>
<script type="text/javascript" src="/_layouts/15/1033/initstrings.js?rev=94%2F8Pzbtowd6g2cd%2FsOoIg%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/init.js?rev=eqiUN2EN5Xn%2F2YyfuJQDtA%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/theming.js?rev=SuLUbbwTXcxFWOWLFUsOkw%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=sa1PqOHf5j2-6ssMNtdqimFp8nte-oIkdwJ1eOlUHUtOp0vjD2ImoMOMcCHq1bp0xvsD4Z3e86bZnUB2GeqPAZ5tXV4_nTT2jYY2_isi_31MH0efbPRKDe01qwHMlhjCqLYGR-Z4R_iUcMTmpehd2gzVBx3-AFsGfQMAjUkrTW2nxC2ljpAK-Lzwgqii3l2k0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=KvY94j2NghrBo6dT9b1k169bI6meVaRfhNlBBvNxLwKSSwkjBP3MBZHoPl9f9rloh9rNbh8ojtrmFM5d9fu_pn052DtTQVrukBbiH42jb3KYVgH6ktRQ-N9tLXZaVfnOiMT6hM1r-FY7atAipPNrcmQHuNtbk-ilaUaQ4QiBaTJCYyFOuHhrtEDu9ZQfUWGH0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/suitenav.js?rev=VM%2FdyE40A0OgsmOI%2BIKIqQ%3D%3DTAG0"></script>
<script type="text/javascript">RegisterSod("require.js", "\u002f_layouts\u002f15\u002frequire.js?rev=bv3fWJhk0uFGpVwBxnZKNQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("strings.js", "\u002f_layouts\u002f15\u002f1033\u002fstrings.js?rev=qTd5Iu3wkfWjQOhKADG18A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.res.resx", "\u002f_layouts\u002f15\u002f1033\u002fsp.res.js?rev=FnWveYddVjlqQYS2ZBOOzA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.runtime.js", "\u002f_layouts\u002f15\u002fsp.runtime.js?rev=ieBn\u00252FPr8FuV9095CsVXFdw\u00253D\u00253DTAG0");RegisterSodDep("sp.runtime.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.js", "\u002f_layouts\u002f15\u002fsp.js?rev=Os4G339\u00252BEf5vdNuG9dSWtw\u00253D\u00253DTAG0");RegisterSodDep("sp.js", "sp.runtime.js");RegisterSodDep("sp.js", "sp.ui.dialog.js");RegisterSodDep("sp.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.init.js", "\u002f_layouts\u002f15\u002fsp.init.js?rev=GcX1\u00252BQkwU9iewwepsza2Kw\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.dialog.js", "\u002f_layouts\u002f15\u002fsp.ui.dialog.js?rev=d7y1SiSVwqLJzuIiMAukpg\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.dialog.js", "sp.init.js");RegisterSodDep("sp.ui.dialog.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("core.js", "\u002f_layouts\u002f15\u002fcore.js?rev=OuK8lknoOD37VvjQyOsHrw\u00253D\u00253DTAG0");RegisterSodDep("core.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("menu.js", "\u002f_layouts\u002f15\u002fmenu.js?rev=WMbI5XqdDKTzX20rarEQsQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("mQuery.js", "\u002f_layouts\u002f15\u002fmquery.js?rev=wdHoEUjBno2g0ULGFwFjAg\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("callout.js", "\u002f_layouts\u002f15\u002fcallout.js?rev=yFnKkBSYasfA2rW6krdVFQ\u00253D\u00253DTAG0");RegisterSodDep("callout.js", "strings.js");RegisterSodDep("callout.js", "mQuery.js");RegisterSodDep("callout.js", "core.js");</script>
<script type="text/javascript">RegisterSod("sp.core.js", "\u002f_layouts\u002f15\u002fsp.core.js?rev=LSKJVyPWTBdDAU6EL2A6kw\u00253D\u00253DTAG0");RegisterSodDep("sp.core.js", "strings.js");RegisterSodDep("sp.core.js", "sp.init.js");RegisterSodDep("sp.core.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clienttemplates.js", "\u002f_layouts\u002f15\u002fclienttemplates.js?rev=oZO8iLnMIX278DJXZp9S4A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sharing.js", "\u002f_layouts\u002f15\u002fsharing.js?rev=z7dWWrP\u00252FqzzxvtLQKR08Ww\u00253D\u00253DTAG0");RegisterSodDep("sharing.js", "strings.js");RegisterSodDep("sharing.js", "mQuery.js");RegisterSodDep("sharing.js", "clienttemplates.js");RegisterSodDep("sharing.js", "core.js");</script>
<script type="text/javascript">RegisterSod("suitelinks.js", "\u002f_layouts\u002f15\u002fsuitelinks.js?rev=hNe7S\u00252B4EVV83bzPy9U\u00252BEvQ\u00253D\u00253DTAG0");RegisterSodDep("suitelinks.js", "strings.js");RegisterSodDep("suitelinks.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clientrenderer.js", "\u002f_layouts\u002f15\u002fclientrenderer.js?rev=Evu1eqGPwP\u00252FeN5ZuIpaSTQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("srch.resources.resx", "\u002f_layouts\u002f15\u002f1033\u002fsrch.resources.js?rev=vZPcBJM2l80oZNzRUCRQ4g\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("search.clientcontrols.js", "\u002f_layouts\u002f15\u002fsearch.clientcontrols.js?rev=xgTuNRzK\u00252B28qr6bjGThpIw\u00253D\u00253DTAG0");RegisterSodDep("search.clientcontrols.js", "sp.init.js");RegisterSodDep("search.clientcontrols.js", "clientrenderer.js");RegisterSodDep("search.clientcontrols.js", "srch.resources.resx");</script>
<script type="text/javascript">RegisterSod("sp.search.js", "\u002f_layouts\u002f15\u002fsp.search.js?rev=eMyDf7ZGV6rTjB2sDSdovA\u00253D\u00253DTAG0");RegisterSodDep("sp.search.js", "sp.init.js");RegisterSodDep("sp.search.js", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("ajaxtoolkit.js", "\u002f_layouts\u002f15\u002fajaxtoolkit.js?rev=I3jVxnVkBqeUZ\u00252FWA\u00252BgwTLg\u00253D\u00253DTAG0");RegisterSodDep("ajaxtoolkit.js", "search.clientcontrols.js");</script>
<script type="text/javascript">RegisterSod("userprofile", "\u002f_layouts\u002f15\u002fsp.userprofiles.js?rev=J0M1pzLkfDXcJflabMvTYA\u00253D\u00253DTAG0");RegisterSodDep("userprofile", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("followingcommon.js", "\u002f_layouts\u002f15\u002ffollowingcommon.js?rev=MgAestdI8p64n4UsP1Xeug\u00253D\u00253DTAG0");RegisterSodDep("followingcommon.js", "strings.js");RegisterSodDep("followingcommon.js", "sp.js");RegisterSodDep("followingcommon.js", "userprofile");RegisterSodDep("followingcommon.js", "core.js");RegisterSodDep("followingcommon.js", "mQuery.js");</script>
<script type="text/javascript">RegisterSod("profilebrowserscriptres.resx", "\u002f_layouts\u002f15\u002f1033\u002fprofilebrowserscriptres.js?rev=qwf69WaVc1mYlJLXqmZmVA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.mysitecommon.js", "\u002f_layouts\u002f15\u002fsp.ui.mysitecommon.js?rev=5nRJiZWvHP3AB7VS14cjuw\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.mysitecommon.js", "sp.init.js");RegisterSodDep("sp.ui.mysitecommon.js", "sp.runtime.js");RegisterSodDep("sp.ui.mysitecommon.js", "userprofile");RegisterSodDep("sp.ui.mysitecommon.js", "profilebrowserscriptres.resx");</script>
<script type="text/javascript">RegisterSod("browserScript", "\u002f_layouts\u002f15\u002fnon_ie.js?rev=KT6LY54Wt0vnHyVV6VVzWw\u00253D\u00253DTAG0");RegisterSodDep("browserScript", "strings.js");</script>
<script type="text/javascript">RegisterSod("inplview", "\u002f_layouts\u002f15\u002finplview.js?rev=ecdG8BqIlGbfoftF0\u00252FIAZA\u00253D\u00253DTAG0");RegisterSodDep("inplview", "strings.js");RegisterSodDep("inplview", "core.js");RegisterSodDep("inplview", "clienttemplates.js");RegisterSodDep("inplview", "sp.js");</script>
<script type="text/javascript">RegisterSod("cui.js", "\u002f_layouts\u002f15\u002fcui.js?rev=ejf8nksDjeL2s1mvUvw77w\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("ribbon", "\u002f_layouts\u002f15\u002fsp.ribbon.js?rev=wPDmc1LZubpR2Fgk01M8qw\u00253D\u00253DTAG0");RegisterSodDep("ribbon", "strings.js");RegisterSodDep("ribbon", "core.js");RegisterSodDep("ribbon", "sp.core.js");RegisterSodDep("ribbon", "sp.js");RegisterSodDep("ribbon", "cui.js");RegisterSodDep("ribbon", "sp.res.resx");RegisterSodDep("ribbon", "sp.runtime.js");RegisterSodDep("ribbon", "inplview");</script>
<script type="text/javascript">RegisterSod("WPAdderClass", "\u002f_layouts\u002f15\u002fwpadder.js?rev=cLi8ZAp2DVY4x\u00252BMDFIRWvQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("dragdrop.js", "\u002f_layouts\u002f15\u002fdragdrop.js?rev=h\u00252F2Jd5ursJLUu88iNs\u00252FM2A\u00253D\u00253DTAG0");RegisterSodDep("dragdrop.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("quicklaunch.js", "\u002f_layouts\u002f15\u002fquicklaunch.js?rev=yuA4NhRQlmo9X6TJsaidUg\u00253D\u00253DTAG0");RegisterSodDep("quicklaunch.js", "strings.js");RegisterSodDep("quicklaunch.js", "dragdrop.js");</script>
<link type="text/xml" rel="alternate" href="/en/statistik/informasi-kurs/transaksi-bi/_vti_bin/spsdisco.aspx" /><link href="/Style Library/biweb/css/bootstrap4.min.css" rel="stylesheet" />
        
        <!-- Update Font Family 1 Februari 2024 -->
        <link rel="preconnect" href="https://fonts.googleapis.com" /><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin="" />
		<!-- Update Font Family 2 Februari 2026 -->
		<link href="https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,400;1,300&amp;display=swap" integrity="sha512-e2mrHtfsfL/rkAg+Q3rQpEIkWMdGU36OfDwUIJz4nyq7/pevf44ZAXwTt1/mr8mLsnPJbslCx85k+qRTTZIDjA==" crossorigin="anonymous" rel="stylesheet" /><link href="https://fonts.googleapis.com/css2?family=PT+Sans&amp;display=swap" integrity="sha512-pZRQvRtRsHut00kYTpiGGYlYLiGNEP+/efrLNNzhAxe/uT3UiRpLYUEqXW1+zwVvWAxWrVyYxrDT6tDShkc2lA==" crossorigin="anonymous" rel="stylesheet" /><link href="/Style Library/biweb/css/maincss.min.css" rel="stylesheet" />
        
        <!--<script src="/Style Library/biweb/js/jquery-3.4.1.min.js" type="text/javascript"></script>-->
        <script src="/Style Library/biweb/js/jquery-3.5.1.min.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/bootstrap4.min.js" type="text/javascript"></script>        
        <script src="/Style Library/biweb/js/jquery.scollingTabs.min.js" type="text/javascript"></script>       
        <script src="/Style Library/biweb/js/mainjs.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/jquery.dataTables.min.js" type="text/javascript"></script>
        <link href="/Style Library/biweb/css/jquery.dataTables.min.css" rel="stylesheet" />
                
		<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
		new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
		j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
		'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
		})(window,document,'script','dataLayer','GTM-TX6N9KL');</script>
		<script>
			  $(document).ready(function() {
			    if (window.location.href.indexOf("/en/") > -1) {
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia has one single objective of achieving and maintaining stability of the Rupiah value." />' );
							    }
			    else{
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia adalah Bank Sentral Republik Indonesia dengan Satu Tujuan Tunggal yaitu Mencapai dan Memelihara Kestabilan Nilai Rupiah." />' );
							    }
			  });
		</script>
		<script  type="text/javascript">
			$(document).ready(function(){
				setTimeout(function () {
					$('#ctl00_onetidProjectPropertyTitleGraphic').attr("title", "Bank Indonesia")
			        if (window.location.href.indexOf("/en/") > -1) {
			           $('#ctl00_onetidProjectPropertyTitleGraphic').attr('href', '/en/');
			        }
			    }, 500); 	
			    
				$('#tablecustom').DataTable();		
			});
		</script>
		
        
            
	<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
    <script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>
    <script type="text/javascript">
        $(window).ready(function () {
            $('#selectPeriod').change(function () {
                $('.datepicker-period').hide();
                $('#' + $(this).val()).show();
            });



            var date_input_harian = $('.input-daterange-harian input');
            var options = {
                format: 'mm/dd/yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto"
            };
            date_input_harian.datepicker(options);
        });
    </script>

            <link rel="canonical" href="https://www.bi.go.id:443/en/statistik/informasi-kurs/transaksi-bi/default.aspx" />
            
        </head>

    <body>
	<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TX6N9KL"
	height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
      <div id="imgPrefetch" style="display:none">
<img src="/favicon.png?rev=43" />
<img src="/_layouts/15/images/spcommon.png?rev=43" />
<img src="/SiteAssets/logo-bi@2x.png?rev=43" />
</div>

        <noscript><div class='noindex'>You may be trying to access this site from a secured browser on the server. Please enable scripts and reload this page.</div></noscript>
        
        <form method="post" action="./default.aspx" onsubmit="javascript:return WebForm_OnSubmit();" id="aspnetForm">
<div class="aspNetHidden">
<input type="hidden" name="_wpcmWpid" id="_wpcmWpid" value="" />
<input type="hidden" name="wpcmVal" id="wpcmVal" value="" />
<input type="hidden" name="MSOWebPartPage_PostbackSource" id="MSOWebPartPage_PostbackSource" value="" />
<input type="hidden" name="MSOTlPn_SelectedWpId" id="MSOTlPn_SelectedWpId" value="" />
<input type="hidden" name="MSOTlPn_View" id="MSOTlPn_View" value="0" />
<input type="hidden" name="MSOTlPn_ShowSettings" id="MSOTlPn_ShowSettings" value="False" />
<input type="hidden" name="MSOGallery_SelectedLibrary" id="MSOGallery_SelectedLibrary" value="" />
<input type="hidden" name="MSOGallery_FilterString" id="MSOGallery_FilterString" value="" />
<input type="hidden" name="MSOTlPn_Button" id="MSOTlPn_Button" value="none" />
<input type="hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
<input type="hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
<input type="hidden" name="__REQUESTDIGEST" id="__REQUESTDIGEST" value="0x7CEFA56864A9EC24B8834706AD7AF84DEE4A204F6FD16E402913A618B695F3832119B0ADC2AD9C3242E8A91F20A0B07AC956E4CB582CB495B9718FD0C4189B5C,05 Apr 2026 00:49:26 -0000" />
<input type="hidden" name="MSOSPWebPartManager_DisplayModeName" id="MSOSPWebPartManager_DisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_ExitingDesignMode" id="MSOSPWebPartManager_ExitingDesignMode" value="false" />
<input type="hidden" name="MSOWebPartPage_Shared" id="MSOWebPartPage_Shared" value="" />
<input type="hidden" name="MSOLayout_LayoutChanges" id="MSOLayout_LayoutChanges" value="" />
<input type="hidden" name="MSOLayout_InDesignMode" id="MSOLayout_InDesignMode" value="" />
<input type="hidden" name="_wpSelected" id="_wpSelected" value="" />
<input type="hidden" name="_wzSelected" id="_wzSelected" value="" />
<input type="hidden" name="MSOSPWebPartManager_OldDisplayModeName" id="MSOSPWebPartManager_OldDisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_StartWebPartEditingName" id="MSOSPWebPartManager_StartWebPartEditingName" value="false" />
<input type="hidden" name="MSOSPWebPartManager_EndWebPartEditing" id="MSOSPWebPartManager_EndWebPartEditing" value="false" />
<input type="hidden" name="_maintainWorkspaceScrollPosition" id="_maintainWorkspaceScrollPosition" value="0" />
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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" />
</div>

<script type="text/javascript">
//<![CDATA[
var theForm = document.forms['aspnetForm'];
if (!theForm) {
    theForm = document.aspnetForm;
}
function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
        theForm.__EVENTTARGET.value = eventTarget;
        theForm.__EVENTARGUMENT.value = eventArgument;
        theForm.submit();
    }
}
//]]>
</script>


<script src="/WebResource.axd?d=HRMEYubZPUzVts77E_7Ik1yT-44y5_IDixxutdmFieYdhwteoLUd0gvCyyYvKy3z7ple1Au9_czBVt-tA8fqYJ7_DchPiphcRPRL6mZmE2M1&amp;t=638259656865233147" type="text/javascript"></script>


<script type="text/javascript">
//<![CDATA[
var MSOWebPartPageFormName = 'aspnetForm';
var g_presenceEnabled = true;
var g_wsaEnabled = false;

var g_correlationId = 'a8d406a2-7cb2-c0de-c56e-9352db4420e1';
var g_wsaQoSEnabled = false;
var g_wsaQoSDataPoints = [];
var g_wsaRUMEnabled = false;
var g_wsaLCID = 1033;
var g_wsaListTemplateId = null;
var g_wsaSiteTemplateId = 'CMSPUBLISHING#0';
var _spPageContextInfo={"webServerRelativeUrl":"/en/statistik/informasi-kurs/transaksi-bi","webAbsoluteUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","viewId":"","listId":"","listPermsMask":null,"listUrl":"","listTitle":null,"listBaseTemplate":-1,"viewOnlyExperienceEnabled":false,"blockDownloadsExperienceEnabled":false,"idleSessionSignOutEnabled":false,"cdnPrefix":"","siteAbsoluteUrl":"https://www.bi.go.id","siteId":"{e671e14c-2777-404f-9b86-2f3b332aa0f1}","showNGSCDialogForSyncOnTS":false,"supportPoundStorePath":true,"supportPercentStorePath":true,"siteSubscriptionId":null,"CustomMarkupInCalculatedFieldDisabled":true,"AllowCustomMarkupInCalculatedField":false,"isSPO":false,"farmLabel":null,"serverRequestPath":"/en/statistik/informasi-kurs/transaksi-bi/default.aspx","layoutsUrl":"_layouts/15","webId":"{18d3b9c9-56e5-44c2-9518-566e5ed25d9a}","webTitle":"Foreign Exchange Rates","webTemplate":"39","webTemplateConfiguration":"CMSPUBLISHING#0","webDescription":"","tenantAppVersion":"0","isAppWeb":false,"webLogoUrl":"/SiteAssets/logo-bi@2x.png","webLanguage":1033,"currentLanguage":1033,"currentUICultureName":"en-US","currentCultureName":"en-US","currentCultureLCID":1033,"env":null,"nid":0,"fid":0,"serverTime":"2026-04-05T00:49:26.4037716Z","siteClientTag":"2144$$16.0.10417.20037","crossDomainPhotosEnabled":false,"openInClient":false,"Has2019Era":true,"webUIVersion":15,"webPermMasks":{"High":16,"Low":196673},"pageListId":null,"pageItemId":-1,"pagePermsMask":null,"pagePersonalizationScope":1,"userEmail":"","userId":0,"userLoginName":null,"userDisplayName":null,"isAnonymousUser":true,"isAnonymousGuestUser":false,"isEmailAuthenticationGuestUser":false,"isExternalGuestUser":false,"systemUserKey":null,"alertsEnabled":true,"siteServerRelativeUrl":"/","allowSilverlightPrompt":"True","themeCacheToken":"/en/statistik/informasi-kurs/transaksi-bi::9:","themedCssFolderUrl":null,"themedImageFileNames":null,"modernThemingEnabled":true,"isSiteAdmin":false,"ExpFeatures":[480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"killSwitches":{},"InternalValidAuthorities":["www.bi.go.id","web.bi.go.id","dc1biwebapp21","dc1biwebapp22"],"CorrelationId":"a8d406a2-7cb2-c0de-c56e-9352db4420e1","hasManageWebPermissions":false,"isNoScriptEnabled":false,"groupId":null,"groupHasHomepage":true,"groupHasQuickLaunchConversationsLink":false,"departmentId":null,"hubSiteId":null,"hasPendingWebTemplateExtension":false,"isHubSite":false,"isWebWelcomePage":true,"siteClassification":"","hideSyncButtonOnODB":false,"showNGSCDialogForSyncOnODB":false,"sitePagesEnabled":false,"sitePagesFeatureVersion":0,"DesignPackageId":"00000000-0000-0000-0000-000000000000","groupType":null,"groupColor":"#757575","siteColor":"#757575","headerEmphasis":0,"navigationInfo":null,"guestsEnabled":false,"MenuData":{"SignInUrl":"/en/statistik/informasi-kurs/transaksi-bi/_layouts/15/Authenticate.aspx?Source=%2Fen%2Fstatistik%2Finformasi%2Dkurs%2Ftransaksi%2Dbi%2Fdefault%2Easpx"},"RecycleBinItemCount":-1,"PublishingFeatureOn":true,"PreviewFeaturesEnabled":false,"disableAppViews":false,"disableFlows":false,"serverRedirectedUrl":null,"formDigestValue":"0x7CEFA56864A9EC24B8834706AD7AF84DEE4A204F6FD16E402913A618B695F3832119B0ADC2AD9C3242E8A91F20A0B07AC956E4CB582CB495B9718FD0C4189B5C,05 Apr 2026 00:49:26 -0000","maximumFileSize":10240,"formDigestTimeoutSeconds":1800,"canUserCreateMicrosoftForm":false,"canUserCreateVisioDrawing":true,"readOnlyState":null,"isTenantDevSite":false,"preferUserTimeZone":false,"userTimeZoneData":null,"userTime24":false,"userFirstDayOfWeek":null,"webTimeZoneData":null,"webTime24":false,"webFirstDayOfWeek":null,"isSelfServiceSiteCreationEnabled":null,"alternateWebAppHost":"","aadTenantId":"","aadUserId":"","aadInstanceUrl":"","msGraphEndpointUrl":"https://","allowInfectedDownload":true};_spPageContextInfo.updateFormDigestPageLoaded=new Date();_spPageContextInfo.clientServerTimeDelta=new Date(_spPageContextInfo.serverTime)-new Date();if(typeof(define)=='function'){define('SPPageContextInfo',[],function(){return _spPageContextInfo;});}
function _spNavigateHierarchy(nodeDiv, dataSourceId, dataPath, url, listInContext, type) {

    CoreInvoke('ProcessDefaultNavigateHierarchy', nodeDiv, dataSourceId, dataPath, url, listInContext, type, document.forms.aspnetForm, "", "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002fdefault.aspx");

}
Flighting.ExpFeatures = [480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; (function()
{
    if(typeof(window.SP) == "undefined") window.SP = {};
    if(typeof(window.SP.YammerSwitch) == "undefined") window.SP.YammerSwitch = {};

    var ysObj = window.SP.YammerSwitch;
    ysObj.IsEnabled = false;
    ysObj.TargetYammerHostName = "www.yammer.com";
} )(); //]]>
</script>

<script src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0" type="text/javascript"></script>
<script type="text/javascript">
//<![CDATA[
window.SPThemeUtils && SPThemeUtils.RegisterCssReferences([{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","Id":"CssLink-48064803c727466a9df3f494e8372a07","ConditionalExpression":"","After":"","RevealToNonIE":"false"},{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","Id":"CssLink-eabced0807bd4f67a275521f1f216e28","ConditionalExpression":"","After":"","RevealToNonIE":"false"}]);
(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingDocument', function() { FollowingDocument(); });
        });
    })();(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingCallout', function() { FollowingCallout(); });
        });
    })();if (typeof(DeferWebFormInitCallback) == 'function') DeferWebFormInitCallback();function WebForm_OnSubmit() {
UpdateFormDigest('\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi', 1440000);
                    var workspaceElem = GetCachedElement("s4-workspace");
                    if (workspaceElem != null)
                    {
                        var scrollElem = GetCachedElement("_maintainWorkspaceScrollPosition");
                        if (scrollElem != null)
                        {
                            scrollElem.value = workspaceElem.scrollTop;
                        }
                    };
                if (typeof(_spFormOnSubmitWrapper) != 'undefined') {return _spFormOnSubmitWrapper();} else {return true;};
return true;
}
//]]>
</script>

<div class="aspNetHidden">

	<input type="hidden" name="__VIEWSTATEGENERATOR" id="__VIEWSTATEGENERATOR" value="FC2F6B36" />
	<input type="hidden" name="__SCROLLPOSITIONX" id="__SCROLLPOSITIONX" value="0" />
	<input type="hidden" name="__SCROLLPOSITIONY" id="__SCROLLPOSITIONY" value="0" />
	<input type="hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" value="/wEdAAvM6kKhAmox5xjyokhYwXaHMTZk9qLGncDjImqxppn1M7eMHcICYgTwxOQrGGv6HwHmzm7y1E6CxRRVHDgP72Lq8ktjhOR4OAgN3egzqGWkMacUQTRXg6WjAFVTrNJaR//sGNFsKEXYxX6n4QKhnqmtK20/AEkSVHfI/JCTRr8SpUcjKqH1q9oJ0VR6e8eBC+NaeZ5zk4cyCpiarxz3A4I0tqLtNevYkENLUS02AUyBYdcYSQ7cz/EWzniY60FHxuYv61WVpRyOJlmrPdyp3G0I" />
</div>
            <script type="text/javascript">
//<![CDATA[
Sys.WebForms.PageRequestManager._initialize('ctl00$ScriptManager', 'aspnetForm', ['fctl00$WebPartAdderUpdatePanel',''], [], ['ctl00$WebPartAdder',''], 90, 'ctl00');
//]]>
</script>

            
            <script
                type="text/javascript"> var submitHook = function () { return false; }; theForm._spOldSubmit = theForm.submit; theForm.submit = function () { if (!submitHook()) { this._spOldSubmit(); } }; </script>
            <span id="DeltaSPWebPartManager">
            </span>
            <span id="DeltaDelegateControls">
                
                
            </span>
            <div id="TurnOnAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOnAcc"
                    title="Turn on more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(true);UpdateAccessibilityUI();document.getElementById('linkTurnOffAcc').focus();return
                false;">
                Turn on more accessible mode</a></div>
            <div id="TurnOffAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOffAcc"
                    title="Turn off more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(false);UpdateAccessibilityUI();document.getElementById('linkTurnOnAcc').focus();return
                false;">
                Turn off more accessible mode</a></div>
            <div class="s4-notdlg s4-skipribbonshortcut noindex">
                <a href="javascript:;"
                    title="Skip Ribbon Commands"
                onclick="document.getElementById('startNavigation').focus();" class="ms-accessible ms-acc-button"
                accesskey="
                Y">
                Skip Ribbon Commands</a></div>
            <div class="s4-notdlg noindex">
                <a href="javascript:;"
                    title="Skip to main content"
                onclick="document.getElementById('mainContent').focus();" class="ms-accessible ms-acc-button">
                Skip to main content</a></div>
            <div id="TurnOffAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOffAnimation"
                    title="Turn off Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn off Animations</a></div>
            <div id="TurnOnAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOnAnimation"
                    title="Turn on Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn on Animations</a></div>
            <a id="HiddenAnchor" href="javascript:;" style="display:none;"></a>

                <div id="suiteBarDelta" class="ms-dialogHidden ms-fullWidth noindex">
	
                    <div id="suiteMenuData" class="ms-hide">
                        


                        <span class="ms-siteactions-root" id="siteactiontd">
                            
                        </span>
                    </div>
                    <script type="text/javascript">// <![CDATA[ 

var g_navBarHelpDefaultKey = "HelpHome";
		
		 // ]]>
</script>
                    <div id="suiteBarTop" class="ms-fullWidth ms-TopBarBackground-bgColor" style="height:50px; position:relative;">

	</div><div class="wf-family-o365 o365wf" style="display:none">

	</div>
                
</div>

                <div id="ms-hcTest"></div>
                                <div id="s4-ribbonrow">
                    <div id="globalNavBox" class="noindex">
                        <div id="ribbonBox">
                            <div id="s4-ribboncont">
                                <div id="DeltaSPRibbon">
	
                                    

                                    <input id="RibbonContainer_activeTabId" name="ctl00$ctl74" type="hidden" value=""/><div id='RibbonContainer'><div class="ms-cui-ribbon ms-cui-needIEFilter" id="Ribbon" unselectable="on" aria-describedby="ribboninstructions" role="toolbar"><span class="ms-cui-hidden" id="ribboninstructions" unselectable="on">To navigate through the Ribbon, use standard browser navigation keys. To skip between groups, use Ctrl+LEFT or Ctrl+RIGHT. To jump to the first Ribbon tab use Ctrl+[. To jump to the last selected command use Ctrl+]. To activate a command, use Enter.</span><div class="ms-cui-ribbonTopBars" unselectable="on"><div class="ms-cui-topBar1" unselectable="on" style="display:none"><div class="ms-cui-qat-container" unselectable="on"></div></div><div class="ms-cui-topBar2" unselectable="on"><div class="ms-cui-jewel-container" id="jewelcontainer" unselectable="on" style="display:none"></div><div class="ms-cui-TabRowLeft ms-core-defaultFont ms-dialogHidden" id="RibbonContainer-TabRowLeft" unselectable="on">
									
								
                                        </div><ul class="ms-cui-tts" unselectable="on" role="tablist"><li class="ms-cui-tt ms-browseTab ms-cui-tt-s" id="Ribbon.Read-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.Read',false, event);" title="Browse" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.Read',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Browse</span><span class="ms-cui-hidden" unselectable="on">Tab 1 of 2.</span></a></li><li class="ms-cui-tt" id="Ribbon.WebPartPage-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.WebPartPage',false, event);" title="Page" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.WebPartPage',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Page</span><span class="ms-cui-hidden" unselectable="on">Tab 2 of 2.</span></a></li></ul><div class="ms-cui-TabRowRight s4-trc-container s4-notdlg ms-core-defaultFont" id="RibbonContainer-TabRowRight" unselectable="on">
									
								
                                            
                                            <a onmouseover="this.firstChild.firstChild.style.left=&#39;-217px&#39;; this.firstChild.firstChild.style.top=&#39;-192px&#39;;" onmouseout="this.firstChild.firstChild.style.left=&#39;-218px&#39;; this.firstChild.firstChild.style.top=&#39;-48px&#39;;" onclick="SP.SOD.executeFunc(&#39;followingcommon.js&#39;, &#39;FollowSite&#39;, function() { FollowSite(); }); return false;" id="site_follow_button" title="Follow this site and get back to it easily from your sites page." class="ms-promotedActionButton" href="javascript:__doPostBack(&#39;ctl00$site_follow_button&#39;,&#39;&#39;)" style="display:inline-block;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust ms-promotedActionButton-icon"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Follow" style="position:absolute;left:-218px;top:-48px;" /></span><span class="ms-promotedActionButton-text">Follow</span></a>
                                            
                                            
                                            <span id="fullscreenmodebox" class="ms-qatbutton">
                                                <span id="fullscreenmode">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-125px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-143px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_fullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(true);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-143px;top:-178px;" /></span></span></a>
                                                </span>
                                                <span id="exitfullscreenmode" style="display: none;">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-179px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-96px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-107px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_exitfullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(false);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-107px;top:-178px;" /></span></span></a>
                                                </span>
                                            </span>
                                            
                                            
                                        </div></div></div></div></div>
                                
</div>
                            </div>
                            <span id="DeltaSPNavigation">
                                
									<span id="ctl00_SPNavigation_ctl00_publishingRibbon"></span>

                                
                            </span>
                        </div>
                        <div id="DeltaWebPartAdderUpdatePanelContainer" class="ms-core-webpartadder">
	
                            <div id="WebPartAdderUpdatePanelContainer">
                                <div id="ctl00_WebPartAdderUpdatePanel">
		
										<span id="ctl00_WebPartAdder"></span>
									
	</div>
                            </div>
                        
</div>
                    </div>
                </div>

         

            <div id="s4-workspace" class="ms-core-overlay">
                <div id="s4-bodyContainer">
                    <div id="s4-titlerow" class="ms-dialogHidden s4-titlerowhidetitle d-none">
                        <div id="titleAreaBox" class="ms-noList ms-table ms-core-tableNoSpace">
                            <div id="titleAreaRow" class="ms-tableRow">
                                <div class="ms-breadcrumb-box ms-tableCell ms-verticalAlignTop">
                                    <div class="ms-breadcrumb-top">
                                        <div class="ms-breadcrumb-dropdownBox" style="display:none;">
                                            <span id="DeltaBreadcrumbDropdown">
                                                
                                            </span>
                                        </div>
                                        <div id="DeltaTopNavigation" class="ms-displayInline ms-core-navigation" role="navigation">
	
                                            
                                            
												<div id="zz1_TopNavigationMenu" class=" noindex ms-core-listMenu-horizontalBox">
		<ul id="zz2_RootAspMenu" class="root ms-core-listMenu-root static">
			<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" title="Home" href="/default.aspx" accesskey="1"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Bank Indonesia</span><span class="ms-hidden">Currently selected</span></span></a></li>
		</ul>
	</div>
                                            
                                        
</div>
                                    </div>
                                    <h1 id="pageTitle" class="ms-core-pageTitle">
                                        <span id="DeltaPlaceHolderPageTitleInTitleArea">
                                            
												Foreign Exchange Rates
                                            
                                        </span>
                                        <div id="DeltaPlaceHolderPageDescription" class="ms-displayInlineBlock ms-normalWrap">
	
                                            <a href="javascript:;" id="ms-pageDescriptionDiv" style="display:none;"
                                                data-accessibility-nocheck="true">
                                                <span id="ms-pageDescriptionImage">&#160;</span>
                                            </a>
                                            <span class="ms-accessible" id="ms-pageDescription">
                                                
                                            </span>
                                            <script type="text/javascript">// <![CDATA[ 

_spBodyOnLoadFunctionNames.push("setupPageDescriptionCallout");
										
										 // ]]>
</script>
                                        
</div>
                                    </h1>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                    <div id="DeltaPlaceHolderGroupActionsArea" class="ms-floatRight ms-noWrap">
	
                                        
                                    
</div>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                </div>
                            </div>
                        </div>
                    </div>

                    <header class="ms-dialogHidden mega-menu-wrapper noindex">
                        <div class="top-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                        
                                
<div id="ctl00_g_9675ef44_8939_42e2_aefd_df1b1e975487" __MarkupType="vsattributemarkup" __WebPartId="{9675ef44-8939-42e2-aefd-df1b1e975487}" WebPart="true">
	
        <ul class="header-menu navbar-nav">
            
        <li class="nav-item"><a href='https://www.bi.go.id/en/karier' >Career</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/edukasi' >Education</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/glosarium.aspx' >Glossary</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/peta-situs.aspx' >Sitemap</a></li>       
    
        </ul>
    

</div>
                                        
                                
                                    <div id="DeltaPlaceHolderSearchArea" class="ms-mpSearchBox clearfix">
	
                                        
											<div id="searchInputBox">
                                                <div class="ms-webpart-chrome ms-webpart-chrome-fullWidth ">
		<div WebPartID="00000000-0000-0000-0000-000000000000" HasPers="true" id="WebPartWPQ1" width="100%" class="ms-WPBody " OnlyForMePart="true" allowDelete="false" style="" ><div componentid="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"><div id="SearchBox" name="Control"><div class="ms-srch-sb ms-srch-sb-border" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv"><input type="search" value="Search this site" maxlength="2048" title="Search this site" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox" autocomplete="off" autocorrect="off" onkeypress="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {if (Srch.U.isEnterKey(String.fromCharCode(event.keyCode))) {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);return Srch.U.cancelEvent(event);}})" onkeydown="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.activateDefaultQuerySuggestionBehavior();})" onfocus="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.hidePrompt();ctl.setBorder(true);})" onblur="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr'); if (ctl){ ctl.showPrompt(); ctl.setBorder(false);}})" class="ms-textSmall ms-srch-sb-prompt ms-helperText" role="combobox" aria-owns="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" aria-haspopup="true" aria-autocomplete="list" aria-expanded="false" /><a title="Search" role="button" class="ms-srch-sb-searchLink" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink" onclick="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);})" href="javascript: {}" aria-label="Search"><img src="/_layouts/15/images/searchresultui.png?rev=43#ThemeKey=searchresultui" class="ms-srch-sb-searchImg" id="searchImg" alt="Search" /></a><div class="ms-qSuggest-container ms-shadow" id="AutoCompContainer"><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" role="listbox" aria-label="Suggestions"></div></div></div></div></div><noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_noscript">It looks like your browser does not have JavaScript enabled. Please turn on JavaScript and try again.</div></noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1">

		</div><div class="ms-clear"></div></div>
	</div>
                                            </div>
                                        
                                    
</div>

                                    <div id="bahasa-indon" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="ENLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>
                                    <div id="bahasa-english" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="IDLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>


                                </nav>
                            </div>
                        </div>
                        <div class="bottom-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                    <div id="siteIcon" class="ms-tableCell ms-verticalAlignTop">
                                        <div id="DeltaSiteLogo">
	
                                            <a id="ctl00_onetidProjectPropertyTitleGraphic" class="ms-siteicon-a" href="/id/"><img id="ctl00_onetidHeadbnnr2" class="ms-siteicon-img" name="onetidHeadbnnr0" src="/SiteAssets/logo-bi@2x.png" alt="Foreign Exchange Rates" /></a>
                                        
</div>
                                    </div>

                                    <button class="navbar-toggler" type="button" data-toggle="collapse"
                                        data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent"
                                        aria-expanded="false" aria-label="Toggle navigation">
                                        <span class="navbar-toggler-icon"></span>
                                    </button>
                                    
                                    <div class="collapse navbar-collapse navbar-responsive" id="navbarSupportedContent">
										<div class="noindex">
	                                        <div id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7" __MarkupType="vsattributemarkup" __WebPartId="{3e01a6ba-0414-4f22-b082-8b109c19b6c7}" WebPart="true">
	

<ul class="top-menu navbar-nav" id="test-menu">           
    <li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/tentang-bi/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>About BI</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/tentang-bi/profil/Default.aspx'>Profile</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/tentang-bi/profil/organisasi/Default.aspx' > Organization</a></li><li class='level3'><a href = '/en/tentang-bi/profil/governance/default.aspx' >Governance</a></li><li class='level3'><a href = '/en/tentang-bi/profil/uu-bi/Default.aspx' >Regulations</a></li></ul><li><a href = '/en/tentang-bi/sejarah-bi/Default.aspx'> History </a ></li><li><a href = '/en/tentang-bi/transformasi/Default.aspx'> Transformation </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/tentang-BI_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>About BI</p>
                        <p class='dropdown-megamenu__about--description'>Information about the organisation, transformation and history of Bank Indonesia as the central bank of the Republic of Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/fungsi-utama/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Main Functions</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/moneter/Default.aspx'>Monetary</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/moneter/inflasi/Default.aspx' >Inflation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indikator-moneter/default.aspx' >Monetary Indicator</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/bi-rate/default.aspx' >BI-Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/operasi-moneter/Default.aspx' >Monetary Operation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indonia-jibor/Default.aspx' >INDONIA, Compounded INDONIA, INDONIA Index and JIBOR</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/informasi-kurs/default.aspx' >JISDOR, Non-USD/IDR Reference Rate, and Transaction Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pengembangan-ekonomi/Default.aspx' >Sharia Economy and Financial</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/'>Financial System Stability</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/' >Overview</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/instrumen-makroprudensial/default.aspx' >Macroprudential Policy Instrument</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/manajemen-krisis/default.aspx' >Crisis Management Protocol</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/koordinasi-bi-lainnya/' >Institutional Coordination</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/pengembangan-umkm/' >MSME Development</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/keuangan-inklusif/' >Financial Inclusion</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/sistem-pembayaran'>Payment System and Rupiah Currency Management</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/nilai-besar/' >High Value Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/ritel/' >Retail Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/pengelolaan-rupiah/default.aspx' >Rupiah Currency Management</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/perizinan/default.aspx' >Licensing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/anti-pencucian-uang-dan-pencegahan-pendanaan-terrorisme/' >Anti-Money Laundering and Counter-Terrorism Financing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/Standardisasi-Kompetensi/Default.aspx' >Standardisation Of HR Competencies</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/blueprint/default.aspx' >Indonesia Payment System Blueprint</a></li></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Style Library/biweb/img/bi-photo.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Main Functions</p>
                        <p class='dropdown-megamenu__about--description'>Information about the main functions and responsibilities of Bank Indonesia to achieve and maintain rupiah stability.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/rupiah/' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Rupiah</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/rupiah/gambar-uang/Default.aspx'> Currency Image </a ></li><li><a href = '/en/rupiah/uang-dicabut/'> Withdrawn Currency </a ></li><li><a href = '/en/rupiah/pencegahan-rupiah-palsu/'> Counterfeit Prevention and Management </a ></li><li><a href = '/en/rupiah/cinta-bangga-paham-rupiah/default.aspx'> Cinta, Bangga, Paham Rupiah </a ></li><li><a href = '/en/rupiah/digital-rupiah/default.aspx#overview'> Project Garuda: Digital Rupiah </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/rupiah_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Rupiah</p>
                        <p class='dropdown-megamenu__about--description'>Information about the rupiah as the currency of the Republic of Indonesia managed by Bank Indonesia pursuant to prevailing laws and regulations.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/publikasi/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Publications</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='#'>Media Room</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/ruang-media/news-release/' >Latest News (Press Release)</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/cerita-bi/' >Story</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/pidato-dewan-gubernur/' >Board of Governor Speeches</a></li></ul><li><a href = '/en/publikasi/Kalender/'> Calendar </a ></li><li><a href = '/en/publikasi/peraturan/'> Regulation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/publikasi/lelang/'>Transaction</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/lelang/operasi-moneter/' >Monetary Operation</a></li></ul><li><a href = '/en/publikasi/laporan/'> Report </a ></li><li><a href = '/en/publikasi/kajian/'> Review </a ></li><li><a href = '/en/publikasi/lain/default.aspx'>  Other Publications </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/publikasi.jpg?csf=1&e=QrfjCa&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Publications</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia’s publications include regulations, reports and papers, as well as the calendar of activities</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/statistik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Statistics</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/id/statistik/sdds'> Special Data Dissemination Standard (SDDS) </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/ekonomi-keuangan/seki/Default.aspx'>Financial Statistics</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/seki/Default.aspx' >Indonesian Economic and Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/items/Default.aspx' >Monetary and Payment System Selected Indicators</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sekda/Default.aspx' >The Regional Economic Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sulni/Default.aspx' >Indonesia External Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sski/default.aspx' >Indonesia Financial System Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/suspi/default.aspx' >Indonesia Public Sector Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/spip/Default.aspx' >Payment System and Financial Market Infrastructure Statistics</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/informasi-kurs/jisdor'>Foreign Exchange Rate</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/informasi-kurs/jisdor' >JISDOR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi' >Bank Indonesia Foreign Exchange Transaction Rates</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/kurs-acuan-non-usd-idr/' >Reference Rate for Non-USD/IDR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx' >Calculator</a></li></ul><li><a href = '/en/statistik/indikator'> Indicators </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/Statistik.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Statistics</p>
                        <p class='dropdown-megamenu__about--description'>Statistics include historical indicators for all sectors under the jurisdiction of Bank Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/layanan/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Services</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/layanan/permintaan-informasi/default.aspx'> Information Request </a ></li><li><a href = '/en/layanan/pengaduan-konsumen'> Consumer Protection and Complaints </a ></li><li><a href = '/en/layanan/elicensing/default.aspx'>  E-Licensing </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/informasi-perizinan/default.aspx'>Licensed Institutions</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/informasi-perizinan/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/layanan/informasi-perizinan/sistem-pembayaran/default.aspx' >Payment System and Rupiah Currency Management</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/perpustakaan/'>Library</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/perpustakaan/koleksi-buku/' >Book Collection</a></li></ul><li><a href = '/en/layanan/kas-bi/'> Bank Indonesia Cash Service </a ></li><li><a href = '/en/layanan/lelang-jasa-barang/'> Goods and Services Auction </a ></li><li><a href = '/en/layanan/kunjungan-bi/default.aspx'> Visitation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/museum-bi/'>Museum</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/museum-bi/koleksi-museum' >Museum Collection</a></li><li class='level3'><a href = '/en/layanan/museum-bi/program-informasi/default.aspx' >Museum Program and Information</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/Standar/SNAP/default.aspx'>Payment System Standard - Open API</a></div><ul class='dropdown-megamenu__submenu-list'></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/layanan.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Services</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia offers various services, including requests for information, complaints, licensing and so on.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/informasi-publik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Public Information</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/informasi-publik/profil-ppid/Default.aspx'> Profile </a ></li><li><a href = '/en/informasi-publik/dasar-hukum'> Regulation </a ></li><li><a href = '/en/informasi-publik/informasi-publik/Default.aspx'> List of Public Information </a ></li><li><a href = '/en/informasi-publik/layanan-informasi/Default.aspx'> Information Service </a ></li><li><a href = '/en/informasi-publik/berita-ppid/Default.aspx'> News </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/informasi-publik.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Public Information</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia maintains public information in accordance with the Public Information Disclosure Act of 2008.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li>
</ul>
<span id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7_ctl00_LabelDebug"></span>    
 

</div>
                                        </div>
                                    </div>
                                </nav>
                            </div>
                        </div>

                    </header>
                    <div class="menu-overlay"></div>

                    <div id="contentRow">
                        <div id="sideNavBox" role="Navigation" class="ms-dialogHidden ms-forceWrap ms-noList">
                            <div id="DeltaPlaceHolderLeftNavBar" class="ms-core-navigation" role="navigation">
	
                                
									
                                    <a id="startNavigation" name="startNavigation" tabIndex="-1"></a>
                                    
                                    
                                    
                                    
                                    
                                    <div class="ms-core-sideNavBox-removeLeftMargin">
                                        <div id="ctl00_PlaceHolderLeftNavBar_QuickLaunchNavigationManager">
		<div id="zz3_V4QuickLaunchMenu" class=" noindex ms-core-listMenu-verticalBox">
			<ul id="zz4_RootAspMenu" class="root ms-core-listMenu-root static">
				<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" href="/"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Recent</span><span class="ms-hidden">Currently selected</span></span></a></li>
			</ul>
		</div>
	</div>
                                        
                                        
											<div class="ms-core-listMenu-verticalBox">
                                                
                                            </div>
                                            
                                        
                                    </div>
                                    
                                
                            
</div>
                        </div>
                        <div id="contentBox" aria-live="polite" aria-relevant="all" role="main">
                            <a id="mainContent" name="mainContent" tabindex="-1"></a>
                            <div id="notificationArea" class="ms-notif-box"></div>
                            <div id="DeltaPageStatusBar">
	
                                <div id="pageStatusBar"></div>
                            
</div>
                            <div id="DeltaPlaceHolderTop">
	
                                <div class="noindex">
                                	
	<div id="ctl00_PlaceHolderTop_g_717976cb_8b48_4283_98d0_c1ff5d699b5d" __MarkupType="vsattributemarkup" __WebPartId="{717976cb-8b48-4283-98d0-c1ff5d699b5d}" WebPart="true">
		

<div class="top-banner">
    <div class="container">
        <nav aria-label="breadcrumb">
            <ol class="breadcrumb color">
                
                        
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en">Home </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik">Statistics </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik/informasi-kurs">Foreign Exchange Rate </a>
                        </li>
                    
                    
                <li class="breadcrumb-item color-white" aria-current="page">
                    Foreign Exchange Rates
                </li>
            </ol>
        </nav>
        <h1 class="top-banner__title"> Foreign Exchange Rates</h1>
    </div>
    <div class="top-banner__overlay"></div>
</div>



<div style="display:none;">
    Start;Home;Statistics;Foreign Exchange Rate;bukan default.aspx
</div>

	</div>

                                </div>
                            
</div>

                            <div class="container">
								 <a id="button-back-to-top"><img src="/Style Library/biweb/img/ico_back-to-top.svg" alt=""/></a>
                                <div id="DeltaPlaceHolderMain">
	
                                    
<div id="content-wrapper" class="content-text">                
		<h2>EXCHANGE RATES ON TRANSACTION</h2>
		<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf" __MarkupType="vsattributemarkup" __WebPartId="{6C89D4AD-107F-437D-BD54-8FDA17B556BF}" WebPart="true" partorder="2">
		


<script type="text/javascript" src="/Style Library/biweb/js/jquery-ui-1.12.1.min.js"></script>


<script type="text/javascript" src="/Style Library/biweb/js/jquery.cookie.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/Chart.min.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/html2canvas.min.js"></script>
<link rel="stylesheet" href="/Style Library/biweb/css/jquery-ui.css" />

<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
<script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>

<script type="text/javascript"> 
    var myApp = new function () {
        this.printTable = function () {
            var tab = document.getElementById('tableData');
            var win = window.print('', '', 'height=700,width=700');
            win.document.write(tab.outerHTML);
            win.document.close();
            win.print();
        }
    }
</script>

<style>

</style>

<script type="text/javascript">
    //////chart

    var getMataUang = "";
    var arrayValueDate = [];
    var arrayValueKurs = [];
    console.log(arrayValueDate);
    console.log(arrayValueKurs);
    window.onload = function () {
        var ctx = document.getElementById("myChart").getContext("2d");
        console.log(ctx);
        var data = {
            labels: arrayValueDate,
            datasets: [{
                label: "Kurs Transaksi",
                data: arrayValueKurs,
                borderColor: "blue",
                lineTension: 0
            }]
        };

        var myLineChart = new Chart(ctx, {
            type: 'line',
            data: data,
            options: {
                legend: {
                    display: false,
                    labels: {
                        display: false
                    }
                },
                title: {
                    display: true,
                    text: 'Kurs Transaksi (Exchange Rates on Transaction) - ' + getMataUang
                },
                responsive: true,
                maintainAspectRatio: false,
                tooltips: {
                    callbacks: {
                        label: function (t, d) {
                            if (url.toLowerCase().indexOf("/id/") !== -1) {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".") : "Rp " + t.yLabel;
                            }
                            else {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") : "Rp " + t.yLabel;
                            }
                            return yLabel;
                        }
                    }
                },
                scales: {
                    xAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Source Bank Indonesia'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10
                        },

                    }],
                    yAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Rupiah'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10,
                            callback: function (value, index, values) {
                                if (parseInt(value) >= 1000) {
                                    if (url.toLowerCase().indexOf("/id/") !== -1) {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
                                    }
                                    else {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
                                    }

                                } else {
                                    return value;
                                }
                            }
                        }
                    }]
                }
            }
        });

        window.addEventListener('resize', function () {
            myLineChart.resize()
        })
    }
    function setFormSubmitToFalse() {
        setTimeout(function () { _spFormOnSubmitCalled = false; }, 1000);
        return true;
    }
</script>

<script type="text/javascript">

    $(document).ready(function () {
        url = window.location.href;

        

        if (url.toLowerCase().indexOf("/id/") !== -1) {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);

        }
        else {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);
        }


        if (url.toLowerCase().indexOf("/id/") !== -1) {
            var dialogSingkatan = "Code of Currency";
            $(".btn[id$='_btnGraphImage']").prop("value", "Lihat");
            $(".btn[id$='_ButtonExport']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Unduh");
        }
        else {
            var dialogSingkatan = "Kode Singkatan";
            $(".btn[id$='_btnGraphImage']").prop("value", "View");
            $(".btn[id$='_ButtonExport']").prop("value", "Download");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Download");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Download");
            $("#linkId").attr("href", "/en/statistik/informasi-kurs/transaksi-bi/Default.aspx");
            $("#exampleModalLabel").text("Currency Code");
        }

        $("#KodeSingkatan").dialog({
            autoOpen: false,
            show: "blind",
            width: "240",
            height: "500",
            hide: "explode",
            title: dialogSingkatan
        });

        $("#linkSingkatan1").click(function () {
            $("#KodeSingkatan").dialog("open");
            return false;
        });



        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Masukkan periode awal dan akhir dengan benar');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Periode tanggal awal tidak valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('Periode tanggal akhir tidak valid');
                        return false;
                    }

                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Input start date and end date correctly');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Start date is not valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('End date is not valid');
                        return false;
                    }

                }
            }
            

        });

        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Masukkan periode dengan benar');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Periode tanggal tidak valid');
                        return false;
                    }
                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Input period correctly');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Period is not valid');
                        return false;
                    }
                }
            }
            
        });

    });

    function SetSource(SourceID) {
        var hideSourceID = $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID");
        hideSourceID.val(SourceID);
    }

    // function validation 
    function isValidDate(val, format) {
        try {
            var newDate = val.split("-")[0];
            var newMonth = val.split("-")[1];
            var newYear = val.split("-")[2];

            if (newYear.length == 2 || newYear.length == 4) {
                if (newYear.length == 4) { newYear = newYear.substring(2, 4); }
            }
            else {
                return false;
            }

            var date = getDateFromFormat(newDate + '-' + newMonth + '-' + newYear, format);
            if (date == 0) { return false; }
            return true;
        }
        catch (ex) {
            return false;
        }
    }

    var MONTH_NAMES = new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember', 'Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Ags', 'Sep', 'Okt', 'Nov', 'Des');
    var DAY_NAMES = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
    function LZ(x) { return (x < 0 || x > 9 ? "" : "0") + x }
    function getDateFromFormat(val, format) {
        val = val + "";
        format = format + "";
        var i_val = 0;
        var i_format = 0;
        var c = "";
        var token = "";
        var token2 = "";
        var x, y;
        var now = new Date();
        var year = now.getYear();
        var month = now.getMonth() + 1;
        var date = 1;
        var hh = now.getHours();
        var mm = now.getMinutes();
        var ss = now.getSeconds();
        var ampm = "";

        while (i_format < format.length) {
            c = format.charAt(i_format);
            token = "";
            while ((format.charAt(i_format) == c) && (i_format < format.length)) {
                token += format.charAt(i_format++);
            }
            if (token == "yyyy" || token == "yy" || token == "y") {
                if (token == "yyyy") { x = 4; y = 4; }
                if (token == "yy") { x = 2; y = 2; }
                if (token == "y") { x = 2; y = 4; }
                year = _getInt(val, i_val, x, y);
                if (year == null) { return 0; }
                i_val += year.length;
                if (year.length == 2) {
                    if (year > 70) { year = 1900 + (year - 0); }
                    else { year = 2000 + (year - 0); }
                }
            }
            else if (token == "MMM" || token == "NNN") {
                month = 0;
                for (var i = 0; i < MONTH_NAMES.length; i++) {
                    var month_name = MONTH_NAMES[i];
                    if (val.substring(i_val, i_val + month_name.length).toLowerCase() == month_name.toLowerCase()) {
                        if (token == "MMM" || (token == "NNN" && i > 11)) {
                            month = i + 1;
                            if (month > 24) { month -= 24; }
                            if (month > 12) { month -= 12; }
                            i_val += month_name.length;
                            break;
                        }
                    }
                }
                if ((month < 1) || (month > 12)) { return 0; }
            }
            else if (token == "EE" || token == "E") {
                for (var i = 0; i < DAY_NAMES.length; i++) {
                    var day_name = DAY_NAMES[i];
                    if (val.substring(i_val, i_val + day_name.length).toLowerCase() == day_name.toLowerCase()) {
                        i_val += day_name.length;
                        break;
                    }
                }
            }
            else if (token == "MM" || token == "M") {
                month = _getInt(val, i_val, token.length, 2);
                if (month == null || (month < 1) || (month > 12)) { return 0; }
                i_val += month.length;
            }
            else if (token == "dd" || token == "d") {
                date = _getInt(val, i_val, token.length, 2);
                if (date == null || (date < 1) || (date > 31)) { return 0; }
                i_val += date.length;
            }
            else if (token == "hh" || token == "h") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 12)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "HH" || token == "H") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 23)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "KK" || token == "K") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 11)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "kk" || token == "k") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 24)) { return 0; }
                i_val += hh.length; hh--;
            }
            else if (token == "mm" || token == "m") {
                mm = _getInt(val, i_val, token.length, 2);
                if (mm == null || (mm < 0) || (mm > 59)) { return 0; }
                i_val += mm.length;
            }
            else if (token == "ss" || token == "s") {
                ss = _getInt(val, i_val, token.length, 2);
                if (ss == null || (ss < 0) || (ss > 59)) { return 0; }
                i_val += ss.length;
            }
            else if (token == "a") {
                if (val.substring(i_val, i_val + 2).toLowerCase() == "am") { ampm = "AM"; }
                else if (val.substring(i_val, i_val + 2).toLowerCase() == "pm") { ampm = "PM"; }
                else { return 0; }
                i_val += 2;
            }
            else {
                if (val.substring(i_val, i_val + token.length) != token) { return 0; }
                else { i_val += token.length; }
            }
        }
        if (i_val != val.length) { return 0; }
        if (month == 2) {
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
                // leap year
                if (date > 29) { return 0; }
            }
            else { if (date > 28) { return 0; } }
        }
        if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
            if (date > 30) { return 0; }
        }
        if (hh < 12 && ampm == "PM") { hh = hh - 0 + 12; }
        else if (hh > 11 && ampm == "AM") { hh -= 12; }
        var newdate = new Date(year, month - 1, date, hh, mm, ss);
        return newdate.getTime();
    }

    function _isInteger(val) {
        var digits = "1234567890";
        for (var i = 0; i < val.length; i++) {
            if (digits.indexOf(val.charAt(i)) == -1) { return false; }
        }
        return true;
    }

    function _getInt(str, i, minlength, maxlength) {
        for (var x = maxlength; x >= minlength; x--) {
            var token = str.substring(i, i + x);
            if (token.length < minlength) { return null; }
            if (_isInteger(token)) { return token; }
        }
        return null;
    }

    function download() {
        //if (!isChartRendered) return; // return if chart not rendered
        html2canvas(document.getElementById('chart-container'), {
            onrendered: function (canvas) {
                if (canvas.msToBlob) { //for IE
                    var blob = canvas.msToBlob();
                    window.navigator.msSaveBlob(blob, 'BIexchangeRates.jpeg');
                }
                else {
                    var link = document.createElement('a');
                    link.href = canvas.toDataURL('image/jpeg');
                    link.download = 'BIexchangeRates.jpeg';
                    link.click();
                }
            }
        })
    }

</script>


<div class="card-block" id="tableData">
    <div class="card-body">

       

        
        <div class="row datepicker-period" id="harian" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        Daily</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTanggal" type="text" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch2" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
            
            
        </div>
        <div class="row datepicker-period" id="range" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        From</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtFrom" type="text" value="01-Mar-2026" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        To</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTo" type="text" value="05-Mar-2026" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch1" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
        </div>
        <div>
            
            
            <div class="row">
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        <div class="search-box-wrapper text-left">
                            Last Update&nbsp;<span>2 April 2026</span>
                        </div>
                    </div>
                </div>
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        
                        <div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_printRange" class="search-box-wrapper text-right">
                            <input type="button" value="Print Table" onclick="myApp.printTable()" class="btn btn-secondary btn-icon btn-icon__print" />
                            <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ButtonExportRange" value="Unduh" onclick="javascript:setFormSubmitToFalse();" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ButtonExportRange" class=" btn btn-primary btn-export" />
                        </div>
                        
                    </div>
                </div>                
            </div>
            
        </div>
    </div>

</div>

<input type="hidden" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$hidSourceID" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID" />

<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_kursTable1">
    <div class="d-flex justify-content-end mr-4">
        <a id="linkId" class="btn" style="color: white; background: #045498;" href="/id/statistik/informasi-kurs/transaksi-bi/Default.aspx">
            Back</a>
    </div>
    <div style="text-align: center; font-weight: bold;">
        <span id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_Label10">EXCHANGE RATES ON TRANSACTION</span>
        <br />
        <span id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_lblKursTransaksiKTBI2" class="font-weight-bold">CURRENCIES AED  </span>
        <br />
        <a onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_lnkGrafik" href="javascript:__doPostBack(&#39;ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$lnkGrafik&#39;,&#39;&#39;)">Grafik Time Series</a>
        <br />
        <div class="container">
            <div class="page-table table-responsive page-table--bordered mb-3">
                <div>

		</div>
                <div>
			<table class="table table-striped table-no-bordered table-lg" cellspacing="0" rules="all" border="1" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_gvSearchResult2" style="border-collapse:collapse;">
				<tr>
					<th class="borderLeft" scope="col" style="color:White;background-color:#045498;">Value</th><th class="borderLeft" scope="col" style="color:White;background-color:#045498;">Sell</th><th scope="col" style="color:White;background-color:#045498;">Buy</th><th scope="col" style="color:White;background-color:#045498;">Date</th>
				</tr><tr>
					<td>1.00</td><td>4,627.79</td><td>4,580.24</td><td>5 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>4,616.19</td><td>4,569.51</td><td>4 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>4,611.30</td><td>4,563.55</td><td>3 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>4,592.29</td><td>4,545.11</td><td>2 Mar 2026</td>
				</tr>
			</table>
		</div>
            </div>
        </div>
    </div>
</div>

<div id="myChartWrapper" style="width: 100%; height: 100%; display: none">
    <div id="chart-container">
        <canvas id="myChart" width="500" height="400"></canvas>
    </div>
    <div class="text-right my-3">
        <button class="btn btn-primary" onclick="download()">Save Chart</button>
    </div>
</div>




	</div>
		<div id="accordion" style="display:none">
		
                    <div class="card">
                        <div class="card-header" id="headingOne">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseOne" href="#headingOne"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Tentang JISDOR</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseOne" class="collapse" aria-labelledby="headingOne" data-parent="#accordion">
                            <div class="card-block">
                                <div class="card-body">
                                    <div class="content-text-subtitle">
                                        <p>Penjelasan JISDOR</p>
                                    </div>
                                    <ol>

                                        <menu class="ms-hide">
		<ie:menuitem id="MSOMenu_Help" iconsrc="/_layouts/15/images/HelpIcon.gif" onmenuclick="MSOWebPartPage_SetNewWindowLocation(MenuWebPart.getAttribute('helpLink'), MenuWebPart.getAttribute('helpMode'))" text="Help" type="option" style="display:none">

		</ie:menuitem>
	</menu>


                                        
                                        


                                    </ol>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header" id="headingTwo">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseTwo" href="#headingTwo"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Penjelasan Kurs Transaksi</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseTwo" class="collapse" aria-labelledby="headingTwo" data-parent="#accordion">
                            
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a href="/id/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx"
                                        class="collapsed">
                                        <div class="color-gray">
                                            <p>Kalkulator Kurs</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        
                    </div>
                </div>
            </div>
        
<div style='display:none' id='hidZone'></div>
                                
</div>
                            </div>
                            <div id="DeltaPlaceHolderBottom">
	
                                <div class="noindex">
                                
	<div id="ctl00_PlaceHolderBottom_g_e3052be3_673c_405e_9cbe_a883a244c053" __MarkupType="vsattributemarkup" __WebPartId="{e3052be3-673c-405e-9cbe-a883a244c053}" WebPart="true">
		

<script type="text/javascript">
    $(document).ready(function() {
        $(".carousel-item-othersites:first").addClass("active");
        console.log($("#HiddenFieldCount").val());
        if ($("#HiddenFieldCount").val()<=3){
            $(".carousel-control-othersites").hide();
        }
    });
</script>
<input type="hidden" name="ctl00$PlaceHolderBottom$g_e3052be3_673c_405e_9cbe_a883a244c053$ctl00$HiddenFieldCount" id="HiddenFieldCount" />
<div class="bottom-banner">
    <div class="container">
        <p class="bottom-banner__title">Baca Juga</p>
        <div id="carouselOtherSites" class="carousel slide carousel-column" data-ride="carousel" data-interval="false">
            
                    <div class="carousel-inner">
                        
                    <div class="carousel-item carousel-item-othersites">
                        <div class="row bottom-banner-slides">
                            
                    <div class="col-sm-4">
                        <div class="box-list">
                            <a href="https://www.bi.go.id/en/fungsi-utama/moneter/informasi-kurs/default.aspx#floating-2" class="box-list__hyperlink"></a>
                            <p class="mb-0">
                                Bank Indonesia Foreign Exchange Transaction Rates​
                            </p>
                        </div>
                    </div>
                
                        </div>
                    </div>
                
                    </div>
                
            <a class="carousel-control-othersites carousel-control-prev" href="#carouselOtherSites" role="button" data-slide="prev">
                <span class="carousel-control-prev-icon" aria-hidden="true"></span>
                <span class="sr-only">Previous</span>
            </a>
            <a class="carousel-control-othersites carousel-control-next" href="#carouselOtherSites" role="button" data-slide="next">
                <span class="carousel-control-next-icon" aria-hidden="true"></span>
                <span class="sr-only">Next</span>
            </a>
        </div>
    </div>
</div>


	</div>

                                </div>
                            
</div>

                        </div>
                        <div id="DeltaFormDigest">
	
                            
								
                            
                        
</div>
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                    </div>

                    <footer class="ms-dialogHidden noindex">
                        <div class="top-footer">
                            <div class="container">
                                                        	    		
<div id="ctl00_UserControl1" __MarkupType="vsattributemarkup" __WebPartId="{72f5f1f8-08c8-489c-ad0f-67bc21b60514}" WebPart="true">
	
        <ul class="list-unstyled link-list">
            
        <li class="ml-4"><a href='https://www.bi.go.id/en/publikasi/Kalender' class="link__item">Calendar</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/archive' class="link__item">Archieve</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/minisite.aspx' class="link__item">Minisite</a></li>       
    
        </ul>
    

</div>
                                                        	    		
                                <div class="row">
<div id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa" __MarkupType="vsattributemarkup" __WebPartId="{ecc2559e-4a60-437f-ba58-80eaeea6b4aa}" WebPart="true">
	

<div class="col-12 col-md-6 sosmed-wrapper">
    
            <div class="sosmed-list"> 
                
            <a class="sosmed__item" href='https://www.facebook.com/BankIndonesiaOfficial/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-fb.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.instagram.com/bank_indonesia/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-ig.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.youtube.com/user/BankIndonesiaChannel'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-youtube.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.tiktok.com/@bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-tiktok.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://twitter.com/bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-twitter-X_.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://open.spotify.com/show/4Q38i2lcJpxvtJvcmJuWWv'>
                <img src='https://www.bi.go.id/Sosial%20Media/SPOTIFY-svg.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://whatsapp.com/channel/0029VahA0uQL2ATyd7fOSE39'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-WA-Channel.svg' width="32" alt="icon-fb"></a>
         
            </div> 
        
    
            <div class="app-list">
                
            <a class="app__item" href='https://apps.apple.com/id/app/bi-mobile/id1198899727'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-app-store.svg' width="98" alt="icon-app-store"></a>
        
            <a class="app__item" href='https://play.google.com/store/apps/details?id=com.bi.mobile'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-play-store.svg' width="98" alt="icon-app-store"></a>
        
            </div>
        
</div>
<span id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa_ctl00_LabelDebug"></span>

</div>

                                    <div class="col-12 col-md-6 address-wrapper">
                                        <div class="address-list">
                                            <p class="mb-0">Bank Indonesia<br/>
Jalan M.H. Thamrin No. 2, Jakarta 10350<br/>
Contact Center Bank Indonesia Bicara<br/>
Telp. : 131 dan 1500131 (dari luar negeri)<br/>
E-mail : <a href="mailto:bicara@bi.go.id">bicara@bi.go.id</a><br/>
Chatbot LISA :<a href="https://wa.me/6281131131131?text=Hi,%20Lisa" target="blank"> 081 131 131 131</a></p>
                                        </div>
                                    </div>
                                    <div class="col-12 col-md-12 mt-3 d-flex justify-content-end">
                                    	<div id="ctl00_g_e8c52fcb_2724_4885_9437_c0f616f27eb4" __MarkupType="vsattributemarkup" __WebPartId="{e8c52fcb-2724-4885-9437-c0f616f27eb4}" WebPart="true" partorder="2">
	


</div>
                                    </div>
                                </div>
                            </div>
                        </div>
                        <div class="copyright-wrapper">
                            <div class="container">
                                <p class="text-right mb-0">© 2020 Bank Indonesia</p>
                            </div>
                        </div>

                    </footer>

                </div>
                <span id="DeltaHelpPanel">
                    <div id="helppanelCntdiv" class="ms-Help-PanelContainer">
                        
                    </div>
                </span>
                <span id="DeltaPageInstrumentation">
                    
                </span>
            </div>
        

<script type="text/javascript">
//<![CDATA[
var _spFormDigestRefreshInterval = 1440000;window.SPThemeUtils && SPThemeUtils.ApplyCurrentTheme(true); IsSPSocialSwitchEnabled = function() { return true; };var _fV4UI = true;
function _RegisterWebPartPageCUI()
{
    var initInfo = {editable: false,isEditMode: false,allowWebPartAdder: false};
    SP.Ribbon.WebPartComponent.registerWithPageManager(initInfo);
    var wpcomp = SP.Ribbon.WebPartComponent.get_instance();
    var hid;
    hid = document.getElementById("_wpSelected");
    if (hid != null)
    {
        var wpid = hid.value;
        if (wpid.length > 0)
        {
            var zc = document.getElementById(wpid);
            if (zc != null)
                wpcomp.selectWebPart(zc, false);
        }
    }
    hid = document.getElementById("_wzSelected");
    if (hid != null)
    {
        var wzid = hid.value;
        if (wzid.length > 0)
        {
            wpcomp.selectWebPartZone(null, wzid);
        }
    }
};
function __RegisterWebPartPageCUI() {
ExecuteOrDelayUntilScriptLoaded(_RegisterWebPartPageCUI, "sp.ribbon.js");}
_spBodyOnLoadFunctionNames.push("__RegisterWebPartPageCUI");var __wpmExportWarning='This Web Part Page has been personalized. As a result, one or more Web Part properties may contain confidential information. Make sure the properties contain information that is safe for others to read. After exporting this Web Part, view properties in the Web Part description file (.WebPart) by using a text editor such as Microsoft Notepad.';var __wpmCloseProviderWarning='You are about to close this Web Part.  It is currently providing data to other Web Parts, and these connections will be deleted if this Web Part is closed.  To close this Web Part, click OK.  To keep this Web Part, click Cancel.';var __wpmDeleteWarning='You are about to permanently delete this Web Part.  Are you sure you want to do this?  To delete this Web Part, click OK.  To keep this Web Part, click Cancel.';SuiteNavRendering.RenderSuiteNav({top:'suiteBarTop', version:2, dataEndpoint:'Microsoft.SharePoint.Portal.SuiteNavData.GetSuiteNavData', culture:'en-US', signInLink:'\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fAuthenticate.aspx?Source=\u00252Fen\u00252Fstatistik\u00252Finformasi\u00252Dkurs\u00252Ftransaksi\u00252Dbi\u00252Fdefault\u00252Easpx', brandingText:'', brandingLogo:'', brandingLogoLink:'', brandingLogoTitle:''});
var _spWebPermMasks = {High:16,Low:196673};g_spPreFetchKeys.push('sp.core.js');function _cUpdonetidHeadbnnr2(){var myd = null; if (typeof(dataonetidHeadbnnr2) != 'undefined') {myd = dataonetidHeadbnnr2;} var myc = document.getElementById('ctl00_onetidHeadbnnr2');_cUpdconetidHeadbnnr2(myd, myc);}function _cUpdconetidHeadbnnr2(data, ctrl){SiteLogoImagePageUpdate(ctrl, data);}
            ExecuteOrDelayUntilScriptLoaded(
                function() 
                {                    
                    Srch.ScriptApplicationManager.get_current().states = {"webUILanguageName":"en-US","webDefaultLanguageName":"en-US","QueryDateTimeCulture":1033,"timeZoneOffsetInHours":7,"contextUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","contextTitle":"Foreign Exchange Rates","supportedLanguages":[{"id":1025,"label":"Arabic"},{"id":1093,"label":"Bangla"},{"id":1026,"label":"Bulgarian"},{"id":1027,"label":"Catalan"},{"id":2052,"label":"Chinese (Simplified)"},{"id":1028,"label":"Chinese (Traditional)"},{"id":1050,"label":"Croatian"},{"id":1029,"label":"Czech"},{"id":1030,"label":"Danish"},{"id":1043,"label":"Dutch"},{"id":1033,"label":"English"},{"id":1035,"label":"Finnish"},{"id":1036,"label":"French"},{"id":1031,"label":"German"},{"id":1032,"label":"Greek"},{"id":1095,"label":"Gujarati"},{"id":1037,"label":"Hebrew"},{"id":1081,"label":"Hindi"},{"id":1038,"label":"Hungarian"},{"id":1039,"label":"Icelandic"},{"id":1057,"label":"Indonesian"},{"id":1040,"label":"Italian"},{"id":1041,"label":"Japanese"},{"id":1099,"label":"Kannada"},{"id":1042,"label":"Korean"},{"id":1062,"label":"Latvian"},{"id":1063,"label":"Lithuanian"},{"id":1086,"label":"Malay"},{"id":1100,"label":"Malayalam"},{"id":1102,"label":"Marathi"},{"id":1044,"label":"Norwegian"},{"id":1045,"label":"Polish"},{"id":1046,"label":"Portuguese (Brazil)"},{"id":2070,"label":"Portuguese (Portugal)"},{"id":1094,"label":"Punjabi"},{"id":1048,"label":"Romanian"},{"id":1049,"label":"Russian"},{"id":3098,"label":"Serbian (Cyrillic)"},{"id":2074,"label":"Serbian (Latin)"},{"id":1051,"label":"Slovak"},{"id":1060,"label":"Slovenian"},{"id":3082,"label":"Spanish (Spain)"},{"id":2058,"label":"Spanish (Mexico)"},{"id":1053,"label":"Swedish"},{"id":1097,"label":"Tamil"},{"id":1098,"label":"Telugu"},{"id":1054,"label":"Thai"},{"id":1055,"label":"Turkish"},{"id":1058,"label":"Ukrainian"},{"id":1056,"label":"Urdu"},{"id":1066,"label":"Vietnamese"}],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"webUILanguageDirectory":"en-US","showAdminDetails":false,"defaultPagesListName":"Pages","isSPFSKU":false,"defaultQueryProperties":{"culture":1033,"uiLanguage":1033,"summaryLength":180,"desiredSnippetLength":90,"enableStemming":true,"enablePhonetic":false,"enableNicknames":false,"trimDuplicates":true,"bypassResultTypes":false,"enableInterleaving":true,"enableQueryRules":true,"processBestBets":true,"enableOrderingHitHighlightedProperty":false,"hitHighlightedMultivaluePropertyLimit":-1,"processPersonalFavorites":true}};
                    Srch.U.trace(null, 'SerializeToClient', 'ScriptApplicationManager state initialized.');
                }, 'Search.ClientControls.js');var g_clientIdDeltaPlaceHolderMain = "DeltaPlaceHolderMain";
var g_clientIdDeltaPlaceHolderPageTitleInTitleArea = "DeltaPlaceHolderPageTitleInTitleArea";
var g_clientIdDeltaPlaceHolderUtilityContent = "DeltaPlaceHolderUtilityContent";

theForm.oldSubmit = theForm.submit;
theForm.submit = WebForm_SaveScrollPositionSubmit;

theForm.oldOnSubmit = theForm.onsubmit;
theForm.onsubmit = WebForm_SaveScrollPositionOnSubmit;

theForm.oldOnLoad = window.onload;
window.onload = WebForm_RestoreScrollPosition;

                function _ribbonInitFunc1()

                {
                    EnsureScriptParams('core.js', '_ribbonInitFunc1Wrapped', '', '', '\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx', '-1997219614', '1033', 'RibbonContainer', {'Ribbon.Read':true,'Ribbon.WebPartPage':true}, null, {'Ribbon.WebPartInsert.InsertRelatedDataToListForm':true},
                                            null, false, 0, false, 'SP.Ribbon.PageManager.get_instance()', false, null, null, null, '1522130250', 1, '.');
                }
                function _ribbonStartInit(initialTabId, buildMinimized, e)
                {
                    EnsureScriptParams('core.js', '_ribbonStartInitWrapped', initialTabId, buildMinimized, e, true, 'EnsureScriptParams("core.js", "RibbonControlInitWrapped");EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", function () { _registerCUIEComponentWrapped( "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx", "1033", "-1997219614");});EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", _ribbonInitFunc1);');
                }
                function _ribbonKeyboardTitleShortcut(e)
                {
                    EnsureScriptParams('core.js', '_ribbonKeyboardTitleShortcutWrapped', e, 'tff[', 'Ribbon.Read-title');
                }
                function _ribbonDataInit(p6, p7)
                {
                    _ribbon = new Object();
                    _ribbon.initialTabId = p6;
                    _ribbon.buildMinimized = p7;
                    _ribbon.initStarted = false;
                    _ribbon.initialTabSelectedByUser = false;
                    _ribbon.launchedByKeyboard = false;
                }
                function _ribbonWaitForBodyEvent()
                {
                    if (false)
                        _ribbonStartInit();
                    
                function _ribbonOnWindowResizeForHeaderScaling(evt)
                {
                    _ribbonOnWindowResizeForHeaderScalingWrapped(evt, 'RibbonContainer', false);
                }
                EnsureScriptParams('core.js', '_ribbonInitResizeHandlers', _ribbonOnWindowResizeForHeaderScaling, 'RibbonContainer', true, false);
                
                    EnsureScriptParams('core.js', '_ribbonAddEventListener', _ribbonKeyboardTitleShortcut);
                }
                _ribbonDataInit('Ribbon.Read', true);                
                if (SP.SOD.get_prefetch() == 0 && _ribbon.buildMinimized == true)
                {
                    ExecuteOrDelayUntilScriptLoaded(_ribbonWaitForBodyEvent, 'sp.ribbon.js');
                }
                else
                {
                    EnsureScriptFunc('ribbon', 'SP.Ribbon.PageStateActionButton', _ribbonWaitForBodyEvent);
                }
                
var g_commandUIHandlers = {"name":"CommandHandlers","attrs":{},"children":[]};
g_QuickLaunchControlIds.push("zz1_TopNavigationMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz1_TopNavigationMenu = null; function init_zz1_TopNavigationMenu() { if (g_zz1_TopNavigationMenu == null) g_zz1_TopNavigationMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz1_TopNavigationMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz1_TopNavigationMenu, 'SP.Core.js');

                    ExecuteOrDelayUntilScriptLoaded(
                        function() 
                        {
                            if ($isNull($find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr')))
                            {
                                var sb = $create(Srch.SearchBox, {"delayLoadTemplateScripts":true,"initialPrompt":"Search this site","messages":[],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"queryGroupNames":["MasterPage"],"renderTemplateId":"~sitecollection/_catalogs/masterpage/Display Templates/Search/Control_SearchBox_Compact.js","resultsPageAddress":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","serverInitialRender":true,"showDataErrors":true,"showNavigation":true,"states":{},"tryInplaceQuery":false}, null, null, $get("ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"));
                                sb.activate('Search this site', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavButton', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavDropdownList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink', 'ms-srch-sbprogress', 'ms-srch-sb-prompt ms-helperText');
                            }
                        }, 'Search.ClientControls.js');g_QuickLaunchControlIds.push("zz3_V4QuickLaunchMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz3_V4QuickLaunchMenu = null; function init_zz3_V4QuickLaunchMenu() { if (g_zz3_V4QuickLaunchMenu == null) g_zz3_V4QuickLaunchMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz3_V4QuickLaunchMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz3_V4QuickLaunchMenu, 'SP.Core.js');
//]]>
</script>
</form>
        <span id="DeltaPlaceHolderUtilityContent">
            
        </span>
        <script type="text/javascript">// <![CDATA[ 

var g_Workspace = "s4-workspace";
		
		 // ]]>
</script>
    </body>
</html>
recorded_at: Sun, 05 Apr 2026 00:49:27 GMT
- request:
method: post
uri: https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
body:
encoding: US-ASCII
string: MSOWebPartPage_PostbackSource=&MSOTlPn_View=0&MSOTlPn_ShowSettings=False&MSOTlPn_Button=none&__EVENTTARGET=&__EVENTARGUMENT=&__REQUESTDIGEST=0x41D00311222AA5C7BCCDE7DFEA5D3ED0FA83851A66FFBB06DF250B456DB0D3DEACCB775F47795FC4F63284D1626209AAD854D6F5053BDE3EC332F5FFFCE9D770%2C05+Apr+2026+00%3A49%3A24+-0000&MSOSPWebPartManager_DisplayModeName=Browse&MSOSPWebPartManager_ExitingDesignMode=false&MSOSPWebPartManager_OldDisplayModeName=Browse&MSOSPWebPartManager_StartWebPartEditingName=false&MSOSPWebPartManager_EndWebPartEditing=false&_maintainWorkspaceScrollPosition=0&__VIEWSTATE=%2FwEPDwUBMA9kFgJmD2QWAgIBD2QWBAIBD2QWAgInD2QWAgIDD2QWAmYPZBYCZg88KwAGAGQCCQ9kFhYCIw9kFgICAw8WAh4HVmlzaWJsZWgWAmYPZBYEAgMPZBYOAgEPFgIfAGhkAgMPFgIfAGhkAgUPFgIfAGhkAgcPFgIfAGhkAgkPFgIfAGhkAgsPFgIfAGhkAg0PFgIfAGhkAgQPDxYCHglBY2Nlc3NLZXkFAS9kZAIlD2QWAgIDD2QWAgIBD2QWBAIDD2QWAmYPDxYEHgRfIVNCAgIeCENzc0NsYXNzBRdtcy1wcm9tb3RlZEFjdGlvbkJ1dHRvbmRkAgUPDxYGHwMFF21zLXByb21vdGVkQWN0aW9uQnV0dG9uHwICAh8AaGRkAi8PZBYCAgEPZBYCAgEPPCsABQEADxYCHhVQYXJlbnRMZXZlbHNEaXNwbGF5ZWRmZGQCNQ9kFgJmD2QWAmYPFCsAAg8WBB4LXyFEYXRhQm91bmRnHgtfIUl0ZW1Db3VudAIEZGQWAmYPZBYIAgEPZBYCZg8VAh5odHRwczovL3d3dy5iaS5nby5pZC9lbi9rYXJpZXIGQ2FyZWVyZAICD2QWAmYPFQIfaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vZWR1a2FzaQlFZHVjYXRpb25kAgMPZBYCZg8VAiZodHRwczovL3d3dy5iaS5nby5pZC9lbi9nbG9zYXJpdW0uYXNweAhHbG9zc2FyeWQCBA9kFgJmDxUCJ2h0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL3BldGEtc2l0dXMuYXNweAdTaXRlbWFwZAI7D2QWAmYPZBYCAgEPFgIeBFRleHQFqKMBPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi90ZW50YW5nLWJpL2RlZmF1bHQuYXNweCcgaWQ9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJyByb2xlPSdidXR0b24nIGRhdGEtdG9nZ2xlPSdkcm9wZG93bicgYXJpYS1oYXNwb3B1cD0ndHJ1ZScgYXJpYS1leHBhbmRlZD0nZmFsc2UnPkFib3V0IEJJPC9hPgogICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVudSBkcm9wZG93bi1tZWdhbWVudScgYXJpYS1sYWJlbGxlZGJ5PSduYXZiYXJEcm9wZG93blN0YXRpc3Rpayc%2BCiAgICAgICAgPGRpdiBjbGFzcz0nY29udGFpbmVyJz4KICAgICAgICAgICAgPGRpdiBjbGFzcz0nZC1tZC1mbGV4Jz4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gcHItbWQtNCc%2BIAogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19tZW51Jz48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3RlbnRhbmctYmkvcHJvZmlsL0RlZmF1bHQuYXNweCc%2BUHJvZmlsZTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi90ZW50YW5nLWJpL3Byb2ZpbC9vcmdhbmlzYXNpL0RlZmF1bHQuYXNweCcgPiBPcmdhbml6YXRpb248L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vdGVudGFuZy1iaS9wcm9maWwvZ292ZXJuYW5jZS9kZWZhdWx0LmFzcHgnID5Hb3Zlcm5hbmNlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3RlbnRhbmctYmkvcHJvZmlsL3V1LWJpL0RlZmF1bHQuYXNweCcgPlJlZ3VsYXRpb25zPC9hPjwvbGk%2BPC91bD48bGk%2BPGEgaHJlZiA9ICcvZW4vdGVudGFuZy1iaS9zZWphcmFoLWJpL0RlZmF1bHQuYXNweCc%2BIEhpc3RvcnkgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi90ZW50YW5nLWJpL3RyYW5zZm9ybWFzaS9EZWZhdWx0LmFzcHgnPiBUcmFuc2Zvcm1hdGlvbiA8L2EgPjwvbGk%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L01lbnUlMjBJbWFnZS90ZW50YW5nLUJJX3YyLnBuZyZxdW90OyknPjwvZGl2PgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aXRsZSc%2BQWJvdXQgQkk8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgb3JnYW5pc2F0aW9uLCB0cmFuc2Zvcm1hdGlvbiBhbmQgaGlzdG9yeSBvZiBCYW5rIEluZG9uZXNpYSBhcyB0aGUgY2VudHJhbCBiYW5rIG9mIHRoZSBSZXB1YmxpYyBvZiBJbmRvbmVzaWEuPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9mdW5nc2ktdXRhbWEvZGVmYXVsdC5hc3B4JyBpZD0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnIHJvbGU9J2J1dHRvbicgZGF0YS10b2dnbGU9J2Ryb3Bkb3duJyBhcmlhLWhhc3BvcHVwPSd0cnVlJyBhcmlhLWV4cGFuZGVkPSdmYWxzZSc%2BTWFpbiBGdW5jdGlvbnM8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvRGVmYXVsdC5hc3B4Jz5Nb25ldGFyeTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmZsYXNpL0RlZmF1bHQuYXNweCcgPkluZmxhdGlvbjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmRpa2F0b3ItbW9uZXRlci9kZWZhdWx0LmFzcHgnID5Nb25ldGFyeSBJbmRpY2F0b3I8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvYmktcmF0ZS9kZWZhdWx0LmFzcHgnID5CSS1SYXRlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL29wZXJhc2ktbW9uZXRlci9EZWZhdWx0LmFzcHgnID5Nb25ldGFyeSBPcGVyYXRpb248L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvaW5kb25pYS1qaWJvci9EZWZhdWx0LmFzcHgnID5JTkRPTklBLCBDb21wb3VuZGVkIElORE9OSUEsIElORE9OSUEgSW5kZXggYW5kIEpJQk9SPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL2luZm9ybWFzaS1rdXJzL2RlZmF1bHQuYXNweCcgPkpJU0RPUiwgTm9uLVVTRC9JRFIgUmVmZXJlbmNlIFJhdGUsIGFuZCBUcmFuc2FjdGlvbiBSYXRlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL3Bhc2FyLWtldWFuZ2FuL2RlZmF1bHQuYXNweCcgPk1vbmV5IE1hcmtldDwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9wZW5nZW1iYW5nYW4tZWtvbm9taS9EZWZhdWx0LmFzcHgnID5TaGFyaWEgRWNvbm9teSBhbmQgRmluYW5jaWFsPC9hPjwvbGk%2BPC91bD48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL2Z1bmdzaS11dGFtYS9zdGFiaWxpdGFzLXNpc3RlbS1rZXVhbmdhbi9pa2h0aXNhci8nPkZpbmFuY2lhbCBTeXN0ZW0gU3RhYmlsaXR5PC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zdGFiaWxpdGFzLXNpc3RlbS1rZXVhbmdhbi9pa2h0aXNhci8nID5PdmVydmlldzwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4vaW5zdHJ1bWVuLW1ha3JvcHJ1ZGVuc2lhbC9kZWZhdWx0LmFzcHgnID5NYWNyb3BydWRlbnRpYWwgUG9saWN5IEluc3RydW1lbnQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3N0YWJpbGl0YXMtc2lzdGVtLWtldWFuZ2FuL21hbmFqZW1lbi1rcmlzaXMvZGVmYXVsdC5hc3B4JyA%2BQ3Jpc2lzIE1hbmFnZW1lbnQgUHJvdG9jb2w8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3N0YWJpbGl0YXMtc2lzdGVtLWtldWFuZ2FuL2tvb3JkaW5hc2ktYmktbGFpbm55YS8nID5JbnN0aXR1dGlvbmFsIENvb3JkaW5hdGlvbjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4vcGVuZ2VtYmFuZ2FuLXVta20vJyA%2BTVNNRSBEZXZlbG9wbWVudDwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4va2V1YW5nYW4taW5rbHVzaWYvJyA%2BRmluYW5jaWFsIEluY2x1c2lvbjwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4nPlBheW1lbnQgU3lzdGVtIGFuZCBSdXBpYWggQ3VycmVuY3kgTWFuYWdlbWVudDwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4vbmlsYWktYmVzYXIvJyA%2BSGlnaCBWYWx1ZSBQYXltZW50IFN5c3RlbTwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4vcml0ZWwvJyA%2BUmV0YWlsIFBheW1lbnQgU3lzdGVtPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zaXN0ZW0tcGVtYmF5YXJhbi9wZW5nZWxvbGFhbi1ydXBpYWgvZGVmYXVsdC5hc3B4JyA%2BUnVwaWFoIEN1cnJlbmN5IE1hbmFnZW1lbnQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL3Blcml6aW5hbi9kZWZhdWx0LmFzcHgnID5MaWNlbnNpbmc8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL2FudGktcGVuY3VjaWFuLXVhbmctZGFuLXBlbmNlZ2FoYW4tcGVuZGFuYWFuLXRlcnJvcmlzbWUvJyA%2BQW50aS1Nb25leSBMYXVuZGVyaW5nIGFuZCBDb3VudGVyLVRlcnJvcmlzbSBGaW5hbmNpbmc8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL1N0YW5kYXJkaXNhc2ktS29tcGV0ZW5zaS9EZWZhdWx0LmFzcHgnID5TdGFuZGFyZGlzYXRpb24gT2YgSFIgQ29tcGV0ZW5jaWVzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zaXN0ZW0tcGVtYmF5YXJhbi9ibHVlcHJpbnQvZGVmYXVsdC5hc3B4JyA%2BSW5kb25lc2lhIFBheW1lbnQgU3lzdGVtIEJsdWVwcmludDwvYT48L2xpPjwvdWw%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L1N0eWxlIExpYnJhcnkvYml3ZWIvaW1nL2JpLXBob3RvLmpwZyZxdW90OyknPjwvZGl2PgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aXRsZSc%2BTWFpbiBGdW5jdGlvbnM8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgbWFpbiBmdW5jdGlvbnMgYW5kIHJlc3BvbnNpYmlsaXRpZXMgb2YgQmFuayBJbmRvbmVzaWEgdG8gYWNoaWV2ZSBhbmQgbWFpbnRhaW4gcnVwaWFoIHN0YWJpbGl0eS48L3A%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgPC9kaXY%2BCiAgICA8L2Rpdj4KPC9saT48bGkgY2xhc3M9J25hdi1pdGVtIGRyb3Bkb3duJz4KICAgICAgPGEgY2xhc3M9J25hdi1saW5rIGRyb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3J1cGlhaC8nIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5SdXBpYWg8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaT48YSBocmVmID0gJy9lbi9ydXBpYWgvZ2FtYmFyLXVhbmcvRGVmYXVsdC5hc3B4Jz4gQ3VycmVuY3kgSW1hZ2UgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi9ydXBpYWgvdWFuZy1kaWNhYnV0Lyc%2BIFdpdGhkcmF3biBDdXJyZW5jeSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL3J1cGlhaC9wZW5jZWdhaGFuLXJ1cGlhaC1wYWxzdS8nPiBDb3VudGVyZmVpdCBQcmV2ZW50aW9uIGFuZCBNYW5hZ2VtZW50IDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcnVwaWFoL2NpbnRhLWJhbmdnYS1wYWhhbS1ydXBpYWgvZGVmYXVsdC5hc3B4Jz4gQ2ludGEsIEJhbmdnYSwgUGFoYW0gUnVwaWFoIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcnVwaWFoL2RpZ2l0YWwtcnVwaWFoL2RlZmF1bHQuYXNweCNvdmVydmlldyc%2BIFByb2plY3QgR2FydWRhOiBEaWdpdGFsIFJ1cGlhaCA8L2EgPjwvbGk%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L01lbnUlMjBJbWFnZS9ydXBpYWhfdjIucG5nJnF1b3Q7KSc%2BPC9kaXY%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRpdGxlJz5SdXBpYWg8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgcnVwaWFoIGFzIHRoZSBjdXJyZW5jeSBvZiB0aGUgUmVwdWJsaWMgb2YgSW5kb25lc2lhIG1hbmFnZWQgYnkgQmFuayBJbmRvbmVzaWEgcHVyc3VhbnQgdG8gcHJldmFpbGluZyBsYXdzIGFuZCByZWd1bGF0aW9ucy48L3A%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgPC9kaXY%2BCiAgICA8L2Rpdj4KPC9saT48bGkgY2xhc3M9J25hdi1pdGVtIGRyb3Bkb3duJz4KICAgICAgPGEgY2xhc3M9J25hdi1saW5rIGRyb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3B1Ymxpa2FzaS9EZWZhdWx0LmFzcHgnIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5QdWJsaWNhdGlvbnM8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScjJz5NZWRpYSBSb29tPC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9ydWFuZy1tZWRpYS9uZXdzLXJlbGVhc2UvJyA%2BTGF0ZXN0IE5ld3MgKFByZXNzIFJlbGVhc2UpPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9ydWFuZy1tZWRpYS9jZXJpdGEtYmkvJyA%2BU3Rvcnk8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL3J1YW5nLW1lZGlhL3BpZGF0by1kZXdhbi1ndWJlcm51ci8nID5Cb2FyZCBvZiBHb3Zlcm5vciBTcGVlY2hlczwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9LYWxlbmRlci8nPiBDYWxlbmRhciA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9wZXJhdHVyYW4vJz4gUmVndWxhdGlvbiA8L2EgPjwvbGk%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9wdWJsaWthc2kvbGVsYW5nLyc%2BVHJhbnNhY3Rpb248L2E%2BPHNwYW4gY2xhc3M9J2NhcmV0Jz48L3NwYW4%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2xlbGFuZy9vcGVyYXNpLW1vbmV0ZXIvJyA%2BTW9uZXRhcnkgT3BlcmF0aW9uPC9hPjwvbGk%2BPC91bD48bGk%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2xhcG9yYW4vJz4gUmVwb3J0IDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2thamlhbi8nPiBSZXZpZXcgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi9wdWJsaWthc2kvbGFpbi9kZWZhdWx0LmFzcHgnPiAgT3RoZXIgUHVibGljYXRpb25zIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL3B1Ymxpa2FzaS5qcGc%2FY3NmPTEmZT1RcmZqQ2EmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlB1YmxpY2F0aW9uczwvcD4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tZGVzY3JpcHRpb24nPkJhbmsgSW5kb25lc2lh4oCZcyBwdWJsaWNhdGlvbnMgaW5jbHVkZSByZWd1bGF0aW9ucywgcmVwb3J0cyBhbmQgcGFwZXJzLCBhcyB3ZWxsIGFzIHRoZSBjYWxlbmRhciBvZiBhY3Rpdml0aWVzPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9zdGF0aXN0aWsvRGVmYXVsdC5hc3B4JyBpZD0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnIHJvbGU9J2J1dHRvbicgZGF0YS10b2dnbGU9J2Ryb3Bkb3duJyBhcmlhLWhhc3BvcHVwPSd0cnVlJyBhcmlhLWV4cGFuZGVkPSdmYWxzZSc%2BU3RhdGlzdGljczwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2lkL3N0YXRpc3Rpay9zZGRzJz4gU3BlY2lhbCBEYXRhIERpc3NlbWluYXRpb24gU3RhbmRhcmQgKFNERFMpIDwvYSA%2BPC9saT48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nla2kvRGVmYXVsdC5hc3B4Jz5GaW5hbmNpYWwgU3RhdGlzdGljczwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zZWtpL0RlZmF1bHQuYXNweCcgPkluZG9uZXNpYW4gRWNvbm9taWMgYW5kIEZpbmFuY2lhbCBTdGF0aXN0aWNzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL2l0ZW1zL0RlZmF1bHQuYXNweCcgPk1vbmV0YXJ5IGFuZCBQYXltZW50IFN5c3RlbSBTZWxlY3RlZCBJbmRpY2F0b3JzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nla2RhL0RlZmF1bHQuYXNweCcgPlRoZSBSZWdpb25hbCBFY29ub21pYyBGaW5hbmNpYWwgU3RhdGlzdGljczwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zdWxuaS9EZWZhdWx0LmFzcHgnID5JbmRvbmVzaWEgRXh0ZXJuYWwgRGVidCBTdGF0aXN0aWNzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nza2kvZGVmYXVsdC5hc3B4JyA%2BSW5kb25lc2lhIEZpbmFuY2lhbCBTeXN0ZW0gU3RhdGlzdGljczwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zdXNwaS9kZWZhdWx0LmFzcHgnID5JbmRvbmVzaWEgUHVibGljIFNlY3RvciBEZWJ0IFN0YXRpc3RpY3M8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vc3RhdGlzdGlrL2Vrb25vbWkta2V1YW5nYW4vc3BpcC9EZWZhdWx0LmFzcHgnID5QYXltZW50IFN5c3RlbSBhbmQgRmluYW5jaWFsIE1hcmtldCBJbmZyYXN0cnVjdHVyZSBTdGF0aXN0aWNzPC9hPjwvbGk%2BPC91bD48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy9qaXNkb3InPkZvcmVpZ24gRXhjaGFuZ2UgUmF0ZTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvaW5mb3JtYXNpLWt1cnMvamlzZG9yJyA%2BSklTRE9SPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy90cmFuc2Frc2ktYmknID5CYW5rIEluZG9uZXNpYSBGb3JlaWduIEV4Y2hhbmdlIFRyYW5zYWN0aW9uIFJhdGVzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy9rdXJzLWFjdWFuLW5vbi11c2QtaWRyLycgPlJlZmVyZW5jZSBSYXRlIGZvciBOb24tVVNEL0lEUjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvaW5mb3JtYXNpLWt1cnMvdHJhbnNha3NpLWJpL2thbGt1bGF0b3Ita3Vycy5hc3B4JyA%2BQ2FsY3VsYXRvcjwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmRpa2F0b3InPiBJbmRpY2F0b3JzIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL1N0YXRpc3Rpay5qcGcmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlN0YXRpc3RpY3M8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5TdGF0aXN0aWNzIGluY2x1ZGUgaGlzdG9yaWNhbCBpbmRpY2F0b3JzIGZvciBhbGwgc2VjdG9ycyB1bmRlciB0aGUganVyaXNkaWN0aW9uIG9mIEJhbmsgSW5kb25lc2lhLjwvcD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICA8L2Rpdj4KICAgICAgICA8L2Rpdj4KICAgIDwvZGl2Pgo8L2xpPjxsaSBjbGFzcz0nbmF2LWl0ZW0gZHJvcGRvd24nPgogICAgICA8YSBjbGFzcz0nbmF2LWxpbmsgZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vbGF5YW5hbi9kZWZhdWx0LmFzcHgnIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5TZXJ2aWNlczwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vcGVybWludGFhbi1pbmZvcm1hc2kvZGVmYXVsdC5hc3B4Jz4gSW5mb3JtYXRpb24gUmVxdWVzdCA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vcGVuZ2FkdWFuLWtvbnN1bWVuJz4gQ29uc3VtZXIgUHJvdGVjdGlvbiBhbmQgQ29tcGxhaW50cyA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vZWxpY2Vuc2luZy9kZWZhdWx0LmFzcHgnPiAgRS1MaWNlbnNpbmcgPC9hID48L2xpPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vbGF5YW5hbi9pbmZvcm1hc2ktcGVyaXppbmFuL2RlZmF1bHQuYXNweCc%2BTGljZW5zZWQgSW5zdGl0dXRpb25zPC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vaW5mb3JtYXNpLXBlcml6aW5hbi9wYXNhci1rZXVhbmdhbi9kZWZhdWx0LmFzcHgnID5Nb25leSBNYXJrZXQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9pbmZvcm1hc2ktcGVyaXppbmFuL3Npc3RlbS1wZW1iYXlhcmFuL2RlZmF1bHQuYXNweCcgPlBheW1lbnQgU3lzdGVtIGFuZCBSdXBpYWggQ3VycmVuY3kgTWFuYWdlbWVudDwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL3BlcnB1c3Rha2Fhbi8nPkxpYnJhcnk8L2E%2BPHNwYW4gY2xhc3M9J2NhcmV0Jz48L3NwYW4%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9wZXJwdXN0YWthYW4va29sZWtzaS1idWt1LycgPkJvb2sgQ29sbGVjdGlvbjwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4va2FzLWJpLyc%2BIEJhbmsgSW5kb25lc2lhIENhc2ggU2VydmljZSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vbGVsYW5nLWphc2EtYmFyYW5nLyc%2BIEdvb2RzIGFuZCBTZXJ2aWNlcyBBdWN0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9rdW5qdW5nYW4tYmkvZGVmYXVsdC5hc3B4Jz4gVmlzaXRhdGlvbiA8L2EgPjwvbGk%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL211c2V1bS1iaS8nPk11c2V1bTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9sYXlhbmFuL211c2V1bS1iaS9rb2xla3NpLW11c2V1bScgPk11c2V1bSBDb2xsZWN0aW9uPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vbXVzZXVtLWJpL3Byb2dyYW0taW5mb3JtYXNpL2RlZmF1bHQuYXNweCcgPk11c2V1bSBQcm9ncmFtIGFuZCBJbmZvcm1hdGlvbjwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL1N0YW5kYXIvU05BUC9kZWZhdWx0LmFzcHgnPlBheW1lbnQgU3lzdGVtIFN0YW5kYXJkIC0gT3BlbiBBUEk8L2E%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48L3VsPjwvdWw%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIGRyb3Bkb3duLW1lZ2FtZW51X19hYm91dCBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aHVtYm5haWwgbWItMicgc3R5bGU9J2JhY2tncm91bmQtaW1hZ2U6dXJsKCZxdW90Oy9NZW51JTIwSW1hZ2UvbGF5YW5hbi5qcGcmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlNlcnZpY2VzPC9wPgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS1kZXNjcmlwdGlvbic%2BQmFuayBJbmRvbmVzaWEgb2ZmZXJzIHZhcmlvdXMgc2VydmljZXMsIGluY2x1ZGluZyByZXF1ZXN0cyBmb3IgaW5mb3JtYXRpb24sIGNvbXBsYWludHMsIGxpY2Vuc2luZyBhbmQgc28gb24uPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9pbmZvcm1hc2ktcHVibGlrL0RlZmF1bHQuYXNweCcgaWQ9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJyByb2xlPSdidXR0b24nIGRhdGEtdG9nZ2xlPSdkcm9wZG93bicgYXJpYS1oYXNwb3B1cD0ndHJ1ZScgYXJpYS1leHBhbmRlZD0nZmFsc2UnPlB1YmxpYyBJbmZvcm1hdGlvbjwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2VuL2luZm9ybWFzaS1wdWJsaWsvcHJvZmlsLXBwaWQvRGVmYXVsdC5hc3B4Jz4gUHJvZmlsZSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2luZm9ybWFzaS1wdWJsaWsvZGFzYXItaHVrdW0nPiBSZWd1bGF0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9pbmZvcm1hc2ktcHVibGlrL0RlZmF1bHQuYXNweCc%2BIExpc3Qgb2YgUHVibGljIEluZm9ybWF0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9sYXlhbmFuLWluZm9ybWFzaS9EZWZhdWx0LmFzcHgnPiBJbmZvcm1hdGlvbiBTZXJ2aWNlIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9iZXJpdGEtcHBpZC9EZWZhdWx0LmFzcHgnPiBOZXdzIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL2luZm9ybWFzaS1wdWJsaWsucG5nJnF1b3Q7KSc%2BPC9kaXY%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRpdGxlJz5QdWJsaWMgSW5mb3JtYXRpb248L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5CYW5rIEluZG9uZXNpYSBtYWludGFpbnMgcHVibGljIGluZm9ybWF0aW9uIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgUHVibGljIEluZm9ybWF0aW9uIERpc2Nsb3N1cmUgQWN0IG9mIDIwMDguPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BZAI9D2QWAgIBD2QWBAIPDw8WAh8AaGQWAgIBD2QWAgIDD2QWAgIBDzwrAAkBAA8WAh4NTmV2ZXJFeHBhbmRlZGdkZAITD2QWAmYPFgIfAGhkAkEPZBYCAgEPZBYCAgEPZBYCZg9kFggCAQ8UKwACDxYEHwVnHwYCA2RkFgJmD2QWBgIBD2QWAmYPFQIXaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4ESG9tZWQCAg9kFgJmDxUCIWh0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL3N0YXRpc3RpawpTdGF0aXN0aWNzZAIDD2QWAmYPFQIwaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vc3RhdGlzdGlrL2luZm9ybWFzaS1rdXJzFUZvcmVpZ24gRXhjaGFuZ2UgUmF0ZWQCAw8WAh8HBRZGb3JlaWduIEV4Y2hhbmdlIFJhdGVzZAIFDxYCHwcFFkZvcmVpZ24gRXhjaGFuZ2UgUmF0ZXNkAgkPFgIfBwU%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%2FaWQ9Y29tLmJpLm1vYmlsZTdodHRwczovL3d3dy5iaS5nby5pZC9Tb3NpYWwlMjBNZWRpYS9pY29uLXBsYXktc3RvcmUuc3ZnZBgLBVJjdGwwMCRQbGFjZUhvbGRlck1haW4kZ182Yzg5ZDRhZF8xMDdmXzQzN2RfYmQ1NF84ZmRhMTdiNTU2YmYkY3RsMDAkZ3ZTZWFyY2hSZXN1bHQxD2dkBStjdGwwMCRVc2VyQ29udHJvbDEkY3RsMDAkTGlzdFZpZXdNZW51Rm9vdGVyDxQrAA5kZGRkZGRkFCsAA2RkZAIDZGRkZgL%2F%2F%2F%2F%2FD2QFRWN0bDAwJGdfZWNjMjU1OWVfNGE2MF80MzdmX2JhNThfODBlYWVlYTZiNGFhJGN0bDAwJExpc3RWaWV3QXBwc1Nvc21lZA8UKwAOZGRkZGRkZDwrAAcAAgdkZGRmAv%2F%2F%2F%2F8PZAUtY3RsMDAkUGxhY2VIb2xkZXJMZWZ0TmF2QmFyJFY0UXVpY2tMYXVuY2hNZW51Dw9kBQZSZWNlbnRkBU9jdGwwMCRQbGFjZUhvbGRlck1haW4kZ182Yzg5ZDRhZF8xMDdmXzQzN2RfYmQ1NF84ZmRhMTdiNTU2YmYkY3RsMDAkTGlzdFZpZXdLdXJzDxQrAA5kZGRkZGRkPCsAGgACGmRkZGYC%2F%2F%2F%2F%2Fw9kBSxjdGwwMCRQbGFjZUhvbGRlclRvcE5hdkJhciRUb3BOYXZpZ2F0aW9uTWVudQ8PZAUOQmFuayBJbmRvbmVzaWFkBV1jdGwwMCRQbGFjZUhvbGRlckJvdHRvbSRnX2UzMDUyYmUzXzY3M2NfNDA1ZV85Y2JlX2E4ODNhMjQ0YzA1MyRjdGwwMCRMaXN0Vmlld090aGVyTGlua3NTbGlkZXIPFCsADmRkZAIDZGRkFCsAAWQCAWRkZGYC%2F%2F%2F%2F%2Fw9kBUVjdGwwMCRnXzk2NzVlZjQ0Xzg5MzlfNDJlMl9hZWZkX2RmMWIxZTk3NTQ4NyRjdGwwMCRMaXN0Vmlld01lbnVIZWFkZXIPFCsADmRkZGRkZGQ8KwAEAAIEZGRkZgL%2F%2F%2F%2F%2FD2QFUmN0bDAwJFBsYWNlSG9sZGVyTWFpbiRnXzZjODlkNGFkXzEwN2ZfNDM3ZF9iZDU0XzhmZGExN2I1NTZiZiRjdGwwMCRndlNlYXJjaFJlc3VsdDIPZ2QFVGN0bDAwJFBsYWNlSG9sZGVyVG9wJGdfNzE3OTc2Y2JfOGI0OF80MjgzXzk4ZDBfYzFmZjVkNjk5YjVkJGN0bDAwJExpc3RWaWV3QnJlYWRjcnVtYg8UKwAOZGRkZGRkZBQrAANkZGQCA2RkZGYC%2F%2F%2F%2F%2Fw9kBUVjdGwwMCRnX2VjYzI1NTllXzRhNjBfNDM3Zl9iYTU4XzgwZWFlZWE2YjRhYSRjdGwwMCRMaXN0Vmlld09TUGxhdGZvcm0PFCsADmRkZGRkZGQUKwACZGQCAmRkZGYC%2F%2F%2F%2F%2Fw9k0fdDg5ROJEmaSe8FIAazpit1QNOZN4DOxeEIXZpaLeU%3D&__VIEWSTATEGENERATOR=FC2F6B36&__SCROLLPOSITIONX=0&__SCROLLPOSITIONY=0&__EVENTVALIDATION=%2FwEdAD5fPwGme843RfwEsPE1wynjMTZk9qLGncDjImqxppn1M6g%2BuGj1e5yNMxNarkQnNGQD%2FMwBujI58QztY2J%2FpZIxTKKThsEAjvBIzZ%2FazVBGeCseMKUY4FMnWOlaC4KYRMoqTRQkqOJA6zqRb4gMmtkgdx4UmW%2F7xcCfcKpKuvlz1%2Fn%2B9iGjf1yV0RPm%2B5CWNSgnxDJcvG1lEz%2Frc5StNmfqzcjpUZgS1ZX3d1EsQPAXraQs8icFer7v4LiV0lOOQsYkRT4zcerzyfUynDciQYKEq2lCtoHbb2hEni9ouOVEsm39Q00Fw17NOnm%2BozuW3CEwhfeQ2efgxu21Am0Xz33Z7DSMYxpJZKkihQpkRJvnuxXI27Xo9WTRzpFAqk0jLOR7yK6AgeEFi9%2Bu9QgiqdWHV43515M7TTl7yog%2BeChWakHqaPzhK6mK7oXe3z1Y%2FmxT7soP%2FalJ1OhQFU9%2FcTZdT86o%2BG0OT8tvJC5ae6RpK5mq6v%2BczfdP%2Bmy7NXpJ10ozzPUicZg0tsnR9pSA4MkFxSitqMXfoolGmE6GUUl2K5sL2zr2gw1Ecm04IkZ0%2FdPm%2B6NSzvtshRKHOBYURGG%2Ft4wdwgJiBPDE5CsYa%2FofAebObvLUToLFFFUcOA%2FvYuryS2OE5Hg4CA3d6DOoZaQxpxRBNFeDpaMAVVOs0lpH%2F%2BwY0WwoRdjFfqfhAqGeqa3Br28GzRrOR7o1YGWZsPDbuJmlp7jH35v0dcMRth%2Fkxf2ZxlBMrDRMuVgAWL2eRVf7X1zQvWcCOjjl0ejAC%2Bpyie8n0dVD2DOZ%2Fex1pANqnjtB9wxs4OS9Z2gAVh9%2FhP7iwQfY7NduX5ufutrTu8GQmOksuxcPOlo8LRC6lfUzWCeiY25rN0dyS2kHWGOLy%2BZ2zV0tAij06DHnycDDr9GcLbfwn9ozbra6EC0Z1FbCnsHKXYsh7eVy0%2B7zWcYIt7bbaUpWxXuZ0NecmjLcFda1lIZJdkNplB3BstzJsVdUyQHi3jkf1KoJnHceAFWAIlz2mfjyVIv5Sjt2AxeSkjLTCPBwnjM99olJgNCsJpgKW0UC3to7K60JXTWSBxmhAuYViN93nQ6%2B48B8esRgMbNKylMv4%2BxB3WNEOQHn0exjr9ErOzhjTsya3v77e9g1MLjA7%2F1%2Bel5DNfhcSXlZnxX8OM7SY2OjlPjYIcqlT%2F1kbIjHo1RoCoBOdKtPJM9iMrI2UtOvCGtbTiPlI23w2O6l4j3FR%2Fn12JgTE84Akvn%2F29zOw3KyOSJGJryE51hrVCFHIyqh9avaCdFUenvHgQvjtqLtNevYkENLUS02AUyBYW9w%2BQBP9yykaI8C%2FhOJh%2BPSn8FIUpZGYp8gfv9oKqCm&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24ddlmatauang1=AUD++&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtFrom=01-Mar-2026&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtTo=05-Mar-2026&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtTanggal=&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24btnSearch1=Search&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24hidSourceID=ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1
headers:
Accept-Encoding:
- gzip;q=1.0,deflate;q=0.6,identity;q=0.3
Accept:
- "*/*"
User-Agent:
- Mozilla/5.0 (compatible; Frankfurter/2.0; +https://frankfurter.dev)
Host:
- www.bi.go.id
Cookie:
- ''
Referer:
- https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
Content-Type:
- application/x-www-form-urlencoded
response:
status:
code: 200
message: OK
headers:
Cache-Control:
- private
Content-Type:
- text/html; charset=utf-8
Vary:
- Accept-Encoding
X-Sharepointhealthscore:
- ''
Sprequestguid:
- a9d406a2-0c2b-c0de-c56e-9aea96137dd2
Request-Id:
- a9d406a2-0c2b-c0de-c56e-9aea96137dd2
Strict-Transport-Security:
- max-age=31536000; includeSubDomains; preload
X-Frame-Options:
- SAMEORIGIN
Content-Security-Policy:
- frame-ancestors 'self' teams.microsoft.com *.teams.microsoft.com *.skype.com
*.teams.microsoft.us local.teams.office.com *.powerapps.com *.yammer.com *.officeapps.live.com
*.office.com *.stream.azure-test.net *.microsoftstream.com *.dynamics.com
*.microsoft.com onedrive.live.com *.onedrive.live.com;
Sprequestduration:
- '92'
Spiislatency:
- '0'
Microsoftsharepointteamservices:
- ''
X-Ms-Invokeapp:
- 1; RequireReadOnly
X-Xss-Protection:
- 1; mode=block
Date:
- Sun, 05 Apr 2026 00:49:27 GMT
Set-Cookie:
- TS0163f88e=01374ae98b3a7231d578e9e91c545ada939e932003fc7003de8faab9fe0dcd383e11a94787366bde3c0e97dab4a637ab982b289ecd;
Path=/
- cookie_BIWEB=!ZtIR7p6/RR2ALl/Mmb8IdYFy0ddrdVNHBBAbXCERULPgmSSjXd++crjSJucyGAbI5++AQ6+hCY9inCGVrBJbBGcGX7lbrnnFGR9hrpHP;
path=/; Httponly; Secure
Connection:
- Keep-Alive
Transfer-Encoding:
- chunked
body:
encoding: ASCII-8BIT
string: !binary |-

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html dir="ltr" lang="en-US">

    <head><meta name="keywords" content="Bank Indonesia, BI, Rupiah, kurs BI, kurs tengah BI, kalkulator kurs, inflasi, kurs transaksi, JISDOR, PINTAR BI, BI Fast, bank sentral, QRIS, uang Rupiah, SIMODIS, Sobat Rupiah, Cadangan Devisa, Gubernur Bank Indonesia, uang, bank, CBP, Cinta Bangga Rupiah, Cinta Rupiah, JIBOR, IndONIA" /><meta name="robots" content="index, follow" /><meta name="Author" content="Bank Indonesia" /><meta name="GENERATOR" content="Microsoft SharePoint" /><meta http-equiv="Content-type" content="text/html; charset=utf-8" /><meta http-equiv="X-UA-Compatible" content="IE=11; IE=10" /><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" /><meta name="viewport" content="width=device-width, initial-scale=1" /><meta http-equiv="X-UA-Compatible" content="IE=10"/><script type='text/javascript'>var _browserisFlight = true;</script><meta http-equiv="Expires" content="0" /><meta name="msapplication-TileImage" content="/_layouts/15/images/SharePointMetroAppTile.png" /><meta name="msapplication-TileColor" content="#0072C6" /><title>
	Foreign Exchange Rates
</title><link rel="shortcut icon" href="/favicon.png" type="image/vnd.microsoft.icon" id="favicon" /><link id="CssLink-01dfcce9568a4495b18f059df4663ade" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/Themable/corev15.css?rev=UP2nlZLed9gOy%2BMP38oz0A%3D%3DTAG0"/>
<link id="CssLink-6fb05b56652748a38e34acbdd134dc26" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/SuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ%3D%3DTAG0"/>
<style id="SPThemeHideForms" type="text/css">body {opacity:0 !important}</style><script type="text/javascript">// <![CDATA[ 

var g_SPOffSwitches={};
// ]]>
</script>
<script type="text/javascript" src="/_layouts/15/1033/initstrings.js?rev=94%2F8Pzbtowd6g2cd%2FsOoIg%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/init.js?rev=eqiUN2EN5Xn%2F2YyfuJQDtA%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/theming.js?rev=SuLUbbwTXcxFWOWLFUsOkw%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=sa1PqOHf5j2-6ssMNtdqimFp8nte-oIkdwJ1eOlUHUtOp0vjD2ImoMOMcCHq1bp0xvsD4Z3e86bZnUB2GeqPAZ5tXV4_nTT2jYY2_isi_31MH0efbPRKDe01qwHMlhjCqLYGR-Z4R_iUcMTmpehd2gzVBx3-AFsGfQMAjUkrTW2nxC2ljpAK-Lzwgqii3l2k0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=KvY94j2NghrBo6dT9b1k169bI6meVaRfhNlBBvNxLwKSSwkjBP3MBZHoPl9f9rloh9rNbh8ojtrmFM5d9fu_pn052DtTQVrukBbiH42jb3KYVgH6ktRQ-N9tLXZaVfnOiMT6hM1r-FY7atAipPNrcmQHuNtbk-ilaUaQ4QiBaTJCYyFOuHhrtEDu9ZQfUWGH0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/suitenav.js?rev=VM%2FdyE40A0OgsmOI%2BIKIqQ%3D%3DTAG0"></script>
<script type="text/javascript">RegisterSod("require.js", "\u002f_layouts\u002f15\u002frequire.js?rev=bv3fWJhk0uFGpVwBxnZKNQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("strings.js", "\u002f_layouts\u002f15\u002f1033\u002fstrings.js?rev=qTd5Iu3wkfWjQOhKADG18A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.res.resx", "\u002f_layouts\u002f15\u002f1033\u002fsp.res.js?rev=FnWveYddVjlqQYS2ZBOOzA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.runtime.js", "\u002f_layouts\u002f15\u002fsp.runtime.js?rev=ieBn\u00252FPr8FuV9095CsVXFdw\u00253D\u00253DTAG0");RegisterSodDep("sp.runtime.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.js", "\u002f_layouts\u002f15\u002fsp.js?rev=Os4G339\u00252BEf5vdNuG9dSWtw\u00253D\u00253DTAG0");RegisterSodDep("sp.js", "sp.runtime.js");RegisterSodDep("sp.js", "sp.ui.dialog.js");RegisterSodDep("sp.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.init.js", "\u002f_layouts\u002f15\u002fsp.init.js?rev=GcX1\u00252BQkwU9iewwepsza2Kw\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.dialog.js", "\u002f_layouts\u002f15\u002fsp.ui.dialog.js?rev=d7y1SiSVwqLJzuIiMAukpg\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.dialog.js", "sp.init.js");RegisterSodDep("sp.ui.dialog.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("core.js", "\u002f_layouts\u002f15\u002fcore.js?rev=OuK8lknoOD37VvjQyOsHrw\u00253D\u00253DTAG0");RegisterSodDep("core.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("menu.js", "\u002f_layouts\u002f15\u002fmenu.js?rev=WMbI5XqdDKTzX20rarEQsQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("mQuery.js", "\u002f_layouts\u002f15\u002fmquery.js?rev=wdHoEUjBno2g0ULGFwFjAg\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("callout.js", "\u002f_layouts\u002f15\u002fcallout.js?rev=yFnKkBSYasfA2rW6krdVFQ\u00253D\u00253DTAG0");RegisterSodDep("callout.js", "strings.js");RegisterSodDep("callout.js", "mQuery.js");RegisterSodDep("callout.js", "core.js");</script>
<script type="text/javascript">RegisterSod("sp.core.js", "\u002f_layouts\u002f15\u002fsp.core.js?rev=LSKJVyPWTBdDAU6EL2A6kw\u00253D\u00253DTAG0");RegisterSodDep("sp.core.js", "strings.js");RegisterSodDep("sp.core.js", "sp.init.js");RegisterSodDep("sp.core.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clienttemplates.js", "\u002f_layouts\u002f15\u002fclienttemplates.js?rev=oZO8iLnMIX278DJXZp9S4A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sharing.js", "\u002f_layouts\u002f15\u002fsharing.js?rev=z7dWWrP\u00252FqzzxvtLQKR08Ww\u00253D\u00253DTAG0");RegisterSodDep("sharing.js", "strings.js");RegisterSodDep("sharing.js", "mQuery.js");RegisterSodDep("sharing.js", "clienttemplates.js");RegisterSodDep("sharing.js", "core.js");</script>
<script type="text/javascript">RegisterSod("suitelinks.js", "\u002f_layouts\u002f15\u002fsuitelinks.js?rev=hNe7S\u00252B4EVV83bzPy9U\u00252BEvQ\u00253D\u00253DTAG0");RegisterSodDep("suitelinks.js", "strings.js");RegisterSodDep("suitelinks.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clientrenderer.js", "\u002f_layouts\u002f15\u002fclientrenderer.js?rev=Evu1eqGPwP\u00252FeN5ZuIpaSTQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("srch.resources.resx", "\u002f_layouts\u002f15\u002f1033\u002fsrch.resources.js?rev=vZPcBJM2l80oZNzRUCRQ4g\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("search.clientcontrols.js", "\u002f_layouts\u002f15\u002fsearch.clientcontrols.js?rev=xgTuNRzK\u00252B28qr6bjGThpIw\u00253D\u00253DTAG0");RegisterSodDep("search.clientcontrols.js", "sp.init.js");RegisterSodDep("search.clientcontrols.js", "clientrenderer.js");RegisterSodDep("search.clientcontrols.js", "srch.resources.resx");</script>
<script type="text/javascript">RegisterSod("sp.search.js", "\u002f_layouts\u002f15\u002fsp.search.js?rev=eMyDf7ZGV6rTjB2sDSdovA\u00253D\u00253DTAG0");RegisterSodDep("sp.search.js", "sp.init.js");RegisterSodDep("sp.search.js", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("ajaxtoolkit.js", "\u002f_layouts\u002f15\u002fajaxtoolkit.js?rev=I3jVxnVkBqeUZ\u00252FWA\u00252BgwTLg\u00253D\u00253DTAG0");RegisterSodDep("ajaxtoolkit.js", "search.clientcontrols.js");</script>
<script type="text/javascript">RegisterSod("userprofile", "\u002f_layouts\u002f15\u002fsp.userprofiles.js?rev=J0M1pzLkfDXcJflabMvTYA\u00253D\u00253DTAG0");RegisterSodDep("userprofile", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("followingcommon.js", "\u002f_layouts\u002f15\u002ffollowingcommon.js?rev=MgAestdI8p64n4UsP1Xeug\u00253D\u00253DTAG0");RegisterSodDep("followingcommon.js", "strings.js");RegisterSodDep("followingcommon.js", "sp.js");RegisterSodDep("followingcommon.js", "userprofile");RegisterSodDep("followingcommon.js", "core.js");RegisterSodDep("followingcommon.js", "mQuery.js");</script>
<script type="text/javascript">RegisterSod("profilebrowserscriptres.resx", "\u002f_layouts\u002f15\u002f1033\u002fprofilebrowserscriptres.js?rev=qwf69WaVc1mYlJLXqmZmVA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.mysitecommon.js", "\u002f_layouts\u002f15\u002fsp.ui.mysitecommon.js?rev=5nRJiZWvHP3AB7VS14cjuw\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.mysitecommon.js", "sp.init.js");RegisterSodDep("sp.ui.mysitecommon.js", "sp.runtime.js");RegisterSodDep("sp.ui.mysitecommon.js", "userprofile");RegisterSodDep("sp.ui.mysitecommon.js", "profilebrowserscriptres.resx");</script>
<script type="text/javascript">RegisterSod("browserScript", "\u002f_layouts\u002f15\u002fnon_ie.js?rev=KT6LY54Wt0vnHyVV6VVzWw\u00253D\u00253DTAG0");RegisterSodDep("browserScript", "strings.js");</script>
<script type="text/javascript">RegisterSod("inplview", "\u002f_layouts\u002f15\u002finplview.js?rev=ecdG8BqIlGbfoftF0\u00252FIAZA\u00253D\u00253DTAG0");RegisterSodDep("inplview", "strings.js");RegisterSodDep("inplview", "core.js");RegisterSodDep("inplview", "clienttemplates.js");RegisterSodDep("inplview", "sp.js");</script>
<script type="text/javascript">RegisterSod("cui.js", "\u002f_layouts\u002f15\u002fcui.js?rev=ejf8nksDjeL2s1mvUvw77w\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("ribbon", "\u002f_layouts\u002f15\u002fsp.ribbon.js?rev=wPDmc1LZubpR2Fgk01M8qw\u00253D\u00253DTAG0");RegisterSodDep("ribbon", "strings.js");RegisterSodDep("ribbon", "core.js");RegisterSodDep("ribbon", "sp.core.js");RegisterSodDep("ribbon", "sp.js");RegisterSodDep("ribbon", "cui.js");RegisterSodDep("ribbon", "sp.res.resx");RegisterSodDep("ribbon", "sp.runtime.js");RegisterSodDep("ribbon", "inplview");</script>
<script type="text/javascript">RegisterSod("WPAdderClass", "\u002f_layouts\u002f15\u002fwpadder.js?rev=cLi8ZAp2DVY4x\u00252BMDFIRWvQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("dragdrop.js", "\u002f_layouts\u002f15\u002fdragdrop.js?rev=h\u00252F2Jd5ursJLUu88iNs\u00252FM2A\u00253D\u00253DTAG0");RegisterSodDep("dragdrop.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("quicklaunch.js", "\u002f_layouts\u002f15\u002fquicklaunch.js?rev=yuA4NhRQlmo9X6TJsaidUg\u00253D\u00253DTAG0");RegisterSodDep("quicklaunch.js", "strings.js");RegisterSodDep("quicklaunch.js", "dragdrop.js");</script>
<link type="text/xml" rel="alternate" href="/en/statistik/informasi-kurs/transaksi-bi/_vti_bin/spsdisco.aspx" /><link href="/Style Library/biweb/css/bootstrap4.min.css" rel="stylesheet" />
        
        <!-- Update Font Family 1 Februari 2024 -->
        <link rel="preconnect" href="https://fonts.googleapis.com" /><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin="" />
		<!-- Update Font Family 2 Februari 2026 -->
		<link href="https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,400;1,300&amp;display=swap" integrity="sha512-e2mrHtfsfL/rkAg+Q3rQpEIkWMdGU36OfDwUIJz4nyq7/pevf44ZAXwTt1/mr8mLsnPJbslCx85k+qRTTZIDjA==" crossorigin="anonymous" rel="stylesheet" /><link href="https://fonts.googleapis.com/css2?family=PT+Sans&amp;display=swap" integrity="sha512-pZRQvRtRsHut00kYTpiGGYlYLiGNEP+/efrLNNzhAxe/uT3UiRpLYUEqXW1+zwVvWAxWrVyYxrDT6tDShkc2lA==" crossorigin="anonymous" rel="stylesheet" /><link href="/Style Library/biweb/css/maincss.min.css" rel="stylesheet" />
        
        <!--<script src="/Style Library/biweb/js/jquery-3.4.1.min.js" type="text/javascript"></script>-->
        <script src="/Style Library/biweb/js/jquery-3.5.1.min.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/bootstrap4.min.js" type="text/javascript"></script>        
        <script src="/Style Library/biweb/js/jquery.scollingTabs.min.js" type="text/javascript"></script>       
        <script src="/Style Library/biweb/js/mainjs.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/jquery.dataTables.min.js" type="text/javascript"></script>
        <link href="/Style Library/biweb/css/jquery.dataTables.min.css" rel="stylesheet" />
                
		<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
		new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
		j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
		'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
		})(window,document,'script','dataLayer','GTM-TX6N9KL');</script>
		<script>
			  $(document).ready(function() {
			    if (window.location.href.indexOf("/en/") > -1) {
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia has one single objective of achieving and maintaining stability of the Rupiah value." />' );
							    }
			    else{
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia adalah Bank Sentral Republik Indonesia dengan Satu Tujuan Tunggal yaitu Mencapai dan Memelihara Kestabilan Nilai Rupiah." />' );
							    }
			  });
		</script>
		<script  type="text/javascript">
			$(document).ready(function(){
				setTimeout(function () {
					$('#ctl00_onetidProjectPropertyTitleGraphic').attr("title", "Bank Indonesia")
			        if (window.location.href.indexOf("/en/") > -1) {
			           $('#ctl00_onetidProjectPropertyTitleGraphic').attr('href', '/en/');
			        }
			    }, 500); 	
			    
				$('#tablecustom').DataTable();		
			});
		</script>
		
        
            
	<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
    <script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>
    <script type="text/javascript">
        $(window).ready(function () {
            $('#selectPeriod').change(function () {
                $('.datepicker-period').hide();
                $('#' + $(this).val()).show();
            });



            var date_input_harian = $('.input-daterange-harian input');
            var options = {
                format: 'mm/dd/yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto"
            };
            date_input_harian.datepicker(options);
        });
    </script>

            <link rel="canonical" href="https://www.bi.go.id:443/en/statistik/informasi-kurs/transaksi-bi/default.aspx" />
            
        </head>

    <body>
	<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TX6N9KL"
	height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
      <div id="imgPrefetch" style="display:none">
<img src="/favicon.png?rev=43" />
<img src="/_layouts/15/images/spcommon.png?rev=43" />
<img src="/SiteAssets/logo-bi@2x.png?rev=43" />
</div>

        <noscript><div class='noindex'>You may be trying to access this site from a secured browser on the server. Please enable scripts and reload this page.</div></noscript>
        
        <form method="post" action="./default.aspx" onsubmit="javascript:return WebForm_OnSubmit();" id="aspnetForm">
<div class="aspNetHidden">
<input type="hidden" name="_wpcmWpid" id="_wpcmWpid" value="" />
<input type="hidden" name="wpcmVal" id="wpcmVal" value="" />
<input type="hidden" name="MSOWebPartPage_PostbackSource" id="MSOWebPartPage_PostbackSource" value="" />
<input type="hidden" name="MSOTlPn_SelectedWpId" id="MSOTlPn_SelectedWpId" value="" />
<input type="hidden" name="MSOTlPn_View" id="MSOTlPn_View" value="0" />
<input type="hidden" name="MSOTlPn_ShowSettings" id="MSOTlPn_ShowSettings" value="False" />
<input type="hidden" name="MSOGallery_SelectedLibrary" id="MSOGallery_SelectedLibrary" value="" />
<input type="hidden" name="MSOGallery_FilterString" id="MSOGallery_FilterString" value="" />
<input type="hidden" name="MSOTlPn_Button" id="MSOTlPn_Button" value="none" />
<input type="hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
<input type="hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
<input type="hidden" name="__REQUESTDIGEST" id="__REQUESTDIGEST" value="0x5C28D1A02F717AEB030CA283D78945E384C77FD0010AA2FCADBEAD5AD8E5AC3A3800AE82B6576053947B8211DFA98B3467A00F7D48422B949470890776CB920A,05 Apr 2026 00:49:28 -0000" />
<input type="hidden" name="MSOSPWebPartManager_DisplayModeName" id="MSOSPWebPartManager_DisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_ExitingDesignMode" id="MSOSPWebPartManager_ExitingDesignMode" value="false" />
<input type="hidden" name="MSOWebPartPage_Shared" id="MSOWebPartPage_Shared" value="" />
<input type="hidden" name="MSOLayout_LayoutChanges" id="MSOLayout_LayoutChanges" value="" />
<input type="hidden" name="MSOLayout_InDesignMode" id="MSOLayout_InDesignMode" value="" />
<input type="hidden" name="_wpSelected" id="_wpSelected" value="" />
<input type="hidden" name="_wzSelected" id="_wzSelected" value="" />
<input type="hidden" name="MSOSPWebPartManager_OldDisplayModeName" id="MSOSPWebPartManager_OldDisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_StartWebPartEditingName" id="MSOSPWebPartManager_StartWebPartEditingName" value="false" />
<input type="hidden" name="MSOSPWebPartManager_EndWebPartEditing" id="MSOSPWebPartManager_EndWebPartEditing" value="false" />
<input type="hidden" name="_maintainWorkspaceScrollPosition" id="_maintainWorkspaceScrollPosition" value="0" />
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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" />
</div>

<script type="text/javascript">
//<![CDATA[
var theForm = document.forms['aspnetForm'];
if (!theForm) {
    theForm = document.aspnetForm;
}
function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
        theForm.__EVENTTARGET.value = eventTarget;
        theForm.__EVENTARGUMENT.value = eventArgument;
        theForm.submit();
    }
}
//]]>
</script>


<script src="/WebResource.axd?d=HRMEYubZPUzVts77E_7Ik1yT-44y5_IDixxutdmFieYdhwteoLUd0gvCyyYvKy3z7ple1Au9_czBVt-tA8fqYJ7_DchPiphcRPRL6mZmE2M1&amp;t=638259656865233147" type="text/javascript"></script>


<script type="text/javascript">
//<![CDATA[
var MSOWebPartPageFormName = 'aspnetForm';
var g_presenceEnabled = true;
var g_wsaEnabled = false;

var g_correlationId = 'a9d406a2-0c2b-c0de-c56e-9aea96137dd2';
var g_wsaQoSEnabled = false;
var g_wsaQoSDataPoints = [];
var g_wsaRUMEnabled = false;
var g_wsaLCID = 1033;
var g_wsaListTemplateId = null;
var g_wsaSiteTemplateId = 'CMSPUBLISHING#0';
var _spPageContextInfo={"webServerRelativeUrl":"/en/statistik/informasi-kurs/transaksi-bi","webAbsoluteUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","viewId":"","listId":"","listPermsMask":null,"listUrl":"","listTitle":null,"listBaseTemplate":-1,"viewOnlyExperienceEnabled":false,"blockDownloadsExperienceEnabled":false,"idleSessionSignOutEnabled":false,"cdnPrefix":"","siteAbsoluteUrl":"https://www.bi.go.id","siteId":"{e671e14c-2777-404f-9b86-2f3b332aa0f1}","showNGSCDialogForSyncOnTS":false,"supportPoundStorePath":true,"supportPercentStorePath":true,"siteSubscriptionId":null,"CustomMarkupInCalculatedFieldDisabled":true,"AllowCustomMarkupInCalculatedField":false,"isSPO":false,"farmLabel":null,"serverRequestPath":"/en/statistik/informasi-kurs/transaksi-bi/default.aspx","layoutsUrl":"_layouts/15","webId":"{18d3b9c9-56e5-44c2-9518-566e5ed25d9a}","webTitle":"Foreign Exchange Rates","webTemplate":"39","webTemplateConfiguration":"CMSPUBLISHING#0","webDescription":"","tenantAppVersion":"0","isAppWeb":false,"webLogoUrl":"/SiteAssets/logo-bi@2x.png","webLanguage":1033,"currentLanguage":1033,"currentUICultureName":"en-US","currentCultureName":"en-US","currentCultureLCID":1033,"env":null,"nid":0,"fid":0,"serverTime":"2026-04-05T00:49:28.2795332Z","siteClientTag":"2144$$16.0.10417.20037","crossDomainPhotosEnabled":false,"openInClient":false,"Has2019Era":true,"webUIVersion":15,"webPermMasks":{"High":16,"Low":196673},"pageListId":null,"pageItemId":-1,"pagePermsMask":null,"pagePersonalizationScope":1,"userEmail":"","userId":0,"userLoginName":null,"userDisplayName":null,"isAnonymousUser":true,"isAnonymousGuestUser":false,"isEmailAuthenticationGuestUser":false,"isExternalGuestUser":false,"systemUserKey":null,"alertsEnabled":true,"siteServerRelativeUrl":"/","allowSilverlightPrompt":"True","themeCacheToken":"/en/statistik/informasi-kurs/transaksi-bi::9:","themedCssFolderUrl":null,"themedImageFileNames":null,"modernThemingEnabled":true,"isSiteAdmin":false,"ExpFeatures":[480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"killSwitches":{},"InternalValidAuthorities":["www.bi.go.id","web.bi.go.id","dc1biwebapp21","dc1biwebapp22"],"CorrelationId":"a9d406a2-0c2b-c0de-c56e-9aea96137dd2","hasManageWebPermissions":false,"isNoScriptEnabled":false,"groupId":null,"groupHasHomepage":true,"groupHasQuickLaunchConversationsLink":false,"departmentId":null,"hubSiteId":null,"hasPendingWebTemplateExtension":false,"isHubSite":false,"isWebWelcomePage":true,"siteClassification":"","hideSyncButtonOnODB":false,"showNGSCDialogForSyncOnODB":false,"sitePagesEnabled":false,"sitePagesFeatureVersion":0,"DesignPackageId":"00000000-0000-0000-0000-000000000000","groupType":null,"groupColor":"#757575","siteColor":"#757575","headerEmphasis":0,"navigationInfo":null,"guestsEnabled":false,"MenuData":{"SignInUrl":"/en/statistik/informasi-kurs/transaksi-bi/_layouts/15/Authenticate.aspx?Source=%2Fen%2Fstatistik%2Finformasi%2Dkurs%2Ftransaksi%2Dbi%2Fdefault%2Easpx"},"RecycleBinItemCount":-1,"PublishingFeatureOn":true,"PreviewFeaturesEnabled":false,"disableAppViews":false,"disableFlows":false,"serverRedirectedUrl":null,"formDigestValue":"0x5C28D1A02F717AEB030CA283D78945E384C77FD0010AA2FCADBEAD5AD8E5AC3A3800AE82B6576053947B8211DFA98B3467A00F7D48422B949470890776CB920A,05 Apr 2026 00:49:28 -0000","maximumFileSize":10240,"formDigestTimeoutSeconds":1800,"canUserCreateMicrosoftForm":false,"canUserCreateVisioDrawing":true,"readOnlyState":null,"isTenantDevSite":false,"preferUserTimeZone":false,"userTimeZoneData":null,"userTime24":false,"userFirstDayOfWeek":null,"webTimeZoneData":null,"webTime24":false,"webFirstDayOfWeek":null,"isSelfServiceSiteCreationEnabled":null,"alternateWebAppHost":"","aadTenantId":"","aadUserId":"","aadInstanceUrl":"","msGraphEndpointUrl":"https://","allowInfectedDownload":true};_spPageContextInfo.updateFormDigestPageLoaded=new Date();_spPageContextInfo.clientServerTimeDelta=new Date(_spPageContextInfo.serverTime)-new Date();if(typeof(define)=='function'){define('SPPageContextInfo',[],function(){return _spPageContextInfo;});}
function _spNavigateHierarchy(nodeDiv, dataSourceId, dataPath, url, listInContext, type) {

    CoreInvoke('ProcessDefaultNavigateHierarchy', nodeDiv, dataSourceId, dataPath, url, listInContext, type, document.forms.aspnetForm, "", "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002fdefault.aspx");

}
Flighting.ExpFeatures = [480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; (function()
{
    if(typeof(window.SP) == "undefined") window.SP = {};
    if(typeof(window.SP.YammerSwitch) == "undefined") window.SP.YammerSwitch = {};

    var ysObj = window.SP.YammerSwitch;
    ysObj.IsEnabled = false;
    ysObj.TargetYammerHostName = "www.yammer.com";
} )(); //]]>
</script>

<script src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0" type="text/javascript"></script>
<script type="text/javascript">
//<![CDATA[
window.SPThemeUtils && SPThemeUtils.RegisterCssReferences([{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","Id":"CssLink-01dfcce9568a4495b18f059df4663ade","ConditionalExpression":"","After":"","RevealToNonIE":"false"},{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","Id":"CssLink-6fb05b56652748a38e34acbdd134dc26","ConditionalExpression":"","After":"","RevealToNonIE":"false"}]);
(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingDocument', function() { FollowingDocument(); });
        });
    })();(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingCallout', function() { FollowingCallout(); });
        });
    })();if (typeof(DeferWebFormInitCallback) == 'function') DeferWebFormInitCallback();function WebForm_OnSubmit() {
UpdateFormDigest('\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi', 1440000);
                    var workspaceElem = GetCachedElement("s4-workspace");
                    if (workspaceElem != null)
                    {
                        var scrollElem = GetCachedElement("_maintainWorkspaceScrollPosition");
                        if (scrollElem != null)
                        {
                            scrollElem.value = workspaceElem.scrollTop;
                        }
                    };
                if (typeof(_spFormOnSubmitWrapper) != 'undefined') {return _spFormOnSubmitWrapper();} else {return true;};
return true;
}
//]]>
</script>

<div class="aspNetHidden">

	<input type="hidden" name="__VIEWSTATEGENERATOR" id="__VIEWSTATEGENERATOR" value="FC2F6B36" />
	<input type="hidden" name="__SCROLLPOSITIONX" id="__SCROLLPOSITIONX" value="0" />
	<input type="hidden" name="__SCROLLPOSITIONY" id="__SCROLLPOSITIONY" value="0" />
	<input type="hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" value="/wEdAAvDbL/qnU2l5jt/1eEs5GxxMTZk9qLGncDjImqxppn1M7eMHcICYgTwxOQrGGv6HwHmzm7y1E6CxRRVHDgP72Lq8ktjhOR4OAgN3egzqGWkMacUQTRXg6WjAFVTrNJaR//sGNFsKEXYxX6n4QKhnqmtK20/AEkSVHfI/JCTRr8SpUcjKqH1q9oJ0VR6e8eBC+NaeZ5zk4cyCpiarxz3A4I0tqLtNevYkENLUS02AUyBYegI8dLZjYRyLx/nhtUW1Wqvqqcn/I3dak7WFvGtEmxE" />
</div>
            <script type="text/javascript">
//<![CDATA[
Sys.WebForms.PageRequestManager._initialize('ctl00$ScriptManager', 'aspnetForm', ['fctl00$WebPartAdderUpdatePanel',''], [], ['ctl00$WebPartAdder',''], 90, 'ctl00');
//]]>
</script>

            
            <script
                type="text/javascript"> var submitHook = function () { return false; }; theForm._spOldSubmit = theForm.submit; theForm.submit = function () { if (!submitHook()) { this._spOldSubmit(); } }; </script>
            <span id="DeltaSPWebPartManager">
            </span>
            <span id="DeltaDelegateControls">
                
                
            </span>
            <div id="TurnOnAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOnAcc"
                    title="Turn on more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(true);UpdateAccessibilityUI();document.getElementById('linkTurnOffAcc').focus();return
                false;">
                Turn on more accessible mode</a></div>
            <div id="TurnOffAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOffAcc"
                    title="Turn off more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(false);UpdateAccessibilityUI();document.getElementById('linkTurnOnAcc').focus();return
                false;">
                Turn off more accessible mode</a></div>
            <div class="s4-notdlg s4-skipribbonshortcut noindex">
                <a href="javascript:;"
                    title="Skip Ribbon Commands"
                onclick="document.getElementById('startNavigation').focus();" class="ms-accessible ms-acc-button"
                accesskey="
                Y">
                Skip Ribbon Commands</a></div>
            <div class="s4-notdlg noindex">
                <a href="javascript:;"
                    title="Skip to main content"
                onclick="document.getElementById('mainContent').focus();" class="ms-accessible ms-acc-button">
                Skip to main content</a></div>
            <div id="TurnOffAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOffAnimation"
                    title="Turn off Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn off Animations</a></div>
            <div id="TurnOnAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOnAnimation"
                    title="Turn on Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn on Animations</a></div>
            <a id="HiddenAnchor" href="javascript:;" style="display:none;"></a>

                <div id="suiteBarDelta" class="ms-dialogHidden ms-fullWidth noindex">
	
                    <div id="suiteMenuData" class="ms-hide">
                        


                        <span class="ms-siteactions-root" id="siteactiontd">
                            
                        </span>
                    </div>
                    <script type="text/javascript">// <![CDATA[ 

var g_navBarHelpDefaultKey = "HelpHome";
		
		 // ]]>
</script>
                    <div id="suiteBarTop" class="ms-fullWidth ms-TopBarBackground-bgColor" style="height:50px; position:relative;">

	</div><div class="wf-family-o365 o365wf" style="display:none">

	</div>
                
</div>

                <div id="ms-hcTest"></div>
                                <div id="s4-ribbonrow">
                    <div id="globalNavBox" class="noindex">
                        <div id="ribbonBox">
                            <div id="s4-ribboncont">
                                <div id="DeltaSPRibbon">
	
                                    

                                    <input id="RibbonContainer_activeTabId" name="ctl00$ctl74" type="hidden" value=""/><div id='RibbonContainer'><div class="ms-cui-ribbon ms-cui-needIEFilter" id="Ribbon" unselectable="on" aria-describedby="ribboninstructions" role="toolbar"><span class="ms-cui-hidden" id="ribboninstructions" unselectable="on">To navigate through the Ribbon, use standard browser navigation keys. To skip between groups, use Ctrl+LEFT or Ctrl+RIGHT. To jump to the first Ribbon tab use Ctrl+[. To jump to the last selected command use Ctrl+]. To activate a command, use Enter.</span><div class="ms-cui-ribbonTopBars" unselectable="on"><div class="ms-cui-topBar1" unselectable="on" style="display:none"><div class="ms-cui-qat-container" unselectable="on"></div></div><div class="ms-cui-topBar2" unselectable="on"><div class="ms-cui-jewel-container" id="jewelcontainer" unselectable="on" style="display:none"></div><div class="ms-cui-TabRowLeft ms-core-defaultFont ms-dialogHidden" id="RibbonContainer-TabRowLeft" unselectable="on">
									
								
                                        </div><ul class="ms-cui-tts" unselectable="on" role="tablist"><li class="ms-cui-tt ms-browseTab ms-cui-tt-s" id="Ribbon.Read-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.Read',false, event);" title="Browse" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.Read',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Browse</span><span class="ms-cui-hidden" unselectable="on">Tab 1 of 2.</span></a></li><li class="ms-cui-tt" id="Ribbon.WebPartPage-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.WebPartPage',false, event);" title="Page" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.WebPartPage',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Page</span><span class="ms-cui-hidden" unselectable="on">Tab 2 of 2.</span></a></li></ul><div class="ms-cui-TabRowRight s4-trc-container s4-notdlg ms-core-defaultFont" id="RibbonContainer-TabRowRight" unselectable="on">
									
								
                                            
                                            <a onmouseover="this.firstChild.firstChild.style.left=&#39;-217px&#39;; this.firstChild.firstChild.style.top=&#39;-192px&#39;;" onmouseout="this.firstChild.firstChild.style.left=&#39;-218px&#39;; this.firstChild.firstChild.style.top=&#39;-48px&#39;;" onclick="SP.SOD.executeFunc(&#39;followingcommon.js&#39;, &#39;FollowSite&#39;, function() { FollowSite(); }); return false;" id="site_follow_button" title="Follow this site and get back to it easily from your sites page." class="ms-promotedActionButton" href="javascript:__doPostBack(&#39;ctl00$site_follow_button&#39;,&#39;&#39;)" style="display:inline-block;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust ms-promotedActionButton-icon"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Follow" style="position:absolute;left:-218px;top:-48px;" /></span><span class="ms-promotedActionButton-text">Follow</span></a>
                                            
                                            
                                            <span id="fullscreenmodebox" class="ms-qatbutton">
                                                <span id="fullscreenmode">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-125px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-143px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_fullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(true);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-143px;top:-178px;" /></span></span></a>
                                                </span>
                                                <span id="exitfullscreenmode" style="display: none;">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-179px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-96px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-107px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_exitfullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(false);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-107px;top:-178px;" /></span></span></a>
                                                </span>
                                            </span>
                                            
                                            
                                        </div></div></div></div></div>
                                
</div>
                            </div>
                            <span id="DeltaSPNavigation">
                                
									<span id="ctl00_SPNavigation_ctl00_publishingRibbon"></span>

                                
                            </span>
                        </div>
                        <div id="DeltaWebPartAdderUpdatePanelContainer" class="ms-core-webpartadder">
	
                            <div id="WebPartAdderUpdatePanelContainer">
                                <div id="ctl00_WebPartAdderUpdatePanel">
		
										<span id="ctl00_WebPartAdder"></span>
									
	</div>
                            </div>
                        
</div>
                    </div>
                </div>

         

            <div id="s4-workspace" class="ms-core-overlay">
                <div id="s4-bodyContainer">
                    <div id="s4-titlerow" class="ms-dialogHidden s4-titlerowhidetitle d-none">
                        <div id="titleAreaBox" class="ms-noList ms-table ms-core-tableNoSpace">
                            <div id="titleAreaRow" class="ms-tableRow">
                                <div class="ms-breadcrumb-box ms-tableCell ms-verticalAlignTop">
                                    <div class="ms-breadcrumb-top">
                                        <div class="ms-breadcrumb-dropdownBox" style="display:none;">
                                            <span id="DeltaBreadcrumbDropdown">
                                                
                                            </span>
                                        </div>
                                        <div id="DeltaTopNavigation" class="ms-displayInline ms-core-navigation" role="navigation">
	
                                            
                                            
												<div id="zz1_TopNavigationMenu" class=" noindex ms-core-listMenu-horizontalBox">
		<ul id="zz2_RootAspMenu" class="root ms-core-listMenu-root static">
			<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" title="Home" href="/default.aspx" accesskey="1"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Bank Indonesia</span><span class="ms-hidden">Currently selected</span></span></a></li>
		</ul>
	</div>
                                            
                                        
</div>
                                    </div>
                                    <h1 id="pageTitle" class="ms-core-pageTitle">
                                        <span id="DeltaPlaceHolderPageTitleInTitleArea">
                                            
												Foreign Exchange Rates
                                            
                                        </span>
                                        <div id="DeltaPlaceHolderPageDescription" class="ms-displayInlineBlock ms-normalWrap">
	
                                            <a href="javascript:;" id="ms-pageDescriptionDiv" style="display:none;"
                                                data-accessibility-nocheck="true">
                                                <span id="ms-pageDescriptionImage">&#160;</span>
                                            </a>
                                            <span class="ms-accessible" id="ms-pageDescription">
                                                
                                            </span>
                                            <script type="text/javascript">// <![CDATA[ 

_spBodyOnLoadFunctionNames.push("setupPageDescriptionCallout");
										
										 // ]]>
</script>
                                        
</div>
                                    </h1>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                    <div id="DeltaPlaceHolderGroupActionsArea" class="ms-floatRight ms-noWrap">
	
                                        
                                    
</div>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                </div>
                            </div>
                        </div>
                    </div>

                    <header class="ms-dialogHidden mega-menu-wrapper noindex">
                        <div class="top-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                        
                                
<div id="ctl00_g_9675ef44_8939_42e2_aefd_df1b1e975487" __MarkupType="vsattributemarkup" __WebPartId="{9675ef44-8939-42e2-aefd-df1b1e975487}" WebPart="true">
	
        <ul class="header-menu navbar-nav">
            
        <li class="nav-item"><a href='https://www.bi.go.id/en/karier' >Career</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/edukasi' >Education</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/glosarium.aspx' >Glossary</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/peta-situs.aspx' >Sitemap</a></li>       
    
        </ul>
    

</div>
                                        
                                
                                    <div id="DeltaPlaceHolderSearchArea" class="ms-mpSearchBox clearfix">
	
                                        
											<div id="searchInputBox">
                                                <div class="ms-webpart-chrome ms-webpart-chrome-fullWidth ">
		<div WebPartID="00000000-0000-0000-0000-000000000000" HasPers="true" id="WebPartWPQ1" width="100%" class="ms-WPBody " OnlyForMePart="true" allowDelete="false" style="" ><div componentid="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"><div id="SearchBox" name="Control"><div class="ms-srch-sb ms-srch-sb-border" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv"><input type="search" value="Search this site" maxlength="2048" title="Search this site" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox" autocomplete="off" autocorrect="off" onkeypress="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {if (Srch.U.isEnterKey(String.fromCharCode(event.keyCode))) {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);return Srch.U.cancelEvent(event);}})" onkeydown="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.activateDefaultQuerySuggestionBehavior();})" onfocus="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.hidePrompt();ctl.setBorder(true);})" onblur="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr'); if (ctl){ ctl.showPrompt(); ctl.setBorder(false);}})" class="ms-textSmall ms-srch-sb-prompt ms-helperText" role="combobox" aria-owns="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" aria-haspopup="true" aria-autocomplete="list" aria-expanded="false" /><a title="Search" role="button" class="ms-srch-sb-searchLink" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink" onclick="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);})" href="javascript: {}" aria-label="Search"><img src="/_layouts/15/images/searchresultui.png?rev=43#ThemeKey=searchresultui" class="ms-srch-sb-searchImg" id="searchImg" alt="Search" /></a><div class="ms-qSuggest-container ms-shadow" id="AutoCompContainer"><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" role="listbox" aria-label="Suggestions"></div></div></div></div></div><noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_noscript">It looks like your browser does not have JavaScript enabled. Please turn on JavaScript and try again.</div></noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1">

		</div><div class="ms-clear"></div></div>
	</div>
                                            </div>
                                        
                                    
</div>

                                    <div id="bahasa-indon" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="ENLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>
                                    <div id="bahasa-english" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="IDLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>


                                </nav>
                            </div>
                        </div>
                        <div class="bottom-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                    <div id="siteIcon" class="ms-tableCell ms-verticalAlignTop">
                                        <div id="DeltaSiteLogo">
	
                                            <a id="ctl00_onetidProjectPropertyTitleGraphic" class="ms-siteicon-a" href="/id/"><img id="ctl00_onetidHeadbnnr2" class="ms-siteicon-img" name="onetidHeadbnnr0" src="/SiteAssets/logo-bi@2x.png" alt="Foreign Exchange Rates" /></a>
                                        
</div>
                                    </div>

                                    <button class="navbar-toggler" type="button" data-toggle="collapse"
                                        data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent"
                                        aria-expanded="false" aria-label="Toggle navigation">
                                        <span class="navbar-toggler-icon"></span>
                                    </button>
                                    
                                    <div class="collapse navbar-collapse navbar-responsive" id="navbarSupportedContent">
										<div class="noindex">
	                                        <div id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7" __MarkupType="vsattributemarkup" __WebPartId="{3e01a6ba-0414-4f22-b082-8b109c19b6c7}" WebPart="true">
	

<ul class="top-menu navbar-nav" id="test-menu">           
    <li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/tentang-bi/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>About BI</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/tentang-bi/profil/Default.aspx'>Profile</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/tentang-bi/profil/organisasi/Default.aspx' > Organization</a></li><li class='level3'><a href = '/en/tentang-bi/profil/governance/default.aspx' >Governance</a></li><li class='level3'><a href = '/en/tentang-bi/profil/uu-bi/Default.aspx' >Regulations</a></li></ul><li><a href = '/en/tentang-bi/sejarah-bi/Default.aspx'> History </a ></li><li><a href = '/en/tentang-bi/transformasi/Default.aspx'> Transformation </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/tentang-BI_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>About BI</p>
                        <p class='dropdown-megamenu__about--description'>Information about the organisation, transformation and history of Bank Indonesia as the central bank of the Republic of Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/fungsi-utama/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Main Functions</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/moneter/Default.aspx'>Monetary</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/moneter/inflasi/Default.aspx' >Inflation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indikator-moneter/default.aspx' >Monetary Indicator</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/bi-rate/default.aspx' >BI-Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/operasi-moneter/Default.aspx' >Monetary Operation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indonia-jibor/Default.aspx' >INDONIA, Compounded INDONIA, INDONIA Index and JIBOR</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/informasi-kurs/default.aspx' >JISDOR, Non-USD/IDR Reference Rate, and Transaction Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pengembangan-ekonomi/Default.aspx' >Sharia Economy and Financial</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/'>Financial System Stability</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/' >Overview</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/instrumen-makroprudensial/default.aspx' >Macroprudential Policy Instrument</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/manajemen-krisis/default.aspx' >Crisis Management Protocol</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/koordinasi-bi-lainnya/' >Institutional Coordination</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/pengembangan-umkm/' >MSME Development</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/keuangan-inklusif/' >Financial Inclusion</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/sistem-pembayaran'>Payment System and Rupiah Currency Management</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/nilai-besar/' >High Value Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/ritel/' >Retail Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/pengelolaan-rupiah/default.aspx' >Rupiah Currency Management</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/perizinan/default.aspx' >Licensing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/anti-pencucian-uang-dan-pencegahan-pendanaan-terrorisme/' >Anti-Money Laundering and Counter-Terrorism Financing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/Standardisasi-Kompetensi/Default.aspx' >Standardisation Of HR Competencies</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/blueprint/default.aspx' >Indonesia Payment System Blueprint</a></li></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Style Library/biweb/img/bi-photo.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Main Functions</p>
                        <p class='dropdown-megamenu__about--description'>Information about the main functions and responsibilities of Bank Indonesia to achieve and maintain rupiah stability.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/rupiah/' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Rupiah</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/rupiah/gambar-uang/Default.aspx'> Currency Image </a ></li><li><a href = '/en/rupiah/uang-dicabut/'> Withdrawn Currency </a ></li><li><a href = '/en/rupiah/pencegahan-rupiah-palsu/'> Counterfeit Prevention and Management </a ></li><li><a href = '/en/rupiah/cinta-bangga-paham-rupiah/default.aspx'> Cinta, Bangga, Paham Rupiah </a ></li><li><a href = '/en/rupiah/digital-rupiah/default.aspx#overview'> Project Garuda: Digital Rupiah </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/rupiah_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Rupiah</p>
                        <p class='dropdown-megamenu__about--description'>Information about the rupiah as the currency of the Republic of Indonesia managed by Bank Indonesia pursuant to prevailing laws and regulations.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/publikasi/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Publications</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='#'>Media Room</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/ruang-media/news-release/' >Latest News (Press Release)</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/cerita-bi/' >Story</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/pidato-dewan-gubernur/' >Board of Governor Speeches</a></li></ul><li><a href = '/en/publikasi/Kalender/'> Calendar </a ></li><li><a href = '/en/publikasi/peraturan/'> Regulation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/publikasi/lelang/'>Transaction</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/lelang/operasi-moneter/' >Monetary Operation</a></li></ul><li><a href = '/en/publikasi/laporan/'> Report </a ></li><li><a href = '/en/publikasi/kajian/'> Review </a ></li><li><a href = '/en/publikasi/lain/default.aspx'>  Other Publications </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/publikasi.jpg?csf=1&e=QrfjCa&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Publications</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia’s publications include regulations, reports and papers, as well as the calendar of activities</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/statistik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Statistics</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/id/statistik/sdds'> Special Data Dissemination Standard (SDDS) </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/ekonomi-keuangan/seki/Default.aspx'>Financial Statistics</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/seki/Default.aspx' >Indonesian Economic and Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/items/Default.aspx' >Monetary and Payment System Selected Indicators</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sekda/Default.aspx' >The Regional Economic Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sulni/Default.aspx' >Indonesia External Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sski/default.aspx' >Indonesia Financial System Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/suspi/default.aspx' >Indonesia Public Sector Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/spip/Default.aspx' >Payment System and Financial Market Infrastructure Statistics</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/informasi-kurs/jisdor'>Foreign Exchange Rate</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/informasi-kurs/jisdor' >JISDOR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi' >Bank Indonesia Foreign Exchange Transaction Rates</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/kurs-acuan-non-usd-idr/' >Reference Rate for Non-USD/IDR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx' >Calculator</a></li></ul><li><a href = '/en/statistik/indikator'> Indicators </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/Statistik.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Statistics</p>
                        <p class='dropdown-megamenu__about--description'>Statistics include historical indicators for all sectors under the jurisdiction of Bank Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/layanan/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Services</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/layanan/permintaan-informasi/default.aspx'> Information Request </a ></li><li><a href = '/en/layanan/pengaduan-konsumen'> Consumer Protection and Complaints </a ></li><li><a href = '/en/layanan/elicensing/default.aspx'>  E-Licensing </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/informasi-perizinan/default.aspx'>Licensed Institutions</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/informasi-perizinan/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/layanan/informasi-perizinan/sistem-pembayaran/default.aspx' >Payment System and Rupiah Currency Management</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/perpustakaan/'>Library</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/perpustakaan/koleksi-buku/' >Book Collection</a></li></ul><li><a href = '/en/layanan/kas-bi/'> Bank Indonesia Cash Service </a ></li><li><a href = '/en/layanan/lelang-jasa-barang/'> Goods and Services Auction </a ></li><li><a href = '/en/layanan/kunjungan-bi/default.aspx'> Visitation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/museum-bi/'>Museum</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/museum-bi/koleksi-museum' >Museum Collection</a></li><li class='level3'><a href = '/en/layanan/museum-bi/program-informasi/default.aspx' >Museum Program and Information</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/Standar/SNAP/default.aspx'>Payment System Standard - Open API</a></div><ul class='dropdown-megamenu__submenu-list'></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/layanan.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Services</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia offers various services, including requests for information, complaints, licensing and so on.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/informasi-publik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Public Information</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/informasi-publik/profil-ppid/Default.aspx'> Profile </a ></li><li><a href = '/en/informasi-publik/dasar-hukum'> Regulation </a ></li><li><a href = '/en/informasi-publik/informasi-publik/Default.aspx'> List of Public Information </a ></li><li><a href = '/en/informasi-publik/layanan-informasi/Default.aspx'> Information Service </a ></li><li><a href = '/en/informasi-publik/berita-ppid/Default.aspx'> News </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/informasi-publik.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Public Information</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia maintains public information in accordance with the Public Information Disclosure Act of 2008.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li>
</ul>
<span id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7_ctl00_LabelDebug"></span>    
 

</div>
                                        </div>
                                    </div>
                                </nav>
                            </div>
                        </div>

                    </header>
                    <div class="menu-overlay"></div>

                    <div id="contentRow">
                        <div id="sideNavBox" role="Navigation" class="ms-dialogHidden ms-forceWrap ms-noList">
                            <div id="DeltaPlaceHolderLeftNavBar" class="ms-core-navigation" role="navigation">
	
                                
									
                                    <a id="startNavigation" name="startNavigation" tabIndex="-1"></a>
                                    
                                    
                                    
                                    
                                    
                                    <div class="ms-core-sideNavBox-removeLeftMargin">
                                        <div id="ctl00_PlaceHolderLeftNavBar_QuickLaunchNavigationManager">
		<div id="zz3_V4QuickLaunchMenu" class=" noindex ms-core-listMenu-verticalBox">
			<ul id="zz4_RootAspMenu" class="root ms-core-listMenu-root static">
				<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" href="/"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Recent</span><span class="ms-hidden">Currently selected</span></span></a></li>
			</ul>
		</div>
	</div>
                                        
                                        
											<div class="ms-core-listMenu-verticalBox">
                                                
                                            </div>
                                            
                                        
                                    </div>
                                    
                                
                            
</div>
                        </div>
                        <div id="contentBox" aria-live="polite" aria-relevant="all" role="main">
                            <a id="mainContent" name="mainContent" tabindex="-1"></a>
                            <div id="notificationArea" class="ms-notif-box"></div>
                            <div id="DeltaPageStatusBar">
	
                                <div id="pageStatusBar"></div>
                            
</div>
                            <div id="DeltaPlaceHolderTop">
	
                                <div class="noindex">
                                	
	<div id="ctl00_PlaceHolderTop_g_717976cb_8b48_4283_98d0_c1ff5d699b5d" __MarkupType="vsattributemarkup" __WebPartId="{717976cb-8b48-4283-98d0-c1ff5d699b5d}" WebPart="true">
		

<div class="top-banner">
    <div class="container">
        <nav aria-label="breadcrumb">
            <ol class="breadcrumb color">
                
                        
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en">Home </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik">Statistics </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik/informasi-kurs">Foreign Exchange Rate </a>
                        </li>
                    
                    
                <li class="breadcrumb-item color-white" aria-current="page">
                    Foreign Exchange Rates
                </li>
            </ol>
        </nav>
        <h1 class="top-banner__title"> Foreign Exchange Rates</h1>
    </div>
    <div class="top-banner__overlay"></div>
</div>



<div style="display:none;">
    Start;Home;Statistics;Foreign Exchange Rate;bukan default.aspx
</div>

	</div>

                                </div>
                            
</div>

                            <div class="container">
								 <a id="button-back-to-top"><img src="/Style Library/biweb/img/ico_back-to-top.svg" alt=""/></a>
                                <div id="DeltaPlaceHolderMain">
	
                                    
<div id="content-wrapper" class="content-text">                
		<h2>EXCHANGE RATES ON TRANSACTION</h2>
		<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf" __MarkupType="vsattributemarkup" __WebPartId="{6C89D4AD-107F-437D-BD54-8FDA17B556BF}" WebPart="true" partorder="2">
		


<script type="text/javascript" src="/Style Library/biweb/js/jquery-ui-1.12.1.min.js"></script>


<script type="text/javascript" src="/Style Library/biweb/js/jquery.cookie.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/Chart.min.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/html2canvas.min.js"></script>
<link rel="stylesheet" href="/Style Library/biweb/css/jquery-ui.css" />

<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
<script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>

<script type="text/javascript"> 
    var myApp = new function () {
        this.printTable = function () {
            var tab = document.getElementById('tableData');
            var win = window.print('', '', 'height=700,width=700');
            win.document.write(tab.outerHTML);
            win.document.close();
            win.print();
        }
    }
</script>

<style>

</style>

<script type="text/javascript">
    //////chart

    var getMataUang = "";
    var arrayValueDate = [];
    var arrayValueKurs = [];
    console.log(arrayValueDate);
    console.log(arrayValueKurs);
    window.onload = function () {
        var ctx = document.getElementById("myChart").getContext("2d");
        console.log(ctx);
        var data = {
            labels: arrayValueDate,
            datasets: [{
                label: "Kurs Transaksi",
                data: arrayValueKurs,
                borderColor: "blue",
                lineTension: 0
            }]
        };

        var myLineChart = new Chart(ctx, {
            type: 'line',
            data: data,
            options: {
                legend: {
                    display: false,
                    labels: {
                        display: false
                    }
                },
                title: {
                    display: true,
                    text: 'Kurs Transaksi (Exchange Rates on Transaction) - ' + getMataUang
                },
                responsive: true,
                maintainAspectRatio: false,
                tooltips: {
                    callbacks: {
                        label: function (t, d) {
                            if (url.toLowerCase().indexOf("/id/") !== -1) {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".") : "Rp " + t.yLabel;
                            }
                            else {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") : "Rp " + t.yLabel;
                            }
                            return yLabel;
                        }
                    }
                },
                scales: {
                    xAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Source Bank Indonesia'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10
                        },

                    }],
                    yAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Rupiah'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10,
                            callback: function (value, index, values) {
                                if (parseInt(value) >= 1000) {
                                    if (url.toLowerCase().indexOf("/id/") !== -1) {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
                                    }
                                    else {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
                                    }

                                } else {
                                    return value;
                                }
                            }
                        }
                    }]
                }
            }
        });

        window.addEventListener('resize', function () {
            myLineChart.resize()
        })
    }
    function setFormSubmitToFalse() {
        setTimeout(function () { _spFormOnSubmitCalled = false; }, 1000);
        return true;
    }
</script>

<script type="text/javascript">

    $(document).ready(function () {
        url = window.location.href;

        

        if (url.toLowerCase().indexOf("/id/") !== -1) {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);

        }
        else {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);
        }


        if (url.toLowerCase().indexOf("/id/") !== -1) {
            var dialogSingkatan = "Code of Currency";
            $(".btn[id$='_btnGraphImage']").prop("value", "Lihat");
            $(".btn[id$='_ButtonExport']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Unduh");
        }
        else {
            var dialogSingkatan = "Kode Singkatan";
            $(".btn[id$='_btnGraphImage']").prop("value", "View");
            $(".btn[id$='_ButtonExport']").prop("value", "Download");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Download");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Download");
            $("#linkId").attr("href", "/en/statistik/informasi-kurs/transaksi-bi/Default.aspx");
            $("#exampleModalLabel").text("Currency Code");
        }

        $("#KodeSingkatan").dialog({
            autoOpen: false,
            show: "blind",
            width: "240",
            height: "500",
            hide: "explode",
            title: dialogSingkatan
        });

        $("#linkSingkatan1").click(function () {
            $("#KodeSingkatan").dialog("open");
            return false;
        });



        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Masukkan periode awal dan akhir dengan benar');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Periode tanggal awal tidak valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('Periode tanggal akhir tidak valid');
                        return false;
                    }

                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Input start date and end date correctly');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Start date is not valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('End date is not valid');
                        return false;
                    }

                }
            }
            

        });

        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Masukkan periode dengan benar');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Periode tanggal tidak valid');
                        return false;
                    }
                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Input period correctly');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Period is not valid');
                        return false;
                    }
                }
            }
            
        });

    });

    function SetSource(SourceID) {
        var hideSourceID = $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID");
        hideSourceID.val(SourceID);
    }

    // function validation 
    function isValidDate(val, format) {
        try {
            var newDate = val.split("-")[0];
            var newMonth = val.split("-")[1];
            var newYear = val.split("-")[2];

            if (newYear.length == 2 || newYear.length == 4) {
                if (newYear.length == 4) { newYear = newYear.substring(2, 4); }
            }
            else {
                return false;
            }

            var date = getDateFromFormat(newDate + '-' + newMonth + '-' + newYear, format);
            if (date == 0) { return false; }
            return true;
        }
        catch (ex) {
            return false;
        }
    }

    var MONTH_NAMES = new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember', 'Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Ags', 'Sep', 'Okt', 'Nov', 'Des');
    var DAY_NAMES = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
    function LZ(x) { return (x < 0 || x > 9 ? "" : "0") + x }
    function getDateFromFormat(val, format) {
        val = val + "";
        format = format + "";
        var i_val = 0;
        var i_format = 0;
        var c = "";
        var token = "";
        var token2 = "";
        var x, y;
        var now = new Date();
        var year = now.getYear();
        var month = now.getMonth() + 1;
        var date = 1;
        var hh = now.getHours();
        var mm = now.getMinutes();
        var ss = now.getSeconds();
        var ampm = "";

        while (i_format < format.length) {
            c = format.charAt(i_format);
            token = "";
            while ((format.charAt(i_format) == c) && (i_format < format.length)) {
                token += format.charAt(i_format++);
            }
            if (token == "yyyy" || token == "yy" || token == "y") {
                if (token == "yyyy") { x = 4; y = 4; }
                if (token == "yy") { x = 2; y = 2; }
                if (token == "y") { x = 2; y = 4; }
                year = _getInt(val, i_val, x, y);
                if (year == null) { return 0; }
                i_val += year.length;
                if (year.length == 2) {
                    if (year > 70) { year = 1900 + (year - 0); }
                    else { year = 2000 + (year - 0); }
                }
            }
            else if (token == "MMM" || token == "NNN") {
                month = 0;
                for (var i = 0; i < MONTH_NAMES.length; i++) {
                    var month_name = MONTH_NAMES[i];
                    if (val.substring(i_val, i_val + month_name.length).toLowerCase() == month_name.toLowerCase()) {
                        if (token == "MMM" || (token == "NNN" && i > 11)) {
                            month = i + 1;
                            if (month > 24) { month -= 24; }
                            if (month > 12) { month -= 12; }
                            i_val += month_name.length;
                            break;
                        }
                    }
                }
                if ((month < 1) || (month > 12)) { return 0; }
            }
            else if (token == "EE" || token == "E") {
                for (var i = 0; i < DAY_NAMES.length; i++) {
                    var day_name = DAY_NAMES[i];
                    if (val.substring(i_val, i_val + day_name.length).toLowerCase() == day_name.toLowerCase()) {
                        i_val += day_name.length;
                        break;
                    }
                }
            }
            else if (token == "MM" || token == "M") {
                month = _getInt(val, i_val, token.length, 2);
                if (month == null || (month < 1) || (month > 12)) { return 0; }
                i_val += month.length;
            }
            else if (token == "dd" || token == "d") {
                date = _getInt(val, i_val, token.length, 2);
                if (date == null || (date < 1) || (date > 31)) { return 0; }
                i_val += date.length;
            }
            else if (token == "hh" || token == "h") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 12)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "HH" || token == "H") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 23)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "KK" || token == "K") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 11)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "kk" || token == "k") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 24)) { return 0; }
                i_val += hh.length; hh--;
            }
            else if (token == "mm" || token == "m") {
                mm = _getInt(val, i_val, token.length, 2);
                if (mm == null || (mm < 0) || (mm > 59)) { return 0; }
                i_val += mm.length;
            }
            else if (token == "ss" || token == "s") {
                ss = _getInt(val, i_val, token.length, 2);
                if (ss == null || (ss < 0) || (ss > 59)) { return 0; }
                i_val += ss.length;
            }
            else if (token == "a") {
                if (val.substring(i_val, i_val + 2).toLowerCase() == "am") { ampm = "AM"; }
                else if (val.substring(i_val, i_val + 2).toLowerCase() == "pm") { ampm = "PM"; }
                else { return 0; }
                i_val += 2;
            }
            else {
                if (val.substring(i_val, i_val + token.length) != token) { return 0; }
                else { i_val += token.length; }
            }
        }
        if (i_val != val.length) { return 0; }
        if (month == 2) {
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
                // leap year
                if (date > 29) { return 0; }
            }
            else { if (date > 28) { return 0; } }
        }
        if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
            if (date > 30) { return 0; }
        }
        if (hh < 12 && ampm == "PM") { hh = hh - 0 + 12; }
        else if (hh > 11 && ampm == "AM") { hh -= 12; }
        var newdate = new Date(year, month - 1, date, hh, mm, ss);
        return newdate.getTime();
    }

    function _isInteger(val) {
        var digits = "1234567890";
        for (var i = 0; i < val.length; i++) {
            if (digits.indexOf(val.charAt(i)) == -1) { return false; }
        }
        return true;
    }

    function _getInt(str, i, minlength, maxlength) {
        for (var x = maxlength; x >= minlength; x--) {
            var token = str.substring(i, i + x);
            if (token.length < minlength) { return null; }
            if (_isInteger(token)) { return token; }
        }
        return null;
    }

    function download() {
        //if (!isChartRendered) return; // return if chart not rendered
        html2canvas(document.getElementById('chart-container'), {
            onrendered: function (canvas) {
                if (canvas.msToBlob) { //for IE
                    var blob = canvas.msToBlob();
                    window.navigator.msSaveBlob(blob, 'BIexchangeRates.jpeg');
                }
                else {
                    var link = document.createElement('a');
                    link.href = canvas.toDataURL('image/jpeg');
                    link.download = 'BIexchangeRates.jpeg';
                    link.click();
                }
            }
        })
    }

</script>


<div class="card-block" id="tableData">
    <div class="card-body">

       

        
        <div class="row datepicker-period" id="harian" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        Daily</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTanggal" type="text" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch2" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
            
            
        </div>
        <div class="row datepicker-period" id="range" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        From</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtFrom" type="text" value="01-Mar-2026" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        To</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTo" type="text" value="05-Mar-2026" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch1" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
        </div>
        <div>
            
            
            <div class="row">
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        <div class="search-box-wrapper text-left">
                            Last Update&nbsp;<span>2 April 2026</span>
                        </div>
                    </div>
                </div>
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        
                        <div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_printRange" class="search-box-wrapper text-right">
                            <input type="button" value="Print Table" onclick="myApp.printTable()" class="btn btn-secondary btn-icon btn-icon__print" />
                            <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ButtonExportRange" value="Unduh" onclick="javascript:setFormSubmitToFalse();" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ButtonExportRange" class=" btn btn-primary btn-export" />
                        </div>
                        
                    </div>
                </div>                
            </div>
            
        </div>
    </div>

</div>

<input type="hidden" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$hidSourceID" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID" />

<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_kursTable1">
    <div class="d-flex justify-content-end mr-4">
        <a id="linkId" class="btn" style="color: white; background: #045498;" href="/id/statistik/informasi-kurs/transaksi-bi/Default.aspx">
            Back</a>
    </div>
    <div style="text-align: center; font-weight: bold;">
        <span id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_Label10">EXCHANGE RATES ON TRANSACTION</span>
        <br />
        <span id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_lblKursTransaksiKTBI2" class="font-weight-bold">CURRENCIES AUD  </span>
        <br />
        <a onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_lnkGrafik" href="javascript:__doPostBack(&#39;ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$lnkGrafik&#39;,&#39;&#39;)">Grafik Time Series</a>
        <br />
        <div class="container">
            <div class="page-table table-responsive page-table--bordered mb-3">
                <div>

		</div>
                <div>
			<table class="table table-striped table-no-bordered table-lg" cellspacing="0" rules="all" border="1" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_gvSearchResult2" style="border-collapse:collapse;">
				<tr>
					<th class="borderLeft" scope="col" style="color:White;background-color:#045498;">Value</th><th class="borderLeft" scope="col" style="color:White;background-color:#045498;">Sell</th><th scope="col" style="color:White;background-color:#045498;">Buy</th><th scope="col" style="color:White;background-color:#045498;">Date</th>
				</tr><tr>
					<td>1.00</td><td>11,949.58</td><td>11,827.30</td><td>5 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>12,001.98</td><td>11,879.20</td><td>4 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>11,964.32</td><td>11,835.21</td><td>3 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>12,013.13</td><td>11,891.92</td><td>2 Mar 2026</td>
				</tr>
			</table>
		</div>
            </div>
        </div>
    </div>
</div>

<div id="myChartWrapper" style="width: 100%; height: 100%; display: none">
    <div id="chart-container">
        <canvas id="myChart" width="500" height="400"></canvas>
    </div>
    <div class="text-right my-3">
        <button class="btn btn-primary" onclick="download()">Save Chart</button>
    </div>
</div>




	</div>
		<div id="accordion" style="display:none">
		
                    <div class="card">
                        <div class="card-header" id="headingOne">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseOne" href="#headingOne"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Tentang JISDOR</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseOne" class="collapse" aria-labelledby="headingOne" data-parent="#accordion">
                            <div class="card-block">
                                <div class="card-body">
                                    <div class="content-text-subtitle">
                                        <p>Penjelasan JISDOR</p>
                                    </div>
                                    <ol>

                                        <menu class="ms-hide">
		<ie:menuitem id="MSOMenu_Help" iconsrc="/_layouts/15/images/HelpIcon.gif" onmenuclick="MSOWebPartPage_SetNewWindowLocation(MenuWebPart.getAttribute('helpLink'), MenuWebPart.getAttribute('helpMode'))" text="Help" type="option" style="display:none">

		</ie:menuitem>
	</menu>


                                        
                                        


                                    </ol>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header" id="headingTwo">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseTwo" href="#headingTwo"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Penjelasan Kurs Transaksi</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseTwo" class="collapse" aria-labelledby="headingTwo" data-parent="#accordion">
                            
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a href="/id/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx"
                                        class="collapsed">
                                        <div class="color-gray">
                                            <p>Kalkulator Kurs</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        
                    </div>
                </div>
            </div>
        
<div style='display:none' id='hidZone'></div>
                                
</div>
                            </div>
                            <div id="DeltaPlaceHolderBottom">
	
                                <div class="noindex">
                                
	<div id="ctl00_PlaceHolderBottom_g_e3052be3_673c_405e_9cbe_a883a244c053" __MarkupType="vsattributemarkup" __WebPartId="{e3052be3-673c-405e-9cbe-a883a244c053}" WebPart="true">
		

<script type="text/javascript">
    $(document).ready(function() {
        $(".carousel-item-othersites:first").addClass("active");
        console.log($("#HiddenFieldCount").val());
        if ($("#HiddenFieldCount").val()<=3){
            $(".carousel-control-othersites").hide();
        }
    });
</script>
<input type="hidden" name="ctl00$PlaceHolderBottom$g_e3052be3_673c_405e_9cbe_a883a244c053$ctl00$HiddenFieldCount" id="HiddenFieldCount" />
<div class="bottom-banner">
    <div class="container">
        <p class="bottom-banner__title">Baca Juga</p>
        <div id="carouselOtherSites" class="carousel slide carousel-column" data-ride="carousel" data-interval="false">
            
                    <div class="carousel-inner">
                        
                    <div class="carousel-item carousel-item-othersites">
                        <div class="row bottom-banner-slides">
                            
                    <div class="col-sm-4">
                        <div class="box-list">
                            <a href="https://www.bi.go.id/en/fungsi-utama/moneter/informasi-kurs/default.aspx#floating-2" class="box-list__hyperlink"></a>
                            <p class="mb-0">
                                Bank Indonesia Foreign Exchange Transaction Rates​
                            </p>
                        </div>
                    </div>
                
                        </div>
                    </div>
                
                    </div>
                
            <a class="carousel-control-othersites carousel-control-prev" href="#carouselOtherSites" role="button" data-slide="prev">
                <span class="carousel-control-prev-icon" aria-hidden="true"></span>
                <span class="sr-only">Previous</span>
            </a>
            <a class="carousel-control-othersites carousel-control-next" href="#carouselOtherSites" role="button" data-slide="next">
                <span class="carousel-control-next-icon" aria-hidden="true"></span>
                <span class="sr-only">Next</span>
            </a>
        </div>
    </div>
</div>


	</div>

                                </div>
                            
</div>

                        </div>
                        <div id="DeltaFormDigest">
	
                            
								
                            
                        
</div>
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                    </div>

                    <footer class="ms-dialogHidden noindex">
                        <div class="top-footer">
                            <div class="container">
                                                        	    		
<div id="ctl00_UserControl1" __MarkupType="vsattributemarkup" __WebPartId="{72f5f1f8-08c8-489c-ad0f-67bc21b60514}" WebPart="true">
	
        <ul class="list-unstyled link-list">
            
        <li class="ml-4"><a href='https://www.bi.go.id/en/publikasi/Kalender' class="link__item">Calendar</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/archive' class="link__item">Archieve</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/minisite.aspx' class="link__item">Minisite</a></li>       
    
        </ul>
    

</div>
                                                        	    		
                                <div class="row">
<div id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa" __MarkupType="vsattributemarkup" __WebPartId="{ecc2559e-4a60-437f-ba58-80eaeea6b4aa}" WebPart="true">
	

<div class="col-12 col-md-6 sosmed-wrapper">
    
            <div class="sosmed-list"> 
                
            <a class="sosmed__item" href='https://www.facebook.com/BankIndonesiaOfficial/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-fb.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.instagram.com/bank_indonesia/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-ig.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.youtube.com/user/BankIndonesiaChannel'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-youtube.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.tiktok.com/@bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-tiktok.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://twitter.com/bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-twitter-X_.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://open.spotify.com/show/4Q38i2lcJpxvtJvcmJuWWv'>
                <img src='https://www.bi.go.id/Sosial%20Media/SPOTIFY-svg.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://whatsapp.com/channel/0029VahA0uQL2ATyd7fOSE39'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-WA-Channel.svg' width="32" alt="icon-fb"></a>
         
            </div> 
        
    
            <div class="app-list">
                
            <a class="app__item" href='https://apps.apple.com/id/app/bi-mobile/id1198899727'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-app-store.svg' width="98" alt="icon-app-store"></a>
        
            <a class="app__item" href='https://play.google.com/store/apps/details?id=com.bi.mobile'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-play-store.svg' width="98" alt="icon-app-store"></a>
        
            </div>
        
</div>
<span id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa_ctl00_LabelDebug"></span>

</div>

                                    <div class="col-12 col-md-6 address-wrapper">
                                        <div class="address-list">
                                            <p class="mb-0">Bank Indonesia<br/>
Jalan M.H. Thamrin No. 2, Jakarta 10350<br/>
Contact Center Bank Indonesia Bicara<br/>
Telp. : 131 dan 1500131 (dari luar negeri)<br/>
E-mail : <a href="mailto:bicara@bi.go.id">bicara@bi.go.id</a><br/>
Chatbot LISA :<a href="https://wa.me/6281131131131?text=Hi,%20Lisa" target="blank"> 081 131 131 131</a></p>
                                        </div>
                                    </div>
                                    <div class="col-12 col-md-12 mt-3 d-flex justify-content-end">
                                    	<div id="ctl00_g_e8c52fcb_2724_4885_9437_c0f616f27eb4" __MarkupType="vsattributemarkup" __WebPartId="{e8c52fcb-2724-4885-9437-c0f616f27eb4}" WebPart="true" partorder="2">
	


</div>
                                    </div>
                                </div>
                            </div>
                        </div>
                        <div class="copyright-wrapper">
                            <div class="container">
                                <p class="text-right mb-0">© 2020 Bank Indonesia</p>
                            </div>
                        </div>

                    </footer>

                </div>
                <span id="DeltaHelpPanel">
                    <div id="helppanelCntdiv" class="ms-Help-PanelContainer">
                        
                    </div>
                </span>
                <span id="DeltaPageInstrumentation">
                    
                </span>
            </div>
        

<script type="text/javascript">
//<![CDATA[
var _spFormDigestRefreshInterval = 1440000;window.SPThemeUtils && SPThemeUtils.ApplyCurrentTheme(true); IsSPSocialSwitchEnabled = function() { return true; };var _fV4UI = true;
function _RegisterWebPartPageCUI()
{
    var initInfo = {editable: false,isEditMode: false,allowWebPartAdder: false};
    SP.Ribbon.WebPartComponent.registerWithPageManager(initInfo);
    var wpcomp = SP.Ribbon.WebPartComponent.get_instance();
    var hid;
    hid = document.getElementById("_wpSelected");
    if (hid != null)
    {
        var wpid = hid.value;
        if (wpid.length > 0)
        {
            var zc = document.getElementById(wpid);
            if (zc != null)
                wpcomp.selectWebPart(zc, false);
        }
    }
    hid = document.getElementById("_wzSelected");
    if (hid != null)
    {
        var wzid = hid.value;
        if (wzid.length > 0)
        {
            wpcomp.selectWebPartZone(null, wzid);
        }
    }
};
function __RegisterWebPartPageCUI() {
ExecuteOrDelayUntilScriptLoaded(_RegisterWebPartPageCUI, "sp.ribbon.js");}
_spBodyOnLoadFunctionNames.push("__RegisterWebPartPageCUI");var __wpmExportWarning='This Web Part Page has been personalized. As a result, one or more Web Part properties may contain confidential information. Make sure the properties contain information that is safe for others to read. After exporting this Web Part, view properties in the Web Part description file (.WebPart) by using a text editor such as Microsoft Notepad.';var __wpmCloseProviderWarning='You are about to close this Web Part.  It is currently providing data to other Web Parts, and these connections will be deleted if this Web Part is closed.  To close this Web Part, click OK.  To keep this Web Part, click Cancel.';var __wpmDeleteWarning='You are about to permanently delete this Web Part.  Are you sure you want to do this?  To delete this Web Part, click OK.  To keep this Web Part, click Cancel.';SuiteNavRendering.RenderSuiteNav({top:'suiteBarTop', version:2, dataEndpoint:'Microsoft.SharePoint.Portal.SuiteNavData.GetSuiteNavData', culture:'en-US', signInLink:'\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fAuthenticate.aspx?Source=\u00252Fen\u00252Fstatistik\u00252Finformasi\u00252Dkurs\u00252Ftransaksi\u00252Dbi\u00252Fdefault\u00252Easpx', brandingText:'', brandingLogo:'', brandingLogoLink:'', brandingLogoTitle:''});
var _spWebPermMasks = {High:16,Low:196673};g_spPreFetchKeys.push('sp.core.js');function _cUpdonetidHeadbnnr2(){var myd = null; if (typeof(dataonetidHeadbnnr2) != 'undefined') {myd = dataonetidHeadbnnr2;} var myc = document.getElementById('ctl00_onetidHeadbnnr2');_cUpdconetidHeadbnnr2(myd, myc);}function _cUpdconetidHeadbnnr2(data, ctrl){SiteLogoImagePageUpdate(ctrl, data);}
            ExecuteOrDelayUntilScriptLoaded(
                function() 
                {                    
                    Srch.ScriptApplicationManager.get_current().states = {"webUILanguageName":"en-US","webDefaultLanguageName":"en-US","QueryDateTimeCulture":1033,"timeZoneOffsetInHours":7,"contextUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","contextTitle":"Foreign Exchange Rates","supportedLanguages":[{"id":1025,"label":"Arabic"},{"id":1093,"label":"Bangla"},{"id":1026,"label":"Bulgarian"},{"id":1027,"label":"Catalan"},{"id":2052,"label":"Chinese (Simplified)"},{"id":1028,"label":"Chinese (Traditional)"},{"id":1050,"label":"Croatian"},{"id":1029,"label":"Czech"},{"id":1030,"label":"Danish"},{"id":1043,"label":"Dutch"},{"id":1033,"label":"English"},{"id":1035,"label":"Finnish"},{"id":1036,"label":"French"},{"id":1031,"label":"German"},{"id":1032,"label":"Greek"},{"id":1095,"label":"Gujarati"},{"id":1037,"label":"Hebrew"},{"id":1081,"label":"Hindi"},{"id":1038,"label":"Hungarian"},{"id":1039,"label":"Icelandic"},{"id":1057,"label":"Indonesian"},{"id":1040,"label":"Italian"},{"id":1041,"label":"Japanese"},{"id":1099,"label":"Kannada"},{"id":1042,"label":"Korean"},{"id":1062,"label":"Latvian"},{"id":1063,"label":"Lithuanian"},{"id":1086,"label":"Malay"},{"id":1100,"label":"Malayalam"},{"id":1102,"label":"Marathi"},{"id":1044,"label":"Norwegian"},{"id":1045,"label":"Polish"},{"id":1046,"label":"Portuguese (Brazil)"},{"id":2070,"label":"Portuguese (Portugal)"},{"id":1094,"label":"Punjabi"},{"id":1048,"label":"Romanian"},{"id":1049,"label":"Russian"},{"id":3098,"label":"Serbian (Cyrillic)"},{"id":2074,"label":"Serbian (Latin)"},{"id":1051,"label":"Slovak"},{"id":1060,"label":"Slovenian"},{"id":3082,"label":"Spanish (Spain)"},{"id":2058,"label":"Spanish (Mexico)"},{"id":1053,"label":"Swedish"},{"id":1097,"label":"Tamil"},{"id":1098,"label":"Telugu"},{"id":1054,"label":"Thai"},{"id":1055,"label":"Turkish"},{"id":1058,"label":"Ukrainian"},{"id":1056,"label":"Urdu"},{"id":1066,"label":"Vietnamese"}],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"webUILanguageDirectory":"en-US","showAdminDetails":false,"defaultPagesListName":"Pages","isSPFSKU":false,"defaultQueryProperties":{"culture":1033,"uiLanguage":1033,"summaryLength":180,"desiredSnippetLength":90,"enableStemming":true,"enablePhonetic":false,"enableNicknames":false,"trimDuplicates":true,"bypassResultTypes":false,"enableInterleaving":true,"enableQueryRules":true,"processBestBets":true,"enableOrderingHitHighlightedProperty":false,"hitHighlightedMultivaluePropertyLimit":-1,"processPersonalFavorites":true}};
                    Srch.U.trace(null, 'SerializeToClient', 'ScriptApplicationManager state initialized.');
                }, 'Search.ClientControls.js');var g_clientIdDeltaPlaceHolderMain = "DeltaPlaceHolderMain";
var g_clientIdDeltaPlaceHolderPageTitleInTitleArea = "DeltaPlaceHolderPageTitleInTitleArea";
var g_clientIdDeltaPlaceHolderUtilityContent = "DeltaPlaceHolderUtilityContent";

theForm.oldSubmit = theForm.submit;
theForm.submit = WebForm_SaveScrollPositionSubmit;

theForm.oldOnSubmit = theForm.onsubmit;
theForm.onsubmit = WebForm_SaveScrollPositionOnSubmit;

theForm.oldOnLoad = window.onload;
window.onload = WebForm_RestoreScrollPosition;

                function _ribbonInitFunc1()

                {
                    EnsureScriptParams('core.js', '_ribbonInitFunc1Wrapped', '', '', '\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx', '-1997219614', '1033', 'RibbonContainer', {'Ribbon.Read':true,'Ribbon.WebPartPage':true}, null, {'Ribbon.WebPartInsert.InsertRelatedDataToListForm':true},
                                            null, false, 0, false, 'SP.Ribbon.PageManager.get_instance()', false, null, null, null, '1522130250', 1, '.');
                }
                function _ribbonStartInit(initialTabId, buildMinimized, e)
                {
                    EnsureScriptParams('core.js', '_ribbonStartInitWrapped', initialTabId, buildMinimized, e, true, 'EnsureScriptParams("core.js", "RibbonControlInitWrapped");EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", function () { _registerCUIEComponentWrapped( "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx", "1033", "-1997219614");});EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", _ribbonInitFunc1);');
                }
                function _ribbonKeyboardTitleShortcut(e)
                {
                    EnsureScriptParams('core.js', '_ribbonKeyboardTitleShortcutWrapped', e, 'tff[', 'Ribbon.Read-title');
                }
                function _ribbonDataInit(p6, p7)
                {
                    _ribbon = new Object();
                    _ribbon.initialTabId = p6;
                    _ribbon.buildMinimized = p7;
                    _ribbon.initStarted = false;
                    _ribbon.initialTabSelectedByUser = false;
                    _ribbon.launchedByKeyboard = false;
                }
                function _ribbonWaitForBodyEvent()
                {
                    if (false)
                        _ribbonStartInit();
                    
                function _ribbonOnWindowResizeForHeaderScaling(evt)
                {
                    _ribbonOnWindowResizeForHeaderScalingWrapped(evt, 'RibbonContainer', false);
                }
                EnsureScriptParams('core.js', '_ribbonInitResizeHandlers', _ribbonOnWindowResizeForHeaderScaling, 'RibbonContainer', true, false);
                
                    EnsureScriptParams('core.js', '_ribbonAddEventListener', _ribbonKeyboardTitleShortcut);
                }
                _ribbonDataInit('Ribbon.Read', true);                
                if (SP.SOD.get_prefetch() == 0 && _ribbon.buildMinimized == true)
                {
                    ExecuteOrDelayUntilScriptLoaded(_ribbonWaitForBodyEvent, 'sp.ribbon.js');
                }
                else
                {
                    EnsureScriptFunc('ribbon', 'SP.Ribbon.PageStateActionButton', _ribbonWaitForBodyEvent);
                }
                
var g_commandUIHandlers = {"name":"CommandHandlers","attrs":{},"children":[]};
g_QuickLaunchControlIds.push("zz1_TopNavigationMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz1_TopNavigationMenu = null; function init_zz1_TopNavigationMenu() { if (g_zz1_TopNavigationMenu == null) g_zz1_TopNavigationMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz1_TopNavigationMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz1_TopNavigationMenu, 'SP.Core.js');

                    ExecuteOrDelayUntilScriptLoaded(
                        function() 
                        {
                            if ($isNull($find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr')))
                            {
                                var sb = $create(Srch.SearchBox, {"delayLoadTemplateScripts":true,"initialPrompt":"Search this site","messages":[],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"queryGroupNames":["MasterPage"],"renderTemplateId":"~sitecollection/_catalogs/masterpage/Display Templates/Search/Control_SearchBox_Compact.js","resultsPageAddress":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","serverInitialRender":true,"showDataErrors":true,"showNavigation":true,"states":{},"tryInplaceQuery":false}, null, null, $get("ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"));
                                sb.activate('Search this site', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavButton', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavDropdownList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink', 'ms-srch-sbprogress', 'ms-srch-sb-prompt ms-helperText');
                            }
                        }, 'Search.ClientControls.js');g_QuickLaunchControlIds.push("zz3_V4QuickLaunchMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz3_V4QuickLaunchMenu = null; function init_zz3_V4QuickLaunchMenu() { if (g_zz3_V4QuickLaunchMenu == null) g_zz3_V4QuickLaunchMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz3_V4QuickLaunchMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz3_V4QuickLaunchMenu, 'SP.Core.js');
//]]>
</script>
</form>
        <span id="DeltaPlaceHolderUtilityContent">
            
        </span>
        <script type="text/javascript">// <![CDATA[ 

var g_Workspace = "s4-workspace";
		
		 // ]]>
</script>
    </body>
</html>
recorded_at: Sun, 05 Apr 2026 00:49:28 GMT
- request:
method: post
uri: https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
body:
encoding: US-ASCII
string: MSOWebPartPage_PostbackSource=&MSOTlPn_View=0&MSOTlPn_ShowSettings=False&MSOTlPn_Button=none&__EVENTTARGET=&__EVENTARGUMENT=&__REQUESTDIGEST=0x41D00311222AA5C7BCCDE7DFEA5D3ED0FA83851A66FFBB06DF250B456DB0D3DEACCB775F47795FC4F63284D1626209AAD854D6F5053BDE3EC332F5FFFCE9D770%2C05+Apr+2026+00%3A49%3A24+-0000&MSOSPWebPartManager_DisplayModeName=Browse&MSOSPWebPartManager_ExitingDesignMode=false&MSOSPWebPartManager_OldDisplayModeName=Browse&MSOSPWebPartManager_StartWebPartEditingName=false&MSOSPWebPartManager_EndWebPartEditing=false&_maintainWorkspaceScrollPosition=0&__VIEWSTATE=%2FwEPDwUBMA9kFgJmD2QWAgIBD2QWBAIBD2QWAgInD2QWAgIDD2QWAmYPZBYCZg88KwAGAGQCCQ9kFhYCIw9kFgICAw8WAh4HVmlzaWJsZWgWAmYPZBYEAgMPZBYOAgEPFgIfAGhkAgMPFgIfAGhkAgUPFgIfAGhkAgcPFgIfAGhkAgkPFgIfAGhkAgsPFgIfAGhkAg0PFgIfAGhkAgQPDxYCHglBY2Nlc3NLZXkFAS9kZAIlD2QWAgIDD2QWAgIBD2QWBAIDD2QWAmYPDxYEHgRfIVNCAgIeCENzc0NsYXNzBRdtcy1wcm9tb3RlZEFjdGlvbkJ1dHRvbmRkAgUPDxYGHwMFF21zLXByb21vdGVkQWN0aW9uQnV0dG9uHwICAh8AaGRkAi8PZBYCAgEPZBYCAgEPPCsABQEADxYCHhVQYXJlbnRMZXZlbHNEaXNwbGF5ZWRmZGQCNQ9kFgJmD2QWAmYPFCsAAg8WBB4LXyFEYXRhQm91bmRnHgtfIUl0ZW1Db3VudAIEZGQWAmYPZBYIAgEPZBYCZg8VAh5odHRwczovL3d3dy5iaS5nby5pZC9lbi9rYXJpZXIGQ2FyZWVyZAICD2QWAmYPFQIfaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vZWR1a2FzaQlFZHVjYXRpb25kAgMPZBYCZg8VAiZodHRwczovL3d3dy5iaS5nby5pZC9lbi9nbG9zYXJpdW0uYXNweAhHbG9zc2FyeWQCBA9kFgJmDxUCJ2h0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL3BldGEtc2l0dXMuYXNweAdTaXRlbWFwZAI7D2QWAmYPZBYCAgEPFgIeBFRleHQFqKMBPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi90ZW50YW5nLWJpL2RlZmF1bHQuYXNweCcgaWQ9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJyByb2xlPSdidXR0b24nIGRhdGEtdG9nZ2xlPSdkcm9wZG93bicgYXJpYS1oYXNwb3B1cD0ndHJ1ZScgYXJpYS1leHBhbmRlZD0nZmFsc2UnPkFib3V0IEJJPC9hPgogICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVudSBkcm9wZG93bi1tZWdhbWVudScgYXJpYS1sYWJlbGxlZGJ5PSduYXZiYXJEcm9wZG93blN0YXRpc3Rpayc%2BCiAgICAgICAgPGRpdiBjbGFzcz0nY29udGFpbmVyJz4KICAgICAgICAgICAgPGRpdiBjbGFzcz0nZC1tZC1mbGV4Jz4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gcHItbWQtNCc%2BIAogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19tZW51Jz48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3RlbnRhbmctYmkvcHJvZmlsL0RlZmF1bHQuYXNweCc%2BUHJvZmlsZTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi90ZW50YW5nLWJpL3Byb2ZpbC9vcmdhbmlzYXNpL0RlZmF1bHQuYXNweCcgPiBPcmdhbml6YXRpb248L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vdGVudGFuZy1iaS9wcm9maWwvZ292ZXJuYW5jZS9kZWZhdWx0LmFzcHgnID5Hb3Zlcm5hbmNlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3RlbnRhbmctYmkvcHJvZmlsL3V1LWJpL0RlZmF1bHQuYXNweCcgPlJlZ3VsYXRpb25zPC9hPjwvbGk%2BPC91bD48bGk%2BPGEgaHJlZiA9ICcvZW4vdGVudGFuZy1iaS9zZWphcmFoLWJpL0RlZmF1bHQuYXNweCc%2BIEhpc3RvcnkgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi90ZW50YW5nLWJpL3RyYW5zZm9ybWFzaS9EZWZhdWx0LmFzcHgnPiBUcmFuc2Zvcm1hdGlvbiA8L2EgPjwvbGk%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L01lbnUlMjBJbWFnZS90ZW50YW5nLUJJX3YyLnBuZyZxdW90OyknPjwvZGl2PgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aXRsZSc%2BQWJvdXQgQkk8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgb3JnYW5pc2F0aW9uLCB0cmFuc2Zvcm1hdGlvbiBhbmQgaGlzdG9yeSBvZiBCYW5rIEluZG9uZXNpYSBhcyB0aGUgY2VudHJhbCBiYW5rIG9mIHRoZSBSZXB1YmxpYyBvZiBJbmRvbmVzaWEuPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9mdW5nc2ktdXRhbWEvZGVmYXVsdC5hc3B4JyBpZD0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnIHJvbGU9J2J1dHRvbicgZGF0YS10b2dnbGU9J2Ryb3Bkb3duJyBhcmlhLWhhc3BvcHVwPSd0cnVlJyBhcmlhLWV4cGFuZGVkPSdmYWxzZSc%2BTWFpbiBGdW5jdGlvbnM8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvRGVmYXVsdC5hc3B4Jz5Nb25ldGFyeTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmZsYXNpL0RlZmF1bHQuYXNweCcgPkluZmxhdGlvbjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9pbmRpa2F0b3ItbW9uZXRlci9kZWZhdWx0LmFzcHgnID5Nb25ldGFyeSBJbmRpY2F0b3I8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvYmktcmF0ZS9kZWZhdWx0LmFzcHgnID5CSS1SYXRlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL29wZXJhc2ktbW9uZXRlci9EZWZhdWx0LmFzcHgnID5Nb25ldGFyeSBPcGVyYXRpb248L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL21vbmV0ZXIvaW5kb25pYS1qaWJvci9EZWZhdWx0LmFzcHgnID5JTkRPTklBLCBDb21wb3VuZGVkIElORE9OSUEsIElORE9OSUEgSW5kZXggYW5kIEpJQk9SPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL2luZm9ybWFzaS1rdXJzL2RlZmF1bHQuYXNweCcgPkpJU0RPUiwgTm9uLVVTRC9JRFIgUmVmZXJlbmNlIFJhdGUsIGFuZCBUcmFuc2FjdGlvbiBSYXRlPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9tb25ldGVyL3Bhc2FyLWtldWFuZ2FuL2RlZmF1bHQuYXNweCcgPk1vbmV5IE1hcmtldDwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvbW9uZXRlci9wZW5nZW1iYW5nYW4tZWtvbm9taS9EZWZhdWx0LmFzcHgnID5TaGFyaWEgRWNvbm9teSBhbmQgRmluYW5jaWFsPC9hPjwvbGk%2BPC91bD48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL2Z1bmdzaS11dGFtYS9zdGFiaWxpdGFzLXNpc3RlbS1rZXVhbmdhbi9pa2h0aXNhci8nPkZpbmFuY2lhbCBTeXN0ZW0gU3RhYmlsaXR5PC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zdGFiaWxpdGFzLXNpc3RlbS1rZXVhbmdhbi9pa2h0aXNhci8nID5PdmVydmlldzwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4vaW5zdHJ1bWVuLW1ha3JvcHJ1ZGVuc2lhbC9kZWZhdWx0LmFzcHgnID5NYWNyb3BydWRlbnRpYWwgUG9saWN5IEluc3RydW1lbnQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3N0YWJpbGl0YXMtc2lzdGVtLWtldWFuZ2FuL21hbmFqZW1lbi1rcmlzaXMvZGVmYXVsdC5hc3B4JyA%2BQ3Jpc2lzIE1hbmFnZW1lbnQgUHJvdG9jb2w8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3N0YWJpbGl0YXMtc2lzdGVtLWtldWFuZ2FuL2tvb3JkaW5hc2ktYmktbGFpbm55YS8nID5JbnN0aXR1dGlvbmFsIENvb3JkaW5hdGlvbjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4vcGVuZ2VtYmFuZ2FuLXVta20vJyA%2BTVNNRSBEZXZlbG9wbWVudDwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc3RhYmlsaXRhcy1zaXN0ZW0ta2V1YW5nYW4va2V1YW5nYW4taW5rbHVzaWYvJyA%2BRmluYW5jaWFsIEluY2x1c2lvbjwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4nPlBheW1lbnQgU3lzdGVtIGFuZCBSdXBpYWggQ3VycmVuY3kgTWFuYWdlbWVudDwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4vbmlsYWktYmVzYXIvJyA%2BSGlnaCBWYWx1ZSBQYXltZW50IFN5c3RlbTwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9mdW5nc2ktdXRhbWEvc2lzdGVtLXBlbWJheWFyYW4vcml0ZWwvJyA%2BUmV0YWlsIFBheW1lbnQgU3lzdGVtPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zaXN0ZW0tcGVtYmF5YXJhbi9wZW5nZWxvbGFhbi1ydXBpYWgvZGVmYXVsdC5hc3B4JyA%2BUnVwaWFoIEN1cnJlbmN5IE1hbmFnZW1lbnQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL3Blcml6aW5hbi9kZWZhdWx0LmFzcHgnID5MaWNlbnNpbmc8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL2FudGktcGVuY3VjaWFuLXVhbmctZGFuLXBlbmNlZ2FoYW4tcGVuZGFuYWFuLXRlcnJvcmlzbWUvJyA%2BQW50aS1Nb25leSBMYXVuZGVyaW5nIGFuZCBDb3VudGVyLVRlcnJvcmlzbSBGaW5hbmNpbmc8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vZnVuZ3NpLXV0YW1hL3Npc3RlbS1wZW1iYXlhcmFuL1N0YW5kYXJkaXNhc2ktS29tcGV0ZW5zaS9EZWZhdWx0LmFzcHgnID5TdGFuZGFyZGlzYXRpb24gT2YgSFIgQ29tcGV0ZW5jaWVzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2Z1bmdzaS11dGFtYS9zaXN0ZW0tcGVtYmF5YXJhbi9ibHVlcHJpbnQvZGVmYXVsdC5hc3B4JyA%2BSW5kb25lc2lhIFBheW1lbnQgU3lzdGVtIEJsdWVwcmludDwvYT48L2xpPjwvdWw%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L1N0eWxlIExpYnJhcnkvYml3ZWIvaW1nL2JpLXBob3RvLmpwZyZxdW90OyknPjwvZGl2PgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aXRsZSc%2BTWFpbiBGdW5jdGlvbnM8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgbWFpbiBmdW5jdGlvbnMgYW5kIHJlc3BvbnNpYmlsaXRpZXMgb2YgQmFuayBJbmRvbmVzaWEgdG8gYWNoaWV2ZSBhbmQgbWFpbnRhaW4gcnVwaWFoIHN0YWJpbGl0eS48L3A%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgPC9kaXY%2BCiAgICA8L2Rpdj4KPC9saT48bGkgY2xhc3M9J25hdi1pdGVtIGRyb3Bkb3duJz4KICAgICAgPGEgY2xhc3M9J25hdi1saW5rIGRyb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3J1cGlhaC8nIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5SdXBpYWg8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaT48YSBocmVmID0gJy9lbi9ydXBpYWgvZ2FtYmFyLXVhbmcvRGVmYXVsdC5hc3B4Jz4gQ3VycmVuY3kgSW1hZ2UgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi9ydXBpYWgvdWFuZy1kaWNhYnV0Lyc%2BIFdpdGhkcmF3biBDdXJyZW5jeSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL3J1cGlhaC9wZW5jZWdhaGFuLXJ1cGlhaC1wYWxzdS8nPiBDb3VudGVyZmVpdCBQcmV2ZW50aW9uIGFuZCBNYW5hZ2VtZW50IDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcnVwaWFoL2NpbnRhLWJhbmdnYS1wYWhhbS1ydXBpYWgvZGVmYXVsdC5hc3B4Jz4gQ2ludGEsIEJhbmdnYSwgUGFoYW0gUnVwaWFoIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcnVwaWFoL2RpZ2l0YWwtcnVwaWFoL2RlZmF1bHQuYXNweCNvdmVydmlldyc%2BIFByb2plY3QgR2FydWRhOiBEaWdpdGFsIFJ1cGlhaCA8L2EgPjwvbGk%2BPC91bD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4gCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0IHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPgogICAgICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRodW1ibmFpbCBtYi0yJyBzdHlsZT0nYmFja2dyb3VuZC1pbWFnZTp1cmwoJnF1b3Q7L01lbnUlMjBJbWFnZS9ydXBpYWhfdjIucG5nJnF1b3Q7KSc%2BPC9kaXY%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRpdGxlJz5SdXBpYWg8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5JbmZvcm1hdGlvbiBhYm91dCB0aGUgcnVwaWFoIGFzIHRoZSBjdXJyZW5jeSBvZiB0aGUgUmVwdWJsaWMgb2YgSW5kb25lc2lhIG1hbmFnZWQgYnkgQmFuayBJbmRvbmVzaWEgcHVyc3VhbnQgdG8gcHJldmFpbGluZyBsYXdzIGFuZCByZWd1bGF0aW9ucy48L3A%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgPC9kaXY%2BCiAgICA8L2Rpdj4KPC9saT48bGkgY2xhc3M9J25hdi1pdGVtIGRyb3Bkb3duJz4KICAgICAgPGEgY2xhc3M9J25hdi1saW5rIGRyb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3B1Ymxpa2FzaS9EZWZhdWx0LmFzcHgnIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5QdWJsaWNhdGlvbnM8L2E%2BCiAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZW51IGRyb3Bkb3duLW1lZ2FtZW51JyBhcmlhLWxhYmVsbGVkYnk9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJz4KICAgICAgICA8ZGl2IGNsYXNzPSdjb250YWluZXInPgogICAgICAgICAgICA8ZGl2IGNsYXNzPSdkLW1kLWZsZXgnPgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBwci1tZC00Jz4gCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX21lbnUnPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScjJz5NZWRpYSBSb29tPC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9ydWFuZy1tZWRpYS9uZXdzLXJlbGVhc2UvJyA%2BTGF0ZXN0IE5ld3MgKFByZXNzIFJlbGVhc2UpPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9ydWFuZy1tZWRpYS9jZXJpdGEtYmkvJyA%2BU3Rvcnk8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL3J1YW5nLW1lZGlhL3BpZGF0by1kZXdhbi1ndWJlcm51ci8nID5Cb2FyZCBvZiBHb3Zlcm5vciBTcGVlY2hlczwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9LYWxlbmRlci8nPiBDYWxlbmRhciA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL3B1Ymxpa2FzaS9wZXJhdHVyYW4vJz4gUmVndWxhdGlvbiA8L2EgPjwvbGk%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9wdWJsaWthc2kvbGVsYW5nLyc%2BVHJhbnNhY3Rpb248L2E%2BPHNwYW4gY2xhc3M9J2NhcmV0Jz48L3NwYW4%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2xlbGFuZy9vcGVyYXNpLW1vbmV0ZXIvJyA%2BTW9uZXRhcnkgT3BlcmF0aW9uPC9hPjwvbGk%2BPC91bD48bGk%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2xhcG9yYW4vJz4gUmVwb3J0IDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vcHVibGlrYXNpL2thamlhbi8nPiBSZXZpZXcgPC9hID48L2xpPjxsaT48YSBocmVmID0gJy9lbi9wdWJsaWthc2kvbGFpbi9kZWZhdWx0LmFzcHgnPiAgT3RoZXIgUHVibGljYXRpb25zIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL3B1Ymxpa2FzaS5qcGc%2FY3NmPTEmZT1RcmZqQ2EmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlB1YmxpY2F0aW9uczwvcD4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tZGVzY3JpcHRpb24nPkJhbmsgSW5kb25lc2lh4oCZcyBwdWJsaWNhdGlvbnMgaW5jbHVkZSByZWd1bGF0aW9ucywgcmVwb3J0cyBhbmQgcGFwZXJzLCBhcyB3ZWxsIGFzIHRoZSBjYWxlbmRhciBvZiBhY3Rpdml0aWVzPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9zdGF0aXN0aWsvRGVmYXVsdC5hc3B4JyBpZD0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnIHJvbGU9J2J1dHRvbicgZGF0YS10b2dnbGU9J2Ryb3Bkb3duJyBhcmlhLWhhc3BvcHVwPSd0cnVlJyBhcmlhLWV4cGFuZGVkPSdmYWxzZSc%2BU3RhdGlzdGljczwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2lkL3N0YXRpc3Rpay9zZGRzJz4gU3BlY2lhbCBEYXRhIERpc3NlbWluYXRpb24gU3RhbmRhcmQgKFNERFMpIDwvYSA%2BPC9saT48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nla2kvRGVmYXVsdC5hc3B4Jz5GaW5hbmNpYWwgU3RhdGlzdGljczwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zZWtpL0RlZmF1bHQuYXNweCcgPkluZG9uZXNpYW4gRWNvbm9taWMgYW5kIEZpbmFuY2lhbCBTdGF0aXN0aWNzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL2l0ZW1zL0RlZmF1bHQuYXNweCcgPk1vbmV0YXJ5IGFuZCBQYXltZW50IFN5c3RlbSBTZWxlY3RlZCBJbmRpY2F0b3JzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nla2RhL0RlZmF1bHQuYXNweCcgPlRoZSBSZWdpb25hbCBFY29ub21pYyBGaW5hbmNpYWwgU3RhdGlzdGljczwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zdWxuaS9EZWZhdWx0LmFzcHgnID5JbmRvbmVzaWEgRXh0ZXJuYWwgRGVidCBTdGF0aXN0aWNzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9la29ub21pLWtldWFuZ2FuL3Nza2kvZGVmYXVsdC5hc3B4JyA%2BSW5kb25lc2lhIEZpbmFuY2lhbCBTeXN0ZW0gU3RhdGlzdGljczwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvZWtvbm9taS1rZXVhbmdhbi9zdXNwaS9kZWZhdWx0LmFzcHgnID5JbmRvbmVzaWEgUHVibGljIFNlY3RvciBEZWJ0IFN0YXRpc3RpY3M8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vc3RhdGlzdGlrL2Vrb25vbWkta2V1YW5nYW4vc3BpcC9EZWZhdWx0LmFzcHgnID5QYXltZW50IFN5c3RlbSBhbmQgRmluYW5jaWFsIE1hcmtldCBJbmZyYXN0cnVjdHVyZSBTdGF0aXN0aWNzPC9hPjwvbGk%2BPC91bD48bGkgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51Jz48ZGl2IGNsYXNzPSdjbGVhcmZpeCc%2BPGEgY2xhc3M9J2Ryb3Bkb3duLXRvZ2dsZScgaHJlZj0nL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy9qaXNkb3InPkZvcmVpZ24gRXhjaGFuZ2UgUmF0ZTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvaW5mb3JtYXNpLWt1cnMvamlzZG9yJyA%2BSklTRE9SPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy90cmFuc2Frc2ktYmknID5CYW5rIEluZG9uZXNpYSBGb3JlaWduIEV4Y2hhbmdlIFRyYW5zYWN0aW9uIFJhdGVzPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmZvcm1hc2kta3Vycy9rdXJzLWFjdWFuLW5vbi11c2QtaWRyLycgPlJlZmVyZW5jZSBSYXRlIGZvciBOb24tVVNEL0lEUjwvYT48L2xpPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9zdGF0aXN0aWsvaW5mb3JtYXNpLWt1cnMvdHJhbnNha3NpLWJpL2thbGt1bGF0b3Ita3Vycy5hc3B4JyA%2BQ2FsY3VsYXRvcjwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL3N0YXRpc3Rpay9pbmRpa2F0b3InPiBJbmRpY2F0b3JzIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL1N0YXRpc3Rpay5qcGcmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlN0YXRpc3RpY3M8L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5TdGF0aXN0aWNzIGluY2x1ZGUgaGlzdG9yaWNhbCBpbmRpY2F0b3JzIGZvciBhbGwgc2VjdG9ycyB1bmRlciB0aGUganVyaXNkaWN0aW9uIG9mIEJhbmsgSW5kb25lc2lhLjwvcD4KICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICA8L2Rpdj4KICAgICAgICA8L2Rpdj4KICAgIDwvZGl2Pgo8L2xpPjxsaSBjbGFzcz0nbmF2LWl0ZW0gZHJvcGRvd24nPgogICAgICA8YSBjbGFzcz0nbmF2LWxpbmsgZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vbGF5YW5hbi9kZWZhdWx0LmFzcHgnIGlkPSduYXZiYXJEcm9wZG93blN0YXRpc3Rpaycgcm9sZT0nYnV0dG9uJyBkYXRhLXRvZ2dsZT0nZHJvcGRvd24nIGFyaWEtaGFzcG9wdXA9J3RydWUnIGFyaWEtZXhwYW5kZWQ9J2ZhbHNlJz5TZXJ2aWNlczwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vcGVybWludGFhbi1pbmZvcm1hc2kvZGVmYXVsdC5hc3B4Jz4gSW5mb3JtYXRpb24gUmVxdWVzdCA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vcGVuZ2FkdWFuLWtvbnN1bWVuJz4gQ29uc3VtZXIgUHJvdGVjdGlvbiBhbmQgQ29tcGxhaW50cyA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vZWxpY2Vuc2luZy9kZWZhdWx0LmFzcHgnPiAgRS1MaWNlbnNpbmcgPC9hID48L2xpPjxsaSBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUnPjxkaXYgY2xhc3M9J2NsZWFyZml4Jz48YSBjbGFzcz0nZHJvcGRvd24tdG9nZ2xlJyBocmVmPScvZW4vbGF5YW5hbi9pbmZvcm1hc2ktcGVyaXppbmFuL2RlZmF1bHQuYXNweCc%2BTGljZW5zZWQgSW5zdGl0dXRpb25zPC9hPjxzcGFuIGNsYXNzPSdjYXJldCc%2BPC9zcGFuPjwvZGl2Pjx1bCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX3N1Ym1lbnUtbGlzdCc%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vaW5mb3JtYXNpLXBlcml6aW5hbi9wYXNhci1rZXVhbmdhbi9kZWZhdWx0LmFzcHgnID5Nb25leSBNYXJrZXQ8L2E%2BPC9saT48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9pbmZvcm1hc2ktcGVyaXppbmFuL3Npc3RlbS1wZW1iYXlhcmFuL2RlZmF1bHQuYXNweCcgPlBheW1lbnQgU3lzdGVtIGFuZCBSdXBpYWggQ3VycmVuY3kgTWFuYWdlbWVudDwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL3BlcnB1c3Rha2Fhbi8nPkxpYnJhcnk8L2E%2BPHNwYW4gY2xhc3M9J2NhcmV0Jz48L3NwYW4%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48bGkgY2xhc3M9J2xldmVsMyc%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9wZXJwdXN0YWthYW4va29sZWtzaS1idWt1LycgPkJvb2sgQ29sbGVjdGlvbjwvYT48L2xpPjwvdWw%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4va2FzLWJpLyc%2BIEJhbmsgSW5kb25lc2lhIENhc2ggU2VydmljZSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vbGVsYW5nLWphc2EtYmFyYW5nLyc%2BIEdvb2RzIGFuZCBTZXJ2aWNlcyBBdWN0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vbGF5YW5hbi9rdW5qdW5nYW4tYmkvZGVmYXVsdC5hc3B4Jz4gVmlzaXRhdGlvbiA8L2EgPjwvbGk%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL211c2V1bS1iaS8nPk11c2V1bTwvYT48c3BhbiBjbGFzcz0nY2FyZXQnPjwvc3Bhbj48L2Rpdj48dWwgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19zdWJtZW51LWxpc3QnPjxsaSBjbGFzcz0nbGV2ZWwzJz48YSBocmVmID0gJy9lbi9sYXlhbmFuL211c2V1bS1iaS9rb2xla3NpLW11c2V1bScgPk11c2V1bSBDb2xsZWN0aW9uPC9hPjwvbGk%2BPGxpIGNsYXNzPSdsZXZlbDMnPjxhIGhyZWYgPSAnL2VuL2xheWFuYW4vbXVzZXVtLWJpL3Byb2dyYW0taW5mb3JtYXNpL2RlZmF1bHQuYXNweCcgPk11c2V1bSBQcm9ncmFtIGFuZCBJbmZvcm1hdGlvbjwvYT48L2xpPjwvdWw%2BPGxpIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudSc%2BPGRpdiBjbGFzcz0nY2xlYXJmaXgnPjxhIGNsYXNzPSdkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9sYXlhbmFuL1N0YW5kYXIvU05BUC9kZWZhdWx0LmFzcHgnPlBheW1lbnQgU3lzdGVtIFN0YW5kYXJkIC0gT3BlbiBBUEk8L2E%2BPC9kaXY%2BPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fc3VibWVudS1saXN0Jz48L3VsPjwvdWw%2BCiAgICAgICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4gcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIGRyb3Bkb3duLW1lZ2FtZW51X19hYm91dCBwbC1tZC00Jz4KICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS10aHVtYm5haWwgbWItMicgc3R5bGU9J2JhY2tncm91bmQtaW1hZ2U6dXJsKCZxdW90Oy9NZW51JTIwSW1hZ2UvbGF5YW5hbi5qcGcmcXVvdDspJz48L2Rpdj4KICAgICAgICAgICAgICAgICAgICAgICAgPHAgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGl0bGUnPlNlcnZpY2VzPC9wPgogICAgICAgICAgICAgICAgICAgICAgICA8cCBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2Fib3V0LS1kZXNjcmlwdGlvbic%2BQmFuayBJbmRvbmVzaWEgb2ZmZXJzIHZhcmlvdXMgc2VydmljZXMsIGluY2x1ZGluZyByZXF1ZXN0cyBmb3IgaW5mb3JtYXRpb24sIGNvbXBsYWludHMsIGxpY2Vuc2luZyBhbmQgc28gb24uPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BPGxpIGNsYXNzPSduYXYtaXRlbSBkcm9wZG93bic%2BCiAgICAgIDxhIGNsYXNzPSduYXYtbGluayBkcm9wZG93bi10b2dnbGUnIGhyZWY9Jy9lbi9pbmZvcm1hc2ktcHVibGlrL0RlZmF1bHQuYXNweCcgaWQ9J25hdmJhckRyb3Bkb3duU3RhdGlzdGlrJyByb2xlPSdidXR0b24nIGRhdGEtdG9nZ2xlPSdkcm9wZG93bicgYXJpYS1oYXNwb3B1cD0ndHJ1ZScgYXJpYS1leHBhbmRlZD0nZmFsc2UnPlB1YmxpYyBJbmZvcm1hdGlvbjwvYT4KICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lbnUgZHJvcGRvd24tbWVnYW1lbnUnIGFyaWEtbGFiZWxsZWRieT0nbmF2YmFyRHJvcGRvd25TdGF0aXN0aWsnPgogICAgICAgIDxkaXYgY2xhc3M9J2NvbnRhaW5lcic%2BCiAgICAgICAgICAgIDxkaXYgY2xhc3M9J2QtbWQtZmxleCc%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHByLW1kLTQnPiAKICAgICAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uLS13cmFwcGVyJz4KICAgICAgICAgICAgICAgICAgICAgICAgPHVsIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fbWVudSc%2BPGxpPjxhIGhyZWYgPSAnL2VuL2luZm9ybWFzaS1wdWJsaWsvcHJvZmlsLXBwaWQvRGVmYXVsdC5hc3B4Jz4gUHJvZmlsZSA8L2EgPjwvbGk%2BPGxpPjxhIGhyZWYgPSAnL2VuL2luZm9ybWFzaS1wdWJsaWsvZGFzYXItaHVrdW0nPiBSZWd1bGF0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9pbmZvcm1hc2ktcHVibGlrL0RlZmF1bHQuYXNweCc%2BIExpc3Qgb2YgUHVibGljIEluZm9ybWF0aW9uIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9sYXlhbmFuLWluZm9ybWFzaS9EZWZhdWx0LmFzcHgnPiBJbmZvcm1hdGlvbiBTZXJ2aWNlIDwvYSA%2BPC9saT48bGk%2BPGEgaHJlZiA9ICcvZW4vaW5mb3JtYXNpLXB1Ymxpay9iZXJpdGEtcHBpZC9EZWZhdWx0LmFzcHgnPiBOZXdzIDwvYSA%2BPC9saT48L3VsPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgICAgICA8ZGl2IGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fY29sdW1uIHBsLW1kLTQnPgogICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19jb2x1bW4tLXdyYXBwZXInPiAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2Rpdj4KICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbiBkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQgcGwtbWQtNCc%2BCiAgICAgICAgICAgICAgICAgICAgPGRpdiBjbGFzcz0nZHJvcGRvd24tbWVnYW1lbnVfX2NvbHVtbi0td3JhcHBlcic%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxkaXYgY2xhc3M9J2Ryb3Bkb3duLW1lZ2FtZW51X19hYm91dC0tdGh1bWJuYWlsIG1iLTInIHN0eWxlPSdiYWNrZ3JvdW5kLWltYWdlOnVybCgmcXVvdDsvTWVudSUyMEltYWdlL2luZm9ybWFzaS1wdWJsaWsucG5nJnF1b3Q7KSc%2BPC9kaXY%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLXRpdGxlJz5QdWJsaWMgSW5mb3JtYXRpb248L3A%2BCiAgICAgICAgICAgICAgICAgICAgICAgIDxwIGNsYXNzPSdkcm9wZG93bi1tZWdhbWVudV9fYWJvdXQtLWRlc2NyaXB0aW9uJz5CYW5rIEluZG9uZXNpYSBtYWludGFpbnMgcHVibGljIGluZm9ybWF0aW9uIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgUHVibGljIEluZm9ybWF0aW9uIERpc2Nsb3N1cmUgQWN0IG9mIDIwMDguPC9wPgogICAgICAgICAgICAgICAgICAgIDwvZGl2PgogICAgICAgICAgICAgICAgPC9kaXY%2BCiAgICAgICAgICAgIDwvZGl2PgogICAgICAgIDwvZGl2PgogICAgPC9kaXY%2BCjwvbGk%2BZAI9D2QWAgIBD2QWBAIPDw8WAh8AaGQWAgIBD2QWAgIDD2QWAgIBDzwrAAkBAA8WAh4NTmV2ZXJFeHBhbmRlZGdkZAITD2QWAmYPFgIfAGhkAkEPZBYCAgEPZBYCAgEPZBYCZg9kFggCAQ8UKwACDxYEHwVnHwYCA2RkFgJmD2QWBgIBD2QWAmYPFQIXaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4ESG9tZWQCAg9kFgJmDxUCIWh0dHBzOi8vd3d3LmJpLmdvLmlkL2VuL3N0YXRpc3RpawpTdGF0aXN0aWNzZAIDD2QWAmYPFQIwaHR0cHM6Ly93d3cuYmkuZ28uaWQvZW4vc3RhdGlzdGlrL2luZm9ybWFzaS1rdXJzFUZvcmVpZ24gRXhjaGFuZ2UgUmF0ZWQCAw8WAh8HBRZGb3JlaWduIEV4Y2hhbmdlIFJhdGVzZAIFDxYCHwcFFkZvcmVpZ24gRXhjaGFuZ2UgUmF0ZXNkAgkPFgIfBwU%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%2FaWQ9Y29tLmJpLm1vYmlsZTdodHRwczovL3d3dy5iaS5nby5pZC9Tb3NpYWwlMjBNZWRpYS9pY29uLXBsYXktc3RvcmUuc3ZnZBgLBVJjdGwwMCRQbGFjZUhvbGRlck1haW4kZ182Yzg5ZDRhZF8xMDdmXzQzN2RfYmQ1NF84ZmRhMTdiNTU2YmYkY3RsMDAkZ3ZTZWFyY2hSZXN1bHQxD2dkBStjdGwwMCRVc2VyQ29udHJvbDEkY3RsMDAkTGlzdFZpZXdNZW51Rm9vdGVyDxQrAA5kZGRkZGRkFCsAA2RkZAIDZGRkZgL%2F%2F%2F%2F%2FD2QFRWN0bDAwJGdfZWNjMjU1OWVfNGE2MF80MzdmX2JhNThfODBlYWVlYTZiNGFhJGN0bDAwJExpc3RWaWV3QXBwc1Nvc21lZA8UKwAOZGRkZGRkZDwrAAcAAgdkZGRmAv%2F%2F%2F%2F8PZAUtY3RsMDAkUGxhY2VIb2xkZXJMZWZ0TmF2QmFyJFY0UXVpY2tMYXVuY2hNZW51Dw9kBQZSZWNlbnRkBU9jdGwwMCRQbGFjZUhvbGRlck1haW4kZ182Yzg5ZDRhZF8xMDdmXzQzN2RfYmQ1NF84ZmRhMTdiNTU2YmYkY3RsMDAkTGlzdFZpZXdLdXJzDxQrAA5kZGRkZGRkPCsAGgACGmRkZGYC%2F%2F%2F%2F%2Fw9kBSxjdGwwMCRQbGFjZUhvbGRlclRvcE5hdkJhciRUb3BOYXZpZ2F0aW9uTWVudQ8PZAUOQmFuayBJbmRvbmVzaWFkBV1jdGwwMCRQbGFjZUhvbGRlckJvdHRvbSRnX2UzMDUyYmUzXzY3M2NfNDA1ZV85Y2JlX2E4ODNhMjQ0YzA1MyRjdGwwMCRMaXN0Vmlld090aGVyTGlua3NTbGlkZXIPFCsADmRkZAIDZGRkFCsAAWQCAWRkZGYC%2F%2F%2F%2F%2Fw9kBUVjdGwwMCRnXzk2NzVlZjQ0Xzg5MzlfNDJlMl9hZWZkX2RmMWIxZTk3NTQ4NyRjdGwwMCRMaXN0Vmlld01lbnVIZWFkZXIPFCsADmRkZGRkZGQ8KwAEAAIEZGRkZgL%2F%2F%2F%2F%2FD2QFUmN0bDAwJFBsYWNlSG9sZGVyTWFpbiRnXzZjODlkNGFkXzEwN2ZfNDM3ZF9iZDU0XzhmZGExN2I1NTZiZiRjdGwwMCRndlNlYXJjaFJlc3VsdDIPZ2QFVGN0bDAwJFBsYWNlSG9sZGVyVG9wJGdfNzE3OTc2Y2JfOGI0OF80MjgzXzk4ZDBfYzFmZjVkNjk5YjVkJGN0bDAwJExpc3RWaWV3QnJlYWRjcnVtYg8UKwAOZGRkZGRkZBQrAANkZGQCA2RkZGYC%2F%2F%2F%2F%2Fw9kBUVjdGwwMCRnX2VjYzI1NTllXzRhNjBfNDM3Zl9iYTU4XzgwZWFlZWE2YjRhYSRjdGwwMCRMaXN0Vmlld09TUGxhdGZvcm0PFCsADmRkZGRkZGQUKwACZGQCAmRkZGYC%2F%2F%2F%2F%2Fw9k0fdDg5ROJEmaSe8FIAazpit1QNOZN4DOxeEIXZpaLeU%3D&__VIEWSTATEGENERATOR=FC2F6B36&__SCROLLPOSITIONX=0&__SCROLLPOSITIONY=0&__EVENTVALIDATION=%2FwEdAD5fPwGme843RfwEsPE1wynjMTZk9qLGncDjImqxppn1M6g%2BuGj1e5yNMxNarkQnNGQD%2FMwBujI58QztY2J%2FpZIxTKKThsEAjvBIzZ%2FazVBGeCseMKUY4FMnWOlaC4KYRMoqTRQkqOJA6zqRb4gMmtkgdx4UmW%2F7xcCfcKpKuvlz1%2Fn%2B9iGjf1yV0RPm%2B5CWNSgnxDJcvG1lEz%2Frc5StNmfqzcjpUZgS1ZX3d1EsQPAXraQs8icFer7v4LiV0lOOQsYkRT4zcerzyfUynDciQYKEq2lCtoHbb2hEni9ouOVEsm39Q00Fw17NOnm%2BozuW3CEwhfeQ2efgxu21Am0Xz33Z7DSMYxpJZKkihQpkRJvnuxXI27Xo9WTRzpFAqk0jLOR7yK6AgeEFi9%2Bu9QgiqdWHV43515M7TTl7yog%2BeChWakHqaPzhK6mK7oXe3z1Y%2FmxT7soP%2FalJ1OhQFU9%2FcTZdT86o%2BG0OT8tvJC5ae6RpK5mq6v%2BczfdP%2Bmy7NXpJ10ozzPUicZg0tsnR9pSA4MkFxSitqMXfoolGmE6GUUl2K5sL2zr2gw1Ecm04IkZ0%2FdPm%2B6NSzvtshRKHOBYURGG%2Ft4wdwgJiBPDE5CsYa%2FofAebObvLUToLFFFUcOA%2FvYuryS2OE5Hg4CA3d6DOoZaQxpxRBNFeDpaMAVVOs0lpH%2F%2BwY0WwoRdjFfqfhAqGeqa3Br28GzRrOR7o1YGWZsPDbuJmlp7jH35v0dcMRth%2Fkxf2ZxlBMrDRMuVgAWL2eRVf7X1zQvWcCOjjl0ejAC%2Bpyie8n0dVD2DOZ%2Fex1pANqnjtB9wxs4OS9Z2gAVh9%2FhP7iwQfY7NduX5ufutrTu8GQmOksuxcPOlo8LRC6lfUzWCeiY25rN0dyS2kHWGOLy%2BZ2zV0tAij06DHnycDDr9GcLbfwn9ozbra6EC0Z1FbCnsHKXYsh7eVy0%2B7zWcYIt7bbaUpWxXuZ0NecmjLcFda1lIZJdkNplB3BstzJsVdUyQHi3jkf1KoJnHceAFWAIlz2mfjyVIv5Sjt2AxeSkjLTCPBwnjM99olJgNCsJpgKW0UC3to7K60JXTWSBxmhAuYViN93nQ6%2B48B8esRgMbNKylMv4%2BxB3WNEOQHn0exjr9ErOzhjTsya3v77e9g1MLjA7%2F1%2Bel5DNfhcSXlZnxX8OM7SY2OjlPjYIcqlT%2F1kbIjHo1RoCoBOdKtPJM9iMrI2UtOvCGtbTiPlI23w2O6l4j3FR%2Fn12JgTE84Akvn%2F29zOw3KyOSJGJryE51hrVCFHIyqh9avaCdFUenvHgQvjtqLtNevYkENLUS02AUyBYW9w%2BQBP9yykaI8C%2FhOJh%2BPSn8FIUpZGYp8gfv9oKqCm&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24ddlmatauang1=BND++&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtFrom=01-Mar-2026&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtTo=05-Mar-2026&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24txtTanggal=&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24btnSearch1=Search&ctl00%24PlaceHolderMain%24g_6c89d4ad_107f_437d_bd54_8fda17b556bf%24ctl00%24hidSourceID=ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1
headers:
Accept-Encoding:
- gzip;q=1.0,deflate;q=0.6,identity;q=0.3
Accept:
- "*/*"
User-Agent:
- Mozilla/5.0 (compatible; Frankfurter/2.0; +https://frankfurter.dev)
Host:
- www.bi.go.id
Cookie:
- ''
Referer:
- https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi/default.aspx
Content-Type:
- application/x-www-form-urlencoded
response:
status:
code: 200
message: OK
headers:
Cache-Control:
- private
Content-Type:
- text/html; charset=utf-8
Vary:
- Accept-Encoding
X-Sharepointhealthscore:
- ''
Sprequestguid:
- aad406a2-fcc0-c0de-605c-d9631f89d3af
Request-Id:
- aad406a2-fcc0-c0de-605c-d9631f89d3af
Strict-Transport-Security:
- max-age=31536000; includeSubDomains; preload
X-Frame-Options:
- SAMEORIGIN
Content-Security-Policy:
- frame-ancestors 'self' teams.microsoft.com *.teams.microsoft.com *.skype.com
*.teams.microsoft.us local.teams.office.com *.powerapps.com *.yammer.com *.officeapps.live.com
*.office.com *.stream.azure-test.net *.microsoftstream.com *.dynamics.com
*.microsoft.com onedrive.live.com *.onedrive.live.com;
Sprequestduration:
- '15497'
Spiislatency:
- '426'
Microsoftsharepointteamservices:
- ''
X-Ms-Invokeapp:
- 1; RequireReadOnly
X-Xss-Protection:
- 1; mode=block
Date:
- Sun, 05 Apr 2026 00:49:49 GMT
Set-Cookie:
- TS0163f88e=01374ae98b6204d17a5a8d6cb1439f6ca3ae4eadac2a71201054d7a64312a4e9a75c6ac76cc2124f4799ed30762bc7d39087b4ffbe;
Path=/
- cookie_BIWEB=!nH8lPOWVks4d8ydQY4uedwkwddTnI4Tl+POX0LJUq/6ZT6F4wB2tdrJuj/K6vznrXHVaRxAUgRIibwa72Nsu9lLm/quJf8v3EGe3/KNj;
path=/; Httponly; Secure
Connection:
- Keep-Alive
Transfer-Encoding:
- chunked
body:
encoding: ASCII-8BIT
string: !binary |-

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html dir="ltr" lang="en-US">

    <head><meta name="keywords" content="Bank Indonesia, BI, Rupiah, kurs BI, kurs tengah BI, kalkulator kurs, inflasi, kurs transaksi, JISDOR, PINTAR BI, BI Fast, bank sentral, QRIS, uang Rupiah, SIMODIS, Sobat Rupiah, Cadangan Devisa, Gubernur Bank Indonesia, uang, bank, CBP, Cinta Bangga Rupiah, Cinta Rupiah, JIBOR, IndONIA" /><meta name="robots" content="index, follow" /><meta name="Author" content="Bank Indonesia" /><meta name="GENERATOR" content="Microsoft SharePoint" /><meta http-equiv="Content-type" content="text/html; charset=utf-8" /><meta http-equiv="X-UA-Compatible" content="IE=11; IE=10" /><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1" /><meta name="viewport" content="width=device-width, initial-scale=1" /><meta http-equiv="X-UA-Compatible" content="IE=10"/><script type='text/javascript'>var _browserisFlight = true;</script><meta http-equiv="Expires" content="0" /><meta name="msapplication-TileImage" content="/_layouts/15/images/SharePointMetroAppTile.png" /><meta name="msapplication-TileColor" content="#0072C6" /><title>
	Foreign Exchange Rates
</title><link rel="shortcut icon" href="/favicon.png" type="image/vnd.microsoft.icon" id="favicon" /><link id="CssLink-8ab7bad8c5b14baca58b1928bab4da87" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/Themable/corev15.css?rev=UP2nlZLed9gOy%2BMP38oz0A%3D%3DTAG0"/>
<link id="CssLink-b254dd1d578346ca9afce172e1c0e829" rel="stylesheet" type="text/css" href="/_layouts/15/1033/styles/SuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ%3D%3DTAG0"/>
<style id="SPThemeHideForms" type="text/css">body {opacity:0 !important}</style><script type="text/javascript">// <![CDATA[ 

var g_SPOffSwitches={};
// ]]>
</script>
<script type="text/javascript" src="/_layouts/15/1033/initstrings.js?rev=94%2F8Pzbtowd6g2cd%2FsOoIg%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/init.js?rev=eqiUN2EN5Xn%2F2YyfuJQDtA%3D%3DTAG0"></script>
<script type="text/javascript" src="/_layouts/15/theming.js?rev=SuLUbbwTXcxFWOWLFUsOkw%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=sa1PqOHf5j2-6ssMNtdqimFp8nte-oIkdwJ1eOlUHUtOp0vjD2ImoMOMcCHq1bp0xvsD4Z3e86bZnUB2GeqPAZ5tXV4_nTT2jYY2_isi_31MH0efbPRKDe01qwHMlhjCqLYGR-Z4R_iUcMTmpehd2gzVBx3-AFsGfQMAjUkrTW2nxC2ljpAK-Lzwgqii3l2k0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0"></script>
<script type="text/javascript" src="/ScriptResource.axd?d=KvY94j2NghrBo6dT9b1k169bI6meVaRfhNlBBvNxLwKSSwkjBP3MBZHoPl9f9rloh9rNbh8ojtrmFM5d9fu_pn052DtTQVrukBbiH42jb3KYVgH6ktRQ-N9tLXZaVfnOiMT6hM1r-FY7atAipPNrcmQHuNtbk-ilaUaQ4QiBaTJCYyFOuHhrtEDu9ZQfUWGH0&amp;t=ffffffffb1d0f179"></script>
<script type="text/javascript" src="/_layouts/15/suitenav.js?rev=VM%2FdyE40A0OgsmOI%2BIKIqQ%3D%3DTAG0"></script>
<script type="text/javascript">RegisterSod("require.js", "\u002f_layouts\u002f15\u002frequire.js?rev=bv3fWJhk0uFGpVwBxnZKNQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("strings.js", "\u002f_layouts\u002f15\u002f1033\u002fstrings.js?rev=qTd5Iu3wkfWjQOhKADG18A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.res.resx", "\u002f_layouts\u002f15\u002f1033\u002fsp.res.js?rev=FnWveYddVjlqQYS2ZBOOzA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.runtime.js", "\u002f_layouts\u002f15\u002fsp.runtime.js?rev=ieBn\u00252FPr8FuV9095CsVXFdw\u00253D\u00253DTAG0");RegisterSodDep("sp.runtime.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.js", "\u002f_layouts\u002f15\u002fsp.js?rev=Os4G339\u00252BEf5vdNuG9dSWtw\u00253D\u00253DTAG0");RegisterSodDep("sp.js", "sp.runtime.js");RegisterSodDep("sp.js", "sp.ui.dialog.js");RegisterSodDep("sp.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("sp.init.js", "\u002f_layouts\u002f15\u002fsp.init.js?rev=GcX1\u00252BQkwU9iewwepsza2Kw\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.dialog.js", "\u002f_layouts\u002f15\u002fsp.ui.dialog.js?rev=d7y1SiSVwqLJzuIiMAukpg\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.dialog.js", "sp.init.js");RegisterSodDep("sp.ui.dialog.js", "sp.res.resx");</script>
<script type="text/javascript">RegisterSod("core.js", "\u002f_layouts\u002f15\u002fcore.js?rev=OuK8lknoOD37VvjQyOsHrw\u00253D\u00253DTAG0");RegisterSodDep("core.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("menu.js", "\u002f_layouts\u002f15\u002fmenu.js?rev=WMbI5XqdDKTzX20rarEQsQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("mQuery.js", "\u002f_layouts\u002f15\u002fmquery.js?rev=wdHoEUjBno2g0ULGFwFjAg\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("callout.js", "\u002f_layouts\u002f15\u002fcallout.js?rev=yFnKkBSYasfA2rW6krdVFQ\u00253D\u00253DTAG0");RegisterSodDep("callout.js", "strings.js");RegisterSodDep("callout.js", "mQuery.js");RegisterSodDep("callout.js", "core.js");</script>
<script type="text/javascript">RegisterSod("sp.core.js", "\u002f_layouts\u002f15\u002fsp.core.js?rev=LSKJVyPWTBdDAU6EL2A6kw\u00253D\u00253DTAG0");RegisterSodDep("sp.core.js", "strings.js");RegisterSodDep("sp.core.js", "sp.init.js");RegisterSodDep("sp.core.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clienttemplates.js", "\u002f_layouts\u002f15\u002fclienttemplates.js?rev=oZO8iLnMIX278DJXZp9S4A\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sharing.js", "\u002f_layouts\u002f15\u002fsharing.js?rev=z7dWWrP\u00252FqzzxvtLQKR08Ww\u00253D\u00253DTAG0");RegisterSodDep("sharing.js", "strings.js");RegisterSodDep("sharing.js", "mQuery.js");RegisterSodDep("sharing.js", "clienttemplates.js");RegisterSodDep("sharing.js", "core.js");</script>
<script type="text/javascript">RegisterSod("suitelinks.js", "\u002f_layouts\u002f15\u002fsuitelinks.js?rev=hNe7S\u00252B4EVV83bzPy9U\u00252BEvQ\u00253D\u00253DTAG0");RegisterSodDep("suitelinks.js", "strings.js");RegisterSodDep("suitelinks.js", "core.js");</script>
<script type="text/javascript">RegisterSod("clientrenderer.js", "\u002f_layouts\u002f15\u002fclientrenderer.js?rev=Evu1eqGPwP\u00252FeN5ZuIpaSTQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("srch.resources.resx", "\u002f_layouts\u002f15\u002f1033\u002fsrch.resources.js?rev=vZPcBJM2l80oZNzRUCRQ4g\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("search.clientcontrols.js", "\u002f_layouts\u002f15\u002fsearch.clientcontrols.js?rev=xgTuNRzK\u00252B28qr6bjGThpIw\u00253D\u00253DTAG0");RegisterSodDep("search.clientcontrols.js", "sp.init.js");RegisterSodDep("search.clientcontrols.js", "clientrenderer.js");RegisterSodDep("search.clientcontrols.js", "srch.resources.resx");</script>
<script type="text/javascript">RegisterSod("sp.search.js", "\u002f_layouts\u002f15\u002fsp.search.js?rev=eMyDf7ZGV6rTjB2sDSdovA\u00253D\u00253DTAG0");RegisterSodDep("sp.search.js", "sp.init.js");RegisterSodDep("sp.search.js", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("ajaxtoolkit.js", "\u002f_layouts\u002f15\u002fajaxtoolkit.js?rev=I3jVxnVkBqeUZ\u00252FWA\u00252BgwTLg\u00253D\u00253DTAG0");RegisterSodDep("ajaxtoolkit.js", "search.clientcontrols.js");</script>
<script type="text/javascript">RegisterSod("userprofile", "\u002f_layouts\u002f15\u002fsp.userprofiles.js?rev=J0M1pzLkfDXcJflabMvTYA\u00253D\u00253DTAG0");RegisterSodDep("userprofile", "sp.runtime.js");</script>
<script type="text/javascript">RegisterSod("followingcommon.js", "\u002f_layouts\u002f15\u002ffollowingcommon.js?rev=MgAestdI8p64n4UsP1Xeug\u00253D\u00253DTAG0");RegisterSodDep("followingcommon.js", "strings.js");RegisterSodDep("followingcommon.js", "sp.js");RegisterSodDep("followingcommon.js", "userprofile");RegisterSodDep("followingcommon.js", "core.js");RegisterSodDep("followingcommon.js", "mQuery.js");</script>
<script type="text/javascript">RegisterSod("profilebrowserscriptres.resx", "\u002f_layouts\u002f15\u002f1033\u002fprofilebrowserscriptres.js?rev=qwf69WaVc1mYlJLXqmZmVA\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("sp.ui.mysitecommon.js", "\u002f_layouts\u002f15\u002fsp.ui.mysitecommon.js?rev=5nRJiZWvHP3AB7VS14cjuw\u00253D\u00253DTAG0");RegisterSodDep("sp.ui.mysitecommon.js", "sp.init.js");RegisterSodDep("sp.ui.mysitecommon.js", "sp.runtime.js");RegisterSodDep("sp.ui.mysitecommon.js", "userprofile");RegisterSodDep("sp.ui.mysitecommon.js", "profilebrowserscriptres.resx");</script>
<script type="text/javascript">RegisterSod("browserScript", "\u002f_layouts\u002f15\u002fnon_ie.js?rev=KT6LY54Wt0vnHyVV6VVzWw\u00253D\u00253DTAG0");RegisterSodDep("browserScript", "strings.js");</script>
<script type="text/javascript">RegisterSod("inplview", "\u002f_layouts\u002f15\u002finplview.js?rev=ecdG8BqIlGbfoftF0\u00252FIAZA\u00253D\u00253DTAG0");RegisterSodDep("inplview", "strings.js");RegisterSodDep("inplview", "core.js");RegisterSodDep("inplview", "clienttemplates.js");RegisterSodDep("inplview", "sp.js");</script>
<script type="text/javascript">RegisterSod("cui.js", "\u002f_layouts\u002f15\u002fcui.js?rev=ejf8nksDjeL2s1mvUvw77w\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("ribbon", "\u002f_layouts\u002f15\u002fsp.ribbon.js?rev=wPDmc1LZubpR2Fgk01M8qw\u00253D\u00253DTAG0");RegisterSodDep("ribbon", "strings.js");RegisterSodDep("ribbon", "core.js");RegisterSodDep("ribbon", "sp.core.js");RegisterSodDep("ribbon", "sp.js");RegisterSodDep("ribbon", "cui.js");RegisterSodDep("ribbon", "sp.res.resx");RegisterSodDep("ribbon", "sp.runtime.js");RegisterSodDep("ribbon", "inplview");</script>
<script type="text/javascript">RegisterSod("WPAdderClass", "\u002f_layouts\u002f15\u002fwpadder.js?rev=cLi8ZAp2DVY4x\u00252BMDFIRWvQ\u00253D\u00253DTAG0");</script>
<script type="text/javascript">RegisterSod("dragdrop.js", "\u002f_layouts\u002f15\u002fdragdrop.js?rev=h\u00252F2Jd5ursJLUu88iNs\u00252FM2A\u00253D\u00253DTAG0");RegisterSodDep("dragdrop.js", "strings.js");</script>
<script type="text/javascript">RegisterSod("quicklaunch.js", "\u002f_layouts\u002f15\u002fquicklaunch.js?rev=yuA4NhRQlmo9X6TJsaidUg\u00253D\u00253DTAG0");RegisterSodDep("quicklaunch.js", "strings.js");RegisterSodDep("quicklaunch.js", "dragdrop.js");</script>
<link type="text/xml" rel="alternate" href="/en/statistik/informasi-kurs/transaksi-bi/_vti_bin/spsdisco.aspx" /><link href="/Style Library/biweb/css/bootstrap4.min.css" rel="stylesheet" />
        
        <!-- Update Font Family 1 Februari 2024 -->
        <link rel="preconnect" href="https://fonts.googleapis.com" /><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin="" />
		<!-- Update Font Family 2 Februari 2026 -->
		<link href="https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,400;1,300&amp;display=swap" integrity="sha512-e2mrHtfsfL/rkAg+Q3rQpEIkWMdGU36OfDwUIJz4nyq7/pevf44ZAXwTt1/mr8mLsnPJbslCx85k+qRTTZIDjA==" crossorigin="anonymous" rel="stylesheet" /><link href="https://fonts.googleapis.com/css2?family=PT+Sans&amp;display=swap" integrity="sha512-pZRQvRtRsHut00kYTpiGGYlYLiGNEP+/efrLNNzhAxe/uT3UiRpLYUEqXW1+zwVvWAxWrVyYxrDT6tDShkc2lA==" crossorigin="anonymous" rel="stylesheet" /><link href="/Style Library/biweb/css/maincss.min.css" rel="stylesheet" />
        
        <!--<script src="/Style Library/biweb/js/jquery-3.4.1.min.js" type="text/javascript"></script>-->
        <script src="/Style Library/biweb/js/jquery-3.5.1.min.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/bootstrap4.min.js" type="text/javascript"></script>        
        <script src="/Style Library/biweb/js/jquery.scollingTabs.min.js" type="text/javascript"></script>       
        <script src="/Style Library/biweb/js/mainjs.js" type="text/javascript"></script>
        <script src="/Style Library/biweb/js/jquery.dataTables.min.js" type="text/javascript"></script>
        <link href="/Style Library/biweb/css/jquery.dataTables.min.css" rel="stylesheet" />
                
		<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':
		new Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],
		j=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=
		'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);
		})(window,document,'script','dataLayer','GTM-TX6N9KL');</script>
		<script>
			  $(document).ready(function() {
			    if (window.location.href.indexOf("/en/") > -1) {
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia has one single objective of achieving and maintaining stability of the Rupiah value." />' );
							    }
			    else{
			    document.head.insertAdjacentHTML( 'beforeEnd', '<meta name="description" content="Bank Indonesia adalah Bank Sentral Republik Indonesia dengan Satu Tujuan Tunggal yaitu Mencapai dan Memelihara Kestabilan Nilai Rupiah." />' );
							    }
			  });
		</script>
		<script  type="text/javascript">
			$(document).ready(function(){
				setTimeout(function () {
					$('#ctl00_onetidProjectPropertyTitleGraphic').attr("title", "Bank Indonesia")
			        if (window.location.href.indexOf("/en/") > -1) {
			           $('#ctl00_onetidProjectPropertyTitleGraphic').attr('href', '/en/');
			        }
			    }, 500); 	
			    
				$('#tablecustom').DataTable();		
			});
		</script>
		
        
            
	<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
    <script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>
    <script type="text/javascript">
        $(window).ready(function () {
            $('#selectPeriod').change(function () {
                $('.datepicker-period').hide();
                $('#' + $(this).val()).show();
            });



            var date_input_harian = $('.input-daterange-harian input');
            var options = {
                format: 'mm/dd/yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto"
            };
            date_input_harian.datepicker(options);
        });
    </script>

            <link rel="canonical" href="https://www.bi.go.id:443/en/statistik/informasi-kurs/transaksi-bi/default.aspx" />
            
        </head>

    <body>
	<noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-TX6N9KL"
	height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
      <div id="imgPrefetch" style="display:none">
<img src="/favicon.png?rev=43" />
<img src="/_layouts/15/images/spcommon.png?rev=43" />
<img src="/SiteAssets/logo-bi@2x.png?rev=43" />
</div>

        <noscript><div class='noindex'>You may be trying to access this site from a secured browser on the server. Please enable scripts and reload this page.</div></noscript>
        
        <form method="post" action="./default.aspx" onsubmit="javascript:return WebForm_OnSubmit();" id="aspnetForm">
<div class="aspNetHidden">
<input type="hidden" name="_wpcmWpid" id="_wpcmWpid" value="" />
<input type="hidden" name="wpcmVal" id="wpcmVal" value="" />
<input type="hidden" name="MSOWebPartPage_PostbackSource" id="MSOWebPartPage_PostbackSource" value="" />
<input type="hidden" name="MSOTlPn_SelectedWpId" id="MSOTlPn_SelectedWpId" value="" />
<input type="hidden" name="MSOTlPn_View" id="MSOTlPn_View" value="0" />
<input type="hidden" name="MSOTlPn_ShowSettings" id="MSOTlPn_ShowSettings" value="False" />
<input type="hidden" name="MSOGallery_SelectedLibrary" id="MSOGallery_SelectedLibrary" value="" />
<input type="hidden" name="MSOGallery_FilterString" id="MSOGallery_FilterString" value="" />
<input type="hidden" name="MSOTlPn_Button" id="MSOTlPn_Button" value="none" />
<input type="hidden" name="__EVENTTARGET" id="__EVENTTARGET" value="" />
<input type="hidden" name="__EVENTARGUMENT" id="__EVENTARGUMENT" value="" />
<input type="hidden" name="__REQUESTDIGEST" id="__REQUESTDIGEST" value="0x35BC2D2C4DC663A833A616DBBC24E84FB60F5061B356488E6835B50097795E3833C3860D630304C84BBF62AE0C9DFA8CB43179D54FCA8028200ABA5C420A4555,05 Apr 2026 00:49:48 -0000" />
<input type="hidden" name="MSOSPWebPartManager_DisplayModeName" id="MSOSPWebPartManager_DisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_ExitingDesignMode" id="MSOSPWebPartManager_ExitingDesignMode" value="false" />
<input type="hidden" name="MSOWebPartPage_Shared" id="MSOWebPartPage_Shared" value="" />
<input type="hidden" name="MSOLayout_LayoutChanges" id="MSOLayout_LayoutChanges" value="" />
<input type="hidden" name="MSOLayout_InDesignMode" id="MSOLayout_InDesignMode" value="" />
<input type="hidden" name="_wpSelected" id="_wpSelected" value="" />
<input type="hidden" name="_wzSelected" id="_wzSelected" value="" />
<input type="hidden" name="MSOSPWebPartManager_OldDisplayModeName" id="MSOSPWebPartManager_OldDisplayModeName" value="Browse" />
<input type="hidden" name="MSOSPWebPartManager_StartWebPartEditingName" id="MSOSPWebPartManager_StartWebPartEditingName" value="false" />
<input type="hidden" name="MSOSPWebPartManager_EndWebPartEditing" id="MSOSPWebPartManager_EndWebPartEditing" value="false" />
<input type="hidden" name="_maintainWorkspaceScrollPosition" id="_maintainWorkspaceScrollPosition" value="0" />
<input type="hidden" name="__VIEWSTATE" id="__VIEWSTATE" value="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" />
</div>

<script type="text/javascript">
//<![CDATA[
var theForm = document.forms['aspnetForm'];
if (!theForm) {
    theForm = document.aspnetForm;
}
function __doPostBack(eventTarget, eventArgument) {
    if (!theForm.onsubmit || (theForm.onsubmit() != false)) {
        theForm.__EVENTTARGET.value = eventTarget;
        theForm.__EVENTARGUMENT.value = eventArgument;
        theForm.submit();
    }
}
//]]>
</script>


<script src="/WebResource.axd?d=HRMEYubZPUzVts77E_7Ik1yT-44y5_IDixxutdmFieYdhwteoLUd0gvCyyYvKy3z7ple1Au9_czBVt-tA8fqYJ7_DchPiphcRPRL6mZmE2M1&amp;t=638259656865233147" type="text/javascript"></script>


<script type="text/javascript">
//<![CDATA[
var MSOWebPartPageFormName = 'aspnetForm';
var g_presenceEnabled = true;
var g_wsaEnabled = false;

var g_correlationId = 'aad406a2-fcc0-c0de-605c-d9631f89d3af';
var g_wsaQoSEnabled = false;
var g_wsaQoSDataPoints = [];
var g_wsaRUMEnabled = false;
var g_wsaLCID = 1033;
var g_wsaListTemplateId = null;
var g_wsaSiteTemplateId = 'CMSPUBLISHING#0';
var _spPageContextInfo={"webServerRelativeUrl":"/en/statistik/informasi-kurs/transaksi-bi","webAbsoluteUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","viewId":"","listId":"","listPermsMask":null,"listUrl":"","listTitle":null,"listBaseTemplate":-1,"viewOnlyExperienceEnabled":false,"blockDownloadsExperienceEnabled":false,"idleSessionSignOutEnabled":false,"cdnPrefix":"","siteAbsoluteUrl":"https://www.bi.go.id","siteId":"{e671e14c-2777-404f-9b86-2f3b332aa0f1}","showNGSCDialogForSyncOnTS":false,"supportPoundStorePath":true,"supportPercentStorePath":true,"siteSubscriptionId":null,"CustomMarkupInCalculatedFieldDisabled":true,"AllowCustomMarkupInCalculatedField":false,"isSPO":false,"farmLabel":null,"serverRequestPath":"/en/statistik/informasi-kurs/transaksi-bi/default.aspx","layoutsUrl":"_layouts/15","webId":"{18d3b9c9-56e5-44c2-9518-566e5ed25d9a}","webTitle":"Foreign Exchange Rates","webTemplate":"39","webTemplateConfiguration":"CMSPUBLISHING#0","webDescription":"","tenantAppVersion":"0","isAppWeb":false,"webLogoUrl":"/SiteAssets/logo-bi@2x.png","webLanguage":1033,"currentLanguage":1033,"currentUICultureName":"en-US","currentCultureName":"en-US","currentCultureLCID":1033,"env":null,"nid":0,"fid":0,"serverTime":"2026-04-05T00:49:48.8799767Z","siteClientTag":"2144$$16.0.10417.20037","crossDomainPhotosEnabled":false,"openInClient":false,"Has2019Era":true,"webUIVersion":15,"webPermMasks":{"High":16,"Low":196673},"pageListId":null,"pageItemId":-1,"pagePermsMask":null,"pagePersonalizationScope":1,"userEmail":"","userId":0,"userLoginName":null,"userDisplayName":null,"isAnonymousUser":true,"isAnonymousGuestUser":false,"isEmailAuthenticationGuestUser":false,"isExternalGuestUser":false,"systemUserKey":null,"alertsEnabled":true,"siteServerRelativeUrl":"/","allowSilverlightPrompt":"True","themeCacheToken":"/en/statistik/informasi-kurs/transaksi-bi::9:","themedCssFolderUrl":null,"themedImageFileNames":null,"modernThemingEnabled":true,"isSiteAdmin":false,"ExpFeatures":[480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],"killSwitches":{},"InternalValidAuthorities":["www.bi.go.id","web.bi.go.id","dc1biwebapp21","dc1biwebapp22"],"CorrelationId":"aad406a2-fcc0-c0de-605c-d9631f89d3af","hasManageWebPermissions":false,"isNoScriptEnabled":false,"groupId":null,"groupHasHomepage":true,"groupHasQuickLaunchConversationsLink":false,"departmentId":null,"hubSiteId":null,"hasPendingWebTemplateExtension":false,"isHubSite":false,"isWebWelcomePage":true,"siteClassification":"","hideSyncButtonOnODB":false,"showNGSCDialogForSyncOnODB":false,"sitePagesEnabled":false,"sitePagesFeatureVersion":0,"DesignPackageId":"00000000-0000-0000-0000-000000000000","groupType":null,"groupColor":"#757575","siteColor":"#757575","headerEmphasis":0,"navigationInfo":null,"guestsEnabled":false,"MenuData":{"SignInUrl":"/en/statistik/informasi-kurs/transaksi-bi/_layouts/15/Authenticate.aspx?Source=%2Fen%2Fstatistik%2Finformasi%2Dkurs%2Ftransaksi%2Dbi%2Fdefault%2Easpx"},"RecycleBinItemCount":-1,"PublishingFeatureOn":true,"PreviewFeaturesEnabled":false,"disableAppViews":false,"disableFlows":false,"serverRedirectedUrl":null,"formDigestValue":"0x35BC2D2C4DC663A833A616DBBC24E84FB60F5061B356488E6835B50097795E3833C3860D630304C84BBF62AE0C9DFA8CB43179D54FCA8028200ABA5C420A4555,05 Apr 2026 00:49:48 -0000","maximumFileSize":10240,"formDigestTimeoutSeconds":1800,"canUserCreateMicrosoftForm":false,"canUserCreateVisioDrawing":true,"readOnlyState":null,"isTenantDevSite":false,"preferUserTimeZone":false,"userTimeZoneData":null,"userTime24":false,"userFirstDayOfWeek":null,"webTimeZoneData":null,"webTime24":false,"webFirstDayOfWeek":null,"isSelfServiceSiteCreationEnabled":null,"alternateWebAppHost":"","aadTenantId":"","aadUserId":"","aadInstanceUrl":"","msGraphEndpointUrl":"https://","allowInfectedDownload":true};_spPageContextInfo.updateFormDigestPageLoaded=new Date();_spPageContextInfo.clientServerTimeDelta=new Date(_spPageContextInfo.serverTime)-new Date();if(typeof(define)=='function'){define('SPPageContextInfo',[],function(){return _spPageContextInfo;});}
function _spNavigateHierarchy(nodeDiv, dataSourceId, dataPath, url, listInContext, type) {

    CoreInvoke('ProcessDefaultNavigateHierarchy', nodeDiv, dataSourceId, dataPath, url, listInContext, type, document.forms.aspnetForm, "", "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002fdefault.aspx");

}
Flighting.ExpFeatures = [480216468,1884350801,1158731092,62197791,538521105,335811073,4194306,34614301,268500996,-1946025984,28445328,-2147475455,134291456,65536,288,950272,1282,808326148,134217873,0,0,-1073217536,545285252,18350656,-467402752,6291457,-2147483644,1074794496,-1728053184,1845537108,622628,4102,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; (function()
{
    if(typeof(window.SP) == "undefined") window.SP = {};
    if(typeof(window.SP.YammerSwitch) == "undefined") window.SP.YammerSwitch = {};

    var ysObj = window.SP.YammerSwitch;
    ysObj.IsEnabled = false;
    ysObj.TargetYammerHostName = "www.yammer.com";
} )(); //]]>
</script>

<script src="/_layouts/15/blank.js?rev=OqEYlnomw4m5X%2FMg2wSuyA%3D%3DTAG0" type="text/javascript"></script>
<script type="text/javascript">
//<![CDATA[
window.SPThemeUtils && SPThemeUtils.RegisterCssReferences([{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fThemable\u002fcorev15.css?rev=UP2nlZLed9gOy\u00252BMP38oz0A\u00253D\u00253DTAG0","Id":"CssLink-8ab7bad8c5b14baca58b1928bab4da87","ConditionalExpression":"","After":"","RevealToNonIE":"false"},{"Url":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","OriginalUrl":"\u002f_layouts\u002f15\u002f1033\u002fstyles\u002fSuiteNav.css?rev=0FFXFnNqA1cSZmEYhq76UQ\u00253D\u00253DTAG0","Id":"CssLink-b254dd1d578346ca9afce172e1c0e829","ConditionalExpression":"","After":"","RevealToNonIE":"false"}]);
(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingDocument', function() { FollowingDocument(); });
        });
    })();(function(){

        if (typeof(_spBodyOnLoadFunctions) === 'undefined' || _spBodyOnLoadFunctions === null) {
            return;
        }
        _spBodyOnLoadFunctions.push(function() {
            SP.SOD.executeFunc('core.js', 'FollowingCallout', function() { FollowingCallout(); });
        });
    })();if (typeof(DeferWebFormInitCallback) == 'function') DeferWebFormInitCallback();function WebForm_OnSubmit() {
UpdateFormDigest('\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi', 1440000);
                    var workspaceElem = GetCachedElement("s4-workspace");
                    if (workspaceElem != null)
                    {
                        var scrollElem = GetCachedElement("_maintainWorkspaceScrollPosition");
                        if (scrollElem != null)
                        {
                            scrollElem.value = workspaceElem.scrollTop;
                        }
                    };
                if (typeof(_spFormOnSubmitWrapper) != 'undefined') {return _spFormOnSubmitWrapper();} else {return true;};
return true;
}
//]]>
</script>

<div class="aspNetHidden">

	<input type="hidden" name="__VIEWSTATEGENERATOR" id="__VIEWSTATEGENERATOR" value="FC2F6B36" />
	<input type="hidden" name="__SCROLLPOSITIONX" id="__SCROLLPOSITIONX" value="0" />
	<input type="hidden" name="__SCROLLPOSITIONY" id="__SCROLLPOSITIONY" value="0" />
	<input type="hidden" name="__EVENTVALIDATION" id="__EVENTVALIDATION" value="/wEdAAvlQ7pme0IMZpNFcu9c7MimMTZk9qLGncDjImqxppn1M7eMHcICYgTwxOQrGGv6HwHmzm7y1E6CxRRVHDgP72Lq8ktjhOR4OAgN3egzqGWkMacUQTRXg6WjAFVTrNJaR//sGNFsKEXYxX6n4QKhnqmtK20/AEkSVHfI/JCTRr8SpUcjKqH1q9oJ0VR6e8eBC+NaeZ5zk4cyCpiarxz3A4I0tqLtNevYkENLUS02AUyBYa4mCg64JzRm9lpw8J2q/jeu2Iq6WX3g3S+6ATMzB8fZ" />
</div>
            <script type="text/javascript">
//<![CDATA[
Sys.WebForms.PageRequestManager._initialize('ctl00$ScriptManager', 'aspnetForm', ['fctl00$WebPartAdderUpdatePanel',''], [], ['ctl00$WebPartAdder',''], 90, 'ctl00');
//]]>
</script>

            
            <script
                type="text/javascript"> var submitHook = function () { return false; }; theForm._spOldSubmit = theForm.submit; theForm.submit = function () { if (!submitHook()) { this._spOldSubmit(); } }; </script>
            <span id="DeltaSPWebPartManager">
            </span>
            <span id="DeltaDelegateControls">
                
                
            </span>
            <div id="TurnOnAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOnAcc"
                    title="Turn on more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(true);UpdateAccessibilityUI();document.getElementById('linkTurnOffAcc').focus();return
                false;">
                Turn on more accessible mode</a></div>
            <div id="TurnOffAccessibility" style="display:none" class="s4-notdlg noindex">
                <a id="linkTurnOffAcc"
                    title="Turn off more accessible mode"
                href="#" class="ms-accessible ms-acc-button"
                onclick="SetIsAccessibilityFeatureEnabled(false);UpdateAccessibilityUI();document.getElementById('linkTurnOnAcc').focus();return
                false;">
                Turn off more accessible mode</a></div>
            <div class="s4-notdlg s4-skipribbonshortcut noindex">
                <a href="javascript:;"
                    title="Skip Ribbon Commands"
                onclick="document.getElementById('startNavigation').focus();" class="ms-accessible ms-acc-button"
                accesskey="
                Y">
                Skip Ribbon Commands</a></div>
            <div class="s4-notdlg noindex">
                <a href="javascript:;"
                    title="Skip to main content"
                onclick="document.getElementById('mainContent').focus();" class="ms-accessible ms-acc-button">
                Skip to main content</a></div>
            <div id="TurnOffAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOffAnimation"
                    title="Turn off Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn off Animations</a></div>
            <div id="TurnOnAnimation" style="display:none;" class="s4-notdlg noindex">
                <a id="linkTurnOnAnimation"
                    title="Turn on Animations"
                href="#" class="ms-accessible ms-acc-button" onclick="ToggleAnimationStatus();return false;">
                Turn on Animations</a></div>
            <a id="HiddenAnchor" href="javascript:;" style="display:none;"></a>

                <div id="suiteBarDelta" class="ms-dialogHidden ms-fullWidth noindex">
	
                    <div id="suiteMenuData" class="ms-hide">
                        


                        <span class="ms-siteactions-root" id="siteactiontd">
                            
                        </span>
                    </div>
                    <script type="text/javascript">// <![CDATA[ 

var g_navBarHelpDefaultKey = "HelpHome";
		
		 // ]]>
</script>
                    <div id="suiteBarTop" class="ms-fullWidth ms-TopBarBackground-bgColor" style="height:50px; position:relative;">

	</div><div class="wf-family-o365 o365wf" style="display:none">

	</div>
                
</div>

                <div id="ms-hcTest"></div>
                                <div id="s4-ribbonrow">
                    <div id="globalNavBox" class="noindex">
                        <div id="ribbonBox">
                            <div id="s4-ribboncont">
                                <div id="DeltaSPRibbon">
	
                                    

                                    <input id="RibbonContainer_activeTabId" name="ctl00$ctl74" type="hidden" value=""/><div id='RibbonContainer'><div class="ms-cui-ribbon ms-cui-needIEFilter" id="Ribbon" unselectable="on" aria-describedby="ribboninstructions" role="toolbar"><span class="ms-cui-hidden" id="ribboninstructions" unselectable="on">To navigate through the Ribbon, use standard browser navigation keys. To skip between groups, use Ctrl+LEFT or Ctrl+RIGHT. To jump to the first Ribbon tab use Ctrl+[. To jump to the last selected command use Ctrl+]. To activate a command, use Enter.</span><div class="ms-cui-ribbonTopBars" unselectable="on"><div class="ms-cui-topBar1" unselectable="on" style="display:none"><div class="ms-cui-qat-container" unselectable="on"></div></div><div class="ms-cui-topBar2" unselectable="on"><div class="ms-cui-jewel-container" id="jewelcontainer" unselectable="on" style="display:none"></div><div class="ms-cui-TabRowLeft ms-core-defaultFont ms-dialogHidden" id="RibbonContainer-TabRowLeft" unselectable="on">
									
								
                                        </div><ul class="ms-cui-tts" unselectable="on" role="tablist"><li class="ms-cui-tt ms-browseTab ms-cui-tt-s" id="Ribbon.Read-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.Read',false, event);" title="Browse" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.Read',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Browse</span><span class="ms-cui-hidden" unselectable="on">Tab 1 of 2.</span></a></li><li class="ms-cui-tt" id="Ribbon.WebPartPage-title" unselectable="on" role="tab"><a class="ms-cui-tt-a" unselectable="on" href="javascript:;" onclick="_ribbonStartInit('Ribbon.WebPartPage',false, event);" title="Page" onkeydown="if(event != null && event.keyCode == 13){ if(typeof(_ribbon) != 'undefined') _ribbon.launchedByKeyboard = true; _ribbonStartInit('Ribbon.WebPartPage',false, event);  }"><span class="ms-cui-tt-span" unselectable="on">Page</span><span class="ms-cui-hidden" unselectable="on">Tab 2 of 2.</span></a></li></ul><div class="ms-cui-TabRowRight s4-trc-container s4-notdlg ms-core-defaultFont" id="RibbonContainer-TabRowRight" unselectable="on">
									
								
                                            
                                            <a onmouseover="this.firstChild.firstChild.style.left=&#39;-217px&#39;; this.firstChild.firstChild.style.top=&#39;-192px&#39;;" onmouseout="this.firstChild.firstChild.style.left=&#39;-218px&#39;; this.firstChild.firstChild.style.top=&#39;-48px&#39;;" onclick="SP.SOD.executeFunc(&#39;followingcommon.js&#39;, &#39;FollowSite&#39;, function() { FollowSite(); }); return false;" id="site_follow_button" title="Follow this site and get back to it easily from your sites page." class="ms-promotedActionButton" href="javascript:__doPostBack(&#39;ctl00$site_follow_button&#39;,&#39;&#39;)" style="display:inline-block;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust ms-promotedActionButton-icon"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Follow" style="position:absolute;left:-218px;top:-48px;" /></span><span class="ms-promotedActionButton-text">Follow</span></a>
                                            
                                            
                                            <span id="fullscreenmodebox" class="ms-qatbutton">
                                                <span id="fullscreenmode">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-125px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-143px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_fullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(true);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-143px;top:-178px;" /></span></span></a>
                                                </span>
                                                <span id="exitfullscreenmode" style="display: none;">
                                                    <a onmouseover="this.firstChild.firstChild.firstChild.style.left=&#39;-179px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-96px&#39;;" onmouseout="this.firstChild.firstChild.firstChild.style.left=&#39;-107px&#39;; this.firstChild.firstChild.firstChild.style.top=&#39;-178px&#39;;" id="ctl00_exitfullscreenmodeBtn" title="Focus on Content" onclick="SetFullScreenMode(false);PreventDefaultNavigation();return false;" href="../../../../_catalogs/masterpage/#" style="display:inline-block;height:30px;width:30px;"><span style="display:inline-block;overflow:hidden;height:16px;width:16px;padding-left:7px;padding-top:7px;padding-right:7px;padding-bottom:7px;"><span style="height:16px;width:16px;position:relative;display:inline-block;overflow:hidden;" class="s4-clust"><img src="/_layouts/15/images/spcommon.png?rev=43#ThemeKey=spcommon" alt="Focus on Content" style="border:0;position:absolute;left:-107px;top:-178px;" /></span></span></a>
                                                </span>
                                            </span>
                                            
                                            
                                        </div></div></div></div></div>
                                
</div>
                            </div>
                            <span id="DeltaSPNavigation">
                                
									<span id="ctl00_SPNavigation_ctl00_publishingRibbon"></span>

                                
                            </span>
                        </div>
                        <div id="DeltaWebPartAdderUpdatePanelContainer" class="ms-core-webpartadder">
	
                            <div id="WebPartAdderUpdatePanelContainer">
                                <div id="ctl00_WebPartAdderUpdatePanel">
		
										<span id="ctl00_WebPartAdder"></span>
									
	</div>
                            </div>
                        
</div>
                    </div>
                </div>

         

            <div id="s4-workspace" class="ms-core-overlay">
                <div id="s4-bodyContainer">
                    <div id="s4-titlerow" class="ms-dialogHidden s4-titlerowhidetitle d-none">
                        <div id="titleAreaBox" class="ms-noList ms-table ms-core-tableNoSpace">
                            <div id="titleAreaRow" class="ms-tableRow">
                                <div class="ms-breadcrumb-box ms-tableCell ms-verticalAlignTop">
                                    <div class="ms-breadcrumb-top">
                                        <div class="ms-breadcrumb-dropdownBox" style="display:none;">
                                            <span id="DeltaBreadcrumbDropdown">
                                                
                                            </span>
                                        </div>
                                        <div id="DeltaTopNavigation" class="ms-displayInline ms-core-navigation" role="navigation">
	
                                            
                                            
												<div id="zz1_TopNavigationMenu" class=" noindex ms-core-listMenu-horizontalBox">
		<ul id="zz2_RootAspMenu" class="root ms-core-listMenu-root static">
			<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" title="Home" href="/default.aspx" accesskey="1"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Bank Indonesia</span><span class="ms-hidden">Currently selected</span></span></a></li>
		</ul>
	</div>
                                            
                                        
</div>
                                    </div>
                                    <h1 id="pageTitle" class="ms-core-pageTitle">
                                        <span id="DeltaPlaceHolderPageTitleInTitleArea">
                                            
												Foreign Exchange Rates
                                            
                                        </span>
                                        <div id="DeltaPlaceHolderPageDescription" class="ms-displayInlineBlock ms-normalWrap">
	
                                            <a href="javascript:;" id="ms-pageDescriptionDiv" style="display:none;"
                                                data-accessibility-nocheck="true">
                                                <span id="ms-pageDescriptionImage">&#160;</span>
                                            </a>
                                            <span class="ms-accessible" id="ms-pageDescription">
                                                
                                            </span>
                                            <script type="text/javascript">// <![CDATA[ 

_spBodyOnLoadFunctionNames.push("setupPageDescriptionCallout");
										
										 // ]]>
</script>
                                        
</div>
                                    </h1>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                    <div id="DeltaPlaceHolderGroupActionsArea" class="ms-floatRight ms-noWrap">
	
                                        
                                    
</div>
                                </div>
                                <div class="ms-tableCell ms-verticalAlignTop">
                                </div>
                            </div>
                        </div>
                    </div>

                    <header class="ms-dialogHidden mega-menu-wrapper noindex">
                        <div class="top-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                        
                                
<div id="ctl00_g_9675ef44_8939_42e2_aefd_df1b1e975487" __MarkupType="vsattributemarkup" __WebPartId="{9675ef44-8939-42e2-aefd-df1b1e975487}" WebPart="true">
	
        <ul class="header-menu navbar-nav">
            
        <li class="nav-item"><a href='https://www.bi.go.id/en/karier' >Career</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/edukasi' >Education</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/glosarium.aspx' >Glossary</a></li>       
    
        <li class="nav-item"><a href='https://www.bi.go.id/en/peta-situs.aspx' >Sitemap</a></li>       
    
        </ul>
    

</div>
                                        
                                
                                    <div id="DeltaPlaceHolderSearchArea" class="ms-mpSearchBox clearfix">
	
                                        
											<div id="searchInputBox">
                                                <div class="ms-webpart-chrome ms-webpart-chrome-fullWidth ">
		<div WebPartID="00000000-0000-0000-0000-000000000000" HasPers="true" id="WebPartWPQ1" width="100%" class="ms-WPBody " OnlyForMePart="true" allowDelete="false" style="" ><div componentid="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"><div id="SearchBox" name="Control"><div class="ms-srch-sb ms-srch-sb-border" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv"><input type="search" value="Search this site" maxlength="2048" title="Search this site" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox" autocomplete="off" autocorrect="off" onkeypress="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {if (Srch.U.isEnterKey(String.fromCharCode(event.keyCode))) {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);return Srch.U.cancelEvent(event);}})" onkeydown="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.activateDefaultQuerySuggestionBehavior();})" onfocus="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr');ctl.hidePrompt();ctl.setBorder(true);})" onblur="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {var ctl = $find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr'); if (ctl){ ctl.showPrompt(); ctl.setBorder(false);}})" class="ms-textSmall ms-srch-sb-prompt ms-helperText" role="combobox" aria-owns="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" aria-haspopup="true" aria-autocomplete="list" aria-expanded="false" /><a title="Search" role="button" class="ms-srch-sb-searchLink" id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink" onclick="EnsureScriptFunc('Search.ClientControls.js', 'Srch.U', function() {$find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr').search($get('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox').value);})" href="javascript: {}" aria-label="Search"><img src="/_layouts/15/images/searchresultui.png?rev=43#ThemeKey=searchresultui" class="ms-srch-sb-searchImg" id="searchImg" alt="Search" /></a><div class="ms-qSuggest-container ms-shadow" id="AutoCompContainer"><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList" role="listbox" aria-label="Suggestions"></div></div></div></div></div><noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_noscript">It looks like your browser does not have JavaScript enabled. Please turn on JavaScript and try again.</div></noscript><div id="ctl00_PlaceHolderSearchArea_SmallSearchInputBox1">

		</div><div class="ms-clear"></div></div>
	</div>
                                            </div>
                                        
                                    
</div>

                                    <div id="bahasa-indon" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="ENLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>
                                    <div id="bahasa-english" class="navbar-language">
                                        <a class="navbar-language__item indo" id="" href="#"><img
                                                src="/Style Library/biweb/img/flag-eng.png" width="26" /></a>
                                        <a class="navbar-language__item englishnya" id="IDLang" href="#" ><img
                                                src="/Style Library/biweb/img/flag-indo.png" width="26" /></a>
                                        <span class="arrow-down"></span>
                                    </div>


                                </nav>
                            </div>
                        </div>
                        <div class="bottom-navbar">
                            <div class="container">
                                <nav class="navbar navbar-expand-md navbar-light">
                                    <div id="siteIcon" class="ms-tableCell ms-verticalAlignTop">
                                        <div id="DeltaSiteLogo">
	
                                            <a id="ctl00_onetidProjectPropertyTitleGraphic" class="ms-siteicon-a" href="/id/"><img id="ctl00_onetidHeadbnnr2" class="ms-siteicon-img" name="onetidHeadbnnr0" src="/SiteAssets/logo-bi@2x.png" alt="Foreign Exchange Rates" /></a>
                                        
</div>
                                    </div>

                                    <button class="navbar-toggler" type="button" data-toggle="collapse"
                                        data-target="#navbarSupportedContent" aria-controls="navbarSupportedContent"
                                        aria-expanded="false" aria-label="Toggle navigation">
                                        <span class="navbar-toggler-icon"></span>
                                    </button>
                                    
                                    <div class="collapse navbar-collapse navbar-responsive" id="navbarSupportedContent">
										<div class="noindex">
	                                        <div id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7" __MarkupType="vsattributemarkup" __WebPartId="{3e01a6ba-0414-4f22-b082-8b109c19b6c7}" WebPart="true">
	

<ul class="top-menu navbar-nav" id="test-menu">           
    <li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/tentang-bi/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>About BI</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/tentang-bi/profil/Default.aspx'>Profile</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/tentang-bi/profil/organisasi/Default.aspx' > Organization</a></li><li class='level3'><a href = '/en/tentang-bi/profil/governance/default.aspx' >Governance</a></li><li class='level3'><a href = '/en/tentang-bi/profil/uu-bi/Default.aspx' >Regulations</a></li></ul><li><a href = '/en/tentang-bi/sejarah-bi/Default.aspx'> History </a ></li><li><a href = '/en/tentang-bi/transformasi/Default.aspx'> Transformation </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/tentang-BI_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>About BI</p>
                        <p class='dropdown-megamenu__about--description'>Information about the organisation, transformation and history of Bank Indonesia as the central bank of the Republic of Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/fungsi-utama/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Main Functions</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/moneter/Default.aspx'>Monetary</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/moneter/inflasi/Default.aspx' >Inflation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indikator-moneter/default.aspx' >Monetary Indicator</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/bi-rate/default.aspx' >BI-Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/operasi-moneter/Default.aspx' >Monetary Operation</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/indonia-jibor/Default.aspx' >INDONIA, Compounded INDONIA, INDONIA Index and JIBOR</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/informasi-kurs/default.aspx' >JISDOR, Non-USD/IDR Reference Rate, and Transaction Rate</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/fungsi-utama/moneter/pengembangan-ekonomi/Default.aspx' >Sharia Economy and Financial</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/'>Financial System Stability</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/ikhtisar/' >Overview</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/instrumen-makroprudensial/default.aspx' >Macroprudential Policy Instrument</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/manajemen-krisis/default.aspx' >Crisis Management Protocol</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/koordinasi-bi-lainnya/' >Institutional Coordination</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/pengembangan-umkm/' >MSME Development</a></li><li class='level3'><a href = '/en/fungsi-utama/stabilitas-sistem-keuangan/keuangan-inklusif/' >Financial Inclusion</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/fungsi-utama/sistem-pembayaran'>Payment System and Rupiah Currency Management</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/nilai-besar/' >High Value Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/ritel/' >Retail Payment System</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/pengelolaan-rupiah/default.aspx' >Rupiah Currency Management</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/perizinan/default.aspx' >Licensing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/anti-pencucian-uang-dan-pencegahan-pendanaan-terrorisme/' >Anti-Money Laundering and Counter-Terrorism Financing</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/Standardisasi-Kompetensi/Default.aspx' >Standardisation Of HR Competencies</a></li><li class='level3'><a href = '/en/fungsi-utama/sistem-pembayaran/blueprint/default.aspx' >Indonesia Payment System Blueprint</a></li></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Style Library/biweb/img/bi-photo.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Main Functions</p>
                        <p class='dropdown-megamenu__about--description'>Information about the main functions and responsibilities of Bank Indonesia to achieve and maintain rupiah stability.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/rupiah/' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Rupiah</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/rupiah/gambar-uang/Default.aspx'> Currency Image </a ></li><li><a href = '/en/rupiah/uang-dicabut/'> Withdrawn Currency </a ></li><li><a href = '/en/rupiah/pencegahan-rupiah-palsu/'> Counterfeit Prevention and Management </a ></li><li><a href = '/en/rupiah/cinta-bangga-paham-rupiah/default.aspx'> Cinta, Bangga, Paham Rupiah </a ></li><li><a href = '/en/rupiah/digital-rupiah/default.aspx#overview'> Project Garuda: Digital Rupiah </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/rupiah_v2.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Rupiah</p>
                        <p class='dropdown-megamenu__about--description'>Information about the rupiah as the currency of the Republic of Indonesia managed by Bank Indonesia pursuant to prevailing laws and regulations.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/publikasi/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Publications</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='#'>Media Room</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/ruang-media/news-release/' >Latest News (Press Release)</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/cerita-bi/' >Story</a></li><li class='level3'><a href = '/en/publikasi/ruang-media/pidato-dewan-gubernur/' >Board of Governor Speeches</a></li></ul><li><a href = '/en/publikasi/Kalender/'> Calendar </a ></li><li><a href = '/en/publikasi/peraturan/'> Regulation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/publikasi/lelang/'>Transaction</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/publikasi/lelang/operasi-moneter/' >Monetary Operation</a></li></ul><li><a href = '/en/publikasi/laporan/'> Report </a ></li><li><a href = '/en/publikasi/kajian/'> Review </a ></li><li><a href = '/en/publikasi/lain/default.aspx'>  Other Publications </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/publikasi.jpg?csf=1&e=QrfjCa&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Publications</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia’s publications include regulations, reports and papers, as well as the calendar of activities</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/statistik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Statistics</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/id/statistik/sdds'> Special Data Dissemination Standard (SDDS) </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/ekonomi-keuangan/seki/Default.aspx'>Financial Statistics</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/seki/Default.aspx' >Indonesian Economic and Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/items/Default.aspx' >Monetary and Payment System Selected Indicators</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sekda/Default.aspx' >The Regional Economic Financial Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sulni/Default.aspx' >Indonesia External Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/sski/default.aspx' >Indonesia Financial System Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/suspi/default.aspx' >Indonesia Public Sector Debt Statistics</a></li><li class='level3'><a href = '/en/statistik/ekonomi-keuangan/spip/Default.aspx' >Payment System and Financial Market Infrastructure Statistics</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/statistik/informasi-kurs/jisdor'>Foreign Exchange Rate</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/statistik/informasi-kurs/jisdor' >JISDOR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi' >Bank Indonesia Foreign Exchange Transaction Rates</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/kurs-acuan-non-usd-idr/' >Reference Rate for Non-USD/IDR</a></li><li class='level3'><a href = '/en/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx' >Calculator</a></li></ul><li><a href = '/en/statistik/indikator'> Indicators </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/Statistik.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Statistics</p>
                        <p class='dropdown-megamenu__about--description'>Statistics include historical indicators for all sectors under the jurisdiction of Bank Indonesia.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/layanan/default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Services</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/layanan/permintaan-informasi/default.aspx'> Information Request </a ></li><li><a href = '/en/layanan/pengaduan-konsumen'> Consumer Protection and Complaints </a ></li><li><a href = '/en/layanan/elicensing/default.aspx'>  E-Licensing </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/informasi-perizinan/default.aspx'>Licensed Institutions</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/informasi-perizinan/pasar-keuangan/default.aspx' >Money Market</a></li><li class='level3'><a href = '/en/layanan/informasi-perizinan/sistem-pembayaran/default.aspx' >Payment System and Rupiah Currency Management</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/perpustakaan/'>Library</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/perpustakaan/koleksi-buku/' >Book Collection</a></li></ul><li><a href = '/en/layanan/kas-bi/'> Bank Indonesia Cash Service </a ></li><li><a href = '/en/layanan/lelang-jasa-barang/'> Goods and Services Auction </a ></li><li><a href = '/en/layanan/kunjungan-bi/default.aspx'> Visitation </a ></li><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/museum-bi/'>Museum</a><span class='caret'></span></div><ul class='dropdown-megamenu__submenu-list'><li class='level3'><a href = '/en/layanan/museum-bi/koleksi-museum' >Museum Collection</a></li><li class='level3'><a href = '/en/layanan/museum-bi/program-informasi/default.aspx' >Museum Program and Information</a></li></ul><li class='dropdown-megamenu__submenu'><div class='clearfix'><a class='dropdown-toggle' href='/en/layanan/Standar/SNAP/default.aspx'>Payment System Standard - Open API</a></div><ul class='dropdown-megamenu__submenu-list'></ul></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/layanan.jpg&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Services</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia offers various services, including requests for information, complaints, licensing and so on.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li><li class='nav-item dropdown'>
      <a class='nav-link dropdown-toggle' href='/en/informasi-publik/Default.aspx' id='navbarDropdownStatistik' role='button' data-toggle='dropdown' aria-haspopup='true' aria-expanded='false'>Public Information</a>
    <div class='dropdown-menu dropdown-megamenu' aria-labelledby='navbarDropdownStatistik'>
        <div class='container'>
            <div class='d-md-flex'>
                <div class='dropdown-megamenu__column pr-md-4'> 
                    <div class='dropdown-megamenu__column--wrapper'>
                        <ul class='dropdown-megamenu__menu'><li><a href = '/en/informasi-publik/profil-ppid/Default.aspx'> Profile </a ></li><li><a href = '/en/informasi-publik/dasar-hukum'> Regulation </a ></li><li><a href = '/en/informasi-publik/informasi-publik/Default.aspx'> List of Public Information </a ></li><li><a href = '/en/informasi-publik/layanan-informasi/Default.aspx'> Information Service </a ></li><li><a href = '/en/informasi-publik/berita-ppid/Default.aspx'> News </a ></li></ul>
                    </div>
                </div>
                <div class='dropdown-megamenu__column pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'> 
                                            </div>
                </div>
                <div class='dropdown-megamenu__column dropdown-megamenu__about pl-md-4'>
                    <div class='dropdown-megamenu__column--wrapper'>
                        <div class='dropdown-megamenu__about--thumbnail mb-2' style='background-image:url(&quot;/Menu%20Image/informasi-publik.png&quot;)'></div>
                        <p class='dropdown-megamenu__about--title'>Public Information</p>
                        <p class='dropdown-megamenu__about--description'>Bank Indonesia maintains public information in accordance with the Public Information Disclosure Act of 2008.</p>
                    </div>
                </div>
            </div>
        </div>
    </div>
</li>
</ul>
<span id="ctl00_g_3e01a6ba_0414_4f22_b082_8b109c19b6c7_ctl00_LabelDebug"></span>    
 

</div>
                                        </div>
                                    </div>
                                </nav>
                            </div>
                        </div>

                    </header>
                    <div class="menu-overlay"></div>

                    <div id="contentRow">
                        <div id="sideNavBox" role="Navigation" class="ms-dialogHidden ms-forceWrap ms-noList">
                            <div id="DeltaPlaceHolderLeftNavBar" class="ms-core-navigation" role="navigation">
	
                                
									
                                    <a id="startNavigation" name="startNavigation" tabIndex="-1"></a>
                                    
                                    
                                    
                                    
                                    
                                    <div class="ms-core-sideNavBox-removeLeftMargin">
                                        <div id="ctl00_PlaceHolderLeftNavBar_QuickLaunchNavigationManager">
		<div id="zz3_V4QuickLaunchMenu" class=" noindex ms-core-listMenu-verticalBox">
			<ul id="zz4_RootAspMenu" class="root ms-core-listMenu-root static">
				<li class="static selected"><a class="static selected menu-item ms-core-listMenu-item ms-displayInline ms-core-listMenu-selected ms-navedit-linkNode" href="/"><span class="additional-background ms-navedit-flyoutArrow"><span class="menu-item-text">Recent</span><span class="ms-hidden">Currently selected</span></span></a></li>
			</ul>
		</div>
	</div>
                                        
                                        
											<div class="ms-core-listMenu-verticalBox">
                                                
                                            </div>
                                            
                                        
                                    </div>
                                    
                                
                            
</div>
                        </div>
                        <div id="contentBox" aria-live="polite" aria-relevant="all" role="main">
                            <a id="mainContent" name="mainContent" tabindex="-1"></a>
                            <div id="notificationArea" class="ms-notif-box"></div>
                            <div id="DeltaPageStatusBar">
	
                                <div id="pageStatusBar"></div>
                            
</div>
                            <div id="DeltaPlaceHolderTop">
	
                                <div class="noindex">
                                	
	<div id="ctl00_PlaceHolderTop_g_717976cb_8b48_4283_98d0_c1ff5d699b5d" __MarkupType="vsattributemarkup" __WebPartId="{717976cb-8b48-4283-98d0-c1ff5d699b5d}" WebPart="true">
		

<div class="top-banner">
    <div class="container">
        <nav aria-label="breadcrumb">
            <ol class="breadcrumb color">
                
                        
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en">Home </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik">Statistics </a>
                        </li>
                    
                        <li class="breadcrumb-item color-white">
                            <a href="https://www.bi.go.id/en/statistik/informasi-kurs">Foreign Exchange Rate </a>
                        </li>
                    
                    
                <li class="breadcrumb-item color-white" aria-current="page">
                    Foreign Exchange Rates
                </li>
            </ol>
        </nav>
        <h1 class="top-banner__title"> Foreign Exchange Rates</h1>
    </div>
    <div class="top-banner__overlay"></div>
</div>



<div style="display:none;">
    Start;Home;Statistics;Foreign Exchange Rate;bukan default.aspx
</div>

	</div>

                                </div>
                            
</div>

                            <div class="container">
								 <a id="button-back-to-top"><img src="/Style Library/biweb/img/ico_back-to-top.svg" alt=""/></a>
                                <div id="DeltaPlaceHolderMain">
	
                                    
<div id="content-wrapper" class="content-text">                
		<h2>EXCHANGE RATES ON TRANSACTION</h2>
		<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf" __MarkupType="vsattributemarkup" __WebPartId="{6C89D4AD-107F-437D-BD54-8FDA17B556BF}" WebPart="true" partorder="2">
		


<script type="text/javascript" src="/Style Library/biweb/js/jquery-ui-1.12.1.min.js"></script>


<script type="text/javascript" src="/Style Library/biweb/js/jquery.cookie.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/Chart.min.js"></script>
<script type="text/javascript" src="/Style Library/biweb/js/html2canvas.min.js"></script>
<link rel="stylesheet" href="/Style Library/biweb/css/jquery-ui.css" />

<link rel="stylesheet" href="/Style Library/biweb/css/bootstrap-datepicker3.min.css">
<script type="text/javascript" src="/Style Library/biweb/js/bootstrap-datepicker.min.js"></script>

<script type="text/javascript"> 
    var myApp = new function () {
        this.printTable = function () {
            var tab = document.getElementById('tableData');
            var win = window.print('', '', 'height=700,width=700');
            win.document.write(tab.outerHTML);
            win.document.close();
            win.print();
        }
    }
</script>

<style>

</style>

<script type="text/javascript">
    //////chart

    var getMataUang = "";
    var arrayValueDate = [];
    var arrayValueKurs = [];
    console.log(arrayValueDate);
    console.log(arrayValueKurs);
    window.onload = function () {
        var ctx = document.getElementById("myChart").getContext("2d");
        console.log(ctx);
        var data = {
            labels: arrayValueDate,
            datasets: [{
                label: "Kurs Transaksi",
                data: arrayValueKurs,
                borderColor: "blue",
                lineTension: 0
            }]
        };

        var myLineChart = new Chart(ctx, {
            type: 'line',
            data: data,
            options: {
                legend: {
                    display: false,
                    labels: {
                        display: false
                    }
                },
                title: {
                    display: true,
                    text: 'Kurs Transaksi (Exchange Rates on Transaction) - ' + getMataUang
                },
                responsive: true,
                maintainAspectRatio: false,
                tooltips: {
                    callbacks: {
                        label: function (t, d) {
                            if (url.toLowerCase().indexOf("/id/") !== -1) {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".") : "Rp " + t.yLabel;
                            }
                            else {
                                var yLabel = t.yLabel >= 1000 ? "Rp " + t.yLabel.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",") : "Rp " + t.yLabel;
                            }
                            return yLabel;
                        }
                    }
                },
                scales: {
                    xAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Source Bank Indonesia'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10
                        },

                    }],
                    yAxes: [{
                        gridLines: {
                            display: false
                        },
                        display: true,
                        scaleLabel: {
                            display: true,
                            fontColor: 'blue',
                            fontSize: 10,
                            labelString: 'Rupiah'
                        },
                        ticks: {
                            fontColor: "blue",
                            fontSize: 10,
                            callback: function (value, index, values) {
                                if (parseInt(value) >= 1000) {
                                    if (url.toLowerCase().indexOf("/id/") !== -1) {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ".");
                                    }
                                    else {
                                        return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
                                    }

                                } else {
                                    return value;
                                }
                            }
                        }
                    }]
                }
            }
        });

        window.addEventListener('resize', function () {
            myLineChart.resize()
        })
    }
    function setFormSubmitToFalse() {
        setTimeout(function () { _spFormOnSubmitCalled = false; }, 1000);
        return true;
    }
</script>

<script type="text/javascript">

    $(document).ready(function () {
        url = window.location.href;

        

        if (url.toLowerCase().indexOf("/id/") !== -1) {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);

        }
        else {
            

            var date_range_from = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_from.datepicker(options);

            

            var date_range_to = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo');
            var options = {
                format: 'dd-M-yyyy',
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_range_to.datepicker(options);

            

            var date_input_harian = $('#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal');
            var options = {
                format: "dd-M-yyyy",
                container: '#s4-bodyContainer',
                todayHighlight: true,
                autoclose: true,
                orientation: "bottom auto",
                endDate: '+0d',
            };
            date_input_harian.datepicker(options);
        }


        if (url.toLowerCase().indexOf("/id/") !== -1) {
            var dialogSingkatan = "Code of Currency";
            $(".btn[id$='_btnGraphImage']").prop("value", "Lihat");
            $(".btn[id$='_ButtonExport']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Unduh");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Unduh");
        }
        else {
            var dialogSingkatan = "Kode Singkatan";
            $(".btn[id$='_btnGraphImage']").prop("value", "View");
            $(".btn[id$='_ButtonExport']").prop("value", "Download");
            $(".btn[id$='_ButtonExportRange']").prop("value", "Download");
            $(".btn[id$='_ButtonExportDaily']").prop("value", "Download");
            $("#linkId").attr("href", "/en/statistik/informasi-kurs/transaksi-bi/Default.aspx");
            $("#exampleModalLabel").text("Currency Code");
        }

        $("#KodeSingkatan").dialog({
            autoOpen: false,
            show: "blind",
            width: "240",
            height: "500",
            hide: "explode",
            title: dialogSingkatan
        });

        $("#linkSingkatan1").click(function () {
            $("#KodeSingkatan").dialog("open");
            return false;
        });



        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Masukkan periode awal dan akhir dengan benar');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Periode tanggal awal tidak valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('Periode tanggal akhir tidak valid');
                        return false;
                    }

                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val() == "" || $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val() == "") {
                    alert('Input start date and end date correctly');
                    return false;
                }
                else {

                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom").val(), "d-MMM-yy")) {
                        alert('Start date is not valid');
                        return false;
                    }
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo").val(), "d-MMM-yy")) {
                        alert('End date is not valid');
                        return false;
                    }

                }
            }
            

        });

        $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2").click(function () {
            if (url.toLowerCase().indexOf("/id/") !== -1) {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Masukkan periode dengan benar');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Periode tanggal tidak valid');
                        return false;
                    }
                }
            }
            else {
                if ($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val() == "") {
                    alert('Input period correctly');
                    return false;
                }
                else {
                    if (!isValidDate($("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal").val(), "d-MMM-yy")) {
                        alert('Period is not valid');
                        return false;
                    }
                }
            }
            
        });

    });

    function SetSource(SourceID) {
        var hideSourceID = $("#ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID");
        hideSourceID.val(SourceID);
    }

    // function validation 
    function isValidDate(val, format) {
        try {
            var newDate = val.split("-")[0];
            var newMonth = val.split("-")[1];
            var newYear = val.split("-")[2];

            if (newYear.length == 2 || newYear.length == 4) {
                if (newYear.length == 4) { newYear = newYear.substring(2, 4); }
            }
            else {
                return false;
            }

            var date = getDateFromFormat(newDate + '-' + newMonth + '-' + newYear, format);
            if (date == 0) { return false; }
            return true;
        }
        catch (ex) {
            return false;
        }
    }

    var MONTH_NAMES = new Array('January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December', 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec', 'Januari', 'Februari', 'Maret', 'April', 'Mei', 'Juni', 'Juli', 'Agustus', 'September', 'Oktober', 'November', 'Desember', 'Jan', 'Feb', 'Mar', 'Apr', 'Mei', 'Jun', 'Jul', 'Ags', 'Sep', 'Okt', 'Nov', 'Des');
    var DAY_NAMES = new Array('Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat');
    function LZ(x) { return (x < 0 || x > 9 ? "" : "0") + x }
    function getDateFromFormat(val, format) {
        val = val + "";
        format = format + "";
        var i_val = 0;
        var i_format = 0;
        var c = "";
        var token = "";
        var token2 = "";
        var x, y;
        var now = new Date();
        var year = now.getYear();
        var month = now.getMonth() + 1;
        var date = 1;
        var hh = now.getHours();
        var mm = now.getMinutes();
        var ss = now.getSeconds();
        var ampm = "";

        while (i_format < format.length) {
            c = format.charAt(i_format);
            token = "";
            while ((format.charAt(i_format) == c) && (i_format < format.length)) {
                token += format.charAt(i_format++);
            }
            if (token == "yyyy" || token == "yy" || token == "y") {
                if (token == "yyyy") { x = 4; y = 4; }
                if (token == "yy") { x = 2; y = 2; }
                if (token == "y") { x = 2; y = 4; }
                year = _getInt(val, i_val, x, y);
                if (year == null) { return 0; }
                i_val += year.length;
                if (year.length == 2) {
                    if (year > 70) { year = 1900 + (year - 0); }
                    else { year = 2000 + (year - 0); }
                }
            }
            else if (token == "MMM" || token == "NNN") {
                month = 0;
                for (var i = 0; i < MONTH_NAMES.length; i++) {
                    var month_name = MONTH_NAMES[i];
                    if (val.substring(i_val, i_val + month_name.length).toLowerCase() == month_name.toLowerCase()) {
                        if (token == "MMM" || (token == "NNN" && i > 11)) {
                            month = i + 1;
                            if (month > 24) { month -= 24; }
                            if (month > 12) { month -= 12; }
                            i_val += month_name.length;
                            break;
                        }
                    }
                }
                if ((month < 1) || (month > 12)) { return 0; }
            }
            else if (token == "EE" || token == "E") {
                for (var i = 0; i < DAY_NAMES.length; i++) {
                    var day_name = DAY_NAMES[i];
                    if (val.substring(i_val, i_val + day_name.length).toLowerCase() == day_name.toLowerCase()) {
                        i_val += day_name.length;
                        break;
                    }
                }
            }
            else if (token == "MM" || token == "M") {
                month = _getInt(val, i_val, token.length, 2);
                if (month == null || (month < 1) || (month > 12)) { return 0; }
                i_val += month.length;
            }
            else if (token == "dd" || token == "d") {
                date = _getInt(val, i_val, token.length, 2);
                if (date == null || (date < 1) || (date > 31)) { return 0; }
                i_val += date.length;
            }
            else if (token == "hh" || token == "h") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 12)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "HH" || token == "H") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 23)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "KK" || token == "K") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 0) || (hh > 11)) { return 0; }
                i_val += hh.length;
            }
            else if (token == "kk" || token == "k") {
                hh = _getInt(val, i_val, token.length, 2);
                if (hh == null || (hh < 1) || (hh > 24)) { return 0; }
                i_val += hh.length; hh--;
            }
            else if (token == "mm" || token == "m") {
                mm = _getInt(val, i_val, token.length, 2);
                if (mm == null || (mm < 0) || (mm > 59)) { return 0; }
                i_val += mm.length;
            }
            else if (token == "ss" || token == "s") {
                ss = _getInt(val, i_val, token.length, 2);
                if (ss == null || (ss < 0) || (ss > 59)) { return 0; }
                i_val += ss.length;
            }
            else if (token == "a") {
                if (val.substring(i_val, i_val + 2).toLowerCase() == "am") { ampm = "AM"; }
                else if (val.substring(i_val, i_val + 2).toLowerCase() == "pm") { ampm = "PM"; }
                else { return 0; }
                i_val += 2;
            }
            else {
                if (val.substring(i_val, i_val + token.length) != token) { return 0; }
                else { i_val += token.length; }
            }
        }
        if (i_val != val.length) { return 0; }
        if (month == 2) {
            if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) {
                // leap year
                if (date > 29) { return 0; }
            }
            else { if (date > 28) { return 0; } }
        }
        if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
            if (date > 30) { return 0; }
        }
        if (hh < 12 && ampm == "PM") { hh = hh - 0 + 12; }
        else if (hh > 11 && ampm == "AM") { hh -= 12; }
        var newdate = new Date(year, month - 1, date, hh, mm, ss);
        return newdate.getTime();
    }

    function _isInteger(val) {
        var digits = "1234567890";
        for (var i = 0; i < val.length; i++) {
            if (digits.indexOf(val.charAt(i)) == -1) { return false; }
        }
        return true;
    }

    function _getInt(str, i, minlength, maxlength) {
        for (var x = maxlength; x >= minlength; x--) {
            var token = str.substring(i, i + x);
            if (token.length < minlength) { return null; }
            if (_isInteger(token)) { return token; }
        }
        return null;
    }

    function download() {
        //if (!isChartRendered) return; // return if chart not rendered
        html2canvas(document.getElementById('chart-container'), {
            onrendered: function (canvas) {
                if (canvas.msToBlob) { //for IE
                    var blob = canvas.msToBlob();
                    window.navigator.msSaveBlob(blob, 'BIexchangeRates.jpeg');
                }
                else {
                    var link = document.createElement('a');
                    link.href = canvas.toDataURL('image/jpeg');
                    link.download = 'BIexchangeRates.jpeg';
                    link.click();
                }
            }
        })
    }

</script>


<div class="card-block" id="tableData">
    <div class="card-body">

       

        
        <div class="row datepicker-period" id="harian" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        Daily</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTanggal" type="text" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTanggal" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch2" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch2" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
            
            
        </div>
        <div class="row datepicker-period" id="range" style='display: none;'>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        From</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtFrom" type="text" value="01-Mar-2026" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtFrom" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <div class="sidebar__list input-daterange">
                    <label class="label-custom mb-1">
                        To</label>
                    <div class="input-wrapper mb-3" style="margin-top: 10px">
                        <input name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$txtTo" type="text" value="05-Mar-2026" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_txtTo" class="form-control mr-sm-2 text-left" placeholder="dd-mm-yyyy" autocomplete="off" />
                        <i class="far fa-calendar-alt input-icon"></i>
                    </div>
                </div>
            </div>
            <div class="col-lg-4">
                <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$btnSearch1" value="Search" onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_btnSearch1" class="btn btn-primary" AutoPostBack="True" style="margin-top: 31px" />
            </div>
        </div>
        <div>
            
            
            <div class="row">
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        <div class="search-box-wrapper text-left">
                            Last Update&nbsp;<span>2 April 2026</span>
                        </div>
                    </div>
                </div>
                <div class="col-12 col-md-6">
                    <div class="form-group">
                        
                        <div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_printRange" class="search-box-wrapper text-right">
                            <input type="button" value="Print Table" onclick="myApp.printTable()" class="btn btn-secondary btn-icon btn-icon__print" />
                            <input type="submit" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$ButtonExportRange" value="Unduh" onclick="javascript:setFormSubmitToFalse();" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_ButtonExportRange" class=" btn btn-primary btn-export" />
                        </div>
                        
                    </div>
                </div>                
            </div>
            
        </div>
    </div>

</div>

<input type="hidden" name="ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$hidSourceID" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_hidSourceID" />

<div id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_kursTable1">
    <div class="d-flex justify-content-end mr-4">
        <a id="linkId" class="btn" style="color: white; background: #045498;" href="/id/statistik/informasi-kurs/transaksi-bi/Default.aspx">
            Back</a>
    </div>
    <div style="text-align: center; font-weight: bold;">
        <span id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_Label10">EXCHANGE RATES ON TRANSACTION</span>
        <br />
        <span id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_lblKursTransaksiKTBI2" class="font-weight-bold">CURRENCIES BND  </span>
        <br />
        <a onclick="SetSource(this.id);" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_lnkGrafik" href="javascript:__doPostBack(&#39;ctl00$PlaceHolderMain$g_6c89d4ad_107f_437d_bd54_8fda17b556bf$ctl00$lnkGrafik&#39;,&#39;&#39;)">Grafik Time Series</a>
        <br />
        <div class="container">
            <div class="page-table table-responsive page-table--bordered mb-3">
                <div>

		</div>
                <div>
			<table class="table table-striped table-no-bordered table-lg" cellspacing="0" rules="all" border="1" id="ctl00_PlaceHolderMain_g_6c89d4ad_107f_437d_bd54_8fda17b556bf_ctl00_gvSearchResult2" style="border-collapse:collapse;">
				<tr>
					<th class="borderLeft" scope="col" style="color:White;background-color:#045498;">Value</th><th class="borderLeft" scope="col" style="color:White;background-color:#045498;">Sell</th><th scope="col" style="color:White;background-color:#045498;">Buy</th><th scope="col" style="color:White;background-color:#045498;">Date</th>
				</tr><tr>
					<td>1.00</td><td>13,315.23</td><td>13,173.44</td><td>5 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>13,290.23</td><td>13,151.81</td><td>4 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>13,312.56</td><td>13,171.81</td><td>3 Mar 2026</td>
				</tr><tr>
					<td>1.00</td><td>13,337.74</td><td>13,197.71</td><td>2 Mar 2026</td>
				</tr>
			</table>
		</div>
            </div>
        </div>
    </div>
</div>

<div id="myChartWrapper" style="width: 100%; height: 100%; display: none">
    <div id="chart-container">
        <canvas id="myChart" width="500" height="400"></canvas>
    </div>
    <div class="text-right my-3">
        <button class="btn btn-primary" onclick="download()">Save Chart</button>
    </div>
</div>




	</div>
		<div id="accordion" style="display:none">
		
                    <div class="card">
                        <div class="card-header" id="headingOne">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseOne" href="#headingOne"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Tentang JISDOR</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseOne" class="collapse" aria-labelledby="headingOne" data-parent="#accordion">
                            <div class="card-block">
                                <div class="card-body">
                                    <div class="content-text-subtitle">
                                        <p>Penjelasan JISDOR</p>
                                    </div>
                                    <ol>

                                        <menu class="ms-hide">
		<ie:menuitem id="MSOMenu_Help" iconsrc="/_layouts/15/images/HelpIcon.gif" onmenuclick="MSOWebPartPage_SetNewWindowLocation(MenuWebPart.getAttribute('helpLink'), MenuWebPart.getAttribute('helpMode'))" text="Help" type="option" style="display:none">

		</ie:menuitem>
	</menu>


                                        
                                        


                                    </ol>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header" id="headingTwo">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a data-toggle="collapse" data-target="#collapseTwo" href="#headingTwo"
                                        class="collapsed state-accordion">
                                        <i class="fa fa-angle-up" aria-hidden="true"></i>
                                        <div class="color-gray">
                                            <p>Penjelasan Kurs Transaksi</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        <div id="collapseTwo" class="collapse" aria-labelledby="headingTwo" data-parent="#accordion">
                            
                        </div>
                    </div>

                    <div class="card">
                        <div class="card-header">
                            <div class="mb-0 row">
                                <div class="col-12 no-padding accordion-head">
                                    <a href="/id/statistik/informasi-kurs/transaksi-bi/kalkulator-kurs.aspx"
                                        class="collapsed">
                                        <div class="color-gray">
                                            <p>Kalkulator Kurs</p>
                                        </div>
                                    </a>
                                </div>
                            </div>
                        </div>
                        
                    </div>
                </div>
            </div>
        
<div style='display:none' id='hidZone'></div>
                                
</div>
                            </div>
                            <div id="DeltaPlaceHolderBottom">
	
                                <div class="noindex">
                                
	<div id="ctl00_PlaceHolderBottom_g_e3052be3_673c_405e_9cbe_a883a244c053" __MarkupType="vsattributemarkup" __WebPartId="{e3052be3-673c-405e-9cbe-a883a244c053}" WebPart="true">
		

<script type="text/javascript">
    $(document).ready(function() {
        $(".carousel-item-othersites:first").addClass("active");
        console.log($("#HiddenFieldCount").val());
        if ($("#HiddenFieldCount").val()<=3){
            $(".carousel-control-othersites").hide();
        }
    });
</script>
<input type="hidden" name="ctl00$PlaceHolderBottom$g_e3052be3_673c_405e_9cbe_a883a244c053$ctl00$HiddenFieldCount" id="HiddenFieldCount" />
<div class="bottom-banner">
    <div class="container">
        <p class="bottom-banner__title">Baca Juga</p>
        <div id="carouselOtherSites" class="carousel slide carousel-column" data-ride="carousel" data-interval="false">
            
                    <div class="carousel-inner">
                        
                    <div class="carousel-item carousel-item-othersites">
                        <div class="row bottom-banner-slides">
                            
                    <div class="col-sm-4">
                        <div class="box-list">
                            <a href="https://www.bi.go.id/en/fungsi-utama/moneter/informasi-kurs/default.aspx#floating-2" class="box-list__hyperlink"></a>
                            <p class="mb-0">
                                Bank Indonesia Foreign Exchange Transaction Rates​
                            </p>
                        </div>
                    </div>
                
                        </div>
                    </div>
                
                    </div>
                
            <a class="carousel-control-othersites carousel-control-prev" href="#carouselOtherSites" role="button" data-slide="prev">
                <span class="carousel-control-prev-icon" aria-hidden="true"></span>
                <span class="sr-only">Previous</span>
            </a>
            <a class="carousel-control-othersites carousel-control-next" href="#carouselOtherSites" role="button" data-slide="next">
                <span class="carousel-control-next-icon" aria-hidden="true"></span>
                <span class="sr-only">Next</span>
            </a>
        </div>
    </div>
</div>


	</div>

                                </div>
                            
</div>

                        </div>
                        <div id="DeltaFormDigest">
	
                            
								
                            
                        
</div>
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                        
                    </div>

                    <footer class="ms-dialogHidden noindex">
                        <div class="top-footer">
                            <div class="container">
                                                        	    		
<div id="ctl00_UserControl1" __MarkupType="vsattributemarkup" __WebPartId="{72f5f1f8-08c8-489c-ad0f-67bc21b60514}" WebPart="true">
	
        <ul class="list-unstyled link-list">
            
        <li class="ml-4"><a href='https://www.bi.go.id/en/publikasi/Kalender' class="link__item">Calendar</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/archive' class="link__item">Archieve</a></li>       
    
        <li class="ml-4"><a href='https://www.bi.go.id/en/minisite.aspx' class="link__item">Minisite</a></li>       
    
        </ul>
    

</div>
                                                        	    		
                                <div class="row">
<div id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa" __MarkupType="vsattributemarkup" __WebPartId="{ecc2559e-4a60-437f-ba58-80eaeea6b4aa}" WebPart="true">
	

<div class="col-12 col-md-6 sosmed-wrapper">
    
            <div class="sosmed-list"> 
                
            <a class="sosmed__item" href='https://www.facebook.com/BankIndonesiaOfficial/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-fb.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.instagram.com/bank_indonesia/'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-ig.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.youtube.com/user/BankIndonesiaChannel'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-youtube.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://www.tiktok.com/@bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-tiktok.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://twitter.com/bank_indonesia'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-twitter-X_.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://open.spotify.com/show/4Q38i2lcJpxvtJvcmJuWWv'>
                <img src='https://www.bi.go.id/Sosial%20Media/SPOTIFY-svg.svg' width="32" alt="icon-fb"></a>
        
            <a class="sosmed__item" href='https://whatsapp.com/channel/0029VahA0uQL2ATyd7fOSE39'>
                <img src='https://www.bi.go.id/Sosial%20Media/icon-WA-Channel.svg' width="32" alt="icon-fb"></a>
         
            </div> 
        
    
            <div class="app-list">
                
            <a class="app__item" href='https://apps.apple.com/id/app/bi-mobile/id1198899727'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-app-store.svg' width="98" alt="icon-app-store"></a>
        
            <a class="app__item" href='https://play.google.com/store/apps/details?id=com.bi.mobile'>
                <img class="svg" src='https://www.bi.go.id/Sosial%20Media/icon-play-store.svg' width="98" alt="icon-app-store"></a>
        
            </div>
        
</div>
<span id="ctl00_g_ecc2559e_4a60_437f_ba58_80eaeea6b4aa_ctl00_LabelDebug"></span>

</div>

                                    <div class="col-12 col-md-6 address-wrapper">
                                        <div class="address-list">
                                            <p class="mb-0">Bank Indonesia<br/>
Jalan M.H. Thamrin No. 2, Jakarta 10350<br/>
Contact Center Bank Indonesia Bicara<br/>
Telp. : 131 dan 1500131 (dari luar negeri)<br/>
E-mail : <a href="mailto:bicara@bi.go.id">bicara@bi.go.id</a><br/>
Chatbot LISA :<a href="https://wa.me/6281131131131?text=Hi,%20Lisa" target="blank"> 081 131 131 131</a></p>
                                        </div>
                                    </div>
                                    <div class="col-12 col-md-12 mt-3 d-flex justify-content-end">
                                    	<div id="ctl00_g_e8c52fcb_2724_4885_9437_c0f616f27eb4" __MarkupType="vsattributemarkup" __WebPartId="{e8c52fcb-2724-4885-9437-c0f616f27eb4}" WebPart="true" partorder="2">
	


</div>
                                    </div>
                                </div>
                            </div>
                        </div>
                        <div class="copyright-wrapper">
                            <div class="container">
                                <p class="text-right mb-0">© 2020 Bank Indonesia</p>
                            </div>
                        </div>

                    </footer>

                </div>
                <span id="DeltaHelpPanel">
                    <div id="helppanelCntdiv" class="ms-Help-PanelContainer">
                        
                    </div>
                </span>
                <span id="DeltaPageInstrumentation">
                    
                </span>
            </div>
        

<script type="text/javascript">
//<![CDATA[
var _spFormDigestRefreshInterval = 1440000;window.SPThemeUtils && SPThemeUtils.ApplyCurrentTheme(true); IsSPSocialSwitchEnabled = function() { return true; };var _fV4UI = true;
function _RegisterWebPartPageCUI()
{
    var initInfo = {editable: false,isEditMode: false,allowWebPartAdder: false};
    SP.Ribbon.WebPartComponent.registerWithPageManager(initInfo);
    var wpcomp = SP.Ribbon.WebPartComponent.get_instance();
    var hid;
    hid = document.getElementById("_wpSelected");
    if (hid != null)
    {
        var wpid = hid.value;
        if (wpid.length > 0)
        {
            var zc = document.getElementById(wpid);
            if (zc != null)
                wpcomp.selectWebPart(zc, false);
        }
    }
    hid = document.getElementById("_wzSelected");
    if (hid != null)
    {
        var wzid = hid.value;
        if (wzid.length > 0)
        {
            wpcomp.selectWebPartZone(null, wzid);
        }
    }
};
function __RegisterWebPartPageCUI() {
ExecuteOrDelayUntilScriptLoaded(_RegisterWebPartPageCUI, "sp.ribbon.js");}
_spBodyOnLoadFunctionNames.push("__RegisterWebPartPageCUI");var __wpmExportWarning='This Web Part Page has been personalized. As a result, one or more Web Part properties may contain confidential information. Make sure the properties contain information that is safe for others to read. After exporting this Web Part, view properties in the Web Part description file (.WebPart) by using a text editor such as Microsoft Notepad.';var __wpmCloseProviderWarning='You are about to close this Web Part.  It is currently providing data to other Web Parts, and these connections will be deleted if this Web Part is closed.  To close this Web Part, click OK.  To keep this Web Part, click Cancel.';var __wpmDeleteWarning='You are about to permanently delete this Web Part.  Are you sure you want to do this?  To delete this Web Part, click OK.  To keep this Web Part, click Cancel.';SuiteNavRendering.RenderSuiteNav({top:'suiteBarTop', version:2, dataEndpoint:'Microsoft.SharePoint.Portal.SuiteNavData.GetSuiteNavData', culture:'en-US', signInLink:'\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fAuthenticate.aspx?Source=\u00252Fen\u00252Fstatistik\u00252Finformasi\u00252Dkurs\u00252Ftransaksi\u00252Dbi\u00252Fdefault\u00252Easpx', brandingText:'', brandingLogo:'', brandingLogoLink:'', brandingLogoTitle:''});
var _spWebPermMasks = {High:16,Low:196673};g_spPreFetchKeys.push('sp.core.js');function _cUpdonetidHeadbnnr2(){var myd = null; if (typeof(dataonetidHeadbnnr2) != 'undefined') {myd = dataonetidHeadbnnr2;} var myc = document.getElementById('ctl00_onetidHeadbnnr2');_cUpdconetidHeadbnnr2(myd, myc);}function _cUpdconetidHeadbnnr2(data, ctrl){SiteLogoImagePageUpdate(ctrl, data);}
            ExecuteOrDelayUntilScriptLoaded(
                function() 
                {                    
                    Srch.ScriptApplicationManager.get_current().states = {"webUILanguageName":"en-US","webDefaultLanguageName":"en-US","QueryDateTimeCulture":1033,"timeZoneOffsetInHours":7,"contextUrl":"https://www.bi.go.id/en/statistik/informasi-kurs/transaksi-bi","contextTitle":"Foreign Exchange Rates","supportedLanguages":[{"id":1025,"label":"Arabic"},{"id":1093,"label":"Bangla"},{"id":1026,"label":"Bulgarian"},{"id":1027,"label":"Catalan"},{"id":2052,"label":"Chinese (Simplified)"},{"id":1028,"label":"Chinese (Traditional)"},{"id":1050,"label":"Croatian"},{"id":1029,"label":"Czech"},{"id":1030,"label":"Danish"},{"id":1043,"label":"Dutch"},{"id":1033,"label":"English"},{"id":1035,"label":"Finnish"},{"id":1036,"label":"French"},{"id":1031,"label":"German"},{"id":1032,"label":"Greek"},{"id":1095,"label":"Gujarati"},{"id":1037,"label":"Hebrew"},{"id":1081,"label":"Hindi"},{"id":1038,"label":"Hungarian"},{"id":1039,"label":"Icelandic"},{"id":1057,"label":"Indonesian"},{"id":1040,"label":"Italian"},{"id":1041,"label":"Japanese"},{"id":1099,"label":"Kannada"},{"id":1042,"label":"Korean"},{"id":1062,"label":"Latvian"},{"id":1063,"label":"Lithuanian"},{"id":1086,"label":"Malay"},{"id":1100,"label":"Malayalam"},{"id":1102,"label":"Marathi"},{"id":1044,"label":"Norwegian"},{"id":1045,"label":"Polish"},{"id":1046,"label":"Portuguese (Brazil)"},{"id":2070,"label":"Portuguese (Portugal)"},{"id":1094,"label":"Punjabi"},{"id":1048,"label":"Romanian"},{"id":1049,"label":"Russian"},{"id":3098,"label":"Serbian (Cyrillic)"},{"id":2074,"label":"Serbian (Latin)"},{"id":1051,"label":"Slovak"},{"id":1060,"label":"Slovenian"},{"id":3082,"label":"Spanish (Spain)"},{"id":2058,"label":"Spanish (Mexico)"},{"id":1053,"label":"Swedish"},{"id":1097,"label":"Tamil"},{"id":1098,"label":"Telugu"},{"id":1054,"label":"Thai"},{"id":1055,"label":"Turkish"},{"id":1058,"label":"Ukrainian"},{"id":1056,"label":"Urdu"},{"id":1066,"label":"Vietnamese"}],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"webUILanguageDirectory":"en-US","showAdminDetails":false,"defaultPagesListName":"Pages","isSPFSKU":false,"defaultQueryProperties":{"culture":1033,"uiLanguage":1033,"summaryLength":180,"desiredSnippetLength":90,"enableStemming":true,"enablePhonetic":false,"enableNicknames":false,"trimDuplicates":true,"bypassResultTypes":false,"enableInterleaving":true,"enableQueryRules":true,"processBestBets":true,"enableOrderingHitHighlightedProperty":false,"hitHighlightedMultivaluePropertyLimit":-1,"processPersonalFavorites":true}};
                    Srch.U.trace(null, 'SerializeToClient', 'ScriptApplicationManager state initialized.');
                }, 'Search.ClientControls.js');var g_clientIdDeltaPlaceHolderMain = "DeltaPlaceHolderMain";
var g_clientIdDeltaPlaceHolderPageTitleInTitleArea = "DeltaPlaceHolderPageTitleInTitleArea";
var g_clientIdDeltaPlaceHolderUtilityContent = "DeltaPlaceHolderUtilityContent";

theForm.oldSubmit = theForm.submit;
theForm.submit = WebForm_SaveScrollPositionSubmit;

theForm.oldOnSubmit = theForm.onsubmit;
theForm.onsubmit = WebForm_SaveScrollPositionOnSubmit;

theForm.oldOnLoad = window.onload;
window.onload = WebForm_RestoreScrollPosition;

                function _ribbonInitFunc1()

                {
                    EnsureScriptParams('core.js', '_ribbonInitFunc1Wrapped', '', '', '\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx', '-1997219614', '1033', 'RibbonContainer', {'Ribbon.Read':true,'Ribbon.WebPartPage':true}, null, {'Ribbon.WebPartInsert.InsertRelatedDataToListForm':true},
                                            null, false, 0, false, 'SP.Ribbon.PageManager.get_instance()', false, null, null, null, '1522130250', 1, '.');
                }
                function _ribbonStartInit(initialTabId, buildMinimized, e)
                {
                    EnsureScriptParams('core.js', '_ribbonStartInitWrapped', initialTabId, buildMinimized, e, true, 'EnsureScriptParams("core.js", "RibbonControlInitWrapped");EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", function () { _registerCUIEComponentWrapped( "\u002fen\u002fstatistik\u002finformasi-kurs\u002ftransaksi-bi\u002f_layouts\u002f15\u002fcommandui.ashx", "1033", "-1997219614");});EnsureScriptFunc("ribbon", "SP.Ribbon.PageManager", _ribbonInitFunc1);');
                }
                function _ribbonKeyboardTitleShortcut(e)
                {
                    EnsureScriptParams('core.js', '_ribbonKeyboardTitleShortcutWrapped', e, 'tff[', 'Ribbon.Read-title');
                }
                function _ribbonDataInit(p6, p7)
                {
                    _ribbon = new Object();
                    _ribbon.initialTabId = p6;
                    _ribbon.buildMinimized = p7;
                    _ribbon.initStarted = false;
                    _ribbon.initialTabSelectedByUser = false;
                    _ribbon.launchedByKeyboard = false;
                }
                function _ribbonWaitForBodyEvent()
                {
                    if (false)
                        _ribbonStartInit();
                    
                function _ribbonOnWindowResizeForHeaderScaling(evt)
                {
                    _ribbonOnWindowResizeForHeaderScalingWrapped(evt, 'RibbonContainer', false);
                }
                EnsureScriptParams('core.js', '_ribbonInitResizeHandlers', _ribbonOnWindowResizeForHeaderScaling, 'RibbonContainer', true, false);
                
                    EnsureScriptParams('core.js', '_ribbonAddEventListener', _ribbonKeyboardTitleShortcut);
                }
                _ribbonDataInit('Ribbon.Read', true);                
                if (SP.SOD.get_prefetch() == 0 && _ribbon.buildMinimized == true)
                {
                    ExecuteOrDelayUntilScriptLoaded(_ribbonWaitForBodyEvent, 'sp.ribbon.js');
                }
                else
                {
                    EnsureScriptFunc('ribbon', 'SP.Ribbon.PageStateActionButton', _ribbonWaitForBodyEvent);
                }
                
var g_commandUIHandlers = {"name":"CommandHandlers","attrs":{},"children":[]};
g_QuickLaunchControlIds.push("zz1_TopNavigationMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz1_TopNavigationMenu = null; function init_zz1_TopNavigationMenu() { if (g_zz1_TopNavigationMenu == null) g_zz1_TopNavigationMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz1_TopNavigationMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz1_TopNavigationMenu, 'SP.Core.js');

                    ExecuteOrDelayUntilScriptLoaded(
                        function() 
                        {
                            if ($isNull($find('ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr')))
                            {
                                var sb = $create(Srch.SearchBox, {"delayLoadTemplateScripts":true,"initialPrompt":"Search this site","messages":[],"navigationNodes":[{"id":0,"name":"This Site","url":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","promptString":"Search this site"}],"queryGroupNames":["MasterPage"],"renderTemplateId":"~sitecollection/_catalogs/masterpage/Display Templates/Search/Control_SearchBox_Compact.js","resultsPageAddress":"~site/_layouts/15/osssearchresults.aspx?u={contexturl}","serverInitialRender":true,"showDataErrors":true,"showNavigation":true,"states":{},"tryInplaceQuery":false}, null, null, $get("ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr"));
                                sb.activate('Search this site', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sbox', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_sboxdiv', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavButton', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_AutoCompList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_NavDropdownList', 'ctl00_PlaceHolderSearchArea_SmallSearchInputBox1_csr_SearchLink', 'ms-srch-sbprogress', 'ms-srch-sb-prompt ms-helperText');
                            }
                        }, 'Search.ClientControls.js');g_QuickLaunchControlIds.push("zz3_V4QuickLaunchMenu");_spBodyOnLoadFunctionNames.push('QuickLaunchInitDroppable'); var g_zz3_V4QuickLaunchMenu = null; function init_zz3_V4QuickLaunchMenu() { if (g_zz3_V4QuickLaunchMenu == null) g_zz3_V4QuickLaunchMenu = $create(SP.UI.AspMenu, null, null, null, $get('zz3_V4QuickLaunchMenu')); } ExecuteOrDelayUntilScriptLoaded(init_zz3_V4QuickLaunchMenu, 'SP.Core.js');
//]]>
</script>
</form>
        <span id="DeltaPlaceHolderUtilityContent">
            
        </span>
        <script type="text/javascript">// <![CDATA[ 

var g_Workspace = "s4-workspace";
		
		 // ]]>
</script>
    </body>
</html>
recorded_at: Sun, 05 Apr 2026 00:49:51 GMT
recorded_with: VCR 6.4.0
Reference in a new issue View git blame Copy permalink