[enhance-bug] AI quality issues in 49b5b45b3b60...

[will-break-it]

AI Enhancement Issue

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

Script: 49b5b45b3b600416fee318dc34d9660ebb3a759fbd2db683fef641ff
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: 88.9% → 100.0%
• Placeholders: 100.0% → 100.0%
• Abstraction: 53.1% → 82.6%

AI-Enhanced Aiken

use aiken/builtin
use aiken/crypto

const policy_id_0 = #"222d66110efec4c43152a7c5833ec4c1cef412cd9ba45662230d195512bbab1a"

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

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

fn compare_sorted_lists(list1: List<Data>, list2: List<Data>, count: Int) -> Int {
  when list1 is {
    [] -> count
    [head1, ..tail1] -> when list2 is {
      [] -> count
      [head2, ..tail2] -> {
        let bytes1 = builtin.un_b_data(head1)
        let bytes2 = builtin.un_b_data(head2)
        if builtin.equals_bytearray(bytes1, bytes2) {
          compare_sorted_lists(tail1, tail2, count + 1)
        } else if builtin.less_than_bytearray(bytes1, bytes2) {
          compare_sorted_lists(tail1, list2, count)
        } else {
          compare_sorted_lists(list1, tail2, count)
        }
      }
    }
  }
}

fn find_constructor_field(constructor_tag: Int, constructors: List<Data>) -> List<Pair<Data, Data>> {
  when constructors is {
    [] -> fail
    [head, ..tail] -> {
      let pair = builtin.un_constr_data(head)
      if builtin.fst_pair(pair) == constructor_tag {
        builtin.un_map_data(builtin.snd_pair(pair))
      } else {
        find_constructor_field(constructor_tag, tail)
      }
    }
  }
}

fn validate_sorted_ascending(result: Data, items: List<Data>) -> Data {
  when items is {
    [] -> result
    [_] -> result
    [first, second, ..rest] ->
      if builtin.less_than_bytearray(
        builtin.un_b_data(first),
        builtin.un_b_data(second)
      ) {
        validate_sorted_ascending(result, [second, ..rest])
      } else {
        fail
      }
  }
}

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

fn compare_utxos(utxo1: Data, utxo2: Data) -> Bool {
  let fields1 = builtin.snd_pair(builtin.un_constr_data(utxo1))
  let fields2 = builtin.snd_pair(builtin.un_constr_data(utxo2))
  let addr1 = builtin.head_list(fields1)
  let addr2 = builtin.head_list(fields2)
  if addr1 == addr2 {
    let value1 = builtin.head_list(builtin.tail_list(fields1))
    let value2 = builtin.head_list(builtin.tail_list(fields2))
    value1 == value2
  } else {
    False
  }
}

fn get_fourth_tail(items: List<Data>) -> List<Data> {
  builtin.tail_list(builtin.tail_list(builtin.tail_list(builtin.tail_list(items))))
}

