dtr(ndtr(Q),A,C) --> [npnTr(Q,A,C,A)].
dtr(pdtr(Q),A,C) --> [pnpTr(Q,C,A,C)].

res(X,A,B) --> [resistor(X,A,B)].
res(X,A,B) --> [resistor(X,B,A)].

vbeReg(vreg(D,R),Vp,Com,Out) --> dtr(D,Out,Com),
                                 res(R,Vp,Out).

cSink(sink(VR,Q),In,Com) --> vbeReg(VR,_,Com,B),
                             [npnTr(Q,B,Com,In)].

cSink(sink(VR,Q),In,Com) --> test(vbeReg(VR,_,Com,B)),
                             [npnTr(Q,B,Com,In)].

eCoupledPair(ecup(Q1,Q2),B1,B2,E,C1,C2) -->
                             [npnTr(Q1,B1,E,C1)],
                             [npnTr(Q2,B2,E,C2)].

activeLoad(al(D,Q),Ref,Vp,Ld) -->
                             dtr(D,Vp,Ref),
                             [pnpTr(Q,Ref,Vp,Ld)].

sDiffAmp(sdAmp(EC,AL,CS),B1,B2,C1,Vp,Vm) -->
                             eCoupledPair(EC,B1,B2,E,C1,C2),
                             activeLoad(AL,C2,Vp,C1),
                             cSink(CS,E,Vm).

commonEmitter(pnpCE(Q,CS),In,Out,Vp,Vm) -->
                             [pnpTr(Q,In,Vp,Out)],
                             cSink(CS,Out,Vm).

emitterFollower(npnEF(Q,R),In,Out,Vp,Vm) -->
                             [npnTr(Q,In,Out,Vp)],
                             res(R,Out,Vm).

opAmp(opAmp1(DA,CE,EF),In1,In2,Out,Vp,Vm) -->
                             sDiffAmp(DA,In1,In2,O1,Vp,Vm),
                             commonEmitter(CE,O1,O2,Vp,Vm),
                             emitterFollower(EF,O2,Out,Vp,Vm),
                             [terminal(T1,In1)],
                             [terminal(T2,In2)],
                             [terminal(T3,Out)],
                             [terminal(T4,Vp)],
                             [terminal(T5,Vm)].
cap(X,A,B) --> [capacitor(X,A,B)].
cap(X,A,B) --> [capacitor(X,B,A)].

lowpassFilter(lpf(X),A,B) --> cap(X,A,B).

cSink(sink2(VS,Q,R),In,Com) --> [npnTr(Q,B,E,In)],
                                res(R,E,Com),
                                vSource(VS,B,Com).

activeLoad(al2(D,Q1,Q2),Ref,Vp,Ld) -->
                             dtr(D,Vp,B),
                             [pnpTr(Q1,B,Vp,Ref)],
                             [pnpTr(Q2,Ref,B,Ld)].

sDiffAmp(sdAmp2(EC,R,CS),B1,B2,C1,Vp,Vm) -->
                             eCoupledPair(EC,B1,B2,E,C1,Vp),
                             res(R,Vp,C1),
                             cSink(CS,E,Vm).

commonEmitter(pnpCE2(Q,R),In,Ot,Vp,Vm) -->
                             [pnpTr(Q,In,Vp,Ot)],
                             res(R,Ot,Vm).

levelshiftEF(lsEF(Q,LS,CS),In,Ot,Vp,Vm) -->
                             [npnTr(Q,In,E,Vp)],
                             seriesRD(LS,E,Ot),
                             cSink(CS,Ot,Vm).

dBalanceDA(dbda(AL,Ec1,Ec2,Ec,CS),B1,B2,D1,D2,C2,Vp,Vm) -->
                             activeLoad(AL,C1,Vp,C2),
                             eCoupledPair(Ec1,D1,D2,E1,C1,C2),
                             eCoupledPair(Ec2,D2,D1,E2,C1,C2),
                             eCoupledPair(Ec,B1,B2,E,E1,E2),
                             cSink(CS,E,Vm).

