Github Experimental restricted subset of Python for safe evaluation by @readevalprint
19.839955000009013 ms
[None, None, 1]

Previous Evaluation

def map_dict(func, o):
    if isinstance(o, dict):
        for k,v in o.items():
            func(k,v)
            map_dict(func, v)
    elif isinstance(o, list) or isinstance(o, tuple):
        for i, v in enumerate(o):
            func(i,v)
            map_dict(func, v)
out = []
def f(k, v):
    if isinstance(v, str):
        out.append((k,v))
map_dict(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out

[None, None, None, None, [('c', 'C')]]
Link time elapsed: 52.471 ms
def map_dict(func, o):
	if isinstance(o, dict):
		for k,v in o.items():
			func(k,v)
			map_dict(func, v)
	elif isinstance(o, list) or isinstance(o, tuple):
		for i, v in enumerate(o):
			func(i,v)
			map_dict(func, v)
out = []
def f(k, v):
	if isinstance(v, str):
		out = out + [(k,v)]
map_dict(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
[None, None, None, None, []]
Link time elapsed: 16.934 ms
def map_dict(func, o):
	if isinstance(o, dict):
		for k,v in o.items():
			func(k,v)
			map_dict(func, v)
	elif isinstance(o, list) or isinstance(o, tuple):
		for i, v in enumerate(o):
			func(i,v)
			map_dict(func, v)
out = []
def f(k, v):
	if isinstance(o, str):
		out = out + [(k,v)]
map_dict(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
NameNotDefined("'o' is not defined")
Link time elapsed: 3.158 ms
def map_dict(func, o):
	if isinstance(o, dict):
		for k,v in o.items():
			func(k,v)
			map_dict(func, v)
	elif isinstance(o, list) or isinstance(o, tuple):
		for i, v in enumerate(o):
			func(i,v)
			map_dict(func, v)
out = []
def f(k, v):
	out = out + [(k,v)]
map_dict(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
[None, None, None, None, []]
Link time elapsed: 20.666 ms
def map_dict(func, o):
	if isinstance(o, dict):
		for k,v in o.items():
			func(k,v)
			map_dict(func, v)
	elif isinstance(value, list) or isinstance(value, tuple):
		for i, v in enumerate(value):
			func(i,v)
			map_dict(func, v)
out = []
def f(k, v):
	out = out + [(k,v)]
map_dict(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
NameNotDefined("'value' is not defined")
Link time elapsed: 5.440 ms
def map_dict(func, o):
	if isinstance(o, dict):
		for k,v in o.items():
			func(k,v)
			map_dict(func, v)
	elif isinstance(value, list) or isinstance(value, tuple):
		for i, v in enumerate(value):
			func(i,v)
			map_dict(func, v)
out = []
def f(k, v):
	out = out + [(k,v)]
dict_generator(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
NameNotDefined("'dict_generator' is not defined")
Link time elapsed: 1.907 ms
def map_dict(func, o):
    if isinstance(o, dict):
        for k,v in o.items():
            func(k,v)
			map_dict(func, v)
	elif isinstance(value, list) or isinstance(value, tuple):
        for i, v in enumerate(value):
            func(i,v)
			map_dict(func, v)

out = []
def f(k, v):
	out = out + [(k,v)]
dict_generator(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 5, 21, '\t\t\tmap_dict(func, v)\n'))
Link time elapsed: 0.286 ms
def map_dict(func, o):
    if isinstance(o, dict):
        for k,v in o.items():
            func(k,v)
        	map_dict(func, v)
    elif isinstance(value, list) or isinstance(value, tuple):
        for i, v in enumerate(value):
            func(i,v)
        	map_dict(func, v)

out = []
def f(k, v):
	out = out + [(k,v)]
dict_generator(f, {"a": [1,{"b": [4,5,{"c": "C"}]},3]})
out
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 5, 27, '        \tmap_dict(func, v)\n'))
Link time elapsed: 0.153 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(value, dict):
        for d in dict_generator(value, [key] + pre):
            out = out + d
    elif isinstance(value, list) or isinstance(value, tuple):
        for i, v in enumerate(value):
            for d in dict_generator(v, pre + [key, i]):
                out = out + [d]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,{"c": "C"}]},3]})
