diff --git a/src/tbitfield.cpp b/src/tbitfield.cpp
index 3bfa48182..680857e68 100644
--- a/src/tbitfield.cpp
+++ b/src/tbitfield.cpp
@@ -1,7 +1,7 @@
 // ННГУ, ВМК, Курс "Методы программирования-2", С++, ООП
 //
 // tbitfield.cpp - Copyright (c) Гергель В.П. 07.05.2001
-//   Переработано для Microsoft Visual Studio 2008 Сысоевым А.В. (19.04.2015)
+// Переработано для Microsoft Visual Studio 2008 Сысоевым А.В. (19.04.2015)
 //
 // Битовое поле
 
@@ -13,86 +13,227 @@ static TBitField FAKE_BITFIELD(1);
 
 TBitField::TBitField(int len)
 {
+    if (len < 0)
+        throw ("negative lenght");
+    BitLen = len;
+    if (len % 32 == 0)
+    {
+        MemLen = len / (sizeof(TELEM) * 8);
+    }
+    else
+    {
+        MemLen = len / (sizeof(TELEM) * 8) + 1;
+    }  
+    pMem = new TELEM [MemLen] {0};
 }
 
-TBitField::TBitField(const TBitField &bf) // конструктор копирования
+TBitField::TBitField(const TBitField& bf) // конструктор копирования
 {
+    BitLen = bf.BitLen;
+    MemLen = bf.MemLen;
+    pMem = new TELEM [MemLen];
+    for (int i = 0; i < MemLen; i++) {
+        pMem[i] = bf.pMem[i];
+    }
 }
 
 TBitField::~TBitField()
 {
+    BitLen = 0;
+    MemLen = 0;
+    delete[] pMem;
 }
 
 int TBitField::GetMemIndex(const int n) const // индекс Мем для бита n
 {
-    return FAKE_INT;
+  if ((n < 0) || (n > BitLen))
+        throw ("Error input");
+    return n / (sizeof(TELEM) * 8);
 }
 
 TELEM TBitField::GetMemMask(const int n) const // битовая маска для бита n
 {
-    return FAKE_INT;
+   if ((n < 0) || (n > BitLen))
+        throw ("Error input");
+    const int j = n % (sizeof(TELEM) * 8);
+    const TELEM mask = (1 << j);
+    return mask;
 }
 
 // доступ к битам битового поля
 
 int TBitField::GetLength(void) const // получить длину (к-во битов)
 {
-  return FAKE_INT;
+    return BitLen;
 }
 
 void TBitField::SetBit(const int n) // установить бит
 {
+    if ((n < 0) || (n > BitLen))
+    {
+       throw ("Error input");
+    }
+    const int i = GetMemIndex(n);
+    const int p = GetMemMask(n);
+    pMem[i] = (pMem[i] | p);
 }
 
 void TBitField::ClrBit(const int n) // очистить бит
 {
+    if ((n < 0) || (n > BitLen))
+    {
+        throw ("Error input");
+    }
+    const int i = GetMemIndex(n);
+    const int p = GetMemMask(n);
+    pMem[i] = (pMem[i] & (~p));
 }
 
 int TBitField::GetBit(const int n) const // получить значение бита
 {
-  return FAKE_INT;
+    if ((n < 0) || (n > BitLen))
+    {
+       throw ("Error input");
+    }
+
+    const int i = GetMemIndex(n);
+    const int p = GetMemMask(n);
+    return (pMem[i] & p);
 }
 
 // битовые операции
 
-TBitField& TBitField::operator=(const TBitField &bf) // присваивание
+TBitField& TBitField::operator=(const TBitField& bf) // присваивание
 {
-    return FAKE_BITFIELD;
+    BitLen = bf.BitLen;
+    MemLen = bf.MemLen;
+    pMem = new TELEM [MemLen];
+    for (int i = 0; i < MemLen; i++)
+        pMem[i] = bf.pMem[i];
+    return *this;
 }
 
-int TBitField::operator==(const TBitField &bf) const // сравнение
+int TBitField::operator==(const TBitField& bf) const // сравнение
 {
-  return FAKE_INT;
+
+    if (BitLen != bf.BitLen)
+        return 0;
+    for (int i = 0; i < MemLen; i++)
+        if (pMem[i] != bf.pMem[i])
+            return 0;
+    return 1;
 }
 
