...

#include <bits/stdc++.h>
using namespace std;
 
using ll = long long;
using db = long double; // or double, if TL is tight
using str = string; // yay python! 

// pairs
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using pd = pair<db,db>;
#define mp make_pair
#define f first
#define s second

#define tcT template<class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT> using V = vector<T>; 
tcT, size_t SZ> using AR = array<T,SZ>; 
using vi = V<int>;
using vb = V<bool>;
using vl = V<ll>;
using vd = V<db>;
using vs = V<str>;
using vpi = V<pi>;
using vpl = V<pl>;
using vpd = V<pd>;

// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend() 
#define sor(x) sort(all(x)) 
#define rsz resize
#define ins insert 
#define pb push_back
#define eb emplace_back
#define ft front()
#define bk back()

#define lb lower_bound
#define ub upper_bound
tcT> int lwb(V<T>& a, const T& b) { return int(lb(all(a),b)-bg(a)); }
tcT> int upb(V<T>& a, const T& b) { return int(ub(all(a),b)-bg(a)); }

// loops
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define rep(a) F0R(_,a)
#define each(a,x) for (auto& a: x)

const int MOD = 1e9+7; // 998244353;
const int MX = 2e5+5;
const ll BIG = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4]{1,0,-1,0}, dy[4]{0,1,0,-1}; // for every grid problem!!
mt19937 rng(0);
template<class T> using pqg = priority_queue<T,vector<T>,greater<T>>;

// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
  return x == 0 ? 0 : 31-__builtin_clz(x); } // floor(log2(x)) 
constexpr int p2(int x) { return 1<<x; }
constexpr int msk2(int x) { return p2(x)-1; }

ll cdiv(ll a, ll b) { return a/b+((a^b)>0&&a%b); } // divide a by b rounded up
ll fdiv(ll a, ll b) { return a/b-((a^b)<0&&a%b); } // divide a by b rounded down

tcT> bool ckmin(T& a, const T& b) {
  return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
  return a < b ? a = b, 1 : 0; } // set a = max(a,b)

tcTU> T fstTrue(T lo, T hi, U f) {
  ++hi; assert(lo <= hi); // assuming f is increasing
  while (lo < hi) { // find first index such that f is true 
    T mid = lo+(hi-lo)/2;
    f(mid) ? hi = mid : lo = mid+1; 
  } 
  return lo;
}
tcTU> T lstTrue(T lo, T hi, U f) {
  --lo; assert(lo <= hi); // assuming f is decreasing
  while (lo < hi) { // find first index such that f is true 
    T mid = lo+(hi-lo+1)/2;
    f(mid) ? lo = mid : hi = mid-1;
  } 
  return lo;
}
tcT> void remDup(vector<T>& v) { // sort and remove duplicates
  sort(all(v)); v.erase(unique(all(v)),end(v)); }
tcTU> void erase(T& t, const U& u) { // don't erase
  auto it = t.find(u); assert(it != end(t));
  t.erase(it); } // element that doesn't exist from (multi)set

#define tcTUU tcT, class ...U

inline namespace Helpers {
  //////////// is_iterable
  // https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
  // this gets used only when we can call begin() and end() on that type
  tcT, class = void> struct is_iterable : false_type {};
  tcT> struct is_iterable<T, void_t<decltype(begin(declval<T>())),
                                    decltype(end(declval<T>()))
                                   >
                         > : true_type {};
  tcT> constexpr bool is_iterable_v = is_iterable<T>::value;

  //////////// is_readable
  tcT, class = void> struct is_readable : false_type {};
  tcT> struct is_readable<T,
          typename std::enable_if_t<
              is_same_v<decltype(cin >> declval<T&>()), istream&>
          >
      > : true_type {};
  tcT> constexpr bool is_readable_v = is_readable<T>::value;

  //////////// is_printable
  // // https://nafe.es/posts/2020-02-29-is-printable/
  tcT, class = void> struct is_printable : false_type {};
  tcT> struct is_printable<T,
          typename std::enable_if_t<
              is_same_v<decltype(cout << declval<T>()), ostream&>
          >
      > : true_type {};
  tcT> constexpr bool is_printable_v = is_printable<T>::value;
}

