[BASKET] TRAINING
762 28 Januari 2021
[BASKET] TRAINING
BUFC0422 (1)
Aperture: 2.8 Camera: Canon EOS 5D Mark III Iso: 2500
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2734.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 2500
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2550.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 2500
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2731.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 2500
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2533.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 2500
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2735.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 2500
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC3121.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 800
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2949.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 800
28 Januari 2021
![[Basket] Training](data:image/jpg;base64,<!DOCTYPE html>
<html lang="en-US" class="no-js">
    <head>
<!-- Debug: Bootstrap Inserted by WordPress Twitter Bootstrap CSS plugin v3.4.1-0 http://icwp.io/w/ -->
<link rel="stylesheet" type="text/css" href="https://www.baliunitedlibrary.com/wp-content/plugins/wordpress-bootstrap-css/resources/bootstrap-3.4.1/css/bootstrap.css" />
<!-- / WordPress Twitter Bootstrap CSS Plugin from iControlWP. -->
        <meta charset="UTF-8">
        <meta id="viewport" name="viewport" content="width=device-width, user-scalable=no" />
        <meta name="viewport" content="initial-scale=1, maximum-scale=1">
        <link rel="profile" href="https://gmpg.org/xfn/11">
        <link rel="pingback" href="https://www.baliunitedlibrary.com/xmlrpc.php">
        <!--[if lt IE 9]>
        <script src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/html5.js"></script>
        <![endif]-->
        <script>(function(html){html.className = html.className.replace(/\bno-js\b/,'js')})(document.documentElement);</script>
<title>Page not found &#8211; Bali United</title>

<!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[-1,-1] -->
<!-- /all in one seo pack -->
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Feed" href="https://www.baliunitedlibrary.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Bali United &raquo; Comments Feed" href="https://www.baliunitedlibrary.com/comments/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/72x72\/","ext":".png","source":{"concatemoji":"https:\/\/www.baliunitedlibrary.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=4.4.14"}};
			!function(a,b,c){function d(a){var c,d,e,f=b.createElement("canvas"),g=f.getContext&&f.getContext("2d"),h=String.fromCharCode;return g&&g.fillText?(g.textBaseline="top",g.font="600 32px Arial","flag"===a?(g.fillText(h(55356,56806,55356,56826),0,0),f.toDataURL().length>3e3):"diversity"===a?(g.fillText(h(55356,57221),0,0),c=g.getImageData(16,16,1,1).data,g.fillText(h(55356,57221,55356,57343),0,0),c=g.getImageData(16,16,1,1).data,e=c[0]+","+c[1]+","+c[2]+","+c[3],d!==e):("simple"===a?g.fillText(h(55357,56835),0,0):g.fillText(h(55356,57135),0,0),0!==g.getImageData(16,16,1,1).data[0])):!1}function e(a){var c=b.createElement("script");c.src=a,c.type="text/javascript",b.getElementsByTagName("head")[0].appendChild(c)}var f,g;c.supports={simple:d("simple"),flag:d("flag"),unicode8:d("unicode8"),diversity:d("diversity")},c.DOMReady=!1,c.readyCallback=function(){c.DOMReady=!0},c.supports.simple&&c.supports.flag&&c.supports.unicode8&&c.supports.diversity||(g=function(){c.readyCallback()},b.addEventListener?(b.addEventListener("DOMContentLoaded",g,!1),a.addEventListener("load",g,!1)):(a.attachEvent("onload",g),b.attachEvent("onreadystatechange",function(){"complete"===b.readyState&&c.readyCallback()})),f=c.source||{},f.concatemoji?e(f.concatemoji):f.wpemoji&&f.twemoji&&(e(f.twemoji),e(f.wpemoji)))}(window,document,window._wpemojiSettings);
		</script>
		<style type="text/css">
img.wp-smiley,
img.emoji {
	display: inline !important;
	border: none !important;
	box-shadow: none !important;
	height: 1em !important;
	width: 1em !important;
	margin: 0 .07em !important;
	vertical-align: -0.1em !important;
	background: none !important;
	padding: 0 !important;
}
</style>
<link rel='stylesheet' id='contact-form-7-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=4.3.1' type='text/css' media='all' />
<link rel='stylesheet' id='easingslider-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/css/easingslider.min.css?ver=2.2.1.1' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-1.10.3.custom.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='jquery-ui-spinner-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/jquery-ui-spinner.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_calendar-jos-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/calendar-jos.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='form_maker_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/css/form_maker_frontend.css?ver=4.4.14' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_frontend-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/bwg_frontend.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_sumoselect-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/sumoselect.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_font-awesome-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/font-awesome/font-awesome.css?ver=4.2.0' type='text/css' media='all' />
<link rel='stylesheet' id='bwg_mCustomScrollbar-css'  href='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/css/jquery.mCustomScrollbar.css?ver=1.2.78' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-fonts-css'  href='https://fonts.googleapis.com/css?family=Noto+Sans%3A400italic%2C700italic%2C400%2C700%7CNoto+Serif%3A400italic%2C700italic%2C400%2C700%7CInconsolata%3A400%2C700&#038;subset=latin%2Clatin-ext' type='text/css' media='all' />
<link rel='stylesheet' id='genericons-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/genericons/genericons.css?ver=3.2' type='text/css' media='all' />
<link rel='stylesheet' id='twentyfifteen-style-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/style.css?ver=4.4.14' type='text/css' media='all' />
<!--[if lt IE 9]>
<link rel='stylesheet' id='twentyfifteen-ie-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<!--[if lt IE 8]>
<link rel='stylesheet' id='twentyfifteen-ie7-css'  href='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/css/ie7.css?ver=20141010' type='text/css' media='all' />
<![endif]-->
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery.js?ver=1.11.3'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.2.1'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.validate.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var ajax_login_object = {"ajaxurl":"https:\/\/www.baliunitedlibrary.com\/wp-admin\/admin-ajax.php","redirecturl":"https:\/\/www.baliunitedlibrary.com\/profile","loadingmessage":"Sending user info, please wait...","redirectregister":"https:\/\/www.baliunitedlibrary.com\/register"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/themes/baliunited/ajax-login-script.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/easing-slider/js/jquery.easingslider.min.js?ver=2.2.1.1'></script>
<script type='text/javascript' src='https://maps.google.com/maps/api/js?sensor=false&#038;ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/if_gmap_front_end.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/jelly.min.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/file-upload.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar.js?ver=4.4.14'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/calendar/calendar_function.js?ver=4.4.14'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var fm_objectL10n = {"plugin_url":"https:\/\/www.baliunitedlibrary.com\/wp-content\/plugins\/form-maker"};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/form-maker/js/main_div_front_end.js?ver=1.8.12'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_frontend.js?ver=1.2.78'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectsL10n = {"bwg_select_tag":"Select Tag."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.sumoselect.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mobile.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.mCustomScrollbar.concat.min.js?ver=1.2.78'></script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/jquery.fullscreen-0.4.1.js?ver=0.4.1'></script>
<script type='text/javascript'>
/* <![CDATA[ */
var bwg_objectL10n = {"bwg_field_required":"field is required.","bwg_mail_validation":"This is not a valid email address.","bwg_search_result":"There are no images matching your search."};
/* ]]> */
</script>
<script type='text/javascript' src='https://www.baliunitedlibrary.com/wp-content/plugins/photo-gallery/js/bwg_gallery_box.js?ver=1.2.78'></script>
<link rel='https://api.w.org/' href='https://www.baliunitedlibrary.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.baliunitedlibrary.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.baliunitedlibrary.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 4.4.14" />
		<style type="text/css">.recentcomments a{display:inline !important;padding:0 !important;margin:0 !important;}</style>
		<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon-precomposed" href="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.baliunitedlibrary.com/wp-content/uploads/2016/01/cropped-BU_Favicon-270x270.png" />
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/modernizr.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.easing.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/owl.carousel.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/mediaelement-and-player.min.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bali.style.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.jscrollpane.js"></script>
        <script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/jquery.mousewheel.js"></script>
		<script type="text/javascript" src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/js/bootstrap.js"></script>
        <script src='https://www.google.com/recaptcha/api.js'></script>
		<script>
		(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
		(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
		m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
		})(window,document,'script','https://www.google-analytics.com/analytics.js','ga');
		ga('create', 'UA-75299166-2', 'auto');
		ga('send', 'pageview');
		</script>
    </head>

    <body class="bali-united-page">
                <div id="site-header" class="container-fluid header">
            <div class="row">
                <ul class="nav navbar-nav menu  desktop-ver">
                    <li><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/bali-united-logo.jpg" height="70px" alt="Logo"></a></li>
                    <li id="menu-item-50" class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li id="menu-item-33" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li id="menu-item-100" class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li id="menu-item-102" class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li id="menu-item-90694946" class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li id="menu-item-90694956" class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                </ul>

                <ul class="nav navbar-nav menu mobile-ver">
                                        <li class="burger-menu active"></li>
                    <li class="logo-center-mobile"><a href="https://www.baliunitedlibrary.com" class="logo"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/logo-mobile.png" alt="Logo"></a></li>
                    <ul class="burger-menu-click">
                        <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-home menu-item-50"><a href="http://www.baliunitedlibrary.com/"><span>HOME</span></a></li>
<li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-33"><a href="https://www.baliunitedlibrary.com/photos/"><span>PHOTOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-video menu-item-100"><a href="https://www.baliunitedlibrary.com/video/"><span>VIDEOS</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media-release menu-item-102"><a href="https://www.baliunitedlibrary.com/media-release/"><span>MEDIA RELEASE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-media_exposure menu-item-90694946"><a href="https://www.baliunitedlibrary.com/media_exposure/"><span>MEDIA EXPOSURE</span></a></li>
<li class="menu-item menu-item-type-post_type_archive menu-item-object-social_media menu-item-90694956"><a href="https://www.baliunitedlibrary.com/social_media/"><span>SOCIAL MEDIA</span></a></li>
                        						    <li class="last-tree">
                                <ul class="user-history clearfix">
									<li class="icon-history-download-mobile"><span class="icon-history-download-span"></span></li>
                                    <li class="separate">|</li>
									<a href="https://www.baliunitedlibrary.com/login-bali"><li class="icon-login-mobile"><span class="log"></span></li></a>
                                </ul>
                            </li>
                                            </ul>
                </ul>
                <div class="pull-right">
                    <ul class="nav navbar-nav user-log">
                        							<li class="icon-history-download"><span class="icon-history-download-span"></span>
                                <div class="wrp-history-download">
                                    <div id="img_right_pop"></div>
                                    <div class="seeall-history"><a href="https://www.baliunitedlibrary.com/login">Please login to start download <i class="fa fa-arrow-right"></i></a></div>
                                </div>                                    
                            </li>
                            <li class="icon-login"><span class="log"></span>
                                <div class="wrp-login">
                                    <div class="col-md-12">
                                        <form method="post" action="login" id="login" autocomplete="off">
                                            <h3>Login</h3>
                                            <div class="form-group">
                                                <label for="emailAddress" >Email</label>
                                                <input type="email" name="log" class="form-control" id="username" placeholder="" required>
                                            </div>
                                            <div class="form-group">
                                                <label for="Password">Password</label>
                                                <input type="Password" class="form-control bg-white" name="pwd" id="password" placeholder="" required>
                                            </div>
                                            <div id="msg" class="err-msg"></div>
                                            <div class="bali-button"><input type="submit" value="login" class="right-arrow"> Or <a href="https://www.baliunitedlibrary.com/register" class="red-color"><span>Register now</span></a></div>
                                            <input type="hidden" id="security" name="security" value="f7c1087219" /><input type="hidden" name="_wp_http_referer" value="/wp-content/uploads/photo-gallery/Bali%20United%20Basket/Latihan%20Perdana/thumb/watermark-BUFC2980.jpg" />                                            
                                        </form>
                                    </div>
                                </div>
                            </li>

                            <!-- login user -->
                                                </ul>
                </div>
            </div>
        </div>

        <div id="site-content" class="container-fluid content">
                        <div class="categories active">
                <ul>
                    <li class="txt-categories" id="click-categories">CATEGORIES <span><i class="arrow-cat fa fa-angle-double-down"></i></span></li>
                    <ul class="sub-categories active">
                                                    <li id="highlight_0" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/players"><p id="cat_list_0">Players</p></a></li>
                                                    <li id="highlight_1" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/pre-season"><p id="cat_list_1">Pre Season</p></a></li>
                                                    <li id="highlight_2" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/bali-united-store"><p id="cat_list_2">Bali United Store</p></a></li>
                                                    <li id="highlight_3" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/goal-celebrations"><p id="cat_list_3">Goal Celebrations</p></a></li>
                                                    <li id="highlight_4" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/charities"><p id="cat_list_4">Charities</p></a></li>
                                                    <li id="highlight_5" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/press-conferences"><p id="cat_list_5">Press Conferences</p></a></li>
                                                    <li id="highlight_6" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/matches"><p id="cat_list_6">Matches</p></a></li>
                                                    <li id="highlight_7" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/training-sessions"><p id="cat_list_7">Training Sessions</p></a></li>
                                                    <li id="highlight_8" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/international-match"><p id="cat_list_8">International Match</p></a></li>
                                                    <li id="highlight_9" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/kit-shoot"><p id="cat_list_9">Kit Shoot</p></a></li>
                                                    <li id="highlight_10" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/photoshoot"><p id="cat_list_10">Photoshoot</p></a></li>
                                                    <li id="highlight_11" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/fans"><p id="cat_list_11">Fans</p></a></li>
                                                    <li id="highlight_12" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/stadium"><p id="cat_list_12">Stadium</p></a></li>
                                                    <li id="highlight_13" class="highlight" ><a href="https://www.baliunitedlibrary.com/categories/football-club"><p id="cat_list_13">Football Club</p></a></li>
                                            </ul>
                </ul>
            </div>
            
                <div class="row search-area mobile-ver">
                    <div class="container">
                            
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                        <div class="small">Player's Name / Photo ID / League's Name</div>
                    </div>
                </div>

            
            

	<div class="row">
                <div class="col-md-12 no-padding left333">
                    <div class="col-md-6">
                        <p class="breadcrumb"><span><a href="https://www.baliunitedlibrary.com">Home</a></span> <i class="fa fa-angle-right"></i> <span>Error 404</span></p>
                    </div>
                    
        <form role="search" method="get" action="https://www.baliunitedlibrary.com/" >
        <div class="col-md-6 wrp-search-content">
            <input required type="text" value="" name="s" id="s" class="form-control content-search" placeholder="Search Images, Media Release, Video Here">
            <button type="submit" value="Search" class="icon-search input-group-addon"></button>
        </div>
        </form>                </div>
                
                <!-- Page 404 -->
                <div class="col-md-12 wrp-404 no-padding">
                    <div class="container">
                        <div class="images"><img src="https://www.baliunitedlibrary.com/wp-content/themes/baliunited/images/404.png" alt="error 404"></div>
                        <div class="txt-notfound">Page Not Found...</div>
                    </div>
                </div>
                <!-- End 404 -->
				<div class="bali-button" style="text-align:center;">
					<input type="submit" value="Back" id="back_button">
				</div>
            </div>
<script type="text/javascript">
    document.getElementById("back_button").onclick = function () {
        location.href = "http://baliunited.staging5.salt.co.id/";
    };
</script>
			

</div>
        </div>
        <div id="site-footer" class="container-fluid footer">
            <div class="row">
                <div class="col-md-7">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-policy">
                        <li id="menu-item-53" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-53"><a href="https://www.baliunitedlibrary.com/contact/">CONTACT US</a></li>
                        </ul>
                    </div>
                </div>
                <div class="col-md-5">
                    <div class="pull-right">
                        <ul class="nav navbar-nav wrp-socmed">
                            <li><p class="txt-follow">FOLLOW US</p></li>
                            <li><a href="http://www.baliutd.com/" target="_blank"><p class="icon-fb">fb</p></a></li>
                            <li><a href="https://twitter.com/baliutd" target="_blank"><p class="icon-yt">yt</p></a></li>
                            <li><a href="https://www.youtube.com/channel/UCgzKxL4ofFySn7zp-adnhNQ" target="_blank"><p class="icon-tw">tw</p></a></li>
                            <li><a href="https://www.facebook.com/OfficialBaliUnited" target="_blank"><p class="icon-wb">wb</p></a></li>
                        </ul>
                    </div>
                </div>
            </div>
        </div>
    </div><!-- #page -->
	<!-- Overlay -->
    <div class="bg-overlay"></div>
    <!-- Modal -->
    <div class="modal fade" id="history-download-modal" tabindex="-1" role="dialog" aria-labelledby="histortDownloadModal">
      <div class="modal-dialog" role="document">
        <div class="modal-content">
          <div class="modal-header download-items">
            <button type="button" class="close" data-dismiss="modal" aria-label="Close"><span aria-hidden="true">&times;</span></button>
          </div>
          <div class="modal-body">
            <div class="row">
                        </div>
          </div>
		  			<div class="modal-footer">
				<a href="https://www.baliunitedlibrary.com/login" class="download-link">Silahkan Login untuk mulai mendownload</a>
			</div>
		          </div>
      </div>
    </div>
	<div id="loading">Loading&#8230;</div>
</body>
</html>
)
Aperture: 1.8 Camera: Canon EOS 5D Mark III Iso: 800
28 Januari 2021