-int TBitField::operator!=(const TBitField &bf) const // сравнение
+int TBitField::operator!=(const TBitField& bf) const // сравнение
 {
-  return FAKE_INT;
+    //if (BitLen == bf.BitLen)
+    //    return 0;
+    //for (int i = 0; i < MemLen; i++)
+    //    if (pMem[i] == bf.pMem[i])
+    //        return 0;
+    //if (BitLen == bf.BitLen)
+    //    return 0;
+    //return 1;
+    return !(*this == bf);
 }
 
-TBitField TBitField::operator|(const TBitField &bf) // операция "или"
+TBitField TBitField::operator|(const TBitField& bf) // операция "или"
 {
-    return FAKE_BITFIELD;
+    int len = BitLen;
+    if (bf.BitLen > len)
+        len = bf.BitLen;
+    TBitField a(len);
+
+    for (int i = 0; i < a.MemLen; i++)
+        a.pMem[i] = pMem[i];
+    for (int j = 0; j < bf.MemLen; j++)
+        a.pMem[j] |= bf.pMem[j];
+    return a;
 }
 
-TBitField TBitField::operator&(const TBitField &bf) // операция "и"
+TBitField TBitField::operator&(const TBitField& bf) // операция "и"
 {
-    return FAKE_BITFIELD;
+    int len = BitLen;
+    if (bf.BitLen > len)
+        len = bf.BitLen;
+    TBitField a(len);
+
+    for (int i = 0; i < a.MemLen; i++)
+        a.pMem[i] = pMem[i];
+    for (int j = 0; j < bf.MemLen; j++)
+        a.pMem[j] &= bf.pMem[j];
+    return a;
 }
 
 TBitField TBitField::operator~(void) // отрицание
 {
-    return FAKE_BITFIELD;
+    TBitField a(BitLen);
+    TELEM tmp = sizeof(TELEM) * 8;
+
+    for (int i = 0; i < MemLen; i++)
+    {
+        a.pMem[i] = ~pMem[i];
+        if (i == MemLen - 1)
+        {
+            for (int j = BitLen % tmp; j < tmp; j++)
+            {
+                a.pMem[i] &= ~(1 << j);
+            }
+        }
+    }
+
+    //for (int i = 0; i < MemLen; i++)
+    //{
+    //    a.pMem[i] = ~pMem[i];
+    //}
+    //
+    //for (int i = BitLen % tmp; i < tmp; i++)
+    //{
+    //    a.pMem[MemLen - 1] &= ~(1 << i);
+    //}
+  //
+  //........................
+    return a;
 }
 
 // ввод/вывод
 
 istream &operator>>(istream &istr, TBitField &bf) // ввод
 {
+    char c;
+    int i = 0;
+    while (true)
+    {
+        istr >> c;
+        if (c == '0')
+        {
+            bf.ClrBit(i); 
+            i++;
+        }
+        else if (c == '1')
+        {
+            bf.SetBit(i);
+            i++;
+        }
+        else
+        {
+            break;
+        }
+    }
     return istr;
 }
-
 ostream &operator<<(ostream &ostr, const TBitField &bf) // вывод
 {
+    for (int i = 0; i < bf.BitLen; i++)
+    {
+        if (bf.GetBit(i) == 0)
+        {
+            ostr << '0';
+        }
+        else
+        {
+            ostr << '1';
+        }
+    }
     return ostr;
 }
diff --git a/src/tset.cpp b/src/tset.cpp
index e70a76e58..d4fc82998 100644
--- a/src/tset.cpp
+++ b/src/tset.cpp
@@ -12,93 +12,153 @@ static const int FAKE_INT = -1;
 static TBitField FAKE_BITFIELD(1);
 static TSet FAKE_SET(1);
 
-TSet::TSet(int mp) : BitField(-1)
-{
-}
+TSet::TSet(int mp) : BitField(mp), MaxPower(mp) {}
 
 // конструктор копирования
-TSet::TSet(const TSet &s) : BitField(-1)
-{
-}
+TSet::TSet(const TSet& s) : BitField(s.BitField), MaxPower(s.MaxPower) {}
+
+// BitField = s.BitField;
+// MaxPower = s.MaxPower;
+
+
 
 // конструктор преобразования типа