multiBiasVsource(mvbs(R1,E2,R3,Q1,Q2),Vp,V1,V2,V3,V4,Vm) -->
                             [npnTr(Q1,V3,V4,Vp)],
                             [npnTr(Q2,V4,Vm,V3)],
                             res(R3,V2,V3),
                             res(R2,V1,V2),
                             res(R1,Vp,V1).
                             
vSource(VS,V,Com) --> mvSource(VS,V,Com).
vSource(VS,V,Com) --> test(mvSource(VS,V,Com)).

mvSource(mbv1(MB),V,Com) --> multiBiasVsource(MB,_,V,_,_,_,Com).
mvSource(mbv2(MB),V,Com) --> multiBiasVsource(MB,_,_,V,_,_,Com).
mvSource(mbv3(MB),V,Com) --> multiBiasVsource(MB,_,_,_,V,_,Com).
mvSource(mbv4(MB),V,Com) --> multiBiasVsource(MB,_,_,_,_,V,Com).

phaseDetector(pdet(DA,R1,R2,VS1,VS2,RL,R3,R4),In1,In2,Ot,Vp,Vm) -->
                             dBalanceDA(DA,In1,B2,BB1,In2,Ot,Vp,Vm),
                             res(R1,In1,V2),
                             res(R2,B2,V2),
                             vSource(VS1,BB1,Vm),
                             vSource(VS2,V2,Vm),
                             res(RL,Ot,V3),
                             res(R3,Vp,V3),
                             res(R4,V3,Vm).

voltageCurrentConverter(vcc(VV,Q,R),In,Sink,Vp,Vm) -->
                             vvConverter(VV,In,B,Vp,Vm),
                             [npnTr(Q,B,E,Sink)],
                             res(R,E,Vm).

vvConverter(vv(D1,D2,Q1,Q2,Q3,Q4,R1,R2,R3),In,Ot,Vp,Vm) -->
                             dtr(D1,In,B),
                             dtr(D2,B,In),
                             [pnpTr(Q1,B,E,C)],
                             [npnTr(Q2,C,Ot,A)],
                             [npnTr(Q3,B,A,Vp)],
                             [npnTr(Q4,Ot,D,E)],
                             res(R1,Vp,E),
                             res(R2,E,Vm),
                             res(R3,Ot,Vm),
                             res(R4,D,Vm).

vctrlChargeDischarge(vccd(VC,EC,AL,C,VS),I1,I2,Ot,Vp,Vm) -->
                             voltageCurrentConverter(VC,I1,E,Vp,Vm),
                             eCoupledPair(EC,I2,B2,E,C1,Ot),
                             activeLoad(AL,C1,Vp,Ot),
                             cap(C,Ot,Vm),
                             vSource(VS,B2,Vm).

schmitTrig(strig(EF,DA,CE,Q,R1,R2,R3),In,Ot,Vp,Vm) -->
                             sDiffAmp(DA,B1,Ot,C1,Vp,Vm),
                             levelshiftEF(EF,In,B1,Vp,Vm),
                             commonEmitter(CE,C1,C2,Vp,Vm),
                             [npnTr(Q,C2,Vm,C3)],
                             res(R1,C3,Vm),
                             res(R2,Ot,C3),
                             res(R3,Vp,Ot).

voltageControledOsc(vco(CD,TRIG),In,Ot,Vp,Vm) -->
                             vctrlChargeDischarge(CD,In,Ot,O1,Vp,Vm),
                             schmitTrig(TRIG,O1,Ot,Vp,Vm).

phaseLockedLoop(pll(PD,LPF,VCO),In,Ot,Vp,Vm) -->
                             phaseDetector(PD,In,Ot,O1,Vp,Vm),
                             lowpassFilter(LPF,O1,Vm),
                             voltageControledOsc(VCO,O1,Ot,Vp,Vm),
                             [terminal(T1,In)],
                             [terminal(T2,Ot)],
                             [terminal(T3,Vp)],
                             [terminal(T4,Vm)].

seriesRD(X,A,C) --> resDtr(X,A,C).
seriesRD(srd(X,Y),A,C) --> resDtr(X,A,B),
                           seriesRD(Y,B,C).

resDtr(X,A,C) --> res(X,A,C).
resDtr(X,A,C) --> dtr(X,A,C).