#include <iostream>
#include <iomanip>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <sstream>

using namespace std;

struct buf {
	static const int size = 128;
	buf() { memset(bytes, 0, size);	}

	bool valid_offset(int o) { return (0 <= o && o < size); }

	void set_c(char c, int offset) {
		if (valid_offset(offset)) bytes[offset] = c;
	}

	void set_s(const char *s, int offset) {
		for (size_t i = 0; i < strlen(s)+1; i++){
			set_c(s[i], offset+i);
		} 
	}

	void set_i(int i, int offset) {
		union {int x; char s[5] = {0};};
		x = i;
		set_s(s, offset);
	}

	void print() {
		for(auto b : bytes) {
			cout << setw(2) << setfill('0') << hex << uppercase
				<< ((unsigned int)b & 0xff);
		}
		cout << endl;
	}
	
	char bytes[size];
};

struct arg {
	enum type_t{ a_u,a_s,a_x,a_c } _type;
	int offset;
	union { int i;char*s;char c; } data;

	static type_t cast_type(char c) {
		if (c == 'u') return a_u;
		if (c == 'x') return a_x;
		if (c == 's') return a_s;
		if (c == 'c') return a_c;
		throw string("this should not happen");
	}

	void type(type_t t) {
		_type = t;
		if (t == a_s) {
			data.s = new char[512];
		}
	}	

	void type(char c) {
		type(cast_type(c));
	}
	
	type_t type() {return _type;}
	
	void* get() {
		if (type() == a_s)
			return data.s;
		else 
			return &data.i;
	}
};

void read_args(string str, string fmt, vector<arg> &varg) {
	void *args[100] = {0};
	int i = 0;
	for (arg &a :varg) {
		args[i++] = a.get();
	}
	//TODO: template this or fake va_list
	sscanf(str.c_str(), fmt.c_str()
	,args[0],args[1],args[2],args[3],args[4] 
	,args[5],args[6],args[7],args[8],args[9] 
	,args[10],args[11],args[12],args[13],args[14] 
	,args[15],args[16],args[17],args[18],args[19] 
	,args[20],args[21],args[22],args[23],args[24] 
	,args[25],args[26],args[27],args[28],args[29] 
	,args[30],args[31],args[32],args[33],args[34] 
	,args[35],args[36],args[37],args[38],args[39] 
	,args[40],args[41],args[42],args[43],args[44] 
	,args[45],args[46],args[47],args[48],args[49] 
	,args[50],args[51],args[52],args[53],args[54] 
	,args[55],args[56],args[57],args[58],args[59] 
	,args[60],args[61],args[62],args[63],args[64] 
	,args[65],args[66],args[67],args[68],args[69] 
	,args[70],args[71],args[72],args[73],args[74] 
	,args[75],args[76],args[77],args[78],args[79] 
	,args[80],args[81],args[82],args[83],args[84] 
	,args[85],args[86],args[87],args[88],args[89] 
	,args[90],args[91],args[92],args[93],args[94] 
	,args[95],args[96],args[97],args[98],args[99] 
	);
}

vector<arg> extract_args(string str) {
	vector<arg> varg;
	istringstream istr;
	istr.str(str);
	int idx = 0;
	while (!istr.eof()) {
		char c;
		istr >> c;
		if (c == '%') {
			arg a;
			istr >> c;
			a.type(c);
			varg.push_back(a);
		} else if (c == ',') {
			int n;
			istr >> n;
			varg[idx++].offset = n;
		}
	}
	return varg;
}

string extract_fmt(string &str) {
	return str.substr(0, str.find(','));
}

string stdin_readline() {
	char a[512];
	cin.getline(a, 512);
	return string(a);
}

int main()
{
	string desc, str;
	desc = stdin_readline();
	str = stdin_readline();
	auto varg = extract_args(desc);
	string fmt = extract_fmt(desc);
	read_args(str, fmt, varg);
	buf buffer;
	for (arg &a : varg) {
		if (a.type() == arg::a_c)
			buffer.set_c(a.data.c, a.offset);
		else if (a.type() == arg::a_s)
			buffer.set_s(a.data.s, a.offset);
		else if (a.type() == arg::a_u || a.type() == arg::a_x)
			buffer.set_i(a.data.i, a.offset);
	}
	buffer.print();
		
	return 0;
}