using R = long double;

inline namespace Input {
void re(R& r) {
  db d; cin >> d;
  r = d;
}
  tcT> constexpr bool needs_input_v = !is_readable_v<T> && is_iterable_v<T>;
  tcTUU> void re(T& t, U&... u);
  tcTU> void re(pair<T,U>& p); // pairs

  // re: read
  tcT> typename enable_if<is_readable_v<T>,void>::type re(T& x) { cin >> x; } // default
  tcT> void re(complex<T>& c) { T a,b; re(a,b); c = {a,b}; } // complex
  tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i); // ex. vectors, arrays
  tcTU> void re(pair<T,U>& p) { 
    str x,y; re(x,y);
    p.f = stold(x);
    p.s = stold(y);
     }
  tcT> typename enable_if<needs_input_v<T>,void>::type re(T& i) {
    each(x,i) re(x); }
  tcTUU> void re(T& t, U&... u) { re(t); re(u...); } // read multiple

  // rv: resize and read vectors
  void rv(size_t) {}
  tcTUU> void rv(size_t N, V<T>& t, U&... u);
  template<class...U> void rv(size_t, size_t N2, U&... u);
  tcTUU> void rv(size_t N, V<T>& t, U&... u) {
    t.rsz(N); re(t);
    rv(N,u...); }
  template<class...U> void rv(size_t, size_t N2, U&... u) {
    rv(N2,u...); }

  // dumb shortcuts to read in ints
  void decrement() {} // subtract one from each
  tcTUU> void decrement(T& t, U&... u) { --t; decrement(u...); }
  #define ints(...) int __VA_ARGS__; re(__VA_ARGS__);
  #define int1(...) ints(__VA_ARGS__); decrement(__VA_ARGS__);
}

inline namespace ToString {
  tcT> constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;

  // ts: string representation to print
  tcT> typename enable_if<is_printable_v<T>,str>::type ts(T v) {
    stringstream ss; ss << fixed << setprecision(15) << v;
    return ss.str(); } // default
  tcT> str bit_vec(T t) { // bit vector to string
    str res = "{"; F0R(i,sz(t)) res += ts(t[i]);
    res += "}"; return res; }
  str ts(V<bool> v) { return bit_vec(v); }
  template<size_t SZ> str ts(bitset<SZ> b) { return bit_vec(b); } // bit vector
  tcTU> str ts(pair<T,U> p); // pairs
  tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v); // vectors, arrays
  tcTU> str ts(pair<T,U> p) { return "("+ts(p.f)+", "+ts(p.s)+")"; }
  tcT> typename enable_if<is_iterable_v<T>,str>::type ts_sep(T v, str sep) {
    // convert container to string w/ separator sep
    bool fst = 1; str res = "";
    for (const auto& x: v) {
      if (!fst) res += sep;
      fst = 0; res += ts(x);
    }
    return res;
  }
  tcT> typename enable_if<needs_output_v<T>,str>::type ts(T v) {
    return "{"+ts_sep(v,", ")+"}"; }

  // for nested DS
  template<int, class T> typename enable_if<!needs_output_v<T>,vs>::type 
    ts_lev(const T& v) { return {ts(v)}; }
  template<int lev, class T> typename enable_if<needs_output_v<T>,vs>::type 
    ts_lev(const T& v) {
    if (lev == 0 || !sz(v)) return {ts(v)};
    vs res;
    for (const auto& t: v) {
      if (sz(res)) res.bk += ",";
      vs tmp = ts_lev<lev-1>(t);
      res.ins(end(res),all(tmp));
    }
    F0R(i,sz(res)) {
      str bef = " "; if (i == 0) bef = "{";
      res[i] = bef+res[i];
    }
    res.bk += "}";
    return res;
  }
}

