<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE module [
  <!ELEMENT module (dtdversion,name,version,description*,help*,about*,requires*,file+)>
  <!ELEMENT dtdversion (#PCDATA)>
  <!ELEMENT name (#PCDATA)>
  <!ELEMENT version (#PCDATA)>
  <!ELEMENT mincmsversion (#PCDATA)>
  <!ELEMENT description (#PCDATA)>
  <!ELEMENT help (#PCDATA)>
  <!ELEMENT about (#PCDATA)>
  <!ELEMENT requires (requiredname,requiredversion)>
  <!ELEMENT requiredname (#PCDATA)>
  <!ELEMENT requiredversion (#PCDATA)>
  <!ELEMENT file (filename,isdir,data)>
  <!ELEMENT filename (#PCDATA)>
  <!ELEMENT isdir (#PCDATA)>
  <!ELEMENT data (#PCDATA)>
]>
<module>
	<dtdversion>1.3</dtdversion>
	<name>Losungen</name>
	<version>1.0.1</version>
  <mincmsversion>1.9.4.3</mincmsversion>
	<help><![CDATA[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]]></help>
	<about><![CDATA[PGJyIC8+QXV0aG9yOiBibGF0dGVydGVjaCBpbmZvcm1hdGlrICZsdDtpbmZvQGJsYXR0ZXJ0ZWNoLmNoJmd0OzxiciAvPjxiciAvPlZlcnNpb246IDEuMC4xPGJyIC8+]]></about>
	<description><![CDATA[-- Missing Languagestring - module:Losungen string:moddescription--]]></description>
	<file>
	  <filename>/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/action.admin_editoption.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQojDQojIE1vZHVsZSA6IExvc3VuZ2VuIChjKSAyMDEyIGJ5IGJsYXR0ZXJ0ZWNoIGluZm9ybWF0aWsgKGluZm9AYmxhdHRlcnRlY2guY2gpDQojICAgICAgICAgIEhlcnJuaHV0ZXIgTG9zdW5nZW4gZsO8ciBDTVMgTWFkZSBTaW1wbGUNCiMgICAgICAgICAgVGhlIHByb2plY3RzIGhvbWVwYWdlIGlzIGRldi5jbXNtYWRlc2ltcGxlLm9yZy9wcm9qZWN0cy9sb3N1bmcvDQojICAgICAgICAgIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNC0yMDExIGJ5IFRlZCBLdWxwDQojICAgICAgICAgIFRoZSBwcm9qZWN0cyBob21lcGFnZSBpczogY21zbWFkZXNpbXBsZS5vcmcNCiMgVmVyc2lvbjogMS4wLjENCiMgRmlsZSAgIDogYWN0aW9uLmFkbWluX2VkaXRvcHRpb24ucGhwDQojIFB1cnBvc2U6IFNhdmUgYW5kIEVkaXQgT3B0aW9ucw0KIyBMaWNlbnNlOiBHUEwNCiMNCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQoNCmlmICghJHRoaXMtPkNoZWNrUGVybWlzc2lvbignVXNlIExvc3VuZycpKSByZXR1cm47DQoNCmlmIChpc3NldCgkcGFyYW1zWydyZXNldGJ1dHRvbiddKSApDQp7DQoJJGZpbGVuYW1lID0gJGZpbGVuYW1lID0gcmVhbHBhdGgoZGlybmFtZShfX0ZJTEVfXykgLiIvdGVtcGxhdGVzL2xvc3VuZy50cGwiKTsNCgkkdGVtcGxhdGUgPSAiIjsJDQoJaWYgKGlzX2ZpbGUoJGZpbGVuYW1lKSkgJHRlbXBsYXRlID0gZmlsZV9nZXRfY29udGVudHMoJGZpbGVuYW1lKTsNCgkNCgkkdGhpcy0+U2V0VGVtcGxhdGUoImxvc3VuZ2VuIiwgJHRlbXBsYXRlKTsNCn0NCmVsc2Ugew0KCSR0aGlzLT5TZXRUZW1wbGF0ZSgibG9zdW5nZW4iLCAkcGFyYW1zWyd0ZW1wbGF0ZSddKTsNCn0NCg0KJHRoaXMtPlJlZGlyZWN0KCRpZCwgJ2RlZmF1bHRhZG1pbicsICRyZXR1cm5pZCwgYXJyYXkoJ21lc3NhZ2UnPT4gJ29wdGlvbnNfdXBkYXRlZCcsICdhY3RpdmVfdGFiJyA9PiAnbG9zdW5nJykpOw0K]]></data>
	</file>
	<file>
	  <filename>/action.default.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/action.defaultadmin.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQojDQojIE1vZHVsZSA6IExvc3VuZ2VuIChjKSAyMDEyIGJ5IGJsYXR0ZXJ0ZWNoIGluZm9ybWF0aWsgKGluZm9AYmxhdHRlcnRlY2guY2gpDQojICAgICAgICAgIEhlcnJuaHV0ZXIgTG9zdW5nZW4gZsO8ciBDTVMgTWFkZSBTaW1wbGUNCiMgICAgICAgICAgVGhlIHByb2plY3RzIGhvbWVwYWdlIGlzIGRldi5jbXNtYWRlc2ltcGxlLm9yZy9wcm9qZWN0cy9sb3N1bmcvDQojICAgICAgICAgIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNC0yMDExIGJ5IFRlZCBLdWxwDQojICAgICAgICAgIFRoZSBwcm9qZWN0cyBob21lcGFnZSBpczogY21zbWFkZXNpbXBsZS5vcmcNCiMgVmVyc2lvbjogMS4wLjENCiMgRmlsZSAgIDogYWN0aW9uLmRlZmF1bHRhZG1pbi5waHANCiMgUHVycG9zZTogcGVyZm9ybXMgdGhlIGRlZmF1bHQgYmFja2VuZCBhY3Rpb24gaWYgIkNvbnRlbnQtPkxvc3VuZyIgaXMgc2VsZWN0ZWQNCiMgTGljZW5zZTogR1BMDQojDQojLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQ0KDQppZighZnVuY3Rpb25fZXhpc3RzKCdjbXNtcycpIHx8ICFpc19vYmplY3QoY21zbXMoKSkpIGV4aXQ7DQoNCmlmICghJHRoaXMtPkNoZWNrUGVybWlzc2lvbignVXNlIExvc3VuZ2VuJykpIHsNCglyZXR1cm47DQp9DQoNCmlmIChpc3NldCgkcGFyYW1zWydhY3RpdmVfdGFiJ10pIGFuZCAkcGFyYW1zWydhY3RpdmVfdGFiJ10gIT0gIiIpIA0KCSR0YWIgPSAkcGFyYW1zWydhY3RpdmVfdGFiJ107DQplbHNlIA0KCSR0YWIgPSAibG9zdW5nIjsNCg0KJGdDbXMgPSBjbXNtcygpOw0KDQplY2hvICR0aGlzLT5TdGFydFRhYkhlYWRlcnMoKTsNCg0KZWNobyAkdGhpcy0+U2V0VGFiSGVhZGVyKCdsb3N1bmcnLCAkdGhpcy0+TGFuZygnZnJpZW5kbHlfbmFtZScpLCAoJHRhYiA9PSAnbG9zdW5nJykpOw0KDQplY2hvICR0aGlzLT5FbmRUYWJIZWFkZXJzKCk7DQplY2hvICR0aGlzLT5TdGFydFRhYkNvbnRlbnQoKTsNCg0KZWNobyAkdGhpcy0+U3RhcnRUYWIoJ2xvc3VuZycsICRwYXJhbXMpOw0KaW5jbHVkZSBkaXJuYW1lKF9fRklMRV9fKSAuICcvZnVuY3Rpb24uYWRtaW5fbG9zdW5nLnBocCc7DQplY2hvICR0aGlzLT5FbmRUYWIoKTsNCg0KZWNobyAkdGhpcy0+RW5kVGFiQ29udGVudCgpOw0KDQoNCg==]]></data>
	</file>
	<file>
	  <filename>/function.admin_losung.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQojDQojIE1vZHVsZSA6IExvc3VuZ2VuIChjKSAyMDExIGJ5IGJsYXR0ZXJ0ZWNoIGluZm9ybWF0aWsgKGluZm9AYmxhdHRlcnRlY2guY2gpDQojICAgICAgICAgIEhlcnJuaHV0ZXIgTG9zdW5nZW4gZsO8ciBDTVMgTWFkZSBTaW1wbGUNCiMgICAgICAgICAgVGhlIHByb2plY3RzIGhvbWVwYWdlIGlzIGRldi5jbXNtYWRlc2ltcGxlLm9yZy9wcm9qZWN0cy9sb3N1bmcvDQojICAgICAgICAgIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNC0yMDExIGJ5IFRlZCBLdWxwDQojICAgICAgICAgIFRoZSBwcm9qZWN0cyBob21lcGFnZSBpczogY21zbWFkZXNpbXBsZS5vcmcNCiMgVmVyc2lvbjogMS4wLjENCiMgRmlsZSAgIDogZnVuY3Rpb24uYWRtaW5fbG9zdW5nLnBocA0KIyBQdXJwb3NlOiBFaW5zdGVsbHVuZ2VuIExvc3VuZ2VuDQojIExpY2Vuc2U6IEdQTA0KIw0KIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCg0KaWYgKCEkdGhpcy0+Q2hlY2tQZXJtaXNzaW9uKCdVc2UgTG9zdW5nJykpIHJldHVybjsNCg0KJHNtYXJ0eS0+YXNzaWduKCdzdGFydEZvcm0nLCAkdGhpcy0+Q3JlYXRlRm9ybVN0YXJ0KCRpZCwgJ2FkbWluX2VkaXRvcHRpb24nLCAkcmV0dXJuaWQsJ3Bvc3QnLCdtdWx0aXBhcnQvZm9ybS1kYXRhJykpOw0KJHNtYXJ0eS0+YXNzaWduKCdlbmRGb3JtJywJICR0aGlzLT5DcmVhdGVGb3JtRW5kKCkpOw0KJHNtYXJ0eS0+YXNzaWduKCdzdWJtaXQnLCAgICAkdGhpcy0+Q3JlYXRlSW5wdXRTdWJtaXQoJGlkLCAnc3VibWl0JywgbGFuZygnc3VibWl0JykpKTsNCiRzbWFydHktPmFzc2lnbigncmVzZXQnLCAgICAkdGhpcy0+Q3JlYXRlSW5wdXRTdWJtaXQoJGlkLCAncmVzZXRidXR0b24nLCAkdGhpcy0+TGFuZygncmVzZXRidXR0b24nKSkpOw0KDQokc21hcnR5LT5hc3NpZ24oJ3Byb21wdF9saXplbnonLCAkdGhpcy0+TGFuZygnbGl6ZW56JykpOw0KJHNtYXJ0eS0+YXNzaWduKCdwcm9tcHRfbGl6ZW56aGlud2VpcycsICR0aGlzLT5MYW5nKCdsaXplbnpoaW53ZWlzJykpOw0KJHNtYXJ0eS0+YXNzaWduKCdwcm9tcHRfdGVtcGxhdGUnLCAkdGhpcy0+TGFuZygncHJvbXB0X3RlbXBsYXRlJykpOw0KJHNtYXJ0eS0+YXNzaWduKCdpbnB1dF90ZW1wbGF0ZScsICR0aGlzLT5DcmVhdGVTeW50YXhBcmVhICgkaWQsICR0aGlzLT5HZXRUZW1wbGF0ZSgibG9zdW5nZW4iKSwgJ3RlbXBsYXRlJywndGJfdGV4dGFyZWEnLCcnLCcnLCcnLCc4MCcsJzUnKSk7DQoNCiRzbWFydHktPmFzc2lnbignZ2xvYmFsb3B0aW9ucycsICR0aGlzLT5MYW5nKCdnbG9iYWxvcHRpb25zJykpOw0KDQoNCmVjaG8gJHRoaXMtPlByb2Nlc3NUZW1wbGF0ZSgnYWRtaW5fbG9zdW5nLnRwbCcpOw0KDQo=]]></data>
	</file>
	<file>
	  <filename>/index.html</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[]]></data>
	</file>
	<file>
	  <filename>/lang/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/lang/de_DE.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/lang/en_US.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/Losungen.module.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/losungen/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/losungen/losungen2012.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[﻿<?xml version="1.0" standalone="yes"?>
<FreeXml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://losungen.de/losungen.xsd">
  <Losungen>
    <Datum>2012-01-01T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Neujahr</Sonntag>
    <Losungstext>Die Furcht des HERRN wird Zions Schatz sein.</Losungstext>
    <Losungsvers>Jesaja 33,6</Losungsvers>
    <Lehrtext>Ein Mann war in Jerusalem, mit Namen Simeon; und dieser Mann war fromm und gottesfürchtig und wartete auf den Trost Israels. Er nahm Jesus auf seine Arme und lobte Gott und sprach: Herr, nun lässt du deinen Diener in Frieden fahren, wie du gesagt hast; denn meine Augen haben deinen Heiland gesehen.</Lehrtext>
    <Lehrtextvers>Lukas 2,25.28-30</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-02T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist deine Zuversicht.</Losungstext>
    <Losungsvers>Psalm 91,9</Losungsvers>
    <Lehrtext>Alle eure Sorge werft auf ihn; denn er sorgt für euch.</Lehrtext>
    <Lehrtextvers>1.Petrus 5,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-03T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Vor einem grauen Haupt sollst du aufstehen und die Alten ehren.</Losungstext>
    <Losungsvers>3.Mose 19,32</Losungsvers>
    <Lehrtext>Einen Älteren fahre nicht an, sondern ermahne ihn wie einen Vater, die jüngeren Männer wie Brüder, die älteren Frauen wie Mütter, die jüngeren wie Schwestern, mit allem Anstand.</Lehrtext>
    <Lehrtextvers>1.Timotheus 5,1-2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-04T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt nicht stehlen noch lügen noch betrügerisch handeln einer mit dem andern.</Losungstext>
    <Losungsvers>3.Mose 19,11</Losungsvers>
    <Lehrtext>Die Liebe freut sich nicht über die Ungerechtigkeit, sie freut sich aber an der Wahrheit.</Lehrtext>
    <Lehrtextvers>1.Korinther 13,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-05T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wo viele Träume sind und viele Worte, ist auch viel Nichtiges. Gott sollst du fürchten!</Losungstext>
    <Losungsvers>Prediger 5,6</Losungsvers>
    <Lehrtext>Wer sollte dich, Herr, nicht fürchten und deinen Namen nicht preisen? Denn du allein bist heilig!</Lehrtext>
    <Lehrtextvers>Offenbarung 15,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-06T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag>Epiphanias (Erscheinungsfest)</Sonntag>
    <Losungstext>Deinen Willen, mein Gott, tue ich gern, und dein Gesetz hab ich in meinem Herzen.</Losungstext>
    <Losungsvers>Psalm 40,9</Losungsvers>
    <Lehrtext>/Christus spricht:/ Liebt ihr mich, so werdet ihr meine Gebote halten.</Lehrtext>
    <Lehrtextvers>Johannes 14,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-07T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn ich mich zu Bette lege, so denke ich an dich, wenn ich wach liege, sinne ich über dich nach.</Losungstext>
    <Losungsvers>Psalm 63,7</Losungsvers>
    <Lehrtext>Sollte Gott nicht Recht schaffen seinen Auserwählten, die zu ihm Tag und Nacht rufen, und sollte er's bei ihnen lange hinziehen?</Lehrtext>
    <Lehrtextvers>Lukas 18,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-08T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag nach Epiphanias</Sonntag>
    <Losungstext>Weh denen, die Schaden zu tun trachten, weil sie die Macht haben!</Losungstext>
    <Losungsvers>Micha 2,1</Losungsvers>
    <Lehrtext>Jesus sprach: Mit welchem Maß ihr messt, wird man euch wieder messen.</Lehrtext>
    <Lehrtextvers>Markus 4,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-09T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Weh denen, die sich verlassen auf Rosse und hoffen auf Wagen, weil ihrer viele sind, und fragen nichts nach dem HERRN!</Losungstext>
    <Losungsvers>Jesaja 31,1</Losungsvers>
    <Lehrtext>Euer Glaube stehe nicht auf Menschenweisheit, sondern auf Gottes Kraft.</Lehrtext>
    <Lehrtextvers>1.Korinther 2,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-10T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Zerreißt eure Herzen und nicht eure Kleider und bekehret euch zu dem HERRN, eurem Gott!</Losungstext>
    <Losungsvers>Joel 2,13</Losungsvers>
    <Lehrtext>Jesus sprach: Die Zeit ist erfüllt und das Reich Gottes ist herbeigekommen. Tut Buße und glaubt an das Evangelium!</Lehrtext>
    <Lehrtextvers>Markus 1,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-11T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Siehe, was ich früher verkündigt habe, ist gekommen. So verkündige ich auch Neues; ehe denn es aufgeht, lasse ich's euch hören.</Losungstext>
    <Losungsvers>Jesaja 42,9</Losungsvers>
    <Lehrtext>Die Finsternis vergeht und das wahre Licht scheint jetzt.</Lehrtext>
    <Lehrtextvers>1.Johannes 2,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-12T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR sprach zu Gideon: Friede sei mit dir! Fürchte dich nicht, du wirst nicht sterben. Da baute Gideon dem HERRN dort einen Altar und nannte ihn: »Der HERR ist Friede«.</Losungstext>
    <Losungsvers>Richter 6,23-24</Losungsvers>
    <Lehrtext>/Christus spricht:/ In der Welt habt ihr Angst; aber seid getrost, ich habe die Welt überwunden.</Lehrtext>
    <Lehrtextvers>Johannes 16,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-13T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Tröstet, tröstet mein Volk! spricht euer Gott.</Losungstext>
    <Losungsvers>Jesaja 40,1</Losungsvers>
    <Lehrtext>Gott, der sprach: Licht soll aus der Finsternis hervorleuchten, der hat einen hellen Schein in unsre Herzen gegeben, dass durch uns entstünde die Erleuchtung zur Erkenntnis der Herrlichkeit Gottes in dem Angesicht Jesu Christi.</Lehrtext>
    <Lehrtextvers>2.Korinther 4,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-14T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Alle Lande sollen seiner Ehre voll werden!</Losungstext>
    <Losungsvers>Psalm 72,19</Losungsvers>
    <Lehrtext>/Christus spricht:/ Gehet hin in alle Welt und predigt das Evangelium aller Kreatur.</Lehrtext>
    <Lehrtextvers>Markus 16,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-15T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>2. Sonntag nach Epiphanias</Sonntag>
    <Losungstext>Wehe denen, die ein Haus zum andern bringen und einen Acker an den andern rücken, bis kein Raum mehr da ist und sie allein das Land besitzen!</Losungstext>
    <Losungsvers>Jesaja 5,8</Losungsvers>
    <Lehrtext>Was hat ein Mensch davon, wenn er die ganze Welt gewinnt, aber zuletzt sein Leben verliert?</Lehrtext>
    <Lehrtextvers>Markus 8,36</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-16T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Hütet euch, dass sich euer Herz nicht betören lasse, dass ihr abfallt und dient andern Göttern und betet sie an.</Losungstext>
    <Losungsvers>5.Mose 11,16</Losungsvers>
    <Lehrtext>Wir haben nur #einen# Gott, den Vater, von dem alle Dinge sind und wir zu ihm; und #einen# Herrn, Jesus Christus, durch den alle Dinge sind und wir durch ihn.</Lehrtext>
    <Lehrtextvers>1.Korinther 8,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-17T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Dein, HERR, ist das Reich, und du bist erhöht zum Haupt über alles.</Losungstext>
    <Losungsvers>1.Chronik 29,11</Losungsvers>
    <Lehrtext>Lasst uns wahrhaftig sein in der Liebe und wachsen in allen Stücken zu dem hin, der das Haupt ist, Christus.</Lehrtext>
    <Lehrtextvers>Epheser 4,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-18T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist unser Richter, der HERR ist unser Meister, der HERR ist unser König; der hilft uns!</Losungstext>
    <Losungsvers>Jesaja 33,22</Losungsvers>
    <Lehrtext>Der Vater des kranken Kindes schrie: Ich glaube; hilf meinem Unglauben!</Lehrtext>
    <Lehrtextvers>Markus 9,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-19T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Danket dem HERRN; denn er ist freundlich, und seine Güte währet ewiglich.</Losungstext>
    <Losungsvers>Psalm 106,1</Losungsvers>
    <Lehrtext>Alles, was ihr tut mit Worten oder mit Werken, das tut alles im Namen des Herrn Jesus und dankt Gott, dem Vater, durch ihn.</Lehrtext>
    <Lehrtextvers>Kolosser 3,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-20T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Abram sprach zu Lot: Lass doch nicht Zank sein zwischen mir und dir und zwischen meinen und deinen Hirten; denn wir sind Brüder.</Losungstext>
    <Losungsvers>1.Mose 13,8</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wenn ihr den Menschen ihre Verfehlungen vergebt, so wird euch euer himmlischer Vater auch vergeben.</Lehrtext>
    <Lehrtextvers>Matthäus 6,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-21T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>HERR, du hast angefangen, deinem Knecht zu offenbaren deine Herrlichkeit und deine starke Hand.</Losungstext>
    <Losungsvers>5.Mose 3,24</Losungsvers>
    <Lehrtext>Setzt eure Hoffnung ganz auf die Gnade, die euch angeboten wird in der Offenbarung Jesu Christi.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-22T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>3. Sonntag nach Epiphanias</Sonntag>
    <Losungstext>Gott hat den Menschen aufrichtig gemacht; aber sie suchen viele Künste.</Losungstext>
    <Losungsvers>Prediger 7,29</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wenn ihr bleiben werdet an meinem Wort, so seid ihr wahrhaftig meine Jünger und werdet die Wahrheit erkennen, und die Wahrheit wird euch frei machen.</Lehrtext>
    <Lehrtextvers>Johannes 8,31-32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-23T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du hast mein Leben aus dem Verderben geführt, HERR, mein Gott!</Losungstext>
    <Losungsvers>Jona 2,7</Losungsvers>
    <Lehrtext>Christus Jesus ist in die Welt gekommen, die Sünder selig zu machen, unter denen ich der erste bin.</Lehrtext>
    <Lehrtextvers>1.Timotheus 1,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-24T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will den HERRN loben in den Versammlungen.</Losungstext>
    <Losungsvers>Psalm 26,12</Losungsvers>
    <Lehrtext>Lasst uns aufeinander Acht haben und uns anreizen zur Liebe und zu guten Werken und nicht verlassen unsre Versammlungen, wie einige zu tun pflegen.</Lehrtext>
    <Lehrtextvers>Hebräer 10,24-25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-25T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird seinen Engel vor dir her senden.</Losungstext>
    <Losungsvers>1.Mose 24,7</Losungsvers>
    <Lehrtext>Der Engel sprach zu Petrus: Gürte dich und zieh deine Schuhe an! Und er tat es.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 12,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-26T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Naaman sprach: Dein Knecht will nicht mehr andern Göttern opfern, sondern allein dem HERRN.</Losungstext>
    <Losungsvers>2.Könige 5,17</Losungsvers>
    <Lehrtext>Jesus Christus ist der wahrhaftige Gott und das ewige Leben. Kinder, hütet euch vor den Abgöttern!</Lehrtext>
    <Lehrtextvers>1.Johannes 5,20-21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-27T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Gott ist unsre Zuversicht und Stärke, eine Hilfe in den großen Nöten, die uns getroffen haben. Darum fürchten wir uns nicht.</Losungstext>
    <Losungsvers>Psalm 46,2-3</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wenn ich schwach bin, so bin ich stark.</Lehrtext>
    <Lehrtextvers>2.Korinther 12,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-28T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Mose sprach: HERR, habe ich Gnade gefunden in deinen Augen, so wollest du, Herr, mitten unter uns einherziehen.</Losungstext>
    <Losungsvers>2.Mose 34,9</Losungsvers>
    <Lehrtext>Die Gott vorherbestimmt hat, die hat er auch berufen; die er aber berufen hat, die hat er auch verherrlicht.</Lehrtext>
    <Lehrtextvers>Römer 8,30</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-29T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Letzter Sonntag nach Epiphanias</Sonntag>
    <Losungstext>Der HERR behütet dich; der HERR ist dein Schatten über deiner rechten Hand, dass dich des Tages die Sonne nicht steche noch der Mond des Nachts.</Losungstext>
    <Losungsvers>Psalm 121,5-6</Losungsvers>
    <Lehrtext>Dem, der euch vor dem Straucheln behüten kann und euch untadelig stellen kann vor das Angesicht seiner Herrlichkeit mit Freuden, dem alleinigen Gott, unserm Heiland, sei durch Jesus Christus, unsern Herrn, Ehre und Majestät und Gewalt und Macht!</Lehrtext>
    <Lehrtextvers>Judas 24-25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-30T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Herr, lass mich wieder genesen und leben!</Losungstext>
    <Losungsvers>Jesaja 38,16</Losungsvers>
    <Lehrtext>Als die Frau von Jesus hörte, kam sie in der Menge von hinten heran und berührte sein Gewand. Denn sie sagte sich: Wenn ich nur seine Kleider berühren könnte, so würde ich gesund. Er aber sprach zu ihr: Meine Tochter, dein Glaube hat dich gesund gemacht!</Lehrtext>
    <Lehrtextvers>Markus 5,27-28.34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-01-31T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ein Sohn soll seinen Vater ehren. Bin ich nun Vater, wo ist meine Ehre? spricht der HERR.</Losungstext>
    <Losungsvers>Maleachi 1,6</Losungsvers>
    <Lehrtext>Gott, dem ewigen König, dem Unvergänglichen und Unsichtbaren, der allein Gott ist, sei Ehre und Preis in Ewigkeit!</Lehrtext>
    <Lehrtextvers>1.Timotheus 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-01T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>HERR, sei du mit mir um deines Namens willen; denn deine Gnade ist mein Trost: Errette mich!</Losungstext>
    <Losungsvers>Psalm 109,21</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich gebe meinen Schafen das ewige Leben, und sie werden nimmermehr umkommen, und niemand wird sie aus meiner Hand reißen.</Lehrtext>
    <Lehrtextvers>Johannes 10,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-02T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will euch von all eurer Unreinheit erlösen.</Losungstext>
    <Losungsvers>Hesekiel 36,29</Losungsvers>
    <Lehrtext>Ihr wisst, dass ihr nicht mit vergänglichem Silber oder Gold erlöst seid von eurem nichtigen Wandel nach der Väter Weise, sondern mit dem teuren Blut Christi als eines unschuldigen und unbefleckten Lammes.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,18-19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-03T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wenn ich sprach: Mein Fuß ist gestrauchelt, so hielt mich, HERR, deine Gnade.</Losungstext>
    <Losungsvers>Psalm 94,18</Losungsvers>
    <Lehrtext>Lasst uns hinzutreten mit Zuversicht zu dem Thron der Gnade, damit wir Barmherzigkeit empfangen und Gnade finden zu der Zeit, wenn wir Hilfe nötig haben.</Lehrtext>
    <Lehrtextvers>Hebräer 4,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-04T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Noah fand Gnade vor dem HERRN.</Losungstext>
    <Losungsvers>1.Mose 6,8</Losungsvers>
    <Lehrtext>Der Menschensohn wird seine Auserwählten versammeln von den vier Winden, vom Ende der Erde bis zum Ende des Himmels.</Lehrtext>
    <Lehrtextvers>Markus 13,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-05T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Septuagesimae (70 Tage vor Ostern)</Sonntag>
    <Losungstext>Es wird geschehen zu der Zeit, dass das Reis aus der Wurzel Isais dasteht als Zeichen für die Völker. Nach ihm werden die Heiden fragen.</Losungstext>
    <Losungsvers>Jesaja 11,10</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wenn aber nun du, der du ein wilder Ölzweig warst, in den Ölbaum eingepfropft worden bist und teilbekommen hast an der Wurzel und dem Saft des Ölbaums, so rühme dich nicht gegenüber den Zweigen. Rühmst du dich aber, so sollst du wissen, dass nicht du die Wurzel trägst, sondern die Wurzel trägt dich.</Lehrtext>
    <Lehrtextvers>Römer 11,17-18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-06T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, des HERRN Arm ist nicht zu kurz, dass er nicht helfen könnte, und seine Ohren sind nicht hart geworden, sodass er nicht hören könnte, sondern eure Verschuldungen scheiden euch von eurem Gott.</Losungstext>
    <Losungsvers>Jesaja 59,1-2</Losungsvers>
    <Lehrtext>Wisst ihr nicht, dass die Ungerechten das Reich Gottes nicht ererben werden? Lasst euch nicht irreführen!</Lehrtext>
    <Lehrtextvers>1.Korinther 6,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-07T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Die Wasserwogen im Meer sind groß und brausen mächtig; der HERR aber ist noch größer in der Höhe.</Losungstext>
    <Losungsvers>Psalm 93,4</Losungsvers>
    <Lehrtext>Jesus stand auf und bedrohte den Wind und sprach zu dem Meer: Schweig und verstumme! Und der Wind legte sich und es entstand eine große Stille.</Lehrtext>
    <Lehrtextvers>Markus 4,39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-08T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Lass leuchten dein Antlitz über dein zerstörtes Heiligtum um deinetwillen, Herr!</Losungstext>
    <Losungsvers>Daniel 9,17</Losungsvers>
    <Lehrtext>Ihr seid aufgebaut auf dem Fundament der Apostel und Propheten - der Schlussstein ist Christus Jesus selbst. Durch ihn wird der ganze Bau zusammengehalten und wächst zu einem heiligen Tempel im Herrn, durch ihn werdet auch ihr mit eingebaut in die Wohnung Gottes im Geist.</Lehrtext>
    <Lehrtextvers>Epheser 2,20-22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-09T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du den Hungrigen dein Herz finden lässt und den Elenden sättigst, dann wird dein Licht in der Finsternis aufgehen.</Losungstext>
    <Losungsvers>Jesaja 58,10</Losungsvers>
    <Lehrtext>Erbringt den Beweis eurer Liebe.</Lehrtext>
    <Lehrtextvers>2.Korinther 8,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-10T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Es wird ein Reis hervorgehen aus dem Stamm Isais und ein Zweig aus seiner Wurzel Frucht bringen.</Losungstext>
    <Losungsvers>Jesaja 11,1</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin der Weinstock, ihr seid die Reben. Wer in mir bleibt und ich in ihm, der bringt viel Frucht; denn ohne mich könnt ihr nichts tun.</Lehrtext>
    <Lehrtextvers>Johannes 15,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-11T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ruft laut, rühmt und sprecht: Der HERR hat seinem Volk geholfen!</Losungstext>
    <Losungsvers>Jeremia 31,7</Losungsvers>
    <Lehrtext>Herr, gib deinen Knechten, mit allem Freimut zu reden dein Wort.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 4,29</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-12T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Sexagesimae (60 Tage vor Ostern)</Sonntag>
    <Losungstext>HERR, ich habe lieb die Stätte deines Hauses und den Ort, da deine Ehre wohnt.</Losungstext>
    <Losungsvers>Psalm 26,8</Losungsvers>
    <Lehrtext>Nach drei Tagen fanden die Eltern Jesus im Tempel sitzen, mitten unter den Lehrern, wie er ihnen zuhörte und sie fragte.</Lehrtext>
    <Lehrtextvers>Lukas 2,46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-13T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Auch wir wollen dem HERRN dienen, denn er ist unser Gott.</Losungstext>
    <Losungsvers>Josua 24,18</Losungsvers>
    <Lehrtext>Man fordert nicht mehr von den Haushaltern, als dass sie für treu befunden werden.</Lehrtext>
    <Lehrtextvers>1.Korinther 4,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-14T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Versammle mir das Volk, dass sie meine Worte hören und so mich fürchten lernen alle Tage ihres Lebens auf Erden und ihre Kinder lehren.</Losungstext>
    <Losungsvers>5.Mose 4,10</Losungsvers>
    <Lehrtext>Bemühe dich darum, dich vor Gott zu erweisen als einen rechtschaffenen und untadeligen Arbeiter, der das Wort der Wahrheit recht austeilt.</Lehrtext>
    <Lehrtextvers>2.Timotheus 2,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-15T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Noah war ein frommer Mann und ohne Tadel zu seinen Zeiten; er wandelte mit Gott.</Losungstext>
    <Losungsvers>1.Mose 6,9</Losungsvers>
    <Lehrtext>Durch den Glauben hat Noah Gott geehrt und die Arche gebaut zur Rettung seines Hauses, als er ein göttliches Wort empfing über das, was man noch nicht sah.</Lehrtext>
    <Lehrtextvers>Hebräer 11,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-16T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du bist mein Helfer und Erretter; mein Gott, säume doch nicht!</Losungstext>
    <Losungsvers>Psalm 40,18</Losungsvers>
    <Lehrtext>Ein Aussätziger kam zu Jesus, der bat ihn, kniete nieder und sprach zu ihm: Willst du, so kannst du mich reinigen. Und es jammerte ihn und er streckte die Hand aus, rührte ihn an und sprach zu ihm: Ich will's tun; sei rein!</Lehrtext>
    <Lehrtextvers>Markus 1,40-41</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-17T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wohl dem, der seine Hoffnung setzt auf den HERRN!</Losungstext>
    <Losungsvers>Psalm 40,5</Losungsvers>
    <Lehrtext>Hoffen wir allein in diesem Leben auf Christus, so sind wir die elendesten unter allen Menschen.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-18T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, das ist mein Knecht - ich halte ihn - und mein Auserwählter, an dem meine Seele Wohlgefallen hat.</Losungstext>
    <Losungsvers>Jesaja 42,1</Losungsvers>
    <Lehrtext>Jesus Christus empfing von Gott, dem Vater, Ehre und Preis durch eine Stimme, die zu ihm kam von der großen Herrlichkeit: Dies ist mein lieber Sohn, an dem ich Wohlgefallen habe.</Lehrtext>
    <Lehrtextvers>2.Petrus 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-19T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Estomihi (Sei mir ein starker Fels! Psalm 31,3)</Sonntag>
    <Losungstext>Der HERR allein ist im Recht; denn seinem Worte habe ich getrotzt.</Losungstext>
    <Losungsvers>Klagelieder 1,18</Losungsvers>
    <Lehrtext>Der Sohn sprach: Vater, ich habe gesündigt gegen den Himmel und vor dir; ich bin hinfort nicht mehr wert, dass ich dein Sohn heiße.</Lehrtext>
    <Lehrtextvers>Lukas 15,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-20T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Fürchte dich nicht und verzage nicht!</Losungstext>
    <Losungsvers>Josua 8,1</Losungsvers>
    <Lehrtext>Fürchte dich nicht! Ich bin der Erste und der Letzte und der Lebendige.</Lehrtext>
    <Lehrtextvers>Offenbarung 1,17-18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-21T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Weißt du nicht? Hast du nicht gehört? Der HERR, der ewige Gott, der die Enden der Erde geschaffen hat, wird nicht müde noch matt, sein Verstand ist unausforschlich.</Losungstext>
    <Losungsvers>Jesaja 40,28</Losungsvers>
    <Lehrtext>Gott hat sich selbst nicht unbezeugt gelassen, hat viel Gutes getan und euch vom Himmel Regen und fruchtbare Zeiten gegeben, hat euch ernährt und eure Herzen mit Freude erfüllt.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 14,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-22T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Du hast meine Seele vom Tode errettet, mein Auge von den Tränen, meinen Fuß vom Gleiten.</Losungstext>
    <Losungsvers>Psalm 116,8</Losungsvers>
    <Lehrtext>Petrus stieg aus dem Boot und ging auf dem Wasser und kam auf Jesus zu. Als er aber den starken Wind sah, erschrak er und begann zu sinken und schrie: Herr, hilf mir! Jesus aber streckte sogleich die Hand aus und ergriff ihn.</Lehrtext>
    <Lehrtextvers>Matthäus 14,29-31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-23T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Fürchte dich nicht, denn du sollst nicht zuschanden werden.</Losungstext>
    <Losungsvers>Jesaja 54,4</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wenn man euch abführt und vor Gericht stellt, dann sorgt euch nicht im Voraus, was ihr reden sollt, sondern was euch in jener Stunde eingegeben wird, das redet. Denn nicht ihr seid es, die reden, sondern der heilige Geist.</Lehrtext>
    <Lehrtextvers>Markus 13,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-24T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich freue mich deines Heils.</Losungstext>
    <Losungsvers>1.Samuel 2,1</Losungsvers>
    <Lehrtext>Als Jesus auferstanden war früh am ersten Tag der Woche, erschien er zuerst Maria von Magdala. Und sie ging hin und verkündete es denen, die mit ihm gewesen waren und Leid trugen und weinten.</Lehrtext>
    <Lehrtextvers>Markus 16,9.10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-25T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gott, du bist mein Gott, den ich suche. Es dürstet meine Seele nach dir.</Losungstext>
    <Losungsvers>Psalm 63,2</Losungsvers>
    <Lehrtext>/Christus spricht:/ Trachtet zuerst nach dem Reich Gottes und nach seiner Gerechtigkeit, so wird euch das alles zufallen.</Lehrtext>
    <Lehrtextvers>Matthäus 6,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-26T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Invokavit (Er ruft mich an, darum will ich ihn erhören. Psalm 91,15)</Sonntag>
    <Losungstext>Ich will sie gnädig ansehen und will sie bauen und nicht verderben, ich will sie pflanzen und nicht ausreißen.</Losungstext>
    <Losungsvers>Jeremia 24,6</Losungsvers>
    <Lehrtext>Es ist weder der pflanzt noch der begießt etwas, sondern Gott, der das Gedeihen gibt.</Lehrtext>
    <Lehrtextvers>1.Korinther 3,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-27T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Es werden sich zum HERRN bekehren aller Welt Enden und vor ihm anbeten alle Geschlechter der Heiden.</Losungstext>
    <Losungsvers>Psalm 22,28</Losungsvers>
    <Lehrtext>Gott will, dass allen Menschen geholfen werde und sie zur Erkenntnis der Wahrheit kommen.</Lehrtext>
    <Lehrtextvers>1.Timotheus 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-28T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Die sich halten an das Nichtige, verlassen ihre Gnade.</Losungstext>
    <Losungsvers>Jona 2,9</Losungsvers>
    <Lehrtext>Geldgier ist eine Wurzel alles Übels; danach hat einige gelüstet und sie sind vom Glauben abgeirrt und machen sich selbst viel Schmerzen.</Lehrtext>
    <Lehrtextvers>1.Timotheus 6,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-02-29T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der Mensch, vom Weibe geboren, lebt kurze Zeit und ist voll Unruhe.</Losungstext>
    <Losungsvers>Hiob 14,1</Losungsvers>
    <Lehrtext>Gesät wird in Niedrigkeit, auferweckt wird in Herrlichkeit. Gesät wird in Schwachheit, auferweckt wird in Kraft.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,43</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-01T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wahrlich, das ist Gott, unser Gott für immer und ewig. Er ist's, der uns führet.</Losungstext>
    <Losungsvers>Psalm 48,15</Losungsvers>
    <Lehrtext>Lasst uns festhalten an dem Bekenntnis der Hoffnung und nicht wanken; denn er ist treu, der sie verheißen hat.</Lehrtext>
    <Lehrtextvers>Hebräer 10,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-02T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Er weiß, was in der Finsternis liegt, denn bei ihm ist lauter Licht.</Losungstext>
    <Losungsvers>Daniel 2,22</Losungsvers>
    <Lehrtext>Es ist nichts verborgen, was nicht offenbar werden soll, und ist nichts geheim, was nicht an den Tag kommen soll.</Lehrtext>
    <Lehrtextvers>Markus 4,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-03T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gott ist mein König von alters her, der alle Hilfe tut, die auf Erden geschieht.</Losungstext>
    <Losungsvers>Psalm 74,12</Losungsvers>
    <Lehrtext>Wo Jesus in Dörfer, Städte und Höfe hineinging, da legten sie die Kranken auf den Markt und baten ihn, dass diese auch nur den Saum seines Gewandes berühren dürften; und alle, die ihn berührten, wurden gesund.</Lehrtext>
    <Lehrtextvers>Markus 6,56</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-04T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Reminiszere (Gedenke, HERR, an deine Barmherzigkeit! Psalm 25,6)</Sonntag>
    <Losungstext>Wer unter dem Schirm des Höchsten sitzt und unter dem Schatten des Allmächtigen bleibt, der spricht zu dem Herrn: Meine Zuversicht und meine Burg, mein Gott, auf den ich hoffe.</Losungstext>
    <Losungsvers>Psalm 91,1-2</Losungsvers>
    <Lehrtext>Gott hat uns nicht gegeben den Geist der Furcht, sondern der Kraft und der Liebe und der Besonnenheit.</Lehrtext>
    <Lehrtextvers>2.Timotheus 1,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-05T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Mose sprach zu Gott: Wer bin ich, dass ich zum Pharao gehe und führe die Israeliten aus Ägypten? Gott sprach: Ich will mit dir sein.</Losungstext>
    <Losungsvers>2.Mose 3,11-12</Losungsvers>
    <Lehrtext>Nicht der ist tüchtig, der sich selbst empfiehlt, sondern der, den der Herr empfiehlt.</Lehrtext>
    <Lehrtextvers>2.Korinther 10,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-06T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Es segne uns Gott, und alle Welt fürchte ihn!</Losungstext>
    <Losungsvers>Psalm 67,8</Losungsvers>
    <Lehrtext>Gelobt sei Gott, der Vater unseres Herrn Jesus Christus, der uns gesegnet hat mit allem geistlichen Segen im Himmel durch Christus.</Lehrtext>
    <Lehrtextvers>Epheser 1,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-07T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR, euer Gott, ist der Gott aller Götter und der Herr über alle Herren, der große Gott, der Mächtige und der Schreckliche, der die Person nicht ansieht und kein Geschenk nimmt.</Losungstext>
    <Losungsvers>5.Mose 10,17</Losungsvers>
    <Lehrtext>Von ihm und durch ihn und zu ihm sind alle Dinge. Ihm sei Ehre in Ewigkeit!</Lehrtext>
    <Lehrtextvers>Römer 11,36</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-08T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Mein Volk tut eine zwiefache Sünde: mich, die lebendige Quelle, verlassen sie und machen sich Zisternen, die doch rissig sind und kein Wasser geben.</Losungstext>
    <Losungsvers>Jeremia 2,13</Losungsvers>
    <Lehrtext>/Christus spricht:/ Kommt her zu mir, alle, die ihr mühselig und beladen seid; ich will euch erquicken.</Lehrtext>
    <Lehrtextvers>Matthäus 11,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-09T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Meine Worte, die ich in deinen Mund gelegt habe, sollen von deinem Mund nicht weichen noch von dem Mund deiner Kinder und Kindeskinder.</Losungstext>
    <Losungsvers>Jesaja 59,21</Losungsvers>
    <Lehrtext>Des Herrn Wort bleibt in Ewigkeit. Das ist aber das Wort, welches unter euch verkündigt ist.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,24-25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-10T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Meine Seele ist stille zu Gott, der mir hilft.</Losungstext>
    <Losungsvers>Psalm 62,2</Losungsvers>
    <Lehrtext>/Christus spricht:/ Alles, was ihr bittet in eurem Gebet, glaubt nur, dass ihr's empfangt, so wird's euch zuteil werden.</Lehrtext>
    <Lehrtextvers>Markus 11,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-11T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Okuli (Meine Augen sehen stets auf den HERRN. Psalm 25,15)</Sonntag>
    <Losungstext>Der Name des HERRN ist ein starker Turm; dorthin eilt der Fromme und ist geborgen.</Losungstext>
    <Losungsvers>Sprüche 18,10</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Wer zu mir kommt und hört meine Rede und tut sie - ich will euch zeigen, wem er gleicht. Er gleicht einem Menschen, der ein Haus baute und grub tief und legte den Grund auf Fels.</Lehrtext>
    <Lehrtextvers>Lukas 6,47-48</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-12T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR schafft Recht den Waisen und Witwen und hat die Fremdlinge lieb, dass er ihnen Speise und Kleider gibt. Darum sollt ihr auch die Fremdlinge lieben.</Losungstext>
    <Losungsvers>5.Mose 10,18.19</Losungsvers>
    <Lehrtext>Solche sollen wir aufnehmen, damit wir Gehilfen der Wahrheit werden.</Lehrtext>
    <Lehrtextvers>3.Johannes 8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-13T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du bist doch der HERR, unser Gott, auf den wir hoffen.</Losungstext>
    <Losungsvers>Jeremia 14,22</Losungsvers>
    <Lehrtext>Wir warten auf die selige Hoffnung und Erscheinung der Herrlichkeit des großen Gottes und unseres Heilands Jesus Christus.</Lehrtext>
    <Lehrtextvers>Titus 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-14T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>So gingen Mose und Aaron hin zum Pharao und sprachen zu ihm: So spricht der HERR: Lass mein Volk ziehen, dass es mir diene!</Losungstext>
    <Losungsvers>2.Mose 10,3</Losungsvers>
    <Lehrtext>Gott widersteht den Hochmütigen, aber den Demütigen gibt er Gnade.</Lehrtext>
    <Lehrtextvers>1.Petrus 5,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-15T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird seinem Volk Kraft geben.</Losungstext>
    <Losungsvers>Psalm 29,11</Losungsvers>
    <Lehrtext>Durch Christus Jesus seid ihr in allen Stücken reich gemacht in aller Lehre und in aller Erkenntnis.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-16T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Gib mir, mein Sohn, dein Herz, und lass deinen Augen meine Wege wohlgefallen.</Losungstext>
    <Losungsvers>Sprüche 23,26</Losungsvers>
    <Lehrtext>Jesus sah den reichen Mann an und gewann ihn lieb und sprach zu ihm: Eines fehlt dir. Geh hin, verkaufe alles, was du hast, und gib's den Armen, so wirst du einen Schatz im Himmel haben, und komm und folge mir nach!</Lehrtext>
    <Lehrtextvers>Markus 10,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-17T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Menschen sind ja nichts, große Leute täuschen auch; sie wiegen weniger als nichts, soviel ihrer sind.</Losungstext>
    <Losungsvers>Psalm 62,10</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wahrlich, ich sage euch: Wer das Reich Gottes nicht empfängt wie ein Kind, der wird nicht hineinkommen.</Lehrtext>
    <Lehrtextvers>Markus 10,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-18T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Lätare (Freuet euch mit Jerusalem! Jesaja 66,10)</Sonntag>
    <Losungstext>Sieh doch, dass dies Volk dein Volk ist.</Losungstext>
    <Losungsvers>2.Mose 33,13</Losungsvers>
    <Lehrtext>Der feste Grund Gottes besteht und hat dieses Siegel: Der Herr kennt die Seinen.</Lehrtext>
    <Lehrtextvers>2.Timotheus 2,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-19T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>/Jeremia sprach:/ Mich jammert von Herzen, dass mein Volk so ganz zerschlagen ist. Ist denn keine Salbe in Gilead, oder ist kein Arzt da?</Losungstext>
    <Losungsvers>Jeremia 8,21.22</Losungsvers>
    <Lehrtext>Die Frau spürte es am Leibe, dass sie von ihrer Plage geheilt war. Und Jesus spürte sogleich an sich selbst, dass eine Kraft von ihm ausgegangen war.</Lehrtext>
    <Lehrtextvers>Markus 5,29-30</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-20T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wir haben gesündigt samt unsern Vätern, wir haben unrecht getan und sind gottlos gewesen.</Losungstext>
    <Losungsvers>Psalm 106,6</Losungsvers>
    <Lehrtext>Wer keine Leistung vorzuweisen hat, aber an den glaubt, der den Gottlosen gerecht macht, dem wird sein Glaube als Gerechtigkeit angerechnet.</Lehrtext>
    <Lehrtextvers>Römer 4,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-21T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Dünke dich nicht weise zu sein, sondern fürchte den HERRN und weiche vom Bösen.</Losungstext>
    <Losungsvers>Sprüche 3,7</Losungsvers>
    <Lehrtext>Christus Jesus ist uns von Gott gemacht zur Weisheit und zur Gerechtigkeit und zur Heiligung und zur Erlösung.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,30</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-22T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Lass deine Augen offen stehen über diesem Hause Nacht und Tag, über der Stätte, von der du gesagt hast: Da soll mein Name sein.</Losungstext>
    <Losungsvers>1.Könige 8,29</Losungsvers>
    <Lehrtext>Jesus sprach: Macht nicht meines Vaters Haus zum Kaufhaus!</Lehrtext>
    <Lehrtextvers>Johannes 2,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-23T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>HERR, es ist dir nicht schwer, dem Schwachen gegen den Starken zu helfen.</Losungstext>
    <Losungsvers>2.Chronik 14,10</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Gott, dem ich diene, wird euch alles geben, was ihr braucht, so gewiss er euch durch Jesus Christus am Reichtum seiner Herrlichkeit teilhaben lässt.</Lehrtext>
    <Lehrtextvers>Philipper 4,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-24T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich weiß, mein Gott, dass du das Herz prüfst, und Aufrichtigkeit ist dir angenehm.</Losungstext>
    <Losungsvers>1.Chronik 29,17</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wenn ihr steht und betet, so vergebt, wenn ihr etwas gegen jemanden habt, damit auch euer Vater im Himmel euch vergebe eure Übertretungen.</Lehrtext>
    <Lehrtextvers>Markus 11,25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-25T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Judika (Gott, schaffe mir Recht! Psalm 43,1)</Sonntag>
    <Losungstext>Sie werden weder hungern noch dürsten, sie wird weder Hitze noch Sonne stechen; denn ihr Erbarmer wird sie führen und sie an die Wasserquellen leiten.</Losungstext>
    <Losungsvers>Jesaja 49,10</Losungsvers>
    <Lehrtext>Gott hat den Heiligen Geist reichlich über uns ausgegossen durch Jesus Christus, unsern Heiland, damit wir, durch dessen Gnade gerecht geworden, Erben des ewigen Lebens würden nach unsrer Hoffnung.</Lehrtext>
    <Lehrtextvers>Titus 3,6-7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-26T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR sprach zu Jeremia: Siehe, ich lege meine Worte in deinen Mund.</Losungstext>
    <Losungsvers>Jeremia 1,9</Losungsvers>
    <Lehrtext>Fürchte dich nicht, sondern rede und schweige nicht!</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 18,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-27T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Lobet ihn, Sonne und Mond, lobet ihn, alle leuchtenden Sterne! Denn er gebot, da wurden sie geschaffen.</Losungstext>
    <Losungsvers>Psalm 148,3.5</Losungsvers>
    <Lehrtext>Herr, unser Gott, du bist würdig, zu nehmen Preis und Ehre und Kraft; denn du hast alle Dinge geschaffen, und durch deinen Willen waren sie und wurden sie geschaffen.</Lehrtext>
    <Lehrtextvers>Offenbarung 4,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-28T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wenn ihr zur Rechten oder zur Linken abweichen wollt, werden deine Ohren den Ruf hinter dir vernehmen: »Dies ist der Weg, den gehet!«</Losungstext>
    <Losungsvers>Jesaja 30,21</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater denn durch mich.</Lehrtext>
    <Lehrtextvers>Johannes 14,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-29T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Frage doch zuerst nach dem Wort des HERRN!</Losungstext>
    <Losungsvers>2.Chronik 18,4</Losungsvers>
    <Lehrtext>Bleibe bei dem, was du gelernt hast und was dir anvertraut ist.</Lehrtext>
    <Lehrtextvers>2.Timotheus 3,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-30T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Denen nichts davon verkündet ist, die werden es nun sehen.</Losungstext>
    <Losungsvers>Jesaja 52,15</Losungsvers>
    <Lehrtext>Die Jünger zogen aus und predigten an allen Orten. Und der Herr wirkte mit ihnen und bekräftigte das Wort durch die mitfolgenden Zeichen.</Lehrtext>
    <Lehrtextvers>Markus 16,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-03-31T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will zu Gott rufen und der HERR wird mir helfen.</Losungstext>
    <Losungsvers>Psalm 55,17</Losungsvers>
    <Lehrtext>Auf Gott hoffen wir, er werde uns auch hinfort erretten.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-01T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Palmsonntag</Sonntag>
    <Losungstext>Siehe, ich lege euch heute vor den Segen und den Fluch: den Segen, wenn ihr gehorcht den Geboten des HERRN, eures Gottes; den Fluch aber, wenn ihr nicht gehorchen werdet den Geboten des HERRN, eures Gottes.</Losungstext>
    <Losungsvers>5.Mose 11,26-27.28</Losungsvers>
    <Lehrtext>Das Himmelreich gleicht einem Kaufmann, der gute Perlen suchte, und als er eine kostbare Perle fand, ging er hin und verkaufte alles, was er hatte, und kaufte sie.</Lehrtext>
    <Lehrtextvers>Matthäus 13,45-46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-02T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Es freue sich das Herz derer, die den HERRN suchen!</Losungstext>
    <Losungsvers>Psalm 105,3</Losungsvers>
    <Lehrtext>Was sucht ihr den Lebenden bei den Toten?</Lehrtext>
    <Lehrtextvers>Lukas 24,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-03T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Redet mit Jerusalem freundlich und predigt ihr, dass ihre Knechtschaft ein Ende hat, dass ihre Schuld vergeben ist.</Losungstext>
    <Losungsvers>Jesaja 40,2</Losungsvers>
    <Lehrtext>Christus hat unsre Sünde selbst hinaufgetragen an seinem Leibe auf das Holz, damit wir, der Sünde abgestorben, der Gerechtigkeit leben.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-04T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hebe sein Angesicht über dich und gebe dir Frieden.</Losungstext>
    <Losungsvers>4.Mose 6,26</Losungsvers>
    <Lehrtext>Der Friede Gottes, der höher ist als alle Vernunft, bewahre eure Herzen und Sinne in Christus Jesus.</Lehrtext>
    <Lehrtextvers>Philipper 4,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-05T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag>Gründonnerstag</Sonntag>
    <Losungstext>Nach deiner großen Barmherzigkeit hast du mit deinem Volk nicht ein Ende gemacht noch es verlassen.</Losungstext>
    <Losungsvers>Nehemia 9,31</Losungsvers>
    <Lehrtext>Der Herr Jesus, in der Nacht, da er verraten ward, nahm er das Brot, dankte und brach's und sprach: Das ist mein Leib, der für euch gegeben wird; das tut zu meinem Gedächtnis. Desgleichen nahm er auch den Kelch nach dem Mahl und sprach: Dieser Kelch ist der neue Bund in meinem Blut; das tut, sooft ihr daraus trinkt, zu meinem Gedächtnis.</Lehrtext>
    <Lehrtextvers>1.Korinther 11,23-25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-06T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag>Karfreitag</Sonntag>
    <Losungstext>O Jerusalem, ich habe Wächter über deine Mauern bestellt, die den ganzen Tag und die ganze Nacht nicht mehr schweigen sollen.</Losungstext>
    <Losungsvers>Jesaja 62,6</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich habe euch weitergegeben, was ich auch empfangen habe: Dass Christus gestorben ist für unsre Sünden nach der Schrift; und dass er begraben worden ist; und dass er auferstanden ist am dritten Tage nach der Schrift.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,3-4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-07T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Es sollen wohl Berge weichen und Hügel hinfallen, aber meine Gnade soll nicht von dir weichen, und der Bund meines Friedens soll nicht hinfallen, spricht der HERR, dein Erbarmer.</Losungstext>
    <Losungsvers>Jesaja 54,10</Losungsvers>
    <Lehrtext>/Christus spricht:/ Den Frieden lasse ich euch, meinen Frieden gebe ich euch. Nicht gebe ich euch, wie die Welt gibt. Euer Herz erschrecke nicht und fürchte sich nicht.</Lehrtext>
    <Lehrtextvers>Johannes 14,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-08T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Osterfest</Sonntag>
    <Losungstext>Als er gemartert ward, litt er doch willig und tat seinen Mund nicht auf wie ein Lamm, das zur Schlachtbank geführt wird.</Losungstext>
    <Losungsvers>Jesaja 53,7</Losungsvers>
    <Lehrtext>Nun aber ist Christus auferstanden von den Toten als Erstling unter denen, die entschlafen sind.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-09T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Ostermontag</Sonntag>
    <Losungstext>Muss ich nicht das halten und reden, was mir der HERR in den Mund gibt?</Losungstext>
    <Losungsvers>4.Mose 23,12</Losungsvers>
    <Lehrtext>Wenn jemand die Gabe der Rede hat, soll Gott durch ihn zu Wort kommen. Wenn jemand die Gabe der helfenden Tat hat, soll er aus der Kraft handeln, die Gott ihm verleiht. Alles, was ihr tut, soll durch Jesus Christus zur Ehre Gottes geschehen.</Lehrtext>
    <Lehrtextvers>1.Petrus 4,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-10T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wie kann ein Mensch gerecht sein vor Gott oder ein Mann rein sein vor dem, der ihn gemacht hat?</Losungstext>
    <Losungsvers>Hiob 4,17</Losungsvers>
    <Lehrtext>Jesus Christus hat sich selbst für uns gegeben, damit er uns erlöste von aller Ungerechtigkeit und reinigte sich selbst ein Volk zum Eigentum, das eifrig wäre zu guten Werken.</Lehrtext>
    <Lehrtextvers>Titus 2,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-11T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Gott hat mein Elend und meine Mühe angesehen.</Losungstext>
    <Losungsvers>1.Mose 31,42</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Seid standhaft, lasst euch nicht erschüttern, tut jederzeit das Werk des Herrn in reichem Maße! Ihr wisst ja: Im Herrn ist eure Arbeit nicht umsonst.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,58</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-12T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du, HERR, bist meine Leuchte; der HERR macht meine Finsternis licht.</Losungstext>
    <Losungsvers>2.Samuel 22,29</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin in die Welt gekommen als ein Licht, damit, wer an mich glaubt, nicht in der Finsternis bleibe.</Lehrtext>
    <Lehrtextvers>Johannes 12,46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-13T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Deine Güte, HERR, sei über uns, wie wir auf dich hoffen.</Losungstext>
    <Losungsvers>Psalm 33,22</Losungsvers>
    <Lehrtext>Aus Gnade seid ihr selig geworden durch Glauben, und das nicht aus euch: Gottes Gabe ist es.</Lehrtext>
    <Lehrtextvers>Epheser 2,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-14T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Unser Herr ist groß und von großer Kraft, und unbegreiflich ist, wie er regiert.</Losungstext>
    <Losungsvers>Psalm 147,5</Losungsvers>
    <Lehrtext>Jesus sprach: Bei den Menschen ist's unmöglich, aber nicht bei Gott; denn alle Dinge sind möglich bei Gott.</Lehrtext>
    <Lehrtextvers>Markus 10,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-15T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Quasimodogeniti (Wie die neugeborenen Kindlein. 1.Petrus 2,2)</Sonntag>
    <Losungstext>Ich will den Frieden zu deiner Obrigkeit machen und die Gerechtigkeit zu deiner Regierung.</Losungstext>
    <Losungsvers>Jesaja 60,17</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Es geschieht alles um euretwillen, damit die überschwängliche Gnade durch die Danksagung vieler noch reicher werde zur Ehre Gottes.</Lehrtext>
    <Lehrtextvers>2.Korinther 4,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-16T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR schafft deinen Grenzen Frieden.</Losungstext>
    <Losungsvers>Psalm 147,14</Losungsvers>
    <Lehrtext>Selig sind die Friedfertigen; denn sie werden Gottes Kinder heißen.</Lehrtext>
    <Lehrtextvers>Matthäus 5,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-17T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will ihnen ein anderes Herz geben und einen neuen Geist in sie geben.</Losungstext>
    <Losungsvers>Hesekiel 11,19</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ist jemand in Christus, so ist er eine neue Kreatur; das Alte ist vergangen, siehe, Neues ist geworden.</Lehrtext>
    <Lehrtextvers>2.Korinther 5,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-18T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich will dich loben mein Leben lang und meine Hände in deinem Namen aufheben.</Losungstext>
    <Losungsvers>Psalm 63,5</Losungsvers>
    <Lehrtext>Ich will beten mit dem Geist und will auch beten mit dem Verstand; ich will Psalmen singen mit dem Geist und will auch Psalmen singen mit dem Verstand.</Lehrtext>
    <Lehrtextvers>1.Korinther 14,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-19T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt Priester des HERRN heißen, und man wird euch Diener unsres Gottes nennen.</Losungstext>
    <Losungsvers>Jesaja 61,6</Losungsvers>
    <Lehrtext>Ihr seid das auserwählte Geschlecht, die königliche Priesterschaft, das heilige Volk, das Volk des Eigentums, dass ihr verkündigen sollt die Wohltaten dessen, der euch berufen hat von der Finsternis zu seinem wunderbaren Licht.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-20T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Kindeskinder werden deine Werke preisen und deine gewaltigen Taten verkündigen.</Losungstext>
    <Losungsvers>Psalm 145,4</Losungsvers>
    <Lehrtext>Blinde und Lahme im Tempel gingen zu Jesus und er heilte sie. Als aber die Hohenpriester und Schriftgelehrten die Wunder sahen, die er tat, und die Kinder, die im Tempel schrien: Hosianna dem Sohn Davids!, entrüsteten sie sich.</Lehrtext>
    <Lehrtextvers>Matthäus 21,14-15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-21T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Die Furcht des HERRN ist die Schule der Weisheit.</Losungstext>
    <Losungsvers>Sprüche 15,33</Losungsvers>
    <Lehrtext>Wenn jemand meint, er habe etwas erkannt, der hat noch nicht erkannt, wie man erkennen soll. Wenn aber jemand Gott liebt, der ist von ihm erkannt.</Lehrtext>
    <Lehrtextvers>1.Korinther 8,2-3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-22T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Miserikordias Domini (Die Erde ist voll der Güte des HERRN. Psalm 33,5)</Sonntag>
    <Losungstext>Ich will sie mehren und nicht mindern, ich will sie herrlich machen und nicht geringer.</Losungstext>
    <Losungsvers>Jeremia 30,19</Losungsvers>
    <Lehrtext>/Jesus sprach im Gleichnis:/ Wenn das Senfkorn gesät ist, so geht es auf und wird größer als alle Kräuter und treibt große Zweige, sodass die Vögel unter dem Himmel unter seinem Schatten wohnen können.</Lehrtext>
    <Lehrtextvers>Markus 4,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-23T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Alles, was der HERR gesagt hat, wollen wir tun und darauf hören.</Losungstext>
    <Losungsvers>2.Mose 24,7</Losungsvers>
    <Lehrtext>/Christus spricht:/ Daran wird jedermann erkennen, dass ihr meine Jünger seid, wenn ihr Liebe untereinander habt.</Lehrtext>
    <Lehrtextvers>Johannes 13,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-24T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Verwirf mich nicht in meinem Alter, verlass mich nicht, wenn ich schwach werde.</Losungstext>
    <Losungsvers>Psalm 71,9</Losungsvers>
    <Lehrtext>Wenn auch unser äußerer Mensch verfällt, so wird doch der innere von Tag zu Tag erneuert.</Lehrtext>
    <Lehrtextvers>2.Korinther 4,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-25T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der Gerechte ist wie ein Baum, gepflanzt an den Wasserbächen, der seine Frucht bringt zu seiner Zeit, und seine Blätter verwelken nicht.</Losungstext>
    <Losungsvers>Psalm 1,3</Losungsvers>
    <Lehrtext>An ihren Früchten sollt ihr sie erkennen.</Lehrtext>
    <Lehrtextvers>Matthäus 7,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-26T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Seid getrost und unverzagt alle, die ihr des HERRN harret!</Losungstext>
    <Losungsvers>Psalm 31,25</Losungsvers>
    <Lehrtext>Jage nach der Gerechtigkeit, der Frömmigkeit, dem Glauben, der Liebe, der Geduld, der Sanftmut!</Lehrtext>
    <Lehrtextvers>1.Timotheus 6,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-27T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Was betrübst du dich, meine Seele, und bist so unruhig in mir? Harre auf Gott; denn ich werde ihm noch danken, dass er meines Angesichts Hilfe und mein Gott ist.</Losungstext>
    <Losungsvers>Psalm 42,12</Losungsvers>
    <Lehrtext>Der Gott aller Gnade, der euch berufen hat zu seiner ewigen Herrlichkeit in Christus Jesus, der wird euch, die ihr eine kleine Zeit leidet, aufrichten, stärken, kräftigen, gründen.</Lehrtext>
    <Lehrtextvers>1.Petrus 5,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-28T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Sagt den verzagten Herzen: »Seid getrost, fürchtet euch nicht! Seht, da ist euer Gott!«</Losungstext>
    <Losungsvers>Jesaja 35,4</Losungsvers>
    <Lehrtext>Das sagt der Erste und der Letzte, der tot war und ist lebendig geworden: Ich kenne deine Bedrängnis und deine Armut - du bist aber reich.</Lehrtext>
    <Lehrtextvers>Offenbarung 2,8-9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-29T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Jubilate (Jauchzet Gott, alle Lande! Psalm 66,1)</Sonntag>
    <Losungstext>Der HERR schafft Recht den Unterdrückten, er gibt den Hungernden Brot.</Losungstext>
    <Losungsvers>Psalm 146,7</Losungsvers>
    <Lehrtext>Jesus nahm die sieben Brote, dankte und brach sie und gab sie seinen Jüngern, damit sie sie austeilten, und sie teilten sie unter das Volk aus.</Lehrtext>
    <Lehrtextvers>Markus 8,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-04-30T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Als du mich in der Not anriefst, half ich dir heraus.</Losungstext>
    <Losungsvers>Psalm 81,8</Losungsvers>
    <Lehrtext>Jesus sprach zu den Jüngern: Was seid ihr so furchtsam? Habt ihr noch keinen Glauben?</Lehrtext>
    <Lehrtextvers>Markus 4,40</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-01T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Mein Volk wird in friedlichen Auen wohnen, in sicheren Wohnungen.</Losungstext>
    <Losungsvers>Jesaja 32,18</Losungsvers>
    <Lehrtext>Wir warten auf einen neuen Himmel und eine neue Erde nach seiner Verheißung, in denen Gerechtigkeit wohnt.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-02T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>/Der HERR spricht:/ Ich bin bei ihm in der Not, ich will ihn herausreißen und zu Ehren bringen.</Losungstext>
    <Losungsvers>Psalm 91,15</Losungsvers>
    <Lehrtext>Gott ist mächtig, euch zu erbauen und euch das Erbe zu geben mit allen, die geheiligt sind.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 20,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-03T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich habe den HERRN allezeit vor Augen.</Losungstext>
    <Losungsvers>Psalm 16,8</Losungsvers>
    <Lehrtext>Darum setzen wir unsre Ehre darein, ob wir daheim sind oder in der Fremde, dass wir ihm wohlgefallen.</Lehrtext>
    <Lehrtextvers>2.Korinther 5,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-04T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wenn ich das Haus Israel wieder sammle aus den Völkern, unter die sie zerstreut sind, so will ich an ihnen vor den Augen der Heiden zeigen, dass ich heilig bin.</Losungstext>
    <Losungsvers>Hesekiel 28,25</Losungsvers>
    <Lehrtext>Gottes Gaben und Berufung können ihn nicht gereuen.</Lehrtext>
    <Lehrtextvers>Römer 11,29</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-05T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Rufe mich an in der Not, so will ich dich erretten, und du sollst mich preisen.</Losungstext>
    <Losungsvers>Psalm 50,15</Losungsvers>
    <Lehrtext>Des Gerechten Gebet vermag viel, wenn es ernstlich ist.</Lehrtext>
    <Lehrtextvers>Jakobus 5,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-06T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Kantate (Singet dem HERRN ein neues Lied! Psalm 98,1)</Sonntag>
    <Losungstext>Warum sprichst du denn, Jakob, und du, Israel, sagst: »Mein Weg ist dem Herrn verborgen, und mein Recht geht vor meinem Gott vorüber?«</Losungstext>
    <Losungsvers>Jesaja 40,27</Losungsvers>
    <Lehrtext>Ihr werdet euch freuen, die ihr jetzt eine kleine Zeit, wenn es sein soll, traurig seid in mancherlei Anfechtungen.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-07T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wir preisen dich, o Gott, wir preisen dich, und die deinen Namen anrufen, erzählen von deinen Wundern.</Losungstext>
    <Losungsvers>Psalm 75,2</Losungsvers>
    <Lehrtext>/Die Menschen in Jerusalem riefen:/ Gelobt sei das Reich unseres Vaters David, das da kommt! Hosianna in der Höhe!</Lehrtext>
    <Lehrtextvers>Markus 11,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-08T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Höret des HERRN Wort! Denn der HERR hat Ursache zu schelten, die im Lande wohnen; denn es ist keine Treue, keine Liebe und keine Erkenntnis Gottes im Lande.</Losungstext>
    <Losungsvers>Hosea 4,1</Losungsvers>
    <Lehrtext>Der Zöllner aber stand ferne, wollte auch die Augen nicht aufheben zum Himmel, sondern schlug an seine Brust und sprach: Gott, sei mir Sünder gnädig!</Lehrtext>
    <Lehrtextvers>Lukas 18,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-09T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Bei dir, Herr, unser Gott, ist Barmherzigkeit und Vergebung.</Losungstext>
    <Losungsvers>Daniel 9,9</Losungsvers>
    <Lehrtext>Als aber erschien die Freundlichkeit und Menschenliebe Gottes, unseres Heilands, machte er uns selig - nicht um der Werke der Gerechtigkeit willen, die wir getan hatten, sondern nach seiner Barmherzigkeit.</Lehrtext>
    <Lehrtextvers>Titus 3,4-5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-10T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Höre, Israel, der HERR ist unser Gott, der HERR allein.</Losungstext>
    <Losungsvers>5.Mose 6,4</Losungsvers>
    <Lehrtext>Es sind verschiedene Kräfte; aber es ist #ein# Gott, der da wirkt alles in allen.</Lehrtext>
    <Lehrtextvers>1.Korinther 12,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-11T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Sage nicht: »Ich bin zu jung«, sondern du sollst gehen, wohin ich dich sende, und predigen alles, was ich dir gebiete.</Losungstext>
    <Losungsvers>Jeremia 1,7</Losungsvers>
    <Lehrtext>Sei stark durch die Gnade in Christus Jesus.</Lehrtext>
    <Lehrtextvers>2.Timotheus 2,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-12T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, da ist Gott der HERR! Er kommt gewaltig, und sein Arm wird herrschen.</Losungstext>
    <Losungsvers>Jesaja 40,10</Losungsvers>
    <Lehrtext>Seht euch vor, wachet! Denn ihr wisst nicht, wann die Zeit da ist.</Lehrtext>
    <Lehrtextvers>Markus 13,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-13T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Rogate (Betet!)</Sonntag>
    <Losungstext>Ich bin gnädig, spricht der HERR, und will nicht ewiglich zürnen. Allein erkenne deine Schuld, dass du wider den HERRN, deinen Gott, gesündigt hast.</Losungstext>
    <Losungsvers>Jeremia 3,12-13</Losungsvers>
    <Lehrtext>Ich will mich aufmachen und zu meinem Vater gehen und zu ihm sagen: Vater, ich habe gesündigt gegen den Himmel und vor dir.</Lehrtext>
    <Lehrtextvers>Lukas 15,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-14T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt merken, dass ein lebendiger Gott unter euch ist.</Losungstext>
    <Losungsvers>Josua 3,10</Losungsvers>
    <Lehrtext>Mit großer Kraft bezeugten die Apostel die Auferstehung des Herrn Jesus, und große Gnade war bei ihnen allen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 4,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-15T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will meinen Odem in euch geben, dass ihr wieder leben sollt, und will euch in euer Land setzen, und ihr sollt erfahren, dass ich der HERR bin.</Losungstext>
    <Losungsvers>Hesekiel 37,14</Losungsvers>
    <Lehrtext>Der letzte Feind, der vernichtet wird, ist der Tod.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-16T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Bringe uns, HERR, zu dir zurück, dass wir wieder heimkommen; erneure unsre Tage wie vor alters!</Losungstext>
    <Losungsvers>Klagelieder 5,21</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Was meint ihr? Wenn ein Mensch hundert Schafe hätte und eins unter ihnen sich verirrte: lässt er nicht die neunundneunzig auf den Bergen, geht hin und sucht das verirrte?</Lehrtext>
    <Lehrtextvers>Matthäus 18,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-17T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag>Himmelfahrt des Herrn</Sonntag>
    <Losungstext>Helft dem Elenden und Bedürftigen zum Recht.</Losungstext>
    <Losungsvers>Psalm 82,3</Losungsvers>
    <Lehrtext>Unser Herr Jesus Christus stärke euch in allem guten Werk und Wort.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 2,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-18T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wer ist nun willig, heute eine Gabe für den HERRN zu spenden?</Losungstext>
    <Losungsvers>1.Chronik 29,5</Losungsvers>
    <Lehrtext>Jeder gebe, wie er es sich im Herzen vorgenommen hat, ohne Bedauern und ohne Zwang; denn einen fröhlichen Geber hat Gott lieb.</Lehrtext>
    <Lehrtextvers>2.Korinther 9,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-19T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>So sollst du nun wissen, dass der HERR, dein Gott, allein Gott ist, der treue Gott, der den Bund und die Barmherzigkeit bis ins tausendste Glied hält denen, die ihn lieben und seine Gebote halten.</Losungstext>
    <Losungsvers>5.Mose 7,9</Losungsvers>
    <Lehrtext>Dass einige nicht treu waren, was liegt daran? Sollte ihre Untreue Gottes Treue aufheben? Das sei ferne!</Lehrtext>
    <Lehrtextvers>Römer 3,3-4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-20T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Exaudi (HERR, höre meine Stimme! Psalm 27,7)</Sonntag>
    <Losungstext>Wer Dank opfert, der preiset mich, und da ist der Weg, dass ich ihm zeige das Heil Gottes.</Losungstext>
    <Losungsvers>Psalm 50,23</Losungsvers>
    <Lehrtext>Gott aber sei Dank, der uns den Sieg gibt durch unsern Herrn Jesus Christus!</Lehrtext>
    <Lehrtextvers>1.Korinther 15,57</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-21T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR, der gütig ist, wolle gnädig sein allen, die ihr Herz darauf richten, Gott zu suchen.</Losungstext>
    <Losungsvers>2.Chronik 30,18.19</Losungsvers>
    <Lehrtext>Naht euch zu Gott, so naht er sich zu euch.</Lehrtext>
    <Lehrtextvers>Jakobus 4,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-22T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Er heilt, die zerbrochenen Herzens sind, und verbindet ihre Wunden.</Losungstext>
    <Losungsvers>Psalm 147,3</Losungsvers>
    <Lehrtext>Sie brachten zu Jesus alle Kranken und Besessenen. Und er half vielen Kranken, die mit mancherlei Gebrechen beladen waren.</Lehrtext>
    <Lehrtextvers>Markus 1,32.34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-23T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR Zebaoth ist mit uns, der Gott Jakobs ist unser Schutz.</Losungstext>
    <Losungsvers>Psalm 46,8</Losungsvers>
    <Lehrtext>Alle haben ja gesündigt und die Herrlichkeit Gottes verspielt. Gerecht gemacht werden sie ohne Verdienst aus seiner Gnade durch die Erlösung, die in Christus Jesus ist.</Lehrtext>
    <Lehrtextvers>Römer 3,23-24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-24T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ist mein Arm nun so kurz geworden, dass er nicht mehr erlösen kann?</Losungstext>
    <Losungsvers>Jesaja 50,2</Losungsvers>
    <Lehrtext>Der Herr verzögert nicht die Verheißung, wie es einige für eine Verzögerung halten; sondern er hat Geduld mit euch und will nicht, dass jemand verloren werde, sondern dass jedermann zur Buße finde.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-25T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst anbeten vor dem HERRN, deinem Gott, und sollst fröhlich sein über alles Gut, das der HERR, dein Gott, dir und deinem Hause gegeben hat.</Losungstext>
    <Losungsvers>5.Mose 26,10.11</Losungsvers>
    <Lehrtext>Sagt Dank Gott, dem Vater, allezeit für alles, im Namen unseres Herrn Jesus Christus.</Lehrtext>
    <Lehrtextvers>Epheser 5,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-26T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du, Herr, bist gerecht, wir aber müssen uns alle heute schämen.</Losungstext>
    <Losungsvers>Daniel 9,7</Losungsvers>
    <Lehrtext>Der Hahn krähte zum zweiten Mal. Da gedachte Petrus an das Wort, das Jesus zu ihm gesagt hatte: Ehe der Hahn zweimal kräht, wirst du mich dreimal verleugnen. Und er fing an zu weinen.</Lehrtext>
    <Lehrtextvers>Markus 14,72</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-27T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Pfingstfest</Sonntag>
    <Losungstext>Du aber bleibst, wie du bist, und deine Jahre nehmen kein Ende.</Losungstext>
    <Losungsvers>Psalm 102,28</Losungsvers>
    <Lehrtext>Gott ist treu, durch den ihr berufen seid zur Gemeinschaft seines Sohnes Jesus Christus, unseres Herrn.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-28T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Pfingstmontag</Sonntag>
    <Losungstext>Fürchtet den HERRN und dient ihm treu von ganzem Herzen; denn seht doch, wie große Dinge er an euch getan hat.</Losungstext>
    <Losungsvers>1.Samuel 12,24</Losungsvers>
    <Lehrtext>Die sein Wort annahmen blieben beständig in der Lehre der Apostel und in der Gemeinschaft und im Brotbrechen und im Gebet.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 2,42</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-29T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wir wollen mit euch gehen, denn wir hören, dass Gott mit euch ist.</Losungstext>
    <Losungsvers>Sacharja 8,23</Losungsvers>
    <Lehrtext>Euer Leben mitten unter den Menschen, die Gott nicht kennen, muss einwandfrei sein. Wenn sie euch alles mögliche Böse nachsagen, sollen sie eure guten Taten sehen und von ihren eigenen Augen eines Besseren belehrt werden.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-30T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wie heilig ist diese Stätte! Hier ist nichts anderes als Gottes Haus, und hier ist die Pforte des Himmels.</Losungstext>
    <Losungsvers>1.Mose 28,17</Losungsvers>
    <Lehrtext>Das Haus Gottes, das ist die Gemeinde des lebendigen Gottes, ein Pfeiler und eine Grundfeste der Wahrheit.</Lehrtext>
    <Lehrtextvers>1.Timotheus 3,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-05-31T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Großen Frieden haben, die dein Gesetz lieben; sie werden nicht straucheln.</Losungstext>
    <Losungsvers>Psalm 119,165</Losungsvers>
    <Lehrtext>Friede sei mit euch allen, die ihr in Christus seid!</Lehrtext>
    <Lehrtextvers>1.Petrus 5,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-01T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wer den HERRN fürchtet, hat eine sichere Festung.</Losungstext>
    <Losungsvers>Sprüche 14,26</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wer meine Rede hört und tut sie, der gleicht einem klugen Mann, der sein Haus auf Fels baute.</Lehrtext>
    <Lehrtextvers>Matthäus 7,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-02T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, die Furcht des Herrn, das ist Weisheit, und meiden das Böse, das ist Einsicht.</Losungstext>
    <Losungsvers>Hiob 28,28</Losungsvers>
    <Lehrtext>Da ihr den als Vater anruft, der ohne Ansehen der Person einen jeden richtet nach seinem Werk, so führt euer Leben, solange ihr hier in der Fremde weilt, in Gottesfurcht.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-03T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Trinitatis (Dreieinigkeit)</Sonntag>
    <Losungstext>Unser Gott wandte den Fluch in Segen.</Losungstext>
    <Losungsvers>Nehemia 13,2</Losungsvers>
    <Lehrtext>Vergeltet nicht Böses mit Bösem oder Scheltwort mit Scheltwort, sondern segnet vielmehr, weil ihr dazu berufen seid, dass ihr den Segen ererbt.</Lehrtext>
    <Lehrtextvers>1.Petrus 3,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-04T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du nun isst und satt wirst, so hüte dich, dass du nicht den HERRN vergisst.</Losungstext>
    <Losungsvers>5.Mose 6,11-12</Losungsvers>
    <Lehrtext>Ihr sollt so beten: Unser tägliches Brot gib uns heute.</Lehrtext>
    <Lehrtextvers>Matthäus 6,9.11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-05T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ihre Kinder, die das Gesetz nicht kennen, sollen es auch hören und lernen, den HERRN, euren Gott, zu fürchten alle Tage.</Losungstext>
    <Losungsvers>5.Mose 31,13</Losungsvers>
    <Lehrtext>/Paulus schreibt an die Gemeinde in Korinth:/ Ich bin jetzt bereit, zum dritten Mal zu euch zu kommen, und will euch nicht zur Last fallen; denn ich suche nicht das Eure, sondern euch. Denn es sollen nicht die Kinder den Eltern Schätze sammeln, sondern die Eltern den Kindern.</Lehrtext>
    <Lehrtextvers>2.Korinther 12,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-06T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>So erfülle nun, o Gott, mein HERR, für alle Zeiten die Verheißung und tue, wie du geredet hast.</Losungstext>
    <Losungsvers>2.Samuel 7,25</Losungsvers>
    <Lehrtext>Aus Davids Geschlecht hat Gott, wie er verheißen hat, Jesus kommen lassen als Heiland für das Volk Israel.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 13,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-07T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin ein Gast auf Erden.</Losungstext>
    <Losungsvers>Psalm 119,19</Losungsvers>
    <Lehrtext>Wisst ihr nicht, dass die, die in der Kampfbahn laufen, die laufen alle, aber einer empfängt den Siegespreis? Lauft so, dass ihr ihn erlangt.</Lehrtext>
    <Lehrtextvers>1.Korinther 9,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-08T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Gleichwie ich über sie gewacht habe, auszureißen und einzureißen, so will ich über sie wachen, zu bauen und zu pflanzen, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 31,28</Losungsvers>
    <Lehrtext>Jesus fing an, in Gleichnissen zu reden: Ein Mensch pflanzte einen Weinberg und zog einen Zaun darum und grub eine Kelter und baute einen Turm und verpachtete ihn an Weingärtner und ging außer Landes.</Lehrtext>
    <Lehrtextvers>Markus 12,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-09T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Bei dir ist die Vergebung, dass man dich fürchte.</Losungstext>
    <Losungsvers>Psalm 130,4</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Als Mitarbeiter ermahnen wir euch, dass ihr die Gnade Gottes nicht vergeblich empfangt.</Lehrtext>
    <Lehrtextvers>2.Korinther 6,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-10T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Im Schweiße deines Angesichts sollst du dein Brot essen, bis du wieder zu Erde werdest, davon du genommen bist. Denn du bist Erde und sollst zu Erde werden.</Losungstext>
    <Losungsvers>1.Mose 3,19</Losungsvers>
    <Lehrtext>Unser Heiland Christus Jesus hat dem Tode die Macht genommen und das Leben und ein unvergängliches Wesen ans Licht gebracht durch das Evangelium.</Lehrtext>
    <Lehrtextvers>2.Timotheus 1,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-11T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Rede, HERR, denn dein Knecht hört.</Losungstext>
    <Losungsvers>1.Samuel 3,9</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wer mein Wort hört und glaubt dem, der mich gesandt hat, der hat das ewige Leben und kommt nicht in das Gericht, sondern er ist vom Tode zum Leben hindurchgedrungen.</Lehrtext>
    <Lehrtextvers>Johannes 5,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-12T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gott der HERR rief dem Menschen und sprach zu ihm: Wo bist du? Er sprach: Ich hörte dich im Garten; da fürchtete ich mich.</Losungstext>
    <Losungsvers>1.Mose 3,9.10</Losungsvers>
    <Lehrtext>Jesus sprach: Ich bin gekommen, die Sünder zu rufen und nicht die Gerechten.</Lehrtext>
    <Lehrtextvers>Markus 2,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-13T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich habe die Erde gemacht und den Menschen auf ihr geschaffen.</Losungstext>
    <Losungsvers>Jesaja 45,12</Losungsvers>
    <Lehrtext>Betet an den, der gemacht hat Himmel und Erde und Meer und die Wasserquellen!</Lehrtext>
    <Lehrtextvers>Offenbarung 14,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-14T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Es gibt noch eine Hoffnung für deine Zukunft, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 31,17</Losungsvers>
    <Lehrtext>Gott hat seinen eigenen Sohn nicht verschont, sondern hat ihn für uns alle dahingegeben - wie sollte er uns mit ihm nicht alles schenken?</Lehrtext>
    <Lehrtextvers>Römer 8,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-15T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Das geknickte Rohr wird er nicht zerbrechen, und den glimmenden Docht wird er nicht auslöschen.</Losungstext>
    <Losungsvers>Jesaja 42,3</Losungsvers>
    <Lehrtext>Jesus sprach: Die Starken bedürfen keines Arztes, sondern die Kranken.</Lehrtext>
    <Lehrtextvers>Markus 2,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-16T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du erfreust mein Herz, ob jene auch viel Wein und Korn haben.</Losungstext>
    <Losungsvers>Psalm 4,8</Losungsvers>
    <Lehrtext>Wir haben nichts in die Welt gebracht; darum werden wir auch nichts hinausbringen.</Lehrtext>
    <Lehrtextvers>1.Timotheus 6,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-17T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>2. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Weh denen, die dem Schuldigen Recht geben um Bestechung und dem Unschuldigen sein Recht absprechen!</Losungstext>
    <Losungsvers>Jesaja 5,22.23</Losungsvers>
    <Lehrtext>Das Reich Gottes ist Gerechtigkeit und Friede und Freude in dem Heiligen Geist. Wer darin Christus dient, der ist Gott wohlgefällig und bei den Menschen geachtet.</Lehrtext>
    <Lehrtextvers>Römer 14,17.18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-18T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Dennoch soll die Stadt Gottes fein lustig bleiben mit ihren Brünnlein, da die heiligen Wohnungen des Höchsten sind. Gott ist bei ihr drinnen, darum wird sie fest bleiben.</Losungstext>
    <Losungsvers>Psalm 46,5-6</Losungsvers>
    <Lehrtext>Die Stadt bedarf keiner Sonne noch des Mondes, dass sie ihr scheinen; denn die Herrlichkeit Gottes erleuchtet sie, und ihre Leuchte ist das Lamm.</Lehrtext>
    <Lehrtextvers>Offenbarung 21,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-19T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt mir ein Königreich von Priestern und ein heiliges Volk sein.</Losungstext>
    <Losungsvers>2.Mose 19,6</Losungsvers>
    <Lehrtext>Erbaut euch als lebendige Steine zum geistlichen Hause und zur heiligen Priesterschaft, zu opfern geistliche Opfer, die Gott wohlgefällig sind durch Jesus Christus.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-20T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Sein Zorn währet einen Augenblick und lebenslang seine Gnade. Den Abend lang währet das Weinen, aber des Morgens ist Freude.</Losungstext>
    <Losungsvers>Psalm 30,6</Losungsvers>
    <Lehrtext>Gott hat uns nicht dazu bestimmt, dass wir dem Zorn verfallen, sondern dass wir die Rettung erlangen durch unseren Herrn Jesus Christus.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-21T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Warum sollen die Heiden sagen: Wo ist denn ihr Gott? Unser Gott ist im Himmel; er kann schaffen, was er will.</Losungstext>
    <Losungsvers>Psalm 115,2.3</Losungsvers>
    <Lehrtext>Das Wort vom Kreuz ist eine Torheit denen, die verloren werden; uns aber, die wir selig werden, ist's eine Gotteskraft.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-22T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, hier bin ich. Der HERR mach's mit mir, wie es ihm wohlgefällt.</Losungstext>
    <Losungsvers>2.Samuel 15,26</Losungsvers>
    <Lehrtext>Dein Wille geschehe wie im Himmel so auf Erden.</Lehrtext>
    <Lehrtextvers>Matthäus 6,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-23T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Lass mein Herz sich nicht neigen zum Bösen.</Losungstext>
    <Losungsvers>Psalm 141,4</Losungsvers>
    <Lehrtext>Führe uns nicht in Versuchung, sondern erlöse uns von dem Bösen.</Lehrtext>
    <Lehrtextvers>Matthäus 6,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-24T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>3. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Siehe, auch jetzt noch ist mein Zeuge im Himmel, und mein Fürsprecher ist in der Höhe.</Losungstext>
    <Losungsvers>Hiob 16,19</Losungsvers>
    <Lehrtext>Es ist #ein# Gott und #ein# Mittler zwischen Gott und den Menschen, nämlich der Mensch Christus Jesus.</Lehrtext>
    <Lehrtextvers>1.Timotheus 2,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-25T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gott sprach zu Mose: Ich werde sein, der ich sein werde.</Losungstext>
    <Losungsvers>2.Mose 3,14</Losungsvers>
    <Lehrtext>Ich bin das A und das O, der Anfang und das Ende. Ich will dem Durstigen geben von der Quelle des lebendigen Wassers umsonst.</Lehrtext>
    <Lehrtextvers>Offenbarung 21,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-26T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>So spricht der HERR: Es soll meine Freude sein, ihnen Gutes zu tun.</Losungstext>
    <Losungsvers>Jeremia 32,41</Losungsvers>
    <Lehrtext>Also hat Gott die Welt geliebt, dass er seinen eingeborenen Sohn gab, damit alle, die an ihn glauben, nicht verloren werden, sondern das ewige Leben haben.</Lehrtext>
    <Lehrtextvers>Johannes 3,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-27T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist mein Hirte, mir wird nichts mangeln.</Losungstext>
    <Losungsvers>Psalm 23,1</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin gekommen, damit sie das Leben und volle Genüge haben sollen. Ich bin der gute Hirte. Der gute Hirte lässt sein Leben für die Schafe.</Lehrtext>
    <Lehrtextvers>Johannes 10,10-11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-28T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Lobet Gott für seine Taten, lobet ihn in seiner großen Herrlichkeit!</Losungstext>
    <Losungsvers>Psalm 150,2</Losungsvers>
    <Lehrtext>Auf alle Gottesverheißungen ist in Jesus Christus das Ja; darum sprechen wir auch durch ihn das Amen, Gott zum Lobe.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-29T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>In deiner Hand ist Kraft und Macht, und es ist niemand, der dir zu widerstehen vermag.</Losungstext>
    <Losungsvers>2.Chronik 20,6</Losungsvers>
    <Lehrtext>Gott hat den Herrn auferweckt und wird auch uns auferwecken durch seine Kraft.</Lehrtext>
    <Lehrtextvers>1.Korinther 6,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-06-30T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Um deines Namens willen, HERR, vergib mir meine Schuld, die so groß ist!</Losungstext>
    <Losungsvers>Psalm 25,11</Losungsvers>
    <Lehrtext>Jesus sprach: Vater, vergib ihnen; denn sie wissen nicht, was sie tun!</Lehrtext>
    <Lehrtextvers>Lukas 23,34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-01T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>4. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Du hast dich müde gemacht mit der Menge deiner Pläne.</Losungstext>
    <Losungsvers>Jesaja 47,13</Losungsvers>
    <Lehrtext>Jeder soll so leben, wie der Herr es ihm zugemessen, wie Gott einen jeden berufen hat.</Lehrtext>
    <Lehrtextvers>1.Korinther 7,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-02T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Halte dich ferne von einer Sache, bei der Lüge im Spiel ist.</Losungstext>
    <Losungsvers>2.Mose 23,7</Losungsvers>
    <Lehrtext>Legt ab alle Bosheit und allen Betrug und Heuchelei und Neid und alle üble Nachrede und seid begierig nach der vernünftigen lauteren Milch wie die neugeborenen Kindlein, damit ihr durch sie zunehmt zu eurem Heil.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,1-2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-03T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Viele sagen: »Wer wird uns Gutes sehen lassen?« HERR, lass leuchten über uns das Licht deines Antlitzes!</Losungstext>
    <Losungsvers>Psalm 4,7</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin das Licht der Welt. Wer mir nachfolgt, der wird nicht wandeln in der Finsternis, sondern wird das Licht des Lebens haben.</Lehrtext>
    <Lehrtextvers>Johannes 8,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-04T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Gott der HERR hilft mir, darum werde ich nicht zuschanden.</Losungstext>
    <Losungsvers>Jesaja 50,7</Losungsvers>
    <Lehrtext>In Christus Jesus seid ihr, die ihr einst Ferne wart, Nahe geworden durch das Blut Christi.</Lehrtext>
    <Lehrtextvers>Epheser 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-05T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Auf ihm wird ruhen der Geist des HERRN, der Geist der Weisheit und des Verstandes, der Geist des Rates und der Stärke, der Geist der Erkenntnis und der Furcht des HERRN.</Losungstext>
    <Losungsvers>Jesaja 11,2</Losungsvers>
    <Lehrtext>Gott war in Christus und versöhnte die Welt mit sich selber und rechnete ihnen ihre Sünden nicht zu und hat unter uns aufgerichtet das Wort von der Versöhnung.</Lehrtext>
    <Lehrtextvers>2.Korinther 5,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-06T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Dein Erlöser ist der Heilige Israels, der aller Welt Gott genannt wird.</Losungstext>
    <Losungsvers>Jesaja 54,5</Losungsvers>
    <Lehrtext>Es kann niemand sagen: »Jesus ist der Herr!«, wenn nicht der Heilige Geist in ihm wirkt.</Lehrtext>
    <Lehrtextvers>1.Korinther 12,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-07T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Hast du des HERRN vergessen, der dich gemacht hat, der den Himmel ausgebreitet und die Erde gegründet hat?</Losungstext>
    <Losungsvers>Jesaja 51,13</Losungsvers>
    <Lehrtext>Ihr seid wiedergeboren nicht aus vergänglichem, sondern aus unvergänglichem Samen, nämlich aus dem lebendigen Wort Gottes, das da bleibt.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-08T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>5. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Weh dem, der sein Gut mehrt mit fremdem Gut! Wie lange wird's währen?</Losungstext>
    <Losungsvers>Habakuk 2,6</Losungsvers>
    <Lehrtext>Wer gestohlen hat, der stehle nicht mehr, sondern arbeite und schaffe mit eigenen Händen das nötige Gut, damit er dem Bedürftigen abgeben kann.</Lehrtext>
    <Lehrtextvers>Epheser 4,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-09T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR, und sonst keiner mehr, der ich das Licht mache und schaffe die Finsternis, der ich Frieden gebe und schaffe Unheil. Ich bin der HERR, der dies alles tut.</Losungstext>
    <Losungsvers>Jesaja 45,6-7</Losungsvers>
    <Lehrtext>Wir danken dir, Herr, allmächtiger Gott, der du bist und der du warst, dass du an dich genommen hast deine große Macht und herrschest!</Lehrtext>
    <Lehrtextvers>Offenbarung 11,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-10T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will der Gnade des HERRN gedenken und der Ruhmestaten des HERRN in allem, was uns der HERR getan hat.</Losungstext>
    <Losungsvers>Jesaja 63,7</Losungsvers>
    <Lehrtext>Gelobt sei Gott, der Vater unseres Herrn Jesus Christus, der uns nach seiner großen Barmherzigkeit wiedergeboren hat zu einer lebendigen Hoffnung durch die Auferstehung Jesu Christi von den Toten.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-11T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wenn ihr euch von ganzem Herzen zu dem HERRN bekehren wollt, so tut von euch die fremden Götter.</Losungstext>
    <Losungsvers>1.Samuel 7,3</Losungsvers>
    <Lehrtext>Wo dein Schatz ist, da ist auch dein Herz.</Lehrtext>
    <Lehrtextvers>Matthäus 6,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-12T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst nicht begehren deines Nächsten Haus noch alles, was sein ist.</Losungstext>
    <Losungsvers>5.Mose 5,21</Losungsvers>
    <Lehrtext>Tötet, was in euren Gliedern irdisch ist: böse Begierde und die Habgier - sie ist Götzendienst!</Lehrtext>
    <Lehrtextvers>Kolosser 3,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-13T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Du lässest die Menschen dahinfahren wie einen Strom, sie sind wie ein Schlaf, wie ein Gras, das am Morgen noch sprosst und des Abends welkt und verdorrt.</Losungstext>
    <Losungsvers>Psalm 90,5.6</Losungsvers>
    <Lehrtext>Es wird gesät verweslich und wird auferstehen unverweslich.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,42</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-14T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Steh mir bei, HERR, mein Gott! Hilf mir nach deiner Gnade.</Losungstext>
    <Losungsvers>Psalm 109,26</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Von allen Seiten waren wir bedrängt, von außen mit Streit, von innen mit Furcht. Aber Gott, der die Geringen tröstet, der tröstete uns.</Lehrtext>
    <Lehrtextvers>2.Korinther 7,5-6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-15T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>6. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Wie hat er sein Volk so lieb!</Losungstext>
    <Losungsvers>5.Mose 33,3</Losungsvers>
    <Lehrtext>Lasst uns lieben, denn er hat uns zuerst geliebt.</Lehrtext>
    <Lehrtextvers>1.Johannes 4,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-16T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Uns, HERR, wirst du Frieden schaffen; denn auch alles, was wir ausrichten, das hast du für uns getan.</Losungstext>
    <Losungsvers>Jesaja 26,12</Losungsvers>
    <Lehrtext>Durch Gottes Gnade bin ich, was ich bin.</Lehrtext>
    <Lehrtextvers>1.Korinther 15,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-17T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du siehst es doch, denn du schaust das Elend und den Jammer; es steht in deinen Händen.</Losungstext>
    <Losungsvers>Psalm 10,14</Losungsvers>
    <Lehrtext>Jesus sah die vielen Menschen, und sie taten ihm leid, denn sie waren wie Schafe, die keinen Hirten haben. Und er fing an, sie vieles zu lehren.</Lehrtext>
    <Lehrtextvers>Markus 6,34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-18T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Kommt, lasst uns hinziehen, den HERRN anzuflehen und den HERRN der Heerscharen zu suchen! Auch ich will hinziehen!</Losungstext>
    <Losungsvers>Sacharja 8,21</Losungsvers>
    <Lehrtext>Sie brachten zu Jesus einen Blinden und baten ihn, dass er ihn anrühre.</Lehrtext>
    <Lehrtextvers>Markus 8,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-19T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Gott sieht die Enden der Erde und schaut alles, was unter dem Himmel ist.</Losungstext>
    <Losungsvers>Hiob 28,24</Losungsvers>
    <Lehrtext>Gott ist größer als unser Herz und erkennt alle Dinge.</Lehrtext>
    <Lehrtextvers>1.Johannes 3,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-20T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Daniel hatte an seinem Obergemach offene Fenster nach Jerusalem, und er fiel dreimal am Tag auf seine Knie, betete, lobte und dankte seinem Gott.</Losungstext>
    <Losungsvers>Daniel 6,11</Losungsvers>
    <Lehrtext>Wir leiden Verfolgung, aber wir werden nicht verlassen. Wir werden unterdrückt, aber wir kommen nicht um.</Lehrtext>
    <Lehrtextvers>2.Korinther 4,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-21T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Er sendet eine Erlösung seinem Volk; er verheißt, dass sein Bund ewig bleiben soll.</Losungstext>
    <Losungsvers>Psalm 111,9</Losungsvers>
    <Lehrtext>Da wir nun gerecht geworden sind durch den Glauben, haben wir Frieden mit Gott durch unsern Herrn Jesus Christus.</Lehrtext>
    <Lehrtextvers>Römer 5,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-22T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>7. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Ich wache auf, wenn's noch Nacht ist, nachzusinnen über dein Wort.</Losungstext>
    <Losungsvers>Psalm 119,148</Losungsvers>
    <Lehrtext>Ihr tut gut daran, dass ihr auf das prophetische Wort achtet als auf ein Licht, das da scheint an einem dunklen Ort, bis der Tag anbreche und der Morgenstern aufgehe in euren Herzen.</Lehrtext>
    <Lehrtextvers>2.Petrus 1,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-23T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Sie kamen zu Mose und sprachen: Wir haben gesündigt, dass wir wider den HERRN und wider dich geredet haben. Bitte den HERRN, dass er die Schlangen von uns nehme. Und Mose bat für das Volk.</Losungstext>
    <Losungsvers>4.Mose 21,7</Losungsvers>
    <Lehrtext>Jesus kann für immer selig machen, die durch ihn zu Gott kommen; denn er lebt für immer und bittet für sie.</Lehrtext>
    <Lehrtextvers>Hebräer 7,25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-24T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Fürchte dich nicht, Abram! #Ich# bin dein Schild und dein sehr großer Lohn.</Losungstext>
    <Losungsvers>1.Mose 15,1</Losungsvers>
    <Lehrtext>Gehört ihr Christus an, so seid ihr Abrahams Kinder und nach der Verheißung Erben.</Lehrtext>
    <Lehrtextvers>Galater 3,29</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-25T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>HERR, mein Gott, als ich schrie zu dir, da machtest du mich gesund.</Losungstext>
    <Losungsvers>Psalm 30,3</Losungsvers>
    <Lehrtext>/Christus spricht:/ Was ihr mich bitten werdet in meinem Namen, das will ich tun.</Lehrtext>
    <Lehrtextvers>Johannes 14,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-26T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du gegessen hast und satt bist, sollst du den HERRN, deinen Gott, loben.</Losungstext>
    <Losungsvers>5.Mose 8,10</Losungsvers>
    <Lehrtext>Ob ihr nun esst oder trinkt oder was ihr auch tut, das tut alles zu Gottes Ehre.</Lehrtext>
    <Lehrtextvers>1.Korinther 10,31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-27T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich schwor dir's und schloss mit dir einen Bund, spricht Gott der HERR, dass du solltest mein sein.</Losungstext>
    <Losungsvers>Hesekiel 16,8</Losungsvers>
    <Lehrtext>Ihr seid die, die einst kein Volk waren, jetzt aber das Volk Gottes sind, die einst keine Barmherzigkeit erlangten, jetzt aber Barmherzigkeit erlangt haben.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-28T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Bekehre du mich, so will ich mich bekehren; denn du, HERR, bist mein Gott!</Losungstext>
    <Losungsvers>Jeremia 31,18</Losungsvers>
    <Lehrtext>Ich lebe, doch nun nicht ich, sondern Christus lebt in mir.</Lehrtext>
    <Lehrtextvers>Galater 2,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-29T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>8. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Wo ist ein Gott im Himmel und auf Erden, der es deinen Werken und deiner Macht gleichtun könnte?</Losungstext>
    <Losungsvers>5.Mose 3,24</Losungsvers>
    <Lehrtext>Christus ist offenbart im Fleisch, gerechtfertigt im Geist, erschienen den Engeln, gepredigt den Heiden, geglaubt in der Welt, aufgenommen in die Herrlichkeit.</Lehrtext>
    <Lehrtextvers>1.Timotheus 3,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-30T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Tretet hin und steht und seht die Hilfe des HERRN, der mit euch ist.</Losungstext>
    <Losungsvers>2.Chronik 20,17</Losungsvers>
    <Lehrtext>Paulus sprach: Gottes Hilfe habe ich erfahren bis zum heutigen Tag und stehe nun hier und bin sein Zeuge bei Groß und Klein.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 26,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-07-31T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gleichwie Gewächs aus der Erde wächst und Same im Garten aufgeht, so lässt Gott der HERR Gerechtigkeit aufgehen und Ruhm vor allen Heidenvölkern.</Losungstext>
    <Losungsvers>Jesaja 61,11</Losungsvers>
    <Lehrtext>Jesus sprach: Die Ernte ist groß, der Arbeiter aber sind wenige. Darum bittet den Herrn der Ernte, dass er Arbeiter aussende in seine Ernte.</Lehrtext>
    <Lehrtextvers>Lukas 10,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-01T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>So schau nun vom Himmel und sieh herab von deiner heiligen, herrlichen Wohnung! Wo ist nun dein Eifer und deine Macht?</Losungstext>
    <Losungsvers>Jesaja 63,15</Losungsvers>
    <Lehrtext>Gott hat die Mächte und Gewalten ihrer Macht entkleidet und sie öffentlich zur Schau gestellt und hat einen Triumph aus ihnen gemacht in Christus.</Lehrtext>
    <Lehrtextvers>Kolosser 2,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-02T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR, unser Gott, ist gerecht in allen seinen Werken, die er tut.</Losungstext>
    <Losungsvers>Daniel 9,14</Losungsvers>
    <Lehrtext>Es ist kein Ansehen der Person vor Gott.</Lehrtext>
    <Lehrtextvers>Römer 2,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-03T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Lass ab vom Bösen und tu Gutes; suche Frieden und jage ihm nach!</Losungstext>
    <Losungsvers>Psalm 34,15</Losungsvers>
    <Lehrtext>Seid alle eines Sinnes, voller Mitgefühl, liebt einander, übt Barmherzigkeit, seid demütig.</Lehrtext>
    <Lehrtextvers>1.Petrus 3,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-04T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn ihr mich von ganzem Herzen suchen werdet, so will ich mich von euch finden lassen, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 29,13-14</Losungsvers>
    <Lehrtext>Zachäus stieg auf einen Maulbeerbaum, um Jesus zu sehen; denn dort sollte er durchkommen. Und als Jesus an die Stelle kam, sah er auf und sprach zu ihm: Zachäus, steig eilend herunter; denn ich muss heute in deinem Haus einkehren.</Lehrtext>
    <Lehrtextvers>Lukas 19,4-5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-05T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>9. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Ich will wachen über meinem Wort, dass ich's tue.</Losungstext>
    <Losungsvers>Jeremia 1,12</Losungsvers>
    <Lehrtext>Himmel und Erde werden vergehen; meine Worte aber werden nicht vergehen.</Lehrtext>
    <Lehrtextvers>Markus 13,31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-06T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wenn ein Gerechter Böses tut, so wird's ihm nicht helfen, dass er gerecht gewesen ist; und wenn ein Gottloser von seiner Gottlosigkeit umkehrt, so soll's ihm nicht schaden, dass er gottlos gewesen ist.</Losungstext>
    <Losungsvers>Hesekiel 33,12</Losungsvers>
    <Lehrtext>Die Jünger zogen aus und predigten, man solle Buße tun.</Lehrtext>
    <Lehrtextvers>Markus 6,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-07T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Schaffe in mir, Gott, ein reines Herz und gib mir einen neuen, beständigen Geist.</Losungstext>
    <Losungsvers>Psalm 51,12</Losungsvers>
    <Lehrtext>Ihr seid teuer erkauft; darum preist Gott mit eurem Leibe.</Lehrtext>
    <Lehrtextvers>1.Korinther 6,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-08T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR, der die Zeichen der Wahrsager zunichte macht und die Weissager zu Narren.</Losungstext>
    <Losungsvers>Jesaja 44,25</Losungsvers>
    <Lehrtext>Bewahre, was dir anvertraut ist, und wende dich ab vom heillosen und leeren Gerede, von den Behauptungen der sogenannten Erkenntnis.</Lehrtext>
    <Lehrtextvers>1.Timotheus 6,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-09T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will mich freuen des HERRN und fröhlich sein in Gott, meinem Heil.</Losungstext>
    <Losungsvers>Habakuk 3,18</Losungsvers>
    <Lehrtext>Jesus sprach: Wie können die Hochzeitsgäste fasten, während der Bräutigam bei ihnen ist?</Lehrtext>
    <Lehrtextvers>Markus 2,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-10T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich erzähle dir meine Wege, und du erhörst mich; lehre mich deine Gebote.</Losungstext>
    <Losungsvers>Psalm 119,26</Losungsvers>
    <Lehrtext>/Christus spricht:/ Das ist mein Gebot, dass ihr euch untereinander liebt, wie ich euch liebe.</Lehrtext>
    <Lehrtextvers>Johannes 15,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-11T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Sieht Gott nicht meine Wege und zählt alle meine Schritte?</Losungstext>
    <Losungsvers>Hiob 31,4</Losungsvers>
    <Lehrtext>Wir müssen alle offenbar werden vor dem Richterstuhl Christi, damit jeder seinen Lohn empfange für das, was er getan hat bei Lebzeiten, es sei gut oder böse.</Lehrtext>
    <Lehrtextvers>2.Korinther 5,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-12T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>10. Sonntag nach Trinitatis (Israelsonntag)</Sonntag>
    <Losungstext>Gottes Brünnlein hat Wasser die Fülle.</Losungstext>
    <Losungsvers>Psalm 65,10</Losungsvers>
    <Lehrtext>Von seiner Fülle haben wir alle genommen Gnade um Gnade.</Lehrtext>
    <Lehrtextvers>Johannes 1,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-13T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>So spricht der HERR: Ich gedenke der Treue deiner Jugend und der Liebe deiner Brautzeit, wie du mir folgtest in der Wüste, im Lande, da man nicht sät.</Losungstext>
    <Losungsvers>Jeremia 2,2</Losungsvers>
    <Lehrtext>Sei getreu bis an den Tod, so will ich dir die Krone des Lebens geben.</Lehrtext>
    <Lehrtextvers>Offenbarung 2,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-14T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Jauchzet, ihr Himmel; freue dich, Erde! Lobet, ihr Berge, mit Jauchzen! Denn der HERR hat sein Volk getröstet und erbarmt sich seiner Elenden.</Losungstext>
    <Losungsvers>Jesaja 49,13</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich habe zu euch allen das Vertrauen, dass meine Freude euer aller Freude ist.</Lehrtext>
    <Lehrtextvers>2.Korinther 2,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-15T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Siehe, du wirst Heiden rufen, die du nicht kennst, und Heiden, die dich nicht kennen, werden zu dir laufen um des HERRN willen.</Losungstext>
    <Losungsvers>Jesaja 55,5</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich war bei euch in Schwachheit und in Furcht und mit großem Zittern; und mein Wort und meine Predigt geschahen nicht mit überredenden Worten menschlicher Weisheit, sondern in Erweisung des Geistes und der Kraft.</Lehrtext>
    <Lehrtextvers>1.Korinther 2,3-4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-16T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Erhebe deine Stimme wie eine Posaune und verkündige meinem Volk seine Abtrünnigkeit!</Losungstext>
    <Losungsvers>Jesaja 58,1</Losungsvers>
    <Lehrtext>Sind wir untreu, so bleibt er doch treu; denn er kann sich selbst nicht verleugnen.</Lehrtext>
    <Lehrtextvers>2.Timotheus 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-17T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich will schauen dein Antlitz in Gerechtigkeit, ich will satt werden, wenn ich erwache, an deinem Bilde.</Losungstext>
    <Losungsvers>Psalm 17,15</Losungsvers>
    <Lehrtext>Das Wort ward Fleisch und wohnte unter uns, und wir sahen seine Herrlichkeit.</Lehrtext>
    <Lehrtextvers>Johannes 1,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-18T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Fürchte dich nicht; denn ich bin bei dir und will dich erretten, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 1,8</Losungsvers>
    <Lehrtext>Ihr habt nicht einen knechtischen Geist empfangen, dass ihr euch abermals fürchten müsstet; sondern ihr habt einen kindlichen Geist empfangen, durch den wir rufen: Abba, lieber Vater!</Lehrtext>
    <Lehrtextvers>Römer 8,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-19T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>11. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Die Blinden will ich auf dem Wege leiten, den sie nicht wissen; ich will sie führen auf den Steigen, die sie nicht kennen.</Losungstext>
    <Losungsvers>Jesaja 42,16</Losungsvers>
    <Lehrtext>Gott ist Licht, und in ihm ist keine Finsternis.</Lehrtext>
    <Lehrtextvers>1.Johannes 1,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-20T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gott der HERR wird die Hand nicht abziehen und dich nicht verlassen, bis du jedes Werk für den Dienst im Hause des HERRN vollendet hast.</Losungstext>
    <Losungsvers>1.Chronik 28,20</Losungsvers>
    <Lehrtext>Unser Herr Jesus Christus wird euch fest erhalten bis ans Ende, dass ihr untadelig seid am Tag unseres Herrn Jesus Christus.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-21T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Lobet den HERRN, alle seine Werke, an allen Orten seiner Herrschaft! Lobe den HERRN, meine Seele!</Losungstext>
    <Losungsvers>Psalm 103,22</Losungsvers>
    <Lehrtext>/Christus spricht:/ Gehet hin und machet zu Jüngern alle Völker.</Lehrtext>
    <Lehrtextvers>Matthäus 28,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-22T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Hilf, HERR! Die Heiligen haben abgenommen, und gläubig sind wenige unter den Menschenkindern.</Losungstext>
    <Losungsvers>Psalm 12,2</Losungsvers>
    <Lehrtext>Wie eng ist die Pforte und wie schmal der Weg, der zum Leben führt, und wenige sind's, die ihn finden!</Lehrtext>
    <Lehrtextvers>Matthäus 7,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-23T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Dies Volk naht mir mit seinem Munde und ehrt mich mit seinen Lippen, aber ihr Herz ist fern von mir.</Losungstext>
    <Losungsvers>Jesaja 29,13</Losungsvers>
    <Lehrtext>Jesus sprach: Wer Gottes Willen tut, der ist mein Bruder und meine Schwester und meine Mutter.</Lehrtext>
    <Lehrtextvers>Markus 3,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-24T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Eile, mir beizustehen, Herr, du meine Hilfe!</Losungstext>
    <Losungsvers>Psalm 38,23</Losungsvers>
    <Lehrtext>Das Gebet des Glaubens wird dem Kranken helfen, und der Herr wird ihn aufrichten.</Lehrtext>
    <Lehrtextvers>Jakobus 5,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-25T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Jakob nannte die Stätte, da Gott mit ihm geredet hatte, Bethel (Haus Gottes).</Losungstext>
    <Losungsvers>1.Mose 35,15</Losungsvers>
    <Lehrtext>Christus war treu als Sohn über Gottes Haus. Sein Haus sind wir, wenn wir das Vertrauen und den Ruhm der Hoffnung festhalten.</Lehrtext>
    <Lehrtextvers>Hebräer 3,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-26T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>12. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Dass aber ein Mensch essen und trinken kann und sich gütlich tun bei all seiner Mühsal, auch das ist eine Gabe Gottes.</Losungstext>
    <Losungsvers>Prediger 3,13</Losungsvers>
    <Lehrtext>Sie waren täglich einmütig beieinander im Tempel und brachen das Brot hier und dort in den Häusern, hielten die Mahlzeiten mit Freude und lauterem Herzen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 2,46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-27T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Danket dem Herrn aller Herren, der allein große Wunder tut, denn seine Güte währet ewiglich.</Losungstext>
    <Losungsvers>Psalm 136,3.4</Losungsvers>
    <Lehrtext>Alle gute Gabe und alle vollkommene Gabe kommt von oben herab, von dem Vater des Lichts.</Lehrtext>
    <Lehrtextvers>Jakobus 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-28T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich pries und ehrte den, der ewig lebt, dessen Gewalt ewig ist und dessen Reich für und für währt, gegen den alle, die auf Erden wohnen, für nichts zu rechnen sind.</Losungstext>
    <Losungsvers>Daniel 4,31-32</Losungsvers>
    <Lehrtext>Wir predigen Christus als Gottes Kraft und Gottes Weisheit. Denn die Schwachheit Gottes ist stärker, als die Menschen sind.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,24.25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-29T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Die Toren sprechen in ihrem Herzen: »Es ist kein Gott.«</Losungstext>
    <Losungsvers>Psalm 14,1</Losungsvers>
    <Lehrtext>Was töricht ist vor der Welt, das hat Gott erwählt, damit er die Weisen zuschanden mache.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-30T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ach HERR, strafe mich nicht in deinem Zorn und züchtige mich nicht in deinem Grimm!</Losungstext>
    <Losungsvers>Psalm 6,2</Losungsvers>
    <Lehrtext>Christus ist darum für alle gestorben, damit, die da leben, hinfort nicht sich selbst leben, sondern dem, der für sie gestorben und auferstanden ist.</Lehrtext>
    <Lehrtextvers>2.Korinther 5,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-08-31T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Das Volk, das im Finstern wandelt, sieht ein großes Licht, und über denen, die da wohnen im finstern Lande, scheint es hell.</Losungstext>
    <Losungsvers>Jesaja 9,1</Losungsvers>
    <Lehrtext>Ihr wart früher Finsternis; nun aber seid ihr Licht in dem Herrn. Lebt als Kinder des Lichts.</Lehrtext>
    <Lehrtextvers>Epheser 5,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-01T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will dir danken in großer Gemeinde; unter vielem Volk will ich dich rühmen.</Losungstext>
    <Losungsvers>Psalm 35,18</Losungsvers>
    <Lehrtext>Lasst euer Licht leuchten vor den Leuten, damit sie eure guten Werke sehen und euren Vater im Himmel preisen.</Lehrtext>
    <Lehrtextvers>Matthäus 5,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-02T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>13. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Du sollst dir kein Gottesbild machen, in keinerlei Gestalt.</Losungstext>
    <Losungsvers>5.Mose 5,8</Losungsvers>
    <Lehrtext>Niemand hat Gott jemals gesehen. Wenn wir uns untereinander lieben, so bleibt Gott in uns, und seine Liebe ist in uns vollkommen.</Lehrtext>
    <Lehrtextvers>1.Johannes 4,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-03T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich will das steinerne Herz wegnehmen aus ihrem Leibe und ihnen ein fleischernes Herz geben, damit sie in meinen Geboten wandeln und meine Ordnungen halten und danach tun.</Losungstext>
    <Losungsvers>Hesekiel 11,19.20</Losungsvers>
    <Lehrtext>Im Gehorsam gegenüber der Wahrheit habt ihr eure Seelen rein gemacht, frei für die Liebe unter Brüdern und Schwestern, die keine Verstellung kennt; so liebt denn einander aus reinem Herzen, ohne nachzulassen!</Lehrtext>
    <Lehrtextvers>1.Petrus 1,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-04T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Die Erde ist voll der Güte des HERRN.</Losungstext>
    <Losungsvers>Psalm 33,5</Losungsvers>
    <Lehrtext>Ihr kennt die Gnade unseres Herrn Jesus Christus: obwohl er reich ist, wurde er doch arm um euretwillen, damit ihr durch seine Armut reich würdet.</Lehrtext>
    <Lehrtextvers>2.Korinther 8,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-05T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Noah tat alles, was ihm Gott gebot.</Losungstext>
    <Losungsvers>1.Mose 6,22</Losungsvers>
    <Lehrtext>Legt von euch ab den alten Menschen mit seinem früheren Wandel, der sich durch trügerische Begierden zugrunde richtet. Erneuert euch aber in eurem Geist und Sinn.</Lehrtext>
    <Lehrtextvers>Epheser 4,22-23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-06T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der Engel des HERRN lagert sich um die her, die ihn fürchten, und hilft ihnen heraus.</Losungstext>
    <Losungsvers>Psalm 34,8</Losungsvers>
    <Lehrtext>Der Engel des Herrn kam herein und Licht leuchtete auf in dem Raum; und er stieß Petrus in die Seite und weckte ihn und sprach: Steh schnell auf! Und die Ketten fielen ihm von seinen Händen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 12,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-07T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wir warten auf dich, HERR, auch auf dem Wege deiner Gerichte.</Losungstext>
    <Losungsvers>Jesaja 26,8</Losungsvers>
    <Lehrtext>Werden wir vom Herrn gerichtet, so werden wir zurechtgebracht, damit wir nicht zusammen mit der Welt verurteilt werden.</Lehrtext>
    <Lehrtextvers>1.Korinther 11,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-08T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Das ist meine Freude, dass ich mich zu Gott halte und meine Zuversicht setze auf Gott den HERRN, dass ich verkündige all dein Tun.</Losungstext>
    <Losungsvers>Psalm 73,28</Losungsvers>
    <Lehrtext>Welche ihren Dienst gut versehen, die erwerben sich selbst ein gutes Ansehen und große Zuversicht im Glauben an Christus Jesus.</Lehrtext>
    <Lehrtextvers>1.Timotheus 3,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-09T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>14. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Ich werde dich entrinnen lassen, dass du nicht durch das Schwert umkommen sollst; du wirst dein Leben als Beute davontragen, weil du auf mich vertraut hast, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 39,18</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wer da lebt und glaubt an mich, der wird nimmermehr sterben.</Lehrtext>
    <Lehrtextvers>Johannes 11,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-10T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, der Hüter Israels schläft und schlummert nicht.</Losungstext>
    <Losungsvers>Psalm 121,4</Losungsvers>
    <Lehrtext>Die Nacht ist vorgerückt, der Tag aber nahe herbeigekommen. So lasst uns ablegen die Werke der Finsternis und anlegen die Waffen des Lichts.</Lehrtext>
    <Lehrtextvers>Römer 13,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-11T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, es ist kein Wort auf meiner Zunge, das du, HERR, nicht schon wüsstest.</Losungstext>
    <Losungsvers>Psalm 139,4</Losungsvers>
    <Lehrtext>Die guten Werke einiger Menschen sind zuvor offenbar, und wenn es anders ist, können sie doch nicht verborgen bleiben.</Lehrtext>
    <Lehrtextvers>1.Timotheus 5,25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-12T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Die Gnade des HERRN währt von Ewigkeit zu Ewigkeit über denen, die ihn fürchten, und seine Gerechtigkeit auf Kindeskind bei denen, die seinen Bund halten.</Losungstext>
    <Losungsvers>Psalm 103,17-18</Losungsvers>
    <Lehrtext>Bleibt im Glauben, gegründet und fest, und weicht nicht von der Hoffnung des Evangeliums, das ihr gehört habt und das gepredigt ist allen Geschöpfen unter dem Himmel.</Lehrtext>
    <Lehrtextvers>Kolosser 1,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-13T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Unser Leben währet siebzig Jahre, und wenn's hoch kommt, so sind's achtzig Jahre, und was daran köstlich scheint, ist doch nur vergebliche Mühe.</Losungstext>
    <Losungsvers>Psalm 90,10</Losungsvers>
    <Lehrtext>Was sichtbar ist, das ist zeitlich; was aber unsichtbar ist, das ist ewig.</Lehrtext>
    <Lehrtextvers>2.Korinther 4,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-14T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Seine Hilfe ist nahe denen, die ihn fürchten, dass Güte und Treue einander begegnen, Gerechtigkeit und Friede sich küssen.</Losungstext>
    <Losungsvers>Psalm 85,10.11</Losungsvers>
    <Lehrtext>Weil ihr darauf wartet, darum setzt auch alles daran, dass eure Gemeinschaft mit dem Herrn durch nichts beeinträchtigt wird. Bemüht euch, rein und fehlerlos vor ihm zu stehen, wenn er kommt.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-15T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR lebt! Gelobt sei mein Fels!</Losungstext>
    <Losungsvers>Psalm 18,47</Losungsvers>
    <Lehrtext>Kommt zu Jesus Christus als zu dem lebendigen Stein, der von den Menschen verworfen ist, aber bei Gott auserwählt und kostbar.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-16T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>15. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>So spricht der HERR: Ich habe Lust an der Liebe und nicht am Opfer, an der Erkenntnis Gottes und nicht am Brandopfer.</Losungstext>
    <Losungsvers>Hosea 6,6</Losungsvers>
    <Lehrtext>Ihn lieben von ganzem Herzen, von ganzem Gemüt und von allen Kräften, und seinen Nächsten lieben wie sich selbst, das ist mehr als alle Brandopfer und Schlachtopfer.</Lehrtext>
    <Lehrtextvers>Markus 12,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-17T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wenn sich der Ungerechte abkehrt von seiner Ungerechtigkeit, die er getan hat, und übt nun Recht und Gerechtigkeit, der wird sein Leben erhalten.</Losungstext>
    <Losungsvers>Hesekiel 18,27</Losungsvers>
    <Lehrtext>Die Geduld unseres Herrn erachtet für eure Rettung.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-18T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Lasst uns mit Danken vor sein Angesicht kommen und mit Psalmen ihm jauchzen! Denn der HERR ist ein großer Gott.</Losungstext>
    <Losungsvers>Psalm 95,2-3</Losungsvers>
    <Lehrtext>Jesus sprach: Gebt Gott, was Gottes ist!</Lehrtext>
    <Lehrtextvers>Markus 12,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-19T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR. Was ich rede, das soll geschehen.</Losungstext>
    <Losungsvers>Hesekiel 12,25</Losungsvers>
    <Lehrtext>Der Hauptmann sprach zu Jesus: Herr, sprich nur ein Wort, so wird mein Knecht gesund.</Lehrtext>
    <Lehrtextvers>Matthäus 8,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-20T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Aus Zion bricht an der schöne Glanz Gottes. Unser Gott kommt und schweiget nicht.</Losungstext>
    <Losungsvers>Psalm 50,2-3</Losungsvers>
    <Lehrtext>Jesus ließ sich taufen von Johannes im Jordan. Und alsbald, als er aus dem Wasser stieg, sah er, dass sich der Himmel auftat und der Geist wie eine Taube herabkam auf ihn. Und da geschah eine Stimme vom Himmel: Du bist mein lieber Sohn, an dir habe ich Wohlgefallen.</Lehrtext>
    <Lehrtextvers>Markus 1,9-11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-21T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Du bist meine Zuversicht, HERR, mein Gott, meine Hoffnung von meiner Jugend an.</Losungstext>
    <Losungsvers>Psalm 71,5</Losungsvers>
    <Lehrtext>Dieses kostbare Gut, das dir anvertraut ist, bewahre durch den Heiligen Geist, der in uns wohnt.</Lehrtext>
    <Lehrtextvers>2.Timotheus 1,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-22T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du bist mein Schutz und meine Zuflucht, mein Heiland, der du mir hilfst vor Gewalt.</Losungstext>
    <Losungsvers>2.Samuel 22,3</Losungsvers>
    <Lehrtext>Seid stark in dem Herrn und in der Macht seiner Stärke.</Lehrtext>
    <Lehrtextvers>Epheser 6,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-23T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>16. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Siehe, ich, der HERR, bin der Gott allen Fleisches, sollte mir etwas unmöglich sein?</Losungstext>
    <Losungsvers>Jeremia 32,27</Losungsvers>
    <Lehrtext>Ich bin das A und das O, spricht Gott der Herr, der da ist und der da war und der da kommt, der Allmächtige.</Lehrtext>
    <Lehrtextvers>Offenbarung 1,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-24T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, wie Ton in der Hand des Töpfers, so seid ihr in meiner Hand.</Losungstext>
    <Losungsvers>Jeremia 18,6</Losungsvers>
    <Lehrtext>Gott ist's, der in euch wirkt beides, das Wollen und das Vollbringen, nach seinem Wohlgefallen.</Lehrtext>
    <Lehrtextvers>Philipper 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-25T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Meine Gedanken sind nicht eure Gedanken, und eure Wege sind nicht meine Wege, spricht der HERR.</Losungstext>
    <Losungsvers>Jesaja 55,8</Losungsvers>
    <Lehrtext>Jesus sprach zu Simon und Andreas: Folgt mir nach; ich will euch zu Menschenfischern machen! Sogleich verließen sie ihre Netze und folgten ihm nach.</Lehrtext>
    <Lehrtextvers>Markus 1,17-18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-26T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Darum will ich ihm die Vielen zur Beute geben, und er soll die Starken zum Raube haben, dafür dass er sein Leben in den Tod gegeben hat.</Losungstext>
    <Losungsvers>Jesaja 53,12</Losungsvers>
    <Lehrtext>/Christus spricht:/ Alles ist mir übergeben von meinem Vater; und niemand kennt den Sohn als nur der Vater; und niemand kennt den Vater als nur der Sohn und wem es der Sohn offenbaren will.</Lehrtext>
    <Lehrtextvers>Matthäus 11,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-27T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Lass uns leben, so wollen wir deinen Namen anrufen.</Losungstext>
    <Losungsvers>Psalm 80,19</Losungsvers>
    <Lehrtext>Jesus sprach zu Bartimäus: Geh hin, dein Glaube hat dir geholfen. Und sogleich wurde er sehend und folgte ihm nach auf dem Wege.</Lehrtext>
    <Lehrtextvers>Markus 10,52</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-28T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Er handelt nicht mit uns nach unsern Sünden und vergilt uns nicht nach unsrer Missetat.</Losungstext>
    <Losungsvers>Psalm 103,10</Losungsvers>
    <Lehrtext>Darin besteht die Liebe: nicht dass wir Gott geliebt haben, sondern dass er uns geliebt hat und gesandt seinen Sohn zur Versöhnung für unsre Sünden.</Lehrtext>
    <Lehrtextvers>1.Johannes 4,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-29T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag>Michaelistag</Sonntag>
    <Losungstext>Der Storch unter dem Himmel weiß seine Zeit, Turteltaube, Kranich und Schwalbe halten die Zeit ein, in der sie wiederkommen sollen; aber mein Volk will das Recht des HERRN nicht wissen.</Losungstext>
    <Losungsvers>Jeremia 8,7</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Was nennt ihr mich Herr, Herr, und tut nicht, was ich euch sage?</Lehrtext>
    <Lehrtextvers>Lukas 6,46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-09-30T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>17. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Du, HERR, wollest deine Barmherzigkeit nicht von mir wenden; lass deine Güte und Treue allewege mich behüten.</Losungstext>
    <Losungsvers>Psalm 40,12</Losungsvers>
    <Lehrtext>Der Herr ist treu; der wird euch stärken und bewahren vor dem Bösen.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 3,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-01T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich glaube aber doch, dass ich sehen werde die Güte des HERRN im Lande der Lebendigen.</Losungstext>
    <Losungsvers>Psalm 27,13</Losungsvers>
    <Lehrtext>Siehe, jetzt ist die Zeit der Gnade, siehe, jetzt ist der Tag des Heils!</Lehrtext>
    <Lehrtextvers>2.Korinther 6,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-02T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hat mich gesandt, zu verkündigen ein gnädiges Jahr des HERRN und einen Tag der Vergeltung unsres Gottes.</Losungstext>
    <Losungsvers>Jesaja 61,1.2</Losungsvers>
    <Lehrtext>Jesus kam nach Nazareth und ging nach seiner Gewohnheit am Sabbat in die Synagoge. Und er fing an, zu ihnen zu reden: Heute ist dieses Wort der Schrift erfüllt vor euren Ohren.</Lehrtext>
    <Lehrtextvers>Lukas 4,16.21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-03T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>HERR, sei mir gnädig! Heile mich; denn ich habe an dir gesündigt.</Losungstext>
    <Losungsvers>Psalm 41,5</Losungsvers>
    <Lehrtext>Es kamen einige zu Jesus, die brachten einen Gelähmten, von vieren getragen. Als Jesus ihren Glauben sah, sprach er zu dem Gelähmten: Mein Sohn, deine Sünden sind dir vergeben.</Lehrtext>
    <Lehrtextvers>Markus 2,3.5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-04T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR war mit Josef, und was er tat, dazu gab der HERR Glück.</Losungstext>
    <Losungsvers>1.Mose 39,23</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich habe gepflanzt, Apollos hat begossen; aber Gott hat das Gedeihen gegeben.</Lehrtext>
    <Lehrtextvers>1.Korinther 3,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-05T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR lässt sein Heil kundwerden; vor den Völkern macht er seine Gerechtigkeit offenbar.</Losungstext>
    <Losungsvers>Psalm 98,2</Losungsvers>
    <Lehrtext>Es sei euch kundgetan, dass den Heiden dies Heil Gottes gesandt ist; und sie werden es hören.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 28,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-06T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Mit fröhlichem Schall verkündigt dies und lasst es hören, tragt's hinaus bis an die Enden der Erde und sprecht: Der HERR hat seinen Knecht Jakob erlöst.</Losungstext>
    <Losungsvers>Jesaja 48,20</Losungsvers>
    <Lehrtext>Es hat Gott wohlgefallen, dass in Christus Jesus alle Fülle wohnen sollte und er durch ihn alles mit sich versöhnte, es sei auf Erden oder im Himmel, indem er Frieden machte durch sein Blut am Kreuz.</Lehrtext>
    <Lehrtextvers>Kolosser 1,19-20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-07T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Erntedankfest</Sonntag>
    <Losungstext>Bei Gott steht die Kraft zu helfen und fallen zu lassen.</Losungstext>
    <Losungsvers>2.Chronik 25,8</Losungsvers>
    <Lehrtext>Ihr sagt: Heute oder morgen wollen wir in die oder die Stadt gehen und wollen ein Jahr dort zubringen und Handel treiben und Gewinn machen, und wisst nicht, was morgen sein wird.</Lehrtext>
    <Lehrtextvers>Jakobus 4,13-14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-08T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du der Stimme des HERRN, deines Gottes, gehorchen wirst: Gesegnet wirst du sein bei deinem Eingang und gesegnet bei deinem Ausgang.</Losungstext>
    <Losungsvers>5.Mose 28,1.6</Losungsvers>
    <Lehrtext>Wer Ohren hat zu hören, der höre!</Lehrtext>
    <Lehrtextvers>Markus 4,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-09T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will dem HERRN singen, denn er hat eine herrliche Tat getan.</Losungstext>
    <Losungsvers>2.Mose 15,1</Losungsvers>
    <Lehrtext>Gott hat uns dazu vorherbestimmt, seine Kinder zu sein durch Jesus Christus nach dem Wohlgefallen seines Willens, zum Lob seiner herrlichen Gnade.</Lehrtext>
    <Lehrtextvers>Epheser 1,5-6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-10T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Du sollst das Recht deines Armen nicht beugen in seiner Sache.</Losungstext>
    <Losungsvers>2.Mose 23,6</Losungsvers>
    <Lehrtext>Was wahrhaftig ist, was ehrbar, was gerecht - darauf seid bedacht!</Lehrtext>
    <Lehrtextvers>Philipper 4,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-11T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wasche dein Herz von der Bosheit, auf dass dir geholfen werde. Wie lange wollen bei dir bleiben deine heillosen Gedanken?</Losungstext>
    <Losungsvers>Jeremia 4,14</Losungsvers>
    <Lehrtext>Wisst ihr nicht, dass ein wenig Sauerteig den ganzen Teig durchsäuert? Darum schafft den alten Sauerteig weg, damit ihr ein neuer Teig seid, wie ihr ja ungesäuert seid.</Lehrtext>
    <Lehrtextvers>1.Korinther 5,6-7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-12T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR, dein Gott, der deine rechte Hand fasst und zu dir spricht: Fürchte dich nicht, ich helfe dir!</Losungstext>
    <Losungsvers>Jesaja 41,13</Losungsvers>
    <Lehrtext>Jesus ergriff das Kind bei der Hand und sprach zu ihm: Talita kum! - das heißt übersetzt: Mädchen, ich sage dir, steh auf!</Lehrtext>
    <Lehrtextvers>Markus 5,41</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-13T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will sie sammeln von den Enden der Erde, auch Blinde und Lahme, Schwangere und junge Mütter, dass sie als große Gemeinde wieder hierher kommen sollen.</Losungstext>
    <Losungsvers>Jeremia 31,8</Losungsvers>
    <Lehrtext>/Jesus erzählt im Gleichnis:/ Der König sprach zu seinen Knechten: Geht hinaus auf die Straßen und ladet zur Hochzeit ein, wen ihr findet.</Lehrtext>
    <Lehrtextvers>Matthäus 22,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-14T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>19. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Besser wenig mit Gerechtigkeit als viel Einkommen mit Unrecht.</Losungstext>
    <Losungsvers>Sprüche 16,8</Losungsvers>
    <Lehrtext>Die Frömmigkeit ist eine Quelle großen Reichtums - wenn sie mit Genügsamkeit verbunden ist.</Lehrtext>
    <Lehrtextvers>1.Timotheus 6,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-15T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Er wird mich ans Licht bringen, dass ich seine Gnade schaue.</Losungstext>
    <Losungsvers>Micha 7,9</Losungsvers>
    <Lehrtext>Die Sünde wird nicht herrschen können über euch, weil ihr ja nicht unter dem Gesetz seid, sondern unter der Gnade.</Lehrtext>
    <Lehrtextvers>Römer 6,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-16T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin bei dir, dass ich dir helfe und dich errette, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 15,20</Losungsvers>
    <Lehrtext>Wo zwei oder drei versammelt sind in meinem Namen, da bin ich mitten unter ihnen.</Lehrtext>
    <Lehrtextvers>Matthäus 18,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-17T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Herr, tu meine Lippen auf, dass mein Mund deinen Ruhm verkündige.</Losungstext>
    <Losungsvers>Psalm 51,17</Losungsvers>
    <Lehrtext>Lobt unsern Gott, alle seine Knechte und die ihn fürchten, Klein und Groß!</Lehrtext>
    <Lehrtextvers>Offenbarung 19,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-18T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Des HERRN Wort ist wahrhaftig, und was er zusagt, das hält er gewiss.</Losungstext>
    <Losungsvers>Psalm 33,4</Losungsvers>
    <Lehrtext>Durch den Glauben empfing Sara, die unfruchtbar war, Kraft, Nachkommen hervorzubringen trotz ihres Alters; denn sie hielt den für treu, der es verheißen hatte.</Lehrtext>
    <Lehrtextvers>Hebräer 11,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-19T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der Tag des HERRN kommt und ist nahe.</Losungstext>
    <Losungsvers>Joel 2,1</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wachet und betet, dass ihr nicht in Versuchung fallt! Der Geist ist willig; aber das Fleisch ist schwach.</Lehrtext>
    <Lehrtextvers>Markus 14,38</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-20T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Es ist niemand heilig wie der HERR, außer dir ist keiner.</Losungstext>
    <Losungsvers>1.Samuel 2,2</Losungsvers>
    <Lehrtext>Einen andern Grund kann niemand legen als den, der gelegt ist, welcher ist Jesus Christus.</Lehrtext>
    <Lehrtextvers>1.Korinther 3,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-21T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>20. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Mose trat in das Tor des Lagers und rief: Her zu mir, wer dem HERRN angehört!</Losungstext>
    <Losungsvers>2.Mose 32,26</Losungsvers>
    <Lehrtext>Erforscht euch selbst, ob ihr im Glauben steht; prüft euch selbst!</Lehrtext>
    <Lehrtextvers>2.Korinther 13,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-22T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Nicht hat euch der HERR angenommen und euch erwählt, weil ihr größer wäret als alle Völker - denn du bist das kleinste unter allen Völkern -, sondern weil er euch geliebt hat.</Losungstext>
    <Losungsvers>5.Mose 7,7-8</Losungsvers>
    <Lehrtext>Das Geringe vor der Welt und das Verachtete hat Gott erwählt, das, was nichts ist, damit er zunichte mache, was etwas ist.</Lehrtext>
    <Lehrtextvers>1.Korinther 1,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-23T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR sprach zu Mose: Du sollst alles reden, was ich dir gebieten werde.</Losungstext>
    <Losungsvers>2.Mose 7,1.2</Losungsvers>
    <Lehrtext>Denn nicht ihr seid es, die da reden, sondern eures Vaters Geist ist es, der durch euch redet.</Lehrtext>
    <Lehrtextvers>Matthäus 10,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-24T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich will das Verlorene wieder suchen und das Verirrte zurückbringen.</Losungstext>
    <Losungsvers>Hesekiel 34,16</Losungsvers>
    <Lehrtext>/Christus spricht:/ Das ist der Wille dessen, der mich gesandt hat, dass ich nichts verliere von allem, was er mir gegeben hat, sondern dass ich's auferwecke am Jüngsten Tage.</Lehrtext>
    <Lehrtextvers>Johannes 6,39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-25T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Die Israeliten werden sich bekehren und den HERRN, ihren Gott, suchen und werden mit Zittern zu dem HERRN und seiner Gnade kommen in letzter Zeit.</Losungstext>
    <Losungsvers>Hosea 3,5</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich bin darin guter Zuversicht, dass der in euch angefangen hat das gute Werk, der wird's auch vollenden bis an den Tag Christi Jesu.</Lehrtext>
    <Lehrtextvers>Philipper 1,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-26T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Er wird mit Gerechtigkeit richten die Armen und rechtes Urteil sprechen den Elenden im Lande.</Losungstext>
    <Losungsvers>Jesaja 11,4</Losungsvers>
    <Lehrtext>Es ist erschienen die heilsame Gnade Gottes allen Menschen.</Lehrtext>
    <Lehrtextvers>Titus 2,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-27T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Alle, die dich verlassen, müssen zuschanden werden; denn sie verlassen den HERRN, die Quelle des lebendigen Wassers.</Losungstext>
    <Losungsvers>Jeremia 17,13</Losungsvers>
    <Lehrtext>Seht zu, dass keiner unter euch ein böses, ungläubiges Herz habe, das abfällt von dem lebendigen Gott.</Lehrtext>
    <Lehrtextvers>Hebräer 3,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-28T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>21. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Wenn er spricht, so geschieht's; wenn er gebietet, so steht's da.</Losungstext>
    <Losungsvers>Psalm 33,9</Losungsvers>
    <Lehrtext>Jesus sprach zu dem Tauben: Hefata!, das heißt: Tu dich auf! Und sogleich taten sich seine Ohren auf und die Fessel seiner Zunge löste sich, und er redete richtig.</Lehrtext>
    <Lehrtextvers>Markus 7,34-35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-29T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Bis hierher hat uns der HERR geholfen.</Losungstext>
    <Losungsvers>1.Samuel 7,12</Losungsvers>
    <Lehrtext>Der Herr stand mir bei und stärkte mich, damit durch mich die Botschaft ausgebreitet würde.</Lehrtext>
    <Lehrtextvers>2.Timotheus 4,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-30T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, der HERR lässt es hören bis an die Enden der Erde: Sagt der Tochter Zion: Siehe, dein Heil kommt!</Losungstext>
    <Losungsvers>Jesaja 62,11</Losungsvers>
    <Lehrtext>Christus ist zwar zuvor ausersehen, ehe der Welt Grund gelegt wurde, aber offenbart am Ende der Zeiten um euretwillen.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-10-31T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag>Reformationstag</Sonntag>
    <Losungstext>Wie ein Adler ausführt seine Jungen und über ihnen schwebt, breitete der HERR seine Fittiche aus und nahm sein Volk und trug es auf seinen Flügeln.</Losungstext>
    <Losungsvers>5.Mose 32,11</Losungsvers>
    <Lehrtext>Ihr werdet durch Gottes Macht durch den Glauben bewahrt zur Seligkeit, die bereit ist, dass sie offenbar werde zu der letzten Zeit.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-01T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Hass weckt Streit, Liebe deckt alle Vergehen zu.</Losungstext>
    <Losungsvers>Sprüche 10,12</Losungsvers>
    <Lehrtext>Wenn ich mit Menschen- und mit Engelzungen redete und hätte die Liebe nicht, so wäre ich ein tönendes Erz oder eine klingende Schelle.</Lehrtext>
    <Lehrtextvers>1.Korinther 13,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-02T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Es ist ein köstlich Ding, geduldig sein und auf die Hilfe des HERRN hoffen.</Losungstext>
    <Losungsvers>Klagelieder 3,26</Losungsvers>
    <Lehrtext>Seid standhaft und ihr werdet euer Leben gewinnen.</Lehrtext>
    <Lehrtextvers>Lukas 21,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-03T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR, dein Gott, der Heilige Israels, dein Heiland.</Losungstext>
    <Losungsvers>Jesaja 43,3</Losungsvers>
    <Lehrtext>Wachset in der Gnade und Erkenntnis unseres Herrn und Heilands Jesus Christus.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-04T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>22. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Was ist der Mensch, dass du seiner gedenkst, und des Menschen Kind, dass du dich seiner annimmst?</Losungstext>
    <Losungsvers>Psalm 8,5</Losungsvers>
    <Lehrtext>Gott erweist seine Liebe zu uns darin, dass Christus für uns gestorben ist, als wir noch Sünder waren.</Lehrtext>
    <Lehrtextvers>Römer 5,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-05T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der Übeltäter lasse von seinen Gedanken und bekehre sich zum Herrn, denn bei ihm ist viel Vergebung.</Losungstext>
    <Losungsvers>Jesaja 55,7</Losungsvers>
    <Lehrtext>/Christus spricht:/ Es wird Freude im Himmel sein über #einen# Sünder, der Buße tut, mehr als über neunundneunzig Gerechte, die der Buße nicht bedürfen.</Lehrtext>
    <Lehrtextvers>Lukas 15,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-06T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gott, wir haben mit unsern Ohren gehört, unsre Väter haben's uns erzählt, was du getan hast zu ihren Zeiten, in alten Tagen.</Losungstext>
    <Losungsvers>Psalm 44,2</Losungsvers>
    <Lehrtext>Jesus Christus liebt ihr, obwohl ihr ihn nicht gesehen habt. So erreicht ihr das Ziel eures Glaubens: das Heil eurer Seele. Nach diesem Heil haben die Propheten, die von der Gnade, die euch zuteil werden sollte, kündeten, gesucht und geforscht.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,8.9-10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-07T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der Bogen der Starken ist zerbrochen, und die Schwachen sind umgürtet mit Stärke.</Losungstext>
    <Losungsvers>1.Samuel 2,4</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich will mich rühmen meiner Schwachheit, damit die Kraft Christi bei mir wohne.</Lehrtext>
    <Lehrtextvers>2.Korinther 12,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-08T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sagt: »Der Herr handelt nicht recht.« So höret nun, ihr vom Hause Israel: Handle denn #ich# unrecht? Ist's nicht vielmehr so, dass #ihr# unrecht handelt?</Losungstext>
    <Losungsvers>Hesekiel 18,25</Losungsvers>
    <Lehrtext>Demütigt euch unter die gewaltige Hand Gottes, damit er euch erhöhe zu seiner Zeit.</Lehrtext>
    <Lehrtextvers>1.Petrus 5,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-09T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>In deine Hände befehle ich meinen Geist; du hast mich erlöst, HERR , du treuer Gott.</Losungstext>
    <Losungsvers>Psalm 31,6</Losungsvers>
    <Lehrtext>Alles ist euer, ihr aber seid Christi, Christus aber ist Gottes.</Lehrtext>
    <Lehrtextvers>1.Korinther 3,22-23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-10T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Man singt mit Freuden vom Sieg in den Hütten der Gerechten: Die Rechte des HERRN ist erhöht; die Rechte des HERRN behält den Sieg!</Losungstext>
    <Losungsvers>Psalm 118,15.16</Losungsvers>
    <Lehrtext>Gott sei gedankt, der uns allezeit Sieg gibt in Christus!</Lehrtext>
    <Lehrtextvers>2.Korinther 2,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-11T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Drittletzter Sonntag des Kirchenjahres</Sonntag>
    <Losungstext>Ich will ihnen ein Herz geben, dass sie mich erkennen sollen, dass ich der HERR bin.</Losungstext>
    <Losungsvers>Jeremia 24,7</Losungsvers>
    <Lehrtext>Gott hat uns zusammen mit euch auf diesen festen Grund gestellt: auf Christus. Er hat uns gesalbt und uns sein Siegel aufgedrückt. Er hat seinen Geist in unser Herz gegeben als Anzahlung auf das ewige Leben, das er uns schenken will.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,21-22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-12T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ein Mensch sieht, was vor Augen ist; der HERR aber sieht das Herz an.</Losungstext>
    <Losungsvers>1.Samuel 16,7</Losungsvers>
    <Lehrtext>Wie der, der euch berufen hat, heilig ist, sollt auch ihr heilig sein in eurem ganzen Wandel.</Lehrtext>
    <Lehrtextvers>1.Petrus 1,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-13T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>So viel der Himmel höher ist als die Erde, so sind auch meine Wege höher als eure Wege und meine Gedanken als eure Gedanken.</Losungstext>
    <Losungsvers>Jesaja 55,9</Losungsvers>
    <Lehrtext>Jetzt erkenne ich stückweise; dann aber werde ich erkennen, wie ich erkannt bin.</Lehrtext>
    <Lehrtextvers>1.Korinther 13,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-14T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Meine Zunge soll reden von deiner Gerechtigkeit und dich täglich preisen.</Losungstext>
    <Losungsvers>Psalm 35,28</Losungsvers>
    <Lehrtext>Wenn jemand meint, er diene Gott, und hält seine Zunge nicht im Zaum, sondern betrügt sein Herz, so ist sein Gottesdienst nichtig.</Lehrtext>
    <Lehrtextvers>Jakobus 1,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-15T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du tust mir kund den Weg zum Leben.</Losungstext>
    <Losungsvers>Psalm 16,11</Losungsvers>
    <Lehrtext>Simon Petrus sprach: Herr, wohin sollen wir gehen? Du hast Worte des ewigen Lebens; und wir haben geglaubt und erkannt: Du bist der Heilige Gottes.</Lehrtext>
    <Lehrtextvers>Johannes 6,68-69</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-16T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich verkünde die Zeichen und Wunder, die Gott der Höchste an mir getan hat.</Losungstext>
    <Losungsvers>Daniel 3,32</Losungsvers>
    <Lehrtext>/Der Geheilte sprach:/ Der Mensch, der Jesus heißt, machte einen Brei und strich ihn auf meine Augen und sprach: Geh zum Teich Siloah und wasche dich! Ich ging hin und wusch mich und wurde sehend.</Lehrtext>
    <Lehrtextvers>Johannes 9,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-17T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gott, du kennst meine Torheit, und meine Schuld ist dir nicht verborgen.</Losungstext>
    <Losungsvers>Psalm 69,6</Losungsvers>
    <Lehrtext>Gott hat den Schuldbrief getilgt, der mit seinen Forderungen gegen uns war, und hat ihn weggetan und an das Kreuz geheftet.</Lehrtext>
    <Lehrtextvers>Kolosser 2,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-18T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Vorletzter Sonntag des Kirchenjahres</Sonntag>
    <Losungstext>Wir, dein Volk, die Schafe deiner Weide, danken dir ewiglich und verkünden deinen Ruhm für und für.</Losungstext>
    <Losungsvers>Psalm 79,13</Losungsvers>
    <Lehrtext>Alles, was Gott geschaffen hat, ist gut, und nichts ist verwerflich, was mit Danksagung empfangen wird.</Lehrtext>
    <Lehrtextvers>1.Timotheus 4,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-19T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Dir, HERR, ist niemand gleich; du bist groß, und dein Name ist groß, wie du es mit der Tat beweist.</Losungstext>
    <Losungsvers>Jeremia 10,6</Losungsvers>
    <Lehrtext>Alle Zungen sollen bekennen, dass Jesus Christus der Herr ist, zur Ehre Gottes, des Vaters.</Lehrtext>
    <Lehrtextvers>Philipper 2,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-20T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Tu, was dir vor die Hände kommt; denn Gott ist mit dir.</Losungstext>
    <Losungsvers>1.Samuel 10,7</Losungsvers>
    <Lehrtext>Niemand suche das Seine, sondern was dem andern dient.</Lehrtext>
    <Lehrtextvers>1.Korinther 10,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-21T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag>Buß- und Bettag</Sonntag>
    <Losungstext>Wohl dem, dessen Hilfe der Gott Jakobs ist, der seine Hoffnung setzt auf den HERRN.</Losungstext>
    <Losungsvers>Psalm 146,5</Losungsvers>
    <Lehrtext>Dafür arbeiten und kämpfen wir, weil wir unsre Hoffnung auf den lebendigen Gott gesetzt haben, welcher ist der Heiland aller Menschen.</Lehrtext>
    <Lehrtextvers>1.Timotheus 4,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-22T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Lass mich deine Herrlichkeit sehen!</Losungstext>
    <Losungsvers>2.Mose 33,18</Losungsvers>
    <Lehrtext>Jesus offenbarte seine Herrlichkeit. Und seine Jünger glaubten an ihn.</Lehrtext>
    <Lehrtextvers>Johannes 2,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-23T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Gott sprach: Meinen Bogen habe ich in die Wolken gesetzt; der soll das Zeichen sein des Bundes zwischen mir und der Erde.</Losungstext>
    <Losungsvers>1.Mose 9,13</Losungsvers>
    <Lehrtext>Jesus nahm den Kelch, dankte und gab ihn den Jüngern; und sie tranken alle daraus. Und er sprach zu ihnen: Das ist mein Blut des Bundes, das für viele vergossen wird.</Lehrtext>
    <Lehrtextvers>Markus 14,23-24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-24T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Mein Gott, des Tages rufe ich, doch antwortest du nicht, und des Nachts, doch finde ich keine Ruhe.</Losungstext>
    <Losungsvers>Psalm 22,3</Losungsvers>
    <Lehrtext>Sorgt euch um nichts, sondern in allen Dingen lasst eure Bitten in Gebet und Flehen mit Danksagung vor Gott kundwerden!</Lehrtext>
    <Lehrtextvers>Philipper 4,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-25T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Letzter Sonntag des Kirchenjahres (Ewigkeitssonntag)</Sonntag>
    <Losungstext>Singet dem HERRN ein neues Lied, denn er tut Wunder.</Losungstext>
    <Losungsvers>Psalm 98,1</Losungsvers>
    <Lehrtext>Ermuntert einander mit Psalmen und Lobgesängen und geistlichen Liedern, singt und spielt dem Herrn in eurem Herzen.</Lehrtext>
    <Lehrtextvers>Epheser 5,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-26T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Den HERRN fürchten heißt das Böse hassen.</Losungstext>
    <Losungsvers>Sprüche 8,13</Losungsvers>
    <Lehrtext>Gott hat uns nicht zur Unlauterkeit berufen, sondern zu einem Leben in Heiligung. Darum: Wer solches missachtet, der missachtet nicht einen Menschen, sondern Gott, der doch seinen heiligen Geist in euch hineinlegt.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 4,7-8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-27T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>So habt nun Acht, dass ihr tut, wie euch der HERR, euer Gott, geboten hat, und weicht nicht, weder zur Rechten noch zur Linken.</Losungstext>
    <Losungsvers>5.Mose 5,32</Losungsvers>
    <Lehrtext>/Christus spricht:/ Das höchste Gebot ist das: »Höre, Israel, der Herr, unser Gott, ist der Herr allein, und du sollst den Herrn, deinen Gott, lieben von ganzem Herzen, von ganzer Seele, von ganzem Gemüt und von allen deinen Kräften.« Das andre ist dies: »Du sollst deinen Nächsten lieben wie dich selbst.« Es ist kein anderes Gebot größer als diese.</Lehrtext>
    <Lehrtextvers>Markus 12,29-31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-28T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>In eurer Zeit rede ich ein Wort und tue es auch, spricht Gott der HERR.</Losungstext>
    <Losungsvers>Hesekiel 12,25</Losungsvers>
    <Lehrtext>Jesus spricht zu Marta: Habe ich dir nicht gesagt: Wenn du glaubst, wirst du die Herrlichkeit Gottes sehen?</Lehrtext>
    <Lehrtextvers>Johannes 11,40</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-29T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du hast mich vom Tode errettet, meine Füße vom Gleiten, dass ich wandeln kann vor Gott im Licht der Lebendigen.</Losungstext>
    <Losungsvers>Psalm 56,14</Losungsvers>
    <Lehrtext>Gott ist treu, der euch nicht versuchen lässt über eure Kraft, sondern macht, dass die Versuchung so ein Ende nimmt, dass ihr's ertragen könnt.</Lehrtext>
    <Lehrtextvers>1.Korinther 10,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-11-30T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich will dem HERRN singen mein Leben lang und meinen Gott loben, solange ich bin.</Losungstext>
    <Losungsvers>Psalm 104,33</Losungsvers>
    <Lehrtext>Der Herr wird mich erlösen von allem Übel und mich retten in sein himmlisches Reich. Ihm sei Ehre von Ewigkeit zu Ewigkeit!</Lehrtext>
    <Lehrtextvers>2.Timotheus 4,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-01T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Jonathan ging hin zu David und stärkte sein Vertrauen auf Gott.</Losungstext>
    <Losungsvers>1.Samuel 23,16</Losungsvers>
    <Lehrtext>Ermahnt euch untereinander und einer erbaue den andern.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-02T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag im Advent</Sonntag>
    <Losungstext>Erkennet, dass der HERR Gott ist!</Losungstext>
    <Losungsvers>Psalm 100,3</Losungsvers>
    <Lehrtext>Die vorangingen und die nachfolgten, schrien: Hosianna! Gelobt sei, der da kommt in dem Namen des Herrn!</Lehrtext>
    <Lehrtextvers>Markus 11,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-03T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du bist der Gott, der mir hilft; täglich harre ich auf dich.</Losungstext>
    <Losungsvers>Psalm 25,5</Losungsvers>
    <Lehrtext>/Christus spricht:/ Bittet, so wird euch gegeben; suchet, so werdet ihr finden; klopfet an, so wird euch aufgetan.</Lehrtext>
    <Lehrtextvers>Lukas 11,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-04T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du auf das Wort des HERRN, deines Gottes, hörst: Gesegnet bist du in der Stadt und gesegnet auf dem Felde.</Losungstext>
    <Losungsvers>5.Mose 28,2-3</Losungsvers>
    <Lehrtext>Jesus sprach: Selig sind, die das Wort Gottes hören und bewahren.</Lehrtext>
    <Lehrtextvers>Lukas 11,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-05T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird meine Sache hinausführen.</Losungstext>
    <Losungsvers>Psalm 138,8</Losungsvers>
    <Lehrtext>Wer will die Auserwählten Gottes beschuldigen? Gott ist hier, der gerecht macht.</Lehrtext>
    <Lehrtextvers>Römer 8,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-06T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der Gerechten Pfad glänzt wie das Licht am Morgen, das immer heller leuchtet bis zum vollen Tag.</Losungstext>
    <Losungsvers>Sprüche 4,18</Losungsvers>
    <Lehrtext>Wir sind nicht von der Nacht noch von der Finsternis. So lasst uns nun nicht schlafen wie die andern, sondern lasst uns wachen und nüchtern sein.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,5-6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-07T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist gut und gerecht; darum weist er Sündern den Weg.</Losungstext>
    <Losungsvers>Psalm 25,8</Losungsvers>
    <Lehrtext>Durch Jesus wird euch die Vergebung der Sünden verkündigt.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 13,38</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-08T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Er ist ein Schild allen, die ihm vertrauen.</Losungstext>
    <Losungsvers>Psalm 18,31</Losungsvers>
    <Lehrtext>Jesus sprach zu seinen Jüngern: Sorgt nicht um euer Leben, was ihr essen sollt, auch nicht um euren Leib, was ihr anziehen sollt. Denn das Leben ist mehr als die Nahrung und der Leib mehr als die Kleidung.</Lehrtext>
    <Lehrtextvers>Lukas 12,22.23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-09T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>2. Sonntag im Advent</Sonntag>
    <Losungstext>Der HERR tötet und macht lebendig, führt hinab zu den Toten und wieder herauf.</Losungstext>
    <Losungsvers>1.Samuel 2,6</Losungsvers>
    <Lehrtext>Die Himmelskräfte werden erschüttert werden. Und dann werden sie den Menschensohn kommen sehen auf einer Wolke mit großer Macht und Herrlichkeit. Wenn aber das zu geschehen beginnt, richtet euch auf und erhebt eure Häupter, denn eure Erlösung naht.</Lehrtext>
    <Lehrtextvers>Lukas 21,26-28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-10T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Meine Tränen sind meine Speise Tag und Nacht, weil man täglich zu mir sagt: Wo ist nun dein Gott?</Losungstext>
    <Losungsvers>Psalm 42,4</Losungsvers>
    <Lehrtext>Christus hat in den Tagen seines irdischen Lebens Bitten und Flehen mit lautem Schreien und mit Tränen dem dargebracht, der ihn vom Tod erretten konnte; und er ist auch erhört worden, weil er Gott in Ehren hielt.</Lehrtext>
    <Lehrtextvers>Hebräer 5,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-11T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der Vogel hat ein Haus gefunden und die Schwalbe ein Nest für ihre Jungen - deine Altäre, HERR Zebaoth, mein König und mein Gott.</Losungstext>
    <Losungsvers>Psalm 84,4</Losungsvers>
    <Lehrtext>Es ist also noch eine Ruhe vorhanden für das Volk Gottes.</Lehrtext>
    <Lehrtextvers>Hebräer 4,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-12T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wie ein Hirte seine Schafe sucht, wenn sie von seiner Herde verirrt sind, so will ich meine Schafe suchen.</Losungstext>
    <Losungsvers>Hesekiel 34,12</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin der gute Hirte und kenne die Meinen und die Meinen kennen mich.</Lehrtext>
    <Lehrtextvers>Johannes 10,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-13T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du erkennst ja in deinem Herzen, dass der HERR, dein Gott, dich erzogen hat, wie ein Mann seinen Sohn erzieht.</Losungstext>
    <Losungsvers>5.Mose 8,5</Losungsvers>
    <Lehrtext>Als der Sohn noch weit entfernt war, sah ihn sein Vater und es jammerte ihn; er lief und fiel ihm um den Hals und küsste ihn.</Lehrtext>
    <Lehrtextvers>Lukas 15,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-14T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Das Volk, das ich mir bereitet habe, soll meinen Ruhm verkündigen.</Losungstext>
    <Losungsvers>Jesaja 43,21</Losungsvers>
    <Lehrtext>Euch hat Christus versöhnt durch den Tod seines sterblichen Leibes, damit er euch heilig und untadelig und makellos vor sein Angesicht stelle.</Lehrtext>
    <Lehrtextvers>Kolosser 1,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-15T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Fürchtet euch nur nicht und stärkt eure Hände!</Losungstext>
    <Losungsvers>Sacharja 8,13</Losungsvers>
    <Lehrtext>Ihr seid das Licht der Welt.</Lehrtext>
    <Lehrtextvers>Matthäus 5,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-16T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>3. Sonntag im Advent</Sonntag>
    <Losungstext>Ich habe euch lieb, spricht der HERR.</Losungstext>
    <Losungsvers>Maleachi 1,2</Losungsvers>
    <Lehrtext>Der Herr richte eure Herzen aus auf die Liebe Gottes und auf die Geduld Christi.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 3,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-17T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Hiob antwortete dem HERRN: Siehe, ich bin zu gering, was soll ich antworten? Ich will meine Hand auf meinen Mund legen.</Losungstext>
    <Losungsvers>Hiob 40,3.4</Losungsvers>
    <Lehrtext>Weil Gott uns für wert geachtet hat, uns das Evangelium anzuvertrauen, darum reden wir, nicht, als wollten wir den Menschen gefallen, sondern Gott, der unsere Herzen prüft.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-18T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Er steht dem Armen zur Rechten, dass er ihm helfe von denen, die ihn verurteilen.</Losungstext>
    <Losungsvers>Psalm 109,31</Losungsvers>
    <Lehrtext>Er, der heiligt, und sie, die geheiligt werden, stammen alle von Einem ab. Aus diesem Grund scheut er sich nicht, sie Brüder und Schwestern zu nennen.</Lehrtext>
    <Lehrtextvers>Hebräer 2,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-19T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird dein ewiges Licht und dein Gott wird dein Glanz sein.</Losungstext>
    <Losungsvers>Jesaja 60,19</Losungsvers>
    <Lehrtext>Johannes der Täufer kam zum Zeugnis, um von dem Licht zu zeugen, damit sie alle durch ihn glaubten.</Lehrtext>
    <Lehrtextvers>Johannes 1,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-20T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn der HERR nicht die Stadt behütet, so wacht der Wächter umsonst.</Losungstext>
    <Losungsvers>Psalm 127,1</Losungsvers>
    <Lehrtext>Nicht dass wir tüchtig sind von uns selber, uns etwas zuzurechnen als von uns selber; sondern dass wir tüchtig sind, ist von Gott.</Lehrtext>
    <Lehrtextvers>2.Korinther 3,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-21T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Nach diesem will ich meinen Geist ausgießen über alles Fleisch.</Losungstext>
    <Losungsvers>Joel 3,1</Losungsvers>
    <Lehrtext>Jesus sprach: Der Tröster, der Heilige Geist, den mein Vater senden wird in meinem Namen, der wird euch alles lehren und euch an alles erinnern, was ich euch gesagt habe.</Lehrtext>
    <Lehrtextvers>Johannes 14,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-22T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Nimm ja nicht von meinem Munde das Wort der Wahrheit.</Losungstext>
    <Losungsvers>Psalm 119,43</Losungsvers>
    <Lehrtext>Dafür halte uns jedermann: für Diener Christi und Haushalter über Gottes Geheimnisse.</Lehrtext>
    <Lehrtextvers>1.Korinther 4,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-23T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>4. Sonntag im Advent</Sonntag>
    <Losungstext>Ihr sollt euch nicht wenden zu den Geisterbeschwörern und Zeichendeutern und sollt sie nicht befragen, dass ihr nicht an ihnen unrein werdet; ich bin der HERR, euer Gott.</Losungstext>
    <Losungsvers>3.Mose 19,31</Losungsvers>
    <Lehrtext>Er hat uns errettet von der Macht der Finsternis und hat uns versetzt in das Reich seines lieben Sohnes.</Lehrtext>
    <Lehrtextvers>Kolosser 1,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-24T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Heiliger Abend</Sonntag>
    <Losungstext>Wer dem Geringen Gewalt tut, lästert dessen Schöpfer.</Losungstext>
    <Losungsvers>Sprüche 14,31</Losungsvers>
    <Lehrtext>Eure Güte lasst kund sein allen Menschen! Der Herr ist nahe!</Lehrtext>
    <Lehrtextvers>Philipper 4,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-25T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag>Weihnachtsfest</Sonntag>
    <Losungstext>Kein Bewohner Zions wird sagen: »Ich bin schwach«; denn das Volk, das darin wohnt, wird Vergebung der Sünde haben.</Losungstext>
    <Losungsvers>Jesaja 33,24</Losungsvers>
    <Lehrtext>Der Engel sprach: Fürchtet euch nicht! Siehe, ich verkündige euch große Freude, die allem Volk widerfahren wird; denn euch ist heute der Heiland geboren, welcher ist Christus, der Herr.</Lehrtext>
    <Lehrtextvers>Lukas 2,10-11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-26T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag>2. Weihnachtstag</Sonntag>
    <Losungstext>Fürchtet euch nicht! Haltet stand, so werdet ihr sehen, wie der HERR euch heute helfen wird.</Losungstext>
    <Losungsvers>2.Mose 14,13</Losungsvers>
    <Lehrtext>Die Hirten kehrten wieder um, priesen und lobten Gott für alles, was sie gehört und gesehen hatten, wie denn zu ihnen gesagt war.</Lehrtext>
    <Lehrtextvers>Lukas 2,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-27T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>HERR, zürne nicht so sehr und gedenke nicht ewig der Sünde! Sieh doch an, dass wir alle dein Volk sind!</Losungstext>
    <Losungsvers>Jesaja 64,8</Losungsvers>
    <Lehrtext>Wer an den Sohn glaubt, der hat das ewige Leben. Wer aber dem Sohn nicht gehorsam ist, der wird das Leben nicht sehen, sondern der Zorn Gottes bleibt über ihm.</Lehrtext>
    <Lehrtextvers>Johannes 3,36</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-28T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der Tag des HERRN ist groß und voller Schrecken, wer kann ihn ertragen? Doch auch jetzt noch, spricht der HERR, bekehrt euch zu mir von ganzem Herzen!</Losungstext>
    <Losungsvers>Joel 2,11-12</Losungsvers>
    <Lehrtext>Der Herr lasse euch wachsen und immer reicher werden in der Liebe untereinander und zu jedermann, damit eure Herzen gestärkt werden und untadelig seien in Heiligkeit vor Gott, unserm Vater, wenn unser Herr Jesus kommt.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 3,12.13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-29T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst nicht falsch Zeugnis reden wider deinen Nächsten.</Losungstext>
    <Losungsvers>2.Mose 20,16</Losungsvers>
    <Lehrtext>Lasst kein faules Geschwätz aus eurem Mund gehen, sondern redet, was gut ist, was erbaut und was notwendig ist, damit es Segen bringe denen, die es hören.</Lehrtext>
    <Lehrtextvers>Epheser 4,29</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-30T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag nach Weihnachten</Sonntag>
    <Losungstext>Weigere dich nicht, dem Bedürftigen Gutes zu tun, wenn deine Hand es vermag.</Losungstext>
    <Losungsvers>Sprüche 3,27</Losungsvers>
    <Lehrtext>Seid Täter des Worts und nicht Hörer allein; sonst betrügt ihr euch selbst.</Lehrtext>
    <Lehrtextvers>Jakobus 1,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2012-12-31T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Altjahrsabend</Sonntag>
    <Losungstext>Meine Augen sehnen sich nach deinem Wort und sagen: Wann tröstest du mich?</Losungstext>
    <Losungsvers>Psalm 119,82</Losungsvers>
    <Lehrtext>Unser Herr Jesus Christus, und Gott, unser Vater, der uns geliebt und uns einen ewigen Trost gegeben hat und eine gute Hoffnung durch Gnade, der tröste eure Herzen.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 2,16-17</Lehrtextvers>
  </Losungen>
</FreeXml>]]></data>
	</file>
	<file>
	  <filename>/losungen/losungen2013.xml</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[﻿<?xml version="1.0" standalone="yes"?>
<FreeXml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="http://losungen.de/losungen.xsd">
  <Losungen>
    <Datum>2013-01-01T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag>Neujahr</Sonntag>
    <Losungstext>Mir sollen sich alle Knie beugen und alle Zungen schwören und sagen: Im HERRN habe ich Gerechtigkeit und Stärke.</Losungstext>
    <Losungsvers>Jesaja 45,23-24</Losungsvers>
    <Lehrtext>Ich beuge meine Knie vor dem Vater, der der rechte Vater ist über alles, was da Kinder heißt im Himmel und auf Erden.</Lehrtext>
    <Lehrtextvers>Epheser 3,14-15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-02T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Die Furcht des HERRN ist der Anfang der Erkenntnis.</Losungstext>
    <Losungsvers>Sprüche 1,7</Losungsvers>
    <Lehrtext>Petrus sprach: Gott sieht die Person nicht an; sondern in jedem Volk, wer ihn fürchtet und recht tut, der ist ihm angenehm.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 10,34.35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-03T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der Fremdling soll bei euch wohnen wie ein Einheimischer.</Losungstext>
    <Losungsvers>3.Mose 19,34</Losungsvers>
    <Lehrtext>Gastfrei zu sein vergesst nicht; denn dadurch haben einige ohne ihr Wissen Engel beherbergt.</Lehrtext>
    <Lehrtextvers>Hebräer 13,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-04T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Weh mir, ich vergehe! Denn ich bin unreiner Lippen und wohne unter einem Volk von unreinen Lippen.</Losungstext>
    <Losungsvers>Jesaja 6,5</Losungsvers>
    <Lehrtext>Eure Rede soll stets Anklang finden und doch voller Würze sein; ihr sollt imstande sein, jedermann Red und Antwort zu stehen.</Lehrtext>
    <Lehrtextvers>Kolosser 4,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-05T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ein hörendes Ohr und ein sehendes Auge, die macht beide der HERR.</Losungstext>
    <Losungsvers>Sprüche 20,12</Losungsvers>
    <Lehrtext>Jesus öffnete den Jüngern das Verständnis, sodass sie die Schrift verstanden.</Lehrtext>
    <Lehrtextvers>Lukas 24,45</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-06T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Epiphanias (Erscheinungsfest)</Sonntag>
    <Losungstext>Da dachte ich: Ich will nicht mehr an ihn denken und nicht mehr in seinem Namen predigen. Aber es ward in meinem Herzen wie ein brennendes Feuer.</Losungstext>
    <Losungsvers>Jeremia 20,9</Losungsvers>
    <Lehrtext>Wehe mir, wenn ich das Evangelium nicht predigte!</Lehrtext>
    <Lehrtextvers>1.Korinther 9,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-07T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Josua fiel auf sein Angesicht zur Erde nieder, betete an und sprach: Was sagt mein Herr seinem Knecht?</Losungstext>
    <Losungsvers>Josua 5,14</Losungsvers>
    <Lehrtext>Jesus sprach: Meine Mutter und meine Brüder sind diese, die Gottes Wort hören und tun.</Lehrtext>
    <Lehrtextvers>Lukas 8,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-08T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du bist ja doch unter uns, HERR, und wir heißen nach deinem Namen; verlass uns nicht!</Losungstext>
    <Losungsvers>Jeremia 14,9</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin bei euch alle Tage bis an der Welt Ende.</Lehrtext>
    <Lehrtextvers>Matthäus 28,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-09T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>In meinem Zorn habe ich dich geschlagen, aber in meiner Gnade erbarme ich mich über dich.</Losungstext>
    <Losungsvers>Jesaja 60,10</Losungsvers>
    <Lehrtext>Darum lasst uns hinzutreten mit Zuversicht zu dem Thron der Gnade, damit wir Barmherzigkeit empfangen und Gnade finden zu der Zeit, wenn wir Hilfe nötig haben.</Lehrtext>
    <Lehrtextvers>Hebräer 4,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-10T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Bei dem HERRN, unserm Gott, ist kein Unrecht, weder Ansehen der Person noch Annehmen von Geschenken.</Losungstext>
    <Losungsvers>2.Chronik 19,7</Losungsvers>
    <Lehrtext>Allerlei Zöllner und Sünder nahten sich Jesus, um ihn zu hören. Und die Pharisäer und Schriftgelehrten murrten und sprachen: Dieser nimmt die Sünder an und isst mit ihnen.</Lehrtext>
    <Lehrtextvers>Lukas 15,1-2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-11T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Deine Toten werden leben.</Losungstext>
    <Losungsvers>Jesaja 26,19</Losungsvers>
    <Lehrtext>Wenn wir glauben, dass Jesus gestorben und auferstanden ist, so wird Gott auch die, die entschlafen sind, durch Jesus mit ihm einherführen.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 4,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-12T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gott wird mich erlösen aus des Todes Gewalt; denn er nimmt mich auf.</Losungstext>
    <Losungsvers>Psalm 49,16</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich elender Mensch! Wer wird mich erlösen von diesem todverfallenen Leibe? Dank sei Gott durch Jesus Christus, unsern Herrn!</Lehrtext>
    <Lehrtextvers>Römer 7,24-25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-13T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag nach Epiphanias</Sonntag>
    <Losungstext>Es ist der HERR; er tue, was ihm wohlgefällt.</Losungstext>
    <Losungsvers>1.Samuel 3,18</Losungsvers>
    <Lehrtext>Wer ist unter euch, der, wie sehr er sich auch darum sorgt, seines Lebens Länge eine Spanne zusetzen könnte? Wenn ihr nun auch das Geringste nicht vermögt, warum sorgt ihr euch um das andre?</Lehrtext>
    <Lehrtextvers>Lukas 12,25-26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-14T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gott der HERR ist Sonne und Schild.</Losungstext>
    <Losungsvers>Psalm 84,12</Losungsvers>
    <Lehrtext>/Christus spricht:/ Gott, der sprach: Licht soll aus der Finsternis hervorleuchten, der hat einen hellen Schein in unsre Herzen gegeben, dass durch uns entstünde die Erleuchtung zur Erkenntnis der Herrlichkeit Gottes in dem Angesicht Jesu Christi.</Lehrtext>
    <Lehrtextvers>2. Korinther 4,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-15T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Dein Knecht lässt sich durch deine Gebote warnen.</Losungstext>
    <Losungsvers>Psalm 19,12</Losungsvers>
    <Lehrtext>Es gibt keinen guten Baum, der faule Frucht trägt, und keinen faulen Baum, der gute Frucht trägt.</Lehrtext>
    <Lehrtextvers>Lukas 6,43</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-16T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wendet euch zu mir, so werdet ihr gerettet, aller Welt Enden; denn ich bin Gott und sonst keiner mehr.</Losungstext>
    <Losungsvers>Jesaja 45,22</Losungsvers>
    <Lehrtext>Der Herr sprach zu dem Knecht: Geh hinaus auf die Landstraßen und an die Zäune und nötige sie hereinzukommen, dass mein Haus voll werde.</Lehrtext>
    <Lehrtextvers>Lukas 14,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-17T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will die Zerstreuten sammeln und will sie zu Lob und Ehren bringen in allen Landen, wo man sie verachtet.</Losungstext>
    <Losungsvers>Zefanja 3,19</Losungsvers>
    <Lehrtext>Treu ist er, der euch ruft; er wird’s auch tun.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-18T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>/Gott spricht:/ Von nun an lasse ich dich Neues hören und Verborgenes, das du nicht wusstest.</Losungstext>
    <Losungsvers>Jesaja 48,6</Losungsvers>
    <Lehrtext>Wer Ohren hat zu hören, der höre!</Lehrtext>
    <Lehrtextvers>Lukas 8,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-19T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird seinem Volk Recht schaffen, und über seine Knechte wird er sich erbarmen.</Losungstext>
    <Losungsvers>5.Mose 32,36</Losungsvers>
    <Lehrtext>Der Menschensohn ist gekommen, zu suchen und selig zu machen, was verloren ist.</Lehrtext>
    <Lehrtextvers>Lukas 19,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-20T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Letzter Sonntag nach Epiphanias</Sonntag>
    <Losungstext>Suchet den HERRN, alle ihr Elenden im Lande, die ihr seine Rechte haltet! Suchet Gerechtigkeit, suchet Demut!</Losungstext>
    <Losungsvers>Zefanja 2,3</Losungsvers>
    <Lehrtext>Seid ihr mit Christus auferstanden, so sucht, was droben ist, wo Christus ist, sitzend zur Rechten Gottes.</Lehrtext>
    <Lehrtextvers>Kolosser 3,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-21T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gelobt sei Gott, der seinen Engel gesandt und seine Knechte errettet hat, die ihm vertraut haben.</Losungstext>
    <Losungsvers>Daniel 3,28</Losungsvers>
    <Lehrtext>Kein Haar von eurem Haupt soll verloren gehen.</Lehrtext>
    <Lehrtextvers>Lukas 21,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-22T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Lernt Gutes tun, trachtet nach Recht, helft den Unterdrückten!</Losungstext>
    <Losungsvers>Jesaja 1,17</Losungsvers>
    <Lehrtext>Denkt an die Gefangenen, weil auch ihr Gefangene seid; denkt an die Misshandelten, weil auch ihr Verletzliche seid.</Lehrtext>
    <Lehrtextvers>Hebräer 13,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-23T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Meinst du, dass ich Gefallen habe am Tode des Gottlosen, spricht Gott der HERR, und nicht vielmehr daran, dass er sich bekehrt von seinen Wegen und am Leben bleibt?</Losungstext>
    <Losungsvers>Hesekiel 18,23</Losungsvers>
    <Lehrtext>Der Vater sprach: Dieser mein Sohn war tot und ist wieder lebendig geworden; er war verloren und ist gefunden worden.</Lehrtext>
    <Lehrtextvers>Lukas 15,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-24T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Das Warten der Gerechten wird Freude werden.</Losungstext>
    <Losungsvers>Sprüche 10,28</Losungsvers>
    <Lehrtext>Geduld habt ihr nötig, damit ihr den Willen Gottes tut und das Verheißene empfangt.</Lehrtext>
    <Lehrtextvers>Hebräer 10,36</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-25T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Gott, dein Weg ist heilig.</Losungstext>
    <Losungsvers>Psalm 77,14</Losungsvers>
    <Lehrtext>Welch eine Tiefe des Reichtums, beides, der Weisheit und der Erkenntnis Gottes! Wie unbegreiflich sind seine Gerichte und unerforschlich seine Wege!</Lehrtext>
    <Lehrtextvers>Römer 11,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-26T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Den Demütigen wird der HERR Gnade geben.</Losungstext>
    <Losungsvers>Sprüche 3,34</Losungsvers>
    <Lehrtext>Wer unter euch groß sein will, der sei euer Diener.</Lehrtext>
    <Lehrtextvers>Matthäus 20,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-27T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Septuagesimae (70 Tage vor Ostern)</Sonntag>
    <Losungstext>Pflüget ein Neues und säet nicht unter die Dornen!</Losungstext>
    <Losungsvers>Jeremia 4,3</Losungsvers>
    <Lehrtext>Wer seine Hand an den Pflug legt und sieht zurück, der ist nicht geschickt für das Reich Gottes.</Lehrtext>
    <Lehrtextvers>Lukas 9,62</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-28T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hat mir ein neues Lied in meinen Mund gegeben, zu loben unsern Gott.</Losungstext>
    <Losungsvers>Psalm 40,4</Losungsvers>
    <Lehrtext>Jesus sprach zu dem Blinden: Sei sehend! Dein Glaube hat dir geholfen. Und sogleich wurde er sehend und folgte ihm nach und pries Gott.</Lehrtext>
    <Lehrtextvers>Lukas 18,42-43</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-29T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gott ist mit dir in allem, was du tust.</Losungstext>
    <Losungsvers>1.Mose 21,22</Losungsvers>
    <Lehrtext>Die Gnade unseres Herrn Jesus Christus sei mit euch!</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-30T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Gott ist weise und mächtig; wem ist’s je gelungen, der sich gegen ihn gestellt hat?</Losungstext>
    <Losungsvers>Hiob 9,4</Losungsvers>
    <Lehrtext>Ja, lieber Mensch, wer bist du denn, dass du mit Gott rechten willst?</Lehrtext>
    <Lehrtextvers>Römer 9,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-01-31T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist der wahrhaftige Gott, der lebendige Gott, der ewige König.</Losungstext>
    <Losungsvers>Jeremia 10,10</Losungsvers>
    <Lehrtext>/Der Engel sprach zu Maria:/ Du wirst schwanger werden und einen Sohn gebären, und er wird König sein über das Haus Jakob in Ewigkeit, und sein Reich wird kein Ende haben.</Lehrtext>
    <Lehrtextvers>Lukas 1,31-33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-01T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Weh denen, die weise sind in ihren eigenen Augen und halten sich selbst für klug!</Losungstext>
    <Losungsvers>Jesaja 5,21</Losungsvers>
    <Lehrtext>In Christus liegen verborgen alle Schätze der Weisheit und der Erkenntnis.</Lehrtext>
    <Lehrtextvers>Kolosser 2,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-02T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Viele, die unter der Erde schlafen liegen, werden aufwachen, die einen zum ewigen Leben, die andern zu ewiger Schmach und Schande.</Losungstext>
    <Losungsvers>Daniel 12,2</Losungsvers>
    <Lehrtext>Gott ist nicht ein Gott der Toten, sondern der Lebenden; denn ihm leben sie alle.</Lehrtext>
    <Lehrtextvers>Lukas 20,38</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-03T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Sexagesimae (60 Tage vor Ostern)</Sonntag>
    <Losungstext>Wer bereitet dem Raben die Speise, wenn seine Jungen zu Gott rufen und irrefliegen, weil sie nichts zu essen haben?</Losungstext>
    <Losungsvers>Hiob 38,41</Losungsvers>
    <Lehrtext>Seht die Vögel unter dem Himmel an: sie säen nicht, sie ernten nicht, sie sammeln nicht in die Scheunen; und euer himmlischer Vater ernährt sie doch.</Lehrtext>
    <Lehrtextvers>Matthäus 6,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-04T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>HERR, du bist meine Stärke und Kraft und meine Zuflucht in der Not!</Losungstext>
    <Losungsvers>Jeremia 16,19</Losungsvers>
    <Lehrtext>Jesus sprach: Es hat mich jemand berührt; denn ich habe gespürt, dass eine Kraft von mir ausgegangen ist.</Lehrtext>
    <Lehrtextvers>Lukas 8,46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-05T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will singen von der Gnade des Herrn ewiglich und seine Treue verkünden mit meinem Munde für und für.</Losungstext>
    <Losungsvers>Psalm 89,2</Losungsvers>
    <Lehrtext>Er hat alles wohl gemacht; die Tauben macht er hörend und die Sprachlosen redend.</Lehrtext>
    <Lehrtextvers>Markus 7,37</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-06T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Himmel und Erde sind dein, du hast gegründet den Erdkreis und was darinnen ist. Nord und Süd hast du geschaffen.</Losungstext>
    <Losungsvers>Psalm 89,12-13</Losungsvers>
    <Lehrtext>Wir haben #einen# Gott, den Vater, von dem alle Dinge sind und wir zu ihm; und #einen# Herrn, Jesus Christus, durch den alle Dinge sind und wir durch ihn.</Lehrtext>
    <Lehrtextvers>1.Korinther 8,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-07T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich gehe einher in der Kraft Gottes des HERRN; ich preise deine Gerechtigkeit allein.</Losungstext>
    <Losungsvers>Psalm 71,16</Losungsvers>
    <Lehrtext>Wenn Christus auch gekreuzigt worden ist in Schwachheit, so lebt er doch in der Kraft Gottes. Und wenn wir auch schwach sind in ihm, so werden wir uns doch mit ihm lebendig erweisen an euch in der Kraft Gottes.</Lehrtext>
    <Lehrtextvers>2.Korinther 13,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-08T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>So spricht der HERR: Verflucht ist der Mann, der sich auf Menschen verlässt und weicht mit seinem Herzen vom HERRN. Gesegnet aber ist der Mann, der sich auf den HERRN verlässt und dessen Zuversicht der HERR ist.</Losungstext>
    <Losungsvers>Jeremia 17,5.7</Losungsvers>
    <Lehrtext>Wir haben an Christus Anteil bekommen, wenn wir die Zuversicht vom Anfang bis zum Ende festhalten.</Lehrtext>
    <Lehrtextvers>Hebräer 3,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-09T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will einen ewigen Bund mit meinem Volk schließen, dass ich nicht ablassen will, ihnen Gutes zu tun.</Losungstext>
    <Losungsvers>Jeremia 32,40</Losungsvers>
    <Lehrtext>Jesus nahm den Kelch nach dem Mahl und sprach: Dieser Kelch ist der neue Bund in meinem Blut, das für euch vergossen wird!</Lehrtext>
    <Lehrtextvers>Lukas 22,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-10T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Estomihi (Sei mir ein starker Fels! Psalm 31,3)</Sonntag>
    <Losungstext>Wenn nicht dein Angesicht vorangeht, so führe uns nicht von hier hinauf.</Losungstext>
    <Losungsvers>2.Mose 33,15</Losungsvers>
    <Lehrtext>Als Paulus die Erscheinung gesehen hatte, da suchten wir sogleich nach Mazedonien zu reisen, gewiss, dass uns Gott dahin berufen hatte, ihnen das Evangelium zu predigen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 16,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-11T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du, HERR, sei nicht ferne; meine Stärke, eile, mir zu helfen!</Losungstext>
    <Losungsvers>Psalm 22,20</Losungsvers>
    <Lehrtext>Der Herr ist treu; der wird euch stärken und bewahren vor dem Bösen.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 3,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-12T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR, dein Gott, der dich lehrt, was dir hilft, und dich leitet auf dem Wege, den du gehst.</Losungstext>
    <Losungsvers>Jesaja 48,17</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Ihr sollt euch nicht Lehrer nennen lassen; denn einer ist euer Lehrer: Christus.</Lehrtext>
    <Lehrtextvers>Matthäus 23,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-13T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Nun hat der HERR mir die Bitte erfüllt, die ich an ihn gerichtet hatte.</Losungstext>
    <Losungsvers>1.Samuel 1,27</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Alles, was ihr bittet in eurem Gebet, glaubt nur, dass ihr’s empfangt, so wird’s euch zuteil werden.</Lehrtext>
    <Lehrtextvers>Markus 11,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-14T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will ihr Trauern in Freude verwandeln.</Losungstext>
    <Losungsvers>Jeremia 31,13</Losungsvers>
    <Lehrtext>Unsre Trübsal, die zeitlich und leicht ist, schafft eine ewige und über alle Maßen gewichtige Herrlichkeit.</Lehrtext>
    <Lehrtextvers>2.Korinther 4,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-15T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt in Freuden ausziehen und im Frieden geleitet werden.</Losungstext>
    <Losungsvers>Jesaja 55,12</Losungsvers>
    <Lehrtext>Jesus sprach zu den Jüngern: Als ich euch ausgesandt habe ohne Geldbeutel, ohne Tasche und ohne Schuhe, habt ihr da je Mangel gehabt? Sie sprachen: Niemals.</Lehrtext>
    <Lehrtextvers>Lukas 22,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-16T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Sieh an meinen Jammer und mein Elend und vergib mir alle meine Sünden!</Losungstext>
    <Losungsvers>Psalm 25,18</Losungsvers>
    <Lehrtext>Christus hat euch mit ihm lebendig gemacht, die ihr tot wart in den Sünden und hat uns vergeben alle Sünden.</Lehrtext>
    <Lehrtextvers>Kolosser 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-17T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Invokavit (Er ruft mich an, darum will ich ihn erhören. Psalm 91,15)</Sonntag>
    <Losungstext>Wie sollte ich ein so großes Unrecht begehen und wider Gott sündigen?</Losungstext>
    <Losungsvers>1.Mose 39,9</Losungsvers>
    <Lehrtext>Wir wollen alle Last ablegen und die Sünde, die uns so leicht umgarnt. Wir wollen mit Ausdauer laufen in dem Wettlauf, der noch vor uns liegt.</Lehrtext>
    <Lehrtextvers>Hebräer 12,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-18T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gott, schweige doch nicht! Gott, bleib nicht so still und ruhig! Denn siehe, deine Feinde toben, und die dich hassen, erheben das Haupt.</Losungstext>
    <Losungsvers>Psalm 83,2-3</Losungsvers>
    <Lehrtext>Der Herr verzögert nicht die Verheißung, wie es einige für eine Verzögerung halten; sondern er hat Geduld mit euch und will nicht, dass jemand verloren werde, sondern dass jedermann zur Buße finde.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-19T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Sie gieren alle, Klein und Groß, nach unrechtem Gewinn, und Propheten und Priester gehen alle mit Lüge um und heilen den Schaden meines Volks nur obenhin, indem sie sagen: »Friede! Friede!«, und ist doch nicht Friede.</Losungstext>
    <Losungsvers>Jeremia 6,13-14</Losungsvers>
    <Lehrtext>Wir sehen darauf, dass es redlich zugehe nicht allein vor dem Herrn, sondern auch vor den Menschen.</Lehrtext>
    <Lehrtextvers>2.Korinther 8,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-20T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>/Gott spricht:/ Ich will nicht immerdar hadern und nicht ewiglich zürnen.</Losungstext>
    <Losungsvers>Jesaja 57,16</Losungsvers>
    <Lehrtext>/Jesus sprach zu dem Gelähmten:/ Mensch, deine Sünden sind dir vergeben.</Lehrtext>
    <Lehrtextvers>Lukas 5,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-21T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Meine Seele soll sich rühmen des HERRN, dass es die Elenden hören und sich freuen.</Losungstext>
    <Losungsvers>Psalm 34,3</Losungsvers>
    <Lehrtext>Lasst uns nun durch Jesus Gott allezeit das Lobopfer darbringen, das ist die Frucht der Lippen, die seinen Namen bekennen.</Lehrtext>
    <Lehrtextvers>Hebräer 13,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-22T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Unsre Seele ist entronnen wie ein Vogel dem Netze des Vogelfängers; das Netz ist zerrissen, und wir sind frei.</Losungstext>
    <Losungsvers>Psalm 124,7</Losungsvers>
    <Lehrtext>Zur Freiheit hat uns Christus befreit! So steht nun fest und lasst euch nicht wieder das Joch der Knechtschaft auflegen!</Lehrtext>
    <Lehrtextvers>Galater 5,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-23T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du durch Wasser gehst, will ich bei dir sein, dass dich die Ströme nicht ersäufen sollen; und wenn du ins Feuer gehst, sollst du nicht brennen, und die Flamme soll dich nicht versengen.</Losungstext>
    <Losungsvers>Jesaja 43,2</Losungsvers>
    <Lehrtext>Ist Gott für uns, wer kann wider uns sein?</Lehrtext>
    <Lehrtextvers>Römer 8,31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-24T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Reminiszere (Gedenke, HERR, an deine Barmherzigkeit! Psalm 25,6)</Sonntag>
    <Losungstext>Er behütete sein Volk wie seinen Augapfel.</Losungstext>
    <Losungsvers>5.Mose 32,10</Losungsvers>
    <Lehrtext>/Christus spricht:/ Nicht ihr habt mich erwählt, sondern ich habe euch erwählt und bestimmt, dass ihr hingeht und Frucht bringt.</Lehrtext>
    <Lehrtextvers>Johannes 15,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-25T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>HERR, du hast mich von den Toten heraufgeholt; du hast mich am Leben erhalten.</Losungstext>
    <Losungsvers>Psalm 30,4</Losungsvers>
    <Lehrtext>Die Jünger weckten Jesus auf und sprachen: Meister, Meister, wir kommen um! Da stand er auf und bedrohte den Wind und die Wogen des Wassers, und sie legten sich und es entstand eine Stille.</Lehrtext>
    <Lehrtextvers>Lukas 8,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-26T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Es ist dir gesagt, Mensch, was gut ist, und was der HERR von dir fordert, nämlich Gottes Wort halten und Liebe üben und demütig sein vor deinem Gott.</Losungstext>
    <Losungsvers>Micha 6,8</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Seid so unter euch gesinnt, wie es auch der Gemeinschaft in Christus Jesus entspricht.</Lehrtext>
    <Lehrtextvers>Philipper 2,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-27T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Gott hatte ihnen große Freude bereitet; auch die Frauen und Kinder freuten sich, und man vernahm den Jubel Jerusalems weithin.</Losungstext>
    <Losungsvers>Nehemia 12,43</Losungsvers>
    <Lehrtext>Alles Volk freute sich über alle herrlichen Taten, die durch Jesus geschahen.</Lehrtext>
    <Lehrtextvers>Lukas 13,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-02-28T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Des Mondes Schein wird sein wie der Sonne Schein, und der Sonne Schein wird siebenmal heller sein zu der Zeit, wenn der HERR den Schaden seines Volks verbinden und seine Wunden heilen wird.</Losungstext>
    <Losungsvers>Jesaja 30,26</Losungsvers>
    <Lehrtext>Wir wünschen, dass jeder von euch denselben Eifer beweise, die Hoffnung festzuhalten bis ans Ende.</Lehrtext>
    <Lehrtextvers>Hebräer 6,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-01T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR segne dich und behüte dich.</Losungstext>
    <Losungsvers>4.Mose 6,24</Losungsvers>
    <Lehrtext>Die Gnade des Herrn Jesus Christus sei mit eurem Geist!</Lehrtext>
    <Lehrtextvers>Philemon 25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-02T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Unter dem Schatten deiner Flügel habe ich Zuflucht, bis das Unglück vorübergehe.</Losungstext>
    <Losungsvers>Psalm 57,2</Losungsvers>
    <Lehrtext>Von der Geduld Hiobs habt ihr gehört und habt gesehen, zu welchem Ende es der Herr geführt hat; denn der Herr ist barmherzig und ein Erbarmer.</Lehrtext>
    <Lehrtextvers>Jakobus 5,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-03T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Okuli (Meine Augen sehen stets auf den HERRN. Psalm 25,15)</Sonntag>
    <Losungstext>Zu einem Volk, das meinen Namen nicht anrief, sagte ich: Hier bin ich, hier bin ich!</Losungstext>
    <Losungsvers>Jesaja 65,1</Losungsvers>
    <Lehrtext>Der Hauptmann, der dabeistand, Jesus gegenüber, und sah, dass er so verschied, sprach: Wahrlich, dieser Mensch ist Gottes Sohn gewesen!</Lehrtext>
    <Lehrtextvers>Markus 15,39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-04T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Mache dich auf, hilf uns und erlöse uns um deiner Güte willen!</Losungstext>
    <Losungsvers>Psalm 44,27</Losungsvers>
    <Lehrtext>/Christus spricht:/ Das Reich Gottes ist mitten unter euch.</Lehrtext>
    <Lehrtextvers>Lukas 17,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-05T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will auch fernerhin mit diesem Volke wunderbar verfahren, wunderbar und wundersam, und die Weisheit seiner Weisen wird zunichte werden.</Losungstext>
    <Losungsvers>Jesaja 29,14</Losungsvers>
    <Lehrtext>Gott hat dazu Zeugnis gegeben durch Zeichen, Wunder und mancherlei mächtige Taten und durch die Austeilung des Heiligen Geistes nach seinem Willen.</Lehrtext>
    <Lehrtextvers>Hebräer 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-06T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Lasst euer großes Rühmen und Trotzen; denn der HERR ist ein Gott, der es merkt, und von ihm werden Taten gewogen.</Losungstext>
    <Losungsvers>1.Samuel 2,3</Losungsvers>
    <Lehrtext>Lasst uns nicht lieben mit Worten noch mit der Zunge, sondern mit der Tat und mit der Wahrheit.</Lehrtext>
    <Lehrtextvers>1.Johannes 3,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-07T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Dein, HERR, ist die Majestät und Gewalt, Herrlichkeit, Sieg und Hoheit. Denn alles, was im Himmel und auf Erden ist, das ist dein.</Losungstext>
    <Losungsvers>1.Chronik 29,11</Losungsvers>
    <Lehrtext>Betet an den, der gemacht hat Himmel und Erde und Meer und die Wasserquellen!</Lehrtext>
    <Lehrtextvers>Offenbarung 14,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-08T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Als ich in Angst war, rief ich den HERRN an und schrie zu meinem Gott; da hörte er meine Stimme.</Losungstext>
    <Losungsvers>Psalm 18,7</Losungsvers>
    <Lehrtext>/Paulus sprach:/ Gottes Hilfe habe ich erfahren bis zum heutigen Tag und stehe nun hier und bin sein Zeuge bei Groß und Klein.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 26,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-09T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist gerecht und hat Gerechtigkeit lieb.</Losungstext>
    <Losungsvers>Psalm 11,7</Losungsvers>
    <Lehrtext>Gott ist gerecht und macht gerecht den, der aus dem Glauben an Jesus lebt.</Lehrtext>
    <Lehrtextvers>Römer 3,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-10T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Lätare (Freuet euch mit Jerusalem! Jesaja 66,10)</Sonntag>
    <Losungstext>Meine Seele verlangt nach deinem Heil; ich hoffe auf dein Wort.</Losungstext>
    <Losungsvers>Psalm 119,81</Losungsvers>
    <Lehrtext>Der Glaube ist eine feste Zuversicht auf das, was man hofft, und ein Nichtzweifeln an dem, was man nicht sieht.</Lehrtext>
    <Lehrtextvers>Hebräer 11,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-11T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich bete zu dir, HERR, zur Zeit der Gnade; Gott, nach deiner großen Güte erhöre mich mit deiner treuen Hilfe.</Losungstext>
    <Losungsvers>Psalm 69,14</Losungsvers>
    <Lehrtext>Seid beharrlich im Gebet und wacht in ihm mit Danksagung!</Lehrtext>
    <Lehrtextvers>Kolosser 4,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-12T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wohl dem, dem die Übertretungen vergeben sind, dem die Sünde bedeckt ist!</Losungstext>
    <Losungsvers>Psalm 32,1</Losungsvers>
    <Lehrtext>In Christus haben wir die Erlösung, nämlich die Vergebung der Sünden.</Lehrtext>
    <Lehrtextvers>Kolosser 1,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-13T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Die gepflanzt sind im Hause des HERRN, werden in den Vorhöfen unsres Gottes grünen. Und wenn sie auch alt werden, werden sie dennoch blühen, fruchtbar und frisch sein.</Losungstext>
    <Losungsvers>Psalm 92,14-15</Losungsvers>
    <Lehrtext>Auf dem guten Land sind die, die das Wort hören und behalten in einem feinen, guten Herzen und bringen Frucht in Geduld.</Lehrtext>
    <Lehrtextvers>Lukas 8,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-14T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wohl dem, der den HERRN fürchtet, der große Freude hat an seinen Geboten!</Losungstext>
    <Losungsvers>Psalm 112,1</Losungsvers>
    <Lehrtext>Alles, was ihr tut mit Worten oder mit Werken, das tut alles im Namen des Herrn Jesus und dankt Gott, dem Vater, durch ihn.</Lehrtext>
    <Lehrtextvers>Kolosser 3,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-15T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wenn du, HERR , Sünden anrechnen willst - HERR, wer wird bestehen?</Losungstext>
    <Losungsvers>Psalm 130,3</Losungsvers>
    <Lehrtext>In Jesus Christus haben wir die Erlösung durch sein Blut, die Vergebung der Sünden, nach dem Reichtum seiner Gnade.</Lehrtext>
    <Lehrtextvers>Epheser 1,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-16T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Er ist aus dem Lande der Lebendigen weggerissen, da er für die Missetat meines Volks geplagt war.</Losungstext>
    <Losungsvers>Jesaja 53,8</Losungsvers>
    <Lehrtext>Musste nicht Christus dies erleiden und in seine Herrlichkeit eingehen?</Lehrtext>
    <Lehrtextvers>Lukas 24,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-17T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Judika (Gott, schaffe mir Recht! Psalm 43,1)</Sonntag>
    <Losungstext>Ich bin der HERR, dein Arzt.</Losungstext>
    <Losungsvers>2.Mose 15,26</Losungsvers>
    <Lehrtext>Die Frau verkündete vor allem Volk, warum sie Jesus angerührt hatte und wie sie sogleich gesund geworden war. Er aber sprach zu ihr: Meine Tochter, dein Glaube hat dir geholfen. Geh hin in Frieden!</Lehrtext>
    <Lehrtextvers>Lukas 8,47.48</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-18T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>HERR, lehre mich doch, dass es ein Ende mit mir haben muss und mein Leben ein Ziel hat und ich davon muss.</Losungstext>
    <Losungsvers>Psalm 39,5</Losungsvers>
    <Lehrtext>Unser Bürgerrecht ist im Himmel; woher wir auch erwarten den Heiland, den Herrn Jesus Christus,</Lehrtext>
    <Lehrtextvers>Philipper 3,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-19T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du hast gesehen, dass dich der HERR, dein Gott, getragen hat, wie ein Mann seinen Sohn trägt.</Losungstext>
    <Losungsvers>5.Mose 1,31</Losungsvers>
    <Lehrtext>Wir haben erkannt und geglaubt die Liebe, die Gott zu uns hat.</Lehrtext>
    <Lehrtextvers>1.Johannes 4,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-20T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wenn sie aber zu euch sagen: Ihr müsst die Totengeister und Beschwörer befragen, so sprecht: Soll nicht ein Volk seinen Gott befragen?</Losungstext>
    <Losungsvers>Jesaja 8,19</Losungsvers>
    <Lehrtext>Christus hat die Mächte und Gewalten ihrer Macht entkleidet und sie öffentlich zur Schau gestellt und hat einen Triumph aus ihnen gemacht in Christus.</Lehrtext>
    <Lehrtextvers>Kolosser 2,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-21T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt Brot die Fülle haben und sollt sicher in eurem Lande wohnen.</Losungstext>
    <Losungsvers>3.Mose 26,5</Losungsvers>
    <Lehrtext>Jesus nahm die fünf Brote und zwei Fische und sah auf zum Himmel und dankte, brach sie und gab sie den Jüngern, damit sie dem Volk austeilten. Und sie aßen und wurden alle satt.</Lehrtext>
    <Lehrtextvers>Lukas 9,16-17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-22T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>HERR, du bist Gott, und deine Worte sind Wahrheit.</Losungstext>
    <Losungsvers>2.Samuel 7,28</Losungsvers>
    <Lehrtext>Gott, unser Heiland, will, dass allen Menschen geholfen werde und sie zur Erkenntnis der Wahrheit kommen.</Lehrtext>
    <Lehrtextvers>1.Timotheus 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-23T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist meine Stärke und mein Lobgesang und ist mein Heil.</Losungstext>
    <Losungsvers>2.Mose 15,2</Losungsvers>
    <Lehrtext>Als Jesus schon nahe am Abhang des Ölbergs war, fing die ganze Menge der Jünger an, mit Freuden Gott zu loben mit lauter Stimme über alle Taten, die sie gesehen hatten.</Lehrtext>
    <Lehrtextvers>Lukas 19,37</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-24T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Palmsonntag</Sonntag>
    <Losungstext>Ich freue mich über den Weg, den deine Mahnungen zeigen, wie über großen Reichtum.</Losungstext>
    <Losungsvers>Psalm 119,14</Losungsvers>
    <Lehrtext>Der Gott des Friedens mache euch tüchtig in allem Guten, zu tun seinen Willen, und schaffe in uns, was ihm gefällt, durch Jesus Christus, welchem sei Ehre von Ewigkeit zu Ewigkeit!</Lehrtext>
    <Lehrtextvers>Hebräer 13,20.21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-25T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Das Los ist mir gefallen auf liebliches Land; mir ist ein schönes Erbteil geworden.</Losungstext>
    <Losungsvers>Psalm 16,6</Losungsvers>
    <Lehrtext>Was ihr auch tut, tut es mit Leib und Seele, so als wäre es für den Herrn und nicht für Menschen, im Wissen, dass ihr dafür vom Herrn das Erbe empfangen werdet. Dient Christus, dem Herrn!</Lehrtext>
    <Lehrtextvers>Kolosser 3,23-24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-26T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gelobet sei der Name Gottes von Ewigkeit zu Ewigkeit, denn ihm gehören Weisheit und Stärke!</Losungstext>
    <Losungsvers>Daniel 2,20</Losungsvers>
    <Lehrtext>Wo sind die Weisen dieser Welt? Hat nicht Gott die Weisheit der Welt zur Torheit gemacht?</Lehrtext>
    <Lehrtextvers>1.Korinther 1,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-27T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Gott, der HERR, der Mächtige, redet und ruft der Welt zu vom Aufgang der Sonne bis zu ihrem Niedergang.</Losungstext>
    <Losungsvers>Psalm 50,1</Losungsvers>
    <Lehrtext>Seht zu, dass ihr den nicht abweist, der da redet.</Lehrtext>
    <Lehrtextvers>Hebräer 12,25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-28T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag>Gründonnerstag</Sonntag>
    <Losungstext>Meine Gerechtigkeit ist nahe, mein Heil tritt hervor, und meine Arme werden die Völker richten.</Losungstext>
    <Losungsvers>Jesaja 51,5</Losungsvers>
    <Lehrtext>Jesus sprach zu den Jüngern: Mich hat herzlich verlangt, dies Passalamm mit euch zu essen, ehe ich leide.</Lehrtext>
    <Lehrtextvers>Lukas 22,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-29T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag>Karfreitag</Sonntag>
    <Losungstext>Mein Herz hält dir vor dein Wort: »Ihr sollt mein Antlitz suchen.« Darum suche ich auch, HERR, dein Antlitz.</Losungstext>
    <Losungsvers>Psalm 27,8</Losungsvers>
    <Lehrtext>Jesus kam heraus und trug die Dornenkrone und das Purpurgewand. Und Pilatus spricht zu ihnen: Seht, welch ein Mensch!</Lehrtext>
    <Lehrtextvers>Johannes 19,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-30T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich wohne in der Höhe und im Heiligtum und bei denen, die zerschlagenen und demütigen Geistes sind, auf dass ich erquicke den Geist der Gedemütigten und das Herz der Zerschlagenen.</Losungstext>
    <Losungsvers>Jesaja 57,15</Losungsvers>
    <Lehrtext>Gott hat das Wort dem Volk Israel gesandt und Frieden verkündigt durch Jesus Christus, welcher ist Herr über alle.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 10,36</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-03-31T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Osterfest</Sonntag>
    <Losungstext>Seine Wahrheit ist Schirm und Schild.</Losungstext>
    <Losungsvers>Psalm 91,4</Losungsvers>
    <Lehrtext>/Die Engel sprachen die zu den Frauen:/ Was sucht ihr den Lebenden bei den Toten? Er ist nicht hier, er ist auferstanden.</Lehrtext>
    <Lehrtextvers>Lukas 24,5-6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-01T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Ostermontag</Sonntag>
    <Losungstext>Habe deine Lust am HERRN; der wird dir geben, was dein Herz wünscht.</Losungstext>
    <Losungsvers>Psalm 37,4</Losungsvers>
    <Lehrtext>Gott sei Dank für seine unaussprechliche Gabe!</Lehrtext>
    <Lehrtextvers>2.Korinther 9,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-02T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist bei mir wie ein starker Held.</Losungstext>
    <Losungsvers>Jeremia 20,11</Losungsvers>
    <Lehrtext>Ich vermag alles durch den, der mich mächtig macht.</Lehrtext>
    <Lehrtextvers>Philipper 4,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-03T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich will dem HERRN singen, dass er so wohl an mir tut.</Losungstext>
    <Losungsvers>Psalm 13,6</Losungsvers>
    <Lehrtext>Philippus taufte den Kämmerer. Als sie aber aus dem Wasser heraufstiegen, entrückte der Geist des Herrn den Philippus und der Kämmerer sah ihn nicht mehr; er zog aber seine Straße fröhlich.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 8,38-39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-04T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Tut kund unter den Völkern seine Taten, verkündet, dass sein Name erhaben ist!</Losungstext>
    <Losungsvers>Jesaja 12,4</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Wer euch hört, der hört mich; und wer euch verachtet, der verachtet mich; wer aber mich verachtet, der verachtet den, der mich gesandt hat.</Lehrtext>
    <Lehrtextvers>Lukas 10,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-05T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin der HERR, dein Gott, und du solltest keinen andern Gott kennen als mich und keinen Heiland als allein mich.</Losungstext>
    <Losungsvers>Hosea 13,4</Losungsvers>
    <Lehrtext>Das ist das ewige Leben, dass sie dich, der du allein wahrer Gott bist, und den du gesandt hast, Jesus Christus, erkennen.</Lehrtext>
    <Lehrtextvers>Johannes 17,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-06T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich bin, ehe denn ein Tag war, und niemand ist da, der aus meiner Hand erretten kann. Ich wirke; wer will’s wenden?</Losungstext>
    <Losungsvers>Jesaja 43,13</Losungsvers>
    <Lehrtext>Christus ist vor allem, und es besteht alles in ihm.</Lehrtext>
    <Lehrtextvers>Kolosser 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-07T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Quasimodogeniti (Wie die neugeborenen Kindlein. 1.Petrus 2,2)</Sonntag>
    <Losungstext>In Treue will ich mich mit dir verloben, und du wirst den HERRN erkennen.</Losungstext>
    <Losungsvers>Hosea 2,22</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ihr kennt das Wort: »Deshalb verlässt ein Mann Vater und Mutter, um mit seiner Frau zu leben. Die zwei sind dann eins, mit Leib und Seele.« In diesem Wort liegt ein tiefes Geheimnis. Ich beziehe die Aussage auf Christus und die Gemeinde.</Lehrtext>
    <Lehrtextvers>Epheser 5,31-32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-08T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>In Gottes Hand ist die Seele von allem, was lebt.</Losungstext>
    <Losungsvers>Hiob 12,10</Losungsvers>
    <Lehrtext>Gott ist nicht ferne von einem jeden unter uns. Denn in ihm leben, weben und sind wir.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 17,27-28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-09T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist seines Volkes Stärke.</Losungstext>
    <Losungsvers>Psalm 28,8</Losungsvers>
    <Lehrtext>Seid in Christus Jesus verwurzelt und gegründet und fest im Glauben, wie ihr gelehrt worden seid, und seid reichlich dankbar.</Lehrtext>
    <Lehrtextvers>Kolosser 2,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-10T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Lehre mich tun nach deinem Wohlgefallen, denn du bist mein Gott; dein guter Geist führe mich auf ebener Bahn.</Losungstext>
    <Losungsvers>Psalm 143,10</Losungsvers>
    <Lehrtext>Lasst euch nicht durch mancherlei und fremde Lehren umtreiben, denn es ist ein köstlich Ding, dass das Herz fest werde, welches geschieht durch Gnade.</Lehrtext>
    <Lehrtextvers>Hebräer 13,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-11T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Herr, ich leide Not, tritt für mich ein!</Losungstext>
    <Losungsvers>Jesaja 38,14</Losungsvers>
    <Lehrtext>Wer den Sohn hat, der hat das Leben.</Lehrtext>
    <Lehrtextvers>1.Johannes 5,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-12T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich will einige von ihnen, die errettet sind, zu den Völkern senden, wo man nichts von mir gehört hat; und sie sollen meine Herrlichkeit unter den Völkern verkündigen.</Losungstext>
    <Losungsvers>Jesaja 66,19</Losungsvers>
    <Lehrtext>/Christus spricht:/ Gehet hin in alle Welt und predigt das Evangelium aller Kreatur.</Lehrtext>
    <Lehrtextvers>Markus 16,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-13T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Liebet den HERRN, alle seine Heiligen!</Losungstext>
    <Losungsvers>Psalm 31,24</Losungsvers>
    <Lehrtext>Die Liebe freut sich nicht über die Ungerechtigkeit, sie freut sich aber an der Wahrheit.</Lehrtext>
    <Lehrtextvers>1.Korinther 13,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-14T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Miserikordias Domini (Die Erde ist voll der Güte des HERRN. Psalm 33,5)</Sonntag>
    <Losungstext>Halte meine Augen davon ab, nach Nichtigem zu schauen.</Losungstext>
    <Losungsvers>Psalm 119,37</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Was siehst du den Splitter in deines Bruders Auge und den Balken in deinem Auge nimmst du nicht wahr?</Lehrtext>
    <Lehrtextvers>Lukas 6,41</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-15T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wer meine Gebote hält und nach meinen Gesetzen lebt, der soll nicht sterben um der Schuld seines Vaters willen.</Losungstext>
    <Losungsvers>Hesekiel 18,17</Losungsvers>
    <Lehrtext>Leben wir, so leben wir dem Herrn; sterben wir, so sterben wir dem Herrn. Darum: wir leben oder sterben, so sind wir des Herrn.</Lehrtext>
    <Lehrtextvers>Römer 14,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-16T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Es soll nicht durch Heer oder Kraft, sondern durch meinen Geist geschehen, spricht der HERR Zebaoth.</Losungstext>
    <Losungsvers>Sacharja 4,6</Losungsvers>
    <Lehrtext>Jage der Gerechtigkeit nach, dem Glauben, der Liebe, dem Frieden mit allen, die den Herrn anrufen aus reinem Herzen.</Lehrtext>
    <Lehrtextvers>2.Timotheus 2,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-17T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wenn ich dich anrufe, so erhörst du mich und gibst meiner Seele große Kraft.</Losungstext>
    <Losungsvers>Psalm 138,3</Losungsvers>
    <Lehrtext>Es ist über alle derselbe Herr, reich für alle, die ihn anrufen.</Lehrtext>
    <Lehrtextvers>Römer 10,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-18T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du nahtest dich zu mir, als ich dich anrief, und sprachst: Fürchte dich nicht!</Losungstext>
    <Losungsvers>Klagelieder 3,57</Losungsvers>
    <Lehrtext>Der Herr hat gesagt: »Ich will dich nicht verlassen und nicht von dir weichen.« So können auch wir getrost sagen: »Der Herr ist mein Helfer, ich will mich nicht fürchten; was kann mir ein Mensch tun?«</Lehrtext>
    <Lehrtextvers>Hebräer 13,5-6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-19T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst dem Tauben nicht fluchen und sollst vor den Blinden kein Hindernis legen, denn du sollst dich vor deinem Gott fürchten.</Losungstext>
    <Losungsvers>3.Mose 19,14</Losungsvers>
    <Lehrtext>Gott hat uns nicht berufen zur Unreinheit, sondern zur Heiligung. Wer das nun verachtet, der verachtet nicht Menschen, sondern Gott, der seinen Heiligen Geist in euch gibt.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 4,7-8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-20T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gott tut große Dinge, die wir nicht begreifen.</Losungstext>
    <Losungsvers>Hiob 37,5</Losungsvers>
    <Lehrtext>Jesus sprach: Blinde sehen, Lahme gehen, Aussätzige werden rein, Taube hören, Tote stehen auf, Armen wird das Evangelium gepredigt; und selig ist, wer sich nicht ärgert an mir.</Lehrtext>
    <Lehrtextvers>Lukas 7,22-23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-21T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Jubilate (Jauchzet Gott, alle Lande! Psalm 66,1)</Sonntag>
    <Losungstext>Der HERR denkt an uns und segnet uns.</Losungstext>
    <Losungsvers>Psalm 115,12</Losungsvers>
    <Lehrtext>Wenn Gott das Gras, das heute auf dem Feld steht und morgen in den Ofen geworfen wird, so kleidet, wie viel mehr wird er euch kleiden, ihr Kleingläubigen!</Lehrtext>
    <Lehrtextvers>Lukas 12,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-22T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich will unter euch wandeln und will euer Gott sein, und ihr sollt mein Volk sein.</Losungstext>
    <Losungsvers>3.Mose 26,12</Losungsvers>
    <Lehrtext>Es hat Gott wohlgefallen, dass in Christus alle Fülle wohnen sollte.</Lehrtext>
    <Lehrtextvers>Kolosser 1,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-23T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn dein Wort offenbar wird, so erfreut es und macht klug die Unverständigen.</Losungstext>
    <Losungsvers>Psalm 119,130</Losungsvers>
    <Lehrtext>Darum sollen wir desto mehr achten auf das Wort, das wir hören, damit wir nicht am Ziel vorbeitreiben.</Lehrtext>
    <Lehrtextvers>Hebräer 2,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-24T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Er dachte an uns, als wir unterdrückt waren, denn seine Güte währet ewiglich.</Losungstext>
    <Losungsvers>Psalm 136,23</Losungsvers>
    <Lehrtext>/Paulus sprach:/ Wenn wir heute wegen der Wohltat an einem kranken Menschen verhört und gefragt werden, wodurch dieser gerettet worden sei, dann sei euch allen und dem ganzen Volk Israel kundgetan: Durch den Namen Jesu Christi.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 4,9-10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-25T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist meines Lebens Kraft; vor wem sollte mir grauen?</Losungstext>
    <Losungsvers>Psalm 27,1</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Ihr Kleingläubigen, warum seid ihr so furchtsam?</Lehrtext>
    <Lehrtextvers>Matthäus 8,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-26T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist gerecht in allen seinen Wegen und gnädig in allen seinen Werken.</Losungstext>
    <Losungsvers>Psalm 145,17</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich bin darin guter Zuversicht, dass der in euch angefangen hat das gute Werk, der wird's auch vollenden bis an den Tag Christi Jesu.</Lehrtext>
    <Lehrtextvers>Philipper 1,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-27T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will mit euch einen ewigen Bund schließen.</Losungstext>
    <Losungsvers>Jesaja 55,3</Losungsvers>
    <Lehrtext>Werdet nicht träge, sondern Nachfolger derer, die durch Glauben und Geduld die Verheißungen ererben.</Lehrtext>
    <Lehrtextvers>Hebräer 6,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-28T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Kantate (Singet dem HERRN ein neues Lied! Psalm 98,1)</Sonntag>
    <Losungstext>Wer weiß? Vielleicht lässt Gott es sich gereuen und wendet sich ab von seinem grimmigen Zorn, dass wir nicht verderben.</Losungstext>
    <Losungsvers>Jona 3,9</Losungsvers>
    <Lehrtext>Gott hat uns nicht bestimmt zum Zorn, sondern dazu, das Heil zu erlangen durch unsern Herrn Jesus Christus, der für uns gestorben ist, damit, ob wir wachen oder schlafen, wir zugleich mit ihm leben.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,9-10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-29T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst dein Herz nicht verhärten und deine Hand nicht zuhalten gegenüber deinem armen Bruder.</Losungstext>
    <Losungsvers>5.Mose 15,7</Losungsvers>
    <Lehrtext>/Paulus sprach:/ Ich habe euch in allem gezeigt, dass man so arbeiten und sich der Schwachen annehmen muss im Gedenken an das Wort des Herrn Jesus, der selbst gesagt hat: Geben ist seliger als nehmen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 20,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-04-30T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>So hört nun ihr, die ihr ferne seid, was ich getan habe, und die ihr nahe seid, erkennt meine Stärke!</Losungstext>
    <Losungsvers>Jesaja 33,13</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wir wissen, dass ihr erwählt seid; denn unsere Predigt des Evangeliums kam zu euch nicht allein im Wort, sondern auch in der Kraft und in dem Heiligen Geist und in großer Gewissheit.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 1,4-5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-01T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Haltet meine Gebote und tut danach; ich bin der HERR.</Losungstext>
    <Losungsvers>3.Mose 22,31</Losungsvers>
    <Lehrtext>Einer trage des andern Last, so werdet ihr das Gesetz Christi erfüllen.</Lehrtext>
    <Lehrtextvers>Galater 6,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-02T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Deine Gnade soll mein Trost sein, wie du deinem Knecht zugesagt hast.</Losungstext>
    <Losungsvers>Psalm 119,76</Losungsvers>
    <Lehrtext>Wie die Leiden Christi reichlich über uns kommen, so werden wir auch reichlich getröstet durch Christus.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-03T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>HERR, deine Güte ist ewig. Das Werk deiner Hände wollest du nicht lassen.</Losungstext>
    <Losungsvers>Psalm 138,8</Losungsvers>
    <Lehrtext>Wir sind sein Werk, geschaffen in Christus Jesus zu guten Werken, die Gott zuvor bereitet hat, dass wir darin wandeln sollen.</Lehrtext>
    <Lehrtextvers>Epheser 2,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-04T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der das Ohr gepflanzt hat, sollte der nicht hören? Der das Auge gemacht hat, sollte der nicht sehen?</Losungstext>
    <Losungsvers>Psalm 94,9</Losungsvers>
    <Lehrtext>Unter den Jüngern kam der Gedanke auf, wer von ihnen der Größte sei. Als aber Jesus den Gedanken ihres Herzens erkannte, nahm er ein Kind und stellte es neben sich und sprach zu ihnen: Wer dieses Kind aufnimmt in meinem Namen, der nimmt mich auf.</Lehrtext>
    <Lehrtextvers>Lukas 9,46-48</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-05T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Rogate (Betet!)</Sonntag>
    <Losungstext>Mögt ihr zürnen, nur sündiget nicht!</Losungstext>
    <Losungsvers>Psalm 4,5</Losungsvers>
    <Lehrtext>Lasst die Sonne nicht über eurem Zorn untergehen</Lehrtext>
    <Lehrtextvers>Epheser 4,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-06T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst dich nicht durch Geschenke bestechen lassen; denn Geschenke machen die Sehenden blind und verdrehen die Sache derer, die im Recht sind.</Losungstext>
    <Losungsvers>2.Mose 23,8</Losungsvers>
    <Lehrtext>Die Gnade Gottes ist erschienen, allen Menschen zum Heil. Sie erzieht uns dazu, der Gottlosigkeit und den Begierden der Welt abzuschwören und besonnen, gerecht und fromm zu leben in dieser Weltzeit.</Lehrtext>
    <Lehrtextvers>Titus 2,11-12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-07T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Betrachte das Buch des Gesetzes Tag und Nacht, dass du es hältst und tust in allen Dingen.</Losungstext>
    <Losungsvers>Josua 1,8</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Es werden nicht alle, die zu mir sagen: Herr, Herr!, in das Himmelreich kommen, sondern die den Willen tun meines Vaters im Himmel.</Lehrtext>
    <Lehrtextvers>Matthäus 7,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-08T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ein Ochse kennt seinen Herrn und ein Esel die Krippe seines Herrn; aber mein Volk versteht’s nicht.</Losungstext>
    <Losungsvers>Jesaja 1,3</Losungsvers>
    <Lehrtext>Werdet nicht unverständig, sondern versteht, was der Wille des Herrn ist.</Lehrtext>
    <Lehrtextvers>Epheser 5,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-09T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag>Himmelfahrt des Herrn</Sonntag>
    <Losungstext>Ich will ihnen einerlei Sinn und einerlei Wandel geben, dass sie mich fürchten ihr Leben lang.</Losungstext>
    <Losungsvers>Jeremia 32,39</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Es ist gut für euch, dass ich weggehe. Denn wenn ich nicht weggehe, kommt der Tröster nicht zu euch. Wenn ich aber gehe, will ich ihn zu euch senden.</Lehrtext>
    <Lehrtextvers>Johannes 16,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-10T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hat die Erde durch seine Kraft gemacht und den Himmel ausgebreitet durch seinen Verstand.</Losungstext>
    <Losungsvers>Jeremia 10,12</Losungsvers>
    <Lehrtext>Durch den Glauben erkennen wir, dass die Welt durch Gottes Wort geschaffen ist, sodass alles, was man sieht, aus nichts geworden ist.</Lehrtext>
    <Lehrtextvers>Hebräer 11,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-11T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>O Land, Land, Land, höre des HERRN Wort!</Losungstext>
    <Losungsvers>Jeremia 22,29</Losungsvers>
    <Lehrtext>Lasst das Wort Christi reichlich unter euch wohnen.</Lehrtext>
    <Lehrtextvers>Kolosser 3,16a</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-12T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Exaudi (HERR, höre meine Stimme! Psalm 27,7)</Sonntag>
    <Losungstext>Er hat für die Übeltäter gebeten.</Losungstext>
    <Losungsvers>Jesaja 53,12</Losungsvers>
    <Lehrtext>Sie kreuzigten Jesus und die Übeltäter mit ihm, einen zur Rechten und einen zur Linken. Jesus aber sprach: Vater, vergib ihnen; denn sie wissen nicht, was sie tun!</Lehrtext>
    <Lehrtextvers>Lukas 23,33-34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-13T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Züchtige mich, HERR, doch mit Maßen und nicht in deinem Grimm, auf dass du mich nicht ganz zunichte machst.</Losungstext>
    <Losungsvers>Jeremia 10,24</Losungsvers>
    <Lehrtext>Gott ist treu, der euch nicht versuchen lässt über eure Kraft, sondern macht, dass die Versuchung so ein Ende nimmt, dass ihr's ertragen könnt.</Lehrtext>
    <Lehrtextvers>1.Korinther 10,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-14T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du, unser Gott, bist gerecht bei allem, was über uns gekommen ist; denn du hast Treue geübt, wir aber sind gottlos gewesen.</Losungstext>
    <Losungsvers>Nehemia 9,33</Losungsvers>
    <Lehrtext>Wenn wir unsre Sünden bekennen, so ist er treu und gerecht, dass er uns die Sünden vergibt und reinigt uns von aller Ungerechtigkeit.</Lehrtext>
    <Lehrtextvers>1.Johannes 1,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-15T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wie soll ich dem HERRN vergelten all seine Wohltat, die er an mir tut?</Losungstext>
    <Losungsvers>Psalm 116,12</Losungsvers>
    <Lehrtext>Jesus sprach zu dem Geheilten: Geh wieder heim und sage, wie große Dinge Gott an dir getan hat. Und er ging hin und verkündigte überall in der Stadt, wie große Dinge Jesus an ihm getan hatte.</Lehrtext>
    <Lehrtextvers>Lukas 8,39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-16T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will Frieden geben an dieser Stätte, spricht der HERR Zebaoth.</Losungstext>
    <Losungsvers>Haggai 2,9</Losungsvers>
    <Lehrtext>Durch Christus hat Gott alles mit sich versöhnt, es sei auf Erden oder im Himmel, indem er Frieden machte durch sein Blut am Kreuz.</Lehrtext>
    <Lehrtextvers>Kolosser 1,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-17T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hilft denen, die ein zerschlagenes Gemüt haben.</Losungstext>
    <Losungsvers>Psalm 34,19</Losungsvers>
    <Lehrtext>Der Zöllner stand ferne, wollte auch die Augen nicht aufheben zum Himmel, sondern schlug an seine Brust und sprach: Gott, sei mir Sünder gnädig!</Lehrtext>
    <Lehrtextvers>Lukas 18,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-18T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Denk an deinen Schöpfer in deiner Jugend, ehe die bösen Tage kommen und die Jahre sich nahen, da du wirst sagen: »Sie gefallen mir nicht.«</Losungstext>
    <Losungsvers>Prediger 12,1</Losungsvers>
    <Lehrtext>Es ist alles durch ihn und zu ihm geschaffen.</Lehrtext>
    <Lehrtextvers>Kolosser 1,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-19T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Pfingstfest</Sonntag>
    <Losungstext>Sie verwandelten die Herrlichkeit ihres Gottes in das Bild eines Ochsen, der Gras frisst.</Losungstext>
    <Losungsvers>Psalm 106,20</Losungsvers>
    <Lehrtext>Petrus sprach: Tut Buße und jeder von euch lasse sich taufen auf den Namen Jesu Christi zur Vergebung eurer Sünden, so werdet ihr empfangen die Gabe des Heiligen Geistes.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 2,38</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-20T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Pfingstmontag</Sonntag>
    <Losungstext>Der du mich tröstest in Angst, sei mir gnädig und erhöre mein Gebet!</Losungstext>
    <Losungsvers>Psalm 4,2</Losungsvers>
    <Lehrtext>/Jesus sprach zu Petrus:/ Ich aber habe für dich gebeten, dass dein Glaube nicht aufhöre.</Lehrtext>
    <Lehrtextvers>Lukas 22,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-21T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hat mich gesandt, zu trösten alle Trauernden.</Losungstext>
    <Losungsvers>Jesaja 61,1.2</Losungsvers>
    <Lehrtext>Gott tröstet uns in aller unserer Trübsal, damit wir auch trösten können, die in allerlei Trübsal sind, mit dem Trost, mit dem wir selber getröstet werden von Gott.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-22T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Vor dir ist Freude die Fülle und Wonne zu deiner Rechten ewiglich.</Losungstext>
    <Losungsvers>Psalm 16,11</Losungsvers>
    <Lehrtext>Herr, wohin sollen wir gehen? Du hast Worte des ewigen Lebens.</Lehrtext>
    <Lehrtextvers>Johannes 6,68</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-23T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Alles Fleisch ist Gras, und alle seine Güte ist wie eine Blume auf dem Felde. Das Gras verdorrt, die Blume verwelkt, aber das Wort unseres Gottes bleibt ewiglich.</Losungstext>
    <Losungsvers>Jesaja 40,6.8</Losungsvers>
    <Lehrtext>/Christus spricht:/ Himmel und Erde werden vergehen; aber meine Worte vergehen nicht.</Lehrtext>
    <Lehrtextvers>Lukas 21,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-24T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Nicht uns, HERR, nicht uns, sondern deinem Namen gib Ehre um deiner Gnade und Treue willen!</Losungstext>
    <Losungsvers>Psalm 115,1</Losungsvers>
    <Lehrtext>Jesus sprach: Wenn ihr betet, so sprecht: Vater! Dein Name werde geheiligt.</Lehrtext>
    <Lehrtextvers>Lukas 11,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-25T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR hat Zion mit Recht und Gerechtigkeit erfüllt. Und du wirst sichere Zeiten haben: Reichtum an Heil, Weisheit und Klugheit.</Losungstext>
    <Losungsvers>Jesaja 33,5-6</Losungsvers>
    <Lehrtext>Von seiner Fülle haben wir alle genommen Gnade um Gnade.</Lehrtext>
    <Lehrtextvers>Johannes 1,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-26T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Trinitatis (Dreieinigkeit)</Sonntag>
    <Losungstext>Männer werden müde und matt, und Jünglinge straucheln und fallen; aber die auf den HERRN harren, kriegen neue Kraft, dass sie auffahren mit Flügeln wie Adler, dass sie laufen und nicht matt werden.</Losungstext>
    <Losungsvers>Jesaja 40,30-31</Losungsvers>
    <Lehrtext>Gott ist’s, der in euch wirkt beides, das Wollen und das Vollbringen, nach seinem Wohlgefallen.</Lehrtext>
    <Lehrtextvers>Philipper 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-27T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Merkt auf mich, ihr Völker, und ihr Menschen, hört mir zu! Denn Weisung wird von mir ausgehen, und mein Recht will ich gar bald zum Licht der Völker machen.</Losungstext>
    <Losungsvers>Jesaja 51,4</Losungsvers>
    <Lehrtext>/Paulus sprach/ Ich sage nichts anderes, als was nach den Worten der Propheten und des Mose geschehen musste: dass nämlich der Gesalbte leiden muss und dass er als Erster von den Toten auferstehen und dem Volk und allen Völkern das Licht verkündigen wird.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 26,22-23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-28T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wer kann merken, wie oft er fehlet? Verzeihe mir die verborgenen Sünden!</Losungstext>
    <Losungsvers>Psalm 19,13</Losungsvers>
    <Lehrtext>Als aber erschien die Freundlichkeit und Menschenliebe Gottes, unseres Heilands, machte er uns selig - nicht um der Werke der Gerechtigkeit willen, die wir getan hatten, sondern nach seiner Barmherzigkeit.</Lehrtext>
    <Lehrtextvers>Titus 3,4-5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-29T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist nahe denen, die zerbrochenen Herzens sind.</Losungstext>
    <Losungsvers>Psalm 34,19</Losungsvers>
    <Lehrtext>/Christus sprach zu Maria:/ Frau, was weinst du? Wen suchst du?</Lehrtext>
    <Lehrtextvers>Johannes 20,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-30T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich gab ihnen meine Gebote und lehrte sie meine Gesetze, durch die der Mensch lebt, der sie hält.</Losungstext>
    <Losungsvers>Hesekiel 20,11</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Ihr sollt nicht meinen, dass ich gekommen bin, das Gesetz oder die Propheten aufzulösen; ich bin nicht gekommen aufzulösen, sondern zu erfüllen.</Lehrtext>
    <Lehrtextvers>Matthäus 5,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-05-31T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Nun, unser Gott, wir danken dir und rühmen deinen herrlichen Namen.</Losungstext>
    <Losungsvers>1.Chronik 29,13</Losungsvers>
    <Lehrtext>Wie ihr nun den Herrn Christus Jesus angenommen habt, so lebt auch in ihm.</Lehrtext>
    <Lehrtextvers>Kolosser 2,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-01T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der Himmel wird wie ein Rauch vergehen und die Erde wie ein Kleid zerfallen, und die darauf wohnen, werden wie Mücken dahinsterben. Aber mein Heil bleibt ewiglich.</Losungstext>
    <Losungsvers>Jesaja 51,6</Losungsvers>
    <Lehrtext>/Der Seher Johannes schreibt:/ Ich hörte eine große Stimme von dem Thron her, die sprach: Siehe da, die Hütte Gottes bei den Menschen! Und er wird bei ihnen wohnen, und sie werden sein Volk sein und er selbst, Gott mit ihnen, wird ihr Gott sein.</Lehrtext>
    <Lehrtextvers>Offenbarung 21,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-02T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Er wird herrlich werden, so weit die Welt ist.</Losungstext>
    <Losungsvers>Micha 5,3</Losungsvers>
    <Lehrtext>Alle Zungen sollen bekennen, dass Jesus Christus der Herr ist, zur Ehre Gottes, des Vaters.</Lehrtext>
    <Lehrtextvers>Philipper 2,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-03T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, der Himmel und aller Himmel Himmel und die Erde und alles, was darinnen ist, das ist des HERRN, deines Gottes.</Losungstext>
    <Losungsvers>5.Mose 10,14</Losungsvers>
    <Lehrtext>Gott hat zu uns geredet durch den Sohn, den er eingesetzt hat zum Erben über alles, durch den er auch die Welt gemacht hat.</Lehrtext>
    <Lehrtextvers>Hebräer 1,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-04T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird vor euch herziehen und der Gott Israels euren Zug beschließen.</Losungstext>
    <Losungsvers>Jesaja 52,12</Losungsvers>
    <Lehrtext>Paulus und Barnabas berichteten, was Gott alles durch sie getan und dass er allen Völkern die Tür zum Glauben aufgetan habe.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 14,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-05T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Unsre Missetat drückt uns hart; du wollest unsre Sünde vergeben.</Losungstext>
    <Losungsvers>Psalm 65,4</Losungsvers>
    <Lehrtext>Gott hat den Schuldbrief getilgt, der mit seinen Forderungen gegen uns war, und hat ihn weggetan und an das Kreuz geheftet.</Lehrtext>
    <Lehrtextvers>Kolosser 2,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-06T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Warum zählt ihr Geld dar für das, was kein Brot ist, und sauren Verdienst für das, was nicht satt macht? Hört doch auf mich, so werdet ihr Gutes essen.</Losungstext>
    <Losungsvers>Jesaja 55,2</Losungsvers>
    <Lehrtext>Als Jesus mit ihnen zu Tisch saß, nahm er das Brot, dankte, brach’s und gab’s ihnen. Da wurden ihre Augen geöffnet und sie erkannten ihn.</Lehrtext>
    <Lehrtextvers>Lukas 24,30-31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-07T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Alles, was der HERR will, das tut er im Himmel und auf Erden, im Meer und in allen Tiefen.</Losungstext>
    <Losungsvers>Psalm 135,6</Losungsvers>
    <Lehrtext>Wollen wir den Herrn herausfordern? Sind wir stärker als er?</Lehrtext>
    <Lehrtextvers>1.Korinther 10,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-08T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Tu mir kund den Weg, den ich gehen soll; denn mich verlangt nach dir.</Losungstext>
    <Losungsvers>Psalm 143,8</Losungsvers>
    <Lehrtext>Jesus sah einen Zöllner mit Namen Levi am Zoll sitzen und sprach zu ihm: Folge mir nach! Und er verließ alles, stand auf und folgte ihm nach.</Lehrtext>
    <Lehrtextvers>Lukas 5,27-28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-09T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>2. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Was bin ich? Was ist mein Volk, dass wir freiwillig so viel zu geben vermochten? Von dir ist alles gekommen, und von deiner Hand haben wir dir's gegeben.</Losungstext>
    <Losungsvers>1.Chronik 29,14</Losungsvers>
    <Lehrtext>Dient einander, ein jeder mit der Gabe, die er empfangen hat, als die guten Haushalter der mancherlei Gnade Gottes.</Lehrtext>
    <Lehrtextvers>1.Petrus 4,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-10T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Des Menschen Herz erdenkt sich seinen Weg; aber der HERR allein lenkt seinen Schritt.</Losungstext>
    <Losungsvers>Sprüche 16,9</Losungsvers>
    <Lehrtext>Der reiche Mensch sprach: Ich will meine Scheunen abbrechen und größere bauen. Aber Gott sprach zu ihm: Du Narr! Diese Nacht wird man deine Seele von dir fordern; und wem wird dann gehören, was du angehäuft hast?</Lehrtext>
    <Lehrtextvers>Lukas 12,18.20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-11T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Seine Macht ist ewig und vergeht nicht.</Losungstext>
    <Losungsvers>Daniel 7,14</Losungsvers>
    <Lehrtext>Jesus Christus gestern und heute und derselbe auch in Ewigkeit.</Lehrtext>
    <Lehrtextvers>Hebräer 13,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-12T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Halleluja! Ich danke dem HERRN von ganzem Herzen im Rate der Frommen und in der Gemeinde.</Losungstext>
    <Losungsvers>Psalm 111,1</Losungsvers>
    <Lehrtext>Lehrt und ermahnt einander in aller Weisheit; mit Psalmen, Lobgesängen und geistlichen Liedern singt Gott dankbar in euren Herzen.</Lehrtext>
    <Lehrtextvers>Kolosser 3,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-13T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>HERR, du bist unser Gott, gegen dich vermag kein Mensch etwas.</Losungstext>
    <Losungsvers>2.Chronik 14,10</Losungsvers>
    <Lehrtext>Ihr habt nicht einen knechtischen Geist empfangen, dass ihr euch abermals fürchten müsstet; sondern ihr habt einen kindlichen Geist empfangen, durch den wir rufen: Abba, lieber Vater!</Lehrtext>
    <Lehrtextvers>Römer 8,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-14T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ging vorüber: ein großer, gewaltiger Sturm, der Berge zerriss und Felsen zerbrach, kam vor dem HERRN her; aber der HERR war nicht im Sturm. Nach dem Sturm ein Erdbeben; aber der HERR war nicht im Erdbeben. Nach dem Erdbeben ein Feuer; aber der HERR war nicht im Feuer. Nach dem Feuer das Flüstern eines leisen Wehens.</Losungstext>
    <Losungsvers>1.Könige 19,11-12</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Was ich euch sage, das sage ich allen: Wachet!</Lehrtext>
    <Lehrtextvers>Markus 13,37</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-15T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du, Gott, vergabst und warst gnädig, barmherzig, geduldig und von großer Güte.</Losungstext>
    <Losungsvers>Nehemia 9,17</Losungsvers>
    <Lehrtext>Vergib uns unsre Sünden; denn auch wir vergeben allen, die an uns schuldig werden.</Lehrtext>
    <Lehrtextvers>Lukas 11,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-16T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>3. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Gottes Zeichen sind groß, und seine Wunder sind mächtig, und sein Reich ist ein ewiges Reich, und seine Herrschaft währet für und für.</Losungstext>
    <Losungsvers>Daniel 3,33</Losungsvers>
    <Lehrtext>Gott wirkte nicht geringe Taten durch die Hände des Paulus.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 19,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-17T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Amos sprach: Ich bin ein Hirt, der Maulbeeren züchtet. Aber der HERR nahm mich von der Herde und sprach zu mir: Geh hin und weissage meinem Volk Israel!</Losungstext>
    <Losungsvers>Amos 7,14-15</Losungsvers>
    <Lehrtext>Jesus sprach zu Simon: Fürchte dich nicht! Von nun an wirst du Menschen fangen.</Lehrtext>
    <Lehrtextvers>Lukas 5,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-18T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du hast mir meine Klage verwandelt in einen Reigen, du hast mir den Sack der Trauer ausgezogen und mich mit Freude gegürtet.</Losungstext>
    <Losungsvers>Psalm 30,12</Losungsvers>
    <Lehrtext>Als Jesus die verkrümmte Frau sah, rief er sie zu sich und sprach zu ihr: Frau, sei frei von deiner Krankheit! Und legte die Hände auf sie; und sogleich richtete sie sich auf und pries Gott.</Lehrtext>
    <Lehrtextvers>Lukas 13,12-13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-19T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Danket dem HERRN und rufet an seinen Namen; verkündigt sein Tun unter den Völkern!</Losungstext>
    <Losungsvers>Psalm 105,1</Losungsvers>
    <Lehrtext>/Paulus sprach:/ Ich achte mein Leben nicht der Rede wert, wenn ich nur meinen Lauf vollende und das Amt ausrichte, das ich von dem Herrn Jesus empfangen habe, zu bezeugen das Evangelium von der Gnade Gottes.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 20,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-20T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>HERR, lass den Geringen nicht beschämt davongehen.</Losungstext>
    <Losungsvers>Psalm 74,21</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Was ihr getan habt einem von diesen meinen geringsten Brüdern, das habt ihr mir getan.</Lehrtext>
    <Lehrtextvers>Matthäus 25,40</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-21T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird sein Volk nicht verstoßen noch sein Erbe verlassen.</Losungstext>
    <Losungsvers>Psalm 94,14</Losungsvers>
    <Lehrtext>Gott hat sein Volk nicht verstoßen, das er zuvor erwählt hat.</Lehrtext>
    <Lehrtextvers>Römer 11,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-22T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du krönst das Jahr mit deinem Gut.</Losungstext>
    <Losungsvers>Psalm 65,12</Losungsvers>
    <Lehrtext>Gott hat sich nicht unbezeugt gelassen, hat viel Gutes getan und euch vom Himmel Regen und fruchtbare Zeiten gegeben, hat euch ernährt und eure Herzen mit Freude erfüllt.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 14,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-23T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>4. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Sie stimmten den Lobpreis an und dankten dem HERRN: Denn er ist gütig, und seine Barmherzigkeit währt ewiglich.</Losungstext>
    <Losungsvers>Esra 3,11</Losungsvers>
    <Lehrtext>Sie waren täglich einmütig beieinander im Tempel und brachen das Brot hier und dort in den Häusern, hielten die Malzeiten mit Freude und lauterem Herzen und lobten Gott und fanden Wohlgefallen beim ganzen Volk.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 2,46.47</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-24T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag>Johannistag</Sonntag>
    <Losungstext>Die Himmel erzählen die Ehre Gottes.</Losungstext>
    <Losungsvers>Psalm 19,2</Losungsvers>
    <Lehrtext>Als Jesus getauft worden war, da tat sich der Himmel auf, und der Heilige Geist fuhr hernieder auf ihn in leiblicher Gestalt wie eine Taube, und eine Stimme kam aus dem Himmel: Du bist mein lieber Sohn, an dir habe ich Wohlgefallen.</Lehrtext>
    <Lehrtextvers>Lukas 3,21.22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-25T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Wasche mich rein von meiner Missetat, und reinige mich von meiner Sünde.</Losungstext>
    <Losungsvers>Psalm 51,4</Losungsvers>
    <Lehrtext>Der Herr Jesus Christus hat sich selbst für unsre Sünden dahingegeben, dass er uns errette von dieser gegenwärtigen, bösen Welt nach dem Willen Gottes, unseres Vaters.</Lehrtext>
    <Lehrtextvers>Galater 1,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-26T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR sprach zu Mose: Du hast Gnade vor meinen Augen gefunden, und ich kenne dich mit Namen.</Losungstext>
    <Losungsvers>2.Mose 33,17</Losungsvers>
    <Lehrtext>Das Fundament Gottes wankt nicht, und es trägt das Siegel mit der Aufschrift: Der Herr kennt die Seinen.</Lehrtext>
    <Lehrtextvers>2.Timotheus 2,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-27T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Erforsche mich, Gott, und erkenne mein Herz; prüfe mich und erkenne, wie ich’s meine. Und sieh, ob ich auf bösem Wege bin, und leite mich auf ewigem Wege.</Losungstext>
    <Losungsvers>Psalm 139,23-24</Losungsvers>
    <Lehrtext>Petrus sprach: Herr, du weißt alle Dinge, du weißt, dass ich dich lieb habe. Spricht Jesus zu ihm: Weide meine Schafe!</Lehrtext>
    <Lehrtextvers>Johannes 21,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-28T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich erkenne, dass du alles vermagst, und nichts, das du dir vorgenommen, ist dir zu schwer.</Losungstext>
    <Losungsvers>Hiob 42,2</Losungsvers>
    <Lehrtext>Jesus sprach: Was bei den Menschen unmöglich ist, das ist bei Gott möglich.</Lehrtext>
    <Lehrtextvers>Lukas 18,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-29T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wenn mein Geist in Ängsten ist, so nimmst du dich meiner an.</Losungstext>
    <Losungsvers>Psalm 142,4</Losungsvers>
    <Lehrtext>/Jesus sprach:/ So nehmt nun zu Herzen, dass ihr euch nicht vorher sorgt, wie ihr euch verantworten sollt. Denn ich will euch Mund und Weisheit geben, der alle eure Gegner nicht widerstehen noch widersprechen können.</Lehrtext>
    <Lehrtextvers>Lukas 21,14-15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-06-30T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>5. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Ich lasse dich nicht, du segnest mich denn.</Losungstext>
    <Losungsvers>1.Mose 32,27</Losungsvers>
    <Lehrtext>Gott hat seinen Knecht Jesus erweckt und hat ihn zu euch gesandt, euch zu segnen, dass ein jeder sich bekehre von seiner Bosheit.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 3,26</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-01T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich will euch erlösen, dass ihr ein Segen sein sollt.</Losungstext>
    <Losungsvers>Sacharja 8,13</Losungsvers>
    <Lehrtext>Vergeltet nicht Böses mit Bösem oder Scheltwort mit Scheltwort, sondern segnet vielmehr, weil ihr dazu berufen seid, dass ihr den Segen ererbt.</Lehrtext>
    <Lehrtextvers>1.Petrus 3,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-02T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gott ist mein Fels, meine Hilfe und mein Schutz, dass ich nicht fallen werde.</Losungstext>
    <Losungsvers>Psalm 62,7</Losungsvers>
    <Lehrtext>Darum seid fest, unerschütterlich und nehmt immer zu in dem Werk des Herrn, weil ihr wisst, dass eure Arbeit nicht vergeblich ist in dem Herrn.</Lehrtext>
    <Lehrtextvers>1. Korinther 15,58</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-03T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich, der HERR, habe dich gerufen in Gerechtigkeit und halte dich bei der Hand und behüte dich.</Losungstext>
    <Losungsvers>Jesaja 42,6</Losungsvers>
    <Lehrtext>Wer will uns scheiden von der Liebe Christi? Trübsal oder Angst oder Verfolgung oder Hunger oder Blöße oder Gefahr oder Schwert?</Lehrtext>
    <Lehrtextvers>Römer 8,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-04T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Wer wird aber den Tag seines Kommens ertragen können, und wer wird bestehen, wenn er erscheint?</Losungstext>
    <Losungsvers>Maleachi 3,2</Losungsvers>
    <Lehrtext>Der Engel sprach: Fürchtet euch nicht! Siehe, ich verkündige euch große Freude, die allem Volk widerfahren wird.</Lehrtext>
    <Lehrtextvers>Lukas 2,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-05T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Du wirst sein wie ein bewässerter Garten und wie eine Wasserquelle, der es nie an Wasser fehlt.</Losungstext>
    <Losungsvers>Jesaja 58,11</Losungsvers>
    <Lehrtext>In Christus wohnt die ganze Fülle der Gottheit leibhaftig, und an dieser Fülle habt ihr teil in ihm, der das Haupt aller Mächte und Gewalten ist.</Lehrtext>
    <Lehrtextvers>Kolosser 2,9-10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-06T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will dir ein Freudenopfer bringen und deinen Namen, HERR, preisen, dass er so tröstlich ist.</Losungstext>
    <Losungsvers>Psalm 54,8</Losungsvers>
    <Lehrtext>Wenn einer spricht, dann Worte Gottes; wenn einer dient, dann aus der Kraft, die Gott ihm schenkt, damit in allen Dingen Gott verherrlicht werde durch Jesus Christus; ihm sei die Herrlichkeit und die Herrschaft in alle Ewigkeit.</Lehrtext>
    <Lehrtextvers>1.Petrus 4,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-07T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>6. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Die Gebote des HERRN sind lauter und erleuchten die Augen.</Losungstext>
    <Losungsvers>Psalm 19,9</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Wer eines von den kleinsten Geboten auflöst und lehrt die Leute so, der wird der Kleinste heißen im Himmelreich; wer es aber tut und lehrt, der wird groß heißen im Himmelreich.</Lehrtext>
    <Lehrtextvers>Matthäus 5,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-08T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gott segnete sie und sprach zu ihnen: Seid fruchtbar und mehret euch und füllet die Erde und machet sie euch untertan.</Losungstext>
    <Losungsvers>1.Mose 1,28</Losungsvers>
    <Lehrtext>Wem viel gegeben ist, bei dem wird man viel suchen; und wem viel anvertraut ist, von dem wird man umso mehr fordern.</Lehrtext>
    <Lehrtextvers>Lukas 12,48</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-09T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Seid stille vor Gott dem HERRN, denn des HERRN Tag ist nahe.</Losungstext>
    <Losungsvers>Zefanja 1,7</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Selig sind die Knechte, die der Herr, wenn er kommt, wachend findet.</Lehrtext>
    <Lehrtextvers>Lukas 12,37</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-10T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich rief zu dem HERRN in meiner Angst, und er antwortete mir.</Losungstext>
    <Losungsvers>Jona 2,3</Losungsvers>
    <Lehrtext>Die Haare auf eurem Haupt sind alle gezählt. Darum fürchtet euch nicht.</Lehrtext>
    <Lehrtextvers>Lukas 12,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-11T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Du feuchtest die Berge von oben her, du machst das Land voll Früchte, die du schaffest.</Losungstext>
    <Losungsvers>Psalm 104,13</Losungsvers>
    <Lehrtext>Seid dankbar in allen Dingen; denn das ist der Wille Gottes in Christus Jesus an euch.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,18</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-12T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Sie sollen sicher wohnen, und niemand soll sie schrecken.</Losungstext>
    <Losungsvers>Hesekiel 34,28</Losungsvers>
    <Lehrtext>Macht sichere Schritte mit euren Füßen, damit nicht jemand strauchle wie ein Lahmer, sondern vielmehr gesund werde.</Lehrtext>
    <Lehrtextvers>Hebräer 12,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-13T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich weiß, dass mein Erlöser lebt.</Losungstext>
    <Losungsvers>Hiob 19,25</Losungsvers>
    <Lehrtext>Jesus hat die Menschen befreit, die durch ihre Angst vor dem Tod das ganze Leben lang Sklaven gewesen sind.</Lehrtext>
    <Lehrtextvers>Hebräer 2,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-14T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>7. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Pflüget ein Neues, solange es Zeit ist, den HERRN zu suchen!</Losungstext>
    <Losungsvers>Hosea 10,12</Losungsvers>
    <Lehrtext>Verhaltet euch weise gegenüber denen, die draußen sind, und kauft die Zeit aus.</Lehrtext>
    <Lehrtextvers>Kolosser 4,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-15T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Sorge im Herzen bedrückt den Menschen; aber ein freundliches Wort erfreut ihn.</Losungstext>
    <Losungsvers>Sprüche 12,25</Losungsvers>
    <Lehrtext>So zieht nun an als die Auserwählten Gottes, als die Heiligen und Geliebten, herzliches Erbarmen, Freundlichkeit, Demut, Sanftmut, Geduld; und ertrage einer den andern!</Lehrtext>
    <Lehrtextvers>Kolosser 3,12-13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-16T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Sprich nicht: »Ich will Böses vergelten!« Harre des HERRN, der wird dir helfen.</Losungstext>
    <Losungsvers>Sprüche 20,22</Losungsvers>
    <Lehrtext>Seht zu, dass keiner dem andern Böses mit Bösem vergelte, sondern jagt allezeit dem Guten nach untereinander und gegen jedermann.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-17T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wenn ich auch noch so viele meiner Gebote aufschreibe, so werden sie doch geachtet wie eine fremde Lehre.</Losungstext>
    <Losungsvers>Hosea 8,12</Losungsvers>
    <Lehrtext>Vor Gott sind nicht gerecht, die das Gesetz #hören#, sondern die das Gesetz #tun#, werden gerecht sein.</Lehrtext>
    <Lehrtextvers>Römer 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-18T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Gottes Wege sind vollkommen.</Losungstext>
    <Losungsvers>Psalm 18,31</Losungsvers>
    <Lehrtext>Darum sorgt nicht für morgen, denn der morgige Tag wird für das Seine sorgen.</Lehrtext>
    <Lehrtextvers>Matthäus 6,34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-19T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR sprach zu Jona: Dich jammert die Staude, um die du dich nicht gemüht hast, die in #einer# Nacht ward und in #einer# Nacht verdarb, und mich sollte nicht jammern Ninive, eine so große Stadt?</Losungstext>
    <Losungsvers>Jona 4,10-11</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Ich bin gekommen, die Sünder zur Buße zu rufen und nicht die Gerechten.</Lehrtext>
    <Lehrtextvers>Lukas 5,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-20T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der Stein, den die Bauleute verworfen haben, ist zum Eckstein geworden. Das ist vom HERRN geschehen und ist ein Wunder vor unsern Augen.</Losungstext>
    <Losungsvers>Psalm 118,22-23</Losungsvers>
    <Lehrtext>Kommt zu Christus als zu dem lebendigen Stein, der von den Menschen verworfen ist, aber bei Gott auserwählt und kostbar.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-21T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>8. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Der HERR behütet die Fremdlinge und erhält Waisen und Witwen.</Losungstext>
    <Losungsvers>Psalm 146,9</Losungsvers>
    <Lehrtext>Lasst uns lieben, denn er hat uns zuerst geliebt.</Lehrtext>
    <Lehrtextvers>1.Johannes 4,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-22T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>So spricht der HERR: Gleichwie ich über dies Volk all dies große Unheil habe kommen lassen, so will ich auch alles Gute über sie kommen lassen, das ich ihnen zugesagt habe.</Losungstext>
    <Losungsvers>Jeremia 32,42</Losungsvers>
    <Lehrtext>Fürchte dich nicht, du kleine Herde! Denn es hat eurem Vater wohlgefallen, euch das Reich zu geben.</Lehrtext>
    <Lehrtextvers>Lukas 12,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-23T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Lass sich freuen alle, die auf dich trauen.</Losungstext>
    <Losungsvers>Psalm 5,12</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wenn ihr meine Gebote haltet, so bleibt ihr in meiner Liebe, wie ich meines Vaters Gebote halte und bleibe in seiner Liebe. Das sage ich euch, damit meine Freude in euch bleibe und eure Freude vollkommen werde.</Lehrtext>
    <Lehrtextvers>Johannes 15,10-11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-24T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Dein Wort ist meines Herzens Freude und Trost; denn ich bin ja nach deinem Namen genannt, HERR, Gott Zebaoth.</Losungstext>
    <Losungsvers>Jeremia 15,16</Losungsvers>
    <Lehrtext>Herr, gib deinen Knechten, mit allem Freimut zu reden dein Wort.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 4,29</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-25T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Gott, sei mir gnädig nach deiner Güte, und tilge meine Sünden nach deiner großen Barmherzigkeit.</Losungstext>
    <Losungsvers>Psalm 51,3</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Ihre vielen Sünden sind vergeben, denn sie hat viel Liebe gezeigt; wem aber wenig vergeben wird, der liebt wenig.</Lehrtext>
    <Lehrtextvers>Lukas 7,47</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-26T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Säet Gerechtigkeit und erntet nach dem Maße der Liebe!</Losungstext>
    <Losungsvers>Hosea 10,12</Losungsvers>
    <Lehrtext>Zieht den neuen Menschen an, der nach Gott geschaffen ist in wahrer Gerechtigkeit und Heiligkeit.</Lehrtext>
    <Lehrtextvers>Epheser 4,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-27T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR, der König Israels, ist bei dir, dass du dich vor keinem Unheil mehr fürchten musst.</Losungstext>
    <Losungsvers>Zefanja 3,15</Losungsvers>
    <Lehrtext>Pilatus fragte Jesus und sprach: Bist du der Juden König? Er antwortete ihm und sprach: Du sagst es.</Lehrtext>
    <Lehrtextvers>Lukas 23,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-28T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>9. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>HERR, ich warte auf dein Heil!</Losungstext>
    <Losungsvers>1.Mose 49,18</Losungsvers>
    <Lehrtext>Christus ist #einmal# geopfert worden, die Sünden vieler wegzunehmen; zum zweiten Mal wird er nicht der Sünde wegen erscheinen, sondern denen, die auf ihn warten, zum Heil.</Lehrtext>
    <Lehrtextvers>Hebräer 9,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-29T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Adam versteckte sich mit seiner Frau vor dem Angesicht Gottes des HERRN.</Losungstext>
    <Losungsvers>1.Mose 3,8</Losungsvers>
    <Lehrtext>Es ist nichts verborgen, was nicht offenbar werden soll, auch nichts geheim, was nicht bekannt werden und an den Tag kommen soll.</Lehrtext>
    <Lehrtextvers>Lukas 8,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-30T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Sie zogen Daniel aus der Grube heraus, und man fand keine Verletzung an ihm; denn er hatte seinem Gott vertraut.</Losungstext>
    <Losungsvers>Daniel 6,24</Losungsvers>
    <Lehrtext>Werft euer Vertrauen nicht weg, welches eine große Belohnung hat.</Lehrtext>
    <Lehrtextvers>Hebräer 10,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-07-31T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wenn dich dein Bruder oder dein Sohn oder deine Tochter oder deine Frau in deinen Armen oder dein Freund, der dir so lieb ist wie dein Leben, heimlich überreden würde und sagen: Lass uns hingehen und andern Göttern dienen, so willige nicht ein.</Losungstext>
    <Losungsvers>5.Mose 13,7.9</Losungsvers>
    <Lehrtext>Ich bitte den Vater, dass Christus durch den Glauben in euren Herzen Wohnung nimmt und ihr in der Liebe tief verwurzelt und fest gegründet seid.</Lehrtext>
    <Lehrtextvers>Epheser 3,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-01T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>So lass nun deine Kraft, o Herr, groß werden, wie du gesagt hast.</Losungstext>
    <Losungsvers>4.Mose 14,17</Losungsvers>
    <Lehrtext>Christus ist mächtig unter euch.</Lehrtext>
    <Lehrtextvers>2.Korinther 13,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-02T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich, der HERR, behüte den Weinberg und begieße ihn immer wieder. Damit man ihn nicht verderbe, will ich ihn Tag und Nacht behüten.</Losungstext>
    <Losungsvers>Jesaja 27,3</Losungsvers>
    <Lehrtext>Er aber, der Gott des Friedens, heilige euch durch und durch und bewahre euren Geist samt Seele und Leib unversehrt, untadelig für die Ankunft unseres Herrn Jesus Christus.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-03T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wie lange weigerst du dich, dich vor mir zu demütigen?</Losungstext>
    <Losungsvers>2.Mose 10,3</Losungsvers>
    <Lehrtext>Wer sich selbst erhöht, der wird erniedrigt werden; und wer sich selbst erniedrigt, der wird erhöht werden.</Lehrtext>
    <Lehrtextvers>Lukas 18,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-04T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>10. Sonntag nach Trinitatis (Israelsonntag)</Sonntag>
    <Losungstext>So fürchte dich nun nicht, denn ich bin bei dir.</Losungstext>
    <Losungsvers>Jesaja 43,5</Losungsvers>
    <Lehrtext>Die Jünger fürchteten sich und verwunderten sich und sprachen zueinander: Wer ist dieser? Auch dem Wind und dem Wasser gebietet er und sie sind ihm gehorsam.</Lehrtext>
    <Lehrtextvers>Lukas 8,25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-05T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Alle Völker, die du gemacht hast, werden kommen und vor dir anbeten, Herr, und deinen Namen ehren.</Losungstext>
    <Losungsvers>Psalm 86,9</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wir wollen das Evangelium auch denen predigen, die jenseits von euch wohnen.</Lehrtext>
    <Lehrtextvers>2.Korinther 10,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-06T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>So kehrt nun um von euren bösen Wegen. Warum wollt ihr sterben?</Losungstext>
    <Losungsvers>Hesekiel 33,11</Losungsvers>
    <Lehrtext>/Johannes der Täufer sprach:/ Wer zwei Hemden hat, der gebe dem, der keines hat; und wer zu essen hat, tue ebenso.</Lehrtext>
    <Lehrtextvers>Lukas 3,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-07T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Sei mir ein starker Hort, zu dem ich immer fliehen kann, der du zugesagt hast, mir zu helfen; denn du bist mein Fels und meine Burg.</Losungstext>
    <Losungsvers>Psalm 71,3</Losungsvers>
    <Lehrtext>/Christus spricht:/ Kommt her zu mir, alle, die ihr mühselig und beladen seid; ich will euch erquicken.</Lehrtext>
    <Lehrtextvers>Matthäus 11,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-08T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Freue dich und sei fröhlich, du Tochter Zion! Denn siehe, ich komme und will bei dir wohnen, spricht der HERR.</Losungstext>
    <Losungsvers>Sacharja 2,14</Losungsvers>
    <Lehrtext>/Der Seher Johannes schreibt:/ Es spricht, der dies bezeugt: Ja, ich komme bald. - Amen, ja, komm, Herr Jesus!</Lehrtext>
    <Lehrtextvers>Offenbarung 22,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-09T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR, euer Gott, schafft euch Ruhe und gibt euch dieses Land.</Losungstext>
    <Losungsvers>Josua 1,13</Losungsvers>
    <Lehrtext>So lasst uns bemüht sein, zu dieser Ruhe zu kommen.</Lehrtext>
    <Lehrtextvers>Hebräer 4,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-10T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Es wird ein einziger Tag sein - er ist dem Herrn bekannt! -, es wird nicht Tag und Nacht sein, und auch um den Abend wird es licht sein.</Losungstext>
    <Losungsvers>Sacharja 14,7</Losungsvers>
    <Lehrtext>Die Nacht ist vorgerückt, der Tag aber nahe herbeigekommen. So lasst uns ablegen die Werke der Finsternis und anlegen die Waffen des Lichts.</Lehrtext>
    <Lehrtextvers>Römer 13,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-11T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>11. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>In deiner Hand, HERR, steht es, jedermann groß und stark zu machen.</Losungstext>
    <Losungsvers>1.Chronik 29,12</Losungsvers>
    <Lehrtext>/Petrus sprach nach der Heilung des Gelähmten:/ Durch den Glauben an seinen Namen hat sein Name diesen, den ihr seht und kennt, stark gemacht; und der Glaube, der durch ihn gewirkt ist, hat diesem die Gesundheit gegeben vor euer aller Augen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 3,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-12T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR antwortete Hiob: Wo warst du, als ich die Erde gründete und zum Meer sprach: »Bis hierher sollst du kommen und nicht weiter; hier sollen sich legen deine stolzen Wellen!«?</Losungstext>
    <Losungsvers>Hiob 38,4.11</Losungsvers>
    <Lehrtext>Im Anfang war das Wort, und das Wort war bei Gott, und Gott war das Wort. Alle Dinge sind durch dasselbe gemacht, und ohne dasselbe ist nichts gemacht, was gemacht ist.</Lehrtext>
    <Lehrtextvers>Johannes 1,1.3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-13T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will dich nicht verlassen noch von dir weichen.</Losungstext>
    <Losungsvers>Josua 1,5</Losungsvers>
    <Lehrtext>Auf alle Gottesverheißungen ist in Jesus Christus das Ja.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-14T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wie um Jerusalem Berge sind, so ist der HERR um sein Volk her von nun an bis in Ewigkeit.</Losungstext>
    <Losungsvers>Psalm 125,2</Losungsvers>
    <Lehrtext>Der Herr lasse euch wachsen und immer reicher werden in der Liebe untereinander und zu jedermann, damit eure Herzen gestärkt werden und untadelig seien in Heiligkeit vor Gott, unserm Vater, wenn unser Herr Jesus kommt.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 3,12.13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-15T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Suchet das Gute und nicht das Böse, auf dass ihr leben könnt.</Losungstext>
    <Losungsvers>Amos 5,14</Losungsvers>
    <Lehrtext>Vergeltet niemandem Böses mit Bösem. Seid auf Gutes bedacht gegenüber jedermann.</Lehrtext>
    <Lehrtextvers>Römer 12,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-16T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, ich will meinen Boten senden, der vor mir her den Weg bereiten soll.</Losungstext>
    <Losungsvers>Maleachi 3,1</Losungsvers>
    <Lehrtext>/Johannes der Täufer sprach:/ Es kommt einer, der ist stärker als ich, und ich bin nicht wert, dass ich ihm die Riemen seiner Schuhe löse.</Lehrtext>
    <Lehrtextvers>Lukas 3,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-17T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Das soll mein Ruhm und meine Wonne, mein Preis und meine Ehre sein unter allen Völkern auf Erden, wenn sie all das Gute hören, das ich Jerusalem tue.</Losungstext>
    <Losungsvers>Jeremia 33,9</Losungsvers>
    <Lehrtext>Da Christus nun durch die rechte Hand Gottes erhöht ist und empfangen hat den verheißenen Heiligen Geist vom Vater, hat er diesen ausgegossen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 2,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-18T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>12. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Wer kann die großen Taten des HERRN alle erzählen und sein Lob genug verkündigen?</Losungstext>
    <Losungsvers>Psalm 106,2</Losungsvers>
    <Lehrtext>Alles, was zum Leben und zur Frömmigkeit dient, hat uns seine göttliche Kraft geschenkt durch die Erkenntnis dessen, der uns berufen hat durch seine Herrlichkeit und Kraft.</Lehrtext>
    <Lehrtextvers>2.Petrus 1,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-19T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Weise mir, HERR, deinen Weg, dass ich wandle in deiner Wahrheit.</Losungstext>
    <Losungsvers>Psalm 86,11</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wir danken Gott ohne Unterlass dafür, dass ihr das Wort der göttlichen Predigt, das ihr von uns empfangen habt, nicht als Menschenwort aufgenommen habt, sondern als das, was es in Wahrheit ist, als Gottes Wort, das in euch wirkt, die ihr glaubt.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 2,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-20T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Lass meinen Mund deines Ruhmes und deines Preises voll sein täglich.</Losungstext>
    <Losungsvers>Psalm 71,8</Losungsvers>
    <Lehrtext>Um Mitternacht beteten Paulus und Silas und lobten Gott. Und die Gefangenen hörten sie.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 16,25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-21T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Er wird Frieden gebieten den Völkern.</Losungstext>
    <Losungsvers>Sacharja 9,10</Losungsvers>
    <Lehrtext>Der Friede Christi regiere in euren Herzen; zum Frieden seid ihr berufen als Glieder des einen Leibes. Und dafür sollt ihr dankbar sein.</Lehrtext>
    <Lehrtextvers>Kolosser 3,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-22T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR erhörte unser Schreien und sah unser Elend, unsere Angst und Not.</Losungstext>
    <Losungsvers>5.Mose 26,7</Losungsvers>
    <Lehrtext>Christus hat in den Tagen seines irdischen Lebens Bitten und Flehen mit lautem Schreien und mit Tränen dem dargebracht, der ihn vom Tod erretten konnte; und er ist auch erhört worden, weil er Gott in Ehren hielt.</Lehrtext>
    <Lehrtextvers>Hebräer 5,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-23T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR macht arm und macht reich; er erniedrigt und erhöht.</Losungstext>
    <Losungsvers>1.Samuel 2,7</Losungsvers>
    <Lehrtext>Gebt, so wird euch gegeben.</Lehrtext>
    <Lehrtextvers>Lukas 6,38</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-24T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gerechtigkeit führt zum Leben; aber dem Bösen nachjagen führt zum Tode.</Losungstext>
    <Losungsvers>Sprüche 11,19</Losungsvers>
    <Lehrtext>Ich habe die Hoffnung zu Gott, die auch sie selbst haben, nämlich dass es eine Auferstehung der Gerechten wie der Ungerechten geben wird.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 24,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-25T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>13. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Der HERR kommt, das Erdreich zu richten. Er wird den Erdkreis richten mit Gerechtigkeit und die Völker, wie es recht ist.</Losungstext>
    <Losungsvers>Psalm 98,9</Losungsvers>
    <Lehrtext>/Christus spricht:/ Meine Speise ist die, dass ich tue den Willen dessen, der mich gesandt hat, und vollende sein Werk.</Lehrtext>
    <Lehrtextvers>Johannes 4,34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-26T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Gott, wir gedenken deiner Güte in deinem Tempel.</Losungstext>
    <Losungsvers>Psalm 48,10</Losungsvers>
    <Lehrtext>Lasst uns aufeinander acht haben und uns anreizen zur Liebe und zu guten Werken und nicht verlassen unsre Versammlungen, wie einige zu tun pflegen, sondern einander ermahnen.</Lehrtext>
    <Lehrtextvers>Hebräer 10,24-25</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-27T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Unsre Hilfe steht im Namen des HERRN, der Himmel und Erde gemacht hat.</Losungstext>
    <Losungsvers>Psalm 124,8</Losungsvers>
    <Lehrtext>In dem Namen Jesu sollen sich beugen aller derer Knie, die im Himmel und auf Erden und unter der Erde sind.</Lehrtext>
    <Lehrtextvers>Philipper 2,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-28T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Schaff uns Beistand in der Not; denn Menschenhilfe ist nichts nütze.</Losungstext>
    <Losungsvers>Psalm 60,13</Losungsvers>
    <Lehrtext>Jesus sprach: Jüngling, ich sage dir, steh auf! Und der Tote richtete sich auf und fing an zu reden, und Jesus gab ihn seiner Mutter.</Lehrtext>
    <Lehrtextvers>Lukas 7,14-15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-29T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird dir seinen guten Schatz auftun, den Himmel, dass er deinem Land Regen gebe zur rechten Zeit und dass er segne alle Werke deiner Hände.</Losungstext>
    <Losungsvers>5.Mose 28,12</Losungsvers>
    <Lehrtext>Der Vater im Himmel lässt seine Sonne aufgehen über Böse und Gute und lässt regnen über Gerechte und Ungerechte.</Lehrtext>
    <Lehrtextvers>Matthäus 5,45</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-30T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Kommt nun, lasst uns wandeln im Licht des HERRN!</Losungstext>
    <Losungsvers>Jesaja 2,5</Losungsvers>
    <Lehrtext>Tut alles ohne Murren und ohne Zweifel, damit ihr ohne Tadel und lauter seid, Gottes Kinder, ohne Makel mitten unter einem verdorbenen und verkehrten Geschlecht, unter dem ihr scheint als Lichter in der Welt.</Lehrtext>
    <Lehrtextvers>Philipper 2,14-15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-08-31T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du, Herr, bist gut und gnädig, von großer Güte allen, die dich anrufen.</Losungstext>
    <Losungsvers>Psalm 86,5</Losungsvers>
    <Lehrtext>Der Herr richte eure Herzen aus auf die Liebe Gottes und auf die Geduld Christi.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 3,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-01T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>14. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Du, o HERR, kennst mich, du prüfst, wie mein Herz zu dir steht.</Losungstext>
    <Losungsvers>Jeremia 12,3</Losungsvers>
    <Lehrtext>Seht zu, dass keiner unter euch ein böses, ungläubiges Herz habe, das abfällt von dem lebendigen Gott.</Lehrtext>
    <Lehrtextvers>Hebräer 3,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-02T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich habe das Elend meines Volks in Ägypten gesehen und ihr Geschrei über ihre Bedränger gehört.</Losungstext>
    <Losungsvers>2.Mose 3,7</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wir rühmen uns der Bedrängnisse, weil wir wissen, dass Bedrängnis Geduld bringt, Geduld aber Bewährung, Bewährung aber Hoffnung, Hoffnung aber lässt nicht zuschanden werden.</Lehrtext>
    <Lehrtextvers>Römer 5,3-4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-03T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Jakob zog seinen Weg. Und es begegneten ihm die Engel Gottes.</Losungstext>
    <Losungsvers>1.Mose 32,2</Losungsvers>
    <Lehrtext>Sind die Engel nicht allesamt dienstbare Geister, ausgesandt zum Dienst um derer willen, die das Heil ererben sollen?</Lehrtext>
    <Lehrtextvers>Hebräer 1,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-04T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der König antwortete Daniel und sprach: Es ist kein Zweifel, euer Gott ist ein Gott über alle Götter und ein Herr über alle Könige.</Losungstext>
    <Losungsvers>Daniel 2,47</Losungsvers>
    <Lehrtext>Ich bin gewiss, dass weder Tod noch Leben, weder Engel noch Mächte noch Gewalten, weder Gegenwärtiges noch Zukünftiges, weder Hohes noch Tiefes noch eine andere Kreatur uns scheiden kann von der Liebe Gottes, die in Christus Jesus ist, unserm Herrn.</Lehrtext>
    <Lehrtextvers>Römer 8,38-39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-05T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Leite mich in deiner Wahrheit und lehre mich!</Losungstext>
    <Losungsvers>Psalm 25,5</Losungsvers>
    <Lehrtext>Jesus spricht: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater denn durch mich.</Lehrtext>
    <Lehrtextvers>Johannes 14,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-06T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Von dem HERRN kommt es, wenn eines Mannes Schritte fest werden. Fällt er, so stürzt er doch nicht; denn der HERR hält ihn fest an der Hand.</Losungstext>
    <Losungsvers>Psalm 37,23.24</Losungsvers>
    <Lehrtext>Jesus streckte die Hand aus und ergriff Petrus und sprach zu ihm: Du Kleingläubiger, warum hast du gezweifelt?</Lehrtext>
    <Lehrtextvers>Matthäus 14,31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-07T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der Herr liebt Gerechtigkeit und Recht.</Losungstext>
    <Losungsvers>Psalm 33,5</Losungsvers>
    <Lehrtext>/Paulus sprach:/ Durch Christus wird Vergebung der Sünden verkündigt; und in all dem, worin ihr durch das Gesetz des Mose nicht gerecht werden konntet, ist der gerecht gemacht, der an ihn glaubt.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 13,38-39</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-08T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>15. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Die Angst meines Herzens ist groß; führe mich aus meinen Nöten!</Losungstext>
    <Losungsvers>Psalm 25,17</Losungsvers>
    <Lehrtext>/Die Engel sprachen:/ Ihr Männer von Galiläa, was steht ihr da und seht zum Himmel? Dieser Jesus, der von euch weg gen Himmel aufgenommen wurde, wird so wiederkommen, wie ihr ihn habt gen Himmel fahren sehen.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 1,11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-09T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Kommt, wir wollen uns dem HERRN zuwenden zu einem ewigen Bunde, der nimmermehr vergessen werden soll!</Losungstext>
    <Losungsvers>Jeremia 50,5</Losungsvers>
    <Lehrtext>Christus ist der Mittler des neuen Bundes.</Lehrtext>
    <Lehrtextvers>Hebräer 9,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-10T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Die Worte des HERRN sind lauter wie Silber, im Tiegel geschmolzen, geläutert siebenmal.</Losungstext>
    <Losungsvers>Psalm 12,7</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wenn ihr bleiben werdet an meinem Wort, so seid ihr wahrhaftig meine Jünger und werdet die Wahrheit erkennen, und die Wahrheit wird euch frei machen.</Lehrtext>
    <Lehrtextvers>Johannes 8,31-32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-11T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Einem König hilft nicht seine große Macht; ein Held kann sich nicht retten durch seine große Kraft.</Losungstext>
    <Losungsvers>Psalm 33,16</Losungsvers>
    <Lehrtext>Wer groß sein will unter euch, der soll euer Diener sein.</Lehrtext>
    <Lehrtextvers>Markus 10,43</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-12T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Jauchze, du Tochter Zion! Frohlocke, Israel! Freue dich und sei fröhlich von ganzem Herzen, du Tochter Jerusalem! Denn der HERR hat deine Strafe weggenommen.</Losungstext>
    <Losungsvers>Zefanja 3,14-15</Losungsvers>
    <Lehrtext>Christus hat unsre Sünde selbst hinaufgetragen an seinem Leibe auf das Holz, damit wir, der Sünde abgestorben, der Gerechtigkeit leben.</Lehrtext>
    <Lehrtextvers>1.Petrus 2,24</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-13T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Hüte dich nur und bewahre deine Seele gut, dass du nicht vergisst, was deine Augen gesehen haben.</Losungstext>
    <Losungsvers>5.Mose 4,9</Losungsvers>
    <Lehrtext>Gott hat Jesus von Nazareth gesalbt mit Heiligem Geist und Kraft; der ist umhergezogen und hat Gutes getan.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 10,38</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-14T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Sie sollen mein Volk sein, und ich will ihr Gott sein in Treue und Gerechtigkeit.</Losungstext>
    <Losungsvers>Sacharja 8,8</Losungsvers>
    <Lehrtext>Gehört ihr Christus an, so seid ihr Abrahams Kinder und nach der Verheißung Erben.</Lehrtext>
    <Lehrtextvers>Galater 3,29</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-15T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>16. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Wenn doch mein Volk mir gehorsam wäre!</Losungstext>
    <Losungsvers>Psalm 81,14</Losungsvers>
    <Lehrtext>So tut nun Buße und bekehrt euch, dass eure Sünden getilgt werden, damit die Zeit der Erquickung komme von dem Angesicht des Herrn und er den sende, der euch zuvor zum Christus bestimmt ist: Jesus.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 3,19-20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-16T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Höret auf mich, ihr Verzagten, die ihr fern seid vom Heil: Schon lasse ich nahen mein Heil, es ist nicht fern.</Losungstext>
    <Losungsvers>Jesaja 46,12-13</Losungsvers>
    <Lehrtext>Sollte Gott nicht Recht schaffen seinen Auserwählten, die zu ihm Tag und Nacht rufen, und sollte er’s bei ihnen lange hinziehen?</Lehrtext>
    <Lehrtextvers>Lukas 18,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-17T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Dann aber will ich den Völkern reine Lippen geben, dass sie alle des HERRN Namen anrufen sollen und ihm einträchtig dienen.</Losungstext>
    <Losungsvers>Zefanja 3,9</Losungsvers>
    <Lehrtext>Weil wir ein unerschütterliches Reich empfangen, lasst uns dankbar sein und so Gott dienen mit Scheu und Furcht, wie es ihm gefällt.</Lehrtext>
    <Lehrtextvers>Hebräer 12,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-18T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>HERR, sei unser Arm alle Morgen, dazu unser Heil zur Zeit der Trübsal!</Losungstext>
    <Losungsvers>Jesaja 33,2</Losungsvers>
    <Lehrtext>Wir, die wir Kinder des Tages sind, wollen nüchtern sein, angetan mit dem Panzer des Glaubens und der Liebe und mit dem Helm der Hoffnung auf das Heil.</Lehrtext>
    <Lehrtextvers>1.Thessalonicher 5,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-19T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich liebe den HERRN, denn er hört die Stimme meines Flehens.</Losungstext>
    <Losungsvers>Psalm 116,1</Losungsvers>
    <Lehrtext>/Christus spricht:/ Euer Vater weiß, was ihr bedürft, bevor ihr ihn bittet.</Lehrtext>
    <Lehrtextvers>Matthäus 6,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-20T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>/Gott spricht:/ Ich will für Israel wie ein Tau sein, dass es blühen soll wie eine Lilie.</Losungstext>
    <Losungsvers>Hosea 14,6</Losungsvers>
    <Lehrtext>Seht die Lilien an, wie sie wachsen: sie spinnen nicht, sie weben nicht. Ich sage euch aber, dass auch Salomo in aller seiner Herrlichkeit nicht gekleidet gewesen ist wie eine von ihnen.</Lehrtext>
    <Lehrtextvers>Lukas 12,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-21T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wie schwer sind für mich, Gott, deine Gedanken! Wie ist ihre Summe so groß!</Losungstext>
    <Losungsvers>Psalm 139,17</Losungsvers>
    <Lehrtext>Wir sehen jetzt durch einen Spiegel ein dunkles Bild; dann aber von Angesicht zu Angesicht. Jetzt erkenne ich stückweise; dann aber werde ich erkennen, wie ich erkannt bin.</Lehrtext>
    <Lehrtextvers>1.Korinther 13,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-22T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>17. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Sechs Tage sollst du arbeiten und alle deine Werke tun. Aber am siebenten Tage ist der Sabbat des HERRN, deines Gottes. Da sollst du keine Arbeit tun.</Losungstext>
    <Losungsvers>2.Mose 20,9.10</Losungsvers>
    <Lehrtext>Wer zu Gottes Ruhe gekommen ist, der ruht auch von seinen Werken so wie Gott von den seinen.</Lehrtext>
    <Lehrtextvers>Hebräer 4,10-11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-23T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Hüte dich und bleibe still; fürchte dich nicht, und dein Herz sei unverzagt.</Losungstext>
    <Losungsvers>Jesaja 7,4</Losungsvers>
    <Lehrtext>Seid stark in dem Herrn und in der Macht seiner Stärke.</Lehrtext>
    <Lehrtextvers>Epheser 6,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-24T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Du sprichst: Ich bin unschuldig; er hat ja doch seinen Zorn von mir gewandt. Siehe, ich will dich richten, weil du sprichst: Ich habe nicht gesündigt.</Losungstext>
    <Losungsvers>Jeremia 2,35</Losungsvers>
    <Lehrtext>Es wird Freude im Himmel sein über #einen# Sünder, der Buße tut, mehr als über neunundneunzig Gerechte, die der Buße nicht bedürfen.</Lehrtext>
    <Lehrtextvers>Lukas 15,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-25T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>/Der Herr sprach zu Mose:/ Mein Angesicht kannst du nicht sehen; denn kein Mensch wird leben, der mich sieht.</Losungstext>
    <Losungsvers>2.Mose 33,20</Losungsvers>
    <Lehrtext>Wer mich sieht, der sieht den, der mich gesandt hat.</Lehrtext>
    <Lehrtextvers>Johannes 12,45</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-26T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Siehe, es kommt die Zeit, spricht der HERR, dass man zugleich ackern und ernten, zugleich keltern und säen wird. Und die Berge werden von süßem Wein triefen, und alle Hügel werden fruchtbar sein. Denn ich will die Gefangenschaft meines Volkes Israel wenden, dass sie die verwüsteten Städte wieder aufbauen und bewohnen sollen, dass sie Weinberge pflanzen und Wein davon trinken, Gärten anlegen und Früchte daraus essen.</Losungstext>
    <Losungsvers>Amos 9,13-14</Losungsvers>
    <Lehrtext>Wenn dieses anfängt zu geschehen, dann seht auf und erhebt eure Häupter, weil sich eure Erlösung naht.</Lehrtext>
    <Lehrtextvers>Lukas 21,28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-27T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ja, was du durch deinen Mund verheißen hattest, das hast du durch deine Hand erfüllt, wie es jetzt am Tage ist.</Losungstext>
    <Losungsvers>1.Könige 8,24</Losungsvers>
    <Lehrtext>/Paulus sprach:/ Wir verkündigen euch die Verheißung, die an die Väter ergangen ist, dass Gott sie uns, ihren Kindern, erfüllt hat, indem er Jesus auferweckte.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 13,32-33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-28T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Sei du mir nur nicht schrecklich, meine Zuversicht in der Not!</Losungstext>
    <Losungsvers>Jeremia 17,17</Losungsvers>
    <Lehrtext>Durch Jesus Christus haben wir den Zugang im Glauben zu dieser Gnade, in der wir stehen, und rühmen uns der Hoffnung der zukünftigen Herrlichkeit, die Gott geben wird.</Lehrtext>
    <Lehrtextvers>Römer 5,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-29T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>18. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Achtet ernstlich darauf um euer selbst willen, dass ihr den HERRN, euren Gott, lieb habt.</Losungstext>
    <Losungsvers>Josua 23,11</Losungsvers>
    <Lehrtext>Hüten wir uns also davor, solange die Verheißung, in seine Ruhe einzugehen, noch nicht erfüllt ist, zu meinen, jemand sei zu spät gekommen.</Lehrtext>
    <Lehrtextvers>Hebräer 4,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-09-30T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Rede einer mit dem andern Wahrheit!</Losungstext>
    <Losungsvers>Sacharja 8,16</Losungsvers>
    <Lehrtext>Belügt einander nicht; denn ihr habt den alten Menschen mit seinen Werken ausgezogen.</Lehrtext>
    <Lehrtextvers>Kolosser 3,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-01T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>/Elisa sprach zu dem Diener:/ Fürchte dich nicht, denn derer sind mehr, die bei uns sind, als derer, die bei ihnen sind!</Losungstext>
    <Losungsvers>2.Könige 6,16</Losungsvers>
    <Lehrtext>Gedenkt an den, der so viel Widerspruch gegen sich von den Sündern erduldet hat, damit ihr nicht matt werdet und den Mut nicht sinken lasst.</Lehrtext>
    <Lehrtextvers>Hebräer 12,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-02T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Wer seinen Nächsten verachtet, versündigt sich; aber wohl dem, der sich der Elenden erbarmt!</Losungstext>
    <Losungsvers>Sprüche 14,21</Losungsvers>
    <Lehrtext>Seid barmherzig, wie auch euer Vater barmherzig ist.</Lehrtext>
    <Lehrtextvers>Lukas 6,36</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-03T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Es ströme das Recht wie Wasser und die Gerechtigkeit wie ein nie versiegender Bach.</Losungstext>
    <Losungsvers>Amos 5,24</Losungsvers>
    <Lehrtext>Lass dich nicht vom Bösen überwinden, sondern überwinde das Böse mit Gutem.</Lehrtext>
    <Lehrtextvers>Römer 12,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-04T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Die zum Frieden raten, haben Freude.</Losungstext>
    <Losungsvers>Sprüche 12,20</Losungsvers>
    <Lehrtext>Jagt dem Frieden nach mit jedermann und der Heiligung, ohne die niemand den Herrn sehen wird.</Lehrtext>
    <Lehrtextvers>Hebräer 12,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-05T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Du bereitest vor mir einen Tisch im Angesicht meiner Feinde. Du salbest mein Haupt mit Öl und schenkest mir voll ein.</Losungstext>
    <Losungsvers>Psalm 23,5</Losungsvers>
    <Lehrtext>Mit Freuden sagt Dank dem Vater, der euch tüchtig gemacht hat zu dem Erbteil der Heiligen im Licht.</Lehrtext>
    <Lehrtextvers>Kolosser 1,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-06T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Erntedankfest</Sonntag>
    <Losungstext>Siehe, ich bin mit dir und will dich behüten, wo du hinziehst.</Losungstext>
    <Losungsvers>1.Mose 28,15</Losungsvers>
    <Lehrtext>Durch den Glauben wurde #Abraham# gehorsam, als er berufen wurde, in ein Land zu ziehen, das er erben sollte; und er zog aus und wusste nicht, wo er hinkäme.</Lehrtext>
    <Lehrtextvers>Hebräer 11,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-07T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Es ist ein Gott im Himmel, der kann Geheimnisse offenbaren.</Losungstext>
    <Losungsvers>Daniel 2,28</Losungsvers>
    <Lehrtext>Jetzt ist das Geheimnis seinen Heiligen offenbart worden, denen Gott kundtun wollte, wie reich unter den Völkern die Herrlichkeit dieses Geheimnisses ist: Christus in euch, die Hoffnung auf die Herrlichkeit.</Lehrtext>
    <Lehrtextvers>Kolosser 1,26-27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-08T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gott sah an alles, was er gemacht hatte, und siehe, es war sehr gut.</Losungstext>
    <Losungsvers>1.Mose 1,31</Losungsvers>
    <Lehrtext>Gott, dem ewigen König, dem Unvergänglichen und Unsichtbaren, der allein Gott ist, sei Ehre und Preis in Ewigkeit!</Lehrtext>
    <Lehrtextvers>1.Timotheus 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-09T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ihr gedachtet es böse mit mir zu machen, aber Gott gedachte es gut zu machen.</Losungstext>
    <Losungsvers>1.Mose 50,20</Losungsvers>
    <Lehrtext>Wie der Herr euch vergeben hat, so vergebt auch ihr!</Lehrtext>
    <Lehrtextvers>Kolosser 3,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-10T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Die Wahrsager schauen Trug und erzählen nichtige Träume, und ihr Trösten ist nichts.</Losungstext>
    <Losungsvers>Sacharja 10,2</Losungsvers>
    <Lehrtext>Jesus sprach zu Pilatus: Ich bin dazu geboren und in die Welt gekommen, dass ich die Wahrheit bezeugen soll. Wer aus der Wahrheit ist, der hört meine Stimme.</Lehrtext>
    <Lehrtextvers>Johannes 18,37</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-11T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Wenn ich schaue allein auf deine Gebote, so werde ich nicht zuschanden.</Losungstext>
    <Losungsvers>Psalm 119,6</Losungsvers>
    <Lehrtext>Dieses kostbare Gut, das dir anvertraut ist, bewahre durch den Heiligen Geist, der in uns wohnt.</Lehrtext>
    <Lehrtextvers>2.Timotheus 1,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-12T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Hat Gott vergessen, gnädig zu sein, oder sein Erbarmen im Zorn verschlossen?</Losungstext>
    <Losungsvers>Psalm 77,10</Losungsvers>
    <Lehrtext>Wenn du mit deinem Munde bekennst, dass Jesus der Herr ist, und in deinem Herzen glaubst, dass ihn Gott von den Toten auferweckt hat, so wirst du gerettet.</Lehrtext>
    <Lehrtextvers>Römer 10,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-13T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>20. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Träufelt, ihr Himmel, von oben, und ihr Wolken, regnet Gerechtigkeit! Die Erde tue sich auf und bringe Heil, und Gerechtigkeit wachse mit auf! Ich, der HERR, habe es geschaffen.</Losungstext>
    <Losungsvers>Jesaja 45,8</Losungsvers>
    <Lehrtext>Wir warten im Geist durch den Glauben auf die Gerechtigkeit, auf die man hoffen muss.</Lehrtext>
    <Lehrtextvers>Galater 5,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-14T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich hatte viel Kummer in meinem Herzen, aber deine Tröstungen erquickten meine Seele.</Losungstext>
    <Losungsvers>Psalm 94,19</Losungsvers>
    <Lehrtext>Unser Herr Jesus Christus, und Gott, unser Vater, der uns geliebt und uns einen ewigen Trost gegeben hat und eine gute Hoffnung durch Gnade, der tröste eure Herzen und stärke euch in allem guten Werk und Wort.</Lehrtext>
    <Lehrtextvers>2.Thessalonicher 2,16-17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-15T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ist nicht Ephraim mein teurer Sohn und mein liebes Kind? Denn sooft ich ihm auch drohe, muss ich doch seiner gedenken; darum bricht mir mein Herz, dass ich mich seiner erbarmen muss, spricht der HERR.</Losungstext>
    <Losungsvers>Jeremia 31,20</Losungsvers>
    <Lehrtext>Der Sohn machte sich auf und kam zu seinem Vater. Als er aber noch weit entfernt war, sah ihn sein Vater und es jammerte ihn; er lief und fiel ihm um den Hals und küsste ihn.</Lehrtext>
    <Lehrtextvers>Lukas 15,20</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-16T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Siehe, um Trost war mir sehr bange. Du aber hast dich meiner Seele herzlich angenommen, dass sie nicht verdürbe; denn du wirfst alle meine Sünden hinter dich zurück.</Losungstext>
    <Losungsvers>Jesaja 38,17</Losungsvers>
    <Lehrtext>/Jesus sprach zu der Frau:/ Hat dich niemand verdammt? Sie antwortete: Niemand, Herr. Und Jesus sprach: So verdamme ich dich auch nicht; geh hin und sündige hinfort nicht mehr.</Lehrtext>
    <Lehrtextvers>Johannes 8,10-11</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-17T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Er wird Israel erlösen aus allen seinen Sünden.</Losungstext>
    <Losungsvers>Psalm 130,8</Losungsvers>
    <Lehrtext>Gott hat Jesus durch seine rechte Hand erhöht zum Fürsten und Heiland, um Israel Buße und Vergebung der Sünden zu geben.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 5,31</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-18T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ich gehe oder liege, so bist du um mich und siehst alle meine Wege.</Losungstext>
    <Losungsvers>Psalm 139,3</Losungsvers>
    <Lehrtext>Sorgt euch um nichts, sondern in allen Dingen lasst eure Bitten in Gebet und Flehen mit Danksagung vor Gott kundwerden!</Lehrtext>
    <Lehrtextvers>Philipper 4,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-19T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR, dein Gott, ist ein barmherziger Gott; er wird dich nicht verlassen noch verderben.</Losungstext>
    <Losungsvers>5.Mose 4,31</Losungsvers>
    <Lehrtext>Seine Barmherzigkeit währt von Geschlecht zu Geschlecht bei denen, die ihn fürchten.</Lehrtext>
    <Lehrtextvers>Lukas 1,50</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-20T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>21. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Ich, ich bin euer Tröster! Wer bist du denn, dass du dich vor Menschen gefürchtet hast, die doch sterben?</Losungstext>
    <Losungsvers>Jesaja 51,12</Losungsvers>
    <Lehrtext>Fürchtet euch nicht vor denen, die den Leib töten und danach nichts mehr tun können.</Lehrtext>
    <Lehrtextvers>Lukas 12,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-21T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ich will meinen Geist in euch geben und will solche Leute aus euch machen, die in meinen Geboten wandeln und meine Rechte halten und danach tun.</Losungstext>
    <Losungsvers>Hesekiel 36,27</Losungsvers>
    <Lehrtext>Gott hat uns tüchtig gemacht zu Dienern des neuen Bundes.</Lehrtext>
    <Lehrtextvers>2.Korinther 3,6</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-22T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Gott schuf den Menschen zu seinem Bilde, zum Bilde Gottes schuf er ihn.</Losungstext>
    <Losungsvers>1.Mose 1,27</Losungsvers>
    <Lehrtext>Ihr habt den neuen Menschen angezogen, der erneuert wird zur Erkenntnis nach dem Ebenbild dessen, der ihn geschaffen hat.</Lehrtext>
    <Lehrtextvers>Kolosser 3,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-23T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich habe mich unterfangen, mit meinem Herrn zu reden, wiewohl ich Staub und Asche bin.</Losungstext>
    <Losungsvers>1.Mose 18,27</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wer da bittet, der empfängt; und wer da sucht, der findet; und wer da anklopft, dem wird aufgetan.</Lehrtext>
    <Lehrtextvers>Lukas 11,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-24T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ich nahm mich deiner an in der Wüste, im dürren Lande.</Losungstext>
    <Losungsvers>Hosea 13,5</Losungsvers>
    <Lehrtext>Jesus sprach: Das Volk jammert mich; ich will sie nicht hungrig gehen lassen, damit sie nicht verschmachten auf dem Wege.</Lehrtext>
    <Lehrtextvers>Matthäus 15,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-25T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Haben wir nicht alle #einen# Vater? Hat uns nicht #ein# Gott geschaffen? Warum verachten wir denn einer den andern?</Losungstext>
    <Losungsvers>Maleachi 2,10</Losungsvers>
    <Lehrtext>Daran wird jedermann erkennen, dass ihr meine Jünger seid, wenn ihr Liebe untereinander habt.</Lehrtext>
    <Lehrtextvers>Johannes 13,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-26T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Lobsinget dem HERRN; denn Großes hat er getan, kund sei das in aller Welt!</Losungstext>
    <Losungsvers>Jesaja 12,5</Losungsvers>
    <Lehrtext>Die Apostel hörten nicht auf, alle Tage im Tempel und hier und dort in den Häusern zu lehren und zu predigen das Evangelium von Jesus Christus.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 5,42</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-27T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>22. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Du wirst an deine Wege denken und dich schämen, wenn ich dir alles vergeben werde, was du getan hast, spricht Gott der HERR.</Losungstext>
    <Losungsvers>Hesekiel 16,61.63</Losungsvers>
    <Lehrtext>Weißt du nicht, dass Gottes Güte dich zur Umkehr leitet?</Lehrtext>
    <Lehrtextvers>Römer 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-28T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Erhöre mich, HERR, erhöre mich, damit dies Volk erkennt, dass du, HERR, Gott bist und ihr Herz wieder zu dir kehrst!</Losungstext>
    <Losungsvers>1.Könige 18,37</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Wir lassen nicht ab, für euch zu beten und zu bitten, dass ihr erfüllt werdet mit der Erkenntnis seines Willens in aller geistlichen Weisheit und Einsicht.</Lehrtext>
    <Lehrtextvers>Kolosser 1,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-29T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Diene Gott mit ganzem Herzen und mit williger Seele! Denn der HERR erforscht alle Herzen.</Losungstext>
    <Losungsvers>1.Chronik 28,9</Losungsvers>
    <Lehrtext>/Der Herr sprach zu Paulus:/ Ich bin dir erschienen, um dich zu erwählen zum Diener und zum Zeugen für mich, so wie du mich jetzt gesehen hast und wie ich dir künftig erscheinen werde.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 26,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-30T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Trachte nicht nach Bösem gegen deinen Nächsten, der arglos bei dir wohnt.</Losungstext>
    <Losungsvers>Sprüche 3,29</Losungsvers>
    <Lehrtext>Die Liebe ist langmütig und freundlich, die Liebe eifert nicht, die Liebe treibt nicht Mutwillen, sie bläht sich nicht auf.</Lehrtext>
    <Lehrtextvers>1.Korinther 13,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-10-31T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag>Reformationstag</Sonntag>
    <Losungstext>Der HERR aber, der selber vor euch hergeht, der wird mit dir sein und wird die Hand nicht abtun und dich nicht verlassen. Fürchte dich nicht und erschrick nicht!</Losungstext>
    <Losungsvers>5.Mose 31,8</Losungsvers>
    <Lehrtext>Nicht, dass ichs schon ergriffen habe oder schon vollkommen sei; ich jage ihm aber nach, ob ich’s wohl ergreifen könnte, weil ich von Christus Jesus ergriffen bin.</Lehrtext>
    <Lehrtextvers>Philipper 3,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-01T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR Zebaoth hat’s beschlossen - wer will’s wehren? Und seine Hand ist ausgereckt - wer will sie wenden?</Losungstext>
    <Losungsvers>Jesaja 14,27</Losungsvers>
    <Lehrtext>Des Herrn Wille geschehe.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 21,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-02T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Es ist nicht #eins# dahingefallen von allen seinen guten Worten, die er geredet hat durch seinen Knecht Mose.</Losungstext>
    <Losungsvers>1.Könige 8,56</Losungsvers>
    <Lehrtext>Durch die herzliche Barmherzigkeit unseres Gottes wird uns besuchen das aufgehende Licht aus der Höhe.</Lehrtext>
    <Lehrtextvers>Lukas 1,78</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-03T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>23. Sonntag nach Trinitatis</Sonntag>
    <Losungstext>Er ist nahe, der mich gerecht spricht; wer will mit mir rechten?</Losungstext>
    <Losungsvers>Jesaja 50,8</Losungsvers>
    <Lehrtext>Wer an Christus glaubt, der ist gerecht.</Lehrtext>
    <Lehrtextvers>Römer 10,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-04T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wir sind alle wie die Unreinen, und alle unsre Gerechtigkeit ist wie ein beflecktes Kleid.</Losungstext>
    <Losungsvers>Jesaja 64,5</Losungsvers>
    <Lehrtext>Der Sohn sprach: Vater, ich habe gesündigt gegen den Himmel und vor dir; ich bin hinfort nicht mehr wert, dass ich dein Sohn heiße. Aber der Vater sprach zu seinen Knechten: Bringt schnell das beste Gewand her und zieht es ihm an.</Lehrtext>
    <Lehrtextvers>Lukas 15,21-22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-05T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>HERR, sei mir gnädig, denn mir ist angst!</Losungstext>
    <Losungsvers>Psalm 31,10</Losungsvers>
    <Lehrtext>Fürchte dich nicht, sondern rede und schweige nicht!</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 18,9</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-06T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich will ihre Abtrünnigkeit wieder heilen; gerne will ich sie lieben.</Losungstext>
    <Losungsvers>Hosea 14,5</Losungsvers>
    <Lehrtext>Jesus sprachzu dem Übeltäter: Wahrlich, ich sage dir: Heute wirst du mit mir im Paradies sein.</Lehrtext>
    <Lehrtextvers>Lukas 23,43</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-07T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Sende dein Licht und deine Wahrheit, dass sie mich leiten zu deiner Wohnung.</Losungstext>
    <Losungsvers>Psalm 43,3</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin das Licht der Welt. Wer mir nachfolgt, der wird nicht wandeln in der Finsternis, sondern wird das Licht des Lebens haben.</Lehrtext>
    <Lehrtextvers>Johannes 8,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-08T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Was hast du von meinen Geboten zu reden und nimmst meinen Bund in deinen Mund, da du doch Zucht hassest und wirfst meine Worte hinter dich?</Losungstext>
    <Losungsvers>Psalm 50,16-17</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Was nennt ihr mich Herr, Herr, und tut nicht, was ich euch sage?</Lehrtext>
    <Lehrtextvers>Lukas 6,46</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-09T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR richtet auf, die niedergeschlagen sind.</Losungstext>
    <Losungsvers>Psalm 146,8</Losungsvers>
    <Lehrtext>/Die Jünger in Emmaus sprachen untereinander:/ Brannte nicht unser Herz in uns, als er mit uns redete auf dem Wege und uns die Schrift öffnete?</Lehrtext>
    <Lehrtextvers>Lukas 24,32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-10T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Drittletzter Sonntag des Kirchenjahres</Sonntag>
    <Losungstext>Du sollst deinen Vater und deine Mutter ehren.</Losungstext>
    <Losungsvers>2.Mose 20,12</Losungsvers>
    <Lehrtext>Einen Älteren fahre nicht an, sondern ermahne ihn wie einen Vater, die älteren Frauen wie Mütter.</Lehrtext>
    <Lehrtextvers>1.Timotheus 5,1.2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-11T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Sammle meine Tränen in deinen Krug; ohne Zweifel, du zählst sie.</Losungstext>
    <Losungsvers>Psalm 56,9</Losungsvers>
    <Lehrtext>Selig seid ihr, die ihr jetzt weint; denn ihr werdet lachen.</Lehrtext>
    <Lehrtextvers>Lukas 6,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-12T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will dich nicht verlassen, bis ich alles tue, was ich dir zugesagt habe.</Losungstext>
    <Losungsvers>1.Mose 28,15</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ihr werdet die Kraft des Heiligen Geistes empfangen, der auf euch kommen wird, und werdet meine Zeugen sein.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 1,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-13T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Lobe den HERRN, der dir alle deine Sünde vergibt und heilet alle deine Gebrechen.</Losungstext>
    <Losungsvers>Psalm 103,2.3</Losungsvers>
    <Lehrtext>Wir sind wir ja mit ihm begraben durch die Taufe in den Tod, damit, wie Christus auferweckt ist von den Toten durch die Herrlichkeit des Vaters, auch wir in einem neuen Leben wandeln.</Lehrtext>
    <Lehrtextvers>Römer 6,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-14T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Erhalte mich durch dein Wort, dass ich lebe, und lass mich nicht zuschanden werden in meiner Hoffnung.</Losungstext>
    <Losungsvers>Psalm 119,116</Losungsvers>
    <Lehrtext>Seid allezeit bereit zur Verantwortung vor jedermann, der von euch Rechenschaft fordert über die Hoffnung, die in euch ist.</Lehrtext>
    <Lehrtextvers>1.Petrus 3,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-15T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Gott breitet den Himmel aus und geht auf den Wogen des Meers. Er macht den Wagen am Himmel und den Orion und das Siebengestirn und die Sterne des Südens.</Losungstext>
    <Losungsvers>Hiob 9,8.9</Losungsvers>
    <Lehrtext>/Paulus und Barnabas sprachen:/ Wir sind sterbliche Menschen wie ihr und predigen euch das Evangelium, dass ihr euch bekehren sollt zu dem lebendigen Gott, der Himmel und Erde und das Meer und alles, was darin ist, gemacht hat.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 14,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-16T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Gott tut große Dinge, die nicht zu erforschen, und Wunder, die nicht zu zählen sind.</Losungstext>
    <Losungsvers>Hiob 9,10</Losungsvers>
    <Lehrtext>Gelobt sei Gott, der Vater unseres Herrn Jesus Christus, der Vater der Barmherzigkeit und Gott allen Trostes.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-17T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Vorletzter Sonntag des Kirchenjahres</Sonntag>
    <Losungstext>Siehe, ich will die Heiden lehren und meine Kraft und Gewalt ihnen kundtun, dass sie erfahren sollen: Ich heiße der HERR.</Losungstext>
    <Losungsvers>Jeremia 16,21</Losungsvers>
    <Lehrtext>Durch Jesus Christus haben wir empfangen Gnade und Apostelamt, in seinem Namen den Gehorsam des Glaubens aufzurichten unter allen Heiden.</Lehrtext>
    <Lehrtextvers>Römer 1,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-18T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR ist mein Fels und meine Burg und mein Erretter.</Losungstext>
    <Losungsvers>2.Samuel 22,2</Losungsvers>
    <Lehrtext>/Christus spricht:/ Wer zu mir kommt und hört meine Rede und tut sie, der gleicht einem Menschen, der ein Haus baute und grub tief und legte den Grund auf Fels.</Lehrtext>
    <Lehrtextvers>Lukas 6,47-48</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-19T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Sie haben mich oft bedrängt von meiner Jugend auf; aber sie haben mich nicht überwältigt.</Losungstext>
    <Losungsvers>Psalm 129,2</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Gott ist’s, der uns fest macht samt euch in Christus.</Lehrtext>
    <Lehrtextvers>2.Korinther 1,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-20T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag>Buß- und Bettag</Sonntag>
    <Losungstext>Höre mein Gebet, HERR, und vernimm mein Schreien, schweige nicht zu meinen Tränen.</Losungstext>
    <Losungsvers>Psalm 39,13</Losungsvers>
    <Lehrtext>Gott wird abwischen alle Tränen von ihren Augen, und der Tod wird nicht mehr sein, noch Leid noch Geschrei noch Schmerz wird mehr sein; denn das Erste ist vergangen.</Lehrtext>
    <Lehrtextvers>Offenbarung 21,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-21T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Weh denen, die Böses gut und Gutes böse nennen, die aus Finsternis Licht und aus Licht Finsternis machen!</Losungstext>
    <Losungsvers>Jesaja 5,20</Losungsvers>
    <Lehrtext>Sie werden Rechenschaft geben müssen dem, der bereit ist, zu richten die Lebenden und die Toten.</Lehrtext>
    <Lehrtextvers>1.Petrus 4,5</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-22T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst nicht ehebrechen.</Losungstext>
    <Losungsvers>2.Mose 20,14</Losungsvers>
    <Lehrtext>Die Ehe soll in Ehren gehalten werden bei allen.</Lehrtext>
    <Lehrtextvers>Hebräer 13,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-23T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Der HERR sprach: Ich habe vergeben, wie du es erbeten hast.</Losungstext>
    <Losungsvers>4.Mose 14,20</Losungsvers>
    <Lehrtext>Das ist die Zuversicht, die wir haben zu Gott: Wenn wir um etwas bitten nach seinem Willen, so hört er uns.</Lehrtext>
    <Lehrtextvers>1.Johannes 5,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-24T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>Letzter Sonntag des Kirchenjahres (Ewigkeitssonntag)</Sonntag>
    <Losungstext>Der HERR redete mit Mose von Angesicht zu Angesicht, wie ein Mann mit seinem Freunde redet.</Losungstext>
    <Losungsvers>2.Mose 33,11</Losungsvers>
    <Lehrtext>Jesus spricht er zu Thomas: Reiche deinen Finger her und sieh meine Hände, und reiche deine Hand her und lege sie in meine Seite, und sei nicht ungläubig, sondern gläubig!</Lehrtext>
    <Lehrtextvers>Johannes 20,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-25T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Wir haben einen Gott, der da hilft, und den HERRN, der vom Tode errettet.</Losungstext>
    <Losungsvers>Psalm 68,21</Losungsvers>
    <Lehrtext>Weil wir einen großen Hohenpriester haben, Jesus, den Sohn Gottes, der die Himmel durchschritten hat, so lasst uns festhalten an dem Bekenntnis.</Lehrtext>
    <Lehrtextvers>Hebräer 4,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-26T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Einer teilt reichlich aus und hat immer mehr; ein andrer kargt, wo er nicht soll, und wird doch ärmer.</Losungstext>
    <Losungsvers>Sprüche 11,24</Losungsvers>
    <Lehrtext>Seht zu und hütet euch vor aller Habgier; denn niemand lebt davon, dass er viele Güter hat.</Lehrtext>
    <Lehrtextvers>Lukas 12,15</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-27T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Der HERR wird König sein immer und ewig.</Losungstext>
    <Losungsvers>2.Mose 15,18</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Alles ist mir übergeben von meinem Vater.</Lehrtext>
    <Lehrtextvers>Lukas 10,22</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-28T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Der lebendige Gott ist ein Retter und Nothelfer.</Losungstext>
    <Losungsvers>Daniel 6,28</Losungsvers>
    <Lehrtext>Wir haben gesehen und bezeugen, dass der Vater den Sohn gesandt hat als Heiland der Welt.</Lehrtext>
    <Lehrtextvers>1.Johannes 4,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-29T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Verlass dich auf den HERRN von ganzem Herzen, und verlass dich nicht auf deinen Verstand, sondern gedenke an ihn in allen deinen Wegen, so wird er dich recht führen.</Losungstext>
    <Losungsvers>Sprüche 3,5-6</Losungsvers>
    <Lehrtext>Haltet euch nicht selbst für klug.</Lehrtext>
    <Lehrtextvers>Römer 12,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-11-30T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Des Menschen Geist muss davon, und er muss wieder zu Erde werden; dann sind verloren alle seine Pläne.</Losungstext>
    <Losungsvers>Psalm 146,4</Losungsvers>
    <Lehrtext>Trachtet nach dem, was droben ist, nicht nach dem, was auf Erden ist.</Lehrtext>
    <Lehrtextvers>Kolosser 3,2</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-01T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag im Advent</Sonntag>
    <Losungstext>Ein jeder gebe, was er geben kann nach dem Segen, den dir der HERR, dein Gott, beschieden hat.</Losungstext>
    <Losungsvers>5.Mose 16,17</Losungsvers>
    <Lehrtext>Gutes zu tun und mit andern zu teilen vergesst nicht; denn solche Opfer gefallen Gott.</Lehrtext>
    <Lehrtextvers>Hebräer 13,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-02T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du sollst der Menge nicht auf dem Weg zum Bösen folgen.</Losungstext>
    <Losungsvers>2.Mose 23,2</Losungsvers>
    <Lehrtext>Lasst einen neuen Geist euer Denken bestimmen.</Lehrtext>
    <Lehrtextvers>Epheser 4,23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-03T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Ich will euch annehmen zu meinem Volk und will euer Gott sein.</Losungstext>
    <Losungsvers>2.Mose 6,7</Losungsvers>
    <Lehrtext>Alles hat er unter Christi Füße getan und hat ihn gesetzt der Gemeinde zum Haupt über alles, welche sein Leib ist, nämlich die Fülle dessen, der alles in allem erfüllt.</Lehrtext>
    <Lehrtextvers>Epheser 1,22-23</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-04T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich will mich freuen über mein Volk. Man soll in ihm nicht mehr hören die Stimme des Weinens noch die Stimme des Klagens.</Losungstext>
    <Losungsvers>Jesaja 65,19</Losungsvers>
    <Lehrtext>Wir warten auf einen neuen Himmel und eine neue Erde nach seiner Verheißung, in denen Gerechtigkeit wohnt.</Lehrtext>
    <Lehrtextvers>2.Petrus 3,13</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-05T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Gelobt sei Gott, der mein Gebet nicht verwirft noch seine Güte von mir wendet.</Losungstext>
    <Losungsvers>Psalm 66,20</Losungsvers>
    <Lehrtext>Jesus sprach zu der samaritischen Frau: Wenn du erkenntest die Gabe Gottes und wer der ist, der zu dir sagt: Gib mir zu trinken!, du bätest ihn und er gäbe dir lebendiges Wasser.</Lehrtext>
    <Lehrtextvers>Johannes 4,10</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-06T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Alle Morgen weckt er mir das Ohr, dass ich höre, wie Jünger hören.</Losungstext>
    <Losungsvers>Jesaja 50,4</Losungsvers>
    <Lehrtext>Am Morgen, noch vor Tage, stand Jesus auf und ging hinaus. Und er ging an eine einsame Stätte und betete dort.</Lehrtext>
    <Lehrtextvers>Markus 1,35</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-07T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Ich sprach wohl in meinem Zagen: Ich bin von deinen Augen verstoßen. Doch du hörtest die Stimme meines Flehens, als ich zu dir schrie.</Losungstext>
    <Losungsvers>Psalm 31,23</Losungsvers>
    <Lehrtext>/Christus spricht:/ Ich bin der gute Hirte und kenne die Meinen und die Meinen kennen mich.</Lehrtext>
    <Lehrtextvers>Johannes 10,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-08T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>2. Sonntag im Advent</Sonntag>
    <Losungstext>Dem HERRN, eurem Gott, sollt ihr dienen, so wird er dein Brot und dein Wasser segnen.</Losungstext>
    <Losungsvers>2.Mose 23,25</Losungsvers>
    <Lehrtext>/Jesus sprach:/ Ihr sollt nicht sorgen und sagen: Was werden wir essen? Was werden wir trinken? Womit werden wir uns kleiden? Denn euer himmlischer Vater weiß, dass ihr all dessen bedürft.</Lehrtext>
    <Lehrtextvers>Matthäus 6,31.32</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-09T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Was können die Weisen Weises lehren, wenn sie des HERRN Wort verwerfen?</Losungstext>
    <Losungsvers>Jeremia 8,9</Losungsvers>
    <Lehrtext>Der Gott unseres Herrn Jesus Christus, der Vater der Herrlichkeit, gebe euch den Geist der Weisheit und der Offenbarung, ihn zu erkennen.</Lehrtext>
    <Lehrtextvers>Epheser 1,17</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-10T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Eine linde Antwort stillt den Zorn; aber ein hartes Wort erregt Grimm.</Losungstext>
    <Losungsvers>Sprüche 15,1</Losungsvers>
    <Lehrtext>Ein jeder Mensch sei schnell zum Hören, langsam zum Reden, langsam zum Zorn.</Lehrtext>
    <Lehrtextvers>Jakobus 1,19</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-11T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Tu wohl an Zion nach deiner Gnade.</Losungstext>
    <Losungsvers>Psalm 51,20</Losungsvers>
    <Lehrtext>Seht, welch eine Liebe hat uns der Vater erwiesen, dass wir Gottes Kinder heißen sollen - und wir sind es auch!</Lehrtext>
    <Lehrtextvers>1.Johannes 3,1</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-12T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Ist denn die Hand des HERRN zu kurz? Aber du sollst jetzt sehen, ob sich dir mein Wort erfüllt oder nicht.</Losungstext>
    <Losungsvers>4.Mose 11,23</Losungsvers>
    <Lehrtext>Was Gott verheißt, das kann er auch tun.</Lehrtext>
    <Lehrtextvers>Römer 4,21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-13T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Deine Hand hat mich gemacht und bereitet; unterweise mich, dass ich deine Gebote lerne.</Losungstext>
    <Losungsvers>Psalm 119,73</Losungsvers>
    <Lehrtext>/Christus spricht:/ Das ist mein Gebot, dass ihr euch untereinander liebt, wie ich euch liebe.</Lehrtext>
    <Lehrtextvers>Johannes 15,12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-14T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Wer der Gerechtigkeit und Güte nachjagt, der findet Leben und Ehre.</Losungstext>
    <Losungsvers>Sprüche 21,21</Losungsvers>
    <Lehrtext>Trachtet zuerst nach dem Reich Gottes und nach seiner Gerechtigkeit, so wird euch das alles zufallen.</Lehrtext>
    <Lehrtextvers>Matthäus 6,33</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-15T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>3. Sonntag im Advent</Sonntag>
    <Losungstext>/Der HERR spricht:/ Wer mich ehrt, den ehre ich; wer mich verachtet, der wird zuschanden.</Losungstext>
    <Losungsvers>1.Samuel 2,30</Losungsvers>
    <Lehrtext>Irret euch nicht! Gott lässt sich nicht spotten. Denn was der Mensch sät, das wird er ernten.</Lehrtext>
    <Lehrtextvers>Galater 6,7</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-16T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Du, HERR, segnest die Gerechten, du deckest sie mit Gnade wie mit einem Schilde.</Losungstext>
    <Losungsvers>Psalm 5,13</Losungsvers>
    <Lehrtext>Ergreift den Schild des Glaubens, mit dem ihr auslöschen könnt alle feurigen Pfeile des Bösen.</Lehrtext>
    <Lehrtextvers>Epheser 6,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-17T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag />
    <Losungstext>Jakob sprach zu seinem Hause: Tut von euch die fremden Götter, die unter euch sind, und reinigt euch.</Losungstext>
    <Losungsvers>1.Mose 35,2</Losungsvers>
    <Lehrtext>Denn wo euer Schatz ist, da wird auch euer Herz sein.</Lehrtext>
    <Lehrtextvers>Lukas 12,34</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-18T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag />
    <Losungstext>Ich, der HERR, das ist mein Name, ich will meine Ehre keinem andern geben noch meinen Ruhm den Götzen.</Losungstext>
    <Losungsvers>Jesaja 42,8</Losungsvers>
    <Lehrtext>Wer sollte dich, Herr, nicht fürchten und deinen Namen nicht preisen? Denn du allein bist heilig!</Lehrtext>
    <Lehrtextvers>Offenbarung 15,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-19T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag />
    <Losungstext>Mein Wort wird nicht wieder leer zu mir zurückkommen, sondern wird tun, was mir gefällt, und ihm wird gelingen, wozu ich es sende.</Losungstext>
    <Losungsvers>Jesaja 55,11</Losungsvers>
    <Lehrtext>Eine gottesfürchtige Frau mit Namen Lydia, eine Purpurhändlerin aus der Stadt Thyatia, hörte zu; der tat der Herr das Herz auf.</Lehrtext>
    <Lehrtextvers>Apostelgeschichte 16,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-20T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Ihr sollt nichts dazutun zu dem, was ich euch gebiete, und sollt auch nichts davontun, auf dass ihr bewahrt die Gebote des HERRN, eures Gottes.</Losungstext>
    <Losungsvers>5.Mose 4,2</Losungsvers>
    <Lehrtext>Gib acht auf dich und auf die Lehre, bleib bei alledem! Denn wenn du dies tust, wirst du sowohl dich retten als auch die, die auf dich hören.</Lehrtext>
    <Lehrtextvers>1.Timotheus 4,16</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-21T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>Sechs Tage sollst du arbeiten; am siebenten Tage sollst du ruhen.</Losungstext>
    <Losungsvers>2.Mose 34,21</Losungsvers>
    <Lehrtext>Der Sabbat ist um des Menschen willen gemacht und nicht der Mensch um des Sabbats willen.</Lehrtext>
    <Lehrtextvers>Markus 2,27</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-22T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>4. Sonntag im Advent</Sonntag>
    <Losungstext>Das Gesetz des HERRN ist vollkommen und erquickt die Seele.</Losungstext>
    <Losungsvers>Psalm 19,8</Losungsvers>
    <Lehrtext>Daran merken wir, dass wir ihn kennen, wenn wir seine Gebote halten.</Lehrtext>
    <Lehrtextvers>1.Johannes 2,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-23T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Israel ward durch den Herrn errettet, errettet für alle Zeit; ihr werdet nicht zuschanden, nicht mit Schmach bedeckt werden in Ewigkeit.</Losungstext>
    <Losungsvers>Jesaja 45,17</Losungsvers>
    <Lehrtext>Der Engel des Herrn sprach im Traum: Maria wird einen Sohn gebären, dem sollst du den Namen Jesus geben, denn er wird sein Volk retten von ihren Sünden.</Lehrtext>
    <Lehrtextvers>Matthäus 1,20.21</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-24T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag>Heiliger Abend</Sonntag>
    <Losungstext>Gelobt sei der Herr täglich. Gott legt uns eine Last auf, aber er hilft uns auch.</Losungstext>
    <Losungsvers>Psalm 68,20</Losungsvers>
    <Lehrtext>Die Menge der himmlischen Heerscharen lobten Gott und sprachen: Ehre sei Gott in der Höhe und Friede auf Erden bei den Menschen seines Wohlgefallens.</Lehrtext>
    <Lehrtextvers>Lukas 2,13-14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-25T00:00:00</Datum>
    <Wtag>Mittwoch</Wtag>
    <Sonntag>Weihnachtsfest</Sonntag>
    <Losungstext>Du hast Menschen über unser Haupt dahinfahren lassen. Wir sind durch Feuer und Wasser gegangen, aber du hast uns herausgeführt ins Weite.</Losungstext>
    <Losungsvers>Psalm 66,12</Losungsvers>
    <Lehrtext>/Christus spricht:/ Meine Schafe hören meine Stimme, und ich kenne sie und sie folgen mir; und ich gebe ihnen das ewige Leben, und sie werden nimmermehr umkommen, und niemand wird sie aus meiner Hand reißen.</Lehrtext>
    <Lehrtextvers>Johannes 10,27-28</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-26T00:00:00</Datum>
    <Wtag>Donnerstag</Wtag>
    <Sonntag>2. Weihnachtstag</Sonntag>
    <Losungstext>HERR Zebaoth, du bist allein Gott über alle Königreiche auf Erden, du hast Himmel und Erde gemacht.</Losungstext>
    <Losungsvers>Jesaja 37,16</Losungsvers>
    <Lehrtext>Gelobt sei Gott, der Vater unseres Herrn Jesus Christus, der uns gesegnet hat mit allem geistlichen Segen im Himmel durch Christus.</Lehrtext>
    <Lehrtextvers>Epheser 1,3</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-27T00:00:00</Datum>
    <Wtag>Freitag</Wtag>
    <Sonntag />
    <Losungstext>Die dich, HERR, lieben, sind wie die Sonne, wenn sie aufgeht in ihrer Pracht.</Losungstext>
    <Losungsvers>Richter 5,31</Losungsvers>
    <Lehrtext>Ihr wart früher Finsternis; nun aber seid ihr Licht in dem Herrn. Lebt als Kinder des Lichts.</Lehrtext>
    <Lehrtextvers>Epheser 5,8</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-28T00:00:00</Datum>
    <Wtag>Samstag</Wtag>
    <Sonntag />
    <Losungstext>/Der HERR sprach zu Abram:/ Ich will dich segnen, und du sollst ein Segen sein.</Losungstext>
    <Losungsvers>1.Mose 12,2</Losungsvers>
    <Lehrtext>Segnet, die euch verfolgen; segnet, und flucht nicht.</Lehrtext>
    <Lehrtextvers>Römer 12,14</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-29T00:00:00</Datum>
    <Wtag>Sonntag</Wtag>
    <Sonntag>1. Sonntag nach Weihnachten</Sonntag>
    <Losungstext>Ich denke an die früheren Zeiten; ich sinne nach über all deine Taten und spreche von den Werken deiner Hände.</Losungstext>
    <Losungsvers>Psalm 143,5</Losungsvers>
    <Lehrtext>/Paulus schreibt:/ Ich tue euch kund, dass das Evangelium, das von mir gepredigt ist, nicht von menschlicher Art ist. Denn ich habe es nicht von einem Menschen empfangen oder gelernt, sondern durch eine Offenbarung Jesu Christi.</Lehrtext>
    <Lehrtextvers>Galater 1,11-12</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-30T00:00:00</Datum>
    <Wtag>Montag</Wtag>
    <Sonntag />
    <Losungstext>Ihr trinkt Wein aus Schalen und salbt euch mit dem besten Öl, aber bekümmert euch nicht um den Schaden Josefs.</Losungstext>
    <Losungsvers>Amos 6,6</Losungsvers>
    <Lehrtext>Ein jeder sehe nicht auf das Seine, sondern auch auf das, was dem andern dient.</Lehrtext>
    <Lehrtextvers>Philipper 2,4</Lehrtextvers>
  </Losungen>
  <Losungen>
    <Datum>2013-12-31T00:00:00</Datum>
    <Wtag>Dienstag</Wtag>
    <Sonntag>Altjahrsabend</Sonntag>
    <Losungstext>Der HERR verstößt nicht ewig; sondern er betrübt wohl und erbarmt sich wieder nach seiner großen Güte.</Losungstext>
    <Losungsvers>Klagelieder 3,31-32</Losungsvers>
    <Lehrtext>Durch die Gnade seid ihr gerettet aufgrund des Glaubens, und zwar nicht aus euch selbst, nein, Gottes Gabe ist es.</Lehrtext>
    <Lehrtextvers>Epheser 2,8</Lehrtextvers>
  </Losungen>
</FreeXml>]]></data>
	</file>
	<file>
	  <filename>/losungen/Nutzungsbedingungen_10.2010.pdf</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[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]]></data>
	</file>
	<file>
	  <filename>/method.install.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQojDQojIE1vZHVsZSA6IExvc3VuZ2VuIChjKSAyMDEyIGJ5IGJsYXR0ZXJ0ZWNoIGluZm9ybWF0aWsgKGluZm9AYmxhdHRlcnRlY2guY2gpDQojICAgICAgICAgIEhlcnJuaHV0ZXIgTG9zdW5nZW4gZsO8ciBDTVMgTWFkZSBTaW1wbGUNCiMgICAgICAgICAgVGhlIHByb2plY3RzIGhvbWVwYWdlIGlzIGRldi5jbXNtYWRlc2ltcGxlLm9yZy9wcm9qZWN0cy9sb3N1bmcvDQojICAgICAgICAgIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNC0yMDExIGJ5IFRlZCBLdWxwDQojICAgICAgICAgIFRoZSBwcm9qZWN0cyBob21lcGFnZSBpczogY21zbWFkZXNpbXBsZS5vcmcNCiMgVmVyc2lvbjogMS4wLjENCiMgRmlsZSAgIDogbWV0aG9kLmluc3RhbGwucGhwDQojIFB1cnBvc2U6IGluc3RhbGwgbW9kdWxlIHNldHRpbmdzDQojIExpY2Vuc2U6IEdQTA0KIw0KIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0NCg0KJGRiID0gY21zbXMoKS0+R2V0RGIoKTsNCg0KLy8gaW1wb3J0IHRlbXBsYXRlDQokZmlsZW5hbWUgPSAkZmlsZW5hbWUgPSByZWFscGF0aChkaXJuYW1lKF9fRklMRV9fKSAuIi90ZW1wbGF0ZXMvbG9zdW5nLnRwbCIpOw0KJHRlbXBsYXRlID0gIiI7CQ0KaWYgKGlzX2ZpbGUoJGZpbGVuYW1lKSkgJHRlbXBsYXRlID0gZmlsZV9nZXRfY29udGVudHMoJGZpbGVuYW1lKTsNCg0KJHRoaXMtPlNldFRlbXBsYXRlKCJsb3N1bmdlbiIsICR0ZW1wbGF0ZSk7DQoNCi8vIGltcG9ydCBTdHlsZXNoZWV0DQokZmlsZW5hbWUgPSAkZmlsZW5hbWUgPSByZWFscGF0aChkaXJuYW1lKF9fRklMRV9fKSAuIi90ZW1wbGF0ZXMvbG9zdW5nLmNzcyIpOw0KaWYgKGlzX2ZpbGUoJGZpbGVuYW1lKSkgew0KCSRjc3MgPSBmaWxlX2dldF9jb250ZW50cygkZmlsZW5hbWUpOw0KCSRjc3NfaWQgPSAkZGItPkdlbklEKGNtc19kYl9wcmVmaXgoKS4nY3NzX3NlcScpOw0KCSRkYi0+RXhlY3V0ZSgnaW5zZXJ0IGludG8gJy5jbXNfZGJfcHJlZml4KCkuJ2NzcyAoY3NzX2lkLCBjc3NfbmFtZSwgY3NzX3RleHQsIG1lZGlhX3R5cGUsIGNyZWF0ZV9kYXRlKSB2YWx1ZXMgKD8sPyw/LD8sPyknLA0KCQlhcnJheSgkY3NzX2lkLCdMb3N1bmdlbicsJGNzcywnc2NyZWVuJyxkYXRlKCdZLW0tZCcpKSk7DQp9DQoNCi8vIHNldCBwZXJtaXNzaW9uDQokdGhpcy0+Q3JlYXRlUGVybWlzc2lvbignVXNlIExvc3VuZ2VuJywgJ1VzZSBMb3N1bmdlbicpOw0KDQovLyBtZXNzYWdlDQokdGhpcy0+QXVkaXQoMCwgJHRoaXMtPkxhbmcoJ2ZyaWVuZGx5bmFtZScpLCAkdGhpcy0+TGFuZygnaW5zdGFsbGVkJywgJHRoaXMtPkdldFZlcnNpb24oKSkpOw0K]]></data>
	</file>
	<file>
	  <filename>/method.uninstall.php</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PD9waHANCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQojDQojIE1vZHVsZSA6IExvc3VuZ2VuIChjKSAyMDEyIGJ5IGJsYXR0ZXJ0ZWNoIGluZm9ybWF0aWsgKGluZm9AYmxhdHRlcnRlY2guY2gpDQojICAgICAgICAgIEhlcnJuaHV0ZXIgTG9zdW5nZW4gZsO8ciBDTVMgTWFkZSBTaW1wbGUNCiMgICAgICAgICAgVGhlIHByb2plY3RzIGhvbWVwYWdlIGlzIGRldi5jbXNtYWRlc2ltcGxlLm9yZy9wcm9qZWN0cy9sb3N1bmcvDQojICAgICAgICAgIENNUyBNYWRlIFNpbXBsZSBpcyAoYykgMjAwNC0yMDExIGJ5IFRlZCBLdWxwDQojICAgICAgICAgIFRoZSBwcm9qZWN0cyBob21lcGFnZSBpczogY21zbWFkZXNpbXBsZS5vcmcNCiMgVmVyc2lvbjogMS4wLjENCiMgRmlsZSAgIDogbWV0aG9kLnVuaW5zdGFsbC5waHANCiMgUHVycG9zZTogdW5pbnN0YWxsIG1vZHVsZQ0KIyBMaWNlbnNlOiBHUEwNCiMNCiMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tDQoNCiR0aGlzLT5EZWxldGVUZW1wbGF0ZSgpOw0KJHRoaXMtPlJlbW92ZVByZWZlcmVuY2UoKTsNCiR0aGlzLT5SZW1vdmVQZXJtaXNzaW9uKCk7DQoNCiR0aGlzLT5BdWRpdCgwLCAkdGhpcy0+TGFuZygnZnJpZW5kbHluYW1lJyksICR0aGlzLT5MYW5nKCd1bmluc3RhbGxlZCcpKTsNCg==]]></data>
	</file>
	<file>
	  <filename>/templates/</filename>
	  <isdir>1</isdir>
	</file>
	<file>
	  <filename>/templates/admin_losung.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[77u/eyRzdGFydEZvcm19DQo8ZmllbGRzZXQ+DQo8bGVnZW5kPnskZ2xvYmFsb3B0aW9uc308L2xlZ2VuZD4NCgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPg0KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X2xpemVuen06PC9wPg0KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JHByb21wdF9saXplbnpoaW53ZWlzfTwvcD4NCgk8L2Rpdj4NCgk8ZGl2IGNsYXNzPSJwYWdlb3ZlcmZsb3ciPg0KCQk8cCBjbGFzcz0icGFnZXRleHQiPnskcHJvbXB0X3RlbXBsYXRlfTo8L3A+DQoJCTxwIGNsYXNzPSJwYWdlaW5wdXQiPnskaW5wdXRfdGVtcGxhdGV9PC9wPg0KCTwvZGl2Pg0KCTxkaXYgY2xhc3M9InBhZ2VvdmVyZmxvdyI+DQoJCTxwIGNsYXNzPSJwYWdldGV4dCI+Jm5ic3A7PC9wPg0KCQk8cCBjbGFzcz0icGFnZWlucHV0Ij57JHN1Ym1pdH0geyRyZXNldH08L3A+DQoJPC9kaXY+DQo8L2ZpZWxkc2V0Pg0KeyRlbmRGb3JtfQ==]]></data>
	</file>
	<file>
	  <filename>/templates/losung.css</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[I2xvc3VuZyB7DQoJcGFkZGluZzogNXB4OwkNCglib3JkZXI6IDFweCBzb2xpZCAjY2NjOw0KCWJhY2tncm91bmQ6ICNmZmY7DQoJd2lkdGg6IDM1MHB4Ow0KfQ0KDQojbG9zdW5nIGgzIHsNCgliYWNrZ3JvdW5kOiAjMjQzODdGOw0KCWNvbG9yOiAjZmZmOw0KCWZvbnQtc2l6ZTogMS4zZW07DQoJcGFkZGluZzogN3B4Ow0KCXRleHQtYWxpZ246IGNlbnRlcjsJDQoJbWFyZ2luLWJvdHRvbTogMTVweDsNCn0NCg0KI2xvc3VuZyB1bC5sb3N1bmcgew0KCWxpc3Qtc3R5bGUtdHlwZTpzcXVhcmU7DQp9DQoNCiNsb3N1bmcgLnZlcnMgew0KCWNvbG9yOiAjMDAwOw0KCWZvbnQtc2l6ZTogMWVtOw0KCW1hcmdpbjogMCAwIDVweCAwOw0KCXBhZGRpbmc6IDA7CQ0KfQ0KDQojbG9zdW5nIC5iaWJlbCB7DQoJY29sb3I6ICMwMDA7DQoJZm9udC1zaXplOiAxZW07DQoJcGFkZGluZzogMDsJDQp9DQoNCiNsb3N1bmcgLmJpYmVsIGEgew0KCWNvbG9yOiAjMDAwOw0KCWZvbnQtc2l6ZTogMWVtOw0KfQ0KI2xvc3VuZyAuY29weXJpZ2h0IHsNCgl0ZXh0LWFsaWduOiBjZW50ZXI7DQp9DQojbG9zdW5nIC5jb3B5cmlnaHQgYSB7DQoJY29sb3I6ICM2NjY3NkU7DQoJZm9udC1zaXplOiAwLjllbTsNCn0NCg0KI2xvc3VuZyBhOmhvdmVyIHsNCgl0ZXh0LWRlY29yYXRpb246IHVuZGVybGluZTsNCn0=]]></data>
	</file>
	<file>
	  <filename>/templates/losung.tpl</filename>
	  <isdir>0</isdir>
	  <data><![CDATA[PGRpdiBpZD0ibG9zdW5nIj4NCjxoMz5Mb3N1bmcgdm9tIHskbG9zdW5nLT5kYXR1bX08L2gzPg0KPHVsIGNsYXNzPSJsb3N1bmciPg0KICA8bGkgY2xhc3M9Imxvc3VuZyI+DQogICAgPHAgY2xhc3M9InZlcnMiPnskbG9zdW5nLT5sb3N1bmdzdGV4dH08L3A+DQogICAgPHAgY2xhc3M9ImJpYmVsIj48YSBocmVmPSJ7JGxvc3VuZy0+bG9zdW5nc3ZlcnNsaW5rfSIgdGFyZ2V0PSJfYmxhbmsiIHRpdGxlPSJCaWJlbHN0ZWxsZSBhdWYgYmlibGVzZXJ2ZXIuY29tIG5hY2hzY2hsYWdlbiI+eyRsb3N1bmctPmxvc3VuZ3N2ZXJzfTwvYT48L3A+DQogIDwvbGk+DQogIDxsaSBjbGFzcz0ibGVocnRleHQiPgkJDQogICAgPHAgY2xhc3M9InZlcnMiPnskbG9zdW5nLT5sZWhydGV4dH08L3A+DQogICAgPHAgY2xhc3M9ImJpYmVsIj48YSBocmVmPSJ7JGxvc3VuZy0+bGVocnZlcnNsaW5rfSIgdGFyZ2V0PSJfYmxhbmsiIHRpdGxlPSJCaWJlbHN0ZWxsZSBhdWYgYmlibGVzZXJ2ZXIuY29tIG5hY2hzY2hsYWdlbiI+eyRsb3N1bmctPmxlaHJ2ZXJzfTwvYT48L3A+DQogIDwvbGk+DQo8L3VsPg0KPHAgY2xhc3M9ImNvcHlyaWdodCI+eyRsb3N1bmctPmNvcHlyaWdodH08L3A+DQo8L2Rpdj4=]]></data>
	</file>
</module>
