API tools faq
paste
Advertisement
vendetta25

hack magazine

vendetta25
Jul 25th, 2020 (edited)
44
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 286.59 KB | None | 0 0
raw download clone embed print report
  1. X-Powered-By: PHP/7.2.31
  2. Expires: Wed, 11 Jan 1984 05:00:00 GMT
  3. Cache-Control: no-cache, must-revalidate, max-age=0
  4. Set-Cookie: wordpress_test_cookie=WP+Cookie+check; path=/; secure
  5. X-Frame-Options: SAMEORIGIN
  6. Set-Cookie: wordpress_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/wp-admin
  7. Set-Cookie: wordpress_sec_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/wp-admin
  8. Set-Cookie: wordpress_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/wp-content/plugins
  9. Set-Cookie: wordpress_sec_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/wp-content/plugins
  10. Set-Cookie: wordpress_logged_in_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  11. Set-Cookie: wordpress_logged_in_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  12. Set-Cookie: wp-settings-0=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  13. Set-Cookie: wp-settings-time-0=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  14. Set-Cookie: wordpress_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  15. Set-Cookie: wordpress_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  16. Set-Cookie: wordpress_sec_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  17. Set-Cookie: wordpress_sec_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  18. Set-Cookie: wordpressuser_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  19. Set-Cookie: wordpresspass_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  20. Set-Cookie: wordpressuser_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  21. Set-Cookie: wordpresspass_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  22. Set-Cookie: wp-postpass_dd597eaac0544d3fda087659fa28c37e=+; expires=Fri, 26-Jul-2019 14:55:20 GMT; Max-Age=0; path=/
  23. X-Frame-Options: DENY
  24. X-XSS-Protection: 1; mode=block
  25. X-Content-Type-Options: nosniff
  26. X-UA-Compatible: IE=Edge,chrome=1
  27. X-Robots-Tag: none
  28. X-Download-Options: noopen
  29. X-Permitted-Cross-Domain-Policies: none
  30. Strict-Transport-Security: max-age=31536000; includeSubdomains
  31. CF-Cache-Status: DYNAMIC
  32. cf-request-id: 042811b7f70000e4e29ab83200000001
  33. Expect-CT: max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
  34. Server: cloudflare
  35. CF-RAY: 5b86b89ff92be4e2-LAX
  36.  
  37. =======================/ /=================================================================/ /======
  38.  
  39. <?xml version="1.0" encoding="UTF-8" standalone="no"?>
  40. <Message>
  41. <Headers>SFRUUC8xLjEgMjAwIE9LDQpEYXRlOiBTYXQsIDI1IEp1bCAyMDIwIDEyOjExOjMyIEdNVA0KQ29udGVudC1UeXBlOiB0ZXh0L2h0bWw7IGNoYXJzZXQ9VVRGLTgNCkNvbm5lY3Rpb246IGtlZXAtYWxpdmUNClNldC1Db29raWU6IF9fY2ZkdWlkPWQzMjY0Nzk0YTNhNzBlZGMwZGJkYjFkODUzOTJiNGE1YjE1OTU2NzkwOTA7IGV4cGlyZXM9TW9uLCAyNC1BdWctMjAgMTI6MTE6MzAgR01UOyBwYXRoPS87IGRvbWFpbj0ua2FyZWJhdG9yYWphLmNvbTsgSHR0cE9ubHk7IFNhbWVTaXRlPUxheA0KWC1Qb3dlcmVkLUJ5OiBQSFAvNy4yLjMxDQpYLVBpbmdiYWNrOiBodHRwczovL3d3dy5rYXJlYmF0b3JhamEuY29tL3htbHJwYy5waHANCkxpbms6IDxodHRwczovL3d3dy5rYXJlYmF0b3JhamEuY29tL3dwLWpzb24vPjsgcmVsPSJodHRwczovL2FwaS53Lm9yZy8iDQpMaW5rOiA8aHR0cHM6Ly93d3cua2FyZWJhdG9yYWphLmNvbS8+OyByZWw9c2hvcnRsaW5rDQpYLUZyYW1lLU9wdGlvbnM6IERFTlkNClgtWFNTLVByb3RlY3Rpb246IDE7IG1vZGU9YmxvY2sNClgtQ29udGVudC1UeXBlLU9wdGlvbnM6IG5vc25pZmYNClgtVUEtQ29tcGF0aWJsZTogSUU9RWRnZSxjaHJvbWU9MQ0KWC1Sb2JvdHMtVGFnOiBub25lDQpYLURvd25sb2FkLU9wdGlvbnM6IG5vb3Blbg0KWC1QZXJtaXR0ZWQtQ3Jvc3MtRG9tYWluLVBvbGljaWVzOiBub25lDQpTdHJpY3QtVHJhbnNwb3J0LVNlY3VyaXR5OiBtYXgtYWdlPTMxNTM2MDAwOyBpbmNsdWRlU3ViZG9tYWlucw0KQ0YtQ2FjaGUtU3RhdHVzOiBEWU5BTUlDDQpjZi1yZXF1ZXN0LWlkOiAwNDI3N2JiZWUwMDAwMGU3YmQxYWExNTIwMDAwMDAwMQ0KRXhwZWN0LUNUOiBtYXgtYWdlPTYwNDgwMCwgcmVwb3J0LXVyaT0iaHR0cHM6Ly9yZXBvcnQtdXJpLmNsb3VkZmxhcmUuY29tL2Nkbi1jZ2kvYmVhY29uL2V4cGVjdC1jdCINClNlcnZlcjogY2xvdWRmbGFyZQ0KQ0YtUkFZOiA1Yjg1YzhhYjA5MzVlN2JkLUxBWA0KDQo=</Headers>
  42. <Body><!doctype html>
<html lang="id-ID" xmlns:og="http://ogp.me/ns#" xmlns:fb="http://ogp.me/ns/fb#">
<head>
	<meta charset="UTF-8">
	<meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=1">
	<link rel="profile" href="https://gmpg.org/xfn/11">
	<link rel="pingback" href="https://www.karebatoraja.com/xmlrpc.php">
	<link rel="icon" href="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon" href="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-270x270.png" />
		
	<meta http-equiv="x-dns-prefetch-control" content="on">
	<link rel="dns-prefetch" href="//fonts.googleapis.com" />
	<link rel="dns-prefetch" href="//fonts.gstatic.com" />
	<link rel="dns-prefetch" href="//0.gravatar.com/" />
	<link rel="dns-prefetch" href="//2.gravatar.com/" />
	<link rel="dns-prefetch" href="//1.gravatar.com/" />
	<title>Kareba Toraja &#8211; Update Informasi Toraja</title>
<style type="text/css">			.heateorSssInstagramBackground{background:radial-gradient(circle at 30% 107%,#fdf497 0,#fdf497 5%,#fd5949 45%,#d6249f 60%,#285aeb 90%)}
											.heateor_sss_horizontal_sharing .heateorSssSharing,.heateor_sss_standard_follow_icons_container .heateorSssSharing{
							color: #fff;
						border-width: 0px;
			border-style: solid;
			border-color: transparent;
		}
				.heateor_sss_horizontal_sharing .heateorSssTCBackground{
			color:#666;
		}
				.heateor_sss_horizontal_sharing .heateorSssSharing:hover,.heateor_sss_standard_follow_icons_container .heateorSssSharing:hover{
						border-color: transparent;
		}
		.heateor_sss_vertical_sharing .heateorSssSharing,.heateor_sss_floating_follow_icons_container .heateorSssSharing{
							color: #fff;
						border-width: 0px;
			border-style: solid;
			border-color: transparent;
		}
				.heateor_sss_vertical_sharing .heateorSssTCBackground{
			color:#666;
		}
				.heateor_sss_vertical_sharing .heateorSssSharing:hover,.heateor_sss_floating_follow_icons_container .heateorSssSharing:hover{
						border-color: transparent;
		}
		
		div.heateor_sss_mobile_footer{display:none;}@media screen and (max-width:783px){i.heateorSssTCBackground{background-color:white!important}div.heateor_sss_bottom_sharing{width:100%!important;left:0!important;}div.heateor_sss_bottom_sharing li{width:25% !important;}div.heateor_sss_bottom_sharing .heateorSssSharing{width: 100% !important;}div.heateor_sss_bottom_sharing div.heateorSssTotalShareCount{font-size:1em!important;line-height:28px!important}div.heateor_sss_bottom_sharing div.heateorSssTotalShareText{font-size:.7em!important;line-height:0px!important}div.heateor_sss_mobile_footer{display:block;height:40px;}.heateor_sss_bottom_sharing{padding:0!important;display:block!important;width: auto!important;bottom:-2px!important;top: auto!important;}.heateor_sss_bottom_sharing .heateor_sss_square_count{line-height: inherit;}.heateor_sss_bottom_sharing .heateorSssSharingArrow{display:none;}.heateor_sss_bottom_sharing .heateorSssTCBackground{margin-right: 1.1em !important}}</style><link rel='dns-prefetch' href='//www.karebatoraja.com' />
<link rel='dns-prefetch' href='//cdnjs.cloudflare.com' />
<link rel='dns-prefetch' href='//fonts.googleapis.com' />
<link rel='dns-prefetch' href='//s.w.org' />
<link rel="alternate" type="application/rss+xml" title="Kareba Toraja &raquo; Feed" href="https://www.karebatoraja.com/feed/" />
<link rel="alternate" type="application/rss+xml" title="Kareba Toraja &raquo; Umpan Komentar" href="https://www.karebatoraja.com/comments/feed/" />
<link rel="alternate" type="application/rss+xml" title="Kareba Toraja &raquo; Home Umpan Komentar" href="https://www.karebatoraja.com/foto-suatu-pagi-di-pasar-bolu-toraja-utara/feed/" />
		<script type="text/javascript">
			window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/12.0.0-1\/72x72\/","ext":".png","svgUrl":"https:\/\/s.w.org\/images\/core\/emoji\/12.0.0-1\/svg\/","svgExt":".svg","source":{"concatemoji":"https:\/\/www.karebatoraja.com\/wp-includes\/js\/wp-emoji-release.min.js?ver=5.4.2"}};
			/*! This file is auto-generated */
			!function(e,a,t){var r,n,o,i,p=a.createElement("canvas"),s=p.getContext&&p.getContext("2d");function c(e,t){var a=String.fromCharCode;s.clearRect(0,0,p.width,p.height),s.fillText(a.apply(this,e),0,0);var r=p.toDataURL();return s.clearRect(0,0,p.width,p.height),s.fillText(a.apply(this,t),0,0),r===p.toDataURL()}function l(e){if(!s||!s.fillText)return!1;switch(s.textBaseline="top",s.font="600 32px Arial",e){case"flag":return!c([127987,65039,8205,9895,65039],[127987,65039,8203,9895,65039])&&(!c([55356,56826,55356,56819],[55356,56826,8203,55356,56819])&&!c([55356,57332,56128,56423,56128,56418,56128,56421,56128,56430,56128,56423,56128,56447],[55356,57332,8203,56128,56423,8203,56128,56418,8203,56128,56421,8203,56128,56430,8203,56128,56423,8203,56128,56447]));case"emoji":return!c([55357,56424,55356,57342,8205,55358,56605,8205,55357,56424,55356,57340],[55357,56424,55356,57342,8203,55358,56605,8203,55357,56424,55356,57340])}return!1}function d(e){var t=a.createElement("script");t.src=e,t.defer=t.type="text/javascript",a.getElementsByTagName("head")[0].appendChild(t)}for(i=Array("flag","emoji"),t.supports={everything:!0,everythingExceptFlag:!0},o=0;o<i.length;o++)t.supports[i[o]]=l(i[o]),t.supports.everything=t.supports.everything&&t.supports[i[o]],"flag"!==i[o]&&(t.supports.everythingExceptFlag=t.supports.everythingExceptFlag&&t.supports[i[o]]);t.supports.everythingExceptFlag=t.supports.everythingExceptFlag&&!t.supports.flag,t.DOMReady=!1,t.readyCallback=function(){t.DOMReady=!0},t.supports.everything||(n=function(){t.readyCallback()},a.addEventListener?(a.addEventListener("DOMContentLoaded",n,!1),e.addEventListener("load",n,!1)):(e.attachEvent("onload",n),a.attachEvent("onreadystatechange",function(){"complete"===a.readyState&&t.readyCallback()})),(r=t.source||{}).concatemoji?d(r.concatemoji):r.wpemoji&&r.twemoji&&(d(r.twemoji),d(r.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="wp-block-library-css"  href="https://www.karebatoraja.com/wp-includes/css/dist/block-library/style.min.css?ver=5.4.2" media="all" />
<link rel="stylesheet" id="thb-fa-css"  href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.css" media="all" />
<link rel="stylesheet" id="thb-app-css"  href="https://www.karebatoraja.com/wp-content/themes/goodlife-wp/assets/css/app.css?ver=3.2.9" media="all" />
<style id='thb-app-inline-css' type='text/css'>
body { font-family:'Georgia';}h1, h2, h3, h4, h5, h6, blockquote, .post-review ul li, .post-review .comment_section p:before, .post-review .post_comment, .subcategory_container ul li a, .featured_image_credit,.post .post-category, .widget > strong, .menu-holder .sf-menu > li > a, .mobile-menu li a, .menu-holder ul li .sub-menu li a,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li > a, .mobile-menu .sub-menu li a, label, .featured_image_credit, .trending-bar, .woocommerce-MyAccount-navigation, .subheader, .post .post-bottom-meta, #subfooter, .btn, .button, input[type=submit], .widget.widget_topreviews .style1 li > a, .post.blog-post .single_category_title, .thb-login-form ul li, .woocommerce-tabs .tabs li, .thb-cart-empty p, .post-title-bullets li button span, .post .post-gallery .counts, .widget.widget_socialcounter ul li {font-family:'Georgia';}.subheader {background-color:#f21818 !important;}.subheader.dark ul > li .sub-menu,.subheader.light ul > li .sub-menu {background:#ff1a1a;}.subheader ul {}@media only screen and (min-width:48.063em) {.header {}}.header {}@media only screen and (min-width:64.063em) {.header .logo .logoimg {max-height:300%;}}@media only screen and (min-width:64.063em) {.subheader.fixed .logo .logolink .logoimg {max-height:200px;}}.menu-holder.style1.dark {background-color:#f43838 !important;}.post .post-category {}.widget > strong {}.menu-holder ul.sf-menu > li > a {font-family:'Arial';font-size:12px;}.menu-holder ul li .sub-menu li a,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li > a {}.header .menu-holder ul.sf-menu > li.menu-item-category-3796 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-3796 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-3796 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-3796.active > a,.menu-holder ul li .sub-menu li.menu-item-category-3796 > a:hover,.post .single_category_title.category-link-3796 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-3796 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-3796.boxed-link,.category_title.cat-3796:before,.category-title.style1 .category-header.cat-3796 {background-color:#dd3333;}.post.carousel-style2[data-catid="3796"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-31 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-31 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-31 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-31.active > a,.menu-holder ul li .sub-menu li.menu-item-category-31 > a:hover,.post .single_category_title.category-link-31 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-31 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-31.boxed-link,.category_title.cat-31:before,.category-title.style1 .category-header.cat-31 {background-color:#dd3333;}.post.carousel-style2[data-catid="31"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-34 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-34 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-34 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-34.active > a,.menu-holder ul li .sub-menu li.menu-item-category-34 > a:hover,.post .single_category_title.category-link-34 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-34 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-34.boxed-link,.category_title.cat-34:before,.category-title.style1 .category-header.cat-34 {background-color:#dd3333;}.post.carousel-style2[data-catid="34"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-8 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-8 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-8 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-8.active > a,.menu-holder ul li .sub-menu li.menu-item-category-8 > a:hover,.post .single_category_title.category-link-8 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-8 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-8.boxed-link,.category_title.cat-8:before,.category-title.style1 .category-header.cat-8 {background-color:#dd3333;}.post.carousel-style2[data-catid="8"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-11 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-11 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-11 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-11.active > a,.menu-holder ul li .sub-menu li.menu-item-category-11 > a:hover,.post .single_category_title.category-link-11 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-11 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-11.boxed-link,.category_title.cat-11:before,.category-title.style1 .category-header.cat-11 {background-color:#dd3333;}.post.carousel-style2[data-catid="11"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-39 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-39 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-39 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-39.active > a,.menu-holder ul li .sub-menu li.menu-item-category-39 > a:hover,.post .single_category_title.category-link-39 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-39 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-39.boxed-link,.category_title.cat-39:before,.category-title.style1 .category-header.cat-39 {background-color:#dd3333;}.post.carousel-style2[data-catid="39"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-10 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-10 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-10 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-10.active > a,.menu-holder ul li .sub-menu li.menu-item-category-10 > a:hover,.post .single_category_title.category-link-10 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-10 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-10.boxed-link,.category_title.cat-10:before,.category-title.style1 .category-header.cat-10 {background-color:#dd3333;}.post.carousel-style2[data-catid="10"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-9 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-9 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-9 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-9.active > a,.menu-holder ul li .sub-menu li.menu-item-category-9 > a:hover,.post .single_category_title.category-link-9 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-9 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-9.boxed-link,.category_title.cat-9:before,.category-title.style1 .category-header.cat-9 {background-color:#dd3333;}.post.carousel-style2[data-catid="9"]:hover {background-color:#dd3333;}.category-title.style1 .category-header.cat-9 {background-image:url(https://www.karebatoraja.com/wp-content/uploads/2017/01/images-9.jpg);}.header .menu-holder ul.sf-menu > li.menu-item-category-1531 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-1531 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-1531 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-1531.active > a,.menu-holder ul li .sub-menu li.menu-item-category-1531 > a:hover,.post .single_category_title.category-link-1531 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-1531 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-1531.boxed-link,.category_title.cat-1531:before,.category-title.style1 .category-header.cat-1531 {background-color:#dd3333;}.post.carousel-style2[data-catid="1531"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-4 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-4 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-4 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-4.active > a,.menu-holder ul li .sub-menu li.menu-item-category-4 > a:hover,.post .single_category_title.category-link-4 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-4 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-4.boxed-link,.category_title.cat-4:before,.category-title.style1 .category-header.cat-4 {background-color:#dd3333;}.post.carousel-style2[data-catid="4"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-1530 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-1530 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-1530 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-1530.active > a,.menu-holder ul li .sub-menu li.menu-item-category-1530 > a:hover,.post .single_category_title.category-link-1530 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-1530 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-1530.boxed-link,.category_title.cat-1530:before,.category-title.style1 .category-header.cat-1530 {background-color:#dd3333;}.post.carousel-style2[data-catid="1530"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-37 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-37 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-37 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-37.active > a,.menu-holder ul li .sub-menu li.menu-item-category-37 > a:hover,.post .single_category_title.category-link-37 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-37 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-37.boxed-link,.category_title.cat-37:before,.category-title.style1 .category-header.cat-37 {background-color:#dd3333;}.post.carousel-style2[data-catid="37"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-2128 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-2128 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-2128 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-2128.active > a,.menu-holder ul li .sub-menu li.menu-item-category-2128 > a:hover,.post .single_category_title.category-link-2128 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-2128 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-2128.boxed-link,.category_title.cat-2128:before,.category-title.style1 .category-header.cat-2128 {background-color:#dd3333;}.post.carousel-style2[data-catid="2128"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-3795 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-3795 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-3795 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-3795.active > a,.menu-holder ul li .sub-menu li.menu-item-category-3795 > a:hover,.post .single_category_title.category-link-3795 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-3795 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-3795.boxed-link,.category_title.cat-3795:before,.category-title.style1 .category-header.cat-3795 {background-color:#dd3333;}.post.carousel-style2[data-catid="3795"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-38 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-38 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-38 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-38.active > a,.menu-holder ul li .sub-menu li.menu-item-category-38 > a:hover,.post .single_category_title.category-link-38 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-38 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-38.boxed-link,.category_title.cat-38:before,.category-title.style1 .category-header.cat-38 {background-color:#dd3333;}.post.carousel-style2[data-catid="38"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-40 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-40 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-40 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-40.active > a,.menu-holder ul li .sub-menu li.menu-item-category-40 > a:hover,.post .single_category_title.category-link-40 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-40 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-40.boxed-link,.category_title.cat-40:before,.category-title.style1 .category-header.cat-40 {background-color:#dd3333;}.post.carousel-style2[data-catid="40"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-1 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-1 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-1 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-1.active > a,.menu-holder ul li .sub-menu li.menu-item-category-1 > a:hover,.post .single_category_title.category-link-1 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-1 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-1.boxed-link,.category_title.cat-1:before,.category-title.style1 .category-header.cat-1 {background-color:#dd3333;}.post.carousel-style2[data-catid="1"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-7 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-7 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-7 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-7.active > a,.menu-holder ul li .sub-menu li.menu-item-category-7 > a:hover,.post .single_category_title.category-link-7 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-7 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-7.boxed-link,.category_title.cat-7:before,.category-title.style1 .category-header.cat-7 {background-color:#dd3333;}.post.carousel-style2[data-catid="7"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-41 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-41 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-41 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-41.active > a,.menu-holder ul li .sub-menu li.menu-item-category-41 > a:hover,.post .single_category_title.category-link-41 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-41 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-41.boxed-link,.category_title.cat-41:before,.category-title.style1 .category-header.cat-41 {background-color:#dd3333;}.post.carousel-style2[data-catid="41"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-42 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-42 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-42 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-42.active > a,.menu-holder ul li .sub-menu li.menu-item-category-42 > a:hover,.post .single_category_title.category-link-42 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-42 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-42.boxed-link,.category_title.cat-42:before,.category-title.style1 .category-header.cat-42 {background-color:#dd3333;}.post.carousel-style2[data-catid="42"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-2990 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-2990 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-2990 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-2990.active > a,.menu-holder ul li .sub-menu li.menu-item-category-2990 > a:hover,.post .single_category_title.category-link-2990 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-2990 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-2990.boxed-link,.category_title.cat-2990:before,.category-title.style1 .category-header.cat-2990 {background-color:#dd3333;}.post.carousel-style2[data-catid="2990"]:hover {background-color:#dd3333;}.header .menu-holder ul.sf-menu > li.menu-item-category-5 > a:hover,.menu-holder.style1 ul.sf-menu > li.menu-item-category-5 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-5 > a:hover,.menu-holder ul li.menu-item-mega-parent .thb_mega_menu_holder .thb_mega_menu li.menu-item-category-5.active > a,.menu-holder ul li .sub-menu li.menu-item-category-5 > a:hover,.post .single_category_title.category-link-5 {color:#dd3333;}.menu-holder ul.sf-menu > li.menu-item-category-5 > a + .thb_mega_menu_holder {border-color:#dd3333;}.post .single_category_title.category-boxed-link-5.boxed-link,.category_title.cat-5:before,.category-title.style1 .category-header.cat-5 {background-color:#dd3333;}.post.carousel-style2[data-catid="5"]:hover {background-color:#dd3333;}.category-title.style1 .category-header.cat-5 {background-image:url(https://www.karebatoraja.com/wp-content/uploads/2017/01/Kar.jpg);}#subfooter {background-color:#ad4227 !important;}@media only screen and (min-width:48.063em) {#subfooter .subfooter-menu-holder .logolink .logoimg {max-height:200px;}}
</style>
<link rel="stylesheet" id="style-css"  href="https://www.karebatoraja.com/wp-content/themes/goodlife-wp/style.css" media="all" />
<link rel="stylesheet" id="thb-google-fonts-css"  href="https://fonts.googleapis.com/css?family&#038;subset=latin,latin-ext" media="all" />
<link rel="stylesheet" id="rpt_front_style-css"  href="https://www.karebatoraja.com/wp-content/plugins/related-posts-thumbnails/assets/css/front.css?ver=1.6.2" media="all" />
<link rel="stylesheet" id="heateor_sss_frontend_css-css"  href="https://www.karebatoraja.com/wp-content/plugins/sassy-social-share/public/css/sassy-social-share-public.css?ver=3.3.10" media="all" />
<link rel="stylesheet" id="heateor_sss_sharing_default_svg-css"  href="https://www.karebatoraja.com/wp-content/plugins/sassy-social-share/admin/css/sassy-social-share-svg.css?ver=3.3.10" media="all" />
<link rel="stylesheet" id="js_composer_front-css"  href="https://www.karebatoraja.com/wp-content/plugins/js_composer/assets/css/js_composer.min.css?ver=5.6" media="all" />
<script src="https://www.karebatoraja.com/wp-includes/js/jquery/jquery.js?ver=1.12.4-wp"></script>
<script src="https://www.karebatoraja.com/wp-includes/js/jquery/jquery-migrate.min.js?ver=1.4.1"></script>
<link rel='https://api.w.org/' href='https://www.karebatoraja.com/wp-json/' />
<link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.karebatoraja.com/xmlrpc.php?rsd" />
<link rel="wlwmanifest" type="application/wlwmanifest+xml" href="https://www.karebatoraja.com/wp-includes/wlwmanifest.xml" /> 
<meta name="generator" content="WordPress 5.4.2" />
<link rel="canonical" href="https://www.karebatoraja.com/" />
<link rel='shortlink' href='https://www.karebatoraja.com/' />
<link rel="alternate" type="application/json+oembed" href="https://www.karebatoraja.com/wp-json/oembed/1.0/embed?url=https%3A%2F%2Fwww.karebatoraja.com%2F" />
<link rel="alternate" type="text/xml+oembed" href="https://www.karebatoraja.com/wp-json/oembed/1.0/embed?url=https%3A%2F%2Fwww.karebatoraja.com%2F&#038;format=xml" />
<meta name="generator" content="Powered by WPBakery Page Builder - drag and drop page builder for WordPress."/>
<!--[if lte IE 9]><link rel="stylesheet" type="text/css" href="https://www.karebatoraja.com/wp-content/plugins/js_composer/assets/css/vc_lte_ie9.min.css" media="screen"><![endif]-->      <style>
      #related_posts_thumbnails li{
          border-right: 1px solid #DDDDDD;
          background-color: #ffffff      }
      #related_posts_thumbnails li:hover{
          background-color: #efefef;
      }
      .relpost_content{
          font-size: 16px;
          color: #0c0c0c;
      }
      .relpost-block-single{
          background-color: #ffffff;
          border-right: 1px solid  #DDDDDD;
          border-left: 1px solid  #DDDDDD;
          margin-right: -1px;
      }
      .relpost-block-single:hover{
          background-color: #efefef;
      }
      </style>

  <link rel="icon" href="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-32x32.png" sizes="32x32" />
<link rel="icon" href="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-192x192.png" sizes="192x192" />
<link rel="apple-touch-icon" href="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-180x180.png" />
<meta name="msapplication-TileImage" content="https://www.karebatoraja.com/wp-content/uploads/2018/02/cropped-LOGO-PATEN-1-1-270x270.png" />
<noscript><style type="text/css"> .wpb_animate_when_almost_visible { opacity: 1; }</style></noscript>
<!-- START - Open Graph and Twitter Card Tags 3.0.0 -->
 <!-- Facebook Open Graph -->
  <meta property="og:locale" content="id_ID"/>
  <meta property="og:site_name" content="Kareba Toraja"/>
  <meta property="og:title" content="Home"/>
  <meta property="og:url" content="https://www.karebatoraja.com"/>
  <meta property="og:type" content="website"/>
  <meta property="og:description" content="Home"/>
  <meta property="og:image" content="https://www.karebatoraja.com/wp-content/uploads/2017/01/Jutaan_Cinta2.jpg"/>
  <meta property="og:image:url" content="https://www.karebatoraja.com/wp-content/uploads/2017/01/Jutaan_Cinta2.jpg"/>
  <meta property="og:image:secure_url" content="https://www.karebatoraja.com/wp-content/uploads/2017/01/Jutaan_Cinta2.jpg"/>
 <!-- Google+ / Schema.org -->
  <meta itemprop="name" content="Home"/>
  <meta itemprop="headline" content="Home"/>
  <meta itemprop="description" content="Home"/>
  <meta itemprop="image" content="https://www.karebatoraja.com/wp-content/uploads/2017/01/Jutaan_Cinta2.jpg"/>
  <meta itemprop="author" content="adminkareba"/>
 <!-- Twitter Cards -->
  <meta name="twitter:title" content="Home"/>
  <meta name="twitter:url" content="https://www.karebatoraja.com"/>
  <meta name="twitter:description" content="Home"/>
  <meta name="twitter:image" content="https://www.karebatoraja.com/wp-content/uploads/2017/01/Jutaan_Cinta2.jpg"/>
  <meta name="twitter:card" content="summary_large_image"/>
 <!-- SEO -->
 <!-- Misc. tags -->
 <!-- is_singular -->
<!-- END - Open Graph and Twitter Card Tags 3.0.0 -->
	
</head>
<body data-rsssl=1 class="home page-template-default page page-id-3817 lazy-load-on thb_ads_header_mobile_on thb-lightbox-on thb-capitalize-off wpb-js-composer js-comp-ver-5.6 vc_responsive">
<div id="wrapper" class="open">
	
	<!-- Start Mobile Menu -->
			<nav id="mobile-menu">
			<div class="custom_scroll" id="menu-scroll">
				<div>
																				  <ul id="menu-navigation" class="mobile-menu"><li id="menu-item-20788" class=" menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-3817 current_page_item menu-item-20788"><a href="https://www.karebatoraja.com/">Home</a></li>
<li id="menu-item-4264" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4264 menu-item-category-4"><a href="https://www.karebatoraja.com/category/kareba-toraya/">KAREBA TORAYA</a></li>
<li id="menu-item-4265" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4265 menu-item-category-41"><a href="https://www.karebatoraja.com/category/kareba-toraya/tana-toraja/">TANA TORAJA</a></li>
<li id="menu-item-4266" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4266 menu-item-category-42"><a href="https://www.karebatoraja.com/category/kareba-toraya/toraja-utara/">TORAJA UTARA</a></li>
<li id="menu-item-4267" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4267 menu-item-category-10"><a href="https://www.karebatoraja.com/category/hl/">HEADLINE</a></li>
<li id="menu-item-4268" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4268 menu-item-category-8"><a href="https://www.karebatoraja.com/category/diaspora/">DIASPORA</a></li>
<li id="menu-item-4269" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4269 menu-item-category-1"><a href="https://www.karebatoraja.com/category/pendidikan/">PENDIDIKAN</a></li>
<li id="menu-item-4270" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4270 menu-item-category-9"><a href="https://www.karebatoraja.com/category/hukun-dan-kriminal/">HUKUM &#038; KRIMINAL</a></li>
<li id="menu-item-4271" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4271 menu-item-category-11"><a href="https://www.karebatoraja.com/category/ekobis/">EKOBIS</a></li>
<li id="menu-item-4272" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4272 menu-item-category-31"><a href="https://www.karebatoraja.com/category/foto-foto/">BERITA FOTO</a></li>
<li id="menu-item-4273" class=" menu-item menu-item-type-taxonomy menu-item-object-category menu-item-4273 menu-item-category-39"><a href="https://www.karebatoraja.com/category/wisata/event/">EVENT</a></li>
</ul>															<div class="social-links">
										<a href="https://www.facebook.com/karebatoraya/" class="facebook icon-1x" target="_blank"><i class="fa fa-facebook"></i></a>
																										<a href="https://www.youtube.com/channel/UCisnXwY_bivukR2zNSm9lqg" class="youtube icon-1x" target="_blank"><i class="fa fa-youtube"></i></a>
																</div>
					<div class="menu-footer">
											</div>
				</div>
			</div>
		</nav>
		<!-- End Mobile Menu -->
	
	<!-- Start Content Container -->
	<div id="content-container">
		<!-- Start Content Click Capture -->
		<div class="click-capture"></div>
		<!-- End Content Click Capture -->
		<!-- Start Sub Header -->
<div class="subheader show-for-large light boxed">
	<div class="row full-width-row">
		<div class="small-12 medium-6 large-7 columns">
			<nav class="subheader-menu">
				<div class="sf-menu"><ul>
<li class="page_item page-item-3817 current_page_item"><a href="https://www.karebatoraja.com/" aria-current="page">Home</a></li>
<li class="page_item page-item-4488"><a href="https://www.karebatoraja.com/karier/">Karier</a></li>
<li class="page_item page-item-1151"><a href="https://www.karebatoraja.com/pedoman-media-siber/">Pedoman Media Siber</a></li>
<li class="page_item page-item-1107"><a href="https://www.karebatoraja.com/redaksi/">Redaksi</a></li>
</ul></div>
			</nav>
		</div>
		<div class="small-12 medium-6 large-5 columns text-right">
			<ul class="sf-menu right-menu">
				
					<li class="menu-item-has-children">
		<a href="#">Follow Us</a>
		<ul class="sub-menu">
						<li><a href="https://www.facebook.com/karebatoraya/" class="facebook icon-1x" target="_blank"><i class="fa fa-facebook"></i> Facebook</a></li>
																																							<li><a href="https://www.youtube.com/channel/UCisnXwY_bivukR2zNSm9lqg" class="youtube icon-1x" target="_blank"><i class="fa fa-youtube"></i> Youtube</a></li>
																							</ul>
	</li>
													<li>	<div class="quick_search">
		<a href="#" class="quick_toggle"></a>
		<svg version="1.1" class="quick_search_icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="20px" height="20px" viewBox="0 -1 20 18" xml:space="preserve">
			<path d="M18.96,16.896l-4.973-4.926c1.02-1.255,1.633-2.846,1.633-4.578c0-4.035-3.312-7.317-7.385-7.317S0.849,3.358,0.849,7.393
				c0,4.033,3.313,7.316,7.386,7.316c1.66,0,3.188-0.552,4.422-1.471l4.998,4.95c0.181,0.179,0.416,0.268,0.652,0.268
				c0.235,0,0.472-0.089,0.652-0.268C19.32,17.832,19.32,17.253,18.96,16.896z M2.693,7.393c0-3.027,2.485-5.489,5.542-5.489
				c3.054,0,5.541,2.462,5.541,5.489c0,3.026-2.486,5.489-5.541,5.489C5.179,12.882,2.693,10.419,2.693,7.393z"/>
		</svg>
		<!-- Start SearchForm -->
<form method="get" class="searchform" role="search" action="https://www.karebatoraja.com/">
    <fieldset>
    	<input name="s" type="text" placeholder="Search" class="s">
    	<input type="submit" value="Search">
    </fieldset>
</form>
<!-- End SearchForm -->	</div>
	
</li>			</ul>
		</div>
	</div>
</div>
<!-- End Sub Header -->
<!-- Start Header -->
<header class="header style1 boxed light">
	<div class="row">
		<div class="small-2 columns text-left mobile-icon-holder">
			<a href="#" data-target="open-menu" class="mobile-toggle"><i class="fa fa-bars"></i></a>
		</div>
		<div class="small-8 large-4 columns logo">
			<div>
								<a href="https://www.karebatoraja.com/" class="logolink">
					<img src="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg" class="logoimg" alt="Kareba Toraja"/>
				</a>
			</div>
		</div>
		<div class="small-2 columns text-right mobile-share-holder">
			<div>
				<div class="quick_search">
		<a href="#" class="quick_toggle"></a>
		<svg version="1.1" class="quick_search_icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="20px" height="20px" viewBox="0 -1 20 18" xml:space="preserve">
			<path d="M18.96,16.896l-4.973-4.926c1.02-1.255,1.633-2.846,1.633-4.578c0-4.035-3.312-7.317-7.385-7.317S0.849,3.358,0.849,7.393
				c0,4.033,3.313,7.316,7.386,7.316c1.66,0,3.188-0.552,4.422-1.471l4.998,4.95c0.181,0.179,0.416,0.268,0.652,0.268
				c0.235,0,0.472-0.089,0.652-0.268C19.32,17.832,19.32,17.253,18.96,16.896z M2.693,7.393c0-3.027,2.485-5.489,5.542-5.489
				c3.054,0,5.541,2.462,5.541,5.489c0,3.026-2.486,5.489-5.541,5.489C5.179,12.882,2.693,10.419,2.693,7.393z"/>
		</svg>
		<!-- Start SearchForm -->
<form method="get" class="searchform" role="search" action="https://www.karebatoraja.com/">
    <fieldset>
    	<input name="s" type="text" placeholder="Search" class="s">
    	<input type="submit" value="Search">
    </fieldset>
</form>
<!-- End SearchForm -->	</div>
	
			</div>
		</div>
		<div class="small-12 large-8 columns thb-a">
			<script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<!-- TOP ARTIKEL -->
<ins class="adsbygoogle"
     style="display:block"
     data-ad-client="ca-pub-7321028307295773"
     data-ad-slot="7131809443"
     data-ad-format="auto"></ins>
<script>
     (adsbygoogle = window.adsbygoogle || []).push({});
</script>		</div>
	</div>
</header>
<!-- End Header -->
<div id="navholder" class="dark-menu boxed">
	<div class="row">
		<div class="small-12 columns">
			<nav class="menu-holder style1 dark" id="menu_width">
								  <ul id="menu-kareba-menu" class="sf-menu style1"><li id="menu-item-4274" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-home current-menu-item page_item page-item-3817 current_page_item menu-item-4274"><a href="https://www.karebatoraja.com/">HOME</a></li>
<li id="menu-item-936" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-936 menu-item-category-4"><a href="https://www.karebatoraja.com/category/kareba-toraya/">KAREBA TORAJA</a>


<ul class="sub-menu ">
	<li id="menu-item-1465" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1465 menu-item-category-41"><a href="https://www.karebatoraja.com/category/kareba-toraya/tana-toraja/">TANA TORAJA</a></li>
	<li id="menu-item-1466" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1466 menu-item-category-42"><a href="https://www.karebatoraja.com/category/kareba-toraya/toraja-utara/">TORAJA UTARA</a></li>
</ul>
</li>
<li id="menu-item-15724" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-15724 menu-item-category-3796"><a href="https://www.karebatoraja.com/category/berita/">BERITA</a>


<ul class="sub-menu ">
	<li id="menu-item-934" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-934 menu-item-category-7"><a href="https://www.karebatoraja.com/category/politik/">POLITIK</a></li>
	<li id="menu-item-937" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-937 menu-item-category-9"><a href="https://www.karebatoraja.com/category/hukun-dan-kriminal/">HUKUM &#038; KRIMINAL</a></li>
	<li id="menu-item-935" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-935 menu-item-category-11"><a href="https://www.karebatoraja.com/category/ekobis/">EKOBIS</a></li>
	<li id="menu-item-1449" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1449 menu-item-category-40"><a href="https://www.karebatoraja.com/category/olah-raga/">OLAH RAGA</a></li>
	<li id="menu-item-939" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-939 menu-item-category-1"><a href="https://www.karebatoraja.com/category/pendidikan/">PENDIDIKAN</a></li>
</ul>
</li>
<li id="menu-item-933" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-933 menu-item-category-5"><a href="https://www.karebatoraja.com/category/wisata/">WISATA</a>


<ul class="sub-menu ">
	<li id="menu-item-1445" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1445 menu-item-category-38"><a href="https://www.karebatoraja.com/category/wisata/objek-wisata/">OBJEK WISATA</a></li>
	<li id="menu-item-1443" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1443 menu-item-category-37"><a href="https://www.karebatoraja.com/category/wisata/kuliner/">KULINER</a></li>
	<li id="menu-item-1447" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1447 menu-item-category-39"><a href="https://www.karebatoraja.com/category/wisata/event/">EVENT</a></li>
</ul>
</li>
<li id="menu-item-938" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-938 menu-item-category-8"><a href="https://www.karebatoraja.com/category/diaspora/">DIASPORA</a></li>
<li id="menu-item-1440" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1440 menu-item-category-34"><a href="https://www.karebatoraja.com/category/budaya/">BUDAYA</a></li>
<li id="menu-item-1462" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-1462 menu-item-category-31"><a href="https://www.karebatoraja.com/category/foto-foto/">FOTO</a></li>
<li id="menu-item-5785" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-5785 menu-item-category-1530"><a href="https://www.karebatoraja.com/category/komunitas/">KOMUNITAS</a></li>
<li id="menu-item-19667" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-19667 menu-item-category-4683"><a href="https://www.karebatoraja.com/category/suara-netisen/">SUARA NETIZEN</a></li>
<li id="menu-item-15723" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-15723 menu-item-category-3795"><a href="https://www.karebatoraja.com/category/nasional/">NASIONAL</a></li>
<li id="menu-item-20528" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20528 menu-item-category-4931"><a href="https://www.karebatoraja.com/category/sulsel/">Sulsel</a></li>
<li id="menu-item-11026" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-11026 menu-item-category-2990"><a href="https://www.karebatoraja.com/category/video/">Video</a></li>
</ul>									<div class="menu-right-content">
							<div class="quick_search">
		<a href="#" class="quick_toggle"></a>
		<svg version="1.1" class="quick_search_icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="20px" height="20px" viewBox="0 -1 20 18" xml:space="preserve">
			<path d="M18.96,16.896l-4.973-4.926c1.02-1.255,1.633-2.846,1.633-4.578c0-4.035-3.312-7.317-7.385-7.317S0.849,3.358,0.849,7.393
				c0,4.033,3.313,7.316,7.386,7.316c1.66,0,3.188-0.552,4.422-1.471l4.998,4.95c0.181,0.179,0.416,0.268,0.652,0.268
				c0.235,0,0.472-0.089,0.652-0.268C19.32,17.832,19.32,17.253,18.96,16.896z M2.693,7.393c0-3.027,2.485-5.489,5.542-5.489
				c3.054,0,5.541,2.462,5.541,5.489c0,3.026-2.486,5.489-5.541,5.489C5.179,12.882,2.693,10.419,2.693,7.393z"/>
		</svg>
		<!-- Start SearchForm -->
<form method="get" class="searchform" role="search" action="https://www.karebatoraja.com/">
    <fieldset>
    	<input name="s" type="text" placeholder="Search" class="s">
    	<input type="submit" value="Search">
    </fieldset>
</form>
<!-- End SearchForm -->	</div>
	
	</div>
			</nav>
		</div>
	</div>
</div>		
		<div role="main" class="boxed">
<div class="post post-detail post-3817 page type-page status-publish hentry" id="post-3817">
			<div class="post-content">
			<div class="row row row-fluid"><div class="main_content wpb_column columns small-12 medium-8"><div class="vc_column-inner  "><div class="wpb_wrapper"><aside class="gap cf" style="height:10px;"></aside>	<div class="slick grid post-slider post-slider-style2" data-columns="1" data-autoplay="false" data-pagination="false" data-navigation="true" id="thb-post-slider79">
									<div>
					<article itemscope itemtype="http://schema.org/Article" class="post post-overlay bottom-gradient large-padding block-12 no-margin bottom-title post-27586 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-toraja-utara tag-bantah-positif-covid-19 tag-batagor-kang-ujang-rantepao tag-klarifikasi-positif-covid-19 tag-positif-covid-19-toraja-utara tag-warung-batagor-kang-ujang" style="background-image: url(https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1-1145x550.jpg);">
	<figure class="post-gallery">
		<a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" rel="bookmark" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
					</a>
		
		<header class="post-title entry-header">
						<div class="post-category"><a href="https://www.karebatoraja.com/category/hl/" class="single_category_title boxed-link category-boxed-link-10" title="HEADLINE">HEADLINE</a></div>
			<h4 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona</a></h4>				<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T20:15:12+08:00" itemprop="datePublished" content="2020-07-24T20:15:12+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T20:24:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" content="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/">
							</aside>
												</header>
		
	</figure>
</article>				</div>
														<div>
					<article itemscope itemtype="http://schema.org/Article" class="post post-overlay bottom-gradient large-padding block-12 no-margin bottom-title post-27572 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-hukun-dan-kriminal tag-operasi-patuh-2020 tag-polres-tana-toraja tag-polres-toraja-utara" style="background-image: url(https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-2020-Res-Tator-1145x550.jpg);">
	<figure class="post-gallery">
		<a href="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" rel="bookmark" title="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">
					</a>
		
		<header class="post-title entry-header">
						<div class="post-category"><a href="https://www.karebatoraja.com/category/hl/" class="single_category_title boxed-link category-boxed-link-10" title="HEADLINE">HEADLINE</a></div>
			<h4 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" title="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020</a></h4>				<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T19:09:36+08:00" itemprop="datePublished" content="2020-07-23T19:09:36+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T19:09:36+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-2020-Res-Tator.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" content="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/">
							</aside>
												</header>
		
	</figure>
</article>				</div>
														<div>
					<article itemscope itemtype="http://schema.org/Article" class="post post-overlay bottom-gradient large-padding block-12 no-margin bottom-title post-27558 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-nasional category-toraja-utara tag-batagor-kang-ujang-rantepao tag-elisabeth-zakaria tag-positif-covid-19 tag-positif-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara" style="background-image: url(https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1145x550.jpg);">
	<figure class="post-gallery">
		<a href="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/" rel="bookmark" title="Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan">
					</a>
		
		<header class="post-title entry-header">
						<div class="post-category"><a href="https://www.karebatoraja.com/category/hl/" class="single_category_title boxed-link category-boxed-link-10" title="HEADLINE">HEADLINE</a></div>
			<h4 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/" title="Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan">Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan</a></h4>				<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-22T20:01:07+08:00" itemprop="datePublished" content="2020-07-22T20:01:07+08:00">Juli 22, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T13:27:13+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/" content="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/">
							</aside>
												</header>
		
	</figure>
</article>				</div>
														<div>
					<article itemscope itemtype="http://schema.org/Article" class="post post-overlay bottom-gradient large-padding block-12 no-margin bottom-title post-27548 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-nasional category-toraja-utara tag-pasien-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara tag-sembuh-corona-toraja-utara tag-sembuh-covid-19" style="background-image: url(https://www.karebatoraja.com/wp-content/uploads/2020/07/Sembuh-Corona-Toraja-Utara-1145x550.jpg);">
	<figure class="post-gallery">
		<a href="https://www.karebatoraja.com/terbaru-semua-pasien-covid-19-di-toraja-utara-dinyatakan-sembuh-1-meninggal/" rel="bookmark" title="TERBARU: Semua Pasien Covid-19 di Toraja Utara Dinyatakan Sembuh, 1 Meninggal">
					</a>
		
		<header class="post-title entry-header">
						<div class="post-category"><a href="https://www.karebatoraja.com/category/hl/" class="single_category_title boxed-link category-boxed-link-10" title="HEADLINE">HEADLINE</a></div>
			<h4 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/terbaru-semua-pasien-covid-19-di-toraja-utara-dinyatakan-sembuh-1-meninggal/" title="TERBARU: Semua Pasien Covid-19 di Toraja Utara Dinyatakan Sembuh, 1 Meninggal">TERBARU: Semua Pasien Covid-19 di Toraja Utara Dinyatakan Sembuh, 1 Meninggal</a></h4>				<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-21T21:00:05+08:00" itemprop="datePublished" content="2020-07-21T21:00:05+08:00">Juli 21, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="TERBARU: Semua Pasien Covid-19 di Toraja Utara Dinyatakan Sembuh, 1 Meninggal">
		<meta itemprop="dateModified" class="date updated" content="2020-07-21T21:00:05+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Sembuh-Corona-Toraja-Utara.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/terbaru-semua-pasien-covid-19-di-toraja-utara-dinyatakan-sembuh-1-meninggal/" content="https://www.karebatoraja.com/terbaru-semua-pasien-covid-19-di-toraja-utara-dinyatakan-sembuh-1-meninggal/">
							</aside>
												</header>
		
	</figure>
</article>				</div>
								</div>
		<aside class="gap cf" style="height:10px;"></aside>		<div class="row posts endcolumn post-grid-style2" data-loadmore="#loadmore-11" data-rand="11">
						
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27586 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-toraja-utara tag-bantah-positif-covid-19 tag-batagor-kang-ujang-rantepao tag-klarifikasi-positif-covid-19 tag-positif-covid-19-toraja-utara tag-warung-batagor-kang-ujang">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" rel="bookmark" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T20:15:12+08:00" itemprop="datePublished" content="2020-07-24T20:15:12+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T20:24:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" content="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27581 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto tag-banjir-bandang tag-banjir-bandang-masamba tag-korban-banjir-bandang-masamba tag-relawan-sentuhan-peduli-sesama">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" rel="bookmark" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T19:09:33+08:00" itemprop="datePublished" content="2020-07-24T19:09:33+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T19:09:33+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" content="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27578 type-post status-publish format-standard has-post-thumbnail hentry category-komunitas tag-agen-brilink tag-bank-bri tag-paguyuban-agen-brilink-toraja-sikamali">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" rel="bookmark" title="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/BRILink-Peduli-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" title="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:58:29+08:00" itemprop="datePublished" content="2020-07-23T21:58:29+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:58:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/BRILink-Peduli.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" content="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27575 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-covid-19-sembuh tag-positif-covid-19 tag-positif-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara tag-sembuh-covid-19">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" rel="bookmark" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:22:41+08:00" itemprop="datePublished" content="2020-07-23T21:22:41+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:22:41+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" content="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27572 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-hukun-dan-kriminal tag-operasi-patuh-2020 tag-polres-tana-toraja tag-polres-toraja-utara">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" rel="bookmark" title="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-2020-Res-Tator-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" title="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T19:09:36+08:00" itemprop="datePublished" content="2020-07-23T19:09:36+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T19:09:36+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-2020-Res-Tator.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" content="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27569 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-bunuh-diri tag-kecamatan-sopai tag-meninggal-bunuh-diri tag-nonongan tag-polres-toraja-utara tag-polsek-sopai">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" rel="bookmark" title="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Bunuh-Diri-Sopai-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" title="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T18:38:13+08:00" itemprop="datePublished" content="2020-07-23T18:38:13+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T18:38:13+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Bunuh-Diri-Sopai.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" content="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27563 type-post status-publish format-standard has-post-thumbnail hentry category-politik category-toraja-utara tag-dedy-palimbong tag-frederik-victor-palimbong tag-ombas tag-partai-demokrat tag-pilkada-toraja-utara-2020 tag-yohanis-bassang">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/" rel="bookmark" title="Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Surat-Tugas-Demokrat-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/" title="Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong">Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-22T22:09:24+08:00" itemprop="datePublished" content="2020-07-22T22:09:24+08:00">Juli 22, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong">
		<meta itemprop="dateModified" class="date updated" content="2020-07-22T22:09:24+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Surat-Tugas-Demokrat.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/" content="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27560 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-biaya-rapid-test tag-dinas-kesehatan-toraja-utara tag-elisabeth-zakaria tag-kadiskes-toraja-utara tag-rapid-test-covid-19">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/kadiskes-toraja-utara-rapid-test-di-puskesmas-gratis/" rel="bookmark" title="Kadiskes Toraja Utara: Rapid Test di Puskesmas Gratis">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Elisabeth-Zakaria-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/kadiskes-toraja-utara-rapid-test-di-puskesmas-gratis/" title="Kadiskes Toraja Utara: Rapid Test di Puskesmas Gratis">Kadiskes Toraja Utara: Rapid Test di Puskesmas Gratis</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-22T21:21:48+08:00" itemprop="datePublished" content="2020-07-22T21:21:48+08:00">Juli 22, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Kadiskes Toraja Utara: Rapid Test di Puskesmas Gratis">
		<meta itemprop="dateModified" class="date updated" content="2020-07-22T21:21:48+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Elisabeth-Zakaria.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/kadiskes-toraja-utara-rapid-test-di-puskesmas-gratis/" content="https://www.karebatoraja.com/kadiskes-toraja-utara-rapid-test-di-puskesmas-gratis/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27558 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-nasional category-toraja-utara tag-batagor-kang-ujang-rantepao tag-elisabeth-zakaria tag-positif-covid-19 tag-positif-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/" rel="bookmark" title="Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/" title="Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan">Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-22T20:01:07+08:00" itemprop="datePublished" content="2020-07-22T20:01:07+08:00">Juli 22, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Ada Warga Positif Corona, Pengunjung dan Pembeli Batagor Kang Ujang Rantepao Diminta Periksa Kesehatan">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T13:27:13+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/" content="https://www.karebatoraja.com/ada-warga-positif-corona-pengunjung-dan-pembeli-batagor-kang-ujang-rantepao-diminta-periksa-kesehatan/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27551 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-12-tahun-kabupaten-toraja-utara tag-hut-kabupaten-toraja-utara tag-hut-kabupaten-toraja-utara-12 tag-kalatiku-paembonan tag-yosia-rinto-kadang">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/syukuran-hari-jadi-kabupaten-toraja-utara-ke-12-kalatiku-ungkap-prestasi-pemerintah/" rel="bookmark" title="Syukuran Hari Jadi Kabupaten Toraja Utara ke-12, Kalatiku Ungkap Prestasi Pemerintah">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/HUT-Kabupaten-Toraja-Utara-12-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/syukuran-hari-jadi-kabupaten-toraja-utara-ke-12-kalatiku-ungkap-prestasi-pemerintah/" title="Syukuran Hari Jadi Kabupaten Toraja Utara ke-12, Kalatiku Ungkap Prestasi Pemerintah">Syukuran Hari Jadi Kabupaten Toraja Utara ke-12, Kalatiku Ungkap Prestasi Pemerintah</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-21T21:42:26+08:00" itemprop="datePublished" content="2020-07-21T21:42:26+08:00">Juli 21, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Syukuran Hari Jadi Kabupaten Toraja Utara ke-12, Kalatiku Ungkap Prestasi Pemerintah">
		<meta itemprop="dateModified" class="date updated" content="2020-07-21T21:42:26+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/HUT-Kabupaten-Toraja-Utara-12.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/syukuran-hari-jadi-kabupaten-toraja-utara-ke-12-kalatiku-ungkap-prestasi-pemerintah/" content="https://www.karebatoraja.com/syukuran-hari-jadi-kabupaten-toraja-utara-ke-12-kalatiku-ungkap-prestasi-pemerintah/">
							</aside>
		</article>					</div>
												</div>
		
	<aside class="gap cf" style="height:10px;"></aside><div class="row row vc_inner row-fluid"><div class="wpb_column columns small-12 medium-6"><div class="vc_column-inner  "><div class="wpb_wrapper"><aside class="gap cf" style="height:30px;"></aside>		<div class="category-element-holder style6">
									<div class="category_title cat-41">
					<h4>TANA TORAJA</h4>
				</div>
				
			
					<div class="category-element-content" data-style="style6" data-count="4">
  					<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27516 type-post status-publish format-standard has-post-thumbnail hentry category-tana-toraja tag-baznas-tana-toraja tag-janda-miskin tag-kodim-1414-tana-toraja">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/" rel="bookmark" title="Baznas dan Kodim 1414 Tana Toraja Bangun Rumah Baru untuk Warga Miskin di Sangalla Utara">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Baznas-Kodim-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/" title="Baznas dan Kodim 1414 Tana Toraja Bangun Rumah Baru untuk Warga Miskin di Sangalla Utara">Baznas dan Kodim 1414 Tana Toraja Bangun Rumah Baru untuk Warga Miskin di Sangalla Utara</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-19T21:51:12+08:00" itemprop="datePublished" content="2020-07-19T21:51:12+08:00">Juli 19, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Baznas dan Kodim 1414 Tana Toraja Bangun Rumah Baru untuk Warga Miskin di Sangalla Utara">
		<meta itemprop="dateModified" class="date updated" content="2020-07-19T21:51:12+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Baznas-Kodim-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/" content="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/">
							</aside>
			<div class="post-content entry-content small">
		<p>KAREBATORAJA.COM, SANGALLA’ UTARA &#8212; Kolaborasi apik ditunjukkan Badan Zakat Nasional Tana Toraja, Kodim 1414 Tana Toraja dan masyarakat keluraha&hellip;</p>
	</div>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time hide" datetime="2020-07-19T21:51:12+08:00" itemprop="datePublished" content="2020-07-19T21:51:12+08:00">Juli 19, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Baznas dan Kodim 1414 Tana Toraja Bangun Rumah Baru untuk Warga Miskin di Sangalla Utara">
		<meta itemprop="dateModified" class="date updated" content="2020-07-19T21:51:12+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Baznas-Kodim-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/" content="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/">
											<span class="comment">
			<a href="https://www.karebatoraja.com/baznas-dan-kodim-1414-tana-toraja-bangun-rumah-baru-untuk-warga-miskin-di-sangalla-utara/#respond" title="Baznas dan Kodim 1414 Tana Toraja Bangun Rumah Baru untuk Warga Miskin di Sangalla Utara">
				<svg version="1.1" class="comment_icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
			 width="12px" height="13px" viewBox="0 0 12 13" enable-background="new 0 0 12 13" xml:space="preserve">
					<path d="M11.531,0H0.424c-0.23,0-0.419,0.183-0.419,0.407L0.002,8.675c0,0.402-0.097,1.17,1,1.17H3.99v2.367
						c0,0.162,0.057,0.393,0.043,0.752c0.063,0.039,0.105,0.039,0.168,0.039c0.105,0,0.21-0.039,0.294-0.123L7.18,9.845h3.975
						c0.231,0,0.798-0.092,0.798-0.791l-0.002-8.647C11.951,0.183,11.761,0,11.531,0z M11.155,9.054H7.18
						c-0.104,0-0.315,0.119-0.399,0.199l-2.16,2.367V9.75c0-0.225,0.02-0.695-0.631-0.695H0.8l0.044-8.241h10.267L11.155,9.054z"/>
			</svg> 0			</a>
		</span>
					</aside>
		</article>														<ul class="no-list">			<li itemscope itemtype="http://schema.org/Article" class="post listing post-27507 type-post status-publish format-standard has-post-thumbnail hentry category-tana-toraja tag-positif-covid-19-tana-toraja tag-satgas-covid-19-tana-toraja">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/barusan-12-orang-sembuh-satgas-kembali-umumkan-2-kasus-baru-positif-covid-19-di-tana-toraja/" rel="bookmark" title="Barusan 12 Orang Sembuh, Satgas Kembali Umumkan 2 Kasus Baru Positif Covid-19 di Tana Toraja">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kasus-Baru-Tator-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/kareba-toraya/tana-toraja/" class="single_category_title category-link-41" title="TANA TORAJA">TANA TORAJA</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/barusan-12-orang-sembuh-satgas-kembali-umumkan-2-kasus-baru-positif-covid-19-di-tana-toraja/" title="Barusan 12 Orang Sembuh, Satgas Kembali Umumkan 2 Kasus Baru Positif Covid-19 di Tana Toraja">Barusan 12 Orang Sembuh, Satgas Kembali Umumkan 2 Kasus Baru Positif Covid-19 di Tana Toraja</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-18T22:41:37+08:00" itemprop="datePublished" content="2020-07-18T22:41:37+08:00">Juli 18, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Barusan 12 Orang Sembuh, Satgas Kembali Umumkan 2 Kasus Baru Positif Covid-19 di Tana Toraja">
		<meta itemprop="dateModified" class="date updated" content="2020-07-18T22:41:37+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kasus-Baru-Tator.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/barusan-12-orang-sembuh-satgas-kembali-umumkan-2-kasus-baru-positif-covid-19-di-tana-toraja/" content="https://www.karebatoraja.com/barusan-12-orang-sembuh-satgas-kembali-umumkan-2-kasus-baru-positif-covid-19-di-tana-toraja/">
							</aside>
				</div>
</li>												<li itemscope itemtype="http://schema.org/Article" class="post listing post-27504 type-post status-publish format-standard has-post-thumbnail hentry category-sulsel category-tana-toraja tag-banjir-bandang tag-banjir-bandang-masamba tag-korban-banjir-bandang-masamba tag-sentuhan-peduli-sesama tag-victor-datuan-batara">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/dipimpin-wabup-pemkab-tana-toraja-salurkan-bantuan-untuk-korban-banjir-bandang-masamba/" rel="bookmark" title="Dipimpin Wabup, Pemkab Tana Toraja Salurkan Bantuan untuk Korban Banjir Bandang Masamba">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Peduli-Sesama-Masamba-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/sulsel/" class="single_category_title category-link-4931" title="Sulsel">Sulsel</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/dipimpin-wabup-pemkab-tana-toraja-salurkan-bantuan-untuk-korban-banjir-bandang-masamba/" title="Dipimpin Wabup, Pemkab Tana Toraja Salurkan Bantuan untuk Korban Banjir Bandang Masamba">Dipimpin Wabup, Pemkab Tana Toraja Salurkan Bantuan untuk Korban Banjir Bandang Masamba</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-18T21:13:45+08:00" itemprop="datePublished" content="2020-07-18T21:13:45+08:00">Juli 18, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Dipimpin Wabup, Pemkab Tana Toraja Salurkan Bantuan untuk Korban Banjir Bandang Masamba">
		<meta itemprop="dateModified" class="date updated" content="2020-07-18T21:13:45+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Peduli-Sesama-Masamba.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/dipimpin-wabup-pemkab-tana-toraja-salurkan-bantuan-untuk-korban-banjir-bandang-masamba/" content="https://www.karebatoraja.com/dipimpin-wabup-pemkab-tana-toraja-salurkan-bantuan-untuk-korban-banjir-bandang-masamba/">
							</aside>
				</div>
</li>												<li itemscope itemtype="http://schema.org/Article" class="post listing post-27501 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-nasional category-tana-toraja tag-kluster-tongkonan-ada tag-negatif-covid-19 tag-satgas-covid-19-tana-toraja tag-sembuh-covid-19">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/terbaru-12-pasien-positif-covid-19-tana-toraja-dinyatakan-sembuh-total-20-orang-dari-39-kasus/" rel="bookmark" title="TERBARU: 12 Pasien Positif Covid-19 Tana Toraja Dinyatakan Sembuh, Total 20 Orang dari 39 Kasus">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Sembuh-Covid-19-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/hl/" class="single_category_title category-link-10" title="HEADLINE">HEADLINE</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/terbaru-12-pasien-positif-covid-19-tana-toraja-dinyatakan-sembuh-total-20-orang-dari-39-kasus/" title="TERBARU: 12 Pasien Positif Covid-19 Tana Toraja Dinyatakan Sembuh, Total 20 Orang dari 39 Kasus">TERBARU: 12 Pasien Positif Covid-19 Tana Toraja Dinyatakan Sembuh, Total 20 Orang dari 39 Kasus</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-18T19:51:42+08:00" itemprop="datePublished" content="2020-07-18T19:51:42+08:00">Juli 18, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="TERBARU: 12 Pasien Positif Covid-19 Tana Toraja Dinyatakan Sembuh, Total 20 Orang dari 39 Kasus">
		<meta itemprop="dateModified" class="date updated" content="2020-07-18T19:51:42+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Sembuh-Covid-19.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/terbaru-12-pasien-positif-covid-19-tana-toraja-dinyatakan-sembuh-total-20-orang-dari-39-kasus/" content="https://www.karebatoraja.com/terbaru-12-pasien-positif-covid-19-tana-toraja-dinyatakan-sembuh-total-20-orang-dari-39-kasus/">
							</aside>
				</div>
</li>		</ul>		  		</div>
  	</div>
	</div></div></div><div class="wpb_column columns small-12 medium-6"><div class="vc_column-inner  "><div class="wpb_wrapper"><aside class="gap cf" style="height:30px;"></aside>		<div class="category-element-holder style6">
									<div class="category_title cat-42">
					<h4>TORAJA UTARA</h4>
				</div>
				
			
					<div class="category-element-content" data-style="style6" data-count="4">
  					<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27586 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-toraja-utara tag-bantah-positif-covid-19 tag-batagor-kang-ujang-rantepao tag-klarifikasi-positif-covid-19 tag-positif-covid-19-toraja-utara tag-warung-batagor-kang-ujang">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" rel="bookmark" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T20:15:12+08:00" itemprop="datePublished" content="2020-07-24T20:15:12+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T20:24:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" content="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/">
							</aside>
			<div class="post-content entry-content small">
		<p>KAREBATORAJA.COM, RANTEPAO &#8212; Suparno, pemilik Warung Batagor Kang Ujang yang berlokasi di Kelurahan Malango, Kecamatan Rantepao, Toraja Utara, m&hellip;</p>
	</div>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time hide" datetime="2020-07-24T20:15:12+08:00" itemprop="datePublished" content="2020-07-24T20:15:12+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T20:24:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" content="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/">
											<span class="comment">
			<a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/#respond" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
				<svg version="1.1" class="comment_icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
			 width="12px" height="13px" viewBox="0 0 12 13" enable-background="new 0 0 12 13" xml:space="preserve">
					<path d="M11.531,0H0.424c-0.23,0-0.419,0.183-0.419,0.407L0.002,8.675c0,0.402-0.097,1.17,1,1.17H3.99v2.367
						c0,0.162,0.057,0.393,0.043,0.752c0.063,0.039,0.105,0.039,0.168,0.039c0.105,0,0.21-0.039,0.294-0.123L7.18,9.845h3.975
						c0.231,0,0.798-0.092,0.798-0.791l-0.002-8.647C11.951,0.183,11.761,0,11.531,0z M11.155,9.054H7.18
						c-0.104,0-0.315,0.119-0.399,0.199l-2.16,2.367V9.75c0-0.225,0.02-0.695-0.631-0.695H0.8l0.044-8.241h10.267L11.155,9.054z"/>
			</svg> 0			</a>
		</span>
					</aside>
		</article>														<ul class="no-list">			<li itemscope itemtype="http://schema.org/Article" class="post listing post-27575 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-covid-19-sembuh tag-positif-covid-19 tag-positif-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara tag-sembuh-covid-19">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" rel="bookmark" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/kareba-toraya/toraja-utara/" class="single_category_title category-link-42" title="TORAJA UTARA">TORAJA UTARA</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:22:41+08:00" itemprop="datePublished" content="2020-07-23T21:22:41+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:22:41+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" content="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/">
							</aside>
				</div>
</li>												<li itemscope itemtype="http://schema.org/Article" class="post listing post-27569 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-bunuh-diri tag-kecamatan-sopai tag-meninggal-bunuh-diri tag-nonongan tag-polres-toraja-utara tag-polsek-sopai">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" rel="bookmark" title="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Bunuh-Diri-Sopai-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/kareba-toraya/toraja-utara/" class="single_category_title category-link-42" title="TORAJA UTARA">TORAJA UTARA</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" title="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T18:38:13+08:00" itemprop="datePublished" content="2020-07-23T18:38:13+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T18:38:13+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Bunuh-Diri-Sopai.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" content="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/">
							</aside>
				</div>
</li>												<li itemscope itemtype="http://schema.org/Article" class="post listing post-27563 type-post status-publish format-standard has-post-thumbnail hentry category-politik category-toraja-utara tag-dedy-palimbong tag-frederik-victor-palimbong tag-ombas tag-partai-demokrat tag-pilkada-toraja-utara-2020 tag-yohanis-bassang">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/" rel="bookmark" title="Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Surat-Tugas-Demokrat-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/politik/" class="single_category_title category-link-7" title="POLITIK">POLITIK</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/" title="Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong">Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-22T22:09:24+08:00" itemprop="datePublished" content="2020-07-22T22:09:24+08:00">Juli 22, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Partai Demokrat Berikan Surat Tugas kepada Yohanis Bassang – Dedy Palimbong">
		<meta itemprop="dateModified" class="date updated" content="2020-07-22T22:09:24+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Surat-Tugas-Demokrat.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/" content="https://www.karebatoraja.com/partai-demokrat-berikan-surat-tugas-kepada-yohanis-bassang-dedy-palimbong/">
							</aside>
				</div>
</li>		</ul>		  		</div>
  	</div>
	</div></div></div></div>
	<div class="wpb_raw_code wpb_content_element wpb_raw_html" >
		<div class="wpb_wrapper">
			<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<!-- TOP ARTIKEL -->
<ins class="adsbygoogle"
     style="display:inline-block;width:728px;height:90px"
     data-ad-client="ca-pub-7321028307295773"
     data-ad-slot="7131809443"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>
		</div>
	</div>
		<div class="category-element-holder style6">
									<div class="category_title cat-31">
					<h4>BERITA FOTO</h4>
				</div>
				
			
					<div class="category-element-content" data-style="style6" data-count="4">
  					<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27581 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto tag-banjir-bandang tag-banjir-bandang-masamba tag-korban-banjir-bandang-masamba tag-relawan-sentuhan-peduli-sesama">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" rel="bookmark" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T19:09:33+08:00" itemprop="datePublished" content="2020-07-24T19:09:33+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T19:09:33+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" content="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/">
							</aside>
			<div class="post-content entry-content small">
		<p>KAREBATORAJA.COM, MASAMBA &#8212; Hari pertama bergabung dalam misi kemanusiaan untuk Luwu Utara, Tim Relawan Sentuhan Peduli Sesama Pemda Tana Toraja&hellip;</p>
	</div>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time hide" datetime="2020-07-24T19:09:33+08:00" itemprop="datePublished" content="2020-07-24T19:09:33+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T19:09:33+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" content="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/">
											<span class="comment">
			<a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/#respond" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
				<svg version="1.1" class="comment_icon" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
			 width="12px" height="13px" viewBox="0 0 12 13" enable-background="new 0 0 12 13" xml:space="preserve">
					<path d="M11.531,0H0.424c-0.23,0-0.419,0.183-0.419,0.407L0.002,8.675c0,0.402-0.097,1.17,1,1.17H3.99v2.367
						c0,0.162,0.057,0.393,0.043,0.752c0.063,0.039,0.105,0.039,0.168,0.039c0.105,0,0.21-0.039,0.294-0.123L7.18,9.845h3.975
						c0.231,0,0.798-0.092,0.798-0.791l-0.002-8.647C11.951,0.183,11.761,0,11.531,0z M11.155,9.054H7.18
						c-0.104,0-0.315,0.119-0.399,0.199l-2.16,2.367V9.75c0-0.225,0.02-0.695-0.631-0.695H0.8l0.044-8.241h10.267L11.155,9.054z"/>
			</svg> 0			</a>
		</span>
					</aside>
		</article>														<ul class="no-list">			<li itemscope itemtype="http://schema.org/Article" class="post listing post-27264 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto category-hl category-objek-wisata tag-batualu tag-jembatan-tanah tag-sangalla-selatan tag-tete-litak tag-tete-litak-batualu tag-wisata-toraja">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/foto-jembatan-alam-nan-eksotik-tete-litak-di-batualu/" rel="bookmark" title="FOTO Jembatan Alam Nan Eksotik “Tete Litak” di Batualu">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Tete-Litak-1-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/foto-foto/" class="single_category_title category-link-31" title="BERITA FOTO">BERITA FOTO</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/foto-jembatan-alam-nan-eksotik-tete-litak-di-batualu/" title="FOTO Jembatan Alam Nan Eksotik “Tete Litak” di Batualu">FOTO Jembatan Alam Nan Eksotik “Tete Litak” di Batualu</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-05T21:34:41+08:00" itemprop="datePublished" content="2020-07-05T21:34:41+08:00">Juli 5, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="FOTO Jembatan Alam Nan Eksotik “Tete Litak” di Batualu">
		<meta itemprop="dateModified" class="date updated" content="2020-07-05T21:34:41+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Tete-Litak-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/foto-jembatan-alam-nan-eksotik-tete-litak-di-batualu/" content="https://www.karebatoraja.com/foto-jembatan-alam-nan-eksotik-tete-litak-di-batualu/">
							</aside>
				</div>
</li>												<li itemscope itemtype="http://schema.org/Article" class="post listing post-27251 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto category-tana-toraja tag-terminal-bernuansa-wisata tag-terminal-makale tag-terminal-ramah-lingkungan">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/begini-penampilan-gedung-baru-terminal-makale-yang-bernuansa-wisata/" rel="bookmark" title="Begini Penampilan Gedung Baru Terminal Makale yang Bernuansa Wisata">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Terminal-Makale-2-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/foto-foto/" class="single_category_title category-link-31" title="BERITA FOTO">BERITA FOTO</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/begini-penampilan-gedung-baru-terminal-makale-yang-bernuansa-wisata/" title="Begini Penampilan Gedung Baru Terminal Makale yang Bernuansa Wisata">Begini Penampilan Gedung Baru Terminal Makale yang Bernuansa Wisata</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-04T19:20:55+08:00" itemprop="datePublished" content="2020-07-04T19:20:55+08:00">Juli 4, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Begini Penampilan Gedung Baru Terminal Makale yang Bernuansa Wisata">
		<meta itemprop="dateModified" class="date updated" content="2020-07-04T19:20:55+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Terminal-Makale-2.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/begini-penampilan-gedung-baru-terminal-makale-yang-bernuansa-wisata/" content="https://www.karebatoraja.com/begini-penampilan-gedung-baru-terminal-makale-yang-bernuansa-wisata/">
							</aside>
				</div>
</li>												<li itemscope itemtype="http://schema.org/Article" class="post listing post-27221 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto tag-satgas-covid-19-tana-toraja tag-uki-toraja">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/tes-mahasiswa-baru-uki-toraja-dikawal-ketat-satgas-covid-19-tana-toraja/" rel="bookmark" title="Tes Mahasiswa Baru UKI Toraja Dikawal Ketat Satgas Covid-19 Tana Toraja">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Seleksi-UKI-Toraja-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/foto-foto/" class="single_category_title category-link-31" title="BERITA FOTO">BERITA FOTO</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/tes-mahasiswa-baru-uki-toraja-dikawal-ketat-satgas-covid-19-tana-toraja/" title="Tes Mahasiswa Baru UKI Toraja Dikawal Ketat Satgas Covid-19 Tana Toraja">Tes Mahasiswa Baru UKI Toraja Dikawal Ketat Satgas Covid-19 Tana Toraja</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-02T19:09:27+08:00" itemprop="datePublished" content="2020-07-02T19:09:27+08:00">Juli 2, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Tes Mahasiswa Baru UKI Toraja Dikawal Ketat Satgas Covid-19 Tana Toraja">
		<meta itemprop="dateModified" class="date updated" content="2020-07-02T19:09:27+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Seleksi-UKI-Toraja.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/tes-mahasiswa-baru-uki-toraja-dikawal-ketat-satgas-covid-19-tana-toraja/" content="https://www.karebatoraja.com/tes-mahasiswa-baru-uki-toraja-dikawal-ketat-satgas-covid-19-tana-toraja/">
							</aside>
				</div>
</li>		</ul>		  		</div>
  	</div>
	<aside class="gap cf" style="height:30px;"></aside>
	<div class="wpb_raw_code wpb_content_element wpb_raw_html" >
		<div class="wpb_wrapper">
			<script async src="//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js"></script>
<!-- TOP ARTIKEL -->
<ins class="adsbygoogle"
     style="display:inline-block;width:728px;height:90px"
     data-ad-client="ca-pub-7321028307295773"
     data-ad-slot="7131809443"></ins>
<script>
(adsbygoogle = window.adsbygoogle || []).push({});
</script>
		</div>
	</div>
<aside class="gap cf" style="height:30px;"></aside></div></div></div><div class="wpb_column columns small-12 medium-4"><div class="vc_column-inner fixed-me "><div class="wpb_wrapper"><div  class="wpb_widgetised_column wpb_content_element">
		<div class="wpb_wrapper">
			
			<div id="thb_latestimages_widget-8" class="widget cf widget_latestimages"><strong>Berita Terbaru</strong><ul><li itemscope itemtype="http://schema.org/Article" class="post listing post-27602 type-post status-publish format-standard has-post-thumbnail hentry category-pendidikan tag-banjir-bandang-masamba tag-belajar-online tag-korban-banjir-bandang-masamba tag-kpa-anak-rimba-toraja tag-relawan-banjir-bandang-masamba">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/" rel="bookmark" title="Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Defri-1-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/pendidikan/" class="single_category_title category-link-1" title="PENDIDIKAN">PENDIDIKAN</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/" title="Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online">Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-25T19:55:34+08:00" itemprop="datePublished" content="2020-07-25T19:55:34+08:00">Juli 25, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online">
		<meta itemprop="dateModified" class="date updated" content="2020-07-25T19:55:34+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Defri-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/" content="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27597 type-post status-publish format-standard has-post-thumbnail hentry category-sulsel tag-banjir-bandang tag-banjir-bandang-masamba tag-eva-stevany-rataba tag-korban-banjir-bandang-masamba tag-pemda-tana-toraja tag-relawan-sentuhan-peduli-sesama">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/" rel="bookmark" title="Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Eva-Masamba-1-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/sulsel/" class="single_category_title category-link-4931" title="Sulsel">Sulsel</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/" title="Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja">Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-25T18:15:05+08:00" itemprop="datePublished" content="2020-07-25T18:15:05+08:00">Juli 25, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja">
		<meta itemprop="dateModified" class="date updated" content="2020-07-25T18:15:05+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Eva-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/" content="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27594 type-post status-publish format-standard has-post-thumbnail hentry category-nasional tag-bpjs-kesehatan tag-bpjs-kesehatan-makale tag-jkn-kis">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/" rel="bookmark" title="BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/BPJS-Sosialisasi-JKN-KIS-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/nasional/" class="single_category_title category-link-3795" title="NASIONAL">NASIONAL</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/" title="BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS">BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T22:18:08+08:00" itemprop="datePublished" content="2020-07-24T22:18:08+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T22:18:08+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/BPJS-Sosialisasi-JKN-KIS.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/" content="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27591 type-post status-publish format-standard has-post-thumbnail hentry category-hukun-dan-kriminal tag-operasi-patuh-2020 tag-pengemudi-dibawah-umur tag-polres-tana-toraja tag-sat-lantas-polres-tana-toraja">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/" rel="bookmark" title="Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-H2-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/hukun-dan-kriminal/" class="single_category_title category-link-9" title="HUKUM &amp; KRIMINAL">HUKUM &amp; KRIMINAL</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/" title="Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja">Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T21:21:44+08:00" itemprop="datePublished" content="2020-07-24T21:21:44+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T21:21:44+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-H2.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/" content="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27586 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-toraja-utara tag-bantah-positif-covid-19 tag-batagor-kang-ujang-rantepao tag-klarifikasi-positif-covid-19 tag-positif-covid-19-toraja-utara tag-warung-batagor-kang-ujang">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" rel="bookmark" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/hl/" class="single_category_title category-link-10" title="HEADLINE">HEADLINE</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T20:15:12+08:00" itemprop="datePublished" content="2020-07-24T20:15:12+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T20:24:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" content="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27581 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto tag-banjir-bandang tag-banjir-bandang-masamba tag-korban-banjir-bandang-masamba tag-relawan-sentuhan-peduli-sesama">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" rel="bookmark" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/foto-foto/" class="single_category_title category-link-31" title="BERITA FOTO">BERITA FOTO</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T19:09:33+08:00" itemprop="datePublished" content="2020-07-24T19:09:33+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T19:09:33+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" content="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27578 type-post status-publish format-standard has-post-thumbnail hentry category-komunitas tag-agen-brilink tag-bank-bri tag-paguyuban-agen-brilink-toraja-sikamali">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" rel="bookmark" title="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/BRILink-Peduli-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/komunitas/" class="single_category_title category-link-1530" title="KOMUNITAS">KOMUNITAS</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" title="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:58:29+08:00" itemprop="datePublished" content="2020-07-23T21:58:29+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:58:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/BRILink-Peduli.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" content="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/">
							</aside>
				</div>
</li><li itemscope itemtype="http://schema.org/Article" class="post listing post-27575 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-covid-19-sembuh tag-positif-covid-19 tag-positif-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara tag-sembuh-covid-19">
		<figure class="post-gallery">
				<a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" rel="bookmark" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
			<img width="80" height="75" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara-80x75.jpg" class="attachment-post-thumbnail size-post-thumbnail wp-post-image" alt="" />		</a>
	</figure>
		<div class="listing-content">
					<div class="post-category"><a href="https://www.karebatoraja.com/category/kareba-toraya/toraja-utara/" class="single_category_title category-link-42" title="TORAJA UTARA">TORAJA UTARA</a></div>
				<header class="post-title entry-header">
			<h6 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat</a></h6>		</header>
					<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:22:41+08:00" itemprop="datePublished" content="2020-07-23T21:22:41+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:22:41+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" content="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/">
							</aside>
				</div>
</li></ul></div>
		</div>
	</div>
<aside class="gap cf" style="height:10px;"></aside></div></div></div></div><div class="row row row-fluid no-padding full_width"><div class="wpb_column columns small-12 medium-12"><div class="vc_column-inner  "><div class="wpb_wrapper"></div></div></div></div><div class="row row row-fluid"><div class="main_content wpb_column columns small-12 medium-8"><div class="vc_column-inner  "><div class="wpb_wrapper"><aside class="gap cf" style="height:30px;"></aside>		<div class="row posts endcolumn post-grid-style2 pagination-style2 " data-loadmore="#loadmore-64" data-rand="64">
						
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27602 type-post status-publish format-standard has-post-thumbnail hentry category-pendidikan tag-banjir-bandang-masamba tag-belajar-online tag-korban-banjir-bandang-masamba tag-kpa-anak-rimba-toraja tag-relawan-banjir-bandang-masamba">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/" rel="bookmark" title="Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Defri-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/" title="Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online">Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-25T19:55:34+08:00" itemprop="datePublished" content="2020-07-25T19:55:34+08:00">Juli 25, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Jadi Relawan di Masamba, Siswa SMAN 9 Tana Toraja Ini Tetap Ikuti Proses Belajar Online">
		<meta itemprop="dateModified" class="date updated" content="2020-07-25T19:55:34+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Defri-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/" content="https://www.karebatoraja.com/jadi-relawan-di-masamba-siswa-sman-9-tana-toraja-ini-tetap-ikuti-proses-belajar-online/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27597 type-post status-publish format-standard has-post-thumbnail hentry category-sulsel tag-banjir-bandang tag-banjir-bandang-masamba tag-eva-stevany-rataba tag-korban-banjir-bandang-masamba tag-pemda-tana-toraja tag-relawan-sentuhan-peduli-sesama">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/" rel="bookmark" title="Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Eva-Masamba-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/" title="Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja">Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-25T18:15:05+08:00" itemprop="datePublished" content="2020-07-25T18:15:05+08:00">Juli 25, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Anggota DPR RI Apresiasi Tim Relawan Sentuhan Peduli Sesama Tana Toraja">
		<meta itemprop="dateModified" class="date updated" content="2020-07-25T18:15:05+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Eva-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/" content="https://www.karebatoraja.com/anggota-dpr-ri-apresiasi-tim-relawan-sentuhan-peduli-sesama-tana-toraja/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27594 type-post status-publish format-standard has-post-thumbnail hentry category-nasional tag-bpjs-kesehatan tag-bpjs-kesehatan-makale tag-jkn-kis">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/" rel="bookmark" title="BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/BPJS-Sosialisasi-JKN-KIS-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/" title="BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS">BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T22:18:08+08:00" itemprop="datePublished" content="2020-07-24T22:18:08+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="BPJS Kesehatan Minta FKTP Turut Sosialisasikan Regulasi Baru Kepesertaan JKN-KIS">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T22:18:08+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/BPJS-Sosialisasi-JKN-KIS.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/" content="https://www.karebatoraja.com/bpjs-kesehatan-minta-fktp-turut-sosialisasikan-regulasi-baru-kepesertaan-jkn-kis/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27591 type-post status-publish format-standard has-post-thumbnail hentry category-hukun-dan-kriminal tag-operasi-patuh-2020 tag-pengemudi-dibawah-umur tag-polres-tana-toraja tag-sat-lantas-polres-tana-toraja">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/" rel="bookmark" title="Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-H2-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/" title="Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja">Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T21:21:44+08:00" itemprop="datePublished" content="2020-07-24T21:21:44+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Sudah 10 Pengemudi Dibawah Umur Ditilang dalam Operasi Patuh Polres Tana Toraja">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T21:21:44+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-H2.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/" content="https://www.karebatoraja.com/sudah-10-pengemudi-dibawah-umur-ditilang-dalam-operasi-patuh-polres-tana-toraja/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27586 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-toraja-utara tag-bantah-positif-covid-19 tag-batagor-kang-ujang-rantepao tag-klarifikasi-positif-covid-19 tag-positif-covid-19-toraja-utara tag-warung-batagor-kang-ujang">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" rel="bookmark" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" title="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T20:15:12+08:00" itemprop="datePublished" content="2020-07-24T20:15:12+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Pemilik Warung Batagor Kang Ujang Rantepao Klarifikasi Informasi Keliru yang Menyebut Dirinya Positif Corona">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T20:24:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Kang-Ujang-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/" content="https://www.karebatoraja.com/pemilik-warung-batagor-kang-ujang-rantepao-klarifikasi-informasi-keliru-yang-menyebut-dirinya-positif-corona/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27581 type-post status-publish format-standard has-post-thumbnail hentry category-foto-foto tag-banjir-bandang tag-banjir-bandang-masamba tag-korban-banjir-bandang-masamba tag-relawan-sentuhan-peduli-sesama">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" rel="bookmark" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" title="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-24T19:09:33+08:00" itemprop="datePublished" content="2020-07-24T19:09:33+08:00">Juli 24, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="FOTO: Sinergi Relawan Sentuhan Peduli Sesama Pemda Tana Toraja dan TNI di Masamba">
		<meta itemprop="dateModified" class="date updated" content="2020-07-24T19:09:33+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Relawan-Masamba-1.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/" content="https://www.karebatoraja.com/foto-sinergi-relawan-sentuhan-peduli-sesama-pemda-tana-toraja-dan-tni-di-masamba/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27578 type-post status-publish format-standard has-post-thumbnail hentry category-komunitas tag-agen-brilink tag-bank-bri tag-paguyuban-agen-brilink-toraja-sikamali">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" rel="bookmark" title="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/BRILink-Peduli-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" title="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:58:29+08:00" itemprop="datePublished" content="2020-07-23T21:58:29+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Paguyuban Agen BRILink Toraja Sikamali’ Peduli Korban Bencana dan Sesama yang Terdampak Covid-19">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:58:29+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/BRILink-Peduli.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/" content="https://www.karebatoraja.com/paguyuban-agen-brilink-toraja-sikamali-peduli-korban-bencana-dan-sesama-yang-terdampak-covid-19/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27575 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-covid-19-sembuh tag-positif-covid-19 tag-positif-covid-19-toraja-utara tag-satgas-covid-19-toraja-utara tag-sembuh-covid-19">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" rel="bookmark" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" title="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T21:22:41+08:00" itemprop="datePublished" content="2020-07-23T21:22:41+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="10 Kasus Positif Covid-19 di Toraja Utara; 1 Meninggal, 8 Sembuh, 1 Dirawat">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T21:22:41+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Covid-19-Toraja-Utara.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/" content="https://www.karebatoraja.com/10-kasus-positif-covid-19-di-toraja-utara-1-meninggal-8-sembuh-1-dirawat/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27572 type-post status-publish format-standard has-post-thumbnail hentry category-hl category-hukun-dan-kriminal tag-operasi-patuh-2020 tag-polres-tana-toraja tag-polres-toraja-utara">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" rel="bookmark" title="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-2020-Res-Tator-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" title="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T19:09:36+08:00" itemprop="datePublished" content="2020-07-23T19:09:36+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Digelar Selama Dua Pekan, Ini 8 Sasaran Operasi Patuh 2020">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T19:09:36+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Operasi-Patuh-2020-Res-Tator.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/" content="https://www.karebatoraja.com/digelar-selama-dua-pekan-ini-8-sasaran-operasi-patuh-2020/">
							</aside>
		</article>					</div>
										
									<div class="small-6 medium-6 thb-5 columns">
						<article itemscope itemtype="http://schema.org/Article" class="post style3 post-27569 type-post status-publish format-standard has-post-thumbnail hentry category-toraja-utara tag-bunuh-diri tag-kecamatan-sopai tag-meninggal-bunuh-diri tag-nonongan tag-polres-toraja-utara tag-polsek-sopai">
		<figure class="post-gallery max-height">
		<a href="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" rel="bookmark" title="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">
			<img width="570" height="300" src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-original="https://www.karebatoraja.com/wp-content/uploads/2020/07/Bunuh-Diri-Sopai-570x300.jpg" class="attachment-goodlife-latest-short size-goodlife-latest-short wp-post-image" alt="" />					</a>
	</figure>
		<header class="post-title entry-header">
		<h5 class="entry-title" itemprop="name headline"><a href="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" title="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng</a></h5>	</header>
		<aside class="post-bottom-meta">
				<strong itemprop="author" class="author vcard hide"><a href="https://www.karebatoraja.com/author/adminkareba/" title="Pos-pos oleh adminkareba" rel="author">adminkareba</a></strong>
		<time class="date published time" datetime="2020-07-23T18:38:13+08:00" itemprop="datePublished" content="2020-07-23T18:38:13+08:00">Juli 23, 2020</time>
		<meta itemprop="name headline" class="entry-title" content="Warga Nonongan Ditemukan Meninggal dalam Posisi Tergantung di Pohon Lengkeng">
		<meta itemprop="dateModified" class="date updated" content="2020-07-23T18:38:13+08:00">
		<span class="hide" itemprop="publisher" itemscope itemtype="https://schema.org/Organization">
			<meta itemprop="name" content="Kareba Toraja">
			<span itemprop="logo" itemscope itemtype="https://schema.org/ImageObject">
				<meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/04/LOGO-PATEN-1-25-scaled.jpg">
			</span>
			<meta itemprop="url" content="https://www.karebatoraja.com">
		</span>
				<span class="hide" itemprop="image" itemscope itemtype="http://schema.org/ImageObject">
		  <meta itemprop="url" content="https://www.karebatoraja.com/wp-content/uploads/2020/07/Bunuh-Diri-Sopai.jpg">
		  <meta itemprop="width" content="1145">
		  <meta itemprop="height" content="682">
		</span>
				<meta itemscope itemprop="mainEntityOfPage" itemtype="https://schema.org/WebPage" itemid="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/" content="https://www.karebatoraja.com/warga-nonongan-ditemukan-meninggal-dalam-posisi-tergantung-di-pohon-lengkeng/">
							</aside>
		</article>					</div>
																<div class="text-center masonry_loader">
							<a class="masonry_btn btn black small" href="#" id="loadmore-64">Load More</a>
						</div>
								</div>
		
	</div></div></div><div class="wpb_column columns small-12 medium-4"><div class="vc_column-inner fixed-me "><div class="wpb_wrapper"><aside class="gap cf" style="height:30px;"></aside><div  class="wpb_widgetised_column wpb_content_element">
		<div class="wpb_wrapper">
			
			
		</div>
	</div>
</div></div></div></div><div class="row row row-fluid"><div class="wpb_column columns small-12 medium-12"><div class="vc_column-inner  "><div class="wpb_wrapper"></div></div></div></div>
		</div>
	</div>
		</div><!-- End role["main"] -->
			
									<!-- Start Sub Footer -->
			<footer id="subfooter" class="dark boxed">
				<div class="row">
					<div class="small-12 columns">
						<div class="subfooter-menu-holder text-center">
															<a href="https://www.karebatoraja.com/" class="logolink">
									<img src="https://www.karebatoraja.com/wp-content/uploads/2017/01/LOGO-PATEN-1-2.png" class="logoimg" alt="Kareba Toraja"/>
								</a>
														<div class="footer-menu"><ul>
<li class="page_item page-item-3817 current_page_item"><a href="https://www.karebatoraja.com/" aria-current="page">Home</a></li>
<li class="page_item page-item-4488"><a href="https://www.karebatoraja.com/karier/">Karier</a></li>
<li class="page_item page-item-1151"><a href="https://www.karebatoraja.com/pedoman-media-siber/">Pedoman Media Siber</a></li>
<li class="page_item page-item-1107"><a href="https://www.karebatoraja.com/redaksi/">Redaksi</a></li>
</ul></div>
	
							<p>Copyri<a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="482f203c08">[email&#160;protected]</a> Kareba Toraja Email : <a href="/cdn-cgi/l/email-protection" class="__cf_email__" data-cfemail="41132425202a32282a20332423207001262c202d6f222e2c">[email&#160;protected]</a>   </p>
						</div>
					</div>
				</div>
			</footer>
			<!-- End Sub Footer -->
				</div> <!-- End #content-container -->

</div> <!-- End #wrapper -->
	<a id="scroll_totop"><i class="fa fa-angle-up"></i></a>
<script data-cfasync="false" src="/cdn-cgi/scripts/5c5dd728/cloudflare-static/email-decode.min.js"></script><script src="https://www.karebatoraja.com/wp-includes/js/comment-reply.min.js?ver=5.4.2"></script>
<script src="https://www.karebatoraja.com/wp-content/themes/goodlife-wp/assets/js/vendor.min.js?ver=3.2.9"></script>
<script src="https://www.karebatoraja.com/wp-includes/js/underscore.min.js?ver=1.8.3"></script>
<script type='text/javascript'>
/* <![CDATA[ */
var themeajax = {"url":"https:\/\/www.karebatoraja.com\/wp-admin\/admin-ajax.php","l10n":{"loading":"Loading ...","nomore":"No More Posts"}};
var thb_postajax_64 = {"style":"style2","count":null,"loop":"|paged:1|offset:","columns":"5","excerpts":"no"};
/* ]]> */
</script>
<script src="https://www.karebatoraja.com/wp-content/themes/goodlife-wp/assets/js/app.min.js?ver=3.2.9"></script>
<script type="text/javascript">
function heateorSssLoadEvent(e) {var t=window.onload;if (typeof window.onload!="function") {window.onload=e}else{window.onload=function() {t();e()}}};	var heateorSssSharingAjaxUrl = "https://www.karebatoraja.com/wp-admin/admin-ajax.php", heateorSssCloseIconPath = "https://www.karebatoraja.com/wp-content/plugins/sassy-social-share/public/../images/close.png", heateorSssPluginIconPath = "https://www.karebatoraja.com/wp-content/plugins/sassy-social-share/public/../images/logo.png", heateorSssHorizontalSharingCountEnable = 0, heateorSssVerticalSharingCountEnable = 0, heateorSssSharingOffset = -10; var heateorSssMobileStickySharingEnabled = 1;var heateorSssCopyLinkMessage = "Link copied.";var heateorSssUrlCountFetched = [], heateorSssSharesText = "Shares", heateorSssShareText = "Share";function heateorSssPopup(e) {window.open(e,"popUpWindow","height=400,width=600,left=400,top=100,resizable,scrollbars,toolbar=0,personalbar=0,menubar=no,location=no,directories=no,status")};var heateorSssWhatsappShareAPI = "web";
</script>
<script src="https://www.karebatoraja.com/wp-content/plugins/sassy-social-share/public/js/sassy-social-share-public.js?ver=3.3.10"></script>
<script src="https://www.karebatoraja.com/wp-includes/js/wp-embed.min.js?ver=5.4.2"></script>
<script src="https://www.karebatoraja.com/wp-content/plugins/js_composer/assets/js/dist/js_composer_front.min.js?ver=5.6"></script>
	<aside id="thb-login" class="mfp-hide thb-login-form light">
		<ul>
			<li class="lost"><a href="#" class="always">Lost Password</a> <span class="back">Back &#x27F6;</span></li>
			<li><a href="#" class="active">Login</a></li>
			<li><a href="#">Register</a></li>
		</ul>
		<div class="thb-overflow-container">
		<div class="thb-form-container">
			<div class="thb-lost">
				<form id="thb_lost_form" action="https://www.karebatoraja.com/" method="post">
					<div class="thb-errors lost-errors"></div>
					<div class="form-field">
						<input class="form-control required " name="thb_user_or_email" id="thb_user_or_email" type="text" placeholder="Username or E-mail" />
					</div>
					<div class="form-field">
						<input type="hidden" name="action" value="thb_reset_password"/>
						<button class="btn " type="submit">Get new password</button>
					</div>
					<input type="hidden" id="password-security" name="password-security" value="b5fa70a90e" /><input type="hidden" name="_wp_http_referer" value="/" />				</form>
			</div>
			<div class="thb-login">
				<form id="thb_login_form" action="https://www.karebatoraja.com/" method="post">
					<div class="thb-errors login-errors"></div>
					<div class="form-field">
						<input class="form-control required " name="thb_user_login" type="text" placeholder="Username" autocomplete="off" />
					</div>
					<div class="form-field">
						<input class="form-control required " name="thb_user_pass" id="thb_user_pass" type="password" placeholder="Password">
					</div>
					<div class="form-field">
						 <a href="#" class="lost_password">Lost Password?</a>
					</div>
					<div class="form-field last">
						<input type="hidden" name="action" value="thb_login_member"/>
						<button class="btn " type="submit">Login</button>
					</div>
					<input type="hidden" id="login-security" name="login-security" value="b5fa70a90e" /><input type="hidden" name="_wp_http_referer" value="/" />				</form>
				
			</div>
			<div class="thb-register">					 
				<div class="alert alert-warning">Registration is disabled.</div>			</div>
		</div>
		</div>
	</aside>
<script>
/* <![CDATA[ */
ai_front = {"insertion_before":"BEFORE","insertion_after":"AFTER","insertion_prepend":"PREPEND CONTENT","insertion_append":"APPEND CONTENT","insertion_replace_content":"REPLACE CONTENT","insertion_replace_element":"REPLACE ELEMENT","visible":"VISIBLE","hidden":"HIDDEN","fallback":"FALLBACK","automatically_placed":"Automatically placed by AdSense Auto ads code","cancel":"Cancel","use":"Use","add":"Add","parent":"Parent","cancel_element_selection":"Cancel element selection","select_parent_element":"Select parent element","css_selector":"CSS selector","use_current_selector":"Use current selector","element":"ELEMENT","path":"PATH","selector":"SELECTOR"};
/* ]]> */
function b2a(a){var b,c=0,l=0,f="",g=[];if(!a)return a;do{var e=a.charCodeAt(c++);var h=a.charCodeAt(c++);var k=a.charCodeAt(c++);var d=e<<16|h<<8|k;e=63&d>>18;h=63&d>>12;k=63&d>>6;d&=63;g[l++]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(e)+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(h)+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(k)+"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=".charAt(d)}while(c<
a.length);return f=g.join(""),b=a.length%3,(b?f.slice(0,b-3):f)+"===".slice(b||3)}function a2b(a){var b,c,l,f={},g=0,e=0,h="",k=String.fromCharCode,d=a.length;for(b=0;64>b;b++)f["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".charAt(b)]=b;for(c=0;d>c;c++)for(b=f[a.charAt(c)],g=(g<<6)+b,e+=6;8<=e;)((l=255&g>>>(e-=8))||d-2>c)&&(h+=k(l));return h}b64e=function(a){return btoa(encodeURIComponent(a).replace(/%([0-9A-F]{2})/g,function(b,a){return String.fromCharCode("0x"+a)}))};
b64d=function(a){return decodeURIComponent(atob(a).split("").map(function(a){return"%"+("00"+a.charCodeAt(0).toString(16)).slice(-2)}).join(""))};
ai_insert=function(a,c,e){var d=-1!=c.indexOf(":eq")?jQuery(c):document.querySelectorAll(c);Array.prototype.forEach.call(d,function(b,d){selector_string=b.hasAttribute("id")?"#"+b.getAttribute("id"):b.hasAttribute("class")?"."+b.getAttribute("class").replace(RegExp(" ","g"),"."):"";var f=document.createElement("div");f.innerHTML=e;var g=f.getElementsByClassName("ai-selector-counter")[0];null!=g&&(g.innerText=d+1);g=f.getElementsByClassName("ai-debug-name ai-main")[0];if(null!=g){var k="";"before"==
a?k=ai_front.insertion_before:"after"==a?k=ai_front.insertion_after:"prepend"==a?k=ai_front.insertion_prepend:"append"==a?k=ai_front.insertion_append:"replace-content"==a?k=ai_front.insertion_replace_content:"replace-element"==a&&(k=ai_front.insertion_replace_element);-1==selector_string.indexOf(".ai-viewports")&&(g.innerText=k+" "+c+" ("+b.tagName.toLowerCase()+selector_string+")")}g=document.createRange().createContextualFragment(f.innerHTML);"before"==a?b.parentNode.insertBefore(g,b):"after"==
a?b.parentNode.insertBefore(g,b.nextSibling):"prepend"==a?b.insertBefore(g,b.firstChild):"append"==a?b.insertBefore(g,null):"replace-content"==a?b.innerHTML=f.innerHTML:"replace-element"==a&&(b.parentNode.insertBefore(g,b),b.parentNode.removeChild(b))})};
ai_insert_code=function(a){function c(a,b){return null==a?!1:a.classList?a.classList.contains(b):-1<(" "+a.className+" ").indexOf(" "+b+" ")}function e(a,b){null!=a&&(a.classList?a.classList.add(b):a.className+=" "+b)}function d(a,b){null!=a&&(a.classList?a.classList.remove(b):a.className=a.className.replace(new RegExp("(^|\\b)"+b.split(" ").join("|")+"(\\b|$)","gi")," "))}if("undefined"!=typeof a){var b=!1;if(c(a,"no-visibility-check")||a.offsetWidth||a.offsetHeight||a.getClientRects().length){b=
a.getAttribute("data-code");var h=a.getAttribute("data-insertion"),f=a.getAttribute("data-selector");if(null!=b)if(null!=h&&null!=f){if(-1!=f.indexOf(":eq")?jQuery(f).length:document.querySelectorAll(f).length)ai_insert(h,f,b64d(b)),d(a,"ai-viewports")}else b=document.createRange().createContextualFragment(b64d(b)),a.parentNode.insertBefore(b,a.nextSibling),d(a,"ai-viewports");b=!0;a=a.getElementsByClassName("ai-check-block");"undefined"!=typeof a[0]&&a[0].parentNode.removeChild(a[0])}else h=a.previousElementSibling,
c(h,"ai-debug-bar")&&c(h,"ai-debug-script")&&(d(h,"ai-debug-script"),e(h,"ai-debug-viewport-invisible")),d(a,"ai-viewports");return b}};ai_insert_list_code=function(a){var c=document.getElementsByClassName(a)[0];if("undefined"!=typeof c){var e=ai_insert_code(c),d=c.closest("div.code-block");d&&(e||d.removeAttribute("data-ai"),d.classList.remove("ai-list-block"),d.style.visibility="",d.classList.contains("ai-remove-position")&&(d.style.position=""));c.classList.remove(a);e&&ai_process_elements()}};
ai_insert_viewport_code=function(a){var c=document.getElementsByClassName(a)[0];"undefined"!=typeof c&&(ai_insert_code(c),c.classList.remove(a),ai_process_elements())};ai_insert_code_by_class=function(a){var c=document.getElementsByClassName(a)[0];"undefined"!=typeof c&&(ai_insert_code(c),c.classList.remove(a))};
ai_insert_client_code=function(a,c){var e=document.getElementsByClassName(a)[0];if("undefined"!=typeof e){var d=e.getAttribute("data-code");null!=d&&ai_check_block()&&ai_check_and_insert_block()&&(e.setAttribute("data-code",d.substring(Math.floor(c/19))),ai_insert_code_by_class(a),e.remove())}};ai_process_elements_active=!1;
function ai_process_elements(){ai_process_elements_active||setTimeout(function(){ai_process_elements_active=!1;"function"==typeof ai_process_rotations&&ai_process_rotations();"function"==typeof ai_process_lists&&ai_process_lists(jQuery("div.ai-list-data"));"function"==typeof ai_process_ip_addresses&&ai_process_ip_addresses(jQuery("div.ai-ip-data"));"function"==typeof ai_adb_process_blocks&&ai_adb_process_blocks()},5);ai_process_elements_active=!0};
var $jscomp=$jscomp||{};$jscomp.scope={};$jscomp.createTemplateTagFirstArg=function(a){return a.raw=a};$jscomp.createTemplateTagFirstArgWithRaw=function(a,g){a.raw=g;return a};$jscomp.arrayIteratorImpl=function(a){var g=0;return function(){return g<a.length?{done:!1,value:a[g++]}:{done:!0}}};$jscomp.arrayIterator=function(a){return{next:$jscomp.arrayIteratorImpl(a)}};$jscomp.makeIterator=function(a){var g="undefined"!=typeof Symbol&&Symbol.iterator&&a[Symbol.iterator];return g?g.call(a):$jscomp.arrayIterator(a)};
jQuery(function(a){function g(a){a=a.match(d);return null!=a&&1<a.length&&"string"===typeof a[1]&&0<a[1].length?a[1].toLowerCase():null}function p(a){try{var e=Date.parse(a);isNaN(e)&&(e=null)}catch(u){e=null}return e}Array.prototype.includes||(Array.prototype.includes=function(a){return!!~this.indexOf(a)});var d=/:\/\/(.[^/:]+)/i;ai_process_lists=function(d){function e(a,c,k){if(0==a.length)return"!@!"==k?!0:c==k;if("object"!=typeof c&&"array"!=typeof c)return!1;var f=a[0];a=a.slice(1);if("*"==f)for(c=
$jscomp.makeIterator(Object.entries(c)),f=c.next();!f.done;f=c.next()){if(f=$jscomp.makeIterator(f.value),f.next(),f=f.next().value,e(a,f,k))return!0}else if(f in c)return e(a,c[f],k);return!1}function u(a,c,k){if("object"!=typeof a||-1==c.indexOf("["))return!1;c=c.replace(/]| /gi,"").split("[");return e(c,a,k)}d=null==d?a("div.ai-list-data"):d.filter(".ai-list-data");if(d.length){d.removeClass("ai-list-data");var t=document.cookie.split(";");t.forEach(function(a,c){t[c]=a.trim()});var m=getAllUrlParams(window.location.search);
if(null!=m.referrer)var n=m.referrer;else n=document.referrer,""!=n&&(n=g(n));var v=window.navigator.userAgent,w=v.toLowerCase();if("undefined"!==typeof MobileDetect)var z=new MobileDetect(v);d.each(function(){var d=a(this).closest("div.code-block"),c=!0,k=a(this).attr("referer-list");if("undefined"!=typeof k){k=b64d(k).split(",");var f=a(this).attr("referer-list-type"),h=!1;a.each(k,function(a,b){if(""==b)return!0;if("*"==b.charAt(0))if("*"==b.charAt(b.length-1)){if(b=b.substr(1,
b.length-2),-1!=n.indexOf(b))return h=!0,!1}else{if(b=b.substr(1),n.substr(-b.length)==b)return h=!0,!1}else if("*"==b.charAt(b.length-1)){if(b=b.substr(0,b.length-1),0==n.indexOf(b))return h=!0,!1}else if("#"==b){if(""==n)return h=!0,!1}else if(b==n)return h=!0,!1});switch(f){case "B":h&&(c=!1);break;case "W":h||(c=!1)}}k=a(this).attr("client-list");if("undefined"!=typeof k&&"undefined"!==typeof z)switch(k=b64d(k).split(","),f=a(this).attr("client-list-type"),h=!1,a.each(k,function(a,b){if(""==b)return!0;
if("*"==b.charAt(0))if("*"==b.charAt(b.length-1)){if(b=b.substr(1,b.length-2).toLowerCase(),-1!=w.indexOf(b))return h=!0,!1}else{if(b=b.substr(1).toLowerCase(),w.substr(-b.length)==b)return h=!0,!1}else if("*"==b.charAt(b.length-1)){if(b=b.substr(0,b.length-1).toLowerCase(),0==w.indexOf(b))return h=!0,!1}else if(z.is(b))return h=!0,!1}),f){case "B":h&&(c=!1);break;case "W":h||(c=!1)}k=!1;if(c&&(f=a(this).attr("parameter-list"),"undefined"!=typeof f)){f=b64d(f).split(",");var e=a(this).attr("parameter-list-type"),
g=[];t.forEach(function(a){a=a.split("=");try{var b=JSON.parse(decodeURIComponent(a[1]))}catch(B){b=decodeURIComponent(a[1])}g[a[0]]=b});h=!1;a.each(f,function(a,b){if(-1!=b.indexOf("=")){if(-1!=t.indexOf(b))return h=!0,!1;var c=b.split("=");if(u(g,c[0],c[1]))return h=!0,!1}else if(t.forEach(function(a){a=a.split("=");if(b==a[0])return h=!0,!1}),u(g,b,"!@!"))return h=!0,!1});switch(e){case "B":h&&(c=!1);break;case "W":h||(c=!1)}!c&&a(this).hasClass("ai-list-manual")?(k=!0,a(this).addClass("ai-list-data")):
a(this).removeClass("ai-list-manual")}var l=a(this).prevAll(".ai-debug-bar.ai-debug-lists");f=""==n?"#":n;l.find(".ai-debug-name.ai-list-info").text(f).attr("title",v);l.find(".ai-debug-name.ai-list-status").text(c?ai_front.visible:ai_front.hidden);f=!1;if(c){var m=a(this).attr("scheduling-start");l=a(this).attr("scheduling-end");var q=a(this).attr("scheduling-days");if("undefined"!=typeof m&&"undefined"!=typeof l&&"undefined"!=typeof q){f=!0;var x=parseInt(a(this).attr("scheduling-fallback"));e=
parseInt(a(this).attr("gmt"));var r=p(b64d(m))+e;l=p(b64d(l))+e;m=b64d(q).split(",");q=a(this).attr("scheduling-type");var y=(new Date).getTime()+e,A=new Date(y);e=A.getDay();0==e?e=6:e--;r=y>=r&&y<l&&m.includes(e.toString());switch(q){case "B":r=!r}r||(c=!1);q=A.toISOString().split(".")[0].replace("T"," ");l=a(this).prevAll(".ai-debug-bar.ai-debug-scheduling");l.find(".ai-debug-name.ai-scheduling-info").text(q+" "+e);l.find(".ai-debug-name.ai-scheduling-status").text(c?ai_front.visible:ai_front.hidden);
c||0==x||(l.removeClass("ai-debug-scheduling").addClass("ai-debug-fallback"),l.find(".ai-debug-name.ai-scheduling-status").text(ai_front.fallback+"="+x))}}k||(a(this).css({visibility:"",position:"",width:"",height:"","z-index":""}),c?(d.css({visibility:""}),d.hasClass("ai-remove-position")&&d.css({position:""}),"undefined"!=typeof a(this).data("code")&&(c=b64d(a(this).data("code")),a(this).append(c),ai_process_element(this))):f&&!r&&0!=x?(d.css({visibility:""}),d.hasClass("ai-remove-position")&&d.css({position:""}),
a(this).next(".ai-fallback").removeClass("ai-fallback"),"undefined"!=typeof a(this).data("fallback-code")?(c=b64d(a(this).data("fallback-code")),a(this).append(c),ai_process_element(this)):a(this).hide(),c=d.attr("data-ai"),"undefined"!==typeof c&&!1!==c&&(c=a(this).attr("fallback-tracking"),"undefined"!==typeof c&&!1!==c&&d.attr("data-ai",c))):(a(this).hide(),d.removeAttr("data-ai").removeClass("ai-track"),d.find(".ai-debug-block").length?(d.css({visibility:""}).removeClass("ai-close"),d.hasClass("ai-remove-position")&&
d.css({position:""})):d.hide()),a(this).attr("data-code",""),a(this).attr("data-fallback-code",""),d.removeClass("ai-list-block"))})}};a(document).ready(function(a){setTimeout(function(){ai_process_lists()},5)})});
function ai_process_element(a){setTimeout(function(){"function"==typeof ai_process_rotations_in_element&&ai_process_rotations_in_element(a);"function"==typeof ai_process_lists&&ai_process_lists(jQuery("div.ai-list-data",a));"function"==typeof ai_process_ip_addresses&&ai_process_ip_addresses(jQuery("div.ai-ip-data",a));"function"==typeof ai_adb_process_blocks&&ai_adb_process_blocks(a)},5)}
function getAllUrlParams(a){var g=a?a.split("?")[1]:window.location.search.slice(1);a={};if(g){g=g.split("#")[0];g=g.split("&");for(var p=0;p<g.length;p++){var d=g[p].split("="),m=void 0,e=d[0].replace(/\[\d*\]/,function(a){m=a.slice(1,-1);return""});d="undefined"===typeof d[1]?"":d[1];e=e.toLowerCase();d=d.toLowerCase();a[e]?("string"===typeof a[e]&&(a[e]=[a[e]]),"undefined"===typeof m?a[e].push(d):a[e][m]=d):a[e]=d}}return a};

ai_js_code = true;

</script>
</body>
</html></Body>
  43. </Message>
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!