inline namespace Output {
  template<class T> void pr_sep(ostream& os, str, const T& t) { os << ts(t); }
  template<class T, class... U> void pr_sep(ostream& os, str sep, const T& t, const U&... u) {
    pr_sep(os,sep,t); os << sep; pr_sep(os,sep,u...); }
  // print w/ no spaces
  template<class ...T> void pr(const T&... t) { pr_sep(cout,"",t...); } 
  // print w/ spaces, end with newline
  void ps() { cout << "\n"; }
  template<class ...T> void ps(const T&... t) { pr_sep(cout," ",t...); ps(); } 
  // debug to cerr
  template<class ...T> void dbg_out(const T&... t) {
    pr_sep(cerr," | ",t...); cerr << endl; }
  void loc_info(int line, str names) {
    cerr << "Line(" << line << ") -> [" << names << "]: "; }
  template<int lev, class T> void dbgl_out(const T& t) {
    cerr << "\n\n" << ts_sep(ts_lev<lev>(t),"\n") << "\n" << endl; }
  #ifdef LOCAL
    #define dbg(...) loc_info(__LINE__,#__VA_ARGS__), dbg_out(__VA_ARGS__)
    #define dbgl(lev,x) loc_info(__LINE__,#x), dbgl_out<lev>(x)
  #else // don't actually submit with this
    #define dbg(...) 0
    #define dbgl(lev,x) 0
  #endif

  const clock_t beg = clock();
  #define dbg_time() dbg((db)(clock()-beg)/CLOCKS_PER_SEC)
}

inline namespace FileIO {
  void setIn(str s)  { freopen(s.c_str(),"r",stdin); }
  void setOut(str s) { freopen(s.c_str(),"w",stdout); }
  void setIO(str s = "") {
    cin.tie(0)->sync_with_stdio(0); // unsync C / C++ I/O streams
    // cin.exceptions(cin.failbit);
    // throws exception when do smth illegal
    // ex. try to read letter into int
    if (sz(s)) setIn(s+".in"), setOut(s+".out"); // for old USACO
  }
}
// #include <bits/stdc++.h>
 
// using namespace std;


namespace Retro {

using T = R; 
using T2 = R;
using T4 = R;
const T2 INF = 2e6;
 
struct Line { T a, b; T2 c; };
 bool operator==(const Line& x, const Line& y) { return x.a == y.a && x.b == y.b && x.c == y.c; }

bool operator<(Line m, Line n) {
  auto half = [&](Line m) { 
    return m.b < 0 || m.b == 0 && m.a < 0; };
  return make_tuple(half(m), (T2)m.b * n.a) < 
    make_tuple(half(n), (T2)m.a * n.b);
}
tuple<T4, T4, T2> LineIntersection(Line m, Line n) {
  T2 d = (T2)m.a * n.b - (T2)m.b * n.a; // assert(d);
  T4 x = (T4)m.c * n.b - (T4)m.b * n.c; 
  T4 y = (T4)m.a * n.c - (T4)m.c * n.a;
  return {x, y, d};
}
Line LineFromPoints(T x1, T y1, T x2, T y2) {
  T a = y1 - y2, b = x2 - x1;
  T2 c = (T2)a * x1 + (T2)b * y1;
  return {a, b, c};
}
// ostream& operator<<(ostream& out, Line l) {
//   out << "Line " << l.a << " " << l.b << " " << -l.c;
//   // out << "(" << l.a << " * x + " << l.b << " * y <= " << l.c << ")";
//   return out;
// }
 
V<Line> deleted;
 
struct HalfplaneSet : multiset<Line> {
  __float128 total = 0;
  HalfplaneSet() {
    auto it = insert({+1, 0, INF}); 
    add_contrib(it, 1);
    it = insert({0, +1, INF}); 
    add_contrib(it, 1);
    it = insert({-1, 0, INF}); 
    add_contrib(it, 1);
    it = insert({0, -1, INF}); 
    add_contrib(it, 1);
    // dbg(total);
  };
 
