quick save

群星联结，调不动了；

// code by 樓影沫瞬_Hz17
#include <iostream>
#include <map>
#include <vector>
#include <algorithm>
 
struct Chara;
struct Talent;
struct Attack;
 
int turn;
int n; 
 
struct Talent {
	Chara *me;
	int pat, x, y;
	Talent() {
		pat = x = y = 0;
	}
};
 
struct Buff {
	using type_buff = std::pair<int, int>;
	int miege; bool st_miege;
	Chara *me;
	#define num first
	#define tim second
	std::vector<type_buff> mp, def, atk;
	void settle();
	Buff() {
		miege = st_miege = 0;
	}
};
 
 
struct Chara {
	int hp, HP, mp, MP, atk, __atk, def, __def;
	bool life;
	struct Skill_C {
		int pat, x, y, z;
		Skill_C() {
			pat = x = y = z = 0;
		}
	} skill;
	std::vector<Chara*> aims, teamate;
	Talent talent;
	Buff buff;
	Chara() {
		hp = HP = mp = MP = atk = __atk = def = __def = 0;
		life = 1; 
	}
	void del_aim(Chara*to) {
		for(auto it = aims.begin(); it != aims.end(); it ++) {
			if(*it == to) {
				aims.erase(it);
				return;
			}
		}
	}
	void del_mate(Chara*to) {
		for(auto it = teamate.begin(); it != teamate.end(); it ++) {
			if(*it == to) {
				teamate.erase(it);
				return;
			}
		}
	}
	void erase() {
		life = 0;
		for(Chara *enemy : aims) {
			enemy->del_aim(this);
		}
		for(Chara *mate : teamate) {
			mate->del_mate(this);
		}
	}
	int tmp_atk() {
		int res = 0;
		for(auto v : buff.atk) {
			if(v.tim > 0) res += v.num;
		}
		return res;
	}
	int tmp_def() {
		int res = 0;
		for(auto v : buff.def) {
			if(v.tim > 0) res += v.num;
		}
		return res;
	}
	int A() { return std::max(atk + __atk + tmp_atk(), 1); }
	int D() { return std::max(def + __def + tmp_def(), 0); }
	void Heal(int x) { hp = std::min(hp + x, HP); }
	void Mana(int x) { mp = std::min(mp + x, MP); }
	void Team_Mana(int x) {
		for(Chara *mate : teamate) 
			mate->Mana(x); 
 	}
};
 
Chara tm[3][1000];
 
void GAMEOVER() {
	int sm1 = 0, sm2 = 0;
	for(int i = 1; i <= n; i ++) sm1 += tm[1][i].life;
	for(int i = 1; i <= n; i ++) sm2 += tm[2][i].life;
	if(sm1) {
		std::cout << turn << '\n';
		std::cout << "Alice\n";
		for(int i = 1; i <= n; i ++) {
			Chara m = tm[1][i];
			std::cout << std::max(m.hp, 0) << ' ';
		}
		exit(0);
	} 
	if(sm2) {
		std::cout << turn << '\n';
		std::cout << "Bob\n";
		for(int i = 1; i <= n; i ++) {
			Chara m = tm[2][i];
			std::cout << std::max(m.hp, 0) << ' ';
		}
		exit(0);
	}
}
 
void Dead(Chara *me) {
	if(me->hp <= 0) me->erase();
	if(me->teamate.size() == 0) GAMEOVER();
}
 
void Buff::settle() {
	if(st_miege) {
		miege --;
		if(!miege) {
			me->hp = -1145;
			Dead(me);
		}
	}
	for(uint i = 0; i < def.size(); i ++) {
		def[i].tim --;
		if(!def[i].tim) {
			def.erase(def.begin() + i);
			i --;
		}
	}
	for(uint i = 0; i < atk.size(); i ++) {
		atk[i].tim --;
		if(!atk[i].tim) {
			atk.erase(atk.begin() + i);
			i --;
		}
	}
	for(uint i = 0; i < mp.size(); i ++) {
		mp[i].tim --;
		if(!mp[i].tim) {
			mp.erase(mp.begin() + i);
			i --;
		}
	}
}
 
int hit(Chara *me, Chara *to, int x, int pat) {
	if(pat) to->hp -= std::max(x - to->D(), 0);
	Dead(to);
	return std::max(x - to->D(), 0);
}
 
int hit_ndef(Chara *me, Chara *to, int x, int pat) {
	if(to->talent.pat == 1) {
		if(pat) to->hp -= x - x / 2;
		Dead(to);
		return x - x / 2;
	}
	if(pat) to->hp -= x;
	Dead(to);
	return x;
}
 
struct Skills {
	void xtbl(Chara *me) {
	}
	void glzl(Chara *me, int x) {
		for(Chara* enemy : me->aims) {
			enemy->Mana(1);
			hit(me, enemy, x, 1);
			enemy->mp -= enemy->mp / 10;
		}
	}
	void rszy(Chara *me) {
		for(Chara *enemy : me->aims) {
			enemy->Mana(1);
			hit_ndef(me, enemy, me->A(), 1);
		}
	}
	void tlbdj(Chara *me, int x) {
		for(Chara *enemy : me->aims) {
			enemy->Mana(1);
			hit(me, enemy, std::min(enemy->HP / 10, x * me->A()), 1);
		}
	}
	void ycks(Chara *me, int x, int y) {
		for(Chara *mate : me->teamate) {
			mate->buff.mp.push_back({y, x});
		}
	}
	void tlsz(Chara *me, int x) {
		Chara *enemy = me->aims.front();
		enemy->__def -= x;
		enemy->Mana(1);
		hit_ndef(me, enemy, me->A(), 1);
	}
	void txcls(Chara *me, int x, int y) {
		Chara *enemy = me->aims.front();
		enemy->Mana(1);
		hit_ndef(me, enemy, me->A(), 1);
		for(Chara *enemy : me->aims) {
			enemy->buff.atk.push_back({-y, x});
		}
	}
	void jgzf(Chara *me, int x, int y, int z) {
		Chara *mi; int min = INT32_MAX;
		for(Chara *mate : me->teamate) {
			if(mate->hp < min) {
				min = mate->hp;
				mi = mate;
			}
			mate->buff.atk.push_back({y, x});
		}
		mi->Heal(z);
	}
	void lx(Chara *me, int x, int y) {
		for(Chara *enemy : me->aims) {
			enemy->Mana(1);
			hit(me, enemy, me->A(), 1);
		}
		for(Chara *enemy : me->aims) {
			enemy->buff.def.push_back({-y, x});
		}
	}
	void jlbh(Chara *me, int x, int y, int z) {
		for(Chara *mate : me->teamate) {
			mate->Heal(z);
			mate->buff.def.push_back({y, x});
		}
	}
	void qlcqk_lhzzm(Chara *me, int x) {
		for(Chara *mate : me->teamate) {
			mate->atk *= 2;
			mate->def *= 2;
			mate->hp = std::max(mate->HP / 2, mate->hp);
			mate->mp = std::max(mate->MP / 2, mate->mp);
			mate->buff.mp.push_back({1, INT32_MAX});
			mate->buff.st_miege = 1;
			mate->buff.miege = x;
		}
		for(Chara *mate : me->teamate) 
			if(mate->skill.pat == 10) mate->skill.pat = 0;
		for(Chara *enemy : me->aims) 
			if(enemy->skill.pat == 10) enemy->skill.pat = 0;
	}
} skl;
void us_skill(Chara *me) {
	int x = me->skill.x, y = me->skill.y, z = me->skill.z;
	me->mp = 0;
	switch (me->skill.pat) {
		case 0: skl.xtbl(me); break;
		case 1: skl.glzl(me, x); break;
		case 2: skl.rszy(me); break;
		case 3: skl.tlbdj(me, x); break;
		case 4: skl.ycks(me, x, y); break;
		case 5: skl.tlsz(me, x); break;
		case 6: skl.txcls(me, x, y); break;
		case 7: skl.jgzf(me, x, y, z); break;
		case 8: skl.lx(me, x, y); break;
		case 9: skl.jlbh(me, x, y, z); break;
		case 10: skl.qlcqk_lhzzm(me, x); break;
	}
	if(me->talent.pat == 5) me->Mana(me->talent.y);
}
 
void resume(Chara *me) {
	if(me->talent.pat == 3) {
		me->Heal(me->talent.x);
		me->Mana(me->talent.y);
	}
	for(auto v : me->buff.mp) if(v.tim > 0) me->Mana(v.num); 
	me->Mana(1);
}
 
int attack(Chara *me, Chara *to, int pat) {
	int res = 0;
	if(pat) to->Mana(1);
	if(me->talent.pat == 4) 
		return hit_ndef(me, to, me->A(), pat);
	if(me->talent.pat == 2) res += hit_ndef(me, to, me->talent.y, pat);
	res += hit(me, to, me->A(), pat);
	if(me->talent.pat == 5 and pat) me->Heal(me->talent.x);
	return res;
}
 
void debug() {
	std::cout << turn << '\n';
	std::cout << "Alice\n";
	for(int i = 1; i <= n; i ++) {
		Chara m = tm[1][i];
		std::cout << std::max(m.hp, 0) << ' ';
	}
	std::cout << "\nBob\n";
	for(int i = 1; i <= n; i ++) {
		Chara m = tm[2][i];
		std::cout << std::max(m.hp, 0) << ' ';
	}
	std::cout << "\n\n";
	fflush(stdout);
}
 
void ran(int t) {
	int mx = -1;
	Chara *id = 0;
	for(int i = 1; i <= n; i ++) { 
		Chara*m = &tm[t][i];
		if(m->life) 
			if(m->mp >= m->MP) 
				if(m->skill.pat >= mx) {
					mx = m->skill.pat, id = m;
				}
	}
	if(mx != -1) {
		us_skill(id);
		id->Mana(1);
		return;
	}
	int dmg = 0;
	for(int i = 1; i <= n; i ++) {
		Chara*m = &tm[t][i];
		if(m->life) {
			if(m->aims.front()->hp > mx) {
				id = m;
				mx = m->aims.front()->hp;
				dmg = attack(m, m->aims.front(), 0);
			}
			else if(m->aims.front()->hp == mx) {
				int tdmg = attack(m, m->aims.front(), 0);
				if(tdmg >= dmg) {
					id = m;
					dmg = tdmg;
				}
			}
		}
	}
	attack(id, id->aims.front(), 1);
	id->Mana(1);
}
 
void end(int t) {
	for(int i = 1; i <= n; i ++) {
		Chara *m = &tm[t][i];
		if(!m->life) continue;
		resume(m);
	}
}
 
void endall() {
	for(int i : {1, 2})
		for(int j = 1; j <= n; j ++) {
			auto*m = &tm[i][j];
			if(!m->life) continue;
 			m->buff.settle();
		}
}
 
int main() {
	#ifndef ONLINE_JUDGE
		freopen("in.ru", "r", stdin);
		freopen("out.ru", "w", stdout);
	#endif
	std::cin >> n;
	for(int i = 1; i <= n; i ++) {
		Chara tmp; 
		std::cin >> tmp.HP >> tmp.MP >> tmp.atk >> tmp.def;
		tmp.hp = tmp.HP;
		for(int j = 1; j <= n; j ++) {
			int x; std::cin >> x;
			tmp.aims.push_back(&tm[2][x]);
		}
		std::cin >> tmp.talent.pat >> tmp.talent.x >> tmp.talent.y;
		std::cin >> tmp.skill.pat >> tmp.skill.x >> tmp.skill.y >> tmp.skill.z;
		for(int j = 1; j <= n; j ++) {
			tmp.teamate.push_back(&tm[1][j]);
		}
		tm[1][i] = tmp;
		tm[1][i].talent.me = &tm[1][i];
		tm[1][i].buff.me = &tm[1][i];
	}
	for(int i = 1; i <= n; i ++) {
		Chara tmp;
		std::cin >> tmp.HP >> tmp.MP >> tmp.atk >> tmp.def;
		tmp.hp = tmp.HP;
		for(int j = 1; j <= n; j ++) {
			int x; std::cin >> x;
			tmp.aims.push_back(&tm[1][x]);
		}
		std::cin >> tmp.talent.pat >> tmp.talent.x >> tmp.talent.y;
		std::cin >> tmp.skill.pat >> tmp.skill.x >> tmp.skill.y >> tmp.skill.z;
		for(int j = 1; j <= n; j ++) {
			tmp.teamate.push_back(&tm[2][j]);
		}
		tm[2][i] = tmp;
		tm[2][i].talent.me = &tm[2][i];
		tm[2][i].buff.me = &tm[2][i];
	}
 
 
	while(1) {
		turn ++;
		ran(1);
		end(1);
		ran(2);
		end(2);
		endall();
	}
}   
// 星間~ 干渉~ 融解~ 輪迴~ 邂逅~ 再生~ ララバイ~