// compile: make data
// run: ./data < data.in
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#ifdef LOCAL
#include <debug/codeforces.h>
#define debug(x...) _debug_print(#x, x);
#define Debug(x...) _debug_print_format(#x, x);
std::ifstream terminal("/dev/tty");
#define PP cerr<<"\033[1;30mpause...\e[0m",terminal.ignore();
#else
#define debug(x...)
#define Debug(x...)
#define PP
#endif
template<typename...Args> void print_(Args...args){((cout<<args<<" "),...)<<endl;}
#define rep(i,a,b) for(int i=(a);i<(int)(b);++i)
#define sz(v) ((int)(v).size())
#define print(...) print_(__VA_ARGS__);
#define FIND(a, x) ((find(a.begin(),a.end(),(x))!=a.end())?1:0)
#define cmin(x,...) x=min({(x),__VA_ARGS__})
#define cmax(x,...) x=max({(x),__VA_ARGS__})
#define INTMAX (int)(9223372036854775807)
#define INF (int)(1152921504606846976)
#define NaN (int)(0x8b88e1d0595d51d1)
#define double long double
#define int long long
#define uint unsigned long long
#define MAXN 200010

template <typename T> struct point {
    vector<T> cor;
    point() {}
    template<typename...Args> point(Args...args) {set(args...); }
    template<typename...Args> void set(Args...args) {cor = {args...}; }
    point(vector<T> c) {set(c); }
    void set(vector<T> c) {cor = c; }
    point<T> operator+(const point<T> &rhs) const {
        const point<T> &lhs = *this;
        assert(lhs.cor.size() == rhs.cor.size());
        vector<T> c(lhs.cor.size());
        rep(i, 0, lhs.cor.size()) c[i] = lhs.cor[i] + rhs.cor[i];
        point<T> res(c);
        return res;
    }
    point<T> operator-(const point<T> &rhs) const {
        const point<T> &lhs = *this;
        assert(lhs.cor.size() == rhs.cor.size());
        vector<T> c(lhs.cor.size());
        rep(i, 0, lhs.cor.size()) c[i] = lhs.cor[i] - rhs.cor[i];
        point<T> res(c);
        return res;
    }
    T dot(const point<T> &rhs) const {
        const point<T> &lhs = *this;
        assert(lhs.cor.size() == rhs.cor.size());
        T res = 0;
        rep(i, 0, lhs.cor.size()) res += lhs.cor[i] * rhs.cor[i];
        return res;
    }
    T cross2(const point<T> &rhs) const {
        const point<T> &lhs = *this;
        assert(lhs.cor.size() == rhs.cor.size());
        assert(lhs.cor.size() == 2);
        return lhs.cor[0] * rhs.cor[1] - lhs.cor[1] * rhs.cor[0];
    }
    point<T> cross3(const point<T> &rhs) const {
        const point<T> &lhs = *this;
        assert(lhs.cor.size() == rhs.cor.size());
        assert(lhs.cor.size() == 3);
        vector<T> c(lhs.cor.size());
        for (int i = 0; i < (int)lhs.cor.size(); i++) {
            int j = (i + 1) % lhs.cor.size();
            int k = (i + 2) % lhs.cor.size();
            c[i] = lhs.cor[j] * rhs.cor[k] - lhs.cor[k] * rhs.cor[j];
        }
        point<T> res(c);
        return res;
    }
};

template <typename T> struct polygon2d {
    vector<point<T>> p;
    polygon2d() {}
    polygon2d(vector<point<T>> a): p(a) {}
    void add(const point<T> q) {p.push_back(q); }
    T area() const {
        T res = 0;
        rep(i, 0, p.size()) {
            int j = (i + 1) % p.size();
            res += p[i].cross2(p[j]);
        }
        return abs(res);
    }
    T is_convex() const {
        bool res = true;
        rep(i, 0, p.size()) {
            int j = (i + 1) % p.size();
            int k = (i + 2) % p.size();
            res &= (p[j] - p[i]).cross2(p[k] - p[j]) > 0;
        }
        return res;
    }
    bool is_simple() const {
        bool res = true;
        rep(i, 0, p.size()) {
            int j = (i + 1) % p.size();
            rep(k, i + 1, p.size()) {
                int l = (k + 1) % p.size();
                res &= (p[j] - p[i]).cross2(p[l] - p[k]) != 0;
            }
        }
        return res;
    }
    bool is_point_in(const point<T> &q) const {
        const polygon2d<T> &lhs = *this;
        bool res = false;
        rep(i, 0, lhs.p.size()) {
            int j = (i + 1) % lhs.p.size();
            if (min(lhs.p[i].cor[0], lhs.p[j].cor[0]) <= q.cor[0] && q.cor[0] <= max(lhs.p[i].cor[0], lhs.p[j].cor[0])) {
                if (min(lhs.p[i].cor[1], lhs.p[j].cor[1]) <= q.cor[1] && q.cor[1] <= max(lhs.p[i].cor[1], lhs.p[j].cor[1])) {
                    if ((lhs.p[j] - lhs.p[i]).cross2(q - lhs.p[i]) == 0) {
                        res = true;
                        break;
                    }
                }
            }
        }
        return res;
    }
};

int32_t main() {
    ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);

    int n; cin >> n;
    polygon2d<int> p;
    rep(i, 0, n) {
        int x, y; cin >> x >> y;
        p.add(point<int>(x, y));
    }
    cout << p.area() << endl;

    return 0;
}