//meek///#include<bits/stdc++.h>

#include <iostream>

#include <cstdio>

#include <cmath>

#include <string>

#include <cstring>

#include <algorithm>

#include <queue>

#include <map>

#include <set>

#include <stack>

#include <sstream>

#include <vector>

using namespace std ;

#define mem(a) memset(a,0,sizeof(a))

#define pb push_back

#define fi first

#define se second

#define MP make_pair

typedef long long ll;

const int MAXN = ;

const int MAXM = ;

const int INF = 0x3f3f3f3f;

struct Edge

{

    int to,next,cap,flow,cost;

}edge[MAXM];

int head[MAXN],tol;

int pre[MAXN],dis[MAXN];

bool vis[MAXN];

int N;//节点总个数，节点编号从0~N-1

void init(int n)

{

    N = n;

    tol = ;

    memset(head,-,sizeof(head));

}

void add(int u,int v,int cap,int cost)  //点u至点v,容量，花费

{

    edge[tol].to = v;

    edge[tol].cap = cap;

    edge[tol].cost = cost;

    edge[tol].flow = ;

    edge[tol].next = head[u];

    head[u] = tol++;

    edge[tol].to = u;

    edge[tol].cap = ;

    edge[tol].cost = -cost;

    edge[tol].flow = ;

    edge[tol].next = head[v];

    head[v] = tol++;

}

bool spfa(int s,int t)

{

    queue<int>q;

    for(int i = ;i < N;i++)

    {

        dis[i] = INF;

        vis[i] = false;

        pre[i] = -;

    }

    dis[s] = ;

    vis[s] = true;

    q.push(s);

    while(!q.empty())

    {

        int u = q.front();

        q.pop();

        vis[u] = false;

        for(int i = head[u]; i != -;i = edge[i].next)

        {

            int v = edge[i].to;

            if(edge[i].cap > edge[i].flow &&

               dis[v] > dis[u] + edge[i].cost )

            {

                dis[v] = dis[u] + edge[i].cost;

                pre[v] = i;

                if(!vis[v])

                {

                    vis[v] = true;

                    q.push(v);

                }

            }

        }

    }

    if(pre[t] == -)return false;

    else return true;

}

//返回的是最大流，cost存的是最小费用

int minCostMaxflow(int s,int t,int &cost)

{

    int flow = ;

    cost = ;

    while(spfa(s,t))

    {

        int Min = INF;

        for(int i = pre[t];i != -;i = pre[edge[i^].to])

        {

            if(Min > edge[i].cap - edge[i].flow)

                Min = edge[i].cap - edge[i].flow;

        }

        for(int i = pre[t];i != -;i = pre[edge[i^].to])

        {

            edge[i].flow += Min;

            edge[i^].flow -= Min;

            cost += edge[i].cost * Min;

        }

        flow += Min;

    }

    return flow;

}

const int inf = ;

const int mod= ;

bool test(int a,int b) {

     int t=a*a-b*b;

     int tmp =(int)sqrt(t);

    if((tmp*tmp)!=t) return ;

    if(__gcd(b,(int)sqrt(t))==) return ;

    return ;

}

int main() {

    int a,b,S=,T=;

    init();

   scanf("%d%d",&a,&b);

   for(int i=a;i<=b;i++) {

     for(int j=a;j<i;j++) {

        if(test(i,j)) {

            add(i,j+b,,-i-j);

            add(j,i+b,,-i-j);

        }

      }

   }

   for(int i=a;i<=b;i++) {

    add(S,i,,);

    add(i+b,T,,);

   }

   int ans=;

   int L = minCostMaxflow(S,T,ans)/;

   printf("%d %d\n",L,-(ans)/);

    return ;

}