Skip to content

[enhance-bug] AI quality issues in a3d505286463... #33

Open
Open
[enhance-bug] AI quality issues in a3d505286463...#33
Labels
auto-reportedenhance-bug
@will-break-it

Description

@will-break-it
will-break-it
opened on Mar 1, 2026

AI Enhancement Issue

The AI rewrite (Claude) produced output with quality issues.
This may be a prompt problem, missing context, or model hallucination.

Script: a3d5052864638828bc3fbc0d5b9a4223e233620d7911a5376ed4b658
Retry: Force re-enhancement
Confidence: medium

Constants

  • AI output: 3/3 found
  • Static output: 3/3 found

Undefined Functions (1 — AI referenced but never defined)

  • predicate()

Scores (AI → Static)

  • Constants: 100.0% → 100.0%
  • References: 85.7% → 100.0%
  • Placeholders: 100.0% → 100.0%
  • Abstraction: 79.2% → 84.6%

AI-Enhanced Aiken

use aiken/builtin

const policy_id_0 = #"222d66110efec4c43152a7c5833ec4c1cef412cd9ba45662230d195512bbab1a"
const script_hash_0 = #"49b5b45b3b600416fee318dc34d9660ebb3a759fbd2db683fef641ff"

type Action {
  Cancel
}

fn find_in_list(predicate: fn(Data) -> Bool, items: List<Data>) -> Bool {
  when items is {
    [] -> False
    [head, ..tail] -> 
      if predicate(head) {
        True
      } else {
        find_in_list(predicate, tail)
      }
  }
}

fn find_output_by_token(predicate: fn(Data) -> Bool, token_key: Data, outputs: List<Data>) -> Data {
  when outputs is {
    [] -> fail
    [output, ..rest] -> {
      let output_data = builtin.un_constr_data(output)
      let output_fields = builtin.snd_pair(output_data)
      let value_field = builtin.head_list(builtin.tail_list(output_fields))
      let token_map = builtin.un_map_data(value_field)
      
      if find_in_list(
        fn(token_entry) { 
          builtin.fst_pair(token_entry) == token_key 
        }, 
        token_map
      ) {
        output
      } else {
        find_output_by_token(predicate, token_key, rest)
      }
    }
  }
}

fn check_mint_token(and_fn: fn(Bool, Bool) -> Bool, predicate: fn(Data) -> Bool, token_key: Data, outputs: List<Data>, mint_map: List<Data>) -> Bool {
  when mint_map is {
    [] -> False
    [mint_entry, ..rest] -> {
      let mint_pair = builtin.fst_pair(mint_entry)
      let expected_constr = builtin.constr_data(1, [
        builtin.head_list(builtin.snd_pair(builtin.un_constr_data({
          let found_output = find_output_by_token(predicate, token_key, builtin.un_list_data(builtin.head_list(outputs)))
          let output_data = builtin.un_constr_data(found_output)
          let output_fields = builtin.snd_pair(output_data)
          let address_field = builtin.head_list(builtin.tail_list(builtin.tail_list(output_fields)))
          let address_data = builtin.un_constr_data(address_field)
          let address_tag = builtin.fst_pair(address_data)
          let address_fields = builtin.snd_pair(address_data)
          
          if 2 == address_tag {
            builtin.head_list(address_fields)
          } else {
            fail
          }
        })))
      ])
      
      if mint_pair == expected_constr {
        True
      } else {
        check_mint_token(and_fn, predicate, token_key, outputs, rest)
      }
    }
  }
}

fn find_token_in_value(token_key: Data, value_map: List<Data>) -> List<Data> {
  when value_map is {
    [] -> fail
    [value_entry, ..rest] -> {
      let entry_key = builtin.fst_pair(value_entry)
      if entry_key == token_key {
        builtin.un_map_data(builtin.snd_pair(value_entry))
      } else {
        find_token_in_value(token_key, rest)
      }
    }
  }
}