  auto adv(auto it, int z) { // z = {-1, +1}
    while (z != 0) {
      if (z < 0) ++z, it = --(it == begin() ? end() : it);
      else --z, it = (++it == end() ? begin() : it);
    }
    return it;
  }
  void contrib(Line a, Line b, Line c, int sgn) {
    T4 x1, y1, x2, y2; T2 d1, d2;
    tie(x1, y1, d1) = LineIntersection(a, b);
    tie(x2, y2, d2) = LineIntersection(b, c);
    // if (abs(d1) < 1e-9 || abs(d2) < 1e-9) return;
    R er = sgn * (x1 * y2 - x2 * y1) / d1 / d2;
    if (!(-1e25 <= er && er <= 1e25)) return;
    total += er;
  }
  bool chk(auto it) {
    Line l = *it, pl = *adv(it, -1), nl = *adv(it, +1);
    T4 x, y; T2 d; tie(x, y, d) = LineIntersection(pl, nl);
    // auto [x, y, d] = LineIntersection(pl, nl);
    T4 sat = l.a * x + l.b * y - (T4)l.c * d;
    if (d < 0 && sat < 0) {
      each(t,*this) deleted.pb(t);
      return clear(), 0; // unsat
    }
    if ((d > 0 && sat <= 0) || (d == 0 && sat < 0)) {
      deleted.pb(*it);
      add_contrib(it, -1);
      return erase(it), 1;
    }
    return 0;
  }
  tuple<T4, T4, T2> get_vertex() {
    return LineIntersection(*begin(), *next(begin()));
  }
  void add_contrib(multiset<Line>::iterator it, int sgn) {
    // dbg("BEF",total);
    // cout << *it << "\n";
    if (size() >= 4) {
      contrib(*adv(it, -2), *adv(it, -1), *adv(it, 1), -sgn);
      contrib(*adv(it, -1), *adv(it, 1), *adv(it, 2), -sgn);
    }
    // dbg("MID",total);
    if (size() >= 3) {
      contrib(*adv(it,-2), *adv(it,-1), *it, sgn);
      contrib(*adv(it,-1), *it, *adv(it,1), sgn);
      contrib(*it,*adv(it,1),*adv(it,2), sgn);
    }
    // dbg("AFT",total);
  }
  void Cut(Line l) { // add ax + by <= c
    if (empty()) return;
    auto it = insert(l);
    // dbg("BEFORE", total);
    add_contrib(it, 1);
    // dbg("AFTER", total);
    if (chk(it)) return;
    for (int z : {-1, +1}) 
      while (size() && chk(adv(it, z)));
  }
  // db Maximize(T a, T b) { // max ax + by
  //   if (empty()) return -1/0.;
  //   auto it = lower_bound({a, b});
  //   if (it == end()) it = begin();
  //   auto [x, y, d] = LineIntersection(*adv(it, -1), *it);
  //   return (1.0 * a * x + 1.0 * b * y) / d;
  // }
  db Area() {
    if (empty()) return 0;
    return this->total * 0.5;
    // // return this->total * 0.5;
    // db total = 0.;
    // for (auto it = begin(); it != end(); ++it) {
    //   T4 x1, y1, x2, y2; T2 d1, d2;
    //   tie(x1, y1, d1) = LineIntersection(*adv(it, -1), *it);
    //   tie(x2, y2, d2) = LineIntersection(*it, *adv(it, +1));
    //   // auto [x1, y1, d1] = LineIntersection(*adv(it, -1), *it);
    //   // auto [x2, y2, d2] = LineIntersection(*it, *adv(it, +1));
    //   total += (1.0 * x1 * y2 - 1.0 * x2 * y1) / d1 / d2;
    // }
    // if (abs(this->total-total)/max(this->total,total) > 1e-6) {
    //   dbg("WHOOPS",this->total,total);
    //   exit(0);
    // }
    // // dbg("CUR TOTAL",this->total, total);
    // return total * 0.5;
  }
};

}

/**
 * Description: Use in place of \texttt{complex<T>}.
 * Source: http://codeforces.net/blog/entry/22175, KACTL
 * Verification: various
 */

using T = R; // or ll
const T EPS = 1e-9; // adjust as needed
using P = pair<T,T>; using vP = V<P>; using Line = pair<P,P>;
int sgn(T a) { return (a>EPS)-(a<-EPS); }
T sq(T a) { return a*a; }

bool close(const P& a, const P& b) { 
  return sgn(a.f-b.f) == 0 && sgn(a.s-b.s) == 0; } 
