Report-K Köln braucht Report-K. Jetzt braucht Report-K Euch, die Kölner:innen. Werde K-bonnent:in und leiste Deinen Beitrag zur Existenzsicherung von report-K und Medienvielfalt in Köln. Du bist bereits K-bonnent:in? Passwort vergessen Hast Du noch kein K-bo? Schließe ein K-bo für nur 4,85 /Monat ab. Deine Vorteile: • Zugriff auf über…
Dirk Bachhausen
Report-K Köln braucht Report-K. Jetzt braucht Report-K Euch, die Kölner:innen. Werde K-bonnent:in und leiste Deinen Beitrag zur Existenzsicherung von report-K und Medienvielfalt in Köln. Du bist bereits K-bonnent:in? Passwort vergessen Hast Du noch kein K-bo? Schließe ein K-bo für nur 4,85 /Monat ab. Deine Vorteile: • Zugriff auf über…
Köln, 03.05.2025. Mit 256 von 257 gültig abgegebenen Stimmen ist Torsten Burmester heute von der Wahlkonferenz des SPD Unterbezirks Köln offiziell zum Oberbürgermeister-Kandidaten gewählt worden. Die Delegierten der Wahlkonferenz bedankten sich bei Burmester für seine kämpferische Rede mit langem, stehendem Applaus. Bundesgesundheitsminister Karl Lauterbach gehörte zu den Ersten, die Burmester…
![[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende](data:image/svg+xml;base64,<!DOCTYPE html>

<html lang="de">

<head>
	<title>Dirk Bachhausen &frasl; Sagen, was ist. – Tun, was man sagt. – Und sein, was man tut.</title>
	<style>img:is([sizes="auto" i], [sizes^="auto," i]) { contain-intrinsic-size: 3000px 1500px }</style>
	<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<meta name="template" content="Mission News 1.64" />

<!-- The SEO Framework von Sybre Waaijer -->
<meta name="robots" content="max-snippet:-1,max-image-preview:large,max-video-preview:-1" />
<link rel="canonical" href="https://www.bachhausen.de/" />
<link rel="next" href="https://www.bachhausen.de/page/2/" />
<meta property="og:type" content="website" />
<meta property="og:locale" content="de_DE" />
<meta property="og:site_name" content="Dirk Bachhausen" />
<meta property="og:title" content="Dirk Bachhausen" />
<meta property="og:url" content="https://www.bachhausen.de/" />
<meta property="og:image" content="https://www.bachhausen.de/wp-content/uploads/2021/01/dirk_profil.jpg" />
<meta name="twitter:card" content="summary_large_image" />
<meta name="twitter:site" content="@DirkBachhausen" />
<meta name="twitter:title" content="Dirk Bachhausen" />
<meta name="twitter:image" content="https://www.bachhausen.de/wp-content/uploads/2021/01/dirk_profil.jpg" />
<script type="application/ld+json">{"@context":"https:\/\/schema.org","@graph":[{"@type":"WebSite","@id":"https:\/\/www.bachhausen.de\/#\/schema\/WebSite","url":"https:\/\/www.bachhausen.de\/","name":"Dirk Bachhausen","description":"Sagen, was ist. \u2013 Tun, was man sagt. \u2013 Und sein, was man tut.","inLanguage":"de","potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.bachhausen.de\/search\/{search_term_string}\/"},"query-input":"required name=search_term_string"},"publisher":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/#\/schema\/Person","name":"Dirk Bachhausen","url":"https:\/\/www.bachhausen.de\/"}},{"@type":"WebPage","@id":"https:\/\/www.bachhausen.de\/","url":"https:\/\/www.bachhausen.de\/","name":"Dirk Bachhausen &frasl; Sagen, was ist. \u2013 Tun, was man sagt. \u2013 Und sein, was man tut.","inLanguage":"de","isPartOf":{"@id":"https:\/\/www.bachhausen.de\/#\/schema\/WebSite"},"breadcrumb":{"@type":"BreadcrumbList","@id":"https:\/\/www.bachhausen.de\/#\/schema\/BreadcrumbList","itemListElement":{"@type":"ListItem","position":1,"name":"Dirk Bachhausen"}},"about":{"@type":"Organization","@id":"https:\/\/www.bachhausen.de\/#\/schema\/Organization","name":"Dirk Bachhausen","url":"https:\/\/www.bachhausen.de\/","logo":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2021\/01\/dirk_profil.jpg"}}]}</script>
<!-- / The SEO Framework von Sybre Waaijer | 3.20ms meta | 0.77ms boot -->

<link rel='dns-prefetch' href='//fonts.googleapis.com' />
<link href='https://fonts.gstatic.com' crossorigin rel='preconnect' />
<link rel="alternate" type="application/rss+xml" title="Dirk Bachhausen &raquo; Feed" href="https://www.bachhausen.de/feed/" />
<link rel="alternate" type="application/rss+xml" title="Dirk Bachhausen &raquo; Kommentar-Feed" href="https://www.bachhausen.de/comments/feed/" />
<script type="text/javascript">
/* <![CDATA[ */
window._wpemojiSettings = {"baseUrl":"https:\/\/s.w.org\/images\/core\/emoji\/15.1.0\/72x72\/","ext":".png","svgUrl":"https:\/\/s.w.org\/images\/core\/emoji\/15.1.0\/svg\/","svgExt":".svg","source":{"concatemoji":"https:\/\/www.bachhausen.de\/wp-includes\/js\/wp-emoji-release.min.js?ver=6.8.1"}};
/*! This file is auto-generated */
!function(i,n){var o,s,e;function c(e){try{var t={supportTests:e,timestamp:(new Date).valueOf()};sessionStorage.setItem(o,JSON.stringify(t))}catch(e){}}function p(e,t,n){e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(t,0,0);var t=new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data),r=(e.clearRect(0,0,e.canvas.width,e.canvas.height),e.fillText(n,0,0),new Uint32Array(e.getImageData(0,0,e.canvas.width,e.canvas.height).data));return t.every(function(e,t){return e===r[t]})}function u(e,t,n){switch(t){case"flag":return n(e,"\ud83c\udff3\ufe0f\u200d\u26a7\ufe0f","\ud83c\udff3\ufe0f\u200b\u26a7\ufe0f")?!1:!n(e,"\ud83c\uddfa\ud83c\uddf3","\ud83c\uddfa\u200b\ud83c\uddf3")&&!n(e,"\ud83c\udff4\udb40\udc67\udb40\udc62\udb40\udc65\udb40\udc6e\udb40\udc67\udb40\udc7f","\ud83c\udff4\u200b\udb40\udc67\u200b\udb40\udc62\u200b\udb40\udc65\u200b\udb40\udc6e\u200b\udb40\udc67\u200b\udb40\udc7f");case"emoji":return!n(e,"\ud83d\udc26\u200d\ud83d\udd25","\ud83d\udc26\u200b\ud83d\udd25")}return!1}function f(e,t,n){var r="undefined"!=typeof WorkerGlobalScope&&self instanceof WorkerGlobalScope?new OffscreenCanvas(300,150):i.createElement("canvas"),a=r.getContext("2d",{willReadFrequently:!0}),o=(a.textBaseline="top",a.font="600 32px Arial",{});return e.forEach(function(e){o[e]=t(a,e,n)}),o}function t(e){var t=i.createElement("script");t.src=e,t.defer=!0,i.head.appendChild(t)}"undefined"!=typeof Promise&&(o="wpEmojiSettingsSupports",s=["flag","emoji"],n.supports={everything:!0,everythingExceptFlag:!0},e=new Promise(function(e){i.addEventListener("DOMContentLoaded",e,{once:!0})}),new Promise(function(t){var n=function(){try{var e=JSON.parse(sessionStorage.getItem(o));if("object"==typeof e&&"number"==typeof e.timestamp&&(new Date).valueOf()<e.timestamp+604800&&"object"==typeof e.supportTests)return e.supportTests}catch(e){}return null}();if(!n){if("undefined"!=typeof Worker&&"undefined"!=typeof OffscreenCanvas&&"undefined"!=typeof URL&&URL.createObjectURL&&"undefined"!=typeof Blob)try{var e="postMessage("+f.toString()+"("+[JSON.stringify(s),u.toString(),p.toString()].join(",")+"));",r=new Blob([e],{type:"text/javascript"}),a=new Worker(URL.createObjectURL(r),{name:"wpTestEmojiSupports"});return void(a.onmessage=function(e){c(n=e.data),a.terminate(),t(n)})}catch(e){}c(n=f(s,u,p))}t(n)}).then(function(e){for(var t in e)n.supports[t]=e[t],n.supports.everything=n.supports.everything&&n.supports[t],"flag"!==t&&(n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&n.supports[t]);n.supports.everythingExceptFlag=n.supports.everythingExceptFlag&&!n.supports.flag,n.DOMReady=!1,n.readyCallback=function(){n.DOMReady=!0}}).then(function(){return e}).then(function(){var e;n.supports.everything||(n.readyCallback(),(e=n.source||{}).concatemoji?t(e.concatemoji):e.wpemoji&&e.twemoji&&(t(e.twemoji),t(e.wpemoji)))}))}((window,document),window._wpemojiSettings);
/* ]]> */
</script>
  <style>
    :root {
      --include-mastodon-feed-bg-light: rgba(100, 100, 100, 0.15);
      --include-mastodon-feed-bg-dark: rgba(155, 155, 155, 0.15);
      --include-mastodon-feed-accent-color: rgb(99, 100, 255);
      --include-mastodon-feed-accent-font-color: rgb(255, 255, 255);
      --include-mastodon-feed-border-radius: 0.25rem;
    }

    .include-mastodon-feed .status {
      margin: 0.5rem 0 1.5rem;
      border-radius: var(--include-mastodon-feed-border-radius);
      padding: 0.5rem;
      background: var(--include-mastodon-feed-bg-light);
    }
    .include-mastodon-feed .status a {
      color: var(--include-mastodon-feed-accent-color);
      text-decoration: none;
      word-wrap: break-word;
    }
    .include-mastodon-feed .status a:hover {
      text-decoration: underline;
    }
    .include-mastodon-feed .avatar {
      height: 1.25rem;
      border-radius: var(--include-mastodon-feed-border-radius);
      vertical-align: top;
    }
    .include-mastodon-feed .account {
      font-size: 0.8rem;
    }
    .include-mastodon-feed .account a {
      display: inline-block;
    }
    .include-mastodon-feed .account .booster {
      float: right;
      font-style: italic;
    }
    .include-mastodon-feed .boosted .account > a:first-child,
    .include-mastodon-feed .contentWarning a {
      border-radius: var(--include-mastodon-feed-border-radius);
      padding: 0.15rem 0.5rem;
      background: var(--include-mastodon-feed-accent-color);
      color: var(--include-mastodon-feed-accent-font-color);
    }
    .include-mastodon-feed .boosted .account > a:first-child:hover,
    .include-mastodon-feed .contentWarning a:hover {
      border-radius: var(--include-mastodon-feed-border-radius);
      padding: 0.15rem 0.5rem;
      background: var(--include-mastodon-feed-accent-font-color);
      color: var(--include-mastodon-feed-accent-color);
      text-decoration: none;
    }
    .include-mastodon-feed .contentWrapper.boosted {
      margin: 0.5rem 0;
      padding: 0.5rem;
      background: var(--include-mastodon-feed-bg-light);
    }
    .include-mastodon-feed .contentWarning {
      text-align: center;
      margin: 1rem;
      padding: 1rem;
    }
    .include-mastodon-feed .contentWarning .title {
      font-weight: bold;
    }
    .include-mastodon-feed img.emoji {
      height: 1rem;
    }
    .include-mastodon-feed .content .invisible {
      display: none;
    }
    .include-mastodon-feed .media {
      display: flex;
      justify-content: space-around;
      align-items: center;
      flex-wrap: wrap;
      gap: 0.5rem;
      margin: 1rem;
    }
    .include-mastodon-feed .media > div {
      flex-basis: calc(50% - 0.5rem);
      flex-grow: 1;
    }
    .include-mastodon-feed .media > .image {
      font-size: 0.8rem;
      font-weight: bold;
      text-align: center;
    }
    .include-mastodon-feed .media > .image a { 
      border-radius: var(--include-mastodon-feed-border-radius);
      display: block;
      aspect-ratio: 1.618;                                                      
      background-size: cover;
      background-position: center;
    }
        .include-mastodon-feed .media > .image a:hover {
      filter: contrast(110%) brightness(130%) saturate(130%);
    }
    .include-mastodon-feed .media > .image a img {
      width: 100%;
    }
    .include-mastodon-feed .media > .gifv video {
      max-width: 100%;
    }

    .include-mastodon-feed .card {
      border-radius: var(--include-mastodon-feed-border-radius);
      margin: 1rem 0.5rem;
    }
    .include-mastodon-feed .card iframe {
      border-radius: var(--include-mastodon-feed-border-radius);
      width: 100%;
      height: 100%;
      aspect-ratio: 2 / 1.25;
    }
    .include-mastodon-feed .card a {
      border-radius: var(--include-mastodon-feed-border-radius);
      display: block;
      text-decoration: none;
      color: #000;
    }
    .include-mastodon-feed.dark .card a {
      color: #fff;
    }
    .include-mastodon-feed .card a:hover {
      text-decoration: none;
      background: var(--include-mastodon-feed-accent-color);
      color: var(--include-mastodon-feed-accent-font-color);
    }
    .include-mastodon-feed .card .meta {
      background: var(--include-mastodon-feed-bg-light);
      font-size: 0.8rem;
      padding: 1rem;
    }
    .include-mastodon-feed .card .image {
      margin-bottom: 0.5rem;
      text-align: center;
    }
    .include-mastodon-feed .card .image img {
      max-width: 75%;
    }
    .include-mastodon-feed .card .title {
      font-weight: bold;
    }
    .include-mastodon-feed.dark .status,
    .include-mastodon-feed.dark .contentWrapper.boosted,
    .include-mastodon-feed.dark .card {
      background: var(--include-mastodon-feed-bg-dark);
    }
  </style>
<link rel='stylesheet' id='ht_ctc_main_css-css' href='https://www.bachhausen.de/wp-content/plugins/click-to-chat-for-whatsapp/new/inc/assets/css/main.css?ver=4.21' type='text/css' media='all' />
<style id='wp-emoji-styles-inline-css' 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 0.07em !important;
		vertical-align: -0.1em !important;
		background: none !important;
		padding: 0 !important;
	}
</style>
<style id='classic-theme-styles-inline-css' type='text/css'>
/*! This file is auto-generated */
.wp-block-button__link{color:#fff;background-color:#32373c;border-radius:9999px;box-shadow:none;text-decoration:none;padding:calc(.667em + 2px) calc(1.333em + 2px);font-size:1.125em}.wp-block-file__button{background:#32373c;color:#fff;text-decoration:none}
</style>
<style id='activitypub-followers-style-inline-css' type='text/css'>
.activitypub-follower-block.is-style-compact .activitypub-handle,.activitypub-follower-block.is-style-compact .sep{display:none}.activitypub-follower-block.is-style-with-lines ul li{border-bottom:.5px solid;margin-bottom:.5rem;padding-bottom:.5rem}.activitypub-follower-block.is-style-with-lines ul li:last-child{border-bottom:none}.activitypub-follower-block.is-style-with-lines .activitypub-handle,.activitypub-follower-block.is-style-with-lines .activitypub-name{text-decoration:none}.activitypub-follower-block.is-style-with-lines .activitypub-handle:hover,.activitypub-follower-block.is-style-with-lines .activitypub-name:hover{text-decoration:underline}.activitypub-follower-block ul{margin:0!important;padding:0!important}.activitypub-follower-block li{display:flex;margin-bottom:1rem}.activitypub-follower-block img{border-radius:50%;height:40px;margin-right:var(--wp--preset--spacing--20,.5rem);width:40px}.activitypub-follower-block .activitypub-link{align-items:center;color:inherit!important;display:flex;flex-flow:row nowrap;max-width:100%;text-decoration:none!important}.activitypub-follower-block .activitypub-handle,.activitypub-follower-block .activitypub-name{text-decoration:underline;text-decoration-thickness:.8px;text-underline-position:under}.activitypub-follower-block .activitypub-handle:hover,.activitypub-follower-block .activitypub-name:hover{text-decoration:none}.activitypub-follower-block .activitypub-name{font-size:var(--wp--preset--font-size--normal,16px)}.activitypub-follower-block .activitypub-actor{font-size:var(--wp--preset--font-size--small,13px);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.activitypub-follower-block .sep{padding:0 .2rem}.activitypub-follower-block .wp-block-query-pagination{margin-top:1.5rem}.activitypub-follower-block .activitypub-pager{cursor:default}.activitypub-follower-block .activitypub-pager.current{opacity:.33}.activitypub-follower-block .page-numbers{padding:0 .2rem}.activitypub-follower-block .page-numbers.current{font-weight:700;opacity:1}

</style>
<style id='activitypub-follow-me-style-inline-css' type='text/css'>
.activitypub__modal.components-modal__frame{background-color:#f7f7f7;color:#333}.activitypub__modal.components-modal__frame .components-modal__header-heading,.activitypub__modal.components-modal__frame h4{color:#333;letter-spacing:inherit;word-spacing:inherit}.activitypub__modal.components-modal__frame .components-modal__header .components-button:hover{color:var(--color-white)}.activitypub__dialog{max-width:40em}.activitypub__dialog h4{line-height:1;margin:0}.activitypub__dialog .activitypub-dialog__section{margin-bottom:2em}.activitypub__dialog .activitypub-dialog__remember{margin-top:1em}.activitypub__dialog .activitypub-dialog__description{font-size:var(--wp--preset--font-size--normal,.75rem);margin:.33em 0 1em}.activitypub__dialog .activitypub-dialog__button-group{align-items:flex-end;display:flex;justify-content:flex-end}.activitypub__dialog .activitypub-dialog__button-group svg{height:21px;margin-right:.5em;width:21px}.activitypub__dialog .activitypub-dialog__button-group input{background-color:var(--wp--preset--color--white);border-radius:50px 0 0 50px;border-width:1px;border:1px solid var(--wp--preset--color--black);color:var(--wp--preset--color--black);flex:1;font-size:16px;height:inherit;line-height:1;margin-right:0;padding:15px 23px}.activitypub__dialog .activitypub-dialog__button-group button{align-self:center;background-color:var(--wp--preset--color--black);border-radius:0 50px 50px 0;border-width:1px;color:var(--wp--preset--color--white);font-size:16px;height:inherit;line-height:1;margin-left:0;padding:15px 23px;text-decoration:none}.activitypub__dialog .activitypub-dialog__button-group button:hover{border:inherit}.activitypub-follow-me-block-wrapper{width:100%}.activitypub-follow-me-block-wrapper.has-background .activitypub-profile,.activitypub-follow-me-block-wrapper.has-border-color .activitypub-profile{padding-left:1rem;padding-right:1rem}.activitypub-follow-me-block-wrapper .activitypub-profile{align-items:center;display:flex;padding:1rem 0}.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__avatar{border-radius:50%;height:75px;margin-right:1rem;width:75px}.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__content{flex:1;min-width:0}.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__handle,.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__name{line-height:1.2;margin:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__name{font-size:1.25em}.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__follow{align-self:center;background-color:var(--wp--preset--color--black);color:var(--wp--preset--color--white)}.activitypub-follow-me-block-wrapper .activitypub-profile .activitypub-profile__follow:not(:only-child){margin-left:1rem}

</style>
<link rel='stylesheet' id='wp-components-css' href='https://www.bachhausen.de/wp-includes/css/dist/components/style.min.css?ver=6.8.1' type='text/css' media='all' />
<style id='activitypub-reply-style-inline-css' type='text/css'>
.activitypub-embed{background:#fff;border:1px solid #e6e6e6;border-radius:12px;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Roboto,Helvetica,Arial,sans-serif;max-width:100%;padding:0}.activitypub-reply-block .activitypub-embed{margin:1em 0}.activitypub-embed-header{align-items:center;display:flex;gap:10px;padding:15px}.activitypub-embed-header img{border-radius:50%;height:48px;width:48px}.activitypub-embed-header-text{flex-grow:1}.activitypub-embed-header-text h2{color:#000;font-size:15px;font-weight:600;margin:0;padding:0}.activitypub-embed-header-text .ap-account{color:#687684;font-size:14px;text-decoration:none}.activitypub-embed-content{padding:0 15px 15px}.activitypub-embed-content .ap-title{color:#000;font-size:23px;font-weight:600;margin:0 0 10px;padding:0}.activitypub-embed-content .ap-subtitle{color:#000;font-size:15px;margin:0 0 15px}.activitypub-embed-content .ap-preview{border:1px solid #e6e6e6;border-radius:8px;overflow:hidden}.activitypub-embed-content .ap-preview img{display:block;height:auto;width:100%}.activitypub-embed-content .ap-preview-text{padding:15px}.activitypub-embed-meta{border-top:1px solid #e6e6e6;color:#687684;display:flex;font-size:13px;gap:15px;padding:15px}.activitypub-embed-meta .ap-stat{align-items:center;display:flex;gap:5px}@media only screen and (max-width:399px){.activitypub-embed-meta .ap-stat{display:none!important}}.activitypub-embed-meta a.ap-stat{color:inherit;text-decoration:none}.activitypub-embed-meta strong{color:#000;font-weight:600}.activitypub-embed-meta .ap-stat-label{color:#687684}.wp-block-activitypub-reply .components-spinner{height:12px;margin-bottom:0;margin-top:0;width:12px}

</style>
<style id='activitypub-reactions-style-inline-css' type='text/css'>
.activitypub-reactions h6{border-top:1px solid;border-top-color:var(--wp--preset--color--contrast-2);display:inline-block;padding-top:.5em}.activitypub-reactions .reaction-group{align-items:center;display:flex;gap:.75em;justify-content:flex-start;margin:.5em 0;position:relative;width:100%}@media(max-width:782px){.activitypub-reactions .reaction-group:has(.reaction-avatars:not(:empty)){justify-content:space-between}}.activitypub-reactions .reaction-avatars{align-items:center;display:flex;flex-direction:row;list-style:none;margin:0;padding:0}.activitypub-reactions .reaction-avatars li{margin:0 -10px 0 0;padding:0}.activitypub-reactions .reaction-avatars li:last-child{margin-right:0}.activitypub-reactions .reaction-avatars li a{display:block;text-decoration:none}.activitypub-reactions .reaction-avatars .reaction-avatar{border:.5px solid var(--wp--preset--color--contrast,hsla(0,0%,100%,.8));border-radius:50%;box-shadow:0 0 0 .5px hsla(0,0%,100%,.8),0 1px 3px rgba(0,0,0,.2);height:32px;transition:transform .6s cubic-bezier(.34,1.56,.64,1);width:32px;will-change:transform}.activitypub-reactions .reaction-avatars .reaction-avatar.wave-active{transform:translateY(-5px)}.activitypub-reactions .reaction-avatars .reaction-avatar.wave-active.rotate-clockwise{transform:translateY(-5px) rotate(30deg)}.activitypub-reactions .reaction-avatars .reaction-avatar.wave-active.rotate-counter{transform:translateY(-5px) rotate(-30deg)}.activitypub-reactions .reaction-avatars .reaction-avatar:hover{position:relative;z-index:1}.activitypub-reactions .reaction-label.components-button{color:var(--wp--preset--color--contrast,--wp--preset--color--secondary,#2271b1);flex:0 0 auto;height:auto;padding:0;text-decoration:none;white-space:nowrap}.activitypub-reactions .reaction-label.components-button:hover{color:var(--wp--preset--color--contrast,--wp--preset--color--secondary,#135e96);text-decoration:underline}.activitypub-reactions .reaction-label.components-button:focus:not(:disabled){box-shadow:none;outline:1px solid var(--wp--preset--color--contrast,#135e96);outline-offset:2px}.activitypub-reaction-list{background-color:var(--wp--preset--color--background,var(--wp--preset--color--custom-background,var(--wp--preset--color--base)));list-style:none;margin:0;max-width:300px;padding:.25em 1.3em .25em .7em;width:-moz-max-content;width:max-content}.activitypub-reaction-list ul{margin:0;padding:0}.activitypub-reaction-list li{font-size:var(--wp--preset--font-size--small);margin:0;padding:0}.activitypub-reaction-list a{align-items:center;color:var(--wp--preset--color--contrast,var(--wp--preset--color--secondary));display:flex;font-size:var(--wp--preset--font-size--small,.75rem);gap:.5em;justify-content:flex-start;padding:.5em;text-decoration:none}.activitypub-reaction-list a:hover{text-decoration:underline}.activitypub-reaction-list a img{border-radius:50%;flex:none;height:24px;width:24px}

</style>
<link rel='stylesheet' id='auto-delete-post-with-attachments-css' href='https://www.bachhausen.de/wp-content/plugins/auto-delete-post-with-attachments/assets/css/front.css?ver=0.0.1' type='text/css' media='all' />
<link rel='stylesheet' id='awesome-weather-css' href='https://www.bachhausen.de/wp-content/plugins/awesome-weather/awesome-weather.css?ver=6.8.1' type='text/css' media='all' />
<style id='awesome-weather-inline-css' type='text/css'>
.awesome-weather-wrap { font-family: 'Open Sans', sans-serif; font-weight: 400; font-size: 14px; line-height: 14px; }
</style>
<link rel='stylesheet' id='opensans-googlefont-css' href='//fonts.googleapis.com/css?family=Open+Sans%3A400&#038;ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='prefix-style-css' href='https://www.bachhausen.de/wp-content/plugins/bible-verse-of-the-day/bible-verse-of-the-day.css?ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='wp-bulk-post-status-update-css' href='https://www.bachhausen.de/wp-content/plugins/bulk-post-status-update/public/css/wp-bulk-post-status-update-public.css?ver=1.0.0' type='text/css' media='all' />
<link rel='stylesheet' id='contact-form-7-css' href='https://www.bachhausen.de/wp-content/plugins/contact-form-7/includes/css/styles.css?ver=6.0.6' type='text/css' media='all' />
<link rel='stylesheet' id='events-manager-css' href='https://www.bachhausen.de/wp-content/plugins/events-manager/includes/css/events-manager.min.css?ver=6.6.4.4' type='text/css' media='all' />
<link rel='stylesheet' id='lbwps-styles-photoswipe5-main-css' href='https://www.bachhausen.de/wp-content/plugins/lightbox-photoswipe/assets/ps5/styles/main.css?ver=5.6.2' type='text/css' media='all' />
<link rel='stylesheet' id='rgg-simplelightbox-css' href='https://www.bachhausen.de/wp-content/plugins/responsive-gallery-grid/lib/simplelightbox/simplelightbox.min.css?ver=2.3.18' type='text/css' media='all' />
<link rel='stylesheet' id='slickstyle-css' href='https://www.bachhausen.de/wp-content/plugins/responsive-gallery-grid/lib/slick/slick.1.9.0.min.css?ver=2.3.18' type='text/css' media='all' />
<link rel='stylesheet' id='slick-theme-css' href='https://www.bachhausen.de/wp-content/plugins/responsive-gallery-grid/lib/slick/slick-theme.css?ver=2.3.18' type='text/css' media='all' />
<link rel='stylesheet' id='rgg-style-css' href='https://www.bachhausen.de/wp-content/plugins/responsive-gallery-grid/css/style.css?ver=2.3.18' type='text/css' media='all' />
<link rel='stylesheet' id='wettervorhersage-css' href='https://www.bachhausen.de/wp-content/plugins/wettervorhersage/public/css/wettervorhersage-public.css?ver=1.0.0' type='text/css' media='all' />
<link rel='stylesheet' id='ct-mission-news-google-fonts-css' href='//fonts.googleapis.com/css?family=Abril+Fatface%7CPT+Sans%3A400%2C700%7CPT+Serif%3A400%2C400i%2C700%2C700i&#038;subset=latin%2Clatin-ext&#038;display=swap&#038;ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='ct-mission-news-font-awesome-css' href='https://www.bachhausen.de/wp-content/themes/mission-news/assets/font-awesome/css/all.min.css?ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='ct-mission-news-style-css' href='https://www.bachhausen.de/wp-content/themes/mission-news/style.css?ver=6.8.1' type='text/css' media='all' />
<style id='ct-mission-news-style-inline-css' type='text/css'>
.widget-area-site-footer {text-align: left;}
</style>
<link rel='stylesheet' id='wpdreams-asl-basic-css' href='https://www.bachhausen.de/wp-content/plugins/ajax-search-lite/css/style.basic.css?ver=4.12.7' type='text/css' media='all' />
<link rel='stylesheet' id='wpdreams-asl-instance-css' href='https://www.bachhausen.de/wp-content/plugins/ajax-search-lite/css/style-simple-red.css?ver=4.12.7' type='text/css' media='all' />
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/jquery.min.js?ver=3.7.1" id="jquery-core-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/jquery-migrate.min.js?ver=3.4.1" id="jquery-migrate-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/bulk-post-status-update/public/js/wp-bulk-post-status-update-public.js?ver=1.0.0" id="wp-bulk-post-status-update-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/core.min.js?ver=1.13.3" id="jquery-ui-core-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/mouse.min.js?ver=1.13.3" id="jquery-ui-mouse-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/sortable.min.js?ver=1.13.3" id="jquery-ui-sortable-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/datepicker.min.js?ver=1.13.3" id="jquery-ui-datepicker-js"></script>
<script type="text/javascript" id="jquery-ui-datepicker-js-after">
/* <![CDATA[ */
jQuery(function(jQuery){jQuery.datepicker.setDefaults({"closeText":"Schlie\u00dfen","currentText":"Heute","monthNames":["Januar","Februar","M\u00e4rz","April","Mai","Juni","Juli","August","September","Oktober","November","Dezember"],"monthNamesShort":["Jan.","Feb.","M\u00e4rz","Apr.","Mai","Juni","Juli","Aug.","Sep.","Okt.","Nov.","Dez."],"nextText":"Weiter","prevText":"Vorherige","dayNames":["Sonntag","Montag","Dienstag","Mittwoch","Donnerstag","Freitag","Samstag"],"dayNamesShort":["So.","Mo.","Di.","Mi.","Do.","Fr.","Sa."],"dayNamesMin":["S","M","D","M","D","F","S"],"dateFormat":"d. MM yy","firstDay":1,"isRTL":false});});
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/resizable.min.js?ver=1.13.3" id="jquery-ui-resizable-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/draggable.min.js?ver=1.13.3" id="jquery-ui-draggable-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/controlgroup.min.js?ver=1.13.3" id="jquery-ui-controlgroup-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/checkboxradio.min.js?ver=1.13.3" id="jquery-ui-checkboxradio-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/button.min.js?ver=1.13.3" id="jquery-ui-button-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/jquery/ui/dialog.min.js?ver=1.13.3" id="jquery-ui-dialog-js"></script>
<script type="text/javascript" id="events-manager-js-extra">
/* <![CDATA[ */
var EM = {"ajaxurl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php","locationajaxurl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php?action=locations_search","firstDay":"1","locale":"de","dateFormat":"yy-mm-dd","ui_css":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/events-manager\/includes\/css\/jquery-ui\/build.min.css","show24hours":"1","is_ssl":"1","autocomplete_limit":"10","calendar":{"breakpoints":{"small":560,"medium":908,"large":false}},"phone":"","datepicker":{"format":"d.m.Y","locale":"de"},"search":{"breakpoints":{"small":650,"medium":850,"full":false}},"url":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/events-manager","assets":{"input.em-uploader":{"js":{"em-uploader":{"url":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/events-manager\/includes\/js\/em-uploader.js","required":true,"event":"em_uploader_ready"}}}},"bookingInProgress":"Bitte warte, w\u00e4hrend die Buchung abgeschickt wird.","tickets_save":"Ticket speichern","bookingajaxurl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php","bookings_export_save":"Buchungen exportieren","bookings_settings_save":"Einstellungen speichern","booking_delete":"Bist du dir sicher, dass du es l\u00f6schen m\u00f6chtest?","booking_offset":"30","bookings":{"submit_button":{"text":{"default":"Buchung abschicken","free":"Buchung abschicken","payment":"Buchung abschicken","processing":"Processing ..."}},"update_listener":""},"bb_full":"Ausverkauft","bb_book":"Jetzt buchen","bb_booking":"Buche ...","bb_booked":"Buchung Abgesendet","bb_error":"Buchung Fehler. Nochmal versuchen?","bb_cancel":"Abbrechen","bb_canceling":"Stornieren ...","bb_cancelled":"Abgesagt","bb_cancel_error":"Stornierung Fehler. Nochmal versuchen?","txt_search":"Suche","txt_searching":"Suche...","txt_loading":"Wird geladen\u00a0\u2026"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/events-manager/includes/js/events-manager.js?ver=6.6.4.4" id="events-manager-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/events-manager/includes/external/flatpickr/l10n/de.js?ver=6.6.4.4" id="em-flatpickr-localization-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/qa-heatmap-analytics/js/polyfill/object_assign.js?ver=4.1.2.1" id="qahm-polyfill-object-assign-js"></script>
<script type="text/javascript" id="qahm-behavioral-data-init-js-before">
/* <![CDATA[ */
var qahm = qahm || {}; let obj = {"ajax_url":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php","plugin_dir_url":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/qa-heatmap-analytics\/","tracking_hash":"81b484c8aabe414c","nonce_init":"a7637851dd","nonce_behavioral":"8e8417c484","const_debug_level":{"release":0,"staging":1,"debug":2},"const_debug":0,"type":"home","id":1,"dev001":false,"dev002":false,"dev003":false,"cookieMode":false}; qahm = Object.assign( qahm, obj );
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/qa-heatmap-analytics/js/behavioral-data-init.js?ver=4.1.2.1" id="qahm-behavioral-data-init-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/qa-heatmap-analytics/js/common.js?ver=4.1.2.1" id="qahm-common-js"></script>
<script type="text/javascript" id="seo-automated-link-building-js-extra">
/* <![CDATA[ */
var seoAutomatedLinkBuilding = {"ajaxUrl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/seo-automated-link-building/js/seo-automated-link-building.js?ver=6.8.1" id="seo-automated-link-building-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/wettervorhersage/public/js/wettervorhersage-public.js?ver=1.0.0" id="wettervorhersage-js"></script>
<script type="text/javascript" id="wpmst-subscribe-form-ajax-js-extra">
/* <![CDATA[ */
var wpmst_ajax_object = {"ajaxurl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/wp-mailster/asset/js/wpmstsubscribe.js?ver=6.8.1" id="wpmst-subscribe-form-ajax-js"></script>
<link rel="https://api.w.org/" href="https://www.bachhausen.de/wp-json/" /><link rel="EditURI" type="application/rsd+xml" title="RSD" href="https://www.bachhausen.de/xmlrpc.php?rsd" />
<meta name="generator" content="auto-sizes 1.4.0">
<!-- auto ad code generated by Easy Google AdSense plugin v1.0.12 --><script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-9251945324725465" crossorigin="anonymous"></script><!-- Easy Google AdSense plugin --><meta name="generator" content="performance-lab 3.9.0; plugins: auto-sizes, embed-optimizer, image-prioritizer, performant-translations, speculation-rules">
<meta name="generator" content="performant-translations 1.2.0">
<link rel="alternate" type="application/ld+json" href="https://www.bachhausen.de/?format=application/ld+json" title="Structured Descriptor Document (JSON-LD format)"><style type="text/css"> .tippy-box[data-theme~="wprm"] { background-color: #333333; color: #FFFFFF; } .tippy-box[data-theme~="wprm"][data-placement^="top"] > .tippy-arrow::before { border-top-color: #333333; } .tippy-box[data-theme~="wprm"][data-placement^="bottom"] > .tippy-arrow::before { border-bottom-color: #333333; } .tippy-box[data-theme~="wprm"][data-placement^="left"] > .tippy-arrow::before { border-left-color: #333333; } .tippy-box[data-theme~="wprm"][data-placement^="right"] > .tippy-arrow::before { border-right-color: #333333; } .tippy-box[data-theme~="wprm"] a { color: #FFFFFF; } .wprm-comment-rating svg { width: 18px !important; height: 18px !important; } img.wprm-comment-rating { width: 90px !important; height: 18px !important; } body { --comment-rating-star-color: #343434; } body { --wprm-popup-font-size: 16px; } body { --wprm-popup-background: #ffffff; } body { --wprm-popup-title: #000000; } body { --wprm-popup-content: #444444; } body { --wprm-popup-button-background: #444444; } body { --wprm-popup-button-text: #ffffff; }</style><style type="text/css">.wprm-glossary-term {color: #5A822B;text-decoration: underline;cursor: help;}</style><meta property="fediverse:creator" name="fediverse:creator" content="dirk@www.bachhausen.de" />
<meta name="generator" content="speculation-rules 1.5.0">
				<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
				<link rel="preload" as="style" href="//fonts.googleapis.com/css?family=Open+Sans&display=swap" />
				<link rel="stylesheet" href="//fonts.googleapis.com/css?family=Open+Sans&display=swap" media="all" />
				<meta name="generator" content="optimization-detective 1.0.0-beta3; rest_api_unavailable">
<meta name="generator" content="embed-optimizer 1.0.0-beta2">
<meta name="generator" content="image-prioritizer 1.0.0-beta2">

<link rel="alternate" title="ActivityPub (JSON)" type="application/activity+json" href="https://www.bachhausen.de/@dirk" />
            <script type="text/javascript" id="spai_js" data-cfasync="false" data-spai-excluded="true">
                document.documentElement.className += " spai_has_js";
                (function(w, d){
                    var b = d.getElementsByTagName('head')[0];
                    var s = d.createElement("script");
                    var v = ("IntersectionObserver" in w) ? "" : "-compat";
                    s.async = true; // This includes the script as async.
                    s.src = "https://cdn.shortpixel.ai/assets/js/bundles/spai-lib-bg" + v
                        + ".1.1.min.js?v=3.10.3";
                    w.spaiDomain = "cdn.shortpixel.ai";
                    w.spaiData = {
                        version: "3.10.3",
                        key: "spai",
                        quality: "lossy",
                        convert: "auto",
                        lqip: true,
                                                rootMargin: "500px",
                        crop: true,
                        sizeBreakpoints: {"on":false,"base":50,"rate":10},
                        backgroundsMaxWidth: 1920,
                        resizeStyleBackgrounds: true,
                        nativeLazyLoad: false,
                        safeLazyBackgrounds: true,
                        asyncInitialParsing: true,
                        debug: false,
                        doSelectors: [{"selectors":"img","type":"attr","targetAttr":"src","attrType":"url","lazy":true,"resize":true},{"selectors":"[data-spai-bg-on]","type":"attr","targetAttr":"style","attrType":"style"},{"selectors":"style","type":"inner","attrType":"style"}],
                        exclusions: {"selectors":[],"urls":{"regex:\/\\\/\\\/([^\\\/]*\\.|)gravatar.com\\\/\/":{"lazy":0,"cdn":0,"resize":0,"lqip":0,"crop":-1}}},
                        sizeFromImageSuffix: true,
                        ajax_url: "https://www.bachhausen.de/wp-admin/admin-ajax.php",
                    };
                    b.appendChild(s);
                }(window, document));
            </script>
            			            <style>
				            
					div[id*='ajaxsearchlitesettings'].searchsettings .asl_option_inner label {
						font-size: 0px !important;
						color: rgba(0, 0, 0, 0);
					}
					div[id*='ajaxsearchlitesettings'].searchsettings .asl_option_inner label:after {
						font-size: 11px !important;
						position: absolute;
						top: 0;
						left: 0;
						z-index: 1;
					}
					.asl_w_container {
						width: 100%;
						margin: 0px 0px 0px 0px;
						min-width: 200px;
					}
					div[id*='ajaxsearchlite'].asl_m {
						width: 100%;
					}
					div[id*='ajaxsearchliteres'].wpdreams_asl_results div.resdrg span.highlighted {
						font-weight: bold;
						color: #d9312b;
						background-color: #eee;
					}
					div[id*='ajaxsearchliteres'].wpdreams_asl_results .results img.asl_image {
						width: 70px;
						height: 70px;
						object-fit: cover;
					}
					div.asl_r .results {
						max-height: none;
					}
				
						div.asl_r.asl_w.vertical .results .item::after {
							display: block;
							position: absolute;
							bottom: 0;
							content: '';
							height: 1px;
							width: 100%;
							background: #D8D8D8;
						}
						div.asl_r.asl_w.vertical .results .item.asl_last_item::after {
							display: none;
						}
								            </style>
			            
<script>var _activityPubOptions = {"namespace":"activitypub\/1.0","defaultAvatarUrl":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/activitypub\/assets\/img\/mp.jpg","enabled":{"site":true,"users":false}};</script>	<!-- Fonts Plugin CSS - https://fontsplugin.com/ -->
	<style>
		/* Cached: May 8, 2025 at 2:36pm */
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 100;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 100;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 100;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 200;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 200;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 200;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 800;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 800;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 800;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 900;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qoJy_KZA.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 900;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qpJy_KZA.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Deca';
  font-style: normal;
  font-weight: 900;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexenddeca/v22/K2F1fZFYk-dHSE0UPPuwQ5qnJy8.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 100;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 100;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 100;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 200;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 200;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 200;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 300;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 400;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 500;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 600;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 700;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 800;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 800;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 800;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}
/* vietnamese */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 900;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiLdA4M5.woff2) format('woff2');
  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
}
/* latin-ext */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 900;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeaiPdA4M5.woff2) format('woff2');
  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
}
/* latin */
@font-face {
  font-family: 'Lexend Exa';
  font-style: normal;
  font-weight: 900;
  font-display: swap;
  src: url(https://fonts.gstatic.com/s/lexendexa/v31/UMBXrPdOoHOnxExyjdBeai3dAw.woff2) format('woff2');
  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
}

:root {
--font-base: Lexend Deca;
--font-headings: Lexend Deca;
--font-input: Lexend Deca;
}
body, #content, .entry-content, .post-content, .page-content, .post-excerpt, .entry-summary, .entry-excerpt, .widget-area, .widget, .sidebar, #sidebar, footer, .footer, #footer, .site-footer {
font-family: "Lexend Deca";
 }
#site-title, .site-title, #site-title a, .site-title a, .entry-title, .entry-title a, h1, h2, h3, h4, h5, h6, .widget-title, .elementor-heading-title {
font-family: "Lexend Deca";
 }
button, .button, input, select, textarea, .wp-block-button, .wp-block-button__link {
font-family: "Lexend Deca";
 }
#site-title, .site-title, #site-title a, .site-title a, #site-logo, #site-logo a, #logo, #logo a, .logo, .logo a, .wp-block-site-title, .wp-block-site-title a {
font-family: "Lexend Deca";
 }
#site-description, .site-description, #site-tagline, .site-tagline, .wp-block-site-tagline {
font-family: "Lexend Deca";
 }
.menu, .page_item a, .menu-item a, .wp-block-navigation, .wp-block-navigation-item__content {
font-family: "Lexend Deca";
 }
.entry-content, .entry-content p, .post-content, .page-content, .post-excerpt, .entry-summary, .entry-excerpt, .excerpt, .excerpt p, .type-post p, .type-page p, .wp-block-post-content, .wp-block-post-excerpt, .elementor, .elementor p {
font-family: "Lexend Deca";
 }
.wp-block-post-title, .wp-block-post-title a, .entry-title, .entry-title a, .post-title, .post-title a, .page-title, .entry-content h1, #content h1, .type-post h1, .type-page h1, .elementor h1 {
font-family: "Lexend Deca";
 }
.entry-content h2, .post-content h2, .page-content h2, #content h2, .type-post h2, .type-page h2, .elementor h2 {
font-family: "Lexend Deca";
 }
.entry-content h3, .post-content h3, .page-content h3, #content h3, .type-post h3, .type-page h3, .elementor h3 {
font-family: "Lexend Exa";
 }
.entry-content h4, .post-content h4, .page-content h4, #content h4, .type-post h4, .type-page h4, .elementor h4 {
font-family: "Lexend Deca";
 }
.entry-content h5, .post-content h5, .page-content h5, #content h5, .type-post h5, .type-page h5, .elementor h5 {
font-family: "Lexend Deca";
 }
.entry-content h6, .post-content h6, .page-content h6, #content h6, .type-post h6, .type-page h6, .elementor h6 {
font-family: "Lexend Deca";
 }
.widget-title, .widget-area h1, .widget-area h2, .widget-area h3, .widget-area h4, .widget-area h5, .widget-area h6, #secondary h1, #secondary h2, #secondary h3, #secondary h4, #secondary h5, #secondary h6 {
font-family: "Lexend Deca";
 }
.widget-area, .widget, .sidebar, #sidebar, #secondary {
font-family: "Lexend Deca";
 }
