import std.stdio;
import std.regex;

void main(){
	auto io = new IO();
	
	auto w = io.line!string()[0];
	
	foreach( a ; alphaB ){
		if( w.count(a) % 2 != 0 ){
			writeln( "No" );
			return;
		}
	}
	writeln("Yes");
	
	return;
}

import std.stdio,std.conv,std.string;
import std.algorithm,std.array,std.math;

immutable PRIME = 1_000_000_007;
immutable alphaB = "abcdefghijklmnopqrstuvwxyz";
immutable alphaU = "ABCDRFGHIJKLMNOPQRSTUVWXYZ";
class IO
{
	T[] line( T = size_t , string token = " " )( size_t m = 1 ){
		T[] arr = [];
		foreach( i ; 0..m ){
			arr ~= this.read!T();
		}
		return arr;
	}
	T[][] rect( T = size_t , string token = " " )( size_t m = 1 ){
		T[][] arr = new T[][](m);
		foreach( i ; 0..m ){
			arr[i] = this.read!T(token);
		}
		return arr;
	}
	private T[] read( T = size_t )( string token = " " ){
		T[] arr;
		foreach( elm ; readln().chomp().split(token) ){
			arr ~= elm.to!T();
		}
		return arr;
	}
	void swap( T )( ref T x , ref T y ){
		x = x^y;
		y = x^y;
		x = x^y;
	}
}
// Array compute
// T -> T[]
pure T[] step( T = size_t )( in T begin , in T end , in T step = 1 ){
	T[] ret = new T[]((end-begin)/step);
	size_t i;
	for( T n = begin ; n < end ; n += step ){
		ret[i] = n;
		i+=1;
	}
	return ret;
}
unittest{
	assert( step(0,10,2) == [0,2,4,6,8] );
}

// T[] -> T[]
pure T[] fill( T )( T[] args , in T filling ){
	foreach( ref arg ; args ){
		arg = filling;
	}
	return args;
}
T[] map( T )( T[] args , T function(T) f ){
	foreach( ref arg ; args ){
		arg = f(arg);
	}
	return args;
}
unittest{
	assert( [true,false,true,false].fill(true) == [true,true,true,true] );
	assert( [1,-2,3,-4].map!int(x=>x*2) == [2,-4,6,-8] );
}
// operation
// T[] -> T number
pure T sum( T )( in T[] args ){
	T ret = 0;
	foreach( i ; 0..args.length ){
		ret += args[i];
	}
	return ret;
}
pure real multi( in real[] args ){
	real ret = 1.0;
	foreach( i ; 0..args.length ){
		ret *= args[i];
	}
	return ret;
}
pure T ave(T)( in T[] args ){
	return args.sum()/args.length;
}
// Search
// T[] -> any
pure bool any( T )( in T[] args , in T target ){
	foreach( arg ; args ){
		if( arg == target ){return true;}
	}
	return false;
}
pure bool all( T )( in T[] args , in T cond ){
	foreach( arg ; args ){
		if( arg != cond ){return false;}
	}
	return true;
}
pure bool have( T )( in T[] args , in T[] target ... ){
	bool[] found = new bool[](target.length);
	foreach( arg ; args ){
		foreach( i,t ; target ){
			if( arg == t ){
				found[i] = true;
			}
		}
	}
	foreach( f ; found ){
		if( f == false ){return false;}
	}
	return true;
}
pure size_t count( T )( in T[] args , in T target ){
	size_t c = 0;
	foreach( arg ; args ){
		c += ( arg == target ) ? 1 : 0 ;
	}
	return c;
}