( def lerstr lambda
  ( str )
  ( progn
  ( ppn str )
  ( let
  (
  ( a
  ( fgets )
  )
  )
  ( if
  ( equal a "\n" )
  ( _l
  ( fgets )
  )
  ( _l a )
  )
  )
  )
)

( def _l lambda
  ( y )
  ( let
  (
  ( z
  ( strlen y )
  )
  )
  ( substr y 1
  ( sub z 1 )
  )
  )
)


( def lerint lambda
  ( str )
  ( progn
  ( ppn str )
  ( let
  (
  ( a
  ( read )
  )
  )
  ( if
  ( equal
  ( type a ) 'INT
  ) a
  ( lerint str )
  )
  )
  )
)

( def lersetstr lambda
  ( str )
  ( progn
  ( ppn str )
  ( let
  (
  ( a
  ( lerstr "?- " )
  )
  )
  ( if
  ( equal a "." )
  ( makeset )
  ( union
  ( makeset a )
  ( lersetstr " " )
  )
  )
  )
  )
)
(def FIM '.)

( def lerset lambda
  ( str )
  ( progn
  ( ppn str )
  ( let
  (
  ( a
  ( read )
  )
  )
  ( if
  ( equal a FIM )
  ( makeset )
  ( union
  ( makeset a )
  ( lerset "? " )
  )
  )
  )
  )
)


( def pickone lambda
  ( m1 )
  ( let
  (
  ( m
  ( cond
  (
  ( equal 'SET
  ( type m1 )
  )
  ( seq x
  ( from x m1 )
  )
  )
  (
  ( equal 'LIST
  ( type m1 )
  ) m1
  )
  (
  ( equal 'FF
  ( type m1 )
  )
  ( seq
  ( makeff
  ( x
  ( ap m1 x )
  )
  )
  ( from x
  ( dom m1 )
  )
  )
  )
  )
  )
  ( a1
  ( progn
  ( princ "\n--------------------------------------------------\n\t" )
  ( set
  ( princ x " "
  ( el x m ) "\n\t"
  )
  ( from x
  ( inds m )
  )
  )
  ( def _b
  ( leropcao "\nqual destes ? " )
  )
  ( while
  ( or
  ( gt _b
  ( length m )
  )
  ( lt _b 0 )
  )
  ( def _b
  ( leropcao "qual destes ? " )
  )
  )
  ( princ "\n--------------------------------------------------\n" )
  )
  )
  )
  ( if
  ( equal _b 0 ) NIL
  ( el _b m )
  )
  )
)


( def pickmany lambda
  ( m1 )
  ( let
  (
  ( m
  ( cond
  (
  ( equal 'SET
  ( type m1 )
  )
  ( seq x
  ( from x m1 )
  )
  )
  (
  ( equal 'LIST
  ( type m1 )
  ) m1
  )
  (
  ( equal 'FF
  ( type m1 )
  )
  ( seq
  ( makeff
  ( x
  ( ap m1 x )
  )
  )
  ( from x
  ( dom m1 )
  )
  )
  )
  )
  )
  ( a1
  ( progn
  ( princ "\n--------------------------------------------------\n\t" )
  ( set
  ( princ x " "
  ( el x m ) "\n\t"
  )
  ( from x
  ( inds m )
  )
  )
  )
  )
  )
  ( set
  ( el b m )
  ( from b
  ( lerset "\nquais destes (. para terminar)\n ? " )
  )
  )
  )
)


( def ppickone lambda
  ( m1 s )
  ( let
  (
  ( m
  ( cond
  (
  ( equal 'SET
  ( type m1 )
  )
  ( seq x
  ( from x m1 )
  )
  )
  (
  ( equal 'LIST
  ( type m1 )
  ) m1
  )
  (
  ( equal 'FF
  ( type m1 )
  )
  ( seq
  ( makeff
  ( x
  ( ap m1 x )
  )
  )
  ( from x
  ( dom m1 )
  )
  )
  )
  )
  )
  ( a1
  ( progn
  ( princ "\n--------------------------------------------------\n\t" )
  ( set
  ( princ x " "
  ( el x m ) "\n\t"
  )
  ( from x
  ( inds m )
  )
  )
  ( def _b
  ( leropcao
  ( strcat "\n" s )
  )
  )
  ( while
  ( or
  ( gt _b
  ( length m )
  )
  ( lt _b 0 )
  )
  ( def _b
  ( leropcao
  ( strcat "\n" s )
  )
  )
  )
  ( princ "\n--------------------------------------------------\n" )
  )
  )
  )
  ( if
  ( equal _b 0 ) NIL
  ( el _b m )
  )
  )
)

( def lerany lambda
  ( p )
  ( progn
  ( ppn p )
  ( read )
  )
)


( def lerfixdomff lambda
  ( e )
  ( ff1
  ( list x
  ( lerany x )
  )
  ( from x e )
  )
)

( def leropcao lambda
  ( x )
  ( let
  (
  ( a
  ( lerstr x )
  )
  )
  ( if
  ( equal a "\e\n" ) 0
  ( atoi a )
  )
  )
)

( deftype tmenu TUP
  ( titger STR )
  ( opcoes_list LIST opcoes )
)

( deftype opcoes TUP
  ( titopc STR )
  ( accao_op taccao )
)

( deftype taccao ALT tmenu SYM INT _exp )

( deftype _exp ANY )


( def menu lambda
  ( m )
  ( let
  (
  ( m1
  ( opcoes_list m )
  )
  ( a1
  ( progn
  ( princ "\n--------------------------------------------------" )
  ( princ "\n\t"
  ( titger m ) "\n\n\t"
  )
  ( set
  ( princ x " "
  ( titopc
  ( el x m1 )
  ) "\n\t"
  )
  ( from x
  ( inds m1 )
  )
  )
  ( def _b
  ( leropcao "\nqual a opcao? " )
  )
  ( while
  ( or
  ( gt _b
  ( length m1 )
  )
  ( lt _b 0 )
  )
  ( def _b
  ( leropcao "qual a opcao? " )
  )
  )
  ( princ "\n--------------------------------------------------\n" )
  )
  )
  ( acc
  ( if
  ( nequal 0 _b )
  ( accao_op
  ( el _b m1 )
  ) _b
  )
  )
  )
  ( cond
  (
  ( equal 'SYM
  ( type acc )
  )
  (
  ( eval acc )
  )
  )
  (
  ( is tmenu acc )
  ( menu acc )
  )
  (
  ( equal 'LIST
  ( type acc )
  )
  ( eval acc )
  )
  (
  ( equal 'INT
  ( type acc )
  ) acc
  )
  ( true acc )
  )
  )
)


( def run lambda
  ( m )
  ( while
  ( let
  (
  ( x
  ( menu m )
  )
  )
  ( if
  ( nequal x 0 )
  ( progn
  ( pp x ) true
  ) false
  )
  )
  )
)

( def _EDITOR "vi " )

( def _MORE "more < " )


( def vi lambda
  ( f )
  ( progn
  ( sh
  ( strcat _EDITOR f )
  )
  ( nload f )
  )
)
( def vi. lambda ( ) (vi FILENAME))
( def cat. lambda ( ) (cat FILENAME))
( def test lambda ( )
  ( progn
  ( def _l1 ( lerstr "\".\" to end\n ? " ))
  ( while
  ( nequal _l1 "." )
  ( let
  ( ( f1 (fopen "_tmp1" "w"))
  ( x19 ( fputs _l1 f1)) 
  ( x20 (fclose f1))
  ( x ( sh  "seca _tmp1  _tmp" )))
  (if (equal x 0) 
  (let ( ( f ( fopen "_tmp" "r" ))
  ( x1 ( pp ( m2read f ))))
  ( fclose f ))
  (princ "error, try again ...\n")
  )
  )
  ( def _l1 ( lerstr "? " ))
  )
  )
)


( def nload lambda
  ( f )
  ( progn
  ( sh
  ( strcat "seca " f " _tmp" )
  )
  ( load "_tmp" )
  )
)

( def sig lambda
  ( )
  ( pp _ops )
)

( def types lambda
  ( )
  ( set x
  ( from x oblist
  ( equal
  ( type
  ( eval x )
  ) 'TYPE
  )
  )
  )
)

( def cat lambda
  ( f )
  ( sh
  ( strcat _MORE f )
  )
)


( def help lambda
  ( simb )
  ( if
  ( is SYM simb )
  ( sh
  ( strcat _EDITOR "-R \"+/N :  "
  ( symstr simb ) "/\"  " HelpDir "nyag.hlp"
  )
  ) " use: (help 'func) "
  )
)


( def edit lambda
  ( s )
  ( if
  ( is SYM s )
  ( let
  (
  ( f
  ( fopen "_tmp1" "w" )
  )
  ( l1
  ( fputs
  ( strcat
  ( symstr s ) " <- "
  ) f
  )
  )
  ( l2
  ( nwrite f
  ( eval s )
  )
  )
  ( l3
  ( fputs " ;\n" f )
  )
  ( l4
  ( fclose f )
  )
  )
  ( vi "_tmp1" )
  ) " use: (edit 'object) "
  )
)

( def stsave lambda
  ( filename State )
  ( let
  (
  ( f
  ( fopen filename "w" )
  )
  ( l1
  ( m2write f State )
  )
  )
  ( fclose f )
  )
)

( def stload lambda
  ( filename )
  ( let
  (
  ( f
  ( fopen filename "r" )
  )
  ( l1
  ( m2read f )
  )
  ( l2
  ( fclose f )
  )
  ) l1
  )
)

( def HelpDir
  ( strcat "/root/NEW/CAMILA-3" "/" )
)