fn validate_specific_utxo(and_fn: fn(Bool, Bool) -> Bool, empty_token: Data, token_key: Data, amount_one: Data, predicate: fn(Data) -> Bool, datum: Option<Data>, script_context: List<Data>, utxos: List<Data>) -> Data {
  when utxos is {
    [] -> fail
    [utxo, ..rest] -> {
      let utxo_data = builtin.un_constr_data(utxo)
      let utxo_fields = builtin.snd_pair(utxo_data)
      let value_field = builtin.head_list(utxo_fields)
      let value_map = builtin.un_map_data(value_field)
      
      let has_correct_structure = when value_map is {
        [] -> False
        [_, second_entry, ..remaining] -> {
          when remaining is {
            [] -> False
            [third_entry, ..final_remaining] -> {
              let third_tokens = builtin.un_map_data(builtin.snd_pair(third_entry))
              when third_tokens is {
                [] -> False
                [token_entry, ..token_rest] ->
                  and_fn(
                    and_fn(
                      and_fn(
                        builtin.fst_pair(token_entry) == empty_token,
                        when token_rest is { [] -> True; _ -> False }
                      ),
                      builtin.fst_pair(third_entry) == token_key
                    ),
                    and_fn(
                      builtin.snd_pair(token_entry) == amount_one,
                      when final_remaining is { [] -> True; _ -> False }
                    )
                  )
              }
            }
          }
        }
      }
      
      if has_correct_structure {
        let datum_field = builtin.head_list(builtin.tail_list(utxo_fields))
        let script_hash_field = builtin.head_list(builtin.tail_list(builtin.tail_list(utxo_fields)))
        let expected_script_data = builtin.list_data([
          empty_token,
          builtin.b_data(#"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
          builtin.constr_data(1, [])
        ])
        
        if script_hash_field == expected_script_data {
          let cancel_action = builtin.constr_data(1, [])
          let datum_data = builtin.un_constr_data(builtin.head_list(builtin.tail_list(builtin.tail_list(utxo_fields))))
          let datum_tag = builtin.fst_pair(datum_data)
          let datum_fields = builtin.snd_pair(datum_data)
          
          let datum_matches = if datum_tag == 0 {
            let cancel_data = builtin.un_constr_data(cancel_action)
            let cancel_tag = builtin.fst_pair(cancel_data)
            let cancel_fields = builtin.snd_pair(cancel_data)
            
            if cancel_tag == 0 {
              builtin.head_list(datum_fields) == builtin.head_list(cancel_fields)
            } else {
              False
            }
          } else {
            let cancel_data = builtin.un_constr_data(cancel_action)
            let cancel_tag = builtin.fst_pair(cancel_data)
            
            if cancel_tag == 0 {
              False
            } else {
              True
            }
          }
          
          if datum_matches {
            let outputs = builtin.un_list_data(builtin.head_list(script_context))
            
            if find_in_list(
              fn(output) {
                let output_address = builtin.head_list(builtin.snd_pair(builtin.un_constr_data(output)))
                let datum_address_fields = builtin.snd_pair(builtin.un_constr_data(datum))
                let output_address_fields = builtin.snd_pair(builtin.un_constr_data(output_address))
                
                if builtin.head_list(datum_address_fields) == builtin.head_list(output_address_fields) {
                  builtin.head_list(builtin.tail_list(datum_address_fields)) == builtin.head_list(builtin.tail_list(output_address_fields))
                } else {
                  False
                }
              },
              outputs
            ) {
              Void
            } else {
              fail
            }
          } else {
            fail
          }
        } else {
          fail
        }
      } else {
        validate_specific_utxo(and_fn, empty_token, token_key, amount_one, predicate, datum, script_context, rest)
      }
    }
  }
}

validator script {
  spend(datum: Option<Data>, action: Action, script_context: Data, tx: Data) {
    let and_fn = fn(a, b) { if a { b } else { False } }
    let find_fn = fn(predicate) { fn(items) { find_in_list(predicate, items) } }
    
    let tx_data = builtin.un_constr_data(tx)
    let tx_fields = builtin.snd_pair(tx_data)
    let inputs_field = builtin.tail_list(tx_fields)
    let script_context_data = builtin.un_constr_data(builtin.head_list(tx_fields))
    let script_context_fields = builtin.snd_pair(script_context_data)
    let outputs = builtin.tail_list(script_context_fields)
    let signatories = builtin.tail_list(outputs)
    let mint_field = builtin.tail_list(builtin.tail_list(signatories))
    
    let _ = if check_mint_token(
      and_fn,
      find_fn,
      action,
      outputs,
      builtin.un_map_data(builtin.head_list(builtin.tail_list(builtin.tail_list(mint_field))))
    ) {
      Void
    } else {
      fail
    }
    
    let purpose_data = builtin.un_constr_data(builtin.head_list(builtin.tail_list(inpu
... (truncated, 9752 chars total)
Raw Decompiled Aiken 
use aiken/builtin
use aiken/collection/list

// Script parameters (hardcoded constants)
const policy_id_0 = #"222d66110efec4c43152a7c5833ec4c1cef412cd9ba45662230d195512bbab1a"
// param_1: builtin.constr_data(0, [#"222d66110efec4c43152a7c5833ec4c1cef412cd9ba45662230d195512bbab1a", 2])
const script_hash_0 = #"49b5b45b3b600416fee318dc34d9660ebb3a759fbd2db683fef641ff"

type Action {
 Cancel
}

fn rec_0(x2: Data, z2: Data) -> Data {
 if builtin.null_list(z2) { False } else { if {
 expect _ifThenElse_arg0: Bool = x2(builtin.head_list({
 expect _headList_arg0: List<Data> = z2
 _headList_arg0
}))
 _ifThenElse_arg0
} { True } else { rec_0(x2, builtin.tail_list({
 expect _tailList_arg0: List<Data> = z2
 _tailList_arg0
})) } }
}

fn rec_2(h: Data, m: Data, r2: Data) -> Data {
 if builtin.null_list(r2) { fail } else { {
let s2 = builtin.head_list({
 expect _headList_arg0: List<Data> = r2
 _headList_arg0
})
if {
let t2 = builtin.un_map_data(builtin.head_list(builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(builtin.head_list(builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(s2)))))))))
h(fn(u2) { builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = u2
 _fstPair_arg0
}) == m }, t2)
} { s2 } else { rec_2(h, m, builtin.tail_list({
 expect _tailList_arg0: List<Data> = r2
 _tailList_arg0
})) }
} }
}

