Summing up ints in vectors for education
Use Functions
There is a ton of repetition in your code. You could make it much better by just factoring out the common parts.
Printing
You don't like how you print your vector? There's a function for that:
template &lt;typename T&gt;
std::ostream&amp; operator&lt;&lt;(std::ostream&amp; os, std::vector&lt;T&gt; const&amp; xs) {
    bool first = true;
    os &lt;&lt; '{';
    for (T const&amp; x : x) {
        if (!first) os &lt;&lt; &quot;, &quot;;
        os &lt;&lt; x;
        first = false;
    }
    return os &lt;&lt; '}';
}

And now you can just do:
std::cout &lt;&lt; &quot;A = &quot; &lt;&lt; va &lt;&lt; &quot;, B = &quot; &lt;&lt; vb &lt;&lt; std::endl;

Checking Summation
There is a huge amount of repetition here. Effectively, we're summing f(x) on each vector, for differing x. So we can write a function for that:
template &lt;typename F&gt;
int accumulate(std::vector&lt;int&gt; const&amp; xs, F f) {
    int sum = 0;
    for (int x : xs) {
        sum += f(x);
    }
    return sum;

    // aka return boost::accumulate(xs | transformed(f), 0);
}

bool matches(std::vector&lt;int&gt; const&amp; A, std::Vector&lt;int&gt; const&amp; B, F f) {
    return accumulate(A, f) == accumulate(B, f);
}

Don't use goto
There is hardly ever a reason to use goto and this is not it. Once you refactor everything, you can just write out your test:
if (matches(va, vb, [](int x){ return x; }) &amp;&amp;
    matches(va, vb, [](int x){ return x*x; }) &amp;&amp;    
    matches(va, vb, [](int x){ return x*x*x; }) &amp;&amp;
    matches(va, vb, [](int x){ return x*x*x*x; }))
{
    std::cout &lt;&lt; &quot;Found: A=&quot; &lt;&lt; va &lt;&lt; &quot;, B=&quot; &lt;&lt; vb &lt;&lt; std::endl;
    break;
}

No goto needed.
Use a for loop
You are looping on split from 0 to the max uint32_t value. This isn't obvious because you're using the wrong loop:
for (uint32_t split=0; split &lt; std::numeric_limits&lt;uint32_t&gt;::max(); ++split)

Returning from main
You don't have to use return EXIT_SUCCESS; or return 0;. As a special case for main, return 0 is implied.
Better algorithm
Looping over a few billion elements isn't going to be the best approach... especially when there are only ~300 million unique sets to check to begin with (those that have 16 elements on each side, ignoring mirrored duplicates for which one ends up being A).