diff -urN v6/kon.py v7/kon.py
--- v6/kon.py	2018-02-21 13:09:19.000000000 +0900
+++ v7/kon.py	2018-06-22 23:10:50.000000000 +0900
@@ -8,6 +8,14 @@
 import threading
 import socket
 
+map_lst = lambda f, lst: list( map( f, lst ) )
+map_up = lambda f, lst: map( lambda a: f(*a), lst )
+map_up_lst = lambda f, lst: list( map_up( f, lst ) )
+
+filter_lst = lambda f, lst: list( filter( f, lst ) )
+filter_up = lambda f, lst: filter( lambda a: f(*a), lst )
+filter_up_lst = lambda f, lst: list( filter_up(f, lst) )
+
 def dbg(s, *arg):
 	sys.stderr.write(s.format(*arg) + os.linesep)
 	sys.stdout.flush()
@@ -46,7 +54,7 @@
 	if s != None:
 		sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 		sock.connect( get_host_port(s, port=55765) )
-	return lambda s: ( sock.sendall if sock else sys.stdout.write )(s)
+	return lambda s: ( sock.sendall if sock else sys.stdout.write )( s.encode() )
 
 out = out_new()
 
@@ -84,13 +92,13 @@
 			dic_to_cls( cls_to_dic(pcls), self )
 
 def cls_to_dic(c):
-	ks = filter( lambda k: not k.startswith('_'), dir(c) )
-	return dict( map( lambda k: ( k, getattr(c, k) ), ks ) )
+	ks = filter_lst( lambda k: not k.startswith('_'), dir(c) )
+	return dict( map_lst( lambda k: ( k, getattr(c, k) ), ks ) )
 
 def dic_to_cls(d, c=None):
 	if not c:
 		c = Empty()
-	map( lambda (k, v): setattr(c, k, v), d.items() )
+	map_up_lst( lambda k, v: setattr(c, k, v), d.items() )
 	return c
 
 def extends(pcls, c=None):
@@ -130,7 +138,7 @@
 	e.f = wrap_f
 	return e
 
-updiv = lambda a, b: (a + b - 1) / b
+updiv = lambda a, b: int( (a + b - 1) / b )
 
 hz_to_sec = lambda hz: 1.0 / hz if hz > 0 else 0
 sec_to_hz = lambda sec: 1.0 / sec if sec > 0 else 0
@@ -255,7 +263,8 @@
 
 def getkey(tmout=None):
 	fd = sys.stdin.fileno()
-	return os.read(fd, 1) if readable(fd, tmout) else ''
+	#return os.read(fd, 1) if readable(fd, tmout) else ''
+	return os.read(fd, 1).decode() if readable(fd, tmout) else ''
 
 esc = lambda s: chr(0x1b) + '[' + s
 esc_ex = lambda d, v: esc( '?{}{}'.format(d, 'h' if v else 'l' ) )
@@ -263,7 +272,7 @@
 DIRS = ( U, D, L, R ) = 'udlr'
 bak_dir = lambda d: { U: D, D: U, L: R, R: L }.get(d)
 dir_to_xy = lambda d: { U: (0, -1), D: (0, 1), L: (-1, 0), R: (1, 0) }.get(d, (0, 0) )
-step_to = lambda x, y, d: ( lambda (dx, dy): (x+dx, y+dy) )( dir_to_xy(d) )
+step_to = lambda x, y, d: ( lambda dx, dy: (x+dx, y+dy) )( *dir_to_xy(d) )
 
 def keydir(tmout=None):
 	ctl = lambda s: chr( 1 + ord(s) - ord('a') )
@@ -272,12 +281,12 @@
 		[ ctl('p'), ctl('n'), ctl('b'), ctl('f') ], # emacs
 		[ 'k', 'j', 'h', 'l' ], # vi
 	]
-	d = dict( sum( map( lambda k4: zip(k4, DIRS), lst ), [] ) )
+	d = dict( sum( map_lst( lambda k4: list( zip(k4, DIRS) ), lst ), [] ) )
 	d.update({ ctl('a'): L, ctl('e'): R}) # emacs
 	d.update({ '\n': U, '\t': 'U', ' ': 'U' })
 	keys = d.keys()
 	buf = getkey(tmout)
-	while buf and any( map( lambda k: k.startswith(buf), keys ) ):
+	while buf and any( map_lst( lambda k: k.startswith(buf), keys ) ):
 		if buf in keys:
 			return d.get(buf)
 		buf += getkey(tmout)
@@ -331,23 +340,25 @@
 	(s_, col_, r_) = lst[0]
 	return mk_slst(s + s_, col, r) + lst[1:] if col == col_ and r == r_ else [a] + lst
 
-split_show_lst = lambda lst: sum( map( lambda (s, col, r): map( lambda c: (c, col, r), s ), lst ), [] )
+split_show_lst = lambda lst: sum( map_up_lst( lambda s, col, r: map_lst( lambda c: (c, col, r), s ), lst ), [] )
 
-show_lst_len = lambda lst: sum( map( lambda (s, col, r): len(s), lst ) )
+show_lst_len = lambda lst: sum( map_up_lst( lambda s, col, r: len(s), lst ) )
 
 def fit_show_lsts(show_lsts):
-	ns = map( show_lst_len, show_lsts )
+	ns = map_lst( show_lst_len, show_lsts )
 	max_n = max(ns)
-	return map( lambda (lst, n): sum_show_lst( lst + mk_slst(' ') * (max_n - n) ), zip( show_lsts, ns ) )
+	return map_up_lst( lambda lst, n: sum_show_lst( lst + mk_slst(' ') * (max_n - n) ), zip( show_lsts, ns ) )
 
 def shows(x, y, lst, flush_f=False):
-	x = reduce( lambda x, (s, col, r): show(x, y, s, col, r), sum_show_lst(lst), x )
+	#x = reduce( lambda x, s_col_r: show(x, y, *s_col_r), sum_show_lst(lst), x )
+	for (s, col, r) in sum_show_lst(lst):
+		x = show(x, y, s, col, r)
 	if flush_f:
 		flush()
 	return x
 
 def over_show_lst(l, h):
-	get_col = lambda (s, col, r): col
+	get_col = lambda s_col_r: s_col_r[1]
 	f = lambda l, h: l if get_col(h) == 'trans' else h
 	l = split_show_lst(l)
 	h = split_show_lst(h)
@@ -355,10 +366,10 @@
 	apd = mk_slst(' ', 'trans') * n
 	l = ( l + apd )[:n]
 	h = ( h + apd )[:n]
-	o = map( lambda (l, h): f(l, h), zip(l, h) )
+	o = map_up_lst( lambda l, h: f(l, h), zip(l, h) )
 	return sum_show_lst(o)
 
-trans_to_spc_show_lst = lambda lst: map( lambda (s, col, r): (' ' * len(s), '', False) if col == 'trans' else (s, col, r), lst )
+trans_to_spc_show_lst = lambda lst: map_up_lst( lambda s, col, r: (' ' * len(s), '', False) if col == 'trans' else (s, col, r), lst )
 
 def bit_w(v): # only positive value
 	w = 0
@@ -371,12 +382,12 @@
 	sv = f(s)
 	ev = f(e)
 	while e - s > 0:
-		m = (s + e) / 2
+		m = int( (s + e) / 2 )
 		mv = f(m)
 		(s, e, sv, ev) = (s, m, sv, mv) if mv < v else (m, e, mv, ev)
 	return s
 
-loop_xy = lambda w, h, f: sum( map( lambda y: map( lambda x: f(x, y), range(w) ), range(h) ), [] )
+loop_xy = lambda w, h, f: sum( map_lst( lambda y: map_lst( lambda x: f(x, y), range(w) ), range(h) ), [] )
 loop_xywh = lambda x, y, w, h, f: loop_xy( w, h, lambda dx, dy: f(x+dx, y+dy) )
 
 lst_xy = lambda w, h: loop_xy( w, h, lambda x, y: (x, y) )
@@ -388,17 +399,17 @@
 into_x = lambda x, w, ow: max( min( ow - w, x ), 0 )
 into_xy = lambda x, y, w, h, ow, oh: ( into_x(x, w, ow), into_x(y, h, oh) )
 
-cen_xywh = lambda x, y, w, h: (x + w/2, y + h/2)
+cen_xywh = lambda x, y, w, h: ( x + int(w/2), y + int(h/2) )
 
 def arr_xy_new(w, h, v):
 	e = Empty()
-	e.data = data = map( lambda _: [ v ] * w, range(h) )
+	e.data = data = map_lst( lambda _: [ v ] * w, range(h) )
 	e.size = lambda: (w, h)
 	e.chk_xy = lambda x, y: chk_xy(x, y, w, h)
 	e.get = lambda x, y, v=None: data[y][x] if e.chk_xy(x, y) else v
 	e.set = lambda x, y, c: set( data[y], x, c ) if e.chk_xy(x, y) else None
 	e.clear = lambda v: loop_xy( w, h, lambda x, y: e.set(x, y, v) )
-	e.poss = lambda v: filter( lambda (x, y): e.get(x, y) == v, lst_xy(w, h) )
+	e.poss = lambda v: filter_up_lst( lambda x, y: e.get(x, y) == v, lst_xy(w, h) )
 	e.pos = lambda v: next( iter( e.poss(v) ), (-1, -1) )
 	return e
 
@@ -425,7 +436,7 @@
 	e.get = lambda x, y, bit: arr.get(x, y, 0) & pat(bit)
 	e.set = lock_wrap( set_ ).f
 	e.clear = lambda: arr.clear(0)
-	e.gets = lambda x, y: filter( lambda bit: e.get(x, y, bit), range( bit_w( arr.get(x, y, 0) ) ) )
+	e.gets = lambda x, y: filter_lst( lambda bit: e.get(x, y, bit), range( bit_w( arr.get(x, y, 0) ) ) )
 	e.poss = lambda bit: pos_d.get(bit, [])
 	e.pos = lambda bit: next( iter( e.poss(bit) ), (-1, -1) )
 	return e
@@ -436,7 +447,7 @@
 	e.to_bit = to_bit = lambda c: bit_cs.index(c) if c in bit_cs else -1
 	e.get = lambda x, y, c: arr.get( x, y, to_bit(c) )
 	e.set = lambda x, y, c, v: arr.set( x ,y, to_bit(c), v )
-	e.gets = lambda x, y: map( lambda bit: bit_cs[bit], arr.gets(x, y) )
+	e.gets = lambda x, y: map_lst( lambda bit: bit_cs[bit], arr.gets(x, y) )
 	e.poss = lambda c: arr.poss( to_bit(c) )
 	e.pos = lambda c: next( iter( e.poss(c) ), (-1, -1) )
 	return e
@@ -475,7 +486,7 @@
 	def show_lst_area(x, y, show_lst, xcen=False):
 		(w, h) = e.show_lst_wh(show_lst)
 		if xcen:
-			x -= (w - 1) / 2
+			x -= int( (w - 1) / 2 )
 		(ow, oh) = e.size()
 		(x, y) = into_xy(x, y, w, h, ow, oh)
 		return (x, y, w, h)
@@ -500,23 +511,28 @@
 		if get_dx:
 			for ix in (-1, 0, 1):
 				x_ = (x + ix + w) % w
-				cs = filter( lambda c: ix == 0 or get_dx(c) == -ix, e.gets(x_, y) )
-				lst += map( lambda c: ( c, x_, ix if ix else get_dx(c) ), cs )
+				cs = filter_lst( lambda c: ix == 0 or get_dx(c) == -ix, e.gets(x_, y) )
+				lst += map_lst( lambda c: ( c, x_, ix if ix else get_dx(c) ), cs )
 
 			TRANS = mk_slst('  ', 'trans')
 			shift = lambda lst, dx: split_show_lst( lst + TRANS if dx < 0 else TRANS + lst )[1:3] if dx else lst
-			lst = map( lambda (c, x_, dx): ( c, shift( e.get_show_lst(c, x_, y), dx ) ), lst )
+			lst = map_up_lst( lambda c, x_, dx: ( c, shift( e.get_show_lst(c, x_, y), dx ) ), lst )
 		else:
-			lst = map( lambda c: ( c, e.get_show_lst(c, x, y) ), e.gets(x, y) )
+			lst = map_lst( lambda c: ( c, e.get_show_lst(c, x, y) ), e.gets(x, y) )
+
+		lst.sort( key=lambda c_show_lst: e.to_bit( c_show_lst[0] ) )
+		show_lsts = list( zip(*lst) )[1] if lst else []
+
+		#show_lst = reduce( over_show_lst, reversed( show_lsts ), [] )
+		show_lst = []
+		for a in reversed( show_lsts ):
+			show_lst = over_show_lst( show_lst, a )
 
-		lst.sort( key=lambda (c, show_lst): e.to_bit(c) )
-		show_lsts = zip(*lst)[1] if lst else []
-		show_lst = reduce( over_show_lst, reversed( show_lsts ), [] )
 		show_lst = trans_to_spc_show_lst(show_lst) if show_lst else mk_slst('  ')
 		e.shows(x, y, show_lst, flush_f)
 
 	e.update = update
-	e.update_xys = lambda xys, flush_f=False: ( map( lambda (x, y): e.update(x, y), xys ), e.flush(flush_f) )[-1]
+	e.update_xys = lambda xys, flush_f=False: ( map_up_lst( lambda x, y: e.update(x, y), xys ), e.flush(flush_f) )[-1]
 	e.update_area = lambda x, y, w, h, flush_f=False: e.update_xys( lst_xywh(x, y, w, h), flush_f )
 	e.update_line = lambda x, y, w, flush_f=False: e.update_area(x, y, w, 1, flush_f)
 	e.update_all = lambda flush_f=False: e.update_area(0, 0, w, h, flush_f)
@@ -524,9 +540,9 @@
 	def update_c(c, flush_f=False):
 		dx = get_dx(c) if get_dx else 0
 		xys = e.poss(c)
-		#xys += map( lambda (x, y): (x+dx, y), xys ) if dx else []
+		#xys += map_lst( lambda (x, y): (x+dx, y), xys ) if dx else []
 		if dx:
-			xys = xys + map( lambda (x, y): (x+dx, y), xys )
+			xys = xys + map_up_lst( lambda x, y: (x+dx, y), xys )
 		e.update_xys(xys, flush_f)
 	e.update_c = update_c
 
@@ -585,7 +601,7 @@
 		arr.update(x, y, flush_f)
 	e.set = set_
 
-	e.rm = lambda c, flush_f=False: map( lambda (x, y): e.set(x, y, c, False, flush_f), e.poss(c) )
+	e.rm = lambda c, flush_f=False: map_up_lst( lambda x, y: e.set(x, y, c, False, flush_f), e.poss(c) )
 
 	def msg_pause(x, y, show_lst, sec, xcen=False):
 		e.shows(x, y, show_lst, xcen, flush_f=True)
@@ -601,17 +617,17 @@
 	with open(fname, 'r') as f:
 		buf = f.read().strip().split( os.linesep )
 		h = len(buf)
-		w = max( map(len, buf) )
-		buf = map( lambda s: s + ' ' * ( w - len(s) ), buf ) # fill
+		w = max( map_lst(len, buf) )
+		buf = map_lst( lambda s: s + ' ' * ( w - len(s) ), buf ) # fill
 
 	arr = arr_xy_new(w, h, ' ')
-	e = extends(arr)
+	e = extends(arr, None)
 	loop_xy( w, h, lambda x, y: arr.set( x, y, buf[y][x] ) )
 	return e
 
 def main(f, help_msg):
 	if '-h' in sys.argv:
-		print 'Usage: {} {}'.format( sys.argv[0], help_msg )
+		print( 'Usage: {} {}'.format( sys.argv[0], help_msg ) )
 		sys.exit(0)
 	try:
 		restore = term_raw()
diff -urN v6/pac.py v7/pac.py
--- v6/pac.py	2018-02-21 13:09:19.000000000 +0900
+++ v7/pac.py	2018-06-22 23:10:50.000000000 +0900
@@ -8,15 +8,15 @@
 
 NO_DIE = '-m' in sys.argv
 
-txts = map( lambda s: s + '.txt', [ 'pac', 'mon_ret', 'warp', 'pato' ] )
-(pac_buf, mon_ret_buf, warp_buf, pato_buf) = map(kon.rbuf, txts)
+txts = kon.map_lst( lambda s: s + '.txt', [ 'pac', 'mon_ret', 'warp', 'pato' ] )
+(pac_buf, mon_ret_buf, warp_buf, pato_buf) = kon.map_lst(kon.rbuf, txts)
 
 MONS = 'RCMY'
 MOVES = 'P' + MONS
 
 dot_n = len( pac_buf.poss('.') + pac_buf.poss('O') )
 
-stat_inf = dict( map( lambda c: ( c, kon.Empty() ), MOVES ) )
+stat_inf = dict( kon.map_lst( lambda c: ( c, kon.Empty() ), MOVES ) )
 stat_get = lambda c: stat_inf.get(c)
 
 def pac_show(c, x, y):
@@ -26,7 +26,8 @@
 	return mk_slst(s, col, r)
 	
 def blk_show(c, x, y):
-	k = filter( lambda d: pac_buf.get( *kon.step_to(x, y, d) ) == c, DIRS ) # 'udlr'
+	k = kon.filter_lst( lambda d: pac_buf.get( *kon.step_to(x, y, d) ) == c, DIRS ) # 'udlr'
+	k = ''.join(k)
 	s = '=='
 	d = {
 		( 'ud', 'u', 'd', 'udl', 'udr' ): '||',
@@ -34,7 +35,7 @@
 		( 'ur', 'dr' ): ' =',
 		( 'udlr', ): '  ',
 	}
-	s = dict( sum( map( lambda (ks, v): map( lambda k: (k, v), ks ), d.items() ), [] ) ).get(k, s)
+	s = dict( sum( kon.map_up_lst( lambda ks, v: kon.map_lst( lambda k: (k, v), ks ), d.items() ), [] ) ).get(k, s)
 	return mk_slst(s, 'blue', False)
 
 SPC = ('  ', '', False)
@@ -44,7 +45,7 @@
 	e.v = 1
 	e.get = lambda: e.v
 	def check():
-		if not filter( lambda c: mon_mode(c) in ('weak', 'blink'), MONS ):
+		if not kon.filter_lst( lambda c: mon_mode(c) in ('weak', 'blink'), MONS ):
 			e.v = 1
 	e.check = check
 	e.twice = lambda: set( e, 'v', e.v * 2 )
@@ -114,7 +115,7 @@
 
 	return nc != '#'
 
-next_ds = lambda x, y, c: filter( lambda d: is_step(x, y, c, d), DIRS )
+next_ds = lambda x, y, c: kon.filter_lst( lambda d: is_step(x, y, c, d), DIRS )
 
 def arr_msg_pause(show_lst, x=None, y=None, sec=1.0, xcen=True):
 	ths_stop()
@@ -146,7 +147,7 @@
 		if mode in ('weak', 'blink'):
 			mov.en = False
 			ss = [ '. ', 'o ', 'O ', '<>', '()', '^^' ]
-			lsts = map( lambda s: mk_slst(s, 'yellow', True), ss )
+			lsts = kon.map_lst( lambda s: mk_slst(s, 'yellow', True), ss )
 			bak = pac_slider( kon.slider(lsts, 8.0, None, True, repeat=False) )
 			add = mon_price.get() * 200
 			mon_price.twice()
@@ -264,7 +265,7 @@
 bonus = bonus_new()
 
 def try_eat(x, y):
-	lst = filter( lambda c: c in '.OB', arr.gets(x, y) )
+	lst = kon.filter_lst( lambda c: c in '.OB', arr.gets(x, y) )
 	if not lst:
 		return
 	c = lst[0]
@@ -294,7 +295,7 @@
 is_remote = '-r' in sys.argv
 
 def pac_remote(pd, ds):
-	ds = filter( lambda d: d != kon.bak_dir(pd), ds )
+	ds = kon.filter_lst( lambda d: d != kon.bak_dir(pd), ds )
 	if len(ds) == 1:
 		return ds[0]
 
@@ -325,8 +326,8 @@
 		stat_get(c).th.set_hz(hz)
 
 def rand(n):
-	v = sum( sum( map( lambda c: list( arr.pos(c) ), MOVES ), [] ) )
-	return ( v / 4 ) % n
+	v = sum( sum( kon.map_lst( lambda c: list( arr.pos(c) ), MOVES ), [] ) )
+	return ( int( v / 4 ) ) % n
 
 rand_sel = lambda lst: lst[ rand( len(lst) ) ]
 
@@ -346,7 +347,7 @@
 		return mon_ret_buf.get(x, y)
 
 	pd = arr.get_dir(c)
-	ds_ = filter( lambda d: d != kon.bak_dir(pd), ds )
+	ds_ = kon.filter_lst( lambda d: d != kon.bak_dir(pd), ds )
 	ds = ds_ if ds_ else ds
 	
 	(tx, ty) = arr.pos('P')
@@ -356,7 +357,7 @@
 
 	if mode == 'run' and run_mode.get() == 'pato':
 		# MONS = 'RCMY'
-		(w2, h2) = (w/2, h/2)
+		(w2, h2) = ( int(w/2), int(h/2) )
 		area_d = {
 			'R': (w2, 0, w2, h2),
 			'C': (w2, h2, w2, h2),
@@ -429,7 +430,7 @@
 			kon.show( x_, y, s_, col_, r_, flush_f=True )
 	def f(add=0):
 		if add == 0:
-			map( lambda i: draw(True, i), range(e.v) )
+			kon.map_lst( lambda i: draw(True, i), range(e.v) )
 			return ''
 		while add > 0:
 			draw(True, e.v)
@@ -447,13 +448,13 @@
 
 gate = kon.counter(4)
 
-mon_turn = lambda: map( lambda c: arr.set_dir( c, kon.bak_dir( arr.get_dir(c) ) ), MONS )
+mon_turn = lambda: kon.map_lst( lambda c: arr.set_dir( c, kon.bak_dir( arr.get_dir(c) ) ), MONS )
 run_mode = kon.slider( ['pato', 'chase'], f=mon_turn )
 
 def init_once():
 	kon.clr()
 
-	lst = map( lambda r: mk_slst('O ', 'yellow', r), (False, True) )
+	lst = kon.map_lst( lambda r: mk_slst('O ', 'yellow', r), (False, True) )
 	arr.set_sdic( 'O', ( 'slider', kon.slider(lst, 2.0, None, True) ) )
 
 	arr.set_sdic( 'P', ('func', pac_show) )
@@ -466,17 +467,17 @@
 	score()
 	spare()
 
-	map( lambda c: set( stat_get(c), 'hz', 3.0 if c == 'P' else 3.3 ), MOVES )
-	map( lambda c: set( stat_get(c), 'timer', kon.timer_new() ), MONS )
+	kon.map_lst( lambda c: set( stat_get(c), 'hz', 3.0 if c == 'P' else 3.3 ), MOVES )
+	kon.map_lst( lambda c: set( stat_get(c), 'timer', kon.timer_new() ), MONS )
 
 	for c in MOVES:
 		stat = stat_get(c)
 		f = th_pac if c == 'P' else th_mon
 		stat.th = kon.th_loop(f, [c], stat.hz, run=False)
 
-ths_start = lambda: map( lambda c: stat_get(c).th.start(), MOVES )
-ths_stop = lambda: map( lambda c: stat_get(c).th.stop(), MOVES )
-ths_timer_cancel = lambda: map( lambda c: stat_get(c).timer.cancel(), MONS )
+ths_start = lambda: kon.map_lst( lambda c: stat_get(c).th.start(), MOVES )
+ths_stop = lambda: kon.map_lst( lambda c: stat_get(c).th.stop(), MOVES )
+ths_timer_cancel = lambda: kon.map_lst( lambda c: stat_get(c).timer.cancel(), MONS )
 
 def work():
 	init_once()
@@ -521,7 +522,7 @@
 		ths_stop()
 		ths_timer_cancel()
 		kon.sleep(2.0)
-		map( lambda c: arr.rm(c), MOVES )
+		kon.map_lst( lambda c: arr.rm(c), MOVES )
 		bonus.hide()
 		arr.update_all(flush_f=True)
 
@@ -536,7 +537,7 @@
 		v = game_ev.get()
 		if v == 'die':
 			ss = [ '()', '||', ')(', '><', '--', '><', '--', '><', '--', '__', '  ' ]
-			lsts = map( lambda s: mk_slst(s, 'yellow', True), ss )
+			lsts = kon.map_lst( lambda s: mk_slst(s, 'yellow', True), ss )
 			lsts.append( [ SPC ] )
 			bak = pac_slider( kon.slider(lsts, 5.0, None, True, repeat=False) )
 
@@ -548,7 +549,7 @@
 		elif v == 'clear':
 			c = '#'
 			bak = arr.get_sdic(c)
-			lst = map( lambda col: mk_slst('==', col, False), ('white', 'blue') )
+			lst = kon.map_lst( lambda col: mk_slst('==', col, False), ('white', 'blue') )
 			slider = kon.slider(lst, 4.0, None, True)
 			arr.set_sdic( c, ('slider', slider) )
 			kon.sleep(3.0)