(define (stream-car x) (stream-first x))
(define (stream-cdr x) (stream-rest x))

(define (integers-starting-from n)
  (stream-cons n
               (integers-starting-from (+ n 1))))
(define integers (integers-starting-from 1))

(define (merge-weighted s1 s2 weight)
  (cond ((stream-empty? s1) s2)
        ((stream-empty? s2) s1)
        (else (let ((x1 (stream-car s1))
                    (x2 (stream-car s2)))
                (if (<= (weight x1) (weight x2))
                    (stream-cons x1 (merge-weighted (stream-cdr s1) s2 weight))
                    (stream-cons x2 (merge-weighted s1 (stream-cdr s2) weight)))))))



(define (weighted-pairs s t weight)
  (stream-cons
   (cons (stream-car s) (stream-car t))
   (merge-weighted
    (stream-map (lambda (x) (cons (stream-car s) x))
                (stream-cdr t))
    (weighted-pairs (stream-cdr s) (stream-cdr t) weight) weight)))

(define (sum-of-cube x)
  (let ((i (car x)) (j (cdr x)))
    (+ (* i i i) (* j j j))))

(define sorted-pairs
  (weighted-pairs integers integers
                  sum-of-cube))

(define sum-stream
  (stream-map sum-of-cube sorted-pairs))

(define (combine-streams s1 s2)
  (stream-cons (cons (stream-car s1) (stream-car s2))
               (combine-streams (stream-cdr s1) (stream-cdr s2))))

(define ramanujan-numbers
  (stream-map (lambda (x) (cdr x))
              (stream-filter (lambda (x) (= (sum-of-cube (car x)) (cdr x)))
                             (combine-streams sorted-pairs (stream-cdr sum-stream)))))