(
	defun  memb  
	(
		lambda  (a  l) 
		(
			cond  
			(
				(null  l)  
				nil
			)
			(
				(eq  a (car  l))  
				T
			)
			(
				T  
				(memb  a  (cdr l)
			) 
		) 
	)
)


(
	defun  out  
	(
		lambda  (a  l) 
		(
			cond  
			(
				(null  l)  
				nil
			)
			(
				(eq  a (car  l))  
				(out  a  (cdr  l))
			)
			(
				T  
				(
					cons  
					(car  l) 
					(out  a  (cdr l) )
				)
			)
		) 
	)
)


(
	defun  equal  
	(
		lambda (x  y)
		(
			cond  
			(
				(atom  x)  
				(eq  x  y)
			)
			(
				(atom  y)  
				( )
			)
			(
				(equal  (car  x) (car  y)) 
				(equal  (cdr  x) (cdr  y))
			)
            ( 
				T  
				( ) 
			) 
		)
	)
)

(
	defun test1
	(
		lambda (l)
		(
			cond
			(
				(eq (length l) 2)
				(car l)
			)
			(
				T
				( test1 (cdr l) )
			)
		)
	)
)

(
	cons 
	( quote (12) ) 
	( list() ) 
)
->
( 
	cons
	('(12))
	()
)
res: ((12) ())

(
	car 
	( 
		quote 
		( 
			cons 
			(quote A) 
			(quote(B))
		)
	)
)
res: cons

(
	defun deletenumbers
	(
		lambda (l)
		(
			cond
			(
				(null l)
				()
			)
			(
				( is_number (car l) )
				( deletenumbers (cdr l) )
			)
			(
				T
				(
					cons
					(car l)
					( deletenumbers (cdr l) )
				)
			)
		)
	)
)

?????
(
	defun deleteAllNumbers
	(
		lambda (l)
		(
			cond
			(
				(null l)
				()
			)
			(
				( atom (car l) )
				( 
					cond
					(
						( is_number (car l) )
						( deleteAllNumbers (cdr l) )
					)
					(
						T
						(
							cons
							(car l)
							( deleteAllNumbers (cdr l) )
						)
					)
				)
			)
			(
				T
				(
					cons
					( deleteAllNumbers (car l) )
					( deleteAllNumbers (cdr l) )
				)
			)
		)
	)
)

(
	defun DELALLNUM (l)
	(
		prog (i X Y)
		(
			setq X (DELNUM l)
		)	
		(
			setq i 0
		)
		beg 
		(
			cond
			( 
				(< i (length X))
				(
					cond
					( 
						(
							(listp X) 
							( nth (+ i 1) X )
						)
						(
							setq 
							Y 
							(
								append 
								Y 
								(
									(
										DELALLNUM ( nth (+ i 1) X )
									)
								)
							)
						)
					)
					(
						T 
						(
							setq 
							Y 
							(
								append 
								Y 
								(nth (+ i 1) X) 
							)
						)
					) 
				)
				( setq i (+ i 1) )
				(go beg) 
			) 
			(
				T 
				Y
			) 
		) 
	) 
)

List DELALLNUM (List l)
{
	List X = DELNUM(l);
	List Y = NULL;
	int i = 0;
beg:
	if(i < length(X))
	{
		if (is_list(X[i+1]))
		{
			Y.append(DELALLNUM(X[i+1]));
		}
		else
		{
			Y.append(X[i+1]);
		}
		i++;
		goto beg;
	}
	else
	{
		return Y;
	}
}

(
	prog (CONS) 
	(
		setq 
		CONS 
		( quote (quote (A L)) )
	)
	(
		eval 
		(list (quote CONS) CONS CONS)
	)
)
==
((QUOTE (A L)) (A L) (A L))

(
	defun lastnil
	(
		lambda (l)
		(
			cond
			(
				(null l)
				nil
			)
			(
				(eq length(l) 1)
				nil
			)
			(
				T
				(
					cons
					car(l)
					((lastnil cdr(l)))
				)
			)
		)
	)
)