fn rec_1(g: Data, h: Data, m: Data, r: Data, m2: Data) -> Data {
 if builtin.null_list(m2) { False } else { if builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = builtin.head_list({
 expect _headList_arg0: List<Data> = m2
 _headList_arg0
})
 _fstPair_arg0
}) == builtin.constr_data(1, {
 expect _constrData_arg1: List<Data> = [builtin.head_list(builtin.snd_pair(builtin.un_constr_data({
let n2 = builtin.un_constr_data(builtin.head_list(builtin.tail_list(builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(builtin.head_list(builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(rec_2(h, m, builtin.un_list_data(builtin.head_list({
 expect _headList_arg0: List<Data> = r
 _headList_arg0
})))))))))))))
{
let o2 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = n2
 _fstPair_arg0
})
{
let p2 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = n2
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 2 == {
 expect _equalsInteger_arg1: Int = o2
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { builtin.head_list({
 expect _headList_arg0: List<Data> = p2
 _headList_arg0
}) } else { fail }
}
}
}))), ..{
 expect _mkCons_arg1: List<Data> = []
 _mkCons_arg1
}]
 _constrData_arg1
}) { True } else { rec_1(g, h, m, r, builtin.tail_list({
 expect _tailList_arg0: List<Data> = m2
 _tailList_arg0
})) } }
}

fn rec_3(b1: Data, j2: Data) -> Data {
 if builtin.null_list(j2) { fail } else { {
let k2 = builtin.head_list({
 expect _headList_arg0: List<Data> = j2
 _headList_arg0
})
if builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = k2
 _fstPair_arg0
}) == b1 { builtin.un_map_data(builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = k2
 _sndPair_arg0
})) } else { rec_3(b1, builtin.tail_list({
 expect _tailList_arg0: List<Data> = j2
 _tailList_arg0
})) }
} }
}