-TSet::TSet(const TBitField &bf) : BitField(-1)
-{
-}
+TSet::TSet(const TBitField& bf) : BitField(bf), MaxPower(bf.GetLength()) {}
 
+
+// преобразование типа к битовому полю
 TSet::operator TBitField()
 {
-    return FAKE_BITFIELD;
+    return BitField;
 }
 
 int TSet::GetMaxPower(void) const // получить макс. к-во эл-тов
 {
-    return FAKE_INT;
+    return MaxPower;
 }
 
 int TSet::IsMember(const int Elem) const // элемент множества?
 {
-    return FAKE_INT;
+    if ((Elem < 0) || (Elem > MaxPower))
+    {
+        throw("Error input");
+    }
+    return BitField.GetBit(Elem);
 }
 
 void TSet::InsElem(const int Elem) // включение элемента множества
 {
+    if ((Elem < 0) || (Elem > MaxPower))
+    {
+        throw("Error input");
+    }
+    BitField.SetBit(Elem);
 }
 
 void TSet::DelElem(const int Elem) // исключение элемента множества
 {
-}
+    if ((Elem < 0) || (Elem > MaxPower))
+    {
+        throw("Error input");
+    }
+    BitField.ClrBit(Elem);
+} 
 
 // теоретико-множественные операции
 
-TSet& TSet::operator=(const TSet &s) // присваивание
+TSet& TSet::operator=(const TSet& s) // присваивание
 {
-    return FAKE_SET;
+    MaxPower = s.MaxPower;
+    BitField = s.BitField;
+    return *this;
 }
 
-int TSet::operator==(const TSet &s) const // сравнение
+int TSet::operator==(const TSet& s) const // сравнение
 {
-    return FAKE_INT;
+    return BitField == s.BitField;
 }
 
-int TSet::operator!=(const TSet &s) const // сравнение
+int TSet::operator!=(const TSet& s) const // сравнение
 {
-    return FAKE_INT;
+    return !(BitField == s.BitField);
 }
 
-TSet TSet::operator+(const TSet &s) // объединение
+TSet TSet::operator+(const TSet& s) // объединение
 {
-    return FAKE_SET;
+    int len;
+    if (MaxPower > s.MaxPower)
+        len = MaxPower;
+    else
+        len = s.MaxPower;
+    TSet res(len);
+    res.BitField = BitField | s.BitField;
+    return res;
 }
 
 TSet TSet::operator+(const int Elem) // объединение с элементом
 {
-    return FAKE_SET;
+    if (Elem < 0 || Elem > MaxPower)
+    {
+        throw("Error input");
+    }
+    TSet a(*this);
+    a.BitField.SetBit(Elem);
+    return a;
 }
 
 TSet TSet::operator-(const int Elem) // разность с элементом
 {
-    return FAKE_SET;
+    if (Elem < 0 || Elem > MaxPower)
+    {
+        throw("Error input");
+    }
+    TSet a(*this);
+    a.BitField.ClrBit(Elem);
+    return a;
 }
 
-TSet TSet::operator*(const TSet &s) // пересечение
+TSet TSet::operator*(const TSet& s) // пересечение
 {
-    return FAKE_SET;
+    int len;
+    if (MaxPower > s.MaxPower)
+        len = MaxPower;
+    else
+        len = s.MaxPower;
+    TSet res(len);
+    res.BitField = BitField & s.BitField;
+    return res;
 }
 
 TSet TSet::operator~(void) // дополнение
 {
-    return FAKE_SET;
+    TSet a(MaxPower);
+    a.BitField = ~BitField;
+    return a;
 }
 
 // перегрузка ввода/вывода
 
-istream &operator>>(istream &istr, TSet &s) // ввод
+istream& operator>>(istream& istr, TSet& s) // ввод
 {
+    int element;
+    while (istr >> element) {
+        if (element >= s.MaxPower)
+            throw runtime_error("Error Limit");
+        s.InsElem(element);
+    }
+
     return istr;
 }
 
-ostream& operator<<(ostream &ostr, const TSet &s) // вывод
+ostream& operator<<(ostream& ostr, const TSet& s) // вывод
 {
+    for (size_t i = 0; i < s.MaxPower; ++i)
+    {
+        if (s.BitField.GetBit(i))
+            ostr << i;
+        if (i + 1 < s.MaxPower) ostr << " ";
+
+    }
+
     return ostr;
 }