package com.acme.symbolic;

import church.lang.ByteStream;
import church.lang.Collections.$Empty_set;
import church.lang.Hash.$HashCode;
import church.lang.operators.Arithmetic.*;
import church.lang.operators.Relational.$$equal;
import church.lang.operators.Streams.$$encode;
import church.primitives.Integers;
import church.primitives.Objects;
import church.util.HashMap;
import church.util.HashMap.$Map;
import com.acme.symbolic.Derivative.$Derivative;
import com.acme.symbolic.DerivativeTest.$Test;
import com.acme.symbolic.DerivativeTest.$Test0;
import com.acme.symbolic.Expression.$Evaluate;
import com.acme.symbolic.Expression.$ExprEqual;

import static com.acme.symbolic.Expression.$const;

@SuppressWarnings("unchecked")
public class PolynomialDerivativeTest {
    private static final $$dof<Integer>                                                                                         $S0  = Integers::$dof;
    private static final $$encode<ByteStream, Integer>                                                                          $S1  = Integers::$encode;
    private static final $$encode<ByteStream, String>                                                                           $S2  = Objects::$encode;
    private static final $$encode<ByteStream, Expression<Integer>>                                                              $S3  = Expression.$encode($S1, $S2);
    private static final $$sum<Integer>                                                                                         $S4  = Integers::$sum;
    private static final $$neg<Integer>                                                                                         $S5  = Integers::$neg;
    private static final $$sub<Integer>                                                                                         $S6  = Integers::$sub;
    private static final $$prd<Integer, Integer>                                                                                $S7  = Integers::$prd;
    private static final $$div<Integer, Integer>                                                                                $S8  = PolynomialDerivativeTest::$div;
    private static final $$pow<Integer, Integer>                                                                                $S9  = Integers::$pow;
    private static final $Evaluate<Integer>                                                                                     $S10 = Expression.evaluate($S4, $S5, $S6, $S7, $S8, $S9);
    private static final $Additive_identity<Integer>                                                                            $S11 = Integers::additive_identity;
    private static final $Additive_identity<Expression<Integer>>                                                                $S12 = Expression.additive_identity($S11);
    private static final $$equal<Integer>                                                                                       $S13 = Integers::$equal;
    private static final $ExprEqual<Integer>                                                                                    $S14 = Expression.exprEqual($S13);
    private static final $$equal<Expression<Integer>>                                                                           $S15 = Expression.$equal($S14);
    private static final $Multiplicative_identity<Integer>                                                                      $S16 = Integers::multiplicative_identity;
    private static final $Multiplicative_identity<Expression<Integer>>                                                          $S17 = Expression.multiplicative_identity($S16);
    private static final $$prd<Expression<Integer>, Expression<Integer>>                                                        $S18 = Expression.$prd($S15, $S12, $S17);
    private static final $$sum<Expression<Integer>>                                                                             $S19 = Expression.$sum($S15, $S12);
    private static final $$neg<Expression<Integer>>                                                                             $S20 = Expression::$neg;
    private static final $$sub<Expression<Integer>>                                                                             $S21 = Expression.$sub($S15, $S12, $S20);
    private static final $$div<Expression<Integer>, Expression<Integer>>                                                        $S22 = Expression.$div($S15, $S12, $S17);
    private static final $$pow<Expression<Integer>, Integer>                                                                    $S23 = Expression.$pow($S15, $S12, $S13, $S11, $S17, $S16);
    private static final $Derivative<Integer>                                                                                   $S24 = Derivative.derivative($S12, $S15, $S17, $S18, $S19, $S20, $S21, $S22, $S23, $S6, $S16);
    private static final $Test<Integer>                                                                                         $S25 = DerivativeTest.test($S3, $S10, $S1, $S24, $S13);
    private static final $$equal<String>                                                                                        $S26 = Objects::$equal;
    private static final $HashCode<String>                                                                                      $S27 = Objects::hashCode;
    private static final $Map<String, church.lang.Functions.Function1<Integer, Integer>>                                        $S28 = HashMap.map($S26, $S27);
    private static final $Empty_set<HashMap<String, church.lang.Functions.Function1<Integer, Integer>>>                         $S29 = HashMap.empty_set($S28);
    private static final $Map<String, church.lang.Functions.Function1<Expression<Integer>, Expression<Integer>>>                $S30 = HashMap.map($S26, $S27);
    private static final $Empty_set<HashMap<String, church.lang.Functions.Function1<Expression<Integer>, Expression<Integer>>>> $S31 = HashMap.empty_set($S30);
    private static final $Test0<Integer>                                                                                        $S32 = DerivativeTest.test0($S25, $S29, $S31);

    public static int $div(int x, int y) {
        return $S0.$dof(x, y);
    }

    public static void main(String[] args) {
        $S32.test0(x -> $S19.$sum($S19.$sum($S19.$sum($S23.$pow(x, 3), $S18.$prd($const(2), $S23.$pow(x, 2))), $S18.$prd($const(3), x)), $const(4)), 1, 10);
    }

}