Event-Driven Architecture

1
2
3
4

뉴스 구독 시스템:
- Publisher: 뉴스 에디터
- Topic: "스포츠", "정치", "경제"
- Subscriber: 모바일 앱, 웹사이트, 이메일 서비스

1
2
3

주문 처리 시스템:
- Command: 주문 생성, 수정, 취소
- Query: 주문 조회, 통계, 리포트

1
2
3

온라인 쇼핑 주문 처리:
1. 재고 확인 → 2. 결제 처리 → 3. 배송 준비
실패 시: 보상 액션으로 이전 단계 롤백

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

// Node.js를 사용한 브로커 토폴로지 구현
const EventEmitter = require('events');

class EventBroker extends EventEmitter {
    constructor() {
        super();
        this.processors = [];
    }
    
    registerProcessor(processor) {
        this.processors.push(processor);
    }
    
    publishEvent(eventType, eventData) {
        console.log(`Publishing event: ${eventType}`);
        this.emit(eventType, eventData);
    }
}

class OrderProcessor {
    constructor(broker) {
        this.broker = broker;
        this.broker.on('orderPlaced', this.handleOrderPlaced.bind(this));
    }
    
    handleOrderPlaced(orderData) {
        console.log(`Processing order: ${orderData.orderId}`);
        // 주문 처리 로직
        this.broker.publishEvent('orderProcessed', {
            orderId: orderData.orderId,
            status: 'processed'
        });
    }
}

// 사용 예시
const broker = new EventBroker();
const orderProcessor = new OrderProcessor(broker);

broker.publishEvent('orderPlaced', { orderId: '12345', amount: 100 });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

// 중재자 토폴로지 구현
class EventMediator {
    constructor() {
        this.workflows = new Map();
        this.processors = new Map();
    }
    
    registerWorkflow(eventType, steps) {
        this.workflows.set(eventType, steps);
    }
    
    registerProcessor(processorType, processor) {
        this.processors.set(processorType, processor);
    }
    
    async processEvent(eventType, eventData) {
        const workflow = this.workflows.get(eventType);
        if (!workflow) {
            throw new Error(`No workflow found for event type: ${eventType}`);
        }
        
        const context = { …eventData, steps: [] };
        
        for (const step of workflow) {
            try {
                const processor = this.processors.get(step.processorType);
                const result = await processor.process(step, context);
                context.steps.push({ step: step.name, result, status: 'success' });
            } catch (error) {
                context.steps.push({ step: step.name, error, status: 'failed' });
                await this.handleFailure(workflow, context, step);
                break;
            }
        }
        
        return context;
    }
    