T norm(const P& p) { return sq(p.f)+sq(p.s); }
// T abs(const P& p) { return sqrt(norm(p)); }
// T arg(const P& p) { return atan2(p.s,p.f); }
P conj(const P& p) { return P(p.f,-p.s); }
P perp(const P& p) { return P(-p.s,p.f); }
// P dir(T ang) { return P(cos(ang),sin(ang)); }

P operator-(const P& l) { return P(-l.f,-l.s); }
P operator+(const P& l, const P& r) { 
  return P(l.f+r.f,l.s+r.s); }
P operator-(const P& l, const P& r) { 
  return P(l.f-r.f,l.s-r.s); }
P operator*(const P& l, const T& r) { 
  return P(l.f*r,l.s*r); }
P operator*(const T& l, const P& r) { return r*l; }
P operator/(const P& l, const T& r) { 
  return P(l.f/r,l.s/r); }
P operator*(const P& l, const P& r) { 
  return P(l.f*r.f-l.s*r.s,l.s*r.f+l.f*r.s); }
P operator/(const P& l, const P& r) { 
  return l*conj(r)/norm(r); }
P& operator+=(P& l, const P& r) { return l = l+r; }
P& operator-=(P& l, const P& r) { return l = l-r; }
P& operator*=(P& l, const T& r) { return l = l*r; }
P& operator/=(P& l, const T& r) { return l = l/r; }
P& operator*=(P& l, const P& r) { return l = l*r; }
P& operator/=(P& l, const P& r) { return l = l/r; }

// P unit(const P& p) { return p/abs(p); }
T dot(const P& a, const P& b) { return a.f*b.f+a.s*b.s; }
T dot(const P& p, const P& a, const P& b) { return dot(a-p,b-p); }
T cross(const P& a, const P& b) { return a.f*b.s-a.s*b.f; }
T cross(const P& p, const P& a, const P& b) {
  return cross(a-p,b-p); }
P reflect(const P& p, const Line& l) {
  P a = l.f, d = l.s-l.f;
  return a+conj((p-a)/d)*d; }
P foot(const P& p, const Line& l) {
  return (p+reflect(p,l))/(T)2; }
bool onSeg(const P& p, const Line& l) {
  return sgn(cross(l.f,l.s,p)) == 0 && sgn(dot(p,l.f,l.s)) <= 0; }