fn rec_4(k: Data, d1: Data, b1: Data, f1: Data, h: Data, l: Data, q: Data, h1: Data) -> Data {
 if builtin.null_list(h1) { fail } else { {
let i1 = builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(builtin.head_list({
 expect _headList_arg0: List<Data> = h1
 _headList_arg0
}))))
if {
let j1 = builtin.un_map_data(builtin.head_list({
 expect _headList_arg0: List<Data> = i1
 _headList_arg0
}))
if builtin.null_list(j1) { False } else { {
let k1 = builtin.tail_list({
 expect _tailList_arg0: List<Data> = j1
 _tailList_arg0
})
if builtin.null_list(k1) { False } else { {
let l1 = builtin.head_list({
 expect _headList_arg0: List<Data> = k1
 _headList_arg0
})
{
let m1 = builtin.un_map_data(builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = l1
 _sndPair_arg0
}))
if builtin.null_list(m1) { False } else { {
let n1 = builtin.head_list({
 expect _headList_arg0: List<Data> = m1
 _headList_arg0
})
k(k(k(k(builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = n1
 _fstPair_arg0
}) == d1, builtin.null_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = m1
 _tailList_arg0
}))), builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = l1
 _fstPair_arg0
}) == b1), builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = n1
 _sndPair_arg0
}) == f1), builtin.null_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = k1
 _tailList_arg0
})))
} }
}
} }
} }
} { {
let o1 = builtin.tail_list({
 expect _tailList_arg0: List<Data> = i1
 _tailList_arg0
})
if {
let p1 = builtin.un_constr_data(builtin.head_list({
 expect _headList_arg0: List<Data> = o1
 _headList_arg0
}))
{
let q1 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = p1
 _fstPair_arg0
})
{
let r1 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = p1
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 2 == {
 expect _equalsInteger_arg1: Int = q1
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { builtin.head_list({
 expect _headList_arg0: List<Data> = r1
 _headList_arg0
}) } else { fail }
}
}
} == builtin.list_data({
 expect _listData_arg0: List<Data> = [d1, ..{
 expect _mkCons_arg1: List<Data> = [builtin.b_data(#"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), ..{
 expect _mkCons_arg1: List<Data> = [builtin.constr_data(1, []), ..{
 expect _mkCons_arg1: List<Data> = []
 _mkCons_arg1
}]
 _mkCons_arg1
}]
 _mkCons_arg1
}]
 _listData_arg0
}) { if {
 expect _ifThenElse_arg0: Bool = {
let s1 = builtin.constr_data(1, {
 expect _constrData_arg1: List<Data> = []
 _constrData_arg1
})
{
let t1 = builtin.un_constr_data(builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = o1
 _tailList_arg0
})))
{
let u1 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = t1
 _fstPair_arg0
})
{
let v1 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = t1
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 0 == {
 expect _equalsInteger_arg1: Int = u1
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { {
let w1 = builtin.un_constr_data(s1)
{
let x1 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = w1
 _fstPair_arg0
})
{
let y1 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = w1
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 0 == {
 expect _equalsInteger_arg1: Int = x1
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { builtin.head_list({
 expect _headList_arg0: List<Data> = v1
 _headList_arg0
}) == builtin.head_list({
 expect _headList_arg0: List<Data> = y1
 _headList_arg0
}) } else { False }
}
}
} } else { {
let z1 = builtin.un_constr_data(s1)
{
let a2 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = z1
 _fstPair_arg0
})
{
let b2 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = z1
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 0 == {
 expect _equalsInteger_arg1: Int = a2
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { False } else { True }
}
}
} }
}
}
}
}
 _ifThenElse_arg0
} { if {
let c2 = builtin.un_list_data(builtin.head_list({
 expect _headList_arg0: List<Data> = q
 _headList_arg0
}))
h(fn(d2) { {
let e2 = builtin.head_list(builtin.snd_pair(builtin.un_constr_data(d2)))
{
let f2 = builtin.snd_pair(builtin.un_constr_data(l))
{
let g2 = builtin.snd_pair(builtin.un_constr_data(e2))
if {
 expect _ifThenElse_arg0: Bool = builtin.head_list({
 expect _headList_arg0: List<Data> = f2
 _headList_arg0
}) == builtin.head_list({
 expect _headList_arg0: List<Data> = g2
 _headList_arg0
})
 _ifThenElse_arg0
} { builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = f2
 _tailList_arg0
})) == builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = g2
 _tailList_arg0
})) } else { False }
}
}
} }, c2)
} { Void } else { fail } } else { fail } } else { fail }
} } 
... (truncated, 10000 chars total)
UPLC (compact) 
[[[(lam a [(lam b [(lam c [(lam d [(lam e [(lam f [(lam g [(lam h [(lam i [(lam l [(lam m (lam o (lam p (lam q [(lam r [(lam s [(lam t [(lam u [(lam v [(lam z [(lam w [(lam x [(lam y [(lam j (force [[[e [[(builtin equalsInteger) (con integer 0)] y]] (delay [(lam k [(lam A [(lam B (force [[[e [[(builtin equalsInteger) (con integer 0)] A]] (delay [(lam C [(lam D (force [[[f D] (delay (error))] (delay (force [[[e [l [b D]]] (delay [(lam E [(lam F (force [[[e [[(builtin equalsData) [d F]] E]] (delay [(lam G (force [[[e [[(builtin equalsData) [a F]] G]] (delay [[g (lam H (lam I (force [[[f I] (delay (error))] (delay [(lam L (force [[[e [(lam J (force [[[f J] (delay (con boolean False))] (delay [(lam M (force [[[f M] (delay (con boolean False))] (delay [(lam N [(lam O (force [[[f O] (delay (con boolean False))] (delay [(lam P [[m [[m [[m [[m [[(builtin equalsData) [d P]] E]] [l [b O]]]] [[(builtin equalsData) [d N]] C]]] [[(builtin equalsData) [a P]] G]]] [l [b M]]]) [c O]])])) [(builtin unMapData) [a N]]]) [c M]])])) [b J]])])) [(builtin unMapData) [c L]]]] (delay [(lam J (force [[[e [[(builtin equalsData) [(lam M [(lam N [(lam O (force [[[e [[(builtin equalsInteger) (con integer 2)] N]] (delay [c O])] (delay (error))])) [a M]]) [d M]]) [(builtin unConstrData) [c J]]]] [(builtin listData) [[i E] [[i [(builtin bData) (con bytestring #ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)]] [[i (con data Constr 1 [])] (con (list data) [])]]]]]] (delay (force [[[e [(lam M [(lam N [(lam O [(lam P (force [[[e [[(builtin equalsInteger) (con integer 0)] O]] (delay [(lam Q [(lam R [(lam S (force [[[e [[(builtin equalsInteger) (con integer 0)] R]] (delay [[(builtin equalsData) [c P]] [c S]])] (delay (con boolean False))])) [a Q]]) [d Q]]) [(builtin unConstrData) M]])] (delay [(lam Q [(lam R [(lam S (force [[[e [[(builtin equalsInteger) (con integer 0)] R]] (delay (con boolean False))] (delay (con boolean True))])) [a Q]]) [d Q]]) [(builtin unConstrData) M]])])) [a N]]) [d N]]) [(builtin unConstrData) [c [b J]]]]) [[(builtin constrData) (con integer 1)] (con (list data) [])]]] (delay (force [[[e [(lam M [[h (lam N [(lam O [(lam P [(lam Q (force [[[e [[(builtin equalsData) [c P]] [c Q]]] (delay [[(builtin equalsData) [c [b P]]] [c [b Q]]])] (delay (con boolean False))])) [a [(builtin unConstrData) O]]]) [a [(builtin unConstrData) o]]]) [c [a [(builtin unConstrData) N]]]])] M]) [(builtin unListData) [c t]]]] (delay (con unit ()))] (delay (error))]))] (delay (error))]))] (delay (error))])) [b L]])] (delay [H [b I]])])) [b [a [(builtin unConstrData) [c I]]]]])])))] [(builtin unListData) [c v]]])] (delay (error))])) [(builtin iData) (con integer 1)]])] (delay (error))])) [c D]]) [(builtin bData) (con bytestring #)]])] (delay (error))]))])) [(lam D [[g (lam E (lam F (force [[[f F] (delay (error))] (delay [(lam G (force [[[e [[(builtin equalsData) [d G]] C]] (delay [(builtin unMapData) [a G]])] (delay [E [b F]])])) [c F]])])))] D]) [(builtin unMapData) [c z]]]]) [c j]])] (delay (force w))])) [a k]]) [d k]]) [(builtin unConstrData) [c s]]])] (delay (force [[[e [[(builtin equalsInteger) (con integer 1)] y]] (delay (force w))] (delay (error))]))])) [a x]]) [d x]]) [(builtin unConstrData) [c [b s]]]]) (delay (force [[[e [[g (lam w (lam x (force [[[f x] (delay (con boolean False))] (delay (force [[[e [[(builtin equalsData) [d [c x]]] [[(builtin constrData) (con integer 1)] [[i [c [a [(builtin unConstrData) [(lam y [(lam j [(lam k (force [[[e [[(builtin equalsInteger) (con integer 2)] j]] (delay [c k])] (delay (error))])) [a y]]) [d y]]) [(builtin unConstrData) [c [b [b [a [(builtin unConstrData) [c [b [a [(builtin unConstrData) [[g (lam y (lam j (force [[[f j] (delay (error))] (delay [(lam k (force [[[e [(lam A [[h (lam B [[(builtin equalsData) [d B]] p])] A]) [(builtin unMapData) [c [b [a [(builtin unConstrData) [c [b [a [(builtin unConstrData) k]]]]]]]]]]] (delay k)] (delay [y [b j]])])) [c j]])])))] [(builtin unListData) [c u]]]]]]]]]]]]]]]]]] (con (list data) [])]]]] (delay (con boolean True))] (delay [w [b x]])]))])))] [(builtin unMapData) [c [b [b z]]]]]] (delay (con unit ()))] (delay (error))]))]) [b [b v]]]) [b u]]) [b t]]) [a [(builtin unConstrData) [c r]]]]) [b r]]) [a [(builtin unConstrData) q]]])))) (lam m (lam o [[[e m] o] (con boolean False)]))]) (force (builtin nullList))]) (force (builtin mkCons))]) (lam h [g (lam i (lam l (force [[[f l] (delay (con boolean False))] (delay (force [[[e [h [c l]]] (delay (con boolean True))] (delay [i [b l]])]))])))])]) (lam g [(lam h [g (lam i [[g (lam l [[g (lam m [[g (lam o [[g (lam p [[g (lam q [[g (lam r [[g (lam s [[g (lam t [[g (lam u [[g (lam v [[g (lam z [[g (lam w [[g (lam x [[g (lam y [[g (lam j [[g (lam k [[h h] k])] j])] y])] x])] w])] z])] v])] u])] t])] s])] r])] q])] p])] o])] m])] l])] i])]) (lam h [g (lam i [[h h] i])])])]) (force (force (builtin chooseList)))]) (force (builtin ifThenElse))]) (force (force (builtin fstPair)))]) (force (builtin headList))]) (force (builtin tailList))]) (force (force (builtin sndPair)))] (con data Constr 0 [B #222d66110efec4c43152a7c5833ec4c1cef412cd9ba45662230d195512bbab1a,I 2])] (con data B #49b5b45b3b600416fee318dc34d9660ebb3a759fbd2db683fef641ff)]

Auto-filed by UPLC.WTF verification system

Metadata

Metadata

Assignees

No one assigned

    Labels

    auto-reportedenhance-bug

    Projects

    No projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions