Language: C++

#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <functional>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <cassert>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
const double EPS = 1e-9;
const double PI  = acos(-1.0);

#include <complex>
typedef complex<double> P;
#define EQ(x, y) (abs((x)-(y)) < EPS)
double dot(P a, P b) {
    return (a.real() * b.real() + a.imag() * b.imag());
}
double cross(P a, P b) {
    return (a.real() * b.imag() - a.imag() * b.real());
}
int is_point_on_line(P a, P b, P c) {
    return EQ( cross(b-a, c-a), 0.0 );
}
int is_intersected_l_ls(P a1, P a2, P b1, P b2) {
    if ( cross(a2-a1, b1-a1) * cross(a2-a1, b2-a1) < -EPS )
        return true;
    return is_point_on_line(a1, a2, b1) || is_point_on_line(a1, a2, b2);
}
int is_point_on_ls(P a, P b, P c) {
    // |a-c| + |c-b| <= |a-b| then true
    return (abs(a-c) + abs(c-b) < abs(a-b) + EPS);
}


typedef vector<P> vp;

bool can_separate(int edge1,int edge2,int parent_o,int parent_t,vp &ours,vp &theirs){
	if(parent_o!=-1){
		if(!is_intersected_l_ls(ours[edge1],ours[edge2],ours[parent_o],theirs[parent_t])){
			return false;
		}
	}
	if(parent_o!=-1){
		REP(i,ours.size()){
			if(i!=parent_o&&i!=edge1&&i!=edge2){
				if(is_intersected_l_ls(ours[edge1],ours[edge2],ours[i],ours[parent_o])){
					return false;
				}
			}
		}
	}
	REP(i,theirs.size()){
		if(i!=parent_t){
			if(is_intersected_l_ls(ours[edge1],ours[edge2],theirs[i],theirs[parent_t])){
				return false;
			}
		}
	}
	return true;
}

int main(){
	int n,m;
	while(cin>>n>>m,n|m){
		vp black,white;
		REP(i,n){
			int x,y;
			cin>>x>>y;
			black.push_back(P(x,y));
		}
		REP(i,m){
			int x,y;
			cin>>x>>y;
			white.push_back(P(x,y));
		}

		bool ok=false;

		if(n==1&&m==1){
			ok=true;
			goto show;
		}else if(n==2&&m==1){
			ok=!is_point_on_ls(black[0],black[1],white[0]);
			goto show;
		}else if(n==1&&m==2){
			ok=!is_point_on_ls(white[0],white[1],black[0]);
			goto show;
		}

		bool all_on_line=true;
		bool scrumbled=false;
		REP(i,n+m){
			P ip=(i<n?black[i]:white[i-n]);
			REP(j,n+m){
				P jp=(j<n?black[j]:white[j-n]);
				REP(k,n+m){
					P kp=(k<n?black[k]:white[k-n]);
					if(!is_point_on_line(ip,jp,kp)){
						all_on_line=false;
					}
					if(is_point_on_ls(ip,jp,kp)){
						if((i<n)==(j<n)&&(i<n)!=(k<n)){
							scrumbled=true;
						}
					}
				}
			}
		}
		if(all_on_line){
			ok=!scrumbled;
			goto show;
		}

		REP(i1,n){
			FOR(i2,i1+1,n){
				int parent_o=-1;
				REP(j,n){
					if(j!=i1&&j!=i2){
						parent_o=j;
						break;
					}
				}
				if(can_separate(i1,i2,parent_o,0,black,white)){
					ok=true;
					goto show;
				}
			}
		}
		REP(i1,m){
			FOR(i2,i1+1,m){
				int parent_o=-1;
				REP(j,m){
					if(j!=i1&&j!=i2){
						parent_o=j;
						break;
					}
				}
				if(can_separate(i1,i2,parent_o,0,white,black)){
					ok=true;
					goto show;
				}
			}
		}
show:
		cout<<(ok?"YES":"NO")<<endl;
	}
}

Compiler output:
a.cc: In function 'int main()':
a.cc:170:1: error: jump to label 'show'
  170 | show:
      | ^~~~
a.cc:107:30: note:   from here
  107 |                         goto show;
      |                              ^~~~
a.cc:117:22: note:   crosses initialization of 'bool scrumbled'
  117 |                 bool scrumbled=false;
      |                      ^~~~~~~~~
a.cc:116:22: note:   crosses initialization of 'bool all_on_line'
  116 |                 bool all_on_line=true;
      |                      ^~~~~~~~~~~