diff --git a/dcnsanplanung.bewertung/BewM149.cs b/dcnsanplanung.bewertung/BewM149.cs
index 00dd9a2..46312b1 100644
--- a/dcnsanplanung.bewertung/BewM149.cs
+++ b/dcnsanplanung.bewertung/BewM149.cs
@@ -69,6 +69,98 @@ namespace dcnsanplanung.bewertung
             int ZustandPunkteD = startWertD + (int)zuschlagD;
             int ZustandPunkteB = startWertB + (int)zuschlagB;
             int ZustandPunkteS = startWertS + (int)zuschlagS;
+
+            int BewertungspunkteD = ZustandPunkteD + 500 + RD(EBaujahr.VOR1965, EEinstau.NICHTEINGEHALTEN, ELageGrundWasser.IM);
+            int BewertungspunkteS = ZustandPunkteS + 500 + RS(EUeberdeckung.KLEINER25, EBodenGruppe.BG4);
+            int BewertungspunkteB = ZustandPunkteB + 500 + RB(EEinstau.NICHTEINGEHALTEN, EUeberdeckung.KLEINER25);
+
+            // Sanierungsbedarfzahl errechnen
+            List<int> ints = new List<int>();
+            ints.Add(BewertungspunkteB);
+            ints.Add(BewertungspunkteS);
+            ints.Add(BewertungspunkteD);
+
+            int bp1 = ints.Max();
+            int bp3 = ints.Min();
+            int bp2 = ints.Sum() - bp1 - bp3;
+
+            int restbp1 = Convert.ToInt32(bp1.ToString().Substring(1));
+            int restbp2 = Convert.ToInt32(bp2.ToString().Substring(1));
+            int restbp3 = Convert.ToInt32(bp3.ToString().Substring(1));
+
+            int rest = (restbp1 + restbp2 + restbp3) / 30;
+
+            string sanierungszahl = string.Format("{0}{1}{2}{3}",(int)(bp1 / 100),(int)(bp2 /100),(int)(bp3 / 100),rest);
+
+            int sanzahl = Convert.ToInt32(sanierungszahl);
+        }
+
+        public static Tuple<string,string> Beurteilung(int sanierungsbedarfzahl)
+        {
+            switch(sanierungsbedarfzahl)
+            {
+                case >= 9000: return new Tuple<string, string>("sofort", "sehr starker Mangel / Gefahr im Verzuge");
+                case >= 8000: return new Tuple<string, string>("kurzfristig", "starker Mangel");
+                case >= 7000: return new Tuple<string, string>("mittelfristig", "mittlere Mangel");
+                case >= 6000: return new Tuple<string, string>("langfristig", "leichter Mangel");
+                case >= 5000: return new Tuple<string, string>("keiner (geringfügige Schäden", "geringfügiger Mangel");
+                default: return new Tuple<string, string>("schadensfrei", "kein Mangel");
+            }
+        }
+
+        public enum EBaujahr
+        {
+            VOR1965,
+            NACH1965
+        }
+        public enum EEinstau
+        {
+            EINGEHALTEN,
+            NICHTEINGEHALTEN
+        }
+        public enum ELageGrundWasser
+        {
+            IM,
+            AUSSER, 
+            WECHSEL
+        }
+        public enum EUeberdeckung
+        {
+            KLEINER25,
+            ZWISCHEN25UND4,
+            GROESSER4
+
+        }
+        public enum EBodenGruppe
+        {
+            BG1,
+            BG2,
+            BG3,
+            BG4
+        }
+        public static int RD(EBaujahr eBaujahr, EEinstau eEinstau, ELageGrundWasser eLageGrundWasser)
+        {
+            int ver1 = eBaujahr == EBaujahr.VOR1965 ? 1 : 0;
+            int ver2 = eEinstau == EEinstau.EINGEHALTEN ? 0 : 1;
+            decimal ver3 = eLageGrundWasser == ELageGrundWasser.IM ? 1 : eLageGrundWasser == ELageGrundWasser.WECHSEL ? 0.5m : 0;
+            decimal summe = ((ver1+ver2+ver3) / 3) * 50;
+            return (int)Math.Ceiling(summe);
+        }
+        public static int RB(EEinstau eEinstau, EUeberdeckung eUeberdeckung)
+        {
+            int ver1 = eEinstau == EEinstau.EINGEHALTEN ? 0 : 1;
+            decimal ver2 = eUeberdeckung == EUeberdeckung.KLEINER25 ? 1 : eUeberdeckung == EUeberdeckung.ZWISCHEN25UND4 ? 0.5m : 0;
+            decimal summe = ((ver1+ ver2) / 2)*50;
+            return (int)Math.Ceiling(summe);
+        }
+
+       
+        public static int RS(EUeberdeckung eUeberdeckung, EBodenGruppe eBodenGruppe)
+        {
+            decimal ver1 = eUeberdeckung == EUeberdeckung.KLEINER25 ? 1 : eUeberdeckung == EUeberdeckung.ZWISCHEN25UND4 ? 0.5m : 0;
+            decimal ver2 = eBodenGruppe == EBodenGruppe.BG1 ? 0 : eBodenGruppe == EBodenGruppe.BG2 ? 0 : eBodenGruppe == EBodenGruppe.BG3 ? 0.5m : 1;
+            decimal summe = ((ver1 + ver2) / 2) * 50;
+            return (int)Math.Ceiling(summe);
         }
         public static Dictionary<string, int> Klassifiziere(string hauptcode, string ch1, string ch2, string q1, string q2, int dn)
         {
diff --git a/dcnsanplanung.bewertungTests/BewM149Tests.cs b/dcnsanplanung.bewertungTests/BewM149Tests.cs
index ef5a3f0..317f987 100644
--- a/dcnsanplanung.bewertungTests/BewM149Tests.cs
+++ b/dcnsanplanung.bewertungTests/BewM149Tests.cs
@@ -21,10 +21,29 @@ namespace dcnsanplanung.bewertung.Tests
         [TestMethod()]
         public void SXjTest()
         {
-            
-            Assert.AreEqual(0, BewM149.SXj(5,2.5f));
+
+            Assert.AreEqual(0, BewM149.SXj(5, 2.5f));
             Assert.AreEqual(7.5, BewM149.SXj(2, 2.5f));
             Assert.AreEqual(5, BewM149.SXj(3, 2.5f));
         }
+
+        [TestMethod()]
+        public void RDTest()
+        {
+            Assert.AreEqual(9, BewM149.RD(BewM149.EBaujahr.NACH1965, BewM149.EEinstau.EINGEHALTEN, BewM149.ELageGrundWasser.WECHSEL));
+
+        }
+
+        [TestMethod()]
+        public void RSTest()
+        {
+            Assert.AreEqual(13, BewM149.RS(BewM149.EUeberdeckung.ZWISCHEN25UND4, BewM149.EBodenGruppe.BG2));
+        }
+
+        [TestMethod()]
+        public void RBTest()
+        {
+            Assert.AreEqual(13, BewM149.RB(BewM149.EEinstau.EINGEHALTEN, BewM149.EUeberdeckung.ZWISCHEN25UND4));
+        }
     }
 }
\ No newline at end of file