Go: package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b float64
	fmt.Scanf("%v %v", &a, &b)
	fmt.Println(math.Abs(a - b))
}

C++: #include <iostream>
using namespace std;
int main(void){
    // Your code here!
    int x1 , x2;
    cin >> x1 >> x2;
    
    if( x1 < x2) cout<< x2 - x1 << endl;
    else
    cout << x1 - x2 <<endl;
    
    return 0;
}

C++: #include<iostream>
using namespace std;

int main(){
  int a, b;
  cin >> a >> b;
  if(a <= b) {
      cout << b - a << endl;
  } else {
      cout << a - b << endl;
  }
  return 0;
}

C++: #include<iostream>
using namespace std;

int main(){
    int N,n;
    cin>>N>>n;
    if(N<=n){
        cout<<n-N<<endl;
    }else if(n<=N){
        cout<<N-n<<endl;
    }
    return 0;
}

C++: #include<bits/stdc++.h>
using namespace std;
int main(void)
{
	int x,y;
	cin>>x>>y;
	cout<<abs(x-y)<<endl;
	return 0;
}

C++: #include <bits/stdc++.h>

#define rep(i, n) for (int(i) = 0; (i) < (int)(n); (i)++)
#define repr(i, n) for (int(i) = (n); (i) >= 0; (i)--)
#define repf(i, m, n) for (int(i) = (m); (i) < (n); (i)++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define inf 1e9

template <class T>
bool chmax(T &a, const T &b)
{
    if (a < b)
    {
        a = b;
        return 1;
    }
    return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
    if (b < a)
    {
        a = b;
        return 1;
    }
    return 0;
}

using namespace std;
using ll = long long;

int main(int argc, char const *argv[])
{
    int x, y;
    cin >> x >> y;

    cout << abs(x - y) << endl;

    return 0;
}

C++: //#pragma once
#include <stdio.h>
#include <string>
#include <iostream>
#include <queue>
#include <algorithm>
#include <sstream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cctype>


using namespace std;
#define modd 1000000007


typedef pair<long long, long long> pl;


typedef string::const_iterator State;
class ParseError {};




#define ll long long




/*
class UnionFind {
public:
	vector <ll> par;
	vector <ll> siz;
	vector <ll> gr;

	// Constructor
	UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) ,gr(sz_){
		for (ll i = 0; i < sz_; ++i) par[i] = i;
	}
	void init(ll sz_) {
		par.resize(sz_);
		siz.assign(sz_, 1LL);  // resize だとなぜか初期化されなかった
		for (ll i = 0; i < sz_; ++i) par[i] = i; // 初期では親は自分自身
	}

	// Member Function
	// Find
	ll root(ll x) { // 根の検索
		while (par[x] != x) {
			x = par[x] = par[par[x]]; // x の親の親を x の親とする
		}
		return x;
	}

	// Union(Unite, Merge)
	bool merge(ll x, ll y) {
		x = root(x);
		y = root(y);
		if (x == y) return false;

		// merge technique（データ構造をマージするテク．小を大にくっつける）
		if (siz[x] < siz[y]) swap(x, y);
		siz[x] += siz[y];
		par[y] = x;
		return true;
	}



	bool issame(ll x, ll y) { // 連結判定
		return root(x) == root(y);
	}

	ll size(ll x) { // 素集合のサイズ
		return siz[root(x)];
	}


};*/


long long N, M, K, a, b, c, d, e, H, W, L;
ll A[2][100005] = {};
ll B[2][100005] = {};
ll C[200005] = {};
bool f, ff;
string S;
set <long long>sll;
pl bufpl;
vector <long long>vl[3];
vector <pl>vpl;
vector <string> vs;
set<ll> llset;