NameNotDefined("'value' is not defined")
Link time elapsed: 83.611 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for i, v in enumerate(value):
                    for d in dict_generator(v, pre + [key, i]):
                        out = out + [d]
            else:
                pre = pre + [key, value]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,{"c": "C"}]},3]})
[None,
 [(['a', 0], 1), (['a', 1, 'b', 0], 4), (['a', 1, 'b', 1], 5), (['a', 2], 3)]]
Link time elapsed: 66.885 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for i, v in enumerate(value):
                    for d in dict_generator(v, pre + [key, i]):
                        out = out + [d]
            else:
                pre = pre + [key, value]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,6]},3]})
[None,
 [(['a', 0], 1),
  (['a', 1, 'b', 0], 4),
  (['a', 1, 'b', 1], 5),
  (['a', 1, 'b', 2], 6),
  (['a', 2], 3)]]
Link time elapsed: 25.227 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for i, v in enumerate(value):
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre = pre + [key, value]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"b": [4,5,6]},3]})
[None,
 [(['a'], 1), (['b', 'a'], 4), (['b', 'a'], 5), (['b', 'a'], 6), (['a'], 3)]]
Link time elapsed: 27.568 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre = pre + [key, value]
    else:
        out = out + [(pre, indict)]
    return out
    
dict_generator({"a": [1,{"a": [4,5,6]},3]})
[None,
 [(['a'], 1), (['a', 'a'], 4), (['a', 'a'], 5), (['a', 'a'], 6), (['a'], 3)]]
Link time elapsed: 31.111 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre = pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({"a": [1,{"a": [4,5,6]},3]})
[None, [1, 4, 5, 6, 3]]
Link time elapsed: 174.843 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + [(pre, d)]
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [(pre, d)]
            else:
                pre + [key, value]
    else:
        out = out + [(pre, indict)]
    return (out)
    
dict_generator({"a": [1,{"a": [4,5,6]},3]})
[None,
 [([], (['a'], 1)),
  ([], (['a'], (['a', 'a'], 4))),
  ([], (['a'], (['a', 'a'], 5))),
  ([], (['a'], (['a', 'a'], 6))),
  ([], (['a'], 3))]]
Link time elapsed: 44.187 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return (pre, out)
    
dict_generator({"a": [1,{"a": [4,5,6]},3]})
[None,
 ([],
  [['a'],
   [1],
   ['a'],
   [['a', 'a'], [4], ['a', 'a'], [5], ['a', 'a'], [6]],
   ['a'],
   [3]])]
Link time elapsed: 96.892 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({"a": [1,{"a": [4,5,6]},3]})
[None, [1, 4, 5, 6, 3]]
Link time elapsed: 12.575 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({"a": [1,{"a": [4,5,6],3]})
SyntaxError('invalid syntax', ('<unknown>', 19, 40, 'dict_generator({"a": [1,{"a": [4,5,6],3]})\n'))
Link time elapsed: 65.946 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + [d]
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({"a": [1,2,3]})
[None, [1, 2, 3]]
Link time elapsed: 16.166 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + d
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({"a": [1,2,3]})
SnekTypeError('can only concatenate list (not "int") to list')
Link time elapsed: 4.214 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + d
            else:
                pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({})
[None, []]
Link time elapsed: 30.114 ms
def dict_generator(indict, pre=None):
    out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + d
            else:
                yield pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({})
FeatureNotAvailable('Sorry, Yield is not available in this evaluator')
Link time elapsed: 0.762 ms
def dict_generator(indict, pre=None):
	out = []
	pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + d
            else:
                yield pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({})
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 4, 33, '    if isinstance(indict, dict):\n'))
Link time elapsed: 0.196 ms
def dict_generator(indict, pre=None):
	out = []
    pre = pre[:] if pre else []
    if isinstance(indict, dict):
        for key, value in indict.items():
            if isinstance(value, dict):
                for d in dict_generator(value, [key] + pre):
                    out = out + d
            elif isinstance(value, list) or isinstance(value, tuple):
                for v in value:
                    for d in dict_generator(v, [key] + pre):
                        out = out + d
            else:
                yield pre + [key, value]
    else:
        out = out + [indict]
    return out
    
