Напишите условие, которое определяет Закрашенную область

///----------------------------------------------------------------------------|
/// Настройки для MinGW GCC
///     -lmingw32
///      libgdi32.a
///----------------------------------------------------------------------------:
#include <iostream>
#include <cmath>
#include <string>
#include <functional>
#include <windows.h>
 
struct Plot
{   Plot(int color = 1) : delta_x(450), 
                          delta_y(350)
    {   hWnd = GetConsoleWindow();
        hDC  = GetDC       (hWnd);
        
        switch(color)
        {   case 1: cP = CreatePen(PS_SOLID, 2, RGB(  0,255,  0)); break;
            case 2: cP = CreatePen(PS_SOLID, 2, RGB(255,  0,  0)); break;
            case 3: cP = CreatePen(PS_SOLID, 2, RGB(  0,  0,255)); break;
            default:cP = CreatePen(PS_SOLID, 1, RGB(255,255,  0)); break;
        }
        
        cP_black = CreatePen(PS_SOLID, 7, RGB(0,0,0));
        SelectObject(hDC, cP);
    }
    
    struct sPlot
    {   float x;
        float y;
    };
    
    void draw(int x, int y)
    {   x += delta_x;
        y  = delta_y - y;
        
        POINT pp;
        MoveToEx(hDC, x, y,  &pp);
        LineTo(hDC, x, y);
    }
    
    void draw_line(int xs, int ys, int xe, int ye)
    {   xs += delta_x;
        ys  = delta_y - ys;
        xe += delta_x;
        ye  = delta_y - ye;
        
        POINT pp;
        MoveToEx(hDC, xs, ys,  &pp);
        LineTo(hDC, xe, ye);
    }
 
    void color(int r, int g, int b)
    {   DeleteObject(cP);
        cP = CreatePen(PS_SOLID, 7, RGB(r,g,b));
        SelectObject(hDC, cP);
    }
    
private:
    HWND hWnd;
    HDC  hDC;
    HPEN cP, cP_black;
    int  delta_x;
    int  delta_y;
}cout;
 
#include <cstdlib>
int rrand(int range_min, int range_max)
{   return rand() % (range_max - range_min + 1) + range_min;
}
 
void print(int x, int y, std::string s)
{
    HWND hWnd = GetConsoleWindow();
    HDC  hdc  = GetDC(hWnd);
    HFONT font1 = CreateFont(30, 15, 0, 0, FW_BOLD, 0, 0, 0, RUSSIAN_CHARSET,
                                                    0, 0, 0, 0,     "Times");
    HFONT f2 = (HFONT)SelectObject(hdc, font1);
 
    SetTextColor(hdc,   RGB(255,255,0)); /// 0x00bbggrr 
    SetBkMode(hdc, TRANSPARENT);
 
    TextOutA(hdc, x, y, s.c_str(), s.size());
 
    DeleteObject(font1);
}
 
 
///-----------------------------------------|
/// y = fn(x)                               |
///-----------------------------------------:
void draw_graph(const std::function<float(float)>& fn)
{   Plot p(2);
    for(float x = -10; x < 10.f; x += 0.001f)
    {   float y = fn(x);
        p.draw(50*x, 50*y);
    }
    
    Plot pp(1);
    for(int i = -5; i < 5; ++i)
    {   pp.draw_line(100*i,    -4, 100*i,     4);
        pp.draw_line(   -4, 100*i,     4, 100*i);
    }
    
    const int D = 100;
    print(460,  20 + D, "y");
    print(850, 210 + D, "x");
    print(540, 210 + D, "2");
    print(10,   10 + D, "y = x * x");
}
 
///----------------------------------------------------------------------------|
/// Критерий попадания.
///----------------------------------------------------------------------------:
bool is_hit_criterion(double x, double y)
{   return x > 0 && x * x / y > 1 && 2-x > y || 
           x < 0 && x * x / y > 1 && 2-x < y;
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
void test()
{   
    for(int i = 0; i < 10000; ++i)
    {   double x = double(rrand(0, 10000) - 5000)/1000;
        double y = double(rrand(0, 20000) - 10000)/1000;
        
        if(is_hit_criterion(x, y))
        {   cout.draw(x*50, y*50);
        }
    }
}
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main ()
{   
    {   Plot p(5);
             p.draw_line(-450,   0, 450,    0);
             p.draw_line(   0, 230,   0, -200);
    }
    
    auto fn2 = [](float x){return 2-x;};
    draw_graph(fn2);
    
    auto fn1 = [](float x){return x*x;};
    draw_graph(fn1);
    
    test();
    
    std::cin.get();
}