/*struct ST
{
	long long Kati;
	int bangou;

	bool operator<(const ST& another) const
	{
		return Kati < another.Kati;//比較
	};

};



vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/


long long modinv(long long aa, long long mm) {
	long long bb = mm, uu = 1, vv = 0;
	while (bb) {
		long long tt = aa / bb;
		aa -= tt * bb; swap(aa, bb);
		uu -= tt * vv; swap(uu, vv);
	}
	uu %= mm;
	if (uu < 0) uu += mm;
	return uu;
}



ll minn, maxx;
double ansa;
bool fl[30] = {};

string ss, sss;

int main() {


	cin >> a>>b;

	c = abs(a - b);

	cout << c << endl;

	return 0;

}

C++: #include<iostream>
using namespace std;

int main(){
    int x,y;
    cin >> x >> y;

    if(x<=y){
        cout << y-x << endl;
    }

    else{
        cout << x-y << endl;
    }

    return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
int main(){
    int a,b;
    cin >> a >> b;
    if(a>b){
        cout << a-b << endl;
    }else{
        cout << b-a << endl;
    }
}

C++: #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#pragma GCC optimize ("-O3")
using namespace std; void _main(); int main() { cin.tie(0); ios::sync_with_stdio(false); _main(); }
typedef long long ll; const int inf = INT_MAX / 2; const ll infl = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
//---------------------------------------------------------------------------------------------------
/*---------------------------------------------------------------------------------------------------
　　　　　　　　　　　 ∧＿∧  
　　　　　 ∧＿∧ 　（´<_｀ ）　 Welcome to My Coding Space!
　　　　 （ ´_ゝ`）　/　 ⌒i     
　　　　／　　　＼　 　 |　|     
　　　 /　　 /￣￣￣￣/　　|  
　 ＿_(__ﾆつ/　    ＿/ .| .|＿＿＿＿  
　 　　　＼/＿＿＿＿/　（u　⊃  
---------------------------------------------------------------------------------------------------*/





int x1, x2;
//---------------------------------------------------------------------------------------------------
void _main() {
    cin >> x1 >> x2;
    int ans = abs(x1 - x2);
    cout << ans << endl;
}

C++: #include <iostream>
using namespace std;
int main(){

int x,y;
cin>>a>>b;
if(a>b) cout<<(a-b)<<endl;
else
cout<<(b-a)<< endl;
return 0;
}

C++: #include<stdio.h>
int main(void)
{
int x1,x2;
scanf("%d %d",&x1,&x2);
if(x1>x2){
	printf("%d\n",x1-x2);
}
if(x2>x1){
	printf("%d\n",x2-x1);
}
if(x1==x2)
	printf("0\n");
return 0;
}

C++: #include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <map>
#include <string>
#include <queue>
#include <stack>
#include <math.h>
#include <cmath>
#include <numeric>
#include <iomanip>


#define log(x) cout<<x<<endl
#define pb push_back
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
typedef long long lint;
using namespace std;


// <<fixed<<setprecision(6)<<


int gcd(lint x, lint y){
  return y==0 ? x:gcd(y,x % y);
}


int combi(int n, int r){
  int num = 1;
  for(int i = 1; i <= r; i++){
    num = num * (n - i + 1) / i;
  }
  return num;
}


int main(){
  int a,b;
  cin>>a>>b;
  if(a==b){
    cout<<'0'<<endl;
  }
  else{
    cout<<max(a,b)-min(a,b)<<endl;
  }
}

C++: #define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS

#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <bitset>
#include <utility>
#include <numeric>

using namespace std;

using ll = long long;
using ull = unsigned long long;

const ll inf = (ll)1e9;
const ll mod = (ll)1e9 + 7;

int main()
{
	int a, b;
	cin >> a >> b;

	cout << abs(a - b) << endl;
}

C++: #include<bits/stdc++.h>
using namespace std;
int main(void)
{
	int a,b,c;
	cin>>a>>b;
	c=a-b;
	if(c<0) c*=-1;
	cout<<c<<endl;
	
	return 0;
}

C++: #include<iostream>
#include<cmath>

using namespace std;
int main()
{
    int x1,x2;
    cin >> x1 >> x2;
    cout << abs(x1-x2) << endl;
    return 0;
}

C++: // Red Dragonfly

#include <iostream>
using namespace std;

int main() {
    int x1, x2;

    cin >> x1 >> x2;
    if (x1 >= x2) cout << x1 - x2 << '\n';
    else cout << x2 - x1 << '\n';

    return 0;
}

C++: #include <iostream>
using namespace std;
int main(){

int a , b , c ;
cin >> a >> b ;
c = a – b ;
if (c < 0 ) cout << c * -1 <<endl ;
cout << c << endl ;

return 0;
}

C++: #include <iostream>
using namespace std;
int main(){

int x1 , x2 ;
cin >> x1 >> x2 ;

if ( x1 < x2 ) cout<< x2 - x1 << endl ;
else
cout << x1 - x2 <<endl ;

return 0;
}