datatype list = nill | cons of int * list

fun f ( (X,Xs) : int*list ) : list = raise D1

fun main( (X,Xs) : int*list ) : list = f (X,Xs)

%%

fun to_list [] = nill
  | to_list( X :: Xs ) = cons( X, to_list Xs )

fun from_list nill = []
  | from_list( cons( X, Xs ) ) = X :: from_list Xs

fun to_pair (A,B) = (A,to_list B)

val Input = [
  (1,[]),
  (1,[1]),
  (1,[0]),
  (1,[2,3]),
  (3,[1,2]),
  (4,[1,2,3]),
  (3,[1,2,4])
]


val Inputs = map( to_pair , Input )
val Output = [
  [1],
  [1,1],
  [0,1],
  [1,2,3],
  [1,2,3],
  [1,2,3,4],
  [1,2,3,4]
  ]
val Outputs = map( to_list, Output )

val Validation_inputs = []
val Validation_outputs = []

val All_outputs =  Vector.fromList( Outputs @ Validation_outputs )
 
val Funs_to_use = [ 
  "true", "false",  "nill", "cons"
  ]
 
val Reject_funs = []
fun restore_transform D = D
 
structure Grade : GRADE =
struct
 
type grade = unit
val zero = ()
val op+ = fn(_,_) => ()
val comparisons = [ fn _ => EQUAL ]
val toString = fn _ => ""
val fromString = fn _ => SOME()
 
val pack = fn _ => ""
val unpack = fn _ =>()
 
val post_process = fn _ => ()

val toRealOpt = NONE
 
end
 
val Abstract_types = []
 
fun output_eval_fun( I : int, _ , Y ) =
  if Vector.sub( All_outputs, I ) <> Y then
    { numCorrect = 0, numWrong = 1, grade = () }
  else
    { numCorrect = 1, numWrong = 0, grade = () }
 
 
val Max_output_class_card = 2
val Max_output_genus_card = 0
val Max_time_limit = 131072
val Time_limit_base = 2.0