    async handleFailure(workflow, context, failedStep) {
        // 보상 트랜잭션 실행
        const completedSteps = context.steps.filter(s => s.status === 'success');
        for (const completedStep of completedSteps.reverse()) {
            try {
                const processor = this.processors.get(completedStep.processorType);
                await processor.compensate(completedStep, context);
            } catch (compensationError) {
                console.error('Compensation failed:', compensationError);
            }
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "event_id": "abc-001",
  "event_type": "InventoryAdjusted",
  "occurred_at": "2025-07-17T14:00:00Z",
  "payload": {
    "sku": "ITEM-100",
    "change": -2,
    "reason": "OrderFulfilled"
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

{
  "event_id": "def-101",
  "event_type": "UserRegistered",
  "occurred_at": "2025-07-17T14:00:00Z",
  "payload": {
    "user_id": "U123",
    "email": "user@example.com",
    "name": "Lee HyunYoon"
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

// orderService.js
const { Kafka } = require('kafkajs');
const kafka = new Kafka({ brokers: ['localhost:9092'] });
const producer = kafka.producer();

async function createOrder(order) {
  await producer.send({
    topic: 'order.created',
    messages: [{ key: order.id, value: JSON.stringify(order) }]
  });
  console.log(`Order event published: ${order.id}`);
}

module.exports = { createOrder };

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// paymentService.js
const { Kafka } = require('kafkajs');
const kafka = new Kafka({ brokers: ['localhost:9092'] });
const consumer = kafka.consumer({ groupId: 'payment-service' });
const producer = kafka.producer();

async function start() {
  await consumer.connect();
  await consumer.subscribe({ topic: 'order.created' });
  await producer.connect();

  await consumer.run({
    eachMessage: async ({ message }) => {
      const order = JSON.parse(message.value.toString());
      // 결제 처리 로직
      const paymentResult = { orderId: order.id, status: 'PAID' };
      await producer.send({
        topic: 'order.paid',
        messages: [{ key: order.id, value: JSON.stringify(paymentResult) }]
      });
      console.log(`Payment processed for order ${order.id}`);
    },
  });
}

start().catch(console.error);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

# 이벤트 브로커 클래스
class EventBroker:
    def __init__(self):
        self.subscribers = {}

    def subscribe(self, event, callback):
        if event not in self.subscribers:
            self.subscribers[event] = []
        self.subscribers[event].append(callback)

    def publish(self, event, data):
        if event in self.subscribers:
            for callback in self.subscribers[event]:
                callback(data)

# 이벤트 발행자(주문 서비스)
def order_service(broker):
    broker.publish('order', {'order_id': 123, 'product': 'Laptop'})

# 이벤트 소비자(결제, 배송, 알림 서비스)
def payment_service(data):
    print('결제 처리:', data)
def delivery_service(data):
    print('배송 처리:', data)
def notification_service(data):
    print('알림 처리:', data)

# 브로커 생성
broker = EventBroker()
broker.subscribe('order', payment_service)
broker.subscribe('order', delivery_service)
broker.subscribe('order', notification_service)

# 이벤트 발행
order_service(broker)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

# requirements: confluent-kafka==2.0.0
from confluent_kafka import Producer, Consumer, KafkaException
import json, time

# 1. 프로듀서 설정 및 이벤트 발행
producer_conf = {'bootstrap.servers': 'kafka:9092'}
producer = Producer(producer_conf)

def publish_order(order):
    producer.produce('OrderCreated', json.dumps(order).encode('utf-8'))
    producer.flush()

# 2. 컨슈머 설정 및 이벤트 처리
consumer_conf = {
    'bootstrap.servers': 'kafka:9092',
    'group.id': 'inventory-service',
    'auto.offset.reset': 'earliest'
}
consumer = Consumer(consumer_conf)
consumer.subscribe(['OrderCreated'])

def process_inventory():
    while True:
        msg = consumer.poll(1.0)
        if msg is None: continue
        if msg.error():
            print(f"Error: {msg.error()}")
            continue
        event = json.loads(msg.value().decode('utf-8'))
        print(f"InventoryService 처리 중: 주문ID={event['order_id']}")
        # 실제 재고 검사/예외 시 DLQ logic
        time.sleep(0.1)

if __name__ == "__main__":
    import threading
    threading.Thread(target=process_inventory, daemon=True).start()
    # 예시 주문 발행
    for i in range(5):
        publish_order({'order_id': i, 'item': f'product_{i}', 'qty': i*2})
        time.sleep(0.5)

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370

"""
Event-Driven Architecture 구현 예시
Netflix 스타일 콘텐츠 추천 시스템
"""

import asyncio
import json
from datetime import datetime
from typing import Dict, List, Optional, Callable
from dataclasses import dataclass, asdict
from abc import ABC, abstractmethod
import uuid

# ============================================================================
# 1. 이벤트 정의 (Event Definitions)
# ============================================================================

@dataclass
class Event:
    """기본 이벤트 클래스"""
    event_id: str
    event_type: str
    timestamp: datetime
    user_id: str
    data: Dict
    
    def to_json(self) -> str:
        """이벤트를 JSON으로 직렬화"""
        event_dict = asdict(self)
        event_dict['timestamp'] = self.timestamp.isoformat()
        return json.dumps(event_dict)
    
    @classmethod
    def from_json(cls, json_str: str) -> 'Event':
        """JSON에서 이벤트 역직렬화"""
        data = json.loads(json_str)
        data['timestamp'] = datetime.fromisoformat(data['timestamp'])
        return cls(**data)

@dataclass
class UserViewEvent(Event):
    """사용자 시청 이벤트"""
    def __init__(self, user_id: str, content_id: str, duration: int, rating: Optional[float] = None):
        super().__init__(
            event_id=str(uuid.uuid4()),
            event_type="user_view",
            timestamp=datetime.now(),
            user_id=user_id,
            data={
                "content_id": content_id,
                "duration": duration,
                "rating": rating
            }
        )

@dataclass
class ContentRecommendationEvent(Event):
    """콘텐츠 추천 이벤트"""
    def __init__(self, user_id: str, recommendations: List[str]):
        super().__init__(
            event_id=str(uuid.uuid4()),
            event_type="content_recommendation",
            timestamp=datetime.now(),
            user_id=user_id,
            data={
                "recommendations": recommendations
            }
        )

# ============================================================================
# 2. 이벤트 브로커 (Event Broker)
# ============================================================================

class EventBroker:
    """이벤트 브로커 - 이벤트 라우팅 및 전달 담당"""
    
    def __init__(self):
        self.subscribers: Dict[str, List[Callable]] = {}
        self.event_store: List[Event] = []
    
    async def publish(self, event: Event) -> None:
        """이벤트 발행"""
        # 이벤트 저장 (Event Sourcing)
        self.event_store.append(event)
        
        # 구독자들에게 이벤트 전달
        if event.event_type in self.subscribers:
            tasks = []
            for handler in self.subscribers[event.event_type]:
                tasks.append(self._safe_handle(handler, event))
            
            if tasks:
                await asyncio.gather(*tasks, return_exceptions=True)
    
    def subscribe(self, event_type: str, handler: Callable) -> None:
        """이벤트 구독"""
        if event_type not in self.subscribers:
            self.subscribers[event_type] = []
        self.subscribers[event_type].append(handler)
    
    async def _safe_handle(self, handler: Callable, event: Event) -> None:
        """안전한 이벤트 핸들러 실행"""
        try:
            if asyncio.iscoroutinefunction(handler):
                await handler(event)
            else:
                handler(event)
        except Exception as e:
            print(f"이벤트 처리 오류: {e}")
    
    def get_events_by_user(self, user_id: str) -> List[Event]:
        """사용자별 이벤트 조회"""
        return [event for event in self.event_store if event.user_id == user_id]
    
    def get_events_by_type(self, event_type: str) -> List[Event]:
        """타입별 이벤트 조회"""
        return [event for event in self.event_store if event.event_type == event_type]

# ============================================================================
# 3. 이벤트 컨슈머 (Event Consumers)
# ============================================================================

class EventConsumer(ABC):
    """이벤트 컨슈머 기본 클래스"""
    
    def __init__(self, broker: EventBroker):
        self.broker = broker
        self.register_handlers()
    
    @abstractmethod
    def register_handlers(self) -> None:
        """이벤트 핸들러 등록"""
        pass

class RecommendationService(EventConsumer):
    """추천 서비스 - 사용자 시청 이벤트를 기반으로 추천 생성"""
    
    def __init__(self, broker: EventBroker):
        self.user_preferences: Dict[str, Dict] = {}
        self.content_database = {
            "movie_1": {"genre": "action", "rating": 4.5},
            "movie_2": {"genre": "comedy", "rating": 4.2},
            "movie_3": {"genre": "action", "rating": 4.7},
            "movie_4": {"genre": "drama", "rating": 4.3},
            "movie_5": {"genre": "comedy", "rating": 4.1}
        }
        super().__init__(broker)
    
    def register_handlers(self) -> None:
        """이벤트 핸들러 등록"""
        self.broker.subscribe("user_view", self.handle_user_view)
    
    async def handle_user_view(self, event: Event) -> None:
        """사용자 시청 이벤트 처리"""
        user_id = event.user_id
        content_id = event.data["content_id"]
        duration = event.data["duration"]
        rating = event.data.get("rating")
        
        # 사용자 선호도 업데이트
        self._update_user_preferences(user_id, content_id, duration, rating)
        
        # 새로운 추천 생성
        recommendations = self._generate_recommendations(user_id)
        
        # 추천 이벤트 발행
        recommendation_event = ContentRecommendationEvent(user_id, recommendations)
        await self.broker.publish(recommendation_event)
        
        print(f"[추천 서비스] 사용자 {user_id}에게 새로운 추천 생성: {recommendations}")
    
    def _update_user_preferences(self, user_id: str, content_id: str, duration: int, rating: Optional[float]) -> None:
        """사용자 선호도 업데이트"""
        if user_id not in self.user_preferences:
            self.user_preferences[user_id] = {"viewed_content": [], "preferred_genres": {}}
        
        # 시청한 콘텐츠 추가
        self.user_preferences[user_id]["viewed_content"].append({
            "content_id": content_id,
            "duration": duration,
            "rating": rating,
            "timestamp": datetime.now().isoformat()
        })
        
        # 장르 선호도 업데이트 (간단한 로직)
        if content_id in self.content_database:
            genre = self.content_database[content_id]["genre"]
            if genre not in self.user_preferences[user_id]["preferred_genres"]:
                self.user_preferences[user_id]["preferred_genres"][genre] = 0
            
            # 시청 시간과 평점을 기반으로 선호도 점수 계산
            preference_score = duration / 100  # 기본 점수
            if rating:
                preference_score *= rating / 5  # 평점 반영
            
            self.user_preferences[user_id]["preferred_genres"][genre] += preference_score
    
    def _generate_recommendations(self, user_id: str) -> List[str]:
        """추천 콘텐츠 생성"""
        if user_id not in self.user_preferences:
            return ["movie_1", "movie_2"]  # 기본 추천
        
        # 사용자가 본 콘텐츠
        viewed_content = {item["content_id"] for item in self.user_preferences[user_id]["viewed_content"]}
        
        # 선호 장르 기반 추천 (간단한 협업 필터링)
        preferred_genres = self.user_preferences[user_id]["preferred_genres"]
        
        recommendations = []
        for content_id, content_info in self.content_database.items():
            if content_id not in viewed_content:
                genre = content_info["genre"]
                if genre in preferred_genres and preferred_genres[genre] > 0:
                    recommendations.append(content_id)
        
        return recommendations[:3]  # 상위 3개 추천

class AnalyticsService(EventConsumer):
    """분석 서비스 - 이벤트 데이터를 수집하고 분석"""
    
    def __init__(self, broker: EventBroker):
        self.analytics_data: Dict[str, List] = {
            "user_engagement": [],
            "content_performance": [],
            "recommendation_effectiveness": []
        }
        super().__init__(broker)
    
    def register_handlers(self) -> None:
        """이벤트 핸들러 등록"""
        self.broker.subscribe("user_view", self.analyze_user_engagement)
        self.broker.subscribe("content_recommendation", self.analyze_recommendation)
    
    async def analyze_user_engagement(self, event: Event) -> None:
        """사용자 참여도 분석"""
        engagement_data = {
            "user_id": event.user_id,
            "content_id": event.data["content_id"],
            "duration": event.data["duration"],
            "timestamp": event.timestamp.isoformat()
        }
        self.analytics_data["user_engagement"].append(engagement_data)
        print(f"[분석 서비스] 사용자 참여도 데이터 수집: {engagement_data}")
    
    async def analyze_recommendation(self, event: Event) -> None:
        """추천 효과성 분석"""
        recommendation_data = {
            "user_id": event.user_id,
            "recommendations": event.data["recommendations"],
            "timestamp": event.timestamp.isoformat()
        }
        self.analytics_data["recommendation_effectiveness"].append(recommendation_data)
        print(f"[분석 서비스] 추천 데이터 수집: {recommendation_data}")
    
    def get_analytics_summary(self) -> Dict:
        """분석 요약 정보 반환"""
        return {
            "total_user_views": len(self.analytics_data["user_engagement"]),
            "total_recommendations": len(self.analytics_data["recommendation_effectiveness"]),
            "unique_users": len(set(item["user_id"] for item in self.analytics_data["user_engagement"]))
        }

class NotificationService(EventConsumer):
    """알림 서비스 - 사용자에게 알림 전송"""
    
    def register_handlers(self) -> None:
        """이벤트 핸들러 등록"""
        self.broker.subscribe("content_recommendation", self.send_recommendation_notification)
    
    async def send_recommendation_notification(self, event: Event) -> None:
        """추천 알림 전송"""
        user_id = event.user_id
        recommendations = event.data["recommendations"]
        
        # 실제로는 푸시 알림, 이메일 등을 전송
        print(f"[알림 서비스] 사용자 {user_id}에게 알림 전송: 새로운 추천 콘텐츠 {len(recommendations)}개")

# ============================================================================
# 4. 이벤트 프로듀서 (Event Producers)
# ============================================================================

class UserInteractionProducer:
    """사용자 상호작용 이벤트 프로듀서"""
    
    def __init__(self, broker: EventBroker):
        self.broker = broker
    
    async def user_watches_content(self, user_id: str, content_id: str, duration: int, rating: Optional[float] = None) -> None:
        """사용자 콘텐츠 시청 이벤트 생성"""
        event = UserViewEvent(user_id, content_id, duration, rating)
        await self.broker.publish(event)
        print(f"[이벤트 생성] 사용자 {user_id}가 {content_id} 시청 (시간: {duration}분)")

# ============================================================================
# 5. 메인 실행 코드
# ============================================================================

async def main():
    """메인 실행 함수 - Event-Driven Architecture 데모"""
    print("=== Event-Driven Architecture 데모 시작 ===\n")
    
    # 1. 이벤트 브로커 초기화
    broker = EventBroker()
    
    # 2. 이벤트 컨슈머 초기화 (서비스들)
    recommendation_service = RecommendationService(broker)
    analytics_service = AnalyticsService(broker)
    notification_service = NotificationService(broker)
    
    # 3. 이벤트 프로듀서 초기화
    user_producer = UserInteractionProducer(broker)
    
    print("모든 서비스가 초기화되었습니다.\n")
    
    # 4. 사용자 상호작용 시뮬레이션
    print("=== 사용자 상호작용 시뮬레이션 ===")
    
    # 사용자 1의 시청 패턴
    await user_producer.user_watches_content("user_1", "movie_1", 120, 4.5)  # 액션 영화
    await asyncio.sleep(0.1)  # 짧은 지연
    
    await user_producer.user_watches_content("user_1", "movie_3", 110, 4.7)  # 액션 영화
    await asyncio.sleep(0.1)
    
    # 사용자 2의 시청 패턴
    await user_producer.user_watches_content("user_2", "movie_2", 95, 4.0)   # 코미디 영화
    await asyncio.sleep(0.1)
    
    await user_producer.user_watches_content("user_2", "movie_5", 88, 3.8)   # 코미디 영화
    await asyncio.sleep(0.1)
    
    # 사용자 1이 추가로 시청
    await user_producer.user_watches_content("user_1", "movie_4", 130, 4.2)  # 드라마 영화
    await asyncio.sleep(0.1)
    
    print("\n=== 분석 결과 ===")
    summary = analytics_service.get_analytics_summary()
    print(f"총 시청 횟수: {summary['total_user_views']}")
    print(f"총 추천 생성 수: {summary['total_recommendations']}")
    print(f"고유 사용자 수: {summary['unique_users']}")
    
    print("\n=== 사용자별 추천 결과 확인 ===")
    # 사용자별 추천 결과 확인
    for user_id in ["user_1", "user_2"]:
        recommendations = recommendation_service._generate_recommendations(user_id)
        print(f"사용자 {user_id} 최종 추천: {recommendations}")
        
        # 사용자 선호도 확인
        if user_id in recommendation_service.user_preferences:
            preferred_genres = recommendation_service.user_preferences[user_id]["preferred_genres"]
            print(f"사용자 {user_id} 선호 장르: {preferred_genres}")
    
    print("\n=== 이벤트 저장소 확인 ===")
    print(f"총 저장된 이벤트 수: {len(broker.event_store)}")
    
    # 이벤트 타입별 통계
    event_types = {}
    for event in broker.event_store:
        event_type = event.event_type
        event_types[event_type] = event_types.get(event_type, 0) + 1
    
    print("이벤트 타입별 통계:")
    for event_type, count in event_types.items():
        print(f"  {event_type}: {count}개")
    
    print("\n=== Event-Driven Architecture 데모 완료 ===")

# 실행
if __name__ == "__main__":
    asyncio.run(main())

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 이벤트 발행 (Producer)
from kafka import KafkaProducer
import json

producer = KafkaProducer(bootstrap_servers='localhost:9092',
                         value_serializer=lambda v: json.dumps(v).encode('utf-8'))

event = {
    "order_id": "ORD-123",
    "status": "ORDER_CREATED",
    "timestamp": "2025-06-14T12:00:00Z"
}
producer.send('order-events', value=event)
producer.flush()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 이벤트 수신 (Consumer)
from kafka import KafkaConsumer

consumer = KafkaConsumer('order-events',
                         bootstrap_servers='localhost:9092',
                         auto_offset_reset='earliest',
                         group_id='inventory-group',
                         value_deserializer=lambda m: json.loads(m.decode('utf-8')))

for msg in consumer:
    event = msg.value
    print(f"Inventory 처리 중: {event['order_id']} → 상태: {event['status']}")

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254