int main() {
  ios::sync_with_stdio(0); cin.tie(0);
  ints(N,M);
  // rep(10000) {
  //   Retro::HalfplaneSet HS;
  //   rep(10) {
  //     P a{rng()%1000000,rng()%1000000};
  //     P b{rng()%1000000,rng()%1000000};
  //     HS.Cut(Retro::LineFromPoints(a.f,a.s,b.f,b.s));
  //     cout << HS.Area() << "\n";
  //   }
  //   // dbg("WUT");
  // }
  // dbg("OK");
  // exit(0);
  // assert(N == 4 && M == 2);
  dbg("??");
  vP v(N); re(v);
  Retro::HalfplaneSet HS;
  F0R(i,N) {
    int j = (i+1)%N;
    HS.Cut(Retro::LineFromPoints(v[j].f, v[j].s, v[i].f, v[i].s));
    dbg("CUTTING");
  }
  R cur_area = HS.Area();
  dbg((db)cur_area);
  // dbg("HA",cur_area);
  rep(M) {
    // if(_%10000 == 0) dbg("WHOOPS",_);
    P a, b; re(a,b);
    // dbg("GOT");
    // auto HS_copy = HS;
    // HS.Cut(Retro::LineFromPoints(a.f,a.s,b.f,b.s));

    // dbg(sz(HS));
    auto [x,y,z] = HS.get_vertex();
    P p{x/z,y/z};
    // dbg((db)p.f,(db)p.s);
    if (cross(a,b,p) > 0) swap(a,b);
    // dbg("OH",_);
    Retro::deleted.clear();
    auto wut = Retro::LineFromPoints(a.f,a.s,b.f,b.s);
    HS.Cut(wut);
    // dbg(a,b,p,HS.Area());
    // assert(HS.Area() > 0);
    if (2*HS.Area() < cur_area) {
      Retro::HalfplaneSet new_HS;
      each(t,HS) if (!(t == wut)) {
        new_HS.Cut(t);
      }
      each(t,Retro::deleted) new_HS.Cut(t);
      new_HS.Cut(Retro::LineFromPoints(b.f,b.s,a.f,a.s));
      swap(HS, new_HS);
    } else {
      // dbg("OK");
    }
    cur_area = HS.Area();
  }
  dbg_time();
  // assert(abs(cur_area-21) < 1e-9);
  cout << fixed << setprecision(9) << (db)cur_area << "\n";
  // ifstream fin("camera.in");
  // ofstream fout("camera.out");
 
  // int n; fin >> n;
 
  // vector<T> x(n), y(n);
  // for (int i = 0; i < n; ++i) 
  //   fin >> x[i] >> y[i];
  /*
  cout << "Polygon(";
  for (int i = 0; i < n; ++i) {
    if (i != 0) cout << ",";
    cout << "(" << x[i] << "," << y[i] << ")";
  }
  cout << ")" << endl;
  */

  // db ans = 0;
  // for (int rev = 0; rev < 2; ++rev) {
  //   HalfplaneSet HS;
  //   for (int j = n - 1, i = 0; i < n; j = i++) {
  //     HS.Cut(LineFromPoints(x[j], y[j], x[i], y[i]));
  //     //HS.Dump();
  //   }
    
  //   if (HS.size()) {
  //     cerr << "FINAL\n";
  //     for (auto x : HS) cerr << x << "\n";
  //   }
  //   ans = max(ans, HS.Area());
  //   reverse(x.begin(), x.end()); 
  //   reverse(y.begin(), y.end());
  // }
  // fout << fixed << setprecision(2) << ans << endl;
 
  // return 0;
}

#!/usr/bin/env python
# coding: utf-8

# In[3]:


import sys
import numpy as np
import lightgbm as lgb


# In[1]:


DEBUG = False


# In[2]:


if DEBUG:
    with open("example_input.txt", "r") as f:
        lines = f.readlines()
else:
    lines = sys.stdin.readlines()


# In[14]:


k,t,n,m,u = map(int,lines[0].split())
train_lines = lines[1:1+2*n]
train_data = [[0]*u for _ in range(n)]
targets = []
for i in range(n):
    for critic in train_lines[i].split():
        label, val = map(int,critic.split(":"))
        train_data[i][label] = 2*val-1
    targets.append(int(train_lines[n+i]))


# In[13]:


k,t,n,m,u


# In[6]:


test_lines = lines[1+2*n:1+2*n+m]
test_data = []
for line in test_lines:
    lst = [list(map(int,x.split(":"))) for x in line.split()]
    features = [0]*u
    for label, val in lst:
        features[label] = 2*val-1
    test_data.append(features)    


# In[7]:


import pandas as pd


# In[17]:


train_data_p = train_data
test_data_p = test_data
target_train = np.array(targets)
df_train = pd.DataFrame(train_data_p)
df_test = pd.DataFrame(test_data_p)


# In[18]:


df_train.shape


# In[12]:


target_train.shape


# In[20]:


eval_set = np.array([True if i < len(df_train)*0.2 else False for i in range(len(df_train))])
lgb_train = lgb.Dataset(df_train[~eval_set], target_train[~eval_set])
lgb_eval = lgb.Dataset(df_train[eval_set], target_train[eval_set], reference=lgb_train)
lgb_all = lgb.Dataset(df_train, target_train)


# In[22]:


params = {
    'objective': 'regression',
    'verbose': -1 if not DEBUG else 0,
}

gbm = lgb.train(params,
                lgb_train,
                valid_sets=lgb_eval,
                verbose_eval=DEBUG,
                early_stopping_rounds=5)


# In[23]:


res = gbm.predict(df_test, num_iteration=gbm.best_iteration)
if not DEBUG:
    print("\n".join(str(int(x)) for x in res))
else:
    print(t,res)


# In[ ]: