Submission #211661

# Submission time Handle Problem Language Result Execution time Memory
211661 2020-03-20T23:29:37 Z Jatana Sweeping (JOI20_sweeping) C++17
11 / 100
18000 ms 2052108 KB
/*
                                                                                                     
                                             `-:://:::-                                             
                                           `//:-------:/:`                                          
                                          .+:--.......--:+`                                         
                                         `+:--..`````..--//`                                        
                                         .o:--..`` ``..--:o`                                        
                                         .o:--...```..---+/`                                        
                                       `/y+o/---....---:+o.                                         
                                   `...````-os+/:---:/+o/--.`                                       
              `-/+++++/:.      `...`       :h+d+oooo+/+-`   ...                                     
            `/++//:::://++-`....`         -.`//````````:`     `..`                                  
           `o+/::------://o/`           `-` -.          -`       `..`                               
 `---.-o/:./o/::-..``..-ЗАПУСКАЕМ      ..  ..            -`        `...       ``..``                
  `....o+:-++/:--.```..-://s.        `-`  .-              -`          `-o: .-//::::/:-`             
          `:s+/:--....-::/+s-`      .-   `-                -`           -///:--------:/:`           
           ./s+//:::::://oo-``..НЕЙРОННУЮ: СЕТЬ:::::::-`РАБОТЯГИ        `+:--........--:/`          
            .:ooo+++++osso-`    `.:-...`/` ./::-------:/:`   -`         :+--..``````.--:+:...-+:-`  
             `.-/+++++/+-.-`    -.   ``:so:/:--.......--:+`  `-```````o+/+--..`````..--:o/-..:s+:.  
                 ```````:``.. `-`     -` `+:--..`````..--/+-.../.`````..-o:--.......---/o.    `     
                        `:  `:-      -.  .o:--..`` ``..--:o`   `-`      `:o+:--------:+o-`          
                         `-`-...    ..   .o/--...```..--:+/`    `-`     `oy/so/////++o/.`           
                          -/`  `-` `- ``+s/o/:---...---:++.      `-`   .-../d://///:-.`             
                `.---..``-..-    .-/..`````-oo+/:::::/+o+-        `-``-`  `-.  ````                 
             `:++++/+++++-  ..``.-/:`      /y-:/++o++/:.`..`       ./.   `-                         
            -++/::::::://+/..:-``:` ..   `-.`  ```.```    `..`   `..`-` `-                          
       ``  -o//:--....-::/++` -.-`   `-`.-`                 `..`..`  `-.-                           
  -----ss+:++/:--.```..-://s.  /.     `::                    `-:.     ./`                           
  `````/:..+o/::-..``.--:/+s. ..-`   `-``-`                 ..` `-`  `-`-`                          
          `-s+/::-----::/+oo---``-` ..    .:-    ```      .-`     .-.-  `-`                         
           `:oo+//::://+os/..:`..-/:`      :y.-:::::::.`.-`        ./-`  `-`                        
            `./+oooooooo+/.`-    .-:...`.. .//:-------://`        `- `..` `:.                       
              ``.-::::-.``-/`  `-` `-  `oo:+:--.......--:/`      `-    `.:--h.``..```               
                          -.-`.-    .-   `+:--..`````..--//`    `-       /s-//::::::::.             
                         -` `/-      ..  .o:--..`` ``..--:o.```.-        `//:--------://`           
                        -` .-`.-`     -.`-o/--...```..--:+/.``-:....``:-.+:--....`...--:+`          
                       ..`-.   `-.   ``:os:o/:---...---:++.  `-     ``///+:-..``````.--:+-````-.`   
              `.:///////.-`      .:-..` -``-+o+/:::::/+o/.  `-         `:+:-..`````..--:o/:--/ys+-  
            `-++///////+o/. ``....`-.    :` `.:++++++/:.`  .-           -o/---......---/o.   `.`    
           `++//:-----::/+o:..`     .-`   :    ```````    .-           `+so+:--------:++-`          
  `````:-``:o/::-..`..--:/+o`         -.  `-             .-          `../../+o+////+o+:.`           
  -----syo/o+/:--.```..-://s.          .-` `-           .-        `...     ``-:////:-``             
       .` `/s//:--....-::/+s.            -. `-`        .-       `..`                                
           .+o+/:::--:://+s/-..`          .::+y  ```  .-     `..`                                   
            ./oo++////+oso-`   `....       :y-+:::::::/`   ...                                      
             `.:+oooooo/-`         `....-. .//:-------:/:-.`                                        
                ``...``                 /+:+:--.......--:+`                                         
                                         `+:--..`````..--//`                                        
                                         .o:--..`` ``..--:o`                                        
                                         .+/--...```..--:+/`                                        
                                         `-o/:---...---:++.                                         
                                          `-+o+/:---:/+o/.                                          
                                            `.:+oooo+/-.`                                           
                                               ``````                                               
*/

#ifdef aimbot
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#endif

#define hur(f, g) template<class c> int f(c a) {if (sizeof(c) == 8) return g##ll(a); else return g(a);}
hur(popc, __builtin_popcount) hur(ctz, __builtin_ctz) hur(clz, __builtin_clz)

/*
	- place bitset modifications here
*/

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>
#include <queue>
#include <ostream>
#include <istream>
#include <typeinfo>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <limits>
#include <fstream>
#include <array>
#include <list>
#include <bitset>
#include <functional>
#include <random>
#include <cstring>
#include <chrono>

#define random escape__from__random__aetuhoetnuhshe
#define mt make_tuple
#define x first
#define y second
#define pb push_back
#define mp make_pair
#define le(v) ((int)v.size())
#define f(i, n) for (int i = 0; i < (n); i++)
#define rof(i, n) for (int i = ((n) - 1); i >= 0; i--)
#define apply(v, act) for (auto &x : v) { act; }
#define log(args...) {string s = #args;deque<string> deq;\
string buf = "";int bal = 0;for (char c : s) {\
if (c == '(' || c == '[' || c == '{') {bal++;\
} else if (c == ')' || c == ']' || c == '}') {\
bal--;} else {if (bal == 0) {if (c == ',') {\
deq.pb(buf);buf = "";} else {if (c != ' ') {\
buf += c;}}}}}if (!buf.empty()) {deq.pb(buf);}\
smart_io::precall_print();smart_io::_print(deq, args);}

inline int min(const int &x, const int &y) { return (((y-x)>>(32-1))&(x^y))^x; }
inline int max(const int &x, const int &y) { return (((y-x)>>(32-1))&(x^y))^y; }
inline long long min(const long long &x, const long long &y) { return (((y-x)>>(64-1))&(x^y))^x; }
inline long long max(const long long &x, const long long &y) { return (((y-x)>>(64-1))&(x^y))^y; }

#define print    \
smart_io::precall_print(); \
cout,

#define scan cin,

#ifdef fast_allocator
const int MAXMEM = 200 * 1000 * 1024;
char _memory[MAXMEM];
size_t _ptr = 0;
void* operator new(size_t _x) { _ptr += _x; assert(_ptr < MAXMEM); return _memory + _ptr - _x; }
void operator delete (void*) noexcept {}
#endif

using namespace std;

char string_in_buffer[(int)260];


void fast_scan(int &x) { scanf("%d", &x); }
void fast_scan(long long &x) { scanf("%lld", &x); }
void fast_scan(unsigned long long &x) { scanf("%llu", &x); }
void fast_scan(double &x) { scanf("%lf", &x); }
void fast_scan(long double &x) { scanf("%Lf", &x); }
void fast_scan(char &x) {
	scanf("%c", &x);
	if (x == '\n') {
		fast_scan(x);
	}
}
void fast_scan(string &x) {
	scanf("%s", string_in_buffer);
	x = string(string_in_buffer);
}

template<class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
	fast_scan(p.first);
	fast_scan(p.second);
}

template <class T>
void fast_scan(vector<T> &v) {
	for (auto &x : v) fast_scan(x);
}

void fast_print(const int &x) { printf("%d", x); }
void fast_print(const unsigned int &x) { printf("%u", x); }
void fast_print(const long long &x) { printf("%lld", x); }
void fast_print(const unsigned long long &x) { printf("%llu", x); }
void fast_print(const char &x) { printf("%c", x); };
// void fast_print(__int128 x) {
// 	if (x == 0) { fast_print('0'); return; }
// 	if (x < 0) {
// 		fast_print('-');
// 		x = -x;
// 	}
// 	__int128 p = 1;
// 	while (x / (p * 10)) p *= 10;
// 	while (p) {
// 		__int128 symb = x / p;
// 		fast_print((int)symb);
// 		x -= p * symb;
// 		p /= 10;
// 	}
// };
void fast_print(const double &x) { printf("%.15lf", x); }
void fast_print(const long double &x) { printf("%.15Lf", x); }
void fast_print(const string &x) { printf("%s", x.c_str());}
void fast_print(const char v[]) { fast_print((string)v); }

template<class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
	fast_print(p.first);
	fast_print(' ');
	fast_print(p.second);
}

template <class T>
void fast_print(const vector<T> &v) {
	if (v.empty()) return;
	fast_print(v[0]);
	for (int i = 1; i < v.size(); i++) {
		fast_print(' ');
		fast_print(v[i]);
	}
}

template <class T>
void fast_print(const vector<vector<T>> &v) {
	if (v.empty()) return;
	fast_print(v[0]);
	for (int i = 1; i < v.size(); i++) {
		fast_print('\n');
		fast_print(v[i]);
	}
}

template <class T>
void fast_print(const T &v) {
	for (const auto &x : v) {
		fast_print(x);
		fast_print(' ');
	}
}


using namespace std;


namespace smart_io {
	string print_start = "";
	string sep = " ";
	bool first_print = false;
	
	void precall_print() {
		fast_print(print_start);
		print_start = "\n";
		first_print = true;
	}
	
	void _print(deque<string>) {}
	template<class T, class... Args>
	void _print(deque<string> names, T elem, Args... args) {
		if (!first_print) {
			fast_print("\n");
		} else {
			first_print = false;
		}
		fast_print(names.front());
		fast_print(" = ");
		fast_print(elem);
		names.pop_front();
		_print(names, args...);
	}
} //namespace smart_io


template <class T>
ostream &operator,(ostream &os, const T &object) {
	if (!smart_io::first_print) {
		fast_print(smart_io::sep);
	} else {
		smart_io::first_print = false;
	}
	fast_print(object);
	return os;
}

template <class T>
istream &operator,(istream &is, T &object) {
	fast_scan(object);
	return is;
}

namespace random {
	using namespace std::chrono;
	mt19937 rng(duration_cast< milliseconds >(
											  system_clock::now().time_since_epoch()
											  ).count());
	uniform_real_distribution<> prob_dist(0.0, 1.0);
};

namespace typedefs {
	typedef long long ll;
	typedef unsigned long long ull;
	typedef pair<int, int> pii;
	typedef long double ld;
}

namespace numbers_operation {
	template<class T>
	inline T floor_mod(T a, const T &b) {
		a %= b;	
		if (a < 0) a += b;
		return a;
	}
}

using namespace numbers_operation;
using namespace typedefs;
using namespace random;

struct Node;
struct Site {
	Site *l = NULL, *r = NULL;
	Node *god = NULL;
};
struct Node {
	pii key; int prior;
	pii mod = mp(-1, -1);
	Node *l = NULL, *r = NULL;
	Node *up = NULL; Node *pref = NULL;
	vector<Site*> dep;

	Node(pii _key) {
		key = _key; prior = rng();
	}
};

void push(Node *node) {
	if (!node) return;
	if (node->mod.x != -1) {
		node->key.x = node->mod.x;
		if (node->l) node->l->mod.x = node->mod.x;
		if (node->r) node->r->mod.x = node->mod.x;
		node->mod.x = -1;
	}
	if (node->mod.y != -1) {
		node->key.y = node->mod.y;
		if (node->l) node->l->mod.y = node->mod.y;
		if (node->r) node->r->mod.y = node->mod.y;
		node->mod.y = -1;
	}
}

Node *merge(Node *l, Node *r) {
	if (!r) return l;
	if (!l) return r;
	if (l->prior > r->prior) {
		push(l);
		l->r = merge(l->r, r);
		if (l->r) l->r->pref = l;
		return l;
	} else {
		push(r);
		r->l = merge(l, r->l);
		if (r->l) r->l->pref = r;
		return r;
	}
}
template<class TFunc>
pair<Node*, Node*> split(Node *node, TFunc func) {
	// splits < x, >= x
	if (!node) return mp(node, node);
	push(node);
	if (func(node->key)) { // returns true if node belong to left
		if (node->r) node->r->pref = NULL;
		auto tt = split(node->r, func);	
		node->r = tt.x;
		if (node->r) node->r->pref = node;
		return mp(node, tt.y);
	} else {
		if (node->l) node->l->pref = NULL;
		auto tt = split(node->l, func);
		node->l = tt.y;
		if (node->l) node->l->pref = node;
		return mp(tt.x, node);
	}
}
void set_leader(Node *node, Node *lead) {
	if (!node) return;
	push(node);
	node->up = lead;
	set_leader(node->l, lead);
	set_leader(node->r, lead);
}
Node *flex(Node *l, Node *r) {
	if (!l) return r;
	if (!r) return l;
	push(l); push(r);
	if (rng() % 2) swap(l, r);
	auto t0 = split(r, [&](pii key) {
		return key < l->key;
	});	
	auto t1 = split(t0.y, [&](pii key) {
		return key <= l->key;
	});	
	// if (t1.x) t1.x->up = l;
	set_leader(t1.x, l);
	if (l->l) l->l->pref = NULL;
	l->l = flex(l->l, t0.x);
	if (l->l) l->l->pref = l;
	if (l->r) l->r->pref = NULL;
	l->r = flex(l->r, t1.y);
	if (l->r) l->r->pref = l;
	return l;
}

Node *get_root(Node *node) {
	assert(node);
	if (!node->up) return node;
	return node->up = get_root(node->up);
}

pii get_val(Node *node) {
	assert(node);
	node = get_root(node);
	pii key = node->key;
	while (node) {
		if (node->mod.x != -1) {
			key.x = node->mod.x;
		}
		if (node->mod.y != -1) {
			key.y = node->mod.y;
		}
		node = node->pref;
	}
	return key;
}

pii get_min(Node *node) {
	push(node);
	while (node->l) {
		node = node->l;
		push(node);
	}
	return node->key;
}

pii get_max(Node *node) {
	push(node);
	while (node->r) {
		node = node->r;
		push(node);
	}
	return node->key;
}

struct Query {
	int type;
	int X;
	pii pp;	
};

vector<int> cords;
int zip(int x) {
	auto it = lower_bound(cords.begin(), cords.end(), x);
	// assert(it != cords.end());
	// assert(*it == x);
	return it - cords.begin();
}
int zipU(int x) {
	return upper_bound(cords.begin(), cords.end(), x) - cords.begin();
}
void remove_dep(Node *node) {
	for (Site *x : node->dep) {
		if (x->l)
			x->l->r = x->r;
		if (x->r)
			x->r->l = x->l;
	}
	node->dep.clear();
}
struct Invoker {
	int n;
	vector<Site*> S;
	void add(int i, int tl, int tr, int ql, int qr, Node *n) {
		if (qr <= tl || tr <= ql) return;
		if (ql <= tl && tr <= qr) {
			Site *s = new Site;
			s->god = n;
			s->r = S[i]->r;
			if (s->r)
				s->r->l = s;
			S[i]->r = s;
			s->l = S[i];
			n->dep.pb(s);
			// S[i].pb(n);
		} else {
			int m = (tl + tr) / 2;
			add(i + 1, tl, m, ql, qr, n);
			add(i + (m - tl) * 2, m, tr, ql, qr, n);
		}
	}
	void extract(int i, int tl, int tr, int j, vector<Node*> &pool) {
		Site *s = S[i];
		while (s) {
			if (s->god)
				pool.pb(s->god);
			s = s->r;
		}
		if (tl + 1 != tr) {
			int m = (tl + tr) / 2;
			if (j < m) extract(i + 1, tl, m, j, pool);
			else extract(i + (m - tl) * 2, m, tr, j, pool);
		}
	}
	Invoker(int _n) {
		n = _n;
		S.resize(2 * n);
		for (int i = 0; i < 2 * n; i++) {
			S[i] = new Site;
		}
	}
};
signed main(signed argc, char *argv[]) {
	int n, m, q; scan n, m, q;
	vector<Node*> where;
	vector<Node*> pts;
	f(i, m) {
		pii pp; scan pp;
		pts.pb(new Node(pp));
		where.pb(pts.back());
		cords.pb(pp.x); cords.pb(pp.y);
	}
	vector<pii> st;
	vector<Query> qs;
	f(i, q) {
		int t; scan t;
		if (t == 1) {
			int id; scan id; id--;
			qs.pb({t, id});
		} else if (t == 2) {
			int L; scan L;
			cords.pb(L);
			cords.pb(n - L);
			qs.pb({t, L});
		} else if (t == 3) {
			int L; scan L;
			cords.pb(L);
			cords.pb(n - L);
			qs.pb({t, L});
		} else if (t == 4) {
			pii pp; scan pp;
			cords.pb(pp.x); cords.pb(pp.y);
			qs.pb({t, -1, pp});
		} else assert(false);
	}
	sort(cords.begin(), cords.end());
	cords.resize(unique(cords.begin(), cords.end()) - cords.begin());
	Invoker invX(le(cords));
	Invoker invY(le(cords));
	auto add_bomb = [&](Node *nd) {
		if (!nd) return;
		pii L = get_min(nd);
		pii R = get_max(nd);
		// well, so here some special cases can be handled
		if (L.y == R.y) {
			invX.add(0, 0, le(cords), zip(L.y), zip(n - L.x), nd);
			invY.add(0, 0, le(cords), zip(L.y) + 1, zipU(n - L.x), nd);
		} else {
			assert(L.x == R.x);
			invY.add(0, 0, le(cords), zip(L.y) + 1, zip(n - L.x), nd);
			invX.add(0, 0, le(cords), zip(L.y), zip(n - L.x), nd);
		}
	};
	for (int i = 0; i < le(where); i++) {
		add_bomb(where[i]);
	}
	f(i, q) {
		int t = qs[i].type;
		if (t == 1) {
			int id = qs[i].X;
			print get_val(where[id]);
		} else if (t == 2) {
			int L = qs[i].X;
			Node *up = NULL;
			vector<Node*> pool;
			invX.extract(0, 0, le(cords), zip(L), pool);
			// invY.extract(0, 0, le(cords), zip(L), pool);
			// sort(pool.begin(), pool.end());
			// pool.resize(unique(pool.begin(), pool.end()) - pool.begin());
			for (Node *nd : pool) {
				remove_dep(nd);
			}
			for (Node *nd : pool) {
				auto tt = split(nd, [&](pii pp) {
					return pp.y <= L && pp.x < n - L;
				});
				if (tt.x) tt.x->mod.x = (n - L);
				if (tt.y) {
					add_bomb(tt.y);
				}
				up = flex(up, tt.x);
			}
			if (up)
				add_bomb(up);	
		} else if (t == 3) {
			int L = qs[i].X;
			// for (pii &pp : pts) {
			// 	if (pp.x <= L && pp.y < n - L) {
			// 		pp.y = n - L;
			// 	}
			// }
			Node *up = NULL;
			vector<Node*> pool;
			// invX.extract(0, 0, le(cords), zip(L), pool);
			invY.extract(0, 0, le(cords), zip(n - L), pool);
			for (Node *nd : pool) {
				remove_dep(nd);
			}
			for (Node *nd : pool) {
				auto tt = split(nd, [&](pii pp) {
					return pp.x <= L && pp.y < n - L;
				});
				if (tt.x) tt.x->mod.y = n - L;
				if (tt.y)
					add_bomb(tt.y);
				up = flex(up, tt.x);
			}
			if (up)
				add_bomb(up);
		} else if (t == 4) {
			pii pp = qs[i].pp;
			pts.pb(new Node(pp));
			where.pb(pts.back());
			add_bomb(where.back());
		} else assert(false);
	}	
}

Compilation message

sweeping.cpp: In function 'void fast_scan(int&)':
sweeping.cpp:141:31: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(int &x) { scanf("%d", &x); }
                          ~~~~~^~~~~~~~~~
sweeping.cpp: In function 'void fast_scan(long long int&)':
sweeping.cpp:142:37: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(long long &x) { scanf("%lld", &x); }
                                ~~~~~^~~~~~~~~~~~
sweeping.cpp: In function 'void fast_scan(long long unsigned int&)':
sweeping.cpp:143:46: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(unsigned long long &x) { scanf("%llu", &x); }
                                         ~~~~~^~~~~~~~~~~~
sweeping.cpp: In function 'void fast_scan(double&)':
sweeping.cpp:144:34: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(double &x) { scanf("%lf", &x); }
                             ~~~~~^~~~~~~~~~~
sweeping.cpp: In function 'void fast_scan(long double&)':
sweeping.cpp:145:39: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(long double &x) { scanf("%Lf", &x); }
                                  ~~~~~^~~~~~~~~~~
sweeping.cpp: In function 'void fast_scan(char&)':
sweeping.cpp:147:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%c", &x);
  ~~~~~^~~~~~~~~~
sweeping.cpp: In function 'void fast_scan(std::__cxx11::string&)':
sweeping.cpp:153:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%s", string_in_buffer);
  ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
# Verdict Execution time Memory Grader output
1 Correct 29 ms 5888 KB Output is correct
2 Correct 19 ms 3712 KB Output is correct
3 Correct 35 ms 5880 KB Output is correct
4 Correct 38 ms 5496 KB Output is correct
5 Correct 36 ms 4992 KB Output is correct
6 Correct 9 ms 896 KB Output is correct
# Verdict Execution time Memory Grader output
1 Correct 11076 ms 1000540 KB Output is correct
2 Correct 11132 ms 994156 KB Output is correct
3 Correct 10867 ms 999584 KB Output is correct
4 Correct 14781 ms 1491544 KB Output is correct
5 Correct 17206 ms 2052108 KB Output is correct
6 Correct 14649 ms 1480200 KB Output is correct
7 Correct 11789 ms 1096412 KB Output is correct
# Verdict Execution time Memory Grader output
1 Execution timed out 18148 ms 1054876 KB Time limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Execution timed out 18148 ms 1054876 KB Time limit exceeded
2 Halted 0 ms 0 KB -
# Verdict Execution time Memory Grader output
1 Correct 29 ms 5888 KB Output is correct
2 Correct 19 ms 3712 KB Output is correct
3 Correct 35 ms 5880 KB Output is correct
4 Correct 38 ms 5496 KB Output is correct
5 Correct 36 ms 4992 KB Output is correct
6 Correct 9 ms 896 KB Output is correct
7 Correct 11076 ms 1000540 KB Output is correct
8 Correct 11132 ms 994156 KB Output is correct
9 Correct 10867 ms 999584 KB Output is correct
10 Correct 14781 ms 1491544 KB Output is correct
11 Correct 17206 ms 2052108 KB Output is correct
12 Correct 14649 ms 1480200 KB Output is correct
13 Correct 11789 ms 1096412 KB Output is correct
14 Execution timed out 18148 ms 1054876 KB Time limit exceeded
15 Halted 0 ms 0 KB -