validator policy {
  mint(_redeemer: Data, _datum: Data, tx_info: Data) {
    let tx_fields = builtin.snd_pair(builtin.un_constr_data(tx_info))
    let remaining_fields = builtin.tail_list(tx_fields)
    let tx_info_fields = builtin.snd_pair(builtin.un_constr_data(builtin.head_list(tx_fields)))
    let inputs = builtin.tail_list(builtin.tail_list(tx_info_fields))
    let outputs = builtin.tail_list(builtin.tail_list(inputs))
    
    let purpose_data = builtin.un_constr_data(builtin.head_list(builtin.tail_list(remaining_fields)))
    let purpose_tag = builtin.fst_pair(purpose_data)
    let purpose_fields = builtin.snd_pair(purpose_data)
    
    when purpose_tag is {
      0 -> {
        let datum_map = builtin.un_map_data(builtin.head_list(outputs))
        let datum_key = builtin.head_list(purpose_fields)
        
        let datum_entry = {
          let entries = find_constructor_field(datum_key, datum_map)
          when entries is {
            [] -> fail
            [single] -> single
            _ -> fail
          }
        }
        
        let entry_tag = builtin.fst_pair(datum_entry)
        let entry_fields = builtin.snd_pair(datum_entry)
        
        let script_fields = get_fourth_tail(
          builtin.snd_pair(builtin.un_constr_data(
            find_first(
              fn(utxo) {
                any_matches(
                  fn(item) {
                    let pair = builtin.un_constr_data(item)
                    builtin.fst_pair(pair) == datum_key
                  },
                  builtin.un_map_data(builtin.head_list(builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(utxo)))))
                )
              },
              builtin.un_list_data(builtin.head_list(inputs))
            )
          ))
        )
        
        let reference_utxo = builtin.un_constr_data(builtin.head_list(builtin.tail_list(builtin.tail_list(script_fields))))
        let reference_tag = builtin.fst_pair(reference_utxo)
        let reference_fields = builtin.snd_pair(reference_utxo)
        
        when reference_tag is {
          2 -> {
            let protocol_params = builtin.head_list(reference_fields)
            let remaining_script_fields = builtin.tail_list(script_fields)
            let param_count = builtin.un_i_data(builtin.head_list(remaining_script_fields))
            let param_list = builtin.un_list_data(builtin.head_list(script_fields))
            
            let validation_result = 
              if entry_tag == #"555344435850726f746f636f6c506172616d6574657273" &&
                 entry_fields == 1 &&
                 any_matches(
                   fn(input) {
                     compare_utxos(_redeemer, builtin.head_list(builtin.snd_pair(builtin.un_constr_data(input))))
                   },
                   builtin.un_list_data(builtin.head_list(tx_info_fields))
                 ) &&
                 0 < param_count &&
                 param_count <= builtin.un_i_data(builtin.head_list(builtin.tail_list(builtin.tail_list(builtin.tail_list(remaining_script_fields))))) &&
                 0 < builtin.un_i_data(builtin.head_list(builtin.tail_list(builtin.tail_list(builtin.tail_list(remaining_script_fields)))))
              { 
                Void
              } else {
                fail
              }
            
            validate_sorted_ascending(validation_result, param_list)
          }
          _ -> fail
        }
      }
      
      1 -> {
        let target_hash = builtin.head_list(purpose_fields)
        let matching_input = builtin.snd_pair(builtin.un_constr_data(builtin.head_list(builtin.tail_list(
          builtin.snd_pair(builtin.un_constr_data(
            find_first(
              fn(input) {
                compare_utxos(builtin.head_list(builtin.snd_pair(builtin.un_constr_data(input))), target_hash)
              },
              builtin.un_list_data(builtin.head_list(tx_info_fields))
            )
          ))
        ))))
        
        let input_addr = builtin.head_list(matching_input)
        let input_credential = builtin.head_list(builtin.snd_pair(builtin.un_constr_data(builtin.head_list(builtin.snd_pair(builtin.un_constr_data(input_addr))))))
        
        let matching_output = builtin.snd_pair(builtin.un_constr_data(
          find_first(
            fn(output) {
              any_matches(
                fn(item) {
                  let pair = builtin.un_constr_data(item)
                  builtin.fst_pair(pair) == input_credential
                },
                builtin.un_map_data(builtin.head_list(builtin.tail_list(builtin.snd_pair(builtin.un_constr_data(output)))))
              )
            },
            builtin.un_list_data(builtin.head_list(inputs))
          )
        ))
        
        let output_fields = builtin.tail_list(matching_output)
        let script_ref = builtin.un_constr_data(builtin.head_list(builtin.tail_list(output_fields)))
        let script_tag = builtin.fst_pair(script_ref)
        let script_fields = builtin.snd_pair(script_ref)
        
        when script_tag is {
          2 -> {
            let script_data = builtin.head_list(script_fields)
            let tx_purpo
... (truncated, 10000 chars total)

Raw Decompiled Aiken

use aiken/builtin
use aiken/crypto

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

fn rec_0(c7: Data, e7: Data) -> Data {
 if builtin.null_list(e7) { fail } else { {
let f7 = builtin.head_list({
 expect _headList_arg0: List<Data> = e7
 _headList_arg0
})
if {
 expect _ifThenElse_arg0: Bool = c7(f7)
 _ifThenElse_arg0
} { f7 } else { rec_0(c7, builtin.tail_list({
 expect _tailList_arg0: List<Data> = e7
 _tailList_arg0
})) }
} }
}

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

fn rec_2(o6: Data, p6: Data, q6: Data) -> Data {
 if builtin.null_list(o6) { q6 } else { if builtin.null_list(p6) { q6 } else { {
let r6 = builtin.head_list({
 expect _headList_arg0: List<Data> = o6
 _headList_arg0
})
{
let s6 = builtin.head_list({
 expect _headList_arg0: List<Data> = p6
 _headList_arg0
})
{
let t6 = builtin.un_b_data(r6)
{
let u6 = builtin.un_b_data(s6)
if builtin.equals_bytearray({
 expect _equalsByteString_arg0: ByteArray = t6
 _equalsByteString_arg0
}, {
 expect _equalsByteString_arg1: ByteArray = u6
 _equalsByteString_arg1
}) { rec_2(builtin.tail_list({
 expect _tailList_arg0: List<Data> = o6
 _tailList_arg0
}), builtin.tail_list({
 expect _tailList_arg0: List<Data> = p6
 _tailList_arg0
}), {
 expect _addInteger_arg0: Int = q6
 _addInteger_arg0
} + 1) } else { if builtin.less_than_bytearray({
 expect _lessThanByteString_arg0: ByteArray = t6
 _lessThanByteString_arg0
}, {
 expect _lessThanByteString_arg1: ByteArray = u6
 _lessThanByteString_arg1
}) { rec_2(builtin.tail_list({
 expect _tailList_arg0: List<Data> = o6
 _tailList_arg0
}), p6, q6) } else { rec_2(o6, builtin.tail_list({
 expect _tailList_arg0: List<Data> = p6
 _tailList_arg0
}), q6) } }
}
}
}
} } }
}

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

fn rec_4(l1: Data, n1: Data) -> Data {
 if builtin.null_list(n1) { l1 } else { {
let o1 = builtin.tail_list({
 expect _tailList_arg0: List<Data> = n1
 _tailList_arg0
})
if builtin.null_list(o1) { l1 } else { if builtin.less_than_bytearray(builtin.un_b_data(builtin.head_list({
 expect _headList_arg0: List<Data> = n1
 _headList_arg0
})), builtin.un_b_data(builtin.head_list({
 expect _headList_arg0: List<Data> = o1
 _headList_arg0
}))) { rec_4(l1, o1) } else { fail } }
} }
}

fn rec_5(s3: Data, u3: Data) -> Data {
 if builtin.null_list(u3) { s3 } else { {
let v3 = builtin.tail_list({
 expect _tailList_arg0: List<Data> = u3
 _tailList_arg0
})
if builtin.null_list(v3) { s3 } else { if builtin.less_than_bytearray(builtin.un_b_data(builtin.head_list({
 expect _headList_arg0: List<Data> = u3
 _headList_arg0
})), builtin.un_b_data(builtin.head_list({
 expect _headList_arg0: List<Data> = v3
 _headList_arg0
}))) { rec_5(s3, v3) } else { fail } }
} }
}

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

validator policy {
 mint(s: Data, t: Data, tx: Data) {
 let f = fn(b8, c8) { {
let d8 = builtin.snd_pair(builtin.un_constr_data(b8))
{
let e8 = builtin.snd_pair(builtin.un_constr_data(c8))
if {
 expect _ifThenElse_arg0: Bool = builtin.head_list({
 expect _headList_arg0: List<Data> = d8
 _headList_arg0
}) == builtin.head_list({
 expect _headList_arg0: List<Data> = e8
 _headList_arg0
})
 _ifThenElse_arg0
} { builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = d8
 _tailList_arg0
})) == builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = e8
 _tailList_arg0
})) } else { False }
}
} }
{
let h = fn(g7) { {
let h7 = fn(z7) { g7(fn(a8) { (z7 as fn(fn(Data) -> Data, Data) -> Data)(z7 as fn(Data) -> Data, a8) }) }
g7(fn(i7) { g7(fn(j7) { g7(fn(k7) { g7(fn(l7) { g7(fn(m7) { g7(fn(n7) { g7(fn(o7) { g7(fn(p7) { g7(fn(q7) { g7(fn(r7) { g7(fn(s7) { g7(fn(t7) { g7(fn(u7) { g7(fn(v7) { g7(fn(w7) { g7(fn(x7) { g7(fn(y7) { (h7 as fn(fn(Data) -> Data, Data) -> Data)(h7 as fn(Data) -> Data, y7) }, x7) }, w7) }, v7) }, u7) }, t7) }, s7) }, r7) }, q7) }, p7) }, o7) }, n7) }, m7) }, l7) }, k7) }, j7) }, i7) })
} }
{
let i = fn(c7) { fn(e7) { rec_0(c7, e7) } }
{
let j = fn(z6) { fn(b7) { rec_1(z6, b7) } }
{
let k = fn(w6, x6) { j(fn(y6) { builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = y6
 _fstPair_arg0
}) == w6 }, x6) }
{
let l = fn(v6) { builtin.tail_list(builtin.tail_list(builtin.tail_list(builtin.tail_list(builtin.tail_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = v6
 _tailList_arg0
})))))) }
{
let m = fn(l6, m6) { rec_2(l6, m6, 0) }
{
let n = fn(j6, k6) { builtin.map_data({
 expect _mapData_arg0: List<Pair<Data, Data>> = j6
 _mapData_arg0
}) == builtin.map_data({
 expect _mapData_arg0: List<Pair<Data, Data>> = k6
 _mapData_arg0
}) }
{
let o = fn(l5, m5) { {
let n5 = builtin.snd_pair(builtin.un_constr_data(l5))
{
let o5 = builtin.snd_pair(builtin.un_constr_data(m5))
if {
 expect _ifThenElse_arg0: Bool = {
let p5 = builtin.head_list({
 expect _headList_arg0: List<Data> = o5
 _headList_arg0
})
{
let q5 = builtin.un_constr_data(builtin.head_list({
 expect _headList_arg0: List<Data> = n5
 _headList_arg0
}))
{
let r5 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = q5
 _fstPair_arg0
})
{
let s5 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = q5
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 0 == {
 expect _equalsInteger_arg1: Int = r5
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { {
let t5 = builtin.un_constr_data(p5)
{
let u5 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = t5
 _fstPair_arg0
})
{
let v5 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = t5
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 0 == {
 expect _equalsInteger_arg1: Int = u5
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { builtin.head_list({
 expect _headList_arg0: List<Data> = s5
 _headList_arg0
}) == builtin.head_list({
 expect _headList_arg0: List<Data> = v5
 _headList_arg0
}) } else { False }
}
}
} } else { {
let w5 = builtin.un_constr_data(p5)
{
let x5 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = w5
 _fstPair_arg0
})
{
let y5 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int, List<Data>> = w5
 _sndPair_arg0
})
if {
 expect _ifThenElse_arg0: Bool = 0 == {
 expect _equalsInteger_arg1: Int = x5
 _equalsInteger_arg1
}
 _ifThenElse_arg0
} { False } else { builtin.head_list({
 expect _headList_arg0: List<Data> = s5
 _headList_arg0
}) == builtin.head_list({
 expect _headList_arg0: List<Data> = y5
 _headList_arg0
}) }
}
}
} }
}
}
}
}
 _ifThenElse_arg0
} { {
let z5 = builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = o5
 _tailList_arg0
}))
{
let a6 = builtin.un_constr_data(builtin.head_list(builtin.tail_list({
 expect _tailList_arg0: List<Data> = n5
 _tailList_arg0
})))
{
let b6 = builtin.fst_pair({
 expect _fstPair_arg0: Pair<Int, List<Data>> = a6
 _fstPair_arg0
})
{
let c6 = builtin.snd_pair({
 expect _sndPair_arg0: Pair<Int
... (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 [(lam k [(lam A [(lam B [(lam C (force [[[e [[(builtin equalsInteger) (con integer 0)] B]] (delay [(lam D [(lam E [(lam F [(lam G [(lam H [(lam I [(lam L [(lam J [(lam M [(lam N [[h (lam O (lam P (force [[[g P] (delay N)] (delay [(lam Q (force [[[g Q] (delay N)] (delay (force [[[e [[(builtin lessThanByteString) [(builtin unBData) [c P]]] [(builtin unBData) [c Q]]]] (delay [O Q])] (delay (error))]))])) [b P]])])))] M]) (force [[[e [[s [[s [[s [[s [[s [[(builtin equalsData) G] (con data B #555344435850726f746f636f6c506172616d6574657273)]] [[(builtin equalsData) H] (con data I 1)]]] [(lam N [[l (lam O [[f v] [c [a [(builtin unConstrData) O]]]])] N]) [(builtin unListData) [c y]]]]] [[(builtin lessThanInteger) (con integer 0)] J]]] [[(builtin lessThanEqualsInteger) J] [u M]]]] [[(builtin lessThanInteger) (con integer 0)] [(builtin unIData) [c [b [b [b L]]]]]]]] (delay (con unit ()))] (delay (error))])]) [(builtin unListData) [c I]]]) [(builtin unIData) [c L]]]) [b I]]) [o [a [(builtin unConstrData) [(lam I [(lam L [(lam J (force [[[e [[(builtin equalsInteger) (con integer 2)] L]] (delay [c J])] (delay (error))])) [a I]]) [d I]]) [(builtin unConstrData) [c [b [b [a [(builtin unConstrData) [[i (lam I [[m E] [(builtin unMapData) [c [b [a [(builtin unConstrData) I]]]]]])] [(builtin unListData) [c j]]]]]]]]]]]]]]) [a F]]) [d F]]) [(lam F (force [[[g F] (delay (error))] (delay (force [[[g [b F]] (delay [c F])] (delay (error))]))])) [[h (lam F (lam G (force [[[g G] (delay (error))] (delay [(lam H (force [[[e [[(builtin equalsData) [d H]] E]] (delay [(builtin unMapData) [a H]])] (delay [F [b G]])])) [c G]])])))] D]]]) [c C]]) [(builtin unMapData) [c k]]])] (delay (force [[[e [[(builtin equalsInteger) (con integer 1)] B]] (delay [(lam D [(lam E [(lam F [(lam G [(lam H [(lam I [(lam L [(lam J [(lam M (force [[[e [[(builtin equalsInteger) (con integer 2)] J]] (delay [(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 [(lam T [(lam U [(lam V [(lam Z [(lam W [(lam X (force [[[e [[s [[s [[s [[s [[s [[s [[(builtin lessThanEqualsInteger) X] [u [(builtin unListData) [c Z]]]]] [[(builtin lessThanEqualsInteger) [(builtin unIData) [c [b U]]]] [[p [(builtin unListData) [c [b [b [b [b k]]]]]]] [(builtin unListData) [c U]]]]]] [[(builtin lessThanInteger) (con integer 0)] X]]] [[(builtin equalsData) [c T]] [c V]]]] [[(builtin lessThanInteger) (con integer 0)] [(builtin unIData) [c [b [b [b W]]]]]]]] [[r [c H]] F]]] [[q [b [(builtin unMapData) [c I]]]] [b [(builtin unMapData) [c [b E]]]]]]] (delay (con unit ()))] (delay (error))])) [(builtin unIData) [c W]]]) [b Z]]) [b [b V]]]) [t [a [(builtin unConstrData) [c M]]]]]) [b [b T]]]) [t [a [(builtin unConstrData) [c S]]]]])] (delay (error))])) [a Q]]) [d Q]]) [(builtin unConstrData) [c [b C]]]])] (delay (force [[[e [[(builtin equalsInteger) (con integer 1)] O]] (delay [(lam Q [(lam R [(lam S (force [[[e [[(builtin equalsInteger) (con integer 0)] R]] (delay [(lam T [(lam U [(lam V [(lam Z [(lam W [(lam X [(lam Y [(lam J [(lam K [(lam ba [(lam bb [(lam bc [(lam bd [(lam be [(lam bf [(lam bg [(lam bh [(lam bi [(lam bl [(lam bm [(lam bo (force [[[e [[s [[s [(lam bp [[h (lam bq (lam br (force [[[g br] (delay bp)] (delay [(lam bs (force [[[g bs] (delay bp)] (delay (force [[[e [[(builtin lessThanByteString) [(builtin unBData) [c br]]] [(builtin unBData) [c bs]]]] (delay [bq bs])] (delay (error))]))])) [b br]])])))] bo]) [(lam bp [(lam bq [[s [[s [[s [[s [[s [[s [[s [[s [[s [[s [[(builtin equalsByteString) [(builtin unBData) [c T]]] [(builtin unBData) [c ba]]]] [[(builtin equalsData) [c U]] [c bb]]]] [[(builtin equalsByteString) [(builtin unBData) [c V]]] [(builtin unBData) [c bc]]]]] [[(builtin equalsData) [c Z]] [c bd]]]] [[(builtin equalsByteString) bq] [(builtin unBData) [c bf]]]]] [[(builtin equalsData) [c X]] [c bg]]]] [[(builtin equalsInteger) [(builtin unIData) [c Y]]] [(builtin unIData) [c bh]]]]] [[(builtin equalsData) [c J]] [c bi]]]] [[(builtin equalsByteString) [(builtin unBData) [c K]]] [(builtin unBData) [c bl]]]]] [[(builtin equalsData) [c [b K]]] [c [b bl]]]]] [[[(builtin verifyEcdsaSecp256k1Signature) bq] [(builtin keccak_256) [[(builtin appendByteString) [(builtin serialiseData) D]] [(builtin serialiseData) bm]]]] [[[(builtin sliceByteString) (con integer 0)] (con integer 64)] [(builtin unBData) [c P]]]]]) [(builtin unBData) [c W]]]) [b [b bo]]]]] [[r [c H]] F]]] [[q [b [(builtin unMapData) [c I]]]] [b [(builtin unMapData) [c [b E]]]]]]] (delay (con unit ()))] (delay (error))])) [(builtin unListData) bm]]) [c be]]) [b bi]]) [b bh]]) [b bg]]) [b bf]]) [b be]]) [b bd]]) [b bc]]) [b bb]]) [b ba]]) [a [(builtin unConstrData) [c M]]]]) [b J]]) [b Y]]) [b X]]) [b W]]) [b [b Z]]]) [b V]]) [b U]]) [b T]]) [a [(builtin unConstrData) [c S]]]])] (delay (error))])) [a Q]]) [d Q]]) [(builtin unConstrData) [c [b C]]]])] (delay (force [[[e [[(builtin equalsInteger) (con integer 2)] O]] (delay [(lam Q [(lam R [(lam S (force [[[e [[(builtin equalsInteger) (con integer 0)] R]] (delay [(lam T [(lam U [(lam V [(lam Z [(lam W [(lam X [(lam Y [(lam J [(lam K [(lam ba [(lam bb [(lam bc [(lam bd [(lam be [(lam bf [(lam bg [(lam bh [(lam bi [(lam bl (force [[[e [[s [[s [[s [[l (lam bm [[h (lam bo (lam bp (force [[[g bp] (delay (con boolean False))] (delay (force [[[e [[(builtin equalsData) [c bp]] bm]] (delay (con boolean True))] (delay [bo [b bp]])]))])))] [(builtin unListData) [c [b [b [b [b k]]]]]]])] [(builtin unListData) bl]]] [[s [[s [[s [[s [[s [[s [[s [[s [[s [[(builtin equalsByteString) [(builtin unBData) [c T]]] [(builtin unBData) [c ba]]]] [[(builtin equalsData) [c U]] [c bb]]]] [[(builtin equalsByteString) [(builtin unBData) [c V]]] [(builtin unBData) [c bc]]]]] [[(builtin equalsData) [c Z]] [c bd]]]] [[(builtin equalsData) [c W]] [c be]]]] [[(builtin equalsByteString) [(builtin unBData) [c X]]] [(builtin unBData) [c bf]]]]] [[(builtin equalsData) bl] [c bg]]]] [[(builtin equalsInteger) [(builtin unIData) [c J]]] [(builtin unIData) [c bh]]]]] [[(builtin equalsByteString) [(builtin unBData) [c K]]] [(builtin unBData) [c bi]]]]] [[(builtin equalsData) [c [b K]]] [c [b bi]]]]]] [[r [c H]] F]]] [[q [b [(builtin unMapData) [c I]]]] [b [(builtin unMapData) [c [b E]]]]]]] (delay (con unit ()))] (delay (error))])) [c Y]]) [b [b bh]]]) [b bg]]) [b bf]]) [b be]]) [b bd]]) [b bc]]) [b bb]]) [b ba]]) [a [(builtin unConstrData) [c M]]]]) [b [b J]]]) [b Y]]) [b X]]) [b W]]) [b Z]]) [b V]]) [b U]]) [b T]]) [a [(builtin unConstrData) [c S]]]])] (delay (error))])) [a Q]]) [d Q]]) [(builtin unConstrData) [c [b C]]]])] (delay [(lam Q [(lam R [(lam S (force [[[e [[(builtin equalsInteger) (con integer 0)] R]] (delay [(lam T [(lam U (force [[[e [[(builtin equalsInteger) [d U]] (con integer 0)]] (delay [(lam V (force [[[e [[(builtin lessThanEqualsInteger) [(builtin unIData) [c [b T]]]] [[p [(builtin unListData) [c [b [b [b [b k]]]]]]] [(builtin unListData) [c T]]]]] (delay (con unit ()))] (delay (error))])) [(builtin unBData) [c [a U]]]])] (delay (error))])) [(builtin unConstrData) [c M]]]) [o [a [(builtin unConstrData) [c S]]]]])] (delay (error))])) [a Q]]) [d Q]]) [(builtin unConstrData) [c [b C]]]])]))]))])) [a N]]) [d N]]) [(builtin unConstrData) [c x]]])] (delay (error))])) [a L]]) [d L]]) [(builtin unConstrData) [c [b I]]]]) [b H]]) [a [(builtin unConstrData) [[i (lam H [[m G] [(builtin unMapData) [c [b [a [(builtin unConstrData) H]]]]]])] [(builtin unListData) [c j]]]]]]) [c [a [(builtin unConstrData) [c [a [(builtin unConstrData) F]]]]]]]) [c E]]) [a [(builtin unConstrData) [c [b [a [(builtin unConstrData) [[i (lam E [[f [c [a [(builtin unConstrData) E]]]] D])] [(builtin unListData) [c y]]]]]]]]]]) [c C]])] (delay (error))]))])) [a A]]) [d A]]) [(builtin unConstrData) [c [b x]]]]) [b [b j]]]) [b [b y]]]) [a [(builtin unConstrData) [c w]]]]) [b w]]) [a [(builtin unConstrData) z]]]))) [[h (lam u (lam v (lam z (force [[[g z] (delay v)] (delay [[u [[(builtin addInteger) v] (con integer 1)]] [b z]])]))))] (con integer 0)]]) (lam t [b [b [b [b t]]]])]) (lam s (lam t [[[e s] t] (con boolean False)]))]) (lam r (lam s [(lam t [(lam u (force [[[e [(lam v [(lam z [(lam w [(lam x (force [[[e [[(builtin equalsInteger) (con integer 0)] w]] (delay [(lam y [(lam j [(lam k (force [[[e [[(builtin equalsInteger) (con integer 0)] j]] (delay [[(builtin equalsData) [c x]] [c k]])] (delay (con boolean False))])) [a y]]) [d y]]) [(builtin unConstrData) v]])] (delay [(lam y [(lam j [(lam k (force [[[e [[(builtin equalsInteger) (con integer 0)] j]] (delay (con boolean False))] (delay [[(builtin equalsData) [c x]] [c k]])])) [a y]]) [d y]]) [(builtin unConstrData) v]])])) [a z]]) [d z]]) [(builtin unConstrData) [c t]]]) [c u]]] (delay [(lam v [(lam z [(lam w [(lam x (force [[[e [[(builtin equalsInteger) (con integer 0)] w]] (delay [(lam y [(lam j [(lam k (force [[[e [[(builtin equalsInteger) (con integer 0)] j]] (delay [[(builtin equalsData) [c x]] [c k]])] (delay (con boolean False))])) [a y]]) [d y]]) [(builtin unConstrData) v]])] (delay [(lam y [(lam j [(lam k (force [[[e [[(builtin equalsInteger) (con integer 0)] j]] (delay (con boolean False))] (delay (con boolean True))])) [a y]]) [d y]]) [(builtin unConstrData) v]])])) [a z]]) [d z]]) [(builtin unConstrData) [c [b t]]]]) [c [b u]]])] (delay (con boolean False))])) [a [(builtin unConstrData) s]]]) [a [(builtin unConstrData) r]]]))]) (lam q (lam r [[(builtin equalsData) [(builtin mapData) q]] [(builtin mapData) r]]))]) (lam p (lam q [[[[h (lam r (lam s (lam t (lam u (force [[[g s] (delay u)] (delay (force [[[g t] (delay u)] (delay [(lam v [(lam z [(lam w [(lam x (force [[[e [[(builtin equalsByteString) w] x]] (delay [[[r [b s]] [b t]] [[(builtin addInteger) u] (con integer 1)]])] (delay (force [[[e [[(builtin lessThanByteString) w] x]] (delay [[[r [b s]] t] u])] (delay [[[r s] [b t]] u])]))])) [(builtin unBData) z]]) [(builtin unBData) v]]) [c t]]) [c s]])]))])))))] p] q] (con integer 0)]))]) (lam o [b [b [b [b [b [b o]]]]]])]) (lam m (lam o [[l (lam p [[(builtin equalsData) [d p]] m])] o]))]) (lam l [h (lam m (lam o (force [[[g o] (delay (con boolean False))] (delay (force [[[e [l [c o]]] (delay (con boolean True))] (delay [m [b o]])]))])))])]) (lam i [h (lam l (lam m (force [[[g m] (delay (error))] (delay [(lam o (force [[[e [i o]] (delay o)] (delay [l [b m]])])) [c m]])])))])]) (lam h [(lam i [h (lam l [[h (lam m [[h (lam o [[h (lam p [[h (lam q [[h (lam r [[h (lam s [[h (lam t [[h (lam u [[h (lam v [[h (lam z [[h (lam w [[h (lam x [[h (lam y [[h (lam j [[h (lam k [[h (lam A [[i i] A])] k])] j])] y])] x])] w])] z])] v])] u])] t])] s])] r])] q])] p])] o])] m])] l])]) (lam i [h (lam l [[i i] l])])])]) (force (force (builtin chooseList)))]) (lam f (lam g [(lam h [(lam i (force [[[e [[(builtin equalsData) [c h]] [c i]]] (delay [[(builtin equalsData) [c [b h]]] [c [b i]]])] (delay (con boolean False))])) [a [(builtin unConstrData) g]]]) [a [(builtin unConstrData) f]]]))]) (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])]

---

Auto-filed by UPLC.WTF verification system