dict_generator({})
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 3, 32, '    pre = pre[:] if pre else []\n'))
Link time elapsed: 0.218 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
		memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
		iterator = enumerate
	if iterator:
		for kv in iterator(obj):
			path_component = kv[0]
			value = kv[1]
			for result in objwalk(value, path + (path_component,), memo):
				out = out + [result]
	else:	
		out = out + [path, obj]
	return out
	    
objwalk([{"a":1}])
SnekLookupError('string index out of range')
Link time elapsed: 56.223 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
		memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
		iterator = enumerate
	if iterator:
		for kv in iterator(obj):
			path_component = kv[0]
			value = kv[1]
			for result in objwalk(value, path + (path_component,), memo):
				out = out + [result]
	else:	
		out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
SnekLookupError('string index out of range')
Link time elapsed: 5.317 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    for kv in iterator(obj):
	    	path_component = kv[0]
	    	value = kv[1]
	        for result in objwalk(value, path + (path_component,), memo):
	        	out = out + [result]
	        
	else:	
	    out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 16, 71, '\t        for result in objwalk(value, path + (path_component,), memo):\n'))
Link time elapsed: 0.241 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    for kv in iterator(obj):
	    	path_component = kv[0]
	    	value = kv[1]
	        for result in objwalk(value, path + (path_component,), memo):
            	out = out + [result]
	        
	else:	
	    out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 16, 71, '\t        for result in objwalk(value, path + (path_component,), memo):\n'))
Link time elapsed: 0.946 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    for kv in iterator(obj):
	    	path_component = kv[0]
	    	value = kv[1]
	        for result in objwalk(value, path + (path_component,), memo):
            out = out + 	[result]
	        
	else:	
	    out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 16, 71, '\t        for result in objwalk(value, path + (path_component,), memo):\n'))
Link time elapsed: 0.291 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
        for kv in iterator(obj):
        	path_component = kv[0]
        	value = kv[1]
            for result in objwalk(value, path + (path_component,), memo):
                out = out +  [result]
	        
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 13, 33, '        for kv in iterator(obj):\n'))
Link time elapsed: 0.225 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    
	        
	        for kv in iterator(obj):
	        	path_component = kv[0]
	        	value = kv[1]
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 18, 75, '\t            for result in objwalk(value, path + (path_component,), memo):\n'))
Link time elapsed: 0.316 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    
	        
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([{"a":1}, "asdf"])
NameNotDefined("'value' is not defined")
Link time elapsed: 4.539 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iter
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    
	        
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([{}])
[None, []]
Link time elapsed: 4.983 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iteritems
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    
	        
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([{}])
NameNotDefined("'iteritems' is not defined")
Link time elapsed: 63.474 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iteritems
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    
	        
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([])
[None, []]
Link time elapsed: 3.690 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iteritems
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    if obj not in memo:
	        memo.add(obj)
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        memo.remove(obj)
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([])
TypeError("unhashable type: 'list'")
Link time elapsed: 8.151 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iteritems
	elif isinstance(obj, list):
	    iterator = enumerate
	if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        memo.remove(id(obj))
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([])
NameNotDefined("'id' is not defined")
Link time elapsed: 100.146 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, dict):
		iterator = iteritems
	elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
	    iterator = enumerate
	if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        memo.remove(id(obj))
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([])
NameNotDefined("'Sequence' is not defined")
Link time elapsed: 2.504 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, Mapping):
		iterator = iteritems
	elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
	    iterator = enumerate
	if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
	        memo.remove(id(obj))
	else:
	    out = out + [path, obj]
	return out
	    
objwalk([])
NameNotDefined("'Mapping' is not defined")
Link time elapsed: 39.770 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
	if isinstance(obj, Mapping):
		iterator = iteritems
    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
	    iterator = enumerate
    if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
            memo.remove(id(obj))
    else:
        out = out + [path, obj]
    return out
        
objwalk([])
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 10, 81, '    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):\n'))
Link time elapsed: 0.393 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
	
	iterator = None
    if isinstance(obj, Mapping):
		iterator = iteritems
    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
	    iterator = enumerate
    if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
            memo.remove(id(obj))
    else:
        out = out + [path, obj]
    return out
        
objwalk([])
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 8, 33, '    if isinstance(obj, Mapping):\n'))
Link time elapsed: 0.328 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
    iterator = None
    if isinstance(obj, Mapping):
		iterator = iteritems
    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
	    iterator = enumerate
    if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
            memo.remove(id(obj))
    else:
        out = out + [path, obj]
    return out
        
objwalk([])
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 6, 20, '    iterator = None\n'))
Link time elapsed: 0.135 ms
def objwalk(obj, path=(), memo=None):
	out = []
	if memo is None:
	    memo = set()
    iterator = None
    if isinstance(obj, Mapping):
	    iterator = iteritems
    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
	    iterator = enumerate
    if iterator:
	    if id(obj) not in memo:
	        memo.add(id(obj))
	        for path_component, value in iterator(obj):
	            for result in objwalk(value, path + (path_component,), memo):
	                out = out +  [result]
            memo.remove(id(obj))
    else:
        out = out + [path, obj]
    return out
        
objwalk([])
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 6, 20, '    iterator = None\n'))
Link time elapsed: 0.197 ms
def objwalk(obj, path=(), memo=None):
	out = []
    if memo is None:
        memo = set()
    iterator = None
    if isinstance(obj, Mapping):
        iterator = iteritems
    elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
        iterator = enumerate
    if iterator:
        if id(obj) not in memo:
            memo.add(id(obj))
            for path_component, value in iterator(obj):
                for result in objwalk(value, path + (path_component,), memo):
                    out = out +  [result]
            memo.remove(id(obj))
    else:
        out = out + [path, obj]
    return out
        
objwalk([])
IndentationError('unindent does not match any outer indentation level', ('<unknown>', 4, 21, '    if memo is None:\n'))
Link time elapsed: 0.122 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
	return _x
		
a(4, x(1), x(-1), x(-1), x(1), x(0))
 
[None, None, 1]
Link time elapsed: 19.840 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
	return _x
		
a(5, x(1), x(-1), x(-1), x(1), x(0))
 
[None, None, 0]
Link time elapsed: 119.916 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
	return _x
		
a(6, x(1), x(-1), x(-1), x(1), x(0))
 
CallTooDeep('Sorry, stack is to large. The MAX_CALL_DEPTH is 32.')
Link time elapsed: 103.020 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
	return _x
		
a(2, x(1), x(-1), x(-1), x(1), x(0))
 
[None, None, -2]
Link time elapsed: 12.621 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
	return _x
		
a(1, x(1), x(-1), x(-1), x(1), x(0))
 
[None, None, 0]
Link time elapsed: 7.789 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
		
a(1, x(1), x(-1), x(-1), x(1), x(0))
 
SnekRuntimeError('Sorry, NoneType type is not callable')
Link time elapsed: 25.715 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
		
a(10, x(1), x(-1), x(-1), x(1), x(0))
 
CallTooDeep('Sorry, stack is to large. The MAX_CALL_DEPTH is 32.')
Link time elapsed: 112.196 ms
def a(in_k, x1, x2, x3, x4, x5):
    k = [in_k]
    def b():
        k[0] = k[0] - 1
        return a(k[0], b, x1, x2, x3, x4)
    return x4() + x5() if k[0] <= 0 else b()
 
def x(i):
	def _x():
		return i
		
print(a(10, x(1), x(-1), x(-1), x(1), x(0))) 
 
NameNotDefined("'print' is not defined")
Link time elapsed: 69.672 ms
def a(k, x1, x2, x3, x4, x5):
    def b():
        b.k = b.k - 1
        return a(b.k, b, x1, x2, x3, x4)
    b.k = k
    return x4() + x5() if b.k <= 0 else b()
 
def x(i):
	def _x():
		return i
		
a(1, x(1), x(-1), x(-1), x(1), x(0))
 
FeatureNotAvailable('Sorry, cannot assign to Attribute')
Link time elapsed: 6.257 ms
def a(k, x1, x2, x3, x4, x5):
    def b():
        b.k = b.k - 1
        return a(b.k, b, x1, x2, x3, x4)
    b.k = k
    return x4() + x5() if b.k <= 0 else b()
 
def x(i):
	def _x():
		return i
		
print(a(1, x(1), x(-1), x(-1), x(1), x(0))) 
 
NameNotDefined("'print' is not defined")
Link time elapsed: 2.752 ms
def a(k, x1, x2, x3, x4, x5):
    def b():
        b.k -= 1
        return a(b.k, b, x1, x2, x3, x4)
    b.k = k
    return x4() + x5() if b.k <= 0 else b()
 
def x(i):
	def _x():
		return i
		
print(a(10, x(1), x(-1), x(-1), x(1), x(0))) 
 
FeatureNotAvailable('Sorry, AugAssign is not available in this evaluator')
Link time elapsed: 1.184 ms
d = {"a": "A", "b": 2}
for k in d.keys():
	d[k] = [d[k]]
	
d
[None, None, {'a': ['A'], 'b': [2]}]
Link time elapsed: 1.545 ms
d = {"a": "A", "b": 2}
for k in d.keys():
	k[d] = [k[d]]
	
d
SnekTypeError('string indices must be integers')
Link time elapsed: 0.857 ms
d = {"a": "A", "b": 2}
for k in d:
	k[d] = [k[d]]
	
d
SnekTypeError('string indices must be integers')
Link time elapsed: 0.951 ms
{"a": "A", "b": 2}
[{'a': 'A', 'b': 2}]
Link time elapsed: 0.524 ms
a = ["hi", "world"]
" ".join(a)
[None, 'hi world']
Link time elapsed: 1.556 ms
def f():
    try:
        pass
    finally:
        return 1

def g():
    try:
        pass
    finally:
        try:
            return 2
        finally:
            pass

def h():
    try:
        pass
    finally:
        try:
            pass
        finally:
            for x in range(10):
                return 3

f()
g()
h()
FeatureNotAvailable('Sorry, Pass is not available in this evaluator')
Link time elapsed: 0.318 ms
b = []
i = 100
while i > 0:
	b = [b, [b]]
	i = i - 1
b
ScopeTooLarge('Scope has used too much memory: 25116 > 20000.0')
Link time elapsed: 107.407 ms
b = []
i = 10
while i > 0:
	b = [b, [b]]
	i = i - 1
b
[None,
 None,
 None,
 [[[[[[[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
        [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]]]],
       [[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
         [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]]]]]],
      [[[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
         [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]]]],
        [[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
          [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]]]]]]]],
     [[[[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
         [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]]]],
        [[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
          [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]]]]]],
       [[[[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]], [[[], [[]]]]]]],
          [[[[[], [[]]], [[[], [[]]]]], [[[[], [[]]]…
Link time elapsed: 324.471 ms
def f(n=1000):
	if n > 0:
		return f(n-1)
	else:	
		0

f()
CallTooDeep('Sorry, stack is to large. The MAX_CALL_DEPTH is 32.')
Link time elapsed: 15.151 ms
a = ["hi", "world"]
" ".join(a)

def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test()
TypeError("_func() missing a required argument: 'flag_input'")
Link time elapsed: 63.325 ms
a = ["hi", "world"]
" ".join(a)

def another():
	#print(10)
	return 10
	
def test( flag_input ):
	another()
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test('23424')
[None, 'hi world', None, None, 1]
Link time elapsed: 2.338 ms
a = ["hi", "world"]
" ".join(a)

def another():
	print(10)
	return 10
	
def test( flag_input ):
	another()
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test('23424')
NameNotDefined("'print' is not defined")
Link time elapsed: 30.626 ms
a = ["hi", "world"]
" ".join(a)

def another():
	return 10
	
def test( flag_input ):
	another()
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test('23424')
[None, 'hi world', None, None, 1]
Link time elapsed: 3.096 ms
a = ["hi", "world"]
" ".join(a)

def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test('23424')
[None, 'hi world', None, 1]
Link time elapsed: 1.971 ms
10000000000**100000000000000000
SnekArithmeticError("Sorry! I don't want to evaluate 10000000000 ** 100000000000000000")
Link time elapsed: 0.558 ms
f"{1:200f}"
SnekRuntimeError('Sorry, this format width is too long.')
Link time elapsed: 1.105 ms
f"{1:.100f}"
['1.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000']
Link time elapsed: 1.835 ms
 f"{1:.100f}"
IndentationError('unexpected indent', ('<unknown>', 1, 1, ' f"{1:.100f}"\n'))
Link time elapsed: 0.106 ms
import os
SnekImportError("'os' at line: 1, column:0")
Link time elapsed: 0.813 ms
import sys
SnekImportError("'sys' at line: 1, column:0")
Link time elapsed: 0.287 ms
def f(n=1000):
	pass

f.__code__
FeatureNotAvailable('Sorry, access to this attribute is not available. (__code__) at line: 4, column:0')
Link time elapsed: 0.751 ms
def f(n=1000):
	pass

dir(f)
NameNotDefined("'dir' is not defined at line: 4, column:0")
Link time elapsed: 0.807 ms
def f(n=1000):
	pass

vars(f)
NameNotDefined("'vars' is not defined at line: 4, column:0")
Link time elapsed: 1.761 ms
def f(n=1000):
	pass

print(vars(f))
NameNotDefined("'print' is not defined at line: 4, column:0")
Link time elapsed: 0.832 ms
def f(n=1000):

print(vars(f))
IndentationError('expected an indented block', ('<unknown>', 3, 5, 'print(vars(f))\n'))
Link time elapsed: 0.221 ms
def f(n=1000)
	if n > 0:
		return f(n-1)
	else:	
		0

f()
SyntaxError('invalid syntax', ('<unknown>', 1, 14, 'def f(n=1000)\n'))
Link time elapsed: 0.153 ms
def f():
	return f()
[None]
Link time elapsed: 1.574 ms
def f():
	f()
[None]
Link time elapsed: 1.125 ms
num=0
out = []
while num < 20:
    if num % 3 == 0:
         out.append("Fizz")
    if num % 5 == 0:
        out.append("Buzz")
    if num % 5 != 0 and num % 3 != 0:
        out.append(str(num))
    num = num + 1
out
[None,
 None,
 None,
 ['Fizz',
  'Buzz',
  '1',
  '2',
  'Fizz',
  '4',
  'Buzz',
  'Fizz',
  '7',
  '8',
  'Fizz',
  'Buzz',
  '11',
  'Fizz',
  '13',
  '14',
  'Fizz',
  'Buzz',
  '16',
  '17',
  'Fizz',
  '19']]
Link time elapsed: 29.204 ms
def f():
    try:
        pass
    finally:
        return

def g():
    try:
        pass
    finally:
        try:
            return
        finally:
            pass

def h():
    try:
        pass
    finally:
        try:
            pass
        finally:
            for x in range(10):
                return

f()
g()
h()
FeatureNotAvailable('Sorry, Pass is not available in this evaluator at line: 14, column:12')
Link time elapsed: 14.306 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test.func_name
SnekAttributeError("'function' object has no attribute 'func_name' at line: 8, column:0")
Link time elapsed: 0.956 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test.func_dict
SnekAttributeError("'function' object has no attribute 'func_dict' at line: 8, column:0")
Link time elapsed: 0.735 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test.func_code
SnekAttributeError("'function' object has no attribute 'func_code' at line: 8, column:0")
Link time elapsed: 0.883 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

test()
TypeError("_func() missing a required argument: 'flag_input'")
Link time elapsed: 1.007 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

dir(test)
NameNotDefined("'dir' is not defined at line: 8, column:0")
Link time elapsed: 1.978 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
		"Failure !"
	return 1

print dir(test)
SyntaxError('invalid syntax', ('<unknown>', 8, 9, 'print dir(test)\n'))
Link time elapsed: 0.152 ms
def test( flag_input ):
	if flag_input == 12345:
		"Success!"
	else:
        "Failure !"
   return 1

print dir(test)
TabError('inconsistent use of tabs and spaces in indentation', ('<unknown>', 5, 20, '        "Failure !"\n'))
Link time elapsed: 0.196 ms
def test( flag_input ):
   if flag_input == 12345:
        print "Success!"
   else:
        print "Failure !"
   return 1

print dir(test)
SyntaxError('invalid syntax', ('<unknown>', 3, 24, '        print "Success!"\n'))
Link time elapsed: 0.129 ms
x
NameNotDefined("'x' is not defined at line: 1, column:0")
Link time elapsed: 0.501 ms
10**10**10
SnekArithmeticError("Sorry! I don't want to evaluate 10 ** 10000000000 at line: 1, column:0")
Link time elapsed: 1.475 ms
10**1000
[10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000…
Link time elapsed: 0.409 ms
10**100
[10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
Link time elapsed: 0.341 ms
0xa
[10]
Link time elapsed: 0.250 ms
print('abcd')
NameNotDefined("'print' is not defined at line: 1, column:0")
Link time elapsed: 0.211 ms
print(0xa)
NameNotDefined("'print' is not defined at line: 1, column:0")
Link time elapsed: 0.213 ms