JulioHerrlein

My understanding of what you are trying to do is that you should explore loop, here are few examples which might help you with your work:
 
(loop for i in '(1 4 1 4) when (not (equal 1 i)) counting i) => 2 (loop for i in '(8 6 8 7 4 3 3 6 2 2 9 7) counting (evenp i) into evens counting (oddp i) into odds summing i into total maximizing i into max minimizing i into min finally (return (list min max total evens odds))) => (2 9 65 7 5) (loop for i in '(1 2 3) when (> i 1) return i) => 2 ;;; Position (loop for i in '(1 4 1 4) with cnt = -1 for n = (incf cnt) when (not (equal 1 i)) collect n) => (1 3) (loop for i from 1 to 100 if (evenp i) minimize i into min-even and maximize i into max-even and unless (zerop (mod i 4)) sum i into even-not-fours-total end and sum i into even-total else minimize i into min-odd and maximize i into max-odd and when (zerop (mod i 5)) sum i into fives-total end and sum i into odd-total finally (return (list min-even max-even min-odd max-odd even-total odd-total fives-total even-not-fours-total))) => (2 100 1 99 2550 2500 500 1250) (loop repeat 10 collect (random 10000)) => (4338 3277 1359 1272 3755 711 4365 828 4652 2346) (loop repeat 5 for x = 0 then y for y = 1 then (+ x y) collect y) => (1 2 4 8 16) (loop repeat 5 for y = 1 then (+ x y) for x = 0 then y collect y) => (1 1 2 4 8) (loop repeat 5 for x = 0 then y and y = 1 then (+ x y) collect y) => (1 1 2 3 5) (loop for i in '(1 2 3) when (> i 1) return i) => 2 (loop for i across #(1 2 3) do (print i)) => 1 => 2 => 3 => nil (loop for x from 1 to 3 collect (loop for y from 1 to x collect y)) => ((1) (1 2) (1 2 3)) (loop for x from 1 to 3 for y = (* x 10) collect y) => (10 20 30) (loop repeat 10 for x = (random 100) if (evenp x) collect x into evens else collect x into odds finally (return (values evens odds))) => (52 94 86 50 8 50) => (85 27 1 39) (loop for x in '(1 2 3 4 5) until (> x 3) collect x) => (1 2 3) (loop for x in '(1 2 3 4 5) while (< x 4) do (format t "x is ~a~&" x) collect x) => x is 1 => x is 2 => x is 3 => (1 2 3) (loop named loop-1 for x from 0 to 10 by 2 do (loop for y from 0 to 100 by (1+ (random 3)) when (< x y) do (return-from loop-1 (values x y)))) => 0 => 2 (loop for x in '(foo 2) thereis (numberp x)) => t (loop for x in '(foo 2) never (numberp x)) => nil (loop for x in '(foo 2) always (numberp x)) => nil (loop for i from 1 to 3 count (oddp i)) => 2 (loop for i from 1 to 3 sum i) => 6 (loop for i from 1 to 3 maximize (mod i 3)) => 2 (loop for (a b) in '((x 1) (y 2) (z 3)) collect (list b a)) => ((1 x) (2 y) (3 z)) (loop for (x . y) in '((1 . a) (2 . b) (3 . c)) collect y) => (a b c) ;;; Use nil to ignore a term: (loop for (a nil) in '((x 1) (y 2) (z 3)) collect a) => (x y z) (loop for i upto 10 collect i) => (0 1 2 3 4 5 6 7 8 9 10) (loop for i from 0 downto -10 collect i) => (0 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10) (loop for i in (list 10 20 30 40) collect i) => (10 20 30 40) (loop for i in (list 10 20 30 40) by #'cddr collect i) => (10 30) (loop for x on (list 10 20 30) collect x) => ((10 20 30) (20 30) (30)) (loop for x on (list 10 20 30 40) by #'cddr collect x) => ((10 20 30 40) (30 40))  
Tutorial for the Common Lisp Loop Macro
WWW.AI.SRI.COM  
Loop, iteration, mapping
LISPCOOKBOOK.GITHUB.IO A collection of examples of using Common Lisp  

i've experimented a bit with pitch alignment for controlling harmony, here's what I tried. Hope it could help.
;;; Pich alignment with binaries ;;; Proof of concept (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf pch '(c4 d4 e4 f4 g4 a4 b4 c5 b4 a4 g4 f4 e4 d4 c4)) (setf pch1 (binary-map bin1 pch)) (setf pch2 (binary-map bin2 pch)) (setf pch3 (binary-map bin3 pch)) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :fl (list omn2) :fl (list omn3)) ) ;;; Now with intervals (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf pch '(c4 d4 e4 f4 g4 a4 b4 c5 b4 a4 g4 f4 e4 d4 c4)) (setf pch1 (binary-map bin1 pch)) (setf pch2 (binary-map bin2 (pitch-transpose-n '(-4 -3 -7) pch1))) (setf pch3 (binary-map bin3 (pitch-transpose-n '(-17 -20 -19) pch1))) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :cl (list omn2) :bn (list omn3)) ) ;;; Pitch generation from choral with 7th chords (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf chords (gen-chord3 '(d3 f3 e3 a3) '((10 16)))) (setf cpch1 (pitch-demix 1 chords)) (setf cpch2 (pitch-demix 2 chords)) (setf cpch3 (pitch-demix 3 chords)) (setf pch1 (binary-map bin1 cpch1)) (setf pch2 (binary-map bin2 cpch2)) (setf pch3 (binary-map bin3 cpch3)) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :cl (list omn2) :bn (list omn3)) ) ;;; Same as above but with chord change only on every bar (progn (setf lvl (rnd-sample 8 '(8 12 16))) (setf len1 (euclidean-rhythm lvl 1 12 's)) (setf len2 (euclidean-rhythm lvl 1 12 's)) (setf len3 (euclidean-rhythm lvl 1 12 's)) (setf bin1 (length-to-binary len1)) (setf bin2 (length-to-binary len2)) (setf bin3 (length-to-binary len3)) (setf chords (gen-chord3 '(d3 f3 e3 a3) '((10 16)))) (setf cpch1 (mclist (pitch-demix 1 chords))) (setf cpch2 (mclist (pitch-demix 2 chords))) (setf cpch3 (mclist (pitch-demix 3 chords))) (setf pch1 (binary-map bin1 cpch1)) (setf pch2 (binary-map bin2 cpch2)) (setf pch3 (binary-map bin3 cpch3)) (setf omn1 (make-omn :pitch pch1 :length len1)) (setf omn2 (make-omn :pitch pch2 :length len2)) (setf omn3 (make-omn :pitch pch3 :length len3)) (ps 'gm :fl (list omn1) :cl (list omn2) :bn (list omn3)) ) SB.

Exactly, Stephane !!
 
This is precisely the way I´m working.
I´d like to share with you in the forum the complete process for generating the score.
Goes like this:
And with this new function it will became easier !!
Best,
Julio
 
;;; Julio Herrlein ;;;Compositional Process - String Quartet ;;; CHORALE - MIDI GUITAR RECORDED (progn (setf pitmidi2 '(a3b3e4ab4 gs3ds4g4bb4 cs3a3b3e4 gs2f3as3d4)) (assign-variable 'ch pitmidi2) ;;;FASTER PITCH-DEMIX using Array (setf chordarray (build-array (sort-desc (melodize (mclist pitmidi2))))) (setf size (get-count pitmidi2)) ;;; v1rp - repeating 16 notes (setf chrptimes '(16)) (assign-variable 'v1rp (gen-repeat chrptimes (mclist (get-array 0 0 size chordarray :direction 'down)))) (assign-variable 'v2rp (gen-repeat chrptimes (mclist (get-array 0 1 size chordarray :direction 'down)))) (assign-variable 'v3rp (gen-repeat chrptimes (mclist (get-array 0 2 size chordarray :direction 'down)))) (assign-variable 'v4rp (gen-repeat chrptimes (mclist (get-array 0 3 size chordarray :direction 'down)))) ;;; repeating notes material ;;; VOZ 1 a 4 (setf vrpt1 '(v1rp0 v1rp1 v1rp2 v1rp3)) (setf vrpt2 '(v2rp0 v2rp1 v2rp2 v2rp3)) (setf vrpt3 '(v3rp0 v3rp1 v3rp2 v3rp3)) (setf vrpt4 '(v4rp0 v4rp1 v4rp2 v4rp3)) ;;;MELODIC MATERIAL - arpeggios or custom material ;;VL 1 (assign-variable 'melch1- (gen-repeat '(4) (ambitus-octaves 'e4 1 (pitch-rotate 1 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml1 '(melch1-0 melch1-1 melch1-2 melch1-3)) ;;VL 2 (assign-variable 'melch2- (gen-repeat '(4) (ambitus-octaves 'e3 1 (pitch-rotate 0 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml2 '(melch2-0 melch2-1 melch2-2 melch2-3)) ;; VIOLA (assign-variable 'melch3- (gen-repeat '(4) (ambitus-octaves 'e3 1 (pitch-rotate -2 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml3 '(melch3-0 melch3-1 melch3-2 melch3-3)) ;; CELLO (assign-variable 'melch4- (gen-repeat '(4) (ambitus-octaves 'e2 1 (pitch-rotate -1 (melodize (gen-divide 1 (list ch0 ch1 ch2 ch3))))))) (setf vml4 '(melch4-0 melch4-1 melch4-2 melch4-3)) ;;; MIXING LISTS (repeated notes and melodic fragments) (setf list1 vrpt1) (setf list1b vml1) (setf v1dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list1 list1b)))))) (setf list2 vrpt2) (setf list2b vml2) (setf v2dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list2 list2b)))))) (setf list3 vrpt3) (setf list3b vml3) (setf v3dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list3 list3b)))))) (setf list4 vrpt4) (setf list4b vml4) (setf v4dt (gen-divide '(16) (flatten (apply-eval (matrix-transpose (list list4 list4b)))))) ;;; Length Map atualizado - 8 FEV (setf len-map1 '((e (stacc)) (s (ord)) (h (long)) (h. (long)) (w (long)))) (setf len-map2 '((e (list (rnd-pick '(mf f)))) (s (mf)) (e. (mf)) (h (p<f)) (h. (p<f)) (w (P<f>p))(wq (P<f>p))(wh (P<f>p))(wh. (P<f>p))(ww (P<f>p)))) ;;;RITMOS ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; 12 mar B (setf rv1 (gen-repeat 5 (gen-divide '(3 7) (gen-repeat 5 '(q e. s s s s s h_e s s))))) (setf rv2 (gen-repeat 5 (gen-divide '(2) (gen-repeat 5 '(-e eh -e eh))))) (setf rv3 (gen-repeat 5 (gen-divide '(2) (gen-repeat 5 '(-q qq -q qq))))) (setf rv4 (gen-repeat 5 (gen-divide '(2) (gen-repeat 5 '(-q. eq -q. eq))))) (setf timesig '(6 4 1)) (setf timesigs '((6 4 1) (6 4 1))) (setf timesig-proc (butlast (gen-divide 3 (span (flatten v1dt) timesigs)))) ) ;;;FINAL DO PROGN INITIALIZE ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;BUG TRACKING #3 11 mar ;;; Mudando o :span de :pitch para :length, ;;faz com que cada vez que recomeça a lista de length os acordes partem do início;;isso pode ser interessante e os ritmos estão com o comportamento esperado (progn ;(setf timesig '(6 4 1)) (setf vh1-2 (make-omn :length rv1 :pitch (span rv1 v1dt) :span :length :velocity (length-map len-map2 rv1 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv1 :otherwise '(ord) :repeat t))) (setf vh2-2 (make-omn :length rv2 :pitch (span rv2 v2dt) :span :length :velocity (length-map len-map2 rv2 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv2 :otherwise '(ord) :repeat t))) (setf vh3-2 (make-omn :length rv3 :pitch (span rv3 v3dt) :span :length :velocity (length-map len-map2 rv3 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv3 :otherwise '(ord) :repeat t))) (setf vh4-2 (make-omn :length rv4 :pitch (span rv4 v4dt) :span :length :velocity (length-map len-map2 rv4 :otherwise '(mf) :repeat t) :articulation (length-map len-map1 rv4 :otherwise '(ord) :repeat t))) (ps 'gm :sq ;(list (pitch-transpose 12 vh1-2) vh2-2 vh3-2 vh4-2) (list (pitch-transpose 12 (ambitus 'violin vh1-2)) (ambitus 'violin vh2-2) (ambitus 'viola vh3-2) (ambitus 'cello vh4-2)) :key-signature 'atonal ;;;obs: abrindo o time sig aqui, faz bypass do omn-to-time-signature acima :time-signature timesig-proc ;time-signature timesig :tempo 80 :title "STR 4tet" :display :window)) ;;;>>>>>>>>>>>>> F I N A L <<<<<<<<<<<<<<<<< ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ;;;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>  

There are some comments in portuguese...
Maybe I´ll do a video about it, later.
Now, I´m in the process of composition.
Thanks to the forum where I learned the stuff.
This is my modest contribution. Hope it can help someone to work out things in Opusmodus.
 

Only Janusz can do such a function but indeed I think something like that could be useful for controlling vertical intervalic harmony between multiple voices coming from and already generated chord canevas and extracted with pitch-demix or similar function.
 
 
S.

Julio, you need to do that before and not in the make-omn.

What about this:
 
(setf pitchlist '((c4 d4 e4 f4)(cs4 ds4 as4 fs4)(bb4 eb4 ab4)))
(setf rhy '((s s s)(s s) nil (s s s)(s s)(s s)))
(remove-nils (gen-swallow  rhy pitchlist))
=> ((c4 d4 e4) (cs4 ds4) (c4 d4 e4) (cs4 ds4) (bb4 eb4))

You saved me from the bullets

You saved me from the bullets

(setf list1 '(v1rp0 v1rp1 v1rp2 v1rp3 v1rp4)) (setf list2 '(melch1-0 melch1-1 melch1-2 melch1-3 melch1-4)) (matrix-transpose (list list1 list2)) => ((v1rp0 melch1-0) (v1rp1 melch1-1) (v1rp2 melch1-2) (v1rp3 melch1-3) (v1rp4 melch1-4))  
or
(setf mat1 '((c4 db4) (ab4 f4) (g4 bb4) (a4 eb4) (b4 e4) (d4 gb4))) (setf mat2 '((db4 ab4) (f4 g4) (bb4 a4) (eb4 b4) (e4 d4) (gb4 c4))) (gen-mix mat1 mat2) => ((c4 db4) (db4 ab4) (ab4 f4) (f4 g4) (g4 bb4) (bb4 a4)     (a4 eb4) (eb4 b4) (b4 e4) (e4 d4) (d4 gb4) (gb4 c4))  

Hi Julio,
 
use assign-variable function.
 
 
S.

(setf mat0 '(c4 d4 cs5)) (setf mat1 '(c4 db4 ds7)) (setf mat2 '(d4 e4 c5)) (setf mat3 '(d4 eb4 cs5)) (setf mat4 '(d4 f4 c5)) (setf mat5 '(d4 g4 c5)) (setf mat6 '(d4 a4 c5)) (setf mat7 '(e4 a4 c5)) (setf mat8 '(f4 a4 c5)) (setf mat9 '(g4 a4 c5)) (setf mat10 '(a4 a4 c5)) (setf mat11 '(b4 a4 c5)) (setf array (build-array (list (assemble-seq mat0 mat1 mat2 mat3) (assemble-seq mat4 mat5 mat6 mat7) (assemble-seq mat8 mat9 mat10 mat11)))) (get-array 0 1 2 array :direction 'down) => ((c4 db4 ds7) (d4 g4 c5))
In your variables mat0 was missing.

The function LENGTH-DIVIDE and friends are a useful device for introducing some rhythmic variation to some material. However, when the processed sequence is a full OMN expression (see example below), then the added notes cause all other parameters to shift forward (additional parameters are added at the end by looping). For introducing only a slight variation to some existing material (e.g., motif) these functions are therefore not so useful, because this shift of all parameters to basically "fill" the new added notes with pitches etc. greatly change the varied material for a listener.
(length-divide 1 2 '(q f3 leg+m1 q ab3 leg e c4 leg bb3 leg ab3 leg g3))  
Basically, this is the opposite situation of the situation addressed by swallowing. Swallowing (e.g., with GEN-SWALLOW and the swallow argument of many other functions) avoids the shift of parameters like pitch etc. that would result from removing notes and turning them into rests. For addressing the situation above properly we would need something like the opposite of swallowing, some way to fill in parameters like pitch etc. for new notes to avoid shifting existing notes. I hope my explanation makes sense and you can see why something like the opposite of swallowing would be useful for functions that add notes to some input material.
 
Now, the tricky question is of course, what parameters (pitch etc.) should be added in such cases. Musically useful and common in the classical literature would be, e.g., repeating the parameters (pitch etc.) of the predecessor note (though that might be a bit too simplistic and annoying at times) or somehow interpolating some pitch gap between the previous and next note with a little scale or arpeggio and only repeating the other parameters like articulations (resulting in some variation that is likely most similar to the input material, so it would be good to have that as an option).  If the pitch interval between the two original notes is too small to add some pitch in between for the new now (or as an option in general for variety), it would also be good  to add some ornamentation (e.g., using PITCH-ORNAMENT), but for a close similarity between the original material and the variation it would be best as an option to apply such ornamentation only to the newly added notes, not all notes. Of course, other options could also be useful for variations that vary the input material a bit more strongly, e.g., some random pitch for the new notes within certain interval bounds.
 
Does some function that kind of is the opposite of GEN-SWALLOW in that it adds parameters like pitches for subdivided rhythmic values (to avoid the shifting) sound like a good idea?
 
The idea with the interpolation of gaps could be implemented by turning the original duration values and pitches into some envelope and then reading that envelope with the new rhythmic values. So, that is rather strait forward. However, that would not allow for some ornamentation, because such algorithm would not recognise which notes are new that should be ornamented.
 
Any other idea perhaps? Thanks! 

Hi Julio,
 
I've watched the video above, from 1'28 and then decide to make a small gif to make the point& click feature more clear:
 
best!
 
ole

With OMN-DICTUM you are able to edit and make any correction into your score.

Depends on what you want to do with the generated material.
Useful function:
unfold, omn-dictum, find-bar, position-item, position-replace, position-swap
 
Many functions allow you to edit selected bars:
:section (numbers)
 
(pprint-last-score) could help as well with bar numbers.
 
Enable 'Bar Number Display' in the Preferences/Notation

Thanks so much, Julio. This is very helpful! I also appreciate you sharing your dissertation.
-Zvony

Are you sure that your MuseScore lives in /Applications and is named 'MuseScore' and not 'Musescore 3' (or 'MuseScore 2' as your screenshot suggests)?
Maybe you need to change :
"/Applications/MuseScore.app" into
"/Applications/MuseScore\3.app"  
 
Don't know what you are after exactly, but when I evaluate ps (with the numerical enter key) and  then call (last-score-to-musescore), ms opens that last evaluated score (btw you can look at the score by using the (rightclick-) context menu/ PPrint last Score, then it displays in the listener..)

Hi Julio,
 
For me it works like this:
(defun last-score-to-musescore ()   (compile-score *last-score* :output :musicxml :file "temp-last-score")   (musicxml-to-editor "temp-last-score" :application "/Applications/MuseScore.app"))  
in the extensions folder and then calling:
(last-score-to-musescore)  
It was shown in the forum long time ago, you can do a research..
 
hth
 
ole

I discovered today that you can use just length-diminution to expand OR contract rhythms, just by using fractions. You can use ti to make some proportional metric modulation stuff.
 
Here are some examples. 
ORIGINAL
(length-diminution 1/1 '(q e e e e s s s s))

CONTRACT
(length-diminution 2/1 '(q e e e e s s s s))

EXPAND
(length-diminution 1/2 '(q e e e e s s s s))

 
(length-diminution 1/3 '(q e e e e s s s s))

(length-diminution 3/2 '(q e e e e s s s s))
 

 
(length-diminution 3/4 '(q e e e e s s s s))

 
And so on !!
This is cool !
Best,
Julio
 

What is also very cool, you can choose for every bar another value 🙂
(length-diminution '(2/1 1/2 1/3 2/3 3/4) (gen-repeat 5 (list '(q e e e e s s s s))))  

Cool indeed !
 
Thanks for the trick !
 
S.

I discovered today that you can use just length-diminution to expand OR contract rhythms, just by using fractions. You can use ti to make some proportional metric modulation stuff.
 
Here are some examples. 
ORIGINAL
(length-diminution 1/1 '(q e e e e s s s s))

CONTRACT
(length-diminution 2/1 '(q e e e e s s s s))

EXPAND
(length-diminution 1/2 '(q e e e e s s s s))

 
(length-diminution 1/3 '(q e e e e s s s s))

(length-diminution 3/2 '(q e e e e s s s s))
 

 
(length-diminution 3/4 '(q e e e e s s s s))

 
And so on !!
This is cool !
Best,
Julio
 

I discovered today that you can use just length-diminution to expand OR contract rhythms, just by using fractions. You can use ti to make some proportional metric modulation stuff.
 
Here are some examples. 
ORIGINAL
(length-diminution 1/1 '(q e e e e s s s s))

CONTRACT
(length-diminution 2/1 '(q e e e e s s s s))

EXPAND
(length-diminution 1/2 '(q e e e e s s s s))

 
(length-diminution 1/3 '(q e e e e s s s s))

(length-diminution 3/2 '(q e e e e s s s s))
 

 
(length-diminution 3/4 '(q e e e e s s s s))

 
And so on !!
This is cool !
Best,
Julio
 

Please to hear 🙂