footer h1, footer h2, footer h3, footer h4, footer h5, footer h6, .footer h1, .footer h2, .footer h3, .footer h4, .footer h5, .footer h6, #footer h1, #footer h2, #footer h3, #footer h4, #footer h5, #footer h6 {
font-family: "Lexend Deca";
 }
footer, #footer, .footer, .site-footer {
font-family: "Lexend Deca";
 }
	</style>
	<!-- Fonts Plugin CSS -->
	<!-- FIFU: meta tags for home (begin) -->
<meta property="og:image" content="https://www.bachhausen.de/wp-content/uploads/2023/09/Zeitungsleser.webp" />
<!-- FIFU: meta tags for home (end) --><link href="https://cdn.shortpixel.ai" rel="preconnect" crossorigin><style id="spai_bg_lazr">html.spai_has_js [data-spai-bg-on]:not([data-spai-bg-prepared]){background-image: none !important;}</style></head>

<body id="mission-news" class="home blog wp-theme-mission-news layout-rows-excerpt titles-above-image">
<a class="skip-content" href="#main">Drücken Sie „Enter“, um den Inhalte zu überspringen</a>
<div id="overflow-container" class="overflow-container">
	<div id="max-width" class="max-width">
							<header class="site-header" id="site-header" role="banner">
				<div class="top-nav">
										<div id="menu-secondary-container" class="menu-secondary-container">
						<div id="menu-secondary" class="menu-container menu-secondary" role="navigation">
	<nav class="menu"><ul id="menu-secondary-items" class="menu-secondary-items"><li id="menu-item-41" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-41"><a href="https://www.bachhausen.de/pgp-sichere-verschluesselung-fuer-jeden/">PGP – Sichere Verschlüsselung für jeden!</a></li>
</ul></nav></div>
					</div>
					<ul id='social-media-icons' class='social-media-icons'><li>					<a class="twitter" target="_blank"
					   href="https://twitter.com/dirkBachhausen">
						<i class="fa-brands fa-x-twitter"
						   title="twitter"></i>
					</a>
					</li><li>					<a class="facebook" target="_blank"
					   href="https://www.facebook.com/bachhausen.dirk">
						<i class="fab fa-facebook"
						   title="facebook"></i>
					</a>
					</li><li>					<a class="instagram" target="_blank"
					   href="https://www.instagram.com/dirkbachhausen/">
						<i class="fab fa-instagram"
						   title="instagram"></i>
					</a>
					</li><li>					<a class="email" target="_blank"
					   href="mailto:Dir&#107;&#64;&#98;&#97;&#99;h&#104;&#97;&#117;s&#101;&#110;.d&#101;">
						<i class="fas fa-envelope" title="E-Mail"></i>
					</a>
				</li><li>					<a class="phone" target="_blank"
							href="tel:0178/7122713">
						<i class="fas fa-phone"></i>
						<span class="screen-reader-text">phone</span>
					</a>
				</li><li>					<a class="email-form" target="_blank"
					   href="https://www.bachhausen.de/kontakt/">
						<i class="far fa-envelope"
						   title="email-form"></i>
					</a>
					</li><li>					<a class="amazon" target="_blank"
					   href="https://www.amazon.de/gp/registry/wishlist/183AYZGLZYIOW">
						<i class="fab fa-amazon"
						   title="amazon"></i>
					</a>
					</li><li>					<a class="mastodon" target="_blank"
					   href="https://social.cologne/@Adama">
						<i class="fab fa-mastodon"
						   title="mastodon"></i>
					</a>
					</li><li>					<a class="paypal" target="_blank"
					   href="https://www.paypal.me/DirkBachhausen">
						<i class="fab fa-paypal"
						   title="paypal"></i>
					</a>
					</li><li>					<a class="rss" target="_blank"
					   href="https://www.bachhausen.de/feed/">
						<i class="fas fa-rss"
						   title="rss"></i>
					</a>
					</li><li>					<a class="skype" target="_blank"
					   href="skype:adama1976?call">
						<i class="fab fa-skype"
						   title="skype"></i>
					</a>
				</li><li>					<a class="whatsapp" target="_blank"
					   href="https://wa.me/491787122713">
						<i class="fab fa-whatsapp"
						   title="whatsapp"></i>
					</a>
					</li></ul>				</div>
				<div id="title-container" class="title-container"><div class='site-title has-date'><a href='https://www.bachhausen.de'>Dirk Bachhausen</a></div><p class="date">8. Mai 2025</p><p class="tagline">Sagen, was ist. – Tun, was man sagt. – Und sein, was man tut.</p>				</div>
				<button id="toggle-navigation" class="toggle-navigation" name="toggle-navigation" aria-expanded="false">
					<span class="screen-reader-text">Menü öffnen</span>
					<svg xmlns="http://www.w3.org/2000/svg" width="24" height="18" viewBox="0 0 24 18" version="1.1" data-u="https%3A%2F%2Fwww.bachhausen.de%2Fwp-content%2Fuploads%2F2025%2F05%2Fdachau-1875393_1920-1280x720.jpg" data-w="24" data-h="18"><g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd"><g transform="translate(-272.000000, -21.000000)" fill="#000000"><g transform="translate(266.000000, 12.000000)"><g transform="translate(6.000000, 9.000000)"><rect class="top-bar" x="0" y="0" width="24" height="2"/><rect class="middle-bar" x="0" y="8" width="24" height="2"/><rect class="bottom-bar" x="0" y="16" width="24" height="2"/></g></g></g></g></svg>				</button>
				<div id="menu-primary-container" class="menu-primary-container tier-1">
					<div class="dropdown-navigation"><a id="back-button" class="back-button" href="#"><i class="fas fa-angle-left"></i> Back</a><span class="label"></span></div>
<div id="menu-primary" class="menu-container menu-primary" role="navigation">
    <nav class="menu"><ul id="menu-primary-items" class="menu-primary-items"><li id="menu-item-19" class="menu-item menu-item-type-custom menu-item-object-custom current-menu-item current_page_item menu-item-home menu-item-19"><a href="https://www.bachhausen.de/" aria-current="page">Startseite</a></li>
<li id="menu-item-21" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-21"><a href="https://www.bachhausen.de/mandate-funktionen/">Mandate &#038; Funktionen</a></li>
<li id="menu-item-27" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-27"><a href="https://www.bachhausen.de/Thema/politik/">Politik</a><button class="toggle-dropdown" aria-expanded="false" name="toggle-dropdown"><span class="screen-reader-text">Menü öffnen</span><i class="fas fa-angle-right"></i></button>
<ul class="sub-menu">
	<li id="menu-item-28" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-28"><a href="https://www.bachhausen.de/Thema/politik/koeln/">Köln</a></li>
	<li id="menu-item-29" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-29"><a href="https://www.bachhausen.de/Thema/politik/netzpolitik/">Netzpolitik</a></li>
	<li id="menu-item-30" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-30"><a href="https://www.bachhausen.de/Thema/politik/stadtbezirk-chorweiler/">Stadtbezirk Chorweiler</a></li>
</ul>
</li>
<li id="menu-item-23" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-23"><a href="https://www.bachhausen.de/Thema/allgemein/">Themen</a><button class="toggle-dropdown" aria-expanded="false" name="toggle-dropdown"><span class="screen-reader-text">Menü öffnen</span><i class="fas fa-angle-right"></i></button>
<ul class="sub-menu">
	<li id="menu-item-24" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-24"><a href="https://www.bachhausen.de/Thema/allgemein/freifunk/">Freifunk</a></li>
	<li id="menu-item-26" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-26"><a href="https://www.bachhausen.de/Thema/allgemein/verschluesselung/">Verschlüsselung</a></li>
</ul>
</li>
<li id="menu-item-17160" class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-17160"><a href="https://www.bachhausen.de/Thema/rezept/">Rezept</a></li>
<li id="menu-item-22" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-22"><a href="https://www.bachhausen.de/veranstaltungen/">Termine</a></li>
<li id="menu-item-20" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-20"><a href="https://www.bachhausen.de/aktiv-werden/">Aktiv werden</a></li>
<li id="menu-item-50" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-privacy-policy menu-item-has-children menu-item-50"><a rel="privacy-policy" href="https://www.bachhausen.de/kontakt/">Kontakt</a><button class="toggle-dropdown" aria-expanded="false" name="toggle-dropdown"><span class="screen-reader-text">Menü öffnen</span><i class="fas fa-angle-right"></i></button>
<ul class="sub-menu">
	<li id="menu-item-21659" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-21659"><a href="https://www.bachhausen.de/datenschutzerklaerung/">Datenschutzerklärung</a></li>
	<li id="menu-item-21661" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-privacy-policy menu-item-21661"><a rel="privacy-policy" href="https://www.bachhausen.de/kontakt/">Impressum</a></li>
</ul>
</li>
<li id="menu-item-6723" class="menu-item menu-item-type-post_type menu-item-object-page menu-item-6723"><a href="https://www.bachhausen.de/ahnenforschung/">Ahnenforschung</a></li>
</ul></nav></div>
				</div>
			</header>
								<div class="content-container">
						<div class="layout-container">
				    <aside class="sidebar sidebar-left" id="sidebar-left" role="complementary">
        <div class="inner">
            <section id="media_image-3" class="widget widget_media_image"><img width="960" height="960" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA5NjAgOTYwIiB3aWR0aD0iOTYwIiBoZWlnaHQ9Ijk2MCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMTAlMkZkaXJrX3Byb2ZpbC5qcGciIGRhdGEtdz0iOTYwIiBkYXRhLWg9Ijk2MCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="image wp-image-24098  attachment-full size-full" alt="" style="max-width: 100%; height: auto;" decoding="async" fetchpriority="high"  /></section><section id="custom_html-2" class="widget_text widget widget_custom_html"><h2 class="widget-title">Liebe Bürgerinnen und Bürger, liebe Sucher und Finder!</h2><div class="textwidget custom-html-widget">Ich freue mich, dass Sie mich gefunden haben und Sie auf meiner Homepage begrüßen zu dürfen.<br>

Auf den folgenden Seiten finden Sie Informationen zu meiner Person, zu meiner beruflichen Tätigkeit, meinen Ehrenämtern und Mandaten und zu meiner politischen Arbeit für die SPD im Kölner Norden.<br>

Ich freue mich über Ihr Interesse, über Reaktionen und Anregungen.
<br><br>
Ihr Dirk Bachhausen<br><br>
</div></section><section id="categories-2" class="widget widget_categories"><h2 class="widget-title">Themen</h2>
			<ul>
					<li class="cat-item cat-item-1"><a href="https://www.bachhausen.de/Thema/allgemein/">Allgemein</a> (1.091)
</li>
	<li class="cat-item cat-item-3"><a href="https://www.bachhausen.de/Thema/politik/koeln/">Köln</a> (829)
</li>
	<li class="cat-item cat-item-61"><a href="https://www.bachhausen.de/Thema/allgemein/lindweiler/">Lindweiler</a> (1)
</li>
	<li class="cat-item cat-item-4"><a href="https://www.bachhausen.de/Thema/politik/netzpolitik/">Netzpolitik</a> (972)
</li>
	<li class="cat-item cat-item-2"><a href="https://www.bachhausen.de/Thema/politik/">Politik</a> (1.478)
</li>
	<li class="cat-item cat-item-5"><a href="https://www.bachhausen.de/Thema/politik/stadtbezirk-chorweiler/">Stadtbezirk Chorweiler</a> (260)
</li>
			</ul>

			</section>			<section id="wpt_widget-2" class="widget widget_wpt">			<div class="wpt_widget_content" id="wpt_widget-2_content" data-widget-number="2">
				<ul class="wpt-tabs has-2-tabs">
																		<li class="tab_title"><a href="#" id="popular-tab">Popular</a></li>
																																														<li class="tab_title"><a href="#" id="tags-tab">Tags</a></li>
															</ul> <!--end .tabs-->
				<div class="clear"></div>
				<div class="inside">
											<div id="popular-tab-content" class="tab-content">
						</div> <!--end #popular-tab-content-->
																										<div id="tags-tab-content" class="tab-content">
							<ul>
							</ul>
						</div> <!--end #tags-tab-content-->
										<div class="clear"></div>
				</div> <!--end .inside -->
				<div class="clear"></div>
			</div><!--end #tabber -->
						<script type="text/javascript">
				jQuery(function($) {
					$('#wpt_widget-2_content').data('args', {"allow_pagination":"1","post_num":"5","title_length":"15","comment_num":"5","show_thumb":"1","thumb_size":"small","show_date":null,"show_excerpt":null,"excerpt_length":"15","show_comment_num":null,"show_avatar":"1","show_love":null});
				});
			</script>
			</section>			        </div>
    </aside>
				<section id="main" class="main" role="main">
					<h1 class="screen-reader-text">Dirk Bachhausen</h1>
<div id="loop-container" class="loop-container">
    <div class="post-56764 post type-post status-publish format-standard has-post-thumbnail hentry category-politik tag-arbeit tag-jahre tag-kriegsende tag-macht tag-tacheles entry">
		<article>
				<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/tacheles_4-arbeit-macht-frei-80-jahre-kriegsende/">[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende</a>
			</h2>
			<div class="post-byline">Von Belltower News am 8. Mai 2025</div>		</div>
		<div class="featured-image"><a href="https://www.bachhausen.de/tacheles_4-arbeit-macht-frei-80-jahre-kriegsende/">[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende<img alt="[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende" title="[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende" width="1024" height="576" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMjgwIDcyMCIgd2lkdGg9IjEyODAiIGhlaWdodD0iNzIwIiBkYXRhLXU9Imh0dHBzJTNBJTJGJTJGd3d3LmJhY2hoYXVzZW4uZGUlMkZ3cC1jb250ZW50JTJGdXBsb2FkcyUyRjIwMjUlMkYwNSUyRmRhY2hhdS0xODc1MzkzXzE5MjAtMTI4MHg3MjAuanBnIiBkYXRhLXc9IjEyODAiIGRhdGEtaD0iNzIwIiBkYXRhLWJpcD0iIj48L3N2Zz4=" data-spai="1" class="attachment-large size-large wp-post-image" alt="[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende" title="[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende" decoding="async" srcset=" " sizes="(max-width: 1024px) 100vw, 1024px" /></a></div>		<div class="post-content">
			<p>Belltower.News Das Tor des ehemaligen KZ in Dachau. (Quelle: pixabay) Der 8. Mai 2025 markiert den 80. Jahrestag der Kapitulation der Nationalsozialisten und somit das Ende des Zweiten Weltkriegs. Lange haben Holocaust-Überlebende, Familien und Angehörige der Ermordeten alleine um eine gelebte Erinnerungskultur im Land der Täter und darüber hinaus gerungen&#8230;</p>
		</div>
	</article>
	</div><div class="post-56756 post type-post status-publish format-standard has-post-thumbnail hentry category-politik tag-bewegung tag-erkaufen tag-insolvenzverfahren tag-stream entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/bewegung-im-insolvenzverfahren-nord-stream-2-ag-will-sich-zeit-erkaufen/">Bewegung im Insolvenzverfahren – Nord Stream 2 AG will sich Zeit erkaufen<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="Bewegung im Insolvenzverfahren – Nord Stream 2 AG will sich Zeit erkaufen" title="Bewegung im Insolvenzverfahren – Nord Stream 2 AG will sich Zeit erkaufen" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/bewegung-im-insolvenzverfahren-nord-stream-2-ag-will-sich-zeit-erkaufen/">Bewegung im Insolvenzverfahren – Nord Stream 2 AG will sich Zeit erkaufen</a>
			</h2>
			<div class="post-byline">Von Correctiv.org am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Dieser Artikel stammt von CORRECTIV.Faktencheck / Zur Quelle wechseln Russland/Ukraine Bewegung im Insolvenzverfahren – Nord Stream 2 AG will sich Zeit erkaufen Einzelne Firmen, die für Nord Stream 2 Leistungen erbracht hatten, haben nach langer Wartezeit ihr Geld erhalten. Damit könnte das Unternehmen versuchen, eine Insolvenz vorerst abzuwenden. Für potenzielle&#8230;</p>
		</div>
	</article>
	</div><div class="post-56754 post type-post status-publish format-standard has-post-thumbnail hentry category-stadtbezirk-chorweiler tag-heimersdorf tag-platzsanierung tag-sehnsuchtig tag-wartet entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/koeln-heimersdorf-ksv-heimersdorf-wartet-sehnsuechtig-auf-platzsanierung/">Köln-Heimersdorf: KSV Heimersdorf wartet sehnsüchtig auf Platzsanierung<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="Köln-Heimersdorf: KSV Heimersdorf wartet sehnsüchtig auf Platzsanierung" title="Köln-Heimersdorf: KSV Heimersdorf wartet sehnsüchtig auf Platzsanierung" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/koeln-heimersdorf-ksv-heimersdorf-wartet-sehnsuechtig-auf-platzsanierung/">Köln-Heimersdorf: KSV Heimersdorf wartet sehnsüchtig auf Platzsanierung</a>
			</h2>
			<div class="post-byline">Von Kölner Stadtanzeiger am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Auf der Prioritätenliste steht der KSV Heimersdorf auf Platz 11, weiß Gökpinar. „Das klingt nicht schlecht, aber es gibt kein Signal, wann mit der Umsetzung zu rechnen ist“, sagt er. Eine Perspektive aber wäre bereits enorm hilfreich, meint Kowarowski. „Wenn wir den Eltern sagen könnten, in drei, vier oder fünf&#8230;</p>
		</div>
	</article>
	</div><div class="post-56761 post type-post status-publish format-standard has-post-thumbnail hentry category-koeln tag-stadionvorwiesen tag-together entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/come-together-cup-auf-den-stadionvorwiesen/">Come-Together-Cup auf den Stadionvorwiesen<img post-id="56761" fifu-featured="1" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAzMDAgMTU0IiB3aWR0aD0iMzAwIiBoZWlnaHQ9IjE1NCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5yZXBvcnQtay5kZSUyRndwLWNvbnRlbnQlMkZ1cGxvYWRzJTJGMjAyNCUyRjEyJTJGa2Jvbm5lbnRpbl90cmFuc3BhcmVudF9tdHlwby0yLTMwMHgxNTQucG5nIiBkYXRhLXc9IjMwMCIgZGF0YS1oPSIxNTQiIGRhdGEtYmlwPSIiPjwvc3ZnPg==" data-spai="1" class="attachment-large size-large wp-post-image" alt="Come-Together-Cup auf den Stadionvorwiesen" title="Come-Together-Cup auf den Stadionvorwiesen" title="Come-Together-Cup auf den Stadionvorwiesen" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/come-together-cup-auf-den-stadionvorwiesen/">Come-Together-Cup auf den Stadionvorwiesen</a>
			</h2>
			<div class="post-byline">Von Report K am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Report-K Köln braucht Report-K. Jetzt braucht Report-K Euch, die Kölner:innen. Werde K-bonnent:in und leiste Deinen Beitrag zur Existenzsicherung von report-K und Medienvielfalt in Köln. Du bist bereits K-bonnent:in?    Passwort vergessen Hast Du noch kein K-bo? Schließe ein K-bo für nur 4,85 /Monat ab. Deine Vorteile: • Zugriff auf über&#8230;</p>
		</div>
	</article>
	</div><div class="post-56758 post type-post status-publish format-standard has-post-thumbnail hentry category-netzpolitik tag-halten tag-kritische tag-leyen tag-menschenrechte tag-rohstoffe tag-ursula entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/kritische-rohstoffe-und-menschenrechte-ursula-von-der-leyen-muss-wort-halten/">Kritische Rohstoffe und Menschenrechte: „Ursula von der Leyen muss Wort halten“<img post-id="56758" fifu-featured="1" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxIDEiIHdpZHRoPSIxIiBoZWlnaHQ9IjEiIGRhdGEtdT0iaHR0cHMlM0ElMkYlMkZjZG4ubmV0enBvbGl0aWsub3JnJTJGd3AtdXBsb2FkJTJGMjAyNSUyRjA1JTJGQW1uZXN0eV9EUktfS29iYWx0XyVDMiVBOUFtbmVzdHlJbnRlcm5hdGlvbmFsX3ZpZGVvZ3JhcGhlcnNfUmVwb3J0YWdlLVNhbnMtRnJvbnRpZXJlcy0zLXNjYWxlZC5qcGciIGRhdGEtdz0iMSIgZGF0YS1oPSIxIiBkYXRhLWJpcD0iIj48L3N2Zz4=" data-spai="1" class="attachment-large size-large wp-post-image" alt="Kritische Rohstoffe und Menschenrechte: „Ursula von der Leyen muss Wort halten“" title="Kritische Rohstoffe und Menschenrechte: „Ursula von der Leyen muss Wort halten“" title="Kritische Rohstoffe und Menschenrechte: „Ursula von der Leyen muss Wort halten“" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/kritische-rohstoffe-und-menschenrechte-ursula-von-der-leyen-muss-wort-halten/">Kritische Rohstoffe und Menschenrechte: „Ursula von der Leyen muss Wort halten“</a>
			</h2>
			<div class="post-byline">Von Netzpolitik.org am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Dieser Artikel stammt von Netzpolitik.org. Von Berlin und Nairobi aus engagieren sich Kristina Hatas und Christian Rumu für Menschenrechte. Die eine ist Expertin für Klimagerechtigkeit, Wirtschaft und Menschenrechte bei Amnesty International Deutschland, der andere leitet Amnesty Internationals regionales Programm gegen Geschlechterungleichheit in der Demokratischen Republik Kongo, Ruanda und Burundi. Beide&#8230;</p>
		</div>
	</article>
	</div><div class="post-56752 post type-post status-publish format-standard has-post-thumbnail hentry category-allgemein tag-beeinflusst tag-leben tag-leilas tag-podcast tag-queer entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/br-podcast-queer-adhs-so-beeinflusst-es-leilas-leben/">(BR Podcast) Queer &amp; ADHS &#8211; so beeinflusst es Leilas Leben<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="(BR Podcast) Queer &amp; ADHS &#8211; so beeinflusst es Leilas Leben" title="(BR Podcast) Queer &amp; ADHS &#8211; so beeinflusst es Leilas Leben" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/br-podcast-queer-adhs-so-beeinflusst-es-leilas-leben/">(BR Podcast) Queer &amp; ADHS &#8211; so beeinflusst es Leilas Leben</a>
			</h2>
			<div class="post-byline">Von Redaktion am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Wenn Leila in der Schule der Unterrichtsstoff nicht interessiert hat, dann konnte sie sich einfach nicht konzentrieren. Und beim Daten war Leila superschnell verliebt &#8211; aber nach zwei Wochen war das Gefühls-High wieder weg. Der Grund: Sie hat ADHS. Wir wollen von Leila für diese Folge wissen: Wie ist es,&#8230;</p>
		</div>
	</article>
	</div><div class="post-56750 post type-post status-publish format-standard has-post-thumbnail hentry category-allgemein tag-gejammer tag-human tag-rights tag-vernebelt tag-washington tag-watch entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/human-rights-watch-gejammer-ueber-woke-vernebelt-washington/">(Human Rights Watch) Gejammer über &#8220;Woke&#8221; vernebelt Washington<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="(Human Rights Watch) Gejammer über &#8220;Woke&#8221; vernebelt Washington" title="(Human Rights Watch) Gejammer über &#8220;Woke&#8221; vernebelt Washington" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/human-rights-watch-gejammer-ueber-woke-vernebelt-washington/">(Human Rights Watch) Gejammer über &#8220;Woke&#8221; vernebelt Washington</a>
			</h2>
			<div class="post-byline">Von Redaktion am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Wenn eine Gleichberechtigungsbewegung Erfolg hat, ist das für alle ein Grund zum Feiern. Manche Leute sehen Rechte jedoch fälschlicherweise als ein Nullsummenspiel in der Gesellschaft an. Direktlink</p>
		</div>
	</article>
	</div><div class="post-56748 post type-post status-publish format-standard has-post-thumbnail hentry category-allgemein tag-bella tag-mannern tag-ramsey tag-schauspielpreisen tag-spiegel tag-wichtig tag-zwischen entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/spiegel-bella-ramsey-haelt-es-fuer-wichtig-bei-schauspielpreisen-zwischen-maennern-und-frauen-zu-trennen/">(Spiegel) Bella Ramsey hält es für wichtig, bei Schauspielpreisen zwischen Männern und Frauen zu trennen<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="(Spiegel) Bella Ramsey hält es für wichtig, bei Schauspielpreisen zwischen Männern und Frauen zu trennen" title="(Spiegel) Bella Ramsey hält es für wichtig, bei Schauspielpreisen zwischen Männern und Frauen zu trennen" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/spiegel-bella-ramsey-haelt-es-fuer-wichtig-bei-schauspielpreisen-zwischen-maennern-und-frauen-zu-trennen/">(Spiegel) Bella Ramsey hält es für wichtig, bei Schauspielpreisen zwischen Männern und Frauen zu trennen</a>
			</h2>
			<div class="post-byline">Von Redaktion am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Sind nach Geschlechtern getrennte Kategorien bei Schauspielpreisen noch zeitgemäß? Der &#8220;The Last Of Us&#8221;-Star Bella Ramsey ist selbst nicht-binär, wünscht sich aber gesicherte Anerkennung für Frauen. Direktlink</p>
		</div>
	</article>
	</div><div class="post-56746 post type-post status-publish format-standard has-post-thumbnail hentry category-allgemein tag-flinta tag-frankfurt tag-frankfurter tag-keine tag-rundschau tag-waggons entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/frankfurter-rundschau-frankfurt-keine-waggons-nur-fuer-flinta/">(Frankfurter Rundschau) Frankfurt: Keine Waggons nur für &#8220;Flinta&#8221;<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="(Frankfurter Rundschau) Frankfurt: Keine Waggons nur für &#8220;Flinta&#8221;" title="(Frankfurter Rundschau) Frankfurt: Keine Waggons nur für &#8220;Flinta&#8221;" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/frankfurter-rundschau-frankfurt-keine-waggons-nur-fuer-flinta/">(Frankfurter Rundschau) Frankfurt: Keine Waggons nur für &#8220;Flinta&#8221;</a>
			</h2>
			<div class="post-byline">Von Redaktion am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Soll es Abteile im Zug geben, in die nur &#8220;Flinta&#8221; einsteigen dürfen? Das schlägt Volt im Römer vor. Der Magistrat hat dazu eine Meinung. Direktlink</p>
		</div>
	</article>
	</div><div class="post-56744 post type-post status-publish format-standard has-post-thumbnail hentry category-allgemein tag-community tag-nutzt tag-queere entry rows-excerpt">
		<article>
		<div class="featured-image"><a href="https://www.bachhausen.de/srf-mehr-als-show-so-nutzt-die-queere-community-den-esc-fuer-sich/">(SRF) Mehr als Show: So nutzt die queere Community den ESC für sich<img width="800" height="534" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA4MDAgNTM0IiB3aWR0aD0iODAwIiBoZWlnaHQ9IjUzNCIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMDklMkZaZWl0dW5nc2xlc2VyLndlYnAiIGRhdGEtdz0iODAwIiBkYXRhLWg9IjUzNCIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="attachment-large size-large wp-post-image" alt="(SRF) Mehr als Show: So nutzt die queere Community den ESC für sich" title="(SRF) Mehr als Show: So nutzt die queere Community den ESC für sich" decoding="async" /></a></div>		<div class='post-header'>
						<h2 class='post-title'>
				<a href="https://www.bachhausen.de/srf-mehr-als-show-so-nutzt-die-queere-community-den-esc-fuer-sich/">(SRF) Mehr als Show: So nutzt die queere Community den ESC für sich</a>
			</h2>
			<div class="post-byline">Von Redaktion am 8. Mai 2025</div>		</div>
		<div class="post-content">
			<p>Der ESC ist queer und massentauglich. Wie nutzen Fans den Event für ihre Anliegen? Eine Kulturwissenschaftlerin erklärt. Direktlink</p>
		</div>
	</article>
	</div></div>


	<nav class="navigation pagination" aria-label="Seitennummerierung der Beiträge">
		<h2 class="screen-reader-text">Seitennummerierung der Beiträge</h2>
		<div class="nav-links"><span aria-current="page" class="page-numbers current">1</span>
<a class="page-numbers" href="https://www.bachhausen.de/page/2/">2</a>
<span class="page-numbers dots">&hellip;</span>
<a class="page-numbers" href="https://www.bachhausen.de/page/445/">445</a>
<a class="next page-numbers" href="https://www.bachhausen.de/page/2/">Nächste</a></div>
	</nav></section> <!-- .main -->
	<aside class="sidebar sidebar-right" id="sidebar-right" role="complementary">
		<div class="inner">
			<section id="media_image-2" class="widget widget_media_image"><h2 class="widget-title">Das bessere Twitter&#8230; Folgen Sie mir auf Mastodon!</h2><figure style="width: 275px" class="wp-caption alignnone"><a href="https://social.cologne/invite/VmZXL3YH"><img width="275" height="183" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNzUgMTgzIiB3aWR0aD0iMjc1IiBoZWlnaHQ9IjE4MyIgZGF0YS11PSJodHRwcyUzQSUyRiUyRnd3dy5iYWNoaGF1c2VuLmRlJTJGd3AtY29udGVudCUyRnVwbG9hZHMlMkYyMDIzJTJGMTAlMkZtYXN0b2Rvbi5qcGciIGRhdGEtdz0iMjc1IiBkYXRhLWg9IjE4MyIgZGF0YS1iaXA9IiI+PC9zdmc+" data-spai="1" class="image wp-image-24099  attachment-full size-full" alt="" style="max-width: 100%; height: auto;" title="Das bessere Twitter... Folgen Sie mir auf Mastodon!" decoding="async" /></a><figcaption class="wp-caption-text">https://social.cologne/@Adama</figcaption></figure></section><section id="ajaxsearchlitewidget-2" class="widget AjaxSearchLiteWidget"><div class="asl_w_container asl_w_container_1">
	<div id='ajaxsearchlite1'
		 data-id="1"
		 data-instance="1"
		 class="asl_w asl_m asl_m_1 asl_m_1_1">
		<div class="probox">

	
	<div class='prosettings' style='display:none;' data-opened=0>
				<div class='innericon'>
			<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="22" height="22" viewBox="0 0 512 512" enable-background="new 0 0 512 512" xml:space="preserve" data-u="https%3A%2F%2Fwww.bachhausen.de%2Fwp-content%2Fuploads%2F2025%2F05%2Fdachau-1875393_1920-1280x720.jpg" data-w="24" data-h="18">
					<polygon transform = "rotate(90 256 256)" points="142.332,104.886 197.48,50 402.5,256 197.48,462 142.332,407.113 292.727,256 "/>
				</svg>
		</div>
	</div>

	
	
	<div class='proinput'>
        <form role="search" action='#' autocomplete="off"
			  aria-label="Search form">
			<input aria-label="Search input"
				   type='search' class='orig'
				   tabindex="0"
				   name='phrase'
				   placeholder='Search here..'
				   value=''
				   autocomplete="off"/>
			<input aria-label="Search autocomplete"
				   type='text'
				   class='autocomplete'
				   tabindex="-1"
				   name='phrase'
				   value=''
				   autocomplete="off" disabled/>
			<input type='submit' value="Start search" style='width:0; height: 0; visibility: hidden;'>
		</form>
	</div>

	
	
	<button class='promagnifier' tabindex="0" aria-label="Search magnifier">
				<span class='innericon' style="display:block;">
			<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" width="22" height="22" viewBox="0 0 512 512" enable-background="new 0 0 512 512" xml:space="preserve" data-u="https%3A%2F%2Fwww.bachhausen.de%2Fwp-content%2Fuploads%2F2025%2F05%2Fdachau-1875393_1920-1280x720.jpg" data-w="24" data-h="18">
					<path d="M460.355,421.59L353.844,315.078c20.041-27.553,31.885-61.437,31.885-98.037
						C385.729,124.934,310.793,50,218.686,50C126.58,50,51.645,124.934,51.645,217.041c0,92.106,74.936,167.041,167.041,167.041
						c34.912,0,67.352-10.773,94.184-29.158L419.945,462L460.355,421.59z M100.631,217.041c0-65.096,52.959-118.056,118.055-118.056
						c65.098,0,118.057,52.959,118.057,118.056c0,65.096-52.959,118.056-118.057,118.056C153.59,335.097,100.631,282.137,100.631,217.041
						z"/>
				</svg>
		</span>
	</button>

	
	
	<div class='proloading'>

		<div class="asl_loader"><div class="asl_loader-inner asl_simple-circle"></div></div>

			</div>

			<div class='proclose'>
			<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px"
				 y="0px"
				 width="12" height="12" viewBox="0 0 512 512" enable-background="new 0 0 512 512"
				 xml:space="preserve">
				<polygon points="438.393,374.595 319.757,255.977 438.378,137.348 374.595,73.607 255.995,192.225 137.375,73.622 73.607,137.352 192.246,255.983 73.622,374.625 137.352,438.393 256.002,319.734 374.652,438.378 "/>
			</svg>
		</div>
	
	
</div>	</div>
	<div class='asl_data_container' style="display:none !important;">
		<div class="asl_init_data wpdreams_asl_data_ct"
	 style="display:none !important;"
	 id="asl_init_id_1"
	 data-asl-id="1"
	 data-asl-instance="1"
	 data-asldata="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"></div>	<div id="asl_hidden_data">
		<svg style="position:absolute" height="0" width="0" data-u="https%3A%2F%2Fwww.bachhausen.de%2Fwp-content%2Fuploads%2F2025%2F05%2Fdachau-1875393_1920-1280x720.jpg" data-w="24" data-h="18">
			<filter id="aslblur">
				<feGaussianBlur in="SourceGraphic" stdDeviation="4"/>
			</filter>
		</svg>
		<svg style="position:absolute" height="0" width="0" data-u="https%3A%2F%2Fwww.bachhausen.de%2Fwp-content%2Fuploads%2F2025%2F05%2Fdachau-1875393_1920-1280x720.jpg" data-w="24" data-h="18">
			<filter id="no_aslblur"></filter>
		</svg>
	</div>
	</div>

	<div id='ajaxsearchliteres1'
	 class='vertical wpdreams_asl_results asl_w asl_r asl_r_1 asl_r_1_1'>

	
	<div class="results">

		
		<div class="resdrg">
		</div>

		
	</div>

	
	
</div>

	<div id='__original__ajaxsearchlitesettings1'
		 data-id="1"
		 class="searchsettings wpdreams_asl_settings asl_w asl_s asl_s_1">
		<form name='options'
	  aria-label="Search settings form"
	  autocomplete = 'off'>

	
	
	<input type="hidden" name="filters_changed" style="display:none;" value="0">
	<input type="hidden" name="filters_initial" style="display:none;" value="1">

	<div class="asl_option_inner hiddend">
		<input type='hidden' name='qtranslate_lang' id='qtranslate_lang1'
			   value='0'/>
	</div>

	
	
	<fieldset class="asl_sett_scroll">
		<legend style="display: none;">Generic selectors</legend>
		<div class="asl_option" tabindex="0">
			<div class="asl_option_inner">
				<input type="checkbox" value="exact"
					   aria-label="Exact matches only"
					   name="asl_gen[]" />
				<div class="asl_option_checkbox"></div>
			</div>
			<div class="asl_option_label">
				Exact matches only			</div>
		</div>
		<div class="asl_option" tabindex="0">
			<div class="asl_option_inner">
				<input type="checkbox" value="title"
					   aria-label="Search in title"
					   name="asl_gen[]"  checked="checked"/>
				<div class="asl_option_checkbox"></div>
			</div>
			<div class="asl_option_label">
				Search in title			</div>
		</div>
		<div class="asl_option" tabindex="0">
			<div class="asl_option_inner">
				<input type="checkbox" value="content"
					   aria-label="Search in content"
					   name="asl_gen[]"  checked="checked"/>
				<div class="asl_option_checkbox"></div>
			</div>
			<div class="asl_option_label">
				Search in content			</div>
		</div>
		<div class="asl_option_inner hiddend">
			<input type="checkbox" value="excerpt"
				   aria-label="Search in excerpt"
				   name="asl_gen[]"  checked="checked"/>
			<div class="asl_option_checkbox"></div>
		</div>
	</fieldset>
	<fieldset class="asl_sett_scroll">
		<legend style="display: none;">Post Type Selectors</legend>
					<div class="asl_option_inner hiddend">
				<input type="checkbox" value="post"
					   aria-label="Hidden option, ignore please"
					   name="customset[]" checked="checked"/>
			</div>
						<div class="asl_option_inner hiddend">
				<input type="checkbox" value="page"
					   aria-label="Hidden option, ignore please"
					   name="customset[]" checked="checked"/>
			</div>
				</fieldset>
	</form>
	</div>
</div></section><section id="custom_html-6" class="widget_text widget widget_custom_html"><div class="textwidget custom-html-widget">
<div id="graphcomment-widget"></div>

<script src="https://graphcomment.com/js/widget.js"></script>

<script>
graphcommentWidget(document.getElementById('graphcomment-widget'), {
  "graphcomment_id": "bachhausen-de",
  "defaultTab": "last_comments",
  "tabs": [
    "last_comments",
    "top_comments",
    "top_threads"
  ],
  "labels": {
    "last_comments": "",
    "top_comments": "",
    "top_threads": ""
  },
  "period": "90 days",
  "limit": 6,
  "height": null,
  "openLinksNewWindow": true,
  "showVotes": true,
  "locale": "de"
});
</script>
    </div></section><section id="em_widget-2" class="widget widget_em_widget"><h2 class="widget-title">Termine</h2><div class="em pixelbones em-list-widget em-events-widget"><li>Keine Veranstaltungen</li><li class="all-events-link"><a href="https://www.bachhausen.de/veranstaltungen/" title="alle Veranstaltungen">alle Veranstaltungen</a></li></div></section>      <section id="mailpoet_form-2" class="widget widget_mailpoet_form">
  
      <h2 class="widget-title">Abonniere meinen Newsletter</h2>
  
  <div class="
    mailpoet_form_popup_overlay
      "></div>
  <div
    id="mailpoet_form_2"
    class="
      mailpoet_form
      mailpoet_form_widget
      mailpoet_form_position_
      mailpoet_form_animation_
    "
      >

    <style type="text/css">
     #mailpoet_form_2 .mailpoet_form {  }
#mailpoet_form_2 .mailpoet_paragraph { line-height: 20px; }
#mailpoet_form_2 .mailpoet_segment_label, #mailpoet_form_2 .mailpoet_text_label, #mailpoet_form_2 .mailpoet_textarea_label, #mailpoet_form_2 .mailpoet_select_label, #mailpoet_form_2 .mailpoet_radio_label, #mailpoet_form_2 .mailpoet_checkbox_label, #mailpoet_form_2 .mailpoet_list_label, #mailpoet_form_2 .mailpoet_date_label { display: block; font-weight: bold; }
#mailpoet_form_2 .mailpoet_text, #mailpoet_form_2 .mailpoet_textarea, #mailpoet_form_2 .mailpoet_select, #mailpoet_form_2 .mailpoet_date_month, #mailpoet_form_2 .mailpoet_date_day, #mailpoet_form_2 .mailpoet_date_year, #mailpoet_form_2 .mailpoet_date { display: block; }
#mailpoet_form_2 .mailpoet_text, #mailpoet_form_2 .mailpoet_textarea { width: 200px; }
#mailpoet_form_2 .mailpoet_checkbox {  }
#mailpoet_form_2 .mailpoet_submit input {  }
#mailpoet_form_2 .mailpoet_divider {  }
#mailpoet_form_2 .mailpoet_message {  }
#mailpoet_form_2 .mailpoet_validate_success { font-weight: 600; color: #468847; }
#mailpoet_form_2 .mailpoet_validate_error { color: #b94a48; }
#mailpoet_form_2 .mailpoet_form_loading { width: 30px; text-align: center; line-height: normal; }
#mailpoet_form_2 .mailpoet_form_loading > span { width: 5px; height: 5px; background-color: #5b5b5b; }#mailpoet_form_2{;}#mailpoet_form_2 .mailpoet_message {margin: 0; padding: 0 20px;}#mailpoet_form_2 .mailpoet_paragraph.last {margin-bottom: 0} @media (max-width: 500px) {#mailpoet_form_2 {background-image: none;}} @media (min-width: 500px) {#mailpoet_form_2 .last .mailpoet_paragraph:last-child {margin-bottom: 0}}  @media (max-width: 500px) {#mailpoet_form_2 .mailpoet_form_column:last-child .mailpoet_paragraph:last-child {margin-bottom: 0}} 
    </style>

    <form
      target="_self"
      method="post"
      action="https://www.bachhausen.de/wp-admin/admin-post.php?action=mailpoet_subscription_form"
      class="mailpoet_form mailpoet_form_form mailpoet_form_widget"
      novalidate
      data-delay=""
      data-exit-intent-enabled=""
      data-font-family=""
      data-cookie-expiration-time=""
    >
      <input type="hidden" name="data[form_id]" value="2" />
      <input type="hidden" name="token" value="878010ac18" />
      <input type="hidden" name="api_version" value="v1" />
      <input type="hidden" name="endpoint" value="subscribers" />
      <input type="hidden" name="mailpoet_method" value="subscribe" />

      <label class="mailpoet_hp_email_label" style="display: none !important;">Bitte dieses Feld leer lassen<input type="email" name="data[email]"/></label><div class="mailpoet_paragraph"><label for="form_first_name_2" class="mailpoet_text_label"  data-automation-id="form_first_name_label" >Vorname</label><input type="text" autocomplete="given-name" class="mailpoet_text" id="form_first_name_2" name="data[form_field_YTUyZTQzNDExOTBmX2ZpcnN0X25hbWU=]" title="Vorname" value="" data-automation-id="form_first_name" data-parsley-errors-container=".mailpoet_error_wlzyx" data-parsley-names='[&quot;Bitte gib einen gültigen Namen an.&quot;,&quot;Adressen in Namen sind nicht erlaubt, bitte füge stattdessen deinen Namen hinzu.&quot;]'/><span class="mailpoet_error_wlzyx"></span></div>
<div class="mailpoet_paragraph"><label for="form_last_name_2" class="mailpoet_text_label"  data-automation-id="form_last_name_label" >Nachname</label><input type="text" autocomplete="family-name" class="mailpoet_text" id="form_last_name_2" name="data[form_field_ZTk5NDBhOWI4ZGI1X2xhc3RfbmFtZQ==]" title="Nachname" value="" data-automation-id="form_last_name" data-parsley-errors-container=".mailpoet_error_1diak" data-parsley-names='[&quot;Bitte gib einen gültigen Namen an.&quot;,&quot;Adressen in Namen sind nicht erlaubt, bitte füge stattdessen deinen Namen hinzu.&quot;]'/><span class="mailpoet_error_1diak"></span></div>
<div class="mailpoet_paragraph"><label for="form_email_2" class="mailpoet_text_label"  data-automation-id="form_email_label" >E-Mail <span class="mailpoet_required" aria-hidden="true">*</span></label><input type="email" autocomplete="email" class="mailpoet_text" id="form_email_2" name="data[form_field_MGNkMDM1MDVjNDM0X2VtYWls]" title="E-Mail" value="" data-automation-id="form_email" data-parsley-errors-container=".mailpoet_error_3zmb8" data-parsley-required="true" required aria-required="true" data-parsley-minlength="6" data-parsley-maxlength="150" data-parsley-type-message="Dieser Wert sollte eine gültige E-Mail-Adresse sein." data-parsley-required-message="Dieses Feld wird benötigt."/><span class="mailpoet_error_3zmb8"></span></div>
<div class="mailpoet_paragraph"><input type="submit" class="mailpoet_submit" value="Abonnieren!" data-automation-id="subscribe-submit-button" style="border-color:transparent;" /><span class="mailpoet_form_loading"><span class="mailpoet_bounce1"></span><span class="mailpoet_bounce2"></span><span class="mailpoet_bounce3"></span></span></div>

      <div class="mailpoet_message">
        <p class="mailpoet_validate_success"
                style="display:none;"
                >Prüfe deinen Posteingang oder Spam-Ordner, um dein Abonnement zu bestätigen.
        </p>
        <p class="mailpoet_validate_error"
                style="display:none;"
                >        </p>
      </div>
    </form>

      </div>

      </section>
  <section id="dailyverseswidget-2" class="widget widget_dailyverseswidget"><h2 class="widget-title">Die Tageslosung</h2><div class="dailyVerses bibleText">Alles hat er so eingerichtet&#44; dass es schön ist zu seiner Zeit. Auch die Ewigkeit hat er den Menschen ins Herz gelegt. Aber das Werk Gottes vom Anfang bis zum Ende kann kein Mensch begreifen.</div><div class="dailyVerses bibleVerse"><a href="https://dailyverses.net/de/2025/5/8/neu" rel="noopener" target="_blank">Prediger 3:11</a></div></section><section id="custom_html-12" class="widget_text widget widget_custom_html"><h2 class="widget-title">Trööts von @Adama</h2><div class="textwidget custom-html-widget">  <script>
    window.addEventListener("load", () => {
      mastodonFeedLoad(
        "https://social.cologne/api/v1/accounts/107285880833303233/statuses?limit=5",
        "include-mastodon-feed-681cd77ebf317",
        {
          linkTarget: "_self",
          showPreviewCards: true,
          excludeConversationStarters: false,
          content: {
            hideStatusMeta: false,
            hideDateTime: false          },
          images: {
            preserveImageAspectRatio: false,
            size: "preview",
            link: "status",
          },
          text: {
            boosted: "boosted 🚀",
            noStatuses: "No statuses available",
            viewOnInstance: "view on instance",
            showContent: "Show content",
            permalinkPre: "on",
            permalinkPost: "",
            edited: "(edited)",
          },
          localization: {
            date: {
              locale: "de-DE",
              options: {},
            }
          }
        }
      );
    });
  </script>
  <div class="include-mastodon-feed" id="include-mastodon-feed-681cd77ebf317">Loading Mastodon feed...</div>
</div></section>		</div>
	</aside>
</div><!-- layout-container -->
</div><!-- content-container -->

    <footer id="site-footer" class="site-footer" role="contentinfo">
                <div class="footer-title-container">
            <div class='site-title has-date'><a href='https://www.bachhausen.de'>Dirk Bachhausen</a></div>            <p class="footer-tagline">Sagen, was ist. – Tun, was man sagt. – Und sein, was man tut.</p>            <ul class='social-media-icons'><li>					<a class="twitter" target="_blank"
					   href="https://twitter.com/dirkBachhausen">
						<i class="fa-brands fa-x-twitter"
						   title="twitter"></i>
					</a>
					</li><li>					<a class="facebook" target="_blank"
					   href="https://www.facebook.com/bachhausen.dirk">
						<i class="fab fa-facebook"
						   title="facebook"></i>
					</a>
					</li><li>					<a class="instagram" target="_blank"
					   href="https://www.instagram.com/dirkbachhausen/">
						<i class="fab fa-instagram"
						   title="instagram"></i>
					</a>
					</li><li>					<a class="email" target="_blank"
					   href="mailto:&#68;ir&#107;&#64;&#98;&#97;c&#104;h&#97;u&#115;&#101;&#110;.&#100;e">
						<i class="fas fa-envelope" title="E-Mail"></i>
					</a>
				</li><li>					<a class="phone" target="_blank"
							href="tel:0178/7122713">
						<i class="fas fa-phone"></i>
						<span class="screen-reader-text">phone</span>
					</a>
				</li><li>					<a class="email-form" target="_blank"
					   href="https://www.bachhausen.de/kontakt/">
						<i class="far fa-envelope"
						   title="email-form"></i>
					</a>
					</li><li>					<a class="amazon" target="_blank"
					   href="https://www.amazon.de/gp/registry/wishlist/183AYZGLZYIOW">
						<i class="fab fa-amazon"
						   title="amazon"></i>
					</a>
					</li><li>					<a class="mastodon" target="_blank"
					   href="https://social.cologne/@Adama">
						<i class="fab fa-mastodon"
						   title="mastodon"></i>
					</a>
					</li><li>					<a class="paypal" target="_blank"
					   href="https://www.paypal.me/DirkBachhausen">
						<i class="fab fa-paypal"
						   title="paypal"></i>
					</a>
					</li><li>					<a class="rss" target="_blank"
					   href="https://www.bachhausen.de/feed/">
						<i class="fas fa-rss"
						   title="rss"></i>
					</a>
					</li><li>					<a class="skype" target="_blank"
					   href="skype:adama1976?call">
						<i class="fab fa-skype"
						   title="skype"></i>
					</a>
				</li><li>					<a class="whatsapp" target="_blank"
					   href="https://wa.me/491787122713">
						<i class="fab fa-whatsapp"
						   title="whatsapp"></i>
					</a>
					</li></ul>        </div>
        <div id="menu-footer-container" class="menu-footer-container">
            <div id="menu-footer" class="menu-container menu-footer" role="navigation">
	</div>
        </div>
        	<aside id="site-footer-widgets" class="widget-area widget-area-site-footer active-3" role="complementary">
		<section id="custom_html-4" class="widget_text widget widget_custom_html"><div class="textwidget custom-html-widget"><h4><strong><span style="color:#ff0000">Dirk Bachhausen</span> </strong></h4>

<p><em>- Politik f&uuml;r Chorweiler und K&ouml;ln -</em><br />
<br />
Korber Weg 17<br />
50767 K&ouml;ln-Lindweiler<br />
<br />
<a href="tel:01787122713">0178/7122713</a><br />
<a href="mailto:dirk@bachhausen.de">dirk@bachhausen.de</a><br />
<span style="font-size:8px">(Durch eine Mail an diese Adresse erlauzen Sie, diese inkl. Emailadresse zu ver&ouml;ffentlichen.! Wenn Sie dies nicht w&uuml;nschen, w&auml;hlen Sie einen anderen Kommunikationsweg!)</span></p>

<p><a href="https://social.cologne/@Adama" rel="me">Mastodon</a></p>

<p>&nbsp;</p></div></section><section id="wettervorhersage_widget-2" class="widget wettervorhersage_widget">
        <div id=""
             class="weather_widget_wrap wettervorhersage-widget weather_widget_style2"
             data-text-color='#ffffff'
             data-background="#0080ff"
             data-width="100"
             data-days="4"
             data-sunrise="false"
             data-wind="on"
             data-language="german"
             data-city="Köln"
             data-country="Germany">

            <div class="weather_widget_placeholder"></div>
<!--            <div style="font-size: 14px;text-align: center;padding-top: 6px;padding-bottom: 4px;background: rgba(0,0,0,0.03);">-->
<!--                Powered by <a target="_blank" href="https://www.wetter2.com">Wetter2.com</a>-->
<!--            </div>-->
        </div>
        </section><section id="custom_html-13" class="widget_text widget widget_custom_html"><div class="textwidget custom-html-widget"><a title="Bewertungen und Erfahrungen zu bachhausen.de" href="https://www.webwiki.de/bachhausen.de"><img src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxIDEiIHdpZHRoPSIxIiBoZWlnaHQ9IjEiIGRhdGEtdT0iaHR0cHMlM0ElMkYlMkZ3d3cud2Vid2lraS5kZSUyRmV0YyUyRnJhdGluZyUyRndpZGdldCUyRjIwMzg0OTA5NyUyRmJhY2hoYXVzZW4tZGUtYmV3ZXJ0dW5nLWZ1bGwtMTgwLnBuZyIgZGF0YS13PSIxIiBkYXRhLWg9IjEiIGRhdGEtYmlwPSIiPjwvc3ZnPg==" data-spai="1" alt="Bewertungen zu bachhausen.de" /></a></div></section>	</aside>
        <div class="design-credit">
            <span>
                <a href="https://www.competethemes.com/mission-news/" rel="nofollow">Mission News Theme</a> by Compete Themes.            </span>
        </div>
            </footer>
</div><!-- .max-width -->
</div><!-- .overflow-container -->


<script type="speculationrules">
{"prerender":[{"source":"document","where":{"and":[{"href_matches":"\/*"},{"not":{"href_matches":["\/wp-*.php","\/wp-admin\/*","\/wp-content\/uploads\/*","\/wp-content\/*","\/wp-content\/plugins\/*","\/wp-content\/themes\/mission-news\/*","\/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prerender, .no-prerender a"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"moderate"}]}
</script>
	<script>
		jQuery(document).ready(function($) {
			var $checkboxes;
			function storekey() {
				var keysVal = $checkboxes.map(function() {
					if(this.checked) return $(this).attr('data-key');
				}).get().join(',');
				// console.log(keysVal)
				$("input[name='fieldVal']").val(keysVal);
			}
			$(function() {
				$checkboxes = $("input[class='listCheckbox']").change(storekey);
			});
		});
	</script>
	
		<div id="schedule-post-delete-modal" style="display: none">
			<img id="schedule-post-delete-modal-loader" src="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA2NCA2NCIgd2lkdGg9IjY0IiBoZWlnaHQ9IjY0IiBkYXRhLXU9Imh0dHBzJTNBJTJGJTJGd3d3LmJhY2hoYXVzZW4uZGUlMkZ3cC1jb250ZW50JTJGcGx1Z2lucyUyRmF1dG8tZGVsZXRlLXBvc3Qtd2l0aC1hdHRhY2htZW50cyUyRmFzc2V0cyUyRmltZyUyRmxvYWRlci5naWYiIGRhdGEtdz0iNjQiIGRhdGEtaD0iNjQiIGRhdGEtYmlwPSIiPjwvc3ZnPg==" data-spai="1" />
		</div>  <script>

    const mastodonFeedCreateElement = function(type, className = null) {
      let element = document.createElement(type);
      if(null !== className) {
        element.className = className;
      }
      return element;
    }

    const mastodonFeedCreateElementAccountLink = function(account) {
      let accountLinkElem = mastodonFeedCreateElement('a');
      accountLinkElem.href = account.url;

      let accountImageElem = mastodonFeedCreateElement('img', 'avatar');
      accountImageElem.src = account.avatar_static;
      accountImageElem.loading = 'lazy';

      accountLinkElem.addEventListener('mouseover', (event) => {
        accountLinkElem.querySelector('.avatar').src = account.avatar;
      });
      accountLinkElem.addEventListener('mouseout', (event) => {
        accountLinkElem.querySelector('.avatar').src = account.avatar_static;
      });

      accountLinkElem.appendChild(accountImageElem);
      // inject emojis
      let displayName = account.display_name;
      if(account.emojis.length > 0) {
        account.emojis.forEach(function(emoji) {
          displayName = mastodonFeedInjectEmoji(displayName, emoji);
        });
      }
      accountLinkElem.innerHTML += ' ' + displayName;
      return accountLinkElem;
    }

    const mastodonFeedCreateElementPermalink = function(status, label) {
      let linkElem = mastodonFeedCreateElement('a');
      linkElem.href = status.url;
      linkElem.appendChild(document.createTextNode(label));
      return linkElem;
    }

    const mastodonFeedCreateElementMediaAttachments = function(status, options) {
      let attachments = status.media_attachments;
      let mediaWrapperElem = mastodonFeedCreateElement('div', 'media');
      for(let mediaIndex = 0; mediaIndex < attachments.length; mediaIndex++) {
        let media = attachments[mediaIndex];
        let mediaElem = mastodonFeedCreateElement('div', media.type);
        if('image' == media.type) {
          let mediaElemImgLink = mastodonFeedCreateElement('a');
          let imageUrl = media.url;
          if(null !== media.remote_url) {
            imageUrl = media.remote_url;
          }
          else if('full' !== options.images.size && null !== media.preview_url) {
            imageUrl = media.preview_url;
          }
          mediaElemImgLink.href = status.url;
          if('image' === options.images.link) {
            mediaElemImgLink.href = media.remote_url ?? media.url;
          }
          if(null !== media.description) {
            mediaElem.title = media.description;
          }
          if(options.images.preserveImageAspectRatio) {
            let mediaElemImgImage = mastodonFeedCreateElement('img');
            mediaElemImgImage.src = imageUrl;
            mediaElemImgImage.loading = 'lazy';
            mediaElemImgLink.appendChild(mediaElemImgImage);
          }
          else {
            mediaElemImgLink.style.backgroundImage = 'url("' + imageUrl + '")';
          }
          mediaElem.appendChild(mediaElemImgLink);
        }
        else if('gifv' == media.type) {
          let mediaElemGifvLink = mastodonFeedCreateElement('a');
          mediaElemGifvLink.href = status.url;
          let mediaElemGifv = mastodonFeedCreateElement('video', 'requiresInteraction');
          if(null === media.remote_url) {
            mediaElemGifv.src = media.url;
          }
          else {
            mediaElemGifv.src = media.remote_url;
          }
          mediaElemGifv.loop = true;
          mediaElemGifv.muted = 'muted';
          if(null !== media.description) {
            mediaElemGifv.title = media.description;
          }
          mediaElemGifvLink.appendChild(mediaElemGifv);
          mediaElem.appendChild(mediaElemGifvLink);

          mediaElemGifv.addEventListener('mouseover', (event) => {
            mediaElemGifv.play();
          });
          mediaElemGifv.addEventListener('mouseout', (event) => {
            mediaElemGifv.pause();
            mediaElemGifv.currentTime = 0;
          });
        }
        else {
          // TODO implement support for other media types
          //      currently only image and gifv support implemented
          mediaElem.innerHTML = 'Stripped ' + media.type + ' - only available on instance<br />';
          let permalinkElem = mastodonFeedCreateElement('span', 'permalink');
          permalinkElem.appendChild(mastodonFeedCreateElementPermalink(status, options.text.viewOnInstance));
          mediaElem.appendChild(permalinkElem);
        }
        mediaWrapperElem.appendChild(mediaElem);
      }
      return mediaWrapperElem;
    }

    const mastodonFeedCreateElementPreviewCard = function(card)  {
      let cardElem = mastodonFeedCreateElement('div', 'card');
          
      if(null === card.html || card.html.length < 1) {
        let cardElemMeta = mastodonFeedCreateElement('div', 'meta');

        if(null !== card.image) {
          let cardElemImageWrapper = mastodonFeedCreateElement('div', 'image');
          let cardElemImage = mastodonFeedCreateElement('img');
          cardElemImage.src = card.image;
          cardElemImage.loading = 'lazy';
          cardElemImageWrapper.appendChild(cardElemImage);
          cardElemMeta.appendChild(cardElemImageWrapper);
        }

        let cardElemTitle = mastodonFeedCreateElement('div', 'title');
        cardElemTitle.innerHTML = card.title;
        cardElemMeta.appendChild(cardElemTitle);

        let cardElemDescription = mastodonFeedCreateElement('div', 'description');
        cardElemDescription.innerHTML = card.description;
        cardElemMeta.appendChild(cardElemDescription);
        
        if(card.url === null) {
          cardElem.appendChild(cardElemMeta);
        }
        else {
          let cardElemLink = mastodonFeedCreateElement('a');
          cardElemLink.href = card.url;
          cardElemLink.appendChild(cardElemMeta);
          cardElem.appendChild(cardElemLink);
        }
      }
      else {
        cardElem.innerHTML = card.html;
      }
      return cardElem;
    }

    const mastodonFeedCreateElementTimeinfo = function(status, options, url = false) {
      let createdInfo = mastodonFeedCreateElement('span', 'permalink');
      createdInfo.innerHTML = ' ' + options.text.permalinkPre + ' ';
      if(false === url) {
        createdInfo.innerHTML += new Date(status.created_at).toLocaleString(options.localization.date.locale, options.localization.date.options);
      }
      else {
        createdInfo.appendChild(mastodonFeedCreateElementPermalink(status, new Date(status.created_at).toLocaleString(options.localization.date.locale, options.localization.date.options)));
      }
      createdInfo.innerHTML += ' ' + options.text.permalinkPost;
      return createdInfo;
    }

    const mastodonFeedInjectEmoji = function(string, emoji) {
      return string.replaceAll(':' + emoji.shortcode + ':', '<img class="emoji" src="' + emoji.url + '" title="' + emoji.shortcode + '" />');
    }

    const mastodonFeedRenderStatuses = function(statuses, rootElem, options) {
      if(statuses.length < 1) {
        rootElem.innerHTML = options.text.noStatuses;
      }
      else {
        for(let i = 0; i < statuses.length; i++) {
          let status = statuses[i];
          let isEdited = (null === status.edited_at ? true : false);
          let isReblog = (null === status.reblog ? false : true);

          let statusElem = mastodonFeedCreateElement('div', 'status');

          // add account meta info
          if(!options.content.hideStatusMeta) {
            let accountElem = mastodonFeedCreateElement('div', 'account');
            if(isReblog) {
              let boosterElem = mastodonFeedCreateElement('span', 'booster');
              boosterElem.appendChild(document.createTextNode( options.text.boosted ));
              accountElem.appendChild(boosterElem);
            }            
            accountElem.appendChild(mastodonFeedCreateElementAccountLink(status.account));
            if(!options.content.hideDateTime) {
              accountElem.appendChild(mastodonFeedCreateElementTimeinfo(status, options, (isReblog ? false : status.url)));
            }
            if(null !== status.edited_at) {
              accountElem.innerHTML += ' ' + options.text.edited;
            }
            statusElem.appendChild(accountElem);
          }

          // prepare content rendering
          let showStatus = status;
          if(isReblog) {
            showStatus = status.reblog;
          }
          let contentWrapperElem = mastodonFeedCreateElement('div', 'contentWrapper' + (isReblog ? ' boosted' : ''));

          // add boosted post meta info
          if(isReblog) {
            let boostElem = mastodonFeedCreateElement('div', 'account');
            let boostAccountLink = mastodonFeedCreateElementAccountLink(showStatus.account);
            boostElem.appendChild(boostAccountLink);
            boostElem.appendChild(mastodonFeedCreateElementTimeinfo(showStatus, options, showStatus.url));

            contentWrapperElem.appendChild(boostElem);
          }

          let contentElem = mastodonFeedCreateElement('div', 'content');

          // handle content warnings
          if(showStatus.sensitive || showStatus.spoiler_text.length > 0) {
            let cwElem = mastodonFeedCreateElement('div', 'contentWarning');

            if(showStatus.spoiler_text.length > 0) {
              let cwTitleElem = mastodonFeedCreateElement('div', 'title');
              cwTitleElem.innerHTML = showStatus.spoiler_text;
              cwElem.appendChild(cwTitleElem);
            }

            let cwLinkElem = mastodonFeedCreateElement('a');
            cwLinkElem.href = '#';
            cwLinkElem.onclick = function() {
              this.parentElement.style = 'display: none;';
              this.parentElement.nextSibling.style = 'display: block;';
              return false;
            }
            cwLinkElem.innerHTML = options.text.showContent;
            cwElem.appendChild(cwLinkElem);

            contentWrapperElem.appendChild(cwElem);
            contentElem.style = 'display: none;';
          }

          // add regular content
          let renderContent = showStatus.content;
          // inject emojis
          if(showStatus.emojis.length > 0) {
            showStatus.emojis.forEach(function(emoji) {
              renderContent = mastodonFeedInjectEmoji(renderContent, emoji);
            });
          }
          contentElem.innerHTML += renderContent;

          // handle media attachments
          if(showStatus.media_attachments.length > 0) {
            let mediaAttachmentsElem = mastodonFeedCreateElementMediaAttachments(showStatus, options);
            contentElem.appendChild(mediaAttachmentsElem);
          }

          // handle preview card
          if(options.showPreviewCards && showStatus.card != null) {
            let cardElem = mastodonFeedCreateElementPreviewCard(showStatus.card);
            contentElem.appendChild(cardElem);
          }

          contentWrapperElem.appendChild(contentElem);
          statusElem.appendChild(contentWrapperElem);
          rootElem.appendChild(statusElem);
        }
      }
      if('_self' != options.linkTarget) {
        rootElem.querySelectorAll('a').forEach(function(e) {
          e.target = options.linkTarget;
        });
      }
    }

    const mastodonFeedLoad = function(url, elementId, options) {
      const xhr = new XMLHttpRequest();
      xhr.open('GET', url, true);
      xhr.responseType = 'json';
      xhr.onload = function() {
        const statuses = xhr.response;
        const rootElem = document.getElementById(elementId);
        rootElem.innerHTML = '';
                if (xhr.status === 200) {
                    if(options.excludeConversationStarters && statuses.length > 0) {
            const filteredStatuses = [];
            for(let i = 0; i < statuses.length; i++) {
              let includeStatus = true;
              if(statuses[i].mentions.length > 0) {
                const statusContent = document.createElement('div');
                statusContent.innerHTML = statuses[i].content;
                const mentionUsername = statuses[i].mentions[0].acct.split('@')[0];
                const plainTextContent = statusContent.textContent || statusContent.innerText;
                if(plainTextContent.substring(1, ('@' + mentionUsername).length) == mentionUsername) {
                  includeStatus = false;
                }
              }
              if(includeStatus) {
                filteredStatuses.push(statuses[i]);
              }
            }
            mastodonFeedRenderStatuses(filteredStatuses, rootElem, options);
          }
          else  {
            mastodonFeedRenderStatuses(statuses, rootElem, options);
          }
        }
        else {
                    rootElem.appendChild(document.createTextNode(xhr.response.error));
        }
      };
      xhr.send();
    }
  </script>
        <script>
            (function () {
                const calculateParentDistance = (child, parent) => {
                    let count = 0;
                    let currentElement = child;

                    // Traverse up the DOM tree until we reach parent or the top of the DOM
                    while (currentElement && currentElement !== parent) {
                        currentElement = currentElement.parentNode;
                        count++;
                    }

                    // If parent was not found in the hierarchy, return -1
                    if (!currentElement) {
                        return -1; // Indicates parent is not an ancestor of element
                    }

                    return count; // Number of layers between element and parent
                }
                const isMatchingClass = (linkRule, href, classes) => {
                    return classes.includes(linkRule.value)
                }
                const isMatchingDomain = (linkRule, href, classes) => {
                    if(!URL.canParse(href)) {
                        return false
                    }

                    const url = new URL(href)

                    return linkRule.value === url.host
                }
                const isMatchingExtension = (linkRule, href, classes) => {
                    if(!URL.canParse(href)) {
                        return false
                    }

                    const url = new URL(href)

                    return url.pathname.endsWith('.' + linkRule.value)
                }
                const isMatchingSubdirectory = (linkRule, href, classes) => {
                    if(!URL.canParse(href)) {
                        return false
                    }

                    const url = new URL(href)

                    return url.pathname.startsWith('/' + linkRule.value + '/')
                }
                const isMatchingProtocol = (linkRule, href, classes) => {
                    if(!URL.canParse(href)) {
                        return false
                    }

                    const url = new URL(href)

                    return url.protocol === linkRule.value + ':'
                }
                const isMatchingExternal = (linkRule, href, classes) => {
                    if(!URL.canParse(href) || !URL.canParse(document.location.href)) {
                        return false
                    }

                    const matchingProtocols = ['http:', 'https:']
                    const siteUrl = new URL(document.location.href)
                    const linkUrl = new URL(href)

                    // Links to subdomains will appear to be external matches according to JavaScript,
                    // but the PHP rules will filter those events out.
                    return matchingProtocols.includes(linkUrl.protocol) && siteUrl.host !== linkUrl.host
                }
                const isMatch = (linkRule, href, classes) => {
                    switch (linkRule.type) {
                        case 'class':
                            return isMatchingClass(linkRule, href, classes)
                        case 'domain':
                            return isMatchingDomain(linkRule, href, classes)
                        case 'extension':
                            return isMatchingExtension(linkRule, href, classes)
                        case 'subdirectory':
                            return isMatchingSubdirectory(linkRule, href, classes)
                        case 'protocol':
                            return isMatchingProtocol(linkRule, href, classes)
                        case 'external':
                            return isMatchingExternal(linkRule, href, classes)
                        default:
                            return false;
                    }
                }
                const track = (element) => {
                    const href = element.href ?? null
                    const classes = Array.from(element.classList)
                    const linkRules = [{"type":"extension","value":"pdf"},{"type":"extension","value":"zip"},{"type":"protocol","value":"mailto"},{"type":"protocol","value":"tel"}]
                    if(linkRules.length === 0) {
                        return
                    }

                    // For link rules that target a class, we need to allow that class to appear
                    // in any ancestor up to the 7th ancestor. This loop looks for those matches
                    // and counts them.
                    linkRules.forEach((linkRule) => {
                        if(linkRule.type !== 'class') {
                            return;
                        }

                        const matchingAncestor = element.closest('.' + linkRule.value)

                        if(!matchingAncestor || matchingAncestor.matches('html, body')) {
                            return;
                        }

                        const depth = calculateParentDistance(element, matchingAncestor)

                        if(depth < 7) {
                            classes.push(linkRule.value)
                        }
                    });

                    const hasMatch = linkRules.some((linkRule) => {
                        return isMatch(linkRule, href, classes)
                    })

                    if(!hasMatch) {
                        return
                    }

                    const url = "https://www.bachhausen.de/wp-content/plugins/independent-analytics/iawp-click-endpoint.php";
                    const body = {
                        href: href,
                        classes: classes.join(' '),
                        ...{"payload":{"resource":"home","page":1},"signature":"d8ef443b2ab532f418c428b83de9abf3"}                    };

                    if (navigator.sendBeacon) {
                        let blob = new Blob([JSON.stringify(body)], {
                            type: "application/json"
                        });
                        navigator.sendBeacon(url, blob);
                    } else {
                        const xhr = new XMLHttpRequest();
                        xhr.open("POST", url, true);
                        xhr.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
                        xhr.send(JSON.stringify(body))
                    }
                }
                document.addEventListener('mousedown', function (event) {
                                        if (navigator.webdriver || /bot|crawler|spider|crawling|semrushbot|chrome-lighthouse/i.test(navigator.userAgent)) {
                        return;
                    }
                    
                    const element = event.target.closest('a')

                    if(!element) {
                        return
                    }

                    const isPro = false
                    if(!isPro) {
                        return
                    }

                    // Don't track left clicks with this event. The click event is used for that.
                    if(event.button === 0) {
                        return
                    }

                    track(element)
                })
                document.addEventListener('click', function (event) {
                                        if (navigator.webdriver || /bot|crawler|spider|crawling|semrushbot|chrome-lighthouse/i.test(navigator.userAgent)) {
                        return;
                    }
                    
                    const element = event.target.closest('a, button, input[type="submit"], input[type="button"]')

                    if(!element) {
                        return
                    }

                    const isPro = false
                    if(!isPro) {
                        return
                    }

                    track(element)
                })
                document.addEventListener('play', function (event) {
                                        if (navigator.webdriver || /bot|crawler|spider|crawling|semrushbot|chrome-lighthouse/i.test(navigator.userAgent)) {
                        return;
                    }
                    
                    const element = event.target.closest('audio, video')

                    if(!element) {
                        return
                    }

                    const isPro = false
                    if(!isPro) {
                        return
                    }

                    track(element)
                }, true)
                document.addEventListener("DOMContentLoaded", function (e) {
                    if (document.hasOwnProperty("visibilityState") && document.visibilityState === "prerender") {
                        return;
                    }

                                            if (navigator.webdriver || /bot|crawler|spider|crawling|semrushbot|chrome-lighthouse/i.test(navigator.userAgent)) {
                            return;
                        }
                    
                    let referrer_url = null;

                    if (typeof document.referrer === 'string' && document.referrer.length > 0) {
                        referrer_url = document.referrer;
                    }

                    const params = location.search.slice(1).split('&').reduce((acc, s) => {
                        const [k, v] = s.split('=');
                        return Object.assign(acc, {[k]: v});
                    }, {});

                    const url = "https://www.bachhausen.de/wp-json/iawp/search";
                    const body = {
                        referrer_url,
                        utm_source: params.utm_source,
                        utm_medium: params.utm_medium,
                        utm_campaign: params.utm_campaign,
                        utm_term: params.utm_term,
                        utm_content: params.utm_content,
                        gclid: params.gclid,
                        ...{"payload":{"resource":"home","page":1},"signature":"d8ef443b2ab532f418c428b83de9abf3"}                    };

                    if (navigator.sendBeacon) {
                        let blob = new Blob([JSON.stringify(body)], {
                            type: "application/json"
                        });
                        navigator.sendBeacon(url, blob);
                    } else {
                        const xhr = new XMLHttpRequest();
                        xhr.open("POST", url, true);
                        xhr.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
                        xhr.send(JSON.stringify(body))
                    }
                });
            })();
        </script>
        <script type="application/ld+json" data-source="DataFeed:WordPress" data-schema="56744-post-Default">{"@context":"https:\/\/schema.org\/","@type":"Blog","@id":"https:\/\/www.bachhausen.de#Blog","headline":"Dirk Bachhausen","description":"Sagen, was ist. \u2013 Tun, was man sagt. \u2013 Und sein, was man tut.","url":"https:\/\/www.bachhausen.de","hasPart":[{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/tacheles_4-arbeit-macht-frei-80-jahre-kriegsende\/","headline":"[tacheles_4]: \u201cArbeit macht frei\u201d \u2013 80 Jahre Kriegsende","url":"https:\/\/www.bachhausen.de\/tacheles_4-arbeit-macht-frei-80-jahre-kriegsende\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/tacheles_4-arbeit-macht-frei-80-jahre-kriegsende\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/kossiski\/#Person","name":"Belltower News","url":"https:\/\/www.bachhausen.de\/author\/kossiski\/","identifier":2,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/bde97fdd7333b0a8bf3ad9ebeb51cbfddae822d3766e9b7a52bc3ecb72ae9932?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/bde97fdd7333b0a8bf3ad9ebeb51cbfddae822d3766e9b7a52bc3ecb72ae9932?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2025\/05\/dachau-1875393_1920-1280x720.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2025\/05\/dachau-1875393_1920-1280x720.jpg","height":720,"width":1280},"wordCount":1753,"keywords":["arbeit","jahre","kriegsende","macht","tacheles"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/bewegung-im-insolvenzverfahren-nord-stream-2-ag-will-sich-zeit-erkaufen\/","headline":"Bewegung im Insolvenzverfahren \u2013 Nord Stream 2 AG will sich Zeit erkaufen","url":"https:\/\/www.bachhausen.de\/bewegung-im-insolvenzverfahren-nord-stream-2-ag-will-sich-zeit-erkaufen\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/bewegung-im-insolvenzverfahren-nord-stream-2-ag-will-sich-zeit-erkaufen\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/correctiv\/#Person","name":"Correctiv.org","url":"https:\/\/www.bachhausen.de\/author\/correctiv\/","identifier":15,"description":"<div class=\"elementor-element elementor-element-3e1bf03c elementor-widget elementor-widget-heading\" data-id=\"3e1bf03c\">\r\n<div class=\"elementor-widget-container\">\r\n<h1 class=\"elementor-heading-title elementor-size-default\">Recherchen f\u00fcr die Gesellschaft und mit der Gesellschaft<\/h1>\r\n<\/div>\r\n<\/div>\r\n<section class=\"elementor-element elementor-element-5be37e09 elementor-section-content-middle elementor-section-boxed elementor-section-height-default elementor-section-height-default elementor-section elementor-inner-section\" data-id=\"5be37e09\">\r\n<div class=\"elementor-container elementor-column-gap-no\">\r\n<div class=\"elementor-row\">\r\n<div class=\"elementor-element elementor-element-63cc7109 elementor-column elementor-col-50 elementor-inner-column\" data-id=\"63cc7109\">\r\n<div class=\"elementor-column-wrap elementor-element-populated\">\r\n<div class=\"elementor-widget-wrap\">\r\n<div class=\"elementor-element elementor-element-7d9688e9 elementor-widget elementor-widget-text-editor\" data-id=\"7d9688e9\">\r\n<div class=\"elementor-widget-container\">\r\n<div class=\"elementor-text-editor elementor-clearfix\">\r\n\r\n<strong>Investigativ. Unabh\u00e4ngig. Gemeinn\u00fctzig.<\/strong>\r\nCORRECTIV\u00a0ist das erste gemeinn\u00fctzige Recherchezentrum im deutschsprachigen Raum. Wir recherchieren langfristig zu Missst\u00e4nden in der Gesellschaft, f\u00f6rdern Medienkompetenz und f\u00fchren Bildungsprogramme durch.\r\n\r\n<a href=\"https:\/\/correctiv.org\/\">https:\/\/correctiv.org\/<\/a>\r\n\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/div>\r\n<\/section>","image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/51a6c0962ec4a7a9fff8508f3b6a21069f40fbb9a1ee7294cca7a040ced87b6c?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/51a6c0962ec4a7a9fff8508f3b6a21069f40fbb9a1ee7294cca7a040ced87b6c?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":1011,"keywords":["bewegung","erkaufen","insolvenzverfahren","stream"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/koeln-heimersdorf-ksv-heimersdorf-wartet-sehnsuechtig-auf-platzsanierung\/","headline":"K\u00f6ln-Heimersdorf: KSV Heimersdorf wartet sehns\u00fcchtig auf Platzsanierung","url":"https:\/\/www.bachhausen.de\/koeln-heimersdorf-ksv-heimersdorf-wartet-sehnsuechtig-auf-platzsanierung\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/koeln-heimersdorf-ksv-heimersdorf-wartet-sehnsuechtig-auf-platzsanierung\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/ksta\/#Person","name":"K\u00f6lner Stadtanzeiger","url":"https:\/\/www.bachhausen.de\/author\/ksta\/","identifier":3,"description":"Der K\u00f6lner Stadtanzeiger","image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/a3f43e8250594c4ed8be9e86201eefa6cc06ef89c032788db696432ac7e77173?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/a3f43e8250594c4ed8be9e86201eefa6cc06ef89c032788db696432ac7e77173?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":184,"keywords":["heimersdorf","platzsanierung","sehnsuchtig","wartet"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/come-together-cup-auf-den-stadionvorwiesen\/","headline":"Come-Together-Cup auf den Stadionvorwiesen","url":"https:\/\/www.bachhausen.de\/come-together-cup-auf-den-stadionvorwiesen\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/come-together-cup-auf-den-stadionvorwiesen\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/report-k\/#Person","name":"Report K","url":"https:\/\/www.bachhausen.de\/author\/report-k\/","identifier":20,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/36af2c4c1f6de1245282e2f6d3e4483d8c1fb911663df347a69e69f7ff897aac?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/36af2c4c1f6de1245282e2f6d3e4483d8c1fb911663df347a69e69f7ff897aac?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.report-k.de\/wp-content\/uploads\/2024\/12\/kbonnentin_transparent_mtypo-2-300x154.png","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.report-k.de\/wp-content\/uploads\/2024\/12\/kbonnentin_transparent_mtypo-2-300x154.png","height":0,"width":0},"wordCount":183,"keywords":["stadionvorwiesen","together"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/kritische-rohstoffe-und-menschenrechte-ursula-von-der-leyen-muss-wort-halten\/","headline":"Kritische Rohstoffe und Menschenrechte: \u201eUrsula von der Leyen muss Wort halten\u201c","url":"https:\/\/www.bachhausen.de\/kritische-rohstoffe-und-menschenrechte-ursula-von-der-leyen-muss-wort-halten\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/kritische-rohstoffe-und-menschenrechte-ursula-von-der-leyen-muss-wort-halten\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/netzpolitik-org\/#Person","name":"Netzpolitik.org","url":"https:\/\/www.bachhausen.de\/author\/netzpolitik-org\/","identifier":16,"description":"<p class=\"footer__licence\"><strong>Lizenz: <\/strong> Die von netzpolitik.org verfassten Inhalte stehen unter der Lizenz <a href=\"http:\/\/creativecommons.org\/licenses\/by-nc-sa\/4.0\/\">Creative Commons BY-NC-SA 4.0.<\/a><\/p>","image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/4298c2313ababab34aa7eef4ac5338572b0e5d48047c1b7de48f7cc6830c3ffa?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/4298c2313ababab34aa7eef4ac5338572b0e5d48047c1b7de48f7cc6830c3ffa?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/cdn.netzpolitik.org\/wp-upload\/2025\/05\/Amnesty_DRK_Kobalt_\u00a9AmnestyInternational_videographers_Reportage-Sans-Frontieres-3-scaled.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/cdn.netzpolitik.org\/wp-upload\/2025\/05\/Amnesty_DRK_Kobalt_\u00a9AmnestyInternational_videographers_Reportage-Sans-Frontieres-3-scaled.jpg","height":0,"width":0},"wordCount":3850,"keywords":["halten","kritische","leyen","menschenrechte","rohstoffe","ursula"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/br-podcast-queer-adhs-so-beeinflusst-es-leilas-leben\/","headline":"(BR Podcast) Queer &amp; ADHS &#8211; so beeinflusst es Leilas Leben","url":"https:\/\/www.bachhausen.de\/br-podcast-queer-adhs-so-beeinflusst-es-leilas-leben\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/br-podcast-queer-adhs-so-beeinflusst-es-leilas-leben\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/#Person","name":"Redaktion","url":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/","identifier":19,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":85,"keywords":["beeinflusst","leben","leilas","podcast","queer"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/human-rights-watch-gejammer-ueber-woke-vernebelt-washington\/","headline":"(Human Rights Watch) Gejammer \u00fcber &#8220;Woke&#8221; vernebelt Washington","url":"https:\/\/www.bachhausen.de\/human-rights-watch-gejammer-ueber-woke-vernebelt-washington\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/human-rights-watch-gejammer-ueber-woke-vernebelt-washington\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/#Person","name":"Redaktion","url":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/","identifier":19,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":43,"keywords":["gejammer","human","rights","vernebelt","washington","watch"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/spiegel-bella-ramsey-haelt-es-fuer-wichtig-bei-schauspielpreisen-zwischen-maennern-und-frauen-zu-trennen\/","headline":"(Spiegel) Bella Ramsey h\u00e4lt es f\u00fcr wichtig, bei Schauspielpreisen zwischen M\u00e4nnern und Frauen zu trennen","url":"https:\/\/www.bachhausen.de\/spiegel-bella-ramsey-haelt-es-fuer-wichtig-bei-schauspielpreisen-zwischen-maennern-und-frauen-zu-trennen\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/spiegel-bella-ramsey-haelt-es-fuer-wichtig-bei-schauspielpreisen-zwischen-maennern-und-frauen-zu-trennen\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/#Person","name":"Redaktion","url":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/","identifier":19,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":56,"keywords":["bella","mannern","ramsey","schauspielpreisen","spiegel","wichtig","zwischen"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/frankfurter-rundschau-frankfurt-keine-waggons-nur-fuer-flinta\/","headline":"(Frankfurter Rundschau) Frankfurt: Keine Waggons nur f\u00fcr &#8220;Flinta&#8221;","url":"https:\/\/www.bachhausen.de\/frankfurter-rundschau-frankfurt-keine-waggons-nur-fuer-flinta\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/frankfurter-rundschau-frankfurt-keine-waggons-nur-fuer-flinta\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/#Person","name":"Redaktion","url":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/","identifier":19,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":42,"keywords":["flinta","frankfurt","frankfurter","keine","rundschau","waggons"]},{"@type":"NewsArticle","@id":"https:\/\/www.bachhausen.de\/srf-mehr-als-show-so-nutzt-die-queere-community-den-esc-fuer-sich\/","headline":"(SRF) Mehr als Show: So nutzt die queere Community den ESC f\u00fcr sich","url":"https:\/\/www.bachhausen.de\/srf-mehr-als-show-so-nutzt-die-queere-community-den-esc-fuer-sich\/","datePublished":"2025-05-08","dateModified":"2025-05-08","mainEntityOfPage":"https:\/\/www.bachhausen.de\/srf-mehr-als-show-so-nutzt-die-queere-community-den-esc-fuer-sich\/","author":{"@type":"Person","@id":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/#Person","name":"Redaktion","url":"https:\/\/www.bachhausen.de\/author\/lindweiler-de\/","identifier":19,"image":{"@type":"ImageObject","@id":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/?s=96&d=monsterid&r=g","height":96,"width":96}},"publisher":{"@type":"Person","name":"Dirk Bachhausen","image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","url":"https:\/\/cdn.shortpixel.ai\/spai\/q_lossy+ret_img+to_auto\/www.bachhausen.de\/wp-content\/uploads\/2019\/07\/dirk_profil-300x300.jpg","width":600,"height":60}},"image":{"@type":"ImageObject","@id":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","url":"https:\/\/cdn.shortpixel.ai\/spai\/ret_img\/www.bachhausen.de\/wp-content\/uploads\/2023\/09\/Zeitungsleser.webp","height":534,"width":800},"wordCount":34,"keywords":["community","nutzt","queere"]}]}</script>
<script type="application/ld+json" data-source="DataFeed:WordPress" data-schema="Website">{"@context":"https:\/\/schema.org","@type":"WebSite","@id":"https:\/\/www.bachhausen.de\/#website","name":"Dirk Bachhausen","url":"https:\/\/www.bachhausen.de","potentialAction":{"@type":"SearchAction","target":"https:\/\/www.bachhausen.de\/?s={search_term_string}","query-input":"required name=search_term_string"}}</script>
<script>

			var wppl_precheck_remember_me = function() {

				// check remember me by default
				var forms = document.querySelectorAll('form'); 						
				if (forms) {

					var rememberMeNames = ['rememberme', 'remember', 'rcp_user_remember'];
					var rememberArray = [];

					// loop through each remember me name and see if there's a field that matches
					for( z = 0; z < rememberMeNames.length; z++ ) {
						var input = document.getElementsByName( rememberMeNames[z] );
						if( input.length ) {
							rememberArray.push(input);
						}
					}
					
					// if there are remember me inputs
					if( rememberArray.length ) { 	
					
						// 'check' the inputs so they're active		
							for (i = 0; i < rememberArray.length; i++) {
								for (x = 0; x < rememberArray[i].length; x++) {
								  rememberArray[i][x].checked = true;
								}
							}
					
					}

					
					// test for Ultimate Member Plugin forms
						
						// find the UM checkboxes
						var UmCheckboxIcon = document.querySelectorAll('.um-icon-android-checkbox-outline-blank');
						var UmCheckboxLabel = document.querySelectorAll('.um-field-checkbox');
						
						if( UmCheckboxIcon.length && UmCheckboxLabel.length ) {
							
							// loop through UM checkboxes
							for (i = 0; i < UmCheckboxLabel.length; i++) {
								
								// find the UM input element
								var UMCheckboxElement = UmCheckboxLabel[i].children;
								var UMCheckboxElementName = UMCheckboxElement[0].getAttribute('name');
								
								// check if UM input element is remember me box
								if( UMCheckboxElementName === 'remember' || UMCheckboxElementName === 'rememberme' ) {
									
									// activate the UM checkbox if it is a remember me box
									UmCheckboxLabel[i].classList.add('active');
									
									// swap out UM classes to show the active state
									UmCheckboxIcon[i].classList.add('um-icon-android-checkbox-outline');
									UmCheckboxIcon[i].classList.remove('um-icon-android-checkbox-outline-blank');
									
								} // endif
							
							} // end for

						} // endif UM
						
						
						
					// test for AR Member
						
						var ArmRememberMeCheckboxContainer = document.querySelectorAll('.arm_form_input_container_rememberme');
						
						if( ArmRememberMeCheckboxContainer.length ) {
							
							for (i = 0; i < ArmRememberMeCheckboxContainer.length; i++) {
								
								var ArmRememberMeCheckbox = ArmRememberMeCheckboxContainer[i].querySelectorAll('md-checkbox');
								
								if( ArmRememberMeCheckbox.length ) {
									// loop through AR Member checkboxes
									for (x = 0; x < ArmRememberMeCheckbox.length; x++) {
										if( ArmRememberMeCheckbox[x].classList.contains('ng-empty') ) {
											ArmRememberMeCheckbox[x].click();
										}
									}
								}
								
							}
							
						} // end if AR Member
							
							
			
				} // endif forms

			}

			document.addEventListener('DOMContentLoaded', function(event) {
				wppl_precheck_remember_me();
			});

			</script><!-- Click to Chat - https://holithemes.com/plugins/click-to-chat/  v4.21 -->  
            <div class="ht-ctc ht-ctc-chat ctc-analytics ctc_wp_desktop style-2  " id="ht-ctc-chat"  
                style="display: none;  position: fixed; bottom: 10px; right: 10px;"   >
                                <div class="ht_ctc_style ht_ctc_chat_style">
                <div title = 'WhatsApp Kontakt' style="display: flex; justify-content: center; align-items: center;  " class="ctc-analytics ctc_s_2">
    <p class="ctc-analytics ctc_cta ctc_cta_stick ht-ctc-cta " style="padding: 0px 16px; line-height: 1.6; ; background-color: #25D366; color: #ffffff; border-radius:10px; margin:0 10px;  display: none; ">WhatsApp Kontakt</p>
    <svg style="pointer-events:none; display:block; height:50px; width:50px;" width="50px" height="50px" viewBox="0 0 1024 1024" data-u="https%3A%2F%2Fwww.bachhausen.de%2Fwp-content%2Fuploads%2F2025%2F05%2Fdachau-1875393_1920-1280x720.jpg" data-w="24" data-h="18">
        <defs>
        <path id="htwasqicona-chat" d="M1023.941 765.153c0 5.606-.171 17.766-.508 27.159-.824 22.982-2.646 52.639-5.401 66.151-4.141 20.306-10.392 39.472-18.542 55.425-9.643 18.871-21.943 35.775-36.559 50.364-14.584 14.56-31.472 26.812-50.315 36.416-16.036 8.172-35.322 14.426-55.744 18.549-13.378 2.701-42.812 4.488-65.648 5.3-9.402.336-21.564.505-27.15.505l-504.226-.081c-5.607 0-17.765-.172-27.158-.509-22.983-.824-52.639-2.646-66.152-5.4-20.306-4.142-39.473-10.392-55.425-18.542-18.872-9.644-35.775-21.944-50.364-36.56-14.56-14.584-26.812-31.471-36.415-50.314-8.174-16.037-14.428-35.323-18.551-55.744-2.7-13.378-4.487-42.812-5.3-65.649-.334-9.401-.503-21.563-.503-27.148l.08-504.228c0-5.607.171-17.766.508-27.159.825-22.983 2.646-52.639 5.401-66.151 4.141-20.306 10.391-39.473 18.542-55.426C34.154 93.24 46.455 76.336 61.07 61.747c14.584-14.559 31.472-26.812 50.315-36.416 16.037-8.172 35.324-14.426 55.745-18.549 13.377-2.701 42.812-4.488 65.648-5.3 9.402-.335 21.565-.504 27.149-.504l504.227.081c5.608 0 17.766.171 27.159.508 22.983.825 52.638 2.646 66.152 5.401 20.305 4.141 39.472 10.391 55.425 18.542 18.871 9.643 35.774 21.944 50.363 36.559 14.559 14.584 26.812 31.471 36.415 50.315 8.174 16.037 14.428 35.323 18.551 55.744 2.7 13.378 4.486 42.812 5.3 65.649.335 9.402.504 21.564.504 27.15l-.082 504.226z"/>
        </defs>
        <linearGradient id="htwasqiconb-chat" gradientUnits="userSpaceOnUse" x1="512.001" y1=".978" x2="512.001" y2="1025.023">
            <stop offset="0" stop-color="#61fd7d"/>
            <stop offset="1" stop-color="#2bb826"/>
        </linearGradient>
        <use xlink:href="#htwasqicona-chat" overflow="visible" style="fill: url(#htwasqiconb-chat)" fill="url(#htwasqiconb-chat)"/>
        <g>
            <path style="fill: #FFFFFF;" fill="#FFF" d="M783.302 243.246c-69.329-69.387-161.529-107.619-259.763-107.658-202.402 0-367.133 164.668-367.214 367.072-.026 64.699 16.883 127.854 49.017 183.522l-52.096 190.229 194.665-51.047c53.636 29.244 114.022 44.656 175.482 44.682h.151c202.382 0 367.128-164.688 367.21-367.094.039-98.087-38.121-190.319-107.452-259.706zM523.544 808.047h-.125c-54.767-.021-108.483-14.729-155.344-42.529l-11.146-6.612-115.517 30.293 30.834-112.592-7.259-11.544c-30.552-48.579-46.688-104.729-46.664-162.379.066-168.229 136.985-305.096 305.339-305.096 81.521.031 158.154 31.811 215.779 89.482s89.342 134.332 89.312 215.859c-.066 168.243-136.984 305.118-305.209 305.118zm167.415-228.515c-9.177-4.591-54.286-26.782-62.697-29.843-8.41-3.062-14.526-4.592-20.645 4.592-6.115 9.182-23.699 29.843-29.053 35.964-5.352 6.122-10.704 6.888-19.879 2.296-9.176-4.591-38.74-14.277-73.786-45.526-27.275-24.319-45.691-54.359-51.043-63.543-5.352-9.183-.569-14.146 4.024-18.72 4.127-4.109 9.175-10.713 13.763-16.069 4.587-5.355 6.117-9.183 9.175-15.304 3.059-6.122 1.529-11.479-.765-16.07-2.293-4.591-20.644-49.739-28.29-68.104-7.447-17.886-15.013-15.466-20.645-15.747-5.346-.266-11.469-.322-17.585-.322s-16.057 2.295-24.467 11.478-32.113 31.374-32.113 76.521c0 45.147 32.877 88.764 37.465 94.885 4.588 6.122 64.699 98.771 156.741 138.502 21.892 9.45 38.982 15.094 52.308 19.322 21.98 6.979 41.982 5.995 57.793 3.634 17.628-2.633 54.284-22.189 61.932-43.615 7.646-21.427 7.646-39.791 5.352-43.617-2.294-3.826-8.41-6.122-17.585-10.714z"/>
        </g>
        </svg></div>                </div>
            </div>
                        <span class="ht_ctc_chat_data" 
                data-no_number=""
                data-settings="{&quot;number&quot;:&quot;491787122713&quot;,&quot;pre_filled&quot;:&quot;Hallo! Ich melde mich von der Seite https:\/\/www.bachhausen.de\/.&quot;,&quot;dis_m&quot;:&quot;show&quot;,&quot;dis_d&quot;:&quot;show&quot;,&quot;css&quot;:&quot;display: none; cursor: pointer; z-index: 99999999;&quot;,&quot;pos_d&quot;:&quot;position: fixed; bottom: 10px; right: 10px;&quot;,&quot;pos_m&quot;:&quot;position: fixed; bottom: 10px; right: 10px;&quot;,&quot;schedule&quot;:&quot;no&quot;,&quot;se&quot;:&quot;no-show-effects&quot;,&quot;ani&quot;:&quot;no-animation&quot;,&quot;url_structure_d&quot;:&quot;web&quot;,&quot;url_target_d&quot;:&quot;_blank&quot;,&quot;ga&quot;:&quot;yes&quot;,&quot;g_init&quot;:&quot;default&quot;,&quot;g_an_event_name&quot;:&quot;chat: {number}&quot;,&quot;pixel_event_name&quot;:&quot;Click to Chat by HoliThemes&quot;}" 
            ></span>
            <link rel='stylesheet' id='wpt_widget-css' href='https://www.bachhausen.de/wp-content/plugins/wp-tab-widget/css/wp-tab-widget.css?ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='mailpoet_public-css' href='https://www.bachhausen.de/wp-content/plugins/mailpoet/assets/dist/css/mailpoet-public.b1f0906e.css?ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='mailpoet_custom_fonts_0-css' href='https://fonts.googleapis.com/css?family=Abril+FatFace%3A400%2C400i%2C700%2C700i%7CAlegreya%3A400%2C400i%2C700%2C700i%7CAlegreya+Sans%3A400%2C400i%2C700%2C700i%7CAmatic+SC%3A400%2C400i%2C700%2C700i%7CAnonymous+Pro%3A400%2C400i%2C700%2C700i%7CArchitects+Daughter%3A400%2C400i%2C700%2C700i%7CArchivo%3A400%2C400i%2C700%2C700i%7CArchivo+Narrow%3A400%2C400i%2C700%2C700i%7CAsap%3A400%2C400i%2C700%2C700i%7CBarlow%3A400%2C400i%2C700%2C700i%7CBioRhyme%3A400%2C400i%2C700%2C700i%7CBonbon%3A400%2C400i%2C700%2C700i%7CCabin%3A400%2C400i%2C700%2C700i%7CCairo%3A400%2C400i%2C700%2C700i%7CCardo%3A400%2C400i%2C700%2C700i%7CChivo%3A400%2C400i%2C700%2C700i%7CConcert+One%3A400%2C400i%2C700%2C700i%7CCormorant%3A400%2C400i%2C700%2C700i%7CCrimson+Text%3A400%2C400i%2C700%2C700i%7CEczar%3A400%2C400i%2C700%2C700i%7CExo+2%3A400%2C400i%2C700%2C700i%7CFira+Sans%3A400%2C400i%2C700%2C700i%7CFjalla+One%3A400%2C400i%2C700%2C700i%7CFrank+Ruhl+Libre%3A400%2C400i%2C700%2C700i%7CGreat+Vibes%3A400%2C400i%2C700%2C700i&#038;ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='mailpoet_custom_fonts_1-css' href='https://fonts.googleapis.com/css?family=Heebo%3A400%2C400i%2C700%2C700i%7CIBM+Plex%3A400%2C400i%2C700%2C700i%7CInconsolata%3A400%2C400i%2C700%2C700i%7CIndie+Flower%3A400%2C400i%2C700%2C700i%7CInknut+Antiqua%3A400%2C400i%2C700%2C700i%7CInter%3A400%2C400i%2C700%2C700i%7CKarla%3A400%2C400i%2C700%2C700i%7CLibre+Baskerville%3A400%2C400i%2C700%2C700i%7CLibre+Franklin%3A400%2C400i%2C700%2C700i%7CMontserrat%3A400%2C400i%2C700%2C700i%7CNeuton%3A400%2C400i%2C700%2C700i%7CNotable%3A400%2C400i%2C700%2C700i%7CNothing+You+Could+Do%3A400%2C400i%2C700%2C700i%7CNoto+Sans%3A400%2C400i%2C700%2C700i%7CNunito%3A400%2C400i%2C700%2C700i%7COld+Standard+TT%3A400%2C400i%2C700%2C700i%7COxygen%3A400%2C400i%2C700%2C700i%7CPacifico%3A400%2C400i%2C700%2C700i%7CPoppins%3A400%2C400i%2C700%2C700i%7CProza+Libre%3A400%2C400i%2C700%2C700i%7CPT+Sans%3A400%2C400i%2C700%2C700i%7CPT+Serif%3A400%2C400i%2C700%2C700i%7CRakkas%3A400%2C400i%2C700%2C700i%7CReenie+Beanie%3A400%2C400i%2C700%2C700i%7CRoboto+Slab%3A400%2C400i%2C700%2C700i&#038;ver=6.8.1' type='text/css' media='all' />
<link rel='stylesheet' id='mailpoet_custom_fonts_2-css' href='https://fonts.googleapis.com/css?family=Ropa+Sans%3A400%2C400i%2C700%2C700i%7CRubik%3A400%2C400i%2C700%2C700i%7CShadows+Into+Light%3A400%2C400i%2C700%2C700i%7CSpace+Mono%3A400%2C400i%2C700%2C700i%7CSpectral%3A400%2C400i%2C700%2C700i%7CSue+Ellen+Francisco%3A400%2C400i%2C700%2C700i%7CTitillium+Web%3A400%2C400i%2C700%2C700i%7CUbuntu%3A400%2C400i%2C700%2C700i%7CVarela%3A400%2C400i%2C700%2C700i%7CVollkorn%3A400%2C400i%2C700%2C700i%7CWork+Sans%3A400%2C400i%2C700%2C700i%7CYatra+One%3A400%2C400i%2C700%2C700i&#038;ver=6.8.1' type='text/css' media='all' />
<script type="text/javascript" id="ht_ctc_app_js-js-extra">
/* <![CDATA[ */
var ht_ctc_chat_var = {"number":"491787122713","pre_filled":"Hallo! Ich melde mich von der Seite https:\/\/www.bachhausen.de\/.","dis_m":"show","dis_d":"show","css":"display: none; cursor: pointer; z-index: 99999999;","pos_d":"position: fixed; bottom: 10px; right: 10px;","pos_m":"position: fixed; bottom: 10px; right: 10px;","schedule":"no","se":"no-show-effects","ani":"no-animation","url_structure_d":"web","url_target_d":"_blank","ga":"yes","g_init":"default","g_an_event_name":"chat: {number}","pixel_event_name":"Click to Chat by HoliThemes"};
var ht_ctc_variables = {"g_an_event_name":"chat: {number}","pixel_event_type":"trackCustom","pixel_event_name":"Click to Chat by HoliThemes","g_an_params":["g_an_param_1","g_an_param_2","g_an_param_3"],"g_an_param_1":{"key":"number","value":"{number}"},"g_an_param_2":{"key":"title","value":"{title}"},"g_an_param_3":{"key":"url","value":"{url}"},"pixel_params":["pixel_param_1","pixel_param_2","pixel_param_3","pixel_param_4"],"pixel_param_1":{"key":"Category","value":"Click to Chat for WhatsApp"},"pixel_param_2":{"key":"ID","value":"{number}"},"pixel_param_3":{"key":"Title","value":"{title}"},"pixel_param_4":{"key":"URL","value":"{url}"}};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/click-to-chat-for-whatsapp/new/inc/assets/js/app.js?ver=4.21" id="ht_ctc_app_js-js"></script>
<script type="text/javascript" id="auto-delete-post-with-attachments-js-extra">
/* <![CDATA[ */
var IMSPD = {"ajaxurl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php","_wpnonce":"60892b9244"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/auto-delete-post-with-attachments/assets/js/front.js?ver=0.0.1" id="auto-delete-post-with-attachments-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/awesome-weather/js/awesome-weather-widget-frontend.js?ver=1.1" id="awesome_weather-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/dist/hooks.min.js?ver=4d63a3d491d11ffd8ac6" id="wp-hooks-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-includes/js/dist/i18n.min.js?ver=5e580eb46a90c2b997e6" id="wp-i18n-js"></script>
<script type="text/javascript" id="wp-i18n-js-after">
/* <![CDATA[ */
wp.i18n.setLocaleData( { 'text direction\u0004ltr': [ 'ltr' ] } );
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/contact-form-7/includes/swv/js/index.js?ver=6.0.6" id="swv-js"></script>
<script type="text/javascript" id="contact-form-7-js-translations">
/* <![CDATA[ */
( function( domain, translations ) {
	var localeData = translations.locale_data[ domain ] || translations.locale_data.messages;
	localeData[""].domain = domain;
	wp.i18n.setLocaleData( localeData, domain );
} )( "contact-form-7", {"translation-revision-date":"2025-02-03 17:24:24+0000","generator":"GlotPress\/4.0.1","domain":"messages","locale_data":{"messages":{"":{"domain":"messages","plural-forms":"nplurals=2; plural=n != 1;","lang":"de"},"This contact form is placed in the wrong place.":["Dieses Kontaktformular wurde an der falschen Stelle platziert."],"Error:":["Fehler:"]}},"comment":{"reference":"includes\/js\/index.js"}} );
/* ]]> */
</script>
<script type="text/javascript" id="contact-form-7-js-before">
/* <![CDATA[ */
var wpcf7 = {
    "api": {
        "root": "https:\/\/www.bachhausen.de\/wp-json\/",
        "namespace": "contact-form-7\/v1"
    },
    "cached": 1
};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/contact-form-7/includes/js/index.js?ver=6.0.6" id="contact-form-7-js"></script>
<script type="text/javascript" id="lbwps-photoswipe5-js-extra">
/* <![CDATA[ */
var lbwpsOptions = {"label_facebook":"Auf Facebook teilen","label_twitter":"Tweet","label_pinterest":"Auf Pinterest merken","label_download":"Herunterladen","label_copyurl":"Bild-URL kopieren","label_ui_close":"Schlie\u00dfen [Esc]","label_ui_zoom":"Zoom","label_ui_prev":"Vorheriges [\u2190]","label_ui_next":"N\u00e4chstes [\u2192]","label_ui_error":"Das Bild kann nicht geladen werden","label_ui_fullscreen":"Vollbild umschalten [F]","share_facebook":"1","share_twitter":"1","share_pinterest":"1","share_download":"1","share_direct":"0","share_copyurl":"0","close_on_drag":"1","history":"1","show_counter":"1","show_fullscreen":"1","show_zoom":"1","show_caption":"1","loop":"1","pinchtoclose":"1","taptotoggle":"1","close_on_click":"1","fulldesktop":"0","use_alt":"0","usecaption":"1","desktop_slider":"1","share_custom_label":"","share_custom_link":"","wheelmode":"zoom","spacing":"12","idletime":"4000","hide_scrollbars":"1","caption_type":"overlay","bg_opacity":"100","padding_left":"0","padding_top":"0","padding_right":"0","padding_bottom":"0"};
/* ]]> */
</script>
<script type="module" src="https://www.bachhausen.de/wp-content/plugins/lightbox-photoswipe/assets/ps5/frontend.min.js?ver=5.6.2" data-spai-excluded="true"></script><script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/mailgo/dist/mailgo.min.js?ver=0.12.2" id="mailgo_script-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/qa-heatmap-analytics/js/behavioral-data-record.js?ver=4.1.2.1" id="qahm-behavioral-data-record-js"></script>
<script type="text/javascript" id="search-insights-frontend-js-js-extra">
/* <![CDATA[ */
var search_insights_ajax = {"ajaxurl":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php","token":"0783823a53"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/wp-search-insights/assets/js/frontend.min.js?ver=1.4.0" id="search-insights-frontend-js-js"></script>
<script type="text/javascript" id="ct-mission-news-js-js-extra">
/* <![CDATA[ */
var mission_news_objectL10n = {"openMenu":"Men\u00fc \u00f6ffnen","closeMenu":"Men\u00fc schliessen","openChildMenu":"Dropdown-Men\u00fc \u00f6ffnen","closeChildMenu":"Dropdown-Men\u00fc schliessen"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/themes/mission-news/js/build/production.min.js?ver=6.8.1" id="ct-mission-news-js-js"></script>
<script type="text/javascript" id="wd-asl-ajaxsearchlite-js-before">
/* <![CDATA[ */
window.ASL = typeof window.ASL !== 'undefined' ? window.ASL : {}; window.ASL.wp_rocket_exception = "DOMContentLoaded"; window.ASL.ajaxurl = "https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php"; window.ASL.backend_ajaxurl = "https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php"; window.ASL.js_scope = "jQuery"; window.ASL.asl_url = "https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/"; window.ASL.detect_ajax = 1; window.ASL.media_query = 4769; window.ASL.version = 4769; window.ASL.pageHTML = ""; window.ASL.additional_scripts = [{"handle":"wd-asl-ajaxsearchlite","src":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/js\/min\/plugin\/optimized\/asl-prereq.js","prereq":[]},{"handle":"wd-asl-ajaxsearchlite-core","src":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/js\/min\/plugin\/optimized\/asl-core.js","prereq":[]},{"handle":"wd-asl-ajaxsearchlite-vertical","src":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/js\/min\/plugin\/optimized\/asl-results-vertical.js","prereq":["wd-asl-ajaxsearchlite"]},{"handle":"wd-asl-ajaxsearchlite-autocomplete","src":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/js\/min\/plugin\/optimized\/asl-autocomplete.js","prereq":["wd-asl-ajaxsearchlite"]},{"handle":"wd-asl-ajaxsearchlite-load","src":"https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/js\/min\/plugin\/optimized\/asl-load.js","prereq":["wd-asl-ajaxsearchlite-autocomplete"]}]; window.ASL.script_async_load = false; window.ASL.init_only_in_viewport = true; window.ASL.font_url = "https:\/\/www.bachhausen.de\/wp-content\/plugins\/ajax-search-lite\/css\/fonts\/icons2.woff2"; window.ASL.css_async = false; window.ASL.highlight = {"enabled":false,"data":[]}; window.ASL.analytics = {"method":0,"tracking_id":"","string":"?ajax_search={asl_term}","event":{"focus":{"active":1,"action":"focus","category":"ASL","label":"Input focus","value":"1"},"search_start":{"active":0,"action":"search_start","category":"ASL","label":"Phrase: {phrase}","value":"1"},"search_end":{"active":1,"action":"search_end","category":"ASL","label":"{phrase} | {results_count}","value":"1"},"magnifier":{"active":1,"action":"magnifier","category":"ASL","label":"Magnifier clicked","value":"1"},"return":{"active":1,"action":"return","category":"ASL","label":"Return button pressed","value":"1"},"facet_change":{"active":0,"action":"facet_change","category":"ASL","label":"{option_label} | {option_value}","value":"1"},"result_click":{"active":1,"action":"result_click","category":"ASL","label":"{result_title} | {result_url}","value":"1"}}};
window.ASL_INSTANCES = [];window.ASL_INSTANCES[1] = {"homeurl":"https:\/\/www.bachhausen.de\/","resultstype":"vertical","resultsposition":"hover","itemscount":4,"charcount":0,"highlight":0,"highlightwholewords":1,"singleHighlight":0,"scrollToResults":{"enabled":0,"offset":0},"resultareaclickable":1,"autocomplete":{"enabled":1,"lang":"en","trigger_charcount":0},"mobile":{"menu_selector":"#menu-toggle"},"trigger":{"click":"results_page","click_location":"same","update_href":0,"return":"results_page","return_location":"same","facet":1,"type":1,"redirect_url":"?s={phrase}","delay":300},"animations":{"pc":{"settings":{"anim":"fadedrop","dur":300},"results":{"anim":"fadedrop","dur":300},"items":"voidanim"},"mob":{"settings":{"anim":"fadedrop","dur":300},"results":{"anim":"fadedrop","dur":300},"items":"voidanim"}},"autop":{"state":"disabled","phrase":"","count":1},"resPage":{"useAjax":0,"selector":"#main","trigger_type":1,"trigger_facet":1,"trigger_magnifier":0,"trigger_return":0},"resultsSnapTo":"left","results":{"width":"auto","width_tablet":"auto","width_phone":"auto"},"settingsimagepos":"right","closeOnDocClick":1,"overridewpdefault":1,"override_method":"get"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/ajax-search-lite/js/min/plugin/optimized/asl-prereq.js?ver=4769" id="wd-asl-ajaxsearchlite-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/ajax-search-lite/js/min/plugin/optimized/asl-core.js?ver=4769" id="wd-asl-ajaxsearchlite-core-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/ajax-search-lite/js/min/plugin/optimized/asl-results-vertical.js?ver=4769" id="wd-asl-ajaxsearchlite-vertical-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/ajax-search-lite/js/min/plugin/optimized/asl-autocomplete.js?ver=4769" id="wd-asl-ajaxsearchlite-autocomplete-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/ajax-search-lite/js/min/plugin/optimized/asl-load.js?ver=4769" id="wd-asl-ajaxsearchlite-load-js"></script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/ajax-search-lite/js/min/plugin/optimized/asl-wrapper.js?ver=4769" id="wd-asl-ajaxsearchlite-wrapper-js"></script>
<script type="text/javascript" id="wpt_widget-js-extra">
/* <![CDATA[ */
var wpt = {"ajax_url":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php"};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/wp-tab-widget/js/wp-tab-widget.js?ver=6.8.1" id="wpt_widget-js"></script>
<script type="text/javascript" id="mailpoet_public-js-extra">
/* <![CDATA[ */
var MailPoetForm = {"ajax_url":"https:\/\/www.bachhausen.de\/wp-admin\/admin-ajax.php","is_rtl":"","ajax_common_error_message":"Fehler bei der Ausf\u00fchrung einer Anfrage, bitte sp\u00e4ter erneut versuchen."};
/* ]]> */
</script>
<script type="text/javascript" src="https://cdn.shortpixel.ai/spai/ret_auto/www.bachhausen.de/wp-content/plugins/mailpoet/assets/dist/js/public.js?ver=5.12.1" id="mailpoet_public-js" defer="defer" data-wp-strategy="defer"></script>

</body>
</html> "[tacheles_4]: “Arbeit macht frei” – 80 Jahre Kriegsende")
Belltower.News Das Tor des ehemaligen KZ in Dachau. (Quelle: pixabay) Der 8. Mai 2025 markiert den 80. Jahrestag der Kapitulation der Nationalsozialisten und somit das Ende des Zweiten Weltkriegs. Lange haben Holocaust-Überlebende, Familien und Angehörige der Ermordeten alleine um eine gelebte Erinnerungskultur im Land der Täter und darüber hinaus gerungen…
Dieser Artikel stammt von Netzpolitik.org. Biometrie: Passbilder in der Amazon Cloud Wer seine biometrischen Passbilder bei einem externen Dienstleister macht, muss damit rechnen, dass sie in der Amazon Cloud landen – und damit vor dem Zugriff von US-Behörden nicht sicher sind. Das haben IT-Sicherheitsforscher herausgefunden. 08.05.2025 um 16:05 Uhr – Markus…
Dieser Artikel stammt von CORRECTIV.Faktencheck / Zur Quelle wechseln Russland/Ukraine Bewegung im Insolvenzverfahren – Nord Stream 2 AG will sich Zeit erkaufen Einzelne Firmen, die für Nord Stream 2 Leistungen erbracht hatten, haben nach langer Wartezeit ihr Geld erhalten. Damit könnte das Unternehmen versuchen, eine Insolvenz vorerst abzuwenden. Für potenzielle…
Auf der Prioritätenliste steht der KSV Heimersdorf auf Platz 11, weiß Gökpinar. „Das klingt nicht schlecht, aber es gibt kein Signal, wann mit der Umsetzung zu rechnen ist“, sagt er. Eine Perspektive aber wäre bereits enorm hilfreich, meint Kowarowski. „Wenn wir den Eltern sagen könnten, in drei, vier oder fünf…
Report-K Köln braucht Report-K. Jetzt braucht Report-K Euch, die Kölner:innen. Werde K-bonnent:in und leiste Deinen Beitrag zur Existenzsicherung von report-K und Medienvielfalt in Köln. Du bist bereits K-bonnent:in? Passwort vergessen Hast Du noch kein K-bo? Schließe ein K-bo für nur 4,85 /Monat ab. Deine Vorteile: • Zugriff auf über…
Dieser Artikel stammt von Netzpolitik.org. Von Berlin und Nairobi aus engagieren sich Kristina Hatas und Christian Rumu für Menschenrechte. Die eine ist Expertin für Klimagerechtigkeit, Wirtschaft und Menschenrechte bei Amnesty International Deutschland, der andere leitet Amnesty Internationals regionales Programm gegen Geschlechterungleichheit in der Demokratischen Republik Kongo, Ruanda und Burundi. Beide…
Wenn Leila in der Schule der Unterrichtsstoff nicht interessiert hat, dann konnte sie sich einfach nicht konzentrieren. Und beim Daten war Leila superschnell verliebt – aber nach zwei Wochen war das Gefühls-High wieder weg. Der Grund: Sie hat ADHS. Wir wollen von Leila für diese Folge wissen: Wie ist es,…
